/*

 * 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.

 */

/*

**

**    Overview:

**      Implementation of the functions used for both MIDI in and MIDI out.

**

**      Java package com.sun.media.sound defines the AbstractMidiDevice class

**      which encapsulates functionalities shared by both MidiInDevice and

**      MidiOutDevice classes in the same package.

**

**      The Java layer classes MidiInDevice and MidiOutDevice in turn map to

**      the MIDIEndpointRef data type in the CoreMIDI framework, which

**      represents a source or destination for a standard 16-channel MIDI data

**      stream.

*/

/*****************************************************************************/

//#define USE_ERROR

//#define USE_TRACE

/* Use THIS_FILE when it is available. */

#ifndef THIS_FILE

    #define THIS_FILE __FILE__

#endif

#if (USE_PLATFORM_MIDI_IN == TRUE) || (USE_PLATFORM_MIDI_OUT == TRUE)

#include "PLATFORM_API_MacOSX_MidiUtils.h"

#include <pthread.h>

#include <assert.h>

// Constant character string definitions of CoreMIDI's corresponding error codes.

static const char* strMIDIInvalidClient =

                        "An invalid MIDIClientRef was passed.";

static const char* strMIDIInvalidPort =

                        "An invalid MIDIPortRef was passed.";

static const char* strMIDIWrongEndpointType =

                        "A source endpoint was passed to a function expecting a destination, or vice versa.";

static const char* strMIDINoConnection =

                        "Attempt to close a non-existant connection.";

static const char* strMIDIUnknownEndpoint =

                        "An invalid MIDIEndpointRef was passed.";

static const char* strMIDIUnknownProperty =

                        "Attempt to query a property not set on the object.";

static const char* strMIDIWrongPropertyType =

                        "Attempt to set a property with a value not of the correct type.";

static const char* strMIDINoCurrentSetup =

                        "Internal error; there is no current MIDI setup object.";

static const char* strMIDIMessageSendErr =

                        "Communication with MIDIServer failed.";

static const char* strMIDIServerStartErr =

                        "Unable to start MIDIServer.";

static const char* strMIDISetupFormatErr =

                        "Unable to read the saved state.";

static const char* strMIDIWrongThread =

                        "A driver is calling a non-I/O function in the server from a thread other than"

                        "the server's main thread.";

static const char* strMIDIObjectNotFound =

                        "The requested object does not exist.";

static const char* strMIDIIDNotUnique =

                        "Attempt to set a non-unique kMIDIPropertyUniqueID on an object.";

static const char* midi_strerror(int err) {

/*

    @enum           Error Constants

    @abstract       The error constants unique to Core MIDI.

    @discussion     These are the error constants that are unique to Core MIDI. Note that Core MIDI

                    functions may return other codes that are not listed here.

*/

    const char* strerr;

    switch (err) {

    case kMIDIInvalidClient:

        strerr = strMIDIInvalidClient;

        break;

    case kMIDIInvalidPort:

        strerr = strMIDIInvalidPort;

        break;

    case kMIDIWrongEndpointType:

        strerr = strMIDIWrongEndpointType;

        break;

    case kMIDINoConnection:

        strerr = strMIDINoConnection;

        break;

    case kMIDIUnknownEndpoint:

        strerr = strMIDIUnknownEndpoint;

        break;

    case kMIDIUnknownProperty:

        strerr = strMIDIUnknownProperty;

        break;

    case kMIDIWrongPropertyType:

        strerr = strMIDIWrongPropertyType;

        break;

    case kMIDINoCurrentSetup:

        strerr = strMIDINoCurrentSetup;

        break;

    case kMIDIMessageSendErr:

        strerr = strMIDIMessageSendErr;

        break;

    case kMIDIServerStartErr:

        strerr = strMIDIServerStartErr;

        break;

    case kMIDISetupFormatErr:

        strerr = strMIDISetupFormatErr;

        break;

    case kMIDIWrongThread:

        strerr = strMIDIWrongThread;

        break;

    case kMIDIObjectNotFound:

        strerr = strMIDIObjectNotFound;

        break;

    case kMIDIIDNotUnique:

        strerr = strMIDIIDNotUnique;

        break;

    default:

        strerr = "Unknown error.";

        break;

    }

    return strerr;

}

const char* MIDI_Utils_GetErrorMsg(int err) {

    return midi_strerror(err);

}

void MIDI_Utils_PrintError(int err) {

#ifdef USE_ERROR

    const char* s = MIDI_Utils_GetErrorMsg(err);

    if (s != NULL) {

        fprintf(stderr, "%s\n", s);

    }

#endif

}

