drivers/audio/AudioOutputDeviceCoreAudio.h

/***************************************************************************
 *                                                                         *
 *   LinuxSampler - modular, streaming capable sampler                     *
 *                                                                         *
 *   Copyright (C) 2009 Grigor Iliev                                       *
 *   Copyright (C) 2013-2016 Christian Schoenebeck                         *
 *                                                                         *
 *   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() OVERRIDE; // from CAAudioDeviceModelListener

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

            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() OVERRIDE;
                    virtual bool   Fix() OVERRIDE;
                    virtual bool   Mandatory() OVERRIDE;
                    virtual std::map<String,DeviceCreationParameter*> DependsAsParameters() OVERRIDE;
                    virtual optional<String>    DefaultAsString(std::map<String,String> Parameters) OVERRIDE;
                    virtual std::vector<String> PossibilitiesAsString(std::map<String,String> Parameters) OVERRIDE;
                    virtual void                OnSetValue(String s) throw (Exception) OVERRIDE;
                    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() OVERRIDE;
                    virtual optional<int> DefaultAsInt(std::map<String,String> Parameters) OVERRIDE;
                    virtual std::vector<int> PossibilitiesAsInt(std::map<String,String> Parameters) OVERRIDE;
            };

            /** 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) OVERRIDE;
                    virtual std::vector<int> PossibilitiesAsInt(std::map<String,String> Parameters) OVERRIDE;
            };

            /** 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() OVERRIDE;
                    virtual bool   Fix() OVERRIDE;
                    virtual bool   Mandatory() OVERRIDE;
                    virtual std::map<String,DeviceCreationParameter*> DependsAsParameters() OVERRIDE;
                    virtual optional<int>    DefaultAsInt(std::map<String,String> Parameters) OVERRIDE;
                    virtual optional<int>    RangeMinAsInt(std::map<String,String> Parameters) OVERRIDE;
                    virtual optional<int>    RangeMaxAsInt(std::map<String,String> Parameters) OVERRIDE;
                    virtual std::vector<int> PossibilitiesAsInt(std::map<String,String> Parameters) OVERRIDE;
                    virtual void             OnSetValue(int i) throw (Exception) OVERRIDE;
                    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() OVERRIDE;
                    virtual bool   Fix() OVERRIDE;
                    virtual bool   Mandatory() OVERRIDE;
                    virtual std::map<String,DeviceCreationParameter*> DependsAsParameters() OVERRIDE;
                    virtual optional<int>    DefaultAsInt(std::map<String,String> Parameters) OVERRIDE;
                    virtual optional<int>    RangeMinAsInt(std::map<String,String> Parameters) OVERRIDE;
                    virtual optional<int>    RangeMaxAsInt(std::map<String,String> Parameters) OVERRIDE;
                    virtual std::vector<int> PossibilitiesAsInt(std::map<String,String> Parameters) OVERRIDE;
                    virtual void             OnSetValue(int i) throw (Exception) OVERRIDE;
                    static String Name();
            };

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