drivers/audio/AudioOutputDevicePlugin.cpp

/***************************************************************************
 *                                                                         *
 *   Copyright (C) 2008 Andreas Persson                                    *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the Free Software           *
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,                *
 *   MA  02110-1301  USA                                                   *
 ***************************************************************************/

#include "AudioOutputDevicePlugin.h"

namespace LinuxSampler {

// *************** AudioChannelPlugin ***************
// *

    AudioOutputDevicePlugin::AudioChannelPlugin::AudioChannelPlugin(uint ChannelNr) :
        AudioChannel(ChannelNr, 0, 0) {
    }


// *************** ParameterFragmentSize ***************
// *

    AudioOutputDevicePlugin::ParameterFragmentSize::ParameterFragmentSize() : DeviceCreationParameterInt() {
        InitWithDefault();
    }

    AudioOutputDevicePlugin::ParameterFragmentSize::ParameterFragmentSize(String s) throw (Exception) : DeviceCreationParameterInt(s) {
    }

    String AudioOutputDevicePlugin::ParameterFragmentSize::Description() {
        return "Size of each buffer fragment";
    }

    bool AudioOutputDevicePlugin::ParameterFragmentSize::Fix() {
        return true;
    }

    bool AudioOutputDevicePlugin::ParameterFragmentSize::Mandatory() {
        return true;
    }

    std::map<String,DeviceCreationParameter*> AudioOutputDevicePlugin::ParameterFragmentSize::DependsAsParameters() {
        return std::map<String,DeviceCreationParameter*>(); // no dependencies
    }

    optional<int> AudioOutputDevicePlugin::ParameterFragmentSize::DefaultAsInt(std::map<String,String> Parameters) {
        return optional<int>::nothing;
    }

    optional<int> AudioOutputDevicePlugin::ParameterFragmentSize::RangeMinAsInt(std::map<String,String> Parameters) {
        return optional<int>::nothing;
    }

    optional<int> AudioOutputDevicePlugin::ParameterFragmentSize::RangeMaxAsInt(std::map<String,String> Parameters) {
        return optional<int>::nothing;
    }

    std::vector<int> AudioOutputDevicePlugin::ParameterFragmentSize::PossibilitiesAsInt(std::map<String,String> Parameters) {
        return std::vector<int>();
    }

    void AudioOutputDevicePlugin::ParameterFragmentSize::OnSetValue(int i) throw (Exception) {
        // not posssible, as parameter is fix
    }

    String AudioOutputDevicePlugin::ParameterFragmentSize::Name() {
        return "FRAGMENTSIZE";
    }


// *************** AudioOutputDevicePlugin ***************
// *

    AudioOutputDevicePlugin::AudioOutputDevicePlugin(std::map<String, DeviceCreationParameter*> Parameters) : AudioOutputDevice(Parameters) {
        uiSampleRate = dynamic_cast<DeviceCreationParameterInt*>(
            Parameters["SAMPLERATE"])->ValueAsInt();
        uiMaxSamplesPerCycle = dynamic_cast<DeviceCreationParameterInt*>(
            Parameters["FRAGMENTSIZE"])->ValueAsInt();

        // create audio channels
        AcquireChannels(dynamic_cast<DeviceCreationParameterInt*>(
                            Parameters["CHANNELS"])->ValueAsInt());
    }

    void AudioOutputDevicePlugin::Play() {
    }

    bool AudioOutputDevicePlugin::IsPlaying() {
        return true;
    }

    void AudioOutputDevicePlugin::Stop() {
    }

    uint AudioOutputDevicePlugin::MaxSamplesPerCycle() {
        return uiMaxSamplesPerCycle;
    }

    uint AudioOutputDevicePlugin::SampleRate() {
        return uiSampleRate;
    }

    String AudioOutputDevicePlugin::Driver() {
        return Name();
    }

    String AudioOutputDevicePlugin::Name() {
        return "Plugin";
    }

    String AudioOutputDevicePlugin::Version() {
        String s = "$Revision: 1.1 $";
        return s.substr(11, s.size() - 13); // cut dollar signs, spaces and CVS macro keyword
    }

    String AudioOutputDevicePlugin::Description() {
        return Name();
    }

