/*

 * Copyright (c) 2002, 2016, 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 "Ports.h"

#include "PLATFORM_API_SolarisOS_Utils.h"

#if USE_PORTS == TRUE

#define MONITOR_GAIN_STRING "Monitor Gain"

#define ALL_TARGET_PORT_COUNT 6

// define the following to not use audio_prinfo_t.mod_ports

#define SOLARIS7_COMPATIBLE

// Solaris audio defines

static int targetPorts[ALL_TARGET_PORT_COUNT] = {

    AUDIO_SPEAKER,

    AUDIO_HEADPHONE,

    AUDIO_LINE_OUT,

    AUDIO_AUX1_OUT,

    AUDIO_AUX2_OUT,

    AUDIO_SPDIF_OUT

};

static char* targetPortNames[ALL_TARGET_PORT_COUNT] = {

    "Speaker",

    "Headphone",

    "Line Out",

    "AUX1 Out",

    "AUX2 Out",

    "SPDIF Out"

};

// defined in Ports.h

static int targetPortJavaSoundMapping[ALL_TARGET_PORT_COUNT] = {

    PORT_DST_SPEAKER,

    PORT_DST_HEADPHONE,

    PORT_DST_LINE_OUT,

    PORT_DST_UNKNOWN,

    PORT_DST_UNKNOWN,

    PORT_DST_UNKNOWN,

};

#define ALL_SOURCE_PORT_COUNT 7

// Solaris audio defines

static int sourcePorts[ALL_SOURCE_PORT_COUNT] = {

    AUDIO_MICROPHONE,

    AUDIO_LINE_IN,

    AUDIO_CD,

    AUDIO_AUX1_IN,

    AUDIO_AUX2_IN,

    AUDIO_SPDIF_IN,

    AUDIO_CODEC_LOOPB_IN

};

static char* sourcePortNames[ALL_SOURCE_PORT_COUNT] = {

    "Microphone In",

    "Line In",

    "Compact Disc In",

    "AUX1 In",

    "AUX2 In",

    "SPDIF In",

    "Internal Loopback"

};

// Ports.h defines

static int sourcePortJavaSoundMapping[ALL_SOURCE_PORT_COUNT] = {

    PORT_SRC_MICROPHONE,

    PORT_SRC_LINE_IN,

    PORT_SRC_COMPACT_DISC,

    PORT_SRC_UNKNOWN,

    PORT_SRC_UNKNOWN,

    PORT_SRC_UNKNOWN,

    PORT_SRC_UNKNOWN

};

struct tag_PortControlID;

typedef struct tag_PortInfo {

    int fd;                    // file descriptor of the pseudo device

    audio_info_t audioInfo;

    // ports

    int targetPortCount;

    int sourcePortCount;

    // indexes to sourcePorts/targetPorts

    // contains first target ports, then source ports

    int ports[ALL_TARGET_PORT_COUNT + ALL_SOURCE_PORT_COUNT];

    // controls

    int maxControlCount;       // upper bound of number of controls

    int usedControlIDs;        // number of items already filled in controlIDs

    struct tag_PortControlID* controlIDs; // the control IDs themselves

} PortInfo;

#define PORT_CONTROL_TYPE_PLAY          0x4000000

#define PORT_CONTROL_TYPE_RECORD        0x8000000

#define PORT_CONTROL_TYPE_SELECT_PORT   1

#define PORT_CONTROL_TYPE_GAIN          2

#define PORT_CONTROL_TYPE_BALANCE       3

#define PORT_CONTROL_TYPE_MONITOR_GAIN  10

#define PORT_CONTROL_TYPE_OUTPUT_MUTED  11

#define PORT_CONTROL_TYPE_PLAYRECORD_MASK PORT_CONTROL_TYPE_PLAY | PORT_CONTROL_TYPE_RECORD

#define PORT_CONTROL_TYPE_MASK 0xFFFFFF

typedef struct tag_PortControlID {

    PortInfo*  portInfo;

    INT32                 controlType;  // PORT_CONTROL_TYPE_XX

    uint_t                port;

} PortControlID;

///// implemented functions of Ports.h

    return (INT32) getAudioDeviceCount();

}

INT32 PORT_GetPortMixerDescription(INT32 mixerIndex, PortMixerDescription* description) {

    AudioDeviceDescription desc;

    if (getAudioDeviceDescriptionByIndex(mixerIndex, &desc, TRUE)) {

        strncpy(description->name, desc.name, PORT_STRING_LENGTH-1);

        description->name[PORT_STRING_LENGTH-1] = 0;

        strncpy(description->vendor, desc.vendor, PORT_STRING_LENGTH-1);

        description->vendor[PORT_STRING_LENGTH-1] = 0;

        strncpy(description->version, desc.version, PORT_STRING_LENGTH-1);

        description->version[PORT_STRING_LENGTH-1] = 0;

        /*strncpy(description->description, desc.description, PORT_STRING_LENGTH-1);*/

        strncpy(description->description, "Solaris Ports", PORT_STRING_LENGTH-1);

        description->description[PORT_STRING_LENGTH-1] = 0;

        return TRUE;

    }

    return FALSE;

}

