Author: piumarta
Date: 2012-07-30 17:53:30 -0700 (Mon, 30 Jul 2012)
New Revision: 2580
Added:
trunk/platforms/unix/plugins/MIDIPlugin/sqUnixMIDIALSA.inc
trunk/platforms/unix/plugins/MIDIPlugin/sqUnixMIDINone.inc
Log:
add included files
Added: trunk/platforms/unix/plugins/MIDIPlugin/sqUnixMIDIALSA.inc
===================================================================
--- trunk/platforms/unix/plugins/MIDIPlugin/sqUnixMIDIALSA.inc (rev 0)
+++ trunk/platforms/unix/plugins/MIDIPlugin/sqUnixMIDIALSA.inc 2012-07-31 00:53:30 UTC (rev 2580)
@@ -0,0 +1,625 @@
+/* sqUnixMIDIALSA.c -- Unix MIDI support via ALSA
+ *
+ * Copyright (C) 1996-2007 by Florian Hars and other authors/contributors
+ * listed elsewhere in this file.
+ * All rights reserved.
+ *
+ * This file is part of Unix Squeak.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/* Author: Florian(a)Hars.de
+ *
+ * Reformatted for and integrated into Squeak build by: ian at
+ * squeakland dot oh are gee
+ *
+ * Last edited: 2010-04-11 13:19:01 by piumarta on ubuntu
+ */
+
+/*** MIDI Parameters (used with sqMIDIParameter function) ***/
+
+/* TODO: Why is this not in Cross/plugins/MIDIPlugin/MIDIPlugin.h ??? */
+
+#define sqMIDIInstalled 1
+/* Read-only. Return 1 if a MIDI driver is installed, 0 if not. On
+ OMS-based MIDI drivers, this returns 1 only if the OMS system is
+ properly installed and configured. */
+
+#define sqMIDIVersion 2
+/* Read-only. Return the integer version number of this MIDI driver.
+ The version numbering sequence is relative to a particular driver.
+ That is, version 3 of the Macintosh MIDI driver is not necessarily
+ related to version 3 of the Win95 MIDI driver. */
+
+#define sqMIDIHasBuffer 3
+/* Read-only. Return 1 if this MIDI driver has a time-stamped output
+ buffer, 0 otherwise. Such a buffer allows the client to schedule
+ MIDI output packets to be sent later. This can allow more precise
+ timing, since the driver uses timer interrupts to send the data at
+ the right time even if the processor is in the midst of a
+ long-running Squeak primitive or is running some other application
+ or system task. */
+
+#define sqMIDIHasDurs 4
+/* Read-only. Return 1 if this MIDI driver supports an extended
+ primitive for note-playing that includes the note duration and
+ schedules both the note-on and the note-off messages in the driver.
+ Otherwise, return 0. */
+
+#define sqMIDICanSetClock 5
+/* Read-only. Return 1 if this MIDI driver's clock can be set via an
+ extended primitive, 0 if not. */
+
+#define sqMIDICanUseSemaphore 6
+/* Read-only. Return 1 if this MIDI driver can signal a semaphore
+ when MIDI input arrives. Otherwise, return 0. If this driver
+ supports controller caching and it is enabled, then incoming
+ controller messages will not signal the semaphore. */
+
+#define sqMIDIEchoOn 7
+/* Read-write. If this flag is set to a non-zero value, and if the
+ driver supports echoing, then incoming MIDI events will be echoed
+ immediately. If this driver does not support echoing, then queries
+ of this parameter will always return 0 and attempts to change its
+ value will do nothing. */
+
+#define sqMIDIUseControllerCache 8
+/* Read-write. If this flag is set to a non-zero value, and if the
+ driver supports a controller cache, then the driver will maintain a
+ cache of the latest value seen for each MIDI controller, and
+ control update messages will be filtered out of the incoming MIDI
+ stream. An extended MIDI primitive allows the client to poll the
+ driver for the current value of each controller. If this driver
+ does not support a controller cache, then queries of this parameter
+ will always return 0 and attempts to change its value will do
+ nothing. */
+
+#define sqMIDIEventsAvailable 9
+/* Read-only. Return the number of MIDI packets in the input queue. */
+
+#define sqMIDIFlushDriver 10
+/* Write-only. Setting this parameter to any value forces the driver
+ to flush its I/0 buffer, discarding all unprocessed data. Reading
+ this parameter returns 0. Setting this parameter will do nothing
+ if the driver does not support buffer flushing. */
+
+#define sqMIDIClockTicksPerSec 11
+/* Read-only. Return the MIDI clock rate in ticks per second. */
+
+#define sqMIDIHasInputClock 12
+/* Read-only. Return 1 if this MIDI driver timestamps incoming MIDI
+ data with the current value of the MIDI clock, 0 otherwise. If the
+ driver does not support such timestamping, then the client must
+ read input data frequently and provide its own timestamping. */
+
+/* Put the given port into MIDI mode, which uses a clock supplied by
+ an external MIDI interface adaptor to determine the data rate.
+ Possible external clock rates: 31.25 KHz, 0.5 MHz, 1 MHz, or 2
+ MHz. */
+
+#include <alsa/asoundlib.h>
+
+static snd_seq_t *seq = 0;
+static int queue = 0;
+static int in_port = -1;
+static int out_port = -1;
+
+/* MIDI Parser */
+
+enum {idle, want1of2, want2of2, want1of1, sysExclusive};
+
+static int state = idle;
+static int argByte1 = 0;
+static int argByte2 = 0;
+static int lastCmdByte = 0;
+
+/* number of argument bytes for each MIDI command */
+
+char argumentBytes[128] = {
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 3, 1, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+static void performMIDICmd(snd_seq_event_t *ev, int cmdByte, int arg1, int arg2);
+static void processMIDIByte(snd_seq_event_t *ev, int aByte);
+static void startMIDICommand(snd_seq_event_t *ev, int cmdByte);
+
+extern struct VirtualMachine *interpreterProxy;
+
+
+/* Close the given MIDI port. Do nothing if the port is not open.
+ Fail if there is no port of the given number.
+*/
+int sqMIDIClosePort(int portNum)
+{
+ int ret= 0;
+
+ if (portNum == 0)
+ {
+ if (out_port >= 0)
+ ret= snd_seq_delete_simple_port(seq, out_port);
+ out_port= -1;
+ }
+ else if (portNum == 1)
+ {
+ if (in_port >= 0)
+ ret= snd_seq_delete_simple_port(seq, in_port);
+ in_port= -1;
+ }
+ else
+ return interpreterProxy->success(false);
+
+ return ret;
+}
+
+/* Return the current value of the clock used to schedule MIDI events.
+ The MIDI clock is assumed to wrap at or before half the maximum
+ positive SmallInteger value. This allows events to be scheduled
+ into the future without overflowing into LargePositiveIntegers.
+ This implementation does not support event scheduling, so it
+ just returns the value of the Squeak millisecond clock.
+*/
+int sqMIDIGetClock(void)
+{
+ debugf("sqMIDIGetClock\n");
+ success(false);
+ return 0;
+}
+
+/* Return the number of available MIDI interfaces, including both
+ hardware ports and software entities that act like ports. Ports
+ are numbered from 0 to N-1, where N is the number returned by this
+ primitive.
+*/
+int sqMIDIGetPortCount(void)
+{
+ debugf("sqMIDIGetPortCount\n");
+ success(true);
+ return 1;
+}
+
+/* Return an integer indicating the directionality of the given
+ port where: 1 = input, 2 = output, 3 = bidirectional. Fail if
+ there is no port of the given number.
+*/
+int sqMIDIGetPortDirectionality(int portNum)
+{
+ switch (portNum)
+ {
+ case 0: return 2;
+ case 1: return 1;
+ }
+ return interpreterProxy->success(false);
+}
+
+/* Copy the name of the given MIDI port into the string at the given
+ address. Copy at most length characters, and return the number of
+ characters copied. Fail if there is no port of the given number.
+*/
+int sqMIDIGetPortName(int portNum, int namePtr, int length)
+{
+ static char *userName[] = { "out", "in" };
+
+ if (portNum == 0 || portNum == 1)
+ {
+ int count= strlen(userName[portNum]);
+ if (count > length) count= length;
+ memcpy((void *)namePtr, userName, count);
+ return count;
+ }
+ return interpreterProxy->success(false);
+}
+
+/* Open the given port, if possible. If non-zero, readSemaphoreIndex
+ specifies the index in the external objects array of a semaphore to
+ be signalled when incoming MIDI data is available. Note that not
+ all implementations support read semaphores (this one does not);
+ see sqMIDICanUseSemaphore. The interfaceClockRate parameter
+ specifies the clock speed for an external MIDI interface adaptor on
+ platforms that use such adaptors (e.g., Macintosh). Fail if there
+ is no port of the given number.
+*/
+int sqMIDIOpenPort(int portNum, int readSemaIndex, int interfaceClockRate)
+{
+ debugf(("sqMIDIOpenPort(%d, %d, %d)\n", portNum, readSemaIndex, interfaceClockRate));
+ int type= SND_SEQ_PORT_TYPE_APPLICATION;
+
+ switch (portNum)
+ {
+ case 0:
+ if (out_port < 0)
+ {
+ int caps_out= SND_SEQ_PORT_CAP_READ|SND_SEQ_PORT_CAP_SUBS_READ;
+ out_port= snd_seq_create_simple_port(seq, "out", caps_out, type);
+ if (out_port < 0)
+ {
+ success(false);
+ return 0;
+ }
+ }
+ break;
+
+ case 1:
+ if (in_port < 0)
+ {
+ int caps_in= SND_SEQ_PORT_CAP_WRITE|SND_SEQ_PORT_CAP_SUBS_WRITE;
+ in_port= snd_seq_create_simple_port(seq, "in", caps_in, type);
+ if (in_port < 0)
+ {
+ success(false);
+ return 0;
+ }
+ }
+ break;
+
+ default:
+ return interpreterProxy->success(false);
+ }
+
+ snd_seq_queue_tempo_t *tempo= 0;
+ snd_seq_queue_tempo_alloca(&tempo);
+ snd_seq_queue_tempo_set_tempo(tempo, interfaceClockRate);
+ snd_seq_set_queue_tempo(seq, queue, tempo);
+
+ success(true);
+ return 0;
+}
+
+/* Read or write the given MIDI driver parameter. If modify is 0,
+ then newValue is ignored and the current value of the specified
+ parameter is returned. If modify is non-zero, then the specified
+ parameter is set to newValue. Note that many MIDI driver
+ parameters are read-only; attempting to set one of these parameters
+ fails. For boolean parameters, true = 1, false = 0.
+*/
+int sqMIDIParameter(int whichParameter, int modify, int newValue)
+{
+ if (modify == 0)
+ {
+ switch (whichParameter)
+ {
+ case sqMIDIInstalled:
+ return 1;
+ break;
+
+ case sqMIDIVersion:
+ return 100;
+ break;
+
+ case sqMIDIHasBuffer:
+ return 1;
+ break;
+
+ case sqMIDIHasDurs:
+ case sqMIDICanSetClock:
+ case sqMIDICanUseSemaphore:
+ case sqMIDIEchoOn:
+ case sqMIDIUseControllerCache:
+ return 0;
+ break;
+
+ case sqMIDIEventsAvailable:
+ return 1; /* pretend that events are always available */
+ break;
+
+ case sqMIDIFlushDriver:
+ return 0;
+ break;
+
+ case sqMIDIClockTicksPerSec:
+ {
+ snd_seq_queue_tempo_t *tempo= 0;
+ snd_seq_queue_tempo_alloca(&tempo);
+ snd_seq_get_queue_tempo(seq, queue, &tempo);
+ return snd_seq_queue_tempo_get_tempo(tempo) / 1000.0;
+ }
+ break;
+
+ case sqMIDIHasInputClock:
+ return 0;
+ break;
+
+ default:
+ return interpreterProxy->success(false);
+ }
+ }
+ else /* modify != 0 */
+ {
+ switch (whichParameter)
+ {
+ case sqMIDIInstalled:
+ case sqMIDIVersion:
+ case sqMIDIHasBuffer:
+ case sqMIDIHasDurs:
+ case sqMIDICanSetClock:
+ case sqMIDICanUseSemaphore:
+ return interpreterProxy->success(false);
+ break;
+
+ case sqMIDIEchoOn:
+ /* no-op; echoing not supported */
+ break;
+
+ case sqMIDIUseControllerCache:
+ /* no-op; controller cache not supported */
+ break;
+
+ case sqMIDIEventsAvailable:
+ return interpreterProxy->success(false);
+ break;
+
+ case sqMIDIFlushDriver:
+ snd_seq_drain_output(seq);
+ break;
+
+ case sqMIDIClockTicksPerSec:
+ {
+ snd_seq_queue_tempo_t *tempo= 0;
+ snd_seq_queue_tempo_alloca(&tempo);
+ snd_seq_queue_tempo_set_tempo(tempo, 1000.0 * newValue);
+ snd_seq_set_queue_tempo(seq, queue, tempo);
+ }
+ break;
+
+ default:
+ return interpreterProxy->success(false);
+ }
+ }
+
+ return 0;
+}
+
+/* bufferPtr is the address of the first byte of a Smalltalk ByteArray
+ of the given length. Copy up to (length - 4) bytes of incoming
+ MIDI data into that buffer, preceded by a 4-byte timestamp in the
+ units of the MIDI clock, most significant byte first.
+ Implementations that do not support timestamping of incoming data
+ as it arrives (see sqMIDIHasInputClock) simply set the timestamp to
+ the value of the MIDI clock when this function is called. Return
+ the total number of bytes read, including the timestamp bytes.
+ Return zero if no data is available. Fail if the buffer is shorter
+ than five bytes, since there must be enough room for the timestamp
+ plus at least one data byte.
+*/
+int sqMIDIPortReadInto(int portNum, int count, int bufferPtr)
+{
+ debugf(("sqMIDIPortRead\n"));
+ success(false);
+ return 0;
+}
+
+/* bufferPtr is the address of the first byte of a Smalltalk ByteArray
+ of the given length. Send its contents to the given port when the
+ MIDI clock reaches the given time. If time equals zero, then send
+ the data immediately. Implementations that do not support a
+ timestamped output queue, such as this one, always send the data
+ immediately; see sqMIDIHasBuffer.
+*/
+int sqMIDIPortWriteFromAt(int portNum, int count, int bufferPtr, int time)
+{
+ if (portNum == 0)
+ {
+ int i;
+ snd_seq_event_t ev;
+ unsigned char *bytePtr= (unsigned char *)bufferPtr;
+
+ debugf(("Port %d Write:", portNum));
+ for (i= 0; i < count; ++i) debugf((" %d", (int)bytePtr[i]));
+ debugf((" at %d\n", time));
+
+ snd_seq_ev_clear(&ev);
+ snd_seq_ev_set_source(&ev, out_port);
+ snd_seq_ev_set_subs(&ev);
+ snd_seq_ev_schedule_tick(&ev, queue, 0, time);
+ for (i= 0; i < count; ++i)
+ processMIDIByte(&ev, *bytePtr++);
+ snd_seq_event_output(seq, &ev);
+ snd_seq_drain_output(seq);
+
+ success(true);
+ return count;
+ }
+
+ return interpreterProxy->success(false);
+}
+
+
+int midiInit(void)
+{
+ if (snd_seq_open(&seq, "default", SND_SEQ_OPEN_INPUT|SND_SEQ_OPEN_OUTPUT, 0) < 0)
+ {
+ success(false);
+ return 0;
+ }
+ snd_seq_set_client_name(seq, "Squeak");
+ queue= snd_seq_alloc_queue(seq);
+ if (queue < 0)
+ {
+ snd_seq_close(seq);
+ seq= NULL;
+ success(false);
+ return 0;
+ }
+ snd_seq_start_queue(seq, queue, NULL);
+
+ success(true);
+ return true;
+}
+
+int sqMIDIParameterSet(int whichParameter, int newValue)
+{
+ sqMIDIParameter(whichParameter, true, newValue);
+ return 0;
+}
+
+int sqMIDIParameterGet(int whichParameter)
+{
+ sqMIDIParameter(whichParameter, false, 0);
+ return 0;
+}
+
+int midiShutdown(void)
+{
+ debugf(("midiShutdown\n"));
+ success(false);
+ return 0;
+}
+
+static void performMIDICmd(snd_seq_event_t *ev, int cmdByte, int arg1, int arg2)
+{
+ int cmd= cmdByte & 0xF0;
+ int ch= cmdByte & 0x0F;
+
+ switch (cmd)
+ {
+ case 128: /* note off */
+ debugf(("Note off %d, %d\n", ch, arg1));
+ snd_seq_ev_set_noteoff(ev, ch, arg1, 0);
+ break;
+
+ case 144: /* note on */
+ debugf(("Note on %d, %d, %d\n", ch, arg1, arg2));
+ snd_seq_ev_set_noteon(ev, ch, arg1, arg2);
+ break;
+
+ case 176: /* control change */
+ {
+ int val= ((arg1 >= 32) && (arg1 <= 63))
+ ? (arg2 << 1) /* LSB of controllers 0-31 */
+ : (arg2 << 8); /* scale MSB to QT controller range */
+ snd_seq_ev_set_controller(ev, ch, arg1, val);
+ }
+ break;
+
+ case 192: /* program change */
+ {
+ int instrument= arg1 + 1;
+ snd_seq_ev_set_pgmchange(ev, ch, instrument);
+ }
+ break;
+
+ case 224: /* pitch bend */
+ {
+ int bend= ((arg2 << 7) + arg1) - (64 << 7);
+ bend /= 32; /* default sensitivity = +/- 2 semitones */
+ snd_seq_ev_set_pitchbend(ev, ch, bend);
+ }
+ break;
+ }
+}
+
+static void processMIDIByte(snd_seq_event_t *ev, int aByte)
+{
+ if (aByte > 247) return; /* skip all real-time messages */
+
+ switch (state)
+ {
+ case idle:
+ if (aByte >= 128) /* start a new command using the action table */
+ startMIDICommand(ev, aByte);
+ else /* data byte arrived in idle state: use running status if possible */
+ {
+ if (lastCmdByte == 0) /* last command byte is not defined; just skip this byte */
+ return;
+ else
+ {
+ /* process this data as if it had the last command byte in front of it */
+ startMIDICommand(ev, lastCmdByte);
+ /* the previous line put us into a new state; we now do a recursive
+ call to process the data byte in this new state */
+ processMIDIByte(ev, aByte);
+ return;
+ }
+ }
+ break;
+
+ case want1of2:
+ argByte1= aByte;
+ state= want2of2;
+ break;
+
+ case want2of2:
+ argByte2= aByte;
+ performMIDICmd(ev, lastCmdByte, argByte1, argByte2);
+ state= idle;
+ break;
+
+ case want1of1:
+ argByte1= aByte;
+ performMIDICmd(ev, lastCmdByte, argByte1, 0);
+ state= idle;
+ break;
+
+ case sysExclusive:
+ if (aByte < 128)
+ {
+ /* skip a system exclusive data byte */
+ }
+ else
+ {
+ if (aByte < 248)
+ {
+ /* a system exclusive message can be terminated by any non-real-time command byte */
+ state= idle;
+ if (aByte != 247)
+ {
+ processMIDIByte(ev, aByte); /* if not endSysExclusive, byte is the start the next command */
+ }
+ }
+ }
+ break;
+ }
+}
+
+static void startMIDICommand(snd_seq_event_t *ev, int cmdByte)
+{
+ int argCount= argumentBytes[cmdByte - 128];
+
+ switch (argCount)
+ {
+ case 0: /* start a zero argument command (e.g., a real-time message) */
+ /* Stay in the current state and don't change active status.
+ Real-time messages may arrive between data bytes without disruption. */
+ performMIDICmd(ev, cmdByte, 0, 0);
+ break;
+
+ case 1: /* start a one argument command */
+ lastCmdByte= cmdByte;
+ state= want1of1;
+ break;
+
+ case 2: /* start a two argument command */
+ lastCmdByte= cmdByte;
+ state= want1of2;
+ break;
+
+ case 3: /* start a variable length 'system exclusive' command */
+ /* a system exclusive command clears running status */
+ lastCmdByte= 0;
+ state= sysExclusive;
+ break;
+ }
+}
Added: trunk/platforms/unix/plugins/MIDIPlugin/sqUnixMIDINone.inc
===================================================================
--- trunk/platforms/unix/plugins/MIDIPlugin/sqUnixMIDINone.inc (rev 0)
+++ trunk/platforms/unix/plugins/MIDIPlugin/sqUnixMIDINone.inc 2012-07-31 00:53:30 UTC (rev 2580)
@@ -0,0 +1,169 @@
+/* sqUnixMIDINone.c -- Unix with no MIDI support
+ *
+ * Copyright (C) 1996-2007 by Ian Piumarta and other authors/contributors
+ * listed elsewhere in this file.
+ * All rights reserved.
+ *
+ * This file is part of Unix Squeak.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+/* Author: Ian.Piumarta(a)INRIA.FR
+ *
+ * Last edited: 2007-03-11 13:30:32 by piumarta on emilia.local
+ */
+
+/* Put the given port into MIDI mode, which uses a clock supplied
+ by an external MIDI interface adaptor to determine the data rate.
+ Possible external clock rates: 31.25 KHz, 0.5 MHz, 1 MHz, or 2 MHz. */
+int serialPortMidiClockRate(int portNum, int interfaceClockRate)
+{
+ success(false);
+ return 0;
+}
+
+/* Close the given MIDI port. Do nothing if the port is not open.
+ Fail if there is no port of the given number.*/
+int sqMIDIClosePort(int portNum)
+{
+ success(false);
+ return 0;
+}
+
+/* Return the current value of the clock used to schedule MIDI events.
+ The MIDI clock is assumed to wrap at or before half the maximum
+ positive SmallInteger value. This allows events to be scheduled
+ into the future without overflowing into LargePositiveIntegers.
+ This implementation does not support event scheduling, so it
+ just returns the value of the Squeak millisecond clock. */
+int sqMIDIGetClock(void)
+{
+ success(false);
+ return 0;
+}
+
+/* Return the number of available MIDI interfaces, including both
+ hardware ports and software entities that act like ports. Ports
+ are numbered from 0 to N-1, where N is the number returned by this
+ primitive. */
+int sqMIDIGetPortCount(void)
+{
+ success(false);
+ return 0;
+}
+
+/* Return an integer indicating the directionality of the given
+ port where: 1 = input, 2 = output, 3 = bidirectional. Fail if
+ there is no port of the given number. */
+int sqMIDIGetPortDirectionality(int portNum)
+{
+ success(false);
+ return 0;
+}
+
+/* Copy the name of the given MIDI port into the string at the given
+ address. Copy at most length characters, and return the number of
+ characters copied. Fail if there is no port of the given number.*/
+int sqMIDIGetPortName(int portNum, int namePtr, int length)
+{
+ success(false);
+ return 0;
+}
+
+/* Open the given port, if possible. If non-zero, readSemaphoreIndex
+ specifies the index in the external objects array of a semaphore
+ to be signalled when incoming MIDI data is available. Note that
+ not all implementations support read semaphores (this one does
+ not); see sqMIDICanUseSemaphore. The interfaceClockRate parameter
+ specifies the clock speed for an external MIDI interface
+ adaptor on platforms that use such adaptors (e.g., Macintosh).
+ Fail if there is no port of the given number.*/
+int sqMIDIOpenPort(int portNum, int readSemaIndex, int interfaceClockRate)
+{
+ success(false);
+ return 0;
+}
+
+/* Read or write the given MIDI driver parameter. If modify is 0,
+ then newValue is ignored and the current value of the specified
+ parameter is returned. If modify is non-zero, then the specified
+ parameter is set to newValue. Note that many MIDI driver parameters
+ are read-only; attempting to set one of these parameters fails.
+ For boolean parameters, true = 1, false = 0. */
+int sqMIDIParameter(int whichParameter, int modify, int newValue)
+{
+ success(false);
+ return 0;
+}
+
+/* bufferPtr is the address of the first byte of a Smalltalk
+ ByteArray of the given length. Copy up to (length - 4) bytes
+ of incoming MIDI data into that buffer, preceded by a 4-byte
+ timestamp in the units of the MIDI clock, most significant byte
+ first. Implementations that do not support timestamping of
+ incoming data as it arrives (see sqMIDIHasInputClock) simply
+ set the timestamp to the value of the MIDI clock when this
+ function is called. Return the total number of bytes read,
+ including the timestamp bytes. Return zero if no data is
+ available. Fail if the buffer is shorter than five bytes,
+ since there must be enough room for the timestamp plus at
+ least one data byte. */
+int sqMIDIPortReadInto(int portNum, int count, int bufferPtr)
+{
+ success(false);
+ return 0;
+}
+
+/* bufferPtr is the address of the first byte of a Smalltalk
+ ByteArray of the given length. Send its contents to the given
+ port when the MIDI clock reaches the given time. If time equals
+ zero, then send the data immediately. Implementations that do
+ not support a timestamped output queue, such as this one, always
+ send the data immediately; see sqMIDIHasBuffer. */
+int sqMIDIPortWriteFromAt(int portNum, int count, int bufferPtr, int time)
+{
+ success(false);
+ return 0;
+}
+
+
+int midiInit(void)
+{
+ success(false);
+ return 0;
+}
+
+int sqMIDIParameterGet(int which)
+{
+ success(false);
+ return 0;
+}
+
+int sqMIDIParameterSet(int which, int value)
+{
+ success(false);
+ return 0;
+}
+
+int midiShutdown(void)
+{
+ success(false);
+ return 0;
+}