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