/
music.c
1368 lines (1277 loc) · 28.9 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
47
48
49
50
51
52
/* 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
53
#if defined(MOD_MUSIC) || defined(LIBMIKMOD_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
# ifndef LIBMIKMOD_MUSIC
# define MikMod_LoadSongRW(a,b) Player_LoadRW(a,b,0)
61
# 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;
99
100
struct _Mix_Music {
101
Mix_MusicType type;
102
103
104
105
106
107
108
union {
#ifdef CMD_MUSIC
MusicCMD *cmd;
#endif
#ifdef WAV_MUSIC
WAVStream *wave;
#endif
109
#if defined(MOD_MUSIC) || defined(LIBMIKMOD_MUSIC)
110
111
112
UNIMOD *module;
#endif
#ifdef MID_MUSIC
113
#ifdef USE_TIMIDITY_MIDI
114
MidiSong *midi;
115
#endif
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;
136
#endif
137
138
139
#ifdef USE_NATIVE_MIDI
static int native_midi_ok;
#endif
140
#endif
141
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);
156
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;
179
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;
184
}
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();
}
192
return;
193
}
194
music_playing->fading = MIX_NO_FADING;
195
196
}
}
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();
208
}
209
return;
210
}
211
}
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
break;
#endif
223
#if defined(MOD_MUSIC) || defined(LIBMIKMOD_MUSIC)
224
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;
278
int i;
279
280
281
282
283
284
285
286
dst = stream;
for ( i=len; i; --i ) {
*dst++ ^= 0x80;
}
} else
if ( music_swap16 ) {
Uint8 *dst, tmp;
287
int i;
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
308
#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
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
337
#if defined(MOD_MUSIC) || defined(LIBMIKMOD_MUSIC)
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
/* 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
390
391
#ifdef LIBMIKMOD_MUSIC
md_mode |= DMODE_HQMIXER|DMODE_SOFT_MUSIC|DMODE_SURROUND;
#endif
#ifdef LIBMIKMOD_MUSIC
if(!MikMod_InfoDriver())
392
393
MikMod_RegisterDriver(&drv_nos);
#else
394
MikMod_RegisterAllDrivers();
395
396
#endif
397
398
399
400
#ifdef LIBMIKMOD_MUSIC
if(!MikMod_InfoLoader())
#endif
MikMod_RegisterAllLoaders();
401
if ( MikMod_Init() ) {
402
Mix_SetError("%s", MikMod_strerror(MikMod_errno));
403
404
405
406
++music_error;
}
#endif
#ifdef MID_MUSIC
407
#ifdef USE_TIMIDITY_MIDI
408
samplesize = mixer->size / mixer->samples;
409
if ( Timidity_Init(mixer->freq, mixer->format,
410
mixer->channels, mixer->samples) == 0 ) {
411
timidity_ok = 1;
412
413
414
} else {
timidity_ok = 0;
}
415
#endif
416
#ifdef USE_NATIVE_MIDI
417
#ifdef USE_TIMIDITY_MIDI
418
native_midi_ok = !timidity_ok;
419
420
if ( native_midi_ok )
#endif
421
native_midi_ok = native_midi_detect();
422
#endif
423
#endif
424
425
426
427
428
#ifdef OGG_MUSIC
if ( OGG_init(mixer) < 0 ) {
++music_error;
}
#endif
429
430
431
432
#ifdef MP3_MUSIC
/* Keep a copy of the mixer */
used_mixer = *mixer;
#endif
433
music_playing = NULL;
434
music_stopped = 0;
435
436
437
438
439
if ( music_error ) {
return(-1);
}
Mix_VolumeMusic(SDL_MIX_MAXVOLUME);
440
/* Calculate the number of ms for each callback */
441
ms_per_step = (int) (((float)mixer->samples * 1000.0) / mixer->freq);
442
443
444
445
return(0);
}
446
447
448
449
450
451
452
453
454
455
456
457
458
/* 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);
}
459
460
461
462
/* Load a music file */
Mix_Music *Mix_LoadMUS(const char *file)
{
FILE *fp;
463
char *ext;
464
Uint8 magic[5], moremagic[9];
465
466
467
468
469
470
471
472
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);
}
473
Mix_SetError("Couldn't read from '%s'", file);
474
475
return(NULL);
}
476
477
478
479
if (!fread(moremagic, 8, 1, fp)) {
Mix_SetError("Couldn't read from '%s'", file);
return(NULL);
}
480
magic[4] = '\0';
481
moremagic[8] = '\0';
482
483
fclose(fp);
484
485
486
487
/* Figure out the file extension, so we can determine the type */
ext = strrchr(file, '.');
if ( ext ) ++ext; /* skip the dot in the extension */
488
489
490
/* Allocate memory for the music structure */
music = (Mix_Music *)malloc(sizeof(Mix_Music));
if ( music == NULL ) {
491
Mix_SetError("Out of memory");
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
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"
*/
509
if ( (ext && MIX_string_equals(ext, "WAV")) ||
510
((strcmp((char *)magic, "RIFF") == 0) && (strcmp((char *)(moremagic+4), "WAVE") == 0)) ||
511
(strcmp((char *)magic, "FORM") == 0) ) {
512
music->type = MUS_WAV;
513
music->data.wave = WAVStream_LoadSong(file, (char *)magic);
514
if ( music->data.wave == NULL ) {
515
Mix_SetError("Unable to load WAV file");
516
517
518
519
520
521
music->error = 1;
}
} else
#endif
#ifdef MID_MUSIC
/* MIDI files have the magic four bytes "MThd" */
522
523
if ( (ext && MIX_string_equals(ext, "MID")) ||
(ext && MIX_string_equals(ext, "MIDI")) ||
524
525
526
strcmp((char *)magic, "MThd") == 0 ||
( strcmp((char *)magic, "RIFF") == 0 &&
strcmp((char *)(moremagic+4), "RMID") == 0 ) ) {
527
music->type = MUS_MID;
528
529
530
531
532
533
534
#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;
}
535
} MIDI_ELSE
536
#endif
537
#ifdef USE_TIMIDITY_MIDI
538
539
540
if ( timidity_ok ) {
music->data.midi = Timidity_LoadSong((char *)file);
if ( music->data.midi == NULL ) {
541
Mix_SetError("%s", Timidity_Error());
542
543
music->error = 1;
}
544
} else {
545
Mix_SetError("%s", Timidity_Error());
546
547
music->error = 1;
}
548
#endif
549
550
} else
#endif
551
552
#ifdef OGG_MUSIC
/* Ogg Vorbis files have the magic four bytes "OggS" */
553
if ( (ext && MIX_string_equals(ext, "OGG")) ||
554
strcmp((char *)magic, "OggS") == 0 ) {
555
556
557
558
559
560
561
music->type = MUS_OGG;
music->data.ogg = OGG_new(file);
if ( music->data.ogg == NULL ) {
music->error = 1;
}
} else
#endif
562
#ifdef MP3_MUSIC
563
if ( (ext && MIX_string_equals(ext, "MPG")) ||
564
(ext && MIX_string_equals(ext, "MP3")) ||
565
(ext && MIX_string_equals(ext, "MPEG")) ||
566
(magic[0] == 0xFF && (magic[1] & 0xF0) == 0xF0) ) {
567
568
569
SMPEG_Info info;
music->type = MUS_MP3;
music->data.mp3 = SMPEG_new(file, &info, 0);
570
if ( !info.has_audio ) {
571
Mix_SetError("MPEG file does not have any audio stream.");
572
music->error = 1;
573
} else {
574
575
576
577
SMPEG_actualSpec(music->data.mp3, &used_mixer);
}
} else
#endif
578
#if defined(MOD_MUSIC) || defined(LIBMIKMOD_MUSIC)
579
580
581
582
if ( 1 ) {
music->type = MUS_MOD;
music->data.module = MikMod_LoadSong((char *)file, 64);
if ( music->data.module == NULL ) {
583
Mix_SetError("%s", MikMod_strerror(MikMod_errno));
584
music->error = 1;
585
586
587
588
589
590
} 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;
591
592
#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. */
593
music->data.module->fadeout = 1;
594
#endif
595
596
597
598
}
} else
#endif
{
599
Mix_SetError("Unrecognized music format");
600
601
602
603
604
605
606
607
608
609
610
611
612
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 ) {
613
614
615
616
617
618
619
620
621
622
623
/* 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();
624
}
625
}
626
SDL_UnlockAudio();
627
628
629
630
631
632
633
634
635
636
637
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
638
#if defined(MOD_MUSIC) || defined(LIBMIKMOD_MUSIC)
639
640
641
642
643
644
case MUS_MOD:
MikMod_FreeSong(music->data.module);
break;
#endif
#ifdef MID_MUSIC
case MUS_MID:
645
646
647
#ifdef USE_NATIVE_MIDI
if ( native_midi_ok ) {
native_midi_freesong(music->data.nativemidi);
648
} MIDI_ELSE
649
#endif
650
#ifdef USE_TIMIDITY_MIDI
651
652
653
if ( timidity_ok ) {
Timidity_FreeSong(music->data.midi);
}
654
#endif
655
656
break;
#endif
657
658
659
660
661
#ifdef OGG_MUSIC
case MUS_OGG:
OGG_delete(music->data.ogg);
break;
#endif
662
#ifdef MP3_MUSIC
663
case MUS_MP3:
664
665
666
667
668
669
670
671
672
673
674
SMPEG_delete(music->data.mp3);
break;
#endif
default:
/* Unknown music type?? */
break;
}
free(music);
}
}
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
/* 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);
}
694
695
696
/* Play a music chunk. Returns 0, or -1 if there was an error.
*/
static int music_internal_play(Mix_Music *music, double position)
697
{
698
699
700
701
702
703
704
int retval = 0;
/* Note the music we're playing */
if ( music_playing ) {
music_internal_halt();
}
music_playing = music;
705
706
/* Set the initial volume */
707
708
if ( music->type != MUS_MOD ) {
music_internal_initialize_volume();
709
710
711
}
/* Set up for playback */
712
713
switch (music->type) {
#ifdef CMD_MUSIC
714
715
716
case MUS_CMD:
MusicCMD_Start(music->data.cmd);
break;
717
718
#endif
#ifdef WAV_MUSIC
719
720
721
case MUS_WAV:
WAVStream_Start(music->data.wave);
break;
722
#endif
723
#if defined(MOD_MUSIC) || defined(LIBMIKMOD_MUSIC)
724
725
case MUS_MOD:
Player_Start(music->data.module);
726
727
/* Player_SetVolume() does nothing before Player_Start() */
music_internal_initialize_volume();
728
break;
729
730
#endif
#ifdef MID_MUSIC
731
case MUS_MID:
732
#ifdef USE_NATIVE_MIDI
733
734
735
if ( native_midi_ok ) {
native_midi_start(music->data.nativemidi);
} MIDI_ELSE
736
#endif
737
#ifdef USE_TIMIDITY_MIDI
738
739
740
if ( timidity_ok ) {
Timidity_Start(music->data.midi);
}
741
#endif
742
break;
743
#endif
744
#ifdef OGG_MUSIC
745
746
747
case MUS_OGG:
OGG_play(music->data.ogg);
break;
748
#endif
749
#ifdef MP3_MUSIC
750
751
752
case MUS_MP3:
SMPEG_enableaudio(music->data.mp3,1);
SMPEG_enablevideo(music->data.mp3,0);
753
SMPEG_play(music_playing->data.mp3);
754
break;
755
#endif
756
757
758
759
default:
Mix_SetError("Can't play unknown music type");
retval = -1;
break;
760
}
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
/* 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)
781
{
782
783
int retval;
784
785
/* Don't play null pointers :-) */
if ( music == NULL ) {
786
Mix_SetError("music parameter was NULL");
787
788
return(-1);
}
789
790
791
792
793
794
/* Setup the data */
if ( ms ) {
music->fading = MIX_FADING_IN;
} else {
music->fading = MIX_NO_FADING;
795
}
796
797
music->fade_step = 0;
music->fade_steps = ms/ms_per_step;
798
799
800
801
802
803
804
805
/* 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();
806
}
807
music_active = 1;
808
music_loops = loops;
809
810
811
812
813
814
815
816
817
818
819
820
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);
821
822
}
823
824
/* Set the playing music position */
int music_internal_position(double position)
825
{
826
827
828
int retval = 0;
switch (music_playing->type) {
829
#if defined(MOD_MUSIC) || defined(LIBMIKMOD_MUSIC)
830
831
832
case MUS_MOD:
Player_SetPosition((UWORD)position);
break;
833
834
#endif
#ifdef OGG_MUSIC
835
836
837
case MUS_OGG:
OGG_jump_to_time(music_playing->data.ogg, position);
break;
838
839
#endif
#ifdef MP3_MUSIC
840
case MUS_MP3:
841
if ( position > 0.0 ) {
842
SMPEG_skip(music_playing->data.mp3, position);
843
844
845
} else {
SMPEG_rewind(music_playing->data.mp3);
SMPEG_play(music_playing->data.mp3);
846
}
847
848
849
850
851
852
break;
#endif
default:
/* TODO: Implement this for other music backends */
retval = -1;
break;
853
}
854
return(retval);
855
}
856
int Mix_SetMusicPosition(double position)
857
{
858
859
860
861
862
863
864
int retval;
SDL_LockAudio();
if ( music_playing ) {
retval = music_internal_position(position);
if ( retval < 0 ) {
Mix_SetError("Position not implemented for music type");
865
}
866
867
868
} else {
Mix_SetError("Music isn't playing");
retval = -1;
869
}
870
SDL_UnlockAudio();
871
872
return(retval);
873
874
}
875
876
877
878
879
880
881
882
883
884
/* 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);
}
}
885
/* Set the music volume */
886
static void music_internal_volume(int volume)
887
{
888
switch (music_playing->type) {
889
#ifdef CMD_MUSIC
890
891
892
case MUS_CMD:
MusicCMD_SetVolume(volume);
break;
893
894
#endif
#ifdef WAV_MUSIC
895
896
897
case MUS_WAV:
WAVStream_SetVolume(volume);
break;
898
#endif
899
#if defined(MOD_MUSIC) || defined(LIBMIKMOD_MUSIC)
900
901
902
case MUS_MOD:
Player_SetVolume((SWORD)volume);
break;
903
904
#endif
#ifdef MID_MUSIC
905
case MUS_MID:
906
#ifdef USE_NATIVE_MIDI
907
908
909
if ( native_midi_ok ) {
native_midi_setvolume(volume);
} MIDI_ELSE
910
#endif
911
#ifdef USE_TIMIDITY_MIDI
912
913
914
if ( timidity_ok ) {
Timidity_SetVolume(volume);
}
915
#endif
916
break;
917
#endif
918
#ifdef OGG_MUSIC
919
920
921
case MUS_OGG:
OGG_setvolume(music_playing->data.ogg, volume);
break;
922
#endif
923
#ifdef MP3_MUSIC
924
925
926
case MUS_MP3:
SMPEG_setvolume(music_playing->data.mp3,(int)(((float)volume/(float)MIX_MAX_VOLUME)*100.0));
break;
927
#endif
928
929
930
931
932
933
934
935
936
937
938
939
default:
/* Unknown music type?? */
break;
}
}
int Mix_VolumeMusic(int volume)
{
int prev_volume;
prev_volume = music_volume;
if ( volume < 0 ) {
return prev_volume;
940
}
941
942
943
944
945
946
947
948
949
if ( volume > SDL_MIX_MAXVOLUME ) {
volume = SDL_MIX_MAXVOLUME;
}
music_volume = volume;
SDL_LockAudio();
if ( music_playing ) {
music_internal_volume(music_volume);
}
SDL_UnlockAudio();
950
951
952
return(prev_volume);
}
953
954
/* Halt playing of music */
static void music_internal_halt(void)
955
{
956
switch (music_playing->type) {
957
#ifdef CMD_MUSIC
958
case MUS_CMD:
959
960
MusicCMD_Stop(music_playing->data.cmd);
break;
961
962
#endif
#ifdef WAV_MUSIC
963
case MUS_WAV:
964
965
WAVStream_Stop();
break;
966
#endif
967
#if defined(MOD_MUSIC) || defined(LIBMIKMOD_MUSIC)
968
case MUS_MOD:
969
970
Player_Stop();
break;
971
972
#endif
#ifdef MID_MUSIC
973
case MUS_MID:
974
975
976
#ifdef USE_NATIVE_MIDI
if ( native_midi_ok ) {
native_midi_stop();
977
} MIDI_ELSE
978
#endif
979
#ifdef USE_TIMIDITY_MIDI
980
981
982
if ( timidity_ok ) {
Timidity_Stop();
}
983
#endif
984
break;
985
#endif
986
#ifdef OGG_MUSIC
987
case MUS_OGG:
988
989
990
OGG_stop(music_playing->data.ogg);
break;
#endif
991
#ifdef MP3_MUSIC
992
case MUS_MP3:
993
994
SMPEG_stop(music_playing->data.mp3);
break;
995
#endif
996
default:
997
998
999
1000
/* Unknown music type?? */
return;
}
music_playing->fading = MIX_NO_FADING;