drivers/audio/AudioOutputDeviceCoreAudio.cpp

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2009 Grigor Iliev                                       *
 *                                                                         *
 *   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 "AudioOutputDeviceCoreAudio.h"

#include "../../common/global_private.h"

namespace LinuxSampler {

    void AudioOutputDeviceCoreAudio::AudioQueueListener (
            void *inUserData, AudioQueueRef inAQ, AudioQueuePropertyID inID
    ) {
        switch(inID) {
            case kAudioQueueProperty_IsRunning:
                
                break;
            case kAudioQueueProperty_CurrentDevice:
                
                break;
        }
    }

    void AudioOutputDeviceCoreAudio::HandleOutputBuffer (
        void                 *aqData,
        AudioQueueRef        inAQ,
        AudioQueueBufferRef  inBuffer
    ) {
        AQPlayerState* pAqData = (AQPlayerState*) aqData;
        if (atomic_read(&(pAqData->mIsRunning)) == 0) {
            AudioQueueFlush(pAqData->mQueue);
            AudioQueueStop (pAqData->mQueue, true);
            return;
        }

        if(atomic_read(&(pAqData->pDevice->restartQueue))) return;

        uint bufferSize = pAqData->pDevice->uiBufferSize;

        // let all connected engines render 'fragmentSize' sample points
        pAqData->pDevice->RenderAudio(bufferSize);

        int16_t* pDataBuf = (int16_t*)(inBuffer->mAudioData);

        uint uiCoreAudioChannels = pAqData->pDevice->uiCoreAudioChannels;
        // convert from DSP value range (-1.0..+1.0) to 16 bit integer value
        // range (-32768..+32767), check clipping  and copy to Alsa output buffer
        for (int c = 0; c < uiCoreAudioChannels; c++) {
            float* in  = pAqData->pDevice->Channels[c]->Buffer();
            for (int i = 0, o = c; i < bufferSize; i++ , o += uiCoreAudioChannels) {
                float sample_point = in[i] * 32768.0f;
                if (sample_point < -32768.0) sample_point = -32768.0;
                if (sample_point >  32767.0) sample_point =  32767.0;
                pDataBuf[o] = (int16_t) sample_point;
            }
        }

        inBuffer->mAudioDataByteSize = (uiCoreAudioChannels * 2) * bufferSize;

        OSStatus res = AudioQueueEnqueueBuffer(pAqData->mQueue, inBuffer, 0, NULL);
        if(res) std::cerr << "AudioQueueEnqueueBuffer: Error " << res << std::endl;
    }

    void AudioOutputDeviceCoreAudio::DeviceChanged() {
        dmsg(1,("Restarting audio queue..."));
        atomic_set(&restartQueue, 1);
    }

    AudioOutputDeviceCoreAudio::AudioOutputDeviceCoreAudio (
                    std::map<String,DeviceCreationParameter*> Parameters
    ) : AudioOutputDevice(Parameters), Thread(true, true, 1, 0), CurrentDevice(0) {

        dmsg(2,("AudioOutputDeviceCoreAudio::AudioOutputDeviceCoreAudio()\n"));
        if(CAAudioDeviceListModel::GetModel()->GetOutputDeviceCount() < 1) {
            throw Exception("No audio output device found");
        }
        atomic_set(&pausedNew, 0);
        pausedOld = 0;
        atomic_set(&restartQueue, 0);

        uiCoreAudioChannels = ((DeviceCreationParameterInt*)Parameters["CHANNELS"])->ValueAsInt();
        uint samplerate     = ((DeviceCreationParameterInt*)Parameters["SAMPLERATE"])->ValueAsInt();
        uiBufferNumber      = ((DeviceCreationParameterInt*)Parameters["BUFFERS"])->ValueAsInt();
        uiBufferSize        = ((DeviceCreationParameterInt*)Parameters["BUFFERSIZE"])->ValueAsInt();
        int device = 0;
        try { device = ((ParameterDevice*)Parameters["DEVICE"])->GetDeviceIndex(); }
        catch(Exception x) { }

        CurrentDevice = CAAudioDeviceListModel::GetModel()->GetOutputDevice(device);
        CurrentDevice.AddListener(this);

        aqPlayerState.mDataFormat.mSampleRate = samplerate;
        aqPlayerState.mDataFormat.mFormatID = kAudioFormatLinearPCM;

        aqPlayerState.mDataFormat.mFormatFlags =
            kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;

        aqPlayerState.mDataFormat.mBytesPerPacket = uiCoreAudioChannels * 2;
        aqPlayerState.mDataFormat.mFramesPerPacket = 1;
        aqPlayerState.mDataFormat.mBytesPerFrame = uiCoreAudioChannels * 2;
        aqPlayerState.mDataFormat.mChannelsPerFrame = uiCoreAudioChannels;
        aqPlayerState.mDataFormat.mBitsPerChannel = 16;

        aqPlayerState.mBuffers = new AudioQueueBufferRef[uiBufferNumber];

        aqPlayerState.bufferByteSize =
                MaxSamplesPerCycle() * aqPlayerState.mDataFormat.mBytesPerFrame;

        aqPlayerState.mNumPacketsToRead = MaxSamplesPerCycle();

        aqPlayerState.pDevice = this;
        aqPlayerState.mQueue = NULL;

        uint fragmentSize = MaxSamplesPerCycle();
        // create audio channels for this audio device to which the sampler engines can write to
        for (int i = 0; i < uiCoreAudioChannels; i++) {
            this->Channels.push_back(new AudioChannel(i, fragmentSize));
        }

        StartThread();

        if (!((DeviceCreationParameterBool*)Parameters["ACTIVE"])->ValueAsBool()) {
                Stop();
        }
    }

    AudioOutputDeviceCoreAudio::~AudioOutputDevice() {
        atomic_set(&(aqPlayerState.mIsRunning), 0);
        destroyMutex.Lock();
        AudioQueueDispose(aqPlayerState.mQueue, true);
        destroyMutex.Unlock();
        delete [] aqPlayerState.mBuffers;

        CurrentDevice.RemoveListener(this);
    }

