music.c
2
SDL_mixer: An audio mixer library based on the SDL library
3
Copyright (C) 1997-2009 Sam Lantinga
5
6
7
8
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
10
11
12
13
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
15
16
17
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19
20
Sam Lantinga
slouken@libsdl.org
21
22
*/
23
/* $Id$ */
25
26
#include <stdlib.h>
#include <string.h>
27
#include <ctype.h>
28
#include <assert.h>
29
30
#include "SDL_endian.h"
#include "SDL_audio.h"
31
#include "SDL_timer.h"
33
#include "SDL_mixer.h"
34
35
36
37
38
39
40
#ifdef CMD_MUSIC
#include "music_cmd.h"
#endif
#ifdef WAV_MUSIC
#include "wavestream.h"
#endif
41
42
43
#ifdef MODPLUG_MUSIC
#include "music_modplug.h"
#endif
44
45
#ifdef MOD_MUSIC
#include "music_mod.h"
46
47
#endif
#ifdef MID_MUSIC
48
49
50
51
52
53
54
55
56
57
58
# ifdef USE_TIMIDITY_MIDI
# include "timidity.h"
# endif
# ifdef USE_NATIVE_MIDI
# include "native_midi.h"
# endif
# if defined(USE_TIMIDITY_MIDI) && defined(USE_NATIVE_MIDI)
# define MIDI_ELSE else
# else
# define MIDI_ELSE
# endif
59
#endif
60
61
62
#ifdef OGG_MUSIC
#include "music_ogg.h"
#endif
63
#ifdef MP3_MUSIC
64
#include "dynamic_mp3.h"
69
70
71
#ifdef FLAC_MUSIC
#include "music_flac.h"
#endif
74
75
76
static SDL_AudioSpec used_mixer;
#endif
78
79
int volatile music_active = 1;
static int volatile music_stopped = 0;
80
81
static int music_loops = 0;
static char *music_cmd = NULL;
82
static Mix_Music * volatile music_playing = NULL;
83
static int music_volume = MIX_MAX_VOLUME;
85
struct _Mix_Music {
86
Mix_MusicType type;
87
88
89
90
91
92
93
union {
#ifdef CMD_MUSIC
MusicCMD *cmd;
#endif
#ifdef WAV_MUSIC
WAVStream *wave;
#endif
94
95
96
#ifdef MODPLUG_MUSIC
modplug_data *modplug;
#endif
97
98
#ifdef MOD_MUSIC
struct MODULE *module;
99
100
#endif
#ifdef MID_MUSIC
101
#ifdef USE_TIMIDITY_MIDI
102
MidiSong *midi;
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;
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;
131
132
133
#ifdef USE_NATIVE_MIDI
static int native_midi_ok;
#endif
136
137
138
/* Used to calculate fading steps */
static int ms_per_step;
139
140
141
142
/* rcg06042009 report available decoders at runtime. */
static const char **music_decoders = NULL;
static int num_decoders = 0;
143
int Mix_GetNumMusicDecoders(void)
144
145
146
147
148
149
150
151
152
153
154
155
156
157
{
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)
{
158
void *ptr = realloc(music_decoders, (num_decoders + 1) * sizeof (const char **));
159
160
161
if (ptr == NULL) {
return; /* oh well, go on without it. */
}
162
music_decoders = (const char **) ptr;
163
164
165
music_decoders[num_decoders++] = decoder;
}
166
/* Local low-level functions prototypes */
167
static void music_internal_initialize_volume(void);
168
169
170
171
172
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);
174
175
176
177
178
179
180
181
182
183
184
185
/* 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();
}
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
/* 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;
}
216
217
218
/* Mixing function */
void music_mixer(void *udata, Uint8 *stream, int len)
{
219
220
int left = 0;
221
if ( music_playing && music_active ) {
222
/* Handle fading */
223
224
if ( music_playing->fading != MIX_NO_FADING ) {
if ( music_playing->fade_step++ < music_playing->fade_steps ) {
225
int volume;
226
227
int fade_step = music_playing->fade_step;
int fade_steps = music_playing->fade_steps;
229
if ( music_playing->fading == MIX_FADING_OUT ) {
230
volume = (music_volume * (fade_steps-fade_step)) / fade_steps;
231
} else { /* Fading in */
232
volume = (music_volume * fade_step) / fade_steps;
234
music_internal_volume(volume);
235
236
} else {
if ( music_playing->fading == MIX_FADING_OUT ) {
237
238
239
240
music_internal_halt();
if ( music_finished_hook ) {
music_finished_hook();
}
243
music_playing->fading = MIX_NO_FADING;
246
247
248
249
250
if (music_halt_or_loop() == 0)
return;
251
252
253
254
255
256
257
258
switch (music_playing->type) {
#ifdef CMD_MUSIC
case MUS_CMD:
/* The playing is done externally */
break;
#endif
#ifdef WAV_MUSIC
case MUS_WAV:
259
left = WAVStream_PlaySome(stream, len);
260
261
break;
#endif
262
263
264
265
266
#ifdef MODPLUG_MUSIC
case MUS_MODPLUG:
left = modplug_playAudio(music_playing->data.modplug, stream, len);
break;
#endif
267
#ifdef MOD_MUSIC
268
case MUS_MOD:
269
left = MOD_playAudio(music_playing->data.module, stream, len);
270
271
272
break;
#endif
#ifdef MID_MUSIC
273
#ifdef USE_TIMIDITY_MIDI
274
case MUS_MID:
275
276
277
278
if ( timidity_ok ) {
int samples = len / samplesize;
Timidity_PlaySome(stream, samples);
}
279
280
break;
#endif
282
283
#ifdef OGG_MUSIC
case MUS_OGG:
285
left = OGG_playAudio(music_playing->data.ogg, stream, len);
286
287
break;
#endif
288
289
#ifdef FLAC_MUSIC
case MUS_FLAC:
290
left = FLAC_playAudio(music_playing->data.flac, stream, len);
291
292
break;
#endif
293
#ifdef MP3_MUSIC
295
left = (len - smpeg.SMPEG_playAudio(music_playing->data.mp3, stream, len));
296
break;
300
left = mad_getSamples(music_playing->data.mp3_mad, stream, len);
302
303
304
305
306
307
#endif
default:
/* Unknown music type?? */
break;
}
}
308
309
310
311
312
/* Handle seamless music looping */
if (left > 0 && left < len && music_halt_or_loop()) {
music_mixer(udata, stream+(len-left), left);
}
313
314
315
316
317
318
}
/* Initialize the music players with a certain desired audio format */
int open_music(SDL_AudioSpec *mixer)
{
#ifdef WAV_MUSIC
319
if ( WAVStream_Init(mixer) == 0 ) {
320
add_music_decoder("WAVE");
321
322
}
#endif
323
#ifdef MODPLUG_MUSIC
324
if ( modplug_init(mixer) == 0 ) {
325
326
327
add_music_decoder("MODPLUG");
}
#endif
328
#ifdef MOD_MUSIC
329
if ( MOD_init(mixer) == 0 ) {
330
add_music_decoder("MIKMOD");
331
332
333
}
#endif
#ifdef MID_MUSIC
334
#ifdef USE_TIMIDITY_MIDI
335
samplesize = mixer->size / mixer->samples;
336
if ( Timidity_Init(mixer->freq, mixer->format,
337
mixer->channels, mixer->samples) == 0 ) {
338
timidity_ok = 1;
339
add_music_decoder("TIMIDITY");
340
341
342
} else {
timidity_ok = 0;
}
344
#ifdef USE_NATIVE_MIDI
345
#ifdef USE_TIMIDITY_MIDI
346
native_midi_ok = !timidity_ok;
347
348
349
if ( !native_midi_ok ) {
native_midi_ok = (getenv("SDL_NATIVE_MUSIC") != NULL);
}
350
351
if ( native_midi_ok )
#endif
352
native_midi_ok = native_midi_detect();
353
354
if ( native_midi_ok )
add_music_decoder("NATIVEMIDI");
356
#endif
357
#ifdef OGG_MUSIC
358
if ( OGG_init(mixer) == 0 ) {
359
add_music_decoder("OGG");
360
361
}
#endif
362
#ifdef FLAC_MUSIC
363
if ( FLAC_init(mixer) == 0 ) {
364
add_music_decoder("FLAC");
365
366
}
#endif
368
369
/* Keep a copy of the mixer */
used_mixer = *mixer;
370
add_music_decoder("MP3");
371
#endif
373
music_playing = NULL;
374
music_stopped = 0;
375
376
Mix_VolumeMusic(SDL_MIX_MAXVOLUME);
377
/* Calculate the number of ms for each callback */
378
ms_per_step = (int) (((float)mixer->samples * 1000.0) / mixer->freq);
380
381
382
return(0);
}
383
384
385
386
387
388
389
390
391
392
393
394
395
/* 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);
}
396
397
398
399
/* Load a music file */
Mix_Music *Mix_LoadMUS(const char *file)
{
FILE *fp;
400
char *ext;
401
Uint8 magic[5], moremagic[9];
402
403
404
405
406
407
408
409
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);
}
410
Mix_SetError("Couldn't read from '%s'", file);
411
412
return(NULL);
}
413
414
415
416
if (!fread(moremagic, 8, 1, fp)) {
Mix_SetError("Couldn't read from '%s'", file);
return(NULL);
}
417
magic[4] = '\0';
418
moremagic[8] = '\0';
419
420
fclose(fp);
421
422
423
424
/* Figure out the file extension, so we can determine the type */
ext = strrchr(file, '.');
if ( ext ) ++ext; /* skip the dot in the extension */
425
426
427
/* Allocate memory for the music structure */
music = (Mix_Music *)malloc(sizeof(Mix_Music));
if ( music == NULL ) {
428
Mix_SetError("Out of memory");
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
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"
*/
446
if ( (ext && MIX_string_equals(ext, "WAV")) ||
447
((strcmp((char *)magic, "RIFF") == 0) && (strcmp((char *)(moremagic+4), "WAVE") == 0)) ||
448
(strcmp((char *)magic, "FORM") == 0) ) {
449
music->type = MUS_WAV;
450
music->data.wave = WAVStream_LoadSong(file, (char *)magic);
451
if ( music->data.wave == NULL ) {
452
Mix_SetError("Unable to load WAV file");
453
454
455
456
457
458
music->error = 1;
}
} else
#endif
#ifdef MID_MUSIC
/* MIDI files have the magic four bytes "MThd" */
459
460
if ( (ext && MIX_string_equals(ext, "MID")) ||
(ext && MIX_string_equals(ext, "MIDI")) ||
461
462
463
strcmp((char *)magic, "MThd") == 0 ||
( strcmp((char *)magic, "RIFF") == 0 &&
strcmp((char *)(moremagic+4), "RMID") == 0 ) ) {
464
music->type = MUS_MID;
465
466
#ifdef USE_NATIVE_MIDI
if ( native_midi_ok ) {
467
music->data.nativemidi = native_midi_loadsong(file);
468
469
470
471
if ( music->data.nativemidi == NULL ) {
Mix_SetError("%s", native_midi_error());
music->error = 1;
}
472
} MIDI_ELSE
474
#ifdef USE_TIMIDITY_MIDI
475
if ( timidity_ok ) {
476
music->data.midi = Timidity_LoadSong(file);
477
if ( music->data.midi == NULL ) {
478
Mix_SetError("%s", Timidity_Error());
479
480
music->error = 1;
}
481
} else {
482
Mix_SetError("%s", Timidity_Error());
483
484
music->error = 1;
}
486
487
} else
#endif
488
489
#ifdef OGG_MUSIC
/* Ogg Vorbis files have the magic four bytes "OggS" */
490
if ( (ext && MIX_string_equals(ext, "OGG")) ||
491
strcmp((char *)magic, "OggS") == 0 ) {
492
493
494
495
496
497
498
music->type = MUS_OGG;
music->data.ogg = OGG_new(file);
if ( music->data.ogg == NULL ) {
music->error = 1;
}
} else
#endif
499
500
501
502
503
504
505
506
507
508
509
#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
510
#ifdef MP3_MUSIC
511
if ( (ext && MIX_string_equals(ext, "MPG")) ||
512
(ext && MIX_string_equals(ext, "MP3")) ||
513
(ext && MIX_string_equals(ext, "MPEG")) ||
514
515
(magic[0] == 0xFF && (magic[1] & 0xF0) == 0xF0) ||
(strncmp((char *)magic, "ID3", 3) == 0) ) {
516
if ( Mix_Init(MIX_INIT_MP3) ) {
517
518
519
520
521
522
523
524
525
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);
}
526
} else {
527
music->error = 1;
528
529
530
}
} else
#endif
531
532
533
534
535
#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")) ||
536
537
(magic[0] == 0xFF && (magic[1] & 0xF0) == 0xF0) ||
(strncmp((char *)magic, "ID3", 3) == 0) ) {
538
539
540
541
542
543
544
545
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
546
547
548
549
550
551
552
553
554
#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
555
#ifdef MOD_MUSIC
556
557
if ( 1 ) {
music->type = MUS_MOD;
558
music->data.module = MOD_new(file);
559
560
561
562
563
564
if ( music->data.module == NULL ) {
music->error = 1;
}
} else
#endif
{
565
Mix_SetError("Unrecognized music format");
566
567
568
569
570
571
572
573
574
575
576
577
578
music->error = 1;
}
if ( music->error ) {
free(music);
music = NULL;
}
return(music);
}
/* Free a music chunk previously loaded */
void Mix_FreeMusic(Mix_Music *music)
{
if ( music ) {
579
580
581
582
583
584
585
586
587
588
589
/* 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();
591
}
592
SDL_UnlockAudio();
593
594
595
596
597
598
599
600
601
602
603
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
604
605
606
607
608
#ifdef MODPLUG_MUSIC
case MUS_MODPLUG:
modplug_delete(music->data.modplug);
break;
#endif
609
#ifdef MOD_MUSIC
610
case MUS_MOD:
611
MOD_delete(music->data.module);
612
613
614
615
break;
#endif
#ifdef MID_MUSIC
case MUS_MID:
616
617
618
#ifdef USE_NATIVE_MIDI
if ( native_midi_ok ) {
native_midi_freesong(music->data.nativemidi);
619
} MIDI_ELSE
621
#ifdef USE_TIMIDITY_MIDI
622
623
624
if ( timidity_ok ) {
Timidity_FreeSong(music->data.midi);
}
626
627
break;
#endif
628
629
630
631
632
#ifdef OGG_MUSIC
case MUS_OGG:
OGG_delete(music->data.ogg);
break;
#endif
633
634
635
636
637
#ifdef FLAC_MUSIC
case MUS_FLAC:
FLAC_delete(music->data.flac);
break;
#endif
638
#ifdef MP3_MUSIC
640
smpeg.SMPEG_delete(music->data.mp3);
641
break;
642
643
644
645
646
#endif
#ifdef MP3_MAD_MUSIC
case MUS_MP3_MAD:
mad_closeFile(music->data.mp3_mad);
break;
647
648
649
650
651
652
653
654
655
#endif
default:
/* Unknown music type?? */
break;
}
free(music);
}
}
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
/* 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);
}
675
676
677
/* Play a music chunk. Returns 0, or -1 if there was an error.
*/
static int music_internal_play(Mix_Music *music, double position)
678
{
679
680
681
682
683
684
685
int retval = 0;
/* Note the music we're playing */
if ( music_playing ) {
music_internal_halt();
}
music_playing = music;
687
/* Set the initial volume */
688
689
if ( music->type != MUS_MOD ) {
music_internal_initialize_volume();
690
691
692
}
/* Set up for playback */
693
694
switch (music->type) {
#ifdef CMD_MUSIC
695
696
697
case MUS_CMD:
MusicCMD_Start(music->data.cmd);
break;
698
699
#endif
#ifdef WAV_MUSIC
700
701
702
case MUS_WAV:
WAVStream_Start(music->data.wave);
break;
703
#endif
704
705
706
707
708
709
710
#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
711
#ifdef MOD_MUSIC
712
case MUS_MOD:
713
MOD_play(music->data.module);
714
715
/* Player_SetVolume() does nothing before Player_Start() */
music_internal_initialize_volume();
717
718
#endif
#ifdef MID_MUSIC
719
case MUS_MID:
720
#ifdef USE_NATIVE_MIDI
721
722
723
if ( native_midi_ok ) {
native_midi_start(music->data.nativemidi);
} MIDI_ELSE
725
#ifdef USE_TIMIDITY_MIDI
726
727
728
if ( timidity_ok ) {
Timidity_Start(music->data.midi);
}
731
#endif
732
#ifdef OGG_MUSIC
733
734
735
case MUS_OGG:
OGG_play(music->data.ogg);
break;
737
738
739
740
741
#ifdef FLAC_MUSIC
case MUS_FLAC:
FLAC_play(music->data.flac);
break;
#endif
742
#ifdef MP3_MUSIC
743
case MUS_MP3:
744
745
746
smpeg.SMPEG_enableaudio(music->data.mp3,1);
smpeg.SMPEG_enablevideo(music->data.mp3,0);
smpeg.SMPEG_play(music_playing->data.mp3);
748
749
750
751
752
#endif
#ifdef MP3_MAD_MUSIC
case MUS_MP3_MAD:
mad_start(music->data.mp3_mad);
break;
753
#endif
754
755
756
757
default:
Mix_SetError("Can't play unknown music type");
retval = -1;
break;
758
}
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
/* 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)
780
781
int retval;
782
783
/* Don't play null pointers :-) */
if ( music == NULL ) {
784
Mix_SetError("music parameter was NULL");
785
786
return(-1);
}
787
788
789
790
791
792
/* Setup the data */
if ( ms ) {
music->fading = MIX_FADING_IN;
} else {
music->fading = MIX_NO_FADING;
794
795
music->fade_step = 0;
music->fade_steps = ms/ms_per_step;
797
798
799
800
801
802
803
/* 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();
805
music_active = 1;
806
music_loops = loops;
807
808
809
810
811
812
813
814
815
816
817
818
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);
821
822
/* Set the playing music position */
int music_internal_position(double position)
824
825
826
int retval = 0;
switch (music_playing->type) {
827
828
829
830
831
#ifdef MODPLUG_MUSIC
case MUS_MODPLUG:
modplug_jump_to_time(music_playing->data.modplug, position);
break;
#endif
832
#ifdef MOD_MUSIC
833
case MUS_MOD:
834
MOD_jump_to_time(music_playing->data.module, position);
836
837
#endif
#ifdef OGG_MUSIC
838
839
840
case MUS_OGG:
OGG_jump_to_time(music_playing->data.ogg, position);
break;
841
#endif
842
843
844
845
846
#ifdef FLAC_MUSIC
case MUS_FLAC:
FLAC_jump_to_time(music_playing->data.flac, position);
break;
#endif
847
#ifdef MP3_MUSIC
848
case MUS_MP3:
849
if ( position > 0.0 ) {
850
smpeg.SMPEG_skip(music_playing->data.mp3, (float)position);
851
} else {
852
853
smpeg.SMPEG_rewind(music_playing->data.mp3);
smpeg.SMPEG_play(music_playing->data.mp3);
856
857
858
859
860
#endif
#ifdef MP3_MAD_MUSIC
case MUS_MP3_MAD:
mad_seek(music_playing->data.mp3_mad, position);
break;
861
862
863
864
865
#endif
default:
/* TODO: Implement this for other music backends */
retval = -1;
break;
867
return(retval);
869
int Mix_SetMusicPosition(double position)
871
872
873
874
875
876
877
int retval;
SDL_LockAudio();
if ( music_playing ) {
retval = music_internal_position(position);
if ( retval < 0 ) {
Mix_SetError("Position not implemented for music type");
879
880
881
} else {
Mix_SetError("Music isn't playing");
retval = -1;
883
SDL_UnlockAudio();
885
return(retval);
888
889
890
891
892
893
894
895
896
897
/* 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);
}
}
898
/* Set the music volume */
899
static void music_internal_volume(int volume)
900
{
901
switch (music_playing->type) {
902
#ifdef CMD_MUSIC
903
904
905
case MUS_CMD:
MusicCMD_SetVolume(volume);
break;
906
907
#endif
#ifdef WAV_MUSIC
908
909
910
case MUS_WAV:
WAVStream_SetVolume(volume);
break;
911
#endif
912
913
914
915
916
#ifdef MODPLUG_MUSIC
case MUS_MODPLUG:
modplug_setvolume(music_playing->data.modplug, volume);
break;
#endif
917
#ifdef MOD_MUSIC
918
case MUS_MOD:
919
MOD_setvolume(music_playing->data.module, volume);
921
922
#endif
#ifdef MID_MUSIC
923
case MUS_MID:
924
#ifdef USE_NATIVE_MIDI
925
926
927
if ( native_midi_ok ) {
native_midi_setvolume(volume);
} MIDI_ELSE
929
#ifdef USE_TIMIDITY_MIDI
930
931
932
if ( timidity_ok ) {
Timidity_SetVolume(volume);
}
935
#endif
936
#ifdef OGG_MUSIC
937
938
939
case MUS_OGG:
OGG_setvolume(music_playing->data.ogg, volume);
break;
941
942
943
944
945
#ifdef FLAC_MUSIC
case MUS_FLAC:
FLAC_setvolume(music_playing->data.flac, volume);
break;
#endif
946
#ifdef MP3_MUSIC
947
case MUS_MP3:
948
smpeg.SMPEG_setvolume(music_playing->data.mp3,(int)(((float)volume/(float)MIX_MAX_VOLUME)*100.0));
950
951
952
953
954
#endif
#ifdef MP3_MAD_MUSIC
case MUS_MP3_MAD:
mad_setVolume(music_playing->data.mp3_mad, volume);
break;
955
#endif
956
957
958
959
960
961
962
963
964
965
966
967
default:
/* Unknown music type?? */
break;
}
}
int Mix_VolumeMusic(int volume)
{
int prev_volume;
prev_volume = music_volume;
if ( volume < 0 ) {
return prev_volume;
968
}
969
970
971
972
973
974
975
976
977
if ( volume > SDL_MIX_MAXVOLUME ) {
volume = SDL_MIX_MAXVOLUME;
}
music_volume = volume;
SDL_LockAudio();
if ( music_playing ) {
music_internal_volume(music_volume);
}
SDL_UnlockAudio();
978
979
980
return(prev_volume);
}
981
982
/* Halt playing of music */
static void music_internal_halt(void)
983
{
984
switch (music_playing->type) {
985
#ifdef CMD_MUSIC
986
case MUS_CMD:
987
988
MusicCMD_Stop(music_playing->data.cmd);
break;
989
990
#endif
#ifdef WAV_MUSIC
991
case MUS_WAV:
992
993
WAVStream_Stop();
break;
994
#endif
995
996
997
998
999
#ifdef MODPLUG_MUSIC
case MUS_MODPLUG:
modplug_stop(music_playing->data.modplug);
break;
#endif
1000
#ifdef MOD_MUSIC