    AudioChannel* AudioOutputDevicePlugin::CreateChannel(uint ChannelNr) {
        return new AudioChannelPlugin(ChannelNr);
    }
}
1	/***************************************************************************
2	* *
3	* Copyright (C) 2008 Andreas Persson *
4	* *
5	* This program is free software; you can redistribute it and/or modify *
6	* it under the terms of the GNU General Public License as published by *
7	* the Free Software Foundation; either version 2 of the License, or *
8	* (at your option) any later version. *
9	* *
10	* This program is distributed in the hope that it will be useful, *
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13	* GNU General Public License for more details. *
14	* *
15	* You should have received a copy of the GNU General Public License *
16	* along with this program; if not, write to the Free Software *
17	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, *
18	* MA 02110-1301 USA *
19	***************************************************************************/
20
21	#include "AudioOutputDevicePlugin.h"
22
23	namespace LinuxSampler {
24
25	// ************* AudioChannelPlugin *************
26	// *
27
28	AudioOutputDevicePlugin::AudioChannelPlugin::AudioChannelPlugin(uint ChannelNr) :
29	AudioChannel(ChannelNr, 0, 0) {
30	}
31
32
33	// ************* ParameterFragmentSize *************
34	// *
35
36	AudioOutputDevicePlugin::ParameterFragmentSize::ParameterFragmentSize() : DeviceCreationParameterInt() {
37	InitWithDefault();
38	}
39
40	AudioOutputDevicePlugin::ParameterFragmentSize::ParameterFragmentSize(String s) throw (Exception) : DeviceCreationParameterInt(s) {
41	}
42
43	String AudioOutputDevicePlugin::ParameterFragmentSize::Description() {
44	return "Size of each buffer fragment";
45	}
46
47	bool AudioOutputDevicePlugin::ParameterFragmentSize::Fix() {
48	return true;
49	}
50
51	bool AudioOutputDevicePlugin::ParameterFragmentSize::Mandatory() {
52	return true;
53	}
54
55	std::map<String,DeviceCreationParameter*> AudioOutputDevicePlugin::ParameterFragmentSize::DependsAsParameters() {
56	return std::map<String,DeviceCreationParameter*>(); // no dependencies
57	}
58
59	optional<int> AudioOutputDevicePlugin::ParameterFragmentSize::DefaultAsInt(std::map<String,String> Parameters) {
60	return optional<int>::nothing;
61	}
62
63	optional<int> AudioOutputDevicePlugin::ParameterFragmentSize::RangeMinAsInt(std::map<String,String> Parameters) {
64	return optional<int>::nothing;
65	}
66
67	optional<int> AudioOutputDevicePlugin::ParameterFragmentSize::RangeMaxAsInt(std::map<String,String> Parameters) {
68	return optional<int>::nothing;
69	}
70
71	std::vector<int> AudioOutputDevicePlugin::ParameterFragmentSize::PossibilitiesAsInt(std::map<String,String> Parameters) {
72	return std::vector<int>();
73	}
74
75	void AudioOutputDevicePlugin::ParameterFragmentSize::OnSetValue(int i) throw (Exception) {
76	// not posssible, as parameter is fix
77	}
78
79	String AudioOutputDevicePlugin::ParameterFragmentSize::Name() {
80	return "FRAGMENTSIZE";
81	}
82
83
84
85	// ************* AudioOutputDevicePlugin *************
86	// *
87
88	AudioOutputDevicePlugin::AudioOutputDevicePlugin(std::map<String, DeviceCreationParameter*> Parameters) : AudioOutputDevice(Parameters) {
89	uiSampleRate = dynamic_cast<DeviceCreationParameterInt*>(
90	Parameters["SAMPLERATE"])->ValueAsInt();
91	uiMaxSamplesPerCycle = dynamic_cast<DeviceCreationParameterInt*>(
92	Parameters["FRAGMENTSIZE"])->ValueAsInt();
93
94	// create audio channels
95	AcquireChannels(dynamic_cast<DeviceCreationParameterInt*>(
96	Parameters["CHANNELS"])->ValueAsInt());
97	}
98
99	void AudioOutputDevicePlugin::Play() {
100	}
101
102	bool AudioOutputDevicePlugin::IsPlaying() {
103	return true;
104	}
105
106	void AudioOutputDevicePlugin::Stop() {
107	}
108
109	uint AudioOutputDevicePlugin::MaxSamplesPerCycle() {
110	return uiMaxSamplesPerCycle;
111	}
112
113	uint AudioOutputDevicePlugin::SampleRate() {
114	return uiSampleRate;
115	}
116
117	String AudioOutputDevicePlugin::Driver() {
118	return Name();
119	}
120
121	String AudioOutputDevicePlugin::Name() {
122	return "Plugin";
123	}
124
125	String AudioOutputDevicePlugin::Version() {
126	String s = "$Revision: 1.1 $";
127	return s.substr(11, s.size() - 13); // cut dollar signs, spaces and CVS macro keyword
128	}
129
130	String AudioOutputDevicePlugin::Description() {
131	return Name();
132	}
133
134	AudioChannel* AudioOutputDevicePlugin::CreateChannel(uint ChannelNr) {
135	return new AudioChannelPlugin(ChannelNr);
136	}
137	}