    void AudioOutputDeviceCoreAudio::SetAudioDataFormat(AudioStreamBasicDescription* pDataFormat) {
        pDataFormat->mSampleRate = 44100;
        pDataFormat->mFormatID = kAudioFormatLinearPCM;

        pDataFormat->mFormatFlags =
            kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;

        pDataFormat->mBytesPerPacket = 4;
        pDataFormat->mFramesPerPacket = 1;
        pDataFormat->mBytesPerFrame = 4;
        pDataFormat->mChannelsPerFrame = 2;
        pDataFormat->mBitsPerChannel = 16;
    }

    String AudioOutputDeviceCoreAudio::Name() {
        return "COREAUDIO";
    }

    String AudioOutputDeviceCoreAudio::Description() {
        return "Apple CoreAudio";
    }

    String AudioOutputDeviceCoreAudio::Version() {
       String s = "$Revision: 1.3 $";
       return s.substr(11, s.size() - 13); // cut dollar signs, spaces and CVS macro keyword
    }

    void AudioOutputDeviceCoreAudio::Play() {
        atomic_set(&pausedNew, 0);
    }

    bool AudioOutputDeviceCoreAudio::IsPlaying() {
        return !atomic_read(&pausedNew);
    }

    void AudioOutputDeviceCoreAudio::Stop() {
        atomic_set(&pausedNew, 1);
    }

    uint AudioOutputDeviceCoreAudio::MaxSamplesPerCycle() {
        return uiBufferSize;
    }

    uint AudioOutputDeviceCoreAudio::SampleRate() {
        return aqPlayerState.mDataFormat.mSampleRate;
    }

    String AudioOutputDeviceCoreAudio::Driver() {
        return Name();
    }

    AudioChannel* AudioOutputDeviceCoreAudio::CreateChannel(uint ChannelNr) {
        // just create a mix channel
        return new AudioChannel(ChannelNr, Channel(ChannelNr % uiCoreAudioChannels));
    }

    void AudioOutputDeviceCoreAudio::FillBuffers() {
        for (int i = 0; i < uiBufferNumber; ++i) {
            HandleOutputBuffer (
                &aqPlayerState,
                aqPlayerState.mQueue,
                aqPlayerState.mBuffers[i]
            );
        }
    }

    void AudioOutputDeviceCoreAudio::PrimeAudioQueue() {
        OSStatus res = AudioQueuePrime(aqPlayerState.mQueue, 0, NULL);
        if(res) {
            String s = String("AudioQueuePrime: Error ") + ToString(res);
            throw Exception(s);
        }
    }

    void AudioOutputDeviceCoreAudio::CreateAndStartAudioQueue() {
        OSStatus res = AudioQueueNewOutput (
            &aqPlayerState.mDataFormat,
            HandleOutputBuffer,
            &aqPlayerState,
            CFRunLoopGetCurrent(),
            kCFRunLoopCommonModes,
            0,
            &aqPlayerState.mQueue
        );

        if(res) {
            String s = String("AudioQueueNewOutput: Error ") + ToString(res);
            throw Exception(s);
        }

        CFStringRef devUID = CFStringCreateWithCString (
            NULL, CurrentDevice.GetUID().c_str(), kCFStringEncodingASCII
        );
        res = AudioQueueSetProperty (
            aqPlayerState.mQueue,
            kAudioQueueProperty_CurrentDevice,
            &devUID, sizeof(CFStringRef)
        );
        CFRelease(devUID);

        if(res) {
            String s = String("Failed to set audio device: ") + ToString(res);
            throw Exception(s);
        }

        for (int i = 0; i < uiBufferNumber; ++i) {
            res = AudioQueueAllocateBuffer (
                aqPlayerState.mQueue,
                aqPlayerState.bufferByteSize,
                &aqPlayerState.mBuffers[i]
            );

            if(res) {
                String s = String("AudioQueueAllocateBuffer: Error ");
                throw Exception(s + ToString(res));
            }
        }

        res = AudioQueueAddPropertyListener (
            aqPlayerState.mQueue,
            kAudioQueueProperty_CurrentDevice,
            AudioQueueListener,
            NULL
        );
        if(res) std::cerr << "Failed to register device change listener: " << res << std::endl;

        res = AudioQueueAddPropertyListener (
            aqPlayerState.mQueue,
            kAudioQueueProperty_IsRunning,
            AudioQueueListener,
            NULL
        );
        if(res) std::cerr << "Failed to register running listener: " << res << std::endl;

        Float32 gain = 1.0;

        res = AudioQueueSetParameter (
            aqPlayerState.mQueue,
            kAudioQueueParam_Volume,
            gain
        );

        if(res) std::cerr << "AudioQueueSetParameter: Error " << res << std::endl;

        atomic_set(&(aqPlayerState.mIsRunning), 1);
        FillBuffers();
        PrimeAudioQueue();

        res = AudioQueueStart(aqPlayerState.mQueue, NULL);
        if(res) {
            String s = String("AudioQueueStart: Error ") + ToString(res);
            throw Exception(s);
        }
    }

    void AudioOutputDeviceCoreAudio::DestroyAudioQueue() {
        AudioQueueFlush(aqPlayerState.mQueue);
        AudioQueueStop (aqPlayerState.mQueue, true);
        AudioQueueDispose(aqPlayerState.mQueue, true);
        aqPlayerState.mQueue = NULL;
    }

    /**
     * Entry point for the thread.
     */
    int AudioOutputDeviceCoreAudio::Main() {
        dmsg(1,("CoreAudio thread started\n"));
        OSStatus res;
        if(aqPlayerState.mQueue == NULL) {
            /*
             * Need to be run from this thread because of CFRunLoopGetCurrent()
             * which returns the CFRunLoop object for the current thread.
             */
            CreateAndStartAudioQueue();
        }

        destroyMutex.Lock();
        do {
            if(atomic_read(&pausedNew) != pausedOld) {
                pausedOld = atomic_read(&pausedNew);

                if(pausedOld) {
                    res = AudioQueuePause(aqPlayerState.mQueue);
                    if(res) std::cerr << "AudioQueuePause: Error " << res << std::endl;
                } else {
                    res = AudioQueuePrime(aqPlayerState.mQueue, 0, NULL);
                    if(res) std::cerr << "AudioQueuePrime: Error " << res << std::endl;
                    res = AudioQueueStart(aqPlayerState.mQueue, NULL);
                    if(res) std::cerr << "AudioQueueStart: Error " << res << std::endl;
                }
            }

            if(atomic_read(&restartQueue)) {
                DestroyAudioQueue();
                try { CreateAndStartAudioQueue(); }
                catch(Exception e) {
                    destroyMutex.Unlock();
                    throw e;
                }
                atomic_set(&restartQueue, 0);
                dmsg(1,("Audio queue restarted"));
            }
            
            CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.2, false);
        } while (atomic_read(&(aqPlayerState.mIsRunning)));
        destroyMutex.Unlock();

