/*

 * Copyright (c) 2003, 2018, 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_ERROR

//#define USE_TRACE

#include <CoreAudio/CoreAudio.h>

#include <IOKit/audio/IOAudioTypes.h>

#include "PLATFORM_API_MacOSX_Utils.h"

extern "C" {

#include "Ports.h"

}

#if USE_PORTS == TRUE

/* If a device has the only AudioStream in the scope (input or output),

 * PortMixer provides a single Port, using the stream kAudioStreamPropertyTerminalType

 * property value to determine Port.Type (PORT_GetPortType function).

 * If the device has several (more than 1) AudioStreams, there are 2 ways to represent Ports:

 * 1. (HALLab-style) single Port which represents all device channels with

 *    "master volume" and (if number of channel is 2) "master balance"; if AudioDevice

 *    does not provide "master" controls, implement "virtual master" controls.

 *    Port.Type is PORT_SRC_UNKNOWN or PORT_DST_UNKNOWN.

 * 2. provide a separate Port for every AudioStream (with appropriate Port.Type);

 *

 * AudioHardware.h claims that AudioStream objects share AudioControl objects with their owning AudioDevice.

 * In practice 10.7 OSX drivers (built-in devices, USB audio) implement AudioControl only for AudioDevice.

 * For now 1st way is implemented (2nd way can be better if AudioStreams provide AudioControls).

 */

static DeviceList deviceCache;

#define FourCC2Str(n) ((char[5]){(char)(n >> 24), (char)(n >> 16), (char)(n >> 8), (char)(n), 0})

// CoreAudio's AudioControl

struct AudioControl {

    AudioObjectID controlID;

    AudioClassID classID;               // kAudioVolumeControlClassID etc.

    AudioObjectPropertyScope scope;     // input, output

    AudioObjectPropertyElement channel; // master = 0, channels = 1 2 ...

};

// Controls for Java

// PortMixer do all memory management (alloc/free audioControls)

struct PortControl {

    enum ControlType {

        Volume,     // manages single or multiple volume AudioControl

        Mute,       // manages single or multiple mute AudioControls

        Balance     // "virtual" control, manages 2 volume AudioControls (only for stereo lines)

    };

    ControlType type;

    int controlCount;

    AudioControl **audioControls;

    PortControl *next;  // to organize PortControl list

};

// represents line (port) for PortMixer

// used for PORT_GetPortCount/PORT_GetPortType/PORT_GetPortName functions

struct PortLine {

    AudioObjectPropertyScope scope;

    // if the device has several AudioStreams in the scope, streamID == 0

    AudioStreamID streamID;

};

struct PortMixer {

    AudioDeviceID deviceID;

    int portCount;

    PortLine ports[2]; // maximum 2 lines - 1 for input & 1 for output

    int deviceControlCount; // -1 means "not initialized"

    AudioControl *deviceControls;

    PortControl *portControls;  // list of port controls

    bool listenersInstalled;

};

void RemoveChangeListeners(PortMixer *mixer);   // forward declaration

OSStatus ChangeListenerProc(AudioObjectID inObjectID, UInt32 inNumberAddresses,

        const AudioObjectPropertyAddress inAddresses[], void *inClientData)

{

    PortMixer *mixer = (PortMixer *)inClientData;

    OSStatus err = noErr;

    UInt32 size;

    bool invalid = false;

    for (UInt32 i = 0; i < inNumberAddresses; i++) {

        switch (inAddresses[i].mSelector) {

        case kAudioHardwarePropertyDevices:

            // check if the device has been removed

            err = GetAudioObjectPropertySize(kAudioObjectSystemObject, kAudioObjectPropertyScopeGlobal,

                kAudioHardwarePropertyDevices, &size);

            if (err == noErr) {

                int count = size/sizeof(AudioDeviceID);

                AudioDeviceID devices[count];

                err = GetAudioObjectProperty(kAudioObjectSystemObject, kAudioObjectPropertyScopeGlobal,

                    kAudioHardwarePropertyDevices, count*sizeof(AudioDeviceID), devices, 1);

                if (err == noErr) {

                    bool found = false;

                    for (int j = 0; j < count; j++) {

                        if (devices[j] == mixer->deviceID) {

                            found = true;

                            break;

                        }

                    }

                    if (!found) {

                        invalid = true;

                    }

                }

            }

            break;

        case kAudioObjectPropertyOwnedObjects:

        case kAudioDevicePropertyDeviceHasChanged:

            // ensure all _used_ AudioControl are valid

            err = GetAudioObjectPropertySize(mixer->deviceID, kAudioObjectPropertyScopeGlobal,

                kAudioObjectPropertyOwnedObjects, &size);

            if (err == noErr) {

                int count = size / sizeof(AudioObjectID);

                AudioObjectID controlIDs[count];

                err = GetAudioObjectProperty(mixer->deviceID, kAudioObjectPropertyScopeGlobal,

                    kAudioObjectPropertyOwnedObjects, count * sizeof(AudioObjectID), &controlIDs, 1);

                if (err == noErr) {

                    for (PortControl *ctrl = mixer->portControls; ctrl != NULL; ctrl = ctrl->next) {

                        for (int i = 0; i < ctrl->controlCount; i++) {

                            bool found = false;

                            for (int j = 0; j < count; j++) {

                                if (ctrl->audioControls[i]->controlID == controlIDs[j]) {

                                    found = true;

                                    break;

                                }

                            }

                            if (!found) {

                                invalid = true;

                                break;  // goto next control

                            }

                        }

                    }

                }

            }

        }

    }

    if (invalid) {

        TRACE1("PortMixer (deviceID=0x%x) becomes invalid", (int)mixer->deviceID);

        // invalidate all controls

        for (int i=0; i<mixer->deviceControlCount; i++) {

            mixer->deviceControls[i].controlID = 0;

        }

        RemoveChangeListeners(mixer);

    }

    return noErr;

}

