drivers/audio/AudioOutputDeviceCoreAudio.h

/***************************************************************************
 *                                                                         *
 *   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                                                   *
 ***************************************************************************/

#ifndef _AUDIOOUTPUTDEVICECOREAUDIO_H
#define _AUDIOOUTPUTDEVICECOREAUDIO_H

#include "../../common/atomic.h"
#include "../../common/Mutex.h"
#include "../../common/Thread.h"

#include "AudioOutputDevice.h"
#include "CAAudioDeviceModel.h"

#include <AudioToolbox/AudioToolbox.h>
#include <CoreAudio/CoreAudio.h>

namespace LinuxSampler {

    /** Core Audio audio output driver
     *
     * Implements audio output to the Core Audio architecture.
     */
    class AudioOutputDeviceCoreAudio : public AudioOutputDevice,
            public CAAudioDeviceModelListener, protected Thread {

        private:
            struct AQPlayerState {
                AudioStreamBasicDescription   mDataFormat;
                AudioQueueRef                 mQueue;
                AudioQueueBufferRef*          mBuffers;
                UInt32                        bufferByteSize;
                UInt32                        mNumPacketsToRead;
                atomic_t                      mIsRunning;
                AudioOutputDeviceCoreAudio*   pDevice; // needed for the callback
            };

        public:
            AudioOutputDeviceCoreAudio(std::map<String,DeviceCreationParameter*> Parameters);
            virtual ~AudioOutputDeviceCoreAudio();

            virtual void DeviceChanged(); // from CAAudioDeviceModelListener

            // derived abstract methods from class 'AudioOutputDevice'
            virtual void Play();
            virtual bool IsPlaying();
            virtual void Stop();
            virtual uint MaxSamplesPerCycle();
            virtual uint SampleRate();
            virtual String Driver();
            virtual AudioChannel* CreateChannel(uint ChannelNr);

            static String Name();
            static String Description();
            static String Version();


// *************** PARAMETERS ***************

            /** Device Parameter 'DEVICE'
             *
             * Used to select the desired output device.
             */
            class ParameterDevice : public DeviceCreationParameterString {
                public:
                    ParameterDevice();
                    ParameterDevice(String s) throw (Exception);
                    virtual String Description();
                    virtual bool   Fix();
                    virtual bool   Mandatory();
                    virtual std::map<String,DeviceCreationParameter*> DependsAsParameters();
                    virtual optional<String>    DefaultAsString(std::map<String,String> Parameters);
                    virtual std::vector<String> PossibilitiesAsString(std::map<String,String> Parameters);
                    virtual void                OnSetValue(String s) throw (Exception);
                    int GetDeviceIndex();
                    static String Name();

                private:
                    String CreateDeviceName(int devIndex);
            };

            /** Device Parameter 'SAMPLERATE'
             *
             * Used to set the sample rate of the audio output device.
             */
            class ParameterSampleRate : public AudioOutputDevice::ParameterSampleRate {
                public:
                    ParameterSampleRate();
                    ParameterSampleRate(String s);
                    virtual std::map<String,DeviceCreationParameter*> DependsAsParameters();
                    virtual optional<int> DefaultAsInt(std::map<String,String> Parameters);
                    virtual std::vector<int> PossibilitiesAsInt(std::map<String,String> Parameters);
            };

            /** Device Parameters 'CHANNELS'
             *
             * Used to increase / decrease the number of audio channels of
             * audio output device.
             */
            class ParameterChannels : public AudioOutputDevice::ParameterChannels {
                public:
                    ParameterChannels();
                    ParameterChannels(String s);
                    virtual optional<int> DefaultAsInt(std::map<String,String> Parameters);
                    virtual std::vector<int> PossibilitiesAsInt(std::map<String,String> Parameters);
            };

            /** Device Parameter 'BUFFERS'
             *
             * Used to select the number of audio buffers.
             */
            class ParameterBuffers : public DeviceCreationParameterInt {
                public:
                    ParameterBuffers();
                    ParameterBuffers(String s) throw (Exception);
                    virtual String Description();
                    virtual bool   Fix();
                    virtual bool   Mandatory();
                    virtual std::map<String,DeviceCreationParameter*> DependsAsParameters();
                    virtual optional<int>    DefaultAsInt(std::map<String,String> Parameters);
                    virtual optional<int>    RangeMinAsInt(std::map<String,String> Parameters);
                    virtual optional<int>    RangeMaxAsInt(std::map<String,String> Parameters);
                    virtual std::vector<int> PossibilitiesAsInt(std::map<String,String> Parameters);
                    virtual void             OnSetValue(int i) throw (Exception);
                    static String Name();
            };

            /** Device Parameter 'BUFFERSIZE'
             *
             * Used to set the audio buffer size in sample frames.
             */
            class ParameterBufferSize : public DeviceCreationParameterInt {
                public:
                    ParameterBufferSize();
                    ParameterBufferSize(String s) throw (Exception);
                    virtual String Description();
                    virtual bool   Fix();
                    virtual bool   Mandatory();
                    virtual std::map<String,DeviceCreationParameter*> DependsAsParameters();
                    virtual optional<int>    DefaultAsInt(std::map<String,String> Parameters);
                    virtual optional<int>    RangeMinAsInt(std::map<String,String> Parameters);
                    virtual optional<int>    RangeMaxAsInt(std::map<String,String> Parameters);
                    virtual std::vector<int> PossibilitiesAsInt(std::map<String,String> Parameters);
                    virtual void             OnSetValue(int i) throw (Exception);
                    static String Name();
            };

        protected:
            int Main();  ///< Implementation of virtual method from class Thread

        private:
            CAAudioDeviceModel  CurrentDevice;
            uint                uiCoreAudioChannels;
            uint                uiBufferNumber; // once initialized this value shouldn't be changed
            uint                uiBufferSize; // once initialized this value shouldn't be changed
            AQPlayerState       aqPlayerState;
            atomic_t            pausedNew;
            uint                pausedOld;
            atomic_t            restartQueue;
            Mutex               destroyMutex;

            void CreateAndStartAudioQueue();
            void DestroyAudioQueue();
            void FillBuffers();
            void PrimeAudioQueue();

            static void AudioQueueListener(void *inUserData, AudioQueueRef inAQ, AudioQueuePropertyID inID);
            static void HandleOutputBuffer(void *aqData, AudioQueueRef inAQ, AudioQueueBufferRef inBuffer);
            static void SetAudioDataFormat(AudioStreamBasicDescription* pDataFormat);
    };
} // namespace LinuxSampler

