This software is provided 'as-is', without any express or implied

warranty. In no event will the authors be held liable for any damages

arising from the use of this software.

Permission is granted to anyone to use this software for any purpose,

including commercial applications, and to alter it and redistribute it

freely, subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not

claim that you wrote the original software. If you use this software

in a product, an acknowledgment in the product documentation would be

appreciated but is not required.

2. Altered source versions must be plainly marked as such, and must not be

misrepresented as being the original software.

3. This notice may not be removed or altered from any source distribution.

*/

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "SDL_mutex.h"

#include "SDL_endian.h"

#include "load_aiff.h"

#include "load_voc.h"

#include "dynamic_mod.h"

#include "dynamic_mp3.h"

#include "dynamic_ogg.h"

#define __MIX_INTERNAL_EFFECT__

#include "effects_internal.h"

#define RIFF 0x46464952 /* "RIFF" */

#define WAVE 0x45564157 /* "WAVE" */

#define FORM 0x4d524f46 /* "FORM" */

#define OGGS 0x5367674f /* "OggS" */

#define CREA 0x61657243 /* "Crea" */

#define FLAC 0x43614C66 /* "fLaC" */

static int audio_opened = 0;

static SDL_AudioSpec mixer;

typedef struct _Mix_effectinfo

{

Mix_EffectFunc_t callback;

Mix_EffectDone_t done_callback;

void *udata;

struct _Mix_effectinfo *next;

} effect_info;

Mix_Chunk *chunk;

int playing;

int paused;

Uint8 *samples;

int volume;

int looping;

int tag;

Uint32 expire;

Uint32 start_time;

Mix_Fading fading;

int fade_volume;

int fade_volume_reset;

Uint32 fade_length;

Uint32 ticks_fade;

effect_info *effects;

static effect_info *posteffects = NULL;

/* Support for hooking into the mixer callback system */

static void (*mix_postmix)(void *udata, Uint8 *stream, int len) = NULL;

/* rcg07062001 callback to alert when channels are done playing. */

static void (*channel_done_callback)(int channel) = NULL;

/* Music function declarations */

extern int open_music(SDL_AudioSpec *mixer);

extern void close_music(void);

extern void music_mixer(void *udata, Uint8 *stream, int len);

static void (*mix_music)(void *udata, Uint8 *stream, int len) = music_mixer;

/* rcg06042009 report available decoders at runtime. */

static const char **chunk_decoders = NULL;

static int num_decoders = 0;

/* Semicolon-separated SoundFont paths */

#ifdef MID_MUSIC

extern char* soundfont_paths;

#endif

}

const char *Mix_GetChunkDecoder(int index)

{

if ((index < 0) || (index >= num_decoders)) {

return NULL;

}

return(chunk_decoders[index]);

}

static void add_chunk_decoder(const char *decoder)

{

if (ptr == NULL) {

return; /* oh well, go on without it. */

}

chunk_decoders = (const char **) ptr;

chunk_decoders[num_decoders++] = decoder;

/* rcg06192001 get linked library's version. */

const SDL_version *Mix_Linked_Version(void)

{

static SDL_version linked_version;

SDL_MIXER_VERSION(&linked_version);

return(&linked_version);

}

static int initialized = 0;

int Mix_Init(int flags)

{

if ((initialized & MIX_INIT_FLUIDSYNTH) || Mix_InitFluidSynth() == 0) {

result |= MIX_INIT_FLUIDSYNTH;

}

}

if (flags & MIX_INIT_FLAC) {

if ((initialized & MIX_INIT_FLAC) || Mix_InitFLAC() == 0) {

result |= MIX_INIT_FLAC;

}

#endif

}

if (flags & MIX_INIT_MODPLUG) {

#ifdef MODPLUG_MUSIC

if ((initialized & MIX_INIT_MODPLUG) || Mix_InitModPlug() == 0) {

result |= MIX_INIT_MODPLUG;

}

#else

Mix_SetError("Mixer not built with MOD modplug support");

}

if (flags & MIX_INIT_MOD) {

if ((initialized & MIX_INIT_MOD) || Mix_InitMOD() == 0) {

result |= MIX_INIT_MOD;

}

}

if (flags & MIX_INIT_MP3) {

if ((initialized & MIX_INIT_MP3) || Mix_InitMP3() == 0) {

result |= MIX_INIT_MP3;

}

}

if (flags & MIX_INIT_OGG) {

if ((initialized & MIX_INIT_OGG) || Mix_InitOgg() == 0) {

result |= MIX_INIT_OGG;

}

}

initialized |= result;

}

