/
music.c
1675 lines (1564 loc) · 36.2 KB
1
/*
2
SDL_mixer: An audio mixer library based on the SDL library
3
Copyright (C) 1997-2009 Sam Lantinga
4
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.
9
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.
14
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
18
19
20
Sam Lantinga
slouken@libsdl.org
21
22
*/
23
/* $Id$ */
24
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"
32
33
#include "SDL_mixer.h"
34
35
36
37
38
39
40
41
42
#define SDL_SURROUND
#ifdef SDL_SURROUND
#define MAX_OUTPUT_CHANNELS 6
#else
#define MAX_OUTPUT_CHANNELS 2
#endif
43
44
45
46
47
48
49
50
51
52
53
/* The music command hack is UNIX specific */
#ifndef unix
#undef CMD_MUSIC
#endif
#ifdef CMD_MUSIC
#include "music_cmd.h"
#endif
#ifdef WAV_MUSIC
#include "wavestream.h"
#endif
54
#if defined(MOD_MUSIC) || defined(LIBMIKMOD_MUSIC)
55
56
57
58
59
# include "mikmod.h"
# if defined(LIBMIKMOD_VERSION) /* libmikmod 3.1.8 */
# define UNIMOD MODULE
# define MikMod_Init() MikMod_Init(NULL)
# define MikMod_LoadSong(a,b) Player_Load(a,b,0)
60
61
# ifndef LIBMIKMOD_MUSIC
# define MikMod_LoadSongRW(a,b) Player_LoadRW(a,b,0)
62
# endif
63
64
65
66
67
68
# define MikMod_FreeSong Player_Free
extern int MikMod_errno;
# else /* old MikMod 3.0.3 */
# define MikMod_strerror(x) _mm_errmsg[x])
# define MikMod_errno _mm_errno
# endif
69
70
#endif
#ifdef MID_MUSIC
71
72
73
74
75
76
77
78
79
80
81
# 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
82
#endif
83
84
85
#ifdef OGG_MUSIC
#include "music_ogg.h"
#endif
86
#ifdef MP3_MUSIC
87
#include "dynamic_mp3.h"
88
89
90
91
#endif
#ifdef MP3_MAD_MUSIC
#include "music_mad.h"
#endif
92
93
94
#ifdef FLAC_MUSIC
#include "music_flac.h"
#endif
95
96
#if defined(MP3_MUSIC) || defined(MP3_MAD_MUSIC)
97
98
99
static SDL_AudioSpec used_mixer;
#endif
101
102
int volatile music_active = 1;
static int volatile music_stopped = 0;
103
104
static int music_loops = 0;
static char *music_cmd = NULL;
105
static Mix_Music * volatile music_playing = NULL;
106
static int music_volume = MIX_MAX_VOLUME;
107
108
static int music_swap8;
static int music_swap16;
109
110
struct _Mix_Music {
111
Mix_MusicType type;
112
113
114
115
116
117
118
union {
#ifdef CMD_MUSIC
MusicCMD *cmd;
#endif
#ifdef WAV_MUSIC
WAVStream *wave;
#endif
119
#if defined(MOD_MUSIC) || defined(LIBMIKMOD_MUSIC)
120
121
122
UNIMOD *module;
#endif
#ifdef MID_MUSIC
123
#ifdef USE_TIMIDITY_MIDI
124
MidiSong *midi;
125
#endif
126
127
128
#ifdef USE_NATIVE_MIDI
NativeMidiSong *nativemidi;
#endif
129
#endif
130
131
132
#ifdef OGG_MUSIC
OGG_music *ogg;
#endif
133
134
#ifdef MP3_MUSIC
SMPEG *mp3;
135
136
137
#endif
#ifdef MP3_MAD_MUSIC
mad_data *mp3_mad;
138
139
140
#endif
#ifdef FLAC_MUSIC
FLAC_music *flac;
141
142
#endif
} data;
143
Mix_Fading fading;
144
145
int fade_step;
int fade_steps;
146
147
int error;
};
148
#ifdef MID_MUSIC
149
#ifdef USE_TIMIDITY_MIDI
150
static int timidity_ok;
151
static int samplesize;
152
#endif
153
154
155
#ifdef USE_NATIVE_MIDI
static int native_midi_ok;
#endif
156
#endif
157
158
159
160
161
/* Reference for converting mikmod output to 4/6 channels */
static int current_output_channels;
static Uint16 current_output_format;
162
163
164
/* Used to calculate fading steps */
static int ms_per_step;
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
/* rcg06042009 report available decoders at runtime. */
static const char **music_decoders = NULL;
static int num_decoders = 0;
int Mix_NumMusicDecoders(void)
{
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)
{
void *ptr = realloc(music_decoders, num_decoders * sizeof (const char **));
if (ptr == NULL) {
return; /* oh well, go on without it. */
}
music_decoders = (const char **) ptr;
music_decoders[num_decoders++] = decoder;
}
192
/* Local low-level functions prototypes */
193
static void music_internal_initialize_volume(void);
194
195
196
197
198
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);
199
200
201
202
203
204
205
206
207
208
209
210
211
/* 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();
}
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
/* 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;
}
242
243
244
/* Mixing function */
void music_mixer(void *udata, Uint8 *stream, int len)
{
245
if ( music_playing && music_active ) {
246
/* Handle fading */
247
248
if ( music_playing->fading != MIX_NO_FADING ) {
if ( music_playing->fade_step++ < music_playing->fade_steps ) {
249
int volume;
250
251
int fade_step = music_playing->fade_step;
int fade_steps = music_playing->fade_steps;
252
253
if ( music_playing->fading == MIX_FADING_OUT ) {
254
volume = (music_volume * (fade_steps-fade_step)) / fade_steps;
255
} else { /* Fading in */
256
volume = (music_volume * fade_step) / fade_steps;
257
}
258
music_internal_volume(volume);
259
260
} else {
if ( music_playing->fading == MIX_FADING_OUT ) {
261
262
263
264
music_internal_halt();
if ( music_finished_hook ) {
music_finished_hook();
}
265
return;
266
}
267
music_playing->fading = MIX_NO_FADING;
268
269
}
}
270
271
272
273
274
if (music_halt_or_loop() == 0)
return;
275
276
277
278
279
280
281
282
switch (music_playing->type) {
#ifdef CMD_MUSIC
case MUS_CMD:
/* The playing is done externally */
break;
#endif
#ifdef WAV_MUSIC
case MUS_WAV:
283
WAVStream_PlaySome(stream, len);
284
285
break;
#endif
286
#if defined(MOD_MUSIC) || defined(LIBMIKMOD_MUSIC)
287
case MUS_MOD:
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
if (current_output_channels > 2) {
int small_len = 2 * len / current_output_channels;
int i;
Uint8 *src, *dst;
VC_WriteBytes((SBYTE *)stream, small_len);
/* and extend to len by copying channels */
src = stream + small_len;
dst = stream + len;
switch (current_output_format & 0xFF) {
case 8:
for ( i=small_len/2; i; --i ) {
src -= 2;
dst -= current_output_channels;
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[0];
dst[3] = src[1];
if (current_output_channels == 6) {
dst[4] = src[0];
dst[5] = src[1];
}
}
break;
case 16:
for ( i=small_len/4; i; --i ) {
src -= 4;
dst -= 2 * current_output_channels;
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
dst[3] = src[3];
dst[4] = src[0];
dst[5] = src[1];
dst[6] = src[2];
dst[7] = src[3];
if (current_output_channels == 6) {
dst[8] = src[0];
dst[9] = src[1];
dst[10] = src[2];
dst[11] = src[3];
}
}
break;
}
}
else VC_WriteBytes((SBYTE *)stream, len);
339
340
if ( music_swap8 ) {
Uint8 *dst;
341
int i;
342
343
344
345
346
347
348
349
dst = stream;
for ( i=len; i; --i ) {
*dst++ ^= 0x80;
}
} else
if ( music_swap16 ) {
Uint8 *dst, tmp;
350
int i;
351
352
353
354
355
356
357
358
359
360
361
362
dst = stream;
for ( i=(len/2); i; --i ) {
tmp = dst[0];
dst[0] = dst[1];
dst[1] = tmp;
dst += 2;
}
}
break;
#endif
#ifdef MID_MUSIC
363
#ifdef USE_TIMIDITY_MIDI
364
case MUS_MID:
365
366
367
368
if ( timidity_ok ) {
int samples = len / samplesize;
Timidity_PlaySome(stream, samples);
}
369
370
break;
#endif
371
#endif
372
373
#ifdef OGG_MUSIC
case MUS_OGG:
374
375
376
377
378
len = OGG_playAudio(music_playing->data.ogg, stream, len);
if (len > 0 && music_halt_or_loop())
OGG_playAudio(music_playing->data.ogg, stream, len);
379
380
break;
#endif
381
382
383
384
385
386
387
#ifdef FLAC_MUSIC
case MUS_FLAC:
len = FLAC_playAudio(music_playing->data.flac, stream, len);
if (len > 0 && music_halt_or_loop())
FLAC_playAudio(music_playing->data.flac, stream, len);
break;
#endif
388
#ifdef MP3_MUSIC
389
case MUS_MP3:
390
smpeg.SMPEG_playAudio(music_playing->data.mp3, stream, len);
391
break;
392
393
394
395
396
#endif
#ifdef MP3_MAD_MUSIC
case MUS_MP3_MAD:
mad_getSamples(music_playing->data.mp3_mad, stream, len);
break;
397
398
399
400
401
402
403
404
405
406
407
408
#endif
default:
/* Unknown music type?? */
break;
}
}
}
/* Initialize the music players with a certain desired audio format */
int open_music(SDL_AudioSpec *mixer)
{
int music_error;
409
410
411
#ifdef LIBMIKMOD_MUSIC
CHAR *list;
#endif
412
413
414
415
416
music_error = 0;
#ifdef WAV_MUSIC
if ( WAVStream_Init(mixer) < 0 ) {
++music_error;
417
418
} else {
add_music_decoder("WAVE");
419
420
}
#endif
421
#if defined(MOD_MUSIC) || defined(LIBMIKMOD_MUSIC)
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
/* Set the MikMod music format */
music_swap8 = 0;
music_swap16 = 0;
switch (mixer->format) {
case AUDIO_U8:
case AUDIO_S8: {
if ( mixer->format == AUDIO_S8 ) {
music_swap8 = 1;
}
md_mode = 0;
}
break;
case AUDIO_S16LSB:
case AUDIO_S16MSB: {
/* See if we need to correct MikMod mixing */
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
if ( mixer->format == AUDIO_S16MSB ) {
#else
if ( mixer->format == AUDIO_S16LSB ) {
#endif
music_swap16 = 1;
}
md_mode = DMODE_16BITS;
}
break;
default: {
451
Mix_SetError("Unknown hardware audio format");
452
453
454
++music_error;
}
}
455
456
current_output_channels = mixer->channels;
current_output_format = mixer->format;
457
if ( mixer->channels > 1 ) {
458
if ( mixer->channels > MAX_OUTPUT_CHANNELS ) {
459
Mix_SetError("Hardware uses more channels than mixer");
460
461
462
463
++music_error;
}
md_mode |= DMODE_STEREO;
}
464
465
466
md_mixfreq = mixer->freq;
md_device = 0;
md_volume = 96;
467
468
md_musicvolume = 128;
md_sndfxvolume = 128;
469
470
471
md_pansep = 128;
md_reverb = 0;
md_mode |= DMODE_HQMIXER|DMODE_SOFT_MUSIC|DMODE_SURROUND;
472
#ifdef LIBMIKMOD_MUSIC
473
474
475
476
list = MikMod_InfoDriver();
if ( list )
free(list);
else
477
#endif
478
MikMod_RegisterDriver(&drv_nos);
479
#ifdef LIBMIKMOD_MUSIC
480
481
482
483
list = MikMod_InfoLoader();
if ( list )
free(list);
else
484
485
#endif
MikMod_RegisterAllLoaders();
486
if ( MikMod_Init() ) {
487
Mix_SetError("%s", MikMod_strerror(MikMod_errno));
488
489
++music_error;
}
490
add_music_decoder("MIKMOD");
491
492
#endif
#ifdef MID_MUSIC
493
#ifdef USE_TIMIDITY_MIDI
494
samplesize = mixer->size / mixer->samples;
495
if ( Timidity_Init(mixer->freq, mixer->format,
496
mixer->channels, mixer->samples) == 0 ) {
497
timidity_ok = 1;
498
add_music_decoder("TIMIDITY");
499
500
501
} else {
timidity_ok = 0;
}
502
#endif
503
#ifdef USE_NATIVE_MIDI
504
#ifdef USE_TIMIDITY_MIDI
505
native_midi_ok = !timidity_ok;
506
507
if ( native_midi_ok )
#endif
508
native_midi_ok = native_midi_detect();
509
510
if ( native_midi_ok )
add_music_decoder("NATIVEMIDI");
511
#endif
512
#endif
513
514
515
#ifdef OGG_MUSIC
if ( OGG_init(mixer) < 0 ) {
++music_error;
516
517
} else {
add_music_decoder("OGG");
518
519
}
#endif
520
521
522
#ifdef FLAC_MUSIC
if ( FLAC_init(mixer) < 0 ) {
++music_error;
523
524
} else {
add_music_decoder("FLAC");
525
526
}
#endif
527
#if defined(MP3_MUSIC) || defined(MP3_MAD_MUSIC)
528
529
/* Keep a copy of the mixer */
used_mixer = *mixer;
530
add_music_decoder("MP3");
531
#endif
532
533
music_playing = NULL;
534
music_stopped = 0;
535
536
537
538
539
if ( music_error ) {
return(-1);
}
Mix_VolumeMusic(SDL_MIX_MAXVOLUME);
540
/* Calculate the number of ms for each callback */
541
ms_per_step = (int) (((float)mixer->samples * 1000.0) / mixer->freq);
542
543
544
545
return(0);
}
546
547
548
549
550
551
552
553
554
555
556
557
558
/* 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);
}
559
560
561
562
/* Load a music file */
Mix_Music *Mix_LoadMUS(const char *file)
{
FILE *fp;
563
char *ext;
564
Uint8 magic[5], moremagic[9];
565
566
567
568
569
570
571
572
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);
}
573
Mix_SetError("Couldn't read from '%s'", file);
574
575
return(NULL);
}
576
577
578
579
if (!fread(moremagic, 8, 1, fp)) {
Mix_SetError("Couldn't read from '%s'", file);
return(NULL);
}
580
magic[4] = '\0';
581
moremagic[8] = '\0';
582
583
fclose(fp);
584
585
586
587
/* Figure out the file extension, so we can determine the type */
ext = strrchr(file, '.');
if ( ext ) ++ext; /* skip the dot in the extension */
588
589
590
/* Allocate memory for the music structure */
music = (Mix_Music *)malloc(sizeof(Mix_Music));
if ( music == NULL ) {
591
Mix_SetError("Out of memory");
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
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"
*/
609
if ( (ext && MIX_string_equals(ext, "WAV")) ||
610
((strcmp((char *)magic, "RIFF") == 0) && (strcmp((char *)(moremagic+4), "WAVE") == 0)) ||
611
(strcmp((char *)magic, "FORM") == 0) ) {
612
music->type = MUS_WAV;
613
music->data.wave = WAVStream_LoadSong(file, (char *)magic);
614
if ( music->data.wave == NULL ) {
615
Mix_SetError("Unable to load WAV file");
616
617
618
619
620
621
music->error = 1;
}
} else
#endif
#ifdef MID_MUSIC
/* MIDI files have the magic four bytes "MThd" */
622
623
if ( (ext && MIX_string_equals(ext, "MID")) ||
(ext && MIX_string_equals(ext, "MIDI")) ||
624
625
626
strcmp((char *)magic, "MThd") == 0 ||
( strcmp((char *)magic, "RIFF") == 0 &&
strcmp((char *)(moremagic+4), "RMID") == 0 ) ) {
627
music->type = MUS_MID;
628
629
630
631
632
633
634
#ifdef USE_NATIVE_MIDI
if ( native_midi_ok ) {
music->data.nativemidi = native_midi_loadsong((char *)file);
if ( music->data.nativemidi == NULL ) {
Mix_SetError("%s", native_midi_error());
music->error = 1;
}
635
} MIDI_ELSE
636
#endif
637
#ifdef USE_TIMIDITY_MIDI
638
639
640
if ( timidity_ok ) {
music->data.midi = Timidity_LoadSong((char *)file);
if ( music->data.midi == NULL ) {
641
Mix_SetError("%s", Timidity_Error());
642
643
music->error = 1;
}
644
} else {
645
Mix_SetError("%s", Timidity_Error());
646
647
music->error = 1;
}
648
#endif
649
650
} else
#endif
651
652
#ifdef OGG_MUSIC
/* Ogg Vorbis files have the magic four bytes "OggS" */
653
if ( (ext && MIX_string_equals(ext, "OGG")) ||
654
strcmp((char *)magic, "OggS") == 0 ) {
655
656
657
658
659
660
661
music->type = MUS_OGG;
music->data.ogg = OGG_new(file);
if ( music->data.ogg == NULL ) {
music->error = 1;
}
} else
#endif
662
663
664
665
666
667
668
669
670
671
672
#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
673
#ifdef MP3_MUSIC
674
if ( (ext && MIX_string_equals(ext, "MPG")) ||
675
(ext && MIX_string_equals(ext, "MP3")) ||
676
(ext && MIX_string_equals(ext, "MPEG")) ||
677
(magic[0] == 0xFF && (magic[1] & 0xF0) == 0xF0) ) {
678
679
680
681
682
683
684
685
686
687
if ( Mix_InitMP3() == 0 ) {
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);
}
688
} else {
689
music->error = 1;
690
691
692
}
} else
#endif
693
694
695
696
697
698
699
700
701
702
703
704
705
706
#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")) ||
(magic[0] == 0xFF && (magic[1] & 0xF0) == 0xF0) ) {
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
707
#if defined(MOD_MUSIC) || defined(LIBMIKMOD_MUSIC)
708
709
710
711
if ( 1 ) {
music->type = MUS_MOD;
music->data.module = MikMod_LoadSong((char *)file, 64);
if ( music->data.module == NULL ) {
712
Mix_SetError("%s", MikMod_strerror(MikMod_errno));
713
music->error = 1;
714
715
716
717
718
} else {
/* Stop implicit looping, fade out and other flags. */
music->data.module->extspd = 1;
music->data.module->panflag = 1;
music->data.module->wrap = 0;
719
music->data.module->loop = 1;
720
721
#if 0 /* Don't set fade out by default - unfortunately there's no real way
to query the status of the song or set trigger actions. Hum. */
722
music->data.module->fadeout = 1;
723
#endif
724
725
726
727
}
} else
#endif
{
728
Mix_SetError("Unrecognized music format");
729
730
731
732
733
734
735
736
737
738
739
740
741
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 ) {
742
743
744
745
746
747
748
749
750
751
752
/* 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();
753
}
754
}
755
SDL_UnlockAudio();
756
757
758
759
760
761
762
763
764
765
766
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
767
#if defined(MOD_MUSIC) || defined(LIBMIKMOD_MUSIC)
768
769
770
771
772
773
case MUS_MOD:
MikMod_FreeSong(music->data.module);
break;
#endif
#ifdef MID_MUSIC
case MUS_MID:
774
775
776
#ifdef USE_NATIVE_MIDI
if ( native_midi_ok ) {
native_midi_freesong(music->data.nativemidi);
777
} MIDI_ELSE
778
#endif
779
#ifdef USE_TIMIDITY_MIDI
780
781
782
if ( timidity_ok ) {
Timidity_FreeSong(music->data.midi);
}
783
#endif
784
785
break;
#endif
786
787
788
789
790
#ifdef OGG_MUSIC
case MUS_OGG:
OGG_delete(music->data.ogg);
break;
#endif
791
792
793
794
795
#ifdef FLAC_MUSIC
case MUS_FLAC:
FLAC_delete(music->data.flac);
break;
#endif
796
#ifdef MP3_MUSIC
797
case MUS_MP3:
798
799
smpeg.SMPEG_delete(music->data.mp3);
Mix_QuitMP3();
800
break;
801
802
803
804
805
#endif
#ifdef MP3_MAD_MUSIC
case MUS_MP3_MAD:
mad_closeFile(music->data.mp3_mad);
break;
806
807
808
809
810
811
812
813
814
#endif
default:
/* Unknown music type?? */
break;
}
free(music);
}
}
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
/* 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);
}
834
835
836
/* Play a music chunk. Returns 0, or -1 if there was an error.
*/
static int music_internal_play(Mix_Music *music, double position)
837
{
838
839
840
841
842
843
844
int retval = 0;
/* Note the music we're playing */
if ( music_playing ) {
music_internal_halt();
}
music_playing = music;
845
846
/* Set the initial volume */
847
848
if ( music->type != MUS_MOD ) {
music_internal_initialize_volume();
849
850
851
}
/* Set up for playback */
852
853
switch (music->type) {
#ifdef CMD_MUSIC
854
855
856
case MUS_CMD:
MusicCMD_Start(music->data.cmd);
break;
857
858
#endif
#ifdef WAV_MUSIC
859
860
861
case MUS_WAV:
WAVStream_Start(music->data.wave);
break;
862
#endif
863
#if defined(MOD_MUSIC) || defined(LIBMIKMOD_MUSIC)
864
865
case MUS_MOD:
Player_Start(music->data.module);
866
867
/* Player_SetVolume() does nothing before Player_Start() */
music_internal_initialize_volume();
868
break;
869
870
#endif
#ifdef MID_MUSIC
871
case MUS_MID:
872
#ifdef USE_NATIVE_MIDI
873
874
875
if ( native_midi_ok ) {
native_midi_start(music->data.nativemidi);
} MIDI_ELSE
876
#endif
877
#ifdef USE_TIMIDITY_MIDI
878
879
880
if ( timidity_ok ) {
Timidity_Start(music->data.midi);
}
881
#endif
882
break;
883
#endif
884
#ifdef OGG_MUSIC
885
886
887
case MUS_OGG:
OGG_play(music->data.ogg);
break;
888
#endif
889
890
891
892
893
#ifdef FLAC_MUSIC
case MUS_FLAC:
FLAC_play(music->data.flac);
break;
#endif
894
#ifdef MP3_MUSIC
895
case MUS_MP3:
896
897
898
smpeg.SMPEG_enableaudio(music->data.mp3,1);
smpeg.SMPEG_enablevideo(music->data.mp3,0);
smpeg.SMPEG_play(music_playing->data.mp3);
899
break;
900
901
902
903
904
#endif
#ifdef MP3_MAD_MUSIC
case MUS_MP3_MAD:
mad_start(music->data.mp3_mad);
break;
905
#endif
906
907
908
909
default:
Mix_SetError("Can't play unknown music type");
retval = -1;
break;
910
}
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
/* 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)
931
{
932
933
int retval;
934
935
/* Don't play null pointers :-) */
if ( music == NULL ) {
936
Mix_SetError("music parameter was NULL");
937
938
return(-1);
}
939
940
941
942
943
944
/* Setup the data */
if ( ms ) {
music->fading = MIX_FADING_IN;
} else {
music->fading = MIX_NO_FADING;
945
}
946
947
music->fade_step = 0;
music->fade_steps = ms/ms_per_step;
948
949
950
951
952
953
954
955
/* 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();
956
}
957
music_active = 1;
958
music_loops = loops;
959
960
961
962
963
964
965
966
967
968
969
970
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);
971
972
}
973
974
/* Set the playing music position */
int music_internal_position(double position)
975
{
976
977
978
int retval = 0;
switch (music_playing->type) {
979
#if defined(MOD_MUSIC) || defined(LIBMIKMOD_MUSIC)
980
981
982
case MUS_MOD:
Player_SetPosition((UWORD)position);
break;
983
984
#endif
#ifdef OGG_MUSIC
985
986
987
case MUS_OGG:
OGG_jump_to_time(music_playing->data.ogg, position);
break;
988
#endif
989
990
991
992
993
#ifdef FLAC_MUSIC
case MUS_FLAC:
FLAC_jump_to_time(music_playing->data.flac, position);
break;
#endif
994
#ifdef MP3_MUSIC
995
case MUS_MP3:
996
if ( position > 0.0 ) {
997
smpeg.SMPEG_skip(music_playing->data.mp3, (float)position);
998
} else {
999
1000
smpeg.SMPEG_rewind(music_playing->data.mp3);
smpeg.SMPEG_play(music_playing->data.mp3);