#endif  /* _AUDIOOUTPUTDEVICECOREAUDIO_H */
1	iliev	1829	/***************************************************************************
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			#ifndef _AUDIOOUTPUTDEVICECOREAUDIO_H
24			#define _AUDIOOUTPUTDEVICECOREAUDIO_H
25
26			#include "../../common/atomic.h"
27			#include "../../common/Mutex.h"
28			#include "../../common/Thread.h"
29
30			#include "AudioOutputDevice.h"
31	iliev	1832	#include "CAAudioDeviceModel.h"
32	iliev	1829
33			#include <AudioToolbox/AudioToolbox.h>
34			#include <CoreAudio/CoreAudio.h>
35
36			namespace LinuxSampler {
37
38			/** Core Audio audio output driver
39			*
40			* Implements audio output to the Core Audio architecture.
41			*/
42	iliev	1832	class AudioOutputDeviceCoreAudio : public AudioOutputDevice,
43			public CAAudioDeviceModelListener, protected Thread {
44
45	iliev	1829	private:
46			struct AQPlayerState {
47			AudioStreamBasicDescription mDataFormat;
48			AudioQueueRef mQueue;
49			AudioQueueBufferRef* mBuffers;
50			UInt32 bufferByteSize;
51			UInt32 mNumPacketsToRead;
52			atomic_t mIsRunning;
53			AudioOutputDeviceCoreAudio* pDevice; // needed for the callback
54			};
55
56			public:
57			AudioOutputDeviceCoreAudio(std::map<String,DeviceCreationParameter*> Parameters);
58			virtual ~AudioOutputDeviceCoreAudio();
59
60	iliev	1832	virtual void DeviceChanged(); // from CAAudioDeviceModelListener
61
62	iliev	1829	// derived abstract methods from class 'AudioOutputDevice'
63			virtual void Play();
64			virtual bool IsPlaying();
65			virtual void Stop();
66			virtual uint MaxSamplesPerCycle();
67			virtual uint SampleRate();
68			virtual String Driver();
69			virtual AudioChannel* CreateChannel(uint ChannelNr);
70
71			static String Name();
72			static String Description();
73			static String Version();
74
75
76			// ************* PARAMETERS *************
77
78	iliev	1832	/** Device Parameter 'DEVICE'
79			*
80			* Used to select the desired output device.
81			*/
82			class ParameterDevice : public DeviceCreationParameterString {
83			public:
84			ParameterDevice();
85			ParameterDevice(String s) throw (Exception);
86			virtual String Description();
87			virtual bool Fix();
88			virtual bool Mandatory();
89			virtual std::map<String,DeviceCreationParameter*> DependsAsParameters();
90			virtual optional<String> DefaultAsString(std::map<String,String> Parameters);
91			virtual std::vector<String> PossibilitiesAsString(std::map<String,String> Parameters);
92			virtual void OnSetValue(String s) throw (Exception);
93			int GetDeviceIndex();
94			static String Name();
95
96			private:
97			String CreateDeviceName(int devIndex);
98			};
99
100	iliev	1829	/** Device Parameter 'SAMPLERATE'
101			*
102			* Used to set the sample rate of the audio output device.
103			*/
104			class ParameterSampleRate : public AudioOutputDevice::ParameterSampleRate {
105			public:
106			ParameterSampleRate();
107			ParameterSampleRate(String s);
108	iliev	1832	virtual std::map<String,DeviceCreationParameter*> DependsAsParameters();
109	iliev	1829	virtual optional<int> DefaultAsInt(std::map<String,String> Parameters);
110	iliev	1832	virtual std::vector<int> PossibilitiesAsInt(std::map<String,String> Parameters);
111	iliev	1829	};
112
113			/** Device Parameters 'CHANNELS'
114			*
115			* Used to increase / decrease the number of audio channels of
116			* audio output device.
117			*/
118			class ParameterChannels : public AudioOutputDevice::ParameterChannels {
119			public:
120			ParameterChannels();
121			ParameterChannels(String s);
122			virtual optional<int> DefaultAsInt(std::map<String,String> Parameters);
123	iliev	1832	virtual std::vector<int> PossibilitiesAsInt(std::map<String,String> Parameters);
124	iliev	1829	};
125
126			/** Device Parameter 'BUFFERS'
127			*
128			* Used to select the number of audio buffers.
129			*/
130			class ParameterBuffers : public DeviceCreationParameterInt {
131			public:
132			ParameterBuffers();
133			ParameterBuffers(String s) throw (Exception);
134			virtual String Description();
135			virtual bool Fix();
136			virtual bool Mandatory();
137			virtual std::map<String,DeviceCreationParameter*> DependsAsParameters();
138			virtual optional<int> DefaultAsInt(std::map<String,String> Parameters);
139			virtual optional<int> RangeMinAsInt(std::map<String,String> Parameters);
140			virtual optional<int> RangeMaxAsInt(std::map<String,String> Parameters);
141			virtual std::vector<int> PossibilitiesAsInt(std::map<String,String> Parameters);
142			virtual void OnSetValue(int i) throw (Exception);
143			static String Name();
144			};
145
146			/** Device Parameter 'BUFFERSIZE'
147			*
148			* Used to set the audio buffer size in sample frames.
149			*/
150			class ParameterBufferSize : public DeviceCreationParameterInt {
151			public:
152			ParameterBufferSize();
153			ParameterBufferSize(String s) throw (Exception);
154			virtual String Description();
155			virtual bool Fix();
156			virtual bool Mandatory();
157			virtual std::map<String,DeviceCreationParameter*> DependsAsParameters();
158			virtual optional<int> DefaultAsInt(std::map<String,String> Parameters);
159			virtual optional<int> RangeMinAsInt(std::map<String,String> Parameters);
160			virtual optional<int> RangeMaxAsInt(std::map<String,String> Parameters);
161			virtual std::vector<int> PossibilitiesAsInt(std::map<String,String> Parameters);
162			virtual void OnSetValue(int i) throw (Exception);
163			static String Name();
164			};
165
166			protected:
167			int Main(); ///< Implementation of virtual method from class Thread
168
169			private:
170	iliev	1832	CAAudioDeviceModel CurrentDevice;
171			uint uiCoreAudioChannels;
172			uint uiBufferNumber; // once initialized this value shouldn't be changed
173			uint uiBufferSize; // once initialized this value shouldn't be changed
174			AQPlayerState aqPlayerState;
175			atomic_t pausedNew;
176			uint pausedOld;
177			atomic_t restartQueue;
178			Mutex destroyMutex;
179	iliev	1829
180	iliev	1832	void CreateAndStartAudioQueue();
181			void DestroyAudioQueue();
182			void FillBuffers();
183			void PrimeAudioQueue();
184	iliev	1829
185	iliev	1832	static void AudioQueueListener(void *inUserData, AudioQueueRef inAQ, AudioQueuePropertyID inID);
186	iliev	1829	static void HandleOutputBuffer(void *aqData, AudioQueueRef inAQ, AudioQueueBufferRef inBuffer);
187			static void SetAudioDataFormat(AudioStreamBasicDescription* pDataFormat);
188			};
189			} // namespace LinuxSampler
190
191			#endif /* _AUDIOOUTPUTDEVICECOREAUDIO_H */