drivers/audio/CAAudioDeviceModel.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 "CAAudioDeviceModel.h"

#include <iostream>
#include "../../common/Exception.h"
#include "../../common/global_private.h"

namespace LinuxSampler {

    CAAudioDeviceModel::CAAudioDeviceModel(AudioDeviceID Id) {
        this->Id = Id;
        ChannelNumber = 2;
        DefaultSamplerate = 44100;

        charBufSize = 512;
        charBuf = new char[charBufSize];

        Init();
    }

    CAAudioDeviceModel::CAAudioDeviceModel(const CAAudioDeviceModel& m) : Uid(m.Uid),
            Name(m.Name), NominalSamplerates(m.NominalSamplerates), AudioStreams(m.AudioStreams) {

        Id = m.Id;
        ChannelNumber = m.ChannelNumber;
        DefaultSamplerate = m.DefaultSamplerate;

        charBufSize = 512;
        charBuf = new char[charBufSize];

        Init();
    }

    CAAudioDeviceModel::~CAAudioDeviceModel() {
        CAAudioDeviceListModel::GetModel()->RemoveListener(this);
        delete [] charBuf;
    }

    CAAudioDeviceModel& CAAudioDeviceModel::operator=(const CAAudioDeviceModel& m) {
        Id = m.Id;
        Uid = m.Uid;
        Name = m.Name;
        ChannelNumber = m.ChannelNumber;
        DefaultSamplerate = m.DefaultSamplerate;
        NominalSamplerates = m.NominalSamplerates;
        AudioStreams = m.AudioStreams;

        return *this;
    }

    void CAAudioDeviceModel::Init() {
        CAAudioDeviceListModel::GetModel()->AddListener(this);
    }

    void CAAudioDeviceModel::DeviceChanged(AudioDeviceID devID) {
        if(GetID() == devID) FireDeviceChangedEvent();
    }

    void CAAudioDeviceModel::FireDeviceChangedEvent() {
        for(int i = 0; i < GetListenerCount(); i++) {
            GetListener(i)->DeviceChanged();
        }
    }

    AudioDeviceID CAAudioDeviceModel::GetID() { return Id; }

    std::string CAAudioDeviceModel::GetUID() { return Uid; }

    void CAAudioDeviceModel::SetUID(CFStringRef s) {
        Uid = GetStr(s);
    }

    std::string CAAudioDeviceModel::GetName() { return Name; }

    void CAAudioDeviceModel::SetName(CFStringRef s) {
        Name = GetStr(s);
    }

    int CAAudioDeviceModel::GetChannelNumber() { return ChannelNumber; }

    int CAAudioDeviceModel::GetDefaultSamplerate() { return DefaultSamplerate; }

    const std::vector<int> CAAudioDeviceModel::GetNominalSamplerates() {
        return NominalSamplerates;
    }

    std::vector<CAAudioStream> CAAudioDeviceModel::GetAudioStreams() {
        return AudioStreams;
    }

    std::string CAAudioDeviceModel::GetStr(CFStringRef s) {
        if(s == NULL) return std::string("Undefined");

        CFRetain(s);
        CFIndex len = CFStringGetLength(s) + 1;
        if(charBufSize < len) {
            delete [] charBuf;
            charBufSize *= 2;
            if(charBufSize < len) charBufSize = len;
            charBuf = new char[charBufSize];
        }
        
        std::string s2;
        if(CFStringGetCString(s, charBuf, charBufSize, kCFStringEncodingASCII)) {
            s2 = charBuf;
        }
        CFRelease(s);

        return s2;
    }

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

    CAAudioDeviceListModel* CAAudioDeviceListModel::pModel = NULL;

    CAAudioDeviceListModel* CAAudioDeviceListModel::GetModel() {
        if(pModel == NULL) {
            pModel = new CAAudioDeviceListModel();
            pModel->RescanDevices();
            pModel->InstallListeners();
        }
        return pModel;
    }
    
    OSStatus CAAudioDeviceListModel::AudioHardwarePropertyListenerCallback (
        AudioHardwarePropertyID inPropertyID, void* inClientData
    ) {
        CAAudioDeviceListModel* model = CAAudioDeviceListModel::GetModel();
        switch(inPropertyID) {
            case kAudioHardwarePropertyDevices:
                model->RescanDevices();
                break;
            case kAudioHardwarePropertyDefaultOutputDevice:
                model->UpdateDefaultOutputDevice();
                model->FireDefaultOutputDeviceChangedEvent(model->GetDefaultOutputDeviceID());
                break;
        }
        return noErr;
    }

    OSStatus CAAudioDeviceListModel::AudioDevicePropertyListenerCallback (
        AudioDeviceID inDevice,
        UInt32 inChannel,
        Boolean isInput,
        AudioDevicePropertyID inPropertyID,
        void* inClientData
    ) {
        CAAudioDeviceListModel* model = CAAudioDeviceListModel::GetModel();

        switch(inPropertyID) {
            case kAudioDevicePropertyDeviceHasChanged:
                model->FireDeviceChangedEvent(inDevice);
                break;
        }

        return noErr;
    }

