/
music.c
1614 lines (1502 loc) · 34.2 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 = 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
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
/* 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 */
if (!music_internal_playing())
{
/* Restart music if it has to loop at a high level */
if (music_loops && --music_loops)
{
Mix_Fading current_fade = music_playing->fading;
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;
}
224
225
226
/* Mixing function */
void music_mixer(void *udata, Uint8 *stream, int len)
{
227
228
int left = 0;
229
if ( music_playing && music_active ) {
230
/* Handle fading */
231
232
if ( music_playing->fading != MIX_NO_FADING ) {
if ( music_playing->fade_step++ < music_playing->fade_steps ) {
233
int volume;
234
235
int fade_step = music_playing->fade_step;
int fade_steps = music_playing->fade_steps;
236
237
if ( music_playing->fading == MIX_FADING_OUT ) {
238
volume = (music_volume * (fade_steps-fade_step)) / fade_steps;
239
} else { /* Fading in */
240
volume = (music_volume * fade_step) / fade_steps;
241
}
242
music_internal_volume(volume);
243
244
} else {
if ( music_playing->fading == MIX_FADING_OUT ) {
245
246
247
248
music_internal_halt();
if ( music_finished_hook ) {
music_finished_hook();
}
249
return;
250
}
251
music_playing->fading = MIX_NO_FADING;
252
253
}
}
254
255
256
music_halt_or_loop();
if (!music_internal_playing())
257
return;
258
259
260
261
262
263
264
265
266
switch (music_playing->type) {
#ifdef CMD_MUSIC
case MUS_CMD:
/* The playing is done externally */
break;
#endif
#ifdef WAV_MUSIC
case MUS_WAV:
267
left = WAVStream_PlaySome(stream, len);
268
269
break;
#endif
270
271
272
273
274
#ifdef MODPLUG_MUSIC
case MUS_MODPLUG:
left = modplug_playAudio(music_playing->data.modplug, stream, len);
break;
#endif
275
#ifdef MOD_MUSIC
276
case MUS_MOD:
277
left = MOD_playAudio(music_playing->data.module, stream, len);
278
279
280
281
break;
#endif
#ifdef MID_MUSIC
case MUS_MID:
282
283
284
285
286
287
288
#ifdef USE_FLUIDSYNTH_MIDI
if ( fluidsynth_ok ) {
fluidsynth_playsome(music_playing->data.fluidsynthmidi, stream, len);
goto skip;
}
#endif
#ifdef USE_TIMIDITY_MIDI
289
290
291
if ( timidity_ok ) {
int samples = len / samplesize;
Timidity_PlaySome(stream, samples);
292
goto skip;
293
}
294
#endif
295
break;
296
#endif
297
298
#ifdef OGG_MUSIC
case MUS_OGG:
299
300
left = OGG_playAudio(music_playing->data.ogg, stream, len);
301
302
break;
#endif
303
304
#ifdef FLAC_MUSIC
case MUS_FLAC:
305
left = FLAC_playAudio(music_playing->data.flac, stream, len);
306
307
break;
#endif
308
#ifdef MP3_MUSIC
309
case MUS_MP3:
310
left = (len - smpeg.SMPEG_playAudio(music_playing->data.mp3, stream, len));
311
break;
312
313
314
#endif
#ifdef MP3_MAD_MUSIC
case MUS_MP3_MAD:
315
left = mad_getSamples(music_playing->data.mp3_mad, stream, len);
317
318
319
320
321
322
#endif
default:
/* Unknown music type?? */
break;
}
}
323
324
skip:
325
/* Handle seamless music looping */
326
327
328
329
if (left > 0 && left < len) {
music_halt_or_loop();
if (music_internal_playing())
music_mixer(udata, stream+(len-left), left);
330
}
331
332
333
334
335
336
}
/* Initialize the music players with a certain desired audio format */
int open_music(SDL_AudioSpec *mixer)
{
#ifdef WAV_MUSIC
337
if ( WAVStream_Init(mixer) == 0 ) {
338
add_music_decoder("WAVE");
339
340
}
#endif
341
#ifdef MODPLUG_MUSIC
342
if ( modplug_init(mixer) == 0 ) {
343
344
345
add_music_decoder("MODPLUG");
}
#endif
346
#ifdef MOD_MUSIC
347
if ( MOD_init(mixer) == 0 ) {
348
add_music_decoder("MIKMOD");
349
350
351
}
#endif
#ifdef MID_MUSIC
352
#ifdef USE_TIMIDITY_MIDI
353
samplesize = mixer->size / mixer->samples;
354
if ( Timidity_Init(mixer->freq, mixer->format,
355
mixer->channels, mixer->samples) == 0 ) {
356
timidity_ok = 1;
357
add_music_decoder("TIMIDITY");
358
359
360
} else {
timidity_ok = 0;
}
361
#endif
362
363
364
365
366
367
368
369
#ifdef USE_FLUIDSYNTH_MIDI
if ( fluidsynth_init(mixer) == 0 ) {
fluidsynth_ok = 1;
add_music_decoder("FLUIDSYNTH");
} else {
fluidsynth_ok = 0;
}
#endif
370
#ifdef USE_NATIVE_MIDI
371
372
373
374
#ifdef USE_FLUIDSYNTH_MIDI
native_midi_ok = !fluidsynth_ok;
if ( native_midi_ok )
#endif
375
#ifdef USE_TIMIDITY_MIDI
376
native_midi_ok = !timidity_ok;
377
378
379
if ( !native_midi_ok ) {
native_midi_ok = (getenv("SDL_NATIVE_MUSIC") != NULL);
}
380
381
if ( native_midi_ok )
#endif
382
native_midi_ok = native_midi_detect();
383
384
if ( native_midi_ok )
add_music_decoder("NATIVEMIDI");
385
#endif
386
#endif
387
#ifdef OGG_MUSIC
388
if ( OGG_init(mixer) == 0 ) {
389
add_music_decoder("OGG");
390
391
}
#endif
392
#ifdef FLAC_MUSIC
393
if ( FLAC_init(mixer) == 0 ) {
394
add_music_decoder("FLAC");
395
396
}
#endif
397
#if defined(MP3_MUSIC) || defined(MP3_MAD_MUSIC)
398
399
/* Keep a copy of the mixer */
used_mixer = *mixer;
400
add_music_decoder("MP3");
401
#endif
402
403
music_playing = NULL;
404
music_stopped = 0;
405
406
Mix_VolumeMusic(SDL_MIX_MAXVOLUME);
407
/* Calculate the number of ms for each callback */
408
ms_per_step = (int) (((float)mixer->samples * 1000.0) / mixer->freq);
409
410
411
412
return(0);
}
413
414
415
416
417
418
419
420
421
422
423
424
425
/* 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);
}
426
427
428
429
/* Load a music file */
Mix_Music *Mix_LoadMUS(const char *file)
{
FILE *fp;
430
char *ext;
431
Uint8 magic[5], moremagic[9];
432
433
434
435
436
437
438
439
Mix_Music *music;
/* Figure out what kind of file this is */
fp = fopen(file, "rb");
if ( (fp == NULL) || !fread(magic, 4, 1, fp) ) {
if ( fp != NULL ) {
fclose(fp);
}
440
Mix_SetError("Couldn't read from '%s'", file);
441
442
return(NULL);
}
443
444
445
446
if (!fread(moremagic, 8, 1, fp)) {
Mix_SetError("Couldn't read from '%s'", file);
return(NULL);
}
447
magic[4] = '\0';
448
moremagic[8] = '\0';
449
450
fclose(fp);
451
452
453
454
/* Figure out the file extension, so we can determine the type */
ext = strrchr(file, '.');
if ( ext ) ++ext; /* skip the dot in the extension */
455
456
457
/* Allocate memory for the music structure */
music = (Mix_Music *)malloc(sizeof(Mix_Music));
if ( music == NULL ) {
458
Mix_SetError("Out of memory");
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
return(NULL);
}
music->error = 0;
#ifdef CMD_MUSIC
if ( music_cmd ) {
music->type = MUS_CMD;
music->data.cmd = MusicCMD_LoadSong(music_cmd, file);
if ( music->data.cmd == NULL ) {
music->error = 1;
}
} else
#endif
#ifdef WAV_MUSIC
/* WAVE files have the magic four bytes "RIFF"
AIFF files have the magic 12 bytes "FORM" XXXX "AIFF"
*/
476
if ( (ext && MIX_string_equals(ext, "WAV")) ||
477
((strcmp((char *)magic, "RIFF") == 0) && (strcmp((char *)(moremagic+4), "WAVE") == 0)) ||
478
(strcmp((char *)magic, "FORM") == 0) ) {
479
music->type = MUS_WAV;
480
music->data.wave = WAVStream_LoadSong(file, (char *)magic);
481
if ( music->data.wave == NULL ) {
482
Mix_SetError("Unable to load WAV file");
483
484
485
486
487
488
music->error = 1;
}
} else
#endif
#ifdef MID_MUSIC
/* MIDI files have the magic four bytes "MThd" */
489
490
if ( (ext && MIX_string_equals(ext, "MID")) ||
(ext && MIX_string_equals(ext, "MIDI")) ||
491
492
493
strcmp((char *)magic, "MThd") == 0 ||
( strcmp((char *)magic, "RIFF") == 0 &&
strcmp((char *)(moremagic+4), "RMID") == 0 ) ) {
494
music->type = MUS_MID;
495
496
#ifdef USE_NATIVE_MIDI
if ( native_midi_ok ) {
497
music->data.nativemidi = native_midi_loadsong(file);
498
499
500
501
if ( music->data.nativemidi == NULL ) {
Mix_SetError("%s", native_midi_error());
music->error = 1;
}
502
503
504
505
506
507
508
509
510
511
512
goto skip;
}
#endif
#ifdef USE_FLUIDSYNTH_MIDI
if ( fluidsynth_ok ) {
music->data.fluidsynthmidi = fluidsynth_loadsong(file);
if ( music->data.fluidsynthmidi == NULL ) {
music->error = 1;
}
goto skip;
}
513
#endif
514
#ifdef USE_TIMIDITY_MIDI
515
if ( timidity_ok ) {
516
music->data.midi = Timidity_LoadSong(file);
517
if ( music->data.midi == NULL ) {
518
Mix_SetError("%s", Timidity_Error());
519
520
music->error = 1;
}
521
} else {
522
Mix_SetError("%s", Timidity_Error());
523
524
music->error = 1;
}
525
#endif
526
527
} else
#endif
528
529
#ifdef OGG_MUSIC
/* Ogg Vorbis files have the magic four bytes "OggS" */
530
if ( (ext && MIX_string_equals(ext, "OGG")) ||
531
strcmp((char *)magic, "OggS") == 0 ) {
532
533
534
535
536
537
538
music->type = MUS_OGG;
music->data.ogg = OGG_new(file);
if ( music->data.ogg == NULL ) {
music->error = 1;
}
} else
#endif
539
540
541
542
543
544
545
546
547
548
549
#ifdef FLAC_MUSIC
/* FLAC files have the magic four bytes "fLaC" */
if ( (ext && MIX_string_equals(ext, "FLAC")) ||
strcmp((char *)magic, "fLaC") == 0 ) {
music->type = MUS_FLAC;
music->data.flac = FLAC_new(file);
if ( music->data.flac == NULL ) {
music->error = 1;
}
} else
#endif
550
#ifdef MP3_MUSIC
551
if ( (ext && MIX_string_equals(ext, "MPG")) ||
552
(ext && MIX_string_equals(ext, "MP3")) ||
553
(ext && MIX_string_equals(ext, "MPEG")) ||
554
555
(magic[0] == 0xFF && (magic[1] & 0xF0) == 0xF0) ||
(strncmp((char *)magic, "ID3", 3) == 0) ) {
556
if ( Mix_Init(MIX_INIT_MP3) ) {
557
558
559
560
561
562
563
564
565
SMPEG_Info info;
music->type = MUS_MP3;
music->data.mp3 = smpeg.SMPEG_new(file, &info, 0);
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);
}
566
} else {
567
music->error = 1;
568
569
570
}
} else
#endif
571
572
573
574
575
#ifdef MP3_MAD_MUSIC
if ( (ext && MIX_string_equals(ext, "MPG")) ||
(ext && MIX_string_equals(ext, "MP3")) ||
(ext && MIX_string_equals(ext, "MPEG")) ||
(ext && MIX_string_equals(ext, "MAD")) ||
576
577
(magic[0] == 0xFF && (magic[1] & 0xF0) == 0xF0) ||
(strncmp((char *)magic, "ID3", 3) == 0) ) {
578
579
580
581
582
583
584
585
music->type = MUS_MP3_MAD;
music->data.mp3_mad = mad_openFile(file, &used_mixer);
if (music->data.mp3_mad == 0) {
Mix_SetError("Could not initialize MPEG stream.");
music->error = 1;
}
} else
#endif
586
587
588
589
590
591
592
593
594
#ifdef MODPLUG_MUSIC
if ( 1 ) {
music->type = MUS_MODPLUG;
music->data.modplug = modplug_new(file);
if ( music->data.modplug == NULL ) {
music->error = 1;
}
} else
#endif
595
#ifdef MOD_MUSIC
596
597
if ( 1 ) {
music->type = MUS_MOD;
598
music->data.module = MOD_new(file);
599
600
601
602
603
604
if ( music->data.module == NULL ) {
music->error = 1;
}
} else
#endif
{
605
Mix_SetError("Unrecognized music format");
606
607
music->error = 1;
}
608
609
skip:
610
611
612
613
614
615
616
617
618
619
620
if ( music->error ) {
free(music);
music = NULL;
}
return(music);
}
/* Free a music chunk previously loaded */
void Mix_FreeMusic(Mix_Music *music)
{
if ( music ) {
621
622
623
624
625
626
627
628
629
630
631
/* 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();
632
}
633
}
634
SDL_UnlockAudio();
635
636
637
638
639
640
641
642
643
644
645
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
646
647
648
649
650
#ifdef MODPLUG_MUSIC
case MUS_MODPLUG:
modplug_delete(music->data.modplug);
break;
#endif
651
#ifdef MOD_MUSIC
652
case MUS_MOD:
653
MOD_delete(music->data.module);
654
655
656
657
break;
#endif
#ifdef MID_MUSIC
case MUS_MID:
658
659
660
#ifdef USE_NATIVE_MIDI
if ( native_midi_ok ) {
native_midi_freesong(music->data.nativemidi);
661
662
663
664
665
666
667
668
goto skip;
}
#endif
#ifdef USE_FLUIDSYNTH_MIDI
if ( fluidsynth_ok ) {
fluidsynth_freesong(music->data.fluidsynthmidi);
goto skip;
}
669
#endif
670
#ifdef USE_TIMIDITY_MIDI
671
672
if ( timidity_ok ) {
Timidity_FreeSong(music->data.midi);
673
goto skip;
674
}
675
#endif
676
677
break;
#endif
678
679
680
681
682
#ifdef OGG_MUSIC
case MUS_OGG:
OGG_delete(music->data.ogg);
break;
#endif
683
684
685
686
687
#ifdef FLAC_MUSIC
case MUS_FLAC:
FLAC_delete(music->data.flac);
break;
#endif
688
#ifdef MP3_MUSIC
689
case MUS_MP3:
690
smpeg.SMPEG_delete(music->data.mp3);
691
break;
692
693
694
695
696
#endif
#ifdef MP3_MAD_MUSIC
case MUS_MP3_MAD:
mad_closeFile(music->data.mp3_mad);
break;
697
698
699
700
701
#endif
default:
/* Unknown music type?? */
break;
}
702
703
skip:
704
705
706
707
free(music);
}
}
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
/* 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);
}
727
728
729
/* Play a music chunk. Returns 0, or -1 if there was an error.
*/
static int music_internal_play(Mix_Music *music, double position)
730
{
731
732
733
734
735
736
737
int retval = 0;
/* Note the music we're playing */
if ( music_playing ) {
music_internal_halt();
}
music_playing = music;
738
739
/* Set the initial volume */
740
741
if ( music->type != MUS_MOD ) {
music_internal_initialize_volume();
742
743
744
}
/* Set up for playback */
745
746
switch (music->type) {
#ifdef CMD_MUSIC
747
748
749
case MUS_CMD:
MusicCMD_Start(music->data.cmd);
break;
750
751
#endif
#ifdef WAV_MUSIC
752
753
754
case MUS_WAV:
WAVStream_Start(music->data.wave);
break;
755
#endif
756
757
758
759
760
761
762
#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
763
#ifdef MOD_MUSIC
764
case MUS_MOD:
765
MOD_play(music->data.module);
766
767
/* Player_SetVolume() does nothing before Player_Start() */
music_internal_initialize_volume();
768
break;
769
770
#endif
#ifdef MID_MUSIC
771
case MUS_MID:
772
#ifdef USE_NATIVE_MIDI
773
774
if ( native_midi_ok ) {
native_midi_start(music->data.nativemidi);
775
776
777
778
779
780
781
782
goto skip;
}
#endif
#ifdef USE_FLUIDSYNTH_MIDI
if (fluidsynth_ok ) {
fluidsynth_start(music->data.fluidsynthmidi);
goto skip;
}
783
#endif
784
#ifdef USE_TIMIDITY_MIDI
785
786
if ( timidity_ok ) {
Timidity_Start(music->data.midi);
787
goto skip;
788
}
789
#endif
790
break;
791
#endif
792
#ifdef OGG_MUSIC
793
794
795
case MUS_OGG:
OGG_play(music->data.ogg);
break;
796
#endif
797
798
799
800
801
#ifdef FLAC_MUSIC
case MUS_FLAC:
FLAC_play(music->data.flac);
break;
#endif
802
#ifdef MP3_MUSIC
803
case MUS_MP3:
804
805
806
smpeg.SMPEG_enableaudio(music->data.mp3,1);
smpeg.SMPEG_enablevideo(music->data.mp3,0);
smpeg.SMPEG_play(music_playing->data.mp3);
807
break;
808
809
810
811
812
#endif
#ifdef MP3_MAD_MUSIC
case MUS_MP3_MAD:
mad_start(music->data.mp3_mad);
break;
813
#endif
814
815
816
817
default:
Mix_SetError("Can't play unknown music type");
retval = -1;
break;
818
}
819
820
skip:
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
/* 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)
840
{
841
842
int retval;
843
844
845
846
847
if ( ms_per_step == 0 ) {
SDL_SetError("Audio device hasn't been opened");
return(-1);
}
848
849
/* Don't play null pointers :-) */
if ( music == NULL ) {
850
Mix_SetError("music parameter was NULL");
851
852
return(-1);
}
853
854
855
856
857
858
/* Setup the data */
if ( ms ) {
music->fading = MIX_FADING_IN;
} else {
music->fading = MIX_NO_FADING;
859
}
860
861
music->fade_step = 0;
music->fade_steps = ms/ms_per_step;
862
863
864
865
866
867
868
869
/* Play the puppy */
SDL_LockAudio();
/* If the current music is fading out, wait for the fade to complete */
while ( music_playing && (music_playing->fading == MIX_FADING_OUT) ) {
SDL_UnlockAudio();
SDL_Delay(100);
SDL_LockAudio();
870
}
871
music_active = 1;
872
music_loops = loops;
873
874
875
876
877
878
879
880
881
882
883
884
retval = music_internal_play(music, position);
SDL_UnlockAudio();
return(retval);
}
int Mix_FadeInMusic(Mix_Music *music, int loops, int ms)
{
return Mix_FadeInMusicPos(music, loops, ms, 0.0);
}
int Mix_PlayMusic(Mix_Music *music, int loops)
{
return Mix_FadeInMusicPos(music, loops, 0, 0.0);
885
886
}
887
888
/* Set the playing music position */
int music_internal_position(double position)
889
{
890
891
892
int retval = 0;
switch (music_playing->type) {
893
894
895
896
897
#ifdef MODPLUG_MUSIC
case MUS_MODPLUG:
modplug_jump_to_time(music_playing->data.modplug, position);
break;
#endif
898
#ifdef MOD_MUSIC
899
case MUS_MOD:
900
MOD_jump_to_time(music_playing->data.module, position);
901
break;
902
903
#endif
#ifdef OGG_MUSIC
904
905
906
case MUS_OGG:
OGG_jump_to_time(music_playing->data.ogg, position);
break;
907
#endif
908
909
910
911
912
#ifdef FLAC_MUSIC
case MUS_FLAC:
FLAC_jump_to_time(music_playing->data.flac, position);
break;
#endif
913
#ifdef MP3_MUSIC
914
case MUS_MP3:
915
if ( position > 0.0 ) {
916
smpeg.SMPEG_skip(music_playing->data.mp3, (float)position);
917
} else {
918
919
smpeg.SMPEG_rewind(music_playing->data.mp3);
smpeg.SMPEG_play(music_playing->data.mp3);
920
}
921
break;
922
923
924
925
926
#endif
#ifdef MP3_MAD_MUSIC
case MUS_MP3_MAD:
mad_seek(music_playing->data.mp3_mad, position);
break;
927
928
929
930
931
#endif
default:
/* TODO: Implement this for other music backends */
retval = -1;
break;
932
}
933
return(retval);
934
}
935
int Mix_SetMusicPosition(double position)
936
{
937
938
939
940
941
942
943
int retval;
SDL_LockAudio();
if ( music_playing ) {
retval = music_internal_position(position);
if ( retval < 0 ) {
Mix_SetError("Position not implemented for music type");
944
}
945
946
947
} else {
Mix_SetError("Music isn't playing");
retval = -1;
948
}
949
SDL_UnlockAudio();
950
951
return(retval);
952
953
}
954
955
956
957
958
959
960
961
962
963
/* Set the music's initial volume */
static void music_internal_initialize_volume(void)
{
if ( music_playing->fading == MIX_FADING_IN ) {
music_internal_volume(0);
} else {
music_internal_volume(music_volume);
}
}
964
/* Set the music volume */
965
static void music_internal_volume(int volume)
966
{
967
switch (music_playing->type) {
968
#ifdef CMD_MUSIC
969
970
971
case MUS_CMD:
MusicCMD_SetVolume(volume);
break;
972
973
#endif
#ifdef WAV_MUSIC
974
975
976
case MUS_WAV:
WAVStream_SetVolume(volume);
break;
977
#endif
978
979
980
981
982
#ifdef MODPLUG_MUSIC
case MUS_MODPLUG:
modplug_setvolume(music_playing->data.modplug, volume);
break;
#endif
983
#ifdef MOD_MUSIC
984
case MUS_MOD:
985
MOD_setvolume(music_playing->data.module, volume);
986
break;
987
988
#endif
#ifdef MID_MUSIC
989
case MUS_MID:
990
#ifdef USE_NATIVE_MIDI
991
992
if ( native_midi_ok ) {
native_midi_setvolume(volume);
993
994
995
996
997
998
999
1000
return;
}
#endif
#ifdef USE_FLUIDSYNTH_MIDI
if ( fluidsynth_ok ) {
fluidsynth_setvolume(music_playing->data.fluidsynthmidi, volume);
return;
}