245 lines
6.5 KiB
C++
245 lines
6.5 KiB
C++
// Game_Music_Emu $vers. http://www.slack.net/~ant/
|
|
|
|
#include "Music_Emu.h"
|
|
|
|
/* Copyright (C) 2003-2008 Shay Green. This module is free software; you
|
|
can redistribute it and/or modify it under the terms of the GNU Lesser
|
|
General Public License as published by the Free Software Foundation; either
|
|
version 2.1 of the License, or (at your option) any later version. This
|
|
module 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 Lesser General Public License for more
|
|
details. You should have received a copy of the GNU Lesser General Public
|
|
License along with this module; if not, write to the Free Software Foundation,
|
|
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */
|
|
|
|
#include "blargg_source.h"
|
|
|
|
int const stereo = 2; // number of channels for stereo
|
|
|
|
Music_Emu::equalizer_t const Music_Emu::tv_eq = { -8.0, 180, 0,0,0,0,0,0,0,0 };
|
|
|
|
void Music_Emu::clear_track_vars()
|
|
{
|
|
current_track_ = -1;
|
|
warning(); // clear warning
|
|
track_filter.stop();
|
|
}
|
|
|
|
void Music_Emu::unload()
|
|
{
|
|
voice_count_ = 0;
|
|
clear_track_vars();
|
|
Gme_File::unload();
|
|
}
|
|
|
|
Music_Emu::gme_t()
|
|
{
|
|
effects_buffer_ = NULL;
|
|
sample_rate_ = 0;
|
|
mute_mask_ = 0;
|
|
tempo_ = 1.0;
|
|
gain_ = 1.0;
|
|
|
|
fade_set = false;
|
|
|
|
// defaults
|
|
tfilter = track_filter.setup();
|
|
set_max_initial_silence( 15 );
|
|
set_silence_lookahead( 3 );
|
|
ignore_silence( false );
|
|
|
|
equalizer_.treble = -1.0;
|
|
equalizer_.bass = 60;
|
|
|
|
static const char* const names [] = {
|
|
"Voice 1", "Voice 2", "Voice 3", "Voice 4",
|
|
"Voice 5", "Voice 6", "Voice 7", "Voice 8"
|
|
};
|
|
set_voice_names( names );
|
|
Music_Emu::unload(); // clears fields
|
|
}
|
|
|
|
Music_Emu::~gme_t()
|
|
{
|
|
assert( !effects_buffer_ );
|
|
}
|
|
|
|
blargg_err_t Music_Emu::set_sample_rate( int rate )
|
|
{
|
|
require( !sample_rate() ); // sample rate can't be changed once set
|
|
RETURN_ERR( set_sample_rate_( rate ) );
|
|
RETURN_ERR( track_filter.init( this ) );
|
|
sample_rate_ = rate;
|
|
tfilter.max_silence = 6 * stereo * sample_rate();
|
|
return blargg_ok;
|
|
}
|
|
|
|
void Music_Emu::pre_load()
|
|
{
|
|
require( sample_rate() ); // set_sample_rate() must be called before loading a file
|
|
Gme_File::pre_load();
|
|
}
|
|
|
|
void Music_Emu::set_equalizer( equalizer_t const& eq )
|
|
{
|
|
// TODO: why is GCC generating memcpy call here?
|
|
// Without the 'if', valgrind flags it.
|
|
if ( &eq != &equalizer_ )
|
|
equalizer_ = eq;
|
|
set_equalizer_( eq );
|
|
}
|
|
|
|
void Music_Emu::mute_voice( int index, bool mute )
|
|
{
|
|
require( (unsigned) index < (unsigned) voice_count() );
|
|
int bit = 1 << index;
|
|
int mask = mute_mask_ | bit;
|
|
if ( !mute )
|
|
mask ^= bit;
|
|
mute_voices( mask );
|
|
}
|
|
|
|
void Music_Emu::mute_voices( int mask )
|
|
{
|
|
require( sample_rate() ); // sample rate must be set first
|
|
mute_mask_ = mask;
|
|
mute_voices_( mask );
|
|
}
|
|
|
|
const char* Music_Emu::voice_name( int i ) const
|
|
{
|
|
if ( (unsigned) i < (unsigned) voice_count_ )
|
|
return voice_names_ [i];
|
|
|
|
//check( false ); // TODO: enable?
|
|
return "";
|
|
}
|
|
|
|
void Music_Emu::set_tempo( double t )
|
|
{
|
|
require( sample_rate() ); // sample rate must be set first
|
|
double const min = 0.02;
|
|
double const max = 4.00;
|
|
if ( t < min ) t = min;
|
|
if ( t > max ) t = max;
|
|
tempo_ = t;
|
|
set_tempo_( t );
|
|
}
|
|
|
|
blargg_err_t Music_Emu::post_load()
|
|
{
|
|
set_tempo( tempo_ );
|
|
remute_voices();
|
|
return Gme_File::post_load();
|
|
}
|
|
|
|
// Tell/Seek
|
|
|
|
int Music_Emu::msec_to_samples( int msec ) const
|
|
{
|
|
int sec = msec / 1000;
|
|
msec -= sec * 1000;
|
|
return (sec * sample_rate() + msec * sample_rate() / 1000) * stereo;
|
|
}
|
|
|
|
int Music_Emu::tell() const
|
|
{
|
|
int rate = sample_rate() * stereo;
|
|
int sec = track_filter.sample_count() / rate;
|
|
return sec * 1000 + (track_filter.sample_count() - sec * rate) * 1000 / rate;
|
|
}
|
|
|
|
blargg_err_t Music_Emu::seek( int msec )
|
|
{
|
|
int time = msec_to_samples( msec );
|
|
if ( time < track_filter.sample_count() )
|
|
{
|
|
RETURN_ERR( start_track( current_track_ ) );
|
|
if ( fade_set )
|
|
set_fade( length_msec, fade_msec );
|
|
}
|
|
return skip( time - track_filter.sample_count() );
|
|
}
|
|
|
|
blargg_err_t Music_Emu::skip( int count )
|
|
{
|
|
require( current_track() >= 0 ); // start_track() must have been called already
|
|
return track_filter.skip( count );
|
|
}
|
|
|
|
blargg_err_t Music_Emu::skip_( int count )
|
|
{
|
|
// for long skip, mute sound
|
|
const int threshold = 32768;
|
|
if ( count > threshold )
|
|
{
|
|
int saved_mute = mute_mask_;
|
|
mute_voices( ~0 );
|
|
|
|
int n = count - threshold/2;
|
|
n &= ~(2048-1); // round to multiple of 2048
|
|
count -= n;
|
|
RETURN_ERR( track_filter.skip_( n ) );
|
|
|
|
mute_voices( saved_mute );
|
|
}
|
|
|
|
return track_filter.skip_( count );
|
|
}
|
|
|
|
// Playback
|
|
|
|
blargg_err_t Music_Emu::start_track( int track )
|
|
{
|
|
clear_track_vars();
|
|
|
|
int remapped = track;
|
|
RETURN_ERR( remap_track_( &remapped ) );
|
|
current_track_ = track;
|
|
blargg_err_t err = start_track_( remapped );
|
|
if ( err )
|
|
{
|
|
current_track_ = -1;
|
|
return err;
|
|
}
|
|
|
|
// convert filter times to samples
|
|
Track_Filter::setup_t s = tfilter;
|
|
s.max_initial *= sample_rate() * stereo;
|
|
#if GME_DISABLE_SILENCE_LOOKAHEAD
|
|
s.lookahead = 1;
|
|
#endif
|
|
track_filter.setup( s );
|
|
|
|
return track_filter.start_track();
|
|
}
|
|
|
|
void Music_Emu::set_fade( int start_msec, int length_msec )
|
|
{
|
|
fade_set = true;
|
|
this->length_msec = start_msec;
|
|
this->fade_msec = length_msec;
|
|
track_filter.set_fade( msec_to_samples( start_msec ),
|
|
length_msec * sample_rate() / (1000 / stereo) );
|
|
}
|
|
|
|
blargg_err_t Music_Emu::play( int out_count, sample_t out [] )
|
|
{
|
|
require( current_track() >= 0 );
|
|
require( out_count % stereo == 0 );
|
|
|
|
return track_filter.play( out_count, out );
|
|
}
|
|
|
|
// Gme_Info_
|
|
|
|
blargg_err_t Gme_Info_::set_sample_rate_( int ) { return blargg_ok; }
|
|
void Gme_Info_::pre_load() { Gme_File::pre_load(); } // skip Music_Emu
|
|
blargg_err_t Gme_Info_::post_load() { return Gme_File::post_load(); } // skip Music_Emu
|
|
void Gme_Info_::set_equalizer_( equalizer_t const& ){ check( false ); }
|
|
void Gme_Info_::mute_voices_( int ) { check( false ); }
|
|
void Gme_Info_::set_tempo_( double ) { }
|
|
blargg_err_t Gme_Info_::start_track_( int ) { return BLARGG_ERR( BLARGG_ERR_CALLER, "can't play file opened for info only" ); }
|
|
blargg_err_t Gme_Info_::play_( int, sample_t [] ) { return BLARGG_ERR( BLARGG_ERR_CALLER, "can't play file opened for info only" ); }
|