drivers/audio/AudioOutputDevice.cpp

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
 *   Copyright (C) 2005 Christian Schoenebeck                              *
 *                                                                         *
 *   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., 59 Temple Place, Suite 330, Boston,                 *
 *   MA  02111-1307  USA                                                   *
 ***************************************************************************/

#include "AudioOutputDeviceFactory.h"
#include "AudioOutputDevice.h"

namespace LinuxSampler {

// *************** ParameterActive ***************
// *

    AudioOutputDevice::ParameterActive::ParameterActive() : DeviceCreationParameterBool() {
        InitWithDefault();
    }

    AudioOutputDevice::ParameterActive::ParameterActive(String s) : DeviceCreationParameterBool(s) {
    }

    String AudioOutputDevice::ParameterActive::Description() {
        return "Enable / disable device";
    }

    bool AudioOutputDevice::ParameterActive::Fix() {
        return false;
    }

    bool AudioOutputDevice::ParameterActive::Mandatory() {
        return false;
    }

    std::map<String,DeviceCreationParameter*> AudioOutputDevice::ParameterActive::DependsAsParameters() {
        return std::map<String,DeviceCreationParameter*>();
    }

    optional<bool> AudioOutputDevice::ParameterActive::DefaultAsBool(std::map<String,String> Parameters) {
        return true;
    }

    void AudioOutputDevice::ParameterActive::OnSetValue(bool b) throw (LinuxSamplerException) {
        if (b) ((AudioOutputDevice*)pDevice)->Play();
        else ((AudioOutputDevice*)pDevice)->Stop();
    }

    String AudioOutputDevice::ParameterActive::Name() {
        return "ACTIVE";
    }


// *************** ParameterSampleRate ***************
// *

    AudioOutputDevice::ParameterSampleRate::ParameterSampleRate() : DeviceCreationParameterInt() {
        InitWithDefault();
    }

    AudioOutputDevice::ParameterSampleRate::ParameterSampleRate(String s) : DeviceCreationParameterInt(s) {
    }

    String AudioOutputDevice::ParameterSampleRate::Description() {
        return "Output sample rate";
    }

    bool AudioOutputDevice::ParameterSampleRate::Fix() {
        return true;
    }

    bool AudioOutputDevice::ParameterSampleRate::Mandatory() {
        return false;
    }

    std::map<String,DeviceCreationParameter*> AudioOutputDevice::ParameterSampleRate::DependsAsParameters() {
        return std::map<String,DeviceCreationParameter*>();
    }

    optional<int> AudioOutputDevice::ParameterSampleRate::DefaultAsInt(std::map<String,String> Parameters) {
        return 44100;
    }

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

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

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

    void AudioOutputDevice::ParameterSampleRate::OnSetValue(int i) throw (LinuxSamplerException) {
        /* cannot happen, as parameter is fix */
    }

    String AudioOutputDevice::ParameterSampleRate::Name() {
        return "SAMPLERATE";
    }


// *************** ParameterChannels ***************
// *

    AudioOutputDevice::ParameterChannels::ParameterChannels() : DeviceCreationParameterInt() {
       InitWithDefault();
    }

    AudioOutputDevice::ParameterChannels::ParameterChannels(String s) : DeviceCreationParameterInt(s) {
    }

    String AudioOutputDevice::ParameterChannels::Description() {
        return "Number of output channels";
    }

    bool AudioOutputDevice::ParameterChannels::Fix() {
        return false;
    }

    bool AudioOutputDevice::ParameterChannels::Mandatory() {
        return false;
    }

    std::map<String,DeviceCreationParameter*> AudioOutputDevice::ParameterChannels::DependsAsParameters() {
        return std::map<String,DeviceCreationParameter*>();
    }

    optional<int> AudioOutputDevice::ParameterChannels::DefaultAsInt(std::map<String,String> Parameters) {
        return 2;
    }

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

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

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

    void AudioOutputDevice::ParameterChannels::OnSetValue(int i) throw (LinuxSamplerException) {
        ((AudioOutputDevice*)pDevice)->AcquireChannels(i);
    }

    String AudioOutputDevice::ParameterChannels::Name() {
        return "CHANNELS";
    }


// *************** AudioOutputDevice ***************
// *

    AudioOutputDevice::AudioOutputDevice(std::map<String,DeviceCreationParameter*> DriverParameters) {
        this->Parameters = DriverParameters;
    }

