/
music.c
1589 lines (1468 loc) · 33 KB
1
/*
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
SDL_mixer: An audio mixer library based on the SDL library
Copyright (C) 1997-2012 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
20
21
*/
22
/* $Id$ */
23
24
25
#include <stdlib.h>
#include <string.h>
26
#include <ctype.h>
27
#include <assert.h>
28
29
#include "SDL_endian.h"
#include "SDL_audio.h"
30
#include "SDL_timer.h"
31
32
#include "SDL_mixer.h"
33
34
35
36
37
38
39
#ifdef CMD_MUSIC
#include "music_cmd.h"
#endif
#ifdef WAV_MUSIC
#include "wavestream.h"
#endif
40
41
42
#ifdef MODPLUG_MUSIC
#include "music_modplug.h"
#endif
43
44
#ifdef MOD_MUSIC
#include "music_mod.h"
45
46
#endif
#ifdef MID_MUSIC
47
48
49
# ifdef USE_TIMIDITY_MIDI
# include "timidity.h"
# endif
50
51
52
# ifdef USE_FLUIDSYNTH_MIDI
# include "fluidsynth.h"
# endif
53
54
55
# ifdef USE_NATIVE_MIDI
# include "native_midi.h"
# endif
56
#endif
57
58
59
#ifdef OGG_MUSIC
#include "music_ogg.h"
#endif
60
#ifdef MP3_MUSIC
61
#include "dynamic_mp3.h"
62
#include "music_mpg.h"
63
64
65
66
#endif
#ifdef MP3_MAD_MUSIC
#include "music_mad.h"
#endif
67
68
69
#ifdef FLAC_MUSIC
#include "music_flac.h"
#endif
70
71
#if defined(MP3_MUSIC) || defined(MP3_MAD_MUSIC)
72
73
74
static SDL_AudioSpec used_mixer;
#endif
76
77
int volatile music_active = 1;
static int volatile music_stopped = 0;
78
79
static int music_loops = 0;
static char *music_cmd = NULL;
80
static Mix_Music * volatile music_playing = NULL;
81
static int music_volume = MIX_MAX_VOLUME;
82
83
struct _Mix_Music {
84
Mix_MusicType type;
85
86
87
88
89
90
91
union {
#ifdef CMD_MUSIC
MusicCMD *cmd;
#endif
#ifdef WAV_MUSIC
WAVStream *wave;
#endif
92
93
94
#ifdef MODPLUG_MUSIC
modplug_data *modplug;
#endif
95
96
#ifdef MOD_MUSIC
struct MODULE *module;
97
98
#endif
#ifdef MID_MUSIC
99
#ifdef USE_TIMIDITY_MIDI
100
MidiSong *midi;
101
#endif
102
103
104
#ifdef USE_FLUIDSYNTH_MIDI
FluidSynthMidiSong *fluidsynthmidi;
#endif
105
106
107
#ifdef USE_NATIVE_MIDI
NativeMidiSong *nativemidi;
#endif
108
#endif
109
110
111
#ifdef OGG_MUSIC
OGG_music *ogg;
#endif
112
#ifdef MP3_MUSIC
113
mpg_data *mp3_mpg;
114
115
116
#endif
#ifdef MP3_MAD_MUSIC
mad_data *mp3_mad;
117
118
119
#endif
#ifdef FLAC_MUSIC
FLAC_music *flac;
120
121
#endif
} data;
122
Mix_Fading fading;
123
124
int fade_step;
int fade_steps;
125
126
int error;
};
127
#ifdef MID_MUSIC
128
#ifdef USE_TIMIDITY_MIDI
129
static int timidity_ok;
130
static int samplesize;
131
#endif
132
133
134
#ifdef USE_FLUIDSYNTH_MIDI
static int fluidsynth_ok;
#endif
135
136
137
#ifdef USE_NATIVE_MIDI
static int native_midi_ok;
#endif
138
#endif
139
140
141
142
/* Used to calculate fading steps */
static int ms_per_step;
143
144
145
146
/* rcg06042009 report available decoders at runtime. */
static const char **music_decoders = NULL;
static int num_decoders = 0;
147
148
149
150
151
/* Semicolon-separated SoundFont paths */
#ifdef MID_MUSIC
char* soundfont_paths = NULL;
#endif
152
int Mix_GetNumMusicDecoders(void)
153
154
155
156
157
158
159
160
161
162
163
164
165
166
{
return(num_decoders);
}
const char *Mix_GetMusicDecoder(int index)
{
if ((index < 0) || (index >= num_decoders)) {
return NULL;
}
return(music_decoders[index]);
}
static void add_music_decoder(const char *decoder)
{
167
void *ptr = SDL_realloc(music_decoders, (num_decoders + 1) * sizeof (const char *));
168
169
170
if (ptr == NULL) {
return; /* oh well, go on without it. */
}
171
music_decoders = (const char **) ptr;
172
173
174
music_decoders[num_decoders++] = decoder;
}
175
/* Local low-level functions prototypes */
176
static void music_internal_initialize_volume(void);
177
178
179
180
181
static void music_internal_volume(int volume);
static int music_internal_play(Mix_Music *music, double position);
static int music_internal_position(double position);
static int music_internal_playing();
static void music_internal_halt(void);
182
183
184
/* Support for hooking when the music has finished */
185
static void (SDLCALL *music_finished_hook)(void) = NULL;
186
187
void Mix_HookMusicFinished(void (SDLCALL *music_finished)(void))
188
189
190
191
192
193
194
{
SDL_LockAudio();
music_finished_hook = music_finished;
SDL_UnlockAudio();
}
195
196
197
198
199
/* If music isn't playing, halt it if no looping is required, restart it */
/* otherwhise. NOP if the music is playing */
static int music_halt_or_loop (void)
{
/* Restart music if it has to loop */
200
if (!music_internal_playing()) {
201
#ifdef USE_NATIVE_MIDI
202
203
204
205
/* Native MIDI handles looping internally */
if (music_playing->type == MUS_MID && native_midi_ok) {
music_loops = 0;
}
206
#endif
207
208
/* Restart music if it has to loop at a high level */
209
if (music_loops) {
210
Mix_Fading current_fade;
211
212
213
if (music_loops > 0) {
--music_loops;
}
214
current_fade = music_playing->fading;
215
216
music_internal_play(music_playing, 0.0);
music_playing->fading = current_fade;
217
} else {
218
music_internal_halt();
219
if (music_finished_hook) {
220
music_finished_hook();
221
}
222
223
224
return 0;
}
}
225
226
227
228
229
return 1;
}
230
/* Mixing function */
231
void SDLCALL music_mixer(void *udata, Uint8 *stream, int len)
232
{
233
234
int left = 0;
235
if ( music_playing && music_active ) {
236
/* Handle fading */
237
238
if ( music_playing->fading != MIX_NO_FADING ) {
if ( music_playing->fade_step++ < music_playing->fade_steps ) {
239
int volume;
240
241
int fade_step = music_playing->fade_step;
int fade_steps = music_playing->fade_steps;
242
243
if ( music_playing->fading == MIX_FADING_OUT ) {
244
volume = (music_volume * (fade_steps-fade_step)) / fade_steps;
245
} else { /* Fading in */
246
volume = (music_volume * fade_step) / fade_steps;
247
}
248
music_internal_volume(volume);
249
250
} else {
if ( music_playing->fading == MIX_FADING_OUT ) {
251
252
253
254
music_internal_halt();
if ( music_finished_hook ) {
music_finished_hook();
}
255
return;
256
}
257
music_playing->fading = MIX_NO_FADING;
258
259
}
}
260
261
262
263
264
music_halt_or_loop();
if (!music_internal_playing())
return;
265
266
267
268
269
270
271
272
switch (music_playing->type) {
#ifdef CMD_MUSIC
case MUS_CMD:
/* The playing is done externally */
break;
#endif
#ifdef WAV_MUSIC
case MUS_WAV:
273
left = WAVStream_PlaySome(stream, len);
274
275
break;
#endif
276
277
278
279
280
#ifdef MODPLUG_MUSIC
case MUS_MODPLUG:
left = modplug_playAudio(music_playing->data.modplug, stream, len);
break;
#endif
281
#ifdef MOD_MUSIC
282
case MUS_MOD:
283
left = MOD_playAudio(music_playing->data.module, stream, len);
284
285
286
287
break;
#endif
#ifdef MID_MUSIC
case MUS_MID:
288
#ifdef USE_NATIVE_MIDI
289
if ( native_midi_ok ) {
290
291
/* Native midi is handled asynchronously */
goto skip;
292
}
293
#endif
294
295
296
#ifdef USE_FLUIDSYNTH_MIDI
if ( fluidsynth_ok ) {
fluidsynth_playsome(music_playing->data.fluidsynthmidi, stream, len);
297
goto skip;
298
299
300
}
#endif
#ifdef USE_TIMIDITY_MIDI
301
302
if ( timidity_ok ) {
int samples = len / samplesize;
303
Timidity_PlaySome(stream, samples);
304
goto skip;
305
}
306
#endif
307
break;
308
#endif
309
310
#ifdef OGG_MUSIC
case MUS_OGG:
311
312
left = OGG_playAudio(music_playing->data.ogg, stream, len);
313
314
break;
#endif
315
316
#ifdef FLAC_MUSIC
case MUS_FLAC:
317
left = FLAC_playAudio(music_playing->data.flac, stream, len);
318
319
break;
#endif
320
#ifdef MP3_MUSIC
321
case MUS_MP3:
322
left = mpg_get_samples(music_playing->data.mp3_mpg, stream, len);
323
break;
324
325
326
#endif
#ifdef MP3_MAD_MUSIC
case MUS_MP3_MAD:
327
left = mad_getSamples(music_playing->data.mp3_mad, stream, len);
329
330
331
332
333
#endif
default:
/* Unknown music type?? */
break;
}
334
}
335
336
337
338
skip:
/* Handle seamless music looping */
if (left > 0 && left < len) {
339
music_halt_or_loop();
340
if (music_internal_playing())
341
music_mixer(udata, stream+(len-left), left);
342
}
343
344
345
346
347
348
}
/* Initialize the music players with a certain desired audio format */
int open_music(SDL_AudioSpec *mixer)
{
#ifdef WAV_MUSIC
349
if ( WAVStream_Init(mixer) == 0 ) {
350
add_music_decoder("WAVE");
351
352
}
#endif
353
#ifdef MODPLUG_MUSIC
354
if ( modplug_init(mixer) == 0 ) {
355
356
357
add_music_decoder("MODPLUG");
}
#endif
358
#ifdef MOD_MUSIC
359
if ( MOD_init(mixer) == 0 ) {
360
add_music_decoder("MIKMOD");
361
362
363
}
#endif
#ifdef MID_MUSIC
364
#ifdef USE_TIMIDITY_MIDI
365
samplesize = mixer->size / mixer->samples;
366
if ( Timidity_Init(mixer->freq, mixer->format,
367
mixer->channels, mixer->samples) == 0 ) {
368
timidity_ok = 1;
369
add_music_decoder("TIMIDITY");
370
371
372
} else {
timidity_ok = 0;
}
373
#endif
374
375
376
377
378
379
380
381
#ifdef USE_FLUIDSYNTH_MIDI
if ( fluidsynth_init(mixer) == 0 ) {
fluidsynth_ok = 1;
add_music_decoder("FLUIDSYNTH");
} else {
fluidsynth_ok = 0;
}
#endif
382
#ifdef USE_NATIVE_MIDI
383
384
385
386
#ifdef USE_FLUIDSYNTH_MIDI
native_midi_ok = !fluidsynth_ok;
if ( native_midi_ok )
#endif
387
#ifdef USE_TIMIDITY_MIDI
388
native_midi_ok = !timidity_ok;
389
390
391
if ( !native_midi_ok ) {
native_midi_ok = (getenv("SDL_NATIVE_MUSIC") != NULL);
}
392
393
if ( native_midi_ok )
#endif
394
native_midi_ok = native_midi_detect();
395
396
if ( native_midi_ok )
add_music_decoder("NATIVEMIDI");
397
#endif
398
#endif
399
#ifdef OGG_MUSIC
400
if ( OGG_init(mixer) == 0 ) {
401
add_music_decoder("OGG");
402
403
}
#endif
404
#ifdef FLAC_MUSIC
405
if ( FLAC_init(mixer) == 0 ) {
406
add_music_decoder("FLAC");
407
408
}
#endif
409
#if defined(MP3_MUSIC) || defined(MP3_MAD_MUSIC)
410
411
/* Keep a copy of the mixer */
used_mixer = *mixer;
412
add_music_decoder("MP3");
413
#endif
414
415
music_playing = NULL;
416
music_stopped = 0;
417
418
Mix_VolumeMusic(SDL_MIX_MAXVOLUME);
419
/* Calculate the number of ms for each callback */
420
ms_per_step = (int) (((float)mixer->samples * 1000.0) / mixer->freq);
421
422
423
424
return(0);
}
425
426
427
428
429
430
431
432
433
434
435
436
437
/* Portable case-insensitive string compare function */
int MIX_string_equals(const char *str1, const char *str2)
{
while ( *str1 && *str2 ) {
if ( toupper((unsigned char)*str1) !=
toupper((unsigned char)*str2) )
break;
++str1;
++str2;
}
return (!*str1 && !*str2);
}
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
static int detect_mp3(Uint8 *magic)
{
if ( strncmp((char *)magic, "ID3", 3) == 0 ) {
return 1;
}
/* Detection code lifted from SMPEG */
if(((magic[0] & 0xff) != 0xff) || // No sync bits
((magic[1] & 0xf0) != 0xf0) || //
((magic[2] & 0xf0) == 0x00) || // Bitrate is 0
((magic[2] & 0xf0) == 0xf0) || // Bitrate is 15
((magic[2] & 0x0c) == 0x0c) || // Frequency is 3
((magic[1] & 0x06) == 0x00)) { // Layer is 4
return(0);
}
return 1;
}
/* MUS_MOD can't be auto-detected. If no other format was detected, MOD is
* assumed and MUS_MOD will be returned, meaning that the format might not
* actually be MOD-based.
*
* Returns MUS_NONE in case of errors. */
static Mix_MusicType detect_music_type(SDL_RWops *rw)
{
Uint8 magic[5];
Uint8 moremagic[9];
int start = SDL_RWtell(rw);
if (SDL_RWread(rw, magic, 1, 4) != 4 || SDL_RWread(rw, moremagic, 1, 8) != 8 ) {
Mix_SetError("Couldn't read from RWops");
return MUS_NONE;
}
SDL_RWseek(rw, start, RW_SEEK_SET);
magic[4]='\0';
moremagic[8] = '\0';
/* WAVE files have the magic four bytes "RIFF"
AIFF files have the magic 12 bytes "FORM" XXXX "AIFF" */
if (((strcmp((char *)magic, "RIFF") == 0) && (strcmp((char *)(moremagic+4), "WAVE") == 0)) ||
(strcmp((char *)magic, "FORM") == 0)) {
return MUS_WAV;
}
/* Ogg Vorbis files have the magic four bytes "OggS" */
if (strcmp((char *)magic, "OggS") == 0) {
return MUS_OGG;
}
/* FLAC files have the magic four bytes "fLaC" */
if (strcmp((char *)magic, "fLaC") == 0) {
return MUS_FLAC;
}
/* MIDI files have the magic four bytes "MThd" */
if (strcmp((char *)magic, "MThd") == 0) {
return MUS_MID;
}
if (detect_mp3(magic)) {
return MUS_MP3;
}
/* Assume MOD format.
*
* Apparently there is no way to check if the file is really a MOD,
* or there are too many formats supported by MikMod/ModPlug, or
* MikMod/ModPlug does this check by itself. */
return MUS_MOD;
}
509
510
511
/* Load a music file */
Mix_Music *Mix_LoadMUS(const char *file)
{
512
SDL_RWops *rw;
513
Mix_Music *music;
514
515
Mix_MusicType type;
char *ext = strrchr(file, '.');
516
517
518
519
#ifdef CMD_MUSIC
if ( music_cmd ) {
/* Allocate memory for the music structure */
520
music = (Mix_Music *)SDL_malloc(sizeof(Mix_Music));
521
522
523
if ( music == NULL ) {
Mix_SetError("Out of memory");
return(NULL);
524
}
525
526
527
528
music->error = 0;
music->type = MUS_CMD;
music->data.cmd = MusicCMD_LoadSong(music_cmd, file);
if ( music->data.cmd == NULL ) {
529
SDL_free(music);
530
music = NULL;
531
532
}
return music;
533
}
534
535
536
537
538
539
#endif
rw = SDL_RWFromFile(file, "rb");
if ( rw == NULL ) {
Mix_SetError("Couldn't open '%s'", file);
return NULL;
540
}
541
542
543
/* Use the extension as a first guess on the file type */
type = MUS_NONE;
544
ext = strrchr(file, '.');
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
/* No need to guard these with #ifdef *_MUSIC stuff,
* since we simply call Mix_LoadMUSType_RW() later */
if ( ext ) {
++ext; /* skip the dot in the extension */
if ( MIX_string_equals(ext, "WAV") ) {
type = MUS_WAV;
} else if ( MIX_string_equals(ext, "MID") ||
MIX_string_equals(ext, "MIDI") ||
MIX_string_equals(ext, "KAR") ) {
type = MUS_MID;
} else if ( MIX_string_equals(ext, "OGG") ) {
type = MUS_OGG;
} else if ( MIX_string_equals(ext, "FLAC") ) {
type = MUS_FLAC;
} else if ( MIX_string_equals(ext, "MPG") ||
MIX_string_equals(ext, "MPEG") ||
MIX_string_equals(ext, "MP3") ||
MIX_string_equals(ext, "MAD") ) {
type = MUS_MP3;
}
}
if ( type == MUS_NONE ) {
type = detect_music_type(rw);
}
/* We need to know if a specific error occurs; if not, we'll set a
* generic one, so we clear the current one. */
Mix_SetError("");
music = Mix_LoadMUSType_RW(rw, type, SDL_TRUE);
if ( music == NULL && Mix_GetError()[0] == '\0' ) {
SDL_FreeRW(rw);
Mix_SetError("Couldn't open '%s'", file);
}
return music;
}
Mix_Music *Mix_LoadMUS_RW(SDL_RWops *rw)
{
return Mix_LoadMUSType_RW(rw, MUS_NONE, SDL_FALSE);
}
Mix_Music *Mix_LoadMUSType_RW(SDL_RWops *rw, Mix_MusicType type, int freesrc)
{
Mix_Music *music;
if (!rw) {
Mix_SetError("RWops pointer is NULL");
return NULL;
}
/* If the caller wants auto-detection, figure out what kind of file
* this is. */
if (type == MUS_NONE) {
if ((type = detect_music_type(rw)) == MUS_NONE) {
/* Don't call Mix_SetError() here since detect_music_type()
* does that. */
return NULL;
}
}
604
605
/* Allocate memory for the music structure */
606
music = (Mix_Music *)SDL_malloc(sizeof(Mix_Music));
607
if (music == NULL ) {
608
Mix_SetError("Out of memory");
609
return NULL;
610
611
612
}
music->error = 0;
613
switch (type) {
614
#ifdef WAV_MUSIC
615
616
617
618
619
620
621
case MUS_WAV:
/* The WAVE loader needs the first 4 bytes of the header */
{
Uint8 magic[5];
int start = SDL_RWtell(rw);
if (SDL_RWread(rw, magic, 1, 4) != 4) {
Mix_SetError("Couldn't read from RWops");
622
SDL_free(music);
623
return NULL;
624
}
625
626
627
628
SDL_RWseek(rw, start, RW_SEEK_SET);
magic[4] = '\0';
music->type = MUS_WAV;
music->data.wave = WAVStream_LoadSong_RW(rw, (char *)magic, freesrc);
629
}
630
if (music->data.wave == NULL) {
631
632
music->error = 1;
}
633
break;
634
#endif
635
#ifdef OGG_MUSIC
636
case MUS_OGG:
637
music->type = MUS_OGG;
638
music->data.ogg = OGG_new_RW(rw, freesrc);
639
640
641
if ( music->data.ogg == NULL ) {
music->error = 1;
}
642
break;
643
#endif
644
#ifdef FLAC_MUSIC
645
case MUS_FLAC:
646
music->type = MUS_FLAC;
647
music->data.flac = FLAC_new_RW(rw, freesrc);
648
649
650
if ( music->data.flac == NULL ) {
music->error = 1;
}
651
break;
652
#endif
653
#ifdef MP3_MUSIC
654
case MUS_MP3:
655
if ( Mix_Init(MIX_INIT_MP3) ) {
656
music->type = MUS_MP3;
657
658
659
music->data.mp3_mpg = mpg_new_rw(rw, &used_mixer, freesrc);
if (!music->data.mp3_mpg) {
Mix_SetError("Could not initialize MPEG stream.");
660
661
music->error = 1;
}
662
} else {
663
music->error = 1;
664
}
665
666
667
break;
#elif defined(MP3_MAD_MUSIC)
case MUS_MP3:
668
music->type = MUS_MP3_MAD;
669
music->data.mp3_mad = mad_openFileRW(rw, &used_mixer, freesrc);
670
if (music->data.mp3_mad == 0) {
671
Mix_SetError("Could not initialize MPEG stream.");
672
673
music->error = 1;
}
674
break;
676
677
678
679
680
681
#ifdef MID_MUSIC
case MUS_MID:
music->type = MUS_MID;
#ifdef USE_NATIVE_MIDI
if ( native_midi_ok ) {
music->data.nativemidi = native_midi_loadsong_RW(rw, freesrc);
682
683
684
if ( music->data.nativemidi == NULL ) {
Mix_SetError("%s", native_midi_error());
music->error = 1;
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
}
break;
}
#endif
#ifdef USE_FLUIDSYNTH_MIDI
if ( fluidsynth_ok ) {
music->data.fluidsynthmidi = fluidsynth_loadsong_RW(rw, freesrc);
if ( music->data.fluidsynthmidi == NULL ) {
music->error = 1;
}
break;
}
#endif
#ifdef USE_TIMIDITY_MIDI
if ( timidity_ok ) {
music->data.midi = Timidity_LoadSong_RW(rw, freesrc);
if ( music->data.midi == NULL ) {
Mix_SetError("%s", Timidity_Error());
music->error = 1;
}
} else {
Mix_SetError("%s", Timidity_Error());
707
708
music->error = 1;
}
709
710
711
712
713
714
715
716
717
718
719
720
721
722
#endif
break;
#endif
#if defined(MODPLUG_MUSIC) || defined(MOD_MUSIC)
case MUS_MOD:
music->error = 1;
#ifdef MODPLUG_MUSIC
if ( music->error ) {
music->type = MUS_MODPLUG;
music->data.modplug = modplug_new_RW(rw, freesrc);
if ( music->data.modplug ) {
music->error = 0;
}
}
723
#endif
724
#ifdef MOD_MUSIC
725
726
727
728
729
730
if ( music->error ) {
music->type = MUS_MOD;
music->data.module = MOD_new_RW(rw, freesrc);
if ( music->data.module ) {
music->error = 0;
}
731
732
}
#endif
733
734
735
736
break;
#endif
default:
737
Mix_SetError("Unrecognized music format");
738
music->error = 1;
739
} /* switch (want) */
740
741
if (music->error) {
742
SDL_free(music);
743
music = NULL;
744
745
746
747
748
749
750
751
}
return(music);
}
/* Free a music chunk previously loaded */
void Mix_FreeMusic(Mix_Music *music)
{
if ( music ) {
752
753
754
755
756
757
758
759
760
761
762
/* Stop the music if it's currently playing */
SDL_LockAudio();
if ( music == music_playing ) {
/* Wait for any fade out to finish */
while ( music->fading == MIX_FADING_OUT ) {
SDL_UnlockAudio();
SDL_Delay(100);
SDL_LockAudio();
}
if ( music == music_playing ) {
music_internal_halt();
763
}
764
}
765
SDL_UnlockAudio();
766
767
768
769
770
771
772
773
774
775
776
switch (music->type) {
#ifdef CMD_MUSIC
case MUS_CMD:
MusicCMD_FreeSong(music->data.cmd);
break;
#endif
#ifdef WAV_MUSIC
case MUS_WAV:
WAVStream_FreeSong(music->data.wave);
break;
#endif
777
778
779
780
781
#ifdef MODPLUG_MUSIC
case MUS_MODPLUG:
modplug_delete(music->data.modplug);
break;
#endif
782
#ifdef MOD_MUSIC
783
case MUS_MOD:
784
MOD_delete(music->data.module);
785
786
787
788
break;
#endif
#ifdef MID_MUSIC
case MUS_MID:
789
#ifdef USE_NATIVE_MIDI
790
if ( native_midi_ok ) {
791
native_midi_freesong(music->data.nativemidi);
792
793
794
795
796
797
798
799
goto skip;
}
#endif
#ifdef USE_FLUIDSYNTH_MIDI
if ( fluidsynth_ok ) {
fluidsynth_freesong(music->data.fluidsynthmidi);
goto skip;
}
800
#endif
801
#ifdef USE_TIMIDITY_MIDI
802
803
if ( timidity_ok ) {
Timidity_FreeSong(music->data.midi);
804
goto skip;
805
}
806
#endif
807
808
break;
#endif
809
810
811
812
813
#ifdef OGG_MUSIC
case MUS_OGG:
OGG_delete(music->data.ogg);
break;
#endif
814
815
816
817
818
#ifdef FLAC_MUSIC
case MUS_FLAC:
FLAC_delete(music->data.flac);
break;
#endif
819
#ifdef MP3_MUSIC
820
case MUS_MP3:
821
mpg_delete(music->data.mp3_mpg);
822
break;
823
824
825
826
827
#endif
#ifdef MP3_MAD_MUSIC
case MUS_MP3_MAD:
mad_closeFile(music->data.mp3_mad);
break;
828
829
830
831
832
#endif
default:
/* Unknown music type?? */
break;
}
833
834
skip:
835
SDL_free(music);
836
837
838
}
}
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
/* Find out the music format of a mixer music, or the currently playing
music, if 'music' is NULL.
*/
Mix_MusicType Mix_GetMusicType(const Mix_Music *music)
{
Mix_MusicType type = MUS_NONE;
if ( music ) {
type = music->type;
} else {
SDL_LockAudio();
if ( music_playing ) {
type = music_playing->type;
}
SDL_UnlockAudio();
}
return(type);
}
858
859
860
/* Play a music chunk. Returns 0, or -1 if there was an error.
*/
static int music_internal_play(Mix_Music *music, double position)
861
{
862
863
int retval = 0;
864
#if defined(__MACOSX__) && defined(USE_NATIVE_MIDI)
865
866
/* This fixes a bug with native MIDI on Mac OS X, where you
can't really stop and restart MIDI from the audio callback.
867
*/
868
869
870
871
if ( music == music_playing && music->type == MUS_MID && native_midi_ok ) {
/* Just a seek suffices to restart playing */
music_internal_position(position);
return 0;
872
}
873
#endif
874
875
876
877
878
879
/* Note the music we're playing */
if ( music_playing ) {
music_internal_halt();
}
music_playing = music;
880
881
/* Set the initial volume */
882
883
if ( music->type != MUS_MOD ) {
music_internal_initialize_volume();
884
885
886
}
/* Set up for playback */
887
888
switch (music->type) {
#ifdef CMD_MUSIC
889
890
891
case MUS_CMD:
MusicCMD_Start(music->data.cmd);
break;
892
893
#endif
#ifdef WAV_MUSIC
894
895
896
case MUS_WAV:
WAVStream_Start(music->data.wave);
break;
897
#endif
898
899
900
901
902
903
904
#ifdef MODPLUG_MUSIC
case MUS_MODPLUG:
/* can't set volume until file is loaded, so finally set it now */
music_internal_initialize_volume();
modplug_play(music->data.modplug);
break;
#endif
905
#ifdef MOD_MUSIC
906
case MUS_MOD:
907
MOD_play(music->data.module);
908
909
/* Player_SetVolume() does nothing before Player_Start() */
music_internal_initialize_volume();
910
break;
911
912
#endif
#ifdef MID_MUSIC
913
case MUS_MID:
914
#ifdef USE_NATIVE_MIDI
915
if ( native_midi_ok ) {
916
native_midi_start(music->data.nativemidi, music_loops);
917
918
919
920
921
922
923
924
goto skip;
}
#endif
#ifdef USE_FLUIDSYNTH_MIDI
if (fluidsynth_ok ) {
fluidsynth_start(music->data.fluidsynthmidi);
goto skip;
}
925
#endif
926
#ifdef USE_TIMIDITY_MIDI
927
928
if ( timidity_ok ) {
Timidity_Start(music->data.midi);
929
goto skip;
930
}
931
#endif
932
break;
933
#endif
934
#ifdef OGG_MUSIC
935
936
937
case MUS_OGG:
OGG_play(music->data.ogg);
break;
938
#endif
939
940
941
942
943
#ifdef FLAC_MUSIC
case MUS_FLAC:
FLAC_play(music->data.flac);
break;
#endif
944
#ifdef MP3_MUSIC
945
case MUS_MP3:
946
mpg_start(music->data.mp3_mpg);
947
break;
948
949
950
951
952
#endif
#ifdef MP3_MAD_MUSIC
case MUS_MP3_MAD:
mad_start(music->data.mp3_mad);
break;
953
#endif
954
955
956
957
default:
Mix_SetError("Can't play unknown music type");
retval = -1;
break;
958
}
959
960
skip:
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
/* Set the playback position, note any errors if an offset is used */
if ( retval == 0 ) {
if ( position > 0.0 ) {
if ( music_internal_position(position) < 0 ) {
Mix_SetError("Position not implemented for music type");
retval = -1;
}
} else {
music_internal_position(0.0);
}
}
/* If the setup failed, we're not playing any music anymore */
if ( retval < 0 ) {
music_playing = NULL;
}
return(retval);
}
int Mix_FadeInMusicPos(Mix_Music *music, int loops, int ms, double position)
980
{
981
982
int retval;
983
984
985
986
987
if ( ms_per_step == 0 ) {
SDL_SetError("Audio device hasn't been opened");
return(-1);
}
988
989
/* Don't play null pointers :-) */
if ( music == NULL ) {
990
Mix_SetError("music parameter was NULL");
991
992
return(-1);
}
993
994
995
996
997
998
/* Setup the data */
if ( ms ) {
music->fading = MIX_FADING_IN;
} else {
music->fading = MIX_NO_FADING;
999
}
1000
music->fade_step = 0;