/*

MIXERLIB: An audio mixer library based on the SDL library

Copyright (C) 1997-1999 Sam Lantinga

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.

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.

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

Sam Lantinga

5635-34 Springhouse Dr.

Pleasanton, CA 94588 (USA)

slouken@devolution.com

*/

#include <stdlib.h>

#include <string.h>

#include <SDL/SDL_endian.h>

#include <SDL/SDL_audio.h>

#include "mixer.h"

/* 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

#include "mikmod.h"

#endif

#ifdef MID_MUSIC

#include "timidity.h"

#endif

#ifdef MP3_MUSIC

#include <smpeg/smpeg.h>

static SDL_AudioSpec used_mixer;

#endif

int music_active = 1;

static int music_stopped = 0;

static int music_loops = 0;

static char *music_cmd = NULL;

static int samplesize;

static Mix_Music *music_playing = 0;

static int music_volume;

static int music_swap8;

static int music_swap16;

struct _Mix_Music {

};

static int timidity_ok;

static void lowlevel_halt(void);

/* Mixing function */

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

{

int i;

if ( music_playing ) {

if ( music_stopped ) {

/* To avoid concurrency problems and the use of mutexes,

the music is always stopped from the sound thread */

lowlevel_halt(); /* This function sets music_playing to NULL */

return;

}

if ( music_playing->fading != MIX_NO_FADING ) {

Uint32 ticks = SDL_GetTicks() - music_playing->ticks_fade;

if( ticks > music_playing->fade_length ) {

if ( music_playing->fading == MIX_FADING_OUT ) {

music_volume = music_playing->fade_volume;

music_playing->fading = MIX_NO_FADING;

lowlevel_halt();

return;

}

music_playing->fading = MIX_NO_FADING;

} else {

if ( music_playing->fading == MIX_FADING_OUT ) {

Mix_VolumeMusic((music_playing->fade_volume * (music_playing->fade_length-ticks))

/ music_playing->fade_length);

} else { /* Fading in */

Mix_VolumeMusic((music_playing->fade_volume * ticks)

/ music_playing->fade_length);

}

}

}

switch (music_playing->type) {

#ifdef CMD_MUSIC

case MUS_CMD:

/* The playing is done externally */

break;

#endif

#ifdef WAV_MUSIC

case MUS_WAV:

WAVStream_PlaySome(stream, len);

break;

#endif

#ifdef MOD_MUSIC

case MUS_MOD:

VC_WriteBytes((SBYTE *)stream, len);

if ( music_swap8 ) {

Uint8 *dst;

dst = stream;

for ( i=len; i; --i ) {

*dst++ ^= 0x80;

}

} else

if ( music_swap16 ) {

Uint8 *dst, tmp;

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

case MUS_MID:

Timidity_PlaySome(stream, len/samplesize);

break;

#endif

#ifdef MP3_MUSIC

case MUS_MP3:

SMPEG_playAudio(music_playing->data.mp3, stream, len);

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: {

SDL_SetError("Unknown hardware audio format");

++music_error;

}

}

if ( mixer->channels > 1 ) {

if ( mixer->channels > 2 ) {

SDL_SetError("Hardware uses more channels than mixer");

++music_error;

}

md_mode |= DMODE_STEREO;

}

samplesize = mixer->size/mixer->samples;

md_mixfreq = mixer->freq;

md_device = 0;

md_volume = 96;

md_musicvolume = 128;

md_sndfxvolume = 128;

md_pansep = 128;

md_reverb = 0;

MikMod_RegisterAllLoaders();

MikMod_RegisterAllDrivers();

if ( MikMod_Init() ) {

SDL_SetError("%s", _mm_errmsg[_mm_errno]);

++music_error;

}

#endif

#ifdef MID_MUSIC

if ( Timidity_Init(mixer->freq,

mixer->format, mixer->channels, mixer->samples) == 0 ) {

timidity_ok = 1;

} else {

timidity_ok = 0;

}

#endif

#ifdef MP3_MUSIC

/* Keep a copy of the mixer */

used_mixer = *mixer;

#endif

music_playing = 0;

music_stopped = 0;

if ( music_error ) {

return(-1);

}

Mix_VolumeMusic(SDL_MIX_MAXVOLUME);

return(0);

}

/* Load a music file */

Mix_Music *Mix_LoadMUS(const char *file)

{

FILE *fp;

unsigned char magic[5];

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);

}

SDL_SetError("Couldn't read from '%s'", file);

return(NULL);

}

magic[4] = '\0';

fclose(fp);

/* Allocate memory for the music structure */

music = (Mix_Music *)malloc(sizeof(Mix_Music));

