/[svn]/linuxsampler/trunk/src/drivers/audio/AudioOutputDevice.cpp
ViewVC logotype

Contents of /linuxsampler/trunk/src/drivers/audio/AudioOutputDevice.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 836 - (show annotations) (download)
Wed Feb 8 20:28:46 2006 UTC (14 years, 1 month ago) by persson
File size: 9954 byte(s)
* fixed some invalid iterator errors

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

  ViewVC Help
Powered by ViewVC