void* PORT_Open(INT32 mixerIndex) {

    PortInfo* info = NULL;

    int fd = -1;

    AudioDeviceDescription desc;

    int success = FALSE;

    TRACE0("PORT_Open\n");

    if (getAudioDeviceDescriptionByIndex(mixerIndex, &desc, FALSE)) {

        fd = open(desc.pathctl, O_RDWR);

    }

    if (fd < 0) {

        ERROR1("Couldn't open audio device ctl for device %d!\n", mixerIndex);

        return NULL;

    }

    info = (PortInfo*) malloc(sizeof(PortInfo));

    if (info != NULL) {

        memset(info, 0, sizeof(PortInfo));

        info->fd = fd;

        success = TRUE;

    }

    if (!success) {

        if (fd >= 0) {

            close(fd);

        }

        PORT_Close((void*) info);

        info = NULL;

    }

    return info;

}

void PORT_Close(void* id) {

    TRACE0("PORT_Close\n");

    if (id != NULL) {

        PortInfo* info = (PortInfo*) id;

        if (info->fd >= 0) {

            close(info->fd);

            info->fd = -1;

        }

        if (info->controlIDs) {

            free(info->controlIDs);

            info->controlIDs = NULL;

        }

        free(info);

    }

}

INT32 PORT_GetPortCount(void* id) {

    int ret = 0;

    PortInfo* info = (PortInfo*) id;

    if (info != NULL) {

        if (!info->targetPortCount && !info->sourcePortCount) {

            int i;

            AUDIO_INITINFO(&info->audioInfo);

            if (ioctl(info->fd, AUDIO_GETINFO, &info->audioInfo) >= 0) {

                for (i = 0; i < ALL_TARGET_PORT_COUNT; i++) {

                    if (info->audioInfo.play.avail_ports & targetPorts[i]) {

                        info->ports[info->targetPortCount] = i;

                        info->targetPortCount++;

                    }

#ifdef SOLARIS7_COMPATIBLE

                    TRACE3("Target %d %s: avail=%d\n", i, targetPortNames[i],

                           info->audioInfo.play.avail_ports & targetPorts[i]);

#else

                    TRACE4("Target %d %s: avail=%d  mod=%d\n", i, targetPortNames[i],

                           info->audioInfo.play.avail_ports & targetPorts[i],

                           info->audioInfo.play.mod_ports & targetPorts[i]);

#endif

                }

                for (i = 0; i < ALL_SOURCE_PORT_COUNT; i++) {

                    if (info->audioInfo.record.avail_ports & sourcePorts[i]) {

                        info->ports[info->targetPortCount + info->sourcePortCount] = i;

                        info->sourcePortCount++;

                    }

#ifdef SOLARIS7_COMPATIBLE

                    TRACE3("Source %d %s: avail=%d\n", i, sourcePortNames[i],

                           info->audioInfo.record.avail_ports & sourcePorts[i]);

#else

                    TRACE4("Source %d %s: avail=%d  mod=%d\n", i, sourcePortNames[i],

                           info->audioInfo.record.avail_ports & sourcePorts[i],

                           info->audioInfo.record.mod_ports & sourcePorts[i]);

#endif

                }

            }

        }

        ret = info->targetPortCount + info->sourcePortCount;

    }

    return ret;

}

