Logo Search packages:      
Sourcecode: alsa-utils version File versions

arecordmidi.c

/*
 * arecordmidi.c - record standard MIDI files from sequencer ports
 *
 * Copyright (c) 2004-2005 Clemens Ladisch <clemens@ladisch.de>
 *
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  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.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */

/* TODO: sequencer queue timer selection */

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <signal.h>
#include <getopt.h>
#include <sys/poll.h>
#include <alsa/asoundlib.h>
#include "aconfig.h"
#include "version.h"

#define BUFFER_SIZE 4088

/* linked list of buffers, stores data as in the .mid file */
struct buffer {
      struct buffer *next;
      unsigned char buf[BUFFER_SIZE];
};

struct smf_track {
      int size;               /* size of entire data */
      int cur_buf_size;       /* size of cur_buf */
      struct buffer *cur_buf;
      snd_seq_tick_time_t last_tick;      /* end of track */
      unsigned char last_command;   /* used for running status */
      int used;               /* anything record on this track */
      struct buffer first_buf;      /* list head */
};

/* timing/sysex + 16 channels */
#define TRACKS_PER_PORT 17

/* metronome settings */
/* TODO: create options for this */
#define METRONOME_CHANNEL 9
#define METRONOME_STRONG_NOTE 34
#define METRONOME_WEAK_NOTE 33
#define METRONOME_VELOCITY 100
#define METRONOME_PROGRAM 0

static snd_seq_t *seq;
static int client;
static int port_count;
static snd_seq_addr_t *ports;
static int queue;
static int smpte_timing = 0;
static int beats = 120;
static int frames;
static int ticks = 0;
static FILE *file;
static int channel_split;
static int num_tracks;
static struct smf_track *tracks;
static volatile sig_atomic_t stop = 0;
static int use_metronome = 0;
static snd_seq_addr_t metronome_port;
static int metronome_weak_note = METRONOME_WEAK_NOTE;
static int metronome_strong_note = METRONOME_STRONG_NOTE;
static int metronome_velocity = METRONOME_VELOCITY;
static int metronome_program = METRONOME_PROGRAM;
static int metronome_channel = METRONOME_CHANNEL;
static int ts_num = 4; /* time signature: numerator */
static int ts_div = 4; /* time signature: denominator */
static int ts_dd = 2; /* time signature: denominator as a power of two */


/* prints an error message to stderr, and dies */
static void fatal(const char *msg, ...)
{
      va_list ap;

      va_start(ap, msg);
      vfprintf(stderr, msg, ap);
      va_end(ap);
      fputc('\n', stderr);
      exit(EXIT_FAILURE);
}

/* memory allocation error handling */
static void check_mem(void *p)
{
      if (!p)
            fatal("Out of memory");
}

/* error handling for ALSA functions */
static void check_snd(const char *operation, int err)
{
      if (err < 0)
            fatal("Cannot %s - %s", operation, snd_strerror(err));
}

static void init_seq(void)
{
      int err;

      /* open sequencer */
      err = snd_seq_open(&seq, "default", SND_SEQ_OPEN_DUPLEX, 0);
      check_snd("open sequencer", err);

      /* find out our client's id */
      client = snd_seq_client_id(seq);
      check_snd("get client id", client);

      /* set our client's name */
      err = snd_seq_set_client_name(seq, "arecordmidi");
      check_snd("set client name", err);
}

/* parses one or more port addresses from the string */
static void parse_ports(const char *arg)
{
      char *buf, *s, *port_name;
      int err;

      /* make a copy of the string because we're going to modify it */
      buf = strdup(arg);
      check_mem(buf);

      for (port_name = s = buf; s; port_name = s + 1) {
            /* Assume that ports are separated by commas.  We don't use
             * spaces because those are valid in client names. */
            s = strchr(port_name, ',');
            if (s)
                  *s = '\0';

            ++port_count;
            ports = realloc(ports, port_count * sizeof(snd_seq_addr_t));
            check_mem(ports);

            err = snd_seq_parse_address(seq, &ports[port_count - 1], port_name);
            if (err < 0)
                  fatal("Invalid port %s - %s", port_name, snd_strerror(err));
      }

      free(buf);
}

