/[svn]/linuxsampler/trunk/src/Sampler.cpp
ViewVC logotype

Contents of /linuxsampler/trunk/src/Sampler.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 412 - (show annotations) (download)
Sat Feb 26 22:44:51 2005 UTC (19 years, 1 month ago) by schoenebeck
File size: 14683 byte(s)
* gig::Engine: fixed silence (engine channels' events were not imported
  into the engine, fixed undesired creation of new gig::Engine instances
  (and disk threads)
* AudioOutputDevice: reverted behavior to render per Engine instance (and
  not per EngineChannel instance)

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 <sstream>
25
26 #include "Sampler.h"
27
28 #include "engines/EngineChannelFactory.h"
29 #include "drivers/audio/AudioOutputDeviceFactory.h"
30 #include "drivers/midi/MidiInputDeviceFactory.h"
31 #include "network/lscpserver.h"
32
33 namespace LinuxSampler {
34
35 // ******************************************************************
36 // * SamplerChannel
37
38 SamplerChannel::SamplerChannel(Sampler* pS) {
39 pSampler = pS;
40 pEngineChannel = NULL;
41 pMidiInputDevice = NULL;
42 pAudioOutputDevice = NULL;
43 midiPort = 0;
44 midiChannel = MidiInputPort::midi_chan_all;
45 iIndex = -1;
46 }
47
48 SamplerChannel::~SamplerChannel() {
49 if (pEngineChannel) {
50 MidiInputPort* pMidiInputPort = GetMidiInputDevicePort(this->midiPort);
51 if (pMidiInputPort) pMidiInputPort->Disconnect(pEngineChannel);
52 if (pAudioOutputDevice) pEngineChannel->DisconnectAudioOutputDevice();
53 delete pEngineChannel;
54 }
55 }
56
57 void SamplerChannel::SetEngineType(String EngineType) throw (LinuxSamplerException) {
58 dmsg(2,("SamplerChannel: Assigning engine type..."));
59
60 // create new engine channel
61 EngineChannel* pNewEngineChannel = EngineChannelFactory::Create(EngineType);
62 if (!pNewEngineChannel) throw LinuxSamplerException("Unknown engine type");
63
64 // dereference midi input port.
65 MidiInputPort* pMidiInputPort = GetMidiInputDevicePort(this->midiPort);
66 // disconnect old engine
67 if (pEngineChannel) {
68 if (pMidiInputPort) pMidiInputPort->Disconnect(pEngineChannel);
69 if (pAudioOutputDevice) pEngineChannel->DisconnectAudioOutputDevice();
70 delete pEngineChannel;
71 }
72
73 // connect new engine channel
74 pEngineChannel = pNewEngineChannel;
75 if (pMidiInputPort) pMidiInputPort->Connect(pNewEngineChannel, this->midiChannel);
76 if (pAudioOutputDevice) {
77 pNewEngineChannel->Connect(pAudioOutputDevice);
78 pAudioOutputDevice->Connect(pNewEngineChannel->GetEngine());
79 }
80 dmsg(2,("OK\n"));
81 }
82
83 void SamplerChannel::SetAudioOutputDevice(AudioOutputDevice* pDevice) {
84 // disconnect old device
85 if (pAudioOutputDevice && pEngineChannel) pEngineChannel->DisconnectAudioOutputDevice();
86 // connect new device
87 pAudioOutputDevice = pDevice;
88 if (pEngineChannel) {
89 pEngineChannel->Connect(pAudioOutputDevice);
90 pAudioOutputDevice->Connect(pEngineChannel->GetEngine());
91 }
92 }
93
94 void SamplerChannel::SetMidiInputDevice(MidiInputDevice* pDevice) {
95 SetMidiInput(pDevice, this->midiPort, this->midiChannel);
96 }
97
98 void SamplerChannel::SetMidiInputPort(int MidiPort) {
99 SetMidiInput(pMidiInputDevice, MidiPort, this->midiChannel);
100 }
101
102 void SamplerChannel::SetMidiInputChannel(MidiInputPort::midi_chan_t MidiChannel) {
103 SetMidiInput(pMidiInputDevice, this->midiPort, MidiChannel);
104 }
105
106 void SamplerChannel::SetMidiInput(MidiInputDevice* pDevice, int iMidiPort, MidiInputPort::midi_chan_t MidiChannel) {
107 // dereference old midi input port.
108 MidiInputPort* pMidiInputPort = GetMidiInputDevicePort(this->midiPort);
109 // disconnect old device port
110 if (pMidiInputPort && pEngineChannel) pMidiInputPort->Disconnect(pEngineChannel);
111 // new device, port and channel
112 pMidiInputDevice = pDevice;
113 this->midiPort = iMidiPort;
114 this->midiChannel = MidiChannel;
115 // connect new device port
116 pMidiInputPort = GetMidiInputDevicePort(this->midiPort);
117 if (pMidiInputPort && pEngineChannel) pMidiInputPort->Connect(pEngineChannel, MidiChannel);
118 // Ooops.
119 if (pMidiInputPort == NULL)
120 throw LinuxSamplerException("There is no MIDI input port with index " + ToString(iMidiPort) + ".");
121 }
122
123 EngineChannel* SamplerChannel::GetEngineChannel() {
124 return pEngineChannel;
125 }
126
127 MidiInputPort::midi_chan_t SamplerChannel::GetMidiInputChannel() {
128 return this->midiChannel;
129 }
130
131 int SamplerChannel::GetMidiInputPort() {
132 MidiInputPort* pMidiInputPort = GetMidiInputDevicePort(this->midiPort);
133 return (pMidiInputPort ? (int) pMidiInputPort->GetPortNumber() : -1);
134 }
135
136 AudioOutputDevice* SamplerChannel::GetAudioOutputDevice() {
137 return pAudioOutputDevice;
138 }
139
140 MidiInputDevice* SamplerChannel::GetMidiInputDevice() {
141 return pMidiInputDevice;
142 }
143
144 uint SamplerChannel::Index() {
145 if (iIndex >= 0) return iIndex;
146
147 Sampler::SamplerChannelMap::iterator iter = pSampler->mSamplerChannels.begin();
148 for (; iter != pSampler->mSamplerChannels.end(); iter++) {
149 if (iter->second == this) {
150 iIndex = iter->first;
151 return iIndex;
152 }
153 }
154
155 throw LinuxSamplerException("Internal error: SamplerChannel index not found");
156 }
157
158 MidiInputPort* SamplerChannel::GetMidiInputDevicePort(int iMidiPort) {
159 MidiInputPort* pMidiInputPort = NULL;
160 if (pMidiInputDevice)
161 pMidiInputPort = pMidiInputDevice->GetPort(iMidiPort);
162 return pMidiInputPort;
163 }
164
165
166
167 // ******************************************************************
168 // * Sampler
169
170 Sampler::Sampler() {
171 }
172
173 Sampler::~Sampler() {
174 Reset();
175 }
176
177 uint Sampler::SamplerChannels() {
178 return mSamplerChannels.size();
179 }
180
181 SamplerChannel* Sampler::AddSamplerChannel() {
182 // if there's no sampler channel yet
183 if (!mSamplerChannels.size()) {
184 SamplerChannel* pChannel = new SamplerChannel(this);
185 mSamplerChannels[0] = pChannel;
186 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_channels, 1));
187 return pChannel;
188 }
189
190 // get the highest used sampler channel index
191 uint lastIndex = (--(mSamplerChannels.end()))->first;
192
193 // check if we reached the index limit
194 if (lastIndex + 1 < lastIndex) {
195 // search for an unoccupied sampler channel index starting from 0
196 for (uint i = 0; i < lastIndex; i++) {
197 if (mSamplerChannels.find(i) != mSamplerChannels.end()) continue;
198 // we found an unused index, so insert the new channel there
199 SamplerChannel* pChannel = new SamplerChannel(this);
200 mSamplerChannels[i] = pChannel;
201 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_channels, i));
202 return pChannel;
203 }
204 throw LinuxSamplerException("Internal error: could not find unoccupied sampler channel index.");
205 }
206
207 // we have not reached the index limit so we just add the channel past the highest index
208 SamplerChannel* pChannel = new SamplerChannel(this);
209 mSamplerChannels[lastIndex + 1] = pChannel;
210 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_channels, lastIndex + 1));
211 return pChannel;
212 }
213
214 SamplerChannel* Sampler::GetSamplerChannel(uint uiSamplerChannel) {
215 return (mSamplerChannels.find(uiSamplerChannel) != mSamplerChannels.end()) ? mSamplerChannels[uiSamplerChannel] : NULL;
216 }
217
218 std::map<uint, SamplerChannel*> Sampler::GetSamplerChannels() {
219 return mSamplerChannels;
220 }
221
222 void Sampler::RemoveSamplerChannel(SamplerChannel* pSamplerChannel) {
223 SamplerChannelMap::iterator iterChan = mSamplerChannels.begin();
224 for (; iterChan != mSamplerChannels.end(); iterChan++) {
225 if (iterChan->second == pSamplerChannel) {
226 mSamplerChannels.erase(iterChan);
227 delete pSamplerChannel;
228 LSCPServer::SendLSCPNotify(LSCPEvent(LSCPEvent::event_channels, mSamplerChannels.size()));
229 return;
230 }
231 }
232 }
233
234 void Sampler::RemoveSamplerChannel(uint uiSamplerChannel) {
235 SamplerChannel* pChannel = GetSamplerChannel(uiSamplerChannel);
236 if (!pChannel) return;
237 RemoveSamplerChannel(pChannel);
238 }
239
240 std::vector<String> Sampler::AvailableAudioOutputDrivers() {
241 return AudioOutputDeviceFactory::AvailableDrivers();
242 }
243
244 AudioOutputDevice* Sampler::CreateAudioOutputDevice(String AudioDriver, std::map<String,String> Parameters) throw (LinuxSamplerException) {
245 // create new device
246 AudioOutputDevice* pDevice = AudioOutputDeviceFactory::Create(AudioDriver, Parameters);
247
248 // add new audio device to the audio device list
249 for (uint i = 0; ; i++) { // seek for a free place starting from the beginning
250 if (!mAudioOutputDevices[i]) {
251 mAudioOutputDevices[i] = pDevice;
252 break;
253 }
254 }
255
256 return pDevice;
257 }
258
259 uint Sampler::AudioOutputDevices() {
260 return mAudioOutputDevices.size();
261 }
262
263 uint Sampler::MidiInputDevices() {
264 return mMidiInputDevices.size();
265 }
266
267 std::map<uint, AudioOutputDevice*> Sampler::GetAudioOutputDevices() {
268 return mAudioOutputDevices;
269 }
270
271 std::map<uint, MidiInputDevice*> Sampler::GetMidiInputDevices() {
272 return mMidiInputDevices;
273 }
274
275 void Sampler::DestroyAudioOutputDevice(AudioOutputDevice* pDevice) throw (LinuxSamplerException) {
276 AudioOutputDeviceMap::iterator iter = mAudioOutputDevices.begin();
277 for (; iter != mAudioOutputDevices.end(); iter++) {
278 if (iter->second == pDevice) {
279 // check if there are still sampler engines connected to this device
280 for (uint i = 0; i < SamplerChannels(); i++)
281 if (GetSamplerChannel(i)->GetAudioOutputDevice() == pDevice) throw LinuxSamplerException("Sampler channel " + ToString(i) + " is still connected to the audio output device.");
282
283 // disable device
284 pDevice->Stop();
285
286 // remove device from the device list
287 mAudioOutputDevices.erase(iter);
288
289 // destroy and free device from memory
290 delete pDevice;
291 }
292 }
293 }
294
295 void Sampler::DestroyMidiInputDevice(MidiInputDevice* pDevice) throw (LinuxSamplerException) {
296 MidiInputDeviceMap::iterator iter = mMidiInputDevices.begin();
297 for (; iter != mMidiInputDevices.end(); iter++) {
298 if (iter->second == pDevice) {
299 // check if there are still sampler engines connected to this device
300 for (uint i = 0; i < SamplerChannels(); i++)
301 if (GetSamplerChannel(i)->GetMidiInputDevice() == pDevice) throw LinuxSamplerException("Sampler channel " + ToString(i) + " is still connected to the midi input device.");
302
303 // disable device
304 pDevice->StopListen();
305
306 // remove device from the device list
307 mMidiInputDevices.erase(iter);
308
309 // destroy and free device from memory
310 delete pDevice;
311 }
312 }
313 }
314
315 MidiInputDevice* Sampler::CreateMidiInputDevice(String MidiDriver, std::map<String,String> Parameters) throw (LinuxSamplerException) {
316 // create new device
317 MidiInputDevice* pDevice = MidiInputDeviceFactory::Create(MidiDriver, Parameters);
318
319 // add new device to the midi device list
320 for (uint i = 0; ; i++) { // seek for a free place starting from the beginning
321 if (!mMidiInputDevices[i]) {
322 mMidiInputDevices[i] = pDevice;
323 break;
324 }
325 }
326
327 return pDevice;
328 }
329
330 void Sampler::Reset() {
331 // delete sampler channels
332 try {
333 while (true) {
334 SamplerChannelMap::iterator iter = mSamplerChannels.begin();
335 if (iter == mSamplerChannels.end()) break;
336 RemoveSamplerChannel(iter->second);
337 }
338 }
339 catch(...) {
340 std::cerr << "Sampler::Reset(): Exception occured while trying to delete all sampler channels, exiting.\n" << std::flush;
341 exit(EXIT_FAILURE);
342 }
343
344 // delete midi input devices
345 try {
346 while (true) {
347 MidiInputDeviceMap::iterator iter = mMidiInputDevices.begin();
348 if (iter == mMidiInputDevices.end()) break;
349 DestroyMidiInputDevice(iter->second);
350 }
351 }
352 catch(...) {
353 std::cerr << "Sampler::Reset(): Exception occured while trying to delete all MIDI input devices, exiting.\n" << std::flush;
354 exit(EXIT_FAILURE);
355 }
356
357 // delete audio output devices
358 try {
359 while (true) {
360 AudioOutputDeviceMap::iterator iter = mAudioOutputDevices.begin();
361 if (iter == mAudioOutputDevices.end()) break;
362 DestroyAudioOutputDevice(iter->second);
363 }
364 }
365 catch(...) {
366 std::cerr << "Sampler::Reset(): Exception occured while trying to delete all audio output devices, exiting.\n" << std::flush;
367 exit(EXIT_FAILURE);
368 }
369 }
370
371 } // namespace LinuxSampler

  ViewVC Help
Powered by ViewVC