    CAAudioDeviceListModel::CAAudioDeviceListModel() {
        DefaultOutputDeviceID = 0;
    }

    CAAudioDeviceListModel::~CAAudioDeviceListModel() {
        UninstallListeners();
    }

    void CAAudioDeviceListModel::InstallListeners() {
        InstallHardwareListeners();
        InstallDeviceListeners();
    }

    void CAAudioDeviceListModel::UninstallListeners() {
        UninstallHardwareListeners();
        UninstallDeviceListeners();
    }

    void CAAudioDeviceListModel::InstallHardwareListeners() {
        // Notify when device is added or removed
        InstallHardwareListener(kAudioHardwarePropertyDevices);
        //Notify when the default audio output device is changed
        InstallHardwareListener(kAudioHardwarePropertyDefaultOutputDevice);
    }

    void CAAudioDeviceListModel::UninstallHardwareListeners() {
        UninstallHardwareListener(kAudioHardwarePropertyDevices);
        UninstallHardwareListener(kAudioHardwarePropertyDefaultOutputDevice);
    }

    void CAAudioDeviceListModel::InstallHardwareListener(AudioHardwarePropertyID id) {
        AudioHardwareAddPropertyListener (
            id, AudioHardwarePropertyListenerCallback, NULL
        );
    }

    void CAAudioDeviceListModel::UninstallHardwareListener(AudioHardwarePropertyID id) {
        AudioHardwareRemovePropertyListener (
            id, AudioHardwarePropertyListenerCallback
        );
    }

    void CAAudioDeviceListModel::InstallDeviceListeners() {
        InstallDeviceListener(kAudioDevicePropertyDeviceHasChanged);
    }

    void CAAudioDeviceListModel::UninstallDeviceListeners() {
        UninstallDeviceListener(kAudioDevicePropertyDeviceHasChanged);
    }

    void CAAudioDeviceListModel::InstallDeviceListener(AudioDevicePropertyID id) {
        for(int i = 0; i < GetModel()->GetOutputDeviceCount(); i++) {
            AudioDeviceAddPropertyListener (
                GetModel()->GetOutputDevice(i).GetID(), 0, false,
                id, AudioDevicePropertyListenerCallback, NULL
            );
        }
    }

    void CAAudioDeviceListModel::UninstallDeviceListener(AudioDevicePropertyID id) {
        for(int i = 0; i < GetModel()->GetOutputDeviceCount(); i++) {
            AudioDeviceRemovePropertyListener (
                GetModel()->GetOutputDevice(i).GetID(), 0, false,
                id, AudioDevicePropertyListenerCallback
            );
        }
    }

    void CAAudioDeviceListModel::FireDeviceChangedEvent(AudioDeviceID devID) {
        DeviceMutex.Lock();
        for(int i = 0; i < GetListenerCount(); i++) {
            GetListener(i)->DeviceChanged(devID);
        }
        DeviceMutex.Unlock();
    }

    void CAAudioDeviceListModel::FireDeviceListChangedEvent() {
        DeviceMutex.Lock();
        for(int i = 0; i < GetListenerCount(); i++) {
            GetListener(i)->DeviceListChanged();
        }
        DeviceMutex.Unlock();
    }

    void CAAudioDeviceListModel::FireDefaultOutputDeviceChangedEvent(AudioDeviceID newID) {
        DeviceMutex.Lock();
        for(int i = 0; i < GetListenerCount(); i++) {
            GetListener(i)->DefaultOutputDeviceChanged(newID);
        }
        DeviceMutex.Unlock();
    }

    AudioDeviceID CAAudioDeviceListModel::GetDefaultOutputDeviceID() {
        return DefaultOutputDeviceID;
    }

    UInt32 CAAudioDeviceListModel::GetOutputDeviceCount() {
        DeviceMutex.Lock();
        int size = outDevices.size();
        DeviceMutex.Unlock();
        return size;
    }

    CAAudioDeviceModel CAAudioDeviceListModel::GetOutputDevice(UInt32 Index) {
        DeviceMutex.Lock();
        if(Index < 0 || Index >= GetOutputDeviceCount()) {
            DeviceMutex.Unlock();
            throw Exception("Device index out of bounds");
        }

        CAAudioDeviceModel dev = outDevices[Index];
        DeviceMutex.Unlock();
        return dev;
    }

    CAAudioDeviceModel CAAudioDeviceListModel::GetOutputDeviceByID(AudioDeviceID devID) {
        DeviceMutex.Lock();
        for(int i = 0; i < outDevices.size(); i++) {
            if(outDevices[i].GetID() == devID) {
                CAAudioDeviceModel dev = outDevices[i];
                DeviceMutex.Unlock();
                return dev;
            }
        }
        DeviceMutex.Unlock();
        throw Exception("Unknown audio device ID: " + ToString(devID));
    }

    UInt32 CAAudioDeviceListModel::GetOutputDeviceIndex(AudioDeviceID devID) {
        DeviceMutex.Lock();
        for(UInt32 i = 0; i < outDevices.size(); i++) {
            if(outDevices[i].GetID() == devID) {
                DeviceMutex.Unlock();
                return i;
            }
        }
        DeviceMutex.Unlock();
        throw Exception("Unknown audio device ID: " + ToString(devID));
    }

