music_vorbis.c

/*
 Copyright (C) 2007 Will Glynn

 Derived from music.c:
 Copyright (C) 2005 Michael K. McCarty & Fritz Bronner
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program 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 General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <race.h>
#include <Buzz_inc.h>
#include <mmfile.h>
#include <pace.h>
#include <utils.h>

// A map of music_tracks to filenames
struct music_key {
	enum music_track track;
	char *name;
} music_key[] = {
	{ M_ASSEMBLY, "assembly" },
	{ M_ASTTRNG, "asttrng" },
	{ M_BADNEWS, "badnews" },
	{ M_DRUMSM, "drumsm" },
	{ M_ELEPHANT, "elephant" },
	{ M_FILLER, "filler" },
	{ M_FUTURE, "future" },
	{ M_GOOD, "good" },
	{ M_HARDWARE, "hardware" },
	{ M_HISTORY, "history" },
	{ M_INTEL, "intel" },
	{ M_INTELLEG, "intelleg" },
	{ M_INTERLUD, "interlud" },
	{ M_LIFTOFF, "liftoff" },
	{ M_MISSPLAN, "missplan" },
	{ M_NEW1950, "new1950" },
	{ M_NEW1970, "new1970" },
	{ M_PRES, "pres" },
	{ M_PRGMTRG, "prgmtrg" },
	{ M_RD, "r&d" },
	{ M_SOVTYP, "sovtyp" },
	{ M_SUCCESS, "success" },
	{ M_SVFUN, "svfun" },
	{ M_SVLOGO, "svlogo" },
	{ M_SVPORT, "svport2" },
	{ M_THEME, "theme" },
	{ M_UNSUCC, "unsucc" },
	{ M_USFUN, "usfun" },
	{ M_USMIL, "usmil" },
	{ M_USPORT, "usport2" },
	{ M_USSRMIL, "ussrmil" },
	{ M_VICTORY, "victory" },
	{ M_MAX_MUSIC, NULL },
};

// This structure defines each track
struct music_file {
	// Pointer to the audio buffer, once loaded from disk
	char * buf;
	size_t buf_size;
	
	// Can this track be played? i.e., does it exist?
	int unplayable;
	
	// Is this track playing?
	int playing;
	
	// The SDL audio chunk describing this track
	struct audio_chunk chunk;
};
struct music_file music_files[M_MAX_MUSIC];

// Ensure that the specified music track is in memory, loading it if required
void music_load(enum music_track track)
{
	char fname[20] = "";
	int i;
	ssize_t bytes;
	
	// Check to see if the track is already loaded or known broken; if so, we're already done
	if (music_files[track].buf != NULL || music_files[track].unplayable)
		return;

	// Find the name for this track
	for (i = 0; music_key[i].track != M_MAX_MUSIC; i++) {
		if (music_key[i].track == track && music_key[i].name) {
			snprintf(fname, sizeof(fname), "%s.OGG", music_key[track].name);
			break;
		}
	}
	
	// Bail out if this track isn't known
	if (strlen(fname) == 0) {
		music_files[track].unplayable = 1;
		return;		
	}
	
	// Load the file
	bytes = load_audio_file(fname, &music_files[track].buf, &music_files[track].buf_size);

	// Handle failure gracefully
	if (bytes < 0) {
		free(music_files[track].buf);
		music_files[track].unplayable = 1;
		return;
	}
	
	// XXX: Trim the last two seconds from the audio file, since it's broken
	// This should really be done on the Vorbis files, rather than in the player
	if (bytes > 2 * 11025) {
		music_files[track].buf_size -= 2 * 11025;
		music_files[track].buf = xrealloc(music_files[track].buf, music_files[track].buf_size);
	}
}

// Start playing the given track
void music_start_loop(enum music_track track, int loop)
{
	// Load the track as necessary
	music_load(track);
	
	// Ensure that this track is playable
	if (music_files[track].unplayable)
		return;
	
	// Ignore requests to play a track that's already playing
	if (music_files[track].playing)
		return;
	
	// Initialize the audio chunk
	music_files[track].chunk.data = music_files[track].buf;
	music_files[track].chunk.size = music_files[track].buf_size;
	music_files[track].chunk.loop = loop;
	
	// XXX: Stop the existing music, since we need the music channel
	// This should be changed to dynamic channel allocation, to allow layering music tracks
	music_stop();
	
	// Play the track, and indicate that it's playing
	play(&music_files[track].chunk, AV_MUSIC_CHANNEL);
	music_files[track].playing = 1;
}

// Stop a specific track
void music_stop_track(enum music_track track)
{
	if (music_files[track].playing) {
		// XXX: stop the global music channel
		// This should be assigned on a per-track basis
		av_silence(AV_MUSIC_CHANNEL);
		
		music_files[track].playing = 0;
	}	
}

// Stop all tracks
void music_stop()
{
	int i;
	
	// Iterate through the list and stop any playing tracks by calling music_stop_track()
	for (i = 0; i < M_MAX_MUSIC; i ++) {
		if (music_files[i].playing) {
			music_stop_track(i);
		}
	}
}

int music_is_playing()
{
	int i;
	for (i = 0; i < M_MAX_MUSIC; i ++) {
		if (music_files[i].playing) {
			return 1;
		}
	}
	
	return 0;
}

int music_is_track_playing(enum music_track track)
{
	return music_files[track].playing;
}

void music_pump()
{
	// TODO: Check to see that all the tracks we think are playing actually are
	// This doesn't apply to looped tracks, since those keep playing forever
}

void music_set_mute(int muted)
{
	MuteChannel(AV_MUSIC_CHANNEL, muted);
}