        dmsg(2,("CoreAudio thread stopped\n"));

        return 0;
    }


// *************** ParameterDevice ***************
// *

    AudioOutputDeviceCoreAudio::ParameterDevice::ParameterDevice() : DeviceCreationParameterString() {
        InitWithDefault(); // use default device
    }

    AudioOutputDeviceCoreAudio::ParameterDevice::ParameterDevice(String s)
            throw (Exception) : DeviceCreationParameterString(s) {
    }

    String AudioOutputDeviceCoreAudio::ParameterDevice::Description() {
        return "Output device to be used";
    }

    bool AudioOutputDeviceCoreAudio::ParameterDevice::Fix() {
        return true;
    }

    bool AudioOutputDeviceCoreAudio::ParameterDevice::Mandatory() {
        return false;
    }

    std::map<String,DeviceCreationParameter*>
    AudioOutputDeviceCoreAudio::ParameterDevice::DependsAsParameters() {
        return std::map<String,DeviceCreationParameter*>(); // no dependencies
    }

    optional<String>
    AudioOutputDeviceCoreAudio::ParameterDevice::DefaultAsString(std::map<String,String> Parameters) {
        CAAudioDeviceListModel* devs = CAAudioDeviceListModel::GetModel();
        if (devs->GetOutputDeviceCount() < 1) {
            throw Exception("AudioOutputDeviceCoreAudio: Can't find any output device");
        }
        UInt32 idx = devs->GetOutputDeviceIndex(devs->GetDefaultOutputDeviceID());
        return CreateDeviceName(idx);
    }

    std::vector<String>
    AudioOutputDeviceCoreAudio::ParameterDevice::PossibilitiesAsString(std::map<String,String> Parameters) {
        std::vector<String> deviceNames;

        CAAudioDeviceListModel* devs = CAAudioDeviceListModel::GetModel();
        for(int i = 0; i < devs->GetOutputDeviceCount(); i++) {
            if(devs->GetOutputDevice(i).GetChannelNumber() < 1) continue;

            deviceNames.push_back(CreateDeviceName(i));
        }

        return deviceNames;
    }

    String AudioOutputDeviceCoreAudio::ParameterDevice::CreateDeviceName(int devIndex) {
        CAAudioDeviceListModel* devs = CAAudioDeviceListModel::GetModel();
        // Note that the space " " is used as delimiter to obtain the
        // device index. See GetDeviceIndex()
        return ToString(devIndex + 1) + " " + devs->GetOutputDevice(devIndex).GetName();
    }

    void AudioOutputDeviceCoreAudio::ParameterDevice::OnSetValue(String s) throw (Exception) {
        // not posssible, as parameter is fix
    }

    String AudioOutputDeviceCoreAudio::ParameterDevice::Name() {
        return "DEVICE";
    }

    int AudioOutputDeviceCoreAudio::ParameterDevice::GetDeviceIndex() {
        String s = ValueAsString();
        if(s.empty()) return -1;
        int n = s.find(' ');
        s = s.substr(0, n);
        return ToInt(s) - 1;
    }

// *************** ParameterSampleRate ***************
// *

    AudioOutputDeviceCoreAudio::ParameterSampleRate::ParameterSampleRate() :
                AudioOutputDevice::ParameterSampleRate::ParameterSampleRate() {

    }

    AudioOutputDeviceCoreAudio::ParameterSampleRate::ParameterSampleRate(String s) :
                AudioOutputDevice::ParameterSampleRate::ParameterSampleRate(s) {
        
    }

    std::map<String,DeviceCreationParameter*>
    AudioOutputDeviceCoreAudio::ParameterSampleRate::DependsAsParameters() {
        static ParameterDevice device;
        std::map<String,DeviceCreationParameter*> dependencies;
        dependencies[device.Name()] = &device;
        return dependencies;
    }

    optional<int>
    AudioOutputDeviceCoreAudio::ParameterSampleRate::DefaultAsInt(std::map<String,String> Parameters) {
        dmsg(2,("AudioOutputDeviceCoreAudio::ParameterSampleRate::DefaultAsInt()\n"));
        ParameterDevice dev(Parameters["DEVICE"]);
        int samplerate = 44100;

        try {
            int idx = dev.GetDeviceIndex();

            CAAudioDeviceListModel* devs = CAAudioDeviceListModel::GetModel();
            samplerate = devs->GetOutputDevice(idx).GetDefaultSamplerate();
        } catch(Exception e) { }

        return samplerate;
    }

    std::vector<int>
    AudioOutputDeviceCoreAudio::ParameterSampleRate::PossibilitiesAsInt(std::map<String,String> Parameters) {
        ParameterDevice dev(Parameters["DEVICE"]);
        std::vector<int> srates;

        try {
            int idx = dev.GetDeviceIndex();
            CAAudioDeviceListModel* devs = CAAudioDeviceListModel::GetModel();
            srates = devs->GetOutputDevice(idx).GetNominalSamplerates();
        } catch(Exception x) { }

        return srates;
    }


