media_source_midi.c

   1 /* -*- Mode: C ; c-basic-offset: 2 -*- */
   2 /*****************************************************************************
   3  *
   4  *   Media source implementation that reads MIDI files.
   5  *   This file is part of monster
   6  *
   7  *   Copyright (C) 2006,2007 Nedko Arnaudov <nedko@arnaudov.name>
   8  *
   9  *   This program is free software; you can redistribute it and/or modify
  10  *   it under the terms of the GNU General Public License as published by
  11  *   the Free Software Foundation; version 2 of the License
  12  *
  13  *   This program is distributed in the hope that it will be useful,
  14  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *   GNU General Public License for more details.
  17  *
  18  *   You should have received a copy of the GNU General Public License
  19  *   along with this program; if not, write to the Free Software
  20  *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  21  *
  22  *****************************************************************************/
  23
  24 #include <unistd.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <errno.h>
  28 #include <stdio.h>
  29
  30 #define DISABLE_DEBUG_OUTPUT
  31
  32 #include "media_source.h"
  33 #include "media_source_midi.h"
  34 #include "log.h"
  35 #include "midi_event.h"
  36
  37 /*
  38  * A MIDI event after being parsed/loaded from the file.
  39  * There could be made a case for using snd_seq_event_t instead.
  40  */
  41 struct event
  42 {
  43   struct event * next_ptr;   /* linked list */
  44
  45   struct midi_event event;
  46   unsigned char sysex[0];
  47 };
  48
  49 struct track
  50 {
  51   struct event * first_event_ptr; /* list of all events in this track */
  52   int end_tick;                 /* length of this track */
  53
  54   struct event * current_event_ptr;
  55 };
  56
  57 struct media_source_midi
  58 {
  59   struct media_source virtual;
  60
  61   FILE * file_handle;
  62   int file_offset;   /* current offset in input file */
  63   int num_tracks;
  64   struct track * tracks;
  65   int smpte_timing;
  66   signed int max_tick;
  67   struct event * ppqn_event_ptr;
  68   struct event * tempo_event_ptr;
  69   struct event * event_ptr;
  70   unsigned int counter;
  71 };
  72
  73 static void cleanup_file_data(struct media_source_midi * media_source_ptr)
  74 {
  75   int i;
  76   struct event * event_ptr;
  77
  78   if (media_source_ptr->tracks != NULL)
  79   {
  80     for (i = 0; i < media_source_ptr->num_tracks; ++i)
  81     {
  82       event_ptr = media_source_ptr->tracks[i].first_event_ptr;
  83       while (event_ptr != NULL)
  84       {
  85         struct event * next_ptr = event_ptr->next_ptr;
  86         free(event_ptr);
  87         event_ptr = next_ptr;
  88       }
  89     }
  90
  91     media_source_ptr->num_tracks = 0;
  92
  93     free(media_source_ptr->tracks);
  94   }
  95
  96   if (media_source_ptr->ppqn_event_ptr != NULL)
  97   {
  98     free(media_source_ptr->ppqn_event_ptr);
  99   }
 100
 101   if (media_source_ptr->tempo_event_ptr != NULL)
 102   {
 103     free(media_source_ptr->tempo_event_ptr);
 104   }
 105
 106   media_source_ptr->tracks = NULL;
 107 }
 108
 109 #define media_source_ptr ((struct media_source_midi *)virtual_ptr)
 110
 111 void media_source_midi_destroy(struct media_source * virtual_ptr)
 112 {
 113   DEBUG_OUT("media_source_midi_destroy");
 114   cleanup_file_data(media_source_ptr);
 115   fclose(media_source_ptr->file_handle);
 116   free(media_source_ptr);
 117 }
 118
 119 int media_source_midi_format_query(struct media_source * virtual_ptr, unsigned int * format_ptr)
 120 {
 121   DEBUG_OUT("media_source_midi_format_query");
 122   *format_ptr = MEDIA_FORMAT_MIDI_EVENT;
 123   return 0;
 124 }
 125
 126 int media_source_midi_get_frame_data(struct media_source * virtual_ptr, void ** buffer_ptr_ptr)
 127 {
 128   DEBUG_OUT("media_source_midi_get_frame_data");
 129
 130   if (media_source_ptr->counter == 0)
 131   {
 132     if (media_source_ptr->ppqn_event_ptr == NULL)
 133     {
 134       ERROR_OUT("No PPQN event!");
 135       return -1;
 136     }
 137
 138     *buffer_ptr_ptr = &media_source_ptr->ppqn_event_ptr->event;
 139     DEBUG_OUT("Returning the PPQN event");
 140     return 0;
 141   }
 142
 143   if (media_source_ptr->counter == 1)
 144   {
 145     if (media_source_ptr->tempo_event_ptr == NULL)
 146     {
 147       ERROR_OUT("No tempo event!");
 148       return -1;
 149     }
 150
 151     *buffer_ptr_ptr = &media_source_ptr->tempo_event_ptr->event;
 152     DEBUG_OUT("Returning the tempo event");
 153     return 0;
 154   }
 155
 156   if (media_source_ptr->event_ptr == NULL)
 157   {
 158     *buffer_ptr_ptr = NULL;
 159     return 1;
 160   }
 161
 162   *buffer_ptr_ptr = &media_source_ptr->event_ptr->event;
 163
 164   return 0;
 165 }
 166
 167 void
 168 media_source_midi_next_frame(struct media_source * virtual_ptr)
 169 {
 170   struct event * event_ptr;
 171   struct track * event_track_ptr;
 172   int i;
 173   signed int min_tick;
 174
 175   DEBUG_OUT("media_source_midi_next_frame");
 176
 177   media_source_ptr->counter++;
 178
 179   if (media_source_ptr->counter < 2)
 180   {
 181     return;
 182   }
 183
 184   event_ptr = NULL;
 185   event_track_ptr = NULL;
 186   min_tick = media_source_ptr->max_tick + 1;
 187
 188   //DEBUG_OUT("Search next event, %d tracks, max_tick = %d, min_tick = %d", media_source_ptr->num_tracks, media_source_ptr->max_tick, min_tick);
 189
 190   /* search next event */
 191   for (i = 0; i < media_source_ptr->num_tracks; i++)
 192   {
 193     struct track * track = media_source_ptr->tracks + i;
 194     struct event * e2 = track->current_event_ptr;
 195
 196     //DEBUG_OUT("Event %08X, tick = %u", (unsigned int)e2, e2 ? e2->event.tick : 0);
 197     if (e2 && e2->event.tick < min_tick)
 198     {
 199       min_tick = e2->event.tick;
 200       event_ptr = e2;
 201       event_track_ptr = track;
 202     }
 203   }
 204
 205   if (event_ptr != NULL)        /* if end of song NOT reached */
 206   {
 207     /* advance pointer to next event */
 208     event_track_ptr->current_event_ptr = event_ptr->next_ptr;
 209   }
 210   else
 211   {
 212     DEBUG_OUT("End of song");
 213   }
 214
 215   media_source_ptr->event_ptr = event_ptr;
 216 }
 217
 218 #undef media_source_ptr
 219
 220 static int read_byte(struct media_source_midi * media_source_ptr)
 221 {
 222   media_source_ptr->file_offset++;
 223   return getc(media_source_ptr->file_handle);
 224 }
 225
 226 /* reads a little-endian 32-bit integer */
 227 static int read_32_le(struct media_source_midi * media_source_ptr)
 228 {
 229   int value;
 230   value = read_byte(media_source_ptr);
 231   value |= read_byte(media_source_ptr) << 8;
 232   value |= read_byte(media_source_ptr) << 16;
 233   value |= read_byte(media_source_ptr) << 24;
 234   return !feof(media_source_ptr->file_handle) ? value : -1;
 235 }
 236
 237 /* reads a 4-character identifier */
 238 static int read_id(struct media_source_midi * media_source_ptr)
 239 {
 240   int id;
 241
 242   id = read_32_le(media_source_ptr);
 243
 244   DEBUG_OUT(
 245     "Chunk \"%c%c%c%c\"",
 246     (char)(id & 0xFF),
 247     (char)((id >> 8) & 0xFF),
 248     (char)((id >> 16) & 0xFF),
 249     (char)((id >> 24) & 0xFF));
 250
 251   return id;
 252 }
 253
 254 #define MAKE_ID(c1, c2, c3, c4) ((c1) | ((c2) << 8) | ((c3) << 16) | ((c4) << 24))
 255
 256 /* reads a fixed-size big-endian number */
 257 static int read_int(struct media_source_midi * media_source_ptr, int bytes)
 258 {
 259   int c, value = 0;
 260
 261   do
 262   {
 263     c = read_byte(media_source_ptr);
 264     if (c == EOF)
 265       return -1;
 266     value = (value << 8) | c;
 267   }
 268   while (--bytes);
 269
 270   return value;
 271 }
 272
 273 /* reads a variable-length number */
 274 static int read_var(struct media_source_midi * media_source_ptr)
 275 {
 276   int value, c;
 277
 278   c = read_byte(media_source_ptr);
 279   value = c & 0x7f;
 280   if (c & 0x80)
 281   {
 282     c = read_byte(media_source_ptr);
 283     value = (value << 7) | (c & 0x7f);
 284     if (c & 0x80)
 285     {
 286       c = read_byte(media_source_ptr);
 287       value = (value << 7) | (c & 0x7f);
 288       if (c & 0x80)
 289       {
 290         c = read_byte(media_source_ptr);
 291         value = (value << 7) | c;
 292         if (c & 0x80)
 293           return -1;
 294       }
 295     }
 296   }
 297   return !feof(media_source_ptr->file_handle) ? value : -1;
 298 }
 299
 300 /* allocates a new event */
 301 static
 302 int
 303 new_event(struct track * track_ptr, int sysex_length, struct event ** event_ptr_ptr)
 304 {
 305   struct event * event_ptr;
 306
 307   event_ptr = malloc(sizeof(struct event) + sysex_length);
 308   if (event_ptr == NULL)
 309   {
 310     ERROR_OUT("malloc failed.");
 311     return -1;
 312   }
 313
 314   event_ptr->next_ptr = NULL;
 315
 316   /* append at the end of the track's linked list */
 317   if (track_ptr->current_event_ptr != NULL)
 318   {
 319     track_ptr->current_event_ptr->next_ptr = event_ptr;
 320   }
 321   else
 322   {
 323     track_ptr->first_event_ptr = event_ptr;
 324   }
 325
 326   track_ptr->current_event_ptr = event_ptr;
 327
 328   *event_ptr_ptr = event_ptr;
 329
 330   return 0;
 331 }
 332
 333 static void skip(struct media_source_midi * media_source_ptr, int bytes)
 334 {
 335   while (bytes > 0)
 336     read_byte(media_source_ptr), --bytes;
 337 }
 338
 339 /* reads one complete track from the file */
 340 static int read_track(struct media_source_midi * media_source_ptr, struct track *track, int track_end)
 341 {
 342   int ret;
 343   int tick = 0;
 344   unsigned char last_cmd = 0;
 345
 346   /* the current file position is after the track ID and length */
 347   while (media_source_ptr->file_offset < track_end)
 348   {
 349     unsigned char cmd;
 350     struct event * event_ptr;
 351     int delta_ticks, len, c;
 352
 353     delta_ticks = read_var(media_source_ptr);
 354     if (delta_ticks < 0)
 355       break;
 356     tick += delta_ticks;
 357
 358     c = read_byte(media_source_ptr);
 359     if (c < 0)
 360       break;
 361
 362     if (c & 0x80)
 363     {
 364       /* have command */
 365       cmd = c;
 366       if (cmd < 0xf0)
 367         last_cmd = cmd;
 368     }
 369     else
 370     {
 371       /* running status */
 372       ungetc(c, media_source_ptr->file_handle);
 373       media_source_ptr->file_offset--;
 374       cmd = last_cmd;
 375       if (!cmd)
 376         goto _error;
 377     }
 378
 379     switch (cmd >> 4)
 380     {
 381       /* channel messages with 2 parameter bytes */
 382     case 0x8:                   /* Note Off */
 383       ret = new_event(track, 0, &event_ptr);
 384       if (ret < 0)
 385       {
 386         return -1;
 387       }
 388
 389       event_ptr->event.type = MIDI_EVENT_NOTE_OFF;
 390       event_ptr->event.tick = tick;
 391       event_ptr->event.data.note_off.channel = cmd & 0x0f;
 392       event_ptr->event.data.note_off.note = read_byte(media_source_ptr) & 0x7f;
 393       event_ptr->event.data.note_off.velocity = read_byte(media_source_ptr) & 0x7f;
 394       break;
 395     case 0x9:                   /* Note On */
 396       ret = new_event(track, 0, &event_ptr);
 397       if (ret < 0)
 398       {
 399         return -1;
 400       }
 401
 402       event_ptr->event.type = MIDI_EVENT_NOTE_ON;
 403       event_ptr->event.tick = tick;
 404       event_ptr->event.data.note_on.channel = cmd & 0x0f;
 405       event_ptr->event.data.note_on.note = read_byte(media_source_ptr) & 0x7f;
 406       event_ptr->event.data.note_on.velocity = read_byte(media_source_ptr) & 0x7f;
 407       break;
 408     case 0xa:                   /* Polyphonic Key Pressure (Aftertouch) */
 409       ret = new_event(track, 0, &event_ptr);
 410       if (ret < 0)
 411       {
 412         return -1;
 413       }
 414
 415       event_ptr->event.type = MIDI_EVENT_KEYPRESS;
 416       event_ptr->event.tick = tick;
 417       event_ptr->event.data.keypress.channel = cmd & 0x0f;
 418       event_ptr->event.data.keypress.note = read_byte(media_source_ptr) & 0x7f;
 419       event_ptr->event.data.keypress.velocity = read_byte(media_source_ptr) & 0x7f;
 420       break;
 421     case 0xb:                   /* Control Change */
 422       ret = new_event(track, 0, &event_ptr);
 423       if (ret < 0)
 424       {
 425         return -1;
 426       }
 427
 428       event_ptr->event.type = MIDI_EVENT_CC;
 429       event_ptr->event.tick = tick;
 430       event_ptr->event.data.cc.channel = cmd & 0x0f;
 431       event_ptr->event.data.cc.controller = read_byte(media_source_ptr) & 0x7f;
 432       event_ptr->event.data.cc.value = read_byte(media_source_ptr) & 0x7f;
 433       break;
 434     case 0xe:                   /* Pitch Wheel Change */
 435       ret = new_event(track, 0, &event_ptr);
 436       if (ret < 0)
 437       {
 438         return -1;
 439       }
 440
 441       event_ptr->event.type = MIDI_EVENT_CC;
 442       event_ptr->event.tick = tick;
 443       event_ptr->event.data.pitch.channel = cmd & 0x0f;
 444       event_ptr->event.data.pitch.value = (read_byte(media_source_ptr) & 0x7f) | ((read_byte(media_source_ptr) & 0x7f) << 7);
 445       break;
 446
 447       /* channel messages with 1 parameter byte */
 448     case 0xc:                   /* Program Change */
 449       ret = new_event(track, 0, &event_ptr);
 450       if (ret < 0)
 451       {
 452         return -1;
 453       }
 454
 455       event_ptr->event.type = MIDI_EVENT_PGMCHANGE;
 456       event_ptr->event.tick = tick;
 457       event_ptr->event.data.pgmchange.channel = cmd & 0x0f;
 458       event_ptr->event.data.pgmchange.program = read_byte(media_source_ptr) & 0x7f;
 459       break;
 460     case 0xd:                   /* Channel Pressure (After-touch) */
 461       ret = new_event(track, 0, &event_ptr);
 462       if (ret < 0)
 463       {
 464         return -1;
 465       }
 466
 467       event_ptr->event.type = MIDI_EVENT_CHANPRESS;
 468       event_ptr->event.tick = tick;
 469       event_ptr->event.data.chanpress.channel = cmd & 0x0f;
 470       event_ptr->event.data.chanpress.value = read_byte(media_source_ptr) & 0x7f;
 471       break;
 472
 473     case 0xf:
 474       switch (cmd)
 475       {
 476       case 0xf0: /* sysex */
 477       case 0xf7: /* continued sysex, or escaped commands */
 478         len = read_var(media_source_ptr);
 479
 480         if (len < 0)
 481           goto _error;
 482
 483         if (cmd == 0xf0)
 484           ++len;
 485
 486         ret = new_event(track, len, &event_ptr);
 487         if (ret < 0)
 488         {
 489           return -1;
 490         }
 491
 492         event_ptr->event.type = MIDI_EVENT_SYSEX;
 493         event_ptr->event.tick = tick;
 494         event_ptr->event.data.sysex.size = len;
 495         event_ptr->event.data.sysex.data = event_ptr->sysex;
 496         if (cmd == 0xf0)
 497         {
 498           event_ptr->sysex[0] = 0xf0;
 499           c = 1;
 500         }
 501         else
 502         {
 503           c = 0;
 504         }
 505         for (; c < len; ++c)
 506           event_ptr->sysex[c] = read_byte(media_source_ptr);
 507         break;
 508
 509       case 0xff: /* meta event */
 510         c = read_byte(media_source_ptr);
 511         len = read_var(media_source_ptr);
 512         if (len < 0)
 513           goto _error;
 514
 515         switch (c)
 516         {
 517         case 0x21: /* port number */
 518           if (len < 1)
 519             goto _error;
 520           {
 521             int port;
 522             port = read_byte(media_source_ptr);
 523             DEBUG_OUT("port %u", (unsigned int)port);
 524             skip(media_source_ptr, len - 1);
 525           }
 526           break;
 527
 528         case 0x2f: /* end of track */
 529           track->end_tick = tick;
 530           skip(media_source_ptr, track_end - media_source_ptr->file_offset);
 531           return 0;
 532
 533         case 0x51: /* tempo */
 534           if (len < 3)
 535             goto _error;
 536           if (media_source_ptr->smpte_timing)
 537           {
 538             /* SMPTE timing doesn't change */
 539             skip(media_source_ptr, len);
 540           }
 541           else
 542           {
 543             ret = new_event(track, 0, &event_ptr);
 544             if (ret < 0)
 545             {
 546               return -1;
 547             }
 548
 549             event_ptr->event.type = MIDI_EVENT_TEMPO;
 550             event_ptr->event.tick = tick;
 551             event_ptr->event.data.tempo.value = read_byte(media_source_ptr) << 16;
 552             event_ptr->event.data.tempo.value |= read_byte(media_source_ptr) << 8;
 553             event_ptr->event.data.tempo.value |= read_byte(media_source_ptr);
 554             skip(media_source_ptr, len - 3);
 555           }
 556           break;
 557
 558         default: /* ignore all other meta events */
 559           skip(media_source_ptr, len);
 560           break;
 561         }
 562         break;
 563
 564       default: /* invalid Fx command */
 565         goto _error;
 566       }
 567       break;
 568
 569     default: /* cannot happen */
 570       goto _error;
 571     }
 572   }
 573 _error:
 574   ERROR_OUT("invalid MIDI data (offset %#x)", media_source_ptr->file_offset);
 575   return -1;
 576 }
 577
 578 int
 579 set_ppqn_event(
 580   struct media_source_midi * media_source_ptr,
 581   unsigned int ppqn)
 582 {
 583   media_source_ptr->ppqn_event_ptr = malloc(sizeof(struct event));
 584   if (media_source_ptr->ppqn_event_ptr == NULL)
 585   {
 586     ERROR_OUT("malloc failed.");
 587     return -1;
 588   }
 589
 590   media_source_ptr->ppqn_event_ptr->event.type = MIDI_EVENT_PPQN;
 591   media_source_ptr->ppqn_event_ptr->event.tick = 0;
 592   media_source_ptr->ppqn_event_ptr->event.data.ppqn.value = ppqn;
 593
 594   return 0;
 595 }
 596
 597 int
 598 set_tempo_event(
 599   struct media_source_midi * media_source_ptr,
 600   unsigned int tempo)
 601 {
 602   media_source_ptr->tempo_event_ptr = malloc(sizeof(struct event));
 603   if (media_source_ptr->tempo_event_ptr == NULL)
 604   {
 605     ERROR_OUT("malloc failed.");
 606     return -1;
 607   }
 608
 609
 610   media_source_ptr->tempo_event_ptr->event.type = MIDI_EVENT_TEMPO;
 611   media_source_ptr->tempo_event_ptr->event.tick = 0;
 612   media_source_ptr->tempo_event_ptr->event.data.tempo.value = tempo;
 613
 614   return 0;
 615 }
 616
 617 /* reads an entire MIDI file */
 618 static int
 619 read_smf(
 620   struct media_source_midi * media_source_ptr)
 621 {
 622   int header_len, type, time_division, i;
 623   int ret;
 624
 625   /* the curren position is immediately after the "MThd" id */
 626   header_len = read_int(media_source_ptr, 4);
 627   if (header_len != 6)
 628   {
 629     ERROR_OUT("MIDI parsing error (MThd check)");
 630     return -1;
 631   }
 632
 633   type = read_int(media_source_ptr, 2);
 634
 635   DEBUG_OUT("Type %d", type);
 636
 637   if (type != 0 && type != 1)
 638   {
 639     ERROR_OUT("MIDI type %d format is not supported", type);
 640     return -1;
 641   }
 642
 643   media_source_ptr->num_tracks = read_int(media_source_ptr, 2);
 644   if (media_source_ptr->num_tracks < 1 || media_source_ptr->num_tracks > 1000)
 645   {
 646     ERROR_OUT("invalid number of tracks (%d)", media_source_ptr->num_tracks);
 647     media_source_ptr->num_tracks = 0;
 648     return -1;
 649   }
 650
 651   DEBUG_OUT("Tracks count: %d", media_source_ptr->num_tracks);
 652
 653   media_source_ptr->tracks = calloc(media_source_ptr->num_tracks, sizeof(struct track));
 654   if (!media_source_ptr->tracks)
 655   {
 656     ERROR_OUT("out of memory");
 657     media_source_ptr->num_tracks = 0;
 658     return -1;
 659   }
 660
 661   time_division = read_int(media_source_ptr, 2);
 662   if (time_division < 0)
 663   {
 664     ERROR_OUT("MIDI parsing error (time division is negative)");
 665     return -1;
 666   }
 667
 668   /* interpret and set tempo */
 669   media_source_ptr->smpte_timing = !!(time_division & 0x8000);
 670   if (!media_source_ptr->smpte_timing)
 671   {
 672     DEBUG_OUT("PPQN: %d", time_division);
 673     DEBUG_OUT("Settings default tempo, 120 bpm");
 674     /* time_division is ticks per quarter */
 675
 676     ret = set_ppqn_event(media_source_ptr, time_division);
 677     if (ret < 0)
 678     {
 679       return -1;
 680     }
 681
 682     ret = set_tempo_event(media_source_ptr, 500000); /* default: 120 bpm */
 683     if (ret < 0)
 684     {
 685       return -1;
 686     }
 687   }
 688   else
 689   {
 690     /* upper byte is negative frames per second */
 691     i = 0x80 - ((time_division >> 8) & 0x7f);
 692     /* lower byte is ticks per frame */
 693     time_division &= 0xff;
 694     /* now pretend that we have quarter-note based timing */
 695     switch (i)
 696     {
 697     case 24:
 698       ret = set_tempo_event(media_source_ptr, 12 * time_division);
 699       if (ret < 0)
 700       {
 701         return -1;
 702       }
 703
 704       ret = set_ppqn_event(media_source_ptr, 500000);
 705       if (ret < 0)
 706       {
 707         return -1;
 708       }
 709       break;
 710     case 25:
 711       ret = set_tempo_event(media_source_ptr, 10 * time_division);
 712       if (ret < 0)
 713       {
 714         return -1;
 715       }
 716
 717       ret = set_ppqn_event(media_source_ptr, 400000);
 718       if (ret < 0)
 719       {
 720         return -1;
 721       }
 722       break;
 723     case 29: /* 30 drop-frame */
 724       ret = set_tempo_event(media_source_ptr, 2997 * time_division);
 725       if (ret < 0)
 726       {
 727         return -1;
 728       }
 729
 730       ret = set_ppqn_event(media_source_ptr, 100000000);
 731       if (ret < 0)
 732       {
 733         return -1;
 734       }
 735       break;
 736     case 30:
 737       ret = set_tempo_event(media_source_ptr, 15 * time_division);
 738       if (ret < 0)
 739       {
 740         return -1;
 741       }
 742
 743       ret = set_ppqn_event(media_source_ptr, 500000);
 744       if (ret < 0)
 745       {
 746         return -1;
 747       }
 748       break;
 749     default:
 750       ERROR_OUT("invalid number of SMPTE frames per second (%d)", i);
 751       return -1;
 752     }
 753   }
 754
 755   /* read tracks */
 756   for (i = 0; i < media_source_ptr->num_tracks; ++i)
 757   {
 758     int len;
 759
 760     /* search for MTrk chunk */
 761     for (;;)
 762     {
 763       int id = read_id(media_source_ptr);
 764       len = read_int(media_source_ptr, 4);
 765       if (feof(media_source_ptr->file_handle))
 766       {
 767         ERROR_OUT("unexpected end of file");
 768         return -1;
 769       }
 770       if (len < 0 || len >= 0x10000000)
 771       {
 772         ERROR_OUT("invalid chunk length %d", len);
 773         return -1;
 774       }
 775       if (id == MAKE_ID('M', 'T', 'r', 'k'))
 776         break;
 777       skip(media_source_ptr, len);
 778     }
 779
 780     ret = read_track(media_source_ptr, &media_source_ptr->tracks[i], media_source_ptr->file_offset + len);
 781     if (ret < 0)
 782       return -1;
 783   }
 784
 785   return 0;
 786 }
 787
 788 int
 789 media_source_midi_load(struct media_source_midi * media_source_ptr)
 790 {
 791   int i;
 792   int ret;
 793
 794   ret = read_smf(media_source_ptr);
 795   if (ret < 0)
 796   {
 797     return -1;
 798   }
 799
 800   /* calculate length of the entire file */
 801   DEBUG_OUT("Finding max_tick....");
 802   media_source_ptr->max_tick = -1;
 803   for (i = 0; i < media_source_ptr->num_tracks; ++i)
 804   {
 805     DEBUG_OUT("track i end_tick = %d", media_source_ptr->tracks[i].end_tick);
 806     if (media_source_ptr->tracks[i].end_tick > media_source_ptr->max_tick)
 807     {
 808       media_source_ptr->max_tick = media_source_ptr->tracks[i].end_tick;
 809     }
 810   }
 811   DEBUG_OUT("max_tick = %d", media_source_ptr->max_tick);
 812
 813   /* initialize current position in each track */
 814   for (i = 0; i < media_source_ptr->num_tracks; ++i)
 815   {
 816     media_source_ptr->tracks[i].current_event_ptr = media_source_ptr->tracks[i].first_event_ptr;
 817   }
 818
 819   return 0;
 820 }
 821
 822 int
 823 media_source_midi(
 824   const char * filename,
 825   struct media_source ** media_source_ptr_ptr)
 826 {
 827   struct media_source_midi * media_source_ptr;
 828   int ret;
 829
 830   DEBUG_OUT("media_source_midi");
 831
 832   media_source_ptr = (struct media_source_midi *)malloc(sizeof(struct media_source_midi));
 833   if (media_source_ptr == NULL)
 834   {
 835     ERROR_OUT("malloc() failed.");
 836     ret = -1;
 837     goto exit;
 838   }
 839
 840   media_source_ptr->ppqn_event_ptr = NULL;
 841   media_source_ptr->tempo_event_ptr = NULL;
 842   media_source_ptr->tracks = NULL;
 843
 844   media_source_ptr->file_handle = fopen(filename, "rb");
 845   if (!media_source_ptr->file_handle)
 846   {
 847     ERROR_OUT("Cannot open %s - %s", filename, strerror(errno));
 848     ret = -1;
 849     goto cleanup;
 850   }
 851
 852   media_source_ptr->file_offset = 0;
 853
 854   if (read_id(media_source_ptr) != MAKE_ID('M', 'T', 'h', 'd'))
 855   {
 856     ERROR_OUT("%s is not a Standard MIDI File", filename);
 857     ret = -1;
 858     goto cleanup;
 859   }
 860
 861   media_source_ptr->virtual.destroy = media_source_midi_destroy;
 862   media_source_ptr->virtual.format_query = media_source_midi_format_query;
 863   media_source_ptr->virtual.get_frame_data = media_source_midi_get_frame_data;
 864   media_source_ptr->virtual.next_frame = media_source_midi_next_frame;
 865
 866   ret = media_source_midi_load(media_source_ptr);
 867   if (ret < 0)
 868   {
 869     ERROR_OUT("media_source_midi_load() failed.");
 870     goto cleanup;
 871   }
 872
 873   media_source_ptr->counter = 0;
 874
 875   *media_source_ptr_ptr = &media_source_ptr->virtual;
 876
 877   ret = 0;
 878   goto exit;
 879
 880 cleanup:
 881   cleanup_file_data(media_source_ptr);
 882   goto exit;
 883
 884 exit:
 885   return ret;
 886 }