/* parses the metronome port address */
static void init_metronome(const char *arg)
{
      int err;

      err = snd_seq_parse_address(seq, &metronome_port, arg);
      if (err < 0)
            fatal("Invalid port %s - %s", arg, snd_strerror(err));
      use_metronome = 1;
}

/* parses time signature specification */
static void time_signature(const char *arg)
{
      long x = 0;
      char *sep;

      x = strtol(arg, &sep, 10);
      if (x < 1 || x > 64 || *sep != ':')
            fatal("Invalid time signature (%s)", arg);
      ts_num = x;
      x = strtol(++sep, NULL, 10);
      if (x < 1 || x > 64)
            fatal("Invalid time signature (%s)", arg);
      ts_div = x;
      for (ts_dd = 0; x > 1; x /= 2)
            ++ts_dd;
}

/*
 * Metronome implementation
 */
static void metronome_note(unsigned char note, unsigned int tick)
{
      snd_seq_event_t ev;
      snd_seq_ev_clear(&ev);
      snd_seq_ev_set_note(&ev, metronome_channel, note, metronome_velocity, 1);
      snd_seq_ev_schedule_tick(&ev, queue, 0, tick);
      snd_seq_ev_set_source(&ev, port_count);
      snd_seq_ev_set_subs(&ev);
      snd_seq_event_output(seq, &ev);
}

static void metronome_echo(unsigned int tick)
{
      snd_seq_event_t ev;
      snd_seq_ev_clear(&ev);
      ev.type = SND_SEQ_EVENT_USR0;
      snd_seq_ev_schedule_tick(&ev, queue, 0, tick);
      snd_seq_ev_set_source(&ev, port_count);
      snd_seq_ev_set_dest(&ev, client, port_count);
      snd_seq_event_output(seq, &ev);
}

static void metronome_pattern(unsigned int tick)
{
      int j, t, duration;

      t = tick;
      duration = ticks * 4 / ts_div;
      for (j = 0; j < ts_num; j++) {
            metronome_note(j ? metronome_weak_note : metronome_strong_note, t);
            t += duration;
      }
      metronome_echo(t);
      snd_seq_drain_output(seq);
}

static void metronome_set_program(void)
{
      snd_seq_event_t ev;

      snd_seq_ev_clear(&ev);
      snd_seq_ev_set_pgmchange(&ev, metronome_channel, metronome_program);
      snd_seq_ev_set_source(&ev, port_count);
      snd_seq_ev_set_subs(&ev);
      snd_seq_event_output(seq, &ev);
}

static void init_tracks(void)
{
      int i;

      /* MIDI RP-019 says we need at least one track per port */
      num_tracks = port_count;
      /* Allocate one track for each possible channel.
       * Empty tracks won't be written to the file. */
      if (channel_split)
            num_tracks *= TRACKS_PER_PORT;

      tracks = calloc(num_tracks, sizeof(struct smf_track));
      check_mem(tracks);
      for (i = 0; i < num_tracks; ++i)
            tracks[i].cur_buf = &tracks[i].first_buf;
}

static void create_queue(void)
{
      snd_seq_queue_tempo_t *tempo;
      int err;

      queue = snd_seq_alloc_named_queue(seq, "arecordmidi");
      check_snd("create queue", queue);

      snd_seq_queue_tempo_alloca(&tempo);
      if (!smpte_timing) {
            snd_seq_queue_tempo_set_tempo(tempo, 60000000 / beats);
            snd_seq_queue_tempo_set_ppq(tempo, ticks);
      } else {
            /*
             * ALSA doesn't know about the SMPTE time divisions, so
             * we pretend to have a musical tempo with the equivalent
             * number of ticks/s.
             */
            switch (frames) {
            case 24:
                  snd_seq_queue_tempo_set_tempo(tempo, 500000);
                  snd_seq_queue_tempo_set_ppq(tempo, 12 * ticks);
                  break;
            case 25:
                  snd_seq_queue_tempo_set_tempo(tempo, 400000);
                  snd_seq_queue_tempo_set_ppq(tempo, 10 * ticks);
                  break;
            case 29:
                  snd_seq_queue_tempo_set_tempo(tempo, 100000000);
                  snd_seq_queue_tempo_set_ppq(tempo, 2997 * ticks);
                  break;
            case 30:
                  snd_seq_queue_tempo_set_tempo(tempo, 500000);
                  snd_seq_queue_tempo_set_ppq(tempo, 15 * ticks);
                  break;
            default:
                  fatal("Invalid SMPTE frames %d", frames);
            }
      }
      err = snd_seq_set_queue_tempo(seq, queue, tempo);
      if (err < 0)
            fatal("Cannot set queue tempo (%u/%i)",
                  snd_seq_queue_tempo_get_tempo(tempo),
                  snd_seq_queue_tempo_get_ppq(tempo));
}

