Upto: Table of Contents of full book "Programming and Using Linux Sound"

ALSA

ALSA has some support for MIDI devices by a sequencer API. Clients can send MIDI events to the sequencer and it will play them according to the timing of the events. Other clients can then receive these sequenced events and, for example, synthesize them.

Resources

Introduction

ALSA suplies a sequencer that can receive MIDI events from one set of clients and play them according to the timing information in the events to other clients. The clients that can send such events are file readers such as aplaymidi or other sequencers. Clients can also read events as they should be played. Possible consuming clients include splitters, routers or soft synthesizers such as Timidity.

Timidity can be run as ALSA sequencer client which will consume MIDI events and synthesize them. From The TiMidity Howto - Using TiMidity as the ALSA sequencer client

	
timidity -iA -B2,8 -Os -EFreverb=0
	
      

On my computer this produced

	
Requested buffer size 2048, fragment size 1024
ALSA pcm 'default' set buffer size 2048, period size 680 bytes
TiMidity starting in ALSA server mode
Opening sequencer port: 129:0 129:1 129:2 129:3
	
      

and then sat there waiting for a connection to be made.

FluidSynth can also be used as a server ( Ted's Linux MIDI Guide ):

	
 fluidsynth --server --audio-driver=alsa -C0 -R1 -l /usr/share/soundfonts/FluidR3_GM.sf2 
	
      

The ALSA sequencer sends MIDI "wire" events. This does not include MIDI file events such as Text or Lyric Meta-events. This makes it pretty useless for a Karaoke player. It is possible to modify the file reader aplaymid to send Meta Events to, say, a listener (like the Java MetaEventListener), but as these come from the file reader rather than the sequencer they generally arrive well before the time they will get sequenced to be played. Pity.

Programs such as pykaraoke make use of the ALSA sequencer. However, in order to get the timing of the lyrics right it includes a MIDI file parser and basically acts as a second sequencer just to extract and display the Text/Lyric events.

aconnect

the program aconnect.c can be used to test for sequencer servers and clients such as sequencers. I have set two clients running: Timidity and seqdemo (discussed later). The command

	
aconnect -o
	
      

shows

	
client 14: 'Midi Through' [type=kernel]
    0 'Midi Through Port-0'
client 128: 'TiMidity' [type=user]
    0 'TiMidity port 0 '
    1 'TiMidity port 1 '
    2 'TiMidity port 2 '
    3 'TiMidity port 3 '
client 129: 'ALSA Sequencer Demo' [type=user]
    0 'ALSA Sequencer Demo'
	
      

When run with the -i option it produces

      
$aconnect -i
client 0: 'System' [type=kernel]
    0 'Timer           '
    1 'Announce        '
client 14: 'Midi Through' [type=kernel]
    0 'Midi Through Port-0'
      
    

The program aconnect can establish a connection between input and output clients by

      
aconnect in out
      
    

The code for aconnect.c is from SourceArchive

      
      /*
 ** connect / disconnect two subscriber ports
 **   ver.0.1.3
 **
 ** Copyright (C) 1999 Takashi Iwai
 ** 
 **  This program is free software; you can redistribute it and/or modify
 **  it under the terms of the GNU General Public License version 2 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 General Public License for more details.
 **
 **/

#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <fcntl.h>
#include <getopt.h>
#include <stdarg.h>
#include <sys/ioctl.h>
#include <alsa/asoundlib.h>

static void error_handler(const char *file, int line, const char *function, int err, const char *fmt, ...)
{
      va_list arg;

      if (err == ENOENT)      /* Ignore those misleading "warnings" */
            return;
      va_start(arg, fmt);
      fprintf(stderr, "ALSA lib %s:%i:(%s) ", file, line, function);
      vfprintf(stderr, fmt, arg);
      if (err)
            fprintf(stderr, ": %s", snd_strerror(err));
      putc('\n', stderr);
      va_end(arg);
}

static void usage(void)
{
      fprintf(stderr, "aconnect - ALSA sequencer connection manager\n");
      fprintf(stderr, "Copyright (C) 1999-2000 Takashi Iwai\n");
      fprintf(stderr, "Usage:\n");
      fprintf(stderr, " * Connection/disconnection between two ports\n");
      fprintf(stderr, "   aconnect [-options] sender receiver\n");
      fprintf(stderr, "     sender, receiver = client:port pair\n");
      fprintf(stderr, "     -d,--disconnect     disconnect\n");
      fprintf(stderr, "     -e,--exclusive      exclusive connection\n");
      fprintf(stderr, "     -r,--real #         convert real-time-stamp on queue\n");
      fprintf(stderr, "     -t,--tick #         convert tick-time-stamp on queue\n");
      fprintf(stderr, " * List connected ports (no subscription action)\n");
      fprintf(stderr, "   aconnect -i|-o [-options]\n");
      fprintf(stderr, "     -i,--input          list input (readable) ports\n");
      fprintf(stderr, "     -o,--output         list output (writable) ports\n");
      fprintf(stderr, "     -l,--list           list current connections of each port\n");
      fprintf(stderr, " * Remove all exported connections\n");
      fprintf(stderr, "     -x, --removeall\n");
}

/*
 *  * check permission (capability) of specified port
 *   */

#define LIST_INPUT      1
#define LIST_OUTPUT     2

#define perm_ok(pinfo,bits) ((snd_seq_port_info_get_capability(pinfo) & (bits)) == (bits))

static int check_permission(snd_seq_port_info_t *pinfo, int perm)
{
      if (perm) {
            if (perm & LIST_INPUT) {
                  if (perm_ok(pinfo, SND_SEQ_PORT_CAP_READ|SND_SEQ_PORT_CAP_SUBS_READ))
                        goto __ok;
            }
            if (perm & LIST_OUTPUT) {
                  if (perm_ok(pinfo, SND_SEQ_PORT_CAP_WRITE|SND_SEQ_PORT_CAP_SUBS_WRITE))
                        goto __ok;
            }
            return 0;
      }
 __ok:
      if (snd_seq_port_info_get_capability(pinfo) & SND_SEQ_PORT_CAP_NO_EXPORT)
            return 0;
      return 1;
}

/*
 *  * list subscribers of specified type
 *   */
static void list_each_subs(snd_seq_t *seq, snd_seq_query_subscribe_t *subs, int type, const char *msg)
{
      int count = 0;
      snd_seq_query_subscribe_set_type(subs, type);
      snd_seq_query_subscribe_set_index(subs, 0);
      while (snd_seq_query_port_subscribers(seq, subs) >= 0) {
            const snd_seq_addr_t *addr;
            if (count++ == 0)
                  printf("\t%s: ", msg);
            else
                  printf(", ");
            addr = snd_seq_query_subscribe_get_addr(subs);
            printf("%d:%d", addr->client, addr->port);
            if (snd_seq_query_subscribe_get_exclusive(subs))
                  printf("[ex]");
            if (snd_seq_query_subscribe_get_time_update(subs))
                  printf("[%s:%d]",
                         (snd_seq_query_subscribe_get_time_real(subs) ? "real" : "tick"),
                         snd_seq_query_subscribe_get_queue(subs));
            snd_seq_query_subscribe_set_index(subs, snd_seq_query_subscribe_get_index(subs) + 1);
      }
      if (count > 0)
            printf("\n");
}

/*
 *  * list subscribers
 *   */
static void list_subscribers(snd_seq_t *seq, const snd_seq_addr_t *addr)
{
      snd_seq_query_subscribe_t *subs;
      snd_seq_query_subscribe_alloca(&subs);
      snd_seq_query_subscribe_set_root(subs, addr);
      list_each_subs(seq, subs, SND_SEQ_QUERY_SUBS_READ, "Connecting To");
      list_each_subs(seq, subs, SND_SEQ_QUERY_SUBS_WRITE, "Connected From");
}

/*
 *  * search all ports
 *   */
typedef void (*action_func_t)(snd_seq_t *seq, snd_seq_client_info_t *cinfo, snd_seq_port_info_t *pinfo, int count);

static void do_search_port(snd_seq_t *seq, int perm, action_func_t do_action)
{
      snd_seq_client_info_t *cinfo;
      snd_seq_port_info_t *pinfo;
      int count;

      snd_seq_client_info_alloca(&cinfo);
      snd_seq_port_info_alloca(&pinfo);
      snd_seq_client_info_set_client(cinfo, -1);
      while (snd_seq_query_next_client(seq, cinfo) >= 0) {
            /* reset query info */
            snd_seq_port_info_set_client(pinfo, snd_seq_client_info_get_client(cinfo));
            snd_seq_port_info_set_port(pinfo, -1);
            count = 0;
            while (snd_seq_query_next_port(seq, pinfo) >= 0) {
                  if (check_permission(pinfo, perm)) {
                        do_action(seq, cinfo, pinfo, count);
                        count++;
                  }
            }
      }
}


static void print_port(snd_seq_t *seq, snd_seq_client_info_t *cinfo,
                   snd_seq_port_info_t *pinfo, int count)
{
      if (! count) {
            printf("client %d: '%s' [type=%s]\n",
                   snd_seq_client_info_get_client(cinfo),
                   snd_seq_client_info_get_name(cinfo),
                   (snd_seq_client_info_get_type(cinfo) == SND_SEQ_USER_CLIENT ? "user" : "kernel"));
      }
      printf("  %3d '%-16s'\n",
             snd_seq_port_info_get_port(pinfo),
             snd_seq_port_info_get_name(pinfo));
}

static void print_port_and_subs(snd_seq_t *seq, snd_seq_client_info_t *cinfo,
                        snd_seq_port_info_t *pinfo, int count)
{
      print_port(seq, cinfo, pinfo, count);
      list_subscribers(seq, snd_seq_port_info_get_addr(pinfo));
}


/*
 *  * remove all (exported) connections
 *   */
static void remove_connection(snd_seq_t *seq, snd_seq_client_info_t *cinfo,
                        snd_seq_port_info_t *pinfo, int count)
{
      snd_seq_query_subscribe_t *query;

      snd_seq_query_subscribe_alloca(&query);
      snd_seq_query_subscribe_set_root(query, snd_seq_port_info_get_addr(pinfo));

      snd_seq_query_subscribe_set_type(query, SND_SEQ_QUERY_SUBS_READ);
      snd_seq_query_subscribe_set_index(query, 0);
      for (; snd_seq_query_port_subscribers(seq, query) >= 0;
           snd_seq_query_subscribe_set_index(query, snd_seq_query_subscribe_get_index(query) + 1)) {
            snd_seq_port_info_t *port;
            snd_seq_port_subscribe_t *subs;
            const snd_seq_addr_t *sender = snd_seq_query_subscribe_get_root(query);
            const snd_seq_addr_t *dest = snd_seq_query_subscribe_get_addr(query);
            snd_seq_port_info_alloca(&port);
            if (snd_seq_get_any_port_info(seq, dest->client, dest->port, port) < 0)
                  continue;
            if (!(snd_seq_port_info_get_capability(port) & SND_SEQ_PORT_CAP_SUBS_WRITE))
                  continue;
            if (snd_seq_port_info_get_capability(port) & SND_SEQ_PORT_CAP_NO_EXPORT)
                  continue;
            snd_seq_port_subscribe_alloca(&subs);
            snd_seq_port_subscribe_set_queue(subs, snd_seq_query_subscribe_get_queue(query));
            snd_seq_port_subscribe_set_sender(subs, sender);
            snd_seq_port_subscribe_set_dest(subs, dest);
            snd_seq_unsubscribe_port(seq, subs);
      }

      snd_seq_query_subscribe_set_type(query, SND_SEQ_QUERY_SUBS_WRITE);
      snd_seq_query_subscribe_set_index(query, 0);
      for (; snd_seq_query_port_subscribers(seq, query) >= 0;
           snd_seq_query_subscribe_set_index(query, snd_seq_query_subscribe_get_index(query) + 1)) {
            snd_seq_port_info_t *port;
            snd_seq_port_subscribe_t *subs;
            const snd_seq_addr_t *dest = snd_seq_query_subscribe_get_root(query);
            const snd_seq_addr_t *sender = snd_seq_query_subscribe_get_addr(query);
            snd_seq_port_info_alloca(&port);
            if (snd_seq_get_any_port_info(seq, sender->client, sender->port, port) < 0)
                  continue;
            if (!(snd_seq_port_info_get_capability(port) & SND_SEQ_PORT_CAP_SUBS_READ))
                  continue;
            if (snd_seq_port_info_get_capability(port) & SND_SEQ_PORT_CAP_NO_EXPORT)
                  continue;
            snd_seq_port_subscribe_alloca(&subs);
            snd_seq_port_subscribe_set_queue(subs, snd_seq_query_subscribe_get_queue(query));
            snd_seq_port_subscribe_set_sender(subs, sender);
            snd_seq_port_subscribe_set_dest(subs, dest);
            snd_seq_unsubscribe_port(seq, subs);
      }
}

static void remove_all_connections(snd_seq_t *seq)
{
      do_search_port(seq, 0, remove_connection);
}


/*
 *  * main..
 *   */

enum {
      SUBSCRIBE, UNSUBSCRIBE, LIST, REMOVE_ALL
};

static struct option long_option[] = {
      {"disconnect", 0, NULL, 'd'},
      {"input", 0, NULL, 'i'},
      {"output", 0, NULL, 'o'},
      {"real", 1, NULL, 'r'},
      {"tick", 1, NULL, 't'},
      {"exclusive", 0, NULL, 'e'},
      {"list", 0, NULL, 'l'},
      {"removeall", 0, NULL, 'x'},
      {NULL, 0, NULL, 0},
};

int main(int argc, char **argv)
{
      int c;
      snd_seq_t *seq;
      int queue = 0, convert_time = 0, convert_real = 0, exclusive = 0;
      int command = SUBSCRIBE;
      int list_perm = 0;
      int client;
      int list_subs = 0;
      snd_seq_port_subscribe_t *subs;
      snd_seq_addr_t sender, dest;

      while ((c = getopt_long(argc, argv, "dior:t:elx", long_option, NULL)) != -1) {
            switch (c) {
            case 'd':
                  command = UNSUBSCRIBE;
                  break;
            case 'i':
                  command = LIST;
                  list_perm |= LIST_INPUT;
                  break;
            case 'o':
                  command = LIST;
                  list_perm |= LIST_OUTPUT;
                  break;
            case 'e':
                  exclusive = 1;
                  break;
            case 'r':
                  queue = atoi(optarg);
                  convert_time = 1;
                  convert_real = 1;
                  break;
            case 't':
                  queue = atoi(optarg);
                  convert_time = 1;
                  convert_real = 0;
                  break;
            case 'l':
                  list_subs = 1;
                  break;
            case 'x':
                  command = REMOVE_ALL;
                  break;
            default:
                  usage();
                  exit(1);
            }
      }

      if (snd_seq_open(&seq, "default", SND_SEQ_OPEN_DUPLEX, 0) < 0) {
            fprintf(stderr, "can't open sequencer\n");
            return 1;
      }
      
      snd_lib_error_set_handler(error_handler);

      switch (command) {
      case LIST:
            do_search_port(seq, list_perm,
                         list_subs ? print_port_and_subs : print_port);
            snd_seq_close(seq);
            return 0;
      case REMOVE_ALL:
            remove_all_connections(seq);
            snd_seq_close(seq);
            return 0;
      }

      /* connection or disconnection */

      if (optind + 2 > argc) {
            snd_seq_close(seq);
            usage();
            exit(1);
      }

      if ((client = snd_seq_client_id(seq)) < 0) {
            snd_seq_close(seq);
            fprintf(stderr, "can't get client id\n");
            return 1;
      }

      /* set client info */
      if (snd_seq_set_client_name(seq, "ALSA Connector") < 0) {
            snd_seq_close(seq);
            fprintf(stderr, "can't set client info\n");
            return 1;
      }

      /* set subscription */
      if (snd_seq_parse_address(seq, &sender, argv[optind]) < 0) {
            snd_seq_close(seq);
            fprintf(stderr, "invalid sender address %s\n", argv[optind]);
            return 1;
      }
      if (snd_seq_parse_address(seq, &dest, argv[optind + 1]) < 0) {
            snd_seq_close(seq);
            fprintf(stderr, "invalid destination address %s\n", argv[optind + 1]);
            return 1;
      }
      snd_seq_port_subscribe_alloca(&subs);
      snd_seq_port_subscribe_set_sender(subs, &sender);
      snd_seq_port_subscribe_set_dest(subs, &dest);
      snd_seq_port_subscribe_set_queue(subs, queue);
      snd_seq_port_subscribe_set_exclusive(subs, exclusive);
      snd_seq_port_subscribe_set_time_update(subs, convert_time);
      snd_seq_port_subscribe_set_time_real(subs, convert_real);

      if (command == UNSUBSCRIBE) {
            if (snd_seq_get_port_subscription(seq, subs) < 0) {
                  snd_seq_close(seq);
                  fprintf(stderr, "No subscription is found\n");
                  return 1;
            }
            if (snd_seq_unsubscribe_port(seq, subs) < 0) {
                  snd_seq_close(seq);
                  fprintf(stderr, "Disconnection failed (%s)\n", snd_strerror(errno));
                  return 1;
            }
      } else {
            if (snd_seq_get_port_subscription(seq, subs) == 0) {
                  snd_seq_close(seq);
                  fprintf(stderr, "Connection is already subscribed\n");
                  return 1;
            }
            if (snd_seq_subscribe_port(seq, subs) < 0) {
                  snd_seq_close(seq);
                  fprintf(stderr, "Connection failed (%s)\n", snd_strerror(errno));
                  return 1;
            }
      }

      snd_seq_close(seq);

      return 0;
}


      
    

seqdemo

The code for seqdemo.c is

      
      /* seqdemo.c by Matthias Nagorni */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <alsa/asoundlib.h>

snd_seq_t *open_seq();
void midi_action(snd_seq_t *seq_handle);

snd_seq_t *open_seq() {

  snd_seq_t *seq_handle;
  int portid;

  if (snd_seq_open(&seq_handle, "default", SND_SEQ_OPEN_INPUT, 0) < 0) {
    fprintf(stderr, "Error opening ALSA sequencer.\n");
    exit(1);
  }
  snd_seq_set_client_name(seq_handle, "ALSA Sequencer Demo");
  if ((portid = snd_seq_create_simple_port(seq_handle, "ALSA Sequencer Demo",
            SND_SEQ_PORT_CAP_WRITE|SND_SEQ_PORT_CAP_SUBS_WRITE,
            SND_SEQ_PORT_TYPE_APPLICATION)) < 0) {
    fprintf(stderr, "Error creating sequencer port.\n");
    exit(1);
  }
  return(seq_handle);
}

void midi_action(snd_seq_t *seq_handle) {

  snd_seq_event_t *ev;

  do {
    snd_seq_event_input(seq_handle, &ev);
    switch (ev->type) {
      case SND_SEQ_EVENT_CONTROLLER: 
        fprintf(stderr, "Control event on Channel %2d: %5d       \r",
                ev->data.control.channel, ev->data.control.value);
        break;
      case SND_SEQ_EVENT_PITCHBEND:
        fprintf(stderr, "Pitchbender event on Channel %2d: %5d   \r", 
                ev->data.control.channel, ev->data.control.value);
        break;
      case SND_SEQ_EVENT_NOTEON:
        fprintf(stderr, "Note On event on Channel %2d: %5d       \r",
                ev->data.control.channel, ev->data.note.note);
        break;        
      case SND_SEQ_EVENT_NOTEOFF: 
        fprintf(stderr, "Note Off event on Channel %2d: %5d      \r",         
                ev->data.control.channel, ev->data.note.note);           
        break;        
    }
    snd_seq_free_event(ev);
  } while (snd_seq_event_input_pending(seq_handle, 0) > 0);
}

int main(int argc, char *argv[]) {

  snd_seq_t *seq_handle;
  int npfd;
  struct pollfd *pfd;
    
  seq_handle = open_seq();
  npfd = snd_seq_poll_descriptors_count(seq_handle, POLLIN);
  pfd = (struct pollfd *)alloca(npfd * sizeof(struct pollfd));
  snd_seq_poll_descriptors(seq_handle, pfd, npfd, POLLIN);
  while (1) {
    if (poll(pfd, npfd, 100000) > 0) {
      midi_action(seq_handle);
    }  
  }
}

      
    

aplaymidi

The program aplaymidi will play to a backend MIDI synthesizer such as TiMidity. It requires a port name, which can be found by

       
aplaymidi -l
       
     

with output such as

       
 Port    Client name                      Port name
 14:0    Midi Through                     Midi Through Port-0
128:0    TiMidity                         TiMidity port 0
128:1    TiMidity                         TiMidity port 1
128:2    TiMidity                         TiMidity port 2
128:3    TiMidity                         TiMidity port 3
131:0    aseqdump                         aseqdump
       
     

The port numbers are the same as those used by aconnect. These are not the Alsa device names (hw:0, etc) but are special to the Alsa sequencer API.

It can then play a MIDI file to one of these ports as in

	
aplaymidi -p 128:0 54154.mid
	
      

The code can be found from SourceArchive.com

Raw MIDI ports

From RawMidi interface

[The] RawMidi Interface is designed to write or read raw (unchanged) MIDI data over the MIDI line without any timestamps defined in interface.

Raw MIDI phyical devices

The raw MIDI interface is typically used to manage hardware MIDI devices. For example, if I plug in an Edirol SD-20 synthesizer to a USB port, it shows under amidi as

      
$amidi -l
Dir Device    Name
IO  hw:2,0,0  SD-20 Part A
IO  hw:2,0,1  SD-20 Part B
I   hw:2,0,2  SD-20 MIDI
      
    

These names use the same pattern as Alsa playback and record devices of hw:....

Raw MIDI virtual devices

The Linux kernel module snd_virmidi can create virtual raw MIDI devices. First add the modules ( Using TiMidity++ with ALSA raw MIDI and AlsaMidiOverview)

      
modprobe snd-seq snd-virmidi
      
    

This will bring virtual devices both into the ALSA raw MIDI and into the ALSA sequencer spaces:

      
$amidi -l
Dir Device    Name
IO  hw:3,0    Virtual Raw MIDI (16 subdevices)
IO  hw:3,1    Virtual Raw MIDI (16 subdevices)
IO  hw:3,2    Virtual Raw MIDI (16 subdevices)
IO  hw:3,3    Virtual Raw MIDI (16 subdevices)

$aplaymidi -l
 Port    Client name                      Port name
 14:0    Midi Through                     Midi Through Port-0
 28:0    Virtual Raw MIDI 3-0             VirMIDI 3-0
 29:0    Virtual Raw MIDI 3-1             VirMIDI 3-1
 30:0    Virtual Raw MIDI 3-2             VirMIDI 3-2
 31:0    Virtual Raw MIDI 3-3             VirMIDI 3-3
      
    

Mapping MIDI clients into MIDI raw space

Some programs/APIs use the Alsa sequencer space; others use the Alsa raw MIDI space. Virtual ports allow a client using one space to use a client from a different space.

For example, TiMidity can be run as a sequencer client by

      
timidity -iA -B2,8 -Os -EFreverb=0
      
    

This only shows in the sequencer space, not in the raw MIDI space, and shows to aconnect -o as

      
$aconnect -o
client 14: 'Midi Through' [type=kernel]
    0 'Midi Through Port-0'
client 28: 'Virtual Raw MIDI 3-0' [type=kernel]
    0 'VirMIDI 3-0     '
client 29: 'Virtual Raw MIDI 3-1' [type=kernel]
    0 'VirMIDI 3-1     '
client 30: 'Virtual Raw MIDI 3-2' [type=kernel]
    0 'VirMIDI 3-2     '
client 31: 'Virtual Raw MIDI 3-3' [type=kernel]
    0 'VirMIDI 3-3     '
client 128: 'TiMidity' [type=user]
    0 'TiMidity port 0 '
    1 'TiMidity port 1 '
    2 'TiMidity port 2 '
    3 'TiMidity port 3 '
      
    

while aconnect -i shows the virtual ports as

      
$aconnect -i
client 0: 'System' [type=kernel]
    0 'Timer           '
    1 'Announce        '
client 14: 'Midi Through' [type=kernel]
    0 'Midi Through Port-0'
client 28: 'Virtual Raw MIDI 3-0' [type=kernel]
    0 'VirMIDI 3-0     '
client 29: 'Virtual Raw MIDI 3-1' [type=kernel]
    0 'VirMIDI 3-1     '
client 30: 'Virtual Raw MIDI 3-2' [type=kernel]
    0 'VirMIDI 3-2     '
client 31: 'Virtual Raw MIDI 3-3' [type=kernel]
    0 'VirMIDI 3-3     '
      
    

Virtual Raw MIDI 3-0 can then be connected to TiMidity port 0 by

      
aconnect 28:0 128:0
      
    

Clients can then send MIDI messages to the raw MIDI device hw:3,0 and TiMidity will synthesize them. We will use this in the next chapter by showing how to replace the default Java synthesizer by TiMidity.

Turning off all notes

If you have something playing out to a device or softsynth, then if that something gets interrupted, it may not finish playing cleanly. For example, it may have started a NOTE ON on some channel but because of the interrupt will not have sent a note off. The synthesizer will continue to play the note.

To stop it playing, using amidi to send 'raw' MIDI commands. The hexadecimal sequence "00 B0 7B 00" will send "all notes off on channel zero". Similarly, the command "00 B1 7B 00" will send "all notes off on channel one" and there are only 16 possible channels.

The relevant commands for a raw device on port hw:1,0 are

amidi -p hw:1,0 -S "00 B0 7B 00"
...
    

Conclusion

This chapter has briefly discussed the MIDI models available under Alsa. While there is a substantial programming API behind this, we have mainly used the commands amidi, aplaymidi and aconnect.


Copyright © Jan Newmarch, jan@newmarch.name
Creative Commons License
"Programming and Using Linux Sound - in depth" by Jan Newmarch is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License .
Based on a work at https://jan.newmarch.name/LinuxSound/ .

If you like this book, please contribute using PayPal

Or Flattr me:
Flattr this book