void Mix_Quit()

{

if (initialized & MIX_INIT_FLUIDSYNTH) {

Mix_QuitFluidSynth();

}

if (initialized & MIX_INIT_FLAC) {

Mix_QuitFLAC();

}

#ifdef MODPLUG_MUSIC

if (initialized & MIX_INIT_MODPLUG) {

Mix_QuitModPlug();

}

#endif

if (initialized & MIX_INIT_MOD) {

Mix_QuitMOD();

}

#endif

#ifdef MP3_MUSIC

if (initialized & MIX_INIT_MP3) {

Mix_QuitMP3();

}

#endif

#ifdef OGG_MUSIC

if (initialized & MIX_INIT_OGG) {

Mix_QuitOgg();

}

if (soundfont_paths) {

SDL_free(soundfont_paths);

}

/*

* rcg06122001 Cleanup effect callbacks.

* MAKE SURE SDL_LockAudio() is called before this (or you're in the

* audio callback).

*/

static void _Mix_channel_done_playing(int channel)

if (channel_done_callback) {

channel_done_callback(channel);

}

/*

* Call internal function directly, to avoid locking audio from

* inside audio callback.

*/

_Mix_remove_all_effects(channel, &mix_channel[channel].effects);

}

static void *Mix_DoEffects(int chan, void *snd, int len)

{

int posteffect = (chan == MIX_CHANNEL_POST);

effect_info *e = ((posteffect) ? posteffects : mix_channel[chan].effects);

void *buf = snd;

if (e != NULL) { /* are there any registered effects? */

/* if this is the postmix, we can just overwrite the original. */

if (!posteffect) {

buf = SDL_malloc(len);

if (buf == NULL) {

return(snd);

}

}

for (; e != NULL; e = e->next) {

if (e->callback != NULL) {

e->callback(chan, buf, len, e->udata);

}

}

}

/* be sure to SDL_free() the return value if != snd ... */

return(buf);

}

/* Mixing function */

static void mix_channels(void *udata, Uint8 *stream, int len)

{

Uint8 *mix_input;

int i, mixable, volume = SDL_MIX_MAXVOLUME;

Uint32 sdl_ticks;

/* Mix the music (must be done before the channels are added) */

if ( music_active || (mix_music != music_mixer) ) {

mix_music(music_data, stream, len);

}

/* Mix any playing channels... */

sdl_ticks = SDL_GetTicks();

for ( i=0; i<num_channels; ++i ) {

if ( mix_channel[i].expire > 0 && mix_channel[i].expire < sdl_ticks ) {

/* Expiration delay for that channel is reached */

mix_channel[i].playing = 0;

mix_channel[i].looping = 0;

mix_channel[i].fading = MIX_NO_FADING;

mix_channel[i].expire = 0;

_Mix_channel_done_playing(i);

} else if ( mix_channel[i].fading != MIX_NO_FADING ) {

Uint32 ticks = sdl_ticks - mix_channel[i].ticks_fade;

Mix_Volume(i, mix_channel[i].fade_volume_reset); /* Restore the volume */

if( mix_channel[i].fading == MIX_FADING_OUT ) {

mix_channel[i].playing = 0;

mix_channel[i].looping = 0;

mix_channel[i].expire = 0;

_Mix_channel_done_playing(i);

}

mix_channel[i].fading = MIX_NO_FADING;

} else {

Mix_Volume(i, (mix_channel[i].fade_volume * (mix_channel[i].fade_length-ticks))

/ mix_channel[i].fade_length );

} else {

Mix_Volume(i, (mix_channel[i].fade_volume * ticks) / mix_channel[i].fade_length );

}

}

}

