mirror of
https://github.com/openjdk/jdk.git
synced 2026-01-30 21:18:25 +00:00
273 lines
9.7 KiB
C++
273 lines
9.7 KiB
C++
/*
|
|
* 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;
|
|
}
|