/
music.c
1601 lines (1476 loc) · 33.6 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
63
64
65
#endif
#ifdef MP3_MAD_MUSIC
#include "music_mad.h"
#endif
66
67
68
#ifdef FLAC_MUSIC
#include "music_flac.h"
#endif
69
70
#if defined(MP3_MUSIC) || defined(MP3_MAD_MUSIC)
71
72
73
static SDL_AudioSpec used_mixer;
#endif
75
76
int volatile music_active = 1;
static int volatile music_stopped = 0;
77
78
static int music_loops = 0;
static char *music_cmd = NULL;
79
static Mix_Music * volatile music_playing = NULL;
80
static int music_volume = MIX_MAX_VOLUME;
81
82
struct _Mix_Music {
83
Mix_MusicType type;
84
85
86
87
88
89
90
union {
#ifdef CMD_MUSIC
MusicCMD *cmd;
#endif
#ifdef WAV_MUSIC
WAVStream *wave;
#endif
91
92
93
#ifdef MODPLUG_MUSIC
modplug_data *modplug;
#endif
94
95
#ifdef MOD_MUSIC
struct MODULE *module;
96
97
#endif
#ifdef MID_MUSIC
98
#ifdef USE_TIMIDITY_MIDI
99
MidiSong *midi;
100
#endif
101
102
103
#ifdef USE_FLUIDSYNTH_MIDI
FluidSynthMidiSong *fluidsynthmidi;
#endif
104
105
106
#ifdef USE_NATIVE_MIDI
NativeMidiSong *nativemidi;
#endif
107
#endif
108
109
110
#ifdef OGG_MUSIC
OGG_music *ogg;
#endif
111
112
#ifdef MP3_MUSIC
SMPEG *mp3;
113
114
115
#endif
#ifdef MP3_MAD_MUSIC
mad_data *mp3_mad;
116
117
118
#endif
#ifdef FLAC_MUSIC
FLAC_music *flac;
119
120
#endif
} data;
121
Mix_Fading fading;
122
123
int fade_step;
int fade_steps;
124
125
int error;
};
126
#ifdef MID_MUSIC
127
#ifdef USE_TIMIDITY_MIDI
128
static int timidity_ok;
129
static int samplesize;
130
#endif
131
132
133
#ifdef USE_FLUIDSYNTH_MIDI
static int fluidsynth_ok;
#endif
134
135
136
#ifdef USE_NATIVE_MIDI
static int native_midi_ok;
#endif
137
#endif
138
139
140
141
/* Used to calculate fading steps */
static int ms_per_step;
142
143
144
145
/* rcg06042009 report available decoders at runtime. */
static const char **music_decoders = NULL;
static int num_decoders = 0;
146
147
148
149
150
/* Semicolon-separated SoundFont paths */
#ifdef MID_MUSIC
char* soundfont_paths = NULL;
#endif
151
int Mix_GetNumMusicDecoders(void)
152
153
154
155
156
157
158
159
160
161
162
163
164
165
{
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)
{
166
void *ptr = SDL_realloc(music_decoders, (num_decoders + 1) * sizeof (const char *));
167
168
169
if (ptr == NULL) {
return; /* oh well, go on without it. */
}
170
music_decoders = (const char **) ptr;
171
172
173
music_decoders[num_decoders++] = decoder;
}
174
/* Local low-level functions prototypes */
175
static void music_internal_initialize_volume(void);
176
177
178
179
180
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);
181
182
183
184
185
186
187
188
189
190
191
192
193
/* Support for hooking when the music has finished */
static void (*music_finished_hook)(void) = NULL;
void Mix_HookMusicFinished(void (*music_finished)(void))
{
SDL_LockAudio();
music_finished_hook = music_finished;
SDL_UnlockAudio();
}
194
195
196
197
198
/* 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 */
199
200
201
if (!music_internal_playing())
{
202
#ifdef USE_NATIVE_MIDI
203
204
205
206
/* Native MIDI handles looping internally */
if (music_playing->type == MUS_MID && native_midi_ok) {
music_loops = 0;
}
207
#endif
208
209
/* Restart music if it has to loop at a high level */
210
if (music_loops)
211
{
212
213
214
Mix_Fading current_fade;
--music_loops;
current_fade = music_playing->fading;
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
music_internal_play(music_playing, 0.0);
music_playing->fading = current_fade;
}
else
{
music_internal_halt();
if (music_finished_hook)
music_finished_hook();
return 0;
}
}
return 1;
}
233
234
235
/* Mixing function */
void music_mixer(void *udata, Uint8 *stream, int len)
{
236
237
int left = 0;
238
if ( music_playing && music_active ) {
239
/* Handle fading */
240
241
if ( music_playing->fading != MIX_NO_FADING ) {
if ( music_playing->fade_step++ < music_playing->fade_steps ) {
242
int volume;
243
244
int fade_step = music_playing->fade_step;
int fade_steps = music_playing->fade_steps;
245
246
if ( music_playing->fading == MIX_FADING_OUT ) {
247
volume = (music_volume * (fade_steps-fade_step)) / fade_steps;
248
} else { /* Fading in */
249
volume = (music_volume * fade_step) / fade_steps;
250
}
251
music_internal_volume(volume);
252
253
} else {
if ( music_playing->fading == MIX_FADING_OUT ) {
254
255
256
257
music_internal_halt();
if ( music_finished_hook ) {
music_finished_hook();
}
258
return;
259
}
260
music_playing->fading = MIX_NO_FADING;
261
262
}
}
263
264
265
266
267
music_halt_or_loop();
if (!music_internal_playing())
return;
268
269
270
271
272
273
274
275
switch (music_playing->type) {
#ifdef CMD_MUSIC
case MUS_CMD:
/* The playing is done externally */
break;
#endif
#ifdef WAV_MUSIC
case MUS_WAV:
276
left = WAVStream_PlaySome(stream, len);
277
278
break;
#endif
279
280
281
282
283
#ifdef MODPLUG_MUSIC
case MUS_MODPLUG:
left = modplug_playAudio(music_playing->data.modplug, stream, len);
break;
#endif
284
#ifdef MOD_MUSIC
285
case MUS_MOD:
286
left = MOD_playAudio(music_playing->data.module, stream, len);
287
288
289
290
break;
#endif
#ifdef MID_MUSIC
case MUS_MID:
291
292
293
294
295
296
#ifdef USE_NATIVE_MIDI
if ( native_midi_ok ) {
/* Native midi is handled asynchronously */
goto skip;
}
#endif
297
298
299
#ifdef USE_FLUIDSYNTH_MIDI
if ( fluidsynth_ok ) {
fluidsynth_playsome(music_playing->data.fluidsynthmidi, stream, len);
300
goto skip;
301
302
303
}
#endif
#ifdef USE_TIMIDITY_MIDI
304
305
306
if ( timidity_ok ) {
int samples = len / samplesize;
Timidity_PlaySome(stream, samples);
307
goto skip;
308
}
309
#endif
310
break;
311
#endif
312
313
#ifdef OGG_MUSIC
case MUS_OGG:
314
315
left = OGG_playAudio(music_playing->data.ogg, stream, len);
316
317
break;
#endif
318
319
#ifdef FLAC_MUSIC
case MUS_FLAC:
320
left = FLAC_playAudio(music_playing->data.flac, stream, len);
321
322
break;
#endif
323
#ifdef MP3_MUSIC
324
case MUS_MP3:
325
left = (len - smpeg.SMPEG_playAudio(music_playing->data.mp3, stream, len));
326
break;
327
328
329
#endif
#ifdef MP3_MAD_MUSIC
case MUS_MP3_MAD:
330
left = mad_getSamples(music_playing->data.mp3_mad, stream, len);
332
333
334
335
336
#endif
default:
/* Unknown music type?? */
break;
}
337
}
338
339
340
341
skip:
/* Handle seamless music looping */
if (left > 0 && left < len) {
342
music_halt_or_loop();
343
if (music_internal_playing())
344
music_mixer(udata, stream+(len-left), left);
345
}
346
347
348
349
350
351
}
/* Initialize the music players with a certain desired audio format */
int open_music(SDL_AudioSpec *mixer)
{
#ifdef WAV_MUSIC
352
if ( WAVStream_Init(mixer) == 0 ) {
353
add_music_decoder("WAVE");
354
355
}
#endif
356
#ifdef MODPLUG_MUSIC
357
if ( modplug_init(mixer) == 0 ) {
358
359
360
add_music_decoder("MODPLUG");
}
#endif
361
#ifdef MOD_MUSIC
362
if ( MOD_init(mixer) == 0 ) {
363
add_music_decoder("MIKMOD");
364
365
366
}
#endif
#ifdef MID_MUSIC
367
#ifdef USE_TIMIDITY_MIDI
368
samplesize = mixer->size / mixer->samples;
369
if ( Timidity_Init(mixer->freq, mixer->format,
370
mixer->channels, mixer->samples) == 0 ) {
371
timidity_ok = 1;
372
add_music_decoder("TIMIDITY");
373
374
375
} else {
timidity_ok = 0;
}
376
#endif
377
378
379
380
381
382
383
384
#ifdef USE_FLUIDSYNTH_MIDI
if ( fluidsynth_init(mixer) == 0 ) {
fluidsynth_ok = 1;
add_music_decoder("FLUIDSYNTH");
} else {
fluidsynth_ok = 0;
}
#endif
385
#ifdef USE_NATIVE_MIDI
386
387
388
389
#ifdef USE_FLUIDSYNTH_MIDI
native_midi_ok = !fluidsynth_ok;
if ( native_midi_ok )
#endif
390
#ifdef USE_TIMIDITY_MIDI
391
native_midi_ok = !timidity_ok;
392
393
394
if ( !native_midi_ok ) {
native_midi_ok = (getenv("SDL_NATIVE_MUSIC") != NULL);
}
395
396
if ( native_midi_ok )
#endif
397
native_midi_ok = native_midi_detect();
398
399
if ( native_midi_ok )
add_music_decoder("NATIVEMIDI");
400
#endif
401
#endif
402
#ifdef OGG_MUSIC
403
if ( OGG_init(mixer) == 0 ) {
404
add_music_decoder("OGG");
405
406
}
#endif
407
#ifdef FLAC_MUSIC
408
if ( FLAC_init(mixer) == 0 ) {
409
add_music_decoder("FLAC");
410
411
}
#endif
412
#if defined(MP3_MUSIC) || defined(MP3_MAD_MUSIC)
413
414
/* Keep a copy of the mixer */
used_mixer = *mixer;
415
add_music_decoder("MP3");
416
#endif
417
418
music_playing = NULL;
419
music_stopped = 0;
420
421
Mix_VolumeMusic(SDL_MIX_MAXVOLUME);
422
/* Calculate the number of ms for each callback */
423
ms_per_step = (int) (((float)mixer->samples * 1000.0) / mixer->freq);
424
425
426
427
return(0);
}
428
429
430
431
432
433
434
435
436
437
438
439
440
/* 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);
}
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
509
510
511
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;
}
512
513
514
/* Load a music file */
Mix_Music *Mix_LoadMUS(const char *file)
{
515
SDL_RWops *rw;
516
Mix_Music *music;
517
518
Mix_MusicType type;
char *ext = strrchr(file, '.');
519
520
521
522
#ifdef CMD_MUSIC
if ( music_cmd ) {
/* Allocate memory for the music structure */
523
music = (Mix_Music *)SDL_malloc(sizeof(Mix_Music));
524
525
526
if ( music == NULL ) {
Mix_SetError("Out of memory");
return(NULL);
527
}
528
529
530
531
music->error = 0;
music->type = MUS_CMD;
music->data.cmd = MusicCMD_LoadSong(music_cmd, file);
if ( music->data.cmd == NULL ) {
532
SDL_free(music);
533
music = NULL;
534
535
}
return music;
536
}
537
538
539
540
541
542
#endif
rw = SDL_RWFromFile(file, "rb");
if ( rw == NULL ) {
Mix_SetError("Couldn't open '%s'", file);
return NULL;
543
}
544
545
546
/* Use the extension as a first guess on the file type */
type = MUS_NONE;
547
ext = strrchr(file, '.');
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
604
605
606
/* 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;
}
}
607
608
/* Allocate memory for the music structure */
609
music = (Mix_Music *)SDL_malloc(sizeof(Mix_Music));
610
if (music == NULL ) {
611
Mix_SetError("Out of memory");
612
return NULL;
613
614
615
}
music->error = 0;
616
switch (type) {
617
#ifdef WAV_MUSIC
618
619
620
621
622
623
624
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");
625
SDL_free(music);
626
return MUS_NONE;
627
}
628
629
630
631
SDL_RWseek(rw, start, RW_SEEK_SET);
magic[4] = '\0';
music->type = MUS_WAV;
music->data.wave = WAVStream_LoadSong_RW(rw, (char *)magic, freesrc);
632
}
633
if (music->data.wave == NULL) {
634
635
music->error = 1;
}
636
break;
637
#endif
638
#ifdef OGG_MUSIC
639
case MUS_OGG:
640
music->type = MUS_OGG;
641
music->data.ogg = OGG_new_RW(rw, freesrc);
642
643
644
if ( music->data.ogg == NULL ) {
music->error = 1;
}
645
break;
646
#endif
647
#ifdef FLAC_MUSIC
648
case MUS_FLAC:
649
music->type = MUS_FLAC;
650
music->data.flac = FLAC_new_RW(rw, freesrc);
651
652
653
if ( music->data.flac == NULL ) {
music->error = 1;
}
654
break;
655
#endif
656
#ifdef MP3_MUSIC
657
case MUS_MP3:
658
if ( Mix_Init(MIX_INIT_MP3) ) {
659
660
SMPEG_Info info;
music->type = MUS_MP3;
661
music->data.mp3 = smpeg.SMPEG_new_rwops(rw, &info, 0);
662
663
664
665
666
667
if ( !info.has_audio ) {
Mix_SetError("MPEG file does not have any audio stream.");
music->error = 1;
} else {
smpeg.SMPEG_actualSpec(music->data.mp3, &used_mixer);
}
668
} else {
669
music->error = 1;
670
}
671
672
673
break;
#elif defined(MP3_MAD_MUSIC)
case MUS_MP3:
674
music->type = MUS_MP3_MAD;
675
music->data.mp3_mad = mad_openFileRW(rw, &used_mixer, freesrc);
676
if (music->data.mp3_mad == 0) {
677
Mix_SetError("Could not initialize MPEG stream.");
678
679
music->error = 1;
}
680
break;
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
#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);
if ( music->data.nativemidi == NULL ) {
Mix_SetError("%s", native_midi_error());
music->error = 1;
}
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());
713
714
music->error = 1;
}
715
716
717
718
719
720
721
722
723
724
725
726
727
728
#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;
}
}
729
#endif
730
#ifdef MOD_MUSIC
731
732
733
734
735
736
if ( music->error ) {
music->type = MUS_MOD;
music->data.module = MOD_new_RW(rw, freesrc);
if ( music->data.module ) {
music->error = 0;
}
737
738
}
#endif
739
740
741
742
break;
#endif
default:
743
Mix_SetError("Unrecognized music format");
744
745
music->error=1;
} /* switch (want) */
746
747
748
if (music->error) {
749
SDL_free(music);
750
music=NULL;
751
752
753
754
755
756
757
758
}
return(music);
}
/* Free a music chunk previously loaded */
void Mix_FreeMusic(Mix_Music *music)
{
if ( music ) {
759
760
761
762
763
764
765
766
767
768
769
/* 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();
770
}
771
}
772
SDL_UnlockAudio();
773
774
775
776
777
778
779
780
781
782
783
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
784
785
786
787
788
#ifdef MODPLUG_MUSIC
case MUS_MODPLUG:
modplug_delete(music->data.modplug);
break;
#endif
789
#ifdef MOD_MUSIC
790
case MUS_MOD:
791
MOD_delete(music->data.module);
792
793
794
795
break;
#endif
#ifdef MID_MUSIC
case MUS_MID:
796
797
798
#ifdef USE_NATIVE_MIDI
if ( native_midi_ok ) {
native_midi_freesong(music->data.nativemidi);
799
800
801
802
803
804
805
806
goto skip;
}
#endif
#ifdef USE_FLUIDSYNTH_MIDI
if ( fluidsynth_ok ) {
fluidsynth_freesong(music->data.fluidsynthmidi);
goto skip;
}
807
#endif
808
#ifdef USE_TIMIDITY_MIDI
809
810
if ( timidity_ok ) {
Timidity_FreeSong(music->data.midi);
811
goto skip;
812
}
813
#endif
814
815
break;
#endif
816
817
818
819
820
#ifdef OGG_MUSIC
case MUS_OGG:
OGG_delete(music->data.ogg);
break;
#endif
821
822
823
824
825
#ifdef FLAC_MUSIC
case MUS_FLAC:
FLAC_delete(music->data.flac);
break;
#endif
826
#ifdef MP3_MUSIC
827
case MUS_MP3:
828
smpeg.SMPEG_delete(music->data.mp3);
829
break;
830
831
832
833
834
#endif
#ifdef MP3_MAD_MUSIC
case MUS_MP3_MAD:
mad_closeFile(music->data.mp3_mad);
break;
835
836
837
838
839
#endif
default:
/* Unknown music type?? */
break;
}
840
841
skip:
842
SDL_free(music);
843
844
845
}
}
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
/* 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);
}
865
866
867
/* Play a music chunk. Returns 0, or -1 if there was an error.
*/
static int music_internal_play(Mix_Music *music, double position)
868
{
869
870
int retval = 0;
871
#if defined(__MACOSX__) && defined(USE_NATIVE_MIDI)
872
873
/* This fixes a bug with native MIDI on Mac OS X, where you
can't really stop and restart MIDI from the audio callback.
874
*/
875
876
877
878
if ( music == music_playing && music->type == MUS_MID && native_midi_ok ) {
/* Just a seek suffices to restart playing */
music_internal_position(position);
return 0;
879
}
880
#endif
881
882
883
884
885
886
/* Note the music we're playing */
if ( music_playing ) {
music_internal_halt();
}
music_playing = music;
887
888
/* Set the initial volume */
889
890
if ( music->type != MUS_MOD ) {
music_internal_initialize_volume();
891
892
893
}
/* Set up for playback */
894
895
switch (music->type) {
#ifdef CMD_MUSIC
896
897
898
case MUS_CMD:
MusicCMD_Start(music->data.cmd);
break;
899
900
#endif
#ifdef WAV_MUSIC
901
902
903
case MUS_WAV:
WAVStream_Start(music->data.wave);
break;
904
#endif
905
906
907
908
909
910
911
#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
912
#ifdef MOD_MUSIC
913
case MUS_MOD:
914
MOD_play(music->data.module);
915
916
/* Player_SetVolume() does nothing before Player_Start() */
music_internal_initialize_volume();
917
break;
918
919
#endif
#ifdef MID_MUSIC
920
case MUS_MID:
921
#ifdef USE_NATIVE_MIDI
922
if ( native_midi_ok ) {
923
native_midi_start(music->data.nativemidi, music_loops);
924
925
926
927
928
929
930
931
goto skip;
}
#endif
#ifdef USE_FLUIDSYNTH_MIDI
if (fluidsynth_ok ) {
fluidsynth_start(music->data.fluidsynthmidi);
goto skip;
}
932
#endif
933
#ifdef USE_TIMIDITY_MIDI
934
935
if ( timidity_ok ) {
Timidity_Start(music->data.midi);
936
goto skip;
937
}
938
#endif
939
break;
940
#endif
941
#ifdef OGG_MUSIC
942
943
944
case MUS_OGG:
OGG_play(music->data.ogg);
break;
945
#endif
946
947
948
949
950
#ifdef FLAC_MUSIC
case MUS_FLAC:
FLAC_play(music->data.flac);
break;
#endif
951
#ifdef MP3_MUSIC
952
case MUS_MP3:
953
954
955
smpeg.SMPEG_enableaudio(music->data.mp3,1);
smpeg.SMPEG_enablevideo(music->data.mp3,0);
smpeg.SMPEG_play(music_playing->data.mp3);
956
break;
957
958
959
960
961
#endif
#ifdef MP3_MAD_MUSIC
case MUS_MP3_MAD:
mad_start(music->data.mp3_mad);
break;
962
#endif
963
964
965
966
default:
Mix_SetError("Can't play unknown music type");
retval = -1;
break;
967
}
968
969
skip:
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
/* 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)
989
{
990
991
int retval;
992
993
994
995
996
if ( ms_per_step == 0 ) {
SDL_SetError("Audio device hasn't been opened");
return(-1);
}
997
998
/* Don't play null pointers :-) */
if ( music == NULL ) {
999
Mix_SetError("music parameter was NULL");
1000
return(-1);