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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 200 by schoenebeck, Tue Jul 13 22:04:16 2004 UTC revision 554 by schoenebeck, Thu May 19 19:25:14 2005 UTC
# Line 3  Line 3 
3   *   LinuxSampler - modular, streaming capable sampler                     *   *   LinuxSampler - modular, streaming capable sampler                     *
4   *                                                                         *   *                                                                         *
5   *   Copyright (C) 2003, 2004 by Benno Senoner and Christian Schoenebeck   *   *   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  *   *   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  *   *   it under the terms of the GNU General Public License as published by  *
# Line 25  Line 26 
26    
27  namespace LinuxSampler {  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) {      AudioOutputDevice::AudioOutputDevice(std::map<String,DeviceCreationParameter*> DriverParameters) {
178          this->Parameters = DriverParameters;          this->Parameters = DriverParameters;
179      }      }
180    
181      AudioOutputDevice::~AudioOutputDevice() {      AudioOutputDevice::~AudioOutputDevice() {
182          std::map<String,DeviceCreationParameter*>::iterator iter = Parameters.begin();          // delete all audio channels
183          while (iter != Parameters.end()) {          {
184              Parameters.erase(iter);              std::vector<AudioChannel*>::iterator iter = Channels.begin();
185              delete iter->second;              while (iter != Channels.end()) {
186              iter++;                  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) {      void AudioOutputDevice::Connect(Engine* pEngine) {
205          if (Engines.find(pEngine) == Engines.end()) {          if (Engines.find(pEngine) == Engines.end()) {
             pEngine->Connect(this);  
206              Engines.insert(pEngine);              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) {      void AudioOutputDevice::Disconnect(Engine* pEngine) {
213          if (Engines.find(pEngine) != Engines.end()) { // if clause to prevent disconnect loop          if (Engines.find(pEngine) != Engines.end()) { // if clause to prevent disconnect loop
214              Engines.erase(pEngine);              Engines.erase(pEngine);
215              pEngine->DisconnectAudioOutputDevice();              // make sure the engine knows about the disconnection
216                //pEngine->DisconnectAudioOutputDevice();
217          }          }
218      }      }
219    
# Line 56  namespace LinuxSampler { Line 221  namespace LinuxSampler {
221          return (ChannelIndex < Channels.size()) ? Channels[ChannelIndex] : NULL;          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() {      std::map<String,DeviceCreationParameter*> AudioOutputDevice::DeviceParameters() {
233          return Parameters;          return Parameters;
234      }      }
# Line 74  namespace LinuxSampler { Line 247  namespace LinuxSampler {
247          int result = 0;          int result = 0;
248    
249          // let all connected engines render audio for the current audio fragment cycle          // 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();              std::set<Engine*>::iterator iterEngine = Engines.begin();
255              std::set<Engine*>::iterator end        = Engines.end();              std::set<Engine*>::iterator end        = Engines.end();
# Line 82  namespace LinuxSampler { Line 258  namespace LinuxSampler {
258                  if (res != 0) result = res;                  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;          return result;
269      }      }
Legend:
Removed from v.200  
changed lines
  Added in v.554
  ViewVC Help
Powered by ViewVC