drivers/audio/CAAudioDeviceModel.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 __CAAUDIODEVICEMODEL_H__
#define __CAAUDIODEVICEMODEL_H__

#include <string>
#include <vector>
#include <CoreAudio/CoreAudio.h>

#include "../../EventListeners.h"
#include "../../common/Mutex.h"

namespace LinuxSampler {

    class CAAudioStream {
        private:
            UInt32  InputStream;
            UInt32  ChannelNumber;

        public:
            CAAudioStream(UInt32 input, UInt32 chns) {
                InputStream = input, ChannelNumber = chns;
            }

            CAAudioStream& operator=(const CAAudioStream& s) {
                InputStream = s.InputStream;
                ChannelNumber = s.ChannelNumber;
                return *this;
            }

            CAAudioStream(const CAAudioStream& s) { *this = s; }

            UInt32  IsInputStream() { return InputStream; }
            UInt32  GetChannelNumber() { return ChannelNumber; }
    };

    class CAAudioDeviceModelListener {
        public:
            virtual void DeviceChanged() { }
    };

    class CAAudioDeviceListModelListener {
        public:
            virtual void DeviceChanged(AudioDeviceID devID) { }
            virtual void DeviceListChanged() { }
            virtual void DefaultOutputDeviceChanged(AudioDeviceID newID) { }
    };

    class CAAudioDeviceModel : public ListenerList<CAAudioDeviceModelListener*>,
            public CAAudioDeviceListModelListener {

        friend class CAAudioDeviceListModel;

        public:
            CAAudioDeviceModel(AudioDeviceID Id);
            CAAudioDeviceModel(const CAAudioDeviceModel& m);
            ~CAAudioDeviceModel();
            CAAudioDeviceModel& operator=(const CAAudioDeviceModel& m);

            AudioDeviceID  GetID();
            std::string    GetUID();
            std::string    GetName();
            int            GetChannelNumber();
            int            GetDefaultSamplerate();

            const std::vector<int>      GetNominalSamplerates();
            std::vector<CAAudioStream>  GetAudioStreams();

            //from CAAudioDeviceListModelListener
            virtual void                DeviceChanged(AudioDeviceID devID);

        private:
            AudioDeviceID  Id;
            std::string    Uid;
            std::string    Name;
            int            ChannelNumber;
            int            DefaultSamplerate;

            std::vector<int>            NominalSamplerates;
            std::vector<CAAudioStream>  AudioStreams;

            char*          charBuf;
            UInt32         charBufSize;

            void           Init();
            std::string    GetStr(CFStringRef s);
            void           SetUID(CFStringRef s);
            void           SetName(CFStringRef s);
            void           FireDeviceChangedEvent();
    };

/////////////////////////////////////////////////////
////

    class CAAudioDeviceListModel : public ListenerList<CAAudioDeviceListModelListener*> {
        public:
            ~CAAudioDeviceListModel();
            static CAAudioDeviceListModel* GetModel();

            AudioDeviceID       GetDefaultOutputDeviceID();
            UInt32              GetOutputDeviceCount();
            CAAudioDeviceModel  GetOutputDevice(UInt32 Index);
            CAAudioDeviceModel  GetOutputDeviceByID(AudioDeviceID devID);
            UInt32              GetOutputDeviceIndex(AudioDeviceID devID);

        private:
            CAAudioDeviceListModel(); // Forbid instantiation of this class
            static CAAudioDeviceListModel*   pModel;
            std::vector<CAAudioDeviceModel>  inDevices;
            std::vector<CAAudioDeviceModel>  outDevices;
            AudioDeviceID                    DefaultOutputDeviceID;
            Mutex  DeviceMutex;

            void InstallListeners();
            void UninstallListeners();
            void InstallDeviceListeners();
            void InstallDeviceListener(AudioDevicePropertyID id);
            void UninstallDeviceListeners();
            void UninstallDeviceListener(AudioDevicePropertyID id);
            void InstallHardwareListeners();
            void InstallHardwareListener(AudioHardwarePropertyID id);
            void UninstallHardwareListeners();
            void UninstallHardwareListener(AudioHardwarePropertyID id);
            void RescanDevices();
            void GetSamplerates(CAAudioDeviceModel* pDev);
            void GetChannels(CAAudioDeviceModel* pDev);
            void GetStreams(CAAudioDeviceModel* pDev);
            void UpdateDefaultOutputDevice();
            void FireDeviceChangedEvent(AudioDeviceID devID);
            void FireDeviceListChangedEvent();
            void FireDefaultOutputDeviceChangedEvent(AudioDeviceID newID);

            static OSStatus AudioHardwarePropertyListenerCallback (
                AudioHardwarePropertyID inPropertyID, void* inClientData
            );

            static OSStatus AudioDevicePropertyListenerCallback (
                AudioDeviceID inDevice,
                UInt32 inChannel,
                Boolean isInput,
                AudioDevicePropertyID inPropertyID,
                void* inClientData
            );
    };
} // namespace LinuxSampler

