drivers/audio/AudioOutputDevice.cpp

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *
 *   Copyright (C) 2005 - 2008 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();
        }

        // delete all master effect chains
        {
            std::vector<EffectChain*>::iterator iter = vEffectChains.begin();
            while (iter != vEffectChains.end()) {
                delete *iter;
                iter++;
            }
            vEffectChains.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;
    }

    EffectChain* AudioOutputDevice::AddMasterEffectChain() {
        EffectChain* pChain = new EffectChain(this);
        vEffectChains.push_back(pChain);
        return pChain;
    }

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

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

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

    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
        }
        // 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(); // zero out audio buffer
        }

        return 0;
    }

} // namespace LinuxSampler
1	schoenebeck	200	/***************************************************************************
2			* *
3			* LinuxSampler - modular, streaming capable sampler *
4			* *
5			* Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck *
6	schoenebeck	1722	* Copyright (C) 2005 - 2008 Christian Schoenebeck *
7	schoenebeck	200	* *
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	schoenebeck	1424	#include "../../common/global_private.h"
27	schoenebeck	200
28			namespace LinuxSampler {
29
30	schoenebeck	226	// ************* 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	schoenebeck	880	void AudioOutputDevice::ParameterActive::OnSetValue(bool b) throw (Exception) {
61	schoenebeck	226	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	schoenebeck	1607	int AudioOutputDevice::ParameterSampleRate::ValueAsInt() {
114			return (pDevice) ? (int) ((AudioOutputDevice*)pDevice)->SampleRate()
115			: DeviceCreationParameterInt::ValueAsInt();
116			}
117
118	schoenebeck	880	void AudioOutputDevice::ParameterSampleRate::OnSetValue(int i) throw (Exception) {
119	schoenebeck	226	/* 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	iliev	1305	return 1;
160	schoenebeck	226	}
161
162			optional<int> AudioOutputDevice::ParameterChannels::RangeMaxAsInt(std::map<String,String> Parameters) {
163	schoenebeck	1599	return optional<int>::nothing;
164	schoenebeck	226	}
165
166			std::vector<int> AudioOutputDevice::ParameterChannels::PossibilitiesAsInt(std::map<String,String> Parameters) {
167			return std::vector<int>();
168			}
169
170	schoenebeck	880	void AudioOutputDevice::ParameterChannels::OnSetValue(int i) throw (Exception) {
171	schoenebeck	226	((AudioOutputDevice*)pDevice)->AcquireChannels(i);
172			}
173
174			String AudioOutputDevice::ParameterChannels::Name() {
175			return "CHANNELS";
176			}
177
178
179
180			// ************* AudioOutputDevice *************
181			// *
182
183	persson	846	AudioOutputDevice::AudioOutputDevice(std::map<String,DeviceCreationParameter*> DriverParameters)
184			: EnginesReader(Engines) {
185	schoenebeck	200	this->Parameters = DriverParameters;
186			}
187
188			AudioOutputDevice::~AudioOutputDevice() {
189	schoenebeck	226	// 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	persson	836	Channels.clear();
197	schoenebeck	200	}
198	schoenebeck	226
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	persson	835	Parameters.clear();
207	schoenebeck	226	}
208	schoenebeck	1722
209			// delete all master effect chains
210			{
211			std::vector<EffectChain*>::iterator iter = vEffectChains.begin();
212			while (iter != vEffectChains.end()) {
213			delete *iter;
214			iter++;
215			}
216			vEffectChains.clear();
217			}
218	schoenebeck	200	}
219
220	schoenebeck	412	void AudioOutputDevice::Connect(Engine* pEngine) {
221	persson	840	std::set<Engine*>& engines = Engines.GetConfigForUpdate();
222			if (engines.find(pEngine) == engines.end()) {
223			engines.insert(pEngine);
224			Engines.SwitchConfig().insert(pEngine);
225	schoenebeck	412	// make sure the engine knows about the connection
226			//pEngine->Connect(this);
227	schoenebeck	200	}
228			}
229
230	schoenebeck	412	void AudioOutputDevice::Disconnect(Engine* pEngine) {
231	persson	840	std::set<Engine*>& engines = Engines.GetConfigForUpdate();
232			if (engines.find(pEngine) != engines.end()) { // if clause to prevent disconnect loop
233			engines.erase(pEngine);
234			Engines.SwitchConfig().erase(pEngine);
235	schoenebeck	412	// make sure the engine knows about the disconnection
236			//pEngine->DisconnectAudioOutputDevice();
237	schoenebeck	200	}
238			}
239
240			AudioChannel* AudioOutputDevice::Channel(uint ChannelIndex) {
241			return (ChannelIndex < Channels.size()) ? Channels[ChannelIndex] : NULL;
242			}
243
244	schoenebeck	226	void AudioOutputDevice::AcquireChannels(uint Channels) {
245			if (Channels > this->Channels.size()) {
246			for (int c = this->Channels.size(); c < Channels; c++) {
247			this->Channels.push_back(CreateChannel(c));
248			}
249			}
250			}
251
252	schoenebeck	1001	uint AudioOutputDevice::ChannelCount() {
253			return Channels.size();
254			}
255
256	schoenebeck	200	std::map<String,DeviceCreationParameter*> AudioOutputDevice::DeviceParameters() {
257			return Parameters;
258			}
259
260	schoenebeck	1722	EffectChain* AudioOutputDevice::AddMasterEffectChain() {
261			EffectChain* pChain = new EffectChain(this);
262			vEffectChains.push_back(pChain);
263			return pChain;
264			}
265
266			void AudioOutputDevice::RemoveMasterEffectChain(uint iChain) throw (Exception) {
267			if (iChain >= vEffectChains.size())
268			throw Exception(
269			"Could not remove master effect chain " + ToString(iChain) +
270			", index out of bounds"
271			);
272			std::vector<EffectChain*>::iterator iter = vEffectChains.begin();
273			for (int i = 0; i < iChain; ++i) ++iter;
274			vEffectChains.erase(iter);
275			}
276
277			EffectChain* AudioOutputDevice::MasterEffectChain(uint iChain) const {
278			if (iChain >= vEffectChains.size()) return NULL;
279			return vEffectChains[iChain];
280			}
281
282			uint AudioOutputDevice::MasterEffectChainCount() const {
283			return vEffectChains.size();
284			}
285
286	schoenebeck	200	int AudioOutputDevice::RenderAudio(uint Samples) {
287			if (Channels.empty()) return 0;
288
289			// reset all channels with silence
290			{
291			std::vector<AudioChannel*>::iterator iterChannels = Channels.begin();
292			std::vector<AudioChannel*>::iterator end = Channels.end();
293			for (; iterChannels != end; iterChannels++)
294			(*iterChannels)->Clear(); // zero out audio buffer
295			}
296	schoenebeck	1722	// do the same for master effects
297			{
298			std::vector<EffectChain*>::iterator iterChains = vEffectChains.begin();
299			std::vector<EffectChain*>::iterator end = vEffectChains.end();
300			for (; iterChains != end; ++iterChains)
301			(*iterChains)->ClearAllChannels(); // zero out audio buffers
302			}
303	schoenebeck	200
304			int result = 0;
305
306			// let all connected engines render audio for the current audio fragment cycle
307	persson	846	const std::set<Engine*>& engines = EnginesReader.Lock();
308	schoenebeck	554	#if CONFIG_RT_EXCEPTIONS
309	schoenebeck	272	try
310	schoenebeck	554	#endif // CONFIG_RT_EXCEPTIONS
311	schoenebeck	200	{
312	persson	840	std::set<Engine*>::iterator iterEngine = engines.begin();
313			std::set<Engine*>::iterator end = engines.end();
314	schoenebeck	412	for (; iterEngine != end; iterEngine++) {
315			int res = (*iterEngine)->RenderAudio(Samples);
316	schoenebeck	200	if (res != 0) result = res;
317			}
318			}
319	schoenebeck	554	#if CONFIG_RT_EXCEPTIONS
320	schoenebeck	272	catch (std::runtime_error se) {
321			std::cerr << "std::runtime_error: " << se.what() << std::endl << std::flush;
322			exit(EXIT_FAILURE);
323			}
324	schoenebeck	554	#endif // CONFIG_RT_EXCEPTIONS
325	schoenebeck	1722	EnginesReader.Unlock();
326	schoenebeck	200
327	schoenebeck	1722	// now that the engines (might) have left fx send signals for master
328			// effects, render all master effects
329			{
330			std::vector<EffectChain*>::iterator iterChains = vEffectChains.begin();
331			std::vector<EffectChain*>::iterator end = vEffectChains.end();
332			for (; iterChains != end; ++iterChains) {
333			if (!(*iterChains)->EffectCount()) continue;
334			(*iterChains)->RenderAudio(Samples);
335			// mix the result of the last effect in the chain to the audio
336			// output device channel(s)
337			Effect* pLastEffect =
338			(iterChains)->GetEffect((iterChains)->EffectCount() - 1);
339			for (int iChan = 0; iChan < pLastEffect->OutputChannelCount() && iChan < ChannelCount(); ++iChan)
340			pLastEffect->OutputChannel(iChan)->MixTo(Channel(iChan), Samples);
341			}
342			}
343
344	schoenebeck	200	return result;
345			}
346
347			int AudioOutputDevice::RenderSilence(uint Samples) {
348			if (Channels.empty()) return 0;
349
350			// reset all channels with silence
351			{
352			std::vector<AudioChannel*>::iterator iterChannels = Channels.begin();
353			std::vector<AudioChannel*>::iterator end = Channels.end();
354			for (; iterChannels != end; iterChannels++)
355			(*iterChannels)->Clear(); // zero out audio buffer
356			}
357
358			return 0;
359			}
360
361			} // namespace LinuxSampler