    AudioOutputDevice::~AudioOutputDevice() {
        // delete all audio channels
        {
            std::vector<AudioChannel*>::iterator iter = Channels.begin();
            while (iter != Channels.end()) {
                Channels.erase(iter);
                delete *iter;
                iter++;
            }

        }

        // delete all device parameters
        {
            std::map<String,DeviceCreationParameter*>::iterator iter = Parameters.begin();
            while (iter != Parameters.end()) {
                Parameters.erase(iter);
                delete iter->second;
                iter++;
            }
        }
    }

    void AudioOutputDevice::Connect(EngineChannel* pEngineChannel) {
        if (EngineChannels.find(pEngineChannel) == EngineChannels.end()) {
            pEngineChannel->Connect(this);
            EngineChannels.insert(pEngineChannel);
        }
    }

    void AudioOutputDevice::Disconnect(EngineChannel* pEngineChannel) {
        if (EngineChannels.find(pEngineChannel) != EngineChannels.end()) { // if clause to prevent disconnect loop
            EngineChannels.erase(pEngineChannel);
            pEngineChannel->DisconnectAudioOutputDevice();
        }
    }

    AudioChannel* AudioOutputDevice::Channel(uint ChannelIndex) {
        return (ChannelIndex < Channels.size()) ? Channels[ChannelIndex] : NULL;
    }

    void AudioOutputDevice::AcquireChannels(uint Channels) {
        if (Channels > this->Channels.size()) {
            for (int c = this->Channels.size(); c < Channels; c++) {
                this->Channels.push_back(CreateChannel(c));
            }
        }
    }

    std::map<String,DeviceCreationParameter*> AudioOutputDevice::DeviceParameters() {
        return Parameters;
    }

    int AudioOutputDevice::RenderAudio(uint Samples) {
        if (Channels.empty()) return 0;

        // reset all channels with silence
        {
            std::vector<AudioChannel*>::iterator iterChannels = Channels.begin();
            std::vector<AudioChannel*>::iterator end          = Channels.end();
            for (; iterChannels != end; iterChannels++)
                (*iterChannels)->Clear(); // zero out audio buffer
        }

        int result = 0;

        // let all connected engines render audio for the current audio fragment cycle
        #if USE_EXCEPTIONS
        try
        #endif // USE_EXCEPTIONS
        {
            std::set<EngineChannel*>::iterator iterEngineCh = EngineChannels.begin();
            std::set<EngineChannel*>::iterator end          = EngineChannels.end();
            for (; iterEngineCh != end; iterEngineCh++) {
                int res = (*iterEngineCh)->RenderAudio(Samples);
                if (res != 0) result = res;
            }
        }
        #if USE_EXCEPTIONS
        catch (std::runtime_error se) {
            std::cerr << "std::runtime_error: " << se.what() << std::endl << std::flush;
            exit(EXIT_FAILURE);
        }
        #endif // USE_EXCEPTIONS

        return result;
    }