#endif  /* __CAAUDIODEVICEMODEL_H__ */
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	#ifndef __CAAUDIODEVICEMODEL_H__
24	#define __CAAUDIODEVICEMODEL_H__
25
26	#include <string>
27	#include <vector>
28	#include <CoreAudio/CoreAudio.h>
29
30	#include "../../EventListeners.h"
31	#include "../../common/Mutex.h"
32
33	namespace LinuxSampler {
34
35	class CAAudioStream {
36	private:
37	UInt32 InputStream;
38	UInt32 ChannelNumber;
39
40	public:
41	CAAudioStream(UInt32 input, UInt32 chns) {
42	InputStream = input, ChannelNumber = chns;
43	}
44
45	CAAudioStream& operator=(const CAAudioStream& s) {
46	InputStream = s.InputStream;
47	ChannelNumber = s.ChannelNumber;
48	return *this;
49	}
50
51	CAAudioStream(const CAAudioStream& s) { *this = s; }
52
53	UInt32 IsInputStream() { return InputStream; }
54	UInt32 GetChannelNumber() { return ChannelNumber; }
55	};
56
57	class CAAudioDeviceModelListener {
58	public:
59	virtual void DeviceChanged() { }
60	};
61
62	class CAAudioDeviceListModelListener {
63	public:
64	virtual void DeviceChanged(AudioDeviceID devID) { }
65	virtual void DeviceListChanged() { }
66	virtual void DefaultOutputDeviceChanged(AudioDeviceID newID) { }
67	};
68
69	class CAAudioDeviceModel : public ListenerList<CAAudioDeviceModelListener*>,
70	public CAAudioDeviceListModelListener {
71
72	friend class CAAudioDeviceListModel;
73
74	public:
75	CAAudioDeviceModel(AudioDeviceID Id);
76	CAAudioDeviceModel(const CAAudioDeviceModel& m);
77	~CAAudioDeviceModel();
78	CAAudioDeviceModel& operator=(const CAAudioDeviceModel& m);
79
80	AudioDeviceID GetID();
81	std::string GetUID();
82	std::string GetName();
83	int GetChannelNumber();
84	int GetDefaultSamplerate();
85
86	const std::vector<int> GetNominalSamplerates();
87	std::vector<CAAudioStream> GetAudioStreams();
88
89	//from CAAudioDeviceListModelListener
90	virtual void DeviceChanged(AudioDeviceID devID);
91
92	private:
93	AudioDeviceID Id;
94	std::string Uid;
95	std::string Name;
96	int ChannelNumber;
97	int DefaultSamplerate;
98
99	std::vector<int> NominalSamplerates;
100	std::vector<CAAudioStream> AudioStreams;
101
102	char* charBuf;
103	UInt32 charBufSize;
104
105	void Init();
106	std::string GetStr(CFStringRef s);
107	void SetUID(CFStringRef s);
108	void SetName(CFStringRef s);
109	void FireDeviceChangedEvent();
110	};
111
112	/////////////////////////////////////////////////////
113	////
114
115	class CAAudioDeviceListModel : public ListenerList<CAAudioDeviceListModelListener*> {
116	public:
117	~CAAudioDeviceListModel();
118	static CAAudioDeviceListModel* GetModel();
119
120	AudioDeviceID GetDefaultOutputDeviceID();
121	UInt32 GetOutputDeviceCount();
122	CAAudioDeviceModel GetOutputDevice(UInt32 Index);
123	CAAudioDeviceModel GetOutputDeviceByID(AudioDeviceID devID);
124	UInt32 GetOutputDeviceIndex(AudioDeviceID devID);
125
126	private:
127	CAAudioDeviceListModel(); // Forbid instantiation of this class
128	static CAAudioDeviceListModel* pModel;
129	std::vector<CAAudioDeviceModel> inDevices;
130	std::vector<CAAudioDeviceModel> outDevices;
131	AudioDeviceID DefaultOutputDeviceID;
132	Mutex DeviceMutex;
133
134	void InstallListeners();
135	void UninstallListeners();
136	void InstallDeviceListeners();
137	void InstallDeviceListener(AudioDevicePropertyID id);
138	void UninstallDeviceListeners();
139	void UninstallDeviceListener(AudioDevicePropertyID id);
140	void InstallHardwareListeners();
141	void InstallHardwareListener(AudioHardwarePropertyID id);
142	void UninstallHardwareListeners();
143	void UninstallHardwareListener(AudioHardwarePropertyID id);
144	void RescanDevices();
145	void GetSamplerates(CAAudioDeviceModel* pDev);
146	void GetChannels(CAAudioDeviceModel* pDev);
147	void GetStreams(CAAudioDeviceModel* pDev);
148	void UpdateDefaultOutputDevice();
149	void FireDeviceChangedEvent(AudioDeviceID devID);
150	void FireDeviceListChangedEvent();
151	void FireDefaultOutputDeviceChangedEvent(AudioDeviceID newID);
152
153	static OSStatus AudioHardwarePropertyListenerCallback (
154	AudioHardwarePropertyID inPropertyID, void* inClientData
155	);
156
157	static OSStatus AudioDevicePropertyListenerCallback (
158	AudioDeviceID inDevice,
159	UInt32 inChannel,
160	Boolean isInput,
161	AudioDevicePropertyID inPropertyID,
162	void* inClientData
163	);
164	};
165	} // namespace LinuxSampler
166
167	#endif /* __CAAUDIODEVICEMODEL_H__ */