PLATFORM_API_MacOSX_Utils.cpp

/*
 * 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;
}