if ( mix_channel[i].playing > 0 ) {

int index = 0;

int remaining = len;

while (mix_channel[i].playing > 0 && index < len) {

remaining = len - index;

volume = (mix_channel[i].volume*mix_channel[i].chunk->volume) / MIX_MAX_VOLUME;

mixable = mix_channel[i].playing;

if ( mixable > remaining ) {

mixable = remaining;

}

mix_input = Mix_DoEffects(i, mix_channel[i].samples, mixable);

SDL_MixAudio(stream+index,mix_input,mixable,volume);

if (mix_input != mix_channel[i].samples)

SDL_free(mix_input);

mix_channel[i].samples += mixable;

mix_channel[i].playing -= mixable;

index += mixable;

/* rcg06072001 Alert app if channel is done playing. */

if (!mix_channel[i].playing && !mix_channel[i].looping) {

_Mix_channel_done_playing(i);

}

}

/* If looping the sample and we are at its end, make sure

we will still return a full buffer */

while ( mix_channel[i].looping && index < len ) {

int alen = mix_channel[i].chunk->alen;

remaining = len - index;

if (remaining > alen) {

remaining = alen;

}

mix_input = Mix_DoEffects(i, mix_channel[i].chunk->abuf, remaining);

SDL_MixAudio(stream+index, mix_input, remaining, volume);

if (mix_input != mix_channel[i].chunk->abuf)

SDL_free(mix_input);

if (mix_channel[i].looping > 0) {

--mix_channel[i].looping;

}

mix_channel[i].samples = mix_channel[i].chunk->abuf + remaining;

mix_channel[i].playing = mix_channel[i].chunk->alen - remaining;

index += remaining;

}

if ( ! mix_channel[i].playing && mix_channel[i].looping ) {

if (mix_channel[i].looping > 0) {

--mix_channel[i].looping;

}

mix_channel[i].samples = mix_channel[i].chunk->abuf;

mix_channel[i].playing = mix_channel[i].chunk->alen;

}

}

}

}

/* rcg06122001 run posteffects... */

Mix_DoEffects(MIX_CHANNEL_POST, stream, len);

if ( mix_postmix ) {

mix_postmix(mix_postmix_data, stream, len);

}

}

static void PrintFormat(char *title, SDL_AudioSpec *fmt)

{

printf("%s: %d bit %s audio (%s) at %u Hz\n", title, (fmt->format&0xFF),

(fmt->format&0x8000) ? "signed" : "unsigned",

(fmt->channels > 2) ? "surround" :

(fmt->channels > 1) ? "stereo" : "mono", fmt->freq);

int i;

SDL_AudioSpec desired;

/* If the mixer is already opened, increment open count */

if ( audio_opened ) {

if ( format == mixer.format && nchannels == mixer.channels ) {

++audio_opened;

return(0);

}

while ( audio_opened ) {

Mix_CloseAudio();

}

}

/* Set the desired format and frequency */

desired.freq = frequency;

desired.format = format;

desired.channels = nchannels;

desired.samples = chunksize;

desired.callback = mix_channels;

desired.userdata = NULL;

/* Accept nearly any audio format */

if ( SDL_OpenAudio(&desired, &mixer) < 0 ) {

return(-1);

}

#endif

/* Initialize the music players */

if ( open_music(&mixer) < 0 ) {

SDL_CloseAudio();

return(-1);

}

num_channels = MIX_CHANNELS;

mix_channel = (struct _Mix_Channel *) SDL_malloc(num_channels * sizeof(struct _Mix_Channel));

/* Clear out the audio channels */

for ( i=0; i<num_channels; ++i ) {

mix_channel[i].chunk = NULL;

mix_channel[i].playing = 0;

mix_channel[i].looping = 0;

mix_channel[i].volume = SDL_MIX_MAXVOLUME;

mix_channel[i].fade_volume = SDL_MIX_MAXVOLUME;

mix_channel[i].fade_volume_reset = SDL_MIX_MAXVOLUME;

mix_channel[i].fading = MIX_NO_FADING;

mix_channel[i].tag = -1;

mix_channel[i].expire = 0;

mix_channel[i].effects = NULL;

mix_channel[i].paused = 0;

}

Mix_VolumeMusic(SDL_MIX_MAXVOLUME);

_Mix_InitEffects();

/* This list is (currently) decided at build time. */

add_chunk_decoder("WAVE");

add_chunk_decoder("AIFF");

add_chunk_decoder("VOC");

#endif

#ifdef FLAC_MUSIC

#if defined(MP3_MUSIC) || defined(MP3_MAD_MUSIC)

add_chunk_decoder("MP3");

#endif

audio_opened = 1;

SDL_PauseAudio(0);

return(0);

}