// *************** ParameterChannels ***************
// *

    AudioOutputDeviceCoreAudio::ParameterChannels::ParameterChannels() :
                    AudioOutputDevice::ParameterChannels::ParameterChannels() {
        
    }

    AudioOutputDeviceCoreAudio::ParameterChannels::ParameterChannels(String s) :
                    AudioOutputDevice::ParameterChannels::ParameterChannels(s) {
        
    }

    optional<int>
    AudioOutputDeviceCoreAudio::ParameterChannels::DefaultAsInt(std::map<String,String> Parameters) {
        dmsg(2,("AudioOutputDeviceCoreAudio::ParameterChannels::DefaultAsInt()\n"));
        ParameterDevice dev(Parameters["DEVICE"]);
        int chns = 2;

        try {
            int idx = dev.GetDeviceIndex();
            CAAudioDeviceListModel* devs = CAAudioDeviceListModel::GetModel();
            chns = devs->GetOutputDevice(idx).GetChannelNumber();
        } catch(Exception e) { }

        return chns;
    }

    std::vector<int>
    AudioOutputDeviceCoreAudio::ParameterChannels::PossibilitiesAsInt(std::map<String,String> Parameters) {
        ParameterDevice dev(Parameters["DEVICE"]);
        std::vector<int> chns;

        try {
            int idx = dev.GetDeviceIndex();
            CAAudioDeviceListModel* devs = CAAudioDeviceListModel::GetModel();
            for(int i = 1; i <= devs->GetOutputDevice(idx).GetChannelNumber(); i++) {
                chns.push_back(i);
            }
        } catch(Exception x) { }

        return chns;
    }

// *************** ParameterBuffers ***************
// *

    AudioOutputDeviceCoreAudio::ParameterBuffers::ParameterBuffers() : DeviceCreationParameterInt() {
        InitWithDefault();
    }

    AudioOutputDeviceCoreAudio::ParameterBuffers::ParameterBuffers(String s)
            throw (Exception) : DeviceCreationParameterInt(s) {
    }

    String AudioOutputDeviceCoreAudio::ParameterBuffers::Description() {
        return "Number of audio buffer";
    }

    bool AudioOutputDeviceCoreAudio::ParameterBuffers::Fix() {
        return true;
    }

    bool AudioOutputDeviceCoreAudio::ParameterBuffers::Mandatory() {
        return false;
    }

    std::map<String,DeviceCreationParameter*>
    AudioOutputDeviceCoreAudio::ParameterBuffers::DependsAsParameters() {
        return std::map<String,DeviceCreationParameter*>();
    }

    optional<int>
    AudioOutputDeviceCoreAudio::ParameterBuffers::DefaultAsInt(std::map<String,String> Parameters) {
        return 3;
    }

    optional<int>
    AudioOutputDeviceCoreAudio::ParameterBuffers::RangeMinAsInt(std::map<String,String> Parameters) {
        return 2;
    }

    optional<int>
    AudioOutputDeviceCoreAudio::ParameterBuffers::RangeMaxAsInt(std::map<String,String> Parameters) {
        return 16;
    }

    std::vector<int>
    AudioOutputDeviceCoreAudio::ParameterBuffers::PossibilitiesAsInt(std::map<String,String> Parameters) {
        return std::vector<int>();
    }

    void AudioOutputDeviceCoreAudio::ParameterBuffers::OnSetValue(int i) throw (Exception) {
        // not posssible, as parameter is fix
    }

    String AudioOutputDeviceCoreAudio::ParameterBuffers::Name() {
        return "BUFFERS";
    }

