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(Engine* pEngine) {
        if (Engines.find(pEngine) == Engines.end()) {
            Engines.insert(pEngine);
            // make sure the engine knows about the connection
            //pEngine->Connect(this);
        }
    }

    void AudioOutputDevice::Disconnect(Engine* pEngine) {
        if (Engines.find(pEngine) != Engines.end()) { // if clause to prevent disconnect loop
            Engines.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));
            }
        }
    }

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

        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	411	* Copyright (C) 2005 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
27			namespace LinuxSampler {
28
29	schoenebeck	226	// ************* 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	schoenebeck	200	AudioOutputDevice::AudioOutputDevice(std::map<String,DeviceCreationParameter*> DriverParameters) {
178			this->Parameters = DriverParameters;
179			}
180
181			AudioOutputDevice::~AudioOutputDevice() {
182	schoenebeck	226	// 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	schoenebeck	200	}
192	schoenebeck	226
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	schoenebeck	200	}
203
204	schoenebeck	412	void AudioOutputDevice::Connect(Engine* pEngine) {
205			if (Engines.find(pEngine) == Engines.end()) {
206			Engines.insert(pEngine);
207			// make sure the engine knows about the connection
208			//pEngine->Connect(this);
209	schoenebeck	200	}
210			}
211
212	schoenebeck	412	void AudioOutputDevice::Disconnect(Engine* pEngine) {
213			if (Engines.find(pEngine) != Engines.end()) { // if clause to prevent disconnect loop
214			Engines.erase(pEngine);
215			// make sure the engine knows about the disconnection
216			//pEngine->DisconnectAudioOutputDevice();
217	schoenebeck	200	}
218			}
219
220			AudioChannel* AudioOutputDevice::Channel(uint ChannelIndex) {
221			return (ChannelIndex < Channels.size()) ? Channels[ChannelIndex] : NULL;
222			}
223
224	schoenebeck	226	void AudioOutputDevice::AcquireChannels(uint Channels) {
225			if (Channels > this->Channels.size()) {
226			for (int c = this->Channels.size(); c < Channels; c++) {
227			this->Channels.push_back(CreateChannel(c));
228			}
229			}
230			}
231
232	schoenebeck	200	std::map<String,DeviceCreationParameter*> AudioOutputDevice::DeviceParameters() {
233			return Parameters;
234			}
235
236			int AudioOutputDevice::RenderAudio(uint Samples) {
237			if (Channels.empty()) return 0;
238
239			// reset all channels with silence
240			{
241			std::vector<AudioChannel*>::iterator iterChannels = Channels.begin();
242			std::vector<AudioChannel*>::iterator end = Channels.end();
243			for (; iterChannels != end; iterChannels++)
244			(*iterChannels)->Clear(); // zero out audio buffer
245			}
246
247			int result = 0;
248
249			// let all connected engines render audio for the current audio fragment cycle
250	schoenebeck	554	#if CONFIG_RT_EXCEPTIONS
251	schoenebeck	272	try
252	schoenebeck	554	#endif // CONFIG_RT_EXCEPTIONS
253	schoenebeck	200	{
254	schoenebeck	412	std::set<Engine*>::iterator iterEngine = Engines.begin();
255			std::set<Engine*>::iterator end = Engines.end();
256			for (; iterEngine != end; iterEngine++) {
257			int res = (*iterEngine)->RenderAudio(Samples);
258	schoenebeck	200	if (res != 0) result = res;
259			}
260			}
261	schoenebeck	554	#if CONFIG_RT_EXCEPTIONS
262	schoenebeck	272	catch (std::runtime_error se) {
263			std::cerr << "std::runtime_error: " << se.what() << std::endl << std::flush;
264			exit(EXIT_FAILURE);
265			}
266	schoenebeck	554	#endif // CONFIG_RT_EXCEPTIONS
267	schoenebeck	200
268			return result;
269			}
270
271			int AudioOutputDevice::RenderSilence(uint Samples) {
272			if (Channels.empty()) return 0;
273
274			// reset all channels with silence
275			{
276			std::vector<AudioChannel*>::iterator iterChannels = Channels.begin();
277			std::vector<AudioChannel*>::iterator end = Channels.end();
278			for (; iterChannels != end; iterChannels++)
279			(*iterChannels)->Clear(); // zero out audio buffer
280			}
281
282			return 0;
283			}
284
285			} // namespace LinuxSampler