You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1168 lines
34 KiB
1168 lines
34 KiB
/* |
|
* Copyright (C) 2002-2017 The DOSBox Team |
|
* OPL2/OPL3 emulation library |
|
* |
|
* This library 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 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 |
|
* Lesser General Public License for more details. |
|
* |
|
* You should have received a copy of the GNU Lesser General Public |
|
* License along with this library; if not, write to the Free Software |
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
|
*/ |
|
|
|
|
|
/* |
|
* Originally based on ADLIBEMU.C, an AdLib/OPL2 emulation library by Ken Silverman |
|
* Copyright (C) 1998-2001 Ken Silverman |
|
* Ken Silverman's official web site: "http://www.advsys.net/ken" |
|
*/ |
|
|
|
/* |
|
* Converted to HolyC by Alec Murphy, 2020-04-04 |
|
*/ |
|
|
|
#define NUM_CHANNELS 9 |
|
|
|
#define MAXOPERATORS NUM_CHANNELS*2 |
|
|
|
#define FL05 0.5 |
|
#define FL2 2.0 |
|
#define PI pi |
|
|
|
#define FIXEDPT 0x10000 // fixed-point calculations using 16+16 |
|
#define FIXEDPT_LFO 0x1000000 // fixed-point calculations using 8+24 |
|
|
|
#define WAVEPREC 1024 // waveform precision (10 bits) |
|
|
|
#define INTFREQU 14318180.0 / 288.0 // clocking of the chip |
|
|
|
|
|
#define OF_TYPE_ATT 0 |
|
#define OF_TYPE_DEC 1 |
|
#define OF_TYPE_REL 2 |
|
#define OF_TYPE_SUS 3 |
|
#define OF_TYPE_SUS_NOKEEP 4 |
|
#define OF_TYPE_OFF 5 |
|
|
|
#define ARC_CONTROL 0x00 |
|
#define ARC_TVS_KSR_MUL 0x20 |
|
#define ARC_KSL_OUTLEV 0x40 |
|
#define ARC_ATTR_DECR 0x60 |
|
#define ARC_SUSL_RELR 0x80 |
|
#define ARC_FREQ_NUM 0xa0 |
|
#define ARC_KON_BNUM 0xb0 |
|
#define ARC_PERC_MODE 0xbd |
|
#define ARC_FEEDBACK 0xc0 |
|
#define ARC_WAVE_SEL 0xe0 |
|
|
|
#define ARC_SECONDSET 0x100 // second operator set for OPL3 |
|
|
|
|
|
#define OP_ACT_OFF 0x00 |
|
#define OP_ACT_NORMAL 0x01 // regular channel activated (bitmasked) |
|
#define OP_ACT_PERC 0x02 // percussion channel activated (bitmasked) |
|
|
|
#define BLOCKBUF_SIZE 512 |
|
|
|
|
|
// vibrato constants |
|
#define VIBTAB_SIZE 8 |
|
#define VIBFAC 70/50000 // no braces, integer mul/div |
|
|
|
// tremolo constants and table |
|
#define TREMTAB_SIZE 53 |
|
#define TREM_FREQ 3.7 // tremolo at 3.7hz |
|
|
|
#define Bitu U64 |
|
#define Bits I64 |
|
#define Bit32u U32 |
|
#define Bit32s I32 |
|
#define Bit16u U16 |
|
#define Bit16s I16 |
|
#define Bit8u U8 |
|
#define Bit8s I8 |
|
#define fltype F64 |
|
|
|
class op_type { |
|
Bit32s cval, lastcval; // current output/last output (used for feedback) |
|
Bit32u tcount, wfpos, tinc; // time (position in waveform) and time increment |
|
fltype amp, step_amp; // and amplification (envelope) |
|
fltype vol; // volume |
|
fltype sustain_level; // sustain level |
|
Bit32s mfbi; // feedback amount |
|
fltype a0, a1, a2, a3; // attack rate function coefficients |
|
fltype decaymul, releasemul; // decay/release rate functions |
|
Bit32u op_state; // current state of operator (attack/decay/sustain/release/off) |
|
Bit32u toff; |
|
Bit32s freq_high; // highest three bits of the frequency, used for vibrato calculations |
|
Bit16s* cur_wform; // start of selected waveform |
|
Bit32u cur_wmask; // mask for selected waveform |
|
Bit32u act_state; // activity state (regular, percussion) |
|
Bool sus_keep; // keep sustain level when decay finished |
|
Bool vibrato,tremolo; // vibrato/tremolo enable bits |
|
|
|
// variables used to provide non-continuous envelopes |
|
Bit32u generator_pos; // for non-standard sample rates we need to determine how many samples have passed |
|
Bits cur_env_step; // current (standardized) sample position |
|
Bits env_step_a,env_step_d,env_step_r; // number of std samples of one step (for attack/decay/release mode) |
|
Bit8u step_skip_pos_a; // position of 8-cyclic step skipping (always 2^x to check against mask) |
|
Bits env_step_skip_a; // bitmask that determines if a step is skipped (respective bit is zero then) |
|
}; |
|
|
|
Bit32u generator_add; // should be a chip parameter |
|
|
|
// per-chip variables |
|
Bitu chip_num; |
|
op_type op[MAXOPERATORS]; |
|
|
|
Bits int_samplerate; |
|
|
|
Bit8u status; |
|
Bit32u opl_index; |
|
Bit8u adlibreg[256]; // adlib register set |
|
Bit8u wave_sel[22]; // waveform selection |
|
|
|
// vibrato/tremolo increment/counter |
|
Bit32u vibtab_pos; |
|
Bit32u vibtab_add; |
|
Bit32u tremtab_pos; |
|
Bit32u tremtab_add; |
|
|
|
fltype recipsamp; // inverse of sampling rate |
|
Bit16s wavtable[WAVEPREC*3]; // wave form table |
|
|
|
// vibrato/tremolo tables |
|
Bit32s vib_table[VIBTAB_SIZE]; |
|
Bit32s trem_table[TREMTAB_SIZE*2]; |
|
|
|
Bit32s vibval_const[BLOCKBUF_SIZE]; |
|
Bit32s tremval_const[BLOCKBUF_SIZE]; |
|
|
|
// vibrato value tables (used per-operator) |
|
Bit32s vibval_var1[BLOCKBUF_SIZE]; |
|
Bit32s vibval_var2[BLOCKBUF_SIZE]; |
|
//Bit32s vibval_var3[BLOCKBUF_SIZE]; |
|
//Bit32s vibval_var4[BLOCKBUF_SIZE]; |
|
|
|
// vibrato/trmolo value table pointers |
|
Bit32s *vibval1, *vibval2, *vibval3, *vibval4; |
|
Bit32s *tremval1, *tremval2, *tremval3, *tremval4; |
|
|
|
|
|
// key scale level lookup table |
|
fltype kslmul[4] = { |
|
0.0, 0.5, 0.25, 1.0 // -> 0, 3, 1.5, 6 dB/oct |
|
}; |
|
|
|
// frequency multiplicator lookup table |
|
fltype frqmul_tab[16] = { |
|
0.5,1,2,3,4,5,6,7,8,9,10,10,12,12,15,15 |
|
}; |
|
// calculated frequency multiplication values (depend on sampling rate) |
|
fltype frqmul[16]; |
|
|
|
// key scale levels |
|
Bit8u kslev[8][16]; |
|
|
|
// map a channel number to the register offset of the modulator (=register base) |
|
Bit8u modulatorbase[9] = { |
|
0,1,2, |
|
8,9,10, |
|
16,17,18 |
|
}; |
|
|
|
// map a register base to a modulator operator number or operator number |
|
Bit8u regbase2modop[22] = { |
|
0,1,2,0,1,2,0,0,3,4,5,3,4,5,0,0,6,7,8,6,7,8 |
|
}; |
|
Bit8u regbase2op[22] = { |
|
0,1,2,9,10,11,0,0,3,4,5,12,13,14,0,0,6,7,8,15,16,17 |
|
}; |
|
|
|
// start of the waveform |
|
Bit32u waveform[8] = { |
|
WAVEPREC, |
|
WAVEPREC>>1, |
|
WAVEPREC, |
|
(WAVEPREC*3)>>2, |
|
0, |
|
0, |
|
(WAVEPREC*5)>>2, |
|
WAVEPREC<<1 |
|
}; |
|
|
|
// length of the waveform as mask |
|
Bit32u wavemask[8] = { |
|
WAVEPREC-1, |
|
WAVEPREC-1, |
|
(WAVEPREC>>1)-1, |
|
(WAVEPREC>>1)-1, |
|
WAVEPREC-1, |
|
((WAVEPREC*3)>>2)-1, |
|
WAVEPREC>>1, |
|
WAVEPREC-1 |
|
}; |
|
|
|
// where the first entry resides |
|
Bit32u wavestart[8] = { |
|
0, |
|
WAVEPREC>>1, |
|
0, |
|
WAVEPREC>>2, |
|
0, |
|
0, |
|
0, |
|
WAVEPREC>>3 |
|
}; |
|
|
|
// envelope generator function constants |
|
fltype attackconst[4] = { |
|
(1/2.82624), |
|
(1/2.25280), |
|
(1/1.88416), |
|
(1/1.59744) |
|
}; |
|
fltype decrelconst[4] = { |
|
(1/39.28064), |
|
(1/31.41608), |
|
(1/26.17344), |
|
(1/22.44608) |
|
}; |
|
|
|
U0 operator_advance(op_type* op_pt, Bit32s vib) { |
|
op_pt->wfpos = op_pt->tcount; // waveform position |
|
|
|
// advance waveform time |
|
op_pt->tcount += op_pt->tinc; |
|
op_pt->tcount += (op_pt->tinc)*vib/FIXEDPT; |
|
|
|
op_pt->generator_pos += generator_add; |
|
} |
|
|
|
U0 operator_advance_drums(op_type* op_pt1, Bit32s vib1, op_type* op_pt2, Bit32s vib2, op_type* op_pt3, Bit32s vib3) { |
|
Bit32u c1 = op_pt1->tcount/FIXEDPT; |
|
Bit32u c3 = op_pt3->tcount/FIXEDPT; |
|
Bit32u phasebit = Cond((((c1 & 0x88) ^ ((c1<<5) & 0x80)) | ((c3 ^ (c3<<2)) & 0x20)), 0x02, 0x00); |
|
|
|
Bit32u noisebit = RandU64()&1; |
|
|
|
Bit32u snare_phase_bit = ((((op_pt1->tcount/FIXEDPT) / 0x100))&1); |
|
|
|
//Hihat |
|
Bit32u inttm = (phasebit<<8) | (0x34<<(phasebit ^ (noisebit<<1))); |
|
op_pt1->wfpos = inttm*FIXEDPT; // waveform position |
|
// advance waveform time |
|
op_pt1->tcount += op_pt1->tinc; |
|
op_pt1->tcount += (op_pt1->tinc)*vib1/FIXEDPT; |
|
op_pt1->generator_pos += generator_add; |
|
|
|
//Snare |
|
inttm = ((1+snare_phase_bit) ^ noisebit)<<8; |
|
op_pt2->wfpos = inttm*FIXEDPT; // waveform position |
|
// advance waveform time |
|
op_pt2->tcount += op_pt2->tinc; |
|
op_pt2->tcount += (op_pt2->tinc)*vib2/FIXEDPT; |
|
op_pt2->generator_pos += generator_add; |
|
|
|
//Cymbal |
|
inttm = (1+phasebit)<<8; |
|
op_pt3->wfpos = inttm*FIXEDPT; // waveform position |
|
// advance waveform time |
|
op_pt3->tcount += op_pt3->tinc; |
|
op_pt3->tcount += (op_pt3->tinc)*vib3/FIXEDPT; |
|
op_pt3->generator_pos += generator_add; |
|
} |
|
|
|
// output level is sustained, mode changes only when operator is turned off (->release) |
|
// or when the keep-sustained bit is turned off (->sustain_nokeep) |
|
U0 operator_output(op_type* op_pt, Bit32s modulator, Bit32s trem) { |
|
if (op_pt->op_state != OF_TYPE_OFF) { |
|
op_pt->lastcval = op_pt->cval; |
|
Bit32u i = ((op_pt->wfpos+modulator)/FIXEDPT); |
|
|
|
// wform: -16384 to 16383 (0x4000) |
|
// trem : 32768 to 65535 (0x10000) |
|
// step_amp: 0.0 to 1.0 |
|
// vol : 1/2^14 to 1/2^29 (/0x4000; /1../0x8000) |
|
|
|
op_pt->cval = (op_pt->step_amp*op_pt->vol*op_pt->cur_wform[i&op_pt->cur_wmask]*trem/16.0); |
|
} |
|
} |
|
|
|
// no action, operator is off |
|
U0 operator_off(op_type* op_pt) { |
|
} |
|
|
|
// output level is sustained, mode changes only when operator is turned off (->release) |
|
// or when the keep-sustained bit is turned off (->sustain_nokeep) |
|
U0 operator_sustain(op_type* op_pt) { |
|
Bit32u num_steps_add = op_pt->generator_pos/FIXEDPT; // number of (standardized) samples |
|
Bit32u ct; |
|
for (ct=0; ct<num_steps_add; ct++) { |
|
op_pt->cur_env_step++; |
|
} |
|
op_pt->generator_pos -= num_steps_add*FIXEDPT; |
|
} |
|
|
|
// operator in release mode, if output level reaches zero the operator is turned off |
|
U0 operator_release(op_type* op_pt) { |
|
// ??? boundary? |
|
if (op_pt->amp > 0.00000001) { |
|
// release phase |
|
op_pt->amp *= op_pt->releasemul; |
|
} |
|
|
|
Bit32u num_steps_add = op_pt->generator_pos/FIXEDPT; // number of (standardized) samples |
|
Bit32u ct; |
|
for (ct=0; ct<num_steps_add; ct++) { |
|
op_pt->cur_env_step++; // sample counter |
|
if ((op_pt->cur_env_step & op_pt->env_step_r)==0) { |
|
if (op_pt->amp <= 0.00000001) { |
|
// release phase finished, turn off this operator |
|
op_pt->amp = 0.0; |
|
if (op_pt->op_state == OF_TYPE_REL) { |
|
op_pt->op_state = OF_TYPE_OFF; |
|
} |
|
} |
|
op_pt->step_amp = op_pt->amp; |
|
} |
|
} |
|
op_pt->generator_pos -= num_steps_add*FIXEDPT; |
|
} |
|
|
|
// operator in decay mode, if sustain level is reached the output level is either |
|
// kept (sustain level keep enabled) or the operator is switched into release mode |
|
U0 operator_decay(op_type* op_pt) { |
|
if (op_pt->amp > op_pt->sustain_level) { |
|
// decay phase |
|
op_pt->amp *= op_pt->decaymul; |
|
} |
|
|
|
Bit32u num_steps_add = op_pt->generator_pos/FIXEDPT; // number of (standardized) samples |
|
Bit32u ct; |
|
for (ct=0; ct<num_steps_add; ct++) { |
|
op_pt->cur_env_step++; |
|
if ((op_pt->cur_env_step & op_pt->env_step_d)==0) { |
|
if (op_pt->amp <= op_pt->sustain_level) { |
|
// decay phase finished, sustain level reached |
|
if (op_pt->sus_keep) { |
|
// keep sustain level (until turned off) |
|
op_pt->op_state = OF_TYPE_SUS; |
|
op_pt->amp = op_pt->sustain_level; |
|
} else { |
|
// next: release phase |
|
op_pt->op_state = OF_TYPE_SUS_NOKEEP; |
|
} |
|
} |
|
op_pt->step_amp = op_pt->amp; |
|
} |
|
} |
|
op_pt->generator_pos -= num_steps_add*FIXEDPT; |
|
} |
|
|
|
// operator in attack mode, if full output level is reached, |
|
// the operator is switched into decay mode |
|
U0 operator_attack(op_type* op_pt) { |
|
op_pt->amp = ((op_pt->a3*op_pt->amp + op_pt->a2)*op_pt->amp + op_pt->a1)*op_pt->amp + op_pt->a0; |
|
|
|
Bit32u num_steps_add = op_pt->generator_pos/FIXEDPT; // number of (standardized) samples |
|
Bit32u ct; |
|
for (ct=0; ct<num_steps_add; ct++) { |
|
op_pt->cur_env_step++; // next sample |
|
if ((op_pt->cur_env_step & op_pt->env_step_a)==0) { // check if next step already reached |
|
if (op_pt->amp > 1.0) { |
|
// attack phase finished, next: decay |
|
op_pt->op_state = OF_TYPE_DEC; |
|
op_pt->amp = 1.0; |
|
op_pt->step_amp = 1.0; |
|
} |
|
op_pt->step_skip_pos_a <<= 1; |
|
if (op_pt->step_skip_pos_a==0) op_pt->step_skip_pos_a = 1; |
|
if (op_pt->step_skip_pos_a & op_pt->env_step_skip_a) { // check if required to skip next step |
|
op_pt->step_amp = op_pt->amp; |
|
} |
|
} |
|
} |
|
op_pt->generator_pos -= num_steps_add*FIXEDPT; |
|
} |
|
|
|
Bit8u step_skip_mask[5] = {0xff, 0xfe, 0xee, 0xba, 0xaa}; |
|
|
|
U0 change_attackrate(Bitu regbase, op_type* op_pt) { |
|
Bits attackrate = adlibreg[ARC_ATTR_DECR+regbase]>>4; |
|
if (attackrate) { |
|
fltype f = (Pow(FL2,attackrate+(op_pt->toff>>2)-1)*attackconst[op_pt->toff&3]*recipsamp); |
|
// attack rate coefficients |
|
op_pt->a0 = (0.0377*f); |
|
op_pt->a1 = (10.73*f+1); |
|
op_pt->a2 = (-17.57*f); |
|
op_pt->a3 = (7.42*f); |
|
|
|
Bits step_skip = attackrate*4 + op_pt->toff; |
|
Bits steps = step_skip >> 2; |
|
op_pt->env_step_a = (1<<Cond(steps<=12,12-steps,0))-1; |
|
|
|
Bits step_num = Cond((step_skip<=48),(4-(step_skip&3)),0); |
|
op_pt->env_step_skip_a = step_skip_mask[step_num]; |
|
|
|
if (step_skip>=62) { |
|
op_pt->a0 = (2.0); // something that triggers an immediate transition to amp:=1.0 |
|
op_pt->a1 = (0.0); |
|
op_pt->a2 = (0.0); |
|
op_pt->a3 = (0.0); |
|
} |
|
} else { |
|
// attack disabled |
|
op_pt->a0 = 0.0; |
|
op_pt->a1 = 1.0; |
|
op_pt->a2 = 0.0; |
|
op_pt->a3 = 0.0; |
|
op_pt->env_step_a = 0; |
|
op_pt->env_step_skip_a = 0; |
|
} |
|
} |
|
|
|
U0 change_decayrate(Bitu regbase, op_type* op_pt) { |
|
Bits decayrate = adlibreg[ARC_ATTR_DECR+regbase]&15; |
|
// decaymul should be 1.0 when decayrate==0 |
|
if (decayrate) { |
|
fltype f = (-7.4493*decrelconst[op_pt->toff&3]*recipsamp); |
|
op_pt->decaymul = (Pow(FL2,f*Pow(FL2,(decayrate+(op_pt->toff>>2))))); |
|
Bits steps = (decayrate*4 + op_pt->toff) >> 2; |
|
op_pt->env_step_d = (1<<Cond(steps<=12,12-steps,0))-1; |
|
} else { |
|
op_pt->decaymul = 1.0; |
|
op_pt->env_step_d = 0; |
|
} |
|
} |
|
|
|
U0 change_releaserate(Bitu regbase, op_type* op_pt) { |
|
Bits releaserate = adlibreg[ARC_SUSL_RELR+regbase]&15; |
|
// releasemul should be 1.0 when releaserate==0 |
|
if (releaserate) { |
|
fltype f = (-7.4493*decrelconst[op_pt->toff&3]*recipsamp); |
|
op_pt->releasemul = (Pow(FL2,f*Pow(FL2,(releaserate+(op_pt->toff>>2))))); |
|
Bits steps = (releaserate*4 + op_pt->toff) >> 2; |
|
op_pt->env_step_r = (1<<Cond(steps<=12,12-steps,0))-1; |
|
} else { |
|
op_pt->releasemul = 1.0; |
|
op_pt->env_step_r = 0; |
|
} |
|
} |
|
|
|
U0 change_sustainlevel(Bitu regbase, op_type* op_pt) { |
|
Bits sustainlevel = adlibreg[ARC_SUSL_RELR+regbase]>>4; |
|
// sustainlevel should be 0.0 when sustainlevel==15 (max) |
|
if (sustainlevel<15) { |
|
op_pt->sustain_level = (Pow(FL2,sustainlevel * (-FL05))); |
|
} else { |
|
op_pt->sustain_level = 0.0; |
|
} |
|
} |
|
|
|
U0 change_waveform(Bitu regbase, op_type* op_pt) { |
|
// waveform selection |
|
op_pt->cur_wmask = wavemask[wave_sel[regbase]]; |
|
op_pt->cur_wform = &wavtable[waveform[wave_sel[regbase]]]; |
|
// (might need to be adapted to waveform type here...) |
|
} |
|
|
|
U0 change_keepsustain(Bitu regbase, op_type* op_pt) { |
|
op_pt->sus_keep = (adlibreg[ARC_TVS_KSR_MUL+regbase]&0x20)>0; |
|
if (op_pt->op_state==OF_TYPE_SUS) { |
|
if (!op_pt->sus_keep) op_pt->op_state = OF_TYPE_SUS_NOKEEP; |
|
} else if (op_pt->op_state==OF_TYPE_SUS_NOKEEP) { |
|
if (op_pt->sus_keep) op_pt->op_state = OF_TYPE_SUS; |
|
} |
|
} |
|
|
|
// enable/disable vibrato/tremolo LFO effects |
|
U0 change_vibrato(Bitu regbase, op_type* op_pt) { |
|
op_pt->vibrato = (adlibreg[ARC_TVS_KSR_MUL+regbase]&0x40)!=0; |
|
op_pt->tremolo = (adlibreg[ARC_TVS_KSR_MUL+regbase]&0x80)!=0; |
|
} |
|
|
|
// change amount of self-feedback |
|
U0 change_feedback(Bitu chanbase, op_type* op_pt) { |
|
Bits feedback = adlibreg[ARC_FEEDBACK+chanbase]&14; |
|
if (feedback) op_pt->mfbi = (Pow(FL2,((feedback>>1)+8))); |
|
else op_pt->mfbi = 0; |
|
} |
|
|
|
U0 change_frequency(Bitu chanbase, Bitu regbase, op_type* op_pt) { |
|
// frequency |
|
Bit32u frn = (((adlibreg[ARC_KON_BNUM+chanbase])&3)<<8) + adlibreg[ARC_FREQ_NUM+chanbase]; |
|
// block number/octave |
|
Bit32u oct = (((adlibreg[ARC_KON_BNUM+chanbase])>>2)&7); |
|
op_pt->freq_high = ((frn>>7)&7); |
|
|
|
// keysplit |
|
Bit32u note_sel = (adlibreg[8]>>6)&1; |
|
op_pt->toff = ((frn>>9)&(note_sel^1)) | ((frn>>8)¬e_sel); |
|
op_pt->toff += (oct<<1); |
|
|
|
// envelope scaling (KSR) |
|
if (!(adlibreg[ARC_TVS_KSR_MUL+regbase]&0x10)) op_pt->toff >>= 2; |
|
|
|
// 20+a0+b0: |
|
op_pt->tinc = ((((frn<<oct))*frqmul[adlibreg[ARC_TVS_KSR_MUL+regbase]&15])); |
|
// 40+a0+b0: |
|
fltype vol_in = ((adlibreg[ARC_KSL_OUTLEV+regbase]&63) + |
|
kslmul[adlibreg[ARC_KSL_OUTLEV+regbase]>>6]*kslev[oct][frn>>6]); |
|
op_pt->vol = (Pow(FL2,(vol_in * -0.125 - 14))); |
|
|
|
// operator frequency changed, care about features that depend on it |
|
change_attackrate(regbase,op_pt); |
|
change_decayrate(regbase,op_pt); |
|
change_releaserate(regbase,op_pt); |
|
} |
|
|
|
U0 enable_operator(Bitu regbase, op_type* op_pt, Bit32u act_type) { |
|
// check if this is really an off-on transition |
|
if (op_pt->act_state == OP_ACT_OFF) { |
|
Bits wselbase = regbase; |
|
if (wselbase>=ARC_SECONDSET) wselbase -= (ARC_SECONDSET-22); // second set starts at 22 |
|
|
|
op_pt->tcount = wavestart[wave_sel[wselbase]]*FIXEDPT; |
|
|
|
// start with attack mode |
|
op_pt->op_state = OF_TYPE_ATT; |
|
op_pt->act_state |= act_type; |
|
} |
|
} |
|
|
|
U0 disable_operator(op_type* op_pt, Bit32u act_type) { |
|
// check if this is really an on-off transition |
|
if (op_pt->act_state != OP_ACT_OFF) { |
|
op_pt->act_state &= (~act_type); |
|
if (op_pt->act_state == OP_ACT_OFF) { |
|
if (op_pt->op_state != OF_TYPE_OFF) op_pt->op_state = OF_TYPE_REL; |
|
} |
|
} |
|
} |
|
|
|
U0 adlib_init(Bit32u samplerate) { |
|
Bits i, j, oct; |
|
|
|
int_samplerate = samplerate; |
|
|
|
generator_add = (INTFREQU*FIXEDPT/int_samplerate); |
|
|
|
MemSet(adlibreg,0,sizeof(adlibreg)); |
|
MemSet(op,0,sizeof(op_type)*MAXOPERATORS); |
|
MemSet(wave_sel,0,sizeof(wave_sel)); |
|
|
|
for (i=0;i<MAXOPERATORS;i++) { |
|
op[i].op_state = OF_TYPE_OFF; |
|
op[i].act_state = OP_ACT_OFF; |
|
op[i].amp = 0.0; |
|
op[i].step_amp = 0.0; |
|
op[i].vol = 0.0; |
|
op[i].tcount = 0; |
|
op[i].tinc = 0; |
|
op[i].toff = 0; |
|
op[i].cur_wmask = wavemask[0]; |
|
op[i].cur_wform = &wavtable[waveform[0]]; |
|
op[i].freq_high = 0; |
|
|
|
op[i].generator_pos = 0; |
|
op[i].cur_env_step = 0; |
|
op[i].env_step_a = 0; |
|
op[i].env_step_d = 0; |
|
op[i].env_step_r = 0; |
|
op[i].step_skip_pos_a = 0; |
|
op[i].env_step_skip_a = 0; |
|
} |
|
|
|
recipsamp = 1.0 / int_samplerate; |
|
for (i=15;i>=0;i--) { |
|
frqmul[i] = (frqmul_tab[i]*INTFREQU/WAVEPREC*FIXEDPT*recipsamp); |
|
} |
|
|
|
status = 0; |
|
opl_index = 0; |
|
|
|
|
|
// create vibrato table |
|
vib_table[0] = 8; |
|
vib_table[1] = 4; |
|
vib_table[2] = 0; |
|
vib_table[3] = -4; |
|
for (i=4; i<VIBTAB_SIZE; i++) vib_table[i] = vib_table[i-4]*-1; |
|
|
|
// vibrato at ~6.1 ?? (opl3 docs say 6.1, opl4 docs say 6.0, y8950 docs say 6.4) |
|
vibtab_add = (VIBTAB_SIZE*FIXEDPT_LFO/8192*INTFREQU/int_samplerate); |
|
vibtab_pos = 0; |
|
|
|
for (i=0; i<BLOCKBUF_SIZE; i++) vibval_const[i] = 0; |
|
|
|
|
|
// create tremolo table |
|
Bit32s trem_table_int[TREMTAB_SIZE]; |
|
for (i=0; i<14; i++) trem_table_int[i] = i-13; // upwards (13 to 26 -> -0.5/6 to 0) |
|
for (i=14; i<41; i++) trem_table_int[i] = -i+14; // downwards (26 to 0 -> 0 to -1/6) |
|
for (i=41; i<53; i++) trem_table_int[i] = i-40-26; // upwards (1 to 12 -> -1/6 to -0.5/6) |
|
|
|
for (i=0; i<TREMTAB_SIZE; i++) { |
|
// 0.0 .. -26/26*4.8/6 == [0.0 .. -0.8], 4/53 steps == [1 .. 0.57] |
|
fltype trem_val1=((trem_table_int[i])*4.8/26.0/6.0); // 4.8db |
|
fltype trem_val2=(((trem_table_int[i]/4))*1.2/6.0/6.0); // 1.2db (larger stepping) |
|
|
|
trem_table[i] = (Pow(FL2,trem_val1)*FIXEDPT); |
|
trem_table[TREMTAB_SIZE+i] = (Pow(FL2,trem_val2)*FIXEDPT); |
|
} |
|
|
|
// tremolo at 3.7hz |
|
tremtab_add = (TREMTAB_SIZE * TREM_FREQ * FIXEDPT_LFO / int_samplerate); |
|
tremtab_pos = 0; |
|
|
|
for (i=0; i<BLOCKBUF_SIZE; i++) tremval_const[i] = FIXEDPT; |
|
|
|
|
|
Bitu initfirstime = 0; |
|
if (!initfirstime) { |
|
initfirstime = 1; |
|
|
|
// create waveform tables |
|
for (i=0;i<(WAVEPREC>>1);i++) { |
|
wavtable[(i<<1) +WAVEPREC] = (16384*Sin(((i<<1) )*PI*2/WAVEPREC)); |
|
wavtable[(i<<1)+1+WAVEPREC] = (16384*Sin(((i<<1)+1)*PI*2/WAVEPREC)); |
|
wavtable[i] = wavtable[(i<<1) +WAVEPREC]; |
|
// alternative: (zero-less) |
|
/* wavtable[(i<<1) +WAVEPREC] = (16384*sin(((i<<2)+1)*PI/WAVEPREC)); |
|
wavtable[(i<<1)+1+WAVEPREC] = (16384*sin(((i<<2)+3)*PI/WAVEPREC)); |
|
wavtable[i] = wavtable[(i<<1)-1+WAVEPREC]; */ |
|
} |
|
for (i=0;i<(WAVEPREC>>3);i++) { |
|
wavtable[i+(WAVEPREC<<1)] = wavtable[i+(WAVEPREC>>3)]-16384; |
|
wavtable[i+((WAVEPREC*17)>>3)] = wavtable[i+(WAVEPREC>>2)]+16384; |
|
} |
|
|
|
// key scale level table verified ([table in book]*8/3) |
|
kslev[7][0] = 0; kslev[7][1] = 24; kslev[7][2] = 32; kslev[7][3] = 37; |
|
kslev[7][4] = 40; kslev[7][5] = 43; kslev[7][6] = 45; kslev[7][7] = 47; |
|
kslev[7][8] = 48; |
|
for (i=9;i<16;i++) kslev[7][i] = (i+41); |
|
for (j=6;j>=0;j--) { |
|
for (i=0;i<16;i++) { |
|
oct = kslev[j+1][i]-8; |
|
if (oct < 0) oct = 0; |
|
kslev[j][i] = oct; |
|
} |
|
} |
|
} |
|
|
|
} |
|
|
|
U0 adlib_write(Bitu idx, Bit8u val) { |
|
Bit32u second_set = idx&0x100; |
|
adlibreg[idx] = val; |
|
I64 num; |
|
Bitu base; |
|
Bitu modop; |
|
Bitu chanbase; |
|
Bitu regbase; |
|
Bits opbase; |
|
Bits modbase; |
|
op_type* op_ptr; |
|
|
|
switch (idx&0xf0) { |
|
case ARC_CONTROL: |
|
// here we check for the second set registers, too: |
|
switch (idx) { |
|
case 0x02: // timer1 counter |
|
case 0x03: // timer2 counter |
|
break; |
|
case 0x04: |
|
// IRQ reset, timer mask/start |
|
if (val&0x80) { |
|
// clear IRQ bits in status register |
|
status &= ~0x60; |
|
} else { |
|
status = 0; |
|
} |
|
break; |
|
case 0x08: |
|
// CSW, note select |
|
break; |
|
default: |
|
break; |
|
} |
|
break; |
|
case ARC_TVS_KSR_MUL: |
|
case ARC_TVS_KSR_MUL+0x10: { |
|
// tremolo/vibrato/sustain keeping enabled; key scale rate; frequency multiplication |
|
num = idx&7; |
|
base = (idx-ARC_TVS_KSR_MUL)&0xff; |
|
if ((num<6) && (base<22)) { |
|
modop = regbase2modop[Cond(second_set,(base+22),base)]; |
|
regbase = base+second_set; |
|
chanbase = Cond(second_set,(modop-18+ARC_SECONDSET),modop); |
|
|
|
// change tremolo/vibrato and sustain keeping of this operator |
|
op_ptr = &op[modop+Cond((num<3), 0, 9)]; |
|
change_keepsustain(regbase,op_ptr); |
|
change_vibrato(regbase,op_ptr); |
|
|
|
// change frequency calculations of this operator as |
|
// key scale rate and frequency multiplicator can be changed |
|
change_frequency(chanbase,base,op_ptr); |
|
} |
|
} |
|
break; |
|
case ARC_KSL_OUTLEV: |
|
case ARC_KSL_OUTLEV+0x10: { |
|
// key scale level; output rate |
|
num = idx&7; |
|
base = (idx-ARC_KSL_OUTLEV)&0xff; |
|
if ((num<6) && (base<22)) { |
|
modop = regbase2modop[Cond(second_set,(base+22),base)]; |
|
chanbase = Cond(second_set,(modop-18+ARC_SECONDSET),modop); |
|
|
|
// change frequency calculations of this operator as |
|
// key scale level and output rate can be changed |
|
op_ptr = &op[modop+Cond((num<3), 0, 9)]; |
|
change_frequency(chanbase,base,op_ptr); |
|
} |
|
} |
|
break; |
|
case ARC_ATTR_DECR: |
|
case ARC_ATTR_DECR+0x10: { |
|
// attack/decay rates |
|
num = idx&7; |
|
base = (idx-ARC_ATTR_DECR)&0xff; |
|
if ((num<6) && (base<22)) { |
|
regbase = base+second_set; |
|
|
|
// change attack rate and decay rate of this operator |
|
op_ptr = &op[regbase2op[Cond(second_set,(base+22),base)]]; |
|
change_attackrate(regbase,op_ptr); |
|
change_decayrate(regbase,op_ptr); |
|
} |
|
} |
|
break; |
|
case ARC_SUSL_RELR: |
|
case ARC_SUSL_RELR+0x10: { |
|
// sustain level; release rate |
|
num = idx&7; |
|
base = (idx-ARC_SUSL_RELR)&0xff; |
|
if ((num<6) && (base<22)) { |
|
regbase = base+second_set; |
|
|
|
// change sustain level and release rate of this operator |
|
op_ptr = &op[regbase2op[Cond(second_set,(base+22),base)]]; |
|
change_releaserate(regbase,op_ptr); |
|
change_sustainlevel(regbase,op_ptr); |
|
} |
|
} |
|
break; |
|
case ARC_FREQ_NUM: { |
|
// 0xa0-0xa8 low8 frequency |
|
base = (idx-ARC_FREQ_NUM)&0xff; |
|
if (base<9) { |
|
opbase = Cond(second_set,(base+18),base); |
|
// regbase of modulator: |
|
modbase = modulatorbase[base]+second_set; |
|
|
|
chanbase = base+second_set; |
|
|
|
change_frequency(chanbase,modbase,&op[opbase]); |
|
change_frequency(chanbase,modbase+3,&op[opbase+9]); |
|
} |
|
} |
|
break; |
|
case ARC_KON_BNUM: { |
|
if (idx == ARC_PERC_MODE) { |
|
if ((val&0x30) == 0x30) { // BassDrum active |
|
enable_operator(16,&op[6],OP_ACT_PERC); |
|
change_frequency(6,16,&op[6]); |
|
enable_operator(16+3,&op[6+9],OP_ACT_PERC); |
|
change_frequency(6,16+3,&op[6+9]); |
|
} else { |
|
disable_operator(&op[6],OP_ACT_PERC); |
|
disable_operator(&op[6+9],OP_ACT_PERC); |
|
} |
|
if ((val&0x28) == 0x28) { // Snare active |
|
enable_operator(17+3,&op[16],OP_ACT_PERC); |
|
change_frequency(7,17+3,&op[16]); |
|
} else { |
|
disable_operator(&op[16],OP_ACT_PERC); |
|
} |
|
if ((val&0x24) == 0x24) { // TomTom active |
|
enable_operator(18,&op[8],OP_ACT_PERC); |
|
change_frequency(8,18,&op[8]); |
|
} else { |
|
disable_operator(&op[8],OP_ACT_PERC); |
|
} |
|
if ((val&0x22) == 0x22) { // Cymbal active |
|
enable_operator(18+3,&op[8+9],OP_ACT_PERC); |
|
change_frequency(8,18+3,&op[8+9]); |
|
} else { |
|
disable_operator(&op[8+9],OP_ACT_PERC); |
|
} |
|
if ((val&0x21) == 0x21) { // Hihat active |
|
enable_operator(17,&op[7],OP_ACT_PERC); |
|
change_frequency(7,17,&op[7]); |
|
} else { |
|
disable_operator(&op[7],OP_ACT_PERC); |
|
} |
|
|
|
break; |
|
} |
|
// regular 0xb0-0xb8 |
|
base = (idx-ARC_KON_BNUM)&0xff; |
|
if (base<9) { |
|
opbase = Cond(second_set,(base+18),base); |
|
// regbase of modulator: |
|
modbase = modulatorbase[base]+second_set; |
|
|
|
if (val&32) { |
|
// operator switched on |
|
enable_operator(modbase,&op[opbase],OP_ACT_NORMAL); // modulator (if 2op) |
|
enable_operator(modbase+3,&op[opbase+9],OP_ACT_NORMAL); // carrier (if 2op) |
|
} else { |
|
// operator switched off |
|
disable_operator(&op[opbase],OP_ACT_NORMAL); |
|
disable_operator(&op[opbase+9],OP_ACT_NORMAL); |
|
} |
|
|
|
chanbase = base+second_set; |
|
|
|
// change frequency calculations of modulator and carrier (2op) as |
|
// the frequency of the channel has changed |
|
change_frequency(chanbase,modbase,&op[opbase]); |
|
change_frequency(chanbase,modbase+3,&op[opbase+9]); |
|
} |
|
} |
|
break; |
|
case ARC_FEEDBACK: { |
|
// 0xc0-0xc8 feedback/modulation type (AM/FM) |
|
base = (idx-ARC_FEEDBACK)&0xff; |
|
if (base<9) { |
|
opbase = Cond(second_set,(base+18),base); |
|
chanbase = base+second_set; |
|
change_feedback(chanbase,&op[opbase]); |
|
} |
|
} |
|
break; |
|
case ARC_WAVE_SEL: |
|
case ARC_WAVE_SEL+0x10: { |
|
num = idx&7; |
|
base = (idx-ARC_WAVE_SEL)&0xff; |
|
if ((num<6) && (base<22)) { |
|
if (adlibreg[0x01]&0x20) { |
|
// wave selection enabled, change waveform |
|
wave_sel[base] = val&3; |
|
op_ptr = &op[regbase2modop[base]+Cond((num<3), 0, 9)]; |
|
change_waveform(base,op_ptr); |
|
} |
|
} |
|
} |
|
break; |
|
default: |
|
break; |
|
} |
|
} |
|
|
|
Bitu adlib_reg_read(Bitu port) { |
|
// opl2-detection routines require ret&6 to be 6 |
|
if ((port&1)==0) { |
|
return status|6; |
|
} |
|
return 0xff; |
|
} |
|
|
|
U0 adlib_write_index(Bitu port, Bit8u val) { |
|
opl_index = val; |
|
} |
|
|
|
U0 clipit16(Bit32s ival, Bit16s* outval) { |
|
if (ival<32768) { |
|
if (ival>-32769) { |
|
*outval=ival; |
|
} else { |
|
*outval = -32768; |
|
} |
|
} else { |
|
*outval = 32767; |
|
} |
|
} |
|
|
|
U0 (*opfuncs)(op_type*)[6] = { |
|
&operator_attack, |
|
&operator_decay, |
|
&operator_release, |
|
&operator_sustain, // sustain phase (keeping level) |
|
&operator_release, // sustain_nokeep phase (release-style) |
|
&operator_off |
|
}; |
|
|
|
U0 adlib_getsample(Bit8u* sndptr, Bits numsamples, Bit8u is_stereo_output) { |
|
Bits i, endsamples; |
|
op_type* cptr; |
|
|
|
Bit32s outbufl[BLOCKBUF_SIZE]; |
|
|
|
// vibrato/tremolo lookup tables (global, to possibly be used by all operators) |
|
Bit32s vib_lut[BLOCKBUF_SIZE]; |
|
Bit32s trem_lut[BLOCKBUF_SIZE]; |
|
|
|
Bits samples_to_process = numsamples; |
|
Bits cursmp; |
|
Bit32s chanval; |
|
|
|
for (cursmp=0; cursmp<samples_to_process; cursmp+=endsamples) { |
|
endsamples = samples_to_process-cursmp; |
|
if (endsamples>BLOCKBUF_SIZE) endsamples = BLOCKBUF_SIZE; |
|
|
|
MemSet(&outbufl,0,endsamples*sizeof(Bit32s)); |
|
|
|
// calculate vibrato/tremolo lookup tables |
|
Bit32s vib_tshift = Cond(((adlibreg[ARC_PERC_MODE]&0x40)==0), 1, 0); // 14cents/7cents switching |
|
for (i=0;i<endsamples;i++) { |
|
// cycle through vibrato table |
|
vibtab_pos += vibtab_add; |
|
if (vibtab_pos/FIXEDPT_LFO>=VIBTAB_SIZE) vibtab_pos-=VIBTAB_SIZE*FIXEDPT_LFO; |
|
vib_lut[i] = vib_table[vibtab_pos/FIXEDPT_LFO]>>vib_tshift; // 14cents (14/100 of a semitone) or 7cents |
|
|
|
// cycle through tremolo table |
|
tremtab_pos += tremtab_add; |
|
if (tremtab_pos/FIXEDPT_LFO>=TREMTAB_SIZE) tremtab_pos-=TREMTAB_SIZE*FIXEDPT_LFO; |
|
if (adlibreg[ARC_PERC_MODE]&0x80) trem_lut[i] = trem_table[tremtab_pos/FIXEDPT_LFO]; |
|
else trem_lut[i] = trem_table[TREMTAB_SIZE+tremtab_pos/FIXEDPT_LFO]; |
|
} |
|
|
|
if (adlibreg[ARC_PERC_MODE]&0x20) { |
|
//BassDrum |
|
cptr = &op[6]; |
|
if (adlibreg[ARC_FEEDBACK+6]&1) { |
|
// additive synthesis |
|
if (cptr[9].op_state != OF_TYPE_OFF) { |
|
if (cptr[9].vibrato) { |
|
vibval1 = vibval_var1; |
|
for (i=0;i<endsamples;i++) |
|
vibval1[i] = ((vib_lut[i]*cptr[9].freq_high/8)*FIXEDPT*VIBFAC); |
|
} else vibval1 = vibval_const; |
|
if (cptr[9].tremolo) tremval1 = trem_lut; // tremolo enabled, use table |
|
else tremval1 = tremval_const; |
|
|
|
// calculate channel output |
|
for (i=0;i<endsamples;i++) { |
|
operator_advance(&cptr[9],vibval1[i]); |
|
opfuncs[cptr[9].op_state](&cptr[9]); |
|
operator_output(&cptr[9],0,tremval1[i]); |
|
|
|
chanval = cptr[9].cval*2; |
|
outbufl[i] += chanval; |
|
} |
|
} |
|
} else { |
|
// frequency modulation |
|
if ((cptr[9].op_state != OF_TYPE_OFF) || (cptr[0].op_state != OF_TYPE_OFF)) { |
|
if ((cptr[0].vibrato) && (cptr[0].op_state != OF_TYPE_OFF)) { |
|
vibval1 = vibval_var1; |
|
for (i=0;i<endsamples;i++) |
|
vibval1[i] = ((vib_lut[i]*cptr[0].freq_high/8)*FIXEDPT*VIBFAC); |
|
} else vibval1 = vibval_const; |
|
if ((cptr[9].vibrato) && (cptr[9].op_state != OF_TYPE_OFF)) { |
|
vibval2 = vibval_var2; |
|
for (i=0;i<endsamples;i++) |
|
vibval2[i] = ((vib_lut[i]*cptr[9].freq_high/8)*FIXEDPT*VIBFAC); |
|
} else vibval2 = vibval_const; |
|
if (cptr[0].tremolo) tremval1 = trem_lut; // tremolo enabled, use table |
|
else tremval1 = tremval_const; |
|
if (cptr[9].tremolo) tremval2 = trem_lut; // tremolo enabled, use table |
|
else tremval2 = tremval_const; |
|
|
|
// calculate channel output |
|
for (i=0;i<endsamples;i++) { |
|
operator_advance(&cptr[0],vibval1[i]); |
|
opfuncs[cptr[0].op_state](&cptr[0]); |
|
operator_output(&cptr[0],(cptr[0].lastcval+cptr[0].cval)*cptr[0].mfbi/2,tremval1[i]); |
|
|
|
operator_advance(&cptr[9],vibval2[i]); |
|
opfuncs[cptr[9].op_state](&cptr[9]); |
|
operator_output(&cptr[9],cptr[0].cval*FIXEDPT,tremval2[i]); |
|
|
|
chanval = cptr[9].cval*2; |
|
outbufl[i] += chanval; |
|
} |
|
} |
|
} |
|
|
|
//TomTom (j=8) |
|
if (op[8].op_state != OF_TYPE_OFF) { |
|
cptr = &op[8]; |
|
if (cptr[0].vibrato) { |
|
vibval3 = vibval_var1; |
|
for (i=0;i<endsamples;i++) |
|
vibval3[i] = ((vib_lut[i]*cptr[0].freq_high/8)*FIXEDPT*VIBFAC); |
|
} else vibval3 = vibval_const; |
|
|
|
if (cptr[0].tremolo) tremval3 = trem_lut; // tremolo enabled, use table |
|
else tremval3 = tremval_const; |
|
|
|
// calculate channel output |
|
for (i=0;i<endsamples;i++) { |
|
operator_advance(&cptr[0],vibval3[i]); |
|
opfuncs[cptr[0].op_state](&cptr[0]); //TomTom |
|
operator_output(&cptr[0],0,tremval3[i]); |
|
chanval = cptr[0].cval*2; |
|
outbufl[i] += chanval; |
|
} |
|
} |
|
|
|
//Snare/Hihat (j=7), Cymbal (j=8) |
|
if ((op[7].op_state != OF_TYPE_OFF) || (op[16].op_state != OF_TYPE_OFF) || |
|
(op[17].op_state != OF_TYPE_OFF)) { |
|
cptr = &op[7]; |
|
if ((cptr[0].vibrato) && (cptr[0].op_state != OF_TYPE_OFF)) { |
|
vibval1 = vibval_var1; |
|
for (i=0;i<endsamples;i++) |
|
vibval1[i] = ((vib_lut[i]*cptr[0].freq_high/8)*FIXEDPT*VIBFAC); |
|
} else vibval1 = vibval_const; |
|
if ((cptr[9].vibrato) && (cptr[9].op_state == OF_TYPE_OFF)) { |
|
vibval2 = vibval_var2; |
|
for (i=0;i<endsamples;i++) |
|
vibval2[i] = ((vib_lut[i]*cptr[9].freq_high/8)*FIXEDPT*VIBFAC); |
|
} else vibval2 = vibval_const; |
|
|
|
if (cptr[0].tremolo) tremval1 = trem_lut; // tremolo enabled, use table |
|
else tremval1 = tremval_const; |
|
if (cptr[9].tremolo) tremval2 = trem_lut; // tremolo enabled, use table |
|
else tremval2 = tremval_const; |
|
|
|
cptr = &op[8]; |
|
if ((cptr[9].vibrato) && (cptr[9].op_state == OF_TYPE_OFF)) { |
|
vibval4 = vibval_var2; |
|
for (i=0;i<endsamples;i++) |
|
vibval4[i] = ((vib_lut[i]*cptr[9].freq_high/8)*FIXEDPT*VIBFAC); |
|
} else vibval4 = vibval_const; |
|
|
|
if (cptr[9].tremolo) tremval4 = trem_lut; // tremolo enabled, use table |
|
else tremval4 = tremval_const; |
|
|
|
// calculate channel output |
|
for (i=0;i<endsamples;i++) { |
|
operator_advance_drums(&op[7],vibval1[i],&op[7+9],vibval2[i],&op[8+9],vibval4[i]); |
|
|
|
opfuncs[op[7].op_state](&op[7]); //Hihat |
|
operator_output(&op[7],0,tremval1[i]); |
|
|
|
opfuncs[op[7+9].op_state](&op[7+9]); //Snare |
|
operator_output(&op[7+9],0,tremval2[i]); |
|
|
|
opfuncs[op[8+9].op_state](&op[8+9]); //Cymbal |
|
operator_output(&op[8+9],0,tremval4[i]); |
|
|
|
chanval = (op[7].cval + op[7+9].cval + op[8+9].cval)*2; |
|
outbufl[i] += chanval; |
|
} |
|
} |
|
} |
|
|
|
Bitu max_channel = NUM_CHANNELS; |
|
Bits cur_ch; |
|
for (cur_ch=max_channel-1; cur_ch>=0; cur_ch--) { |
|
// skip drum/percussion operators |
|
if ((adlibreg[ARC_PERC_MODE]&0x20) && (cur_ch >= 6) && (cur_ch < 9)) goto cur_ch_cont; |
|
|
|
Bitu k = cur_ch; |
|
cptr = &op[cur_ch]; |
|
|
|
// check for FM/AM |
|
if (adlibreg[ARC_FEEDBACK+k]&1) { |
|
// 2op additive synthesis |
|
if ((cptr[9].op_state == OF_TYPE_OFF) && (cptr[0].op_state == OF_TYPE_OFF)) goto cur_ch_cont; |
|
if ((cptr[0].vibrato) && (cptr[0].op_state != OF_TYPE_OFF)) { |
|
vibval1 = vibval_var1; |
|
for (i=0;i<endsamples;i++) |
|
vibval1[i] = ((vib_lut[i]*cptr[0].freq_high/8)*FIXEDPT*VIBFAC); |
|
} else vibval1 = vibval_const; |
|
if ((cptr[9].vibrato) && (cptr[9].op_state != OF_TYPE_OFF)) { |
|
vibval2 = vibval_var2; |
|
for (i=0;i<endsamples;i++) |
|
vibval2[i] = ((vib_lut[i]*cptr[9].freq_high/8)*FIXEDPT*VIBFAC); |
|
} else vibval2 = vibval_const; |
|
if (cptr[0].tremolo) tremval1 = trem_lut; // tremolo enabled, use table |
|
else tremval1 = tremval_const; |
|
if (cptr[9].tremolo) tremval2 = trem_lut; // tremolo enabled, use table |
|
else tremval2 = tremval_const; |
|
|
|
// calculate channel output |
|
for (i=0;i<endsamples;i++) { |
|
// carrier1 |
|
operator_advance(&cptr[0],vibval1[i]); |
|
opfuncs[cptr[0].op_state](&cptr[0]); |
|
operator_output(&cptr[0],(cptr[0].lastcval+cptr[0].cval)*cptr[0].mfbi/2,tremval1[i]); |
|
|
|
// carrier2 |
|
operator_advance(&cptr[9],vibval2[i]); |
|
opfuncs[cptr[9].op_state](&cptr[9]); |
|
operator_output(&cptr[9],0,tremval2[i]); |
|
|
|
chanval = cptr[9].cval + cptr[0].cval; |
|
outbufl[i] += chanval; |
|
} |
|
} else { |
|
|
|
// 2op frequency modulation |
|
if ((cptr[9].op_state == OF_TYPE_OFF) && (cptr[0].op_state == OF_TYPE_OFF)) goto cur_ch_cont; |
|
if ((cptr[0].vibrato) && (cptr[0].op_state != OF_TYPE_OFF)) { |
|
vibval1 = vibval_var1; |
|
for (i=0;i<endsamples;i++) |
|
vibval1[i] = ((vib_lut[i]*cptr[0].freq_high/8)*FIXEDPT*VIBFAC); |
|
} else vibval1 = vibval_const; |
|
if ((cptr[9].vibrato) && (cptr[9].op_state != OF_TYPE_OFF)) { |
|
vibval2 = vibval_var2; |
|
for (i=0;i<endsamples;i++) |
|
vibval2[i] = ((vib_lut[i]*cptr[9].freq_high/8)*FIXEDPT*VIBFAC); |
|
} else vibval2 = vibval_const; |
|
if (cptr[0].tremolo) tremval1 = trem_lut; // tremolo enabled, use table |
|
else tremval1 = tremval_const; |
|
if (cptr[9].tremolo) tremval2 = trem_lut; // tremolo enabled, use table |
|
else tremval2 = tremval_const; |
|
|
|
// calculate channel output |
|
for (i=0;i<endsamples;i++) { |
|
// modulator |
|
operator_advance(&cptr[0],vibval1[i]); |
|
opfuncs[cptr[0].op_state](&cptr[0]); |
|
operator_output(&cptr[0],(cptr[0].lastcval+cptr[0].cval)*cptr[0].mfbi/2,tremval1[i]); |
|
|
|
// carrier |
|
operator_advance(&cptr[9],vibval2[i]); |
|
opfuncs[cptr[9].op_state](&cptr[9]); |
|
operator_output(&cptr[9],cptr[0].cval*FIXEDPT,tremval2[i]); |
|
|
|
chanval = cptr[9].cval; |
|
outbufl[i] += chanval; |
|
} |
|
} |
|
cur_ch_cont: |
|
} |
|
|
|
// convert to 16bit samples |
|
if (is_stereo_output) { |
|
for (i = 0; i < endsamples; i++) { |
|
clipit16(outbufl[i], sndptr); |
|
sndptr +=2; |
|
clipit16(outbufl[i], sndptr); |
|
sndptr +=2; |
|
} |
|
} else { |
|
for (i = 0; i < endsamples; i++) { |
|
clipit16(outbufl[i], sndptr); |
|
sndptr +=2; |
|
} |
|
} |
|
|
|
} |
|
}
|
|
|