static void create_ports(void)
{
      snd_seq_port_info_t *pinfo;
      int i, err;
      char name[32];

      snd_seq_port_info_alloca(&pinfo);

      /* common information for all our ports */
      snd_seq_port_info_set_capability(pinfo,
                               SND_SEQ_PORT_CAP_WRITE |
                               SND_SEQ_PORT_CAP_SUBS_WRITE);
      snd_seq_port_info_set_type(pinfo,
                           SND_SEQ_PORT_TYPE_MIDI_GENERIC |
                           SND_SEQ_PORT_TYPE_APPLICATION);
      snd_seq_port_info_set_midi_channels(pinfo, 16);

      /* we want to know when the events got delivered to us */
      snd_seq_port_info_set_timestamping(pinfo, 1);
      snd_seq_port_info_set_timestamp_queue(pinfo, queue);

      /* our port number is the same as our port index */
      snd_seq_port_info_set_port_specified(pinfo, 1);
      for (i = 0; i < port_count; ++i) {
            snd_seq_port_info_set_port(pinfo, i);

            sprintf(name, "arecordmidi port %i", i);
            snd_seq_port_info_set_name(pinfo, name);

            err = snd_seq_create_port(seq, pinfo);
            check_snd("create port", err);
      }

      /* create an optional metronome port */
      if (use_metronome) {
            snd_seq_port_info_set_port(pinfo, port_count);
            snd_seq_port_info_set_name(pinfo, "arecordmidi metronome");
            snd_seq_port_info_set_capability(pinfo,
                                     SND_SEQ_PORT_CAP_READ |
                                     SND_SEQ_PORT_CAP_WRITE);
            snd_seq_port_info_set_type(pinfo, SND_SEQ_PORT_TYPE_APPLICATION);
            snd_seq_port_info_set_midi_channels(pinfo, 0);
            snd_seq_port_info_set_timestamping(pinfo, 0);
            err = snd_seq_create_port(seq, pinfo);
            check_snd("create metronome port", err);
      }
}

static void connect_ports(void)
{
      int i, err;

      for (i = 0; i < port_count; ++i) {
            err = snd_seq_connect_from(seq, i, ports[i].client, ports[i].port);
            if (err < 0)
                  fatal("Cannot connect from port %d:%d - %s",
                        ports[i].client, ports[i].port, snd_strerror(err));
      }

      /* subscribe the metronome port */
      if (use_metronome) {
              err = snd_seq_connect_to(seq, port_count, metronome_port.client, metronome_port.port);
            if (err < 0)
                  fatal("Cannot connect to port %d:%d - %s",
                        metronome_port.client, metronome_port.port, snd_strerror(err));
      }
}

/* records a byte to be written to the .mid file */
static void add_byte(struct smf_track *track, unsigned char byte)
{
      /* make sure we have enough room in the current buffer */
      if (track->cur_buf_size >= BUFFER_SIZE) {
            track->cur_buf->next = calloc(1, sizeof(struct buffer));
            if (!track->cur_buf->next)
                  fatal("out of memory");
            track->cur_buf = track->cur_buf->next;
            track->cur_buf_size = 0;
      }

      track->cur_buf->buf[track->cur_buf_size++] = byte;
      track->size++;
}

/* record a variable-length quantity */
static void var_value(struct smf_track *track, int v)
{
      if (v >= (1 << 28))
            add_byte(track, 0x80 | ((v >> 28) & 0x03));
      if (v >= (1 << 21))
            add_byte(track, 0x80 | ((v >> 21) & 0x7f));
      if (v >= (1 << 14))
            add_byte(track, 0x80 | ((v >> 14) & 0x7f));
      if (v >= (1 << 7))
            add_byte(track, 0x80 | ((v >> 7) & 0x7f));
      add_byte(track, v & 0x7f);
}

