| /* |
| * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code 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 |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| //#define USE_TRACE |
| //#define USE_ERROR |
| |
| #include "PLATFORM_API_MacOSX_Utils.h" |
| |
| int MACOSX_DAUDIO_Init() { |
| static int initialized = 0; |
| if (!initialized) { |
| CFRunLoopRef runLoop = NULL; |
| |
| OSStatus err = SetAudioObjectProperty(kAudioObjectSystemObject, kAudioObjectPropertyScopeGlobal, |
| kAudioHardwarePropertyRunLoop, sizeof(CFRunLoopRef), &runLoop); |
| |
| if (err) { |
| OS_ERROR0(err, "MACOSX_DAUDIO_Init(kAudioHardwarePropertyRunLoop)"); |
| } else { |
| TRACE0("MACOSX_DAUDIO_Init(kAudioHardwarePropertyRunLoop): OK\n"); |
| initialized = 1; |
| } |
| } |
| return initialized; |
| } |
| |
| DeviceList::DeviceList(): count(0), devices(NULL) { |
| MACOSX_DAUDIO_Init(); |
| |
| AudioObjectPropertyAddress address = {kAudioHardwarePropertyDevices, |
| kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster}; |
| OSStatus err = AudioObjectAddPropertyListener(kAudioObjectSystemObject, &address, NotificationCallback, this); |
| if (err) { |
| OS_ERROR0(err, "AudioObjectAddPropertyListener(kAudioHardwarePropertyDevices)"); |
| } else { |
| TRACE0("AudioObjectAddPropertyListener(kAudioHardwarePropertyDevices): OK\n"); |
| } |
| } |
| |
| DeviceList::~DeviceList() { |
| Free(); |
| |
| AudioObjectPropertyAddress address = {kAudioHardwarePropertyDevices, |
| kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster}; |
| AudioObjectRemovePropertyListener(kAudioObjectSystemObject, &address, NotificationCallback, this); |
| } |
| |
| OSStatus DeviceList::Refresh() { |
| MutexLock::Locker locker(lock); |
| Free(); |
| |
| OSStatus err; |
| UInt32 size; |
| err = GetAudioObjectPropertySize(kAudioObjectSystemObject, kAudioObjectPropertyScopeGlobal, kAudioHardwarePropertyDevices, &size); |
| if (err == noErr) { |
| devices = (AudioDeviceID *)malloc(size); |
| err = GetAudioObjectProperty(kAudioObjectSystemObject, kAudioObjectPropertyScopeGlobal, kAudioHardwarePropertyDevices, &size, devices); |
| if (err == noErr) { |
| count = size/sizeof(AudioDeviceID); |
| } |
| } |
| if (err) { |
| OS_ERROR0(err, "DeviceList::Refresh"); |
| Free(); |
| } |
| #ifdef USE_TRACE |
| TRACE1("<<DeviceList::Refresh, %d devices {", count); |
| for (int i=0; i<count; i++) { |
| if (i > 0) |
| TRACE0(", "); |
| TRACE1("0x%x", (int)devices[i]); |
| } |
| TRACE0("}\n"); |
| #endif |
| |
| return err; |
| } |
| |
| int DeviceList::GetCount() { |
| MutexLock::Locker locker(lock); |
| return count; |
| } |
| |
| AudioDeviceID DeviceList::GetDeviceID(int index) { |
| MutexLock::Locker locker(lock); |
| return index < 0 ? 0 : index >= count ? 0 : devices[index]; |
| } |
| |
| bool DeviceList::GetDeviceInfo(int index, AudioDeviceID *pDeviceID, int stringLength, char *name, char *vendor, char *description, char *version) { |
| MutexLock::Locker locker(lock); |
| if (index < 0 || index >= count) { |
| return false; |
| } |
| |
| AudioDeviceID deviceID = devices[index]; |
| if (pDeviceID != NULL) |
| *pDeviceID = deviceID; |
| |
| OSStatus err = noErr; |
| |
| if (name != NULL || description != NULL) { |
| CFStringRef cfName = NULL; |
| err = GetAudioObjectProperty(deviceID, kAudioObjectPropertyScopeGlobal, |
| kAudioObjectPropertyName, sizeof(cfName), &cfName, 1); |
| if (err == noErr) { |
| if (name != NULL) |
| CFStringGetCString(cfName, name, stringLength, kCFStringEncodingUTF8); |
| if (description) |
| CFStringGetCString(cfName, description, stringLength, kCFStringEncodingUTF8); |
| CFRelease(cfName); |
| } |
| } |
| |
| if (vendor != NULL) { |
| CFStringRef cfManufacturer = NULL; |
| err = GetAudioObjectProperty(deviceID, kAudioObjectPropertyScopeGlobal, |
| kAudioObjectPropertyManufacturer, sizeof(cfManufacturer), &cfManufacturer, 1); |
| if (err == noErr) { |
| CFStringGetCString(cfManufacturer, vendor, stringLength, kCFStringEncodingUTF8); |
| CFRelease(cfManufacturer); |
| } |
| } |
| |
| return true; |
| } |
| |
| void DeviceList::Free() { |
| if (devices != NULL) { |
| free(devices); |
| devices = NULL; |
| count = 0; |
| } |
| } |
| |
| /*static*/ |
| OSStatus DeviceList::NotificationCallback(AudioObjectID inObjectID, |
| UInt32 inNumberAddresses, const AudioObjectPropertyAddress inAddresses[], void *inClientData) |
| { |
| DeviceList *pThis = (DeviceList *)inClientData; |
| |
| for (UInt32 i=0; i<inNumberAddresses; i++) { |
| switch (inAddresses[i].mSelector) { |
| case kAudioHardwarePropertyDevices: |
| TRACE0("NOTIFICATION: kAudioHardwarePropertyDevices\n"); |
| break; |
| } |
| } |
| |
| return noErr; |
| } |
| |
| |
| |
| AudioDeviceID GetDefaultDevice(int isSource) { |
| AudioDeviceID deviceID; |
| OSStatus err = GetAudioObjectProperty(kAudioObjectSystemObject, kAudioObjectPropertyScopeGlobal, |
| isSource ? kAudioHardwarePropertyDefaultOutputDevice : kAudioHardwarePropertyDefaultInputDevice, |
| sizeof(deviceID), &deviceID, 1); |
| if (err) { |
| OS_ERROR1(err, "GetDefaultDevice(isSource=%d)", isSource); |
| return 0; |
| } |
| return deviceID; |
| } |
| |
| int GetChannelCount(AudioDeviceID deviceID, int isSource) { |
| int result = 0; |
| OSStatus err; |
| UInt32 size, i; |
| AudioObjectPropertyScope scope = isSource ? kAudioDevicePropertyScopeOutput : kAudioDevicePropertyScopeInput; |
| |
| err = GetAudioObjectPropertySize(deviceID, scope, kAudioDevicePropertyStreamConfiguration, &size); |
| if (err) { |
| OS_ERROR2(err, "GetChannelCount(getSize), deviceID=0x%x, isSource=%d", (int)deviceID, isSource); |
| } else { |
| AudioBufferList *pBufferList = (AudioBufferList *)malloc(size); |
| memset(pBufferList, 0, size); |
| err = GetAudioObjectProperty(deviceID, scope, kAudioDevicePropertyStreamConfiguration, &size, pBufferList); |
| if (err == noErr) { |
| for (i=0; i<pBufferList->mNumberBuffers; i++) { |
| result += pBufferList->mBuffers[i].mNumberChannels; |
| } |
| } else { |
| OS_ERROR2(err, "GetChannelCount(getData), deviceID=0x%x, isSource=%d", (int)deviceID, isSource); |
| } |
| free(pBufferList); |
| } |
| TRACE2("GetChannelCount (deviceID=0x%x): total %d channels\n", (int)deviceID, result); |
| return result; |
| } |
| |
| float GetSampleRate(AudioDeviceID deviceID, int isSource) { |
| Float64 result; |
| AudioObjectPropertyScope scope = isSource ? kAudioDevicePropertyScopeOutput : kAudioDevicePropertyScopeInput; |
| OSStatus err = GetAudioObjectProperty(deviceID, scope, kAudioDevicePropertyActualSampleRate, sizeof(result), &result, 1); |
| if (err) { |
| OS_ERROR2(err, "GetSampleRate(ActualSampleRate), deviceID=0x%x, isSource=%d", (int)deviceID, isSource); |
| // try to get NominalSampleRate |
| err = GetAudioObjectProperty(deviceID, scope, kAudioDevicePropertyNominalSampleRate, sizeof(result), &result, 1); |
| if (err) { |
| OS_ERROR2(err, "GetSampleRate(NominalSampleRate), deviceID=0x%x, isSource=%d", (int)deviceID, isSource); |
| return 0; |
| } |
| } |
| return (float)result; |
| } |
| |
| |
| OSStatus GetAudioObjectPropertySize(AudioObjectID object, AudioObjectPropertyScope scope, AudioObjectPropertySelector prop, UInt32 *size) |
| { |
| const AudioObjectPropertyAddress address = {prop, scope, kAudioObjectPropertyElementMaster}; |
| OSStatus err; |
| |
| err = AudioObjectGetPropertyDataSize(object, &address, 0, NULL, size); |
| |
| return err; |
| } |
| |
| OSStatus GetAudioObjectProperty(AudioObjectID object, AudioObjectPropertyScope scope, AudioObjectPropertySelector prop, UInt32 *size, void *data) |
| { |
| const AudioObjectPropertyAddress address = {prop, scope, kAudioObjectPropertyElementMaster}; |
| OSStatus err; |
| |
| err = AudioObjectGetPropertyData(object, &address, 0, NULL, size, data); |
| |
| return err; |
| } |
| |
| OSStatus GetAudioObjectProperty(AudioObjectID object, AudioObjectPropertyScope scope, AudioObjectPropertySelector prop, UInt32 size, void *data, int checkSize) |
| { |
| const AudioObjectPropertyAddress address = {prop, scope, kAudioObjectPropertyElementMaster}; |
| UInt32 oldSize = size; |
| OSStatus err; |
| |
| err = AudioObjectGetPropertyData(object, &address, 0, NULL, &size, data); |
| |
| if (!err && checkSize && size != oldSize) |
| return kAudioHardwareBadPropertySizeError; |
| return err; |
| } |
| |
| // wrapper for AudioObjectSetPropertyData (kAudioObjectPropertyElementMaster) |
| OSStatus SetAudioObjectProperty(AudioObjectID object, AudioObjectPropertyScope scope, AudioObjectPropertySelector prop, UInt32 size, void *data) |
| { |
| AudioObjectPropertyAddress address = {prop, scope, kAudioObjectPropertyElementMaster}; |
| |
| OSStatus err = AudioObjectSetPropertyData(object, &address, 0, NULL, size, data); |
| |
| return err; |
| } |