media/native/midi/midi.cpp - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2017 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #define LOG_TAG "NativeMIDI"

 #include <poll.h>
 #include <unistd.h>

 #include <binder/Binder.h>
 #include <utils/Errors.h>
 #include <utils/Log.h>

 #include "android/media/midi/BpMidiDeviceServer.h"
 #include "media/MidiDeviceInfo.h"

 #include "midi.h"
 #include "midi_internal.h"

 using android::IBinder;
 using android::BBinder;
 using android::OK;
 using android::sp;
 using android::status_t;
 using android::base::unique_fd;
 using android::binder::Status;
 using android::media::midi::MidiDeviceInfo;

 struct AMIDI_Port {
     std::atomic_int state;
     AMIDI_Device    *device;
     sp<IBinder>     binderToken;
     unique_fd       ufd;
 };

 #define SIZE_MIDIRECEIVEBUFFER AMIDI_BUFFER_SIZE

 enum {
     MIDI_PORT_STATE_CLOSED = 0,
     MIDI_PORT_STATE_OPEN_IDLE,
     MIDI_PORT_STATE_OPEN_ACTIVE
 };

 enum {
     PORTTYPE_OUTPUT = 0,
     PORTTYPE_INPUT = 1
 };

 /* TRANSFER PACKET FORMAT (as defined in MidiPortImpl.java)
  *
  * Transfer packet format is as follows (see MidiOutputPort.mThread.run() to see decomposition):
  * |oc|md|md| ......... |md|ts|ts|ts|ts|ts|ts|ts|ts|
  *  ^ +--------------------+-----------------------+
  *  |  ^                    ^
  *  |  |                    |
  *  |  |                    + timestamp (8 bytes)
  *  |  |
  *  |  + MIDI data bytes (numBytes bytes)
  *  |
  *  + OpCode (AMIDI_OPCODE_DATA)
  *
  *  NOTE: The socket pair is configured to use SOCK_SEQPACKET mode.
  *  SOCK_SEQPACKET, for a sequenced-packet socket that is connection-oriented, preserves message
  *  boundaries, and delivers messages in the order that they were sent.
  *  So 'read()' always returns a whole message.
  */

 /*
  * Device Functions
  */
 status_t AMIDI_getDeviceInfo(AMIDI_Device *device, AMIDI_DeviceInfo *deviceInfoPtr) {
     MidiDeviceInfo deviceInfo;
     Status txResult = device->server->getDeviceInfo(&deviceInfo);
     if (!txResult.isOk()) {
         ALOGE("AMIDI_getDeviceInfo transaction error: %d", txResult.transactionError());
         return txResult.transactionError();
     }

     deviceInfoPtr->type = deviceInfo.getType();
     deviceInfoPtr->uid = deviceInfo.getUid();
     deviceInfoPtr->isPrivate = deviceInfo.isPrivate();
     deviceInfoPtr->inputPortCount = deviceInfo.getInputPortNames().size();
     deviceInfoPtr->outputPortCount = deviceInfo.getOutputPortNames().size();

     return OK;
 }

 /*
  * Port Helpers
  */
 static status_t AMIDI_openPort(AMIDI_Device *device, int portNumber, int type,
         AMIDI_Port **portPtr) {
     sp<BBinder> portToken(new BBinder());
     unique_fd ufd;
     Status txResult = type == PORTTYPE_OUTPUT
             ? device->server->openOutputPort(portToken, portNumber, &ufd)
             : device->server->openInputPort(portToken, portNumber, &ufd);
     if (!txResult.isOk()) {
         ALOGE("AMIDI_openPort transaction error: %d", txResult.transactionError());
         return txResult.transactionError();
     }

     AMIDI_Port* port = new AMIDI_Port;
     port->state = MIDI_PORT_STATE_OPEN_IDLE;
     port->device = device;
     port->binderToken = portToken;
     port->ufd = std::move(ufd);

     *portPtr = port;

     return OK;
 }

 static status_t AMIDI_closePort(AMIDI_Port *port) {
     int portState = MIDI_PORT_STATE_OPEN_IDLE;
     while (!port->state.compare_exchange_weak(portState, MIDI_PORT_STATE_CLOSED)) {
         if (portState == MIDI_PORT_STATE_CLOSED) {
             return -EINVAL; // Already closed
         }
     }

     Status txResult = port->device->server->closePort(port->binderToken);
     if (!txResult.isOk()) {
         return txResult.transactionError();
     }

     delete port;

     return OK;
 }

 /*
  * Output (receiving) API
  */
 status_t AMIDI_openOutputPort(AMIDI_Device *device, int portNumber,
         AMIDI_OutputPort **outputPortPtr) {
     return AMIDI_openPort(device, portNumber, PORTTYPE_OUTPUT, (AMIDI_Port**)outputPortPtr);
 }

 ssize_t AMIDI_receive(AMIDI_OutputPort *outputPort, AMIDI_Message *messages, ssize_t maxMessages) {
     AMIDI_Port *port = (AMIDI_Port*)outputPort;
     int portState = MIDI_PORT_STATE_OPEN_IDLE;
     if (!port->state.compare_exchange_strong(portState, MIDI_PORT_STATE_OPEN_ACTIVE)) {
         // The port has been closed.
         return -EPIPE;
     }

     status_t result = OK;
     ssize_t messagesRead = 0;
     while (messagesRead < maxMessages) {
         struct pollfd checkFds[1] = { { port->ufd, POLLIN, 0 } };
         int pollResult = poll(checkFds, 1, 0);
         if (pollResult < 1) {
             result = android::INVALID_OPERATION;
             break;
         }

         AMIDI_Message *message = &messages[messagesRead];
         uint8_t readBuffer[AMIDI_PACKET_SIZE];
         memset(readBuffer, 0, sizeof(readBuffer));
         ssize_t readCount = read(port->ufd, readBuffer, sizeof(readBuffer));
         if (readCount == EINTR) {
             continue;
         }
         if (readCount < 1) {
             result = android::NOT_ENOUGH_DATA;
             break;
         }

         // set Packet Format definition at the top of this file.
         size_t dataSize = 0;
         message->opcode = readBuffer[0];
         message->timestamp = 0;
         if (message->opcode == AMIDI_OPCODE_DATA && readCount >= AMIDI_PACKET_OVERHEAD) {
             dataSize = readCount - AMIDI_PACKET_OVERHEAD;
             if (dataSize) {
                 memcpy(message->buffer, readBuffer + 1, dataSize);
             }
             message->timestamp = *(uint64_t*)(readBuffer + readCount - sizeof(uint64_t));
         }
         message->len = dataSize;
         ++messagesRead;
     }

     port->state.store(MIDI_PORT_STATE_OPEN_IDLE);

     return result == OK ? messagesRead : result;
 }

 status_t AMIDI_closeOutputPort(AMIDI_OutputPort *outputPort) {
     return AMIDI_closePort((AMIDI_Port*)outputPort);
 }

 /*
  * Input (sending) API
  */
 status_t AMIDI_openInputPort(AMIDI_Device *device, int portNumber, AMIDI_InputPort **inputPortPtr) {
     return AMIDI_openPort(device, portNumber, PORTTYPE_INPUT, (AMIDI_Port**)inputPortPtr);
 }

 status_t AMIDI_closeInputPort(AMIDI_InputPort *inputPort) {
     return AMIDI_closePort((AMIDI_Port*)inputPort);
 }

 ssize_t AMIDI_getMaxMessageSizeInBytes(AMIDI_InputPort */*inputPort*/) {
     return SIZE_MIDIRECEIVEBUFFER;
 }

 static ssize_t AMIDI_makeSendBuffer(
         uint8_t *buffer, uint8_t *data, ssize_t numBytes,uint64_t timestamp) {
     buffer[0] = AMIDI_OPCODE_DATA;
     memcpy(buffer + 1, data, numBytes);
     memcpy(buffer + 1 + numBytes, &timestamp, sizeof(timestamp));
     return numBytes + AMIDI_PACKET_OVERHEAD;
 }

 // Handy debugging function.
 //static void AMIDI_logBuffer(uint8_t *data, size_t numBytes) {
 //    for (size_t index = 0; index < numBytes; index++) {
 //      ALOGI("  data @%zu [0x%X]", index, data[index]);
 //    }
 //}

 ssize_t AMIDI_send(AMIDI_InputPort *inputPort, uint8_t *buffer, ssize_t numBytes) {
     return AMIDI_sendWithTimestamp(inputPort, buffer, numBytes, 0);
 }

 ssize_t AMIDI_sendWithTimestamp(AMIDI_InputPort *inputPort, uint8_t *data,
         ssize_t numBytes, int64_t timestamp) {

     if (numBytes > SIZE_MIDIRECEIVEBUFFER) {
         return android::BAD_VALUE;
     }

     // AMIDI_logBuffer(data, numBytes);

     uint8_t writeBuffer[SIZE_MIDIRECEIVEBUFFER + AMIDI_PACKET_OVERHEAD];
     ssize_t numTransferBytes = AMIDI_makeSendBuffer(writeBuffer, data, numBytes, timestamp);
     ssize_t numWritten = write(((AMIDI_Port*)inputPort)->ufd, writeBuffer, numTransferBytes);

     if (numWritten < numTransferBytes) {
         ALOGE("AMIDI_sendWithTimestamp Couldn't write MIDI data buffer. requested:%zu, written%zu",
                 numTransferBytes, numWritten);
     }

     return numWritten - AMIDI_PACKET_OVERHEAD;
 }

 status_t AMIDI_flush(AMIDI_InputPort *inputPort) {
     uint8_t opCode = AMIDI_OPCODE_FLUSH;
     ssize_t numTransferBytes = 1;
     ssize_t numWritten = write(((AMIDI_Port*)inputPort)->ufd, &opCode, numTransferBytes);

     if (numWritten < numTransferBytes) {
         ALOGE("AMIDI_flush Couldn't write MIDI flush. requested:%zu, written%zu",
                 numTransferBytes, numWritten);
         return android::INVALID_OPERATION;
     }

     return OK;
 }
	/*
	* Copyright (C) 2017 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#define LOG_TAG "NativeMIDI"

	#include <poll.h>
	#include <unistd.h>

	#include <binder/Binder.h>
	#include <utils/Errors.h>
	#include <utils/Log.h>

	#include "android/media/midi/BpMidiDeviceServer.h"
	#include "media/MidiDeviceInfo.h"

	#include "midi.h"
	#include "midi_internal.h"

	using android::IBinder;
	using android::BBinder;
	using android::OK;
	using android::sp;
	using android::status_t;
	using android::base::unique_fd;
	using android::binder::Status;
	using android::media::midi::MidiDeviceInfo;

	struct AMIDI_Port {
	std::atomic_int state;
	AMIDI_Device *device;
	sp<IBinder> binderToken;
	unique_fd ufd;
	};

	#define SIZE_MIDIRECEIVEBUFFER AMIDI_BUFFER_SIZE

	enum {
	MIDI_PORT_STATE_CLOSED = 0,
	MIDI_PORT_STATE_OPEN_IDLE,
	MIDI_PORT_STATE_OPEN_ACTIVE
	};

	enum {
	PORTTYPE_OUTPUT = 0,
	PORTTYPE_INPUT = 1
	};

	/* TRANSFER PACKET FORMAT (as defined in MidiPortImpl.java)
	*
	* Transfer packet format is as follows (see MidiOutputPort.mThread.run() to see decomposition):
	* \|oc\|md\|md\| ......... \|md\|ts\|ts\|ts\|ts\|ts\|ts\|ts\|ts\|
	* ^ +--------------------+-----------------------+
	* \| ^ ^
	* \| \| \|
	* \| \| + timestamp (8 bytes)
	* \| \|
	* \| + MIDI data bytes (numBytes bytes)
	* \|
	* + OpCode (AMIDI_OPCODE_DATA)
	*
	* NOTE: The socket pair is configured to use SOCK_SEQPACKET mode.
	* SOCK_SEQPACKET, for a sequenced-packet socket that is connection-oriented, preserves message
	* boundaries, and delivers messages in the order that they were sent.
	* So 'read()' always returns a whole message.
	*/

	/*
	* Device Functions
	*/
	status_t AMIDI_getDeviceInfo(AMIDI_Device device, AMIDI_DeviceInfo deviceInfoPtr) {
	MidiDeviceInfo deviceInfo;
	Status txResult = device->server->getDeviceInfo(&deviceInfo);
	if (!txResult.isOk()) {
	ALOGE("AMIDI_getDeviceInfo transaction error: %d", txResult.transactionError());
	return txResult.transactionError();
	}

	deviceInfoPtr->type = deviceInfo.getType();
	deviceInfoPtr->uid = deviceInfo.getUid();
	deviceInfoPtr->isPrivate = deviceInfo.isPrivate();
	deviceInfoPtr->inputPortCount = deviceInfo.getInputPortNames().size();
	deviceInfoPtr->outputPortCount = deviceInfo.getOutputPortNames().size();

	return OK;
	}

	/*
	* Port Helpers
	*/
	static status_t AMIDI_openPort(AMIDI_Device *device, int portNumber, int type,
	AMIDI_Port **portPtr) {
	sp<BBinder> portToken(new BBinder());
	unique_fd ufd;
	Status txResult = type == PORTTYPE_OUTPUT
	? device->server->openOutputPort(portToken, portNumber, &ufd)
	: device->server->openInputPort(portToken, portNumber, &ufd);
	if (!txResult.isOk()) {
	ALOGE("AMIDI_openPort transaction error: %d", txResult.transactionError());
	return txResult.transactionError();
	}

	AMIDI_Port* port = new AMIDI_Port;
	port->state = MIDI_PORT_STATE_OPEN_IDLE;
	port->device = device;
	port->binderToken = portToken;
	port->ufd = std::move(ufd);

	*portPtr = port;

	return OK;
	}

	static status_t AMIDI_closePort(AMIDI_Port *port) {
	int portState = MIDI_PORT_STATE_OPEN_IDLE;
	while (!port->state.compare_exchange_weak(portState, MIDI_PORT_STATE_CLOSED)) {
	if (portState == MIDI_PORT_STATE_CLOSED) {
	return -EINVAL; // Already closed
	}
	}

	Status txResult = port->device->server->closePort(port->binderToken);
	if (!txResult.isOk()) {
	return txResult.transactionError();
	}

	delete port;

	return OK;
	}

	/*
	* Output (receiving) API
	*/
	status_t AMIDI_openOutputPort(AMIDI_Device *device, int portNumber,
	AMIDI_OutputPort **outputPortPtr) {
	return AMIDI_openPort(device, portNumber, PORTTYPE_OUTPUT, (AMIDI_Port**)outputPortPtr);
	}

	ssize_t AMIDI_receive(AMIDI_OutputPort outputPort, AMIDI_Message messages, ssize_t maxMessages) {
	AMIDI_Port port = (AMIDI_Port)outputPort;
	int portState = MIDI_PORT_STATE_OPEN_IDLE;
	if (!port->state.compare_exchange_strong(portState, MIDI_PORT_STATE_OPEN_ACTIVE)) {
	// The port has been closed.
	return -EPIPE;
	}

	status_t result = OK;
	ssize_t messagesRead = 0;
	while (messagesRead < maxMessages) {
	struct pollfd checkFds[1] = { { port->ufd, POLLIN, 0 } };
	int pollResult = poll(checkFds, 1, 0);
	if (pollResult < 1) {
	result = android::INVALID_OPERATION;
	break;
	}

	AMIDI_Message *message = &messages[messagesRead];
	uint8_t readBuffer[AMIDI_PACKET_SIZE];
	memset(readBuffer, 0, sizeof(readBuffer));
	ssize_t readCount = read(port->ufd, readBuffer, sizeof(readBuffer));
	if (readCount == EINTR) {
	continue;
	}
	if (readCount < 1) {
	result = android::NOT_ENOUGH_DATA;
	break;
	}

	// set Packet Format definition at the top of this file.
	size_t dataSize = 0;
	message->opcode = readBuffer[0];
	message->timestamp = 0;
	if (message->opcode == AMIDI_OPCODE_DATA && readCount >= AMIDI_PACKET_OVERHEAD) {
	dataSize = readCount - AMIDI_PACKET_OVERHEAD;
	if (dataSize) {
	memcpy(message->buffer, readBuffer + 1, dataSize);
	}
	message->timestamp = (uint64_t)(readBuffer + readCount - sizeof(uint64_t));
	}
	message->len = dataSize;
	++messagesRead;
	}

	port->state.store(MIDI_PORT_STATE_OPEN_IDLE);

	return result == OK ? messagesRead : result;
	}

	status_t AMIDI_closeOutputPort(AMIDI_OutputPort *outputPort) {
	return AMIDI_closePort((AMIDI_Port*)outputPort);
	}

	/*
	* Input (sending) API
	*/
	status_t AMIDI_openInputPort(AMIDI_Device device, int portNumber, AMIDI_InputPort *inputPortPtr) {
	return AMIDI_openPort(device, portNumber, PORTTYPE_INPUT, (AMIDI_Port**)inputPortPtr);
	}

	status_t AMIDI_closeInputPort(AMIDI_InputPort *inputPort) {
	return AMIDI_closePort((AMIDI_Port*)inputPort);
	}

	ssize_t AMIDI_getMaxMessageSizeInBytes(AMIDI_InputPort /inputPort*/) {
	return SIZE_MIDIRECEIVEBUFFER;
	}

	static ssize_t AMIDI_makeSendBuffer(
	uint8_t buffer, uint8_t data, ssize_t numBytes,uint64_t timestamp) {
	buffer[0] = AMIDI_OPCODE_DATA;
	memcpy(buffer + 1, data, numBytes);
	memcpy(buffer + 1 + numBytes, &timestamp, sizeof(timestamp));
	return numBytes + AMIDI_PACKET_OVERHEAD;
	}

	// Handy debugging function.
	//static void AMIDI_logBuffer(uint8_t *data, size_t numBytes) {
	// for (size_t index = 0; index < numBytes; index++) {
	// ALOGI(" data @%zu [0x%X]", index, data[index]);
	// }
	//}

	ssize_t AMIDI_send(AMIDI_InputPort inputPort, uint8_t buffer, ssize_t numBytes) {
	return AMIDI_sendWithTimestamp(inputPort, buffer, numBytes, 0);
	}

	ssize_t AMIDI_sendWithTimestamp(AMIDI_InputPort inputPort, uint8_t data,
	ssize_t numBytes, int64_t timestamp) {

	if (numBytes > SIZE_MIDIRECEIVEBUFFER) {
	return android::BAD_VALUE;
	}

	// AMIDI_logBuffer(data, numBytes);

	uint8_t writeBuffer[SIZE_MIDIRECEIVEBUFFER + AMIDI_PACKET_OVERHEAD];
	ssize_t numTransferBytes = AMIDI_makeSendBuffer(writeBuffer, data, numBytes, timestamp);
	ssize_t numWritten = write(((AMIDI_Port*)inputPort)->ufd, writeBuffer, numTransferBytes);

	if (numWritten < numTransferBytes) {
	ALOGE("AMIDI_sendWithTimestamp Couldn't write MIDI data buffer. requested:%zu, written%zu",
	numTransferBytes, numWritten);
	}

	return numWritten - AMIDI_PACKET_OVERHEAD;
	}

	status_t AMIDI_flush(AMIDI_InputPort *inputPort) {
	uint8_t opCode = AMIDI_OPCODE_FLUSH;
	ssize_t numTransferBytes = 1;
	ssize_t numWritten = write(((AMIDI_Port*)inputPort)->ufd, &opCode, numTransferBytes);

	if (numWritten < numTransferBytes) {
	ALOGE("AMIDI_flush Couldn't write MIDI flush. requested:%zu, written%zu",
	numTransferBytes, numWritten);
	return android::INVALID_OPERATION;
	}

	return OK;
	}