/* record the delta time from the last event */
static void delta_time(struct smf_track *track, const snd_seq_event_t *ev)
{
      int diff = ev->time.tick - track->last_tick;
      if (diff < 0)
            diff = 0;
      var_value(track, diff);
      track->last_tick = ev->time.tick;
}

/* record a status byte (or not if we can use running status) */
static void command(struct smf_track *track, unsigned char cmd)
{
      if (cmd != track->last_command)
            add_byte(track, cmd);
      track->last_command = cmd < 0xf0 ? cmd : 0;
}

/* put port numbers into all tracks */
static void record_port_numbers(void)
{
      int i;

      for (i = 0; i < num_tracks; ++i) {
            var_value(&tracks[i], 0);
            add_byte(&tracks[i], 0xff);
            add_byte(&tracks[i], 0x21);
            var_value(&tracks[i], 1);
            if (channel_split)
                  add_byte(&tracks[i], i / TRACKS_PER_PORT);
            else
                  add_byte(&tracks[i], i);
      }
}

static void record_event(const snd_seq_event_t *ev)
{
      unsigned int i;
      struct smf_track *track;

      /* ignore events without proper timestamps */
      if (ev->queue != queue || !snd_seq_ev_is_tick(ev))
            return;

      /* determine which track to record to */
      i = ev->dest.port;
      if (i == port_count) {
            if (ev->type == SND_SEQ_EVENT_USR0)
                  metronome_pattern(ev->time.tick);
            return;
      }
      if (channel_split) {
            i *= TRACKS_PER_PORT;
            if (snd_seq_ev_is_channel_type(ev))
                  i += 1 + (ev->data.note.channel & 0xf);
      }
      if (i >= num_tracks)
            return;
      track = &tracks[i];

      switch (ev->type) {
      case SND_SEQ_EVENT_NOTEON:
            delta_time(track, ev);
            command(track, MIDI_CMD_NOTE_ON | (ev->data.note.channel & 0xf));
            add_byte(track, ev->data.note.note & 0x7f);
            add_byte(track, ev->data.note.velocity & 0x7f);
            break;
      case SND_SEQ_EVENT_NOTEOFF:
            delta_time(track, ev);
            command(track, MIDI_CMD_NOTE_OFF | (ev->data.note.channel & 0xf));
            add_byte(track, ev->data.note.note & 0x7f);
            add_byte(track, ev->data.note.velocity & 0x7f);
            break;
      case SND_SEQ_EVENT_KEYPRESS:
            delta_time(track, ev);
            command(track, MIDI_CMD_NOTE_PRESSURE | (ev->data.note.channel & 0xf));
            add_byte(track, ev->data.note.note & 0x7f);
            add_byte(track, ev->data.note.velocity & 0x7f);
            break;
      case SND_SEQ_EVENT_CONTROLLER:
            delta_time(track, ev);
            command(track, MIDI_CMD_CONTROL | (ev->data.control.channel & 0xf));
            add_byte(track, ev->data.control.param & 0x7f);
            add_byte(track, ev->data.control.value & 0x7f);
            break;
      case SND_SEQ_EVENT_PGMCHANGE:
            delta_time(track, ev);
            command(track, MIDI_CMD_PGM_CHANGE | (ev->data.control.channel & 0xf));
            add_byte(track, ev->data.control.value & 0x7f);
            break;
      case SND_SEQ_EVENT_CHANPRESS:
            delta_time(track, ev);
            command(track, MIDI_CMD_CHANNEL_PRESSURE | (ev->data.control.channel & 0xf));
            add_byte(track, ev->data.control.value & 0x7f);
            break;
      case SND_SEQ_EVENT_PITCHBEND:
            delta_time(track, ev);
            command(track, MIDI_CMD_BENDER | (ev->data.control.channel & 0xf));
            add_byte(track, (ev->data.control.value + 8192) & 0x7f);
            add_byte(track, ((ev->data.control.value + 8192) >> 7) & 0x7f);
            break;
      case SND_SEQ_EVENT_CONTROL14:
            /* create two commands for MSB and LSB */
            delta_time(track, ev);
            command(track, MIDI_CMD_CONTROL | (ev->data.control.channel & 0xf));
            add_byte(track, ev->data.control.param & 0x7f);
            add_byte(track, (ev->data.control.value >> 7) & 0x7f);
            if ((ev->data.control.param & 0x7f) < 0x20) {
                  delta_time(track, ev);
                  /* running status */
                  add_byte(track, (ev->data.control.param & 0x7f) + 0x20);
                  add_byte(track, ev->data.control.value & 0x7f);
            }
            break;
      case SND_SEQ_EVENT_NONREGPARAM:
            delta_time(track, ev);
            command(track, MIDI_CMD_CONTROL | (ev->data.control.channel & 0xf));
            add_byte(track, MIDI_CTL_NONREG_PARM_NUM_LSB);
            add_byte(track, ev->data.control.param & 0x7f);
            delta_time(track, ev);
            add_byte(track, MIDI_CTL_NONREG_PARM_NUM_MSB);
            add_byte(track, (ev->data.control.param >> 7) & 0x7f);
            delta_time(track, ev);
            add_byte(track, MIDI_CTL_MSB_DATA_ENTRY);
            add_byte(track, (ev->data.control.value >> 7) & 0x7f);
            delta_time(track, ev);
            add_byte(track, MIDI_CTL_LSB_DATA_ENTRY);
            add_byte(track, ev->data.control.value & 0x7f);
            break;
      case SND_SEQ_EVENT_REGPARAM:
            delta_time(track, ev);
            command(track, MIDI_CMD_CONTROL | (ev->data.control.channel & 0xf));
            add_byte(track, MIDI_CTL_REGIST_PARM_NUM_LSB);
            add_byte(track, ev->data.control.param & 0x7f);
            delta_time(track, ev);
            add_byte(track, MIDI_CTL_REGIST_PARM_NUM_MSB);
            add_byte(track, (ev->data.control.param >> 7) & 0x7f);
            delta_time(track, ev);
            add_byte(track, MIDI_CTL_MSB_DATA_ENTRY);
            add_byte(track, (ev->data.control.value >> 7) & 0x7f);
            delta_time(track, ev);
            add_byte(track, MIDI_CTL_LSB_DATA_ENTRY);
            add_byte(track, ev->data.control.value & 0x7f);
            break;
#if 0 /* ignore */
      case SND_SEQ_EVENT_SONGPOS:
      case SND_SEQ_EVENT_SONGSEL:
      case SND_SEQ_EVENT_QFRAME:
      case SND_SEQ_EVENT_START:
      case SND_SEQ_EVENT_CONTINUE:
      case SND_SEQ_EVENT_STOP:
      case SND_SEQ_EVENT_TUNE_REQUEST:
      case SND_SEQ_EVENT_RESET:
      case SND_SEQ_EVENT_SENSING:
            break;
#endif
      case SND_SEQ_EVENT_SYSEX:
            if (ev->data.ext.len == 0)
                  break;
            delta_time(track, ev);
            if (*(unsigned char*)ev->data.ext.ptr == 0xf0)
                  command(track, 0xf0), i = 1;
            else
                  command(track, 0xf7), i = 0;
            var_value(track, ev->data.ext.len - i);
            for (; i < ev->data.ext.len; ++i)
                  add_byte(track, ((unsigned char*)ev->data.ext.ptr)[i]);
            break;
      default:
            return;
      }
      track->used = 1;
}

