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