int isSourcePort(PortInfo* info, INT32 portIndex) {

    return (portIndex >= info->targetPortCount);

}

INT32 PORT_GetPortType(void* id, INT32 portIndex) {

    PortInfo* info = (PortInfo*) id;

    if ((portIndex >= 0) && (portIndex < PORT_GetPortCount(id))) {

        if (isSourcePort(info, portIndex)) {

            return sourcePortJavaSoundMapping[info->ports[portIndex]];

        } else {

            return targetPortJavaSoundMapping[info->ports[portIndex]];

        }

    }

    return 0;

}

// pre-condition: portIndex must have been verified!

char* getPortName(PortInfo* info, INT32 portIndex) {

    char* ret = NULL;

    if (isSourcePort(info, portIndex)) {

        ret = sourcePortNames[info->ports[portIndex]];

    } else {

        ret = targetPortNames[info->ports[portIndex]];

    }

    return ret;

}

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

    PortInfo* info = (PortInfo*) id;

    char* n;

    if ((portIndex >= 0) && (portIndex < PORT_GetPortCount(id))) {

        n = getPortName(info, portIndex);

        if (n) {

            strncpy(name, n, len-1);

            name[len-1] = 0;

            return TRUE;

        }

    }

    return FALSE;

}

void createPortControl(PortInfo* info, PortControlCreator* creator, INT32 portIndex,

                       INT32 type, void** controlObjects, int* controlCount) {

    PortControlID* controlID;

    void* newControl = NULL;

    int controlIndex;

    char* jsType = NULL;

    int isBoolean = FALSE;

    TRACE0(">createPortControl\n");

    // fill the ControlID structure and add this control

    if (info->usedControlIDs >= info->maxControlCount) {

        ERROR1("not enough free controlIDs !! maxControlIDs = %d\n", info->maxControlCount);

        return;

    }

    controlID = &(info->controlIDs[info->usedControlIDs]);

    controlID->portInfo = info;

    controlID->controlType = type;

    controlIndex = info->ports[portIndex];

    if (isSourcePort(info, portIndex)) {

        controlID->port = sourcePorts[controlIndex];

    } else {

        controlID->port = targetPorts[controlIndex];

    }

    switch (type & PORT_CONTROL_TYPE_MASK) {

    case PORT_CONTROL_TYPE_SELECT_PORT:

        jsType = CONTROL_TYPE_SELECT; isBoolean = TRUE; break;

    case PORT_CONTROL_TYPE_GAIN:

        jsType = CONTROL_TYPE_VOLUME;  break;

    case PORT_CONTROL_TYPE_BALANCE:

        jsType = CONTROL_TYPE_BALANCE; break;

    case PORT_CONTROL_TYPE_MONITOR_GAIN:

        jsType = CONTROL_TYPE_VOLUME; break;

    case PORT_CONTROL_TYPE_OUTPUT_MUTED:

        jsType = CONTROL_TYPE_MUTE; isBoolean = TRUE; break;

    }

    if (isBoolean) {

        TRACE0(" PORT_CONTROL_TYPE_BOOLEAN\n");

        newControl = (creator->newBooleanControl)(creator, controlID, jsType);

    }

    else if (jsType == CONTROL_TYPE_BALANCE) {

        TRACE0(" PORT_CONTROL_TYPE_BALANCE\n");

        newControl = (creator->newFloatControl)(creator, controlID, jsType,

                                                -1.0f, 1.0f, 2.0f / 65.0f, "");

    } else {

        TRACE0(" PORT_CONTROL_TYPE_FLOAT\n");

        newControl = (creator->newFloatControl)(creator, controlID, jsType,

                                                0.0f, 1.0f, 1.0f / 256.0f, "");

    }

    if (newControl) {

        controlObjects[*controlCount] = newControl;

        (*controlCount)++;

        info->usedControlIDs++;

    }

    TRACE0("<createPortControl\n");

}

