drivers/audio/AudioOutputDevice.cpp

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

    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();
        }

        // delete all master effect chains
        {
            std::vector<EffectChain*>::iterator iter = vEffectChains.begin();
            while (iter != vEffectChains.end()) {
                delete *iter;
                iter++;
            }
            vEffectChains.clear();
        }
        
        delete EffectChainIDs;
    }

    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();
        }
    }
    
    void AudioOutputDevice::ReconnectAll() {
        // copy by value, not by reference here !
        std::set<Engine*> engines = Engines.GetConfigForUpdate();
        {
            std::set<Engine*>::iterator iterEngine = engines.begin();
            std::set<Engine*>::iterator end        = engines.end();
            for (; iterEngine != end; iterEngine++) {
                (*iterEngine)->ReconnectAudioOutputDevice();
            }
        }
    }

    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;
    }

    EffectChain* AudioOutputDevice::AddSendEffectChain() {
        EffectChain* pChain = new EffectChain(this, EffectChainIDs->create());
        vEffectChains.push_back(pChain);
        return pChain;
    }

    void AudioOutputDevice::RemoveSendEffectChain(uint iChain) throw (Exception) {
        if (iChain >= vEffectChains.size())
            throw Exception(
                "Could not remove send effect chain " + ToString(iChain) +
                ", index out of bounds"
            );
        std::vector<EffectChain*>::iterator iter = vEffectChains.begin();
        for (int i = 0; i < iChain; ++i) ++iter;
        EffectChainIDs->destroy((*iter)->ID());
        vEffectChains.erase(iter);
    }

    EffectChain* AudioOutputDevice::SendEffectChain(uint iChain) const {
        if (iChain >= vEffectChains.size()) return NULL;
        return vEffectChains[iChain];
    }

    EffectChain* AudioOutputDevice::SendEffectChainByID(uint iChainID) const {
        for (int i = 0; i < SendEffectChainCount(); i++) {
            if (SendEffectChain(i)->ID() == iChainID) return SendEffectChain(i);
        }

        return NULL;
    }

    uint AudioOutputDevice::SendEffectChainCount() const {
        return vEffectChains.size();
    }

    // TODO: to be removed
    EffectChain* AudioOutputDevice::AddMasterEffectChain() {
        return AddSendEffectChain();
    }

    // TODO: to be removed
    void AudioOutputDevice::RemoveMasterEffectChain(uint iChain) throw (Exception) {
        RemoveSendEffectChain(iChain);
    }

    // TODO: to be removed
    EffectChain* AudioOutputDevice::MasterEffectChain(uint iChain) const {
        return SendEffectChain(iChain);
    }

    // TODO: to be removed
    uint AudioOutputDevice::MasterEffectChainCount() const {
        return SendEffectChainCount();
    }
    
    float AudioOutputDevice::latency() {
        return float(MaxSamplesPerCycle()) / float(SampleRate());
    }

    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(Samples); // zero out audio buffer
        }
        // do the same for master effects
        {
            std::vector<EffectChain*>::iterator iterChains = vEffectChains.begin();
            std::vector<EffectChain*>::iterator end        = vEffectChains.end();
            for (; iterChains != end; ++iterChains)
                (*iterChains)->ClearAllChannels(); // zero out audio buffers
        }

        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();

        // now that the engines (might) have left fx send signals for master
        // effects, render all master effects
        {
            std::vector<EffectChain*>::iterator iterChains = vEffectChains.begin();
            std::vector<EffectChain*>::iterator end        = vEffectChains.end();
            for (; iterChains != end; ++iterChains) {
                if (!(*iterChains)->EffectCount()) continue;
                (*iterChains)->RenderAudio(Samples);
                // mix the result of the last effect in the chain to the audio
                // output device channel(s)
                Effect* pLastEffect =
                    (*iterChains)->GetEffect((*iterChains)->EffectCount() - 1);
                for (int iChan = 0; iChan < pLastEffect->OutputChannelCount() && iChan < ChannelCount(); ++iChan)
                    pLastEffect->OutputChannel(iChan)->MixTo(Channel(iChan), Samples);
            }
        }

        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(Samples); // 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 - 2010 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	#include "../../common/IDGenerator.h"
