SDLPAL/adplug/dosbox_opl.cpp

/*
 *  Copyright (C) 2002-2013  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"
 */

#include "dosbox_opl.h"
#include <stdlib.h>
#include <memory.h>
#include <math.h>

struct opl_chip_struct {

	/*static*/ Bit32u generator_add;	// should be a chip parameter

	// per-chip variables
	op_type op[MAXOPERATORS];

	Bit8u status;
	Bit32u opl_index;
#if defined(OPLTYPE_IS_OPL3)
	Bit8u adlibreg[512];	// adlib register set (including second set)
	Bit8u wave_sel[44];		// waveform selection
#else
	Bit8u adlibreg[256];	// adlib register set
	Bit8u wave_sel[22];		// waveform selection
#endif


	// vibrato/tremolo increment/counter
	Bit32u vibtab_pos;
	Bit32u vibtab_add;
	Bit32u tremtab_pos;
	Bit32u tremtab_add;

	/*static*/ fltype recipsamp;	// inverse of sampling rate
	static Bit16s wavtable[WAVEPREC * 3];	// wave form table

	// vibrato/tremolo tables
	/*static*/ Bit32s vib_table[VIBTAB_SIZE];
	/*static*/ Bit32s trem_table[TREMTAB_SIZE * 2];

	/*static*/ Bit32s vibval_const[BLOCKBUF_SIZE];
	/*static*/ Bit32s tremval_const[BLOCKBUF_SIZE];

	// vibrato value tables (used per-operator)
	/*static*/ Bit32s vibval_var1[BLOCKBUF_SIZE];
	/*static*/ Bit32s vibval_var2[BLOCKBUF_SIZE];
	//static Bit32s vibval_var3[BLOCKBUF_SIZE];
	//static Bit32s vibval_var4[BLOCKBUF_SIZE];

	// vibrato/trmolo value table pointers
	/*static*/ Bit32s *vibval1, *vibval2, *vibval3, *vibval4;
	/*static*/ Bit32s *tremval1, *tremval2, *tremval3, *tremval4;

	// calculated frequency multiplication values (depend on sampling rate)
	/*static*/ fltype frqmul[16];

	// key scale levels
	static Bit8u kslev[8][16];
};

Bit16s opl_chip_struct::wavtable[WAVEPREC * 3];
Bit8u opl_chip_struct::kslev[8][16];

// key scale level lookup table
static const fltype kslmul[4] = {
	0.0, 0.5, 0.25, 1.0		// -> 0, 3, 1.5, 6 dB/oct
};

// frequency multiplicator lookup table
static const fltype frqmul_tab[16] = {
	0.5,1,2,3,4,5,6,7,8,9,10,10,12,12,15,15
};

// map a channel number to the register offset of the modulator (=register base)
static const Bit8u modulatorbase[9]	= {
	0,1,2,
	8,9,10,
	16,17,18
};

// map a register base to a modulator operator number or operator number
#if defined(OPLTYPE_IS_OPL3)
static const Bit8u regbase2modop[44] = {
	0,1,2,0,1,2,0,0,3,4,5,3,4,5,0,0,6,7,8,6,7,8,					// first set
	18,19,20,18,19,20,0,0,21,22,23,21,22,23,0,0,24,25,26,24,25,26	// second set
};
static const Bit8u regbase2op[44] = {
	0,1,2,9,10,11,0,0,3,4,5,12,13,14,0,0,6,7,8,15,16,17,			// first set
	18,19,20,27,28,29,0,0,21,22,23,30,31,32,0,0,24,25,26,33,34,35	// second set
};
#else
static const 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
};
static const 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
};
#endif


// start of the waveform
static const Bit32u waveform[8] = {
	WAVEPREC,
	WAVEPREC>>1,
	WAVEPREC,
	(WAVEPREC*3)>>2,
	0,
	0,
	(WAVEPREC*5)>>2,
	WAVEPREC<<1
};

// length of the waveform as mask
static const 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
static const Bit32u wavestart[8] = {
	0,
	WAVEPREC>>1,
	0,
	WAVEPREC>>2,
	0,
	0,
	0,
	WAVEPREC>>3
};

// envelope generator function constants
static const fltype attackconst[4] = {
	(fltype)(1/2.82624),
	(fltype)(1/2.25280),
	(fltype)(1/1.88416),
	(fltype)(1/1.59744)
};
static const fltype decrelconst[4] = {
	(fltype)(1/39.28064),
	(fltype)(1/31.41608),
	(fltype)(1/26.17344),
	(fltype)(1/22.44608)
};

#pragma region Operators

void 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 += (Bit32s)(op_pt->tinc)*vib/FIXEDPT;
    
	op_pt->generator_pos += op_pt->chip->generator_add;
}

