Until now, we have confusingly used the terms "state" or "table" where we

really mean "channel". Fixed that:

OutputState     -> Channel
_curTable       -> _curChannel
_outputTables[] -> _channels[]

The biggest change was modifying all the "state" and "table" local variables
and function parameters.

Ahd, at no extra charge:

_outputTable[]  -> _regOffset[]

svn-id: r21247

1 files changed, 416 insertions, 416 deletions

diff --git a/engines/kyra/sound_adlib.cpp b/engines/kyra/sound_adlib.cpp
index 2d395469f4..e36e4c6e70 100644
--- a/engines/kyra/sound_adlib.cpp
+++ b/engines/kyra/sound_adlib.cpp
@@ -131,7 +131,7 @@ private:
 	// unk40 - Currently unused, except for updateCallback56()
 	// unk41 - Sound-effect. Used for primaryEffect2()
 
-	struct OutputState {
+	struct Channel {
 		uint8 opExtraLevel2;
 		uint8 *dataptr;
 		uint8 duration;
@@ -159,7 +159,7 @@ private:
 		int8 position;
 		uint8 regAx;
 		uint8 regBx;
-		typedef void (AdlibDriver::*Callback)(OutputState&);
+		typedef void (AdlibDriver::*Callback)(Channel&);
 		Callback primaryEffect;
 		Callback secondaryEffect;
 		uint8 unk12;
@@ -182,27 +182,27 @@ private:
 		int8 unk16;
 	};
 
-	void primaryEffect1(OutputState &state);
-	void primaryEffect2(OutputState &state);
-	void secondaryEffect1(OutputState &state);
+	void primaryEffect1(Channel &channel);
+	void primaryEffect2(Channel &channel);
+	void secondaryEffect1(Channel &channel);
 
 	void resetAdlibState();
 	void writeOPL(byte reg, byte val);
-	void initTable(OutputState &table);
-	void noteOff(OutputState &table);
+	void initChannel(Channel &channel);
+	void noteOff(Channel &channel);
 	void unkOutput2(uint8 num);
 
 	uint16 getRandomNr();
-	void setupDuration(uint8 duration, OutputState &state);
+	void setupDuration(uint8 duration, Channel &channel);
 
-	void setupNote(uint8 rawNote, OutputState &state, bool flag = false);
-	void setupInstrument(uint8 regOffset, uint8 *dataptr, OutputState &state);
-	void noteOn(OutputState &state);
+	void setupNote(uint8 rawNote, Channel &channel, bool flag = false);
+	void setupInstrument(uint8 regOffset, uint8 *dataptr, Channel &channel);
+	void noteOn(Channel &channel);
 
-	void adjustVolume(OutputState &state);
+	void adjustVolume(Channel &channel);
 
-	uint8 calculateOpLevel1(OutputState &state);
-	uint8 calculateOpLevel2(OutputState &state);
+	uint8 calculateOpLevel1(Channel &channel);
+	uint8 calculateOpLevel2(Channel &channel);
 
 	uint16 checkValue(int16 val) {
 		if (val < 0)
@@ -216,69 +216,69 @@ private:
 	void callbackProcess();
 
 	struct ParserOpcode {
-		typedef int (AdlibDriver::*POpcode)(uint8 *&dataptr, OutputState &state, uint8 value);
+		typedef int (AdlibDriver::*POpcode)(uint8 *&dataptr, Channel &channel, uint8 value);
 		POpcode function;
 		const char *name;
 	};
 	static const ParserOpcode _parserOpcodeTable[];
 	static const int _parserOpcodeTableSize;
 
-	int update_setRepeat(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_checkRepeat(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback3(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback4(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_jump(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_jumpToSubroutine(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_returnFromSubroutine(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_setBaseOctave(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback9(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_playRest(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_writeAdlib(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback12(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_setBaseNote(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_setupSecondaryEffect1(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback15(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback16(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback17(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_setupPrimaryEffect1(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_removePrimaryEffect1(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_setBaseFreq(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_setupPrimaryEffect2(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_setPriority(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback23(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback24(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_setExtraLevel1(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback26(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_playNote(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback28(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_setTempo(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_removeSecondaryEffect1(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_setChannelTempo(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_setExtraLevel3(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_setExtraLevel2(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_changeExtraLevel2(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_setAMDepth(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_setVibratoDepth(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_changeExtraLevel1(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback38(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback39(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_removePrimaryEffect2(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback41(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_resetToGlobalTempo(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback43(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback44(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback45(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback46(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback47(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback48(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback49(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback50(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback51(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback52(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback53(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback54(uint8 *&dataptr, OutputState &state, uint8 value);
-	int update_setTempoReset(uint8 *&dataptr, OutputState &state, uint8 value);
-	int updateCallback56(uint8 *&dataptr, OutputState &state, uint8 value);
+	int update_setRepeat(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_checkRepeat(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback3(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback4(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_jump(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_jumpToSubroutine(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_returnFromSubroutine(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_setBaseOctave(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback9(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_playRest(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_writeAdlib(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback12(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_setBaseNote(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_setupSecondaryEffect1(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback15(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback16(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback17(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_setupPrimaryEffect1(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_removePrimaryEffect1(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_setBaseFreq(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_setupPrimaryEffect2(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_setPriority(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback23(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback24(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_setExtraLevel1(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback26(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_playNote(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback28(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_setTempo(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_removeSecondaryEffect1(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_setChannelTempo(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_setExtraLevel3(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_setExtraLevel2(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_changeExtraLevel2(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_setAMDepth(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_setVibratoDepth(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_changeExtraLevel1(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback38(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback39(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_removePrimaryEffect2(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback41(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_resetToGlobalTempo(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback43(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback44(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback45(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback46(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback47(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback48(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback49(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback50(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback51(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback52(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback53(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback54(uint8 *&dataptr, Channel &channel, uint8 value);
+	int update_setTempoReset(uint8 *&dataptr, Channel &channel, uint8 value);
+	int updateCallback56(uint8 *&dataptr, Channel &channel, uint8 value);
 private:
 	// These variables have not yet been named, but some of them are partly
 	// known nevertheless:
@@ -320,7 +320,7 @@ private:
 
 	int _lastProcessed;
 	int8 _flagTrigger;
-	int _curTable;
+	int _curChannel;
 	uint8 _unk4;
 	uint8 _unk5;
 	int _soundsPlaying;
@@ -355,7 +355,7 @@ private:
 	uint8 *_soundData;
 
 	uint8 _soundIdTable[0x10];
-	OutputState _outputTables[10];
+	Channel _channels[10];
 
 	uint8 _unkOutputByte2;
 	uint8 _curRegOffset;
@@ -364,7 +364,7 @@ private:
 	const uint8 *_tablePtr1;
 	const uint8 *_tablePtr2;
 
-	static const uint8 _outputTable[];
+	static const uint8 _regOffset[];
 	static const uint16 _unkTable[];
 	static const uint8 *_unkTable2[];
 	static const uint8 _unkTable2_1[];
@@ -386,12 +386,12 @@ AdlibDriver::AdlibDriver(Audio::Mixer *mixer) {
 	_adlib = makeAdlibOPL(getRate());
 	assert(_adlib);
 
-	memset(_outputTables, 0, sizeof(_outputTables));
+	memset(_channels, 0, sizeof(_channels));
 	_soundData = 0;
 
 	_unkOutputByte2 = _curRegOffset = 0;
 
-	_lastProcessed = _flagTrigger = _curTable = _unk4 = 0;
+	_lastProcessed = _flagTrigger = _curChannel = _unk4 = 0;
 	_rnd = 0x1234;
 	_continueFlag = 0;
 
@@ -511,12 +511,12 @@ int AdlibDriver::snd_unkOpcode3(va_list &list) {
 	++loop;
 
 	while (loop--) {
-		_curTable = value;
-		OutputState &table = _outputTables[_curTable];
-		table.priority = 0;
-		table.dataptr = 0;
+		_curChannel = value;
+		Channel &channel = _channels[_curChannel];
+		channel.priority = 0;
+		channel.dataptr = 0;
 		if (value != 9) {
-			noteOff(table);
+			noteOff(channel);
 		}
 		++value;
 	}
@@ -603,23 +603,23 @@ void AdlibDriver::callbackOutput() {
 		uint8 *ptr = _soundData;
 
 		ptr += READ_LE_UINT16(&ptr[_soundIdTable[_lastProcessed] << 1]);
-		uint8 index = *ptr++;
-		OutputState &table = _outputTables[index];
+		uint8 chan = *ptr++;
+		Channel &channel = _channels[chan];
 
 		uint8 priority = *ptr++;
 
 		// Only start this sound if its priority is higher than the one
 		// already playing.
 
-		if (priority >= table.priority) {
-			initTable(table);
-			table.priority = priority;
-			table.dataptr = ptr;
-			table.tempo = -1;
-			table.position = -1;
-			table.duration = 1;
-			if (index != 9) {
-				unkOutput2(index);
+		if (priority >= channel.priority) {
+			initChannel(channel);
+			channel.priority = priority;
+			channel.dataptr = ptr;
+			channel.tempo = -1;
+			channel.position = -1;
+			channel.duration = 1;
+			if (chan != 9) {
+				unkOutput2(chan);
 			}
 		}
 
@@ -665,47 +665,47 @@ void AdlibDriver::callbackOutput() {
 // function and it returns anything other than 1.
 
 void AdlibDriver::callbackProcess() {
-	for (_curTable = 9; _curTable >= 0; --_curTable) {
-		if (!_outputTables[_curTable].dataptr) {
+	for (_curChannel = 9; _curChannel >= 0; --_curChannel) {
+		if (!_channels[_curChannel].dataptr) {
 			continue;
 		}
 	
-		OutputState &table = _outputTables[_curTable];
-		_curRegOffset = _outputTable[_curTable];
+		Channel &channel = _channels[_curChannel];
+		_curRegOffset = _regOffset[_curChannel];
 
-		if (table.tempoReset) {
-			table.tempo = _tempo;
+		if (channel.tempoReset) {
+			channel.tempo = _tempo;
 		}
 
-		int8 backup = table.position;
-		table.position += table.tempo;
-		if (table.position < backup) {
-			if (--table.duration) {
-				if (table.duration == table.unk7)
-					noteOff(table);
-				if (table.duration == table.unk3 && _curTable != 9)
-					noteOff(table);
+		int8 backup = channel.position;
+		channel.position += channel.tempo;
+		if (channel.position < backup) {
+			if (--channel.duration) {
+				if (channel.duration == channel.unk7)
+					noteOff(channel);
+				if (channel.duration == channel.unk3 && _curChannel != 9)
+					noteOff(channel);
 			} else {
 				int8 opcode = 0;
-				while (table.dataptr) {
-					uint16 command = READ_LE_UINT16(table.dataptr);
-					table.dataptr += 2;
+				while (channel.dataptr) {
+					uint16 command = READ_LE_UINT16(channel.dataptr);
+					channel.dataptr += 2;
 					if (command & 0x0080) {
 						opcode = command & 0x7F;
 						if (opcode > 0x4A)
 							opcode = 0x4A;
-						debugC(9, kDebugLevelSound, "Calling opcode '%s' (%d) (channel: %d)", _parserOpcodeTable[opcode].name, opcode, _curTable);
-						opcode = (this->*(_parserOpcodeTable[opcode].function))(table.dataptr, table, (command & 0xFF00) >> 8);
+						debugC(9, kDebugLevelSound, "Calling opcode '%s' (%d) (channel: %d)", _parserOpcodeTable[opcode].name, opcode, _curChannel);
+						opcode = (this->*(_parserOpcodeTable[opcode].function))(channel.dataptr, channel, (command & 0xFF00) >> 8);
 						--opcode;
 						if (opcode >= 0)
 							break;
 						continue;
 					} else {
-						debugC(9, kDebugLevelSound, "Note on opcode 0x%02X (duration: %d) (channel: %d)", command & 0xFF, (command >> 8) & 0xFF, _curTable);
+						debugC(9, kDebugLevelSound, "Note on opcode 0x%02X (duration: %d) (channel: %d)", command & 0xFF, (command >> 8) & 0xFF, _curChannel);
 						opcode = 0;
-						setupNote(command & 0xFF, table);
-						noteOn(table);
-						setupDuration((command & 0xFF00) >> 8, table);
+						setupNote(command & 0xFF, channel);
+						noteOn(channel);
+						setupDuration((command & 0xFF00) >> 8, channel);
 						if (!_continueFlag)
 							continue;
 						break;
@@ -716,10 +716,10 @@ void AdlibDriver::callbackProcess() {
 			}
 		}
 
-		if (table.primaryEffect)
-			(this->*(table.primaryEffect))(table);
-		if (table.secondaryEffect)
-			(this->*(table.secondaryEffect))(table);
+		if (channel.primaryEffect)
+			(this->*(channel.primaryEffect))(channel);
+		if (channel.secondaryEffect)
+			(this->*(channel.secondaryEffect))(channel);
 	}
 }
 
@@ -743,10 +743,10 @@ void AdlibDriver::resetAdlibState() {
 	while (loop--) {
 		if (loop != 9) {
 			// Silence the channel
-			writeOPL(0x40 + _outputTable[loop], 0x3F);
-			writeOPL(0x43 + _outputTable[loop], 0x3F);
+			writeOPL(0x40 + _regOffset[loop], 0x3F);
+			writeOPL(0x43 + _regOffset[loop], 0x3F);
 		}
-		initTable(_outputTables[loop]);
+		initChannel(_channels[loop]);
 	}
 }
 
@@ -757,54 +757,54 @@ void AdlibDriver::writeOPL(byte reg, byte val) {
 	OPLWriteReg(_adlib, reg, val);
 }
 
-void AdlibDriver::initTable(OutputState &table) {
-	debugC(9, kDebugLevelSound, "initTable(%d)", &table - _outputTables);
-	memset(&table.dataptr, 0, sizeof(OutputState) - ((char*)&table.dataptr - (char*)&table));
+void AdlibDriver::initChannel(Channel &channel) {
+	debugC(9, kDebugLevelSound, "initChannel(%d)", &channel - _channels);
+	memset(&channel.dataptr, 0, sizeof(Channel) - ((char*)&channel.dataptr - (char*)&channel));
 
-	table.tempo = -1;
-	table.priority = 0;
+	channel.tempo = -1;
+	channel.priority = 0;
 	// normally here are nullfuncs but we set 0 for now
-	table.primaryEffect = 0;
-	table.secondaryEffect = 0;
-	table.unk3 = 0x01;
+	channel.primaryEffect = 0;
+	channel.secondaryEffect = 0;
+	channel.unk3 = 0x01;
 }
 
-void AdlibDriver::noteOff(OutputState &table) {
-	debugC(9, kDebugLevelSound, "noteOff(%d)", &table - _outputTables);
+void AdlibDriver::noteOff(Channel &channel) {
+	debugC(9, kDebugLevelSound, "noteOff(%d)", &channel - _channels);
 
 	// I believe that 9 is the percussion channel.
-	if (_curTable == 9)
+	if (_curChannel == 9)
 		return;
 
 	// I believe this has to do with channels 6, 7, and 8 being special
 	// when Adlib's rhythm section is enabled.
-	if (_unk4 && _curTable >= 6)
+	if (_unk4 && _curChannel >= 6)
 		return;
 
 	// This means the "Key On" bit will always be 0
-	table.regBx &= 0xDF;
+	channel.regBx &= 0xDF;
 
 	// Octave / F-Number / Key-On
-	writeOPL(0xB0 + _curTable, table.regBx);
+	writeOPL(0xB0 + _curChannel, channel.regBx);
 }
 
-void AdlibDriver::unkOutput2(uint8 num) {
-	debugC(9, kDebugLevelSound, "unkOutput2(%d)", num);
+void AdlibDriver::unkOutput2(uint8 chan) {
+	debugC(9, kDebugLevelSound, "unkOutput2(%d)", chan);
 
 	// I believe this has to do with channels 6, 7, and 8 being special
 	// when Adlib's rhythm section is enabled.
-	if (_unk4 && num >= 6)
+	if (_unk4 && chan >= 6)
 		return;
 
-	uint8 value = _outputTable[num];
+	uint8 offset = _regOffset[chan];
 
 	// Clear the Attack Rate / Decay Rate for the channel
-	writeOPL(0x60 + value, 0xFF);
-	writeOPL(0x63 + value, 0xFF);
+	writeOPL(0x60 + offset, 0xFF);
+	writeOPL(0x63 + offset, 0xFF);
 
 	// Clear the Sustain Level / Release Rate for the channel
-	writeOPL(0x80 + value, 0xFF);
-	writeOPL(0x83 + value, 0xFF);
+	writeOPL(0x80 + offset, 0xFF);
+	writeOPL(0x83 + offset, 0xFF);
 
 	// Octave / F-Number / Key-On
 
@@ -812,8 +812,8 @@ void AdlibDriver::unkOutput2(uint8 num) {
 	// function, but it also clears the octave and the part of the
 	// frequency (F-Number) stored in this register. Weird.
 
-	writeOPL(0xB0 + num, 0x00);
-	writeOPL(0xB0 + num, 0x20);
+	writeOPL(0xB0 + chan, 0x00);
+	writeOPL(0xB0 + chan, 0x20);
 }
 
 // I believe this is a random number generator. It actually does seem to
@@ -828,29 +828,29 @@ uint16 AdlibDriver::getRandomNr() {
 	return _rnd;
 }
 
-void AdlibDriver::setupDuration(uint8 duration, OutputState &state) {
-	debugC(9, kDebugLevelSound, "setupDuration(%d, %d)", duration, &state - _outputTables);
+void AdlibDriver::setupDuration(uint8 duration, Channel &channel) {
+	debugC(9, kDebugLevelSound, "setupDuration(%d, %d)", duration, &channel - _channels);
 	_continueFlag = duration;
-	if (state.unk11) {
-		state.duration = duration + (getRandomNr() & state.unk11);
+	if (channel.unk11) {
+		channel.duration = duration + (getRandomNr() & channel.unk11);
 		return;
 	}
-	if (state.unk12) {
-		state.unk7 = (duration >> 3) * state.unk12;
+	if (channel.unk12) {
+		channel.unk7 = (duration >> 3) * channel.unk12;
 	}
-	state.duration = duration;
+	channel.duration = duration;
 }
 
 // This function may or may not play the note. It's usually followed by a call
 // to noteOn(), which will always play the current note.
 
-void AdlibDriver::setupNote(uint8 rawNote, OutputState &state, bool flag) {
-	debugC(9, kDebugLevelSound, "setupNote(%d, %d)", rawNote, &state - _outputTables);
+void AdlibDriver::setupNote(uint8 rawNote, Channel &channel, bool flag) {
+	debugC(9, kDebugLevelSound, "setupNote(%d, %d)", rawNote, &channel - _channels);
 
-	state.rawNote = rawNote;
+	channel.rawNote = rawNote;
 
-	int8 note = (rawNote & 0x0F) + state.baseNote;
-	int8 octave = ((rawNote + state.baseOctave) >> 4) & 0x0F;
+	int8 note = (rawNote & 0x0F) + channel.baseNote;
+	int8 octave = ((rawNote + channel.baseOctave) >> 4) & 0x0F;
 
 	// There are only twelve notes. If we go outside that, we have to
 	// adjust the note and octave.
@@ -873,33 +873,33 @@ void AdlibDriver::setupNote(uint8 rawNote, OutputState &state, bool flag) {
 	// octave bits, and that could possibly have been used in some sound.
 	// But as it is now, I can't see any way it would happen.
 
-	uint16 freq = _unkTable[note] + state.baseFreq;
+	uint16 freq = _unkTable[note] + channel.baseFreq;
 
 	// When called from callback 41, the behaviour is slightly different:
-	// We adjust the frequency, even when state.unk16 is 0.
+	// We adjust the frequency, even when channel.unk16 is 0.
 
-	if (state.unk16 || flag) {
+	if (channel.unk16 || flag) {
 		const uint8 *table;
 
-		if (state.unk16 >= 0) {
-			table = _unkTables[(state.rawNote & 0x0F) + 2];
-			freq += table[state.unk16];
+		if (channel.unk16 >= 0) {
+			table = _unkTables[(channel.rawNote & 0x0F) + 2];
+			freq += table[channel.unk16];
 		} else {
-			table = _unkTables[state.rawNote & 0x0F];
-			freq -= table[-state.unk16];
+			table = _unkTables[channel.rawNote & 0x0F];
+			freq -= table[-channel.unk16];
 		}
 	}
 
-	state.regAx = freq & 0xFF;
-	state.regBx = (state.regBx & 0x20) | (octave << 2) | ((freq >> 8) & 0x03);
+	channel.regAx = freq & 0xFF;
+	channel.regBx = (channel.regBx & 0x20) | (octave << 2) | ((freq >> 8) & 0x03);
 
 	// Keep the note on or off
-	writeOPL(0xA0 + _curTable, state.regAx);
-	writeOPL(0xB0 + _curTable, state.regBx);
+	writeOPL(0xA0 + _curChannel, channel.regAx);
+	writeOPL(0xB0 + _curChannel, channel.regBx);
 }
 
-void AdlibDriver::setupInstrument(uint8 regOffset, uint8 *dataptr, OutputState &state) {
-	debugC(9, kDebugLevelSound, "setupInstrument(%d, %p, %d)", regOffset, (const void *)dataptr, &state - _outputTables);
+void AdlibDriver::setupInstrument(uint8 regOffset, uint8 *dataptr, Channel &channel) {
+	debugC(9, kDebugLevelSound, "setupInstrument(%d, %p, %d)", regOffset, (const void *)dataptr, &channel - _channels);
 	// Amplitude Modulation / Vibrato / Envelope Generator Type /
 	// Keyboard Scaling Rate / Modulator Frequency Multiple
 	writeOPL(0x20 + regOffset, *dataptr++);
@@ -909,10 +909,10 @@ void AdlibDriver::setupInstrument(uint8 regOffset, uint8 *dataptr, OutputState &
 
 	// Feedback / Algorithm
 
-	// It is very likely that _curTable really does refer to the same
+	// It is very likely that _curChannel really does refer to the same
 	// channel as regOffset, but there's only one Cx register per channel.
 
-	writeOPL(0xC0 + _curTable, temp);
+	writeOPL(0xC0 + _curChannel, temp);
 
 	// The algorithm bit. I don't pretend to understand this fully, but
 	// "If set to 0, operator 1 modulates operator 2. In this case,
@@ -920,18 +920,18 @@ void AdlibDriver::setupInstrument(uint8 regOffset, uint8 *dataptr, OutputState &
 	// operators produce sound directly. Complex sounds are more easily
 	// created if the algorithm is set to 0."
 
-	state.twoChan = temp & 1;
+	channel.twoChan = temp & 1;
 
 	// Waveform Select
 	writeOPL(0xE0 + regOffset, *dataptr++);
 	writeOPL(0xE3 + regOffset, *dataptr++);
 
-	state.opLevel1 = *dataptr++;
-	state.opLevel2 = *dataptr++;
+	channel.opLevel1 = *dataptr++;
+	channel.opLevel2 = *dataptr++;
 
 	// Level Key Scaling / Total Level
-	writeOPL(0x40 + regOffset, calculateOpLevel1(state));
-	writeOPL(0x43 + regOffset, calculateOpLevel2(state));
+	writeOPL(0x40 + regOffset, calculateOpLevel1(channel));
+	writeOPL(0x43 + regOffset, calculateOpLevel2(channel));
 
 	// Attack Rate / Decay Rate
 	writeOPL(0x60 + regOffset, *dataptr++);
@@ -945,27 +945,27 @@ void AdlibDriver::setupInstrument(uint8 regOffset, uint8 *dataptr, OutputState &
 // Apart from playing the note, this function also updates the variables for
 // primary effect 2.
 
-void AdlibDriver::noteOn(OutputState &state) {
-	debugC(9, kDebugLevelSound, "noteOn(%d)", &state - _outputTables);
+void AdlibDriver::noteOn(Channel &channel) {
+	debugC(9, kDebugLevelSound, "noteOn(%d)", &channel - _channels);
 
 	// The "note on" bit is set, and the current note is played.
 
-	state.regBx |= 0x20;
-	writeOPL(0xB0 + _curTable, state.regBx);
+	channel.regBx |= 0x20;
+	writeOPL(0xB0 + _curChannel, channel.regBx);
 
-	int8 shift = 9 - state.unk33;
-	uint16 temp = state.regAx | (state.regBx << 8);
-	state.unk37 = ((temp & 0x3FF) >> shift) & 0xFF;
-	state.unk38 = state.unk36;
+	int8 shift = 9 - channel.unk33;
+	uint16 temp = channel.regAx | (channel.regBx << 8);
+	channel.unk37 = ((temp & 0x3FF) >> shift) & 0xFF;
+	channel.unk38 = channel.unk36;
 }
 
-void AdlibDriver::adjustVolume(OutputState &state) {
-	debugC(9, kDebugLevelSound, "adjustVolume(%d)", &state - _outputTables);
+void AdlibDriver::adjustVolume(Channel &channel) {
+	debugC(9, kDebugLevelSound, "adjustVolume(%d)", &channel - _channels);
 	// Level Key Scaling / Total Level
 
-	writeOPL(0x43 + _outputTable[_curTable], calculateOpLevel2(state));
-	if (state.twoChan)
-		writeOPL(0x40 + _outputTable[_curTable], calculateOpLevel1(state));
+	writeOPL(0x43 + _regOffset[_curChannel], calculateOpLevel2(channel));
+	if (channel.twoChan)
+		writeOPL(0x40 + _regOffset[_curChannel], calculateOpLevel1(channel));
 }
 
 // This is presumably only used for some sound effects, e.g. Malcolm blowing up
@@ -984,21 +984,21 @@ void AdlibDriver::adjustVolume(OutputState &state) {
 // unk30 - modifies the frequency
 // unk31 - determines how often the notes are played
 
-void AdlibDriver::primaryEffect1(OutputState &state) {
-	debugC(9, kDebugLevelSound, "Calling primaryEffect1 (channel: %d)", _curTable);
-	int8 temp = state.unk31;
-	state.unk31 += state.unk29;
-	if (state.unk31 >= temp)
+void AdlibDriver::primaryEffect1(Channel &channel) {
+	debugC(9, kDebugLevelSound, "Calling primaryEffect1 (channel: %d)", _curChannel);
+	int8 temp = channel.unk31;
+	channel.unk31 += channel.unk29;
+	if (channel.unk31 >= temp)
 		return;
 
 	// Initialise unk1 to the current frequency
-	uint16 unk1 = ((state.regBx & 3) << 8) | state.regAx;
+	uint16 unk1 = ((channel.regBx & 3) << 8) | channel.regAx;
 
 	// This is presumably to shift the "note on" bit so far to the left
 	// that it won't be affected by any of the calculations below.
-	uint16 unk2 = ((state.regBx & 0x20) << 8) | (state.regBx & 0x1C);
+	uint16 unk2 = ((channel.regBx & 0x20) << 8) | (channel.regBx & 0x1C);
 
-	int16 unk3 = (int16)state.unk30;
+	int16 unk3 = (int16)channel.unk30;
 
 	if (unk3 >= 0) {
 		unk1 += unk3;
@@ -1027,16 +1027,16 @@ void AdlibDriver::primaryEffect1(OutputState &state) {
 	// Make sure that the new frequency is still a 10-bit value.
 	unk1 &= 0x3FF;
 
-	writeOPL(0xA0 + _curTable, unk1 & 0xFF);
-	state.regAx = unk1 & 0xFF;
+	writeOPL(0xA0 + _curChannel, unk1 & 0xFF);
+	channel.regAx = unk1 & 0xFF;
 
 	// Shift down the "note on" bit again.
 	uint8 value = unk1 >> 8;
 	value |= (unk2 >> 8) & 0xFF;
 	value |= unk2 & 0xFF;
 
-	writeOPL(0xB0 + _curTable, value);
-	state.regBx = value;
+	writeOPL(0xB0 + _curChannel, value);
+	channel.regBx = value;
 }
 
 // This is presumably only used for some sound effects, e.g. Malcolm entering
@@ -1067,33 +1067,33 @@ void AdlibDriver::primaryEffect1(OutputState &state) {
 // Note that unk41 is never initialised. Not that it should matter much, but it
 // is a bit sloppy.
 
-void AdlibDriver::primaryEffect2(OutputState &state) {
-	debugC(9, kDebugLevelSound, "Calling primaryEffect2 (channel: %d)", _curTable);
-	if (state.unk38) {
-		--state.unk38;
+void AdlibDriver::primaryEffect2(Channel &channel) {
+	debugC(9, kDebugLevelSound, "Calling primaryEffect2 (channel: %d)", _curChannel);
+	if (channel.unk38) {
+		--channel.unk38;
 		return;
 	}
 
-	int8 temp = state.unk41;
-	state.unk41 += state.unk32;
-	if (state.unk41 < temp) {
-		uint16 unk1 = state.unk37;
-		if (!(--state.unk34)) {
+	int8 temp = channel.unk41;
+	channel.unk41 += channel.unk32;
+	if (channel.unk41 < temp) {
+		uint16 unk1 = channel.unk37;
+		if (!(--channel.unk34)) {
 			unk1 ^= 0xFFFF;
 			++unk1;
-			state.unk37 = unk1;
-			state.unk34 = state.unk35;
+			channel.unk37 = unk1;
+			channel.unk34 = channel.unk35;
 		}
 
-		uint16 unk2 = (state.regAx | (state.regBx << 8)) & 0x3FF;
+		uint16 unk2 = (channel.regAx | (channel.regBx << 8)) & 0x3FF;
 		unk2 += unk1;
 		
-		state.regAx = unk2 & 0xFF;
-		state.regBx = (state.regBx & 0xFC) | (unk2 >> 8);
+		channel.regAx = unk2 & 0xFF;
+		channel.regBx = (channel.regBx & 0xFC) | (unk2 >> 8);
 
 		// Octave / F-Number / Key-On
-		writeOPL(0xA0 + _curTable, state.regAx);
-		writeOPL(0xB0 + _curTable, state.regBx);
+		writeOPL(0xA0 + _curChannel, channel.regAx);
+		writeOPL(0xB0 + _curChannel, channel.regBx);
 	}
 }
 
@@ -1122,25 +1122,25 @@ void AdlibDriver::primaryEffect2(OutputState &state) {
 // unk22 -  the operation to perform
 // offset - the offset to the data chunk
 
-void AdlibDriver::secondaryEffect1(OutputState &state) {
-	debugC(9, kDebugLevelSound, "Calling secondaryEffect1 (channel: %d)", _curTable);
-	int8 temp = state.unk18;
-	state.unk18 += state.unk19;
-	if (state.unk18 < temp) {
-		if (--state.unk21 < 0) {
-			state.unk21 = state.unk20;
+void AdlibDriver::secondaryEffect1(Channel &channel) {
+	debugC(9, kDebugLevelSound, "Calling secondaryEffect1 (channel: %d)", _curChannel);
+	int8 temp = channel.unk18;
+	channel.unk18 += channel.unk19;
+	if (channel.unk18 < temp) {
+		if (--channel.unk21 < 0) {
+			channel.unk21 = channel.unk20;
 		}
-		writeOPL(state.unk22 + _curRegOffset, _soundData[state.offset + state.unk21]);
+		writeOPL(channel.unk22 + _curRegOffset, _soundData[channel.offset + channel.unk21]);
 	}
 }
 
-uint8 AdlibDriver::calculateOpLevel1(OutputState &state) {
-	int8 value = state.opLevel1 & 0x3F;
+uint8 AdlibDriver::calculateOpLevel1(Channel &channel) {
+	int8 value = channel.opLevel1 & 0x3F;
 
-	if (state.twoChan) {
-		value += state.opExtraLevel1;
-		value += state.opExtraLevel2;
-		value += state.opExtraLevel3;
+	if (channel.twoChan) {
+		value += channel.opExtraLevel1;
+		value += channel.opExtraLevel2;
+		value += channel.opExtraLevel3;
 	}
 
 	// Don't allow the total level to overflow into the scaling level bits.
@@ -1152,15 +1152,15 @@ uint8 AdlibDriver::calculateOpLevel1(OutputState &state) {
 
 	// Preserve the scaling level bits from opLevel1
 
-	return value | (state.opLevel1 & 0xC0);
+	return value | (channel.opLevel1 & 0xC0);
 }
 
-uint8 AdlibDriver::calculateOpLevel2(OutputState &state) {
-	int8 value = state.opLevel2 & 0x3F;
+uint8 AdlibDriver::calculateOpLevel2(Channel &channel) {
+	int8 value = channel.opLevel2 & 0x3F;
 
-	value += state.opExtraLevel1;
-	value += state.opExtraLevel2;
-	value += state.opExtraLevel3;
+	value += channel.opExtraLevel1;
+	value += channel.opExtraLevel2;
+	value += channel.opExtraLevel3;
 
 	// Don't allow the total level to overflow into the scaling level bits.
 
@@ -1171,19 +1171,19 @@ uint8 AdlibDriver::calculateOpLevel2(OutputState &state) {
 
 	// Preserve the scaling level bits from opLevel2
 
-	return value | (state.opLevel2 & 0xC0);
+	return value | (channel.opLevel2 & 0xC0);
 }
 
 // parser opcodes
 
-int AdlibDriver::update_setRepeat(uint8 *&dataptr, OutputState &state, uint8 value) {
-	state.repeatCounter = value;
+int AdlibDriver::update_setRepeat(uint8 *&dataptr, Channel &channel, uint8 value) {
+	channel.repeatCounter = value;
 	return 0;
 }
 
-int AdlibDriver::update_checkRepeat(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::update_checkRepeat(uint8 *&dataptr, Channel &channel, uint8 value) {
 	++dataptr;
-	if (--state.repeatCounter) {
+	if (--channel.repeatCounter) {
 		int16 add = READ_LE_UINT16(dataptr - 2);
 		dataptr += add;
 	}
@@ -1192,165 +1192,165 @@ int AdlibDriver::update_checkRepeat(uint8 *&dataptr, OutputState &state, uint8 v
 
 // This is similar to callbackOutput()
 
-int AdlibDriver::updateCallback3(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::updateCallback3(uint8 *&dataptr, Channel &channel, uint8 value) {
 	if (value == 0xFF)
 		return 0;
 
 	uint16 add = value << 1;
 	uint8 *ptr = _soundData + READ_LE_UINT16(_soundData + add);
-	uint8 table = *ptr++;
-	OutputState &state2 = _outputTables[table];
+	uint8 chan = *ptr++;
+	Channel &channel2 = _channels[chan];
 	uint8 priority = *ptr++;
-	if (priority >= state2.priority) {
+	if (priority >= channel2.priority) {
 		_flagTrigger = 1;
 		_flags |= 8;
-		initTable(state2);
-		state2.priority = priority;
-		state2.dataptr = ptr;
-		state2.tempo = -1;
-		state2.position = -1;
-		state2.duration = 1;
-		unkOutput2(table);
+		initChannel(channel2);
+		channel2.priority = priority;
+		channel2.dataptr = ptr;
+		channel2.tempo = -1;
+		channel2.position = -1;
+		channel2.duration = 1;
+		unkOutput2(chan);
 	}
 	return 0;
 }
 
-int AdlibDriver::updateCallback4(uint8 *&dataptr, OutputState &state, uint8 value) {
-	state.unk3 = value;
+int AdlibDriver::updateCallback4(uint8 *&dataptr, Channel &channel, uint8 value) {
+	channel.unk3 = value;
 	return 0;
 }
 
-int AdlibDriver::update_jump(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::update_jump(uint8 *&dataptr, Channel &channel, uint8 value) {
 	--dataptr;
 	int16 add = READ_LE_UINT16(dataptr); dataptr += 2;
 	dataptr += add;
 	return 0;
 }
 
-int AdlibDriver::update_jumpToSubroutine(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::update_jumpToSubroutine(uint8 *&dataptr, Channel &channel, uint8 value) {
 	--dataptr;
 	int16 add = READ_LE_UINT16(dataptr); dataptr += 2;
-	state.dataptrStack[state.dataptrStackPos++] = dataptr;
+	channel.dataptrStack[channel.dataptrStackPos++] = dataptr;
 	dataptr += add;
 	return 0;
 }
 
-int AdlibDriver::update_returnFromSubroutine(uint8 *&dataptr, OutputState &state, uint8 value) {
-	dataptr = state.dataptrStack[--state.dataptrStackPos];
+int AdlibDriver::update_returnFromSubroutine(uint8 *&dataptr, Channel &channel, uint8 value) {
+	dataptr = channel.dataptrStack[--channel.dataptrStackPos];
 	return 0;
 }
 
-int AdlibDriver::update_setBaseOctave(uint8 *&dataptr, OutputState &state, uint8 value) {
-	state.baseOctave = value;
+int AdlibDriver::update_setBaseOctave(uint8 *&dataptr, Channel &channel, uint8 value) {
+	channel.baseOctave = value;
 	return 0;
 }
 
-int AdlibDriver::updateCallback9(uint8 *&dataptr, OutputState &state, uint8 value) {
-	state.priority = 0;
-	if (_curTable != 9) {
-		noteOff(state);
+int AdlibDriver::updateCallback9(uint8 *&dataptr, Channel &channel, uint8 value) {
+	channel.priority = 0;
+	if (_curChannel != 9) {
+		noteOff(channel);
 	}
 	dataptr = 0;
 	return 2;
 }
 
-int AdlibDriver::update_playRest(uint8 *&dataptr, OutputState &state, uint8 value) {
-	setupDuration(value, state);
-	noteOff(state);
+int AdlibDriver::update_playRest(uint8 *&dataptr, Channel &channel, uint8 value) {
+	setupDuration(value, channel);
+	noteOff(channel);
 	return (_continueFlag != 0);
 }
 
-int AdlibDriver::update_writeAdlib(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::update_writeAdlib(uint8 *&dataptr, Channel &channel, uint8 value) {
 	writeOPL(value, *dataptr++);
 	return 0;
 }
 
-int AdlibDriver::updateCallback12(uint8 *&dataptr, OutputState &state, uint8 value) {
-	setupNote(value, state);
+int AdlibDriver::updateCallback12(uint8 *&dataptr, Channel &channel, uint8 value) {
+	setupNote(value, channel);
 	value = *dataptr++;
-	setupDuration(value, state);
+	setupDuration(value, channel);
 	return (_continueFlag != 0);
 }
 
-int AdlibDriver::update_setBaseNote(uint8 *&dataptr, OutputState &state, uint8 value) {
-	state.baseNote = value;
+int AdlibDriver::update_setBaseNote(uint8 *&dataptr, Channel &channel, uint8 value) {
+	channel.baseNote = value;
 	return 0;
 }
 
-int AdlibDriver::update_setupSecondaryEffect1(uint8 *&dataptr, OutputState &state, uint8 value) {
-	state.unk18 = value;
-	state.unk19 = value;
-	state.unk20 = state.unk21 = *dataptr++;
-	state.unk22 = *dataptr++;
-	state.offset = READ_LE_UINT16(dataptr); dataptr += 2;
-	state.secondaryEffect = &AdlibDriver::secondaryEffect1;
+int AdlibDriver::update_setupSecondaryEffect1(uint8 *&dataptr, Channel &channel, uint8 value) {
+	channel.unk18 = value;
+	channel.unk19 = value;
+	channel.unk20 = channel.unk21 = *dataptr++;
+	channel.unk22 = *dataptr++;
+	channel.offset = READ_LE_UINT16(dataptr); dataptr += 2;
+	channel.secondaryEffect = &AdlibDriver::secondaryEffect1;
 	return 0;
 }
 
-int AdlibDriver::updateCallback15(uint8 *&dataptr, OutputState &state, uint8 value) {
-	OutputState &state2 = _outputTables[value];
-	state2.duration = 0;
-	state2.priority = 0;
-	state2.dataptr = 0;
+int AdlibDriver::updateCallback15(uint8 *&dataptr, Channel &channel, uint8 value) {
+	Channel &channel2 = _channels[value];
+	channel2.duration = 0;
+	channel2.priority = 0;
+	channel2.dataptr = 0;
 	return 0;
 }
 
-int AdlibDriver::updateCallback16(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::updateCallback16(uint8 *&dataptr, Channel &channel, uint8 value) {
 	uint8 *ptr = _soundData;
 	ptr += READ_LE_UINT16(&_soundData[value << 1]);
-	OutputState &state2 = _outputTables[*ptr];
-	if (!state2.dataptr) {
+	Channel &channel2 = _channels[*ptr];
+	if (!channel2.dataptr) {
 		return 0;
 	}
 	dataptr -= 2;
 	return 2;
 }
 
-int AdlibDriver::updateCallback17(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::updateCallback17(uint8 *&dataptr, Channel &channel, uint8 value) {
 	uint8 *ptr = _soundData;
 	ptr += READ_LE_UINT16(_soundData + (value << 1) + 0x1F4);
-	setupInstrument(_curRegOffset, ptr, state);
+	setupInstrument(_curRegOffset, ptr, channel);
 	return 0;
 }
 
-int AdlibDriver::update_setupPrimaryEffect1(uint8 *&dataptr, OutputState &state, uint8 value) {
-	state.unk29 = value;
-	state.unk30 = READ_BE_UINT16(dataptr);
+int AdlibDriver::update_setupPrimaryEffect1(uint8 *&dataptr, Channel &channel, uint8 value) {
+	channel.unk29 = value;
+	channel.unk30 = READ_BE_UINT16(dataptr);
 	dataptr += 2;
-	state.primaryEffect = &AdlibDriver::primaryEffect1;
-	state.unk31 = -1;
+	channel.primaryEffect = &AdlibDriver::primaryEffect1;
+	channel.unk31 = -1;
 	return 0;
 }
 
-int AdlibDriver::update_removePrimaryEffect1(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::update_removePrimaryEffect1(uint8 *&dataptr, Channel &channel, uint8 value) {
 	--dataptr;
-	state.primaryEffect = 0;
-	state.unk30 = 0;
+	channel.primaryEffect = 0;
+	channel.unk30 = 0;
 	return 0;
 }
 
-int AdlibDriver::update_setBaseFreq(uint8 *&dataptr, OutputState &state, uint8 value) {
-	state.baseFreq = value;
+int AdlibDriver::update_setBaseFreq(uint8 *&dataptr, Channel &channel, uint8 value) {
+	channel.baseFreq = value;
 	return 0;
 }
 
-int AdlibDriver::update_setupPrimaryEffect2(uint8 *&dataptr, OutputState &state, uint8 value) {
-	state.unk32 = (int8)value;
-	state.unk33 = *dataptr++;
+int AdlibDriver::update_setupPrimaryEffect2(uint8 *&dataptr, Channel &channel, uint8 value) {
+	channel.unk32 = (int8)value;
+	channel.unk33 = *dataptr++;
 	uint8 temp = *dataptr++;
-	state.unk34 = temp + 1;
-	state.unk35 = temp << 1;
-	state.unk36 = *dataptr++;
-	state.primaryEffect = &AdlibDriver::primaryEffect2;
+	channel.unk34 = temp + 1;
+	channel.unk35 = temp << 1;
+	channel.unk36 = *dataptr++;
+	channel.primaryEffect = &AdlibDriver::primaryEffect2;
 	return 0;
 }
 
-int AdlibDriver::update_setPriority(uint8 *&dataptr, OutputState &state, uint8 value) {
-	state.priority = value;
+int AdlibDriver::update_setPriority(uint8 *&dataptr, Channel &channel, uint8 value) {
+	channel.priority = value;
 	return 0;
 }
 
-int AdlibDriver::updateCallback23(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::updateCallback23(uint8 *&dataptr, Channel &channel, uint8 value) {
 	value >>= 1;
 	_unkValue1 = _unkValue2 = value;
 	_unkValue3 = -1;
@@ -1358,7 +1358,7 @@ int AdlibDriver::updateCallback23(uint8 *&dataptr, OutputState &state, uint8 val
 	return 0;
 }
 
-int AdlibDriver::updateCallback24(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::updateCallback24(uint8 *&dataptr, Channel &channel, uint8 value) {
 	if (_unkValue5) {
 		if (_unkValue4 & value) {
 			_unkValue5 = 0;
@@ -1371,78 +1371,78 @@ int AdlibDriver::updateCallback24(uint8 *&dataptr, OutputState &state, uint8 val
 	}
 
 	dataptr -= 2;
-	state.duration = 1;
+	channel.duration = 1;
 	return 2;
 }
 
-int AdlibDriver::update_setExtraLevel1(uint8 *&dataptr, OutputState &state, uint8 value) {
-	state.opExtraLevel1 = value;
-	adjustVolume(state);
+int AdlibDriver::update_setExtraLevel1(uint8 *&dataptr, Channel &channel, uint8 value) {
+	channel.opExtraLevel1 = value;
+	adjustVolume(channel);
 	return 0;
 }
 
-int AdlibDriver::updateCallback26(uint8 *&dataptr, OutputState &state, uint8 value) {
-	setupDuration(value, state);
+int AdlibDriver::updateCallback26(uint8 *&dataptr, Channel &channel, uint8 value) {
+	setupDuration(value, channel);
 	return (_continueFlag != 0);
 }
 
-int AdlibDriver::update_playNote(uint8 *&dataptr, OutputState &state, uint8 value) {
-	setupDuration(value, state);
-	noteOn(state);
+int AdlibDriver::update_playNote(uint8 *&dataptr, Channel &channel, uint8 value) {
+	setupDuration(value, channel);
+	noteOn(channel);
 	return (_continueFlag != 0);
 }
 
-int AdlibDriver::updateCallback28(uint8 *&dataptr, OutputState &state, uint8 value) {
-	state.unk12 = value & 7;
+int AdlibDriver::updateCallback28(uint8 *&dataptr, Channel &channel, uint8 value) {
+	channel.unk12 = value & 7;
 	return 0;
 }
 
-int AdlibDriver::update_setTempo(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::update_setTempo(uint8 *&dataptr, Channel &channel, uint8 value) {
 	_tempo = (int8)value;
 	return 0;
 }
 
-int AdlibDriver::update_removeSecondaryEffect1(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::update_removeSecondaryEffect1(uint8 *&dataptr, Channel &channel, uint8 value) {
 	--dataptr;
-	state.secondaryEffect = 0;
+	channel.secondaryEffect = 0;
 	return 0;
 }
 
-int AdlibDriver::update_setChannelTempo(uint8 *&dataptr, OutputState &state, uint8 value) {
-	state.tempo = (int8)value;
+int AdlibDriver::update_setChannelTempo(uint8 *&dataptr, Channel &channel, uint8 value) {
+	channel.tempo = (int8)value;
 	return 0;
 }
 
-int AdlibDriver::update_setExtraLevel3(uint8 *&dataptr, OutputState &state, uint8 value) {
-	state.opExtraLevel3 = value;
+int AdlibDriver::update_setExtraLevel3(uint8 *&dataptr, Channel &channel, uint8 value) {
+	channel.opExtraLevel3 = value;
 	return 0;
 }
 
-int AdlibDriver::update_setExtraLevel2(uint8 *&dataptr, OutputState &state, uint8 value) {
-	int tableBackup = _curTable;
+int AdlibDriver::update_setExtraLevel2(uint8 *&dataptr, Channel &channel, uint8 value) {
+	int channelBackUp = _curChannel;
 
-	_curTable = value;
-	OutputState &state2 = _outputTables[value];
-	state2.opExtraLevel2 = *dataptr++;
-	adjustVolume(state2);
+	_curChannel = value;
+	Channel &channel2 = _channels[value];
+	channel2.opExtraLevel2 = *dataptr++;
+	adjustVolume(channel2);
 
-	_curTable = tableBackup;
+	_curChannel = channelBackUp;
 	return 0;
 }
 
-int AdlibDriver::update_changeExtraLevel2(uint8 *&dataptr, OutputState &state, uint8 value) {
-	int tableBackup = _curTable;
+int AdlibDriver::update_changeExtraLevel2(uint8 *&dataptr, Channel &channel, uint8 value) {
+	int channelBackUp = _curChannel;
 
-	_curTable = value;
-	OutputState &state2 = _outputTables[value];
-	state2.opExtraLevel2 += *dataptr++;
-	adjustVolume(state2);
+	_curChannel = value;
+	Channel &channel2 = _channels[value];
+	channel2.opExtraLevel2 += *dataptr++;
+	adjustVolume(channel2);
 
-	_curTable = tableBackup;
+	_curChannel = channelBackUp;
 	return 0;
 }
 
-int AdlibDriver::update_setAMDepth(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::update_setAMDepth(uint8 *&dataptr, Channel &channel, uint8 value) {
 	if (value & 1)
 		_unkOutputByte2 |= 0x80;
 	else
@@ -1453,7 +1453,7 @@ int AdlibDriver::update_setAMDepth(uint8 *&dataptr, OutputState &state, uint8 va
 	return 0;
 }
 
-int AdlibDriver::update_setVibratoDepth(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::update_setVibratoDepth(uint8 *&dataptr, Channel &channel, uint8 value) {
 	if (value & 1)
 		_unkOutputByte2 |= 0x40;
 	else
@@ -1464,26 +1464,26 @@ int AdlibDriver::update_setVibratoDepth(uint8 *&dataptr, OutputState &state, uin
 	return 0;
 }
 
-int AdlibDriver::update_changeExtraLevel1(uint8 *&dataptr, OutputState &state, uint8 value) {
-	state.opExtraLevel1 += value;
-	adjustVolume(state);
+int AdlibDriver::update_changeExtraLevel1(uint8 *&dataptr, Channel &channel, uint8 value) {
+	channel.opExtraLevel1 += value;
+	adjustVolume(channel);
 	return 0;
 }
 
-int AdlibDriver::updateCallback38(uint8 *&dataptr, OutputState &state, uint8 value) {
-	int tableBackUp = _curTable;
+int AdlibDriver::updateCallback38(uint8 *&dataptr, Channel &channel, uint8 value) {
+	int channelBackUp = _curChannel;
 
-	_curTable = value;
-	OutputState &state2 = _outputTables[value];
-	state2.duration = state2.priority = 0;
-	state2.dataptr = 0;
-	state2.opExtraLevel2 = 0;
+	_curChannel = value;
+	Channel &channel2 = _channels[value];
+	channel2.duration = channel2.priority = 0;
+	channel2.dataptr = 0;
+	channel2.opExtraLevel2 = 0;
 
 	if (value != 9) {
-		uint8 outValue = _outputTable[value];
+		uint8 outValue = _regOffset[value];
 
 		// Feedback strength / Connection type
-		writeOPL(0xC0 + _curTable, 0x00);
+		writeOPL(0xC0 + _curChannel, 0x00);
 
 		// Key scaling level / Operator output level
 		writeOPL(0x43 + outValue, 0x3F);
@@ -1492,75 +1492,75 @@ int AdlibDriver::updateCallback38(uint8 *&dataptr, OutputState &state, uint8 val
 		writeOPL(0x83 + outValue, 0xFF);
 
 		// Key On / Octave / Frequency
-		writeOPL(0xB0 + _curTable, 0x00);
+		writeOPL(0xB0 + _curChannel, 0x00);
 	}
 
-	_curTable = tableBackUp;
+	_curChannel = channelBackUp;
 	return 0;
 }
 
-int AdlibDriver::updateCallback39(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::updateCallback39(uint8 *&dataptr, Channel &channel, uint8 value) {
 	uint16 unk = *dataptr++;
 	unk |= value << 8;
 	unk &= getRandomNr();
 
-	uint16 unk2 = ((state.regBx & 0x1F) << 8) | state.regAx;
+	uint16 unk2 = ((channel.regBx & 0x1F) << 8) | channel.regAx;
 	unk2 += unk;
-	unk2 |= ((state.regBx & 0x20) << 8);
+	unk2 |= ((channel.regBx & 0x20) << 8);
 
 	// Frequency
-	writeOPL(0xA0 + _curTable, unk2 & 0xFF);
+	writeOPL(0xA0 + _curChannel, unk2 & 0xFF);
 
 	// Key On / Octave / Frequency
-	writeOPL(0xB0 + _curTable, (unk2 & 0xFF00) >> 8);
+	writeOPL(0xB0 + _curChannel, (unk2 & 0xFF00) >> 8);
 
 	return 0;
 }
 
-int AdlibDriver::update_removePrimaryEffect2(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::update_removePrimaryEffect2(uint8 *&dataptr, Channel &channel, uint8 value) {
 	--dataptr;
-	state.primaryEffect = 0;
+	channel.primaryEffect = 0;
 	return 0;
 }
 
-int AdlibDriver::updateCallback41(uint8 *&dataptr, OutputState &state, uint8 value) {
-	state.unk16 = value;
-	setupNote(state.rawNote, state, true);
+int AdlibDriver::updateCallback41(uint8 *&dataptr, Channel &channel, uint8 value) {
+	channel.unk16 = value;
+	setupNote(channel.rawNote, channel, true);
 	return 0;
 }
 
-int AdlibDriver::update_resetToGlobalTempo(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::update_resetToGlobalTempo(uint8 *&dataptr, Channel &channel, uint8 value) {
 	--dataptr;
-	state.tempo = _tempo;
+	channel.tempo = _tempo;
 	return 0;
 }
 
-int AdlibDriver::updateCallback43(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::updateCallback43(uint8 *&dataptr, Channel &channel, uint8 value) {
 	--dataptr;
 	return 0;
 }
 
-int AdlibDriver::updateCallback44(uint8 *&dataptr, OutputState &state, uint8 value) {
-	state.unk11 = value;
+int AdlibDriver::updateCallback44(uint8 *&dataptr, Channel &channel, uint8 value) {
+	channel.unk11 = value;
 	return 0;
 }
 
-int AdlibDriver::updateCallback45(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::updateCallback45(uint8 *&dataptr, Channel &channel, uint8 value) {
 	if (value & 0x80) {
-		value += state.tempo;
-		if ((int8)value >= (int8)state.tempo)
+		value += channel.tempo;
+		if ((int8)value >= (int8)channel.tempo)
 			value = 1;
 	} else {
 		int8 temp = value;
-		value += state.tempo;
+		value += channel.tempo;
 		if (value < temp)
 			value = (uint8)-1;
 	}
-	state.tempo = (int8)value;
+	channel.tempo = (int8)value;
 	return 0;
 }
 
-int AdlibDriver::updateCallback46(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::updateCallback46(uint8 *&dataptr, Channel &channel, uint8 value) {
 	uint8 entry = *dataptr++;
 	_tablePtr1 = _unkTable2[entry++];
 	_tablePtr2 = _unkTable2[entry];
@@ -1571,66 +1571,66 @@ int AdlibDriver::updateCallback46(uint8 *&dataptr, OutputState &state, uint8 val
 	return 0;
 }
 
-int AdlibDriver::updateCallback47(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::updateCallback47(uint8 *&dataptr, Channel &channel, uint8 value) {
 	--dataptr;
 	return 0;
 }
 
-int AdlibDriver::updateCallback48(uint8 *&dataptr, OutputState &state, uint8 value) {
-	int tableBackUp = _curTable;
+int AdlibDriver::updateCallback48(uint8 *&dataptr, Channel &channel, uint8 value) {
+	int channelBackUp = _curChannel;
 	int regOffsetBackUp = _curRegOffset;
 
 	uint8 entry = value << 1;
 	uint8 *ptr = _soundData + READ_LE_UINT16(_soundData + entry + 0x1F4);
 
-	_curTable = 6;
-	_curRegOffset = _outputTable[6];
+	_curChannel = 6;
+	_curRegOffset = _regOffset[6];
 
 	_unkValue6 = *(ptr + 6);
-	setupInstrument(_curRegOffset, ptr, state);
+	setupInstrument(_curRegOffset, ptr, channel);
 
 	entry = *dataptr++ << 1;
 	ptr = _soundData + READ_LE_UINT16(_soundData + entry + 0x1F4);
 
-	_curTable = 7;
-	_curRegOffset = _outputTable[7];
+	_curChannel = 7;
+	_curRegOffset = _regOffset[7];
 
 	_unkValue7 = entry = *(ptr + 5);
 	_unkValue8 = entry = *(ptr + 6);
-	setupInstrument(_curRegOffset, ptr, state);
+	setupInstrument(_curRegOffset, ptr, channel);
 
 	entry = *dataptr++ << 1;
 	ptr = _soundData + READ_LE_UINT16(_soundData + entry + 0x1F4);
 
-	_curTable = 8;
-	_curRegOffset = _outputTable[8];
+	_curChannel = 8;
+	_curRegOffset = _regOffset[8];
 
 	_unkValue9 = entry = *(ptr + 5);
 	_unkValue10 = entry = *(ptr + 6);
-	setupInstrument(_curRegOffset, ptr, state);
+	setupInstrument(_curRegOffset, ptr, channel);
 
 	// Octave / F-Number / Key-On for channels 6, 7 and 8
 
-	_outputTables[6].regBx = *dataptr++ & 0x2F;
-	writeOPL(0xB6, _outputTables[6].regBx);
+	_channels[6].regBx = *dataptr++ & 0x2F;
+	writeOPL(0xB6, _channels[6].regBx);
 	writeOPL(0xA6, *dataptr++);
 
-	_outputTables[7].regBx = *dataptr++ & 0x2F;
-	writeOPL(0xB7, _outputTables[7].regBx);
+	_channels[7].regBx = *dataptr++ & 0x2F;
+	writeOPL(0xB7, _channels[7].regBx);
 	writeOPL(0xA7, *dataptr++);
 
-	_outputTables[8].regBx = *dataptr++ & 0x2F;
-	writeOPL(0xB8, _outputTables[8].regBx);
+	_channels[8].regBx = *dataptr++ & 0x2F;
+	writeOPL(0xB8, _channels[8].regBx);
 	writeOPL(0xA8, *dataptr++);
 
 	_unk4 = 0x20;
 
 	_curRegOffset = regOffsetBackUp;
-	_curTable = tableBackUp;
+	_curChannel = channelBackUp;
 	return 0;
 }
 
-int AdlibDriver::updateCallback49(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::updateCallback49(uint8 *&dataptr, Channel &channel, uint8 value) {
 	// Amplitude Modulation Depth / Vibrato Depth / Rhythm
 	writeOPL(0xBD, (((value & 0x1F) ^ 0xFF) & _unk4) | 0x20);
 
@@ -1653,7 +1653,7 @@ int AdlibDriver::updateCallback49(uint8 *&dataptr, OutputState &state, uint8 val
 	return 0;
 }
 
-int AdlibDriver::updateCallback50(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::updateCallback50(uint8 *&dataptr, Channel &channel, uint8 value) {
 	--dataptr;
 	_unk4 = 0;
 
@@ -1663,7 +1663,7 @@ int AdlibDriver::updateCallback50(uint8 *&dataptr, OutputState &state, uint8 val
 	return 0;
 }
 
-int AdlibDriver::updateCallback51(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::updateCallback51(uint8 *&dataptr, Channel &channel, uint8 value) {
 	uint16 temp = (value << 8) | *dataptr++;
 
 	if (value & 1) {
@@ -1724,7 +1724,7 @@ int AdlibDriver::updateCallback51(uint8 *&dataptr, OutputState &state, uint8 val
 	return 0;
 }
 
-int AdlibDriver::updateCallback52(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::updateCallback52(uint8 *&dataptr, Channel &channel, uint8 value) {
 	uint16 temp = (value << 8) | *dataptr++;
 
 	if (value & 1) {
@@ -1780,7 +1780,7 @@ int AdlibDriver::updateCallback52(uint8 *&dataptr, OutputState &state, uint8 val
 	return 0;
 }
 
-int AdlibDriver::updateCallback53(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::updateCallback53(uint8 *&dataptr, Channel &channel, uint8 value) {
 	uint16 temp = (value << 8) | *dataptr++;
 
 	if (value & 1) {
@@ -1836,19 +1836,19 @@ int AdlibDriver::updateCallback53(uint8 *&dataptr, OutputState &state, uint8 val
 	return 0;
 }
 
-int AdlibDriver::updateCallback54(uint8 *&dataptr, OutputState &state, uint8 value) {
+int AdlibDriver::updateCallback54(uint8 *&dataptr, Channel &channel, uint8 value) {
 	_unk5 = value;
 	return 0;
 }
 
-int AdlibDriver::update_setTempoReset(uint8 *&dataptr, OutputState &state, uint8 value) {
-	state.tempoReset = value;
+int AdlibDriver::update_setTempoReset(uint8 *&dataptr, Channel &channel, uint8 value) {
+	channel.tempoReset = value;
 	return 0;
 }
 
-int AdlibDriver::updateCallback56(uint8 *&dataptr, OutputState &state, uint8 value) {
-	state.unk39 = value;
-	state.unk40 = *dataptr++;
+int AdlibDriver::updateCallback56(uint8 *&dataptr, Channel &channel, uint8 value) {
+	channel.unk39 = value;
+	channel.unk40 = *dataptr++;
 	return 0;
 }
 
@@ -1998,7 +1998,7 @@ const int AdlibDriver::_parserOpcodeTableSize = ARRAYSIZE(AdlibDriver::_parserOp
 // This table holds the register offset for operator 1 for each of the nine
 // channels. To get the register offset for operator 2, simply add 3.
 
-const uint8 AdlibDriver::_outputTable[] = {
+const uint8 AdlibDriver::_regOffset[] = {
 	0x00, 0x01, 0x02, 0x08, 0x09, 0x0A, 0x10, 0x11,
 	0x12
 };