libs/evoral/src/libsmf/smf_load.c

   1 /*-
   2  * Copyright (c) 2007, 2008 Edward Tomasz Napierała <trasz@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * ALTHOUGH THIS SOFTWARE IS MADE OF WIN AND SCIENCE, IT IS PROVIDED BY THE
  15  * AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  16  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  17  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
  18  * THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  19  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  20  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
  21  * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  23  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  24  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  *
  26  */
  27
  28 /**
  29  * \file
  30  *
  31  * Standard MIDI File format loader.
  32  *
  33  */
  34
  35 /* Reference: http://www.borg.com/~jglatt/tech/midifile.htm */
  36
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <assert.h>
  40 #include <math.h>
  41 #include <errno.h>
  42 #include <ctype.h>
  43 #ifdef WIN32
  44 #include <winsock2.h>
  45 #else
  46 #include <arpa/inet.h>
  47 #endif
  48 #include "smf.h"
  49 #include "smf_private.h"
  50
  51 /**
  52  * Returns pointer to the next SMF chunk in smf->buffer, based on length of the previous one.
  53  * Returns NULL in case of error.
  54  */
  55 static struct chunk_header_struct *
  56 next_chunk(smf_t *smf)
  57 {
  58         struct chunk_header_struct *chunk;
  59         void *next_chunk_ptr;
  60
  61         assert(smf->file_buffer != NULL);
  62         assert(smf->file_buffer_length > 0);
  63
  64         if (smf->next_chunk_offset + sizeof(struct chunk_header_struct) >= smf->file_buffer_length) {
  65                 g_critical("SMF warning: no more chunks left.");
  66                 return (NULL);
  67         }
  68
  69         next_chunk_ptr = (unsigned char *)smf->file_buffer + smf->next_chunk_offset;
  70
  71         chunk = (struct chunk_header_struct *)next_chunk_ptr;
  72
  73         if (!isalpha(chunk->id[0]) || !isalpha(chunk->id[1]) || !isalpha(chunk->id[2]) || !isalpha(chunk->id[3])) {
  74                 g_critical("SMF error: chunk signature contains at least one non-alphanumeric byte.");
  75                 return (NULL);
  76         }
  77
  78         /*
  79          * XXX: On SPARC, after compiling with "-fast" option there will be SIGBUS here.
  80          * Please compile with -xmemalign=8i".
  81          */
  82         smf->next_chunk_offset += sizeof(struct chunk_header_struct) + ntohl(chunk->length);
  83
  84         if (smf->next_chunk_offset > smf->file_buffer_length) {
  85                 g_critical("SMF error: malformed chunk; truncated file?");
  86                 return (NULL);
  87         }
  88
  89         return (chunk);
  90 }
  91
  92 /**
  93  * Returns 1, iff signature of the "chunk" is the same as string passed as "signature".
  94  */
  95 static int
  96 chunk_signature_matches(const struct chunk_header_struct *chunk, const char *signature)
  97 {
  98         if (!memcmp(chunk->id, signature, 4))
  99                 return (1);
 100
 101         return (0);
 102 }
 103
 104 /**
 105  * Verifies if MThd header looks OK.  Returns 0 iff it does.
 106  */
 107 static int
 108 parse_mthd_header(smf_t *smf)
 109 {
 110         int len;
 111         struct chunk_header_struct *mthd, *tmp_mthd;
 112
 113         /* Make sure compiler didn't do anything stupid. */
 114         assert(sizeof(struct chunk_header_struct) == 8);
 115
 116         /*
 117          * We could just do "mthd = smf->file_buffer;" here, but this way we wouldn't
 118          * get useful error messages.
 119          */
 120         if (smf->file_buffer_length < 6) {
 121                 g_critical("SMF error: file is too short, it cannot be a MIDI file.");
 122
 123                 return (-1);
 124         }
 125
 126         tmp_mthd = (chunk_header_struct*)smf->file_buffer;
 127
 128         if (!chunk_signature_matches(tmp_mthd, "MThd")) {
 129                 g_critical("SMF error: MThd signature not found, is that a MIDI file?");
 130
 131                 return (-2);
 132         }
 133
 134         /* Ok, now use next_chunk(). */
 135         mthd = next_chunk(smf);
 136         if (mthd == NULL)
 137                 return (-3);
 138
 139         assert(mthd == tmp_mthd);
 140
 141         len = ntohl(mthd->length);
 142         if (len != 6) {
 143                 g_critical("SMF error: MThd chunk length %d, must be 6.", len);
 144
 145                 return (-4);
 146         }
 147
 148         return (0);
 149 }
 150
 151 /**
 152  * Parses MThd chunk, filling "smf" structure with values extracted from it.  Returns 0 iff everything went OK.
 153  */
 154 static int
 155 parse_mthd_chunk(smf_t *smf)
 156 {
 157         signed char first_byte_of_division, second_byte_of_division;
 158
 159         struct mthd_chunk_struct *mthd;
 160
 161         assert(sizeof(struct mthd_chunk_struct) == 14);
 162
 163         if (parse_mthd_header(smf))
 164                 return (1);
 165
 166         mthd = (struct mthd_chunk_struct *)smf->file_buffer;
 167
 168         smf->format = ntohs(mthd->format);
 169         if (smf->format < 0 || smf->format > 2) {
 170                 g_critical("SMF error: bad MThd format field value: %d, valid values are 0-2, inclusive.", smf->format);
 171                 return (-1);
 172         }
 173
 174         if (smf->format == 2) {
 175                 g_critical("SMF file uses format #2, no support for that yet.");
 176                 return (-2);
 177         }
 178
 179         smf->expected_number_of_tracks = ntohs(mthd->number_of_tracks);
 180         if (smf->expected_number_of_tracks <= 0) {
 181                 g_critical("SMF error: bad number of tracks: %d, must be greater than zero.", smf->expected_number_of_tracks);
 182                 return (-3);
 183         }
 184
 185         /* XXX: endianess? */
 186         first_byte_of_division = *((signed char *)&(mthd->division));
 187         second_byte_of_division = *((signed char *)&(mthd->division) + 1);
 188
 189         if (first_byte_of_division >= 0) {
 190                 smf->ppqn = ntohs(mthd->division);
 191                 smf->frames_per_second = 0;
 192                 smf->resolution = 0;
 193         } else {
 194                 smf->ppqn = 0;
 195                 smf->frames_per_second = - first_byte_of_division;
 196                 smf->resolution = second_byte_of_division;
 197         }
 198
 199         if (smf->ppqn == 0) {
 200                 g_critical("SMF file uses FPS timing instead of PPQN, no support for that yet.");
 201                 return (-4);
 202         }
 203
 204         return (0);
 205 }
 206
 207 /**
 208  * Interprets Variable Length Quantity pointed at by "buf" and puts its value into "value" and number
 209  * of bytes consumed into "len", making sure it does not read past "buf" + "buffer_length".
 210  * Explanation of Variable Length Quantities is here: http://www.borg.com/~jglatt/tech/midifile/vari.htm
 211  * Returns 0 iff everything went OK, different value in case of error.
 212  */
 213 int
 214 smf_extract_vlq(const unsigned char *buf, const size_t buffer_length, uint32_t *value, uint32_t *len)
 215 {
 216         uint32_t val = 0;
 217         const unsigned char *c = buf;
 218
 219         for (;;) {
 220                 if (c >= buf + buffer_length) {
 221                         g_critical("End of buffer in extract_vlq().");
 222                         return (-1);
 223                 }
 224
 225                 val = (val << 7) + (*c & 0x7F);
 226
 227                 if (*c & 0x80)
 228                         c++;
 229                 else
 230                         break;
 231         };
 232
 233         assert(c >= buf);
 234         *value = val;
 235         *len = c - buf + 1;
 236
 237         if (*len > 4) {
 238                 g_critical("SMF error: Variable Length Quantities longer than four bytes are not supported yet.");
 239                 return (-2);
 240         }
 241
 242         return (0);
 243 }
 244
 245 /**
 246  * Returns 1 if the given byte is a valid status byte, 0 otherwise.
 247  */
 248 int
 249 is_status_byte(const unsigned char status)
 250 {
 251         return (status & 0x80);
 252 }
 253
 254 static int
 255 is_sysex_byte(const unsigned char status)
 256 {
 257         if (status == 0xF0)
 258                 return (1);
 259
 260         return (0);
 261 }
 262
 263 static int
 264 is_escape_byte(const unsigned char status)
 265 {
 266         if (status == 0xF7)
 267                 return (1);
 268
 269         return (0);
 270 }
 271
 272 /**
 273  * Just like expected_message_length(), but only for System Exclusive messages.
 274  * Note that value returned by this thing here is the length of SysEx "on the wire",
 275  * not the number of bytes that this sysex takes in the file - in SMF format sysex
 276  * contains VLQ telling how many bytes it takes, "on the wire" format does not have
 277  * this.
 278  */
 279 static int32_t
 280 expected_sysex_length(const unsigned char status, const unsigned char *second_byte, const size_t buffer_length, int32_t *consumed_bytes)
 281 {
 282         uint32_t sysex_length = 0;
 283         uint32_t len = 0;
 284
 285         assert(status == 0xF0);
 286
 287         if (buffer_length < 3) {
 288                 g_critical("SMF error: end of buffer in expected_sysex_length().");
 289                 return (-1);
 290         }
 291
 292         smf_extract_vlq(second_byte, buffer_length, &sysex_length, &len);
 293
 294         if (consumed_bytes != NULL)
 295                 *consumed_bytes = len;
 296
 297         /* +1, because the length does not include status byte. */
 298         return (sysex_length + 1);
 299 }
 300
 301 static int32_t
 302 expected_escaped_length(const unsigned char status, const unsigned char *second_byte, const size_t buffer_length, int32_t *consumed_bytes)
 303 {
 304         /* -1, because we do not want to account for 0x7F status. */
 305         return (expected_sysex_length(status, second_byte, buffer_length, consumed_bytes) - 1);
 306 }
 307
 308 /**
 309  * Returns expected length of the midi message (including the status byte), in bytes, for the given status byte.
 310  * The "second_byte" points to the expected second byte of the MIDI message.  "buffer_length" is the buffer
 311  * length limit, counting from "second_byte".  Returns value < 0 iff there was an error.
 312  */
 313 static int32_t
 314 expected_message_length(unsigned char status, const unsigned char *second_byte, const size_t buffer_length)
 315 {
 316         /* Make sure this really is a valid status byte. */
 317         assert(is_status_byte(status));
 318
 319         /* We cannot use this routine for sysexes. */
 320         assert(!is_sysex_byte(status));
 321
 322         /* We cannot use this routine for escaped events. */
 323         assert(!is_escape_byte(status));
 324
 325         /* Is this a metamessage? */
 326         if (status == 0xFF) {
 327                 if (buffer_length < 2) {
 328                         g_critical("SMF error: end of buffer in expected_message_length().");
 329                         return (-1);
 330                 }
 331
 332                 /*
 333                  * Format of this kind of messages is like this: 0xFF 0xwhatever 0xlength and then "length" bytes.
 334                  * Second byte points to this:                        ^^^^^^^^^^
 335                  */
 336                 return (*(second_byte + 1) + 3);
 337         }
 338
 339         if ((status & 0xF0) == 0xF0) {
 340                 switch (status) {
 341                         case 0xF2: /* Song Position Pointer. */
 342                                 return (3);
 343
 344                         case 0xF1: /* MTC Quarter Frame. */
 345                         case 0xF3: /* Song Select. */
 346                                 return (2);
 347
 348                         case 0xF6: /* Tune Request. */
 349                         case 0xF8: /* MIDI Clock. */
 350                         case 0xF9: /* Tick. */
 351                         case 0xFA: /* MIDI Start. */
 352                         case 0xFB: /* MIDI Continue. */
 353                         case 0xFC: /* MIDI Stop. */
 354                         case 0xFE: /* Active Sense. */
 355                                 return (1);
 356
 357                         default:
 358                                 g_critical("SMF error: unknown 0xFx-type status byte '0x%x'.", status);
 359                                 return (-2);
 360                 }
 361         }
 362
 363         /* Filter out the channel. */
 364         status &= 0xF0;
 365
 366         switch (status) {
 367                 case 0x80: /* Note Off. */
 368                 case 0x90: /* Note On. */
 369                 case 0xA0: /* AfterTouch. */
 370                 case 0xB0: /* Control Change. */
 371                 case 0xE0: /* Pitch Wheel. */
 372                         return (3);
 373
 374                 case 0xC0: /* Program Change. */
 375                 case 0xD0: /* Channel Pressure. */
 376                         return (2);
 377
 378                 default:
 379                         g_critical("SMF error: unknown status byte '0x%x'.", status);
 380                         return (-3);
 381         }
 382 }
 383
 384 static int
 385 extract_sysex_event(const unsigned char *buf, const size_t buffer_length, smf_event_t *event, uint32_t *len, int last_status)
 386 {
 387         (void) last_status;
 388
 389         int status;
 390         int32_t vlq_length, message_length;
 391         const unsigned char *c = buf;
 392
 393         status = *buf;
 394
 395         assert(is_sysex_byte(status));
 396
 397         c++;
 398
 399         message_length = expected_sysex_length(status, c, buffer_length - 1, &vlq_length);
 400
 401         if (message_length < 0)
 402                 return (-3);
 403
 404         c += vlq_length;
 405
 406         if (vlq_length + (size_t)message_length >= buffer_length) {
 407                 g_critical("End of buffer in extract_sysex_event().");
 408                 return (-5);
 409         }
 410
 411         event->midi_buffer_length = message_length;
 412         event->midi_buffer = (uint8_t*)malloc(event->midi_buffer_length);
 413         if (event->midi_buffer == NULL) {
 414                 g_critical("Cannot allocate memory in extract_sysex_event(): %s", strerror(errno));
 415                 return (-4);
 416         }
 417
 418         event->midi_buffer[0] = status;
 419         memcpy(event->midi_buffer + 1, c, message_length - 1);
 420
 421         *len = vlq_length + message_length;
 422
 423         return (0);
 424 }
 425
 426 static int
 427 extract_escaped_event(const unsigned char *buf, const size_t buffer_length, smf_event_t *event, uint32_t *len, int last_status)
 428 {
 429         (void) last_status;
 430
 431         int status;
 432         int32_t message_length = 0;
 433         int32_t vlq_length = 0;
 434         const unsigned char *c = buf;
 435
 436         status = *buf;
 437
 438         assert(is_escape_byte(status));
 439
 440         c++;
 441
 442         message_length = expected_escaped_length(status, c, buffer_length - 1, &vlq_length);
 443
 444         if (message_length < 0)
 445                 return (-3);
 446
 447         c += vlq_length;
 448
 449         if (vlq_length + (size_t)message_length >= buffer_length) {
 450                 g_critical("End of buffer in extract_escaped_event().");
 451                 return (-5);
 452         }
 453
 454         event->midi_buffer_length = message_length;
 455         event->midi_buffer = (uint8_t*)malloc(event->midi_buffer_length);
 456         if (event->midi_buffer == NULL) {
 457                 g_critical("Cannot allocate memory in extract_escaped_event(): %s", strerror(errno));
 458                 return (-4);
 459         }
 460
 461         memcpy(event->midi_buffer, c, message_length);
 462
 463         if (smf_event_is_valid(event)) {
 464                 g_critical("Escaped event is invalid.");
 465                 return (-1);
 466         }
 467
 468         if (smf_event_is_system_realtime(event) || smf_event_is_system_common(event)) {
 469                 g_warning("Escaped event is not System Realtime nor System Common.");
 470         }
 471
 472         *len = vlq_length + message_length;
 473
 474         return (0);
 475 }
 476
 477
 478 /**
 479  * Puts MIDI data extracted from from "buf" into "event" and number of consumed bytes into "len".
 480  * In case valid status is not found, it uses "last_status" (so called "running status").
 481  * Returns 0 iff everything went OK, value < 0 in case of error.
 482  */
 483 static int
 484 extract_midi_event(const unsigned char *buf, const size_t buffer_length, smf_event_t *event, uint32_t *len, int last_status)
 485 {
 486         int status;
 487         int32_t message_length;
 488         const unsigned char *c = buf;
 489
 490         assert(buffer_length > 0);
 491
 492         /* Is the first byte the status byte? */
 493         if (is_status_byte(*c)) {
 494                 status = *c;
 495                 c++;
 496
 497         } else {
 498                 /* No, we use running status then. */
 499                 status = last_status;
 500         }
 501
 502         if (!is_status_byte(status)) {
 503                 g_critical("SMF error: bad status byte (MSB is zero).");
 504                 return (-1);
 505         }
 506
 507         if (is_sysex_byte(status))
 508                 return (extract_sysex_event(buf, buffer_length, event, len, last_status));
 509
 510         if (is_escape_byte(status))
 511                 return (extract_escaped_event(buf, buffer_length, event, len, last_status));
 512
 513         /* At this point, "c" points to first byte following the status byte. */
 514         message_length = expected_message_length(status, c, buffer_length - (c - buf));
 515
 516         if (message_length < 0)
 517                 return (-3);
 518
 519         if ((size_t)message_length > buffer_length - (c - buf) + 1) {
 520                 g_critical("End of buffer in extract_midi_event().");
 521                 return (-5);
 522         }
 523
 524         event->midi_buffer_length = message_length;
 525         event->midi_buffer = (uint8_t*)malloc(event->midi_buffer_length);
 526         if (event->midi_buffer == NULL) {
 527                 g_critical("Cannot allocate memory in extract_midi_event(): %s", strerror(errno));
 528                 return (-4);
 529         }
 530
 531         event->midi_buffer[0] = status;
 532         memcpy(event->midi_buffer + 1, c, message_length - 1);
 533
 534         *len = c + message_length - 1 - buf;
 535
 536         return (0);
 537 }
 538
 539 /**
 540  * Locates, basing on track->next_event_offset, the next event data in track->buffer,
 541  * interprets it, allocates smf_event_t and fills it properly.  Returns smf_event_t
 542  * or NULL, if there was an error.  Allocating event means adding it to the track;
 543  * see smf_event_new().
 544  */
 545 static smf_event_t *
 546 parse_next_event(smf_track_t *track)
 547 {
 548         uint32_t time = 0;
 549         uint32_t len;
 550         size_t buffer_length;
 551         unsigned char *c, *start;
 552
 553         smf_event_t *event = smf_event_new();
 554         if (event == NULL)
 555                 goto error;
 556
 557         c = start = (unsigned char *)track->file_buffer + track->next_event_offset;
 558
 559         assert(track->file_buffer != NULL);
 560         assert(track->file_buffer_length > 0);
 561         assert(track->next_event_offset > 0);
 562
 563         buffer_length = track->file_buffer_length - track->next_event_offset;
 564         assert(buffer_length > 0);
 565
 566         /* First, extract time offset from previous event. */
 567         if (smf_extract_vlq(c, buffer_length, &time, &len))
 568                 goto error;
 569
 570         c += len;
 571         buffer_length -= len;
 572
 573         if (buffer_length <= 0)
 574                 goto error;
 575
 576         /* Now, extract the actual event. */
 577         if (extract_midi_event(c, buffer_length, event, &len, track->last_status))
 578                 goto error;
 579
 580         c += len;
 581         buffer_length -= len;
 582         track->last_status = event->midi_buffer[0];
 583         track->next_event_offset += c - start;
 584
 585         smf_track_add_event_delta_pulses(track, event, time);
 586
 587         return (event);
 588
 589 error:
 590         if (event != NULL)
 591                 smf_event_delete(event);
 592
 593         return (NULL);
 594 }
 595
 596 /**
 597  * Takes "len" characters starting in "buf", making sure it does not access past the length of the buffer,
 598  * and makes ordinary, zero-terminated string from it.  May return NULL if there was any problem.
 599  */
 600 static char *
 601 make_string(const unsigned char *buf, const size_t buffer_length, uint32_t len)
 602 {
 603         char *str;
 604
 605         assert(buffer_length > 0);
 606         assert(len > 0);
 607
 608         if (len > buffer_length) {
 609                 g_critical("End of buffer in make_string().");
 610
 611                 len = buffer_length;
 612         }
 613
 614         str = (char*)malloc(len + 1);
 615         if (str == NULL) {
 616                 g_critical("Cannot allocate memory in make_string().");
 617                 return (NULL);
 618         }
 619
 620         memcpy(str, buf, len);
 621         str[len] = '\0';
 622
 623         return (str);
 624 }
 625
 626 /**
 627  * \return 1, if passed a metaevent containing text, that is, Text, Copyright,
 628  * Sequence/Track Name, Instrument, Lyric, Marker, Cue Point, Program Name,
 629  * or Device Name; 0 otherwise.
 630  */
 631 int
 632 smf_event_is_textual(const smf_event_t *event)
 633 {
 634         if (!smf_event_is_metadata(event))
 635                 return (0);
 636
 637         if (event->midi_buffer_length < 4)
 638                 return (0);
 639
 640         if (event->midi_buffer[3] < 1 && event->midi_buffer[3] > 9)
 641                 return (0);
 642
 643         return (1);
 644 }
 645
 646 /**
 647  * Extracts text from "textual metaevents", such as Text or Lyric.
 648  *
 649  * \return Zero-terminated string extracted from "text events" or NULL, if there was any problem.
 650  */
 651 char *
 652 smf_event_extract_text(const smf_event_t *event)
 653 {
 654         uint32_t string_length = 0;
 655         uint32_t length_length = 0;
 656
 657         if (!smf_event_is_textual(event))
 658                 return (NULL);
 659
 660         if (event->midi_buffer_length < 3) {
 661                 g_critical("smf_event_extract_text: truncated MIDI message.");
 662                 return (NULL);
 663         }
 664
 665         smf_extract_vlq((const unsigned char*)(void *)&(event->midi_buffer[2]), event->midi_buffer_length - 2, &string_length, &length_length);
 666
 667         if (string_length <= 0) {
 668                 g_critical("smf_event_extract_text: truncated MIDI message.");
 669                 return (NULL);
 670         }
 671
 672         return (make_string((const unsigned char*)(void *)(&event->midi_buffer[2] + length_length), event->midi_buffer_length - 2 - length_length, string_length));
 673 }
 674
 675 /**
 676  * Verify if the next chunk really is MTrk chunk, and if so, initialize some track variables and return 0.
 677  * Return different value otherwise.
 678  */
 679 static int
 680 parse_mtrk_header(smf_track_t *track)
 681 {
 682         struct chunk_header_struct *mtrk;
 683
 684         /* Make sure compiler didn't do anything stupid. */
 685         assert(sizeof(struct chunk_header_struct) == 8);
 686         assert(track->smf != NULL);
 687
 688         mtrk = next_chunk(track->smf);
 689
 690         if (mtrk == NULL)
 691                 return (-1);
 692
 693         if (!chunk_signature_matches(mtrk, "MTrk")) {
 694                 g_warning("SMF warning: Expected MTrk signature, got %c%c%c%c instead; ignoring this chunk.",
 695                                 mtrk->id[0], mtrk->id[1], mtrk->id[2], mtrk->id[3]);
 696
 697                 return (-2);
 698         }
 699
 700         track->file_buffer = mtrk;
 701         track->file_buffer_length = sizeof(struct chunk_header_struct) + ntohl(mtrk->length);
 702         track->next_event_offset = sizeof(struct chunk_header_struct);
 703
 704         return (0);
 705 }
 706
 707 /**
 708  * Return 1 if event is end-of-the-track, 0 otherwise.
 709  */
 710 static int
 711 event_is_end_of_track(const smf_event_t *event)
 712 {
 713         if (event->midi_buffer[0] == 0xFF && event->midi_buffer[1] == 0x2F)
 714                 return (1);
 715
 716         return (0);
 717 }
 718
 719 /**
 720  * \return Nonzero, if event is as long as it should be, from the MIDI specification point of view.
 721  * Does not work for SysExes - it doesn't recognize internal structure of SysEx.
 722  */
 723 int
 724 smf_event_length_is_valid(const smf_event_t *event)
 725 {
 726         assert(event);
 727         assert(event->midi_buffer);
 728
 729         int32_t expected;
 730
 731         if (event->midi_buffer_length < 1)
 732                 return (0);
 733
 734         /* We cannot use expected_message_length on sysexes. */
 735         if (smf_event_is_sysex(event))
 736                 return (1);
 737
 738
 739         expected = expected_message_length(event->midi_buffer[0],
 740                         &(event->midi_buffer[1]), event->midi_buffer_length - 1);
 741         if (expected < 0 || event->midi_buffer_length != (size_t)expected) {
 742                 return (0);
 743         }
 744
 745         return (1);
 746 }
 747
 748 /**
 749  * \return Nonzero, if MIDI data in the event is valid, 0 otherwise.  For example,
 750  * it checks if event length is correct.
 751  */
 752 /* XXX: this routine requires some more work to detect more errors. */
 753 int
 754 smf_event_is_valid(const smf_event_t *event)
 755 {
 756         assert(event);
 757         assert(event->midi_buffer);
 758         assert(event->midi_buffer_length >= 1);
 759
 760         if (!is_status_byte(event->midi_buffer[0])) {
 761                 g_critical("First byte of MIDI message is not a valid status byte.");
 762
 763                 return (0);
 764         }
 765
 766         if (!smf_event_length_is_valid(event))
 767                 return (0);
 768
 769         return (1);
 770 }
 771
 772 /**
 773  * Parse events and put it on the track.
 774  */
 775 static int
 776 parse_mtrk_chunk(smf_track_t *track)
 777 {
 778         smf_event_t *event;
 779
 780         if (parse_mtrk_header(track))
 781                 return (-1);
 782
 783         for (;;) {
 784                 event = parse_next_event(track);
 785
 786                 /* Couldn't parse an event? */
 787                 if (event == NULL)
 788                         return (-1);
 789
 790                 assert(smf_event_is_valid(event));
 791
 792                 if (event_is_end_of_track(event))
 793                         break;
 794         }
 795
 796         track->file_buffer = NULL;
 797         track->file_buffer_length = 0;
 798         track->next_event_offset = -1;
 799
 800         return (0);
 801 }
 802
 803 /**
 804  * Allocate buffer of proper size and read file contents into it.
 805  */
 806 static int
 807 load_file_into_buffer(void **file_buffer, size_t *file_buffer_length, FILE* stream)
 808 {
 809         long offset;
 810
 811         if (stream == NULL) {
 812                 g_critical("Cannot open input file: %s", strerror(errno));
 813
 814                 return (-1);
 815         }
 816
 817         if (fseek(stream, 0, SEEK_END)) {
 818                 g_critical("fseek(3) failed: %s", strerror(errno));
 819
 820                 return (-2);
 821         }
 822
 823         offset = ftell(stream);
 824         if (offset < 0) {
 825                 g_critical("ftell(3) failed: %s", strerror(errno));
 826
 827                 return (-3);
 828         }
 829         *file_buffer_length = (size_t)offset;
 830
 831         if (fseek(stream, 0, SEEK_SET)) {
 832                 g_critical("fseek(3) failed: %s", strerror(errno));
 833
 834                 return (-4);
 835         }
 836
 837         *file_buffer = malloc(*file_buffer_length);
 838         if (*file_buffer == NULL) {
 839                 g_critical("malloc(3) failed: %s", strerror(errno));
 840
 841                 return (-5);
 842         }
 843
 844         if (fread(*file_buffer, 1, *file_buffer_length, stream) != *file_buffer_length) {
 845                 g_critical("fread(3) failed: %s", strerror(errno));
 846                 free (*file_buffer);
 847                 *file_buffer = NULL;
 848                 return (-6);
 849         }
 850
 851         return (0);
 852 }
 853
 854 /**
 855   * Creates new SMF and fills it with data loaded from the given buffer.
 856  * \return SMF or NULL, if loading failed.
 857   */
 858 smf_t *
 859 smf_load_from_memory(const void *buffer, const size_t buffer_length)
 860 {
 861         int i;
 862
 863         smf_t *smf = smf_new();
 864
 865         smf->file_buffer = (void *)buffer;
 866         smf->file_buffer_length = buffer_length;
 867         smf->next_chunk_offset = 0;
 868
 869         if (parse_mthd_chunk(smf))
 870                 return (NULL);
 871
 872         for (i = 1; i <= smf->expected_number_of_tracks; i++) {
 873                 smf_track_t *track = smf_track_new();
 874                 if (track == NULL)
 875                         return (NULL);
 876
 877                 smf_add_track(smf, track);
 878
 879                 /* Skip unparseable chunks. */
 880                 if (parse_mtrk_chunk(track)) {
 881                         g_warning("SMF warning: Cannot load track.");
 882                         smf_track_delete(track);
 883                         continue;
 884                 }
 885
 886                 track->file_buffer = NULL;
 887                 track->file_buffer_length = 0;
 888                 track->next_event_offset = -1;
 889         }
 890
 891         if (smf->expected_number_of_tracks != smf->number_of_tracks) {
 892                 g_warning("SMF warning: MThd header declared %d tracks, but only %d found; continuing anyway.",
 893                                 smf->expected_number_of_tracks, smf->number_of_tracks);
 894
 895                 smf->expected_number_of_tracks = smf->number_of_tracks;
 896         }
 897
 898         smf->file_buffer = NULL;
 899         smf->file_buffer_length = 0;
 900         smf->next_chunk_offset = 0;
 901
 902         return (smf);
 903 }
 904
 905 /**
 906  * Loads SMF file.
 907  *
 908  * \param file Open file.
 909  * \return SMF or NULL, if loading failed.
 910  */
 911 smf_t *
 912 smf_load(FILE *file)
 913 {
 914         size_t file_buffer_length;
 915         void *file_buffer;
 916         smf_t *smf;
 917
 918         if (load_file_into_buffer(&file_buffer, &file_buffer_length, file))
 919                 return (NULL);
 920
 921         smf = smf_load_from_memory(file_buffer, file_buffer_length);
 922
 923         memset(file_buffer, 0, file_buffer_length);
 924         free(file_buffer);
 925
 926         if (smf == NULL)
 927                 return (NULL);
 928
 929         smf_rewind(smf);
 930
 931         return (smf);
 932 }
 933