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 PLATFORM_WINDOWS
  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 = (struct 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 #ifndef NDEBUG
 286         (void) status;
 287 #else
 288         assert(status == 0xF0);
 289 #endif
 290
 291         if (buffer_length < 3) {
 292                 g_critical("SMF error: end of buffer in expected_sysex_length().");
 293                 return (-1);
 294         }
 295
 296         smf_extract_vlq(second_byte, buffer_length, &sysex_length, &len);
 297
 298         if (consumed_bytes != NULL)
 299                 *consumed_bytes = len;
 300
 301         /* +1, because the length does not include status byte. */
 302         return (sysex_length + 1);
 303 }
 304
 305 static int32_t
 306 expected_escaped_length(const unsigned char status, const unsigned char *second_byte, const size_t buffer_length, int32_t *consumed_bytes)
 307 {
 308         /* -1, because we do not want to account for 0x7F status. */
 309         return (expected_sysex_length(status, second_byte, buffer_length, consumed_bytes) - 1);
 310 }
 311
 312 /**
 313  * Returns expected length of the midi message (including the status byte), in bytes, for the given status byte.
 314  * The "second_byte" points to the expected second byte of the MIDI message.  "buffer_length" is the buffer
 315  * length limit, counting from "second_byte".  Returns value < 0 iff there was an error.
 316  */
 317 static int32_t
 318 expected_message_length(unsigned char status, const unsigned char *second_byte, const size_t buffer_length)
 319 {
 320         /* Make sure this really is a valid status byte. */
 321         assert(is_status_byte(status));
 322
 323         /* We cannot use this routine for sysexes. */
 324         assert(!is_sysex_byte(status));
 325
 326         /* We cannot use this routine for escaped events. */
 327         assert(!is_escape_byte(status));
 328
 329         /* Is this a metamessage? */
 330         if (status == 0xFF) {
 331                 if (buffer_length < 2) {
 332                         g_critical("SMF error: end of buffer in expected_message_length().");
 333                         return (-1);
 334                 }
 335
 336                 /*
 337                  * Format of this kind of messages is like this: 0xFF 0xwhatever 0xlength and then "length" bytes.
 338                  * Second byte points to this:                        ^^^^^^^^^^
 339                  */
 340                 return (*(second_byte + 1) + 3);
 341         }
 342
 343         if ((status & 0xF0) == 0xF0) {
 344                 switch (status) {
 345                         case 0xF2: /* Song Position Pointer. */
 346                                 return (3);
 347
 348                         case 0xF1: /* MTC Quarter Frame. */
 349                         case 0xF3: /* Song Select. */
 350                                 return (2);
 351
 352                         case 0xF6: /* Tune Request. */
 353                         case 0xF8: /* MIDI Clock. */
 354                         case 0xF9: /* Tick. */
 355                         case 0xFA: /* MIDI Start. */
 356                         case 0xFB: /* MIDI Continue. */
 357                         case 0xFC: /* MIDI Stop. */
 358                         case 0xFE: /* Active Sense. */
 359                                 return (1);
 360
 361                         default:
 362                                 g_critical("SMF error: unknown 0xFx-type status byte '0x%x'.", status);
 363                                 return (-2);
 364                 }
 365         }
 366
 367         /* Filter out the channel. */
 368         status &= 0xF0;
 369
 370         switch (status) {
 371                 case 0x80: /* Note Off. */
 372                 case 0x90: /* Note On. */
 373                 case 0xA0: /* AfterTouch. */
 374                 case 0xB0: /* Control Change. */
 375                 case 0xE0: /* Pitch Wheel. */
 376                         return (3);
 377
 378                 case 0xC0: /* Program Change. */
 379                 case 0xD0: /* Channel Pressure. */
 380                         return (2);
 381
 382                 default:
 383                         g_critical("SMF error: unknown status byte '0x%x'.", status);
 384                         return (-3);
 385         }
 386 }
 387
 388 static int
 389 extract_sysex_event(const unsigned char *buf, const size_t buffer_length, smf_event_t *event, uint32_t *len, int last_status)
 390 {
 391         (void) last_status;
 392
 393         int status;
 394         int32_t vlq_length, message_length;
 395         const unsigned char *c = buf;
 396
 397         status = *buf;
 398
 399         assert(is_sysex_byte(status));
 400
 401         c++;
 402
 403         message_length = expected_sysex_length(status, c, buffer_length - 1, &vlq_length);
 404
 405         if (message_length < 0)
 406                 return (-3);
 407
 408         c += vlq_length;
 409
 410         if (vlq_length + (size_t)message_length >= buffer_length) {
 411                 g_critical("End of buffer in extract_sysex_event().");
 412                 return (-5);
 413         }
 414
 415         event->midi_buffer_length = message_length;
 416         event->midi_buffer = (uint8_t*)malloc(event->midi_buffer_length);
 417         if (event->midi_buffer == NULL) {
 418                 g_critical("Cannot allocate memory in extract_sysex_event(): %s", strerror(errno));
 419                 return (-4);
 420         }
 421
 422         event->midi_buffer[0] = status;
 423         memcpy(event->midi_buffer + 1, c, message_length - 1);
 424
 425         *len = vlq_length + message_length;
 426
 427         return (0);
 428 }
 429
 430 static int
 431 extract_escaped_event(const unsigned char *buf, const size_t buffer_length, smf_event_t *event, uint32_t *len, int last_status)
 432 {
 433         (void) last_status;
 434
 435         int status;
 436         int32_t message_length = 0;
 437         int32_t vlq_length = 0;
 438         const unsigned char *c = buf;
 439
 440         status = *buf;
 441
 442         assert(is_escape_byte(status));
 443
 444         c++;
 445
 446         message_length = expected_escaped_length(status, c, buffer_length - 1, &vlq_length);
 447
 448         if (message_length < 0)
 449                 return (-3);
 450
 451         c += vlq_length;
 452
 453         if (vlq_length + (size_t)message_length >= buffer_length) {
 454                 g_critical("End of buffer in extract_escaped_event().");
 455                 return (-5);
 456         }
 457
 458         event->midi_buffer_length = message_length;
 459         event->midi_buffer = (uint8_t*)malloc(event->midi_buffer_length);
 460         if (event->midi_buffer == NULL) {
 461                 g_critical("Cannot allocate memory in extract_escaped_event(): %s", strerror(errno));
 462                 return (-4);
 463         }
 464
 465         memcpy(event->midi_buffer, c, message_length);
 466
 467         if (smf_event_is_valid(event)) {
 468                 g_critical("Escaped event is invalid.");
 469                 return (-1);
 470         }
 471
 472         if (smf_event_is_system_realtime(event) || smf_event_is_system_common(event)) {
 473                 g_warning("Escaped event is not System Realtime nor System Common.");
 474         }
 475
 476         *len = vlq_length + message_length;
 477
 478         return (0);
 479 }
 480
 481
 482 /**
 483  * Puts MIDI data extracted from from "buf" into "event" and number of consumed bytes into "len".
 484  * In case valid status is not found, it uses "last_status" (so called "running status").
 485  * Returns 0 iff everything went OK, value < 0 in case of error.
 486  */
 487 static int
 488 extract_midi_event(const unsigned char *buf, const size_t buffer_length, smf_event_t *event, uint32_t *len, int last_status)
 489 {
 490         int status;
 491         int32_t message_length;
 492         const unsigned char *c = buf;
 493
 494         assert(buffer_length > 0);
 495
 496         /* Is the first byte the status byte? */
 497         if (is_status_byte(*c)) {
 498                 status = *c;
 499                 c++;
 500
 501         } else {
 502                 /* No, we use running status then. */
 503                 status = last_status;
 504         }
 505
 506         if (!is_status_byte(status)) {
 507                 g_critical("SMF error: bad status byte (MSB is zero).");
 508                 return (-1);
 509         }
 510
 511         if (is_sysex_byte(status))
 512                 return (extract_sysex_event(buf, buffer_length, event, len, last_status));
 513
 514         if (is_escape_byte(status))
 515                 return (extract_escaped_event(buf, buffer_length, event, len, last_status));
 516
 517         /* At this point, "c" points to first byte following the status byte. */
 518         message_length = expected_message_length(status, c, buffer_length - (c - buf));
 519
 520         if (message_length < 0)
 521                 return (-3);
 522
 523         if ((size_t)message_length > buffer_length - (c - buf) + 1) {
 524                 g_critical("End of buffer in extract_midi_event().");
 525                 return (-5);
 526         }
 527
 528         event->midi_buffer_length = message_length;
 529         event->midi_buffer = (uint8_t*)malloc(event->midi_buffer_length);
 530         if (event->midi_buffer == NULL) {
 531                 g_critical("Cannot allocate memory in extract_midi_event(): %s", strerror(errno));
 532                 return (-4);
 533         }
 534
 535         event->midi_buffer[0] = status;
 536         memcpy(event->midi_buffer + 1, c, message_length - 1);
 537
 538         *len = c + message_length - 1 - buf;
 539
 540         return (0);
 541 }
 542
 543 /**
 544  * Locates, basing on track->next_event_offset, the next event data in track->buffer,
 545  * interprets it, allocates smf_event_t and fills it properly.  Returns smf_event_t
 546  * or NULL, if there was an error.  Allocating event means adding it to the track;
 547  * see smf_event_new().
 548  */
 549 static smf_event_t *
 550 parse_next_event(smf_track_t *track)
 551 {
 552         uint32_t etime = 0;
 553         uint32_t len;
 554         size_t buffer_length;
 555         unsigned char *c, *start;
 556
 557         smf_event_t *event = smf_event_new();
 558         if (event == NULL)
 559                 goto error;
 560
 561         c = start = (unsigned char *)track->file_buffer + track->next_event_offset;
 562
 563         assert(track->file_buffer != NULL);
 564         assert(track->file_buffer_length > 0);
 565         assert(track->next_event_offset > 0);
 566
 567         buffer_length = track->file_buffer_length - track->next_event_offset;
 568         assert(buffer_length > 0);
 569
 570         /* First, extract time offset from previous event. */
 571         if (smf_extract_vlq(c, buffer_length, &etime, &len))
 572                 goto error;
 573
 574         c += len;
 575         buffer_length -= len;
 576
 577         if (buffer_length <= 0)
 578                 goto error;
 579
 580         /* Now, extract the actual event. */
 581         if (extract_midi_event(c, buffer_length, event, &len, track->last_status))
 582                 goto error;
 583
 584         c += len;
 585         buffer_length -= len;
 586         track->last_status = event->midi_buffer[0];
 587         track->next_event_offset += c - start;
 588
 589         smf_track_add_event_delta_pulses(track, event, etime);
 590
 591         return (event);
 592
 593 error:
 594         if (event != NULL)
 595                 smf_event_delete(event);
 596
 597         return (NULL);
 598 }
 599
 600 /**
 601  * Takes "len" characters starting in "buf", making sure it does not access past the length of the buffer,
 602  * and makes ordinary, zero-terminated string from it.  May return NULL if there was any problem.
 603  */
 604 static char *
 605 make_string(const unsigned char *buf, const size_t buffer_length, uint32_t len)
 606 {
 607         char *str;
 608
 609         assert(buffer_length > 0);
 610         assert(len > 0);
 611
 612         if (len > buffer_length) {
 613                 g_critical("End of buffer in make_string().");
 614
 615                 len = buffer_length;
 616         }
 617
 618         str = (char*)malloc(len + 1);
 619         if (str == NULL) {
 620                 g_critical("Cannot allocate memory in make_string().");
 621                 return (NULL);
 622         }
 623
 624         memcpy(str, buf, len);
 625         str[len] = '\0';
 626
 627         return (str);
 628 }
 629
 630 /**
 631  * \return 1, if passed a metaevent containing text, that is, Text, Copyright,
 632  * Sequence/Track Name, Instrument, Lyric, Marker, Cue Point, Program Name,
 633  * or Device Name; 0 otherwise.
 634  */
 635 int
 636 smf_event_is_textual(const smf_event_t *event)
 637 {
 638         if (!smf_event_is_metadata(event))
 639                 return (0);
 640
 641         if (event->midi_buffer_length < 4)
 642                 return (0);
 643
 644         if (event->midi_buffer[3] < 1 || event->midi_buffer[3] > 9)
 645                 return (0);
 646
 647         return (1);
 648 }
 649
 650 /**
 651  * Extracts text from "textual metaevents", such as Text or Lyric.
 652  *
 653  * \return Zero-terminated string extracted from "text events" or NULL, if there was any problem.
 654  */
 655 char *
 656 smf_event_extract_text(const smf_event_t *event)
 657 {
 658         uint32_t string_length = 0;
 659         uint32_t length_length = 0;
 660
 661         if (!smf_event_is_textual(event))
 662                 return (NULL);
 663
 664         if (event->midi_buffer_length < 3) {
 665                 g_critical("smf_event_extract_text: truncated MIDI message.");
 666                 return (NULL);
 667         }
 668
 669         smf_extract_vlq((const unsigned char*)(void *)&(event->midi_buffer[2]), event->midi_buffer_length - 2, &string_length, &length_length);
 670
 671         if (string_length <= 0) {
 672                 g_critical("smf_event_extract_text: truncated MIDI message.");
 673                 return (NULL);
 674         }
 675
 676         return (make_string((const unsigned char*)(void *)(&event->midi_buffer[2] + length_length), event->midi_buffer_length - 2 - length_length, string_length));
 677 }
 678
 679 /**
 680  * Verify if the next chunk really is MTrk chunk, and if so, initialize some track variables and return 0.
 681  * Return different value otherwise.
 682  */
 683 static int
 684 parse_mtrk_header(smf_track_t *track)
 685 {
 686         struct chunk_header_struct *mtrk;
 687
 688         /* Make sure compiler didn't do anything stupid. */
 689         assert(sizeof(struct chunk_header_struct) == 8);
 690         assert(track->smf != NULL);
 691
 692         mtrk = next_chunk(track->smf);
 693
 694         if (mtrk == NULL)
 695                 return (-1);
 696
 697         if (!chunk_signature_matches(mtrk, "MTrk")) {
 698                 g_warning("SMF warning: Expected MTrk signature, got %c%c%c%c instead; ignoring this chunk.",
 699                                 mtrk->id[0], mtrk->id[1], mtrk->id[2], mtrk->id[3]);
 700
 701                 return (-2);
 702         }
 703
 704         track->file_buffer = mtrk;
 705         track->file_buffer_length = sizeof(struct chunk_header_struct) + ntohl(mtrk->length);
 706         track->next_event_offset = sizeof(struct chunk_header_struct);
 707
 708         return (0);
 709 }
 710
 711 /**
 712  * Return 1 if event is end-of-the-track, 0 otherwise.
 713  */
 714 static int
 715 event_is_end_of_track(const smf_event_t *event)
 716 {
 717         if (event->midi_buffer[0] == 0xFF && event->midi_buffer[1] == 0x2F)
 718                 return (1);
 719
 720         return (0);
 721 }
 722
 723 /**
 724  * \return Nonzero, if event is as long as it should be, from the MIDI specification point of view.
 725  * Does not work for SysExes - it doesn't recognize internal structure of SysEx.
 726  */
 727 int
 728 smf_event_length_is_valid(const smf_event_t *event)
 729 {
 730         assert(event);
 731         assert(event->midi_buffer);
 732
 733         int32_t expected;
 734
 735         if (event->midi_buffer_length < 1)
 736                 return (0);
 737
 738         /* We cannot use expected_message_length on sysexes. */
 739         if (smf_event_is_sysex(event))
 740                 return (1);
 741
 742
 743         expected = expected_message_length(event->midi_buffer[0],
 744                         &(event->midi_buffer[1]), event->midi_buffer_length - 1);
 745         if (expected < 0 || event->midi_buffer_length != (size_t)expected) {
 746                 return (0);
 747         }
 748
 749         return (1);
 750 }
 751
 752 /**
 753  * \return Nonzero, if MIDI data in the event is valid, 0 otherwise.  For example,
 754  * it checks if event length is correct.
 755  */
 756 /* XXX: this routine requires some more work to detect more errors. */
 757 int
 758 smf_event_is_valid(const smf_event_t *event)
 759 {
 760         assert(event);
 761         assert(event->midi_buffer);
 762         assert(event->midi_buffer_length >= 1);
 763
 764         if (!is_status_byte(event->midi_buffer[0])) {
 765                 g_critical("First byte of MIDI message is not a valid status byte.");
 766
 767                 return (0);
 768         }
 769
 770         if (!smf_event_length_is_valid(event))
 771                 return (0);
 772
 773         return (1);
 774 }
 775
 776 /**
 777  * Parse events and put it on the track.
 778  */
 779 static int
 780 parse_mtrk_chunk(smf_track_t *track)
 781 {
 782         smf_event_t *event;
 783
 784         if (parse_mtrk_header(track))
 785                 return (-1);
 786
 787         for (;;) {
 788                 event = parse_next_event(track);
 789
 790                 /* Couldn't parse an event? */
 791                 if (event == NULL)
 792                         return (-1);
 793
 794                 assert(smf_event_is_valid(event));
 795
 796                 if (event_is_end_of_track(event))
 797                         break;
 798         }
 799
 800         track->file_buffer = NULL;
 801         track->file_buffer_length = 0;
 802         track->next_event_offset = -1;
 803
 804         return (0);
 805 }
 806
 807 /**
 808  * Allocate buffer of proper size and read file contents into it.
 809  */
 810 static int
 811 load_file_into_buffer(void **file_buffer, size_t *file_buffer_length, FILE* stream)
 812 {
 813         long offset;
 814
 815         if (stream == NULL) {
 816                 g_critical("Cannot open input file: %s", strerror(errno));
 817
 818                 return (-1);
 819         }
 820
 821         if (fseek(stream, 0, SEEK_END)) {
 822                 g_critical("fseek(3) failed: %s", strerror(errno));
 823
 824                 return (-2);
 825         }
 826
 827         offset = ftell(stream);
 828         if (offset < 0) {
 829                 g_critical("ftell(3) failed: %s", strerror(errno));
 830
 831                 return (-3);
 832         }
 833         *file_buffer_length = (size_t)offset;
 834
 835         if (fseek(stream, 0, SEEK_SET)) {
 836                 g_critical("fseek(3) failed: %s", strerror(errno));
 837
 838                 return (-4);
 839         }
 840
 841         *file_buffer = malloc(*file_buffer_length);
 842         if (*file_buffer == NULL) {
 843                 g_critical("malloc(3) failed: %s", strerror(errno));
 844
 845                 return (-5);
 846         }
 847
 848         if (fread(*file_buffer, 1, *file_buffer_length, stream) != *file_buffer_length) {
 849                 g_critical("fread(3) failed: %s", strerror(errno));
 850                 free (*file_buffer);
 851                 *file_buffer = NULL;
 852                 return (-6);
 853         }
 854
 855         return (0);
 856 }
 857
 858 /**
 859   * Creates new SMF and fills it with data loaded from the given buffer.
 860  * \return SMF or NULL, if loading failed.
 861   */
 862 smf_t *
 863 smf_load_from_memory(const void *buffer, const size_t buffer_length)
 864 {
 865         int i;
 866
 867         smf_t *smf = smf_new();
 868
 869         smf->file_buffer = (void *)buffer;
 870         smf->file_buffer_length = buffer_length;
 871         smf->next_chunk_offset = 0;
 872
 873         if (parse_mthd_chunk(smf))
 874                 return (NULL);
 875
 876         for (i = 1; i <= smf->expected_number_of_tracks; i++) {
 877                 smf_track_t *track = smf_track_new();
 878                 if (track == NULL)
 879                         return (NULL);
 880
 881                 smf_add_track(smf, track);
 882
 883                 /* Skip unparseable chunks. */
 884                 if (parse_mtrk_chunk(track)) {
 885                         g_warning("SMF warning: Cannot load track.");
 886                         smf_track_delete(track);
 887                         continue;
 888                 }
 889
 890                 track->file_buffer = NULL;
 891                 track->file_buffer_length = 0;
 892                 track->next_event_offset = -1;
 893         }
 894
 895         if (smf->expected_number_of_tracks != smf->number_of_tracks) {
 896                 g_warning("SMF warning: MThd header declared %d tracks, but only %d found; continuing anyway.",
 897                                 smf->expected_number_of_tracks, smf->number_of_tracks);
 898
 899                 smf->expected_number_of_tracks = smf->number_of_tracks;
 900         }
 901
 902         smf->file_buffer = NULL;
 903         smf->file_buffer_length = 0;
 904         smf->next_chunk_offset = 0;
 905
 906         return (smf);
 907 }
 908
 909 /**
 910  * Loads SMF file.
 911  *
 912  * \param file Open file.
 913  * \return SMF or NULL, if loading failed.
 914  */
 915 smf_t *
 916 smf_load(FILE *file)
 917 {
 918         size_t file_buffer_length;
 919         void *file_buffer;
 920         smf_t *smf;
 921
 922         if (load_file_into_buffer(&file_buffer, &file_buffer_length, file))
 923                 return (NULL);
 924
 925         smf = smf_load_from_memory(file_buffer, file_buffer_length);
 926
 927         memset(file_buffer, 0, file_buffer_length);
 928         free(file_buffer);
 929
 930         if (smf == NULL)
 931                 return (NULL);
 932
 933         smf_rewind(smf);
 934
 935         return (smf);
 936 }
 937