static void finish_tracks(void)
{
      snd_seq_queue_status_t *queue_status;
      int tick, i, err;

      snd_seq_queue_status_alloca(&queue_status);

      err = snd_seq_get_queue_status(seq, queue, queue_status);
      check_snd("get queue status", err);
      tick = snd_seq_queue_status_get_tick_time(queue_status);

      /* make length of first track the recording length */
      var_value(&tracks[0], tick - tracks[0].last_tick);
      add_byte(&tracks[0], 0xff);
      add_byte(&tracks[0], 0x2f);
      var_value(&tracks[0], 0);

      /* finish other tracks */
      for (i = 1; i < num_tracks; ++i) {
            var_value(&tracks[i], 0);
            add_byte(&tracks[i], 0xff);
            add_byte(&tracks[i], 0x2f);
            var_value(&tracks[i], 0);
      }
}

static void write_file(void)
{
      int used_tracks, time_division, i;
      struct buffer *buf;

      used_tracks = 0;
      for (i = 0; i < num_tracks; ++i)
            used_tracks += !!tracks[i].used;

      /* header id and length */
      fwrite("MThd\0\0\0\6", 1, 8, file);
      /* type 0 or 1 */
      fputc(0, file);
      fputc(used_tracks > 1, file);
      /* number of tracks */
      fputc((used_tracks >> 8) & 0xff, file);
      fputc(used_tracks & 0xff, file);
      /* time division */
      time_division = ticks;
      if (smpte_timing)
            time_division |= (0x100 - frames) << 8;
      fputc(time_division >> 8, file);
      fputc(time_division & 0xff, file);

      for (i = 0; i < num_tracks; ++i) {
            if (!tracks[i].used)
                  continue;
            /* track id */
            fwrite("MTrk", 1, 4, file);
            /* data length */
            fputc((tracks[i].size >> 24) & 0xff, file);
            fputc((tracks[i].size >> 16) & 0xff, file);
            fputc((tracks[i].size >> 8) & 0xff, file);
            fputc(tracks[i].size & 0xff, file);
            /* track contents */
            for (buf = &tracks[i].first_buf; buf; buf = buf->next)
                  fwrite(buf->buf, 1, buf == tracks[i].cur_buf
                         ? tracks[i].cur_buf_size : BUFFER_SIZE, file);
      }
}

