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