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	/***************************************************************************
2	* *
3	* LinuxSampler - modular, streaming capable sampler *
4	* *
5	* Copyright (C) 2009 Grigor Iliev *
6	* Copyright (C) 2013-2016 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	#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	#include "CAAudioDeviceModel.h"
33
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	class AudioOutputDeviceCoreAudio : public AudioOutputDevice,
44	public CAAudioDeviceModelListener, protected Thread {
45
46	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	virtual void DeviceChanged() OVERRIDE; // from CAAudioDeviceModelListener
62
63	// derived abstract methods from class 'AudioOutputDevice'
64	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
72	static String Name();
73	static String Description();
74	static String Version();
75
76
77	// ************* PARAMETERS *************
78
79	/** 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	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	int GetDeviceIndex();
95	static String Name();
96
97	private:
98	String CreateDeviceName(int devIndex);
99	};
100
101	/** 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	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	};
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	virtual optional<int> DefaultAsInt(std::map<String,String> Parameters) OVERRIDE;
124	virtual std::vector<int> PossibilitiesAsInt(std::map<String,String> Parameters) OVERRIDE;
125	};
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	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	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	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	static String Name();
165	};
166
167	protected:
168	virtual int Main() OVERRIDE; ///< Implementation of virtual method from class Thread
169
170	private:
171	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
181	void CreateAndStartAudioQueue() throw(Exception);
182	void DestroyAudioQueue();
183	void FillBuffers();
184	void PrimeAudioQueue();
185
186	static void AudioQueueListener(void *inUserData, AudioQueueRef inAQ, AudioQueuePropertyID inID);
187	static void HandleOutputBuffer(void *aqData, AudioQueueRef inAQ, AudioQueueBufferRef inBuffer);
188	static void SetAudioDataFormat(AudioStreamBasicDescription* pDataFormat);
189	};
190	} // namespace LinuxSampler
191
192	#endif /* _AUDIOOUTPUTDEVICECOREAUDIO_H */