const AudioObjectPropertyAddress changeListenersAddresses[] = {

    {kAudioHardwarePropertyDevices, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster},

    {kAudioObjectPropertyOwnedObjects, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster},

    {kAudioDevicePropertyDeviceHasChanged, kAudioObjectPropertyScopeGlobal, kAudioObjectPropertyElementMaster}

};

void AddChangeListeners(PortMixer *mixer) {

    if (!mixer->listenersInstalled) {

        for (size_t i=0; i<sizeof(changeListenersAddresses)/sizeof(changeListenersAddresses[0]); i++) {

            AudioObjectAddPropertyListener(mixer->deviceID, &changeListenersAddresses[i], ChangeListenerProc, mixer);

        }

        mixer->listenersInstalled = true;

    }

}

void RemoveChangeListeners(PortMixer *mixer) {

    if (mixer->listenersInstalled) {

        for (size_t i=0; i<sizeof(changeListenersAddresses)/sizeof(changeListenersAddresses[0]); i++) {

            AudioObjectRemovePropertyListener(mixer->deviceID, &changeListenersAddresses[i], ChangeListenerProc, mixer);

        }

        mixer->listenersInstalled = false;

    }

}

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

// functions from Port.h

INT32 PORT_GetPortMixerCount() {

    deviceCache.Refresh();

    int count = deviceCache.GetCount();

    TRACE1("<<PORT_GetPortMixerCount = %d\n", count);

    return count;

}

INT32 PORT_GetPortMixerDescription(INT32 mixerIndex, PortMixerDescription* mixerDescription) {

    bool result = deviceCache.GetDeviceInfo(mixerIndex, NULL, PORT_STRING_LENGTH,

            mixerDescription->name, mixerDescription->vendor, mixerDescription->description, mixerDescription->version);

    return result ? TRUE : FALSE;

}

void* PORT_Open(INT32 mixerIndex) {

    TRACE1("\n>>PORT_Open (mixerIndex=%d)\n", (int)mixerIndex);

    PortMixer *mixer = (PortMixer *)calloc(1, sizeof(PortMixer));

    mixer->deviceID = deviceCache.GetDeviceID(mixerIndex);

    if (mixer->deviceID != 0) {

        mixer->deviceControlCount = -1; // not initialized

        // fill mixer->ports (and mixer->portCount)

        for (int i=0; i<2; i++) {

            OSStatus err;

            UInt32 size = 0;

            AudioObjectPropertyScope scope =

                (i == 0) ? kAudioDevicePropertyScopeInput : kAudioDevicePropertyScopeOutput;

            err = GetAudioObjectPropertySize(mixer->deviceID, scope, kAudioDevicePropertyStreams, &size);

            if (err || size == 0) {

                continue;

            }

            if (size / sizeof(AudioStreamID) == 1) {

                // the device has the only AudioStream

                AudioStreamID streamID;

                err = GetAudioObjectProperty(mixer->deviceID, scope, kAudioDevicePropertyStreams,

                    sizeof(streamID), &streamID, 1);

                if (err) {

                    continue;

                }

                mixer->ports[mixer->portCount].streamID = streamID;

            } else {

                // the device has several AudioStreams in the scope

                mixer->ports[mixer->portCount].streamID = 0;

            }

            mixer->ports[mixer->portCount].scope = scope;

            mixer->portCount++;

        }

    }

    TRACE2("<<PORT_Open (mixerIndex=%d) %p\n", mixerIndex, mixer);

    return mixer;

}

