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