    void CAAudioDeviceListModel::RescanDevices() {
        DeviceMutex.Lock();
        inDevices.clear();
        outDevices.clear();

        UInt32   outSize;
        Boolean  outWritable;

        UpdateDefaultOutputDevice();

        OSStatus res = AudioHardwareGetPropertyInfo (
            kAudioHardwarePropertyDevices, &outSize, &outWritable
        );

        if(res) {
            std::cerr << "Failed to get device list: " << res << std::endl;
            DeviceMutex.Unlock();
            return;
        }

        UInt32 deviceNumber = outSize / sizeof(AudioDeviceID);
        if(deviceNumber < 1) {
            std::cerr << "No audio devices found" << std::endl;
            DeviceMutex.Unlock();
            return;
        }

        if(deviceNumber * sizeof(AudioDeviceID) != outSize) {
            std::cerr << "Invalid device size. This is a bug!" << std::endl;
            DeviceMutex.Unlock();
            return;
        }

        AudioDeviceID* devs = new AudioDeviceID[deviceNumber];

        res = AudioHardwareGetProperty (
            kAudioHardwarePropertyDevices, &outSize, devs
        );

        if(res) {
            std::cerr << "Failed to get device IDs: " << res << std::endl;
            delete [] devs;
            DeviceMutex.Unlock();
            return;
        }

        for(int i = 0; i < deviceNumber; i++) {
            // TODO: for now skip devices which are not alive
            outSize = sizeof(UInt32);
            UInt32 isAlive = 0;

            res = AudioDeviceGetProperty (
                devs[i], 0, false,
                kAudioDevicePropertyDeviceIsAlive,
                &outSize, &isAlive
            );

            if(res || !isAlive) continue;
            ///////

            CAAudioDeviceModel dev(devs[i]);

            CFStringRef tempStringRef = NULL;

            // Get the name of the device
            outSize = sizeof(CFStringRef);

            res = AudioDeviceGetProperty (
                devs[i], 0, false,
                kAudioObjectPropertyName,
                &outSize, &tempStringRef
            );

            dev.SetName(tempStringRef);
            if(tempStringRef != NULL) CFRelease(tempStringRef);
            ///////

            // Get the name of the device
            outSize = sizeof(CFStringRef);

            res = AudioDeviceGetProperty (
                devs[i], 0, false,
                kAudioDevicePropertyDeviceUID,
                &outSize, &tempStringRef
            );

            dev.SetUID(tempStringRef);
            if(tempStringRef != NULL) CFRelease(tempStringRef);
            ///////

            GetChannels(&dev);
            GetSamplerates(&dev);
            if(dev.GetChannelNumber() > 0) outDevices.push_back(dev);
        }

        delete [] devs;
        FireDeviceListChangedEvent();

        /*for(int i = 0; i < GetOutputDeviceCount(); i++) {
            std::cout << "Device ID: " << GetOutputDevice(i).GetID() << std::endl;
            std::cout << "Device name: " << GetOutputDevice(i).GetName() << std::endl;
            std::cout << "Device UID: " << GetOutputDevice(i).GetUID() << std::endl;
            std::cout << "Channels: " << GetOutputDevice(i).GetChannelNumber() << std::endl;
            std::cout << "Default samplerate: " << GetOutputDevice(i).GetDefaultSamplerate() << std::endl;

            const std::vector<int> rates = GetOutputDevice(i).GetNominalSamplerates();
            std::cout << "Nominal samplerates: " << std::endl;
            for(int j = 0; j < rates.size(); j++) {
                std::cout << "\t" << rates[j] << std::endl;
            }
            std::cout << std::endl;
        }*/
        DeviceMutex.Unlock();
    }

    void CAAudioDeviceListModel::UpdateDefaultOutputDevice() {
        AudioDeviceID id;
        UInt32 size = sizeof(AudioDeviceID);
        OSStatus res = AudioHardwareGetProperty (
            kAudioHardwarePropertyDefaultOutputDevice, &size, &id
        );
        if(res) std::cerr << "Failed to get default output device: " << res << std::endl;
        else DefaultOutputDeviceID = id;
    }

    void CAAudioDeviceListModel::GetChannels(CAAudioDeviceModel* pDev) {
        UInt32 outSize;
        bool isInput = false;

        OSStatus res = AudioDeviceGetPropertyInfo (
            pDev->GetID(), 0, isInput,
            kAudioDevicePropertyStreamConfiguration,
            &outSize, NULL
        );
        if(res || outSize == 0) {
            if(res) std::cerr << "Failed to get stream config: " << res << std::endl;
            return;
        }

        AudioBufferList* pBufferList = NULL;
        pBufferList = (AudioBufferList*)malloc(outSize);
        if(pBufferList == NULL) {
            perror(NULL);
            return;
        }

        res = AudioDeviceGetProperty (
            pDev->GetID(), 0, isInput,
            kAudioDevicePropertyStreamConfiguration,
            &outSize, pBufferList
        );

        if(res = noErr) {
            std::cerr << "Failed to get channel number: " << res << std::endl;
            free(pBufferList);
            return;
        }

        UInt32 chns = 0;
        for(int i = 0; i < pBufferList->mNumberBuffers; i++) {
            chns += pBufferList->mBuffers[i].mNumberChannels;
        }

        pDev->ChannelNumber = chns;
        
        free(pBufferList);
    }