void addCompoundControl(PortInfo* info, PortControlCreator* creator, char* name, void** controlObjects, int* controlCount) {

    void* compControl;

    TRACE1(">addCompoundControl %d controls\n", *controlCount);

    if (*controlCount) {

        // create compound control and add it to the vector

        compControl = (creator->newCompoundControl)(creator, name, controlObjects, *controlCount);

        if (compControl) {

            TRACE1(" addCompoundControl: calling addControl %p\n", compControl);

            (creator->addControl)(creator, compControl);

        }

        *controlCount = 0;

    }

    TRACE0("<addCompoundControl\n");

}

void addAllControls(PortInfo* info, PortControlCreator* creator, void** controlObjects, int* controlCount) {

    int i = 0;

    TRACE0(">addAllControl\n");

    // go through all controls and add them to the vector

    for (i = 0; i < *controlCount; i++) {

        (creator->addControl)(creator, controlObjects[i]);

    }

    *controlCount = 0;

    TRACE0("<addAllControl\n");

}

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

    PortInfo* info = (PortInfo*) id;

    int portCount = PORT_GetPortCount(id);

    void* controls[4];

    int controlCount = 0;

    INT32 type;

    int selectable = 1;

    memset(controls, 0, sizeof(controls));

    TRACE4(">PORT_GetControls(id=%p, portIndex=%d). controlIDs=%p, maxControlCount=%d\n",

           id, portIndex, info->controlIDs, info->maxControlCount);

    if ((portIndex >= 0) && (portIndex < portCount)) {

        // if the memory isn't reserved for the control structures, allocate it

        if (!info->controlIDs) {

            int maxCount = 0;

            TRACE0("getControl: allocate mem\n");

            // get a maximum number of controls:

            // each port has a select, balance, and volume control.

            maxCount = 3 * portCount;

            // then there is monitorGain and outputMuted

            maxCount += (2 * info->targetPortCount);

            info->maxControlCount = maxCount;

            info->controlIDs = (PortControlID*) malloc(sizeof(PortControlID) * maxCount);

        }

        if (!isSourcePort(info, portIndex)) {

            type = PORT_CONTROL_TYPE_PLAY;

            // add master mute control

            createPortControl(info, creator, portIndex,

                              type | PORT_CONTROL_TYPE_OUTPUT_MUTED,

                              controls, &controlCount);

            addAllControls(info, creator, controls, &controlCount);

#ifdef SOLARIS7_COMPATIBLE

            selectable = info->audioInfo.play.avail_ports & targetPorts[info->ports[portIndex]];

#else

            selectable = info->audioInfo.play.mod_ports & targetPorts[info->ports[portIndex]];

#endif

        } else {

            type = PORT_CONTROL_TYPE_RECORD;

#ifdef SOLARIS7_COMPATIBLE

            selectable = info->audioInfo.record.avail_ports & sourcePorts[info->ports[portIndex]];

#else

            selectable = info->audioInfo.record.mod_ports & sourcePorts[info->ports[portIndex]];

#endif

        }

        // add a mixer strip with volume, ...

        createPortControl(info, creator, portIndex,

                          type | PORT_CONTROL_TYPE_GAIN,

                          controls, &controlCount);

        // ... balance, ...

        createPortControl(info, creator, portIndex,

                          type | PORT_CONTROL_TYPE_BALANCE,

                          controls, &controlCount);

        // ... and select control (if not always on)...

        if (selectable) {

            createPortControl(info, creator, portIndex,

                              type | PORT_CONTROL_TYPE_SELECT_PORT,

                              controls, &controlCount);

        }

        // ... packaged in a compound control.

        addCompoundControl(info, creator, getPortName(info, portIndex), controls, &controlCount);

        if (type == PORT_CONTROL_TYPE_PLAY) {

            // add a single strip for source ports with monitor gain

            createPortControl(info, creator, portIndex,

                              type | PORT_CONTROL_TYPE_MONITOR_GAIN,

                              controls, &controlCount);

            // also in a compound control

            addCompoundControl(info, creator, MONITOR_GAIN_STRING, controls, &controlCount);

        }

    }

    TRACE0("< PORT_getControls\n");

}

