Mercurial > SDL_sound_CoreAudio
annotate decoders/timidity/readmidi.c @ 552:2e8907ff98e9
Replaced references to COPYING with references to LICENSE.txt ...
| author | Ryan C. Gordon <icculus@icculus.org> |
|---|---|
| date | Tue, 09 Sep 2008 16:28:11 -0400 |
| parents | c66080364dff |
| children |
| rev | line source |
|---|---|
| 199 | 1 /* |
| 2 | |
| 3 TiMidity -- Experimental MIDI to WAVE converter | |
| 4 Copyright (C) 1995 Tuukka Toivonen <toivonen@clinet.fi> | |
| 5 | |
| 6 This program is free software; you can redistribute it and/or modify | |
| 7 it under the terms of the GNU General Public License as published by | |
| 8 the Free Software Foundation; either version 2 of the License, or | |
| 9 (at your option) any later version. | |
| 10 | |
| 11 This program is distributed in the hope that it will be useful, | |
| 12 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| 14 GNU General Public License for more details. | |
| 15 | |
| 16 You should have received a copy of the GNU General Public License | |
| 17 along with this program; if not, write to the Free Software | |
| 18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
| 19 | |
| 20 */ | |
| 21 | |
| 22 #if HAVE_CONFIG_H | |
| 23 # include <config.h> | |
| 24 #endif | |
| 25 | |
| 26 #include <stdio.h> | |
| 27 #include <stdlib.h> | |
| 28 #include <string.h> | |
| 29 | |
| 30 #include "SDL_sound.h" | |
| 31 | |
| 32 #define __SDL_SOUND_INTERNAL__ | |
| 33 #include "SDL_sound_internal.h" | |
| 34 | |
| 35 #include "timidity.h" | |
| 36 #include "common.h" | |
| 37 #include "instrum.h" | |
| 38 #include "playmidi.h" | |
| 39 | |
| 40 /* Computes how many (fractional) samples one MIDI delta-time unit contains */ | |
| 41 static void compute_sample_increment(MidiSong *song, Sint32 tempo, | |
| 42 Sint32 divisions) | |
| 43 { | |
| 44 double a; | |
| 45 a = (double) (tempo) * (double) (song->rate) * (65536.0/1000000.0) / | |
| 46 (double)(divisions); | |
| 47 | |
| 48 song->sample_correction = (Sint32)(a) & 0xFFFF; | |
| 49 song->sample_increment = (Sint32)(a) >> 16; | |
| 50 | |
| 51 SNDDBG(("Samples per delta-t: %d (correction %d)", | |
| 52 song->sample_increment, song->sample_correction)); | |
| 53 } | |
| 54 | |
| 55 /* Read variable-length number (7 bits per byte, MSB first) */ | |
| 56 static Sint32 getvl(SDL_RWops *rw) | |
| 57 { | |
| 58 Sint32 l=0; | |
| 59 Uint8 c; | |
| 60 for (;;) | |
| 61 { | |
| 62 SDL_RWread(rw, &c, 1, 1); | |
| 63 l += (c & 0x7f); | |
| 64 if (!(c & 0x80)) return l; | |
| 65 l<<=7; | |
| 66 } | |
| 67 } | |
| 68 | |
| 69 /* Print a string from the file, followed by a newline. Any non-ASCII | |
| 70 or unprintable characters will be converted to periods. */ | |
| 71 static int dumpstring(SDL_RWops *rw, Sint32 len, char *label) | |
| 72 { | |
| 73 signed char *s=safe_malloc(len+1); | |
| 74 if (len != (Sint32) SDL_RWread(rw, s, 1, len)) | |
| 75 { | |
| 76 free(s); | |
| 77 return -1; | |
| 78 } | |
| 79 s[len]='\0'; | |
| 80 while (len--) | |
| 81 { | |
| 82 if (s[len]<32) | |
| 83 s[len]='.'; | |
| 84 } | |
| 85 SNDDBG(("%s%s", label, s)); | |
| 86 free(s); | |
| 87 return 0; | |
| 88 } | |
| 89 | |
| 90 #define MIDIEVENT(at,t,ch,pa,pb) \ | |
| 91 new=safe_malloc(sizeof(MidiEventList)); \ | |
| 92 new->event.time=at; new->event.type=t; new->event.channel=ch; \ | |
| 93 new->event.a=pa; new->event.b=pb; new->next=0;\ | |
| 94 return new; | |
| 95 | |
| 96 #define MAGIC_EOT ((MidiEventList *)(-1)) | |
| 97 | |
| 98 /* Read a MIDI event, returning a freshly allocated element that can | |
| 99 be linked to the event list */ | |
| 100 static MidiEventList *read_midi_event(MidiSong *song) | |
| 101 { | |
| 102 static Uint8 laststatus, lastchan; | |
| 103 static Uint8 nrpn=0, rpn_msb[16], rpn_lsb[16]; /* one per channel */ | |
| 104 Uint8 me, type, a,b,c; | |
| 105 Sint32 len; | |
| 106 MidiEventList *new; | |
| 107 | |
| 108 for (;;) | |
| 109 { | |
| 110 song->at += getvl(song->rw); | |
| 111 if (SDL_RWread(song->rw, &me, 1, 1) != 1) | |
| 112 { | |
| 113 SNDDBG(("read_midi_event: SDL_RWread() failure\n")); | |
| 114 return 0; | |
| 115 } | |
| 116 | |
| 117 if(me==0xF0 || me == 0xF7) /* SysEx event */ | |
| 118 { | |
| 119 len=getvl(song->rw); | |
| 120 SDL_RWseek(song->rw, len, SEEK_CUR); | |
| 121 } | |
| 122 else if(me==0xFF) /* Meta event */ | |
| 123 { | |
| 124 SDL_RWread(song->rw, &type, 1, 1); | |
| 125 len=getvl(song->rw); | |
| 126 if (type>0 && type<16) | |
| 127 { | |
| 128 static char *label[]={ | |
| 129 "Text event: ", "Text: ", "Copyright: ", "Track name: ", | |
| 130 "Instrument: ", "Lyric: ", "Marker: ", "Cue point: "}; | |
| 131 dumpstring(song->rw, len, label[(type>7) ? 0 : type]); | |
| 132 } | |
| 133 else | |
| 134 switch(type) | |
| 135 { | |
| 136 case 0x2F: /* End of Track */ | |
| 137 return MAGIC_EOT; | |
| 138 | |
| 139 case 0x51: /* Tempo */ | |
| 140 SDL_RWread(song->rw, &a, 1, 1); | |
| 141 SDL_RWread(song->rw, &b, 1, 1); | |
| 142 SDL_RWread(song->rw, &c, 1, 1); | |
| 143 MIDIEVENT(song->at, ME_TEMPO, c, a, b); | |
| 144 | |
| 145 default: | |
| 146 SNDDBG(("(Meta event type 0x%02x, length %d)\n", type, len)); | |
| 147 SDL_RWseek(song->rw, len, SEEK_CUR); | |
| 148 break; | |
| 149 } | |
| 150 } | |
| 151 else | |
| 152 { | |
| 153 a=me; | |
| 154 if (a & 0x80) /* status byte */ | |
| 155 { | |
| 156 lastchan=a & 0x0F; | |
| 157 laststatus=(a>>4) & 0x07; | |
| 158 SDL_RWread(song->rw, &a, 1, 1); | |
| 159 a &= 0x7F; | |
| 160 } | |
| 161 switch(laststatus) | |
| 162 { | |
| 163 case 0: /* Note off */ | |
| 164 SDL_RWread(song->rw, &b, 1, 1); | |
| 165 b &= 0x7F; | |
| 166 MIDIEVENT(song->at, ME_NOTEOFF, lastchan, a,b); | |
| 167 | |
| 168 case 1: /* Note on */ | |
| 169 SDL_RWread(song->rw, &b, 1, 1); | |
| 170 b &= 0x7F; | |
| 171 MIDIEVENT(song->at, ME_NOTEON, lastchan, a,b); | |
| 172 | |
| 173 case 2: /* Key Pressure */ | |
| 174 SDL_RWread(song->rw, &b, 1, 1); | |
| 175 b &= 0x7F; | |
| 176 MIDIEVENT(song->at, ME_KEYPRESSURE, lastchan, a, b); | |
| 177 | |
| 178 case 3: /* Control change */ | |
| 179 SDL_RWread(song->rw, &b, 1, 1); | |
| 180 b &= 0x7F; | |
| 181 { | |
| 182 int control=255; | |
| 183 switch(a) | |
| 184 { | |
| 185 case 7: control=ME_MAINVOLUME; break; | |
| 186 case 10: control=ME_PAN; break; | |
| 187 case 11: control=ME_EXPRESSION; break; | |
| 188 case 64: control=ME_SUSTAIN; break; | |
| 189 case 120: control=ME_ALL_SOUNDS_OFF; break; | |
| 190 case 121: control=ME_RESET_CONTROLLERS; break; | |
| 191 case 123: control=ME_ALL_NOTES_OFF; break; | |
| 192 | |
| 193 /* These should be the SCC-1 tone bank switch | |
| 194 commands. I don't know why there are two, or | |
| 195 why the latter only allows switching to bank 0. | |
| 196 Also, some MIDI files use 0 as some sort of | |
| 197 continuous controller. This will cause lots of | |
| 198 warnings about undefined tone banks. */ | |
| 199 case 0: control=ME_TONE_BANK; break; | |
| 200 case 32: | |
| 201 if (b!=0) | |
| 202 SNDDBG(("(Strange: tone bank change 0x20%02x)\n", b)); | |
| 203 else | |
| 204 control=ME_TONE_BANK; | |
| 205 break; | |
| 206 | |
| 207 case 100: nrpn=0; rpn_msb[lastchan]=b; break; | |
| 208 case 101: nrpn=0; rpn_lsb[lastchan]=b; break; | |
| 209 case 99: nrpn=1; rpn_msb[lastchan]=b; break; | |
| 210 case 98: nrpn=1; rpn_lsb[lastchan]=b; break; | |
| 211 | |
| 212 case 6: | |
| 213 if (nrpn) | |
| 214 { | |
| 215 SNDDBG(("(Data entry (MSB) for NRPN %02x,%02x: %d)\n", | |
| 216 rpn_msb[lastchan], rpn_lsb[lastchan], b)); | |
| 217 break; | |
| 218 } | |
| 219 | |
| 220 switch((rpn_msb[lastchan]<<8) | rpn_lsb[lastchan]) | |
| 221 { | |
| 222 case 0x0000: /* Pitch bend sensitivity */ | |
| 223 control=ME_PITCH_SENS; | |
| 224 break; | |
| 225 | |
| 226 case 0x7F7F: /* RPN reset */ | |
| 227 /* reset pitch bend sensitivity to 2 */ | |
| 228 MIDIEVENT(song->at, ME_PITCH_SENS, lastchan, 2, 0); | |
| 229 | |
| 230 default: | |
| 231 SNDDBG(("(Data entry (MSB) for RPN %02x,%02x: %d)\n", | |
| 232 rpn_msb[lastchan], rpn_lsb[lastchan], b)); | |
| 233 break; | |
| 234 } | |
| 235 break; | |
| 236 | |
| 237 default: | |
| 238 SNDDBG(("(Control %d: %d)\n", a, b)); | |
| 239 break; | |
| 240 } | |
| 241 if (control != 255) | |
| 242 { | |
| 243 MIDIEVENT(song->at, control, lastchan, b, 0); | |
| 244 } | |
| 245 } | |
| 246 break; | |
| 247 | |
| 248 case 4: /* Program change */ | |
| 249 a &= 0x7f; | |
| 250 MIDIEVENT(song->at, ME_PROGRAM, lastchan, a, 0); | |
| 251 | |
| 252 case 5: /* Channel pressure - NOT IMPLEMENTED */ | |
| 253 break; | |
| 254 | |
| 255 case 6: /* Pitch wheel */ | |
| 256 SDL_RWread(song->rw, &b, 1, 1); | |
| 257 b &= 0x7F; | |
| 258 MIDIEVENT(song->at, ME_PITCHWHEEL, lastchan, a, b); | |
| 259 | |
| 260 default: | |
| 261 SNDDBG(("*** Can't happen: status 0x%02X, channel 0x%02X\n", | |
| 262 laststatus, lastchan)); | |
| 263 break; | |
| 264 } | |
| 265 } | |
| 266 } | |
| 267 | |
| 268 return new; | |
| 269 } | |
| 270 | |
| 271 #undef MIDIEVENT | |
| 272 | |
| 273 /* Read a midi track into the linked list, either merging with any previous | |
| 274 tracks or appending to them. */ | |
| 275 static int read_track(MidiSong *song, int append) | |
| 276 { | |
| 277 MidiEventList *meep; | |
| 278 MidiEventList *next, *new; | |
| 279 Sint32 len; | |
| 280 char tmp[4]; | |
| 281 | |
| 282 meep = song->evlist; | |
| 283 if (append && meep) | |
| 284 { | |
| 285 /* find the last event in the list */ | |
| 286 for (; meep->next; meep=meep->next) | |
| 287 ; | |
| 288 song->at = meep->event.time; | |
| 289 } | |
| 290 else | |
| 291 song->at=0; | |
| 292 | |
| 293 /* Check the formalities */ | |
| 294 | |
| 295 if (SDL_RWread(song->rw, tmp, 1, 4) != 4 || SDL_RWread(song->rw, &len, 4, 1) != 1) | |
| 296 { | |
| 297 SNDDBG(("Can't read track header.\n")); | |
| 298 return -1; | |
| 299 } | |
| 300 len=SDL_SwapBE32(len); | |
| 301 if (memcmp(tmp, "MTrk", 4)) | |
| 302 { | |
| 303 SNDDBG(("Corrupt MIDI file.\n")); | |
| 304 return -2; | |
| 305 } | |
| 306 | |
| 307 for (;;) | |
| 308 { | |
| 309 if (!(new=read_midi_event(song))) /* Some kind of error */ | |
| 310 return -2; | |
| 311 | |
| 312 if (new==MAGIC_EOT) /* End-of-track Hack. */ | |
| 313 { | |
| 314 return 0; | |
| 315 } | |
| 316 | |
| 317 next=meep->next; | |
| 318 while (next && (next->event.time < new->event.time)) | |
| 319 { | |
| 320 meep=next; | |
| 321 next=meep->next; | |
| 322 } | |
| 323 | |
| 324 new->next=next; | |
| 325 meep->next=new; | |
| 326 | |
| 327 song->event_count++; /* Count the event. (About one?) */ | |
| 328 meep=new; | |
| 329 } | |
| 330 } | |
| 331 | |
| 332 /* Free the linked event list from memory. */ | |
| 333 static void free_midi_list(MidiSong *song) | |
| 334 { | |
| 335 MidiEventList *meep, *next; | |
| 336 if (!(meep = song->evlist)) return; | |
| 337 while (meep) | |
| 338 { | |
| 339 next=meep->next; | |
| 340 free(meep); | |
| 341 meep=next; | |
| 342 } | |
| 343 song->evlist=0; | |
| 344 } | |
| 345 | |
| 346 /* Allocate an array of MidiEvents and fill it from the linked list of | |
| 347 events, marking used instruments for loading. Convert event times to | |
| 348 samples: handle tempo changes. Strip unnecessary events from the list. | |
| 349 Free the linked list. */ | |
| 350 static MidiEvent *groom_list(MidiSong *song, Sint32 divisions,Sint32 *eventsp, | |
| 351 Sint32 *samplesp) | |
| 352 { | |
| 353 MidiEvent *groomed_list, *lp; | |
| 354 MidiEventList *meep; | |
| 355 Sint32 i, our_event_count, tempo, skip_this_event, new_value; | |
| 356 Sint32 sample_cum, samples_to_do, at, st, dt, counting_time; | |
| 357 | |
| 358 int current_bank[16], current_set[16], current_program[16]; | |
| 359 /* Or should each bank have its own current program? */ | |
| 360 | |
| 361 for (i=0; i<16; i++) | |
| 362 { | |
| 363 current_bank[i]=0; | |
| 364 current_set[i]=0; | |
| 365 current_program[i]=song->default_program; | |
| 366 } | |
| 367 | |
| 368 tempo=500000; | |
| 369 compute_sample_increment(song, tempo, divisions); | |
| 370 | |
| 371 /* This may allocate a bit more than we need */ | |
| 372 groomed_list=lp=safe_malloc(sizeof(MidiEvent) * (song->event_count+1)); | |
| 373 meep=song->evlist; | |
| 374 | |
| 375 our_event_count=0; | |
| 376 st=at=sample_cum=0; | |
| 377 counting_time=2; /* We strip any silence before the first NOTE ON. */ | |
| 378 | |
| 379 for (i = 0; i < song->event_count; i++) | |
| 380 { | |
| 381 skip_this_event=0; | |
| 382 | |
| 383 if (meep->event.type==ME_TEMPO) | |
| 384 { | |
| 385 tempo= | |
| 386 meep->event.channel + meep->event.b * 256 + meep->event.a * 65536; | |
| 387 compute_sample_increment(song, tempo, divisions); | |
| 388 skip_this_event=1; | |
| 389 } | |
| 390 else switch (meep->event.type) | |
| 391 { | |
| 392 case ME_PROGRAM: | |
| 393 if (ISDRUMCHANNEL(song, meep->event.channel)) | |
| 394 { | |
| 395 if (song->drumset[meep->event.a]) /* Is this a defined drumset? */ | |
| 396 new_value=meep->event.a; | |
| 397 else | |
| 398 { | |
| 399 SNDDBG(("Drum set %d is undefined\n", meep->event.a)); | |
| 400 new_value=meep->event.a=0; | |
| 401 } | |
| 402 if (current_set[meep->event.channel] != new_value) | |
| 403 current_set[meep->event.channel]=new_value; | |
| 404 else | |
| 405 skip_this_event=1; | |
| 406 } | |
| 407 else | |
| 408 { | |
| 409 new_value=meep->event.a; | |
| 410 if ((current_program[meep->event.channel] != SPECIAL_PROGRAM) | |
| 411 && (current_program[meep->event.channel] != new_value)) | |
| 412 current_program[meep->event.channel] = new_value; | |
| 413 else | |
| 414 skip_this_event=1; | |
| 415 } | |
| 416 break; | |
| 417 | |
| 418 case ME_NOTEON: | |
| 419 if (counting_time) | |
| 420 counting_time=1; | |
| 421 if (ISDRUMCHANNEL(song, meep->event.channel)) | |
| 422 { | |
| 423 /* Mark this instrument to be loaded */ | |
| 424 if (!(song->drumset[current_set[meep->event.channel]] | |
| 425 ->instrument[meep->event.a])) | |
| 426 song->drumset[current_set[meep->event.channel]] | |
| 427 ->instrument[meep->event.a] = MAGIC_LOAD_INSTRUMENT; | |
| 428 } | |
| 429 else | |
| 430 { | |
| 431 if (current_program[meep->event.channel]==SPECIAL_PROGRAM) | |
| 432 break; | |
| 433 /* Mark this instrument to be loaded */ | |
| 434 if (!(song->tonebank[current_bank[meep->event.channel]] | |
| 435 ->instrument[current_program[meep->event.channel]])) | |
| 436 song->tonebank[current_bank[meep->event.channel]] | |
| 437 ->instrument[current_program[meep->event.channel]] = | |
| 438 MAGIC_LOAD_INSTRUMENT; | |
| 439 } | |
| 440 break; | |
| 441 | |
| 442 case ME_TONE_BANK: | |
| 443 if (ISDRUMCHANNEL(song, meep->event.channel)) | |
| 444 { | |
| 445 skip_this_event=1; | |
| 446 break; | |
| 447 } | |
| 448 if (song->tonebank[meep->event.a]) /* Is this a defined tone bank? */ | |
| 449 new_value=meep->event.a; | |
| 450 else | |
| 451 { | |
| 452 SNDDBG(("Tone bank %d is undefined\n", meep->event.a)); | |
| 453 new_value=meep->event.a=0; | |
| 454 } | |
| 455 if (current_bank[meep->event.channel]!=new_value) | |
| 456 current_bank[meep->event.channel]=new_value; | |
| 457 else | |
| 458 skip_this_event=1; | |
| 459 break; | |
| 460 } | |
| 461 | |
| 462 /* Recompute time in samples*/ | |
| 463 if ((dt=meep->event.time - at) && !counting_time) | |
| 464 { | |
| 465 samples_to_do = song->sample_increment * dt; | |
| 466 sample_cum += song->sample_correction * dt; | |
| 467 if (sample_cum & 0xFFFF0000) | |
| 468 { | |
| 469 samples_to_do += ((sample_cum >> 16) & 0xFFFF); | |
| 470 sample_cum &= 0x0000FFFF; | |
| 471 } | |
| 472 st += samples_to_do; | |
| 473 } | |
| 474 else if (counting_time==1) counting_time=0; | |
| 475 if (!skip_this_event) | |
| 476 { | |
| 477 /* Add the event to the list */ | |
| 478 *lp=meep->event; | |
| 479 lp->time=st; | |
| 480 lp++; | |
| 481 our_event_count++; | |
| 482 } | |
| 483 at=meep->event.time; | |
| 484 meep=meep->next; | |
| 485 } | |
| 486 /* Add an End-of-Track event */ | |
| 487 lp->time=st; | |
| 488 lp->type=ME_EOT; | |
| 489 our_event_count++; | |
| 490 free_midi_list(song); | |
|
474
c66080364dff
Most decoders now report total sample play time, now. Technically, this
Ryan C. Gordon <icculus@icculus.org>
parents:
199
diff
changeset
|
491 |
| 199 | 492 *eventsp=our_event_count; |
| 493 *samplesp=st; | |
| 494 return groomed_list; | |
| 495 } | |
| 496 | |
| 497 MidiEvent *read_midi_file(MidiSong *song, Sint32 *count, Sint32 *sp) | |
| 498 { | |
| 499 Sint32 len, divisions; | |
| 500 Sint16 format, tracks, divisions_tmp; | |
| 501 int i; | |
| 502 char tmp[4]; | |
| 503 | |
| 504 song->event_count=0; | |
| 505 song->at=0; | |
| 506 song->evlist=0; | |
| 507 | |
| 508 if (SDL_RWread(song->rw, tmp, 1, 4) != 4 || SDL_RWread(song->rw, &len, 4, 1) != 1) | |
| 509 { | |
| 510 SNDDBG(("Not a MIDI file!\n")); | |
| 511 return 0; | |
| 512 } | |
| 513 len=SDL_SwapBE32(len); | |
| 514 if (memcmp(tmp, "MThd", 4) || len < 6) | |
| 515 { | |
| 516 SNDDBG(("Not a MIDI file!\n")); | |
| 517 return 0; | |
| 518 } | |
| 519 | |
| 520 SDL_RWread(song->rw, &format, 2, 1); | |
| 521 SDL_RWread(song->rw, &tracks, 2, 1); | |
| 522 SDL_RWread(song->rw, &divisions_tmp, 2, 1); | |
| 523 format=SDL_SwapBE16(format); | |
| 524 tracks=SDL_SwapBE16(tracks); | |
| 525 divisions_tmp=SDL_SwapBE16(divisions_tmp); | |
| 526 | |
| 527 if (divisions_tmp<0) | |
| 528 { | |
| 529 /* SMPTE time -- totally untested. Got a MIDI file that uses this? */ | |
| 530 divisions= | |
| 531 (Sint32)(-(divisions_tmp/256)) * (Sint32)(divisions_tmp & 0xFF); | |
| 532 } | |
| 533 else divisions=(Sint32)(divisions_tmp); | |
| 534 | |
| 535 if (len > 6) | |
| 536 { | |
| 537 SNDDBG(("MIDI file header size %u bytes", len)); | |
| 538 SDL_RWseek(song->rw, len-6, SEEK_CUR); /* skip the excess */ | |
| 539 } | |
| 540 if (format<0 || format >2) | |
| 541 { | |
| 542 SNDDBG(("Unknown MIDI file format %d\n", format)); | |
| 543 return 0; | |
| 544 } | |
| 545 SNDDBG(("Format: %d Tracks: %d Divisions: %d\n", | |
| 546 format, tracks, divisions)); | |
| 547 | |
| 548 /* Put a do-nothing event first in the list for easier processing */ | |
| 549 song->evlist=safe_malloc(sizeof(MidiEventList)); | |
| 550 song->evlist->event.time=0; | |
| 551 song->evlist->event.type=ME_NONE; | |
| 552 song->evlist->next=0; | |
| 553 song->event_count++; | |
| 554 | |
| 555 switch(format) | |
| 556 { | |
| 557 case 0: | |
| 558 if (read_track(song, 0)) | |
| 559 { | |
| 560 free_midi_list(song); | |
| 561 return 0; | |
| 562 } | |
| 563 break; | |
| 564 | |
| 565 case 1: | |
| 566 for (i=0; i<tracks; i++) | |
| 567 if (read_track(song, 0)) | |
| 568 { | |
| 569 free_midi_list(song); | |
| 570 return 0; | |
| 571 } | |
| 572 break; | |
| 573 | |
| 574 case 2: /* We simply play the tracks sequentially */ | |
| 575 for (i=0; i<tracks; i++) | |
| 576 if (read_track(song, 1)) | |
| 577 { | |
| 578 free_midi_list(song); | |
| 579 return 0; | |
| 580 } | |
| 581 break; | |
| 582 } | |
| 583 return groom_list(song, divisions, count, sp); | |
| 584 } |