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