// Note direction is either MIDI_IN or MIDI_OUT.

INT32 MIDI_Utils_GetNumDevices(int direction) {

    int num_endpoints;

    if (direction == MIDI_IN) {

        num_endpoints = MIDIGetNumberOfSources();

    //fprintf(stdout, "MIDIGetNumberOfSources() returns %d\n", num_endpoints);

    } else if (direction == MIDI_OUT) {

        num_endpoints = MIDIGetNumberOfDestinations();

        //printf(stdout, "MIDIGetNumberOfDestinations() returns %d\n", num_endpoints);

    } else {

        assert((direction == MIDI_IN || direction == MIDI_OUT));

        num_endpoints = 0;

    }

    return (INT32) num_endpoints;

}

// Wraps calls to CFStringGetCStringPtr and CFStringGetCString to make sure

// we extract the c characters into the buffer and null-terminate it.

static void CFStringExtractCString(CFStringRef cfs, char* buffer, UINT32 bufferSize, CFStringEncoding encoding) {

    const char* ptr = CFStringGetCStringPtr(cfs, encoding);

    if (ptr) {

        strlcpy(buffer, ptr, bufferSize);

    } else {

        if (! CFStringGetCString(cfs, buffer, bufferSize, encoding)) {

            // There's an error in conversion, make sure we null-terminate the buffer.

            buffer[bufferSize - 1] = '\0';

        }

    }

}

//

// @see com.sun.media.sound.AbstractMidiDeviceProvider.getDeviceInfo().

static int getEndpointProperty(int direction, INT32 deviceID, char *buffer, int bufferLength, CFStringRef propertyID) {

    if (deviceID < 0) {

        return MIDI_INVALID_DEVICEID;

    }

    MIDIEndpointRef endpoint;

    if (direction == MIDI_IN) {

        endpoint = MIDIGetSource(deviceID);

    } else if (direction == MIDI_OUT) {

        endpoint = MIDIGetDestination(deviceID);

    } else {

        return MIDI_INVALID_ARGUMENT;

    }

    if (!endpoint) {

        return MIDI_INVALID_DEVICEID;

    }

    int status = MIDI_SUCCESS;

    if (propertyID == kMIDIPropertyDriverVersion) {

        SInt32 driverVersion;

        status = MIDIObjectGetIntegerProperty(endpoint, kMIDIPropertyDriverVersion, &driverVersion);

        if (status != MIDI_SUCCESS) return status;

        snprintf(buffer,

                 bufferLength,

                 "%d",

                 (int) driverVersion);

    }

    else {

        CFStringRef pname;

        status = MIDIObjectGetStringProperty(endpoint, propertyID, &pname);

        if (status != MIDI_SUCCESS) return status;

        CFStringExtractCString(pname, buffer, bufferLength, 0);

    }

    return MIDI_ERROR_NONE;

}

// A simple utility which encapsulates CoreAudio's HostTime APIs.

// It returns the current host time in nanoseconds which when subtracted from

// a previous getCurrentTimeInNanos() result produces the delta in nanos.

static UInt64 getCurrentTimeInNanos() {

    UInt64 hostTime = AudioGetCurrentHostTime();

    UInt64 nanos = AudioConvertHostTimeToNanos(hostTime);

    return nanos;

}

INT32 MIDI_Utils_GetDeviceName(int direction, INT32 deviceID, char *name, UINT32 bufferLength) {

    return getEndpointProperty(direction, deviceID, name, bufferLength, kMIDIPropertyName);

}

INT32 MIDI_Utils_GetDeviceVendor(int direction, INT32 deviceID, char *name, UINT32 bufferLength) {

    return getEndpointProperty(direction, deviceID, name, bufferLength, kMIDIPropertyManufacturer);

}

INT32 MIDI_Utils_GetDeviceDescription(int direction, INT32 deviceID, char *name, UINT32 bufferLength) {

    return getEndpointProperty(direction, deviceID, name, bufferLength, kMIDIPropertyDisplayName);

}

INT32 MIDI_Utils_GetDeviceVersion(int direction, INT32 deviceID, char *name, UINT32 bufferLength) {

    return getEndpointProperty(direction, deviceID, name, bufferLength, kMIDIPropertyDriverVersion);

}

static MIDIClientRef client = (MIDIClientRef) NULL;

static MIDIPortRef inPort = (MIDIPortRef) NULL;

static MIDIPortRef outPort = (MIDIPortRef) NULL;

// Each MIDIPacket can contain more than one midi messages.

// This function processes the packet and adds the messages to the specified message queue.

// @see also src/share/native/com/sun/media/sound/PlatformMidi.h.

