From acb0917556fc33681c1df5a530cf754193e67705 Mon Sep 17 00:00:00 2001 From: Andree Buschmann Date: Sun, 7 Aug 2011 20:01:04 +0000 Subject: Submit initial patch from FS#12176. Adds support for several new game music formats (AY, GBS, HES, KSS, SGC, VGM and VGZ) and replaces the current NSF and NSFE with a new implementation based on a port of the Game Music Emu library 'GME'. This first submit does not cover the full functionality provided by the author's original patch: Coleco-SGV is not supported, some GME-specific m3u-support has been removed and IRAM is not used yet. Further changes are very likely to follow this submit. Thanks to Mauricio Garrido. git-svn-id: svn://svn.rockbox.org/rockbox/trunk@30264 a1c6a512-1295-4272-9138-f99709370657 --- apps/codecs/libgme/ym2612_emu.c | 1359 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 1359 insertions(+) create mode 100644 apps/codecs/libgme/ym2612_emu.c (limited to 'apps/codecs/libgme/ym2612_emu.c') diff --git a/apps/codecs/libgme/ym2612_emu.c b/apps/codecs/libgme/ym2612_emu.c new file mode 100644 index 0000000000..a2f32d30ca --- /dev/null +++ b/apps/codecs/libgme/ym2612_emu.c @@ -0,0 +1,1359 @@ +// Game_Music_Emu $vers. http://www.slack.net/~ant/ + +// Based on Gens 2.10 ym2612.c + +#include "ym2612_emu.h" + +#include +#include +#include +#include +#include +#include + +/* Copyright (C) 2002 Stéphane Dallongeville (gens AT consolemul.com) */ +/* Copyright (C) 2004-2007 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 */ + +// This is mostly the original source in its C style and all. +// +// Somewhat optimized and simplified. Uses a template to generate the many +// variants of Update_Chan. Rewrote header file. In need of full rewrite by +// someone more familiar with FM sound and the YM2612. Has some inaccuracies +// compared to the Sega Genesis sound, particularly being mixed at such a +// high sample accuracy (the Genesis sounds like it has only 8 bit samples). +// - Shay + +// Ported again to c by gama. +// Not sure if performance is better than the original c version. + +#if !defined(ROCKBOX) + #define YM2612_CALCUL_TABLES +#else + #include "ymtables.h" +#endif + +const int output_bits = 14; + +static const unsigned char DT_DEF_TAB [4 * 32] ICONST_ATTR = +{ +// FD = 0 + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + +// FD = 1 + 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, + 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 7, 8, 8, 8, 8, + +// FD = 2 + 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, + 5, 6, 6, 7, 8, 8, 9, 10, 11, 12, 13, 14, 16, 16, 16, 16, + +// FD = 3 + 2, 2, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 7, + 8 , 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 20, 22, 22, 22, 22 +}; + +static const unsigned char FKEY_TAB [16] ICONST_ATTR = +{ + 0, 0, 0, 0, + 0, 0, 0, 1, + 2, 3, 3, 3, + 3, 3, 3, 3 +}; + +static const unsigned char LFO_AMS_TAB [4] ICONST_ATTR = +{ + 31, 4, 1, 0 +}; + +static const unsigned char LFO_FMS_TAB [8] ICONST_ATTR = +{ + LFO_FMS_BASE * 0, LFO_FMS_BASE * 1, + LFO_FMS_BASE * 2, LFO_FMS_BASE * 3, + LFO_FMS_BASE * 4, LFO_FMS_BASE * 6, + LFO_FMS_BASE * 12, LFO_FMS_BASE * 24 +}; + +int in0, in1, in2, in3; // current phase calculation +// int en0, en1, en2, en3; // current enveloppe calculation + +inline void set_seg( struct slot_t* s, int seg ) +{ + s->env_xor = 0; + s->env_max = INT_MAX; + s->SEG = seg; + if ( seg & 4 ) + { + s->env_xor = ENV_MASK; + s->env_max = ENV_MASK; + } +} + +inline void YM2612_Special_Update(void) { } + +void KEY_ON( struct channel_* ch, struct tables_t *g, int nsl ) +{ + struct slot_t *SL = &(ch->SLOT [nsl]); // on recupere le bon pointeur de slot + + if (SL->Ecurp == RELEASE) // la touche est-elle rel'chee ? + { + SL->Fcnt = 0; + + // Fix Ecco 2 splash sound + + SL->Ecnt = (g->DECAY_TO_ATTACK [g->ENV_TAB [SL->Ecnt >> ENV_LBITS]] + ENV_ATTACK) & SL->ChgEnM; + SL->ChgEnM = ~0; + +// SL->Ecnt = g.DECAY_TO_ATTACK [g.ENV_TAB [SL->Ecnt >> ENV_LBITS]] + ENV_ATTACK; +// SL->Ecnt = 0; + + SL->Einc = SL->EincA; + SL->Ecmp = ENV_DECAY; + SL->Ecurp = ATTACK; + } +} + + +void KEY_OFF( struct channel_* ch, struct tables_t *g, int nsl ) +{ + struct slot_t *SL = &(ch->SLOT [nsl]); // on recupere le bon pointeur de slot + + if (SL->Ecurp != RELEASE) // la touche est-elle appuyee ? + { + if (SL->Ecnt < ENV_DECAY) // attack phase ? + { + SL->Ecnt = (g->ENV_TAB [SL->Ecnt >> ENV_LBITS] << ENV_LBITS) + ENV_DECAY; + } + + SL->Einc = SL->EincR; + SL->Ecmp = ENV_END; + SL->Ecurp = RELEASE; + } +} + + +int SLOT_SET( struct Ym2612_Impl* impl, int Adr, int data ) +{ + int nch = Adr & 3; + if ( nch == 3 ) + return 1; + + struct tables_t *g = &impl->g; + struct state_t *YM2612 = &impl->YM2612; + struct channel_* ch = &YM2612->CHANNEL [nch + (Adr & 0x100 ? 3 : 0)]; + struct slot_t* sl = &ch->SLOT [(Adr >> 2) & 3]; + + switch ( Adr & 0xF0 ) + { + case 0x30: + if ( (sl->MUL = (data & 0x0F)) != 0 ) sl->MUL <<= 1; + else sl->MUL = 1; + + sl->DT = (int*) g->DT_TAB [(data >> 4) & 7]; + + ch->SLOT [0].Finc = -1; + + break; + + case 0x40: + sl->TL = data & 0x7F; + + // SOR2 do a lot of TL adjustement and this fix R.Shinobi jump sound... + YM2612_Special_Update(); + +#if ((ENV_HBITS - 7) < 0) + sl->TLL = sl->TL >> (7 - ENV_HBITS); +#else + sl->TLL = sl->TL << (ENV_HBITS - 7); +#endif + + break; + + case 0x50: + sl->KSR_S = 3 - (data >> 6); + + ch->SLOT [0].Finc = -1; + + if (data &= 0x1F) sl->AR = (int*) &g->AR_TAB [data << 1]; + else sl->AR = (int*) &g->NULL_RATE [0]; + + sl->EincA = sl->AR [sl->KSR]; + if (sl->Ecurp == ATTACK) sl->Einc = sl->EincA; + break; + + case 0x60: + if ( (sl->AMSon = (data & 0x80)) != 0 ) sl->AMS = ch->AMS; + else sl->AMS = 31; + + if (data &= 0x1F) sl->DR = (int*) &g->DR_TAB [data << 1]; + else sl->DR = (int*) &g->NULL_RATE [0]; + + sl->EincD = sl->DR [sl->KSR]; + if (sl->Ecurp == DECAY) sl->Einc = sl->EincD; + break; + + case 0x70: + if (data &= 0x1F) sl->SR = (int*) &g->DR_TAB [data << 1]; + else sl->SR = (int*) &g->NULL_RATE [0]; + + sl->EincS = sl->SR [sl->KSR]; + if ((sl->Ecurp == SUBSTAIN) && (sl->Ecnt < ENV_END)) sl->Einc = sl->EincS; + break; + + case 0x80: + sl->SLL = g->SL_TAB [data >> 4]; + + sl->RR = (int*) &g->DR_TAB [((data & 0xF) << 2) + 2]; + + sl->EincR = sl->RR [sl->KSR]; + if ((sl->Ecurp == RELEASE) && (sl->Ecnt < ENV_END)) sl->Einc = sl->EincR; + break; + + case 0x90: + // SSG-EG envelope shapes : + /* + E At Al H + + 1 0 0 0 \\\\ + 1 0 0 1 \___ + 1 0 1 0 \/\/ + 1 0 1 1 \ + 1 1 0 0 //// + 1 1 0 1 / + 1 1 1 0 /\/\ + 1 1 1 1 /___ + + E = SSG-EG enable + At = Start negate + Al = Altern + H = Hold */ + + set_seg( sl, (data & 8) ? (data & 0x0F) : 0 ); + break; + } + + return 0; +} + + +int CHANNEL_SET( struct state_t* YM2612, int Adr, int data ) +{ + int num = Adr & 3; + if ( num == 3 ) + return 1; + + struct channel_* ch = &YM2612->CHANNEL [num + (Adr & 0x100 ? 3 : 0)]; + + switch ( Adr & 0xFC ) + { + case 0xA0: + YM2612_Special_Update(); + + ch->FNUM [0] = (ch->FNUM [0] & 0x700) + data; + ch->KC [0] = (ch->FOCT [0] << 2) | FKEY_TAB [ch->FNUM [0] >> 7]; + + ch->SLOT [0].Finc = -1; + break; + + case 0xA4: + YM2612_Special_Update(); + + ch->FNUM [0] = (ch->FNUM [0] & 0x0FF) + ((data & 0x07) << 8); + ch->FOCT [0] = (data & 0x38) >> 3; + ch->KC [0] = (ch->FOCT [0] << 2) | FKEY_TAB [ch->FNUM [0] >> 7]; + + ch->SLOT [0].Finc = -1; + break; + + case 0xA8: + if ( Adr < 0x100 ) + { + num++; + + YM2612_Special_Update(); + + YM2612->CHANNEL [2].FNUM [num] = (YM2612->CHANNEL [2].FNUM [num] & 0x700) + data; + YM2612->CHANNEL [2].KC [num] = (YM2612->CHANNEL [2].FOCT [num] << 2) | + FKEY_TAB [YM2612->CHANNEL [2].FNUM [num] >> 7]; + + YM2612->CHANNEL [2].SLOT [0].Finc = -1; + } + break; + + case 0xAC: + if ( Adr < 0x100 ) + { + num++; + + YM2612_Special_Update(); + + YM2612->CHANNEL [2].FNUM [num] = (YM2612->CHANNEL [2].FNUM [num] & 0x0FF) + ((data & 0x07) << 8); + YM2612->CHANNEL [2].FOCT [num] = (data & 0x38) >> 3; + YM2612->CHANNEL [2].KC [num] = (YM2612->CHANNEL [2].FOCT [num] << 2) | + FKEY_TAB [YM2612->CHANNEL [2].FNUM [num] >> 7]; + + YM2612->CHANNEL [2].SLOT [0].Finc = -1; + } + break; + + case 0xB0: + if ( ch->ALGO != (data & 7) ) + { + // Fix VectorMan 2 heli sound (level 1) + YM2612_Special_Update(); + + ch->ALGO = data & 7; + + ch->SLOT [0].ChgEnM = 0; + ch->SLOT [1].ChgEnM = 0; + ch->SLOT [2].ChgEnM = 0; + ch->SLOT [3].ChgEnM = 0; + } + + ch->FB = 9 - ((data >> 3) & 7); // Real thing ? + +// if (ch->FB = ((data >> 3) & 7)) ch->FB = 9 - ch->FB; // Thunder force 4 (music stage 8), Gynoug, Aladdin bug sound... +// else ch->FB = 31; + break; + + case 0xB4: { + YM2612_Special_Update(); + + ch->LEFT = 0 - ((data >> 7) & 1); + ch->RIGHT = 0 - ((data >> 6) & 1); + + ch->AMS = LFO_AMS_TAB [(data >> 4) & 3]; + ch->FMS = LFO_FMS_TAB [data & 7]; + + int i; + for ( i = 0; i < 4; i++ ) + { + struct slot_t* sl = &ch->SLOT [i]; + sl->AMS = (sl->AMSon ? ch->AMS : 31); + } + break; + } + } + + return 0; +} + + +int YM_SET( struct Ym2612_Impl* impl, int Adr, int data ) +{ + struct state_t* YM2612 = &impl->YM2612; + struct tables_t* g = &impl->g; + switch ( Adr ) + { + case 0x22: + if (data & 8) // LFO enable + { + // Cool Spot music 1, LFO modified severals time which + // distord the sound, have to check that on a real genesis... + + g->LFOinc = g->LFO_INC_TAB [data & 7]; + } + else + { + g->LFOinc = g->LFOcnt = 0; + } + break; + + case 0x24: + YM2612->TimerA = (YM2612->TimerA & 0x003) | (((int) data) << 2); + + if (YM2612->TimerAL != (1024 - YM2612->TimerA) << 12) + { + YM2612->TimerAcnt = YM2612->TimerAL = (1024 - YM2612->TimerA) << 12; + } + break; + + case 0x25: + YM2612->TimerA = (YM2612->TimerA & 0x3FC) | (data & 3); + + if (YM2612->TimerAL != (1024 - YM2612->TimerA) << 12) + { + YM2612->TimerAcnt = YM2612->TimerAL = (1024 - YM2612->TimerA) << 12; + } + break; + + case 0x26: + YM2612->TimerB = data; + + if (YM2612->TimerBL != (256 - YM2612->TimerB) << (4 + 12)) + { + YM2612->TimerBcnt = YM2612->TimerBL = (256 - YM2612->TimerB) << (4 + 12); + } + break; + + case 0x27: + // Parametre divers + // b7 = CSM MODE + // b6 = 3 slot mode + // b5 = reset b + // b4 = reset a + // b3 = timer enable b + // b2 = timer enable a + // b1 = load b + // b0 = load a + + if ((data ^ YM2612->Mode) & 0x40) + { + // We changed the channel 2 mode, so recalculate phase step + // This fix the punch sound in Street of Rage 2 + + YM2612_Special_Update(); + + YM2612->CHANNEL [2].SLOT [0].Finc = -1; // recalculate phase step + } + +// if ((data & 2) && (YM2612->Status & 2)) YM2612->TimerBcnt = YM2612->TimerBL; +// if ((data & 1) && (YM2612->Status & 1)) YM2612->TimerAcnt = YM2612->TimerAL; + +// YM2612->Status &= (~data >> 4); // Reset du Status au cas ou c'est demande + YM2612->Status &= (~data >> 4) & (data >> 2); // Reset Status + + YM2612->Mode = data; + break; + + case 0x28: { + int nch = data & 3; + if ( nch == 3 ) + return 1; + if ( data & 4 ) + nch += 3; + struct channel_* ch = &YM2612->CHANNEL [nch]; + + YM2612_Special_Update(); + + if (data & 0x10) KEY_ON(ch, g, S0); // On appuie sur la touche pour le slot 1 + else KEY_OFF(ch, g, S0); // On rel'che la touche pour le slot 1 + if (data & 0x20) KEY_ON(ch, g, S1); // On appuie sur la touche pour le slot 3 + else KEY_OFF(ch, g, S1); // On rel'che la touche pour le slot 3 + if (data & 0x40) KEY_ON(ch, g, S2); // On appuie sur la touche pour le slot 2 + else KEY_OFF(ch, g, S2); // On rel'che la touche pour le slot 2 + if (data & 0x80) KEY_ON(ch, g, S3); // On appuie sur la touche pour le slot 4 + else KEY_OFF(ch, g, S3); // On rel'che la touche pour le slot 4 + break; + } + + case 0x2B: + if (YM2612->DAC ^ (data & 0x80)) YM2612_Special_Update(); + + YM2612->DAC = data & 0x80; // activation/desactivation du DAC + break; + } + + return 0; +} + +#if defined(ROCKBOX) +double fabs(double x) +{ + if (x < 0.0) return -x; + return x; +} + +double ipow(double a,int b) +{ + if (b < 0) { + a = 1.0 / a; + b = -b; + } + double result = 1.0; + while(b) { + if (b & 1) result*=a; + a *= a; + b >>= 1; + } + return result; +} +#endif + +void impl_reset( struct Ym2612_Impl* impl ); +void impl_set_rate( struct Ym2612_Impl* impl, double sample_rate, double clock_rate ) +{ + assert( sample_rate ); + assert( !clock_rate || clock_rate > sample_rate ); + + int i; + + // 144 = 12 * (prescale * 2) = 12 * 6 * 2 + // prescale set to 6 by default + + double Frequence = (clock_rate ? clock_rate / sample_rate / 144.0 : 1.0); + if ( fabs( Frequence - 1.0 ) < 0.0000001 ) + Frequence = 1.0; + impl->YM2612.TimerBase = (int) (Frequence * 4096.0); + + // Tableau TL : + // [0 - 4095] = +output [4095 - ...] = +output overflow (fill with 0) + // [12288 - 16383] = -output [16384 - ...] = -output overflow (fill with 0) + + for ( i = 0; i < TL_LENGHT; i++ ) + { + if (i >= PG_CUT_OFF) // YM2612 cut off sound after 78 dB (14 bits output ?) + { + impl->g.TL_TAB [TL_LENGHT + i] = impl->g.TL_TAB [i] = 0; + } + else + { + // Decibel -> Voltage + #ifdef YM2612_CALCUL_TABLES + impl->g.TL_TAB [i] = (int) (MAX_OUT / pow( 10.0, ENV_STEP / 20.0f * i )); + #else + impl->g.TL_TAB [i] = tl_coeff [i]; + #endif + impl->g.TL_TAB [TL_LENGHT + i] = -impl->g.TL_TAB [i]; + } + } + + // Tableau SIN : + // impl->g.SIN_TAB [x] [y] = sin(x) * y; + // x = phase and y = volume + + impl->g.SIN_TAB [0] = impl->g.SIN_TAB [SIN_LENGHT / 2] = PG_CUT_OFF; + + for ( i = 1; i <= SIN_LENGHT / 4; i++ ) + { + // Sinus in dB + #ifdef YM2612_CALCUL_TABLES + double x = 20 * log10( 1 / sin( 2.0 * PI * i / SIN_LENGHT ) ); // convert to dB + + int j = (int) (x / ENV_STEP); // Get TL range + + if (j > PG_CUT_OFF) j = (int) PG_CUT_OFF; + #else + int j = sindb_coeff [i-1]; + #endif + + impl->g.SIN_TAB [i] = impl->g.SIN_TAB [(SIN_LENGHT / 2) - i] = j; + impl->g.SIN_TAB [(SIN_LENGHT / 2) + i] = impl->g.SIN_TAB [SIN_LENGHT - i] = TL_LENGHT + j; + } + + // Tableau LFO (LFO wav) : + + for ( i = 0; i < LFO_LENGHT; i++ ) + { + #ifdef YM2612_CALCUL_TABLES + double x = 1 + sin( 2.0 * PI * i * (1.0 / LFO_LENGHT) ); // Sinus + x *= 11.8 / ENV_STEP / 2; // ajusted to MAX enveloppe modulation + + impl->g.LFO_ENV_TAB [i] = (int) x; + + x = sin( 2.0 * PI * i * (1.0 / LFO_LENGHT) ); // Sinus + x *= (1 << (LFO_HBITS - 1)) - 1; + + impl->g.LFO_FREQ_TAB [i] = (int) x; + #else + impl->g.LFO_ENV_TAB [i] = lfo_env_coeff [i]; + impl->g.LFO_FREQ_TAB [i] = lfo_freq_coeff [i]; + #endif + } + + // Tableau Enveloppe : + // impl->g.ENV_TAB [0] -> impl->g.ENV_TAB [ENV_LENGHT - 1] = attack curve + // impl->g.ENV_TAB [ENV_LENGHT] -> impl->g.ENV_TAB [2 * ENV_LENGHT - 1] = decay curve + + for ( i = 0; i < ENV_LENGHT; i++ ) + { + // Attack curve (x^8 - music level 2 Vectorman 2) + #if defined(ROCKBOX) + double x = ipow( ((ENV_LENGHT - 1) - i) / (double) ENV_LENGHT, 8.0 ); + #else + double x = pow( ((ENV_LENGHT - 1) - i) / (double) ENV_LENGHT, 8.0 ); + #endif + x *= ENV_LENGHT; + + impl->g.ENV_TAB [i] = (int) x; + + // Decay curve (just linear) + impl->g.ENV_TAB [ENV_LENGHT + i] = i; + } + for ( i = 0; i < 8; i++ ) + impl->g.ENV_TAB [i + ENV_LENGHT * 2] = 0; + + impl->g.ENV_TAB [ENV_END >> ENV_LBITS] = ENV_LENGHT - 1; // for the stopped state + + // Tableau pour la conversion Attack -> Decay and Decay -> Attack + + int j = ENV_LENGHT - 1; + for ( i = 0; i < ENV_LENGHT; i++ ) + { + while ( j && impl->g.ENV_TAB [j] < i ) + j--; + + impl->g.DECAY_TO_ATTACK [i] = j << ENV_LBITS; + } + + // Tableau pour le Substain Level + + for ( i = 0; i < 15; i++ ) + { + double x = i * 3 / ENV_STEP; // 3 and not 6 (Mickey Mania first music for test) + + impl->g.SL_TAB [i] = ((int) x << ENV_LBITS) + ENV_DECAY; + } + + impl->g.SL_TAB [15] = ((ENV_LENGHT - 1) << ENV_LBITS) + ENV_DECAY; // special case : volume off + + // Tableau Frequency Step + { + // 0.5 because MUL = value * 2 + #if SIN_LBITS + SIN_HBITS - (21 - 7) < 0 + double const factor = 0.5 / (1 << ((21 - 7) - SIN_LBITS - SIN_HBITS)) * Frequence; + #else + double const factor = 0.5 * (1 << (SIN_LBITS + SIN_HBITS - (21 - 7))) * Frequence; + #endif + for ( i = 0; i < 2048; i++ ) + impl->g.FINC_TAB [i] = (unsigned) (i * factor); + } + + // Tableaux Attack & Decay Rate + + for ( i = 0; i < 4; i++ ) + { + impl->g.AR_TAB [i] = 0; + impl->g.DR_TAB [i] = 0; + } + + for ( i = 0; i < 60; i++ ) + { + double x = + (1.0 + ((i & 3) * 0.25)) * // bits 0-1 : x1.00, x1.25, x1.50, x1.75 + (ENV_LENGHT << ENV_LBITS) * // on ajuste pour le tableau impl->g.ENV_TAB + Frequence * + (1 << (i >> 2)); // bits 2-5 : shift bits (x2^0 - x2^15) + + impl->g.AR_TAB [i + 4] = (unsigned int) (x / AR_RATE); + impl->g.DR_TAB [i + 4] = (unsigned int) (x / DR_RATE); + } + + for ( i = 64; i < 96; i++ ) + { + impl->g.AR_TAB [i] = impl->g.AR_TAB [63]; + impl->g.DR_TAB [i] = impl->g.DR_TAB [63]; + + impl->g.NULL_RATE [i - 64] = 0; + } + + for ( i = 96; i < 128; i++ ) + impl->g.AR_TAB [i] = 0; + + // Tableau Detune + { + #if SIN_LBITS + SIN_HBITS - 21 < 0 + double const factor = 1.0 / (1 << (21 - SIN_LBITS - SIN_HBITS)) * Frequence; + #else + double const factor = (1 << (SIN_LBITS + SIN_HBITS - 21)) * Frequence; + #endif + for ( i = 0; i < 4; i++ ) + { + int j; + for ( j = 0; j < 32; j++ ) + { + double y = DT_DEF_TAB [(i << 5) + j] * factor; + + impl->g.DT_TAB [i + 0] [j] = (int) y; + impl->g.DT_TAB [i + 4] [j] = (int) -y; + } + } + } + + // Tableau LFO + impl->g.LFO_INC_TAB [0] = (unsigned) (3.98 * (1 << (LFO_HBITS + LFO_LBITS)) / sample_rate); + impl->g.LFO_INC_TAB [1] = (unsigned) (5.56 * (1 << (LFO_HBITS + LFO_LBITS)) / sample_rate); + impl->g.LFO_INC_TAB [2] = (unsigned) (6.02 * (1 << (LFO_HBITS + LFO_LBITS)) / sample_rate); + impl->g.LFO_INC_TAB [3] = (unsigned) (6.37 * (1 << (LFO_HBITS + LFO_LBITS)) / sample_rate); + impl->g.LFO_INC_TAB [4] = (unsigned) (6.88 * (1 << (LFO_HBITS + LFO_LBITS)) / sample_rate); + impl->g.LFO_INC_TAB [5] = (unsigned) (9.63 * (1 << (LFO_HBITS + LFO_LBITS)) / sample_rate); + impl->g.LFO_INC_TAB [6] = (unsigned) (48.1 * (1 << (LFO_HBITS + LFO_LBITS)) / sample_rate); + impl->g.LFO_INC_TAB [7] = (unsigned) (72.2 * (1 << (LFO_HBITS + LFO_LBITS)) / sample_rate); + + impl_reset( impl ); +} + +const char* Ym2612_set_rate( struct Ym2612_Emu* this, double sample_rate, double clock_rate ) +{ +// Only set rates if necessary +#if defined(ROCKBOX) + static double last_sample_rate = 0.0, last_clock_rate = 0.0; + if (last_sample_rate == sample_rate && last_clock_rate == clock_rate) return 0; +#endif + memset( &this->impl.YM2612, 0, sizeof this->impl.YM2612 ); + impl_set_rate( &this->impl, sample_rate, clock_rate ); + + return 0; +} + +inline void write0( struct Ym2612_Impl* impl, int opn_addr, int data ) +{ + assert( (unsigned) data <= 0xFF ); + + if ( opn_addr < 0x30 ) + { + impl->YM2612.REG [0] [opn_addr] = data; + YM_SET( impl, opn_addr, data ); + } + else if ( impl->YM2612.REG [0] [opn_addr] != data ) + { + impl->YM2612.REG [0] [opn_addr] = data; + + if ( opn_addr < 0xA0 ) + SLOT_SET( impl, opn_addr, data ); + else + CHANNEL_SET( &impl->YM2612, opn_addr, data ); + } +} + +inline void write1( struct Ym2612_Impl* impl, int opn_addr, int data ) +{ + assert( (unsigned) data <= 0xFF ); + + if ( opn_addr >= 0x30 && impl->YM2612.REG [1] [opn_addr] != data ) + { + impl->YM2612.REG [1] [opn_addr] = data; + + if ( opn_addr < 0xA0 ) + SLOT_SET( impl, opn_addr + 0x100, data ); + else + CHANNEL_SET( &impl->YM2612, opn_addr + 0x100, data ); + } +} + +void impl_reset( struct Ym2612_Impl* impl ) +{ + impl->g.LFOcnt = 0; + impl->YM2612.TimerA = 0; + impl->YM2612.TimerAL = 0; + impl->YM2612.TimerAcnt = 0; + impl->YM2612.TimerB = 0; + impl->YM2612.TimerBL = 0; + impl->YM2612.TimerBcnt = 0; + impl->YM2612.DAC = 0; + + impl->YM2612.Status = 0; + + int i; + for ( i = 0; i < ym2612_channel_count; i++ ) + { + struct channel_* ch = &impl->YM2612.CHANNEL [i]; + + ch->LEFT = ~0; + ch->RIGHT = ~0; + ch->ALGO = 0; + ch->FB = 31; + ch->FMS = 0; + ch->AMS = 0; + + int j; + for ( j = 0 ;j < 4 ; j++ ) + { + ch->S0_OUT [j] = 0; + ch->FNUM [j] = 0; + ch->FOCT [j] = 0; + ch->KC [j] = 0; + + ch->SLOT [j].Fcnt = 0; + ch->SLOT [j].Finc = 0; + ch->SLOT [j].Ecnt = ENV_END; // Put it at the end of Decay phase... + ch->SLOT [j].Einc = 0; + ch->SLOT [j].Ecmp = 0; + ch->SLOT [j].Ecurp = RELEASE; + + ch->SLOT [j].ChgEnM = 0; + } + } + + for ( i = 0; i < 0x100; i++ ) + { + impl->YM2612.REG [0] [i] = -1; + impl->YM2612.REG [1] [i] = -1; + } + + for ( i = 0xB6; i >= 0xB4; i-- ) + { + write0( impl, i, 0xC0 ); + write1( impl, i, 0xC0 ); + } + + for ( i = 0xB2; i >= 0x22; i-- ) + { + write0( impl, i, 0 ); + write1( impl, i, 0 ); + } + + write0( impl, 0x2A, 0x80 ); +} + +void Ym2612_reset( struct Ym2612_Emu* this ) +{ + impl_reset( &this->impl ); +} + +void Ym2612_write0( struct Ym2612_Emu* this, int addr, int data ) +{ + write0( &this->impl, addr, data ); +} + +void Ym2612_write1( struct Ym2612_Emu* this, int addr, int data ) +{ + write1( &this->impl, addr, data ); +} + +void Ym2612_mute_voices( struct Ym2612_Emu* this, int mask ) { this->impl.mute_mask = mask; } + +static void update_envelope_( struct slot_t* sl ) +{ + switch ( sl->Ecurp ) + { + case 0: + // Env_Attack_Next + + // Verified with Gynoug even in HQ (explode SFX) + sl->Ecnt = ENV_DECAY; + + sl->Einc = sl->EincD; + sl->Ecmp = sl->SLL; + sl->Ecurp = DECAY; + break; + + case 1: + // Env_Decay_Next + + // Verified with Gynoug even in HQ (explode SFX) + sl->Ecnt = sl->SLL; + + sl->Einc = sl->EincS; + sl->Ecmp = ENV_END; + sl->Ecurp = SUBSTAIN; + break; + + case 2: + // Env_Substain_Next(slot_t *SL) + if (sl->SEG & 8) // SSG envelope type + { + int release = sl->SEG & 1; + + if ( !release ) + { + // re KEY ON + + // sl->Fcnt = 0; + // sl->ChgEnM = ~0; + + sl->Ecnt = 0; + sl->Einc = sl->EincA; + sl->Ecmp = ENV_DECAY; + sl->Ecurp = ATTACK; + } + + set_seg( sl, (sl->SEG << 1) & 4 ); + + if ( !release ) + break; + } + // fall through + + case 3: + // Env_Release_Next + sl->Ecnt = ENV_END; + sl->Einc = 0; + sl->Ecmp = ENV_END + 1; + break; + + // default: no op + } +} + +static inline void update_envelope( struct slot_t* sl ) +{ + int ecmp = sl->Ecmp; + if ( (sl->Ecnt += sl->Einc) >= ecmp ) + update_envelope_( sl ); +} + + +typedef void (*ym2612_update_chan_t)( struct tables_t*, struct channel_*, short*, int ); + +#define GET_CURRENT_PHASE \ +int in0 = ch->SLOT[S0].Fcnt; \ +int in1 = ch->SLOT[S1].Fcnt; \ +int in2 = ch->SLOT[S2].Fcnt; \ +int in3 = ch->SLOT[S3].Fcnt; \ + +#define GET_CURRENT_LFO \ +int YM2612_LFOinc = g->LFOinc; \ +int YM2612_LFOcnt = g->LFOcnt + YM2612_LFOinc; + +#define CALC_EN( x ) \ + int temp##x = ENV_TAB [ch->SLOT [S##x].Ecnt >> ENV_LBITS] + ch->SLOT [S##x].TLL; \ + int en##x = ((temp##x ^ ch->SLOT [S##x].env_xor) + (env_LFO >> ch->SLOT [S##x].AMS)) & \ + ((temp##x - ch->SLOT [S##x].env_max) >> 31); + +#define GET_ENV \ +int const env_LFO = g->LFO_ENV_TAB [YM2612_LFOcnt >> LFO_LBITS & LFO_MASK]; \ +short const* const ENV_TAB = g->ENV_TAB; \ +CALC_EN( 0 ) \ +CALC_EN( 1 ) \ +CALC_EN( 2 ) \ +CALC_EN( 3 ) \ +int const* const TL_TAB = g->TL_TAB; + +#define DO_FEEDBACK \ +int CH_S0_OUT_0 = ch->S0_OUT [0]; \ +{ \ + int temp = in0 + ((CH_S0_OUT_0 + CH_S0_OUT_1) >> ch->FB); \ + CH_S0_OUT_1 = CH_S0_OUT_0; \ + CH_S0_OUT_0 = SINT( (temp >> SIN_LBITS) & SIN_MASK, en0 ); \ +} \ + +#define SINT( i, o ) (TL_TAB [g->SIN_TAB [(i)] + (o)]) + +#define DO_LIMIT \ +CH_OUTd >>= MAX_OUT_BITS - output_bits + 2; \ + +#define UPDATE_PHASE_CYCLE \ +unsigned freq_LFO = ((g->LFO_FREQ_TAB [YM2612_LFOcnt >> LFO_LBITS & LFO_MASK] * \ + ch->FMS) >> (LFO_HBITS - 1 + 1)) + (1 << (LFO_FMS_LBITS - 1)); \ +YM2612_LFOcnt += YM2612_LFOinc; \ +in0 += (ch->SLOT [S0].Finc * freq_LFO) >> (LFO_FMS_LBITS - 1); \ +in1 += (ch->SLOT [S1].Finc * freq_LFO) >> (LFO_FMS_LBITS - 1); \ +in2 += (ch->SLOT [S2].Finc * freq_LFO) >> (LFO_FMS_LBITS - 1); \ +in3 += (ch->SLOT [S3].Finc * freq_LFO) >> (LFO_FMS_LBITS - 1); + +#define UPDATE_ENV \ +int t0 = buf [0] + (CH_OUTd & ch->LEFT); \ +int t1 = buf [1] + (CH_OUTd & ch->RIGHT); \ +update_envelope( &ch->SLOT [0] ); \ +update_envelope( &ch->SLOT [1] ); \ +update_envelope( &ch->SLOT [2] ); \ +update_envelope( &ch->SLOT [3] ); + +#define DO_OUTPUT_0 \ +ch->S0_OUT [0] = CH_S0_OUT_0; \ +buf [0] = t0; \ +buf [1] = t1; \ +buf += 2; \ + +#define DO_OUTPUT_1 \ +ch->S0_OUT [1] = CH_S0_OUT_1; + +#define UPDATE_PHASE \ +ch->SLOT [S0].Fcnt = in0; \ +ch->SLOT [S1].Fcnt = in1; \ +ch->SLOT [S2].Fcnt = in2; \ +ch->SLOT [S3].Fcnt = in3; + +void ym2612_update_chan0( struct tables_t* g, struct channel_* ch, + short* buf, int length ) +{ + int not_end = ch->SLOT [S3].Ecnt - ENV_END; + int CH_S0_OUT_1 = ch->S0_OUT [1]; + + GET_CURRENT_PHASE + GET_CURRENT_LFO + + if ( !not_end ) + return; + + do + { + GET_ENV + DO_FEEDBACK + + int CH_OUTd; + int temp = in1 + CH_S0_OUT_1; + temp = in2 + SINT( (temp >> SIN_LBITS) & SIN_MASK, en1 ); + temp = in3 + SINT( (temp >> SIN_LBITS) & SIN_MASK, en2 ); + CH_OUTd = SINT( (temp >> SIN_LBITS) & SIN_MASK, en3 ); + + DO_LIMIT + UPDATE_PHASE_CYCLE + UPDATE_ENV + DO_OUTPUT_0 + } + while ( --length ); + DO_OUTPUT_1 + UPDATE_PHASE +} + +void ym2612_update_chan1( struct tables_t* g, struct channel_* ch, + short* buf, int length ) +{ + int not_end = ch->SLOT [S3].Ecnt - ENV_END; + int CH_S0_OUT_1 = ch->S0_OUT [1]; + + GET_CURRENT_PHASE + GET_CURRENT_LFO + + if ( !not_end ) + return; + + do + { + GET_ENV + DO_FEEDBACK + + int CH_OUTd; + int temp = in2 + CH_S0_OUT_1 + SINT( (in1 >> SIN_LBITS) & SIN_MASK, en1 ); + temp = in3 + SINT( (temp >> SIN_LBITS) & SIN_MASK, en2 ); + CH_OUTd = SINT( (temp >> SIN_LBITS) & SIN_MASK, en3 ); + + DO_LIMIT + UPDATE_PHASE_CYCLE + UPDATE_ENV + DO_OUTPUT_0 + } + while ( --length ); + DO_OUTPUT_1 + UPDATE_PHASE +} + +void ym2612_update_chan2( struct tables_t* g, struct channel_* ch, + short* buf, int length ) +{ + int not_end = ch->SLOT [S3].Ecnt - ENV_END; + int CH_S0_OUT_1 = ch->S0_OUT [1]; + + GET_CURRENT_PHASE + GET_CURRENT_LFO + + if ( !not_end ) + return; + + do + { + GET_ENV + DO_FEEDBACK + + int CH_OUTd; + int temp = in2 + SINT( (in1 >> SIN_LBITS) & SIN_MASK, en1 ); + temp = in3 + CH_S0_OUT_1 + SINT( (temp >> SIN_LBITS) & SIN_MASK, en2 ); + CH_OUTd = SINT( (temp >> SIN_LBITS) & SIN_MASK, en3 ); + + DO_LIMIT + UPDATE_PHASE_CYCLE + UPDATE_ENV + DO_OUTPUT_0 + } + while ( --length ); + DO_OUTPUT_1 + UPDATE_PHASE +} + +void ym2612_update_chan3( struct tables_t* g, struct channel_* ch, + short* buf, int length ) +{ + int not_end = ch->SLOT [S3].Ecnt - ENV_END; + int CH_S0_OUT_1 = ch->S0_OUT [1]; + + GET_CURRENT_PHASE + GET_CURRENT_LFO + + if ( !not_end ) + return; + + do + { + GET_ENV + DO_FEEDBACK + + int CH_OUTd; + int temp = in1 + CH_S0_OUT_1; + temp = in3 + SINT( (temp >> SIN_LBITS) & SIN_MASK, en1 ) + + SINT( (in2 >> SIN_LBITS) & SIN_MASK, en2 ); + CH_OUTd = SINT( (temp >> SIN_LBITS) & SIN_MASK, en3 ); + + DO_LIMIT + UPDATE_PHASE_CYCLE + UPDATE_ENV + DO_OUTPUT_0 + } + while ( --length ); + DO_OUTPUT_1 + UPDATE_PHASE +} + +void ym2612_update_chan4( struct tables_t* g, struct channel_* ch, + short* buf, int length ) +{ + int not_end = ch->SLOT [S3].Ecnt - ENV_END; + not_end |= ch->SLOT [S1].Ecnt - ENV_END; + + int CH_S0_OUT_1 = ch->S0_OUT [1]; + + GET_CURRENT_PHASE + GET_CURRENT_LFO + + if ( !not_end ) + return; + + do + { + GET_ENV + DO_FEEDBACK + + int CH_OUTd; + int temp = in3 + SINT( (in2 >> SIN_LBITS) & SIN_MASK, en2 ); + CH_OUTd = SINT( (temp >> SIN_LBITS) & SIN_MASK, en3 ) + + SINT( ((in1 + CH_S0_OUT_1) >> SIN_LBITS) & SIN_MASK, en1 ); + + DO_LIMIT + UPDATE_PHASE_CYCLE + UPDATE_ENV + DO_OUTPUT_0 + } + while ( --length ); + DO_OUTPUT_1 + UPDATE_PHASE +} + +void ym2612_update_chan5( struct tables_t* g, struct channel_* ch, + short* buf, int length ) +{ + int not_end = ch->SLOT [S3].Ecnt - ENV_END; + not_end |= ch->SLOT [S2].Ecnt - ENV_END; + not_end |= ch->SLOT [S1].Ecnt - ENV_END; + + int CH_S0_OUT_1 = ch->S0_OUT [1]; + + GET_CURRENT_PHASE + GET_CURRENT_LFO + + if ( !not_end ) + return; + + do + { + GET_ENV + DO_FEEDBACK + + int CH_OUTd; + int temp = CH_S0_OUT_1; + CH_OUTd = SINT( ((in3 + temp) >> SIN_LBITS) & SIN_MASK, en3 ) + + SINT( ((in1 + temp) >> SIN_LBITS) & SIN_MASK, en1 ) + + SINT( ((in2 + temp) >> SIN_LBITS) & SIN_MASK, en2 ); + + DO_LIMIT + UPDATE_PHASE_CYCLE + UPDATE_ENV + DO_OUTPUT_0 + } + while ( --length ); + DO_OUTPUT_1 + UPDATE_PHASE +} + +void ym2612_update_chan6( struct tables_t* g, struct channel_* ch, + short* buf, int length ) +{ + int not_end = ch->SLOT [S3].Ecnt - ENV_END; + not_end |= ch->SLOT [S2].Ecnt - ENV_END; + not_end |= ch->SLOT [S1].Ecnt - ENV_END; + + int CH_S0_OUT_1 = ch->S0_OUT [1]; + + GET_CURRENT_PHASE + GET_CURRENT_LFO + + if ( !not_end ) + return; + + do + { + GET_ENV + DO_FEEDBACK + + int CH_OUTd; + CH_OUTd = SINT( (in3 >> SIN_LBITS) & SIN_MASK, en3 ) + + SINT( ((in1 + CH_S0_OUT_1) >> SIN_LBITS) & SIN_MASK, en1 ) + + SINT( (in2 >> SIN_LBITS) & SIN_MASK, en2 ); + + DO_LIMIT + UPDATE_PHASE_CYCLE + UPDATE_ENV + DO_OUTPUT_0 + } + while ( --length ); + DO_OUTPUT_1 + UPDATE_PHASE +} + +void ym2612_update_chan7( struct tables_t* g, struct channel_* ch, + short* buf, int length ) +{ + int not_end = ch->SLOT [S3].Ecnt - ENV_END; + not_end |= ch->SLOT [S0].Ecnt - ENV_END; + not_end |= ch->SLOT [S2].Ecnt - ENV_END; + not_end |= ch->SLOT [S1].Ecnt - ENV_END; + + int CH_S0_OUT_1 = ch->S0_OUT [1]; + + GET_CURRENT_PHASE + GET_CURRENT_LFO + + if ( !not_end ) + return; + + do + { + GET_ENV + DO_FEEDBACK + + int CH_OUTd; + CH_OUTd = SINT( (in3 >> SIN_LBITS) & SIN_MASK, en3 ) + + SINT( (in1 >> SIN_LBITS) & SIN_MASK, en1 ) + + SINT( (in2 >> SIN_LBITS) & SIN_MASK, en2 ) + CH_S0_OUT_1; + + DO_LIMIT + UPDATE_PHASE_CYCLE + UPDATE_ENV + DO_OUTPUT_0 + } + while ( --length ); + DO_OUTPUT_1 + UPDATE_PHASE +} + +static void (*UPDATE_CHAN[8])(struct tables_t* g, struct channel_* ch, + short* buf, int length) = +{ + (void *)ym2612_update_chan0, + (void *)ym2612_update_chan1, + (void *)ym2612_update_chan2, + (void *)ym2612_update_chan3, + (void *)ym2612_update_chan4, + (void *)ym2612_update_chan5, + (void *)ym2612_update_chan6, + (void *)ym2612_update_chan7 +}; + +void run_timer( struct Ym2612_Impl* impl, int length ) +{ + int const step = 6; + int remain = length; + do + { + int n = step; + if ( n > remain ) + n = remain; + remain -= n; + + int i = n * impl->YM2612.TimerBase; + if (impl->YM2612.Mode & 1) // Timer A ON ? + { + // if ((impl->YM2612.TimerAcnt -= 14073) <= 0) // 13879=NTSC (old: 14475=NTSC 14586=PAL) + if ((impl->YM2612.TimerAcnt -= i) <= 0) + { + // timer a overflow + + impl->YM2612.Status |= (impl->YM2612.Mode & 0x04) >> 2; + impl->YM2612.TimerAcnt += impl->YM2612.TimerAL; + + if (impl->YM2612.Mode & 0x80) + { + KEY_ON( &impl->YM2612.CHANNEL [2], &impl->g, 0 ); + KEY_ON( &impl->YM2612.CHANNEL [2], &impl->g, 1 ); + KEY_ON( &impl->YM2612.CHANNEL [2], &impl->g, 2 ); + KEY_ON( &impl->YM2612.CHANNEL [2], &impl->g, 3 ); + } + } + } + + if (impl->YM2612.Mode & 2) // Timer B ON ? + { + // if ((impl->YM2612.TimerBcnt -= 14073) <= 0) // 13879=NTSC (old: 14475=NTSC 14586=PAL) + if ((impl->YM2612.TimerBcnt -= i) <= 0) + { + // timer b overflow + impl->YM2612.Status |= (impl->YM2612.Mode & 0x08) >> 2; + impl->YM2612.TimerBcnt += impl->YM2612.TimerBL; + } + } + } + while ( remain > 0 ); +} + +void impl_run( struct Ym2612_Impl* impl, int pair_count, short out [] ) +{ + if ( pair_count <= 0 ) + return; + + if ( impl->YM2612.Mode & 3 ) + run_timer( impl, pair_count ); + + // Mise à jour des pas des compteurs-frequences s'ils ont ete modifies + + int chi; + for ( chi = 0; chi < ym2612_channel_count; chi++ ) + { + struct channel_* ch = &impl->YM2612.CHANNEL [chi]; + if ( ch->SLOT [0].Finc != -1 ) + continue; + + int i2 = 0; + if ( chi == 2 && (impl->YM2612.Mode & 0x40) ) + i2 = 2; + + int i; + for ( i = 0; i < 4; i++ ) + { + // static int seq [4] = { 2, 1, 3, 0 }; + // if ( i2 ) i2 = seq [i]; + + struct slot_t* sl = &ch->SLOT [i]; + int finc = impl->g.FINC_TAB [ch->FNUM [i2]] >> (7 - ch->FOCT [i2]); + int ksr = ch->KC [i2] >> sl->KSR_S; // keycode attenuation + sl->Finc = (finc + sl->DT [ch->KC [i2]]) * sl->MUL; + if (sl->KSR != ksr) // si le KSR a change alors + { // les differents taux pour l'enveloppe sont mis à jour + sl->KSR = ksr; + + sl->EincA = sl->AR [ksr]; + sl->EincD = sl->DR [ksr]; + sl->EincS = sl->SR [ksr]; + sl->EincR = sl->RR [ksr]; + + if (sl->Ecurp == ATTACK) + { + sl->Einc = sl->EincA; + } + else if (sl->Ecurp == DECAY) + { + sl->Einc = sl->EincD; + } + else if (sl->Ecnt < ENV_END) + { + if (sl->Ecurp == SUBSTAIN) + sl->Einc = sl->EincS; + else if (sl->Ecurp == RELEASE) + sl->Einc = sl->EincR; + } + } + + if ( i2 ) + i2 = (i2 ^ 2) ^ (i2 >> 1); + } + } + + int i; + for ( i = 0; i < ym2612_channel_count; i++ ) + { + if ( !(impl->mute_mask & (1 << i)) && (i != 5 || !impl->YM2612.DAC) ) + UPDATE_CHAN [impl->YM2612.CHANNEL [i].ALGO]( &impl->g, &impl->YM2612.CHANNEL [i], out, pair_count ); + } + + impl->g.LFOcnt += impl->g.LFOinc * pair_count; +} + +void Ym2612_run( struct Ym2612_Emu* this, int pair_count, short out [] ) { impl_run( &this->impl, pair_count, out ); } -- cgit v1.2.3