drivers/audio/AudioOutputDevice.cpp

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
 *   Copyright (C) 2005 - 2007 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"
#include "../../common/global_private.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 (Exception) {
        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>();
    }

    int AudioOutputDevice::ParameterSampleRate::ValueAsInt() {
        return (pDevice) ? (int) ((AudioOutputDevice*)pDevice)->SampleRate()
                         : DeviceCreationParameterInt::ValueAsInt();
    }

    void AudioOutputDevice::ParameterSampleRate::OnSetValue(int i) throw (Exception) {
        /* 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 1;
    }

    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 (Exception) {
        ((AudioOutputDevice*)pDevice)->AcquireChannels(i);
    }

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


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

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

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

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

    void AudioOutputDevice::Connect(Engine* pEngine) {
        std::set<Engine*>& engines = Engines.GetConfigForUpdate();
        if (engines.find(pEngine) == engines.end()) {
            engines.insert(pEngine);
            Engines.SwitchConfig().insert(pEngine);
            // make sure the engine knows about the connection
            //pEngine->Connect(this);
        }
    }

    void AudioOutputDevice::Disconnect(Engine* pEngine) {
        std::set<Engine*>& engines = Engines.GetConfigForUpdate();
        if (engines.find(pEngine) != engines.end()) { // if clause to prevent disconnect loop
            engines.erase(pEngine);
            Engines.SwitchConfig().erase(pEngine);
            // make sure the engine knows about the disconnection
            //pEngine->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));
            }
        }
    }

    uint AudioOutputDevice::ChannelCount() {
        return Channels.size();
    }

    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
        const std::set<Engine*>& engines = EnginesReader.Lock();
        #if CONFIG_RT_EXCEPTIONS
        try
        #endif // CONFIG_RT_EXCEPTIONS
        {
            std::set<Engine*>::iterator iterEngine = engines.begin();
            std::set<Engine*>::iterator end        = engines.end();
            for (; iterEngine != end; iterEngine++) {
                int res = (*iterEngine)->RenderAudio(Samples);
                if (res != 0) result = res;
            }
        }
        #if CONFIG_RT_EXCEPTIONS
        catch (std::runtime_error se) {
            std::cerr << "std::runtime_error: " << se.what() << std::endl << std::flush;
            exit(EXIT_FAILURE);
        }
        #endif // CONFIG_RT_EXCEPTIONS

        EnginesReader.Unlock();
        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 - 2007 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	#include "../../common/global_private.h"
27
28	namespace LinuxSampler {
29
30	// ************* ParameterActive *************
31	// *
32
33	AudioOutputDevice::ParameterActive::ParameterActive() : DeviceCreationParameterBool() {
34	InitWithDefault();
35	}
36
37	AudioOutputDevice::ParameterActive::ParameterActive(String s) : DeviceCreationParameterBool(s) {
38	}
39
40	String AudioOutputDevice::ParameterActive::Description() {
41	return "Enable / disable device";
42	}
43
44	bool AudioOutputDevice::ParameterActive::Fix() {
45	return false;
46	}
47
48	bool AudioOutputDevice::ParameterActive::Mandatory() {
49	return false;
50	}
51
52	std::map<String,DeviceCreationParameter*> AudioOutputDevice::ParameterActive::DependsAsParameters() {
53	return std::map<String,DeviceCreationParameter*>();
54	}
55
56	optional<bool> AudioOutputDevice::ParameterActive::DefaultAsBool(std::map<String,String> Parameters) {
57	return true;
58	}
59
60	void AudioOutputDevice::ParameterActive::OnSetValue(bool b) throw (Exception) {
61	if (b) ((AudioOutputDevice*)pDevice)->Play();
62	else ((AudioOutputDevice*)pDevice)->Stop();
63	}
64
65	String AudioOutputDevice::ParameterActive::Name() {
66	return "ACTIVE";
67	}
68
69
70
71	// ************* ParameterSampleRate *************
72	// *
73
74	AudioOutputDevice::ParameterSampleRate::ParameterSampleRate() : DeviceCreationParameterInt() {
75	InitWithDefault();
76	}
77
78	AudioOutputDevice::ParameterSampleRate::ParameterSampleRate(String s) : DeviceCreationParameterInt(s) {
79	}
80
81	String AudioOutputDevice::ParameterSampleRate::Description() {
82	return "Output sample rate";
83	}
84
85	bool AudioOutputDevice::ParameterSampleRate::Fix() {
86	return true;
87	}
88
89	bool AudioOutputDevice::ParameterSampleRate::Mandatory() {
90	return false;
91	}
92
93	std::map<String,DeviceCreationParameter*> AudioOutputDevice::ParameterSampleRate::DependsAsParameters() {
94	return std::map<String,DeviceCreationParameter*>();
95	}
96
97	optional<int> AudioOutputDevice::ParameterSampleRate::DefaultAsInt(std::map<String,String> Parameters) {
98	return 44100;
99	}
100
101	optional<int> AudioOutputDevice::ParameterSampleRate::RangeMinAsInt(std::map<String,String> Parameters) {
102	return optional<int>::nothing;
103	}
104
105	optional<int> AudioOutputDevice::ParameterSampleRate::RangeMaxAsInt(std::map<String,String> Parameters) {
106	return optional<int>::nothing;
107	}
108
109	std::vector<int> AudioOutputDevice::ParameterSampleRate::PossibilitiesAsInt(std::map<String,String> Parameters) {
110	return std::vector<int>();
111	}
112
113	int AudioOutputDevice::ParameterSampleRate::ValueAsInt() {
114	return (pDevice) ? (int) ((AudioOutputDevice*)pDevice)->SampleRate()
115	: DeviceCreationParameterInt::ValueAsInt();
116	}
117
118	void AudioOutputDevice::ParameterSampleRate::OnSetValue(int i) throw (Exception) {
119	/* cannot happen, as parameter is fix */
120	}
121
122	String AudioOutputDevice::ParameterSampleRate::Name() {
123	return "SAMPLERATE";
124	}
125
126
127
128	// ************* ParameterChannels *************
129	// *
130
131	AudioOutputDevice::ParameterChannels::ParameterChannels() : DeviceCreationParameterInt() {
132	InitWithDefault();
133	}
134
135	AudioOutputDevice::ParameterChannels::ParameterChannels(String s) : DeviceCreationParameterInt(s) {
136	}
137
138	String AudioOutputDevice::ParameterChannels::Description() {
139	return "Number of output channels";
140	}
141
142	bool AudioOutputDevice::ParameterChannels::Fix() {
143	return false;
144	}
145
146	bool AudioOutputDevice::ParameterChannels::Mandatory() {
147	return false;
148	}
149
150	std::map<String,DeviceCreationParameter*> AudioOutputDevice::ParameterChannels::DependsAsParameters() {
151	return std::map<String,DeviceCreationParameter*>();
152	}
153
154	optional<int> AudioOutputDevice::ParameterChannels::DefaultAsInt(std::map<String,String> Parameters) {
155	return 2;
156	}
157
158	optional<int> AudioOutputDevice::ParameterChannels::RangeMinAsInt(std::map<String,String> Parameters) {
159	return 1;
160	}
161
162	optional<int> AudioOutputDevice::ParameterChannels::RangeMaxAsInt(std::map<String,String> Parameters) {
163	return optional<int>::nothing;
164	}
165
166	std::vector<int> AudioOutputDevice::ParameterChannels::PossibilitiesAsInt(std::map<String,String> Parameters) {
167	return std::vector<int>();
168	}
169
170	void AudioOutputDevice::ParameterChannels::OnSetValue(int i) throw (Exception) {
171	((AudioOutputDevice*)pDevice)->AcquireChannels(i);
172	}
173
174	String AudioOutputDevice::ParameterChannels::Name() {
175	return "CHANNELS";
176	}
177
178
179
180	// ************* AudioOutputDevice *************
181	// *
182
183	AudioOutputDevice::AudioOutputDevice(std::map<String,DeviceCreationParameter*> DriverParameters)
184	: EnginesReader(Engines) {
185	this->Parameters = DriverParameters;
186	}
187
188	AudioOutputDevice::~AudioOutputDevice() {
189	// delete all audio channels
190	{
191	std::vector<AudioChannel*>::iterator iter = Channels.begin();
192	while (iter != Channels.end()) {
193	delete *iter;
194	iter++;
195	}
196	Channels.clear();
197	}
198
199	// delete all device parameters
200	{
201	std::map<String,DeviceCreationParameter*>::iterator iter = Parameters.begin();
202	while (iter != Parameters.end()) {
203	delete iter->second;
204	iter++;
205	}
206	Parameters.clear();
207	}
208	}
209
210	void AudioOutputDevice::Connect(Engine* pEngine) {
211	std::set<Engine*>& engines = Engines.GetConfigForUpdate();
212	if (engines.find(pEngine) == engines.end()) {
213	engines.insert(pEngine);
214	Engines.SwitchConfig().insert(pEngine);
215	// make sure the engine knows about the connection
216	//pEngine->Connect(this);
217	}
218	}
219
220	void AudioOutputDevice::Disconnect(Engine* pEngine) {
221	std::set<Engine*>& engines = Engines.GetConfigForUpdate();
222	if (engines.find(pEngine) != engines.end()) { // if clause to prevent disconnect loop
223	engines.erase(pEngine);
224	Engines.SwitchConfig().erase(pEngine);
225	// make sure the engine knows about the disconnection
226	//pEngine->DisconnectAudioOutputDevice();
227	}
228	}
229
230	AudioChannel* AudioOutputDevice::Channel(uint ChannelIndex) {
231	return (ChannelIndex < Channels.size()) ? Channels[ChannelIndex] : NULL;
232	}
233
234	void AudioOutputDevice::AcquireChannels(uint Channels) {
235	if (Channels > this->Channels.size()) {
236	for (int c = this->Channels.size(); c < Channels; c++) {
237	this->Channels.push_back(CreateChannel(c));
238	}
239	}
240	}
241
242	uint AudioOutputDevice::ChannelCount() {
243	return Channels.size();
244	}
245
246	std::map<String,DeviceCreationParameter*> AudioOutputDevice::DeviceParameters() {
247	return Parameters;
248	}
249
250	int AudioOutputDevice::RenderAudio(uint Samples) {
251	if (Channels.empty()) return 0;
252
253	// reset all channels with silence
254	{
255	std::vector<AudioChannel*>::iterator iterChannels = Channels.begin();
256	std::vector<AudioChannel*>::iterator end = Channels.end();
257	for (; iterChannels != end; iterChannels++)
258	(*iterChannels)->Clear(); // zero out audio buffer
259	}
260
261	int result = 0;
262
263	// let all connected engines render audio for the current audio fragment cycle
264	const std::set<Engine*>& engines = EnginesReader.Lock();
265	#if CONFIG_RT_EXCEPTIONS
266	try
267	#endif // CONFIG_RT_EXCEPTIONS
268	{
269	std::set<Engine*>::iterator iterEngine = engines.begin();
270	std::set<Engine*>::iterator end = engines.end();
271	for (; iterEngine != end; iterEngine++) {
272	int res = (*iterEngine)->RenderAudio(Samples);
273	if (res != 0) result = res;
274	}
275	}
276	#if CONFIG_RT_EXCEPTIONS
277	catch (std::runtime_error se) {
278	std::cerr << "std::runtime_error: " << se.what() << std::endl << std::flush;
279	exit(EXIT_FAILURE);
280	}
281	#endif // CONFIG_RT_EXCEPTIONS
282
283	EnginesReader.Unlock();
284	return result;
285	}
286
287	int AudioOutputDevice::RenderSilence(uint Samples) {
288	if (Channels.empty()) return 0;
289
290	// reset all channels with silence
291	{
292	std::vector<AudioChannel*>::iterator iterChannels = Channels.begin();
293	std::vector<AudioChannel*>::iterator end = Channels.end();
294	for (; iterChannels != end; iterChannels++)
295	(*iterChannels)->Clear(); // zero out audio buffer
296	}
297
298	return 0;
299	}
300
301	} // namespace LinuxSampler