INT32 PORT_GetIntValue(void* controlIDV) {

    PortControlID* controlID = (PortControlID*) controlIDV;

    audio_info_t audioInfo;

    audio_prinfo_t* prinfo;

    AUDIO_INITINFO(&audioInfo);

    if (ioctl(controlID->portInfo->fd, AUDIO_GETINFO, &audioInfo) >= 0) {

        if (controlID->controlType & PORT_CONTROL_TYPE_PLAY) {

            prinfo = &(audioInfo.play);

        } else {

            prinfo = &(audioInfo.record);

        }

        switch (controlID->controlType & PORT_CONTROL_TYPE_MASK) {

        case PORT_CONTROL_TYPE_SELECT_PORT:

            return (prinfo->port & controlID->port)?TRUE:FALSE;

        case PORT_CONTROL_TYPE_OUTPUT_MUTED:

            return (audioInfo.output_muted)?TRUE:FALSE;

        default:

            ERROR1("PORT_GetIntValue: Wrong type %d !\n", controlID->controlType & PORT_CONTROL_TYPE_MASK);

        }

    }

    ERROR0("PORT_GetIntValue: Could not ioctl!\n");

    return 0;

}

void PORT_SetIntValue(void* controlIDV, INT32 value) {

    PortControlID* controlID = (PortControlID*) controlIDV;

    audio_info_t audioInfo;

    audio_prinfo_t* prinfo;

    int setPort;

    if (controlID->controlType & PORT_CONTROL_TYPE_PLAY) {

        prinfo = &(audioInfo.play);

    } else {

        prinfo = &(audioInfo.record);

    }

    switch (controlID->controlType & PORT_CONTROL_TYPE_MASK) {

    case PORT_CONTROL_TYPE_SELECT_PORT:

        // first try to just add this port. if that fails, set ONLY to this port.

        AUDIO_INITINFO(&audioInfo);

        if (ioctl(controlID->portInfo->fd, AUDIO_GETINFO, &audioInfo) >= 0) {

            if (value) {

                setPort = (prinfo->port | controlID->port);

            } else {

                setPort = (prinfo->port - controlID->port);

            }

            AUDIO_INITINFO(&audioInfo);

            prinfo->port = setPort;

            if (ioctl(controlID->portInfo->fd, AUDIO_SETINFO, &audioInfo) < 0) {

                // didn't work. Either this line doesn't support to select several

                // ports at once (e.g. record), or a real error

                if (value) {

                    // set to ONLY this port (and disable any other currently selected ports)

                    AUDIO_INITINFO(&audioInfo);

                    prinfo->port = controlID->port;

                    if (ioctl(controlID->portInfo->fd, AUDIO_SETINFO, &audioInfo) < 0) {

                        ERROR2("Error setting output select port %d to port %d!\n", controlID->port, controlID->port);

                    }

                } else {

                    // assume it's an error

                    ERROR2("Error setting output select port %d to port %d!\n", controlID->port, setPort);

                }

            }

            break;

        case PORT_CONTROL_TYPE_OUTPUT_MUTED:

            AUDIO_INITINFO(&audioInfo);

            audioInfo.output_muted = (value?TRUE:FALSE);

            if (ioctl(controlID->portInfo->fd, AUDIO_SETINFO, &audioInfo) < 0) {

                ERROR2("Error setting output muted on port %d to %d!\n", controlID->port, value);