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