From f40bfc9267b13b54e6379dfe7539447662879d24 Mon Sep 17 00:00:00 2001 From: Sean Bartell Date: Sat, 25 Jun 2011 21:32:25 -0400 Subject: Add codecs to librbcodec. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Change-Id: Id7f4717d51ed02d67cb9f9cb3c0ada4a81843f97 Reviewed-on: http://gerrit.rockbox.org/137 Reviewed-by: Nils Wallménius Tested-by: Nils Wallménius --- lib/rbcodec/codecs/libgme/nes_fds_apu.c | 291 ++++++++++++++++++++++++++++++++ 1 file changed, 291 insertions(+) create mode 100644 lib/rbcodec/codecs/libgme/nes_fds_apu.c (limited to 'lib/rbcodec/codecs/libgme/nes_fds_apu.c') diff --git a/lib/rbcodec/codecs/libgme/nes_fds_apu.c b/lib/rbcodec/codecs/libgme/nes_fds_apu.c new file mode 100644 index 0000000000..dc0775d5d3 --- /dev/null +++ b/lib/rbcodec/codecs/libgme/nes_fds_apu.c @@ -0,0 +1,291 @@ +// Game_Music_Emu 0.6-pre. http://www.slack.net/~ant/ + +#include "nes_fds_apu.h" + +/* Copyright (C) 2006 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 fract_range = 65536; + +void Fds_init( struct Nes_Fds_Apu* this ) +{ + Synth_init( &this->synth ); + + this->lfo_tempo = lfo_base_tempo; + Fds_set_output( this, 0, NULL ); + Fds_volume( this, (int)FP_ONE_VOLUME ); + Fds_reset( this ); +} + +void Fds_reset( struct Nes_Fds_Apu* this ) +{ + memset( this->regs_, 0, sizeof this->regs_ ); + memset( this->mod_wave, 0, sizeof this->mod_wave ); + + this->last_time = 0; + this->env_delay = 0; + this->sweep_delay = 0; + this->wave_pos = 0; + this->last_amp = 0; + this->wave_fract = fract_range; + this->mod_fract = fract_range; + this->mod_pos = 0; + this->mod_write_pos = 0; + + static byte const initial_regs [0x0B] = { + 0x80, // disable envelope + 0, 0, 0xC0, // disable wave and lfo + 0x80, // disable sweep + 0, 0, 0x80, // disable modulation + 0, 0, 0xFF // LFO period // TODO: use 0xE8 as FDS ROM does? + }; + int i; + for ( i = 0; i < (int) sizeof initial_regs; i++ ) + { + // two writes to set both gain and period for envelope registers + Fds_write_( this, fds_io_addr + fds_wave_size + i, 0 ); + Fds_write_( this, fds_io_addr + fds_wave_size + i, initial_regs [i] ); + } +} + +void Fds_write_( struct Nes_Fds_Apu* this, unsigned addr, int data ) +{ + unsigned reg = addr - fds_io_addr; + if ( reg < fds_io_size ) + { + if ( reg < fds_wave_size ) + { + if ( *regs_nes (this, 0x4089) & 0x80 ) + this->regs_ [reg] = data & fds_wave_sample_max; + } + else + { + this->regs_ [reg] = data; + switch ( addr ) + { + case 0x4080: + if ( data & 0x80 ) + this->env_gain = data & 0x3F; + else + this->env_speed = (data & 0x3F) + 1; + break; + + case 0x4084: + if ( data & 0x80 ) + this->sweep_gain = data & 0x3F; + else + this->sweep_speed = (data & 0x3F) + 1; + break; + + case 0x4085: + this->mod_pos = this->mod_write_pos; + *regs_nes (this, 0x4085) = data & 0x7F; + break; + + case 0x4088: + if ( *regs_nes (this, 0x4087) & 0x80 ) + { + int pos = this->mod_write_pos; + data &= 0x07; + this->mod_wave [pos ] = data; + this->mod_wave [pos + 1] = data; + this->mod_write_pos = (pos + 2) & (fds_wave_size - 1); + this->mod_pos = (this->mod_pos + 2) & (fds_wave_size - 1); + } + break; + } + } + } +} + +void Fds_set_tempo( struct Nes_Fds_Apu* this, int t ) +{ + this->lfo_tempo = lfo_base_tempo; + if ( t != (int)FP_ONE_TEMPO ) + { + this->lfo_tempo = (int) ((lfo_base_tempo * FP_ONE_TEMPO) / t); + if ( this->lfo_tempo <= 0 ) + this->lfo_tempo = 1; + } +} + +void Fds_run_until( struct Nes_Fds_Apu* this, blip_time_t final_end_time ) +{ + int const wave_freq = (*regs_nes (this, 0x4083) & 0x0F) * 0x100 + *regs_nes (this, 0x4082); + struct Blip_Buffer* const output_ = this->output_; + if ( wave_freq && output_ && !((*regs_nes (this, 0x4089) | *regs_nes (this, 0x4083)) & 0x80) ) + { + Blip_set_modified( output_ ); + + // master_volume + #define MVOL_ENTRY( percent ) (fds_master_vol_max * percent + 50) / 100 + static unsigned char const master_volumes [4] = { + MVOL_ENTRY( 100 ), MVOL_ENTRY( 67 ), MVOL_ENTRY( 50 ), MVOL_ENTRY( 40 ) + }; + int const master_volume = master_volumes [*regs_nes (this, 0x4089) & 0x03]; + + // lfo_period + blip_time_t lfo_period = *regs_nes (this, 0x408A) * this->lfo_tempo; + if ( *regs_nes (this, 0x4083) & 0x40 ) + lfo_period = 0; + + // sweep setup + blip_time_t sweep_time = this->last_time + this->sweep_delay; + blip_time_t const sweep_period = lfo_period * this->sweep_speed; + if ( !sweep_period || *regs_nes (this, 0x4084) & 0x80 ) + sweep_time = final_end_time; + + // envelope setup + blip_time_t env_time = this->last_time + this->env_delay; + blip_time_t const env_period = lfo_period * this->env_speed; + if ( !env_period || *regs_nes (this, 0x4080) & 0x80 ) + env_time = final_end_time; + + // modulation + int mod_freq = 0; + if ( !(*regs_nes (this, 0x4087) & 0x80) ) + mod_freq = (*regs_nes (this, 0x4087) & 0x0F) * 0x100 + *regs_nes (this, 0x4086); + + blip_time_t end_time = this->last_time; + do + { + // sweep + if ( sweep_time <= end_time ) + { + sweep_time += sweep_period; + int mode = *regs_nes (this, 0x4084) >> 5 & 2; + int new_sweep_gain = this->sweep_gain + mode - 1; + if ( (unsigned) new_sweep_gain <= (unsigned) 0x80 >> mode ) + this->sweep_gain = new_sweep_gain; + else + *regs_nes (this, 0x4084) |= 0x80; // optimization only + } + + // envelope + if ( env_time <= end_time ) + { + env_time += env_period; + int mode = *regs_nes (this, 0x4080) >> 5 & 2; + int new_env_gain = this->env_gain + mode - 1; + if ( (unsigned) new_env_gain <= (unsigned) 0x80 >> mode ) + this->env_gain = new_env_gain; + else + *regs_nes (this, 0x4080) |= 0x80; // optimization only + } + + // new end_time + blip_time_t const start_time = end_time; + end_time = final_end_time; + if ( end_time > env_time ) end_time = env_time; + if ( end_time > sweep_time ) end_time = sweep_time; + + // frequency modulation + int freq = wave_freq; + if ( mod_freq ) + { + // time of next modulation clock + blip_time_t mod_time = start_time + (this->mod_fract + mod_freq - 1) / mod_freq; + if ( end_time > mod_time ) + end_time = mod_time; + + // run modulator up to next clock and save old sweep_bias + int sweep_bias = *regs_nes (this, 0x4085); + this->mod_fract -= (end_time - start_time) * mod_freq; + if ( this->mod_fract <= 0 ) + { + this->mod_fract += fract_range; + check( (unsigned) this->mod_fract <= fract_range ); + + static short const mod_table [8] = { 0, +1, +2, +4, 0, -4, -2, -1 }; + int mod = this->mod_wave [this->mod_pos]; + this->mod_pos = (this->mod_pos + 1) & (fds_wave_size - 1); + int new_sweep_bias = (sweep_bias + mod_table [mod]) & 0x7F; + if ( mod == 4 ) + new_sweep_bias = 0; + *regs_nes (this, 0x4085) = new_sweep_bias; + } + + // apply frequency modulation + sweep_bias = (sweep_bias ^ 0x40) - 0x40; + int factor = sweep_bias * this->sweep_gain; + int extra = factor & 0x0F; + factor >>= 4; + if ( extra ) + { + factor--; + if ( sweep_bias >= 0 ) + factor += 3; + } + if ( factor > 193 ) factor -= 258; + if ( factor < -64 ) factor += 256; + freq += (freq * factor) >> 6; + if ( freq <= 0 ) + continue; + } + + // wave + int wave_fract = this->wave_fract; + blip_time_t delay = (wave_fract + freq - 1) / freq; + blip_time_t time = start_time + delay; + + if ( time <= end_time ) + { + // at least one wave clock within start_time...end_time + + blip_time_t const min_delay = fract_range / freq; + int wave_pos = this->wave_pos; + + int volume = this->env_gain; + if ( volume > fds_vol_max ) + volume = fds_vol_max; + volume *= master_volume; + + int const min_fract = min_delay * freq; + + do + { + // clock wave + int amp = this->regs_ [wave_pos] * volume; + wave_pos = (wave_pos + 1) & (fds_wave_size - 1); + int delta = amp - this->last_amp; + if ( delta ) + { + this->last_amp = amp; + Synth_offset_inline( &this->synth, time, delta, output_ ); + } + + wave_fract += fract_range - delay * freq; + check( unsigned (fract_range - wave_fract) < freq ); + + // delay until next clock + delay = min_delay; + if ( wave_fract > min_fract ) + delay++; + check( delay && delay == (wave_fract + freq - 1) / freq ); + + time += delay; + } + while ( time <= end_time ); // TODO: using < breaks things, but <= is wrong + + this->wave_pos = wave_pos; + } + this->wave_fract = wave_fract - (end_time - (time - delay)) * freq; + check( this->wave_fract > 0 ); + } + while ( end_time < final_end_time ); + + this->env_delay = env_time - final_end_time; check( env_delay >= 0 ); + this->sweep_delay = sweep_time - final_end_time; check( sweep_delay >= 0 ); + } + this->last_time = final_end_time; +} -- cgit v1.2.3