void PORT_Close(void* id) {

    TRACE1(">>PORT_Close %p\n", id);

    PortMixer *mixer = (PortMixer *)id;

    if (mixer) {

        RemoveChangeListeners(mixer);

        while (mixer->portControls != NULL) {

            PortControl *control2delete = mixer->portControls;

            mixer->portControls = control2delete->next;

            if (control2delete->audioControls != NULL) {

                free(control2delete->audioControls);

            }

            free(control2delete);

        }

        if (mixer->deviceControls) {

            free(mixer->deviceControls);

        }

        free(mixer);

    }

    TRACE1("<<PORT_Close %p\n", mixer);

}

INT32 PORT_GetPortCount(void* id) {

    PortMixer *mixer = (PortMixer *)id;

    int result = mixer->portCount;

    TRACE1("<<PORT_GetPortCount = %d\n", result);

    return result;

}

INT32 PORT_GetPortType(void* id, INT32 portIndex) {

    PortMixer *mixer = (PortMixer *)id;

    INT32 ret = 0;

    if (portIndex < 0 || portIndex >= mixer->portCount) {

        ERROR1("PORT_GetPortType: line (portIndex = %d) not found\n", portIndex);

        return 0;

    }

    AudioObjectPropertyScope scope = mixer->ports[portIndex].scope;

    AudioStreamID streamID = mixer->ports[portIndex].streamID;

    if (streamID != 0) {

        UInt32 terminalType;

        OSStatus err = GetAudioObjectProperty(streamID, kAudioObjectPropertyScopeGlobal,

            kAudioStreamPropertyTerminalType, sizeof(terminalType), &terminalType, 1);

        if (err) {

            OS_ERROR1(err, "PORT_GetPortType(kAudioStreamPropertyTerminalType), portIndex=%d", portIndex);

            return 0;

        }

        // Note that kAudioStreamPropertyTerminalType actually returns values from

        // IOAudioTypes.h, not the defined kAudioStreamTerminalType*.

        TRACE4("PORT_GetPortType (portIndex=%d), scope=%s, termType=0x%04x (%s)\n",

            (int)portIndex, FourCC2Str(scope), (int)terminalType, FourCC2Str(terminalType));

        switch (terminalType) {

        case INPUT_MICROPHONE:

            ret = PORT_SRC_MICROPHONE;

            break;

        case OUTPUT_SPEAKER:

            ret = PORT_DST_SPEAKER;

            break;

        case OUTPUT_HEADPHONES:

            ret = PORT_DST_HEADPHONE;

            break;

        case EXTERNAL_LINE_CONNECTOR:

            ret = scope == kAudioDevicePropertyScopeInput ? PORT_SRC_LINE_IN : PORT_DST_LINE_OUT;

            break;

        default:

            TRACE1("  unknown output terminal type %#x\n", terminalType);

        }

    } else {

        TRACE0("  PORT_GetPortType: multiple streams\n");

    }

    if (ret == 0) {

        // if the type not detected, return "common type"

        ret = scope == kAudioDevicePropertyScopeInput ? PORT_SRC_UNKNOWN : PORT_DST_UNKNOWN;

    }

    TRACE2("<<PORT_GetPortType (portIndex=%d) = %d\n", portIndex, ret);

    return ret;

}

INT32 PORT_GetPortName(void* id, INT32 portIndex, char* name, INT32 len) {

    PortMixer *mixer = (PortMixer *)id;

    name[0] = 0;    // for safety

    if (portIndex < 0 || portIndex >= mixer->portCount) {

        ERROR1("PORT_GetPortName: line (portIndex = %d) not found\n", portIndex);

        return FALSE;

    }

    AudioStreamID streamID = mixer->ports[portIndex].streamID;

    CFStringRef cfname = NULL;

    if (streamID != 0) {

        OSStatus err = GetAudioObjectProperty(streamID, kAudioObjectPropertyScopeGlobal,

            kAudioObjectPropertyName, sizeof(cfname), &cfname, 1);

        if (err && err != kAudioHardwareUnknownPropertyError) {

            OS_ERROR1(err, "PORT_GetPortName(stream name), portIndex=%d", portIndex);

            return FALSE;

        }

    }

    if (!cfname) {

        // use the device's name if the stream has no name (usually the case)

        // or the device has several AudioStreams

        OSStatus err = GetAudioObjectProperty(mixer->deviceID, kAudioObjectPropertyScopeGlobal,

            kAudioObjectPropertyName, sizeof(cfname), &cfname, 1);

        if (err) {

            OS_ERROR1(err, "PORT_GetPortName(device name), portIndex=%d", portIndex);

            return FALSE;

        }

    }

    if (cfname) {

        CFStringGetCString(cfname, name, len, kCFStringEncodingUTF8);

        CFRelease(cfname);

    }

    TRACE2("<<PORT_GetPortName (portIndex = %d) = %s\n", portIndex, name);

    return TRUE;

}

// counts number of valid (non-NULL) elements in the array of AudioControls