    int AudioOutputDevice::RenderSilence(uint Samples) {
        if (Channels.empty()) return 0;

        // reset all channels with silence
        {
            std::vector<AudioChannel*>::iterator iterChannels = Channels.begin();
            std::vector<AudioChannel*>::iterator end          = Channels.end();
            for (; iterChannels != end; iterChannels++)
                (*iterChannels)->Clear(); // zero out audio buffer
        }

        return 0;
    }

} // namespace LinuxSampler
1	/***************************************************************************
2	* *
3	* LinuxSampler - modular, streaming capable sampler *
4	* *
5	* Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6	* Copyright (C) 2005 Christian Schoenebeck *
7	* *
8	* This program is free software; you can redistribute it and/or modify *
9	* it under the terms of the GNU General Public License as published by *
10	* the Free Software Foundation; either version 2 of the License, or *
11	* (at your option) any later version. *
12	* *
13	* This program is distributed in the hope that it will be useful, *
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16	* GNU General Public License for more details. *
17	* *
18	* You should have received a copy of the GNU General Public License *
19	* along with this program; if not, write to the Free Software *
20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21	* MA 02111-1307 USA *
22	***************************************************************************/
23
24	#include "AudioOutputDeviceFactory.h"
25	#include "AudioOutputDevice.h"
26
27	namespace LinuxSampler {
28
29	// ************* ParameterActive *************
30	// *
31
32	AudioOutputDevice::ParameterActive::ParameterActive() : DeviceCreationParameterBool() {
33	InitWithDefault();
34	}
35
36	AudioOutputDevice::ParameterActive::ParameterActive(String s) : DeviceCreationParameterBool(s) {
37	}
38
39	String AudioOutputDevice::ParameterActive::Description() {
40	return "Enable / disable device";
41	}
42
43	bool AudioOutputDevice::ParameterActive::Fix() {
44	return false;
45	}
46
47	bool AudioOutputDevice::ParameterActive::Mandatory() {
48	return false;
49	}
50
51	std::map<String,DeviceCreationParameter*> AudioOutputDevice::ParameterActive::DependsAsParameters() {
52	return std::map<String,DeviceCreationParameter*>();
53	}
54
55	optional<bool> AudioOutputDevice::ParameterActive::DefaultAsBool(std::map<String,String> Parameters) {
56	return true;
57	}
58
59	void AudioOutputDevice::ParameterActive::OnSetValue(bool b) throw (LinuxSamplerException) {
60	if (b) ((AudioOutputDevice*)pDevice)->Play();
61	else ((AudioOutputDevice*)pDevice)->Stop();
62	}
63
64	String AudioOutputDevice::ParameterActive::Name() {
65	return "ACTIVE";
66	}
67
68
69
70	// ************* ParameterSampleRate *************
71	// *
72
73	AudioOutputDevice::ParameterSampleRate::ParameterSampleRate() : DeviceCreationParameterInt() {
74	InitWithDefault();
75	}
76
77	AudioOutputDevice::ParameterSampleRate::ParameterSampleRate(String s) : DeviceCreationParameterInt(s) {
78	}
79
80	String AudioOutputDevice::ParameterSampleRate::Description() {
81	return "Output sample rate";
82	}
83
84	bool AudioOutputDevice::ParameterSampleRate::Fix() {
85	return true;
86	}
87
88	bool AudioOutputDevice::ParameterSampleRate::Mandatory() {
89	return false;
90	}
91
92	std::map<String,DeviceCreationParameter*> AudioOutputDevice::ParameterSampleRate::DependsAsParameters() {
93	return std::map<String,DeviceCreationParameter*>();
94	}
95
96	optional<int> AudioOutputDevice::ParameterSampleRate::DefaultAsInt(std::map<String,String> Parameters) {
97	return 44100;
98	}
99
100	optional<int> AudioOutputDevice::ParameterSampleRate::RangeMinAsInt(std::map<String,String> Parameters) {
101	return optional<int>::nothing;
102	}
103
104	optional<int> AudioOutputDevice::ParameterSampleRate::RangeMaxAsInt(std::map<String,String> Parameters) {
105	return optional<int>::nothing;
106	}
107
108	std::vector<int> AudioOutputDevice::ParameterSampleRate::PossibilitiesAsInt(std::map<String,String> Parameters) {
109	return std::vector<int>();
110	}
111
112	void AudioOutputDevice::ParameterSampleRate::OnSetValue(int i) throw (LinuxSamplerException) {
113	/* cannot happen, as parameter is fix */
114	}
115
116	String AudioOutputDevice::ParameterSampleRate::Name() {
117	return "SAMPLERATE";
118	}
119
120
121
122	// ************* ParameterChannels *************
123	// *
124
125	AudioOutputDevice::ParameterChannels::ParameterChannels() : DeviceCreationParameterInt() {
126	InitWithDefault();
127	}
128
129	AudioOutputDevice::ParameterChannels::ParameterChannels(String s) : DeviceCreationParameterInt(s) {
130	}
131
132	String AudioOutputDevice::ParameterChannels::Description() {
133	return "Number of output channels";
134	}
135
136	bool AudioOutputDevice::ParameterChannels::Fix() {
137	return false;
138	}
139
140	bool AudioOutputDevice::ParameterChannels::Mandatory() {
141	return false;
142	}
143
144	std::map<String,DeviceCreationParameter*> AudioOutputDevice::ParameterChannels::DependsAsParameters() {
145	return std::map<String,DeviceCreationParameter*>();
146	}
147
148	optional<int> AudioOutputDevice::ParameterChannels::DefaultAsInt(std::map<String,String> Parameters) {
149	return 2;
150	}
151
152	optional<int> AudioOutputDevice::ParameterChannels::RangeMinAsInt(std::map<String,String> Parameters) {
153	return optional<int>::nothing;
154	}
155
156	optional<int> AudioOutputDevice::ParameterChannels::RangeMaxAsInt(std::map<String,String> Parameters) {
157	return optional<int>::nothing;
158	}
159
160	std::vector<int> AudioOutputDevice::ParameterChannels::PossibilitiesAsInt(std::map<String,String> Parameters) {
161	return std::vector<int>();
162	}
163
164	void AudioOutputDevice::ParameterChannels::OnSetValue(int i) throw (LinuxSamplerException) {
165	((AudioOutputDevice*)pDevice)->AcquireChannels(i);
166	}
167
168	String AudioOutputDevice::ParameterChannels::Name() {
169	return "CHANNELS";
170	}
171
172
173
174	// ************* AudioOutputDevice *************
175	// *
176
177	AudioOutputDevice::AudioOutputDevice(std::map<String,DeviceCreationParameter*> DriverParameters) {
178	this->Parameters = DriverParameters;
179	}
180
181	AudioOutputDevice::~AudioOutputDevice() {
182	// delete all audio channels
183	{
184	std::vector<AudioChannel*>::iterator iter = Channels.begin();
185	while (iter != Channels.end()) {
186	Channels.erase(iter);
187	delete *iter;
188	iter++;
189	}
190
191	}
192
193	// delete all device parameters
194	{
195	std::map<String,DeviceCreationParameter*>::iterator iter = Parameters.begin();
196	while (iter != Parameters.end()) {
197	Parameters.erase(iter);
198	delete iter->second;
199	iter++;
200	}
201	}
202	}
203
204	void AudioOutputDevice::Connect(EngineChannel* pEngineChannel) {
205	if (EngineChannels.find(pEngineChannel) == EngineChannels.end()) {
206	pEngineChannel->Connect(this);
207	EngineChannels.insert(pEngineChannel);
208	}
209	}
210
211	void AudioOutputDevice::Disconnect(EngineChannel* pEngineChannel) {
212	if (EngineChannels.find(pEngineChannel) != EngineChannels.end()) { // if clause to prevent disconnect loop
213	EngineChannels.erase(pEngineChannel);
214	pEngineChannel->DisconnectAudioOutputDevice();
215	}
216	}
217
218	AudioChannel* AudioOutputDevice::Channel(uint ChannelIndex) {
219	return (ChannelIndex < Channels.size()) ? Channels[ChannelIndex] : NULL;
220	}
221
222	void AudioOutputDevice::AcquireChannels(uint Channels) {
223	if (Channels > this->Channels.size()) {
224	for (int c = this->Channels.size(); c < Channels; c++) {
225	this->Channels.push_back(CreateChannel(c));
226	}
227	}
228	}
229
230	std::map<String,DeviceCreationParameter*> AudioOutputDevice::DeviceParameters() {
231	return Parameters;
232	}
233
234	int AudioOutputDevice::RenderAudio(uint Samples) {
235	if (Channels.empty()) return 0;
236
237	// reset all channels with silence
238	{
239	std::vector<AudioChannel*>::iterator iterChannels = Channels.begin();
240	std::vector<AudioChannel*>::iterator end = Channels.end();
241	for (; iterChannels != end; iterChannels++)
242	(*iterChannels)->Clear(); // zero out audio buffer
243	}
244
245	int result = 0;
246
247	// let all connected engines render audio for the current audio fragment cycle
248	#if USE_EXCEPTIONS
249	try
250	#endif // USE_EXCEPTIONS
251	{
252	std::set<EngineChannel*>::iterator iterEngineCh = EngineChannels.begin();
253	std::set<EngineChannel*>::iterator end = EngineChannels.end();
254	for (; iterEngineCh != end; iterEngineCh++) {
255	int res = (*iterEngineCh)->RenderAudio(Samples);
256	if (res != 0) result = res;
257	}
258	}
259	#if USE_EXCEPTIONS
260	catch (std::runtime_error se) {
261	std::cerr << "std::runtime_error: " << se.what() << std::endl << std::flush;
262	exit(EXIT_FAILURE);
263	}
264	#endif // USE_EXCEPTIONS
265
266	return result;
267	}
268
269	int AudioOutputDevice::RenderSilence(uint Samples) {
270	if (Channels.empty()) return 0;
271
272	// reset all channels with silence
273	{
274	std::vector<AudioChannel*>::iterator iterChannels = Channels.begin();
275	std::vector<AudioChannel*>::iterator end = Channels.end();
276	for (; iterChannels != end; iterChannels++)
277	(*iterChannels)->Clear(); // zero out audio buffer
278	}
279
280	return 0;
281	}
282
283	} // namespace LinuxSampler