if ( music == NULL ) {

SDL_SetError("Out of memory");

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"

*/

if ( (strcmp(magic, "RIFF") == 0) || (strcmp(magic, "FORM") == 0) ) {

music->type = MUS_WAV;

music->data.wave = WAVStream_LoadSong(file, magic);

if ( music->data.wave == NULL ) {

music->error = 1;

}

} else

#endif

#ifdef MID_MUSIC

/* MIDI files have the magic four bytes "MThd" */

if ( strcmp(magic, "MThd") == 0 ) {

music->type = MUS_MID;

if ( timidity_ok ) {

music->data.midi = Timidity_LoadSong((char *)file);

if ( music->data.midi == NULL ) {

SDL_SetError("%s", Timidity_Error());

music->error = 1;

}

}

else {

SDL_SetError("%s", Timidity_Error());

music->error = 1;

}

} else

#endif

#ifdef MP3_MUSIC

if ( magic[0]==0xFF && (magic[1]&0xF0)==0xF0) {

SMPEG_Info info;

music->type = MUS_MP3;

music->data.mp3 = SMPEG_new(file, &info, 0);

if(!info.has_audio){

SDL_SetError("MPEG file does not have any audio stream.");

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 ) {

SDL_SetError("%s", _mm_errmsg[_mm_errno]);

music->error = 1;

}

} else

#endif

{

SDL_SetError("Unrecognized music format");

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 ) {

/* Caution: If music is playing, mixer will crash */

if ( music == music_playing && !music_stopped ) {

if ( music->fading == MIX_FADING_OUT ) {

/* Wait for the fade out to finish */

while(music->fading == MIX_FADING_OUT)

SDL_Delay(100);

} else {

Mix_HaltMusic(); /* Stop it immediately */

}

}

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:

Timidity_FreeSong(music->data.midi);

break;

#endif

#ifdef MP3_MUSIC

case MUS_MP3:

SMPEG_delete(music->data.mp3);

break;

#endif

default:

/* Unknown music type?? */

break;

}

free(music);

}

}

/* Play a music chunk. Returns 0, or -1 if there was an error.

*/

int Mix_PlayMusic(Mix_Music *music, int loops)

{

/* Don't play null pointers :-) */

if ( music == NULL ) {

return(-1);

}

/* If the current music is fading out, wait for the fade to complete */

while ( music_playing && !music_stopped && music_playing->fading==MIX_FADING_OUT ) {

SDL_Delay(100);

}

switch (music->type) {

#ifdef CMD_MUSIC

case MUS_CMD:

MusicCMD_SetVolume(music_volume);

MusicCMD_Start(music->data.cmd);

break;

#endif

#ifdef WAV_MUSIC

case MUS_WAV:

WAVStream_SetVolume(music_volume);

WAVStream_Start(music->data.wave);

break;

#endif

#ifdef MOD_MUSIC

case MUS_MOD:

Player_SetVolume(music_volume);

Player_Start(music->data.module);

Player_SetPosition(0);

break;

#endif

#ifdef MID_MUSIC

case MUS_MID:

Timidity_SetVolume(music_volume);

Timidity_Start(music->data.midi);

break;

#endif

#ifdef MP3_MUSIC

case MUS_MP3:

SMPEG_enableaudio(music->data.mp3,1);

SMPEG_enablevideo(music->data.mp3,0);

SMPEG_setvolume(music->data.mp3,((float)music_volume/(float)MIX_MAX_VOLUME)*100.0);

SMPEG_loop(music->data.mp3, loops);

SMPEG_play(music->data.mp3);

break;

#endif

default:

/* Unknown music type?? */

return(-1);

}

music_active = 1;

music_stopped = 0;

music_playing = music;

music_playing->fading = MIX_NO_FADING;

return(0);

}

/* Fade in a music over "ms" milliseconds */

int Mix_FadeInMusic(Mix_Music *music, int loops, int ms)

{

if ( music && music_volume > 0 ) { /* No need to fade if we can't hear it */

music->fade_volume = music_volume;

music_volume = 0;

if(Mix_PlayMusic(music,loops)<0)

return(-1);

music_playing->fading = MIX_FADING_IN;

music_playing->fade_length = ms;

music_playing->ticks_fade = SDL_GetTicks();

}

return(0);

}

/* Set the music volume */

int Mix_VolumeMusic(int volume)

{

int prev_volume;

prev_volume = music_volume;

if ( volume < 0 ) {

volume = 0;

}

if ( volume > SDL_MIX_MAXVOLUME ) {

volume = SDL_MIX_MAXVOLUME;

}

music_volume = volume;

if ( music_playing && !music_stopped ) {

switch (music_playing->type) {

#ifdef CMD_MUSIC

case MUS_CMD:

MusicCMD_SetVolume(music_volume);

break;

#endif

#ifdef WAV_MUSIC

case MUS_WAV:

WAVStream_SetVolume(music_volume);

break;

#endif

#ifdef MOD_MUSIC

case MUS_MOD:

Player_SetVolume(music_volume);

break;

#endif

#ifdef MID_MUSIC

case MUS_MID:

Timidity_SetVolume(music_volume);

break;

#endif

#ifdef MP3_MUSIC

case MUS_MP3:

SMPEG_setvolume(music_playing->data.mp3,((float)music_volume/(float)MIX_MAX_VOLUME)*100.0);

break;

#endif

default:

/* Unknown music type?? */

break;

}

}

return(prev_volume);

}