28
29	namespace LinuxSampler {
30
31	// ************* ParameterActive *************
32	// *
33
34	AudioOutputDevice::ParameterActive::ParameterActive() : DeviceCreationParameterBool() {
35	InitWithDefault();
36	}
37
38	AudioOutputDevice::ParameterActive::ParameterActive(String s) : DeviceCreationParameterBool(s) {
39	}
40
41	String AudioOutputDevice::ParameterActive::Description() {
42	return "Enable / disable device";
43	}
44
45	bool AudioOutputDevice::ParameterActive::Fix() {
46	return false;
47	}
48
49	bool AudioOutputDevice::ParameterActive::Mandatory() {
50	return false;
51	}
52
53	std::map<String,DeviceCreationParameter*> AudioOutputDevice::ParameterActive::DependsAsParameters() {
54	return std::map<String,DeviceCreationParameter*>();
55	}
56
57	optional<bool> AudioOutputDevice::ParameterActive::DefaultAsBool(std::map<String,String> Parameters) {
58	return true;
59	}
60
61	void AudioOutputDevice::ParameterActive::OnSetValue(bool b) throw (Exception) {
62	if (b) ((AudioOutputDevice*)pDevice)->Play();
63	else ((AudioOutputDevice*)pDevice)->Stop();
64	}
65
66	String AudioOutputDevice::ParameterActive::Name() {
67	return "ACTIVE";
68	}
69
70
71
72	// ************* ParameterSampleRate *************
73	// *
74
75	AudioOutputDevice::ParameterSampleRate::ParameterSampleRate() : DeviceCreationParameterInt() {
76	InitWithDefault();
77	}
78
79	AudioOutputDevice::ParameterSampleRate::ParameterSampleRate(String s) : DeviceCreationParameterInt(s) {
80	}
81
82	String AudioOutputDevice::ParameterSampleRate::Description() {
83	return "Output sample rate";
84	}
85
86	bool AudioOutputDevice::ParameterSampleRate::Fix() {
87	return true;
88	}
89
90	bool AudioOutputDevice::ParameterSampleRate::Mandatory() {
91	return false;
92	}
93
94	std::map<String,DeviceCreationParameter*> AudioOutputDevice::ParameterSampleRate::DependsAsParameters() {
95	return std::map<String,DeviceCreationParameter*>();
96	}
97
98	optional<int> AudioOutputDevice::ParameterSampleRate::DefaultAsInt(std::map<String,String> Parameters) {
99	return 44100;
100	}
101
102	optional<int> AudioOutputDevice::ParameterSampleRate::RangeMinAsInt(std::map<String,String> Parameters) {
103	return optional<int>::nothing;
104	}
105
106	optional<int> AudioOutputDevice::ParameterSampleRate::RangeMaxAsInt(std::map<String,String> Parameters) {
107	return optional<int>::nothing;
108	}
109
110	std::vector<int> AudioOutputDevice::ParameterSampleRate::PossibilitiesAsInt(std::map<String,String> Parameters) {
111	return std::vector<int>();
112	}
113
114	int AudioOutputDevice::ParameterSampleRate::ValueAsInt() {
115	return (pDevice) ? (int) ((AudioOutputDevice*)pDevice)->SampleRate()
116	: DeviceCreationParameterInt::ValueAsInt();
117	}
118
119	void AudioOutputDevice::ParameterSampleRate::OnSetValue(int i) throw (Exception) {
120	/* cannot happen, as parameter is fix */
121	}
122
123	String AudioOutputDevice::ParameterSampleRate::Name() {
124	return "SAMPLERATE";
125	}
126
127
128
129	// ************* ParameterChannels *************
130	// *
131
132	AudioOutputDevice::ParameterChannels::ParameterChannels() : DeviceCreationParameterInt() {
133	InitWithDefault();
134	}
135
136	AudioOutputDevice::ParameterChannels::ParameterChannels(String s) : DeviceCreationParameterInt(s) {
137	}
138
139	String AudioOutputDevice::ParameterChannels::Description() {
140	return "Number of output channels";
141	}
142
143	bool AudioOutputDevice::ParameterChannels::Fix() {
144	return false;
145	}
146
147	bool AudioOutputDevice::ParameterChannels::Mandatory() {
148	return false;
149	}
150
151	std::map<String,DeviceCreationParameter*> AudioOutputDevice::ParameterChannels::DependsAsParameters() {
152	return std::map<String,DeviceCreationParameter*>();
153	}
154
155	optional<int> AudioOutputDevice::ParameterChannels::DefaultAsInt(std::map<String,String> Parameters) {
156	return 2;
157	}
158
159	optional<int> AudioOutputDevice::ParameterChannels::RangeMinAsInt(std::map<String,String> Parameters) {
160	return 1;
161	}
162
163	optional<int> AudioOutputDevice::ParameterChannels::RangeMaxAsInt(std::map<String,String> Parameters) {
164	return optional<int>::nothing;
165	}
166
167	std::vector<int> AudioOutputDevice::ParameterChannels::PossibilitiesAsInt(std::map<String,String> Parameters) {
168	return std::vector<int>();
169	}
170
171	void AudioOutputDevice::ParameterChannels::OnSetValue(int i) throw (Exception) {
172	((AudioOutputDevice*)pDevice)->AcquireChannels(i);
173	}
174
175	String AudioOutputDevice::ParameterChannels::Name() {
176	return "CHANNELS";
177	}
178
179
180
181	// ************* AudioOutputDevice *************
182	// *
183
184	AudioOutputDevice::AudioOutputDevice(std::map<String,DeviceCreationParameter*> DriverParameters)
185	: EnginesReader(Engines) {
186	this->Parameters = DriverParameters;
187	EffectChainIDs = new IDGenerator();
188	}
189
190	AudioOutputDevice::~AudioOutputDevice() {
191	// delete all audio channels
192	{
193	std::vector<AudioChannel*>::iterator iter = Channels.begin();
194	while (iter != Channels.end()) {
195	delete *iter;
196	iter++;
197	}
198	Channels.clear();
199	}
200
201	// delete all device parameters
202	{
203	std::map<String,DeviceCreationParameter*>::iterator iter = Parameters.begin();
204	while (iter != Parameters.end()) {
205	delete iter->second;
206	iter++;
207	}
208	Parameters.clear();
209	}
210
211	// delete all master effect chains
212	{
213	std::vector<EffectChain*>::iterator iter = vEffectChains.begin();
214	while (iter != vEffectChains.end()) {
215	delete *iter;
216	iter++;
217	}
218	vEffectChains.clear();
219	}
220
221	delete EffectChainIDs;
222	}
223
224	void AudioOutputDevice::Connect(Engine* pEngine) {
225	std::set<Engine*>& engines = Engines.GetConfigForUpdate();
226	if (engines.find(pEngine) == engines.end()) {
227	engines.insert(pEngine);
228	Engines.SwitchConfig().insert(pEngine);
229	// make sure the engine knows about the connection
230	//pEngine->Connect(this);
231	}
232	}
233
234	void AudioOutputDevice::Disconnect(Engine* pEngine) {
235	std::set<Engine*>& engines = Engines.GetConfigForUpdate();
236	if (engines.find(pEngine) != engines.end()) { // if clause to prevent disconnect loop
237	engines.erase(pEngine);
238	Engines.SwitchConfig().erase(pEngine);
239	// make sure the engine knows about the disconnection
240	//pEngine->DisconnectAudioOutputDevice();
241	}
242	}
243
244	void AudioOutputDevice::ReconnectAll() {
245	// copy by value, not by reference here !
246	std::set<Engine*> engines = Engines.GetConfigForUpdate();
247	{
248	std::set<Engine*>::iterator iterEngine = engines.begin();
249	std::set<Engine*>::iterator end = engines.end();
250	for (; iterEngine != end; iterEngine++) {
251	(*iterEngine)->ReconnectAudioOutputDevice();
252	}
253	}
254	}
255
256	AudioChannel* AudioOutputDevice::Channel(uint ChannelIndex) {
257	return (ChannelIndex < Channels.size()) ? Channels[ChannelIndex] : NULL;
258	}
259
260	void AudioOutputDevice::AcquireChannels(uint Channels) {
261	if (Channels > this->Channels.size()) {
262	for (int c = this->Channels.size(); c < Channels; c++) {
263	this->Channels.push_back(CreateChannel(c));
264	}
265	}
266	}
267
268	uint AudioOutputDevice::ChannelCount() {
269	return Channels.size();
270	}
271
272	std::map<String,DeviceCreationParameter*> AudioOutputDevice::DeviceParameters() {
273	return Parameters;
274	}
275
276	EffectChain* AudioOutputDevice::AddSendEffectChain() {
277	EffectChain* pChain = new EffectChain(this, EffectChainIDs->create());
278	vEffectChains.push_back(pChain);
279	return pChain;
280	}
281
282	void AudioOutputDevice::RemoveSendEffectChain(uint iChain) throw (Exception) {
283	if (iChain >= vEffectChains.size())
284	throw Exception(
285	"Could not remove send effect chain " + ToString(iChain) +
286	", index out of bounds"
287	);
288	std::vector<EffectChain*>::iterator iter = vEffectChains.begin();
289	for (int i = 0; i < iChain; ++i) ++iter;
290	EffectChainIDs->destroy((*iter)->ID());
291	vEffectChains.erase(iter);
292	}
293
294	EffectChain* AudioOutputDevice::SendEffectChain(uint iChain) const {
295	if (iChain >= vEffectChains.size()) return NULL;
296	return vEffectChains[iChain];
297	}
298
299	EffectChain* AudioOutputDevice::SendEffectChainByID(uint iChainID) const {
300	for (int i = 0; i < SendEffectChainCount(); i++) {
301	if (SendEffectChain(i)->ID() == iChainID) return SendEffectChain(i);
302	}
303
304	return NULL;
305	}
306
307	uint AudioOutputDevice::SendEffectChainCount() const {
308	return vEffectChains.size();
309	}
310
311	// TODO: to be removed
312	EffectChain* AudioOutputDevice::AddMasterEffectChain() {
313	return AddSendEffectChain();
314	}
315
316	// TODO: to be removed
317	void AudioOutputDevice::RemoveMasterEffectChain(uint iChain) throw (Exception) {
318	RemoveSendEffectChain(iChain);
319	}
320
321	// TODO: to be removed
322	EffectChain* AudioOutputDevice::MasterEffectChain(uint iChain) const {
323	return SendEffectChain(iChain);
324	}
325
326	// TODO: to be removed
327	uint AudioOutputDevice::MasterEffectChainCount() const {
328	return SendEffectChainCount();
329	}
330
331	float AudioOutputDevice::latency() {
332	return float(MaxSamplesPerCycle()) / float(SampleRate());
333	}
334
335	int AudioOutputDevice::RenderAudio(uint Samples) {
336	if (Channels.empty()) return 0;
337
338	// reset all channels with silence
339	{
340	std::vector<AudioChannel*>::iterator iterChannels = Channels.begin();
341	std::vector<AudioChannel*>::iterator end = Channels.end();
342	for (; iterChannels != end; iterChannels++)
343	(*iterChannels)->Clear(Samples); // zero out audio buffer
344	}
345	// do the same for master effects
346	{
347	std::vector<EffectChain*>::iterator iterChains = vEffectChains.begin();
348	std::vector<EffectChain*>::iterator end = vEffectChains.end();
349	for (; iterChains != end; ++iterChains)
350	(*iterChains)->ClearAllChannels(); // zero out audio buffers
351	}
352
353	int result = 0;
354
355	// let all connected engines render audio for the current audio fragment cycle
356	const std::set<Engine*>& engines = EnginesReader.Lock();
357	#if CONFIG_RT_EXCEPTIONS
358	try
359	#endif // CONFIG_RT_EXCEPTIONS
360	{
361	std::set<Engine*>::iterator iterEngine = engines.begin();
362	std::set<Engine*>::iterator end = engines.end();
363	for (; iterEngine != end; iterEngine++) {
364	int res = (*iterEngine)->RenderAudio(Samples);
365	if (res != 0) result = res;
366	}
367	}
368	#if CONFIG_RT_EXCEPTIONS
369	catch (std::runtime_error se) {
370	std::cerr << "std::runtime_error: " << se.what() << std::endl << std::flush;
371	exit(EXIT_FAILURE);
372	}
373	#endif // CONFIG_RT_EXCEPTIONS
374	EnginesReader.Unlock();
375
376	// now that the engines (might) have left fx send signals for master
377	// effects, render all master effects
378	{
379	std::vector<EffectChain*>::iterator iterChains = vEffectChains.begin();
380	std::vector<EffectChain*>::iterator end = vEffectChains.end();
381	for (; iterChains != end; ++iterChains) {
382	if (!(*iterChains)->EffectCount()) continue;
383	(*iterChains)->RenderAudio(Samples);
384	// mix the result of the last effect in the chain to the audio
385	// output device channel(s)
386	Effect* pLastEffect =
387	(iterChains)->GetEffect((iterChains)->EffectCount() - 1);
388	for (int iChan = 0; iChan < pLastEffect->OutputChannelCount() && iChan < ChannelCount(); ++iChan)
389	pLastEffect->OutputChannel(iChan)->MixTo(Channel(iChan), Samples);
390	}
391	}
392
393	return result;
394	}
395
396	int AudioOutputDevice::RenderSilence(uint Samples) {
397	if (Channels.empty()) return 0;
398
399	// reset all channels with silence
400	{
401	std::vector<AudioChannel*>::iterator iterChannels = Channels.begin();
402	std::vector<AudioChannel*>::iterator end = Channels.end();
403	for (; iterChannels != end; iterChannels++)
404	(*iterChannels)->Clear(Samples); // zero out audio buffer
405	}
406
407	return 0;
408	}
409
410	} // namespace LinuxSampler