    /*void CAAudioDeviceListModel::GetStreams(CAAudioDeviceModel* pDev) {
        UInt32 outSize = sizeof(AudioStreamID);

        OSStatus res = AudioDeviceGetPropertyInfo (
            pDev->GetID(), 0, false,
            kAudioDevicePropertyStreams,
            &outSize, NULL
        );

        if(res) {
            std::cerr << "Failed to get device streams: " << res << std::endl;
            return;
        }

        UInt32 streamNumber = outSize / sizeof(AudioStreamID);
        if(streamNumber < 1) {
            std::cerr << "No streams found" << std::endl;
            return;
        }

        if(streamNumber * sizeof(AudioStreamID) != outSize) {
            std::cerr << "Invalid AudioStreamID size. This is a bug!" << std::endl;
            return;
        }

        AudioStreamID* streams = new AudioStreamID[streamNumber];

        res = AudioDeviceGetProperty (
            pDev->GetID(), 0, false,
            kAudioDevicePropertyStreams,
            &outSize, streams
        );

        if(res) {
            std::cerr << "Failed to get stream IDs: " << res << std::endl;
            delete [] streams;
            return;
        }

        for(int i = 0; i < streamNumber; i++) {
            UInt32 inStream;

            res = AudioStreamGetProperty (
                streams[i], 0, kAudioStreamPropertyDirection, &outSize, &inStream
            );

            if(res) {
                std::cerr << "Failed to get stream direction: " << res << std::endl;
                continue;
            }

            //pDev->AudioStreams.push_back(CAAudioStream(inStream, chns));
        }

        delete [] streams;
    }*/