static void processMessagesForPacket(const MIDIPacket* packet, MacMidiDeviceHandle* handle) {

    const UInt8* data;

    UInt16 length;

    UInt8 byte;

    UInt8 pendingMessageStatus;

    UInt8 pendingData[2];

    UInt16 pendingDataIndex, pendingDataLength;

    UINT32 packedMsg;

    MIDITimeStamp ts = packet->timeStamp;

    pendingMessageStatus = 0;

    pendingDataIndex = pendingDataLength = 0;

    data = packet->data;

    length = packet->length;

    while (length--) {

        bool byteIsInvalid = FALSE;

        byte = *data++;

        packedMsg = byte;

        if (byte >= 0xF8) {

            // Each RealTime Category message (ie, Status of 0xF8 to 0xFF) consists of only 1 byte, the Status.

            // Except that 0xFD is an invalid status code.

            //

            // 0xF8 -> Midi clock

            // 0xF9 -> Midi tick

            // 0xFA -> Midi start

            // 0xFB -> Midi continue

            // 0xFC -> Midi stop

            // 0xFE -> Active sense

            // 0xFF -> Reset

            if (byte == 0xFD) {

                byteIsInvalid = TRUE;

            } else {

                pendingDataLength = 0;

            }

        } else {

            if (byte < 0x80) {

                // Not a status byte -- check our history.

                if (handle->readingSysExData) {

                    CFDataAppendBytes(handle->readingSysExData, &byte, 1);

                } else if (pendingDataIndex < pendingDataLength) {

                    pendingData[pendingDataIndex] = byte;

                    pendingDataIndex++;

                    if (pendingDataIndex == pendingDataLength) {

                        // This message is now done -- do the final processing.

                        if (pendingDataLength == 2) {

                            packedMsg = pendingMessageStatus | pendingData[0] << 8 | pendingData[1] << 16;

                        } else if (pendingDataLength == 1) {

                            packedMsg = pendingMessageStatus | pendingData[0] << 8;

                        } else {

                            fprintf(stderr, "%s: %d->internal error: pendingMessageStatus=0x%X, pendingDataLength=%d\n",

                                    THIS_FILE, __LINE__, pendingMessageStatus, pendingDataLength);

                            byteIsInvalid = TRUE;

                        }

                        pendingDataLength = 0;

                    }

                } else {

                    // Skip this byte -- it is invalid.

                    byteIsInvalid = TRUE;

                }

            } else {

                if (handle->readingSysExData /* && (byte == 0xF7) */) {

                    // We have reached the end of system exclusive message -- send it finally.

                    const UInt8* bytes = CFDataGetBytePtr(handle->readingSysExData);

                    CFIndex size = CFDataGetLength(handle->readingSysExData);

                    MIDI_QueueAddLong(handle->h.queue,

                                      (UBYTE*) bytes,

                                      (UINT32) size,

                                      0, // Don't care, windowish porting only.

                                      (INT64) (AudioConvertHostTimeToNanos(ts) + 500) / 1000,

                                      TRUE);

                    CFRelease(handle->readingSysExData);

                    handle->readingSysExData = NULL;

                }

                pendingMessageStatus = byte;

                pendingDataLength = 0;

                pendingDataIndex = 0;

                switch (byte & 0xF0) {

                    case 0x80:    // Note off

                    case 0x90:    // Note on

                    case 0xA0:    // Aftertouch

                    case 0xB0:    // Controller

                    case 0xE0:    // Pitch wheel

                        pendingDataLength = 2;

                        break;

                    case 0xC0:    // Program change

                    case 0xD0:    // Channel pressure

                        pendingDataLength = 1;

                        break;

                    case 0xF0: {

                        // System common message

                        switch (byte) {

                        case 0xF0:

                            // System exclusive

                            // Allocates a CFMutableData reference to accumulate the SysEx data until EOX (0xF7) is reached.

                            handle->readingSysExData = CFDataCreateMutable(NULL, 0);

                            break;

                        case 0xF7:

                            // System exclusive ends--already handled above.

                            // But if this is showing up outside of sysex, it's invalid.

                            byteIsInvalid = TRUE;

                            break;

                        case 0xF1:    // MTC quarter frame message

                        case 0xF3:    // Song select

                            pendingDataLength = 1;

                            break;

                        case 0xF2:    // Song position pointer

                            pendingDataLength = 2;

                            break;

                        case 0xF6:    // Tune request

                            pendingDataLength = 0;

                            break;

                        default:

                            // Invalid message

                            byteIsInvalid = TRUE;

                            break;

                        }

                        break;

                    }

                    default:

                        // This can't happen, but handle it anyway.

                        byteIsInvalid = TRUE;

                        break;

                }

            }

        }

        if (byteIsInvalid) continue;

        // If the byte is valid and pendingDataLength is 0, we are ready to send the message.

        if (pendingDataLength == 0) {

            MIDI_QueueAddShort(handle->h.queue, packedMsg, (INT64) (AudioConvertHostTimeToNanos(ts) + 500) / 1000, TRUE);

        }

    }

}