static void lowlevel_halt(void)

{

switch (music_playing->type) {

#ifdef CMD_MUSIC

case MUS_CMD:

MusicCMD_Stop(music_playing->data.cmd);

break;

#endif

#ifdef WAV_MUSIC

case MUS_WAV:

WAVStream_Stop();

break;

#endif

#ifdef MOD_MUSIC

case MUS_MOD:

Player_Stop();

break;

#endif

#ifdef MID_MUSIC

case MUS_MID:

Timidity_Stop();

break;

#endif

#ifdef MP3_MUSIC

case MUS_MP3:

SMPEG_stop(music_playing->data.mp3);

break;

#endif

default:

/* Unknown music type?? */

return;

}

if(music_playing->fading != MIX_NO_FADING) /* Restore volume */

music_volume = music_playing->fade_volume;

music_playing->fading = MIX_NO_FADING;

music_playing = 0;

music_active = 0;

music_stopped = 0;

}

/* Halt playing of music */

int Mix_HaltMusic(void)

{

if ( music_playing && !music_stopped ) {

/* Mark the music to be stopped from the sound thread */

music_stopped = 1;

/* Wait for it to be actually stopped */

while ( music_playing )

SDL_Delay(10);

}

return(0);

}

/* Progressively stop the music */

int Mix_FadeOutMusic(int ms)

{

if ( music_playing && !music_stopped && music_playing->fading==MIX_NO_FADING ) {

if ( music_volume>0 ) {

music_playing->fading = MIX_FADING_OUT;

music_playing->fade_volume = music_volume;

music_playing->fade_length = ms;

music_playing->ticks_fade = SDL_GetTicks();

return(1);

}

}

return(0);

}

Mix_Fading Mix_FadingMusic(void)

{

if( music_playing && !music_stopped )

return music_playing->fading;

return MIX_NO_FADING;

}

/* Pause/Resume the music stream */

void Mix_PauseMusic(void)

{

if ( music_playing && !music_stopped ) {

switch ( music_playing->type ) {

#ifdef CMD_MUSIC

case MUS_CMD:

MusicCMD_Pause(music_playing->data.cmd);

break;

#endif

#ifdef MP3_MUSIC

case MUS_MP3:

SMPEG_pause(music_playing->data.mp3);

break;

#endif

}

}

music_active = 0;

}

void Mix_ResumeMusic(void)

{

if ( music_playing && !music_stopped ) {

switch ( music_playing->type ) {

#ifdef CMD_MUSIC

case MUS_CMD:

MusicCMD_Resume(music_playing->data.cmd);

break;

#endif

#ifdef MP3_MUSIC

case MUS_MP3:

SMPEG_pause(music_playing->data.mp3);

break;

#endif

}

}

music_active = 1;

}

void Mix_RewindMusic(void)

{

if ( music_playing && !music_stopped ) {

switch ( music_playing->type ) {

#ifdef MP3_MUSIC

case MUS_MP3:

SMPEG_rewind(music_playing->data.mp3);

break;

#endif

/* TODO: Implement this for other music backends */

}

}

}

/* Check the status of the music */

int Mix_PlayingMusic(void)

{

if ( music_playing && !music_stopped ) {

switch (music_playing->type) {

#ifdef CMD_MUSIC

case MUS_CMD:

if (!MusicCMD_Active(music_playing->data.cmd)) {

music_playing = 0;

}

break;

#endif

#ifdef WAV_MUSIC

case MUS_WAV:

if ( ! WAVStream_Active() ) {

music_playing = 0;

}

break;

#endif

#ifdef MOD_MUSIC

case MUS_MOD:

if ( ! Player_Active() ) {

music_playing = 0;

}

break;

#endif

#ifdef MID_MUSIC

case MUS_MID:

if ( ! Timidity_Active() ) {

music_playing = 0;

}

break;

#endif

#ifdef MP3_MUSIC

case MUS_MP3:

if(SMPEG_status(music_playing->data.mp3)!=SMPEG_PLAYING)

music_playing = 0;

break;

#endif

}

}

return(music_playing ? 1 : 0);

}

/* Set the external music playback command */

int Mix_SetMusicCMD(const char *command)

{

Mix_HaltMusic();

if ( music_cmd ) {

free(music_cmd);

music_cmd = NULL;

}

if ( command ) {

music_cmd = (char *)malloc(strlen(command)+1);

if ( music_cmd == NULL ) {

return(-1);

}

strcpy(music_cmd, command);

}

return(0);

}

/* Uninitialize the music players */

void close_music(void)

{

Mix_HaltMusic();

#ifdef CMD_MUSIC

Mix_SetMusicCMD(NULL);

#endif

#ifdef MOD_MUSIC

MikMod_Exit();

#endif

}