Imported Upstream version 4.2-build2006upstream/4.2-build2006upstream

1 files changed, 2230 insertions, 0 deletions

diff --git a/lib/libsalsa/seq.c b/lib/libsalsa/seq.c
new file mode 100644
index 0000000..67f134b
--- /dev/null
+++ b/lib/libsalsa/seq.c
@@ -0,0 +1,2230 @@
+/*
+ *  Copyright (c) 2004 by Hannu Savolainen < hannu@opensound.com>
+ *
+ *   This library is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Lesser General Public License version 2.1 as
+ *   published by the Free Software Foundation.
+ *
+ *   This program 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 Lesser General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Lesser General Public
+ *   License along with this library; if not, write to the Free Software
+ *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+ *
+ */
+#include <stdio.h>
+#include "local.h"
+
+static int nports = 0;
+
+typedef struct _snd_seq_port_subscribe
+{
+  int dummy;
+} snd_seq_port_subscribe_t;
+
+typedef struct _snd_seq_queue_tempo
+{
+  int dummy;
+} snd_seq_queue_tempo_t;
+
+typedef struct _snd_seq_system_info
+{
+  int dummy;
+} snd_seq_system_info_t;
+
+struct _snd_seq_remove_events
+{
+  int dummy;
+};
+
+struct _snd_seq_query_subscribe
+{
+  int dummy;
+};
+
+/**
+ * \brief Open the ALSA sequencer
+ *
+ * \param seqp Pointer to a snd_seq_t pointer.  This pointer must be
+ * kept and passed to most of the other sequencer functions.
+ * \param name The sequencer's "name".  This is \em not a name you make
+ * up for your own purposes; it has special significance to the ALSA
+ * library.  Usually you need to pass \c "default" here.
+ * \param streams The read/write mode of the sequencer.  Can be one of
+ * three values:
+ * - #SND_SEQ_OPEN_OUTPUT - open the sequencer for output only
+ * - #SND_SEQ_OPEN_INPUT - open the sequencer for input only
+ * - #SND_SEQ_OPEN_DUPLEX - open the sequencer for output and input
+ * \note Internally, these are translated to \c O_WRONLY, \c O_RDONLY and
+ * \c O_RDWR respectively and used as the second argument to the C library
+ * open() call.
+ * \param mode Optional modifier.  Can be either 0, or
+ * #SND_SEQ_NONBLOCK, which will make read/write operations
+ * non-blocking.  This can also be set later using #snd_seq_nonblock().
+ * \return 0 on success otherwise a negative error code
+ *
+* Creates a new handle and opens a connection to the kernel
+ * sequencer interface.
+ * After a client is created successfully, an event
+ * with #SND_SEQ_EVENT_CLIENT_START is broadcast to announce port.
+ *
+ * \sa snd_seq_open_lconf(), snd_seq_close(), snd_seq_type(), snd_seq_name(),
+ *     snd_seq_nonblock(), snd_seq_client_id()
+ */
+int
+snd_seq_open (snd_seq_t ** seqp, const char *name, int streams, int mode)
+{
+  snd_seq_t *seq;
+  int err, oss_mode;
+  static int instance = 0;
+
+  char *fname = "/dev/midi", *envname = NULL, tmp[128];
+
+  ALIB_INIT ();
+
+  dbg_printf ("snd_seq_open(name='%s', streams=%d, mode=%x)\n", name, streams,
+	      mode);
+
+  if (!alib_appcheck ())
+    return -ENODEV;
+
+  instance++;
+
+  sprintf (tmp, "%s_mididev%d", alib_appname, instance);
+
+  if ((envname = getenv (tmp)) != NULL)
+    {
+      fname = envname;
+    }
+#if 0
+  if (streams != 1)
+    {
+      fprintf (stderr, "salsa: snd_seq_open doesn't support streams=%d\n",
+	       streams);
+      return -EIO;
+    }
+#endif
+
+  if ((seq = malloc (sizeof (*seq))) == NULL)
+    return -ENOMEM;
+
+  dbg_printf ("Created sequencer seq=%x\n", seq);
+
+  memset (seq, 0, sizeof (*seq));
+
+  switch (streams)
+    {
+    case SND_SEQ_OPEN_INPUT:
+      oss_mode = O_RDONLY;
+      dbg_printf ("Open SND_SEQ_OPEN_INPUT\n");
+      break;
+    case SND_SEQ_OPEN_OUTPUT:
+      oss_mode = O_WRONLY;
+      dbg_printf ("Open SND_SEQ_OPEN_OUTPUT\n");
+      break;
+    case SND_SEQ_OPEN_DUPLEX:
+      dbg_printf ("SND_SEQ_OPEN_DUPLEX\n");
+      oss_mode = O_RDWR;
+      break;
+
+    default:
+      fprintf (stderr, "snd_seq_open: Unknown stream %x\n", streams);
+      return -ENODEV;
+    }
+
+  if ((seq->fd = open (fname, oss_mode, 0)) == -1)
+    {
+      err = errno;
+      perror (fname);
+
+      if (envname == NULL)
+	{
+	  fprintf (stderr,
+		   "You can select another filename using environment variable %s_mididev%d\n",
+		   alib_appname, instance);
+	}
+      return -err;
+    }
+
+  seq->streams = streams;
+  seq->oss_mode = oss_mode;
+
+  if (streams == SND_SEQ_OPEN_INPUT || streams == SND_SEQ_OPEN_DUPLEX)
+    {
+      seq->parser = midiparser_create (midiparser_callback, seq);
+      if (seq->parser == NULL)
+	{
+	  fprintf (stderr, "libsalsa: Can't create MIDI parser\n");
+	  return -ENODEV;
+	}
+    }
+
+  *seqp = seq;
+  return 0;
+}
+
+/**
+ * \brief Close the sequencer
+ * \param handle Handle returned from #snd_seq_open()
+ * \return 0 on success otherwise a negative error code
+ *
+ * Closes the sequencer client and releases its resources.
+ * After a client is closed, an event with
+ * #SND_SEQ_EVENT_CLIENT_EXIT is broadcast to announce port.
+ * The connection between other clients are disconnected.
+ * Call this just before exiting your program.
+ *
+ * \sa snd_seq_close()
+ */
+int
+snd_seq_close (snd_seq_t * seq)
+{
+  dbg_printf ("snd_seq_close(seq=%x)\n", seq);
+
+  close (seq->fd);
+  free (seq);
+}
+
+/**
+ * \brief Set nonblock mode
+ * \param seq sequencer handle
+ * \param nonblock 0 = block, 1 = nonblock mode
+ * \return 0 on success otherwise a negative error code
+ *
+ * Change the blocking mode of the given client.
+ * In block mode, the client falls into sleep when it fills the
+ * output memory pool with full events.  The client will be woken up
+ * after a certain amount of free space becomes available.
+ *
+ * \sa snd_seq_open()
+ */
+int
+snd_seq_nonblock (snd_seq_t * seq, int nonblock)
+{
+  dbg_printf ("snd_seq_nonblock(seq=%x, nonblock=%d)\n", seq, nonblock);
+
+  seq->nonblock = nonblock;
+  return 0;
+}
+
+/**
+ * \brief create a sequencer port on the current client
+ * \param seq sequencer handle
+ * \param port port information for the new port
+ * \return 0 on success otherwise a negative error code
+ *
+ * Creates a sequencer port on the current client.
+ * The attributes of created port is specified in \a info argument.
+ *
+ * The client field in \a info argument is overwritten with the current client id.
+ * The port id to be created can be specified via #snd_seq_port_info_set_port_specified.
+ * You can get the created port id by reading the port pointer via #snd_seq_port_info_get_port.
+ *
+ * Each port has the capability bit-masks to specify the access capability
+ * of the port from other clients.
+ * The capability bit flags are defined as follows:
+ * - #SND_SEQ_PORT_CAP_READ Readable from this port
+ * - #SND_SEQ_PORT_CAP_WRITE Writable to this port.
+ * - #SND_SEQ_PORT_CAP_SYNC_READ For synchronization (not implemented)
+ * - #SND_SEQ_PORT_CAP_SYNC_WRITE For synchronization (not implemented)
+ * - #SND_SEQ_PORT_CAP_DUPLEX Read/write duplex access is supported
+ * - #SND_SEQ_PORT_CAP_SUBS_READ Read subscription is allowed
+ * - #SND_SEQ_PORT_CAP_SUBS_WRITE Write subscription is allowed
+ * - #SND_SEQ_PORT_CAP_SUBS_NO_EXPORT Subscription management from 3rd client is disallowed
+ *
+ * Each port has also the type bitmasks defined as follows:
+ * - #SND_SEQ_PORT_TYPE_SPECIFIC Hardware specific port
+ * - #SND_SEQ_PORT_TYPE_MIDI_GENERIC Generic MIDI device
+ * - #SND_SEQ_PORT_TYPE_MIDI_GM General MIDI compatible device
+ * - #SND_SEQ_PORT_TYPE_MIDI_GS GS compatible device
+ * - #SND_SEQ_PORT_TYPE_MIDI_XG XG compatible device
+ * - #SND_SEQ_PORT_TYPE_MIDI_MT32 MT-32 compatible device
+ * - #SND_SEQ_PORT_TYPE_SYNTH Synth device
+ * - #SND_SEQ_PORT_TYPE_DIRECT_SAMPLE Sampling device (supporting download)
+ * - #SND_SEQ_PORT_TYPE_SAMPLE Sampling device (sample can be downloaded at any time)
+ * - #SND_SEQ_PORT_TYPE_APPLICATION Application (sequencer/editor)
+ *
+ * A port may contain specific midi channels, midi voices and synth voices.
+ * These values could be zero as default.
+ *
+ * \sa snd_seq_delete_port(), snd_seq_get_port_info(),
+ *     snd_seq_create_simple_port()
+ */
+int
+snd_seq_create_port (snd_seq_t * seq, snd_seq_port_info_t * port)
+{
+  dbg_printf ("snd_seq_create_port(seq=%x, port=%x)\n", seq, port);
+
+  port->port = nports++;
+  return 0;
+}
+
+/**
+ * \brief Get the client id
+ * \param seq sequencer handle
+ * \return the client id
+ *
+ * Returns the id of the specified client.
+ * If an error occurs, function returns the negative error code.
+ * A client id is necessary to inquiry or to set the client information.
+ * A user client is assigned from 128 to 191.
+ *
+ * \sa snd_seq_open()
+ */
+int
+snd_seq_client_id (snd_seq_t * seq)
+{
+  static int client_id = 128;
+
+  dbg_printf ("snd_seq_client_id(seq=%x)=%d\n", seq, client_id);
+
+  return client_id++;
+}
+
+/**
+ * \brief Get client id of a client_info container
+ * \param info client_info container
+ * \return client id
+ *
+ * \sa snd_seq_get_client_info(), snd_seq_client_info_set_client(), snd_seq_client_id()
+ */
+int
+snd_seq_client_info_get_client (const snd_seq_client_info_t * info)
+{
+  dbg_printf ("snd_seq_client_info_get_client()\n");
+
+  return 0;
+}
+
+/**
+ * \brief Get client type of a client_info container
+ * \param info client_info container
+ * \return client type
+ *
+ * The client type is either #SEQ_CLIENT_TYPE_KERNEL or #SEQ_CLIENT_TYPE_USER
+ * for kernel or user client respectively.
+ *
+ * \sa snd_seq_get_client_info()
+ */
+snd_seq_client_type_t
+snd_seq_client_info_get_type (const snd_seq_client_info_t * info)
+{
+  dbg_printf ("snd_seq_client_info_get_type(infp=%x)\n", info);
+
+  return SND_SEQ_KERNEL_CLIENT;	// TODO
+}
+
+/**
+ * \brief Set the client id of a client_info container
+ * \param info client_info container
+ * \param client client id
+ *
+ * \sa snd_seq_get_client_info(), snd_seq_client_info_get_client()
+ */
+void
+snd_seq_client_info_set_client (snd_seq_client_info_t * info, int client)
+{
+  dbg_printf ("snd_seq_client_info_set_client(%x, %d)\n", info, client);
+
+  info->client = client;
+}
+
+/**
+ * \brief get size of #snd_seq_client_info_t
+ * \return size in bytes
+ */
+size_t
+snd_seq_client_info_sizeof ()
+{
+  dbg_printf ("snd_seq_client_info_sizeof()\n");
+
+  return sizeof (snd_seq_client_info_t);
+}
+
+/**
+ * \brief retrieve an event from sequencer
+ * \param seq sequencer handle
+ * \param ev event pointer to be stored
+ * \return
+ *
+ * Obtains an input event from sequencer.
+ * The event is created via snd_seq_create_event(), and its pointer is stored on * ev argument.
+ *
+ * This function firstly receives the event byte-stream data from sequencer
+ * as much as possible at once.  Then it retrieves the first event record
+ * and store the pointer on ev.
+ * By calling this function sequentially, events are extracted from the input buffer.
+ *
+ * If there is no input from sequencer, function falls into sleep
+ * in blocking mode until an event is received,
+ * or returns \c -EAGAIN error in non-blocking mode.
+ * Occasionally, this function may return \c -ENOSPC error.
+ * This means that the input FIFO of sequencer overran, and some events are
+ * lost.
+ * Once this error is returned, the input FIFO is cleared automatically.
+ *
+ * Function returns the byte size of remaining events on the input buffer
+ * if an event is successfully received.
+ * Application can determine from the returned value whether to call
+ * input once more or not.
+ *
+ * \sa snd_seq_event_input_pending(), snd_seq_drop_input()
+ */
+int
+snd_seq_event_input (snd_seq_t * seq, snd_seq_event_t ** evp)
+{
+  static snd_seq_event_t *ev;
+  unsigned char buf[256];
+  int i, l;
+
+  dbg_printf2 ("snd_seq_event_input(seq=%x)\n", seq);
+
+  while (1)
+    {
+
+      if (seq->nextevent < seq->nevents)
+	{
+	  *evp = &seq->events[seq->nextevent++];
+
+	  return (seq->nevents - seq->nextevent) * sizeof (snd_seq_event_t);
+	}
+
+      seq->nextevent = seq->nevents = 0;
+      memset (seq->events, 0, sizeof (seq->events));
+
+      // TODO Handling of nonblocking mode
+      if ((l = read (seq->fd, buf, sizeof (buf))) == -1)
+	return -errno;
+
+      midiparser_input_buf (seq->parser, buf, l);
+
+    }
+
+}
+
+/**
+ * \brief output an event directly to the sequencer NOT through output buffer
+ * \param seq sequencer handle
+ * \param ev event to be output
+ * \return the byte size sent to sequencer or a negative error code
+ *
+ * This function sends an event to the sequencer directly not through the
+ * output buffer.  When the event is a variable length event, a temporary
+ * buffer is allocated inside alsa-lib and the data is copied there before
+ * actually sent.
+ *
+ * \sa snd_seq_event_output()
+ */
+int
+snd_seq_event_output_direct (snd_seq_t * seq, snd_seq_event_t * ev)
+{
+  int err;
+
+  dbg_printf3 ("snd_seq_event_output_direct()\n");
+
+  if ((err = convert_event (seq, ev)) < 0)
+    return err;
+  if ((err = snd_seq_drain_output (seq)) < 0)
+    return err;
+
+  return 0;
+}
+
+/**
+ * \brief (DEPRECATED) free an event
+ *
+ * In the former version, this function was used to
+ * release the event pointer which was allocated by snd_seq_event_input().
+ * In the current version, the event record is not allocated, so
+ * you don't have to call this function any more.
+ */
+int
+snd_seq_free_event (snd_seq_event_t * ev)
+{
+  return 0;
+}
+
+/**
+ * \brief obtain the current client information
+ * \param seq sequencer handle
+ * \param info the pointer to be stored
+ * \return 0 on success otherwise a negative error code
+ *
+ * Obtains the information of the current client stored on info.
+ * client and type fields are ignored.
+ *
+ * \sa snd_seq_get_any_client_info(), snd_seq_set_client_info(),
+ *     snd_seq_query_next_client()
+ */
+int
+snd_seq_get_client_info (snd_seq_t * seq, snd_seq_client_info_t * info)
+{
+  dbg_printf ("snd_seq_get_client_info(seq=%x, info=%x)\n", seq, info);
+
+  return 0;
+}
+
+/**
+ * \brief query the next matching port
+ * \param seq sequencer handle
+ * \param info query pattern and result
+                                                                                
+ * Queries the next matching port on the client specified in
+ * \a info argument.
+ * The search begins at the next port specified in
+ * port field of \a info argument.
+ * For finding the first port at a certain client, give -1.
+ *
+ * If a matching port is found, its attributes are stored on
+ * \a info and function returns zero.
+ * Otherwise, a negative error code is returned.
+ *
+ * \sa snd_seq_get_port_info()
+ */
+int
+snd_seq_query_next_port (snd_seq_t * seq, snd_seq_port_info_t * info)
+{
+  dbg_printf ("snd_seq_query_next_port()\n");
+
+  return -EINVAL;
+}
+
+/**
+ * \brief Set the name of a client_info container
+ * \param info client_info container
+ * \param name name string
+ *
+ * \sa snd_seq_get_client_info(), snd_seq_client_info_get_name(),
+ *     snd_seq_set_client_name()
+ */
+void
+snd_seq_client_info_set_name (snd_seq_client_info_t * info, const char *name)
+{
+  dbg_printf ("snd_seq_client_info_set_name(%s)\n", name);
+
+  strncpy (info->name, name, sizeof (info->name) - 1);
+  info->name[sizeof (info->name) - 1] = 0;
+}
+
+/**
+ * \brief subscribe a port connection
+ * \param seq sequencer handle
+ * \param sub subscription information
+ * \return 0 on success otherwise a negative error code
+ *
+ * Subscribes a connection between two ports.
+ * The subscription information is stored in sub argument.
+ *
+ * \sa snd_seq_get_port_subscription(), snd_seq_unsubscribe_port(),
+ *     snd_seq_connect_from(), snd_seq_connect_to()
+ */
+int
+snd_seq_subscribe_port (snd_seq_t * seq, snd_seq_port_subscribe_t * sub)
+{
+  dbg_printf ("snd_seq_subscribe_port()\n");
+
+  return -EINVAL;
+}
+
+/**
+ * \brief get size of #snd_seq_port_subscribe_t
+ * \return size in bytes
+ */
+size_t
+snd_seq_port_subscribe_sizeof ()
+{
+  return sizeof (snd_seq_port_subscribe_t);
+}
+
+/**
+ * \brief Set sender address of a port_subscribe container
+ * \param info port_subscribe container
+ * \param addr sender address
+ *
+ * \sa snd_seq_subscribe_port(), snd_seq_port_subscribe_get_sender()
+ */
+void
+snd_seq_port_subscribe_set_sender (snd_seq_port_subscribe_t * info,
+				   const snd_seq_addr_t * addr)
+{
+  dbg_printf ("snd_seq_port_subscribe_set_sender()\n");
+}
+
+/**
+ * \brief Set destination address of a port_subscribe container
+ * \param info port_subscribe container
+ * \param addr destination address
+ *
+ * \sa snd_seq_subscribe_port(), snd_seq_port_subscribe_get_dest()
+ */
+void
+snd_seq_port_subscribe_set_dest (snd_seq_port_subscribe_t * info,
+				 const snd_seq_addr_t * addr)
+{
+  dbg_printf ("snd_seq_port_subscribe_set_dest()\n");
+}
+
+/**
+ * \brief Set the queue id of a port_subscribe container
+ * \param info port_subscribe container
+ * \param q queue id
+ *
+ * \sa snd_seq_subscribe_port(), snd_seq_port_subscribe_get_queue()
+ */
+void
+snd_seq_port_subscribe_set_queue (snd_seq_port_subscribe_t * info, int q)
+{
+  dbg_printf ("snd_seq_port_subscribe_set_queue()\n");
+}
+
+/**
+ * \brief Set the real-time mode of a port_subscribe container
+ * \param info port_subscribe container
+ * \param val non-zero to enable
+ *
+ * \sa snd_seq_subscribe_port(), snd_seq_port_subscribe_get_time_real()
+ */
+void
+snd_seq_port_subscribe_set_time_real (snd_seq_port_subscribe_t * info,
+				      int val)
+{
+  dbg_printf ("snd_seq_port_subscribe_set_time_real()\n");
+}
+
+/**
+ * \brief Set the time-update mode of a port_subscribe container
+ * \param info port_subscribe container
+ * \param val non-zero to enable
+ *
+ * \sa snd_seq_subscribe_port(), snd_seq_port_subscribe_get_time_update()
+ */
+void
+snd_seq_port_subscribe_set_time_update (snd_seq_port_subscribe_t * info, int
+					val)
+{
+  dbg_printf ("snd_seq_port_subscribe_set_time_update()\n");
+}
+
+/*
+ * Port
+ */
+
+/**
+ * \brief get size of #snd_seq_port_info_t
+ * \return size in bytes
+ */
+size_t
+snd_seq_port_info_sizeof ()
+{
+  return sizeof (snd_seq_port_info_t);
+}
+
+/**
+ * \brief Get the capability bits of a port_info container
+ * \param info port_info container
+ * \return capability bits
+ *
+ * \sa snd_seq_get_port_info(), snd_seq_port_info_set_capability()
+ */
+unsigned int
+snd_seq_port_info_get_capability (const snd_seq_port_info_t * info)
+{
+  dbg_printf ("snd_seq_port_info_get_capability()\n");
+
+  return info->capability;
+}
+
+/**
+ * \brief Get client/port address of a port_info container
+ * \param info port_info container
+ * \return client/port address pointer
+ *
+ * \sa snd_seq_get_port_info(), snd_seq_port_info_set_addr()
+ */
+const snd_seq_addr_t *
+snd_seq_port_info_get_addr (const snd_seq_port_info_t * info)
+{
+  dbg_printf ("snd_seq_port_info_get_addr(info=%x)\n", info);
+
+  return NULL;			// TODO
+}
+
+/**
+ * \brief set the capability bits of a port_info container
+ * \param info port_info container
+ * \param capability capability bits
+ *
+ * \sa snd_seq_get_port_info(), snd_seq_port_info_get_capability()
+ */
+void
+snd_seq_port_info_set_capability (snd_seq_port_info_t * info,
+				  unsigned int capability)
+{
+  dbg_printf ("snd_seq_port_info_set_capability()\n");
+}
+
+/**
+ * \brief Set the port-specified mode of a port_info container
+ * \param info port_info container
+ * \param val non-zero if specifying the port id at creation
+ *
+ * \sa snd_seq_get_port_info(), snd_seq_port_info_get_port_specified()
+ */
+void
+snd_seq_port_info_set_port_specified (snd_seq_port_info_t * info, int val)
+{
+  dbg_printf ("snd_seq_port_info_set_port_specified()\n");
+}
+
+/**
+ * \brief Get the midi channels of a port_info container
+ * \param info port_info container
+ * \return number of midi channels (default 0)
+ *
+ * \sa snd_seq_get_port_info(), snd_seq_port_info_set_midi_channels()
+ */
+int
+snd_seq_port_info_get_midi_channels (const snd_seq_port_info_t * info)
+{
+  dbg_printf ("snd_seq_port_info_get_midi_channels(info=%x)=%d\n",
+	      info, info->midi_channels);
+
+  return info->midi_channels;
+}
+
+/**
+ * \brief set the midi channels of a port_info container
+ * \param info port_info container
+ * \param channels midi channels (default 0)
+ *
+ * \sa snd_seq_get_port_info(), snd_seq_port_info_get_midi_channels()
+ */
+void
+snd_seq_port_info_set_midi_channels (snd_seq_port_info_t * info, int channels)
+{
+  dbg_printf ("snd_seq_port_info_set_midi_channels(info=%x, channels=%d)\n",
+	      info, channels);
+  info->midi_channels = channels;
+}
+
+/**
+ * \brief Get the queue id to update timestamps
+ * \param info port_info container
+ * \return the queue id to get the timestamps
+ *
+ * \sa snd_seq_get_port_info(), snd_seq_port_info_set_timestamp_queue()
+ */
+int
+snd_seq_port_info_get_timestamp_queue (const snd_seq_port_info_t * info)
+{
+  dbg_printf ("snd_seq_port_info_get_timestamp_queue(info=%x)\n", info);
+
+  return 0;			// TODO
+}
+
+/**
+ * \brief Set the queue id for timestamping
+ * \param info port_info container
+ * \param queue the queue id to get timestamps
+ *
+ * \sa snd_seq_get_port_info(), snd_seq_port_info_get_timestamp_queue()
+ */
+void
+snd_seq_port_info_set_timestamp_queue (snd_seq_port_info_t * info, int queue)
+{
+  dbg_printf ("snd_seq_port_info_set_timestamp_queue(info=%x, queue=%d)\n",
+	      info, queue);
+
+  // TODO
+}
+
+/**
+ * \brief Get whether the time-stamping of the given port is real-time mode
+ * \param info port_info container
+ * \return 1 if the time-stamping is in the real-time mode
+ *
+ * \sa snd_seq_get_port_info(), snd_seq_port_info_set_timestamp_real()
+ */
+int
+snd_seq_port_info_get_timestamp_real (const snd_seq_port_info_t * info)
+{
+  dbg_printf ("snd_seq_port_info_get_timestamp_real(info=%x)\n", info);
+
+  return 0;			// TODO
+}
+
+/**
+ * \brief Set whether the timestime is updated in the real-time mode
+ * \param info port_info container
+ * \param enable non-zero if updating the timestamps in real-time mode
+ *
+ * \sa snd_seq_get_port_info(), snd_seq_port_info_get_timestamp_real()
+ */
+void
+snd_seq_port_info_set_timestamp_real (snd_seq_port_info_t * info, int enable)
+{
+  dbg_printf ("snd_seq_port_info_set_timestamp_real(infp=%x, enable=%d)\n",
+	      info, enable);
+}
+
+/**
+ * \brief Get the time-stamping mode of the given port in a port_info container * \param info port_info container
+ * \return 1 if the port updates timestamps of incoming events
+ *
+ * \sa snd_seq_get_port_info(), snd_seq_port_info_set_timestamping()
+ */
+int
+snd_seq_port_info_get_timestamping (const snd_seq_port_info_t * info)
+{
+  dbg_printf ("snd_seq_port_info_get_timestamping(info=%x)\n", info);
+
+  return 0;			// TODO
+}
+
+/**
+ * \brief Set the time-stamping mode of the given port
+ * \param info port_info container
+ * \param enable non-zero if updating the timestamps of incoming events
+ *
+ * \sa snd_seq_get_port_info(), snd_seq_port_info_get_timestamping()
+ */
+void
+snd_seq_port_info_set_timestamping (snd_seq_port_info_t * info, int enable)
+{
+  dbg_printf ("snd_seq_port_info_set_timestamping(info=%x, enable=%d)\n",
+	      info, enable);
+
+  // TODO
+}
+
+/**
+ * \brief Set the name of a port_info container
+ * \param info port_info container
+ * \param name name string
+ *
+ * \sa snd_seq_get_port_info(), snd_seq_port_info_get_name()
+ */
+void
+snd_seq_port_info_set_name (snd_seq_port_info_t * info, const char *name)
+{
+  dbg_printf ("snd_seq_port_info_set_name()\n");
+
+  strncpy (info->name, name, sizeof (info->name));
+}
+
+/**
+ * \brief Get the name of a port_info container
+ * \param info port_info container
+ * \return name string
+ *
+ * \sa snd_seq_get_port_info(), snd_seq_port_info_set_name()
+ */
+const char *
+snd_seq_port_info_get_name (const snd_seq_port_info_t * info)
+{
+  dbg_printf ("snd_seq_port_info_get_name()\n");
+
+  return "Port Name";
+}
+
+/**
+ * \brief Get port id of a port_info container
+ * \param info port_info container
+ * \return port id
+ *
+ * \sa snd_seq_get_port_info(), snd_seq_port_info_set_port()
+ */
+int
+snd_seq_port_info_get_port (const snd_seq_port_info_t * info)
+{
+  dbg_printf ("snd_seq_port_info_get_port()\n");
+
+  return -EIO;
+}
+
+/**
+ * \brief Get the type bits of a port_info container
+ * \param info port_info container
+ * \return port type bits
+ *
+ * \sa snd_seq_get_port_info(), snd_seq_port_info_set_type()
+ */
+unsigned int
+snd_seq_port_info_get_type (const snd_seq_port_info_t * info)
+{
+  dbg_printf ("snd_seq_port_info_get_type()\n");
+
+  return info->type;
+}
+
+/**
+ * \brief Set the client id of a port_info container
+ * \param info port_info container
+ * \param client client id
+ *
+ * \sa snd_seq_get_port_info(), snd_seq_port_info_get_client()
+ */
+void
+snd_seq_port_info_set_client (snd_seq_port_info_t * info, int client)
+{
+  dbg_printf ("snd_seq_port_info_set_client()\n");
+}
+
+/**
+ * \brief Set the port id of a port_info container
+ * \param info port_info container
+ * \param port port id
+ *
+ * \sa snd_seq_get_port_info(), snd_seq_port_info_get_port()
+ */
+void
+snd_seq_port_info_set_port (snd_seq_port_info_t * info, int port)
+{
+  dbg_printf ("snd_seq_port_info_set_port()\n");
+}
+
+/**
+ * \brief query the next matching client
+ * \param seq sequencer handle
+ * \param info query pattern and result
+ *
+ * Queries the next matching client with the given condition in
+ * info argument.
+ * The search begins at the client with an id one greater than
+ * client field in info.
+ * If name field in info is not empty, the client name is compared.
+ * If a matching client is found, its attributes are stored o
+ * info and returns zero.
+ * Otherwise returns a negative error code.
+ *
+ * \sa snd_seq_get_any_client_info()
+ */
+int
+snd_seq_query_next_client (snd_seq_t * seq, snd_seq_client_info_t * info)
+{
+  dbg_printf ("snd_seq_query_next_client()\n");
+
+  return -EIO;
+}
+
+/**
+ * \brief set the current client information
+ * \param seq sequencer handle
+ * \param info the client info data to set
+ * \return 0 on success otherwise a negative error code
+ *
+ * Obtains the information of the current client stored on info.
+ * client and type fields are ignored.
+ *
+ * \sa snd_seq_get_client_info()
+ */
+int
+snd_seq_set_client_info (snd_seq_t * seq, snd_seq_client_info_t * info)
+{
+  dbg_printf ("snd_seq_set_client_info(seq=%x, info=%x)\n", seq, info);
+
+  if (*info->name)
+    {
+      strcpy (seq->name, info->name);
+      ioctl (seq->fd, SNDCTL_SETNAME, seq->name);
+      ioctl (seq->fd, SNDCTL_SETSONG, seq->name);
+    }
+
+  return 0;
+}
+
+/**
+ * \brief check events in input buffer
+ * \return the byte size of remaining input events on input buffer.
+ *
+ * If events remain on the input buffer of user-space, function returns
+ * the total byte size of events on it.
+ * If fetch_sequencer argument is non-zero,
+ * this function checks the presence of events on sequencer FIFO
+ * When events exist, they are transferred to the input buffer,
+ * and the number of received events are returned.
+ * If fetch_sequencer argument is zero and
+ * no events remain on the input buffer, function simply returns zero.
+ *
+ * \sa snd_seq_event_input()
+ */
+int
+snd_seq_event_input_pending (snd_seq_t * seq, int fetch_sequencer)
+{
+  dbg_printf ("snd_seq_event_input_pending()\n");
+
+  return 0;
+}
+
+/**
+ * \brief Get poll descriptors
+ * \param seq sequencer handle
+ * \param pfds array of poll descriptors
+ * \param space space in the poll descriptor array
+ * \param events polling events to be checked (\c POLLIN and \c POLLOUT)
+ * \return count of filled descriptors
+ *
+ * Get poll descriptors assigned to the sequencer handle.
+ * Since a sequencer handle can duplex streams, you need to set which direction(s)
+ * is/are polled in \a events argument.  When \c POLLIN bit is specified,
+ * the incoming events to the ports are checked.
+ *
+ * To check the returned poll-events, call #snd_seq_poll_descriptors_revents()
+ * instead of reading the pollfd structs directly.
+ *
+ * \sa snd_seq_poll_descriptors_count(), snd_seq_poll_descriptors_revents()
+ */
+int
+snd_seq_poll_descriptors (snd_seq_t * seq, struct pollfd *pfds,
+			  unsigned int space, short events)
+{
+  dbg_printf ("snd_seq_poll_descriptors(seq=%x)\n", seq);
+
+  pfds->fd = seq->fd;
+  pfds->events = 0;
+  pfds->revents = 0;
+
+  if (seq->oss_mode == O_WRONLY || seq->oss_mode == O_RDWR)
+    pfds->events = POLLOUT;
+  if (seq->oss_mode == O_RDONLY || seq->oss_mode == O_RDWR)
+    pfds->events = POLLIN;
+
+  return 1;
+}
+
+
+/**
+ * \brief Returns the number of poll descriptors
+ * \param seq sequencer handle
+ * \param events the poll events to be checked (\c POLLIN and \c POLLOUT)
+ * \return the number of poll descriptors.
+ *
+ * Get the number of poll descriptors.  The polling events to be checked
+ * can be specified by the second argument.  When both input and output
+ * are checked, pass \c POLLIN|POLLOUT
+ *
+ * \sa snd_seq_poll_descriptors()
+ */
+int
+snd_seq_poll_descriptors_count (snd_seq_t * seq, short events)
+{
+  dbg_printf ("snd_seq_poll_descriptors_count(seq=%x, events=%x)\n",
+	      seq, events);
+  return 1;
+}
+
+/**
+ * \brief create a queue
+ * \param seq sequencer handle
+ * \param info queue information to initialize
+ * \return the queue id (zero or positive) on success otherwise a negative error code
+ *
+ * \sa snd_seq_alloc_queue()
+ */
+int
+snd_seq_create_queue (snd_seq_t * seq, snd_seq_queue_info_t * info)
+{
+  dbg_printf ("snd_seq_create_queue()\n");
+
+  return 0;
+}
+
+/**
+ * \brief simple subscription (w/o exclusive & time conversion)
+ * \param myport the port id as sender
+ * \param dest_client destination client id
+ * \param dest_port destination port id
+ * \return 0 on success or negative error code
+ *
+ * Connect from the given receiver port in the current client
+ * to the given destination client:port.
+ *
+ * \sa snd_seq_subscribe_port(), snd_seq_disconnect_to()
+ */
+int
+snd_seq_connect_to (snd_seq_t * seq, int myport, int dest_client,
+		    int dest_port)
+{
+  dbg_printf ("snd_seq_connect_to(%d->%d/%d)\n", myport, dest_client,
+	      dest_port);
+
+  return 0;
+}
+
+/**
+ * \brief simple subscription (w/o exclusive & time conversion)
+ * \param myport the port id as receiver
+ * \param src_client sender client id
+ * \param src_port sender port id
+ * \return 0 on success or negative error code
+ *
+ * Connect from the given sender client:port to the given destination port in the
+ * current client.
+ *
+ * \sa snd_seq_subscribe_port(), snd_seq_disconnect_from()
+ */
+int
+snd_seq_connect_from (snd_seq_t * seq, int myport, int src_client,
+		      int src_port)
+{
+  dbg_printf
+    ("snd_seq_connect_from(seq=%x, myport=%d, src_client=%d, src_port=%d)\n",
+     seq, myport, src_client, src_port);
+
+  return 0;
+}
+
+/**
+ * \brief queue controls - start/stop/continue
+ * \param seq sequencer handle
+ * \param q queue id to control
+ * \param type event type
+ * \param value event value
+ * \param ev event instance
+ *
+ * This function sets up general queue control event and sends it.
+ * To send at scheduled time, set the schedule in \a ev.
+ * If \a ev is NULL, the event is composed locally and sent immediately
+ * to the specified queue.  In any cases, you need to call #snd_seq_drain_output()
+ * appropriately to feed the event.
+ *
+ * \sa snd_seq_alloc_queue()
+ */
+int
+snd_seq_control_queue (snd_seq_t * seq, int q, int type, int value,
+		       snd_seq_event_t * ev)
+{
+  dbg_printf ("snd_seq_control_queue()\n");
+
+  return 0;
+}
+
+/**
+ * \brief drain output buffer to sequencer
+ * \param seq sequencer handle
+ * \return 0 when all events are drained and sent to sequencer.
+ *         When events still remain on the buffer, the byte size of remaining
+ *         events are returned.  On error a negative error code is returned.
+ *
+ * This function drains all pending events on the output buffer.
+ * The function returns immediately after the events are sent to the queues
+ * regardless whether the events are processed or not.
+ * To get synchronization with the all event processes, use
+ * #snd_seq_sync_output_queue() after calling this function.
+ *
+ * \sa snd_seq_event_output(), snd_seq_sync_output_queue()
+ */
+int
+snd_seq_drain_output (snd_seq_t * seq)
+{
+  dbg_printf3 ("snd_seq_drain_output(seq=%x)\n", seq);
+
+  return 0;
+}
+
+
+/**
+ * \brief remove all events on output buffer
+ * \param seq sequencer handle
+ *
+ * Removes all events on both user-space output buffer and
+ * output memory pool on kernel.
+ *
+ * \sa snd_seq_drain_output(), snd_seq_drop_output_buffer(), snd_seq_remove_events()
+ */
+int
+snd_seq_drop_output (snd_seq_t * seq)
+{
+  dbg_printf ("snd_seq_drop_output()\n");
+
+  return 0;
+}
+
+/**
+ * \brief output an event
+ * \param seq sequencer handle
+ * \param ev event to be output
+ * \return the number of remaining events or a negative error code
+ *
+ * An event is once expanded on the output buffer.
+ * The output buffer will be drained automatically if it becomes full.
+ *
+ * If events remain unprocessed on output buffer before drained,
+ * the size of total byte data on output buffer is returned.
+ * If the output buffer is empty, this returns zero.
+ *
+ * \sa snd_seq_event_output_direct(), snd_seq_event_output_buffer(),
+ *    snd_seq_event_output_pending(), snd_seq_drain_output(),
+ *    snd_seq_drop_output(), snd_seq_extract_output(),
+ *    snd_seq_remove_events()
+ */
+int
+snd_seq_event_output (snd_seq_t * seq, snd_seq_event_t * ev)
+{
+  dbg_printf3 ("snd_seq_event_output(seq=%x, ev=%x)\n", seq, ev);
+
+  return convert_event (seq, ev);
+}
+
+/**
+ * \brief delete the specified queue
+ * \param seq sequencer handle
+ * \param q queue id to delete
+ * \return 0 on success otherwise a negative error code
+ *
+ * \sa snd_seq_alloc_queue()
+ */
+int
+snd_seq_free_queue (snd_seq_t * seq, int q)
+{
+  dbg_printf ("snd_seq_free_queue()\n");
+
+  return 0;
+}
+
+/**
+ * \brief obtain the information of the given client
+ * \param seq sequencer handle
+ * \param client client id
+ * \param info the pointer to be stored
+ * \return 0 on success otherwise a negative error code
+ *
+ * Obtains the information of the client with a client id specified by
+ * info argument.
+ * The obtained information is written on info parameter.
+ *
+ * \sa snd_seq_get_client_info()
+ */
+int
+snd_seq_get_any_client_info (snd_seq_t * seq, int client,
+			     snd_seq_client_info_t * info)
+{
+  dbg_printf ("snd_seq_get_any_client_info()\n");
+
+  strcpy (info->name, seq->name);
+
+  return 0;
+}
+
+/**
+ * \brief obtain the information of a port on an arbitrary client
+ * \param seq sequencer handle
+ * \param client client id to get
+ * \param port port id to get
+ * \param info pointer information returns
+ * \return 0 on success otherwise a negative error code
+ *
+ * \sa snd_seq_get_port_info()
+ */
+int
+snd_seq_get_any_port_info (snd_seq_t * seq, int client, int port,
+			   snd_seq_port_info_t * info)
+{
+  dbg_printf ("snd_seq_get_any_port_info()\n");
+
+  return 0;
+}
+
+/**
+ * \brief allocate an empty #snd_seq_port_info_t using standard malloc
+ * \param ptr returned pointer
+ * \return 0 on success otherwise negative error code
+ */
+int
+snd_seq_port_info_malloc (snd_seq_port_info_t ** ptr)
+{
+  snd_seq_port_info_t *p;
+
+  dbg_printf ("snd_seq_port_info_malloc()\n");
+
+  if ((p = malloc (sizeof (*p))) == NULL)
+    return -ENOMEM;
+
+  *ptr = p;
+
+  return 0;
+}
+
+/**
+ * \brief frees a previously allocated #snd_seq_port_info_t
+ * \param pointer to object to free
+ */
+void
+snd_seq_port_info_free (snd_seq_port_info_t * obj)
+{
+  free (obj);
+}
+
+/**
+ * \brief allocate an empty #snd_seq_queue_tempo_t using standard malloc
+ * \param ptr returned pointer
+ * \return 0 on success otherwise negative error code
+ */
+int
+snd_seq_queue_tempo_malloc (snd_seq_queue_tempo_t ** ptr)
+{
+  assert (ptr);
+  *ptr = calloc (1, sizeof (snd_seq_queue_tempo_t));
+  dbg_printf ("snd_seq_queue_tempo_malloc()=%x\n", *ptr);
+  if (!*ptr)
+    return -ENOMEM;
+  return 0;
+}
+
+/**
+ * \brief frees a previously allocated #snd_seq_queue_tempo_t
+ * \param pointer to object to free
+ */
+void
+snd_seq_queue_tempo_free (snd_seq_queue_tempo_t * obj)
+{
+  dbg_printf ("snd_seq_queue_tempo_free(%x)\n", obj);
+  free (obj);
+}
+
+/**
+ * \brief Set the ppq of a queue_status container
+ * \param info queue_status container
+ * \param ppq ppq value
+ *
+ * \sa snd_seq_get_queue_tempo()
+ */
+void
+snd_seq_queue_tempo_set_ppq (snd_seq_queue_tempo_t * info, int ppq)
+{
+  dbg_printf ("snd_seq_queue_tempo_set_ppq(info=%x, %d)\n", info, ppq);
+}
+
+/**
+ * \brief Set the tempo of a queue_status container
+ * \param info queue_status container
+ * \param tempo tempo value
+ *
+ * \sa snd_seq_get_queue_tempo()
+ */
+void
+snd_seq_queue_tempo_set_tempo (snd_seq_queue_tempo_t * info,
+			       unsigned int tempo)
+{
+  dbg_printf ("snd_seq_queue_tempo_set_tempo(info=%x, %d)\n", info, tempo);
+}
+
+/**
+ * \brief get size of #snd_seq_queue_tempo_t
+ * \return size in bytes
+ */
+size_t
+snd_seq_queue_tempo_sizeof ()
+{
+  return sizeof (snd_seq_queue_tempo_t);
+}
+
+/**
+ * \brief set the queue timer information
+ * \param seq sequencer handle
+ * \param q queue id to change the timer
+ * \param timer timer information
+ * \return 0 on success otherwise a negative error code
+ *
+ * \sa snd_seq_get_queue_timer()
+ */
+int
+snd_seq_set_queue_timer (snd_seq_t * seq, int q,
+			 snd_seq_queue_timer_t * timer)
+{
+  dbg_printf ("snd_seq_get_queue_timer(seq=%x, q=%d, timer=%X)\n", seq, q,
+	      timer);
+  return -ENXIO;		// TODO
+}
+
+
+/**
+ * \brief Opens a new connection to the timer query interface.
+ * \param timer Returned handle (NULL if not wanted)
+ * \param name ASCII identifier of the RawMidi handle
+ * \param mode Open mode
+ * \return 0 on success otherwise a negative error code
+ *
+ * Opens a new connection to the RawMidi interface specified with
+ * an ASCII identifier and mode.
+ */
+int
+snd_timer_query_open (snd_timer_query_t ** timer, const char *name, int mode)
+{
+  dbg_printf ("snd_timer_query_open(name=%s, mode=%x)\n", name, mode);
+  return -ENXIO;		// TODO
+}
+
+/**
+ * \brief obtain the current tempo of the queue
+ * \param seq sequencer handle
+ * \param q queue id to be queried
+ * \param tempo pointer to store the current tempo
+ * \return 0 on success otherwise a negative error code
+ *
+ * \sa snd_seq_set_queue_tempo()
+ */
+int
+snd_seq_get_queue_tempo (snd_seq_t * seq, int q,
+			 snd_seq_queue_tempo_t * tempo)
+{
+  dbg_printf ("snd_seq_get_queue_tempo(seq=%x, q=%d, tempo=%x)\n", seq, q,
+	      tempo);
+
+  return 0;
+}
+
+/**
+ * \brief allocate an empty #snd_seq_client_info_t using standard malloc
+ * \param ptr returned pointer
+ * \return 0 on success otherwise negative error code
+ */
+int
+snd_seq_client_info_malloc (snd_seq_client_info_t ** ptr)
+{
+  dbg_printf ("snd_seq_client_info_malloc()\n");
+
+  *ptr = malloc (sizeof (snd_seq_client_info_t));
+  if (!*ptr)
+    return -ENOMEM;
+  return 0;
+}
+
+/**
+ * \brief frees a previously allocated #snd_seq_client_info_t
+ * \param pointer to object to free
+ */
+void
+snd_seq_client_info_free (snd_seq_client_info_t * obj)
+{
+  dbg_printf ("snd_seq_client_info_free()\n");
+
+  free (obj);
+}
+
+/**
+ * \brief Get the name of a client_info container
+ * \param info client_info container
+ * \return name string
+ *
+ * \sa snd_seq_get_client_info(), snd_seq_client_info_set_name()
+ */
+const char *
+snd_seq_client_info_get_name (snd_seq_client_info_t * info)
+{
+  dbg_printf ("snd_seq_client_info_get_name()\n");
+  return "OSS seq client";
+}
+
+/**
+ * \brief Get the number of opened ports of a client_info container
+ * \param info client_info container
+ * \return number of opened ports
+ *
+ * \sa snd_seq_get_client_info()
+ */
+int
+snd_seq_client_info_get_num_ports (const snd_seq_client_info_t * info)
+{
+  dbg_printf ("snd_seq_client_info_get_num_ports()\n");
+
+  return 1;
+}
+
+/**
+ * \brief Get size of #snd_seq_system_info_t
+ * \return size in bytes
+ */
+size_t
+snd_seq_system_info_sizeof ()
+{
+  return sizeof (snd_seq_system_info_t);
+}
+
+
+/**
+ * \brief Allocate an empty #snd_seq_system_info_t using standard malloc
+ * \param ptr returned pointer
+ * \return 0 on success otherwise negative error code
+ */
+int
+snd_seq_system_info_malloc (snd_seq_system_info_t ** ptr)
+{
+  dbg_printf ("snd_seq_system_info_malloc()\n");
+
+  *ptr = malloc (sizeof (snd_seq_system_info_t));
+  if (*ptr == NULL)
+    return -ENOMEM;
+  return 0;
+}
+
+/**
+ * \brief Frees a previously allocated #snd_seq_system_info_t
+ * \param pointer to object to free
+ */
+void
+snd_seq_system_info_free (snd_seq_system_info_t * obj)
+{
+  free (obj);
+}
+
+/**
+ * \brief obtain the sequencer system information
+ * \param seq sequencer handle
+ * \param info the pointer to be stored
+ * \return 0 on success otherwise a negative error code
+ *
+ * Stores the global system information of ALSA sequencer system.
+ * The returned data contains
+ * the maximum available numbers of queues, clients, ports and channels.
+ */
+int
+snd_seq_system_info (snd_seq_t * seq, snd_seq_system_info_t * info)
+{
+  dbg_printf ("snd_seq_system_info()\n");
+
+  return 0;
+}
+
+/**
+ * \brief Get maximum number of clients
+ * \param info #snd_seq_system_info_t container
+ * \return maximum number of clients
+ *
+ * \sa snd_seq_system_info()
+ */
+int
+snd_seq_system_info_get_clients (const snd_seq_system_info_t * info)
+{
+  dbg_printf ("snd_seq_system_info_get_clients()\n");
+
+  return 4;
+}
+
+/**
+ * \brief Get maximum number of queues
+ * \param info #snd_seq_system_info_t container
+ * \return maximum number of queues
+ *
+ * \sa snd_seq_system_info()
+ */
+int
+snd_seq_system_info_get_queues (const snd_seq_system_info_t * info)
+{
+  dbg_printf ("snd_seq_system_info_get_queues(info=%x)\n", info);
+
+  return 1;			// TODO
+}
+
+/**
+ * \brief Get maximum number of ports
+ * \param info #snd_seq_system_info_t container
+ * \return maximum number of ports
+ *
+ * \sa snd_seq_system_info()
+ */
+int
+snd_seq_system_info_get_ports (const snd_seq_system_info_t * info)
+{
+  dbg_printf ("snd_seq_system_info_get_ports()\n");
+
+  return 4;
+}
+
+/**
+ * \brief allocate a queue with the specified name
+ * \param seq sequencer handle
+ * \param name the name of the new queue
+ * \return the queue id (zero or positive) on success otherwise a negative error code
+ *
+ * \sa snd_seq_alloc_queue()
+ */
+int
+snd_seq_alloc_named_queue (snd_seq_t * seq, const char *name)
+{
+  dbg_printf ("snd_seq_alloc_named_queue(seq=%x, name=%s)\n", seq, name);
+
+  return 0;
+}
+
+
+/**
+ * \brief Get client id of a port_info container
+ * \param info port_info container
+ * \return client id
+ *
+ * \sa snd_seq_get_port_info(), snd_seq_port_info_set_client()
+ */
+int
+snd_seq_port_info_get_client (const snd_seq_port_info_t * info)
+{
+  dbg_printf ("snd_seq_port_info_get_client()\n");
+
+  return 0;
+}
+
+/**
+ * \brief Get the port-specified mode of a port_info container
+ * \param info port_info container
+ * \return 1 if port id is specified at creation
+ *
+ * \sa snd_seq_get_port_info(), snd_seq_port_info_set_port_specified()
+ */
+int
+snd_seq_port_info_get_port_specified (const snd_seq_port_info_t * info)
+{
+  dbg_printf ("snd_seq_port_info_get_port_specified()\n");
+
+  return 0;
+}
+
+/**
+ * \brief Get the type bits of a port_info container
+ * \param info port_info container
+ * \return port type bits
+ *
+ * \sa snd_seq_get_port_info(), snd_seq_port_info_get_type()
+ */
+void
+snd_seq_port_info_set_type (snd_seq_port_info_t * info, unsigned int type)
+{
+  dbg_printf ("snd_seq_port_info_set_type(%u)\n", type);
+}
+
+
+/**
+ * \brief Get the ppq of a queue_status container
+ * \param info queue_status container
+ * \return ppq value
+ *
+ * \sa snd_seq_get_queue_tempo()
+ */
+int
+snd_seq_queue_tempo_get_ppq (const snd_seq_queue_tempo_t * info)
+{
+  dbg_printf ("snd_seq_queue_tempo_get_ppq()\n");
+
+  return 0;
+}
+
+
+/**
+ * \brief Get the tempo of a queue_status container
+ * \param info queue_status container
+ * \return tempo value
+ *
+ * \sa snd_seq_get_queue_tempo()
+ */
+unsigned int
+snd_seq_queue_tempo_get_tempo (const snd_seq_queue_tempo_t * info)
+{
+  dbg_printf ("snd_seq_queue_tempo_get_tempo()\n");
+
+  return 0;
+}
+
+/**
+ * \brief set the tempo of the queue
+ * \param seq sequencer handle
+ * \param q queue id to change the tempo
+ * \param tempo tempo information
+ * \return 0 on success otherwise a negative error code
+ *
+ * \sa snd_seq_get_queue_tempo()
+ */
+int
+snd_seq_set_queue_tempo (snd_seq_t * seq, int q,
+			 snd_seq_queue_tempo_t * tempo)
+{
+  dbg_printf ("snd_seq_set_queue_tempo(seq=%x, q=%d, tempo=%x)\n", seq, q,
+	      tempo);
+
+  return 0;
+}
+
+/**
+ * \brief allocate a queue
+ * \param seq sequencer handle
+ * \return the queue id (zero or positive) on success otherwise a negative error code
+ *
+ * \sa snd_seq_alloc_named_queue(), snd_seq_create_queue(), snd_seq_free_queue(),
+ *     snd_seq_get_queue_info()
+ */
+int
+snd_seq_alloc_queue (snd_seq_t * seq)
+{
+  static int queue_num = 0;
+  dbg_printf ("snd_seq_alloc_queue(seq=%x)=%d\n", seq, queue_num);
+
+  return queue_num++;
+}
+
+#define FIXED_EV(x)	(_SND_SEQ_TYPE(SND_SEQ_EVFLG_FIXED) | _SND_SEQ_TYPE(x))
+
+/** Event types conversion array */
+const unsigned int snd_seq_event_types[256] = {
+  [SND_SEQ_EVENT_SYSTEM...SND_SEQ_EVENT_RESULT]
+    = FIXED_EV (SND_SEQ_EVFLG_RESULT),
+  [SND_SEQ_EVENT_NOTE]
+    =
+    FIXED_EV (SND_SEQ_EVFLG_NOTE) |
+    _SND_SEQ_TYPE_OPT (SND_SEQ_EVFLG_NOTE_TWOARG),
+  [SND_SEQ_EVENT_NOTEON...SND_SEQ_EVENT_KEYPRESS] =
+    FIXED_EV (SND_SEQ_EVFLG_NOTE),
+  [SND_SEQ_EVENT_CONTROLLER...SND_SEQ_EVENT_REGPARAM] =
+    FIXED_EV (SND_SEQ_EVFLG_CONTROL),
+  [SND_SEQ_EVENT_START...SND_SEQ_EVENT_STOP] = FIXED_EV (SND_SEQ_EVFLG_QUEUE),
+  [SND_SEQ_EVENT_SETPOS_TICK]
+    =
+    FIXED_EV (SND_SEQ_EVFLG_QUEUE) |
+    _SND_SEQ_TYPE_OPT (SND_SEQ_EVFLG_QUEUE_TICK),
+  [SND_SEQ_EVENT_SETPOS_TIME] =
+    FIXED_EV (SND_SEQ_EVFLG_QUEUE) |
+    _SND_SEQ_TYPE_OPT (SND_SEQ_EVFLG_QUEUE_TIME),
+  [SND_SEQ_EVENT_TEMPO...SND_SEQ_EVENT_SYNC_POS] =
+    FIXED_EV (SND_SEQ_EVFLG_QUEUE) |
+    _SND_SEQ_TYPE_OPT (SND_SEQ_EVFLG_QUEUE_VALUE),
+  [SND_SEQ_EVENT_TUNE_REQUEST...SND_SEQ_EVENT_SENSING] =
+    FIXED_EV (SND_SEQ_EVFLG_NONE),
+  [SND_SEQ_EVENT_ECHO...SND_SEQ_EVENT_OSS] =
+    FIXED_EV (SND_SEQ_EVFLG_RAW) | FIXED_EV (SND_SEQ_EVFLG_SYSTEM),
+  [SND_SEQ_EVENT_CLIENT_START...SND_SEQ_EVENT_PORT_CHANGE] =
+    FIXED_EV (SND_SEQ_EVFLG_MESSAGE),
+  [SND_SEQ_EVENT_PORT_SUBSCRIBED...SND_SEQ_EVENT_PORT_UNSUBSCRIBED] =
+    FIXED_EV (SND_SEQ_EVFLG_CONNECTION),
+  [SND_SEQ_EVENT_USR0...SND_SEQ_EVENT_USR9] =
+    FIXED_EV (SND_SEQ_EVFLG_RAW) | FIXED_EV (SND_SEQ_EVFLG_USERS),
+  [SND_SEQ_EVENT_SYSEX...SND_SEQ_EVENT_BOUNCE] =
+    _SND_SEQ_TYPE (SND_SEQ_EVFLG_VARIABLE),
+  [SND_SEQ_EVENT_USR_VAR0...SND_SEQ_EVENT_USR_VAR4] =
+    _SND_SEQ_TYPE (SND_SEQ_EVFLG_VARIABLE) |
+    _SND_SEQ_TYPE (SND_SEQ_EVFLG_USERS),
+  [SND_SEQ_EVENT_NONE] = FIXED_EV (SND_SEQ_EVFLG_NONE),
+};
+
+/**
+ * \brief obtain the running state of the queue
+ * \param seq sequencer handle
+ * \param q queue id to query
+ * \param status pointer to store the current status
+ * \return 0 on success otherwise a negative error code
+ *
+ * Obtains the running state of the specified queue q.
+ */
+int
+snd_seq_get_queue_status (snd_seq_t * seq, int q,
+			  snd_seq_queue_status_t * status)
+{
+  dbg_printf ("snd_seq_get_queue_status(seq=%x. q=%d)\n", seq, q);
+
+  return 0;
+}
+
+/**
+ * \brief allocate an empty #snd_seq_queue_status_t using standard malloc
+ * \param ptr returned pointer
+ * \return 0 on success otherwise negative error code
+ */
+int
+snd_seq_queue_status_malloc (snd_seq_queue_status_t ** ptr)
+{
+  dbg_printf ("snd_seq_queue_status_malloc()\n");
+  *ptr = calloc (1, sizeof (snd_seq_queue_status_t));
+  dbg_printf ("snd_seq_queue_status_malloc()=%x\n", *ptr);
+  if (!*ptr)
+    return -ENOMEM;
+  return 0;
+}
+
+/**
+ * \brief frees a previously allocated #snd_seq_queue_status_t
+ * \param pointer to object to free
+ */
+void
+snd_seq_queue_status_free (snd_seq_queue_status_t * obj)
+{
+  dbg_printf ("snd_seq_queue_status_free(%x)\n", obj);
+
+  free (obj);
+}
+
+/**
+ * \brief Get the tick time of a queue_status container
+ * \param info queue_status container
+ * \return tick time
+ *
+ * \sa snd_seq_get_queue_status()
+ */
+snd_seq_tick_time_t
+snd_seq_queue_status_get_tick_time (const snd_seq_queue_status_t * info)
+{
+  dbg_printf ("snd_seq_queue_status_get_tick_time(info=%x)\n", info);
+
+  return 0;
+}
+
+/**
+ * \brief get size of #snd_seq_remove_events_t
+ * \return size in bytes
+ */
+size_t
+snd_seq_remove_events_sizeof ()
+{
+  return sizeof (snd_seq_remove_events_t);
+}
+
+/**
+ * \brief allocate an empty #snd_seq_remove_events_t using standard malloc
+ * \param ptr returned pointer
+ * \return 0 on success otherwise negative error code
+ */
+int
+snd_seq_remove_events_malloc (snd_seq_remove_events_t ** ptr)
+{
+  assert (ptr);
+  *ptr = calloc (1, sizeof (snd_seq_remove_events_t));
+  dbg_printf ("snd_seq_remove_events_malloc()=%x\n", *ptr);
+  if (!*ptr)
+    return -ENOMEM;
+  return 0;
+}
+
+/**
+ * \brief frees a previously allocated #snd_seq_remove_events_t
+ * \param pointer to object to free
+ */
+void
+snd_seq_remove_events_free (snd_seq_remove_events_t * obj)
+{
+  free (obj);
+}
+
+/**
+ * \brief Set the removal condition bits
+ * \param info remove_events container
+ * \param flags removal condition bits
+ *
+ * \sa snd_seq_remove_events()
+ */
+void
+snd_seq_remove_events_set_condition (snd_seq_remove_events_t * info,
+				     unsigned int flags)
+{
+  dbg_printf ("snd_seq_remove_events_set_condition(rmp=%x, flags=%lu)\n",
+	      info, flags);
+}
+
+/**
+ * \brief Set the queue as removal condition
+ * \param info remove_events container
+ * \param queue queue id
+ *
+ * \sa snd_seq_remove_events()
+ */
+void
+snd_seq_remove_events_set_queue (snd_seq_remove_events_t * info, int queue)
+{
+  dbg_printf ("snd_seq_remove_events_set_queue(rmp=%x, q=%d)\n", info, queue);
+}
+
+/**
+ * \brief remove events on input/output buffers and pools
+ * \param seq sequencer handle
+ * \param rmp remove event container
+ *
+ * Removes matching events with the given condition from input/output buffers
+ * and pools.
+ * The removal condition is specified in \a rmp argument.
+ *
+ * \sa snd_seq_event_output(), snd_seq_drop_output(), snd_seq_reset_pool_output()
+ */
+int
+snd_seq_remove_events (snd_seq_t * seq, snd_seq_remove_events_t * rmp)
+{
+  dbg_printf ("snd_seq_remove_events(seq=%x, rmp=%x)\n", seq, rmp);
+
+  return 1;
+}
+
+
+/**
+ * \brief clear input buffer and and remove events in sequencer queue
+ * \param seq sequencer handle
+ *
+ * \sa snd_seq_drop_input_buffer(), snd_seq_remove_events()
+ */
+int
+snd_seq_drop_input (snd_seq_t * seq)
+{
+  dbg_printf ("snd_seq_drop_input(seq=%x)\n", seq);
+
+  return 0;
+}
+
+/**
+ * \brief remove all events on user-space output buffer
+ * \param seq sequencer handle
+ *
+ * Removes all events on user-space output buffer.
+ * Unlike snd_seq_drain_output(), this function doesn't remove
+ * events on output memory pool of sequencer.
+ *
+ * \sa snd_seq_drop_output()
+ */
+int
+snd_seq_drop_output_buffer (snd_seq_t * seq)
+{
+  dbg_printf ("snd_seq_drop_output_buffer(seq=%x)\n", seq);
+
+  return 0;
+}
+
+/**
+ * \brief extract the first event in output buffer
+ * \param seq sequencer handle
+ * \param ev_res event pointer to be extracted
+ * \return 0 on success otherwise a negative error code
+ *
+ * Extracts the first event in output buffer.
+ * If ev_res is NULL, just remove the event.
+ *
+ * \sa snd_seq_event_output()
+ */
+int
+snd_seq_extract_output (snd_seq_t * seq, snd_seq_event_t ** ev_res)
+{
+  dbg_printf ("snd_seq_extract_output(seq=%x)\n", seq);
+
+  return -EIO;
+}
+
+/**
+ * \brief get size of #snd_seq_queue_status_t
+ * \return size in bytes
+ */
+size_t
+snd_seq_queue_status_sizeof ()
+{
+  return sizeof (snd_seq_queue_status_t);
+}
+
+/**
+ * \brief Return the size of output buffer
+ * \param seq sequencer handle
+ * \return the size of output buffer in bytes
+ *
+ * Obtains the size of output buffer.
+ * This buffer is used to store decoded byte-stream of output events
+ * before transferring to sequencer.
+ *
+ * \sa snd_seq_set_output_buffer_size()
+ */
+size_t
+snd_seq_get_output_buffer_size (snd_seq_t * seq)
+{
+  dbg_printf ("snd_seq_get_output_buffer_size(seq=%x)\n", seq);
+
+  return 1024;
+}
+
+/**
+ * \brief Change the size of output buffer
+ * \param seq sequencer handle
+ * \param size the size of output buffer to be changed in bytes
+ * \return 0 on success otherwise a negative error code
+ *
+ * Changes the size of output buffer.
+ *
+ * \sa snd_seq_get_output_buffer_size()
+ */
+int
+snd_seq_set_output_buffer_size (snd_seq_t * seq, size_t size)
+{
+  dbg_printf ("snd_seq_set_output_buffer_size(seq=%x, size=%d)\n", seq, size);
+  return 0;
+}
+
+/**
+ * \brief unsubscribe a connection between ports
+ * \param seq sequencer handle
+ * \param sub subscription information to disconnect
+ * \return 0 on success otherwise a negative error code
+ *
+ * Unsubscribes a connection between two ports,
+ * described in sender and dest fields in sub argument.
+ *
+ * \sa snd_seq_subscribe_port(), snd_seq_disconnect_from(), snd_seq_disconnect_to()
+ */
+int
+snd_seq_unsubscribe_port (snd_seq_t * seq, snd_seq_port_subscribe_t * sub)
+{
+  dbg_printf ("snd_seq_unsubscribe_port(seq=%x, sub=%x)\n", seq, sub);
+
+  return 0;
+}
+
+/**
+ * \brief Get the queue id of a queue_timer container
+ * \param info queue_timer container
+ * \return queue id
+ *
+ * \sa snd_seq_get_queue_timer()
+ */
+int
+snd_seq_queue_timer_get_queue (const snd_seq_queue_timer_t * info)
+{
+  dbg_printf ("snd_seq_queue_timer_get_queue(timer=%x)\n", info);
+
+  return 0;
+}
+
+/**
+ * \brief obtain the queue timer information
+ * \param seq sequencer handle
+ * \param q queue id to query
+ * \param timer pointer to store the timer information
+ * \return 0 on success otherwise a negative error code
+ *
+ * \sa snd_seq_set_queue_timer()
+ */
+int
+snd_seq_get_queue_timer (snd_seq_t * seq, int q,
+			 snd_seq_queue_timer_t * timer)
+{
+  dbg_printf ("snd_seq_get_queue_timer(seq=%x, q=%d, timer=%x)\n",
+	      seq, 1, timer);
+
+  return 0;
+}
+
+/**
+ * \brief Set the timer id of a queue_timer container
+ * \param info queue_timer container
+ * \param id timer id pointer
+ *
+ * \sa snd_seq_get_queue_timer()
+ */
+void
+snd_seq_queue_timer_set_id (snd_seq_queue_timer_t * info,
+			    const snd_timer_id_t * id)
+{
+  dbg_printf ("snd_seq_queue_timer_set_id(timer=%x, id=%x)\n", info, id);
+}
+
+/**
+ * \brief get size of #snd_seq_queue_timer_t
+ * \return size in bytes
+ */
+size_t
+snd_seq_queue_timer_sizeof ()
+{
+  return sizeof (snd_seq_queue_timer_t);
+}
+
+/**
+ * \brief get size of #snd_seq_query_subscribe_t
+ * \return size in bytes
+ */
+size_t
+snd_seq_query_subscribe_sizeof ()
+{
+  return sizeof (snd_seq_query_subscribe_t);
+}
+
+/**
+ * \brief allocate an empty #snd_seq_query_subscribe_t using standard malloc
+ * \param ptr returned pointer
+ * \return 0 on success otherwise negative error code
+ */
+int
+snd_seq_query_subscribe_malloc (snd_seq_query_subscribe_t ** ptr)
+{
+  *ptr = calloc (1, sizeof (snd_seq_query_subscribe_t));
+
+  dbg_printf ("snd_seq_query_subscribe_malloc()=%x\n", *ptr);
+  if (!*ptr)
+    return -ENOMEM;
+  return 0;
+}
+
+/**
+ * \brief frees a previously allocated #snd_seq_query_subscribe_t
+ * \param pointer to object to free
+ */
+void
+snd_seq_query_subscribe_free (snd_seq_query_subscribe_t * obj)
+{
+  dbg_printf ("snd_seq_query_subscribe_free(obj=%x)\n", obj);
+  free (obj);
+}
+
+/**
+ * \brief Get the address of subscriber of a query_subscribe container
+ * \param info query_subscribe container
+ * \return subscriber's address pointer
+ *
+ * \sa snd_seq_query_port_subscribers()
+ */
+const snd_seq_addr_t *
+snd_seq_query_subscribe_get_addr (const snd_seq_query_subscribe_t * info)
+{
+  dbg_printf ("snd_seq_query_subscribe_get_addr(info=%x)\n", info);
+
+  return NULL;			// TODO
+}
+
+/**
+ * \brief Get the index of subscriber of a query_subscribe container
+ * \param info query_subscribe container
+ * \return subscriber's index
+ *
+ * \sa snd_seq_query_port_subscribers(), snd_seq_query_subscribe_set_index()
+ */
+int
+snd_seq_query_subscribe_get_index (const snd_seq_query_subscribe_t * info)
+{
+  dbg_printf ("snd_seq_query_subscribe_get_index(info=%x)\n", info);
+
+  return 0;			// TODO
+}
+
+/**
+ * \brief Set the subscriber's index to be queried
+ * \param info query_subscribe container
+ * \param index index to be queried
+ *
+ * \sa snd_seq_query_port_subscribers(), snd_seq_query_subscribe_get_index()
+ */
+void
+snd_seq_query_subscribe_set_index (snd_seq_query_subscribe_t * info,
+				   int index)
+{
+  dbg_printf ("snd_seq_query_subscribe_t(info=%x, index=%d)\n", info, index);
+
+  // TODO
+}
+
+/**
+ * \brief Get the client/port address of a query_subscribe container
+ * \param info query_subscribe container
+ * \return client/port address pointer
+ *
+ * \sa snd_seq_query_port_subscribers(), snd_seq_query_subscribe_set_root()
+ */
+const snd_seq_addr_t *
+snd_seq_query_subscribe_get_root (const snd_seq_query_subscribe_t * info)
+{
+  dbg_printf ("snd_seq_query_subscribe_get_root(info=%x)\n", info);
+
+  return NULL;			// TODO
+}
+
+/**
+ * \brief Set the client/port address of a query_subscribe container
+ * \param info query_subscribe container
+ * \param addr client/port address pointer
+ *
+ * \sa snd_seq_query_port_subscribers(), snd_seq_query_subscribe_get_root()
+ */
+void
+snd_seq_query_subscribe_set_root (snd_seq_query_subscribe_t * info,
+				  const snd_seq_addr_t * addr)
+{
+  dbg_printf ("snd_seq_query_subscribe_set_root(info=%d, addr=%x)\n",
+	      info, addr);
+}
+
+/**
+ * \brief Get the query type of a query_subscribe container
+ * \param info query_subscribe container
+ * \return query type
+ *
+ * \sa snd_seq_query_port_subscribers(), snd_seq_query_subscribe_set_type()
+ */
+snd_seq_query_subs_type_t
+snd_seq_query_subscribe_get_type (const snd_seq_query_subscribe_t * info)
+{
+  dbg_printf ("snd_seq_query_subscribe_get_type(info=%x)\n", info);
+
+  return 0;			// TODO
+}
+
+/**
+ * \brief Set the query type of a query_subscribe container
+ * \param info query_subscribe container
+ * \param type query type
+ *
+ * \sa snd_seq_query_port_subscribers(), snd_seq_query_subscribe_get_type()
+ */
+void
+snd_seq_query_subscribe_set_type (snd_seq_query_subscribe_t * info,
+				  snd_seq_query_subs_type_t type)
+{
+  dbg_printf ("snd_seq_query_subscribe_set_type(info=%x, type=%x)\n",
+	      info, type);
+
+  // TODO
+}
+
+/**
+ * \brief obtain subscription information
+ * \param seq sequencer handle
+ * \param sub pointer to return the subscription information
+ * \return 0 on success otherwise a negative error code
+ *
+ * \sa snd_seq_subscribe_port(), snd_seq_query_port_subscribers()
+ */
+int
+snd_seq_get_port_subscription (snd_seq_t * seq,
+			       snd_seq_port_subscribe_t * sub)
+{
+  dbg_printf ("snd_seq_get_port_subscription(seq=%x, sub=%x)\n", seq, sub);
+
+  return 0;			// TODO
+}
+
+/**
+ * \brief query port subscriber list
+ * \param seq sequencer handle
+ * \param subs subscription to query
+ * \return 0 on success otherwise a negative error code
+ *
+ * Queries the subscribers accessing to a port.
+ * The query information is specified in subs argument.
+ *
+ * At least, the client id, the port id, the index number and
+ * the query type must be set to perform a proper query.
+ * As the query type, #SND_SEQ_QUERY_SUBS_READ or #SND_SEQ_QUERY_SUBS_WRITE
+ * can be specified to check whether the readers or the writers to the port.
+ * To query the first subscription, set 0 to the index number.  To list up
+ * all the subscriptions, call this function with the index numbers from 0
+ * until this returns a negative value.
+ *
+ * \sa snd_seq_get_port_subscription()
+ */
+int
+snd_seq_query_port_subscribers (snd_seq_t * seq, snd_seq_query_subscribe_t *
+				subs)
+{
+  dbg_printf ("snd_seq_query_port_subscribers(seq=%x, subs=%x)\n", seq, subs);
+
+  return 0;			// TODO
+}
+
+/**
+ * \brief Get the real time of a queue_status container
+ * \param info queue_status container
+ * \param time real time
+ *
+ * \sa snd_seq_get_queue_status()
+ */
+const snd_seq_real_time_t *
+snd_seq_queue_status_get_real_time (const snd_seq_queue_status_t * info)
+{
+  dbg_printf ("snd_seq_queue_status_get_real_time(info=%x)\n", info);
+
+  return NULL;			// TODO
+}