/* Dynamically change the number of channels managed by the mixer.

If decreasing the number of channels, the upper channels are

stopped.

*/

int Mix_AllocateChannels(int numchans)

{

if ( numchans<0 || numchans==num_channels )

return(num_channels);

if ( numchans < num_channels ) {

/* Stop the affected channels */

int i;

for(i=numchans; i < num_channels; i++) {

Mix_UnregisterAllEffects(i);

Mix_HaltChannel(i);

}

}

SDL_LockAudio();

mix_channel = (struct _Mix_Channel *) SDL_realloc(mix_channel, numchans * sizeof(struct _Mix_Channel));

if ( numchans > num_channels ) {

/* Initialize the new channels */

int i;

for(i=num_channels; i < numchans; i++) {

mix_channel[i].chunk = NULL;

mix_channel[i].playing = 0;

mix_channel[i].looping = 0;

mix_channel[i].volume = SDL_MIX_MAXVOLUME;

mix_channel[i].fade_volume = SDL_MIX_MAXVOLUME;

mix_channel[i].fade_volume_reset = SDL_MIX_MAXVOLUME;

mix_channel[i].fading = MIX_NO_FADING;

mix_channel[i].tag = -1;

mix_channel[i].expire = 0;

mix_channel[i].effects = NULL;

mix_channel[i].paused = 0;

}

}

num_channels = numchans;

SDL_UnlockAudio();

return(num_channels);

}

/* Return the actual mixer parameters */

int Mix_QuerySpec(int *frequency, Uint16 *format, int *channels)

{

if ( audio_opened ) {

if ( frequency ) {

*frequency = mixer.freq;

}

if ( format ) {

*format = mixer.format;

}

if ( channels ) {

*channels = mixer.channels;

}

}

return(audio_opened);

}

static int detect_mp3(Uint8 *magic)

{

if ( strncmp((char *)magic, "ID3", 3) == 0 ) {

return 1;

}

/* Detection code lifted from SMPEG */

if(((magic[0] & 0xff) != 0xff) || // No sync bits

((magic[1] & 0xf0) != 0xf0) || //

((magic[2] & 0xf0) == 0x00) || // Bitrate is 0

((magic[2] & 0xf0) == 0xf0) || // Bitrate is 15

((magic[2] & 0x0c) == 0x0c) || // Frequency is 3

((magic[1] & 0x06) == 0x00)) { // Layer is 4

return(0);

}

return 1;

}

/* Load a wave file */

Mix_Chunk *Mix_LoadWAV_RW(SDL_RWops *src, int freesrc)

{

Uint32 magic;

Mix_Chunk *chunk;

SDL_AudioSpec wavespec, *loaded;

SDL_AudioCVT wavecvt;

int samplesize;

/* rcg06012001 Make sure src is valid */

if ( ! src ) {

SDL_SetError("Mix_LoadWAV_RW with NULL src");

return(NULL);

}

/* Make sure audio has been opened */

if ( ! audio_opened ) {

SDL_SetError("Audio device hasn't been opened");

SDL_RWclose(src);

}

return(NULL);

}

/* Allocate the chunk memory */

chunk = (Mix_Chunk *)SDL_malloc(sizeof(Mix_Chunk));

if ( chunk == NULL ) {

SDL_SetError("Out of memory");

if ( freesrc ) {

SDL_RWclose(src);

}

return(NULL);

}

/* Find out what kind of audio file this is */

magic = SDL_ReadLE32(src);

/* Seek backwards for compatibility with older loaders */

SDL_RWseek(src, -(int)sizeof(Uint32), RW_SEEK_CUR);