static void midiReadProc(const MIDIPacketList* packetList, void* refCon, void* connRefCon) {

    unsigned int i;

    const MIDIPacket* packet;

    MacMidiDeviceHandle* handle = (MacMidiDeviceHandle*) connRefCon;

    packet = packetList->packet;

    for (i = 0; i < packetList->numPackets; ++i) {

        processMessagesForPacket(packet, handle);

        packet = MIDIPacketNext(packet);

    }

    // Notify the waiting thread that there's data available.

    if (handle) {

        MIDI_SignalConditionVariable(handle->h.platformData);

    }

}

static void midiInit() {

    if (client) {

        return;

    }

    OSStatus err = noErr;

    err = MIDIClientCreate(CFSTR("MIDI Client"), NULL, NULL, &client);

    if (err != noErr) { goto Exit; }

    // This just creates an input port through which the client may receive

    // incoming MIDI messages from any MIDI source.

    err = MIDIInputPortCreate(client, CFSTR("MIDI Input Port"), midiReadProc, NULL, &inPort);

    if (err != noErr) { goto Exit; }

    err = MIDIOutputPortCreate(client, CFSTR("MIDI Output Port"), &outPort);

    if (err != noErr) { goto Exit; }

Exit:

    if (err != noErr) {

        const char* s = MIDI_Utils_GetErrorMsg(err);

        if (s != NULL) {

            printf("%s\n", s);

        }

    }

}

INT32 MIDI_Utils_OpenDevice(int direction, INT32 deviceID, MacMidiDeviceHandle** handle,

                            int num_msgs, int num_long_msgs,

                            size_t lm_size)

{

    midiInit();

    int err = MIDI_ERROR_NONE;

    MIDIEndpointRef endpoint = (MIDIEndpointRef) NULL;

    TRACE0("MIDI_Utils_OpenDevice\n");

    (*handle) = (MacMidiDeviceHandle*) malloc(sizeof(MacMidiDeviceHandle));

    if (!(*handle)) {

        ERROR0("ERROR: MIDI_Utils_OpenDevice: out of memory\n");

        return MIDI_OUT_OF_MEMORY;

    }

    memset(*handle, 0, sizeof(MacMidiDeviceHandle));

    // Create the infrastructure for MIDI in/out, and after that,

    // get the device's endpoint.

    if (direction == MIDI_IN) {

        // Create queue and the pthread condition variable.

        (*handle)->h.queue = MIDI_CreateQueue(num_msgs);

        (*handle)->h.platformData = MIDI_CreateConditionVariable();

        if (!(*handle)->h.queue || !(*handle)->h.platformData) {

            ERROR0("< ERROR: MIDI_IN_OpenDevice: could not create queue or condition variable\n");

            free(*handle);

            (*handle) = NULL;

            return MIDI_OUT_OF_MEMORY;

        }

        endpoint = MIDIGetSource(deviceID);

        (*handle)->port = inPort;

    } else if (direction == MIDI_OUT) {

        endpoint = MIDIGetDestination(deviceID);

        (*handle)->port = outPort;

    }

    if (!endpoint) {

        // An error occurred.

        free(*handle);

        return MIDI_INVALID_DEVICEID;

    }

    (*handle)->h.deviceHandle = (void*) (intptr_t) endpoint;

    (*handle)->h.startTime = getCurrentTimeInNanos();

    (*handle)->direction = direction;

    (*handle)->deviceID = deviceID;

    TRACE0("MIDI_Utils_OpenDevice: succeeded\n");

    return err;

}

INT32 MIDI_Utils_CloseDevice(MacMidiDeviceHandle* handle) {

    int err = MIDI_ERROR_NONE;

    bool midiIn = (handle->direction == MIDI_IN);

    TRACE0("> MIDI_Utils_CloseDevice\n");

    if (!handle) {

        ERROR0("< ERROR: MIDI_Utils_CloseDevice: handle is NULL\n");

        return MIDI_INVALID_HANDLE;

    }

    if (!handle->h.deviceHandle) {

        ERROR0("< ERROR: MIDI_Utils_CloseDevice: native handle is NULL\n");

        return MIDI_INVALID_HANDLE;

    }