JDK14/Java14源码在线阅读
/*
* 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;
}
handle->isStarted = FALSE;
handle->h.deviceHandle = NULL;
if (midiIn) {
if (handle->h.queue != NULL) {
MidiMessageQueue* queue = handle->h.queue;
handle->h.queue = NULL;
MIDI_DestroyQueue(queue);
}
if (handle->h.platformData) {
MIDI_DestroyConditionVariable(handle->h.platformData);
}
}
free(handle);
TRACE0("< MIDI_Utils_CloseDevice: succeeded\n");
return err;
}
INT32 MIDI_Utils_StartDevice(MacMidiDeviceHandle* handle) {
OSStatus err = noErr;
if (!handle || !handle->h.deviceHandle) {
ERROR0("ERROR: MIDI_Utils_StartDevice: handle or native is NULL\n");
return MIDI_INVALID_HANDLE;
}
// Clears all the events from the queue.
MIDI_QueueClear(handle->h.queue);
if (!handle->isStarted) {
/* set the flag that we can now receive messages */
handle->isStarted = TRUE;
if (handle->direction == MIDI_IN) {
// The handle->h.platformData field contains the (pthread_cond_t*)
// associated with the source of the MIDI input stream, and is
// used in the CoreMIDI's callback to signal the arrival of new
// data.
//
// Similarly, handle->h.queue is used in the CoreMDID's callback
// to dispatch the incoming messages to the appropriate queue.
//
err = MIDIPortConnectSource(inPort, (MIDIEndpointRef) (intptr_t) (handle->h.deviceHandle), (void*) handle);
} else if (handle->direction == MIDI_OUT) {
// Unschedules previous-sent packets.
err = MIDIFlushOutput((MIDIEndpointRef) (intptr_t) handle->h.deviceHandle);
}
MIDI_CHECK_ERROR;
}
return MIDI_SUCCESS; /* don't fail */
}
INT32 MIDI_Utils_StopDevice(MacMidiDeviceHandle* handle) {
OSStatus err = noErr;
if (!handle || !handle->h.deviceHandle) {
ERROR0("ERROR: MIDI_Utils_StopDevice: handle or native handle is NULL\n");
return MIDI_INVALID_HANDLE;
}
if (handle->isStarted) {
/* set the flag that we don't want to receive messages anymore */
handle->isStarted = FALSE;
if (handle->direction == MIDI_IN) {
err = MIDIPortDisconnectSource(inPort, (MIDIEndpointRef) (intptr_t) (handle->h.deviceHandle));
} else if (handle->direction == MIDI_OUT) {
// Unschedules previously-sent packets.
err = MIDIFlushOutput((MIDIEndpointRef) (intptr_t) handle->h.deviceHandle);
}
MIDI_CHECK_ERROR;
}
return MIDI_SUCCESS;
}
INT64 MIDI_Utils_GetTimeStamp(MacMidiDeviceHandle* handle) {
if (!handle || !handle->h.deviceHandle) {
ERROR0("ERROR: MIDI_Utils_GetTimeStamp: handle or native handle is NULL\n");
return (INT64) -1; /* failure */
}
UInt64 delta = getCurrentTimeInNanos() - handle->h.startTime;
return (INT64) ((delta + 500) / 1000);
}
/***************************************************************************/
/* Condition Variable Support for Mac OS X Port */
/* */
/* This works with the Native Locking Support defined below. We are using */
/* POSIX pthread_cond_t/pthread_mutex_t to do locking and synchronization. */
/* */
/* For MidiDeviceHandle* handle, the mutex reference is stored as handle-> */
/* queue->lock while the condition variabale reference is stored as handle */
/**代码未完, 请加载全部代码(NowJava.com).**/
关注时代Java
关注时代Java