switch (magic) {

case WAVE:

case RIFF:

loaded = SDL_LoadWAV_RW(src, freesrc, &wavespec,

(Uint8 **)&chunk->abuf, &chunk->alen);

break;

case FORM:

loaded = Mix_LoadAIFF_RW(src, freesrc, &wavespec,

(Uint8 **)&chunk->abuf, &chunk->alen);

break;

case OGGS:

loaded = Mix_LoadOGG_RW(src, freesrc, &wavespec,

(Uint8 **)&chunk->abuf, &chunk->alen);

break;

#endif

#ifdef FLAC_MUSIC

case FLAC:

loaded = Mix_LoadFLAC_RW(src, freesrc, &wavespec,

(Uint8 **)&chunk->abuf, &chunk->alen);

break;

case CREA:

loaded = Mix_LoadVOC_RW(src, freesrc, &wavespec,

(Uint8 **)&chunk->abuf, &chunk->alen);

break;

default:

#if defined(MP3_MUSIC) || defined(MP3_MAD_MUSIC)

if (detect_mp3((Uint8*)&magic))

{

/* note: send a copy of the mixer spec */

wavespec = mixer;

loaded = Mix_LoadMP3_RW(src, freesrc, &wavespec,

(Uint8 **)&chunk->abuf, &chunk->alen);

break;

}

#endif

SDL_SetError("Unrecognized sound file type");

if ( freesrc ) {

SDL_RWclose(src);

}

loaded = NULL;

break;

}

if ( !loaded ) {

/* The individual loaders have closed src if needed */

SDL_free(chunk);

return(NULL);

}

PrintFormat("Audio device", &mixer);

PrintFormat("-- Wave file", &wavespec);

#endif

/* Build the audio converter and create conversion buffers */

if ( wavespec.format != mixer.format ||

wavespec.channels != mixer.channels ||

wavespec.freq != mixer.freq ) {

if ( SDL_BuildAudioCVT(&wavecvt,

wavespec.format, wavespec.channels, wavespec.freq,

mixer.format, mixer.channels, mixer.freq) < 0 ) {

SDL_free(chunk->abuf);

SDL_free(chunk);

return(NULL);

}

samplesize = ((wavespec.format & 0xFF)/8)*wavespec.channels;

wavecvt.len = chunk->alen & ~(samplesize-1);

wavecvt.buf = (Uint8 *)SDL_calloc(1, wavecvt.len*wavecvt.len_mult);

if ( wavecvt.buf == NULL ) {

SDL_SetError("Out of memory");

SDL_free(chunk->abuf);

SDL_free(chunk);

return(NULL);

}

SDL_free(chunk->abuf);

/* Run the audio converter */

if ( SDL_ConvertAudio(&wavecvt) < 0 ) {

SDL_free(wavecvt.buf);

SDL_free(chunk);

return(NULL);

}

chunk->abuf = wavecvt.buf;

chunk->alen = wavecvt.len_cvt;

}

chunk->allocated = 1;

chunk->volume = MIX_MAX_VOLUME;

return(chunk);

}

/* Load a wave file of the mixer format from a memory buffer */

Mix_Chunk *Mix_QuickLoad_WAV(Uint8 *mem)

{

Mix_Chunk *chunk;

Uint8 magic[4];

/* Make sure audio has been opened */

if ( ! audio_opened ) {

SDL_SetError("Audio device hasn't been opened");

return(NULL);

}

/* Allocate the chunk memory */

chunk = (Mix_Chunk *)SDL_calloc(1,sizeof(Mix_Chunk));

if ( chunk == NULL ) {

SDL_SetError("Out of memory");

return(NULL);

}

/* Essentially just skip to the audio data (no error checking - fast) */

chunk->allocated = 0;

mem += 12; /* WAV header */

do {

mem += 4;

chunk->alen = ((mem[3]<<24)|(mem[2]<<16)|(mem[1]<<8)|(mem[0]));

mem += 4;

chunk->abuf = mem;

mem += chunk->alen;

} while ( memcmp(magic, "data", 4) != 0 );

chunk->volume = MIX_MAX_VOLUME;