void 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 = (((c1 & 0x88) ^ ((c1<<5) & 0x80)) | ((c3 ^ (c3<<2)) & 0x20)) ? 0x02 : 0x00;
    
	Bit32u noisebit = rand()&1;
    
	Bit32u snare_phase_bit = (((Bitu)((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 += (Bit32s)(op_pt1->tinc)*vib1/FIXEDPT;
	op_pt1->generator_pos += op_pt1->chip->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 += (Bit32s)(op_pt2->tinc)*vib2/FIXEDPT;
	op_pt2->generator_pos += op_pt2->chip->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 += (Bit32s)(op_pt3->tinc)*vib3/FIXEDPT;
	op_pt3->generator_pos += op_pt3->chip->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)
void 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 = (Bit32u)((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 = (Bit32s)(op_pt->step_amp*op_pt->vol*op_pt->cur_wform[i&op_pt->cur_wmask]*trem/16.0);
	}
}


// no action, operator is off
void 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)
void operator_sustain(op_type* op_pt) {
	Bit32u num_steps_add = op_pt->generator_pos/FIXEDPT;	// number of (standardized) samples
	for (Bit32u 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
void 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
	for (Bit32u 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
void 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
	for (Bit32u 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
void 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
	for (Bit32u 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;
}


typedef void (*optype_fptr)(op_type*);

const optype_fptr opfuncs[6] = {
	operator_attack,
	operator_decay,
	operator_release,
	operator_sustain,	// sustain phase (keeping level)
	operator_release,	// sustain_nokeep phase (release-style)
	operator_off
};


void change_attackrate(Bitu regbase, op_type* op_pt) {
	Bits attackrate = op_pt->chip->adlibreg[ARC_ATTR_DECR + regbase] >> 4;
	if (attackrate) {
		fltype f = (fltype)(pow(FL2, (fltype)attackrate + (op_pt->toff >> 2) - 1)*attackconst[op_pt->toff & 3] * op_pt->chip->recipsamp);
		// attack rate coefficients
		op_pt->a0 = (fltype)(0.0377*f);
		op_pt->a1 = (fltype)(10.73*f + 1);
		op_pt->a2 = (fltype)(-17.57*f);
		op_pt->a3 = (fltype)(7.42*f);

		Bits step_skip = attackrate * 4 + op_pt->toff;
		Bits steps = step_skip >> 2;
		op_pt->env_step_a = (1 << (steps <= 12 ? 12 - steps : 0)) - 1;

		Bits step_num = (step_skip <= 48) ? (4 - (step_skip & 3)) : 0;
		static Bit8u step_skip_mask[5] = { 0xff, 0xfe, 0xee, 0xba, 0xaa };
		op_pt->env_step_skip_a = step_skip_mask[step_num];

#if defined(OPLTYPE_IS_OPL3)
		if (step_skip >= 60) {
#else
		if (step_skip >= 62) {
#endif
			op_pt->a0 = (fltype)(2.0);	// something that triggers an immediate transition to amp:=1.0
			op_pt->a1 = (fltype)(0.0);
			op_pt->a2 = (fltype)(0.0);
			op_pt->a3 = (fltype)(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;
	}
}
    
void change_decayrate(Bitu regbase, op_type* op_pt) {
	Bits decayrate = op_pt->chip->adlibreg[ARC_ATTR_DECR + regbase] & 15;
	// decaymul should be 1.0 when decayrate==0
	if (decayrate) {
		fltype f = (fltype)(-7.4493*decrelconst[op_pt->toff & 3] * op_pt->chip->recipsamp);
		op_pt->decaymul = (fltype)(pow(FL2, f*pow(FL2, (fltype)(decayrate + (op_pt->toff >> 2)))));
		Bits steps = (decayrate * 4 + op_pt->toff) >> 2;
		op_pt->env_step_d = (1 << (steps <= 12 ? 12 - steps : 0)) - 1;
	}
	else {
		op_pt->decaymul = 1.0;
		op_pt->env_step_d = 0;
	}
}
    
void change_releaserate(Bitu regbase, op_type* op_pt) {
	Bits releaserate = op_pt->chip->adlibreg[ARC_SUSL_RELR + regbase] & 15;
	// releasemul should be 1.0 when releaserate==0
	if (releaserate) {
		fltype f = (fltype)(-7.4493*decrelconst[op_pt->toff & 3] * op_pt->chip->recipsamp);
		op_pt->releasemul = (fltype)(pow(FL2, f*pow(FL2, (fltype)(releaserate + (op_pt->toff >> 2)))));
		Bits steps = (releaserate * 4 + op_pt->toff) >> 2;
		op_pt->env_step_r = (1 << (steps <= 12 ? 12 - steps : 0)) - 1;
	}
	else {
		op_pt->releasemul = 1.0;
		op_pt->env_step_r = 0;
	}
}
    
void change_sustainlevel(Bitu regbase, op_type* op_pt) {
	Bits sustainlevel = op_pt->chip->adlibreg[ARC_SUSL_RELR + regbase] >> 4;
	// sustainlevel should be 0.0 when sustainlevel==15 (max)
	if (sustainlevel < 15) {
		op_pt->sustain_level = (fltype)(pow(FL2, (fltype)sustainlevel * (-FL05)));
	}
	else {
		op_pt->sustain_level = 0.0;
	}
}
    
void change_waveform(Bitu regbase, op_type* op_pt) {
#if defined(OPLTYPE_IS_OPL3)
	if (regbase>=ARC_SECONDSET) regbase -= (ARC_SECONDSET-22);	// second set starts at 22
#endif
	// waveform selection
	op_pt->cur_wmask = wavemask[op_pt->chip->wave_sel[regbase]];
	op_pt->cur_wform = &op_pt->chip->wavtable[waveform[op_pt->chip->wave_sel[regbase]]];
	// (might need to be adapted to waveform type here...)
}
    
void change_keepsustain(Bitu regbase, op_type* op_pt) {
	op_pt->sus_keep = (op_pt->chip->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
void change_vibrato(Bitu regbase, op_type* op_pt) {
	op_pt->vibrato = (op_pt->chip->adlibreg[ARC_TVS_KSR_MUL + regbase] & 0x40) != 0;
	op_pt->tremolo = (op_pt->chip->adlibreg[ARC_TVS_KSR_MUL + regbase] & 0x80) != 0;
}
    
    // change amount of self-feedback
void change_feedback(Bitu chanbase, op_type* op_pt) {
	Bits feedback = op_pt->chip->adlibreg[ARC_FEEDBACK + chanbase] & 14;
	if (feedback) op_pt->mfbi = (Bit32s)(pow(FL2, (fltype)((feedback >> 1) + 8)));
	else op_pt->mfbi = 0;
}
    
void change_frequency(Bitu chanbase, Bitu regbase, op_type* op_pt) {
	// frequency
	Bit32u frn = ((((Bit32u)op_pt->chip->adlibreg[ARC_KON_BNUM + chanbase]) & 3) << 8) + (Bit32u)op_pt->chip->adlibreg[ARC_FREQ_NUM + chanbase];
	// block number/octave
	Bit32u oct = ((((Bit32u)op_pt->chip->adlibreg[ARC_KON_BNUM + chanbase]) >> 2) & 7);
	op_pt->freq_high = (Bit32s)((frn >> 7) & 7);

	// keysplit
	Bit32u note_sel = (op_pt->chip->adlibreg[8] >> 6) & 1;
	op_pt->toff = ((frn >> 9)&(note_sel ^ 1)) | ((frn >> 8)&note_sel);
	op_pt->toff += (oct << 1);

	// envelope scaling (KSR)
	if (!(op_pt->chip->adlibreg[ARC_TVS_KSR_MUL + regbase] & 0x10)) op_pt->toff >>= 2;

	// 20+a0+b0:
	op_pt->tinc = (Bit32u)((((fltype)(frn << oct))*op_pt->chip->frqmul[op_pt->chip->adlibreg[ARC_TVS_KSR_MUL + regbase] & 15]));
	// 40+a0+b0:
	fltype vol_in = (fltype)((fltype)(op_pt->chip->adlibreg[ARC_KSL_OUTLEV + regbase] & 63) +
		kslmul[op_pt->chip->adlibreg[ARC_KSL_OUTLEV + regbase] >> 6] * opl_chip::kslev[oct][frn >> 6]);
	op_pt->vol = (fltype)(pow(FL2, (fltype)(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);
}

void 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[op_pt->chip->wave_sel[wselbase]] * FIXEDPT;

		// start with attack mode
		op_pt->op_state = OF_TYPE_ATT;
		op_pt->act_state |= act_type;
	}
}
    
void 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;
		}
	}
}

#pragma endregion


opl_chip* adlib_init(Bit32u samplerate) {

	opl_chip* opl = new opl_chip;
	if (!opl) return NULL;

	Bits i, j, oct, int_samplerate = samplerate;

	opl->generator_add = (Bit32u)(INTFREQU*FIXEDPT / int_samplerate);

	memset((void *)opl->adlibreg, 0, sizeof(opl->adlibreg));
	memset((void *)opl->op, 0, sizeof(op_type)*MAXOPERATORS);
	memset((void *)opl->wave_sel, 0, sizeof(opl->wave_sel));

	for (i = 0; i < MAXOPERATORS; i++) {
		opl->op[i].chip = opl;
		opl->op[i].op_state = OF_TYPE_OFF;
		opl->op[i].act_state = OP_ACT_OFF;
		opl->op[i].amp = 0.0;
		opl->op[i].step_amp = 0.0;
		opl->op[i].vol = 0.0;
		opl->op[i].tcount = 0;
		opl->op[i].tinc = 0;
		opl->op[i].toff = 0;
		opl->op[i].cur_wmask = wavemask[0];
		opl->op[i].cur_wform = &opl->wavtable[waveform[0]];
		opl->op[i].freq_high = 0;

		opl->op[i].generator_pos = 0;
		opl->op[i].cur_env_step = 0;
		opl->op[i].env_step_a = 0;
		opl->op[i].env_step_d = 0;
		opl->op[i].env_step_r = 0;
		opl->op[i].step_skip_pos_a = 0;
		opl->op[i].env_step_skip_a = 0;

#if defined(OPLTYPE_IS_OPL3)
		opl->op[i].is_4op = false;
		opl->op[i].is_4op_attached = false;
		opl->op[i].left_pan = 1;
		opl->op[i].right_pan = 1;
#endif
	}

	opl->recipsamp = 1.0 / (fltype)int_samplerate;
	for (i = 15; i >= 0; i--) {
		opl->frqmul[i] = (fltype)(frqmul_tab[i] * INTFREQU / (fltype)WAVEPREC*(fltype)FIXEDPT*opl->recipsamp);
	}

	opl->status = 0;
	opl->opl_index = 0;


	// create vibrato table
	opl->vib_table[0] = 8;
	opl->vib_table[1] = 4;
	opl->vib_table[2] = 0;
	opl->vib_table[3] = -4;
	for (i = 4; i < VIBTAB_SIZE; i++) opl->vib_table[i] = opl->vib_table[i - 4] * -1;

	// vibrato at ~6.1 ?? (opl3 docs say 6.1, opl4 docs say 6.0, y8950 docs say 6.4)
	opl->vibtab_add = static_cast<Bit32u>(VIBTAB_SIZE*FIXEDPT_LFO / 8192 * INTFREQU / int_samplerate);
	opl->vibtab_pos = 0;

	for (i = 0; i < BLOCKBUF_SIZE; i++) opl->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 = (fltype)(((fltype)trem_table_int[i])*4.8 / 26.0 / 6.0);				// 4.8db
		fltype trem_val2 = (fltype)((fltype)((Bit32s)(trem_table_int[i] / 4))*1.2 / 6.0 / 6.0);		// 1.2db (larger stepping)

		opl->trem_table[i] = (Bit32s)(pow(FL2, trem_val1)*FIXEDPT);
		opl->trem_table[TREMTAB_SIZE + i] = (Bit32s)(pow(FL2, trem_val2)*FIXEDPT);
	}

	// tremolo at 3.7hz
	opl->tremtab_add = (Bit32u)((fltype)TREMTAB_SIZE * TREM_FREQ * FIXEDPT_LFO / (fltype)int_samplerate);
	opl->tremtab_pos = 0;

	for (i = 0; i < BLOCKBUF_SIZE; i++) opl->tremval_const[i] = FIXEDPT;


	static Bitu initfirstime = 0;
	if (!initfirstime) {
		initfirstime = 1;

		// create waveform tables
		for (i = 0; i < (WAVEPREC >> 1); i++) {
			opl_chip::wavtable[(i << 1) + WAVEPREC] = (Bit16s)(16384 * sin((fltype)((i << 1))*PI * 2 / WAVEPREC));
			opl_chip::wavtable[(i << 1) + 1 + WAVEPREC] = (Bit16s)(16384 * sin((fltype)((i << 1) + 1)*PI * 2 / WAVEPREC));
			opl_chip::wavtable[i] = opl_chip::wavtable[(i << 1) + WAVEPREC];
			// alternative: (zero-less)
			//opl_chip::wavtable[(i<<1)  +WAVEPREC]	= (Bit16s)(16384*sin((fltype)((i<<2)+1)*PI/WAVEPREC));
			//opl_chip::wavtable[(i<<1)+1+WAVEPREC]	= (Bit16s)(16384*sin((fltype)((i<<2)+3)*PI/WAVEPREC));
			//opl_chip::wavtable[i]					= opl_chip::wavtable[(i<<1)-1+WAVEPREC];
		}
		for (i = 0; i < (WAVEPREC >> 3); i++) {
			opl_chip::wavtable[i + (WAVEPREC << 1)] = opl_chip::wavtable[i + (WAVEPREC >> 3)] - 16384;
			opl_chip::wavtable[i + ((WAVEPREC * 17) >> 3)] = opl_chip::wavtable[i + (WAVEPREC >> 2)] + 16384;
		}

		// key scale level table verified ([table in book]*8/3)
		opl_chip::kslev[7][0] = 0;	opl_chip::kslev[7][1] = 24;	opl_chip::kslev[7][2] = 32;
		opl_chip::kslev[7][3] = 37;	opl_chip::kslev[7][4] = 40;	opl_chip::kslev[7][5] = 43;
		opl_chip::kslev[7][6] = 45;	opl_chip::kslev[7][7] = 47;	opl_chip::kslev[7][8] = 48;
		for (i = 9; i < 16; i++) opl_chip::kslev[7][i] = (Bit8u)(i + 41);
		for (j = 6; j >= 0; j--) {
			for (i = 0; i < 16; i++) {
				oct = (Bits)opl_chip::kslev[j + 1][i] - 8;
				if (oct < 0) oct = 0;
				opl_chip::kslev[j][i] = (Bit8u)oct;
			}
		}
	}

	return opl;
}

void adlib_release(opl_chip* opl)
{
	if (opl) delete opl;
}



void adlib_write(opl_chip* opl, Bitu idx, Bit8u val) {
	Bit32u second_set = idx & 0x100;
	opl->adlibreg[idx] = val;

	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
				opl->status &= ~0x60;
			}
			else {
				opl->status = 0;
			}
			break;
#if defined(OPLTYPE_IS_OPL3)
		case 0x04|ARC_SECONDSET:
			// 4op enable/disable switches for each possible channel
			opl->op[0].is_4op = (val&1)>0;
			opl->op[3].is_4op_attached = opl->op[0].is_4op;
			opl->op[1].is_4op = (val&2)>0;
			opl->op[4].is_4op_attached = opl->op[1].is_4op;
			opl->op[2].is_4op = (val&4)>0;
			opl->op[5].is_4op_attached = opl->op[2].is_4op;
			opl->op[18].is_4op = (val&8)>0;
			opl->op[21].is_4op_attached = opl->op[18].is_4op;
			opl->op[19].is_4op = (val&16)>0;
			opl->op[22].is_4op_attached = opl->op[19].is_4op;
			opl->op[20].is_4op = (val&32)>0;
			opl->op[23].is_4op_attached = opl->op[20].is_4op;
			break;
		case 0x05|ARC_SECONDSET:
			break;
#endif
		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
		int num = idx & 7;
		Bitu base = (idx - ARC_TVS_KSR_MUL) & 0xff;
		if ((num < 6) && (base < 22)) {
			Bitu modop = regbase2modop[second_set ? (base + 22) : base];
			Bitu regbase = base + second_set;
			Bitu chanbase = second_set ? (modop - 18 + ARC_SECONDSET) : modop;

			// change tremolo/vibrato and sustain keeping of this operator
			op_type* op_ptr = &opl->op[modop + ((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
#if defined(OPLTYPE_IS_OPL3)
			if ((opl->adlibreg[0x105]&1) && (opl->op[modop].is_4op_attached)) {
				// operator uses frequency of channel
				change_frequency(chanbase-3,regbase,op_ptr);
			} else {
				change_frequency(chanbase,regbase,op_ptr);
		}
#else
			change_frequency(chanbase, base, op_ptr);
#endif
	}
	}
	break;
	case ARC_KSL_OUTLEV:
	case ARC_KSL_OUTLEV + 0x10:
	{
		// key scale level; output rate
		int num = idx & 7;
		Bitu base = (idx - ARC_KSL_OUTLEV) & 0xff;
		if ((num < 6) && (base < 22)) {
			Bitu modop = regbase2modop[second_set ? (base + 22) : base];
			Bitu chanbase = second_set ? (modop - 18 + ARC_SECONDSET) : modop;

			// change frequency calculations of this operator as
			// key scale level and output rate can be changed
			op_type* op_ptr = &opl->op[modop + ((num < 3) ? 0 : 9)];
#if defined(OPLTYPE_IS_OPL3)
			Bitu regbase = base+second_set;
			if ((opl->adlibreg[0x105]&1) && (opl->op[modop].is_4op_attached)) {
				// operator uses frequency of channel
				change_frequency(chanbase-3,regbase,op_ptr);
			} else {
				change_frequency(chanbase, regbase, op_ptr);
		}
#else
			change_frequency(chanbase, base, op_ptr);
#endif
	}
}
	break;
	case ARC_ATTR_DECR:
	case ARC_ATTR_DECR + 0x10:
	{
		// attack/decay rates
		int num = idx & 7;
		Bitu base = (idx - ARC_ATTR_DECR) & 0xff;
		if ((num < 6) && (base < 22)) {
			Bitu regbase = base + second_set;

			// change attack rate and decay rate of this operator
			op_type* op_ptr = &opl->op[regbase2op[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
		int num = idx & 7;
		Bitu base = (idx - ARC_SUSL_RELR) & 0xff;
		if ((num < 6) && (base < 22)) {
			Bitu regbase = base + second_set;

			// change sustain level and release rate of this operator
			op_type* op_ptr = &opl->op[regbase2op[second_set ? (base + 22) : base]];
			change_releaserate(regbase, op_ptr);
			change_sustainlevel(regbase, op_ptr);
		}
	}
	break;
	case ARC_FREQ_NUM:
	{
		// 0xa0-0xa8 low8 frequency
		Bitu base = (idx - ARC_FREQ_NUM) & 0xff;
		if (base < 9) {
			Bits opbase = second_set ? (base + 18) : base;
#if defined(OPLTYPE_IS_OPL3)
			if ((opl->adlibreg[0x105] & 1) && opl->op[opbase].is_4op_attached) break;
#endif
			// regbase of modulator:
			Bits modbase = modulatorbase[base] + second_set;

			Bitu chanbase = base + second_set;

			change_frequency(chanbase, modbase, &opl->op[opbase]);
			change_frequency(chanbase, modbase + 3, &opl->op[opbase + 9]);
#if defined(OPLTYPE_IS_OPL3)
			// for 4op channels all four operators are modified to the frequency of the channel
			if ((opl->adlibreg[0x105] & 1) && opl->op[second_set ? (base + 18) : base].is_4op) {
				change_frequency(chanbase, modbase + 8, &opl->op[opbase + 3]);
				change_frequency(chanbase, modbase + 3 + 8, &opl->op[opbase + 3 + 9]);
			}
#endif
		}
	}
	break;
	case ARC_KON_BNUM:
	{
		if (idx == ARC_PERC_MODE) {
#if defined(OPLTYPE_IS_OPL3)
			if (second_set) return;
#endif

			if ((val & 0x30) == 0x30) {		// BassDrum active
				enable_operator(16, &opl->op[6], OP_ACT_PERC);
				change_frequency(6, 16, &opl->op[6]);
				enable_operator(16 + 3, &opl->op[6 + 9], OP_ACT_PERC);
				change_frequency(6, 16 + 3, &opl->op[6 + 9]);
			}
			else {
				disable_operator(&opl->op[6], OP_ACT_PERC);
				disable_operator(&opl->op[6 + 9], OP_ACT_PERC);
			}
			if ((val & 0x28) == 0x28) {		// Snare active
				enable_operator(17 + 3, &opl->op[16], OP_ACT_PERC);
				change_frequency(7, 17 + 3, &opl->op[16]);
			}
			else {
				disable_operator(&opl->op[16], OP_ACT_PERC);
			}
			if ((val & 0x24) == 0x24) {		// TomTom active
				enable_operator(18, &opl->op[8], OP_ACT_PERC);
				change_frequency(8, 18, &opl->op[8]);
			}
			else {
				disable_operator(&opl->op[8], OP_ACT_PERC);
			}
			if ((val & 0x22) == 0x22) {		// Cymbal active
				enable_operator(18 + 3, &opl->op[8 + 9], OP_ACT_PERC);
				change_frequency(8, 18 + 3, &opl->op[8 + 9]);
			}
			else {
				disable_operator(&opl->op[8 + 9], OP_ACT_PERC);
			}
			if ((val & 0x21) == 0x21) {		// Hihat active
				enable_operator(17, &opl->op[7], OP_ACT_PERC);
				change_frequency(7, 17, &opl->op[7]);
			}
			else {
				disable_operator(&opl->op[7], OP_ACT_PERC);
			}

			break;
		}
		// regular 0xb0-0xb8
		Bitu base = (idx - ARC_KON_BNUM) & 0xff;
		if (base < 9) {
			Bits opbase = second_set ? (base + 18) : base;
#if defined(OPLTYPE_IS_OPL3)
			if ((opl->adlibreg[0x105] & 1) && opl->op[opbase].is_4op_attached) break;
#endif
			// regbase of modulator:
			Bits modbase = modulatorbase[base] + second_set;

			if (val & 32) {
				// operator switched on
				enable_operator(modbase, &opl->op[opbase], OP_ACT_NORMAL);		// modulator (if 2op)
				enable_operator(modbase + 3, &opl->op[opbase + 9], OP_ACT_NORMAL);	// carrier (if 2op)
#if defined(OPLTYPE_IS_OPL3)
				// for 4op channels all four operators are switched on
				if ((opl->adlibreg[0x105] & 1) && opl->op[opbase].is_4op) {
					// turn on chan+3 operators as well
					enable_operator(modbase + 8, &opl->op[opbase + 3], OP_ACT_NORMAL);
					enable_operator(modbase + 3 + 8, &opl->op[opbase + 3 + 9], OP_ACT_NORMAL);
				}
#endif
			}
			else {
				// operator switched off
				disable_operator(&opl->op[opbase], OP_ACT_NORMAL);
				disable_operator(&opl->op[opbase + 9], OP_ACT_NORMAL);
#if defined(OPLTYPE_IS_OPL3)
				// for 4op channels all four operators are switched off
				if ((opl->adlibreg[0x105] & 1) && opl->op[opbase].is_4op) {
					// turn off chan+3 operators as well
					disable_operator(&opl->op[opbase + 3], OP_ACT_NORMAL);
					disable_operator(&opl->op[opbase + 3 + 9], OP_ACT_NORMAL);
				}
#endif
		}

			Bitu chanbase = base + second_set;

			// change frequency calculations of modulator and carrier (2op) as
			// the frequency of the channel has changed
			change_frequency(chanbase, modbase, &opl->op[opbase]);
			change_frequency(chanbase, modbase + 3, &opl->op[opbase + 9]);
#if defined(OPLTYPE_IS_OPL3)
			// for 4op channels all four operators are modified to the frequency of the channel
			if ((opl->adlibreg[0x105] & 1) && opl->op[second_set ? (base + 18) : base].is_4op) {
				// change frequency calculations of chan+3 operators as well
				change_frequency(chanbase, modbase + 8, &opl->op[opbase + 3]);
				change_frequency(chanbase, modbase + 3 + 8, &opl->op[opbase + 3 + 9]);
			}
#endif
		}
	}
	break;
	case ARC_FEEDBACK:
	{
		// 0xc0-0xc8 feedback/modulation type (AM/FM)
		Bitu base = (idx - ARC_FEEDBACK) & 0xff;
		if (base < 9) {
			Bits opbase = second_set ? (base + 18) : base;
			Bitu chanbase = base + second_set;
			change_feedback(chanbase, &opl->op[opbase]);
#if defined(OPLTYPE_IS_OPL3)
			// OPL3 panning
			opl->op[opbase].left_pan = ((val & 0x10) >> 4);
			opl->op[opbase].right_pan = ((val & 0x20) >> 5);
#endif
		}
	}
	break;
	case ARC_WAVE_SEL:
	case ARC_WAVE_SEL + 0x10:
	{
		int num = idx & 7;
		Bitu base = (idx - ARC_WAVE_SEL) & 0xff;
		if ((num < 6) && (base < 22)) {
#if defined(OPLTYPE_IS_OPL3)
			Bits wselbase = second_set ? (base + 22) : base;	// for easier mapping onto wave_sel[]
			// change waveform
			if (opl->adlibreg[0x105] & 1) opl->wave_sel[wselbase] = val & 7;	// opl3 mode enabled, all waveforms accessible
			else opl->wave_sel[wselbase] = val & 3;
			op_type* op_ptr = &opl->op[regbase2modop[wselbase] + ((num < 3) ? 0 : 9)];
			change_waveform(wselbase, op_ptr);
#else
			if (opl->adlibreg[0x01] & 0x20) {
				// wave selection enabled, change waveform
				opl->wave_sel[base] = val & 3;
				op_type* op_ptr = &opl->op[regbase2modop[base] + ((num < 3) ? 0 : 9)];
				change_waveform(base, op_ptr);
			}
#endif
		}
	}
	break;
	default:
		break;
	}
}


Bitu adlib_reg_read(opl_chip* opl, Bitu port) {
#if defined(OPLTYPE_IS_OPL3)
	// opl3-detection routines require ret&6 to be zero
	if ((port&1)==0) {
		return opl->status;
	}
	return 0x00;
#else
	// opl2-detection routines require ret&6 to be 6
	if ((port & 1) == 0) {
		return opl->status | 6;
	}
	return 0xff;
#endif
}
    
void adlib_write_index(opl_chip* opl, Bitu port, Bit8u val) {
	opl->opl_index = val;
#if defined(OPLTYPE_IS_OPL3)
	if ((port&3)!=0) {
		// possibly second set
		if (((opl->adlibreg[0x105]&1)!=0) || (opl->opl_index==5)) opl->opl_index |= ARC_SECONDSET;
	}
#endif
}

static void OPL_INLINE clipit16(Bit32s ival, Bit16s* outval) {
	if (ival < 32768) {
		if (ival > -32769) {
			*outval = (Bit16s)ival;
		}
		else {
			*outval = -32768;
		}
	}
	else {
		*outval = 32767;
	}
}



// be careful with this
// uses cptr and chanval, outputs into outbufl(/outbufr)
// for opl3 check if opl3-mode is enabled (which uses stereo panning)
#undef CHANVAL_OUT
#if defined(OPLTYPE_IS_OPL3)
#	define CHANVAL_OUT									\
if (opl->adlibreg[0x105]&1) {						\
outbufl[i] += chanval*cptr[0].left_pan;		\
outbufr[i] += chanval*cptr[0].right_pan;	\
} else {										\
outbufl[i] += chanval;						\
}
#else
#	define CHANVAL_OUT									\
outbufl[i] += chanval;
#endif
    
void adlib_getsample(opl_chip* opl, Bit16s* sndptr, Bits numsamples) {
	Bits i, endsamples;
	op_type* cptr;

	Bit32s outbufl[BLOCKBUF_SIZE];
#if defined(OPLTYPE_IS_OPL3)
	// second output buffer (right channel for opl3 stereo)
	Bit32s outbufr[BLOCKBUF_SIZE];
#endif

	// 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;

	for (Bits cursmp = 0; cursmp<samples_to_process; cursmp += endsamples) {
		endsamples = samples_to_process - cursmp;
		if (endsamples>BLOCKBUF_SIZE) endsamples = BLOCKBUF_SIZE;

		memset((void*)&outbufl, 0, endsamples*sizeof(Bit32s));
#if defined(OPLTYPE_IS_OPL3)
		// clear second output buffer (opl3 stereo)
		if (opl->adlibreg[0x105] & 1) memset((void*)&outbufr, 0, endsamples*sizeof(Bit32s));
#endif

		// calculate vibrato/tremolo lookup tables
		Bit32s vib_tshift = ((opl->adlibreg[ARC_PERC_MODE] & 0x40) == 0) ? 1 : 0;	// 14cents/7cents switching
		for (i = 0; i < endsamples; i++) {
			// cycle through vibrato table
			opl->vibtab_pos += opl->vibtab_add;
			if (opl->vibtab_pos / FIXEDPT_LFO >= VIBTAB_SIZE) opl->vibtab_pos -= VIBTAB_SIZE*FIXEDPT_LFO;
			vib_lut[i] = opl->vib_table[opl->vibtab_pos / FIXEDPT_LFO] >> vib_tshift;		// 14cents (14/100 of a semitone) or 7cents

			// cycle through tremolo table
			opl->tremtab_pos += opl->tremtab_add;
			if (opl->tremtab_pos / FIXEDPT_LFO >= TREMTAB_SIZE) opl->tremtab_pos -= TREMTAB_SIZE*FIXEDPT_LFO;
			if (opl->adlibreg[ARC_PERC_MODE] & 0x80) trem_lut[i] = opl->trem_table[opl->tremtab_pos / FIXEDPT_LFO];
			else trem_lut[i] = opl->trem_table[TREMTAB_SIZE + opl->tremtab_pos / FIXEDPT_LFO];
		}

		if (opl->adlibreg[ARC_PERC_MODE] & 0x20) {
			//BassDrum
			cptr = &opl->op[6];
			if (opl->adlibreg[ARC_FEEDBACK + 6] & 1) {
				// additive synthesis
				if (cptr[9].op_state != OF_TYPE_OFF) {
					if (cptr[9].vibrato) {
						opl->vibval1 = opl->vibval_var1;
						for (i = 0; i < endsamples; i++)
							opl->vibval1[i] = (Bit32s)((vib_lut[i] * cptr[9].freq_high / 8)*FIXEDPT*VIBFAC);
					}
					else opl->vibval1 = opl->vibval_const;
					if (cptr[9].tremolo) opl->tremval1 = trem_lut;	// tremolo enabled, use table
					else opl->tremval1 = opl->tremval_const;

					// calculate channel output
					for (i = 0; i < endsamples; i++) {
						operator_advance(&cptr[9], opl->vibval1[i]);
						opfuncs[cptr[9].op_state](&cptr[9]);
						operator_output(&cptr[9], 0, opl->tremval1[i]);

						Bit32s chanval = cptr[9].cval * 2;
						CHANVAL_OUT
					}
				}
			}
			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)) {
						opl->vibval1 = opl->vibval_var1;
						for (i = 0; i < endsamples; i++)
							opl->vibval1[i] = (Bit32s)((vib_lut[i] * cptr[0].freq_high / 8)*FIXEDPT*VIBFAC);
					}
					else opl->vibval1 = opl->vibval_const;
					if ((cptr[9].vibrato) && (cptr[9].op_state != OF_TYPE_OFF)) {
						opl->vibval2 = opl->vibval_var2;
						for (i = 0; i < endsamples; i++)
							opl->vibval2[i] = (Bit32s)((vib_lut[i] * cptr[9].freq_high / 8)*FIXEDPT*VIBFAC);
					}
					else opl->vibval2 = opl->vibval_const;
					if (cptr[0].tremolo) opl->tremval1 = trem_lut;	// tremolo enabled, use table
					else opl->tremval1 = opl->tremval_const;
					if (cptr[9].tremolo) opl->tremval2 = trem_lut;	// tremolo enabled, use table
					else opl->tremval2 = opl->tremval_const;

					// calculate channel output
					for (i = 0; i < endsamples; i++) {
						operator_advance(&cptr[0], opl->vibval1[i]);
						opfuncs[cptr[0].op_state](&cptr[0]);
						operator_output(&cptr[0], (cptr[0].lastcval + cptr[0].cval)*cptr[0].mfbi / 2, opl->tremval1[i]);

						operator_advance(&cptr[9], opl->vibval2[i]);
						opfuncs[cptr[9].op_state](&cptr[9]);
						operator_output(&cptr[9], cptr[0].cval*FIXEDPT, opl->tremval2[i]);

						Bit32s chanval = cptr[9].cval * 2;
						CHANVAL_OUT
					}
				}
			}

			//TomTom (j=8)
			if (opl->op[8].op_state != OF_TYPE_OFF) {
				cptr = &opl->op[8];
				if (cptr[0].vibrato) {
					opl->vibval3 = opl->vibval_var1;
					for (i = 0; i < endsamples; i++)
						opl->vibval3[i] = (Bit32s)((vib_lut[i] * cptr[0].freq_high / 8)*FIXEDPT*VIBFAC);
				}
				else opl->vibval3 = opl->vibval_const;

				if (cptr[0].tremolo) opl->tremval3 = trem_lut;	// tremolo enabled, use table
				else opl->tremval3 = opl->tremval_const;

				// calculate channel output
				for (i = 0; i < endsamples; i++) {
					operator_advance(&cptr[0], opl->vibval3[i]);
					opfuncs[cptr[0].op_state](&cptr[0]);		//TomTom
					operator_output(&cptr[0], 0, opl->tremval3[i]);
					Bit32s chanval = cptr[0].cval * 2;
					CHANVAL_OUT
				}
			}

			//Snare/Hihat (j=7), Cymbal (j=8)
			if ((opl->op[7].op_state != OF_TYPE_OFF) || (opl->op[16].op_state != OF_TYPE_OFF) ||
				(opl->op[17].op_state != OF_TYPE_OFF)) {
				cptr = &opl->op[7];
				if ((cptr[0].vibrato) && (cptr[0].op_state != OF_TYPE_OFF)) {
					opl->vibval1 = opl->vibval_var1;
					for (i = 0; i < endsamples; i++)
						opl->vibval1[i] = (Bit32s)((vib_lut[i] * cptr[0].freq_high / 8)*FIXEDPT*VIBFAC);
				}
				else opl->vibval1 = opl->vibval_const;
				if ((cptr[9].vibrato) && (cptr[9].op_state == OF_TYPE_OFF)) {
					opl->vibval2 = opl->vibval_var2;
					for (i = 0; i < endsamples; i++)
						opl->vibval2[i] = (Bit32s)((vib_lut[i] * cptr[9].freq_high / 8)*FIXEDPT*VIBFAC);
				}
				else opl->vibval2 = opl->vibval_const;

				if (cptr[0].tremolo) opl->tremval1 = trem_lut;	// tremolo enabled, use table
				else opl->tremval1 = opl->tremval_const;
				if (cptr[9].tremolo) opl->tremval2 = trem_lut;	// tremolo enabled, use table
				else opl->tremval2 = opl->tremval_const;

				cptr = &opl->op[8];
				if ((cptr[9].vibrato) && (cptr[9].op_state == OF_TYPE_OFF)) {
					opl->vibval4 = opl->vibval_var2;
					for (i = 0; i < endsamples; i++)
						opl->vibval4[i] = (Bit32s)((vib_lut[i] * cptr[9].freq_high / 8)*FIXEDPT*VIBFAC);
				}
				else opl->vibval4 = opl->vibval_const;

				if (cptr[9].tremolo) opl->tremval4 = trem_lut;	// tremolo enabled, use table
				else opl->tremval4 = opl->tremval_const;

				// calculate channel output
				for (i = 0; i < endsamples; i++) {
					operator_advance_drums(&opl->op[7], opl->vibval1[i], &opl->op[7 + 9], opl->vibval2[i], &opl->op[8 + 9], opl->vibval4[i]);

					opfuncs[opl->op[7].op_state](&opl->op[7]);			//Hihat
					operator_output(&opl->op[7], 0, opl->tremval1[i]);

					opfuncs[opl->op[7 + 9].op_state](&opl->op[7 + 9]);		//Snare
					operator_output(&opl->op[7 + 9], 0, opl->tremval2[i]);

					opfuncs[opl->op[8 + 9].op_state](&opl->op[8 + 9]);		//Cymbal
					operator_output(&opl->op[8 + 9], 0, opl->tremval4[i]);

					Bit32s chanval = (opl->op[7].cval + opl->op[7 + 9].cval + opl->op[8 + 9].cval) * 2;
					CHANVAL_OUT
				}
			}
		}

		Bitu max_channel = NUM_CHANNELS;
#if defined(OPLTYPE_IS_OPL3)
		if ((opl->adlibreg[0x105] & 1) == 0) max_channel = NUM_CHANNELS / 2;
#endif
		for (Bits cur_ch = max_channel - 1; cur_ch >= 0; cur_ch--) {
			// skip drum/percussion operators
			if ((opl->adlibreg[ARC_PERC_MODE] & 0x20) && (cur_ch >= 6) && (cur_ch < 9)) continue;

			Bitu k = cur_ch;
#if defined(OPLTYPE_IS_OPL3)
			if (cur_ch < 9) {
				cptr = &opl->op[cur_ch];
			}
			else {
				cptr = &opl->op[cur_ch + 9];	// second set is operator18-operator35
				k += (-9 + 256);		// second set uses registers 0x100 onwards
			}
			// check if this operator is part of a 4-op
			if ((opl->adlibreg[0x105] & 1) && cptr->is_4op_attached) continue;
#else
			cptr = &opl->op[cur_ch];
#endif

			// check for FM/AM
			if (opl->adlibreg[ARC_FEEDBACK + k] & 1) {
#if defined(OPLTYPE_IS_OPL3)
				if ((opl->adlibreg[0x105] & 1) && cptr->is_4op) {
					if (opl->adlibreg[ARC_FEEDBACK + k + 3] & 1) {
						// AM-AM-style synthesis (op1[fb] + (op2 * op3) + op4)
						if (cptr[0].op_state != OF_TYPE_OFF) {
							if (cptr[0].vibrato) {
								opl->vibval1 = opl->vibval_var1;
								for (i = 0; i < endsamples; i++)
									opl->vibval1[i] = (Bit32s)((vib_lut[i] * cptr[0].freq_high / 8)*FIXEDPT*VIBFAC);
							}
							else opl->vibval1 = opl->vibval_const;
							if (cptr[0].tremolo) opl->tremval1 = trem_lut;	// tremolo enabled, use table
							else opl->tremval1 = opl->tremval_const;

							// calculate channel output
							for (i = 0; i < endsamples; i++) {
								operator_advance(&cptr[0], opl->vibval1[i]);
								opfuncs[cptr[0].op_state](&cptr[0]);
								operator_output(&cptr[0], (cptr[0].lastcval + cptr[0].cval)*cptr[0].mfbi / 2, opl->tremval1[i]);

								Bit32s chanval = cptr[0].cval;
								CHANVAL_OUT
							}
						}

						if ((cptr[3].op_state != OF_TYPE_OFF) || (cptr[9].op_state != OF_TYPE_OFF)) {
							if ((cptr[9].vibrato) && (cptr[9].op_state != OF_TYPE_OFF)) {
								opl->vibval1 = opl->vibval_var1;
								for (i = 0; i < endsamples; i++)
									opl->vibval1[i] = (Bit32s)((vib_lut[i] * cptr[9].freq_high / 8)*FIXEDPT*VIBFAC);
							}
							else opl->vibval1 = opl->vibval_const;
							if (cptr[9].tremolo) opl->tremval1 = trem_lut;	// tremolo enabled, use table
							else opl->tremval1 = opl->tremval_const;
							if (cptr[3].tremolo) opl->tremval2 = trem_lut;	// tremolo enabled, use table
							else opl->tremval2 = opl->tremval_const;

							// calculate channel output
							for (i = 0; i < endsamples; i++) {
								operator_advance(&cptr[9], opl->vibval1[i]);
								opfuncs[cptr[9].op_state](&cptr[9]);
								operator_output(&cptr[9], 0, opl->tremval1[i]);

								operator_advance(&cptr[3], 0);
								opfuncs[cptr[3].op_state](&cptr[3]);
								operator_output(&cptr[3], cptr[9].cval*FIXEDPT, opl->tremval2[i]);

								Bit32s chanval = cptr[3].cval;
								CHANVAL_OUT
							}
						}

						if (cptr[3 + 9].op_state != OF_TYPE_OFF) {
							if (cptr[3 + 9].tremolo) opl->tremval1 = trem_lut;	// tremolo enabled, use table
							else opl->tremval1 = opl->tremval_const;

							// calculate channel output
							for (i = 0; i < endsamples; i++) {
								operator_advance(&cptr[3 + 9], 0);
								opfuncs[cptr[3 + 9].op_state](&cptr[3 + 9]);
								operator_output(&cptr[3 + 9], 0, opl->tremval1[i]);

								Bit32s chanval = cptr[3 + 9].cval;
								CHANVAL_OUT
							}
						}
					}
					else {
						// AM-FM-style synthesis (op1[fb] + (op2 * op3 * op4))
						if (cptr[0].op_state != OF_TYPE_OFF) {
							if (cptr[0].vibrato) {
								opl->vibval1 = opl->vibval_var1;
								for (i = 0; i < endsamples; i++)
									opl->vibval1[i] = (Bit32s)((vib_lut[i] * cptr[0].freq_high / 8)*FIXEDPT*VIBFAC);
							}
							else opl->vibval1 = opl->vibval_const;
							if (cptr[0].tremolo) opl->tremval1 = trem_lut;	// tremolo enabled, use table
							else opl->tremval1 = opl->tremval_const;

							// calculate channel output
							for (i = 0; i < endsamples; i++) {
								operator_advance(&cptr[0], opl->vibval1[i]);
								opfuncs[cptr[0].op_state](&cptr[0]);
								operator_output(&cptr[0], (cptr[0].lastcval + cptr[0].cval)*cptr[0].mfbi / 2, opl->tremval1[i]);

								Bit32s chanval = cptr[0].cval;
								CHANVAL_OUT
							}
						}

						if ((cptr[9].op_state != OF_TYPE_OFF) || (cptr[3].op_state != OF_TYPE_OFF) || (cptr[3 + 9].op_state != OF_TYPE_OFF)) {
							if ((cptr[9].vibrato) && (cptr[9].op_state != OF_TYPE_OFF)) {
								opl->vibval1 = opl->vibval_var1;
								for (i = 0; i < endsamples; i++)
									opl->vibval1[i] = (Bit32s)((vib_lut[i] * cptr[9].freq_high / 8)*FIXEDPT*VIBFAC);
							}
							else opl->vibval1 = opl->vibval_const;
							if (cptr[9].tremolo) opl->tremval1 = trem_lut;	// tremolo enabled, use table
							else opl->tremval1 = opl->tremval_const;
							if (cptr[3].tremolo) opl->tremval2 = trem_lut;	// tremolo enabled, use table
							else opl->tremval2 = opl->tremval_const;
							if (cptr[3 + 9].tremolo) opl->tremval3 = trem_lut;	// tremolo enabled, use table
							else opl->tremval3 = opl->tremval_const;

							// calculate channel output
							for (i = 0; i < endsamples; i++) {
								operator_advance(&cptr[9], opl->vibval1[i]);
								opfuncs[cptr[9].op_state](&cptr[9]);
								operator_output(&cptr[9], 0, opl->tremval1[i]);

								operator_advance(&cptr[3], 0);
								opfuncs[cptr[3].op_state](&cptr[3]);
								operator_output(&cptr[3], cptr[9].cval*FIXEDPT, opl->tremval2[i]);

								operator_advance(&cptr[3 + 9], 0);
								opfuncs[cptr[3 + 9].op_state](&cptr[3 + 9]);
								operator_output(&cptr[3 + 9], cptr[3].cval*FIXEDPT, opl->tremval3[i]);

								Bit32s chanval = cptr[3 + 9].cval;
								CHANVAL_OUT
							}
						}
					}
					continue;
				}
#endif
				// 2op additive synthesis
				if ((cptr[9].op_state == OF_TYPE_OFF) && (cptr[0].op_state == OF_TYPE_OFF)) continue;
				if ((cptr[0].vibrato) && (cptr[0].op_state != OF_TYPE_OFF)) {
					opl->vibval1 = opl->vibval_var1;
					for (i = 0; i < endsamples; i++)
						opl->vibval1[i] = (Bit32s)((vib_lut[i] * cptr[0].freq_high / 8)*FIXEDPT*VIBFAC);
				}
				else opl->vibval1 = opl->vibval_const;
				if ((cptr[9].vibrato) && (cptr[9].op_state != OF_TYPE_OFF)) {
					opl->vibval2 = opl->vibval_var2;
					for (i = 0; i < endsamples; i++)
						opl->vibval2[i] = (Bit32s)((vib_lut[i] * cptr[9].freq_high / 8)*FIXEDPT*VIBFAC);
				}
				else opl->vibval2 = opl->vibval_const;
				if (cptr[0].tremolo) opl->tremval1 = trem_lut;	// tremolo enabled, use table
				else opl->tremval1 = opl->tremval_const;
				if (cptr[9].tremolo) opl->tremval2 = trem_lut;	// tremolo enabled, use table
				else opl->tremval2 = opl->tremval_const;

				// calculate channel output
				for (i = 0; i < endsamples; i++) {
					// carrier1
					operator_advance(&cptr[0], opl->vibval1[i]);
					opfuncs[cptr[0].op_state](&cptr[0]);
					operator_output(&cptr[0], (cptr[0].lastcval + cptr[0].cval)*cptr[0].mfbi / 2, opl->tremval1[i]);

					// carrier2
					operator_advance(&cptr[9], opl->vibval2[i]);
					opfuncs[cptr[9].op_state](&cptr[9]);
					operator_output(&cptr[9], 0, opl->tremval2[i]);

					Bit32s chanval = cptr[9].cval + cptr[0].cval;
					CHANVAL_OUT
				}
			}
			else {
#if defined(OPLTYPE_IS_OPL3)
				if ((opl->adlibreg[0x105] & 1) && cptr->is_4op) {
					if (opl->adlibreg[ARC_FEEDBACK + k + 3] & 1) {
						// FM-AM-style synthesis ((op1[fb] * op2) + (op3 * op4))
						if ((cptr[0].op_state != OF_TYPE_OFF) || (cptr[9].op_state != OF_TYPE_OFF)) {
							if ((cptr[0].vibrato) && (cptr[0].op_state != OF_TYPE_OFF)) {
								opl->vibval1 = opl->vibval_var1;
								for (i = 0; i < endsamples; i++)
									opl->vibval1[i] = (Bit32s)((vib_lut[i] * cptr[0].freq_high / 8)*FIXEDPT*VIBFAC);
							}
							else opl->vibval1 = opl->vibval_const;
							if ((cptr[9].vibrato) && (cptr[9].op_state != OF_TYPE_OFF)) {
								opl->vibval2 = opl->vibval_var2;
								for (i = 0; i < endsamples; i++)
									opl->vibval2[i] = (Bit32s)((vib_lut[i] * cptr[9].freq_high / 8)*FIXEDPT*VIBFAC);
							}
							else opl->vibval2 = opl->vibval_const;
							if (cptr[0].tremolo) opl->tremval1 = trem_lut;	// tremolo enabled, use table
							else opl->tremval1 = opl->tremval_const;
							if (cptr[9].tremolo) opl->tremval2 = trem_lut;	// tremolo enabled, use table
							else opl->tremval2 = opl->tremval_const;

							// calculate channel output
							for (i = 0; i < endsamples; i++) {
								operator_advance(&cptr[0], opl->vibval1[i]);
								opfuncs[cptr[0].op_state](&cptr[0]);
								operator_output(&cptr[0], (cptr[0].lastcval + cptr[0].cval)*cptr[0].mfbi / 2, opl->tremval1[i]);

								operator_advance(&cptr[9], opl->vibval2[i]);
								opfuncs[cptr[9].op_state](&cptr[9]);
								operator_output(&cptr[9], cptr[0].cval*FIXEDPT, opl->tremval2[i]);

								Bit32s chanval = cptr[9].cval;
								CHANVAL_OUT
							}
						}

						if ((cptr[3].op_state != OF_TYPE_OFF) || (cptr[3 + 9].op_state != OF_TYPE_OFF)) {
							if (cptr[3].tremolo) opl->tremval1 = trem_lut;	// tremolo enabled, use table
							else opl->tremval1 = opl->tremval_const;
							if (cptr[3 + 9].tremolo) opl->tremval2 = trem_lut;	// tremolo enabled, use table
							else opl->tremval2 = opl->tremval_const;

							// calculate channel output
							for (i = 0; i < endsamples; i++) {
								operator_advance(&cptr[3], 0);
								opfuncs[cptr[3].op_state](&cptr[3]);
								operator_output(&cptr[3], 0, opl->tremval1[i]);

								operator_advance(&cptr[3 + 9], 0);
								opfuncs[cptr[3 + 9].op_state](&cptr[3 + 9]);
								operator_output(&cptr[3 + 9], cptr[3].cval*FIXEDPT, opl->tremval2[i]);

								Bit32s chanval = cptr[3 + 9].cval;
								CHANVAL_OUT
							}
						}

					}
					else {
						// FM-FM-style synthesis (op1[fb] * op2 * op3 * op4)
						if ((cptr[0].op_state != OF_TYPE_OFF) || (cptr[9].op_state != OF_TYPE_OFF) ||
							(cptr[3].op_state != OF_TYPE_OFF) || (cptr[3 + 9].op_state != OF_TYPE_OFF)) {
							if ((cptr[0].vibrato) && (cptr[0].op_state != OF_TYPE_OFF)) {
								opl->vibval1 = opl->vibval_var1;
								for (i = 0; i < endsamples; i++)
									opl->vibval1[i] = (Bit32s)((vib_lut[i] * cptr[0].freq_high / 8)*FIXEDPT*VIBFAC);
							}
							else opl->vibval1 = opl->vibval_const;
							if ((cptr[9].vibrato) && (cptr[9].op_state != OF_TYPE_OFF)) {
								opl->vibval2 = opl->vibval_var2;
								for (i = 0; i < endsamples; i++)
									opl->vibval2[i] = (Bit32s)((vib_lut[i] * cptr[9].freq_high / 8)*FIXEDPT*VIBFAC);
							}
							else opl->vibval2 = opl->vibval_const;
							if (cptr[0].tremolo) opl->tremval1 = trem_lut;	// tremolo enabled, use table
							else opl->tremval1 = opl->tremval_const;
							if (cptr[9].tremolo) opl->tremval2 = trem_lut;	// tremolo enabled, use table
							else opl->tremval2 = opl->tremval_const;
							if (cptr[3].tremolo) opl->tremval3 = trem_lut;	// tremolo enabled, use table
							else opl->tremval3 = opl->tremval_const;
							if (cptr[3 + 9].tremolo) opl->tremval4 = trem_lut;	// tremolo enabled, use table
							else opl->tremval4 = opl->tremval_const;

							// calculate channel output
							for (i = 0; i < endsamples; i++) {
								operator_advance(&cptr[0], opl->vibval1[i]);
								opfuncs[cptr[0].op_state](&cptr[0]);
								operator_output(&cptr[0], (cptr[0].lastcval + cptr[0].cval)*cptr[0].mfbi / 2, opl->tremval1[i]);

								operator_advance(&cptr[9], opl->vibval2[i]);
								opfuncs[cptr[9].op_state](&cptr[9]);
								operator_output(&cptr[9], cptr[0].cval*FIXEDPT, opl->tremval2[i]);

								operator_advance(&cptr[3], 0);
								opfuncs[cptr[3].op_state](&cptr[3]);
								operator_output(&cptr[3], cptr[9].cval*FIXEDPT, opl->tremval3[i]);

								operator_advance(&cptr[3 + 9], 0);
								opfuncs[cptr[3 + 9].op_state](&cptr[3 + 9]);
								operator_output(&cptr[3 + 9], cptr[3].cval*FIXEDPT, opl->tremval4[i]);

								Bit32s chanval = cptr[3 + 9].cval;
								CHANVAL_OUT
							}
						}
					}
					continue;
				}
#endif
				// 2op frequency modulation
				if ((cptr[9].op_state == OF_TYPE_OFF) && (cptr[0].op_state == OF_TYPE_OFF)) continue;
				if ((cptr[0].vibrato) && (cptr[0].op_state != OF_TYPE_OFF)) {
					opl->vibval1 = opl->vibval_var1;
					for (i = 0; i < endsamples; i++)
						opl->vibval1[i] = (Bit32s)((vib_lut[i] * cptr[0].freq_high / 8)*FIXEDPT*VIBFAC);
				}
				else opl->vibval1 = opl->vibval_const;
				if ((cptr[9].vibrato) && (cptr[9].op_state != OF_TYPE_OFF)) {
					opl->vibval2 = opl->vibval_var2;
					for (i = 0; i < endsamples; i++)
						opl->vibval2[i] = (Bit32s)((vib_lut[i] * cptr[9].freq_high / 8)*FIXEDPT*VIBFAC);
				}
				else opl->vibval2 = opl->vibval_const;
				if (cptr[0].tremolo) opl->tremval1 = trem_lut;	// tremolo enabled, use table
				else opl->tremval1 = opl->tremval_const;
				if (cptr[9].tremolo) opl->tremval2 = trem_lut;	// tremolo enabled, use table
				else opl->tremval2 = opl->tremval_const;

				// calculate channel output
				for (i = 0; i < endsamples; i++) {
					// modulator
					operator_advance(&cptr[0], opl->vibval1[i]);
					opfuncs[cptr[0].op_state](&cptr[0]);
					operator_output(&cptr[0], (cptr[0].lastcval + cptr[0].cval)*cptr[0].mfbi / 2, opl->tremval1[i]);

					// carrier
					operator_advance(&cptr[9], opl->vibval2[i]);
					opfuncs[cptr[9].op_state](&cptr[9]);
					operator_output(&cptr[9], cptr[0].cval*FIXEDPT, opl->tremval2[i]);

					Bit32s chanval = cptr[9].cval;
					CHANVAL_OUT
				}
			}
		}

#if defined(OPLTYPE_IS_OPL3)
		if (opl->adlibreg[0x105] & 1) {
			// convert to 16bit samples (stereo)
			for (i = 0; i < endsamples; i++) {
				clipit16(outbufl[i], sndptr++);
				clipit16(outbufr[i], sndptr++);
			}
		}
		else {
			// convert to 16bit samples (mono)
			for (i = 0; i < endsamples; i++) {
				clipit16(outbufl[i], sndptr++);
				clipit16(outbufl[i], sndptr++);
			}
		}
#else
		// convert to 16bit samples
		for (i = 0; i < endsamples; i++)
			clipit16(outbufl[i], sndptr++);
#endif

	}
}