/[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 554 - (show annotations) (download)
Thu May 19 19:25:14 2005 UTC (18 years, 10 months ago) by schoenebeck
File size: 9971 byte(s)
* All compile time options are now centrally alterable as arguments to the
  ./configure script. All options are C Macros beginning with CONFIG_
  prefix and will be placed into auto generated config.h file.

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 Channels.erase(iter);
187 delete *iter;
188 iter++;
189 }
190
191 }
192
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 }
203
204 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 }
210 }
211
212 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 }
218 }
219
220 AudioChannel* AudioOutputDevice::Channel(uint ChannelIndex) {
221 return (ChannelIndex < Channels.size()) ? Channels[ChannelIndex] : NULL;
222 }
223
224 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 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 #if CONFIG_RT_EXCEPTIONS
251 try
252 #endif // CONFIG_RT_EXCEPTIONS
253 {
254 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 if (res != 0) result = res;
259 }
260 }
261 #if CONFIG_RT_EXCEPTIONS
262 catch (std::runtime_error se) {
263 std::cerr << "std::runtime_error: " << se.what() << std::endl << std::flush;
264 exit(EXIT_FAILURE);
265 }
266 #endif // CONFIG_RT_EXCEPTIONS
267
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

  ViewVC Help
Powered by ViewVC