    void CAAudioDeviceListModel::GetSamplerates(CAAudioDeviceModel* pDev) {
        UInt32 outSize;

        // Get current nominal sample rate
        outSize = sizeof(Float64);
        Float64 srate;

        OSStatus res = AudioDeviceGetProperty (
            pDev->GetID(), 0, false,
            kAudioDevicePropertyNominalSampleRate,
            &outSize, &srate
        );
        
        if(res) std::cerr << "Failed to get default samplerate: " << res << std::endl;
        else pDev->DefaultSamplerate = srate;
        ///////

        res = AudioDeviceGetPropertyInfo (
            pDev->GetID(), 0, false,
            kAudioDevicePropertyAvailableNominalSampleRates,
            &outSize, NULL
        );

        if(res) {
            std::cerr << "Failed to get nominal samplerates: " << res << std::endl;
            return;
        }

        UInt32 rangeNumber = outSize / sizeof(AudioValueRange);
        if(rangeNumber < 1) {
            std::cerr << "No nominal samplerates found" << std::endl;
            return;
        }

        if(rangeNumber * sizeof(AudioValueRange) != outSize) {
            std::cerr << "Invalid AudioValueRange size. This is a bug!" << std::endl;
            return;
        }

        AudioValueRange* ranges = new AudioValueRange[rangeNumber];

        res = AudioDeviceGetProperty (
            pDev->GetID(), 0, false,
            kAudioDevicePropertyAvailableNominalSampleRates,
            &outSize, ranges
        );

        if(res) {
            std::cerr << "Failed to get samplerate ranges: " << res << std::endl;
            delete [] ranges;
            return;
        }

        for(int i = 0; i < rangeNumber; i++) {
            // FIXME: might be ranges of valid samplerates
            UInt32 min = (UInt32)ranges[i].mMinimum;
            UInt32 max = (UInt32)ranges[i].mMaximum;
            pDev->NominalSamplerates.push_back(min);
            if(min != max) pDev->NominalSamplerates.push_back(max);
        }

        delete [] ranges;
    }
} // namespace LinuxSampler
1	iliev	1832	/***************************************************************************
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 "CAAudioDeviceModel.h"
24
25			#include <iostream>
26			#include "../../common/Exception.h"
27			#include "../../common/global_private.h"
28
29			namespace LinuxSampler {
30
31			CAAudioDeviceModel::CAAudioDeviceModel(AudioDeviceID Id) {
32			this->Id = Id;
33			ChannelNumber = 2;
34			DefaultSamplerate = 44100;
35
36			charBufSize = 512;
37			charBuf = new char[charBufSize];
38
39			Init();
40			}
41
42			CAAudioDeviceModel::CAAudioDeviceModel(const CAAudioDeviceModel& m) : Uid(m.Uid),
43			Name(m.Name), NominalSamplerates(m.NominalSamplerates), AudioStreams(m.AudioStreams) {
44
45			Id = m.Id;
46			ChannelNumber = m.ChannelNumber;
47			DefaultSamplerate = m.DefaultSamplerate;
48
49			charBufSize = 512;
50			charBuf = new char[charBufSize];
51
52			Init();
53			}
54
55			CAAudioDeviceModel::~CAAudioDeviceModel() {
56			CAAudioDeviceListModel::GetModel()->RemoveListener(this);
57			delete [] charBuf;
58			}
59
60			CAAudioDeviceModel& CAAudioDeviceModel::operator=(const CAAudioDeviceModel& m) {
61			Id = m.Id;
62			Uid = m.Uid;
63			Name = m.Name;
64			ChannelNumber = m.ChannelNumber;
65			DefaultSamplerate = m.DefaultSamplerate;
66			NominalSamplerates = m.NominalSamplerates;
67			AudioStreams = m.AudioStreams;
68
69			return *this;
70			}
71
72			void CAAudioDeviceModel::Init() {
73			CAAudioDeviceListModel::GetModel()->AddListener(this);
74			}
75
76			void CAAudioDeviceModel::DeviceChanged(AudioDeviceID devID) {
77			if(GetID() == devID) FireDeviceChangedEvent();
78			}
79
80			void CAAudioDeviceModel::FireDeviceChangedEvent() {
81			for(int i = 0; i < GetListenerCount(); i++) {
82			GetListener(i)->DeviceChanged();
83			}
84			}
85
86			AudioDeviceID CAAudioDeviceModel::GetID() { return Id; }
87
88			std::string CAAudioDeviceModel::GetUID() { return Uid; }
89
90			void CAAudioDeviceModel::SetUID(CFStringRef s) {
91			Uid = GetStr(s);
92			}
93
94			std::string CAAudioDeviceModel::GetName() { return Name; }
95
96			void CAAudioDeviceModel::SetName(CFStringRef s) {
97			Name = GetStr(s);
98			}
99
100			int CAAudioDeviceModel::GetChannelNumber() { return ChannelNumber; }
101
102			int CAAudioDeviceModel::GetDefaultSamplerate() { return DefaultSamplerate; }
103
104			const std::vector<int> CAAudioDeviceModel::GetNominalSamplerates() {
105			return NominalSamplerates;
106			}
107
108			std::vector<CAAudioStream> CAAudioDeviceModel::GetAudioStreams() {
109			return AudioStreams;
110			}
111
112			std::string CAAudioDeviceModel::GetStr(CFStringRef s) {
113			if(s == NULL) return std::string("Undefined");
114
115			CFRetain(s);
116			CFIndex len = CFStringGetLength(s) + 1;
117			if(charBufSize < len) {
118			delete [] charBuf;
119			charBufSize *= 2;
120	iliev	1846	if(charBufSize < len) charBufSize = len;
121	iliev	1832	charBuf = new char[charBufSize];
122			}
123
124			std::string s2;
125			if(CFStringGetCString(s, charBuf, charBufSize, kCFStringEncodingASCII)) {
126			s2 = charBuf;
127			}
128			CFRelease(s);
129
130			return s2;
131			}
132
133			//////////////////////////////////////////////////////////////////
134			////
135
136			CAAudioDeviceListModel* CAAudioDeviceListModel::pModel = NULL;
137
138			CAAudioDeviceListModel* CAAudioDeviceListModel::GetModel() {
139			if(pModel == NULL) {
140			pModel = new CAAudioDeviceListModel();
141			pModel->RescanDevices();
142			pModel->InstallListeners();
143			}
144			return pModel;
145			}
146
147			OSStatus CAAudioDeviceListModel::AudioHardwarePropertyListenerCallback (
148			AudioHardwarePropertyID inPropertyID, void* inClientData
149			) {
150			CAAudioDeviceListModel* model = CAAudioDeviceListModel::GetModel();
151			switch(inPropertyID) {
152			case kAudioHardwarePropertyDevices:
153			model->RescanDevices();
154			break;
155			case kAudioHardwarePropertyDefaultOutputDevice:
156			model->UpdateDefaultOutputDevice();
157			model->FireDefaultOutputDeviceChangedEvent(model->GetDefaultOutputDeviceID());
158			break;
159			}
160			return noErr;
161			}
162
163			OSStatus CAAudioDeviceListModel::AudioDevicePropertyListenerCallback (
164			AudioDeviceID inDevice,
165			UInt32 inChannel,
166			Boolean isInput,
167			AudioDevicePropertyID inPropertyID,
168			void* inClientData
169			) {
170			CAAudioDeviceListModel* model = CAAudioDeviceListModel::GetModel();
171
172			switch(inPropertyID) {
173			case kAudioDevicePropertyDeviceHasChanged:
174			model->FireDeviceChangedEvent(inDevice);
175			break;
176			}
177
178			return noErr;
179			}
180
181			CAAudioDeviceListModel::CAAudioDeviceListModel() {
182			DefaultOutputDeviceID = 0;
183			}
184
185			CAAudioDeviceListModel::~CAAudioDeviceListModel() {
186			UninstallListeners();
187			}
188
189			void CAAudioDeviceListModel::InstallListeners() {
190			InstallHardwareListeners();
191			InstallDeviceListeners();
192			}
193
194			void CAAudioDeviceListModel::UninstallListeners() {
195			UninstallHardwareListeners();
196			UninstallDeviceListeners();
197			}
198
199			void CAAudioDeviceListModel::InstallHardwareListeners() {
200			// Notify when device is added or removed
201			InstallHardwareListener(kAudioHardwarePropertyDevices);
202			//Notify when the default audio output device is changed
203			InstallHardwareListener(kAudioHardwarePropertyDefaultOutputDevice);
204			}
205
206			void CAAudioDeviceListModel::UninstallHardwareListeners() {
207			UninstallHardwareListener(kAudioHardwarePropertyDevices);
208			UninstallHardwareListener(kAudioHardwarePropertyDefaultOutputDevice);
209			}
210
211			void CAAudioDeviceListModel::InstallHardwareListener(AudioHardwarePropertyID id) {
212			AudioHardwareAddPropertyListener (
213			id, AudioHardwarePropertyListenerCallback, NULL
214			);
215			}
216
217			void CAAudioDeviceListModel::UninstallHardwareListener(AudioHardwarePropertyID id) {
218			AudioHardwareRemovePropertyListener (
219			id, AudioHardwarePropertyListenerCallback
220			);
221			}
222
223			void CAAudioDeviceListModel::InstallDeviceListeners() {
224			InstallDeviceListener(kAudioDevicePropertyDeviceHasChanged);
225			}
226
227			void CAAudioDeviceListModel::UninstallDeviceListeners() {
228			UninstallDeviceListener(kAudioDevicePropertyDeviceHasChanged);
229			}
230
231			void CAAudioDeviceListModel::InstallDeviceListener(AudioDevicePropertyID id) {
232			for(int i = 0; i < GetModel()->GetOutputDeviceCount(); i++) {
233			AudioDeviceAddPropertyListener (
234			GetModel()->GetOutputDevice(i).GetID(), 0, false,
235			id, AudioDevicePropertyListenerCallback, NULL
236			);
237			}
238			}
239
240			void CAAudioDeviceListModel::UninstallDeviceListener(AudioDevicePropertyID id) {
241			for(int i = 0; i < GetModel()->GetOutputDeviceCount(); i++) {
242			AudioDeviceRemovePropertyListener (
243			GetModel()->GetOutputDevice(i).GetID(), 0, false,
244			id, AudioDevicePropertyListenerCallback
245			);
246			}
247			}
248
249			void CAAudioDeviceListModel::FireDeviceChangedEvent(AudioDeviceID devID) {
250			DeviceMutex.Lock();
251			for(int i = 0; i < GetListenerCount(); i++) {
252			GetListener(i)->DeviceChanged(devID);
253			}
254			DeviceMutex.Unlock();
255			}
256
257			void CAAudioDeviceListModel::FireDeviceListChangedEvent() {
258			DeviceMutex.Lock();
259			for(int i = 0; i < GetListenerCount(); i++) {
260			GetListener(i)->DeviceListChanged();
261			}
262			DeviceMutex.Unlock();
263			}
264
265			void CAAudioDeviceListModel::FireDefaultOutputDeviceChangedEvent(AudioDeviceID newID) {
266			DeviceMutex.Lock();
267			for(int i = 0; i < GetListenerCount(); i++) {
268			GetListener(i)->DefaultOutputDeviceChanged(newID);
269			}
270			DeviceMutex.Unlock();
271			}
272
273			AudioDeviceID CAAudioDeviceListModel::GetDefaultOutputDeviceID() {
274			return DefaultOutputDeviceID;
275			}
276
277			UInt32 CAAudioDeviceListModel::GetOutputDeviceCount() {
278			DeviceMutex.Lock();
279			int size = outDevices.size();
280			DeviceMutex.Unlock();
281			return size;
282			}
283
284			CAAudioDeviceModel CAAudioDeviceListModel::GetOutputDevice(UInt32 Index) {
285			DeviceMutex.Lock();
286			if(Index < 0 \|\| Index >= GetOutputDeviceCount()) {
287			DeviceMutex.Unlock();
288			throw Exception("Device index out of bounds");
289			}
290
291			CAAudioDeviceModel dev = outDevices[Index];
292			DeviceMutex.Unlock();
293			return dev;
294			}
295
296			CAAudioDeviceModel CAAudioDeviceListModel::GetOutputDeviceByID(AudioDeviceID devID) {
297			DeviceMutex.Lock();
298			for(int i = 0; i < outDevices.size(); i++) {
299			if(outDevices[i].GetID() == devID) {
300			CAAudioDeviceModel dev = outDevices[i];
301			DeviceMutex.Unlock();
302			return dev;
303			}
304			}
305			DeviceMutex.Unlock();
306			throw Exception("Unknown audio device ID: " + ToString(devID));
307			}
308
309			UInt32 CAAudioDeviceListModel::GetOutputDeviceIndex(AudioDeviceID devID) {
310			DeviceMutex.Lock();
311			for(UInt32 i = 0; i < outDevices.size(); i++) {
312			if(outDevices[i].GetID() == devID) {
313			DeviceMutex.Unlock();
314			return i;
315			}
316			}
317			DeviceMutex.Unlock();
318			throw Exception("Unknown audio device ID: " + ToString(devID));
319			}
320
321			void CAAudioDeviceListModel::RescanDevices() {
322			DeviceMutex.Lock();
323			inDevices.clear();
324			outDevices.clear();
325
326			UInt32 outSize;
327			Boolean outWritable;
328
329			UpdateDefaultOutputDevice();
330
331			OSStatus res = AudioHardwareGetPropertyInfo (
332			kAudioHardwarePropertyDevices, &outSize, &outWritable
333			);
334
335			if(res) {
336			std::cerr << "Failed to get device list: " << res << std::endl;
337			DeviceMutex.Unlock();
338			return;
339			}
340
341			UInt32 deviceNumber = outSize / sizeof(AudioDeviceID);
342			if(deviceNumber < 1) {
343			std::cerr << "No audio devices found" << std::endl;
344			DeviceMutex.Unlock();
345			return;
346			}
347
348			if(deviceNumber * sizeof(AudioDeviceID) != outSize) {
349			std::cerr << "Invalid device size. This is a bug!" << std::endl;
350			DeviceMutex.Unlock();
351			return;
352			}
353
354			AudioDeviceID* devs = new AudioDeviceID[deviceNumber];
355
356			res = AudioHardwareGetProperty (
357			kAudioHardwarePropertyDevices, &outSize, devs
358			);
359
360			if(res) {
361			std::cerr << "Failed to get device IDs: " << res << std::endl;
362			delete [] devs;
363			DeviceMutex.Unlock();
364			return;
365			}
366
367			for(int i = 0; i < deviceNumber; i++) {
368			// TODO: for now skip devices which are not alive
369			outSize = sizeof(UInt32);
370			UInt32 isAlive = 0;
371
372			res = AudioDeviceGetProperty (
373			devs[i], 0, false,
374			kAudioDevicePropertyDeviceIsAlive,
375			&outSize, &isAlive
376			);
377
378			if(res \|\| !isAlive) continue;
379			///////
380
381			CAAudioDeviceModel dev(devs[i]);
382
383			CFStringRef tempStringRef = NULL;
384
385			// Get the name of the device
386			outSize = sizeof(CFStringRef);
387
388			res = AudioDeviceGetProperty (
389			devs[i], 0, false,
390			kAudioObjectPropertyName,
391			&outSize, &tempStringRef
392			);
393
394			dev.SetName(tempStringRef);
395			if(tempStringRef != NULL) CFRelease(tempStringRef);
396			///////
397
398			// Get the name of the device
399			outSize = sizeof(CFStringRef);
400
401			res = AudioDeviceGetProperty (
402			devs[i], 0, false,
403			kAudioDevicePropertyDeviceUID,
404			&outSize, &tempStringRef
405			);
406
407			dev.SetUID(tempStringRef);
408			if(tempStringRef != NULL) CFRelease(tempStringRef);
409			///////
410
411			GetChannels(&dev);
412			GetSamplerates(&dev);
413			if(dev.GetChannelNumber() > 0) outDevices.push_back(dev);
414			}
415
416			delete [] devs;
417			FireDeviceListChangedEvent();
418
419			/*for(int i = 0; i < GetOutputDeviceCount(); i++) {
420			std::cout << "Device ID: " << GetOutputDevice(i).GetID() << std::endl;
421			std::cout << "Device name: " << GetOutputDevice(i).GetName() << std::endl;
422			std::cout << "Device UID: " << GetOutputDevice(i).GetUID() << std::endl;
423			std::cout << "Channels: " << GetOutputDevice(i).GetChannelNumber() << std::endl;
424			std::cout << "Default samplerate: " << GetOutputDevice(i).GetDefaultSamplerate() << std::endl;
425
426			const std::vector<int> rates = GetOutputDevice(i).GetNominalSamplerates();
427			std::cout << "Nominal samplerates: " << std::endl;
428			for(int j = 0; j < rates.size(); j++) {
429			std::cout << "\t" << rates[j] << std::endl;
430			}
431			std::cout << std::endl;
432			}*/
433			DeviceMutex.Unlock();
434			}
435
436			void CAAudioDeviceListModel::UpdateDefaultOutputDevice() {
437			AudioDeviceID id;
438			UInt32 size = sizeof(AudioDeviceID);
439			OSStatus res = AudioHardwareGetProperty (
440			kAudioHardwarePropertyDefaultOutputDevice, &size, &id
441			);
442			if(res) std::cerr << "Failed to get default output device: " << res << std::endl;
443			else DefaultOutputDeviceID = id;
444			}
445
446			void CAAudioDeviceListModel::GetChannels(CAAudioDeviceModel* pDev) {
447			UInt32 outSize;
448			bool isInput = false;
449
450			OSStatus res = AudioDeviceGetPropertyInfo (
451			pDev->GetID(), 0, isInput,
452			kAudioDevicePropertyStreamConfiguration,
453			&outSize, NULL
454			);
455			if(res \|\| outSize == 0) {
456			if(res) std::cerr << "Failed to get stream config: " << res << std::endl;
457			return;
458			}
459
460			AudioBufferList* pBufferList = NULL;
461			pBufferList = (AudioBufferList*)malloc(outSize);
462			if(pBufferList == NULL) {
463			perror(NULL);
464			return;
465			}
466
467			res = AudioDeviceGetProperty (
468			pDev->GetID(), 0, isInput,
469			kAudioDevicePropertyStreamConfiguration,
470			&outSize, pBufferList
471			);
472
473			if(res = noErr) {
474			std::cerr << "Failed to get channel number: " << res << std::endl;
475			free(pBufferList);
476			return;
477			}
478
479			UInt32 chns = 0;
480			for(int i = 0; i < pBufferList->mNumberBuffers; i++) {
481			chns += pBufferList->mBuffers[i].mNumberChannels;
482			}
483
484			pDev->ChannelNumber = chns;
485
486			free(pBufferList);
487			}
488
489			/void CAAudioDeviceListModel::GetStreams(CAAudioDeviceModel pDev) {
490			UInt32 outSize = sizeof(AudioStreamID);
491
492			OSStatus res = AudioDeviceGetPropertyInfo (
493			pDev->GetID(), 0, false,
494			kAudioDevicePropertyStreams,
495			&outSize, NULL
496			);
497
498			if(res) {
499			std::cerr << "Failed to get device streams: " << res << std::endl;
500			return;
501			}
502
503			UInt32 streamNumber = outSize / sizeof(AudioStreamID);
504			if(streamNumber < 1) {
505			std::cerr << "No streams found" << std::endl;
506			return;
507			}
508
509			if(streamNumber * sizeof(AudioStreamID) != outSize) {
510			std::cerr << "Invalid AudioStreamID size. This is a bug!" << std::endl;
511			return;
512			}
513
514			AudioStreamID* streams = new AudioStreamID[streamNumber];
515
516			res = AudioDeviceGetProperty (
517			pDev->GetID(), 0, false,
518			kAudioDevicePropertyStreams,
519			&outSize, streams
520			);
521
522			if(res) {
523			std::cerr << "Failed to get stream IDs: " << res << std::endl;
524			delete [] streams;
525			return;
526			}
527
528			for(int i = 0; i < streamNumber; i++) {
529			UInt32 inStream;
530
531			res = AudioStreamGetProperty (
532			streams[i], 0, kAudioStreamPropertyDirection, &outSize, &inStream
533			);
534
535			if(res) {
536			std::cerr << "Failed to get stream direction: " << res << std::endl;
537			continue;
538			}
539
540			//pDev->AudioStreams.push_back(CAAudioStream(inStream, chns));
541			}
542
543			delete [] streams;
544			}*/
545
546			void CAAudioDeviceListModel::GetSamplerates(CAAudioDeviceModel* pDev) {
547			UInt32 outSize;
548
549			// Get current nominal sample rate
550			outSize = sizeof(Float64);
551			Float64 srate;
552
553			OSStatus res = AudioDeviceGetProperty (
554			pDev->GetID(), 0, false,
555			kAudioDevicePropertyNominalSampleRate,
556			&outSize, &srate
557			);
558
559			if(res) std::cerr << "Failed to get default samplerate: " << res << std::endl;
560			else pDev->DefaultSamplerate = srate;
561			///////
562
563			res = AudioDeviceGetPropertyInfo (
564			pDev->GetID(), 0, false,
565			kAudioDevicePropertyAvailableNominalSampleRates,
566			&outSize, NULL
567			);
568
569			if(res) {
570			std::cerr << "Failed to get nominal samplerates: " << res << std::endl;
571			return;
572			}
573
574			UInt32 rangeNumber = outSize / sizeof(AudioValueRange);
575			if(rangeNumber < 1) {
576			std::cerr << "No nominal samplerates found" << std::endl;
577			return;
578			}
579
580			if(rangeNumber * sizeof(AudioValueRange) != outSize) {
581			std::cerr << "Invalid AudioValueRange size. This is a bug!" << std::endl;
582			return;
583			}
584
585			AudioValueRange* ranges = new AudioValueRange[rangeNumber];
586
587			res = AudioDeviceGetProperty (
588			pDev->GetID(), 0, false,
589			kAudioDevicePropertyAvailableNominalSampleRates,
590			&outSize, ranges
591			);
592
593			if(res) {
594			std::cerr << "Failed to get samplerate ranges: " << res << std::endl;
595			delete [] ranges;
596			return;
597			}
598
599			for(int i = 0; i < rangeNumber; i++) {
600			// FIXME: might be ranges of valid samplerates
601			UInt32 min = (UInt32)ranges[i].mMinimum;
602			UInt32 max = (UInt32)ranges[i].mMaximum;
603			pDev->NominalSamplerates.push_back(min);
604			if(min != max) pDev->NominalSamplerates.push_back(max);
605			}
606
607			delete [] ranges;
608			}
609			} // namespace LinuxSampler