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