static void list_ports(void)
{
      snd_seq_client_info_t *cinfo;
      snd_seq_port_info_t *pinfo;

      snd_seq_client_info_alloca(&cinfo);
      snd_seq_port_info_alloca(&pinfo);

      puts(" Port    Client name                      Port name");

      snd_seq_client_info_set_client(cinfo, -1);
      while (snd_seq_query_next_client(seq, cinfo) >= 0) {
            int client = snd_seq_client_info_get_client(cinfo);

            if (client == SND_SEQ_CLIENT_SYSTEM)
                  continue; /* don't show system timer and announce ports */
            snd_seq_port_info_set_client(pinfo, client);
            snd_seq_port_info_set_port(pinfo, -1);
            while (snd_seq_query_next_port(seq, pinfo) >= 0) {
                  /* port must understand MIDI messages */
                  if (!(snd_seq_port_info_get_type(pinfo)
                        & SND_SEQ_PORT_TYPE_MIDI_GENERIC))
                        continue;
                  /* we need both READ and SUBS_READ */
                  if ((snd_seq_port_info_get_capability(pinfo)
                       & (SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ))
                      != (SND_SEQ_PORT_CAP_READ | SND_SEQ_PORT_CAP_SUBS_READ))
                        continue;
                  printf("%3d:%-3d  %-32.32s %s\n",
                         snd_seq_port_info_get_client(pinfo),
                         snd_seq_port_info_get_port(pinfo),
                         snd_seq_client_info_get_name(cinfo),
                         snd_seq_port_info_get_name(pinfo));
            }
      }
}

static void help(const char *argv0)
{
      fprintf(stderr, "Usage: %s [options] outputfile\n"
            "\nAvailable options:\n"
            "  -h,--help                  this help\n"
            "  -V,--version               show version\n"
            "  -l,--list                  list input ports\n"
            "  -p,--port=client:port,...  source port(s)\n"
            "  -b,--bpm=beats             tempo in beats per minute\n"
            "  -f,--fps=frames            resolution in frames per second (SMPTE)\n"
            "  -t,--ticks=ticks           resolution in ticks per beat or frame\n"
            "  -s,--split-channels        create a track for each channel\n"
            "  -m,--metronome=client:port play a metronome signal\n"
            "  -i,--timesig=nn:dd         time signature\n",
            argv0);
}

static void version(void)
{
      fputs("arecordmidi version " SND_UTIL_VERSION_STR "\n", stderr);
}

static void sighandler(int sig)
{
      stop = 1;
}