static int ValidControlCount(AudioControl **arr, int offset, int len) {

    int result = 0;

    int end = offset + len;

    for (int i=offset; i<end; i++) {

        if (arr[i] != NULL)

            result++;

    }

    return result;

}

// returns java control

static void* CreatePortControl(PortMixer *mixer, PortControlCreator *creator, PortControl::ControlType type,

                               AudioControl **audioControls, int offset, int len) {

    void *jControl = NULL;

    PortControl *control = (PortControl *)calloc(1, sizeof(PortControl));

    float precision = 0.01;

    control->type = type;

    control->controlCount = len;

    control->audioControls = (AudioControl **)malloc(len * sizeof(AudioControl *));

    memcpy(control->audioControls, audioControls + offset, len * sizeof(AudioControl *));

    switch (control->type) {

    case PortControl::Volume:

        jControl = creator->newFloatControl(creator, control, CONTROL_TYPE_VOLUME, 0, 1, precision, "");

        break;

    case PortControl::Mute:

        jControl = creator->newBooleanControl(creator, control, CONTROL_TYPE_MUTE);

        break;

    case PortControl::Balance:

        jControl = creator->newFloatControl(creator, control, CONTROL_TYPE_BALANCE, -1, 1, precision, "");

        break;

    };

    if (jControl == NULL) {

        ERROR0("CreatePortControl: javaControl was not created\n");

        free(control->audioControls);

        free(control);

        return NULL;

    }

    // add the control to mixer control list;

    control->next = mixer->portControls;

    mixer->portControls = control;

    return jControl;

}

void PORT_GetControls(void* id, INT32 portIndex, PortControlCreator* creator) {

    PortMixer *mixer = (PortMixer *)id;

    TRACE1(">>PORT_GetControls (portIndex = %d)\n", portIndex);

    if (portIndex < 0 || portIndex >= mixer->portCount) {

        ERROR1("<<PORT_GetControls: line (portIndex = %d) not found\n", portIndex);

        return;

    }

    PortLine *port = &(mixer->ports[portIndex]);

    if (mixer->deviceControlCount < 0) {    // not initialized

        OSStatus err;

        UInt32 size;

        // deviceControlCount is overestimated

        // because we don't actually filter by if the owned objects are controls

        err = GetAudioObjectPropertySize(mixer->deviceID, kAudioObjectPropertyScopeGlobal,

            kAudioObjectPropertyOwnedObjects, &size);

        if (err) {

            OS_ERROR1(err, "PORT_GetControls (portIndex = %d) get OwnedObject size", portIndex);

        } else {

            mixer->deviceControlCount = size / sizeof(AudioObjectID);

            TRACE1("  PORT_GetControls: detected %d owned objects\n", mixer->deviceControlCount);

            AudioObjectID controlIDs[mixer->deviceControlCount];

            err = GetAudioObjectProperty(mixer->deviceID, kAudioObjectPropertyScopeGlobal,

                kAudioObjectPropertyOwnedObjects, sizeof(controlIDs), controlIDs, 1);

            if (err) {

                OS_ERROR1(err, "PORT_GetControls (portIndex = %d) get OwnedObject values", portIndex);

            } else {

                mixer->deviceControls = (AudioControl *)calloc(mixer->deviceControlCount, sizeof(AudioControl));

                for (int i = 0; i < mixer->deviceControlCount; i++) {

                    AudioControl *control = &mixer->deviceControls[i];

                    control->controlID = controlIDs[i];

                    OSStatus err1 = GetAudioObjectProperty(control->controlID, kAudioObjectPropertyScopeGlobal,

                        kAudioObjectPropertyClass, sizeof(control->classID), &control->classID, 1);

                    OSStatus err2 = GetAudioObjectProperty(control->controlID, kAudioObjectPropertyScopeGlobal,

                        kAudioControlPropertyScope, sizeof(control->scope), &control->scope, 1);

                    OSStatus err3 = GetAudioObjectProperty(control->controlID, kAudioObjectPropertyScopeGlobal,

                        kAudioControlPropertyElement, sizeof(control->channel), &control->channel, 1);

                    if (err1 || err2 || err3) { // not a control or other error

                        control->classID = 0;

                        continue;

                    }

                    TRACE4("- control 0x%x, class='%s', scope='%s', channel=%d\n",

                        control->controlID, FourCC2Str(control->classID), FourCC2Str(control->scope), control->channel);

                }

            }

        }

    }

    if (mixer->deviceControlCount <= 0) {

        TRACE1("<<PORT_GetControls (portIndex = %d): no owned AudioControls\n", portIndex);

        return;

    }

    int totalChannels = GetChannelCount(mixer->deviceID, port->scope == kAudioDevicePropertyScopeOutput ? 1 : 0);

    // collect volume and mute controls

    AudioControl* volumeControls[totalChannels+1];  // 0 - for master channel