// *************** ParameterBufferSize ***************
// *

    AudioOutputDeviceCoreAudio::ParameterBufferSize::ParameterBufferSize() : DeviceCreationParameterInt() {
        InitWithDefault();
    }

    AudioOutputDeviceCoreAudio::ParameterBufferSize::ParameterBufferSize(String s)
            throw (Exception) : DeviceCreationParameterInt(s) {
    }

    String AudioOutputDeviceCoreAudio::ParameterBufferSize::Description() {
        return "Size of the audio buffer in sample frames";
    }

    bool AudioOutputDeviceCoreAudio::ParameterBufferSize::Fix() {
        return true;
    }

    bool AudioOutputDeviceCoreAudio::ParameterBufferSize::Mandatory() {
        return false;
    }

    std::map<String,DeviceCreationParameter*>
    AudioOutputDeviceCoreAudio::ParameterBufferSize::DependsAsParameters() {
        return std::map<String,DeviceCreationParameter*>();
    }

    optional<int>
    AudioOutputDeviceCoreAudio::ParameterBufferSize::DefaultAsInt(std::map<String,String> Parameters) {
        return 128;
    }

    optional<int>
    AudioOutputDeviceCoreAudio::ParameterBufferSize::RangeMinAsInt(std::map<String,String> Parameters) {
        return 32;
    }

    optional<int>
    AudioOutputDeviceCoreAudio::ParameterBufferSize::RangeMaxAsInt(std::map<String,String> Parameters) {
        return 4096;
    }

    std::vector<int>
    AudioOutputDeviceCoreAudio::ParameterBufferSize::PossibilitiesAsInt(std::map<String,String> Parameters) {
        return std::vector<int>();
    }

    void AudioOutputDeviceCoreAudio::ParameterBufferSize::OnSetValue(int i) throw (Exception) {
        // not posssible, as parameter is fix
    }

    String AudioOutputDeviceCoreAudio::ParameterBufferSize::Name() {
        return "BUFFERSIZE";
    }
} // namespace LinuxSampler
1	/***************************************************************************
2	* *
3	* LinuxSampler - modular, streaming capable sampler *
4	* *
5	* Copyright (C) 2009 Grigor Iliev *
6	* *
7	* This program is free software; you can redistribute it and/or modify *
8	* it under the terms of the GNU General Public License as published by *
9	* the Free Software Foundation; either version 2 of the License, or *
10	* (at your option) any later version. *
11	* *
12	* This program is distributed in the hope that it will be useful, *
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15	* GNU General Public License for more details. *
16	* *
17	* You should have received a copy of the GNU General Public License *
18	* along with this program; if not, write to the Free Software *
19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
20	* MA 02111-1307 USA *
21	***************************************************************************/
22
23	#include "AudioOutputDeviceCoreAudio.h"
24
25	#include "../../common/global_private.h"
26
27	namespace LinuxSampler {
28
29	void AudioOutputDeviceCoreAudio::AudioQueueListener (
30	void *inUserData, AudioQueueRef inAQ, AudioQueuePropertyID inID
31	) {
32	switch(inID) {
33	case kAudioQueueProperty_IsRunning:
34
35	break;
36	case kAudioQueueProperty_CurrentDevice:
37
38	break;
39	}
40	}
41
42	void AudioOutputDeviceCoreAudio::HandleOutputBuffer (
43	void *aqData,
44	AudioQueueRef inAQ,
45	AudioQueueBufferRef inBuffer
46	) {
47	AQPlayerState* pAqData = (AQPlayerState*) aqData;
48	if (atomic_read(&(pAqData->mIsRunning)) == 0) {
49	AudioQueueFlush(pAqData->mQueue);
50	AudioQueueStop (pAqData->mQueue, true);
51	return;
52	}
53
54	if(atomic_read(&(pAqData->pDevice->restartQueue))) return;
55
56	uint bufferSize = pAqData->pDevice->uiBufferSize;
57
58	// let all connected engines render 'fragmentSize' sample points
59	pAqData->pDevice->RenderAudio(bufferSize);
60
61	int16_t* pDataBuf = (int16_t*)(inBuffer->mAudioData);
62
63	uint uiCoreAudioChannels = pAqData->pDevice->uiCoreAudioChannels;
64	// convert from DSP value range (-1.0..+1.0) to 16 bit integer value
65	// range (-32768..+32767), check clipping and copy to Alsa output buffer
66	for (int c = 0; c < uiCoreAudioChannels; c++) {
67	float* in = pAqData->pDevice->Channels[c]->Buffer();
68	for (int i = 0, o = c; i < bufferSize; i++ , o += uiCoreAudioChannels) {
69	float sample_point = in[i] * 32768.0f;
70	if (sample_point < -32768.0) sample_point = -32768.0;
71	if (sample_point > 32767.0) sample_point = 32767.0;
72	pDataBuf[o] = (int16_t) sample_point;
73	}
74	}
75
76	inBuffer->mAudioDataByteSize = (uiCoreAudioChannels * 2) * bufferSize;
77
78	OSStatus res = AudioQueueEnqueueBuffer(pAqData->mQueue, inBuffer, 0, NULL);
79	if(res) std::cerr << "AudioQueueEnqueueBuffer: Error " << res << std::endl;
80	}
81
82	void AudioOutputDeviceCoreAudio::DeviceChanged() {
83	dmsg(1,("Restarting audio queue..."));
84	atomic_set(&restartQueue, 1);
85	}
86
87	AudioOutputDeviceCoreAudio::AudioOutputDeviceCoreAudio (
88	std::map<String,DeviceCreationParameter*> Parameters
89	) : AudioOutputDevice(Parameters), Thread(true, true, 1, 0), CurrentDevice(0) {
90
91	dmsg(2,("AudioOutputDeviceCoreAudio::AudioOutputDeviceCoreAudio()\n"));
92	if(CAAudioDeviceListModel::GetModel()->GetOutputDeviceCount() < 1) {
93	throw Exception("No audio output device found");
94	}
95	atomic_set(&pausedNew, 0);
96	pausedOld = 0;
97	atomic_set(&restartQueue, 0);
98
99	uiCoreAudioChannels = ((DeviceCreationParameterInt*)Parameters["CHANNELS"])->ValueAsInt();
100	uint samplerate = ((DeviceCreationParameterInt*)Parameters["SAMPLERATE"])->ValueAsInt();
101	uiBufferNumber = ((DeviceCreationParameterInt*)Parameters["BUFFERS"])->ValueAsInt();
102	uiBufferSize = ((DeviceCreationParameterInt*)Parameters["BUFFERSIZE"])->ValueAsInt();
103	int device = 0;
104	try { device = ((ParameterDevice*)Parameters["DEVICE"])->GetDeviceIndex(); }
105	catch(Exception x) { }
106
107	CurrentDevice = CAAudioDeviceListModel::GetModel()->GetOutputDevice(device);
108	CurrentDevice.AddListener(this);
109
110	aqPlayerState.mDataFormat.mSampleRate = samplerate;
111	aqPlayerState.mDataFormat.mFormatID = kAudioFormatLinearPCM;
112
113	aqPlayerState.mDataFormat.mFormatFlags =
114	kAudioFormatFlagIsSignedInteger \| kAudioFormatFlagIsPacked;
115
116	aqPlayerState.mDataFormat.mBytesPerPacket = uiCoreAudioChannels * 2;
117	aqPlayerState.mDataFormat.mFramesPerPacket = 1;
118	aqPlayerState.mDataFormat.mBytesPerFrame = uiCoreAudioChannels * 2;
119	aqPlayerState.mDataFormat.mChannelsPerFrame = uiCoreAudioChannels;
120	aqPlayerState.mDataFormat.mBitsPerChannel = 16;
121
122	aqPlayerState.mBuffers = new AudioQueueBufferRef[uiBufferNumber];
123
124	aqPlayerState.bufferByteSize =
125	MaxSamplesPerCycle() * aqPlayerState.mDataFormat.mBytesPerFrame;
126
127	aqPlayerState.mNumPacketsToRead = MaxSamplesPerCycle();
128
129	aqPlayerState.pDevice = this;
130	aqPlayerState.mQueue = NULL;
131
132	uint fragmentSize = MaxSamplesPerCycle();
133	// create audio channels for this audio device to which the sampler engines can write to
134	for (int i = 0; i < uiCoreAudioChannels; i++) {
135	this->Channels.push_back(new AudioChannel(i, fragmentSize));
136	}
137
138	StartThread();
139
140	if (!((DeviceCreationParameterBool*)Parameters["ACTIVE"])->ValueAsBool()) {
141	Stop();
142	}
143	}
144
145	AudioOutputDeviceCoreAudio::~AudioOutputDevice() {
146	atomic_set(&(aqPlayerState.mIsRunning), 0);
147	destroyMutex.Lock();
148	AudioQueueDispose(aqPlayerState.mQueue, true);
149	destroyMutex.Unlock();
150	delete [] aqPlayerState.mBuffers;
151
152	CurrentDevice.RemoveListener(this);
153	}
154
155	void AudioOutputDeviceCoreAudio::SetAudioDataFormat(AudioStreamBasicDescription* pDataFormat) {
156	pDataFormat->mSampleRate = 44100;
157	pDataFormat->mFormatID = kAudioFormatLinearPCM;
158
159	pDataFormat->mFormatFlags =
160	kAudioFormatFlagIsSignedInteger \| kAudioFormatFlagIsPacked;
161
162	pDataFormat->mBytesPerPacket = 4;
163	pDataFormat->mFramesPerPacket = 1;
164	pDataFormat->mBytesPerFrame = 4;
165	pDataFormat->mChannelsPerFrame = 2;
166	pDataFormat->mBitsPerChannel = 16;
167	}
168
169	String AudioOutputDeviceCoreAudio::Name() {
170	return "COREAUDIO";
171	}
172
173	String AudioOutputDeviceCoreAudio::Description() {
174	return "Apple CoreAudio";
175	}
176
177	String AudioOutputDeviceCoreAudio::Version() {
178	String s = "$Revision: 1.3 $";
179	return s.substr(11, s.size() - 13); // cut dollar signs, spaces and CVS macro keyword
180	}
181
182	void AudioOutputDeviceCoreAudio::Play() {
183	atomic_set(&pausedNew, 0);
184	}
185
186	bool AudioOutputDeviceCoreAudio::IsPlaying() {
187	return !atomic_read(&pausedNew);
188	}
189
190	void AudioOutputDeviceCoreAudio::Stop() {
191	atomic_set(&pausedNew, 1);
192	}
193
194	uint AudioOutputDeviceCoreAudio::MaxSamplesPerCycle() {
195	return uiBufferSize;
196	}
197
198	uint AudioOutputDeviceCoreAudio::SampleRate() {
199	return aqPlayerState.mDataFormat.mSampleRate;
200	}
201
202	String AudioOutputDeviceCoreAudio::Driver() {
203	return Name();
204	}
205
206	AudioChannel* AudioOutputDeviceCoreAudio::CreateChannel(uint ChannelNr) {
207	// just create a mix channel
208	return new AudioChannel(ChannelNr, Channel(ChannelNr % uiCoreAudioChannels));
209	}
210
211	void AudioOutputDeviceCoreAudio::FillBuffers() {
212	for (int i = 0; i < uiBufferNumber; ++i) {
213	HandleOutputBuffer (
214	&aqPlayerState,
215	aqPlayerState.mQueue,
216	aqPlayerState.mBuffers[i]
217	);
218	}
219	}
220
221	void AudioOutputDeviceCoreAudio::PrimeAudioQueue() {
222	OSStatus res = AudioQueuePrime(aqPlayerState.mQueue, 0, NULL);
223	if(res) {
224	String s = String("AudioQueuePrime: Error ") + ToString(res);
225	throw Exception(s);
226	}
227	}
228
229	void AudioOutputDeviceCoreAudio::CreateAndStartAudioQueue() {
230	OSStatus res = AudioQueueNewOutput (
231	&aqPlayerState.mDataFormat,
232	HandleOutputBuffer,
233	&aqPlayerState,
234	CFRunLoopGetCurrent(),
235	kCFRunLoopCommonModes,
236	0,
237	&aqPlayerState.mQueue
238	);
239
240	if(res) {
241	String s = String("AudioQueueNewOutput: Error ") + ToString(res);
242	throw Exception(s);
243	}
244
245	CFStringRef devUID = CFStringCreateWithCString (
246	NULL, CurrentDevice.GetUID().c_str(), kCFStringEncodingASCII
247	);
248	res = AudioQueueSetProperty (
249	aqPlayerState.mQueue,
250	kAudioQueueProperty_CurrentDevice,
251	&devUID, sizeof(CFStringRef)
252	);
253	CFRelease(devUID);
254
255	if(res) {
256	String s = String("Failed to set audio device: ") + ToString(res);
257	throw Exception(s);
258	}
259
260	for (int i = 0; i < uiBufferNumber; ++i) {
261	res = AudioQueueAllocateBuffer (
262	aqPlayerState.mQueue,
263	aqPlayerState.bufferByteSize,
264	&aqPlayerState.mBuffers[i]
265	);
266
267	if(res) {
268	String s = String("AudioQueueAllocateBuffer: Error ");
269	throw Exception(s + ToString(res));
270	}
271	}
272
273	res = AudioQueueAddPropertyListener (
274	aqPlayerState.mQueue,
275	kAudioQueueProperty_CurrentDevice,
276	AudioQueueListener,
277	NULL
278	);
279	if(res) std::cerr << "Failed to register device change listener: " << res << std::endl;
280
281	res = AudioQueueAddPropertyListener (
282	aqPlayerState.mQueue,
283	kAudioQueueProperty_IsRunning,
284	AudioQueueListener,
285	NULL
286	);
287	if(res) std::cerr << "Failed to register running listener: " << res << std::endl;
288
289	Float32 gain = 1.0;
290
291	res = AudioQueueSetParameter (
292	aqPlayerState.mQueue,
293	kAudioQueueParam_Volume,
294	gain
295	);
296
297	if(res) std::cerr << "AudioQueueSetParameter: Error " << res << std::endl;
298
299	atomic_set(&(aqPlayerState.mIsRunning), 1);
300	FillBuffers();
301	PrimeAudioQueue();
302
303	res = AudioQueueStart(aqPlayerState.mQueue, NULL);
304	if(res) {
305	String s = String("AudioQueueStart: Error ") + ToString(res);
306	throw Exception(s);
307	}
308	}
309
310	void AudioOutputDeviceCoreAudio::DestroyAudioQueue() {
311	AudioQueueFlush(aqPlayerState.mQueue);
312	AudioQueueStop (aqPlayerState.mQueue, true);
313	AudioQueueDispose(aqPlayerState.mQueue, true);
314	aqPlayerState.mQueue = NULL;
315	}
316
317	/**
318	* Entry point for the thread.
319	*/
320	int AudioOutputDeviceCoreAudio::Main() {
321	dmsg(1,("CoreAudio thread started\n"));
322	OSStatus res;
323	if(aqPlayerState.mQueue == NULL) {
324	/*
325	* Need to be run from this thread because of CFRunLoopGetCurrent()
326	* which returns the CFRunLoop object for the current thread.
327	*/
328	CreateAndStartAudioQueue();
329	}
330
331	destroyMutex.Lock();
332	do {
333	if(atomic_read(&pausedNew) != pausedOld) {
334	pausedOld = atomic_read(&pausedNew);
335
336	if(pausedOld) {
337	res = AudioQueuePause(aqPlayerState.mQueue);
338	if(res) std::cerr << "AudioQueuePause: Error " << res << std::endl;
339	} else {
340	res = AudioQueuePrime(aqPlayerState.mQueue, 0, NULL);
341	if(res) std::cerr << "AudioQueuePrime: Error " << res << std::endl;
342	res = AudioQueueStart(aqPlayerState.mQueue, NULL);
343	if(res) std::cerr << "AudioQueueStart: Error " << res << std::endl;
344	}
345	}
346
347	if(atomic_read(&restartQueue)) {
348	DestroyAudioQueue();
349	try { CreateAndStartAudioQueue(); }
350	catch(Exception e) {
351	destroyMutex.Unlock();
352	throw e;
353	}
354	atomic_set(&restartQueue, 0);
355	dmsg(1,("Audio queue restarted"));
356	}
357
358	CFRunLoopRunInMode(kCFRunLoopDefaultMode, 0.2, false);
359	} while (atomic_read(&(aqPlayerState.mIsRunning)));
360	destroyMutex.Unlock();
361
362	dmsg(2,("CoreAudio thread stopped\n"));
363
364	return 0;
365	}
366
367
368	// ************* ParameterDevice *************
369	// *
370
371	AudioOutputDeviceCoreAudio::ParameterDevice::ParameterDevice() : DeviceCreationParameterString() {
372	InitWithDefault(); // use default device
373	}
374
375	AudioOutputDeviceCoreAudio::ParameterDevice::ParameterDevice(String s)
376	throw (Exception) : DeviceCreationParameterString(s) {
377	}
378
379	String AudioOutputDeviceCoreAudio::ParameterDevice::Description() {
380	return "Output device to be used";
381	}
382
383	bool AudioOutputDeviceCoreAudio::ParameterDevice::Fix() {
384	return true;
385	}
386
387	bool AudioOutputDeviceCoreAudio::ParameterDevice::Mandatory() {
388	return false;
389	}
390
391	std::map<String,DeviceCreationParameter*>
392	AudioOutputDeviceCoreAudio::ParameterDevice::DependsAsParameters() {
393	return std::map<String,DeviceCreationParameter*>(); // no dependencies
394	}
395
396	optional<String>
397	AudioOutputDeviceCoreAudio::ParameterDevice::DefaultAsString(std::map<String,String> Parameters) {
398	CAAudioDeviceListModel* devs = CAAudioDeviceListModel::GetModel();
399	if (devs->GetOutputDeviceCount() < 1) {
400	throw Exception("AudioOutputDeviceCoreAudio: Can't find any output device");
401	}
402	UInt32 idx = devs->GetOutputDeviceIndex(devs->GetDefaultOutputDeviceID());
403	return CreateDeviceName(idx);
404	}
405
406	std::vector<String>
407	AudioOutputDeviceCoreAudio::ParameterDevice::PossibilitiesAsString(std::map<String,String> Parameters) {
408	std::vector<String> deviceNames;
409
410	CAAudioDeviceListModel* devs = CAAudioDeviceListModel::GetModel();
411	for(int i = 0; i < devs->GetOutputDeviceCount(); i++) {
412	if(devs->GetOutputDevice(i).GetChannelNumber() < 1) continue;
413
414	deviceNames.push_back(CreateDeviceName(i));
415	}
416
417	return deviceNames;
418	}
419
420	String AudioOutputDeviceCoreAudio::ParameterDevice::CreateDeviceName(int devIndex) {
421	CAAudioDeviceListModel* devs = CAAudioDeviceListModel::GetModel();
422	// Note that the space " " is used as delimiter to obtain the
423	// device index. See GetDeviceIndex()
424	return ToString(devIndex + 1) + " " + devs->GetOutputDevice(devIndex).GetName();
425	}
426
427	void AudioOutputDeviceCoreAudio::ParameterDevice::OnSetValue(String s) throw (Exception) {
428	// not posssible, as parameter is fix
429	}
430
431	String AudioOutputDeviceCoreAudio::ParameterDevice::Name() {
432	return "DEVICE";
433	}
434
435	int AudioOutputDeviceCoreAudio::ParameterDevice::GetDeviceIndex() {
436	String s = ValueAsString();
437	if(s.empty()) return -1;
438	int n = s.find(' ');
439	s = s.substr(0, n);
440	return ToInt(s) - 1;
441	}
442
443	// ************* ParameterSampleRate *************
444	// *
445
446	AudioOutputDeviceCoreAudio::ParameterSampleRate::ParameterSampleRate() :
447	AudioOutputDevice::ParameterSampleRate::ParameterSampleRate() {
448
449	}
450
451	AudioOutputDeviceCoreAudio::ParameterSampleRate::ParameterSampleRate(String s) :
452	AudioOutputDevice::ParameterSampleRate::ParameterSampleRate(s) {
453
454	}
455
456	std::map<String,DeviceCreationParameter*>
457	AudioOutputDeviceCoreAudio::ParameterSampleRate::DependsAsParameters() {
458	static ParameterDevice device;
459	std::map<String,DeviceCreationParameter*> dependencies;
460	dependencies[device.Name()] = &device;
461	return dependencies;
462	}
463
464	optional<int>
465	AudioOutputDeviceCoreAudio::ParameterSampleRate::DefaultAsInt(std::map<String,String> Parameters) {
466	dmsg(2,("AudioOutputDeviceCoreAudio::ParameterSampleRate::DefaultAsInt()\n"));
467	ParameterDevice dev(Parameters["DEVICE"]);
468	int samplerate = 44100;
469
470	try {
471	int idx = dev.GetDeviceIndex();
472
473	CAAudioDeviceListModel* devs = CAAudioDeviceListModel::GetModel();
474	samplerate = devs->GetOutputDevice(idx).GetDefaultSamplerate();
475	} catch(Exception e) { }
476
477	return samplerate;
478	}
479
480	std::vector<int>
481	AudioOutputDeviceCoreAudio::ParameterSampleRate::PossibilitiesAsInt(std::map<String,String> Parameters) {
482	ParameterDevice dev(Parameters["DEVICE"]);
483	std::vector<int> srates;
484
485	try {
486	int idx = dev.GetDeviceIndex();
487	CAAudioDeviceListModel* devs = CAAudioDeviceListModel::GetModel();
488	srates = devs->GetOutputDevice(idx).GetNominalSamplerates();
489	} catch(Exception x) { }
490
491	return srates;
492	}
493
494
495	// ************* ParameterChannels *************
496	// *
497
498	AudioOutputDeviceCoreAudio::ParameterChannels::ParameterChannels() :
499	AudioOutputDevice::ParameterChannels::ParameterChannels() {
500
501	}
502
503	AudioOutputDeviceCoreAudio::ParameterChannels::ParameterChannels(String s) :
504	AudioOutputDevice::ParameterChannels::ParameterChannels(s) {
505
506	}
507
508	optional<int>
509	AudioOutputDeviceCoreAudio::ParameterChannels::DefaultAsInt(std::map<String,String> Parameters) {
510	dmsg(2,("AudioOutputDeviceCoreAudio::ParameterChannels::DefaultAsInt()\n"));
511	ParameterDevice dev(Parameters["DEVICE"]);
512	int chns = 2;
513
514	try {
515	int idx = dev.GetDeviceIndex();
516	CAAudioDeviceListModel* devs = CAAudioDeviceListModel::GetModel();
517	chns = devs->GetOutputDevice(idx).GetChannelNumber();
518	} catch(Exception e) { }
519
520	return chns;
521	}
522
523	std::vector<int>
524	AudioOutputDeviceCoreAudio::ParameterChannels::PossibilitiesAsInt(std::map<String,String> Parameters) {
525	ParameterDevice dev(Parameters["DEVICE"]);
526	std::vector<int> chns;
527
528	try {
529	int idx = dev.GetDeviceIndex();
530	CAAudioDeviceListModel* devs = CAAudioDeviceListModel::GetModel();
531	for(int i = 1; i <= devs->GetOutputDevice(idx).GetChannelNumber(); i++) {
532	chns.push_back(i);
533	}
534	} catch(Exception x) { }
535
536	return chns;
537	}
538
539	// ************* ParameterBuffers *************
540	// *
541
542	AudioOutputDeviceCoreAudio::ParameterBuffers::ParameterBuffers() : DeviceCreationParameterInt() {
543	InitWithDefault();
544	}
545
546	AudioOutputDeviceCoreAudio::ParameterBuffers::ParameterBuffers(String s)
547	throw (Exception) : DeviceCreationParameterInt(s) {
548	}
549
550	String AudioOutputDeviceCoreAudio::ParameterBuffers::Description() {
551	return "Number of audio buffer";
552	}
553
554	bool AudioOutputDeviceCoreAudio::ParameterBuffers::Fix() {
555	return true;
556	}
557
558	bool AudioOutputDeviceCoreAudio::ParameterBuffers::Mandatory() {
559	return false;
560	}
561
562	std::map<String,DeviceCreationParameter*>
563	AudioOutputDeviceCoreAudio::ParameterBuffers::DependsAsParameters() {
564	return std::map<String,DeviceCreationParameter*>();
565	}
566
567	optional<int>
568	AudioOutputDeviceCoreAudio::ParameterBuffers::DefaultAsInt(std::map<String,String> Parameters) {
569	return 3;
570	}
571
572	optional<int>
573	AudioOutputDeviceCoreAudio::ParameterBuffers::RangeMinAsInt(std::map<String,String> Parameters) {
574	return 2;
575	}
576
577	optional<int>
578	AudioOutputDeviceCoreAudio::ParameterBuffers::RangeMaxAsInt(std::map<String,String> Parameters) {
579	return 16;
580	}
581
582	std::vector<int>
583	AudioOutputDeviceCoreAudio::ParameterBuffers::PossibilitiesAsInt(std::map<String,String> Parameters) {
584	return std::vector<int>();
585	}
586
587	void AudioOutputDeviceCoreAudio::ParameterBuffers::OnSetValue(int i) throw (Exception) {
588	// not posssible, as parameter is fix
589	}
590
591	String AudioOutputDeviceCoreAudio::ParameterBuffers::Name() {
592	return "BUFFERS";
593	}
594
595	// ************* ParameterBufferSize *************
596	// *
597
598	AudioOutputDeviceCoreAudio::ParameterBufferSize::ParameterBufferSize() : DeviceCreationParameterInt() {
599	InitWithDefault();
600	}
601
602	AudioOutputDeviceCoreAudio::ParameterBufferSize::ParameterBufferSize(String s)
603	throw (Exception) : DeviceCreationParameterInt(s) {
604	}
605
606	String AudioOutputDeviceCoreAudio::ParameterBufferSize::Description() {
607	return "Size of the audio buffer in sample frames";
608	}
609
610	bool AudioOutputDeviceCoreAudio::ParameterBufferSize::Fix() {
611	return true;
612	}
613
614	bool AudioOutputDeviceCoreAudio::ParameterBufferSize::Mandatory() {
615	return false;
616	}
617
618	std::map<String,DeviceCreationParameter*>
619	AudioOutputDeviceCoreAudio::ParameterBufferSize::DependsAsParameters() {
620	return std::map<String,DeviceCreationParameter*>();
621	}
622
623	optional<int>
624	AudioOutputDeviceCoreAudio::ParameterBufferSize::DefaultAsInt(std::map<String,String> Parameters) {
625	return 128;
626	}
627
628	optional<int>
629	AudioOutputDeviceCoreAudio::ParameterBufferSize::RangeMinAsInt(std::map<String,String> Parameters) {
630	return 32;
631	}
632
633	optional<int>
634	AudioOutputDeviceCoreAudio::ParameterBufferSize::RangeMaxAsInt(std::map<String,String> Parameters) {
635	return 4096;
636	}
637
638	std::vector<int>
639	AudioOutputDeviceCoreAudio::ParameterBufferSize::PossibilitiesAsInt(std::map<String,String> Parameters) {
640	return std::vector<int>();
641	}
642
643	void AudioOutputDeviceCoreAudio::ParameterBufferSize::OnSetValue(int i) throw (Exception) {
644	// not posssible, as parameter is fix
645	}
646
647	String AudioOutputDeviceCoreAudio::ParameterBufferSize::Name() {
648	return "BUFFERSIZE";
649	}
650	} // namespace LinuxSampler