int main(int argc, char *argv[])
{
      static char short_options[] = "hVlp:b:f:t:sdm:i:";
      static struct option long_options[] = {
            {"help", 0, NULL, 'h'},
            {"version", 0, NULL, 'V'},
            {"list", 0, NULL, 'l'},
            {"port", 1, NULL, 'p'},
            {"bpm", 1, NULL, 'b'},
            {"fps", 1, NULL, 'f'},
            {"ticks", 1, NULL, 't'},
            {"split-channels", 0, NULL, 's'},
            {"dump", 0, NULL, 'd'},
            {"metronome", 1, NULL, 'm'},
            {"timesig", 1, NULL, 'i'},
            { }
      };

      char *filename = NULL;
      int do_list = 0;
      struct pollfd *pfds;
      int npfds;
      int c, err;

      init_seq();

      while ((c = getopt_long(argc, argv, short_options,
                        long_options, NULL)) != -1) {
            switch (c) {
            case 'h':
                  help(argv[0]);
                  return 0;
            case 'V':
                  version();
                  return 0;
            case 'l':
                  do_list = 1;
                  break;
            case 'p':
                  parse_ports(optarg);
                  break;
            case 'b':
                  beats = atoi(optarg);
                  if (beats < 4 || beats > 6000)
                        fatal("Invalid tempo");
                  smpte_timing = 0;
                  break;
            case 'f':
                  frames = atoi(optarg);
                  if (frames != 24 && frames != 25 &&
                      frames != 29 && frames != 30)
                        fatal("Invalid number of frames/s");
                  smpte_timing = 1;
                  break;
            case 't':
                  ticks = atoi(optarg);
                  if (ticks < 1 || ticks > 0x7fff)
                        fatal("Invalid number of ticks");
                  break;
            case 's':
                  channel_split = 1;
                  break;
            case 'd':
                  fputs("The --dump option isn't supported anymore, use aseqdump instead.\n", stderr);
                  break;
            case 'm':
                  init_metronome(optarg);
                  break;
            case 'i':
                  time_signature(optarg);
                  break;
            default:
                  help(argv[0]);
                  return 1;
            }
      }

      if (do_list) {
            list_ports();
            return 0;
      }

      if (port_count < 1) {
            fputs("Pleast specify a source port with --port.\n", stderr);
            return 1;
      }

      if (!ticks)
            ticks = smpte_timing ? 40 : 384;
      if (smpte_timing && ticks > 0xff)
            ticks = 0xff;

      if (optind >= argc) {
            fputs("Please specify a file to record to.\n", stderr);
            return 1;
      }
      filename = argv[optind];

      init_tracks();
      create_queue();
      create_ports();
      connect_ports();
      if (port_count > 1)
            record_port_numbers();

      /* record tempo */
      if (!smpte_timing) {
            int usecs_per_quarter = 60000000 / beats;
            var_value(&tracks[0], 0); /* delta time */
            add_byte(&tracks[0], 0xff);
            add_byte(&tracks[0], 0x51);
            var_value(&tracks[0], 3);
            add_byte(&tracks[0], usecs_per_quarter >> 16);
            add_byte(&tracks[0], usecs_per_quarter >> 8);
            add_byte(&tracks[0], usecs_per_quarter);

            /* time signature */
            var_value(&tracks[0], 0); /* delta time */
            add_byte(&tracks[0], 0xff);
            add_byte(&tracks[0], 0x58);
            var_value(&tracks[0], 4);
            add_byte(&tracks[0], ts_num);
            add_byte(&tracks[0], ts_dd);
            add_byte(&tracks[0], 24); /* MIDI clocks per metronome click */
            add_byte(&tracks[0], 8); /* notated 32nd-notes per MIDI quarter note */
      }
      
      /* always write at least one track */
      tracks[0].used = 1;

      file = fopen(filename, "wb");
      if (!file)
            fatal("Cannot open %s - %s", filename, strerror(errno));

      err = snd_seq_start_queue(seq, queue, NULL);
      check_snd("start queue", err);
      snd_seq_drain_output(seq);

      err = snd_seq_nonblock(seq, 1);
      check_snd("set nonblock mode", err);
      
      if (use_metronome) {
            metronome_set_program();
            metronome_pattern(0);
      }

      signal(SIGINT, sighandler);
      signal(SIGTERM, sighandler);

      npfds = snd_seq_poll_descriptors_count(seq, POLLIN);
      pfds = alloca(sizeof(*pfds) * npfds);
      for (;;) {
            snd_seq_poll_descriptors(seq, pfds, npfds, POLLIN);
            if (poll(pfds, npfds, 69) < 0)
                  break;
            do {
                  snd_seq_event_t *event;
                  err = snd_seq_event_input(seq, &event);
                  if (err < 0)
                        break;
                  if (event)
                        record_event(event);
            } while (err > 0);
            if (stop)
                  break;
      }

      finish_tracks();
      write_file();

      fclose(file);
      snd_seq_close(seq);
      return 0;
}

Generated by  Doxygen 1.6.0   Back to index