/
music.c
1597 lines (1472 loc) · 33.5 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
534
535
music == NULL;
}
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
625
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");
return MUS_NONE;
626
}
627
628
629
630
SDL_RWseek(rw, start, RW_SEEK_SET);
magic[4] = '\0';
music->type = MUS_WAV;
music->data.wave = WAVStream_LoadSong_RW(rw, (char *)magic, freesrc);
631
}
632
if (music->data.wave == NULL) {
633
634
music->error = 1;
}
635
break;
636
#endif
637
#ifdef OGG_MUSIC
638
case MUS_OGG:
639
music->type = MUS_OGG;
640
music->data.ogg = OGG_new_RW(rw, freesrc);
641
642
643
if ( music->data.ogg == NULL ) {
music->error = 1;
}
644
break;
645
#endif
646
#ifdef FLAC_MUSIC
647
case MUS_FLAC:
648
music->type = MUS_FLAC;
649
music->data.flac = FLAC_new_RW(rw, freesrc);
650
651
652
if ( music->data.flac == NULL ) {
music->error = 1;
}
653
break;
654
#endif
655
#ifdef MP3_MUSIC
656
case MUS_MP3:
657
if ( Mix_Init(MIX_INIT_MP3) ) {
658
659
SMPEG_Info info;
music->type = MUS_MP3;
660
music->data.mp3 = smpeg.SMPEG_new_rwops(rw, &info, 0);
661
662
663
664
665
666
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);
}
667
} else {
668
music->error = 1;
669
}
670
671
672
break;
#elif defined(MP3_MAD_MUSIC)
case MUS_MP3:
673
music->type = MUS_MP3_MAD;
674
music->data.mp3_mad = mad_openFileRW(rw, &used_mixer, freesrc);
675
if (music->data.mp3_mad == 0) {
676
Mix_SetError("Could not initialize MPEG stream.");
677
678
music->error = 1;
}
679
break;
681
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
#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());
712
713
music->error = 1;
}
714
715
716
717
718
719
720
721
722
723
724
725
726
727
#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;
}
}
728
#endif
729
#ifdef MOD_MUSIC
730
731
732
733
734
735
if ( music->error ) {
music->type = MUS_MOD;
music->data.module = MOD_new_RW(rw, freesrc);
if ( music->data.module ) {
music->error = 0;
}
736
737
}
#endif
738
739
740
741
break;
#endif
default:
742
Mix_SetError("Unrecognized music format");
743
744
music->error=1;
} /* switch (want) */
745
746
747
if (music->error) {
748
SDL_free(music);
749
music=NULL;
750
751
752
753
754
755
756
757
}
return(music);
}
/* Free a music chunk previously loaded */
void Mix_FreeMusic(Mix_Music *music)
{
if ( music ) {
758
759
760
761
762
763
764
765
766
767
768
/* 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();
769
}
770
}
771
SDL_UnlockAudio();
772
773
774
775
776
777
778
779
780
781
782
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
783
784
785
786
787
#ifdef MODPLUG_MUSIC
case MUS_MODPLUG:
modplug_delete(music->data.modplug);
break;
#endif
788
#ifdef MOD_MUSIC
789
case MUS_MOD:
790
MOD_delete(music->data.module);
791
792
793
794
break;
#endif
#ifdef MID_MUSIC
case MUS_MID:
795
796
797
#ifdef USE_NATIVE_MIDI
if ( native_midi_ok ) {
native_midi_freesong(music->data.nativemidi);
798
799
800
801
802
803
804
805
goto skip;
}
#endif
#ifdef USE_FLUIDSYNTH_MIDI
if ( fluidsynth_ok ) {
fluidsynth_freesong(music->data.fluidsynthmidi);
goto skip;
}
806
#endif
807
#ifdef USE_TIMIDITY_MIDI
808
809
if ( timidity_ok ) {
Timidity_FreeSong(music->data.midi);
810
goto skip;
811
}
812
#endif
813
814
break;
#endif
815
816
817
818
819
#ifdef OGG_MUSIC
case MUS_OGG:
OGG_delete(music->data.ogg);
break;
#endif
820
821
822
823
824
#ifdef FLAC_MUSIC
case MUS_FLAC:
FLAC_delete(music->data.flac);
break;
#endif
825
#ifdef MP3_MUSIC
826
case MUS_MP3:
827
smpeg.SMPEG_delete(music->data.mp3);
828
break;
829
830
831
832
833
#endif
#ifdef MP3_MAD_MUSIC
case MUS_MP3_MAD:
mad_closeFile(music->data.mp3_mad);
break;
834
835
836
837
838
#endif
default:
/* Unknown music type?? */
break;
}
839
840
skip:
841
SDL_free(music);
842
843
844
}
}
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
/* 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);
}
864
865
866
/* Play a music chunk. Returns 0, or -1 if there was an error.
*/
static int music_internal_play(Mix_Music *music, double position)
867
{
868
869
int retval = 0;
870
#if defined(__MACOSX__) && defined(USE_NATIVE_MIDI)
871
872
/* This fixes a bug with native MIDI on Mac OS X, where you
can't really stop and restart MIDI from the audio callback.
873
*/
874
875
876
877
if ( music == music_playing && music->type == MUS_MID && native_midi_ok ) {
/* Just a seek suffices to restart playing */
music_internal_position(position);
return 0;
878
}
879
#endif
880
881
882
883
884
885
/* Note the music we're playing */
if ( music_playing ) {
music_internal_halt();
}
music_playing = music;
886
887
/* Set the initial volume */
888
889
if ( music->type != MUS_MOD ) {
music_internal_initialize_volume();
890
891
892
}
/* Set up for playback */
893
894
switch (music->type) {
#ifdef CMD_MUSIC
895
896
897
case MUS_CMD:
MusicCMD_Start(music->data.cmd);
break;
898
899
#endif
#ifdef WAV_MUSIC
900
901
902
case MUS_WAV:
WAVStream_Start(music->data.wave);
break;
903
#endif
904
905
906
907
908
909
910
#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
911
#ifdef MOD_MUSIC
912
case MUS_MOD:
913
MOD_play(music->data.module);
914
915
/* Player_SetVolume() does nothing before Player_Start() */
music_internal_initialize_volume();
916
break;
917
918
#endif
#ifdef MID_MUSIC
919
case MUS_MID:
920
#ifdef USE_NATIVE_MIDI
921
if ( native_midi_ok ) {
922
native_midi_start(music->data.nativemidi, music_loops);
923
924
925
926
927
928
929
930
goto skip;
}
#endif
#ifdef USE_FLUIDSYNTH_MIDI
if (fluidsynth_ok ) {
fluidsynth_start(music->data.fluidsynthmidi);
goto skip;
}
931
#endif
932
#ifdef USE_TIMIDITY_MIDI
933
934
if ( timidity_ok ) {
Timidity_Start(music->data.midi);
935
goto skip;
936
}
937
#endif
938
break;
939
#endif
940
#ifdef OGG_MUSIC
941
942
943
case MUS_OGG:
OGG_play(music->data.ogg);
break;
944
#endif
945
946
947
948
949
#ifdef FLAC_MUSIC
case MUS_FLAC:
FLAC_play(music->data.flac);
break;
#endif
950
#ifdef MP3_MUSIC
951
case MUS_MP3:
952
953
954
smpeg.SMPEG_enableaudio(music->data.mp3,1);
smpeg.SMPEG_enablevideo(music->data.mp3,0);
smpeg.SMPEG_play(music_playing->data.mp3);
955
break;
956
957
958
959
960
#endif
#ifdef MP3_MAD_MUSIC
case MUS_MP3_MAD:
mad_start(music->data.mp3_mad);
break;
961
#endif
962
963
964
965
default:
Mix_SetError("Can't play unknown music type");
retval = -1;
break;
966
}
967
968
skip:
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
/* 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)
988
{
989
990
int retval;
991
992
993
994
995
if ( ms_per_step == 0 ) {
SDL_SetError("Audio device hasn't been opened");
return(-1);
}
996
997
/* Don't play null pointers :-) */
if ( music == NULL ) {
998
Mix_SetError("music parameter was NULL");
999
1000
return(-1);
}