/* ScummVM - Scumm Interpreter
 * Copyright (C) 2001  Ludvig Strigeus
 * Copyright (C) 2001/2002 The ScummVM project
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 * $Header$
 */

#include "stdafx.h"
#include "scumm/scumm.h"
#include "sound/fmopl.h"
#include "sound/mididrv.h"
#include "scumm/imuse.h"
#include "scumm/saveload.h"
#include "scumm/sound.h"
#include "common/util.h"

/*
 * Some constants
 */
#define TICKS_PER_BEAT 480

// #define FORCE_MT32_SOUNDS // Use only if you are driving an actual MT-32 or compatible
#define IMUSE_SYSEX_ID 0x7D
#define ROLAND_SYSEX_ID 0x41
#define PERCUSSION_CHANNEL 9

#define TRIGGER_ID 0
#define COMMAND_ID 1

#define MDPG_TAG "MDpg"
#define MDHD_TAG "MDhd"

#ifdef FORCE_MT32_SOUNDS
static const byte mt32_to_gmidi[128] = {
//    0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F
	  0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15, // 0x
	 16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31, // 1x
	 32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47, // 2x
	 48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63, // 3x
	 64,  65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79, // 4x
	 80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95, // 5x
	 96,  97,  98,  99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, // 6x
	112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127  // 7x
};
#else
/* Roland to General Midi patch table. Still needs some work. */
static const byte mt32_to_gmidi[128] = {
//    0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F
	  0,   1,   0,   2,   4,   4,   5,   3,  16,  17,  18,  16,  16,  19,  20,  21, // 0x
	  6,   6,   6,   7,   7,   7,   8, 112,  62,  62,  63,  63,  38,  38,  39,  39, // 1x
	 88,  95,  52,  98,  97,  99,  14,  54, 102,  96,  53, 102,  81, 100,  14,  80, // 2x
 	 48,  48,  49,  45,  41,  40,  42,  42,  43,  46,  45,  24,  25,  28,  27, 104, // 3x
	 32,  32,  34,  33,  36,  37,  35,  35,  79,  73,  72,  72,  74,  75,  64,  65, // 4x
	 66,  67,  71,  71,  68,  69,  70,  22,  56,  59,  57,  57,  60,  60,  58,  61, // 5x
	 61,  11,  11,  98,  14,   9,  14,  13,  12, 107, 107,  77,  78,  78,  76,  76, // 6x
	 47, 117, 127, 118, 118, 116, 115, 119, 115, 112,  55, 124, 123,   0,  14, 117  // 7x
};
#endif


/* Put IMUSE specific classes here, instead of in a .h file
 * they will only be used from this file, so it will reduce
 * compile time */

// IMuseMonitor serves as a front-end to IMuseInternal and
// ensures that only one thread accesses the object at a time.
// This is necessary to prevent scripts and the MIDI parser
// from yanking objects out from underneath each other.
class IMuseMonitor : public IMuse {
private:
	OSystem *_system;
	IMuse *_target;
	void *_mutex;

	void in() { _system->lock_mutex (_mutex); }
	void out() { _system->unlock_mutex (_mutex); }
public:
	IMuseMonitor (OSystem *system, IMuse *target) : _system (system), _target (target) { _mutex = system->create_mutex(); }
	virtual ~IMuseMonitor() { _system->delete_mutex (_mutex); };

	void on_timer() { in(); _target->on_timer(); out(); }
	void pause(bool paused) { in(); _target->pause (paused); out(); }
	int save_or_load(Serializer *ser, Scumm *scumm) { in(); int ret = _target->save_or_load (ser, scumm); out(); return ret; }
	int set_music_volume(uint vol) { in(); int ret = _target->set_music_volume (vol); out(); return ret; }
	int get_music_volume() { in(); int ret = _target->get_music_volume(); out(); return ret; }
	int set_master_volume(uint vol) { in(); int ret = _target->set_master_volume (vol); out(); return ret; }
	int get_master_volume() { in(); int ret = _target->get_master_volume(); out(); return ret; }
	bool start_sound(int sound) { in(); bool ret = _target->start_sound (sound); out(); return ret; }
	int stop_sound(int sound) { in(); int ret = _target->stop_sound (sound); out(); return ret; }
	int stop_all_sounds() { in(); int ret = _target->stop_all_sounds(); out(); return ret; }
	int get_sound_status(int sound) { in(); int ret = _target->get_sound_status (sound); out(); return ret; }
	int32 do_command(int a, int b, int c, int d, int e, int f, int g, int h) { in(); int32 ret = _target->do_command (a,b,c,d,e,f,g,h); out(); return ret; }
	int clear_queue() { in(); int ret = _target->clear_queue(); out(); return ret; }
	void setBase(byte **base) { in(); _target->setBase (base); out(); }
	uint32 property(int prop, uint32 value) { in(); uint32 ret = _target->property (prop, value); out(); return ret; }
};

class IMuseDriver;

struct Part;
// struct MidiChannelAdl;
// struct MidiChannelGM;
struct Instrument;


struct HookDatas {
	byte _jump, _transpose;
	byte _part_onoff[16];
	byte _part_volume[16];
	byte _part_program[16];
	byte _part_transpose[16];

	int query_param(int param, byte chan);
	int set(byte cls, byte value, byte chan);
};


struct Player {
	IMuseInternal *_se;

	Part *_parts;
	bool _active;
	bool _scanning;
	int _id;
	byte _priority;
	byte _volume;
	int8 _pan;
	int8 _transpose;
	int8 _detune;
	uint _vol_chan;
	byte _vol_eff;

	uint _song_index;
	uint _track_index;
	uint _timer_counter;
	uint _loop_to_beat;
	uint _loop_from_beat;
	uint _loop_counter;
	uint _loop_to_tick;
	uint _loop_from_tick;
	uint32 _tempo;
	uint32 _tempo_eff;						/* NoSave */
	uint32 _cur_pos;
	uint32 _next_pos;
	uint32 _song_offset;
	uint32 _timer_speed;					/* NoSave */
	uint _tick_index;
	uint _beat_index;
	uint _ticks_per_beat;
	byte _speed;									/* NoSave */
	bool _abort;

	HookDatas _hook;
	byte _marker;	// Sam & Max: SysEx marker

	bool _mt32emulate;
	bool _isGM;

	/* Player part */
	void hook_clear();
	void clear();
	bool start_sound(int sound);
	void uninit_parts();
	byte *parse_midi(byte *s);
	void key_off(uint8 chan, byte data);
	void key_on(uint8 chan, byte data, byte velocity);
	void part_set_transpose(uint8 chan, byte relative, int8 b);
	void parse_sysex(byte *p, uint len);
	void maybe_jump (byte cmd, uint track, uint beat, uint tick);
	void maybe_set_transpose(byte *data);
	void maybe_part_onoff(byte *data);
	void maybe_set_volume(byte *data);
	void maybe_set_program(byte *data);
	void maybe_set_transpose_part(byte *data);
	uint update_actives();
	Part *get_part(uint8 part);
	void turn_off_pedals();
	int set_vol(byte vol);
	int get_param(int param, byte chan);
	int query_part_param(int param, byte chan);
	int set_transpose(byte relative, int b);
	void set_priority(int pri);
	void set_pan(int pan);
	void set_detune(int detune);
	void turn_off_parts();
	void play_active_notes();
	void cancel_volume_fade();

	static void decode_sysex_bytes(byte *src, byte *dst, int len);

	void clear_active_note(int chan, byte note);
	void set_active_note(int chan, byte note);
	void clear_active_notes();

	/* Sequencer part */
	bool set_loop(uint count, uint tobeat, uint totick, uint frombeat, uint fromtick);
	void clear_loop();
	void set_speed(byte speed);
	bool jump(uint track, uint beat, uint tick);
	void uninit_seq();
	void set_tempo(uint32 data);
	int start_seq_sound(int sound);
	void find_sustaining_notes(byte *a, byte *b, uint32 l);
	int scan(uint totrack, uint tobeat, uint totick);
	int query_param(int param);

	int fade_vol(byte vol, int time);
	bool is_fading_out();
	void sequencer_timer();
};

struct VolumeFader {
	Player *player;
	bool active;
	byte curvol;
	uint16 speed_lo_max, num_steps;
	int8 speed_hi;
	int8 direction;
	int8 speed_lo;
	uint16 speed_lo_counter;

	void initialize() {
		active = false;
	}
	void on_timer(bool probe);
	byte fading_to();
};

struct SustainingNotes {
	SustainingNotes *next;
	SustainingNotes *prev;
	Player *player;
	byte note, chan;
	uint32 off_pos;
	uint32 pos;
	uint16 counter;
};

struct CommandQueue {
	uint16 array[8];
};


struct IsNoteCmdData {
	byte chan;
	byte note;
	byte vel;
};


/*
struct MidiChannel {
	Part *_part;
	MidiChannel() : _part(0) {}
	MidiChannelAdl *adl() { return (MidiChannelAdl *)this; }
	MidiChannelGM *gm() { return (MidiChannelGM *)this; }
};


struct MidiChannelGM : MidiChannel {
	byte _chan;
//	uint16 _actives[8];
//	MidiChannelGM() : _chan(0) { memset(_actives, 0, 16); }
};
*/

struct Part {
	int _slot;
	IMuseDriver *_drv;
	Part *_next, *_prev;
	MidiChannel *_mc;
	Player *_player;
	int16 _pitchbend;
	byte _pitchbend_factor;
	int8 _transpose, _transpose_eff;
	byte _vol, _vol_eff;
	int8 _detune, _detune_eff;
	int8 _pan, _pan_eff;
	bool _on;
	byte _modwheel;
	bool _pedal;
	byte _program;
	int8 _pri;
	byte _pri_eff;
	byte _chan;
	byte _effect_level;
	byte _chorus;
	byte _percussion;
	byte _bank;

	// Used to be in MidiDriverGM.
	uint16 _actives[8];

	void key_on(byte note, byte velocity);
	void key_off(byte note);
	void set_param(byte param, int value);
	void init(IMuseDriver * _driver);
	void setup(Player *player);
	void uninit();
	void off();
	void silence();
	void set_instrument(uint b);
	void set_instrument(Instrument * data);

	void set_transpose(int8 transpose);
	void set_vol(uint8 volume);
	void set_detune(int8 detune);
	void set_pri(int8 pri);
	void set_pan(int8 pan);
	void set_modwheel(uint value);
	void set_pedal(bool value);
	void set_pitchbend(int value);
	void release_pedal();
	void set_program(byte program);
	void set_chorus(uint chorus);
	void set_effect_level(uint level);

	int update_actives(uint16 *active);
	void set_pitchbend_factor(uint8 value);
	void set_onoff(bool on);
	void fix_after_load();

	void update_pris();

	void changed(uint16 what);
};

struct ImTrigger {
	int sound;
	byte id;
	uint16 expire;
	byte command [4];
};

/* Abstract IMuseInternal driver class */
class IMuseDriver {
public:
	enum {
		pcMod = 1,
		pcVolume = 2,
		pcPedal = 4,
		pcModwheel = 8,
		pcPan = 16,
		pcEffectLevel = 32,
		pcProgram = 64,
		pcChorus = 128,
		pcPitchBendFactor = 256,
		pcPriority = 512,
		pcAll = 1023,
	};

	virtual void on_timer() = 0;
	virtual uint32 get_base_tempo() = 0;
	virtual byte get_hardware_type() = 0;
	virtual void init(IMuseInternal *eng, OSystem *syst) = 0;
	virtual void uninit() = 0;
	virtual void update_pris() = 0;
	virtual void set_instrument(uint slot, byte *instr) = 0;
	virtual void part_set_instrument(Part *part, Instrument * instr) = 0;
	virtual void part_key_on(Part *part, byte note, byte velocity) = 0;
	virtual void part_key_off(Part *part, byte note) = 0;
	virtual void part_off(Part *part) = 0;
	virtual void part_changed(Part *part, uint16 what) = 0;
	virtual void part_set_param(Part *part, byte param, int value) = 0;
	virtual int part_update_active(Part *part, uint16 *active) = 0;
	virtual byte get_channel_program (byte channel) = 0;
};


// WARNING: This is the internal variant of the IMUSE class.
// imuse.h contains a public version of the same class.
// the public version, only contains a set of methods.
class IMuseInternal : public IMuse {
	friend struct Player;
private:
	IMuseDriver * _driver;

	byte **_base_sounds;

	byte _locked;
	byte _hardware_type;

private:

	bool _paused;
	bool _active_volume_faders;
	bool _initialized;
	byte _volume_fader_counter;

	int _game_tempo;

	uint _queue_end, _queue_pos, _queue_sound;
	byte _queue_adding;

	SustainingNotes *_sustain_notes_used;
	SustainingNotes *_sustain_notes_free;
	SustainingNotes *_sustain_notes_head;

	byte _queue_marker;
	byte _queue_cleared;
	byte _master_volume;					// Master volume. 0-255
	byte _music_volume;						// Global music volume. 0-255

	uint16 _trigger_count;
	ImTrigger _snm_triggers[16];	// Sam & Max triggers
	uint16 _snm_trigger_index;

	uint16 _channel_volume[8];
	uint16 _channel_volume_eff[8];	/* NoSave */
	uint16 _volchan_table[8];

	Player _players[8];
	SustainingNotes _sustaining_notes[24];
	VolumeFader _volume_fader[8];
	Part _parts[32];

	uint16 _active_notes[128];
	CommandQueue _cmd_queue[64];

	byte *findTag(int sound, char *tag, int index);
	bool isMT32(int sound);
	bool isGM(int sound);
	int get_queue_sound_status(int sound);
	Player *allocate_player(byte priority);
	void handle_marker(uint id, byte data);
	int get_channel_volume(uint a);
	void init_players();
	void init_parts();
	void init_volume_fader();
	void init_sustaining_notes();
	void init_queue();

	void sequencer_timers();
	void expire_sustain_notes();
	void expire_volume_faders();

	Part *allocate_part(byte pri);

	int32 ImSetTrigger (int sound, int id, int a, int b, int c, int d);
	int32 ImClearTrigger (int sound, int id);

	int enqueue_command(int a, int b, int c, int d, int e, int f, int g);
	int enqueue_trigger(int sound, int marker);
	int query_queue(int param);
	Player *get_player_byid(int id);

	int get_volchan_entry(uint a);
	int set_volchan_entry(uint a, uint b);
	int set_channel_volume(uint chan, uint vol);
	void update_volumes();
	void reset_tick();
	VolumeFader *allocate_volume_fader();

	int set_volchan(int sound, int volchan);

	void fix_parts_after_load();
	void fix_players_after_load(Scumm *scumm);

	static int saveReference(IMuseInternal *me, byte type, void *ref);
	static void *loadReference(IMuseInternal *me, byte type, int ref);

	void lock();
	void unlock();

public:
	~IMuseInternal();

	Part *parts_ptr() {
		return _parts;
	}
	IMuseDriver *driver() {
		return _driver;
	}
	
	int initialize(OSystem *syst, MidiDriver *midi, SoundMixer *mixer);

	/* Public interface */

	void on_timer();
	void pause(bool paused);
	int terminate();
	int save_or_load(Serializer *ser, Scumm *scumm);
	int set_music_volume(uint vol);
	int get_music_volume();
	int set_master_volume(uint vol);
	int get_master_volume();
	byte get_channel_program (byte channel) { return _driver->get_channel_program (channel); }
	bool start_sound(int sound);
	int stop_sound(int sound);
	int stop_all_sounds();
	int get_sound_status(int sound);
	int32 do_command(int a, int b, int c, int d, int e, int f, int g, int h);
	int clear_queue();
	void setBase(byte **base);

	uint32 property(int prop, uint32 value);

	static IMuseInternal *create(OSystem *syst, MidiDriver *midi, SoundMixer *mixer);
};


/* IMuseAdlib classes */

struct Struct10 {
	byte active;
	int16 cur_val;
	int16 count;
	uint16 param;
	int16 start_value;
	byte loop;
	byte table_a[4];
	byte table_b[4];
	int8 unk3;
	int8 modwheel;
	int8 modwheel_last;
	uint16 speed_lo_max;
	uint16 num_steps;
	int16 speed_hi;
	int8 direction;
	uint16 speed_lo;
	uint16 speed_lo_counter;
};

struct Struct11 {
	int16 modify_val;
	byte param, flag0x40, flag0x10;
	Struct10 *s10;
};

struct InstrumentExtra {
	byte a, b, c, d, e, f, g, h;
};

struct Instrument {
	byte flags_1;
	byte oplvl_1;
	byte atdec_1;
	byte sustrel_1;
	byte waveform_1;
	byte flags_2;
	byte oplvl_2;
	byte atdec_2;
	byte sustrel_2;
	byte waveform_2;
	byte feedback;
	byte flags_a;
	InstrumentExtra extra_a;
	byte flags_b;
	InstrumentExtra extra_b;
	byte duration;
};

struct MidiChannelAdl : MidiChannel {
	MidiChannelAdl *_next, *_prev;
	byte _waitforpedal;
	byte _note;
	byte _channel;
	byte _twochan;
	byte _vol_1, _vol_2;
	int16 _duration;

	Struct10 _s10a;
	Struct11 _s11a;
	Struct10 _s10b;
	Struct11 _s11b;
	
	MidiChannelAdl() : _next(0), _prev(0) {}
};
/*
class IMuseAdlib : public IMuseDriver {
private:
	FM_OPL *_opl;
	byte *_adlib_reg_cache;
	IMuseInternal *_se;
	SoundMixer *_mixer;

	int _adlib_timer_counter;

	uint16 channel_table_2[9];
	int _midichan_index;
	int _next_tick;
	uint16 curnote_table[9];
	MidiChannelAdl _midi_channels[9];

	Instrument _part_instr[32];
	Instrument _glob_instr[32];

	void adlib_key_off(int chan);
	void adlib_note_on(int chan, byte note, int mod);
	void adlib_note_on_ex(int chan, byte note, int mod);
	int adlib_read_param(int chan, byte data);
	void adlib_setup_channel(int chan, Instrument * instr, byte vol_1, byte vol_2);
	byte adlib_read(byte port) {
		return _adlib_reg_cache[port];
	}
	void adlib_set_param(int channel, byte param, int value);
	void adlib_key_onoff(int channel);
	void adlib_write(byte port, byte value);
	void adlib_playnote(int channel, int note);

	MidiChannelAdl *allocate_midichan(byte pri);

	void reset_tick();
	void mc_off(MidiChannel * mc);

	static void link_mc(Part *part, MidiChannelAdl *mc);
	static void mc_inc_stuff(MidiChannelAdl *mc, Struct10 * s10, Struct11 * s11);
	static void mc_init_stuff(MidiChannelAdl *mc, Struct10 * s10, Struct11 * s11, byte flags,
														InstrumentExtra * ie);
	static void struct10_init(Struct10 * s10, InstrumentExtra * ie);
	static byte struct10_ontimer(Struct10 * s10, Struct11 * s11);
	static void struct10_setup(Struct10 * s10);
	static int random_nr(int a);
	void mc_key_on(MidiChannel * mc, byte note, byte velocity);

	static void premix_proc(void *param, int16 *buf, uint len);

public:
	IMuseAdlib(SoundMixer *mixer) {
		_mixer = mixer;
	}
	void uninit() {}
	void init(IMuseInternal *eng, OSystem *syst);
	void update_pris() {
	}
	void generate_samples(int16 *buf, int len);
	void on_timer();
	void set_instrument(uint slot, byte *instr);
	void part_set_instrument(Part *part, Instrument * instr);
	void part_key_on(Part *part, byte note, byte velocity);
	void part_key_off(Part *part, byte note);
	void part_set_param(Part *part, byte param, int value);
	void part_changed(Part *part, uint16 what);
	void part_off(Part *part);
	int part_update_active(Part *part, uint16 *active);
	byte get_channel_program (byte) { return 255; }

	void adjust_priorities() {
	}

	uint32 get_base_tempo() {
#ifdef _WIN32_WCE
		return 0x1D9000 * 2;				// Sampled down to 11 kHz
#else	//_WIN32_WCE
		return 0x1D9000;
#endif //_WIN32_WCE
	}

	byte get_hardware_type() {
		return 1;
	}
};
*/

/* IMuseGM classes */

class IMuseGM : public IMuseDriver {
	IMuseInternal *_se;
	OSystem *_system;
	MidiDriver *_md;
//	MidiChannelGM _midi_channels[16];

	Instrument _part_instr[32]; // Adlib custom instruments
	Instrument _glob_instr[32]; // Adlib custom instruments

	byte _midi_program_last[16];
	int16 _midi_pitchbend_last[16];
	byte _midi_pitchbend_factor_last[16];
	uint8 _midi_volume_last[16];
	bool _midi_pedal_last[16];
	byte _midi_modwheel_last[16];
	byte _midi_effectlevel_last[16];
	byte _midi_chorus_last[16];
	int8 _midi_pan_last[16];


	void midiPitchBend(byte chan, int16 pitchbend);
	void midiPitchBendFactor (byte chan, byte factor);
	void midiVolume(byte chan, byte volume);
	void midiPedal(byte chan, bool pedal);
	void midiModWheel(byte chan, byte modwheel);
	void midiEffectLevel(byte chan, byte level);
	void midiChorus(byte chan, byte chorus);
	void midiControl0(byte chan, byte value);
	void midiProgram(byte chan, byte program, bool mt32emulate);
	void midiPan(byte chan, int8 pan);
	void midiNoteOn(byte chan, byte note, byte velocity);
	void midiNoteOff(byte chan, byte note);
	void midiSilence(byte chan);
	void midiInit();

	static void timer_callback (void *);

public:
	IMuseGM(MidiDriver *midi);
	void uninit();
	void init(IMuseInternal *eng, OSystem *os);
	void update_pris();
	void part_off(Part *part);
	int part_update_active(Part *part, uint16 *active);

	void on_timer() {}
	void set_instrument(uint slot, byte *instr);
	void part_set_instrument(Part *part, Instrument * instr);
	void part_set_param(Part *part, byte param, int value) {}
	void part_key_on(Part *part, byte note, byte velocity);
	void part_key_off(Part *part, byte note);
	void part_changed(Part *part, uint16 what);
	byte get_channel_program (byte channel) { return _midi_program_last [channel]; }

	static int midi_driver_thread(void *param);

	uint32 get_base_tempo() { return _md->getBaseTempo(); } // 0x4A0000; }
	byte get_hardware_type() { return 5; }
};



//*********************************
//**** IMUSE helper functions ****
//*********************************


static int clamp(int val, int min, int max)
{
	if (val < min)
		return min;
	if (val > max)
		return max;
	return val;
}

static int transpose_clamp(int a, int b, int c)
{
	if (b > a)
		a += (b - a + 11) / 12 * 12;
	if (c < a)
		a -= (a - c + 11) / 12 * 12;
	return a;
}

static uint32 get_delta_time(byte **s)
{
	byte *d = *s, b;
	uint32 time = 0;
	do {
		b = *d++;
		time = (time << 7) | (b & 0x7F);
	} while (b & 0x80);
	*s = d;
	return time;
}

static uint read_word(byte *a)
{
	return (a[0] << 8) + a[1];
}

static void skip_midi_cmd(byte **song_ptr)
{
	byte *s, code;

	const byte num_skip[] = {
		2, 2, 2, 2, 1, 1, 2
	};

	s = *song_ptr;

	code = *s++;

	if (code < 0x80) {
		s = NULL;
	} else if (code < 0xF0) {
		s += num_skip[(code & 0x70) >> 4];
	} else {
		if (code == 0xF0 || code == 0xF7 || code == 0xFF && *s++ != 0x2F) {
			s += get_delta_time(&s);
		} else {
			s = NULL;
		}
	}
	*song_ptr = s;
}

static int is_note_cmd(byte **a, IsNoteCmdData * isnote)
{
	byte *s = *a;
	byte code;

	code = *s++;

	switch (code >> 4) {
	case 8:											/* key off */
		isnote->chan = code & 0xF;
		isnote->note = *s++;
		isnote->vel = *s++;
		*a = s;
		return 1;
	case 9:											/* key on */
		isnote->chan = code & 0xF;
		isnote->note = *s++;
		isnote->vel = *s++;
		*a = s;
		if (isnote->vel)
			return 2;
		return 1;
	case 0xA:
	case 0xB:
	case 0xE:
		s++;
	case 0xC:
	case 0xD:
		s++;
		break;
	case 0xF:
		if (code == 0xF0 || code == 0xF7 || code == 0xFF && *s++ != 0x2F) {
			s += get_delta_time(&s);
			break;
		}
		return -1;
	default:
		return -1;
	}
	*a = s;
	return 0;
}

/**********************************************************************/

IMuseInternal::~IMuseInternal() {
	terminate();
}

void IMuseInternal::lock()
{
	_locked++;
}

void IMuseInternal::unlock()
{
	_locked--;
}

byte *IMuseInternal::findTag(int sound, char *tag, int index)
{
	byte *ptr = NULL;
	int32 size, pos;

	if (_base_sounds) {
		// FIXME: This is a hack to make certain parts of Sam & Max work.
		// It's a NASTY HACK because it has to specifically skip sound 1.
		// For some reason (maybe a script parse bug?), sound 1 is being
		// played at the very beginning (opening logo). Until this "fix",
		// the sound was never found and thus never played. It SHOULDN'T
		// be played.
		if (!_base_sounds[sound] && (sound > 1 || g_scumm->_gameId != GID_SAMNMAX))
			g_scumm->ensureResourceLoaded (rtSound, sound);
		ptr = _base_sounds[sound];
	}

	if (ptr == NULL) {
		  debug(1, "IMuseInternal::findTag completely failed finding sound %d", sound);
		return NULL;

	}

	ptr += 8;
	size = READ_BE_UINT32_UNALIGNED(ptr);
	ptr += 4;

	pos = 0;

	while (pos < size) {
		if (!memcmp(ptr + pos, tag, 4) && !index--)
			return ptr + pos + 8;
		pos += READ_BE_UINT32_UNALIGNED(ptr + pos + 4) + 8;
	}

	debug(3, "IMuseInternal::findTag failed finding sound %d", sound);
	return NULL;
}

bool IMuseInternal::isMT32(int sound)
{
	byte *ptr = NULL;
	uint32 tag;

	if (_base_sounds)
		ptr = _base_sounds[sound];

	if (ptr == NULL)
		return false;

	tag = *(((uint32 *)ptr) + 1);
	switch (tag) {
	case MKID('ADL '):
		return false;
	case MKID('ROL '):
		return true;
	case MKID('GMD '):
		return false;
	case MKID('MAC '):
		return true;
	case MKID('SPK '):
		return false;
	}

	return false;
}

bool IMuseInternal::isGM(int sound)
{
	byte *ptr = NULL;
	uint32 tag;

	if (_base_sounds)
		ptr = _base_sounds[sound];

	if (ptr == NULL)
		return false;

	tag = *(((uint32 *)ptr) + 1);
	switch (tag) {
	case MKID('ADL '):
		return false;
	case MKID('ROL '):
		return true; // Yeah... for our purposes, this is GM
	case MKID('GMD '):
		return true;
	case MKID('MIDI'):
		return true;
	case MKID('MAC '):
		return true; // I guess this one too, since it qualifies under isMT32()
	case MKID('SPK '):
		return false;
	}

	return false;
}

bool IMuseInternal::start_sound(int sound)
{
	Player *player;
	void *mdhd;

	mdhd = findTag(sound, MDHD_TAG, 0);
	if (!mdhd) {
		mdhd = findTag(sound, MDPG_TAG, 0);
		if (!mdhd) {
			warning("SE::start_sound failed: Couldn't find sound %d", sound);
			return false;
		}
	}

	// If the requested sound is already playing, start it over
	// from scratch. This was originally a hack to prevent Sam & Max
	// iMuse messiness while upgrading the iMuse engine, but it
	// is apparently necessary to deal with fade-and-restart
	// race conditions that were observed in MI2. Reference
	// Bug #590511 and Patch #607175 (which was reversed to fix
	// an FOA regression: Bug #622606).
	int i;
	for (i = ARRAYSIZE(_players), player = _players; i != 0; i--, player++) {
		if (player->_active && player->_id == sound)
			break;
	}

	if (!i)
		player = allocate_player(128);
	if (!player)
		return false;

	player->clear();
	return player->start_sound(sound);
}


Player *IMuseInternal::allocate_player(byte priority)
{
	Player *player = _players, *best = NULL;
	int i;
	byte bestpri = 255;

	for (i = ARRAYSIZE(_players); i != 0; i--, player++) {
		if (!player->_active)
			return player;
		if (player->_priority < bestpri) {
			best = player;
			bestpri = player->_priority;
		}
	}

	if (bestpri < priority)
		return best;

	debug(1, "Denying player request");
	return NULL;
}

void IMuseInternal::init_players()
{
	Player *player = _players;
	int i;

	for (i = ARRAYSIZE(_players); i != 0; i--, player++) {
		player->_active = false;
		player->_se = this;
	}
}

void IMuseInternal::init_sustaining_notes()
{
	SustainingNotes *next = NULL, *sn = _sustaining_notes;
	int i;

	_sustain_notes_used = NULL;
	_sustain_notes_head = NULL;

	for (i = ARRAYSIZE(_sustaining_notes); i != 0; i--, sn++) {
		sn->next = next;
		next = sn;
	}
	_sustain_notes_free = next;
}

void IMuseInternal::init_volume_fader()
{
	VolumeFader *vf = _volume_fader;
	int i;

	for (i = ARRAYSIZE(_volume_fader); i != 0; i--, vf++)
		vf->initialize();

	_active_volume_faders = false;
}

void IMuseInternal::init_parts()
{
	Part *part;
	int i;

	for (i = 0, part = _parts; i != ARRAYSIZE(_parts); i++, part++) {
		part->init(_driver);
		part->_slot = i;
	}
}

int IMuseInternal::stop_sound(int sound)
{
	Player *player = _players;
	int i;
	int r = -1;

	for (i = ARRAYSIZE(_players); i != 0; i--, player++) {
		if (player->_active && player->_id == sound) {
			player->clear();
			r = 0;
		}
	}
	return r;
}

int IMuseInternal::stop_all_sounds()
{
	Player *player = _players;
	int i;

	for (i = ARRAYSIZE(_players); i != 0; i--, player++) {
		if (player->_active)
			player->clear();
	}
	return 0;
}

void IMuseInternal::on_timer()
{
	if (_locked || _paused)
		return;

	lock();

	sequencer_timers();
	expire_sustain_notes();
	expire_volume_faders();
	_driver->on_timer();

	unlock();
}

void IMuseInternal::sequencer_timers()
{
	Player *player = _players;
	int i;

	for (i = ARRAYSIZE(_players); i != 0; i--, player++) {
		if (player->_active)
			player->sequencer_timer();
	}
}

void IMuseInternal::handle_marker(uint id, byte data)
{
	uint16 *p;
	uint pos;

	pos = _queue_end;
	if (pos == _queue_pos)
		return;

	if (_queue_adding && _queue_sound == id && data == _queue_marker)
		return;

	p = _cmd_queue[pos].array;

	if (p[0] != TRIGGER_ID || p[1] != id || p[2] != data)
		return;

	_trigger_count--;
	_queue_cleared = false;
	do {
		pos = (pos + 1) & (ARRAYSIZE(_cmd_queue) - 1);
		if (_queue_pos == pos)
			break;
		p = _cmd_queue[pos].array;
		if (*p++ != COMMAND_ID)
			break;
		_queue_end = pos;

		do_command(p[0], p[1], p[2], p[3], p[4], p[5], p[6], 0);

		if (_queue_cleared)
			return;
		pos = _queue_end;
	} while (1);

	_queue_end = pos;
}

int IMuseInternal::get_channel_volume(uint a)
{
	if (a < 8)
		return _channel_volume_eff[a];
	return (_master_volume * _music_volume / 255) >> 1;
}

Part *IMuseInternal::allocate_part(byte pri)
{
	Part *part, *best = NULL;
	int i;

	for (i = ARRAYSIZE(_parts), part = _parts; i != 0; i--, part++) {
		if (!part->_player)
			return part;
		if (pri >= part->_pri_eff) {
			pri = part->_pri_eff;
			best = part;
		}
	}

	if (best)
		best->uninit();
	else
		debug(1, "Denying part request");
	return best;
}

void IMuseInternal::expire_sustain_notes()
{
	SustainingNotes *sn, *next;
	Player *player;
	uint32 counter;

	for (sn = _sustain_notes_head; sn; sn = next) {
		next = sn->next;
		player = sn->player;

		counter = sn->counter + player->_timer_speed;
		sn->pos += counter >> 16;
		sn->counter = (unsigned short)counter & 0xFFFF;

		if (sn->pos >= sn->off_pos) {
			player->key_off(sn->chan, sn->note);

			/* Unlink the node */
			if (next)
				next->prev = sn->prev;
			if (sn->prev)
				sn->prev->next = next;
			else
				_sustain_notes_head = next;

			/* And put it in the free list */
			sn->next = _sustain_notes_free;
			_sustain_notes_free = sn;
		}
	}
}

void IMuseInternal::expire_volume_faders()
{
	VolumeFader *vf;
	int i;

	if (++_volume_fader_counter & 7)
		return;

	if (!_active_volume_faders)
		return;

	_active_volume_faders = false;
	vf = _volume_fader;
	for (i = ARRAYSIZE(_volume_fader); i != 0; i--, vf++) {
		if (vf->active) {
			_active_volume_faders = true;
			vf->on_timer(false);
		}
	}
}

void VolumeFader::on_timer(bool probe)
{
	byte newvol;

	newvol = curvol + speed_hi;
	speed_lo_counter += speed_lo;

	if (speed_lo_counter >= speed_lo_max) {
		speed_lo_counter -= speed_lo_max;
		newvol += direction;
	}

	if (curvol != newvol) {
		curvol = newvol;
		if (!newvol) {
			if (!probe)
				player->clear();
			active = false;
			return;
		}
		if (!probe)
			player->set_vol(newvol);
	}

	if (!--num_steps) {
		active = false;
	}
}

byte VolumeFader::fading_to()
{
	byte newvol;
	byte orig_curvol;
	uint16 orig_speed_lo_counter, orig_num_steps;

	if (!active)
		return 127;

	// It would be so much easier to just store the fade-to volume in a
	// variable, but then we'd have to break savegame compatibility. So
	// instead we do a "dry run" fade.

	orig_speed_lo_counter = speed_lo_counter;
	orig_num_steps = num_steps;
	orig_curvol = curvol;

	while (active)
		on_timer(true);

	active = true;
	newvol = curvol;

	speed_lo_counter = orig_speed_lo_counter;
	num_steps = orig_num_steps;
	curvol = orig_curvol;

	return newvol;
}

int IMuseInternal::get_sound_status(int sound)
{
	int i;
	Player *player;
	for (i = ARRAYSIZE(_players), player = _players; i != 0; i--, player++) {
		if (player->_active && player->_id == (uint16)sound) {
			// Assume that anyone asking for the sound status is
			// really asking "is it ok if I start playing this
			// sound now?" So if the sound is about to fade out,
			// pretend it's not playing.
			if (player->is_fading_out())
				continue;
			return 1;
		}
	}
	return get_queue_sound_status(sound);
}

int IMuseInternal::get_queue_sound_status(int sound)
{
	uint16 *a;
	int i, j;

	j = _queue_pos;
	i = _queue_end;

	while (i != j) {
		a = _cmd_queue[i].array;
		if (a[0] == COMMAND_ID && a[1] == 8 && a[2] == (uint16)sound)
			return 2;
		i = (i + 1) & (ARRAYSIZE(_cmd_queue) - 1);
	}
	return 0;
}

int IMuseInternal::set_volchan(int sound, int volchan)
{
	int r;
	int i;
	int num;
	Player *player, *best, *sameid;

	r = get_volchan_entry(volchan);
	if (r == -1)
		return -1;

	if (r >= 8) {
		for (i = ARRAYSIZE(_players), player = _players; i != 0; i--, player++) {
			if (player->_active && player->_id == (uint16)sound && player->_vol_chan != (uint16)volchan) {
				player->_vol_chan = volchan;
				player->set_vol(player->_volume);
				return 0;
			}
		}
		return -1;
	} else {
		best = NULL;
		num = 0;
		sameid = NULL;
		for (i = ARRAYSIZE(_players), player = _players; i != 0; i--, player++) {
			if (player->_active) {
				if (player->_vol_chan == (uint16)volchan) {
					num++;
					if (!best || player->_priority <= best->_priority)
						best = player;
				} else if (player->_id == (uint16)sound) {
					sameid = player;
				}
			}
		}
		if (sameid == NULL)
			return -1;
		if (num >= r)
			best->clear();
		player->_vol_chan = volchan;
		player->set_vol(player->_volume);
		return 0;
	}
}

int IMuseInternal::clear_queue()
{
	_queue_adding = false;
	_queue_cleared = true;
	_queue_pos = 0;
	_queue_end = 0;
	_trigger_count = 0;
	return 0;
}

int IMuseInternal::enqueue_command(int a, int b, int c, int d, int e, int f, int g)
{
	uint16 *p;
	uint i;

	i = _queue_pos;

	if (i == _queue_end)
		return -1;

	if (a == -1) {
		_queue_adding = false;
		_trigger_count++;
		return 0;
	}

	p = _cmd_queue[_queue_pos].array;
	p[0] = COMMAND_ID;
	p[1] = a;
	p[2] = b;
	p[3] = c;
	p[4] = d;
	p[5] = e;
	p[6] = f;
	p[7] = g;

	i = (i + 1) & (ARRAYSIZE(_cmd_queue) - 1);

	if (_queue_end != i) {
		_queue_pos = i;
		return 0;
	} else {
		_queue_pos = (i - 1) & (ARRAYSIZE(_cmd_queue) - 1);
		return -1;
	}
}

int IMuseInternal::query_queue(int param)
{
	switch (param) {
	case 0:											/* get trigger count */
		return _trigger_count;
	case 1:											/* get trigger type */
		if (_queue_end == _queue_pos)
			return -1;
		return _cmd_queue[_queue_end].array[1];
	case 2:											/* get trigger sound */
		if (_queue_end == _queue_pos)
			return 0xFF;
		return _cmd_queue[_queue_end].array[2];
	default:
		return -1;
	}
}

int IMuseInternal::get_music_volume()
{
	return _music_volume;
}

int IMuseInternal::set_music_volume(uint vol)
{
	if (vol > 255)
		vol = 255;
	else if (vol < 0)
		vol = 0;

	if (_music_volume == vol)
		return 0;
	_music_volume = vol;
	vol = vol * _master_volume / 255;
	for (uint i = 0; i < ARRAYSIZE (_channel_volume); i++) {
		_channel_volume_eff[i] = _channel_volume[i] * vol / 255;
	}
	if (!_paused)
		update_volumes();
	return 0;
}

int IMuseInternal::set_master_volume (uint vol)
{
	if (vol > 255)
		vol = 255;
	else if (vol < 0)
		vol = 0;
	if (_master_volume == vol)
		return 0;

	_master_volume = vol;
	vol = vol * _music_volume / 255;
	for (uint i = 0; i < ARRAYSIZE (_channel_volume); i++) {
		_channel_volume_eff[i] = _channel_volume[i] * vol / 255;
	}
	if (!_paused)
		update_volumes();
	return 0;
}

int IMuseInternal::get_master_volume()
{
	return _master_volume;
}

int IMuseInternal::terminate()
{
	if (_driver) {
		_driver->uninit();
		delete _driver;
		_driver = NULL;
	}
	return 0;
	/* not implemented */
}


int IMuseInternal::enqueue_trigger(int sound, int marker)
{
	uint16 *p;
	uint pos;

	pos = _queue_pos;

	p = _cmd_queue[pos].array;
	p[0] = TRIGGER_ID;
	p[1] = sound;
	p[2] = marker;

	pos = (pos + 1) & (ARRAYSIZE(_cmd_queue) - 1);
	if (_queue_end == pos) {
		_queue_pos = (pos - 1) & (ARRAYSIZE(_cmd_queue) - 1);
		return -1;
	}

	_queue_pos = pos;
	_queue_adding = true;
	_queue_sound = sound;
	_queue_marker = marker;
	return 0;
}

int32 IMuseInternal::do_command(int a, int b, int c, int d, int e, int f, int g, int h)
{
	int i;
	byte cmd = a & 0xFF;
	byte param = a >> 8;
	Player *player = NULL;

	if (!_initialized && (cmd || param))
		return -1;

	if (param == 0) {
		switch (cmd) {
		case 6:
			if (b > 127)
				return -1;
			else
				return set_master_volume ((b << 1) | (b ? 0 : 1)); // Convert b from 0-127 to 0-255
		case 7:
			return _master_volume >> 1; // Convert from 0-255 to 0-127
		case 8:
			return start_sound(b) ? 0 : -1;
		case 9:
			return stop_sound(b);
		case 10: // FIXME: Sam and Max - Not sure if this is correct
			return stop_all_sounds();
		case 11:
			return stop_all_sounds();
		case 12:
			// Sam & Max: Player-scope commands
			for (i = ARRAYSIZE(_players), player = _players; i != 0; i--, player++) {
				if (player->_active && player->_id == (uint16)b)
					break;
			}
			if (!i)
				return -1;

			switch (d) {
			case 6:
				// Set player volume.
				// Jamieson360: Good, this is consistent with IMuseDigital.
				return player->set_vol (e);
			default:
				warning("IMuseInternal::do_command (6) unsupported sub-command %d", d);
			}
			return -1;
		case 13:
			return get_sound_status(b);
		case 14:
			// Sam and Max: Volume Fader?
			// Prevent instantaneous volume fades.
			// Fixes a Ball of Twine issue, but might not be the right long-term solution.
			if (f != 0) {
				for (i = ARRAYSIZE(_players), player = _players; i != 0; i--, player++) {
					if (player->_active && player->_id == (uint16)b) {
						player->fade_vol(e, f);
						return 0;
					}
				}
			}
			return -1;
		case 15:
			// Sam & Max: Unconditional Jump?
			for (i = ARRAYSIZE(_players), player = _players; i != 0; i--, player++) {
				if (player->_active && player->_id == (uint16)b) {
					player->_hook._jump = d;
					return 0;
				}
			}
			return -1;
		case 16:
			return set_volchan(b, c);
		case 17:
			if (g_scumm->_gameId != GID_SAMNMAX) {
				return set_channel_volume(b, c);
			} else {
				if (e || f || g || h) 
					return ImSetTrigger (b, d, e, f, g, h);
				else
					return ImClearTrigger (b, d);
			}
		case 18:
			if (g_scumm->_gameId != GID_SAMNMAX) {
				return set_volchan_entry(b, c);
			} else {
				// Sam & Max: ImCheckTrigger.
				// According to Mike's notes to Ender,
				// this function returns the number of triggers
				// associated with a particular player ID and
				// trigger ID.
				a = 0;
				for (i = 0; i < 16; ++i) {
					if (_snm_triggers [i].sound == b && _snm_triggers [i].id &&
					    (d == -1 || _snm_triggers [i].id == d))
					{
						++a;
					}
				}
				return a;
			}
		case 19:
			// Sam & Max: ImClearTrigger
			// This should clear a trigger that's been set up
			// with ImSetTrigger (cmd == 17). Seems to work....
			return ImClearTrigger (b, d);
		case 20: // FIXME: Deferred command system? - Sam and Max
			return 0;
		case 2:
		case 3:
			return 0;
		default:
			warning("do_command (%d [%d/%d], %d, %d, %d, %d, %d, %d, %d) unsupported", a, param, cmd, b, c, d, e, f, g, h);
		}
	} else if (param == 1) {
		if ((1 << cmd) & (0x783FFF)) {
			player = get_player_byid(b);
			if (!player)
				return -1;
			if ((1 << cmd) & (1 << 11 | 1 << 22)) {
				assert(c >= 0 && c <= 15);
				player = (Player *)player->get_part(c);
				if (!player)
					return -1;
			}
		}

		switch (cmd) {
		case 0:
			if (g_scumm->_gameId == GID_SAMNMAX) {
				if (d == 1)
					return player->_marker;
				else if (d == 2)
					return player->_beat_index;
				return -1;
			} else {
				return player->get_param(c, d);
			}
		case 1:
			if (g_scumm->_gameId == GID_SAMNMAX)
				player->jump (d - 1, (e - 1) * 4 + f, ((g * player->_ticks_per_beat) >> 2) + h);
			else
				player->set_priority(c);
			return 0;
		case 2:
			return player->set_vol(c);
		case 3:
			player->set_pan(c);
			return 0;
		case 4:
			return player->set_transpose(c, d);
		case 5:
			player->set_detune(c);
			return 0;
		case 6:
			player->set_speed(c);
			return 0;
		case 7:
			return player->jump(c, d, e) ? 0 : -1;
		case 8:
			return player->scan(c, d, e);
		case 9:
			return player->set_loop(c, d, e, f, g) ? 0 : -1;
		case 10:
			player->clear_loop();
			return 0;
		case 11:
			((Part *)player)->set_onoff(d != 0);
			return 0;
		case 12:
			return player->_hook.set(c, d, e);
		case 13:
			return player->fade_vol(c, d);
		case 14:
			return enqueue_trigger(b, c);
		case 15:
			return enqueue_command(b, c, d, e, f, g, h);
		case 16:
			return clear_queue();
		case 19:
			return player->get_param(c, d);
		case 20:
			return player->_hook.set(c, d, e);
		case 21:
			return -1;
		case 22:
			((Part *)player)->set_vol(d);
			return 0;
		case 23:
			return query_queue(b);
		case 24:
			return 0;
		default:
			warning("do_command (%d [%d/%d], %d, %d, %d, %d, %d, %d, %d) unsupported", a, param, cmd, b, c, d, e, f, g, h);
			return -1;
		}
	}

	return -1;
}

int32 IMuseInternal::ImSetTrigger (int sound, int id, int a, int b, int c, int d) {
	// Sam & Max: ImSetTrigger.
	// Sets a trigger for a particular player and
	// marker ID, along with do_command parameters
	// to invoke at the marker. The marker is
	// represented by MIDI SysEx block 00 xx (F7)
	// where "xx" is the marker ID.
	uint16 oldest_trigger = 0;
	int oldest_index = -1;

	int i;
	for (i = 0; i < 16; ++i) {
		ImTrigger *trig = &_snm_triggers [i];
		if (!trig->id)
			break;
		if (trig->id == id && trig->sound == sound)
			break;

		uint16 diff;
		if (trig->expire <= _snm_trigger_index)
			diff = _snm_trigger_index - trig->expire;
		else
			diff = 0x10000 - trig->expire + _snm_trigger_index;

		if (oldest_index < 0 || oldest_trigger < diff) {
			oldest_index = i;
			oldest_trigger = diff;
		}
	}

	// If we didn't find a trigger, see if we can expire one.
	if (i >= 16) {
		if (oldest_index < 0)
			return -1;
		i = oldest_index;
	}

	_snm_triggers [i].id = id;
	_snm_triggers [i].sound = sound;
	_snm_triggers [i].expire = (++_snm_trigger_index & 0xFFFF);
	_snm_triggers [i].command [0] = a;
	_snm_triggers [i].command [1] = b;
	_snm_triggers [i].command [2] = c;
	_snm_triggers [i].command [3] = d;
	return 0;
}

int32 IMuseInternal::ImClearTrigger (int sound, int id) {
	int count = 0;
	int i;
	for (i = 0; i < 16; ++i) {
		if (_snm_triggers [i].sound == sound && _snm_triggers [i].id &&
			(id == -1 || _snm_triggers [i].id == id))
		{
			_snm_triggers [i].sound = _snm_triggers [i].id = 0;
			++count;
		}
	}
	return (count > 0) ? 0 : -1;
}

int IMuseInternal::set_channel_volume(uint chan, uint vol)
{
	if (chan >= 8 || vol > 127)
		return -1;

	_channel_volume[chan] = vol;
	_channel_volume_eff[chan] = _master_volume * _music_volume * vol / 255 / 255;
	update_volumes();
	return 0;
}

void IMuseInternal::update_volumes()
{
	Player *player;
	int i;

	for (i = ARRAYSIZE(_players), player = _players; i != 0; i--, player++) {
		if (player->_active)
			player->set_vol(player->_volume);
	}
}

int IMuseInternal::set_volchan_entry(uint a, uint b)
{
	if (a >= 8)
		return -1;
	_volchan_table[a] = b;
	return 0;
}

int HookDatas::query_param(int param, byte chan)
{
	switch (param) {
	case 18:
		return _jump;
	case 19:
		return _transpose;
	case 20:
		return _part_onoff[chan];
	case 21:
		return _part_volume[chan];
	case 22:
		return _part_program[chan];
	case 23:
		return _part_transpose[chan];
	default:
		return -1;
	}
}

int HookDatas::set(byte cls, byte value, byte chan)
{
	switch (cls) {
	case 0:
		_jump = value;
		break;
	case 1:
		_transpose = value;
		break;
	case 2:
		if (chan < 16)
			_part_onoff[chan] = value;
		else if (chan == 16)
			memset(_part_onoff, value, 16);
		break;
	case 3:
		if (chan < 16)
			_part_volume[chan] = value;
		else if (chan == 16)
			memset(_part_volume, value, 16);
		break;
	case 4:
		if (chan < 16)
			_part_program[chan] = value;
		else if (chan == 16)
			memset(_part_program, value, 16);
		break;
	case 5:
		if (chan < 16)
			_part_transpose[chan] = value;
		else if (chan == 16)
			memset(_part_transpose, value, 16);
		break;
	default:
		return -1;
	}
	return 0;
}


VolumeFader *IMuseInternal::allocate_volume_fader()
{
	VolumeFader *vf;
	int i;

	vf = _volume_fader;
	for (i = ARRAYSIZE(_volume_fader); vf->active;) {
		vf++;
		if (!--i)
			return NULL;
	}

	vf->active = true;
	_active_volume_faders = true;
	return vf;
}

Player *IMuseInternal::get_player_byid(int id)
{
	int i;
	Player *player, *found = NULL;

	for (i = ARRAYSIZE(_players), player = _players; i != 0; i--, player++) {
		if (player->_active && player->_id == (uint16)id) {
			if (found)
				return NULL;
			found = player;
		}
	}
	return found;
}

int IMuseInternal::get_volchan_entry(uint a)
{
	if (a < 8)
		return _volchan_table[a];
	return -1;
}

uint32 IMuseInternal::property(int prop, uint32 value)
{
	switch (prop) {
	case IMuse::PROP_TEMPO_BASE:
		_game_tempo = value;
		break;
	}
	return 0;
}

void IMuseInternal::setBase(byte **base)
{
	_base_sounds = base;
}


IMuseInternal *IMuseInternal::create(OSystem *syst, MidiDriver *midi, SoundMixer *mixer)
{
	IMuseInternal *i = new IMuseInternal;
	i->initialize(syst, midi, mixer);
	return i;
}


int IMuseInternal::initialize(OSystem *syst, MidiDriver *midi, SoundMixer *mixer)
{
	int i;

	IMuseDriver *driv;

	if (midi == NULL) {
//		driv = new IMuseAdlib(mixer);
		driv = NULL;
	} else {
		driv = new IMuseGM(midi);
	}

	_driver = driv;
	_hardware_type = driv->get_hardware_type();
	_game_tempo = driv->get_base_tempo();

	driv->init(this, syst);

	_master_volume = 255;
	if (_music_volume < 1)
		_music_volume = kDefaultMusicVolume;

	for (i = 0; i != 8; i++)
		_channel_volume[i] = _channel_volume_eff[i] = _volchan_table[i] = 127;

	init_players();
	init_sustaining_notes();
	init_volume_fader();
	init_queue();
	init_parts();

	_initialized = true;

	return 0;
}

void IMuseInternal::init_queue()
{
	_queue_adding = false;
	_queue_pos = 0;
	_queue_end = 0;
	_trigger_count = 0;
}

void IMuseInternal::pause(bool paused)
{
	int vol = _music_volume;
	if (paused)
		_music_volume = 0;
	update_volumes();
	_music_volume = vol;

	_paused = paused;
}


/*************************************************************************/

int Player::fade_vol(byte vol, int time)
{
	VolumeFader *vf;
	int i;

	cancel_volume_fade();
	if (time == 0) {
		set_vol(vol);
		return 0;
	}

	vf = _se->allocate_volume_fader();
	if (vf == NULL)
		return -1;

	vf->player = this;
	vf->num_steps = vf->speed_lo_max = time;
	vf->curvol = _volume;
	i = (vol - vf->curvol);
	vf->speed_hi = i / time;
	if (i < 0) {
		i = -i;
		vf->direction = -1;
	} else {
		vf->direction = 1;
	}
	vf->speed_lo = i % time;
	vf->speed_lo_counter = 0;
	return 0;
}

bool Player::is_fading_out()
{
	VolumeFader *vf = _se->_volume_fader;
	int i;

	for (i = 0; i < 8; i++, vf++) {
		if (vf->active && vf->direction < 0 && vf->player == this && vf->fading_to() == 0)
			return true;
	}
	return false;
}

void Player::clear()
{
	uninit_seq();
	cancel_volume_fade();
	uninit_parts();
	_active = false;
	_ticks_per_beat = TICKS_PER_BEAT;
}

bool Player::start_sound(int sound)
{
	void *mdhd;

	mdhd = _se->findTag(sound, MDHD_TAG, 0);
	if (mdhd == NULL) {
		mdhd = _se->findTag(sound, MDPG_TAG, 0);
		if (mdhd == NULL) {
				warning("P::start_sound failed: Couldn't find %s", MDHD_TAG);
				return false;
		}
	}

	_mt32emulate = _se->isMT32(sound);
	_isGM = _se->isGM(sound);

	_parts = NULL;
	_active = true;
	_id = sound;
	_priority = 0x80;
	_volume = 0x7F;
	_vol_chan = 0xFFFF;

	_vol_eff = (_se->get_channel_volume(0xFFFF) << 7) >> 7;

	_pan = 0;
	_transpose = 0;
	_detune = 0;

	hook_clear();
	if (start_seq_sound(sound) != 0) {
		_active = false;
		return false;
	}
	return true;
}

void Player::hook_clear()
{
	memset(&_hook, 0, sizeof(_hook));
}

int Player::start_seq_sound(int sound)
{
	byte *ptr, *track_ptr;

	_song_index = sound;
	_timer_counter = 0;
	_loop_to_beat = 1;
	_loop_from_beat = 1;
	_track_index = 0;
	_loop_counter = 0;
	_loop_to_tick = 0;
	_loop_from_tick = 0;

	set_tempo(500000);
	set_speed(128);
	ptr = _se->findTag(sound, "MTrk", _track_index);
	if (ptr == NULL)
		return -1;

	track_ptr = ptr;
	_cur_pos = _next_pos = get_delta_time(&track_ptr);
	_song_offset = track_ptr - ptr;

	_tick_index = _cur_pos;
	_beat_index = 1;

	if (_tick_index >= _ticks_per_beat) {
		_beat_index += _tick_index / _ticks_per_beat;
		_tick_index %= _ticks_per_beat;
	}

	return 0;
}

void Player::set_tempo(uint32 b)
{
	uint32 i, j;

	i = _se->_game_tempo;

	j = _tempo = b;

	while (i & 0xFFFF0000 || j & 0xFFFF0000) {
		i >>= 1;
		j >>= 1;
	}

	_tempo_eff = (i << 16) / j;

	set_speed(_speed);
}

void Player::cancel_volume_fade()
{
	VolumeFader *vf = _se->_volume_fader;
	int i;

	for (i = 0; i < 8; i++, vf++) {
		if (vf->active && vf->player == this)
			vf->active = false;
	}
}

void Player::uninit_parts()
{
	if (_parts && _parts->_player != this)
		error("asd");
	while (_parts)
		_parts->uninit();
}

void Player::uninit_seq()
{
	_abort = true;
}

void Player::set_speed(byte speed)
{
	_speed = speed;
	_timer_speed = (_tempo_eff * speed >> 7);
}

byte *Player::parse_midi(byte *s)
{
	byte cmd, chan, note, velocity, control;
	uint value;
	Part *part;

	cmd = *s++;

	chan = cmd & 0xF;

	switch (cmd >> 4) {
	case 0x8:										/* key off */
		note = *s++;
		if (!_scanning) {
			key_off(chan, note);
		} else {
			clear_active_note(chan, note);
		}
		s++;												/* skip velocity */
		break;

	case 0x9:										/* key on */
		note = *s++;
		velocity = *s++;
		if (velocity) {
			if (!_scanning)
				key_on(chan, note, velocity);
			else
				set_active_note(chan, note);
		} else {
			if (!_scanning)
				key_off(chan, note);
			else
				clear_active_note(chan, note);
		}
		break;

	case 0xA:										/* aftertouch */
		s += 2;
		break;

	case 0xB:										/* control change */
		control = *s++;
		value = *s++;
		part = get_part(chan);
		if (!part)
			break;

		switch (control) {
		case 1:										/* modulation wheel */
			part->set_modwheel(value);
			break;
		case 7:										/* volume */
			part->set_vol(value);
			break;
		case 10:										/* pan position */
			part->set_pan(value - 0x40);
			break;
		case 16:										/* pitchbend factor */
			part->set_pitchbend_factor(value);
			break;
		case 17:										/* gp slider 2 */
			part->set_detune(value - 0x40);
			break;
		case 18:										/* gp slider 3 */
			part->set_pri(value - 0x40);
			_se->_driver->update_pris();
			break;
		case 64:										/* hold pedal */
			part->set_pedal(value != 0);
			break;
		case 91:										/* effects level */
			part->set_effect_level(value);
			break;
		case 93:										/* chorus */
			part->set_chorus(value);
			break;
		default:
			warning("parse_midi: invalid control %d", control);
		}
		break;

	case 0xC:										/* program change */
		value = *s++;
		part = get_part(chan);
		if (part)
			part->set_program(value);
		break;

	case 0xD:										/* channel pressure */
		s++;
		break;

	case 0xE:										/* pitch bend */
		part = get_part(chan);
		if (part)
			part->set_pitchbend(((s[1] << 7) | s[0]) - 0x2000);
		s += 2;
		break;

	case 0xF:
		if (chan == 0) {
			uint size = get_delta_time(&s);
			parse_sysex(s, size);
			s += size;
		} else if (chan == 0xF) {
			cmd = *s++;
			if (cmd == 47)
				goto Error;							/* end of song */
			if (cmd == 81) {
				set_tempo((s[1] << 16) | (s[2] << 8) | s[3]);
				s += 4;
				break;
			}
			s += get_delta_time(&s);
		} else if (chan == 0x7) {
			s += get_delta_time(&s);
		} else {
			goto Error;
		}
		break;

	default:
	Error:;
		if (!_scanning)
			clear();
		return NULL;
	}
	return s;
}

struct {
	char *name;
	byte program;
}
roland_to_gm_map [] = {
	// Monkey Island 2 instruments
	// TODO: Complete
//	{ "badspit   ", ??? },
	{ "Big Drum  ", 116 },
//	{ "burp      ", ??? },
//	{ "dinkfall  ", ??? },
//	{ "Fire Pit  ", ??? },
//	{ "foghorn   ", ??? },
	{ "glop      ",  39 },
//	{ "jacob's la", ??? },
	{ "LeshBass  ",  33 }, 
//	{ "lowsnort  ", ??? },
//	{ "ML explosn", ??? },
	{ "ReggaeBass",  32 },
//	{ "rope fall ", ??? },
//	{ "rumble    ", ??? },
//	{ "SdTrk Bend", ??? },
//	{ "snort     ", ??? },
//	{ "spitting  ", ??? },
	{ "Swell 1   ",  95 },
	{ "Swell 2   ",  95 }
//	{ "thnderclap", ??? },

	// Fate of Atlantis instruments
	// TODO: Build
//	{ "*aah!     ", ??? },
//	{ "*ooh!     ", ??? },
//	{ "*ShotFar4 ", ??? },
//	{ "*splash3  ", ??? },
//	{ "*torpedo5 ", ??? },
//	{ "*whip3    ", ??? },
//	{ "*woodknock", ??? },
//	{ "35 lavabub", ??? },
//	{ "49 bzzt!  ", ??? },
//	{ "applause  ", ??? },
//	{ "Arabongo  ", ??? },
//	{ "Big Drum  ", ??? }, // DUPLICATE (todo: confirm)
//	{ "bodythud1 ", ??? },
//	{ "boneKLOK2 ", ??? },
//	{ "boom10    ", ??? },
//	{ "boom11    ", ??? },
//	{ "boom15    ", ??? },
//	{ "boxclik1a ", ??? },
//	{ "brassbonk3", ??? },
//	{ "carstart  ", ??? },
//	{ "cb tpt 2  ", ??? },
//	{ "cell door ", ??? },
//	{ "chains    ", ??? },
//	{ "crash     ", ??? },
//	{ "crsrt/idl3", ??? },
//	{ "Fire Pit  ", ??? }, // DUPLICATE (todo: confirm)
//	{ "Fzooom    ", ??? },
//	{ "Fzooom 2  ", ??? },
//	{ "ghostwhosh", ??? },
//	{ "glasssmash", ??? },
//	{ "gloop2    ", ??? },
//	{ "gunShotNea", ??? },
//	{ "idoorclse ", ??? },
//	{ "knife     ", ??? },
//	{ "lavacmbl4 ", ??? },
//	{ "Mellow Str", ??? },
//	{ "mtlheater1", ??? },
//	{ "pachinko5 ", ??? },
//	{ "Ping1     ", ??? },
//	{ "rockcrunch", ??? },
//	{ "rumble    ", ??? }, // DUPLICATE (todo: confirm)
//	{ "runngwatr ", ??? },
//	{ "scrape2   ", ??? },
//	{ "snakeHiss ", ??? },
//	{ "snort     ", ??? }, // DUPLICATE (todo: confirm)
//	{ "spindle4  ", ??? },
//	{ "splash2   ", ??? },
//	{ "squirel   ", ??? },
//	{ "steam3    ", ??? },
//	{ "stonwheel6", ??? },
//	{ "street    ", ??? },
//	{ "trickle4  ", ??? }
};

void Player::parse_sysex(byte *p, uint len)
{
	byte code;
	byte a;
	uint b;
	byte buf[128];
	Part *part;

	// Check SysEx manufacturer.
	// Roland is 0x41
	a = *p++;
	--len;
	if (a != IMUSE_SYSEX_ID) {
		if (a == ROLAND_SYSEX_ID) {
			// Roland custom instrument definition.
			part = get_part (p[0] & 0x0F);
			if (part) {
				memcpy (buf, p + 6, 10);
				buf[10] = '\0';
				for (b = 0; b < ARRAYSIZE(roland_to_gm_map); ++b) {
					if (!memcmp (roland_to_gm_map[b].name, buf, 10)) {
						a = roland_to_gm_map[b].program;
						for (b = 0; b < ARRAYSIZE(mt32_to_gmidi); ++b) {
							if (mt32_to_gmidi [b] == a) {
								part->set_program (b);
								return;
							}
						}
						warning ("Could not find appropriate MT-32 program for GM program %d", (int) a);
						return;
					}
				}
				warning ("Could not find appropriate GM program for MT-32 custom instrument \"%s\"", buf);
			}
		} else {
			warning ("Unknown SysEx manufacturer 0x%02X", (int) a);
			return;
		}
	}
	--len;

	// Too big?
	if (len >= sizeof(buf) * 2)
		return;

	switch (code = *p++) {
	case 0:
		if (g_scumm->_gameId != GID_SAMNMAX) {
			// There are 17 bytes of useful information beyond
			// what we've read so far. All we know about them is
			// as follows:
			//   BYTE 00: Channel #
			//   BYTE 02: BIT 01 (0x01): Part on? (1 = yes)
			//   BYTE 05: Volume (upper 4 bits) [guessing]
			//   BYTE 06: Volume (lower 4 bits) [guessing]
			//   BYTE 09: BIT 04 (0x08): Percussion? (1 = yes)
			part = get_part (p[0] & 0x0F);
			if (part) {
				part->set_onoff (p[2] & 0x01);
				part->set_vol ((p[5] & 0x0F) << 4 | (p[6] & 0x0F));
				part->_percussion = _isGM ? ((p[9] & 0x08) > 0) : false;
				if (part->_percussion) {
					if (part->_mc)
						part->off();
				} else {
					part->changed (IMuseDriver::pcAll);
				}
			}
		} else {
			// Sam & Max seems to use this as a marker for
			// ImSetTrigger. When a marker is encountered whose sound
			// ID and (presumably) marker ID match what was set by
			// ImSetTrigger, something magical is supposed to happen....
			_marker = *p;
			for (a = 0; a < 16; ++a) {
				if (_se->_snm_triggers [a].sound == _id &&
				    _se->_snm_triggers [a].id == *p)
				{
					_se->_snm_triggers [a].sound = _se->_snm_triggers [a].id = 0;
					_se->do_command (_se->_snm_triggers [a].command [0],
					                 _se->_snm_triggers [a].command [1],
					                 _se->_snm_triggers [a].command [2],
					                 _se->_snm_triggers [a].command [3],
					                 0, 0, 0, 0);
					break;
				}
			}
		} // end if
		break;

	case 1:
		// This SysEx is used in Sam & Max for maybe_jump.
		if (_scanning)
			break;
		maybe_jump (p[0], p[1] - 1, (read_word (p + 2) - 1) * 4 + p[4], ((p[5] * _ticks_per_beat) >> 2) + p[6]);
		break;
		
	case 16:											/* set instrument in part */
		a = *p++ & 0x0F;
		if (_se->_hardware_type != *p++ && false)
			break;
		decode_sysex_bytes(p, buf, len - 3);
		part = get_part(a);
		if (part)
			part->set_instrument((Instrument *) buf);
		break;

	case 17:											/* set global instrument */
		p++;
		if (_se->_hardware_type != *p++ && false)
			break;
		a = *p++;
		decode_sysex_bytes(p, buf, len - 4);
		_se->_driver->set_instrument(a, buf);
		break;

	case 33:											/* param adjust */
		a = *p++ & 0x0F;
		if (_se->_hardware_type != *p++)
			break;
		decode_sysex_bytes(p, buf, len - 3);
		part = get_part(a);
		if (part)
			part->set_param(read_word(buf), read_word(buf + 2));
		break;

	case 48:											/* hook - jump */
		if (_scanning)
			break;
		decode_sysex_bytes(p + 1, buf, len - 2);
		maybe_jump (buf[0], read_word (buf + 1), read_word (buf + 3), read_word (buf + 5));
		break;

	case 49:											/* hook - global transpose */
		decode_sysex_bytes(p + 1, buf, len - 2);
		maybe_set_transpose(buf);
		break;

	case 50:											/* hook - part on/off */
		buf[0] = *p++ & 0x0F;
		decode_sysex_bytes(p, buf + 1, len - 2);
		maybe_part_onoff(buf);
		break;

	case 51:											/* hook - set volume */
		buf[0] = *p++ & 0x0F;
		decode_sysex_bytes(p, buf + 1, len - 2);
		maybe_set_volume(buf);
		break;

	case 52:											/* hook - set program */
		buf[0] = *p++ & 0x0F;
		decode_sysex_bytes(p, buf + 1, len - 2);
		maybe_set_program(buf);
		break;

	case 53:											/* hook - set transpose */
		buf[0] = *p++ & 0x0F;
		decode_sysex_bytes(p, buf + 1, len - 2);
		maybe_set_transpose_part(buf);
		break;

	case 64:											/* marker */
		p++;
		len -= 2;
		while (len--) {
			_se->handle_marker(_id, *p++);
		}
		break;

	case 80:											/* loop */
		decode_sysex_bytes(p + 1, buf, len - 2);
		set_loop(read_word(buf),
						 read_word(buf + 2), read_word(buf + 4), read_word(buf + 6), read_word(buf + 8)
			);
		break;

	case 81:											/* end loop */
		clear_loop();
		break;

	case 96:											/* set instrument */
		part = get_part(p[0] & 0x0F);
		b = (p[1] & 0x0F) << 12 | (p[2] & 0x0F) << 8 | (p[4] & 0x0F) << 4 | (p[4] & 0x0F);
		if (part)
			part->set_instrument(b);
		break;

	default:
		debug(6, "unknown sysex %d", code);
	}
}

void Player::decode_sysex_bytes(byte *src, byte *dst, int len)
{
	while (len >= 0) {
		*dst++ = (src[0] << 4) | (src[1] & 0xF);
		src += 2;
		len -= 2;
	}
}

void Player::maybe_jump (byte cmd, uint track, uint beat, uint tick)
{
	/* is this the hook i'm waiting for? */
	if (cmd && _hook._jump != cmd)
		return;

	/* reset hook? */
	if (cmd != 0 && cmd < 0x80)
		_hook._jump = 0;

	jump (track, beat, tick);
}

void Player::maybe_set_transpose(byte *data)
{
	byte cmd;

	cmd = data[0];

	/* is this the hook i'm waiting for? */
	if (cmd && _hook._transpose != cmd)
		return;

	/* reset hook? */
	if (cmd != 0 && cmd < 0x80)
		_hook._transpose = 0;

	set_transpose(data[1], (int8)data[2]);
}

void Player::maybe_part_onoff(byte *data)
{
	byte cmd, *p;
	uint chan;
	Part *part;

	cmd = data[1];
	chan = data[0];

	p = &_hook._part_onoff[chan];

	/* is this the hook i'm waiting for? */
	if (cmd && *p != cmd)
		return;

	if (cmd != 0 && cmd < 0x80)
		*p = 0;

	part = get_part(chan);
	if (part)
		part->set_onoff(data[2] != 0);
}

void Player::maybe_set_volume(byte *data)
{
	byte cmd;
	byte *p;
	uint chan;
	Part *part;

	cmd = data[1];
	chan = data[0];

	p = &_hook._part_volume[chan];

	/* is this the hook i'm waiting for? */
	if (cmd && *p != cmd)
		return;

	/* reset hook? */
	if (cmd != 0 && cmd < 0x80)
		*p = 0;

	part = get_part(chan);
	if (part)
		part->set_vol(data[2]);
}

void Player::maybe_set_program(byte *data)
{
	byte cmd;
	byte *p;
	uint chan;
	Part *part;

	cmd = data[1];
	chan = data[0];

	/* is this the hook i'm waiting for? */
	p = &_hook._part_program[chan];

	if (cmd && *p != cmd)
		return;

	if (cmd != 0 && cmd < 0x80)
		*p = 0;

	part = get_part(chan);
	if (part)
		part->set_program(data[2]);
}

void Player::maybe_set_transpose_part(byte *data)
{
	byte cmd;
	byte *p;
	uint chan;

	cmd = data[1];
	chan = data[0];

	/* is this the hook i'm waiting for? */
	p = &_hook._part_transpose[chan];

	if (cmd && *p != cmd)
		return;

	/* reset hook? */
	if (cmd != 0 && cmd < 0x80)
		*p = 0;

	part_set_transpose(chan, data[2], (int8)data[3]);
}

int Player::set_transpose(byte relative, int b)
{
	Part *part;

	if (b > 24 || b < -24 || relative > 1)
		return -1;
	if (relative)
		b = transpose_clamp(_transpose + b, -7, 7);

	_transpose = b;

	for (part = _parts; part; part = part->_next) {
		part->set_transpose(part->_transpose);
	}

	return 0;
}

void Player::clear_active_notes()
{
	memset(_se->_active_notes, 0, sizeof(_se->_active_notes));
}

void Player::clear_active_note(int chan, byte note)
{
	_se->_active_notes[note] &= ~(1 << chan);
}

void Player::set_active_note(int chan, byte note)
{
	_se->_active_notes[note] |= (1 << chan);
}

void Player::part_set_transpose(uint8 chan, byte relative, int8 b)
{
	Part *part;

	if (b > 24 || b < -24)
		return;

	part = get_part(chan);
	if (!part)
		return;
	if (relative)
		b = transpose_clamp(b + part->_transpose, -7, 7);
	part->set_transpose(b);
}

void Player::key_on(uint8 chan, uint8 note, uint8 velocity)
{
	Part *part;

	part = get_part(chan);
	if (!part || !part->_on)
		return;

	part->key_on(note, velocity);
}

void Player::key_off(uint8 chan, uint8 note)
{
	Part *part;

	for (part = _parts; part; part = part->_next) {
		if (part->_chan == (byte)chan && part->_on)
			part->key_off(note);
	}
}

bool Player::jump(uint track, uint beat, uint tick)
{
	byte *mtrk, *cur_mtrk, *scanpos;
	uint32 topos, curpos, track_offs;

	if (!_active)
		return false;

	mtrk = _se->findTag(_song_index, "MTrk", track);
	if (!mtrk)
		return false;

	cur_mtrk = _se->findTag(_song_index, "MTrk", _track_index);
	if (!cur_mtrk)
		return false;

	_se->lock();

	if (beat == 0)
		beat = 1;

	topos = (beat - 1) * _ticks_per_beat + tick;

	if (track == _track_index && topos >= _cur_pos) {
		scanpos = _song_offset + mtrk;
		curpos = _next_pos;
	} else {
		scanpos = mtrk;
		curpos = get_delta_time(&scanpos);
	}

	while (curpos < topos) {
		skip_midi_cmd(&scanpos);
		if (!scanpos) {
			_se->unlock();
			return false;
		}
		curpos += get_delta_time(&scanpos);
	}

	track_offs = scanpos - mtrk;

	turn_off_pedals();

	find_sustaining_notes(cur_mtrk + _song_offset, mtrk + track_offs, curpos - topos);

	_beat_index = beat;
	_tick_index = tick;
	_cur_pos = topos;
	_next_pos = curpos;
	_timer_counter = 0;
	_song_offset = track_offs;
	if (track != _track_index) {
		_track_index = track;
		_loop_counter = 0;
	}
	_abort = true;
	_se->unlock();
	return true;
}

bool Player::set_loop(uint count, uint tobeat, uint totick, uint frombeat, uint fromtick)
{
	if (tobeat + 1 >= frombeat)
		return false;

	if (tobeat == 0)
		tobeat = 1;

	_loop_counter = 0;						/* because of possible interrupts */
	_loop_to_beat = tobeat;
	_loop_to_tick = totick;
	_loop_from_beat = frombeat;
	_loop_from_tick = fromtick;
	_loop_counter = count;

	return true;
}

void Player::clear_loop()
{
	_loop_counter = 0;
}

void Player::turn_off_pedals()
{
	Part *part;

	for (part = _parts; part; part = part->_next) {
		if (part->_pedal)
			part->set_pedal(false);
	}
}

void Player::find_sustaining_notes(byte *a, byte *b, uint32 l)
{
	uint32 pos;
	uint16 mask;
	uint16 *bitlist_ptr;
	SustainingNotes *sn, *next;
	IsNoteCmdData isnote;
	int j;
	uint num_active;
	uint max_off_pos;

	num_active = update_actives();

	/* pos contains number of ticks since current position */
	pos = _next_pos - _cur_pos;
	if ((int32)pos < 0)
		pos = 0;

	/* locate the positions where the notes are turned off.
	 * remember each note that was turned off
	 */
	while (num_active != 0) {
		/* is note off? */
		j = is_note_cmd(&a, &isnote);
		if (j == -1)
			break;
		if (j == 1) {
			mask = 1 << isnote.chan;
			bitlist_ptr = _se->_active_notes + isnote.note;
			if (*bitlist_ptr & mask) {
				*bitlist_ptr &= ~mask;
				num_active--;
				/* Get a node from the free list */
				if ((sn = _se->_sustain_notes_free) == NULL)
					return;
				_se->_sustain_notes_free = sn->next;

				/* Insert it in the beginning of the used list */
				sn->next = _se->_sustain_notes_used;
				_se->_sustain_notes_used = sn;
				sn->prev = NULL;
				if (sn->next)
					sn->next->prev = sn;

				sn->note = isnote.note;
				sn->chan = isnote.chan;
				sn->player = this;
				sn->off_pos = pos;
				sn->pos = 0;
				sn->counter = 0;
			}
		}
		pos += get_delta_time(&a);
	}

	/* find the maximum position where a note was turned off */
	max_off_pos = 0;
	for (sn = _se->_sustain_notes_used; sn; sn = sn->next) {
		_se->_active_notes[sn->note] |= (1 << sn->chan);
		if (sn->off_pos > max_off_pos) {
			max_off_pos = sn->off_pos;
		}
	}

	/* locate positions where notes are turned on */
	pos = l;
	while (pos < max_off_pos) {
		j = is_note_cmd(&b, &isnote);
		if (j == -1)
			break;
		if (j == 2) {
			mask = 1 << isnote.chan;
			bitlist_ptr = _se->_active_notes + isnote.note;

			if (*bitlist_ptr & mask) {
				sn = _se->_sustain_notes_used;
				while (sn) {
					next = sn->next;
					if (sn->note == isnote.note && sn->chan == isnote.chan && pos < sn->off_pos) {
						*bitlist_ptr &= ~mask;
						/* Unlink from the sustain list */
						if (next)
							next->prev = sn->prev;
						if (sn->prev)
							sn->prev->next = next;
						else
							_se->_sustain_notes_used = next;
						/* Insert into the free list */
						sn->next = _se->_sustain_notes_free;
						_se->_sustain_notes_free = sn;
					}
					sn = next;
				}
			}
		}
		pos += get_delta_time(&b);
	}

	/* Concatenate head and used list */
	if (!_se->_sustain_notes_head) {
		_se->_sustain_notes_head = _se->_sustain_notes_used;
		_se->_sustain_notes_used = NULL;
		return;
	}
	sn = _se->_sustain_notes_head;
	while (sn->next)
		sn = sn->next;
	sn->next = _se->_sustain_notes_used;
	_se->_sustain_notes_used = NULL;
	if (sn->next)
		sn->next->prev = sn;
}

Part *Player::get_part(uint8 chan)
{
	Part *part;

	part = _parts;
	while (part) {
		if (part->_chan == chan)
			return part;
		part = part->_next;
	}

	part = _se->allocate_part(_priority);
	if (!part) {
		warning("no parts available");
		return NULL;
	}

	part->_chan = chan;
	part->setup(this);

	return part;
}

uint Player::update_actives()
{
	Part *part;
	uint16 *active;
	int count = 0;

	clear_active_notes();
	active = _se->_active_notes;
	for (part = _parts; part; part = part->_next) {
		if (part->_mc)
			count += part->update_actives(active);
	}
	return count;
}

void Player::set_priority(int pri)
{
	Part *part;

	_priority = pri;
	for (part = _parts; part; part = part->_next) {
		part->set_pri(part->_pri);
	}
	_se->_driver->update_pris();
}

void Player::set_pan(int pan)
{
	Part *part;

	_pan = pan;
	for (part = _parts; part; part = part->_next) {
		part->set_pan(part->_pan);
	}
}

void Player::set_detune(int detune)
{
	Part *part;

	_detune = detune;
	for (part = _parts; part; part = part->_next) {
		part->set_detune(part->_detune);
	}
}

int Player::scan(uint totrack, uint tobeat, uint totick)
{
	byte *mtrk, *scanptr;
	uint32 curpos, topos;
	uint32 pos;

	assert(totrack >= 0 && tobeat >= 0 && totick >= 0);

	if (!_active)
		return -1;

	mtrk = _se->findTag(_song_index, "MTrk", totrack);
	if (!mtrk)
		return -1;

	_se->lock();
	if (tobeat == 0)
		tobeat++;

	turn_off_parts();
	clear_active_notes();
	scanptr = mtrk;
	curpos = get_delta_time(&scanptr);
	_scanning = true;

	topos = (tobeat - 1) * _ticks_per_beat + totick;

	while (curpos < topos) {
		scanptr = parse_midi(scanptr);
		if (!scanptr) {
			_scanning = false;
			_se->unlock();
			return -1;
		}
		curpos += get_delta_time(&scanptr);
	}
	pos = scanptr - mtrk;

	_scanning = false;
	_se->driver()->update_pris();
	play_active_notes();
	_beat_index = tobeat;
	_tick_index = totick;
	_cur_pos = topos;
	_next_pos = curpos;
	_timer_counter = 0;
	_song_offset = pos;
	if (_track_index != totrack) {
		_track_index = totrack;
		_loop_counter = 0;
	}
	_se->unlock();
	return 0;
}

void Player::turn_off_parts()
{
	Part *part;

	for (part = _parts; part; part = part->_next)
		part->off();
}

void Player::play_active_notes()
{
	int i, j;
	uint mask;

	for (i = 0; i != 128; i++) {
		mask = _se->_active_notes[i];
		for (j = 0; j != 16; j++, mask >>= 1) {
			if (mask & 1) {
				key_on(j, i, 80);
			}
		}
	}
}

int Player::set_vol(byte vol)
{
	Part *part;

	if (vol > 127)
		return -1;

	_volume = vol;
	_vol_eff = _se->get_channel_volume(_vol_chan) * (vol + 1) >> 7;

	for (part = _parts; part; part = part->_next) {
		part->set_vol(part->_vol);
	}

	return 0;
}

int Player::get_param(int param, byte chan)
{
	switch (param) {
	case 0:
		return (byte)_priority;
	case 1:
		return (byte)_volume;
	case 2:
		return (byte)_pan;
	case 3:
		return (byte)_transpose;
	case 4:
		return (byte)_detune;
	case 5:
		return _speed;
	case 6:
		return _track_index;
	case 7:
		return _beat_index;
	case 8:
		return _tick_index;
	case 9:
		return _loop_counter;
	case 10:
		return _loop_to_beat;
	case 11:
		return _loop_to_tick;
	case 12:
		return _loop_from_beat;
	case 13:
		return _loop_from_tick;
	case 14:
	case 15:
	case 16:
	case 17:
		return query_part_param(param, chan);
	case 18:
	case 19:
	case 20:
	case 21:
	case 22:
	case 23:
		return _hook.query_param(param, chan);
	default:
		return -1;
	}
}

int Player::query_part_param(int param, byte chan)
{
	Part *part;

	part = _parts;
	while (part) {
		if (part->_chan == chan) {
			switch (param) {
			case 14:
				return part->_on;
			case 15:
				return part->_vol;
			case 16:
				return part->_program;
			case 17:
				return part->_transpose;
			default:
				return -1;
			}
		}
		part = part->_next;
	}
	return 129;
}

void Player::sequencer_timer()
{
	byte *mtrk;
	uint32 counter;
	byte *song_ptr;

	counter = _timer_counter + _timer_speed;
	_timer_counter = counter & 0xFFFF;
	_cur_pos += counter >> 16;
	_tick_index += counter >> 16;

	if (_tick_index >= _ticks_per_beat) {
		_beat_index += _tick_index / _ticks_per_beat;
		_tick_index %= _ticks_per_beat;
	}
	if (_loop_counter && _beat_index >= _loop_from_beat && _tick_index >= _loop_from_tick) {
		_loop_counter--;
		jump(_track_index, _loop_to_beat, _loop_to_tick);
	}
	if (_next_pos <= _cur_pos) {
		mtrk = _se->findTag(_song_index, "MTrk", _track_index);
		if (!mtrk) {
			warning("Sound %d was unloaded while active", _song_index);
			clear();
		} else {
			song_ptr = mtrk + _song_offset;
			_abort = false;

			while (_next_pos <= _cur_pos) {
				song_ptr = parse_midi(song_ptr);
				if (!song_ptr || _abort)
					return;
				_next_pos += get_delta_time(&song_ptr);
			}
			_song_offset = song_ptr - mtrk;
		}
	}
}

/*******************************************************************/

enum {
	TYPE_PART = 1,
	TYPE_PLAYER = 2,
};

int IMuseInternal::saveReference(IMuseInternal *me, byte type, void *ref)
{
	switch (type) {
	case TYPE_PART:
		return (Part *)ref - me->_parts;
	case TYPE_PLAYER:
		return (Player *)ref - me->_players;
	default:
		error("saveReference: invalid type");
	}
}

void *IMuseInternal::loadReference(IMuseInternal *me, byte type, int ref)
{
	switch (type) {
	case TYPE_PART:
		return &me->_parts[ref];
	case TYPE_PLAYER:
		return &me->_players[ref];
	default:
		error("loadReference: invalid type");
	}
}

int IMuseInternal::save_or_load(Serializer *ser, Scumm *scumm)
{
	const SaveLoadEntry mainEntries[] = {
		MKLINE(IMuseInternal, _queue_end, sleUint8),
		MKLINE(IMuseInternal, _queue_pos, sleUint8),
		MKLINE(IMuseInternal, _queue_sound, sleUint16),
		MKLINE(IMuseInternal, _queue_adding, sleByte),
		MKLINE(IMuseInternal, _queue_marker, sleByte),
		MKLINE(IMuseInternal, _queue_cleared, sleByte),
		MKLINE(IMuseInternal, _master_volume, sleByte),
		MKLINE(IMuseInternal, _trigger_count, sleUint16),
		MKARRAY(IMuseInternal, _channel_volume[0], sleUint16, 8),
		MKARRAY(IMuseInternal, _volchan_table[0], sleUint16, 8),
		MKEND()
	};

	const SaveLoadEntry playerEntries[] = {
		MKREF(Player, _parts, TYPE_PART),
		MKLINE(Player, _active, sleByte),
		MKLINE(Player, _id, sleUint16),
		MKLINE(Player, _priority, sleByte),
		MKLINE(Player, _volume, sleByte),
		MKLINE(Player, _pan, sleInt8),
		MKLINE(Player, _transpose, sleByte),
		MKLINE(Player, _detune, sleInt8),
		MKLINE(Player, _vol_chan, sleUint16),
		MKLINE(Player, _vol_eff, sleByte),
		MKLINE(Player, _speed, sleByte),
		MKLINE(Player, _song_index, sleUint16),
		MKLINE(Player, _track_index, sleUint16),
		MKLINE(Player, _timer_counter, sleUint16),
		MKLINE(Player, _loop_to_beat, sleUint16),
		MKLINE(Player, _loop_from_beat, sleUint16),
		MKLINE(Player, _loop_counter, sleUint16),
		MKLINE(Player, _loop_to_tick, sleUint16),
		MKLINE(Player, _loop_from_tick, sleUint16),
		MKLINE(Player, _tempo, sleUint32),
		MKLINE(Player, _cur_pos, sleUint32),
		MKLINE(Player, _next_pos, sleUint32),
		MKLINE(Player, _song_offset, sleUint32),
		MKLINE(Player, _tick_index, sleUint16),
		MKLINE(Player, _beat_index, sleUint16),
		MKLINE(Player, _ticks_per_beat, sleUint16),
		MKLINE(Player, _hook._jump, sleByte),
		MKLINE(Player, _hook._transpose, sleByte),
		MKARRAY(Player, _hook._part_onoff[0], sleByte, 16),
		MKARRAY(Player, _hook._part_volume[0], sleByte, 16),
		MKARRAY(Player, _hook._part_program[0], sleByte, 16),
		MKARRAY(Player, _hook._part_transpose[0], sleByte, 16),
		MKEND()
	};

	const SaveLoadEntry volumeFaderEntries[] = {
		MKREF(VolumeFader, player, TYPE_PLAYER),
		MKLINE(VolumeFader, active, sleUint8),
		MKLINE(VolumeFader, curvol, sleUint8),
		MKLINE(VolumeFader, speed_lo_max, sleUint16),
		MKLINE(VolumeFader, num_steps, sleUint16),
		MKLINE(VolumeFader, speed_hi, sleInt8),
		MKLINE(VolumeFader, direction, sleInt8),
		MKLINE(VolumeFader, speed_lo, sleInt8),
		MKLINE(VolumeFader, speed_lo_counter, sleUint16),
		MKEND()
	};

	const SaveLoadEntry partEntries[] = {
		MKREF(Part, _next, TYPE_PART),
		MKREF(Part, _prev, TYPE_PART),
		MKREF(Part, _player, TYPE_PLAYER),
		MKLINE(Part, _pitchbend, sleInt16),
		MKLINE(Part, _pitchbend_factor, sleUint8),
		MKLINE(Part, _transpose, sleInt8),
		MKLINE(Part, _vol, sleUint8),
		MKLINE(Part, _detune, sleInt8),
		MKLINE(Part, _pan, sleInt8),
		MKLINE(Part, _on, sleUint8),
		MKLINE(Part, _modwheel, sleUint8),
		MKLINE(Part, _pedal, sleUint8),
		MKLINE(Part, _program, sleUint8),
		MKLINE(Part, _pri, sleUint8),
		MKLINE(Part, _chan, sleUint8),
		MKLINE(Part, _effect_level, sleUint8),
		MKLINE(Part, _chorus, sleUint8),
		MKLINE(Part, _percussion, sleUint8),
		MKLINE(Part, _bank, sleUint8),
		MKEND()
	};

	if (!ser->isSaving()) {
		stop_all_sounds();
	}
#ifdef _WIN32_WCE								// Don't break savegames made with andys' build
	if (!ser->isSaving() && ser->checkEOFLoadStream())
		return 0;
#endif

	ser->_ref_me = this;
	ser->_saveload_ref = ser->isSaving()? ((void *)&saveReference) : ((void *)&loadReference);

	ser->saveLoadEntries(this, mainEntries);
	ser->saveLoadArrayOf(_players, ARRAYSIZE(_players), sizeof(_players[0]), playerEntries);
	ser->saveLoadArrayOf(_parts, ARRAYSIZE(_parts), sizeof(_parts[0]), partEntries);
	ser->saveLoadArrayOf(_volume_fader, ARRAYSIZE(_volume_fader),
											 sizeof(_volume_fader[0]), volumeFaderEntries);

	if (!ser->isSaving()) {
		/* Load all sounds that we need */
		fix_players_after_load(scumm);
		init_sustaining_notes();
		_active_volume_faders = true;
		fix_parts_after_load();
		_driver->update_pris();
	}

	return 0;
}

#undef MKLINE
#undef MKEND

void IMuseInternal::fix_parts_after_load()
{
	Part *part;
	int i;

	for (i = ARRAYSIZE(_parts), part = _parts; i != 0; i--, part++) {
		if (part->_player)
			part->fix_after_load();
	}
}

/* Only call this routine from the main thread,
 * since it uses getResourceAddress */
void IMuseInternal::fix_players_after_load(Scumm *scumm)
{
	Player *player = _players;
	int i;

	for (i = ARRAYSIZE(_players); i != 0; i--, player++) {
		if (player->_active) {
			player->set_tempo(player->_tempo);
			scumm->getResourceAddress(rtSound, player->_id);
			player->_mt32emulate = isMT32(player->_id);
			player->_isGM = isGM(player->_id);
			if (scumm->_use_adlib) {
				// FIXME - This should make sure the right
				// instruments are loaded, but it does not
				// even try to move to the right position in
				// the track. Using scan() gives a marginally
				// better result, but not good enough.
				//
				// The correct fix is probably to store the
				// Adlib instruments, or information on where
				// to find them, in the savegame.
				player->jump(player->_track_index, 0, 0);
			}
		}
	}
}

void Part::set_detune(int8 detune)
{
	_detune_eff = clamp((_detune = detune) + _player->_detune, -128, 127);
	changed(IMuseDriver::pcMod);
}

void Part::set_pitchbend(int value)
{
	_pitchbend = value;
	changed(IMuseDriver::pcMod);
}

void Part::set_vol(uint8 vol)
{
	_vol_eff = ((_vol = vol) + 1) * _player->_vol_eff >> 7;
	changed(IMuseDriver::pcVolume);
}

void Part::set_pri(int8 pri)
{
	_pri_eff = clamp((_pri = pri) + _player->_priority, 0, 255);
	changed(IMuseDriver::pcPriority);
}

void Part::set_pan(int8 pan)
{
	_pan_eff = clamp((_pan = pan) + _player->_pan, -64, 63);
	changed(IMuseDriver::pcPan);
}

void Part::set_transpose(int8 transpose)
{
	_transpose_eff = transpose_clamp((_transpose = transpose) + _player->_transpose, -12, 12);
	changed(IMuseDriver::pcMod);
}

void Part::set_pedal(bool value)
{
	_pedal = value;
	changed(IMuseDriver::pcPedal);
}

void Part::set_modwheel(uint value)
{
	_modwheel = value;
	changed(IMuseDriver::pcModwheel);
}

void Part::set_chorus(uint chorus)
{
	_chorus = chorus;
	changed(IMuseDriver::pcChorus);
}

void Part::set_effect_level(uint level)
{
	_effect_level = level;
	changed(IMuseDriver::pcEffectLevel);
}

void Part::fix_after_load()
{
	set_transpose(_transpose);
	set_vol(_vol);
	set_detune(_detune);
	set_pri(_pri);
	set_pan(_pan);
}

void Part::set_pitchbend_factor(uint8 value)
{
	if (value > 12)
		return;
	set_pitchbend(0);
	_pitchbend_factor = value;
	changed (IMuseDriver::pcPitchBendFactor);
}

void Part::set_onoff(bool on)
{
	if (_on != on) {
		_on = on;
		if (!on)
			off();
		if (!_percussion)
			update_pris();
	}
}

void Part::set_instrument(Instrument * data)
{
	_drv->part_set_instrument(this, data);
}

void Part::key_on(byte note, byte velocity)
{
	_drv->part_key_on(this, note, velocity);
}

void Part::key_off(byte note)
{
	_drv->part_key_off(this, note);
}

void Part::init(IMuseDriver * driver)
{
	_drv = driver;
	_player = NULL;
	_next = NULL;
	_prev = NULL;
	_mc = NULL;
	memset(_actives, 0, sizeof (_actives));
}

void Part::setup(Player *player)
{
	_player = player;

	/* Insert first into player's list */
	_prev = NULL;
	_next = player->_parts;
	if (player->_parts)
		player->_parts->_prev = this;
	player->_parts = this;

	_percussion = (player->_isGM && _chan == 9); // true;
	_on = true;
	_pri_eff = player->_priority;
	_pri = 0;
	_vol = 127;
	_vol_eff = player->_vol_eff;
	_pan = clamp(player->_pan, -64, 63);
	_transpose_eff = player->_transpose;
	_transpose = 0;
	_detune = 0;
	_detune_eff = player->_detune;
	_pitchbend_factor = 2;
	_pitchbend = 0;
	_effect_level = 64;
	_program = player->_se->get_channel_program (_chan);
	_chorus = 0;
	_modwheel = 0;
	_bank = 0;
	_pedal = false;
	_mc = NULL;

	if (_program < 128)
		changed (IMuseDriver::pcAll);
}

void Part::uninit()
{
	if (!_player)
		return;
	off();

	/* unlink */
	if (_next)
		_next->_prev = _prev;
	if (_prev)
		_prev->_next = _next;
	else
		_player->_parts = _next;
	_player = NULL;
	_next = NULL;
	_prev = NULL;

	update_pris(); // In case another player couldn't allocate all its parts
}

void Part::off()
{
	_drv->part_off(this);
}

void Part::changed(uint16 what)
{
	_drv->part_changed(this, what);
}

void Part::set_param(byte param, int value)
{
	_drv->part_set_param(this, param, value);
}

void Part::update_pris()
{
	_drv->update_pris();
}

int Part::update_actives(uint16 *active)
{
	return _drv->part_update_active(this, active);
}

void Part::set_program(byte program)
{
	if (_program != program || _bank != 0) {
		_program = program;
		_bank = 0;
		changed(IMuseDriver::pcProgram);
	}
}

void Part::set_instrument(uint b)
{
	_bank = (byte)(b >> 8);
	_program = (byte)b;
	changed(IMuseDriver::pcProgram);
}


//********************************************
//***** ADLIB PART OF IMUSE STARTS HERE ******
//********************************************

/*
static byte lookup_table[64][32];
const byte volume_table[] = {
	0, 4, 7, 11,
	13, 16, 18, 20,
	22, 24, 26, 27,
	29, 30, 31, 33,
	34, 35, 36, 37,
	38, 39, 40, 41,
	42, 43, 44, 44,
	45, 46, 47, 47,
	48, 49, 49, 50,
	51, 51, 52, 53,
	53, 54, 54, 55,
	55, 56, 56, 57,
	57, 58, 58, 59,
	59, 60, 60, 60,
	61, 61, 62, 62,
	62, 63, 63, 63
};

int lookup_volume(int a, int b)
{
	if (b == 0)
		return 0;

	if (b == 31)
		return a;

	if (a < -63 || a > 63) {
		return b * (a + 1) >> 5;
	}

	if (b < 0) {
		if (a < 0) {
			return lookup_table[-a][-b];
		} else {
			return -lookup_table[a][-b];
		}
	} else {
		if (a < 0) {
			return -lookup_table[-a][b];
		} else {
			return lookup_table[a][b];
		}
	}
}

void create_lookup_table()
{
	int i, j;
	int sum;

	for (i = 0; i < 64; i++) {
		sum = i;
		for (j = 0; j < 32; j++) {
			lookup_table[i][j] = sum >> 5;
			sum += i;
		}
	}
	for (i = 0; i < 64; i++)
		lookup_table[i][0] = 0;
}

MidiChannelAdl *IMuseAdlib::allocate_midichan(byte pri)
{
	MidiChannelAdl *ac, *best = NULL;
	int i;

	for (i = 0; i < 9; i++) {
		if (++_midichan_index >= 9)
			_midichan_index = 0;
		ac = &_midi_channels[_midichan_index];
		if (!ac->_part)
			return ac;
		if (!ac->_next) {
			if (ac->_part->_pri_eff <= pri) {
				pri = ac->_part->_pri_eff;
				best = ac;
			}
		}
	}

	if (best)
		mc_off(best);
	else;													//debug(1, "Denying adlib channel request");
	return best;
}

void IMuseAdlib::premix_proc(void *param, int16 *buf, uint len)
{
	((IMuseAdlib *) param)->generate_samples(buf, len);
}

void IMuseAdlib::init(IMuseInternal *eng, OSystem *syst)
{
	int i;
	MidiChannelAdl *mc;

	_se = eng;

	for (i = 0, mc = _midi_channels; i != ARRAYSIZE(_midi_channels); i++, mc++) {
		mc->_channel = i;
		mc->_s11a.s10 = &mc->_s10b;
		mc->_s11b.s10 = &mc->_s10a;
	}

	_adlib_reg_cache = (byte *)calloc(256, 1);

	_opl = OPLCreate(OPL_TYPE_YM3812, 3579545, syst->property(OSystem::PROP_GET_SAMPLE_RATE, 0));

	adlib_write(1, 0x20);
	adlib_write(8, 0x40);
	adlib_write(0xBD, 0x00);
	create_lookup_table();

	_mixer->setupPremix(this, premix_proc);
}

void IMuseAdlib::adlib_write(byte port, byte value)
{
	if (_adlib_reg_cache[port] == value)
		return;
	_adlib_reg_cache[port] = value;

	OPLWriteReg(_opl, port, value);
}

void IMuseAdlib::adlib_key_off(int chan)
{
	byte port = chan + 0xB0;
	adlib_write(port, adlib_read(port) & ~0x20);
}

struct AdlibSetParams {
	byte a, b, c, d;
};

static const byte channel_mappings[9] = {
	0, 1, 2, 8,
	9, 10, 16, 17,
	18
};

static const byte channel_mappings_2[9] = {
	3, 4, 5, 11,
	12, 13, 19, 20,
	21
};

static const AdlibSetParams adlib_setparam_table[] = {
	{0x40, 0, 63, 63}, // level
	{0xE0, 2, 0, 0}, // unused
	{0x40, 6, 192, 0}, // level key scaling
	{0x20, 0, 15, 0}, // modulator frequency multiple
	{0x60, 4, 240, 15}, // attack rate
	{0x60, 0, 15, 15}, // decay rate
	{0x80, 4, 240, 15}, // sustain level
	{0x80, 0, 15, 15}, // release rate
	{0xE0, 0, 3, 0}, // waveform select
	{0x20, 7, 128, 0}, // amp mod
	{0x20, 6, 64, 0}, // vib
	{0x20, 5, 32, 0}, // eg typ
	{0x20, 4, 16, 0}, // ksr
	{0xC0, 0, 1, 0}, // decay alg
	{0xC0, 1, 14, 0} // feedback
};

void IMuseAdlib::adlib_set_param(int channel, byte param, int value)
{
	const AdlibSetParams *as;
	byte port;

	assert(channel >= 0 && channel < 9);

	if (param <= 12) {
		port = channel_mappings_2[channel];
	} else if (param <= 25) {
		param -= 13;
		port = channel_mappings[channel];
	} else if (param <= 27) {
		param -= 13;
		port = channel;
	} else if (param == 28 || param == 29) {
		if (param == 28)
			value -= 15;
		else
			value -= 383;
		value <<= 4;
		channel_table_2[channel] = value;
		adlib_playnote(channel, curnote_table[channel] + value);
		return;
	} else {
		return;
	}

	as = &adlib_setparam_table[param];
	if (as->d)
		value = as->d - value;
	port += as->a;
	adlib_write(port, (adlib_read(port) & ~as->c) | (((byte)value) << as->b));
}

static const byte octave_numbers[] = {
	0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 1, 1, 1, 1,
	1, 1, 1, 1, 1, 1, 1, 1,
	2, 2, 2, 2, 2, 2, 2, 2,
	2, 2, 2, 2, 3, 3, 3, 3,
	3, 3, 3, 3, 3, 3, 3, 3,
	4, 4, 4, 4, 4, 4, 4, 4,
	4, 4, 4, 4, 5, 5, 5, 5,
	5, 5, 5, 5, 5, 5, 5, 5,
	6, 6, 6, 6, 6, 6, 6, 6,
	6, 6, 6, 6, 7, 7, 7, 7,
	7, 7, 7, 7, 7, 7, 7, 7,
	7, 7, 7, 7, 7, 7, 7, 7,
	7, 7, 7, 7, 7, 7, 7, 7,
	7, 7, 7, 7, 7, 7, 7, 7,
	7, 7, 7, 7, 7, 7, 7, 7
};

static const byte note_numbers[] = {
	3, 4, 5, 6, 7, 8, 9, 10,
	11, 12, 13, 14, 3, 4, 5, 6,
	7, 8, 9, 10, 11, 12, 13, 14,
	3, 4, 5, 6, 7, 8, 9, 10,
	11, 12, 13, 14, 3, 4, 5, 6,
	7, 8, 9, 10, 11, 12, 13, 14,
	3, 4, 5, 6, 7, 8, 9, 10,
	11, 12, 13, 14, 3, 4, 5, 6,
	7, 8, 9, 10, 11, 12, 13, 14,
	3, 4, 5, 6, 7, 8, 9, 10,
	11, 12, 13, 14, 3, 4, 5, 6,
	7, 8, 9, 10, 11, 12, 13, 14,
	3, 4, 5, 6, 7, 8, 9, 10,
	11, 12, 13, 14, 3, 4, 5, 6,
	7, 8, 9, 10, 11, 12, 13, 14,
	3, 4, 5, 6, 7, 8, 9, 10
};

static const byte note_to_f_num[] = {
	90, 91, 92, 92, 93, 94, 94, 95,
	96, 96, 97, 98, 98, 99, 100, 101,
	101, 102, 103, 104, 104, 105, 106, 107,
	107, 108, 109, 110, 111, 111, 112, 113,
	114, 115, 115, 116, 117, 118, 119, 120,
	121, 121, 122, 123, 124, 125, 126, 127,
	128, 129, 130, 131, 132, 132, 133, 134,
	135, 136, 137, 138, 139, 140, 141, 142,
	143, 145, 146, 147, 148, 149, 150, 151,
	152, 153, 154, 155, 157, 158, 159, 160,
	161, 162, 163, 165, 166, 167, 168, 169,
	171, 172, 173, 174, 176, 177, 178, 180,
	181, 182, 184, 185, 186, 188, 189, 190,
	192, 193, 194, 196, 197, 199, 200, 202,
	203, 205, 206, 208, 209, 211, 212, 214,
	215, 217, 218, 220, 222, 223, 225, 226,
	228, 230, 231, 233, 235, 236, 238, 240,
	242, 243, 245, 247, 249, 251, 252, 254,
};

void IMuseAdlib::adlib_playnote(int channel, int note)
{
	byte old, oct, notex;
	int note2;
	int i;

	note2 = (note >> 7) - 4;

	oct = octave_numbers[note2] << 2;
	notex = note_numbers[note2];

	old = adlib_read(channel + 0xB0);
	if (old & 0x20) {
		old &= ~0x20;
		if (oct > old) {
			if (notex < 6) {
				notex += 12;
				oct -= 4;
			}
		} else if (oct < old) {
			if (notex > 11) {
				notex -= 12;
				oct += 4;
			}
		}
	}

	i = (notex << 3) + ((note >> 4) & 0x7);
	adlib_write(channel + 0xA0, note_to_f_num[i]);
	adlib_write(channel + 0xB0, oct | 0x20);
}

void IMuseAdlib::adlib_note_on(int chan, byte note, int mod)
{
	int code;
	assert(chan >= 0 && chan < 9);
	code = (note << 7) + mod;
	curnote_table[chan] = code;
	adlib_playnote(chan, channel_table_2[chan] + code);
}

void IMuseAdlib::adlib_note_on_ex(int chan, byte note, int mod)
{
	int code;
	assert(chan >= 0 && chan < 9);
	code = (note << 7) + mod;
	curnote_table[chan] = code;
	channel_table_2[chan] = 0;
	adlib_playnote(chan, code);
}

void IMuseAdlib::adlib_key_onoff(int channel)
{
	byte val;
	byte port = channel + 0xB0;
	assert(channel >= 0 && channel < 9);

	val = adlib_read(port);
	adlib_write(port, val & ~0x20);
	adlib_write(port, val | 0x20);
}

void IMuseAdlib::adlib_setup_channel(int chan, Instrument * instr, byte vol_1, byte vol_2)
{
	byte port;

	assert(chan >= 0 && chan < 9);

	port = channel_mappings[chan];
	adlib_write(port + 0x20, instr->flags_1);

        if (!(g_scumm->_features & GF_SMALL_HEADER) || (instr->feedback & 1))
		adlib_write(port + 0x40, (instr->oplvl_1 | 0x3F) - vol_1 );
	else
		adlib_write(port + 0x40, instr->oplvl_1);

	adlib_write(port + 0x60, 0xff & (~instr->atdec_1));
	adlib_write(port + 0x80, 0xff & (~instr->sustrel_1));
	adlib_write(port + 0xE0, instr->waveform_1);

	port = channel_mappings_2[chan];
	adlib_write(port + 0x20, instr->flags_2);
	adlib_write(port + 0x40, (instr->oplvl_2 | 0x3F) - vol_2 );
	adlib_write(port + 0x60, 0xff & (~instr->atdec_2));
	adlib_write(port + 0x80, 0xff & (~instr->sustrel_2));
	adlib_write(port + 0xE0, instr->waveform_2);

	adlib_write((byte)chan + 0xC0, instr->feedback);
}

int IMuseAdlib::adlib_read_param(int chan, byte param)
{
	const AdlibSetParams *as;
	byte val;
	byte port;

	assert(chan >= 0 && chan < 9);

	if (param <= 12) {
		port = channel_mappings_2[chan];
	} else if (param <= 25) {
		param -= 13;
		port = channel_mappings[chan];
	} else if (param <= 27) {
		param -= 13;
		port = chan;
	} else if (param == 28) {
		return 0xF;
	} else if (param == 29) {
		return 0x17F;
	} else {
		return 0;
	}

	as = &adlib_setparam_table[param];
	val = adlib_read(port + as->a);
	val &= as->c;
	val >>= as->b;
	if (as->d)
		val = as->d - val;

	return val;
}

void IMuseAdlib::generate_samples(int16 *data, int len)
{
	int step;

	if (!_opl) {
		memset(data, 0, len * sizeof(int16));
		return;
	}

	do {
		step = len;
		if (step > _next_tick)
			step = _next_tick;
		YM3812UpdateOne(_opl, data, step);

		if (!(_next_tick -= step)) {
			_se->on_timer();
			reset_tick();
		}
		data += step;
	} while (len -= step);
}


void IMuseAdlib::reset_tick()
{
	_next_tick = 88;
}

void IMuseAdlib::on_timer()
{
	MidiChannelAdl *mc;
	int i;

	_adlib_timer_counter += 0xD69;
	while (_adlib_timer_counter >= 0x411B) {
		_adlib_timer_counter -= 0x411B;
		mc = _midi_channels;
		for (i = 0; i != ARRAYSIZE(_midi_channels); i++, mc++) {
			if (!mc->_part)
				continue;
			if (mc->_duration && (mc->_duration -= 0x11) <= 0) {
				mc_off(mc);
				return;
			}
			if (mc->_s10a.active) {
				mc_inc_stuff(mc, &mc->_s10a, &mc->_s11a);
			}
			if (mc->_s10b.active) {
				mc_inc_stuff(mc, &mc->_s10b, &mc->_s11b);
			}
		}
	}
}

const byte param_table_1[16] = {
	29, 28, 27, 0,
	3, 4, 7, 8,
	13, 16, 17, 20,
	21, 30, 31, 0
};

const uint16 param_table_2[16] = {
	0x2FF, 0x1F, 0x7, 0x3F,
	0x0F, 0x0F, 0x0F, 0x3,
	0x3F, 0x0F, 0x0F, 0x0F,
	0x3, 0x3E, 0x1F, 0
};

static const uint16 num_steps_table[] = {
	1, 2, 4, 5,
	6, 7, 8, 9,
	10, 12, 14, 16,
	18, 21, 24, 30,
	36, 50, 64, 82,
	100, 136, 160, 192,
	240, 276, 340, 460,
	600, 860, 1200, 1600
};

int IMuseAdlib::random_nr(int a)
{
	static byte _rand_seed = 1;
	if (_rand_seed & 1) {
		_rand_seed >>= 1;
		_rand_seed ^= 0xB8;
	} else {
		_rand_seed >>= 1;
	}
	return _rand_seed * a >> 8;
}

void IMuseAdlib::struct10_setup(Struct10 * s10)
{
	int b, c, d, e, f, g, h;
	byte t;

	b = s10->unk3;
	f = s10->active - 1;

	t = s10->table_a[f];
	e = num_steps_table[lookup_table[t & 0x7F][b]];
	if (t & 0x80) {
		e = random_nr(e);
	}
	if (e == 0)
		e++;

	s10->num_steps = s10->speed_lo_max = e;

	if (f != 2) {
		c = s10->param;
		g = s10->start_value;
		t = s10->table_b[f];
		d = lookup_volume(c, (t & 0x7F) - 31);
		if (t & 0x80) {
			d = random_nr(d);
		}
		if (d + g > c) {
			h = c - g;
		} else {
			h = d;
			if (d + g < 0)
				h = -g;
		}
		h -= s10->cur_val;
	} else {
		h = 0;
	}

	s10->speed_hi = h / e;
	if (h < 0) {
		h = -h;
		s10->direction = -1;
	} else {
		s10->direction = 1;
	}

	s10->speed_lo = h % e;
	s10->speed_lo_counter = 0;
}

byte IMuseAdlib::struct10_ontimer(Struct10 * s10, Struct11 * s11)
{
	byte result = 0;
	int i;

	if (s10->count && (s10->count -= 17) <= 0) {
		s10->active = 0;
		return 0;
	}

	i = s10->cur_val + s10->speed_hi;
	s10->speed_lo_counter += s10->speed_lo;
	if (s10->speed_lo_counter >= s10->speed_lo_max) {
		s10->speed_lo_counter -= s10->speed_lo_max;
		i += s10->direction;
	}
	if (s10->cur_val != i || s10->modwheel != s10->modwheel_last) {
		s10->cur_val = i;
		s10->modwheel_last = s10->modwheel;
		i = lookup_volume(i, s10->modwheel_last);
		if (i != s11->modify_val) {
			s11->modify_val = i;
			result = 1;
		}
	}

	if (!--s10->num_steps) {
		s10->active++;
		if (s10->active > 4) {
			if (s10->loop) {
				s10->active = 1;
				result |= 2;
				struct10_setup(s10);
			} else {
				s10->active = 0;
			}
		} else {
			struct10_setup(s10);
		}
	}

	return result;
}

void IMuseAdlib::struct10_init(Struct10 * s10, InstrumentExtra * ie)
{
	s10->active = 1;
	s10->cur_val = 0;
	s10->modwheel_last = 31;
	s10->count = ie->a;
	if (s10->count)
		s10->count *= 63;
	s10->table_a[0] = ie->b;
	s10->table_a[1] = ie->d;
	s10->table_a[2] = ie->f;
	s10->table_a[3] = ie->g;

	s10->table_b[0] = ie->c;
	s10->table_b[1] = ie->e;
	s10->table_b[2] = 0;
	s10->table_b[3] = ie->h;

	struct10_setup(s10);
}

void IMuseAdlib::mc_init_stuff(MidiChannelAdl *mc, Struct10 * s10,
															 Struct11 * s11, byte flags, InstrumentExtra * ie)
{
	Part *part = mc->_part;

	s11->modify_val = 0;
	s11->flag0x40 = flags & 0x40;
	s10->loop = flags & 0x20;
	s11->flag0x10 = flags & 0x10;
	s11->param = param_table_1[flags & 0xF];
	s10->param = param_table_2[flags & 0xF];
	s10->unk3 = 31;
	if (s11->flag0x40) {
		s10->modwheel = part->_modwheel >> 2;
	} else {
		s10->modwheel = 31;
	}

	switch (s11->param) {
	case 0:
		s10->start_value = mc->_vol_2;
		break;
	case 13:
		s10->start_value = mc->_vol_1;
		break;
	case 30:
		s10->start_value = 31;
		s11->s10->modwheel = 0;
		break;
	case 31:
		s10->start_value = 0;
		s11->s10->unk3 = 0;
		break;
	default:
		s10->start_value = ((IMuseAdlib *) part->_drv)->adlib_read_param(mc->_channel, s11->param);
	}

	struct10_init(s10, ie);
}

void IMuseAdlib::mc_inc_stuff(MidiChannelAdl *mc, Struct10 * s10, Struct11 * s11)
{
	byte code;
	Part *part = mc->_part;

	code = struct10_ontimer(s10, s11);

	if (code & 1) {
		switch (s11->param) {
		case 0:
			mc->_vol_2 = s10->start_value + s11->modify_val;
			((IMuseAdlib *) part->_drv)->adlib_set_param(mc->_channel, 0,
																									 volume_table[lookup_table[mc->_vol_2]
																																[part->_vol_eff >> 2]]);
			break;
		case 13:
			mc->_vol_1 = s10->start_value + s11->modify_val;
			if (mc->_twochan) {
				((IMuseAdlib *) part->_drv)->adlib_set_param(mc->_channel, 13,
																										 volume_table[lookup_table[mc->_vol_1]
																																	[part->_vol_eff >> 2]]);
			} else {
				((IMuseAdlib *) part->_drv)->adlib_set_param(mc->_channel, 13, mc->_vol_1);
			}
			break;
		case 30:
			s11->s10->modwheel = (char)s11->modify_val;
			break;
		case 31:
			s11->s10->unk3 = (char)s11->modify_val;
			break;
		default:
			((IMuseAdlib *) part->_drv)->adlib_set_param(mc->_channel, s11->param,
																									 s10->start_value + s11->modify_val);
			break;
		}
	}

	if (code & 2 && s11->flag0x10)
		((IMuseAdlib *) part->_drv)->adlib_key_onoff(mc->_channel);
}

static byte map_gm_to_fm [128][30] = {
// DERIVED FROM DAY OF THE TENTACLE
{ 0x2F, 0x0B, 0x08, 0x78, 0x16, 0x24, 0x22, 0x0B, 0x9A, 0x34, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x2F, 0x0B, 0x08, 0x78, 0x16, 0x24, 0x22, 0x0B, 0x9A, 0x34, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Extrapolated
{ 0x84, 0x40, 0x3B, 0x5A, 0x63, 0x81, 0x00, 0x3B, 0x5A, 0x7F, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x2F, 0x0B, 0x08, 0x78, 0x16, 0x24, 0x22, 0x0B, 0x9A, 0x34, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Extrapolated
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x84, 0x40, 0x3B, 0x5A, 0x63, 0x81, 0x00, 0x3B, 0x5A, 0x7F, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x85, 0x80, 0x05, 0xEA, 0x3D, 0x84, 0x18, 0x3C, 0xAA, 0x7C, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0xE2, 0x00, 0x6C, 0x77, 0x7D, 0xE4, 0x40, 0x7D, 0xA7, 0x66, 0x07, 0xA1, 0x00, 0x02, 0x1E, 0x01, 0x20, 0x01, 0x01, 0x1F, 0xAC, 0x00, 0x04, 0x24, 0x02, 0x21, 0x02, 0x02, 0x21, 0x00 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0xC9, 0x40, 0x3A, 0x78, 0x5E, 0xC2, 0x00, 0x4D, 0x9A, 0x7C, 0x00, 0xA1, 0xA0, 0x08, 0x1F, 0x05, 0x1E, 0x02, 0x05, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x28, 0x1D, 0x19, 0x68, 0x02, 0x22, 0x35, 0x09, 0x08, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Extrapolated
{ 0x28, 0x1D, 0x19, 0x68, 0x02, 0x22, 0x35, 0x09, 0x08, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0xC6, 0x40, 0x3B, 0x78, 0x5E, 0xC2, 0x00, 0x4D, 0x9A, 0x7C, 0x00, 0xA1, 0xA0, 0x08, 0x1F, 0x05, 0x1E, 0x02, 0x05, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Extrapolated
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0xE2, 0x00, 0x6C, 0x77, 0x7D, 0xE4, 0x40, 0x7D, 0xA7, 0x66, 0x07, 0xA1, 0x00, 0x02, 0x1E, 0x01, 0x20, 0x01, 0x01, 0x1F, 0xAC, 0x00, 0x04, 0x24, 0x02, 0x21, 0x02, 0x02, 0x21, 0x00 },
{ 0xE2, 0x28, 0x38, 0xE8, 0x02, 0xE6, 0x33, 0x0B, 0xF9, 0x00, 0x08, 0xA1, 0x00, 0x02, 0x1E, 0x02, 0x20, 0x00, 0x02, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Extrapolated
{ 0xE2, 0x28, 0x38, 0xE8, 0x02, 0xE6, 0x33, 0x0B, 0xF9, 0x00, 0x08, 0xA1, 0x00, 0x02, 0x1E, 0x02, 0x20, 0x00, 0x02, 0x1E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0xE2, 0x00, 0x6C, 0x77, 0x7D, 0xE4, 0x40, 0x7D, 0xA7, 0x66, 0x07, 0xA1, 0x00, 0x02, 0x1E, 0x01, 0x20, 0x01, 0x01, 0x1F, 0xAC, 0x00, 0x04, 0x24, 0x02, 0x21, 0x02, 0x02, 0x21, 0x00 },
{ 0x85, 0x80, 0x05, 0xEA, 0x3D, 0x84, 0x18, 0x3C, 0xAA, 0x7C, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Extrapolated
{ 0x85, 0x80, 0x05, 0xEA, 0x3D, 0x84, 0x18, 0x3C, 0xAA, 0x7C, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Extrapolated
{ 0x85, 0x80, 0x05, 0xEA, 0x3D, 0x84, 0x18, 0x3C, 0xAA, 0x7C, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0xC6, 0x00, 0x2E, 0xC7, 0x59, 0xC2, 0x06, 0x0E, 0xA7, 0x7D, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Extrapolated
{ 0xC6, 0x00, 0x2E, 0xC7, 0x59, 0xC2, 0x06, 0x0E, 0xA7, 0x7D, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Extrapolated
{ 0xC6, 0x00, 0x2E, 0xC7, 0x59, 0xC2, 0x06, 0x0E, 0xA7, 0x7D, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0xC6, 0x00, 0x2E, 0xC7, 0x59, 0xC2, 0x06, 0x0E, 0xA7, 0x7D, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x84, 0x40, 0x3B, 0x5A, 0x63, 0x81, 0x00, 0x3B, 0x5A, 0x7F, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0xC6, 0x00, 0x2E, 0xC7, 0x59, 0xC2, 0x06, 0x0E, 0xA7, 0x7D, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x31, 0x0C, 0x2D, 0xD7, 0x40, 0x62, 0x18, 0x2E, 0xB8, 0x7C, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x00, 0x01, 0x1C, 0x00, 0x1F, 0x00, 0x00, 0x1F, 0x00 },
{ 0x22, 0x19, 0x79, 0x67, 0x00, 0x22, 0x3F, 0x2A, 0xC6, 0x02, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x31, 0x0C, 0x2D, 0xD7, 0x40, 0x62, 0x18, 0x2E, 0xB8, 0x7C, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x00, 0x01, 0x1C, 0x00, 0x1F, 0x00, 0x00, 0x1F, 0x00 },
{ 0x31, 0x0C, 0x2D, 0xD7, 0x40, 0x62, 0x18, 0x2E, 0xB8, 0x7C, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x00, 0x01, 0x1C, 0x00, 0x1F, 0x00, 0x00, 0x1F, 0x00 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x31, 0x0C, 0x2D, 0xD7, 0x40, 0x62, 0x18, 0x2E, 0xB8, 0x7C, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x00, 0x01, 0x1C, 0x00, 0x1F, 0x00, 0x00, 0x1F, 0x00 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0xE2, 0x15, 0x7B, 0xB5, 0x02, 0xE1, 0x33, 0xAF, 0xF4, 0x36, 0x08, 0xA1, 0x00, 0x04, 0x1E, 0x04, 0x1F, 0x00, 0x04, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0xC6, 0x00, 0x2E, 0xC7, 0x59, 0xC2, 0x06, 0x0E, 0xA7, 0x7D, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0xF4, 0x40, 0x9F, 0xFA, 0x61, 0xE2, 0x13, 0x7F, 0xFA, 0x7D, 0x02, 0x21, 0x00, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x00, 0x1F, 0x01, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x35, 0x00 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x02, 0x00, 0x67, 0xAA, 0x65, 0x02, 0x64, 0x28, 0xF9, 0x7C, 0x08, 0x81, 0x00, 0x04, 0x1D, 0x00, 0x1F, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x02, 0x40, 0x04, 0x9A, 0x55, 0xC2, 0x4B, 0x2B, 0xCB, 0x7C, 0x06, 0x41, 0x00, 0x00, 0x20, 0x06, 0x1C, 0x00, 0x00, 0x1C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x02, 0x0C, 0x03, 0x6A, 0x7D, 0x02, 0x00, 0x23, 0xEA, 0x7C, 0x02, 0x81, 0x00, 0x02, 0x20, 0x01, 0x1F, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0xF4, 0x40, 0x9F, 0xFA, 0x61, 0xE2, 0x13, 0x7F, 0xFA, 0x7D, 0x02, 0x21, 0x00, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x00, 0x1F, 0x01, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x35, 0x00 },
{ 0xF4, 0x40, 0x9F, 0xFA, 0x61, 0xE2, 0x13, 0x7F, 0xFA, 0x7D, 0x02, 0x21, 0x00, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x00, 0x1F, 0x01, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x35, 0x00 },
{ 0xF4, 0x40, 0x9F, 0xFA, 0x61, 0xE2, 0x13, 0x7F, 0xFA, 0x7D, 0x02, 0x21, 0x00, 0x00, 0x1F, 0x00, 0x1F, 0x00, 0x00, 0x1F, 0x01, 0x00, 0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x35, 0x00 },
{ 0x02, 0x00, 0x67, 0xAA, 0x65, 0x02, 0x64, 0x28, 0xF9, 0x7C, 0x08, 0x81, 0x00, 0x04, 0x1D, 0x00, 0x1F, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0xE1, 0x00, 0xCE, 0xD9, 0x4E, 0xE2, 0x00, 0x8F, 0x99, 0x65, 0x0E, 0x01, 0x00, 0x01, 0x1F, 0x00, 0x1E, 0x01, 0x01, 0x20, 0x01, 0x00, 0x00, 0x1F, 0x06, 0x1E, 0x00, 0x06, 0x1F, 0x00 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0xE2, 0x00, 0xCE, 0xD9, 0x4C, 0xE2, 0x00, 0x8F, 0x99, 0x64, 0x0E, 0x81, 0x10, 0x00, 0x1E, 0x05, 0x1F, 0x12, 0x00, 0x1F, 0x01, 0x00, 0x00, 0x1F, 0x06, 0x1E, 0x00, 0x06, 0x1F, 0x00 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0xB2, 0x25, 0xAD, 0xE9, 0x00, 0x62, 0x00, 0x8F, 0xC8, 0x7C, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0xF2, 0x00, 0xAF, 0xFA, 0x5C, 0xF2, 0x56, 0x9F, 0xEA, 0x7C, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0xF2, 0x00, 0xAF, 0xFA, 0x5C, 0xF2, 0x56, 0x9F, 0xEA, 0x7C, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0xB2, 0x25, 0xAD, 0xE9, 0x00, 0x62, 0x00, 0x8F, 0xC8, 0x7C, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0xE2, 0x02, 0x9F, 0xB8, 0x48, 0x22, 0x89, 0x9F, 0xE8, 0x7C, 0x00, 0x81, 0x00, 0x01, 0x1E, 0x00, 0x1F, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0xE4, 0x28, 0x7E, 0xF8, 0x01, 0xE2, 0x23, 0x8E, 0xE8, 0x7D, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0xE4, 0x28, 0x7E, 0xF8, 0x01, 0xE2, 0x23, 0x8E, 0xE8, 0x7D, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x31, 0x0C, 0x2D, 0xD7, 0x40, 0x62, 0x18, 0x2E, 0xB8, 0x7C, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x00, 0x01, 0x1C, 0x00, 0x1F, 0x00, 0x00, 0x1F, 0x00 },
{ 0x22, 0x10, 0x7E, 0xD8, 0x35, 0x2A, 0x2E, 0x8E, 0xD8, 0x7C, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0xE4, 0x28, 0x7E, 0xF8, 0x01, 0xE2, 0x23, 0x8E, 0xE8, 0x7D, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x22, 0x10, 0x7E, 0xD8, 0x35, 0x2A, 0x2E, 0x8E, 0xD8, 0x7C, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0xE4, 0x08, 0x7E, 0x99, 0x28, 0xE6, 0x16, 0x80, 0xF8, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0xE4, 0x23, 0x8F, 0xF9, 0x7C, 0xE2, 0x18, 0x9F, 0x88, 0x7C, 0x01, 0x01, 0x04, 0x00, 0x1E, 0x00, 0x1F, 0x06, 0x05, 0x1F, 0x03, 0x29, 0x01, 0x1F, 0x02, 0x21, 0x01, 0x02, 0x1F, 0x00 },
{ 0xE4, 0x23, 0x8F, 0xF9, 0x7C, 0xE2, 0x18, 0x9F, 0x88, 0x7C, 0x01, 0x01, 0x04, 0x00, 0x1E, 0x00, 0x1F, 0x06, 0x05, 0x1F, 0x03, 0x29, 0x01, 0x1F, 0x02, 0x21, 0x01, 0x02, 0x1F, 0x00 },
{ 0xE4, 0x23, 0x8F, 0xF9, 0x7C, 0xE2, 0x18, 0x9F, 0x88, 0x7C, 0x01, 0x01, 0x04, 0x00, 0x1E, 0x00, 0x1F, 0x06, 0x05, 0x1F, 0x03, 0x29, 0x01, 0x1F, 0x02, 0x21, 0x01, 0x02, 0x1F, 0x00 },
{ 0x2A, 0x1E, 0x98, 0xA9, 0x00, 0x62, 0x00, 0x9F, 0xB9, 0x7C, 0x00, 0x01, 0x00, 0x01, 0x1E, 0x00, 0x1F, 0x01, 0x01, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x2A, 0x1E, 0x98, 0xA9, 0x00, 0x62, 0x00, 0x9F, 0xB9, 0x7C, 0x00, 0x01, 0x00, 0x01, 0x1E, 0x00, 0x1F, 0x01, 0x01, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x62, 0xA8, 0x9D, 0x84, 0x44, 0x62, 0x23, 0x7F, 0xD5, 0x4C, 0x03, 0xA1, 0x00, 0x01, 0x1E, 0x02, 0x21, 0x01, 0x01, 0x20, 0xA8, 0x00, 0x01, 0x24, 0x06, 0x20, 0x04, 0x03, 0x24, 0x00 },
{ 0xE4, 0x28, 0x7E, 0xF8, 0x01, 0xE2, 0x23, 0x8E, 0xE8, 0x7D, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0xE4, 0x08, 0x7E, 0x99, 0x28, 0xE6, 0x16, 0x80, 0xF8, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0xE4, 0x28, 0x7E, 0xF8, 0x01, 0xE2, 0x23, 0x8E, 0xE8, 0x7D, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x22, 0x10, 0x7E, 0xD8, 0x35, 0x2A, 0x2E, 0x8E, 0xD8, 0x7C, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0xE4, 0x07, 0x05, 0xAA, 0x7C, 0xE2, 0x50, 0xBE, 0xC8, 0x7D, 0x07, 0x01, 0x00, 0x03, 0x1E, 0x01, 0x1E, 0x00, 0x00, 0x1E, 0xA8, 0x00, 0x01, 0x20, 0x06, 0x23, 0x04, 0x03, 0x20, 0x00 },
{ 0x85, 0x80, 0x05, 0xEA, 0x3D, 0x84, 0x18, 0x3C, 0xAA, 0x7C, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0xB2, 0x25, 0xAD, 0xE9, 0x00, 0x62, 0x00, 0x8F, 0xC8, 0x7C, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0xF2, 0x00, 0xAF, 0xFA, 0x5C, 0xF2, 0x56, 0x9F, 0xEA, 0x7C, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0xE2, 0x02, 0x9F, 0xB8, 0x48, 0x22, 0x89, 0x9F, 0xE8, 0x7C, 0x00, 0x81, 0x00, 0x01, 0x1E, 0x00, 0x1F, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0xB2, 0x25, 0xAD, 0xE9, 0x00, 0x62, 0x00, 0x8F, 0xC8, 0x7C, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0xE2, 0x00, 0xCE, 0xD9, 0x4C, 0xE2, 0x00, 0x8F, 0x99, 0x64, 0x0E, 0x81, 0x10, 0x00, 0x1E, 0x05, 0x1F, 0x12, 0x00, 0x1F, 0x01, 0x00, 0x00, 0x1F, 0x06, 0x1E, 0x00, 0x06, 0x1F, 0x00 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0xC9, 0x40, 0x3A, 0x38, 0x5E, 0xC2, 0x00, 0x4C, 0xAA, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0xC9, 0x40, 0x3A, 0x78, 0x5E, 0xC2, 0x00, 0x4D, 0x9A, 0x7C, 0x00, 0xA1, 0xA0, 0x08, 0x1F, 0x05, 0x1E, 0x02, 0x05, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0xC9, 0x40, 0x3A, 0x38, 0x5E, 0xC2, 0x00, 0x4C, 0xAA, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Extrapolated
{ 0xC9, 0x40, 0x3A, 0x78, 0x5E, 0xC2, 0x00, 0x4D, 0x9A, 0x7C, 0x00, 0xA1, 0xA0, 0x08, 0x1F, 0x05, 0x1E, 0x02, 0x05, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Extrapolated
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0xC6, 0x00, 0x2E, 0xC7, 0x59, 0xC2, 0x06, 0x0E, 0xA7, 0x7D, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x02, 0x0C, 0x03, 0x6A, 0x7D, 0x02, 0x00, 0x23, 0xEA, 0x7C, 0x02, 0x81, 0x00, 0x02, 0x20, 0x01, 0x1F, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0xCF, 0x3B, 0x2A, 0xFE, 0x7E, 0xC0, 0xC0, 0x0C, 0xEB, 0x63, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10 }, // Extrapolated
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x02, 0x0C, 0x03, 0x6A, 0x7D, 0x02, 0x00, 0x23, 0xEA, 0x7C, 0x02, 0x81, 0x00, 0x02, 0x20, 0x01, 0x1F, 0x00, 0x00, 0x1F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x0F, 0x10, 0x10, 0x09, 0x49, 0x02, 0x12, 0x07, 0x9A, 0x7C, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0xCF, 0x3B, 0x2A, 0xFE, 0x7E, 0xC0, 0xC0, 0x0C, 0xEB, 0x63, 0x0E, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0xCF, 0x40, 0x0A, 0x30, 0x5C, 0xCF, 0x00, 0x0D, 0x80, 0x7C, 0x00, 0xA0, 0x00, 0x0F, 0x1E, 0x0F, 0x20, 0x00, 0x0B, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, // Unknown
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }  // Unknown
};


void IMuseAdlib::part_changed(Part *part, uint16 what)
{
	MidiChannelAdl *mc;

	if (what & pcProgram) {
               if (part->_player ? part->_player->_isGM : false)
                       part_set_instrument(part, (Instrument *) &map_gm_to_fm[part->_program]);
               else if (part->_program < 32)
                        part_set_instrument(part, &_glob_instr[part->_program]);
	}

	if (what & pcMod) {
		for (mc = part->_mc->adl(); mc; mc = mc->_next) {
			adlib_note_on(mc->_channel, mc->_note + part->_transpose_eff,
			              (part->_pitchbend * part->_pitchbend_factor >> 6) + part->_detune_eff);
		}
	}

	if (what & pcVolume) {
		for (mc = part->_mc->adl(); mc; mc = mc->_next) {
			adlib_set_param(mc->_channel, 0, volume_table[lookup_table[mc->_vol_2]
																										[part->_vol_eff >> 2]]);
			if (mc->_twochan) {
				adlib_set_param(mc->_channel, 13, volume_table[lookup_table[mc->_vol_1]
																											 [part->_vol_eff >> 2]]);
			}
		}
	}

	if (what & pcPedal) {
		if (!part->_pedal) {
			for (mc = (MidiChannelAdl *)part->_mc; mc; mc = mc->_next) {
				if (mc->_waitforpedal)
					mc_off(mc);
			}
		}
	}

	if (what & pcModwheel) {
		for (mc = (MidiChannelAdl *)part->_mc; mc; mc = mc->_next) {
			if (mc->_s10a.active && mc->_s11a.flag0x40)
				mc->_s10a.modwheel = part->_modwheel >> 2;
			if (mc->_s10b.active && mc->_s11b.flag0x40)
				mc->_s10b.modwheel = part->_modwheel >> 2;
		}
	}
}

void IMuseAdlib::mc_key_on(MidiChannel * mc2, byte note, byte velocity)
{
	MidiChannelAdl *mc = (MidiChannelAdl *)mc2;
	Part *part = mc->_part;
	Instrument *instr = &_part_instr[part->_slot];
	int c;
	byte vol_1, vol_2;

	mc->_twochan = instr->feedback & 1;
	mc->_note = note;
	mc->_waitforpedal = false;
	mc->_duration = instr->duration;
	if (mc->_duration != 0)
		mc->_duration *= 63;

	vol_1 = (instr->oplvl_1 & 0x3F) + lookup_table[velocity >> 1][instr->waveform_1 >> 2];
	if (vol_1 > 0x3F)
		vol_1 = 0x3F;
	mc->_vol_1 = vol_1;

	vol_2 = (instr->oplvl_2 & 0x3F) + lookup_table[velocity >> 1][instr->waveform_2 >> 2];
	if (vol_2 > 0x3F)
		vol_2 = 0x3F;
	mc->_vol_2 = vol_2;

	c = part->_vol_eff >> 2;

	vol_2 = volume_table[lookup_table[vol_2][c]];
	if (mc->_twochan)
		vol_1 = volume_table[lookup_table[vol_1][c]];

	adlib_setup_channel(mc->_channel, instr, vol_1, vol_2);
	adlib_note_on_ex(mc->_channel, part->_transpose_eff + note, part->_detune_eff + (part->_pitchbend * part->_pitchbend_factor >> 6));

	if (instr->flags_a & 0x80) {
		mc_init_stuff(mc, &mc->_s10a, &mc->_s11a, instr->flags_a, &instr->extra_a);
	} else {
		mc->_s10a.active = 0;
	}

	if (instr->flags_b & 0x80) {
		mc_init_stuff(mc, &mc->_s10b, &mc->_s11b, instr->flags_b, &instr->extra_b);
	} else {
		mc->_s10b.active = 0;
	}
}

void IMuseAdlib::set_instrument(uint slot, byte *data)
{
	if (slot < 32)
		memcpy(&_glob_instr[slot], data, sizeof(Instrument));
}


void IMuseAdlib::link_mc(Part *part, MidiChannelAdl *mc)
{
	mc->_part = part;
	mc->_next = (MidiChannelAdl *)part->_mc;
	part->_mc = mc;
	mc->_prev = NULL;

	if (mc->_next)
		mc->_next->_prev = mc;
}

void IMuseAdlib::part_key_on(Part *part, byte note, byte velocity)
{
	MidiChannelAdl *mc;

	if ((part->_player ? part->_player->_isGM : false) && part->_chan == 9)
		return; // Jamieson630: GM percussion, not implemented for FM
	mc = allocate_midichan(part->_pri_eff);
	if (!mc)
		return;

	link_mc(part, mc);
	mc_key_on(mc, note, velocity);
}

void IMuseAdlib::part_key_off(Part *part, byte note)
{
	MidiChannelAdl *mc;

	if ((part->_player ? part->_player->_isGM : false) && part->_chan == 9)
		return; // Jamieson630: GM percussion, not implemented for FM
	for (mc = (MidiChannelAdl *)part->_mc; mc; mc = mc->_next) {
		if (mc->_note == note) {
			if (part->_pedal)
				mc->_waitforpedal = true;
			else
				mc_off(mc);
		}
	}
}

struct AdlibInstrSetParams {
	byte param;
	byte shl;
	byte mask;
};

#define MKLINE(_a_,_b_,_c_) { (int)&((Instrument*)0)->_a_, _b_, ((1<<(_c_))-1)<<(_b_) }
static const AdlibInstrSetParams adlib_instr_params[69] = {
	MKLINE(oplvl_2, 0, 6),
	MKLINE(waveform_2, 2, 5),
	MKLINE(oplvl_2, 6, 2),
	MKLINE(flags_2, 0, 4),
	MKLINE(atdec_2, 4, 4),
	MKLINE(atdec_2, 0, 4),
	MKLINE(sustrel_2, 4, 4),
	MKLINE(sustrel_2, 0, 4),
	MKLINE(waveform_2, 0, 2),
	MKLINE(flags_2, 7, 1),
	MKLINE(flags_2, 6, 1),
	MKLINE(flags_2, 5, 1),
	MKLINE(flags_2, 4, 1),

	MKLINE(oplvl_1, 0, 6),
	MKLINE(waveform_1, 2, 5),
	MKLINE(oplvl_1, 6, 2),
	MKLINE(flags_1, 0, 4),
	MKLINE(atdec_1, 4, 4),
	MKLINE(atdec_1, 0, 4),
	MKLINE(sustrel_1, 4, 4),
	MKLINE(sustrel_1, 0, 4),
	MKLINE(waveform_1, 0, 2),
	MKLINE(flags_1, 7, 1),
	MKLINE(flags_1, 6, 1),
	MKLINE(flags_1, 5, 1),
	MKLINE(flags_1, 4, 1),

	MKLINE(feedback, 0, 1),
	MKLINE(feedback, 1, 3),

	MKLINE(flags_a, 7, 1),
	MKLINE(flags_a, 6, 1),
	MKLINE(flags_a, 5, 1),
	MKLINE(flags_a, 4, 1),
	MKLINE(flags_a, 0, 4),
	MKLINE(extra_a.a, 0, 8),
	MKLINE(extra_a.b, 0, 7),
	MKLINE(extra_a.c, 0, 7),
	MKLINE(extra_a.d, 0, 7),
	MKLINE(extra_a.e, 0, 7),
	MKLINE(extra_a.f, 0, 7),
	MKLINE(extra_a.g, 0, 7),
	MKLINE(extra_a.h, 0, 7),
	MKLINE(extra_a.b, 7, 1),
	MKLINE(extra_a.c, 7, 1),
	MKLINE(extra_a.d, 7, 1),
	MKLINE(extra_a.e, 7, 1),
	MKLINE(extra_a.f, 7, 1),
	MKLINE(extra_a.g, 7, 1),
	MKLINE(extra_a.h, 7, 1),

	MKLINE(flags_b, 7, 1),
	MKLINE(flags_b, 6, 1),
	MKLINE(flags_b, 5, 1),
	MKLINE(flags_b, 4, 1),
	MKLINE(flags_b, 0, 4),
	MKLINE(extra_b.a, 0, 8),
	MKLINE(extra_b.b, 0, 7),
	MKLINE(extra_b.c, 0, 7),
	MKLINE(extra_b.d, 0, 7),
	MKLINE(extra_b.e, 0, 7),
	MKLINE(extra_b.f, 0, 7),
	MKLINE(extra_b.g, 0, 7),
	MKLINE(extra_b.h, 0, 7),
	MKLINE(extra_b.b, 7, 1),
	MKLINE(extra_b.c, 7, 1),
	MKLINE(extra_b.d, 7, 1),
	MKLINE(extra_b.e, 7, 1),
	MKLINE(extra_b.f, 7, 1),
	MKLINE(extra_b.g, 7, 1),
	MKLINE(extra_b.h, 7, 1),

	MKLINE(duration, 0, 8),
};
#undef MKLINE

void IMuseAdlib::part_set_param(Part *part, byte param, int value)
{
	const AdlibInstrSetParams *sp = &adlib_instr_params[param];
	byte *p = (byte *)&_part_instr[part->_slot] + sp->param;
	*p = (*p & ~sp->mask) | (value << sp->shl);

	if (param < 28) {
		MidiChannelAdl *mc;

		for (mc = (MidiChannelAdl *)part->_mc; mc; mc = mc->_next) {
			adlib_set_param(mc->_channel, param, value);
		}
	}
}

void IMuseAdlib::part_off(Part *part)
{
	MidiChannelAdl *mc = (MidiChannelAdl *)part->_mc;
	part->_mc = NULL;
	for (; mc; mc = mc->_next) {
		mc_off(mc);
	}
}

void IMuseAdlib::mc_off(MidiChannel * mc2)
{
	MidiChannelAdl *mc = (MidiChannelAdl *)mc2, *tmp;

	adlib_key_off(mc->_channel);

	tmp = mc->_prev;

	if (mc->_next)
		mc->_next->_prev = tmp;
	if (tmp)
		tmp->_next = mc->_next;
	else
		mc->_part->_mc = mc->_next;
	mc->_part = NULL;
}

void IMuseAdlib::part_set_instrument(Part *part, Instrument * instr)
{
	Instrument *i = &_part_instr[part->_slot];
	memcpy(i, instr, sizeof(Instrument));
}

int IMuseAdlib::part_update_active(Part *part, uint16 *active)
{
	uint16 bits;
	int count = 0;
	MidiChannelAdl *mc;

	bits = 1 << part->_chan;

	for (mc = part->_mc->adl(); mc; mc = mc->_next) {
		if (!(active[mc->_note] & bits)) {
			active[mc->_note] |= bits;
			count++;
		}
	}
	return count;
}
*/
//********************************************
//** GENERAL MIDI PART OF IMUSE STARTS HERE **
//********************************************

IMuseGM::IMuseGM (MidiDriver *midi)
{
	int i;

	// Initialize our "last" trackers with impossible
	// values, so that they don't accidentally match
	// any changes that are sent (which would cause
	// the changes to be ignored).
	for (i = 0; i < 16; ++i) {
		_midi_program_last [i] =
		_midi_pitchbend_factor_last [i] =
		_midi_volume_last [i] =
		_midi_modwheel_last [i] =
		_midi_effectlevel_last [i] =
		_midi_chorus_last [i] = 255;
		_midi_pan_last [i] = 127;
		_midi_pitchbend_last [i] = (int16) -1;
		_midi_pedal_last [i] = false;
	}
	_md = midi;
}

void IMuseGM::midiPitchBend(byte chan, int16 pitchbend)
{
	uint16 tmp;

	if (_midi_pitchbend_last[chan] != pitchbend) {
		_midi_pitchbend_last[chan] = pitchbend;
		tmp = pitchbend + 0x2000;
		_md->send(((tmp >> 7) & 0x7F) << 16 | (tmp & 0x7F) << 8 | 0xE0 | chan);
	}
}

void IMuseGM::midiPitchBendFactor (byte chan, byte factor) {
	if (_midi_pitchbend_factor_last[chan] != factor) {
		_midi_pitchbend_factor_last[chan] = factor;
		_md->setPitchBendRange (chan, factor);
	}
}

void IMuseGM::midiVolume(byte chan, byte volume)
{
	if (_midi_volume_last[chan] != volume) {
		_midi_volume_last[chan] = volume;
		_md->send(volume << 16 | 7 << 8 | 0xB0 | chan);
	}
}
void IMuseGM::midiPedal(byte chan, bool pedal)
{
	if (_midi_pedal_last[chan] != pedal) {
		_midi_pedal_last[chan] = pedal;
		_md->send(pedal << 16 | 64 << 8 | 0xB0 | chan);
	}
}

void IMuseGM::midiModWheel(byte chan, byte modwheel)
{
	if (_midi_modwheel_last[chan] != modwheel) {
		_midi_modwheel_last[chan] = modwheel;
		_md->send(modwheel << 16 | 1 << 8 | 0xB0 | chan);
	}
}

void IMuseGM::midiEffectLevel(byte chan, byte level)
{
	if (_midi_effectlevel_last[chan] != level) {
		_midi_effectlevel_last[chan] = level;
		_md->send(level << 16 | 91 << 8 | 0xB0 | chan);
	}
}

void IMuseGM::midiChorus(byte chan, byte chorus)
{
	if (_midi_chorus_last[chan] != chorus) {
		_midi_chorus_last[chan] = chorus;
		_md->send(chorus << 16 | 93 << 8 | 0xB0 | chan);
	}
}

void IMuseGM::midiControl0(byte chan, byte value)
{
	_md->send(value << 16 | 0 << 8 | 0xB0 | chan);
}


void IMuseGM::midiProgram(byte chan, byte program, bool mt32emulate)
{
	if (mt32emulate) {	/* Don't convert the percussion channel, it is the same in GM and MT32 */
		if (chan != PERCUSSION_CHANNEL)
			program = mt32_to_gmidi[program];
	}

	_md->send(program << 8 | 0xC0 | chan);
}

void IMuseGM::midiPan(byte chan, int8 pan)
{
	if (_midi_pan_last[chan] != pan) {
		_midi_pan_last[chan] = pan;
		_md->send(((pan - 64) & 0x7F) << 16 | 10 << 8 | 0xB0 | chan);
	}
}

void IMuseGM::midiNoteOn(byte chan, byte note, byte velocity)
{
	_md->send(velocity << 16 | note << 8 | 0x90 | chan);
}

void IMuseGM::midiNoteOff(byte chan, byte note)
{
	_md->send(note << 8 | 0x80 | chan);
}

void IMuseGM::midiSilence(byte chan)
{
	_md->send((64 << 8) | 0xB0 | chan);
	_md->send((123 << 8) | 0xB0 | chan);
}


void IMuseGM::part_key_on(Part *part, byte note, byte velocity)
{
	MidiChannel/*GM*/ *mc = part->_mc;//->gm();

	part->_actives[note >> 4] |= (1 << (note & 0xF));
	if (mc) {
//		mc->_actives[note >> 4] |= (1 << (note & 0xF));
//		midiNoteOn(mc->_chan, note, velocity);
		mc->noteOn (note, velocity);
	} else if (part->_percussion) {
//		midiVolume(PERCUSSION_CHANNEL, part->_vol_eff);
//		midiProgram(PERCUSSION_CHANNEL, part->_bank, part->_player->_mt32emulate);
//		midiNoteOn(PERCUSSION_CHANNEL, note, velocity);
		mc = _md->getPercussionChannel();
		if (!mc)
			return;
		mc->volume (part->_vol_eff);
		mc->programChange (part->_bank /*, part->_player->_mt32emulate*/);
		mc->noteOn (note, velocity);
	}
}

void IMuseGM::part_key_off(Part *part, byte note)
{
	MidiChannel/*GM*/ *mc = part->_mc;//->gm();

	part->_actives[note >> 4] &= ~(1 << (note & 0xF));
	if (mc) {
//		mc->_actives[note >> 4] &= ~(1 << (note & 0xF));
//		midiNoteOff(mc->_chan, note);
		mc->noteOff (note);
	} else if (part->_percussion) {
//		midiNoteOff(PERCUSSION_CHANNEL, note);
		mc = _md->getPercussionChannel();
		if (mc)
			mc->noteOff (note);
	}
}

#if !defined(__MORPHOS__)
int IMuseGM::midi_driver_thread(void *param)
{
	IMuseGM *mid = (IMuseGM *)param;
	int old_time, cur_time;
	
	old_time = mid->_system->get_msecs();

	for (;;) {
		mid->_system->delay_msecs(10);

		cur_time = mid->_system->get_msecs();
		while (old_time < cur_time) {
			old_time += 10;
			// Don't use mid->_se_on_timer()
			// We must come in through IMuseMonitor to protect
			// against conflicts with script access to IMuse.
			if (g_scumm->_imuse)
				g_scumm->_imuse->on_timer();
		}
	}

	return 0;
}
#else
#include <proto/exec.h>
#include <proto/dos.h>
#include "morphos.h"
#include "morphos_sound.h"
int IMuseGM::midi_driver_thread(void *param)
{
	IMuseGM *mid = (IMuseGM *) param;
	int old_time, cur_time;
	MsgPort *music_timer_port = NULL;
	timerequest *music_timer_request = NULL;

	ObtainSemaphore(&ScummMusicThreadRunning);

	if (!OSystem_MorphOS::OpenATimer(&music_timer_port, (IORequest **) &music_timer_request, UNIT_MICROHZ, false)) {
		warning("Could not open a timer - music will not play");
		Wait(SIGBREAKF_CTRL_C);
	}
	else {
		old_time = mid->_system->get_msecs();

		for (;;) {
			music_timer_request->tr_node.io_Command = TR_ADDREQUEST;
			music_timer_request->tr_time.tv_secs = 0;
			music_timer_request->tr_time.tv_micro = 10000;
			DoIO((struct IORequest *)music_timer_request);

			if (CheckSignal(SIGBREAKF_CTRL_C))
				break;

			cur_time = mid->_system->get_msecs();
			while (old_time < cur_time) {
				old_time += 10;
				mid->_se->on_timer();
			}
		}
	}

	ReleaseSemaphore(&ScummMusicThreadRunning);
	RemTask(NULL);
	return 0;
}
#endif

void IMuseGM::init(IMuseInternal *eng, OSystem *syst)
{
	int i;
//	MidiChannel/*GM*/ *mc;

	_system = syst;

	// Open MIDI driver
	int result = _md->open(MidiDriver::MO_SIMPLE);
	if (result)
		error("IMuseGM::error = %s", MidiDriver::get_error_name(result));

	// Connect to the driver's timer
	_se = eng;
//	syst->create_thread(midi_driver_thread, this);
	_md->setTimerCallback (NULL, &IMuseGM::timer_callback);

	for (i = 0; i != ARRAYSIZE(_midi_program_last); i++) {
//		mc->_chan = i;
		_midi_program_last [i] = 255;
	}
}

void IMuseGM::timer_callback (void *) {
	g_scumm->_imuse->on_timer();
}

void IMuseGM::uninit()
{
	_md->close();
}

void IMuseGM::update_pris()
{
	Part *part, *hipart;
	int i;
	byte hipri, lopri;
//	MidiChannel/*GM*/ *mc, *lomc;
	Part *lopart;

	while (true) {
		hipri = 0;
		hipart = NULL;
		for (i = 32, part = _se->parts_ptr(); i; i--, part++) {
			if (part->_player && !part->_percussion && part->_on && !part->_mc && part->_pri_eff >= hipri) {
				hipri = part->_pri_eff;
				hipart = part;
			}
		}

		if (!hipart)
			return;

		if ((hipart->_mc = _md->allocateChannel()) != NULL) {
			hipart->changed (pcAll);
			return;
		}

		lopri = 255;
		lopart = NULL;
		for (i = 32, part = _se->parts_ptr(); i; i--, part++) {
			if (part->_mc && part->_pri_eff <= lopri) {
				lopri = part->_pri_eff;
				lopart = part;
			}
		}

		if (lopart == NULL || lopri >= hipri)
			return;
		lopart->off();

		if ((hipart->_mc = _md->allocateChannel()) == NULL)
			return;
		hipart->changed(pcAll);
	}
}

int IMuseGM::part_update_active(Part *part, uint16 *active)
{
	int i, j;
	uint16 *act, mask, bits;
	int count = 0;

	bits = 1 << part->_chan;

//	act = part->_mc->gm()->_actives;
	act = part->_actives;

	for (i = 8; i; i--) {
		mask = *act++;
		if (mask) {
			for (j = 16; j; j--, mask >>= 1, active++) {
				if (mask & 1 && !(*active & bits)) {
					*active |= bits;
					count++;
				}
			}
		} else {
			active += 16;
		}
	}
	return count;
}

void IMuseGM::part_set_instrument (Part *part, Instrument *instr)
{
	Instrument *i = &_part_instr[part->_slot];
	memcpy(i, instr, sizeof(Instrument));
	part->changed (pcProgram);
}

void IMuseGM::set_instrument(uint slot, byte *data)
{
	if (slot < 32)
		memcpy(&_glob_instr[slot], data, sizeof(Instrument));
}

void IMuseGM::part_changed(Part *part, uint16 what)
{
	MidiChannel/*GM*/ *mc;

	// Mark for re-schedule if program changed when in pre-state
	if (what & pcProgram && !part->_percussion && !part->_mc) {
		update_pris();
	}

	if (!(mc = part->_mc/*->gm()*/))
		return;

	if (part->_player == NULL) {	// No player, so dump phantom channel
		part->_mc->release();
		part->_mc = NULL;
//		mc->_part = NULL;
//		memset(mc->_actives, 0, sizeof(mc->_actives));
		memset(part->_actives, 0, sizeof(part->_actives));
		return;
	}

	if (what & pcPitchBendFactor)
//		midiPitchBendFactor (mc->_chan, part->_pitchbend_factor);
		mc->pitchBendFactor (part->_pitchbend_factor);

	if (what & pcMod)
//		midiPitchBend(mc->_chan,
//		              clamp(part->_pitchbend +
//					        (part->_detune_eff * 64 / 12) +
//		                    (part->_transpose_eff * 8192 / 12), -8192, 8191));
		mc->pitchBend (clamp(part->_pitchbend +
		               (part->_detune_eff * 64 / 12) +
		               (part->_transpose_eff * 8192 / 12), -8192, 8191));

	if (what & pcVolume)
//		midiVolume(mc->_chan, part->_vol_eff);
		mc->volume (part->_vol_eff);

	if (what & pcPedal)
//		midiPedal(mc->_chan, part->_pedal);
		mc->sustain (part->_pedal);

	if (what & pcModwheel)
//		midiModWheel(mc->_chan, part->_modwheel);
		mc->modulationWheel (part->_modwheel);

	if (what & pcPan)
//		midiPan(mc->_chan, part->_pan_eff);
		mc->panPosition (part->_pan_eff);

	if (what & pcEffectLevel)
//		midiEffectLevel(mc->_chan, part->_effect_level);
		mc->effectLevel (part->_effect_level);

	if (what & pcProgram) {
		if (part->_player->_isGM) {
			if (part->_program < 128) {
				_midi_program_last [part->_chan] = part->_program;
				if (part->_bank) {
//					midiControl0(mc->_chan, part->_bank);
//					midiProgram(mc->_chan, part->_program, part->_player->_mt32emulate);
//					midiControl0(mc->_chan, 0);
					mc->controlChange (0, part->_bank);
					mc->programChange (part->_program /*, part->_player->_mt32emulate*/);
					mc->controlChange (0, 0);
				} else {
//					midiProgram(mc->_chan, part->_program, part->_player->_mt32emulate);
					mc->programChange (part->_program /*, part->_player->_mt32emulate*/);
				}
			}
		} else {
			if (part->_program < 32) {
				memcpy (&_part_instr [part->_slot], &_glob_instr[part->_program], sizeof (Instrument));
			}
//			_md->sysEx_customInstrument (mc->_chan, 'ADL ', (byte *) (&_part_instr [part->_slot]));
			mc->sysEx_customInstrument ('ADL ', (byte *) (&_part_instr [part->_slot]));
		}
	}

	if (what & pcChorus)
//		midiChorus(mc->_chan, part->_effect_level);
		mc->chorusLevel (part->_effect_level);

	if (what & pcPriority)
//		_md->send ((part->_pri_eff << 16) | (18 << 8) | 0xB0 | mc->_chan);
		mc->priority (part->_pri_eff);
}


void IMuseGM::part_off(Part *part)
{
	MidiChannel/*GM*/ *mc = part->_mc/*->gm()*/;
	if (mc) {
		mc->allNotesOff();
		mc->release();
		part->_mc = NULL;
//		mc->_part = NULL;
//		memset(mc->_actives, 0, sizeof(mc->_actives));
		memset(part->_actives, 0, sizeof(part->_actives));
//		midiSilence(mc->_chan);
	}
}



// The IMuse::create method provides a front-end factory
// for creating IMuseInternal without exposing that class
// to the client.
IMuse *IMuse::create(OSystem *syst, MidiDriver *midi, SoundMixer *mixer)
{
	IMuse *engine = (IMuse *) IMuseInternal::create (syst, midi, mixer);
	return (IMuse *) new IMuseMonitor (syst, engine);
}



/*
 *  IMUSE Digital Implementation, for SCUMM v7 and higher.
 */

static void imus_digital_handler(void *engine) {
	// Avoid race condition
	if(engine && ((Scumm *)engine)->_imuseDigital)
		((Scumm *)engine)->_imuseDigital->handler();
}

IMuseDigital::IMuseDigital(Scumm *scumm) {
	memset(_channel, 0, sizeof(channel) * MAX_DIGITAL_CHANNELS);
	_scumm = scumm;
	for (int32 l = 0; l < MAX_DIGITAL_CHANNELS; l++) {
		_channel[l]._initialized = false;
	}
	_scumm->_mixer->beginSlots(MAX_DIGITAL_CHANNELS + 1);
	_scumm->_timer->installProcedure(imus_digital_handler, 200);
	_pause = false;
}

IMuseDigital::~IMuseDigital() {
	for (int32 l = 0; l < MAX_DIGITAL_CHANNELS; l++) {
		_scumm->_mixer->stop(l);
	}
	_scumm->_timer->releaseProcedure(imus_digital_handler);
}

struct imuse_music_table {
	int16 index;
	char name[30];
	char title[30];
	char filename[15];
	int8 unk1;
};

struct imuse_music_map {
	int16 room;
	int16 table_index;
	int16 unk1;
	int16 unk2;
	int16 unk3;
	int16 unk4;
};

static const imuse_music_map _digStateMusicMap[] = {
	{0,		0,	0,	0,	0,	0	},
	{1,		0,	0,	0,	0,	0	},
	{2,		2,	0,	0,	0,	0	},
	{3,		47,	0,	0,	0,	0	},
	{4,		3,	0,	0,	0,	0	},
	{5,		3,	0,	0,	0,	0	},
	{6,		3,	0,	0,	0,	0	},
	{7,		3,	0,	0,	0,	0	},
	{8,		4,	0,	0,	0,	0	},
	{9,		5,	0,	0,	0,	0	},
	{10,	4,	0,	0,	0,	0	},
	{11,	44,	0,	0,	0,	0	},
	{12,	5,	0,	0,	0,	0	},
	{13,	1,	0,	0,	0,	0	},
	{14,	5,	0,	0,	0,	0	},
	{15,	6,	29,	7,	0,	0	},
	{16,	8,	0,	0,	0,	0	},
	{17,	1,	0,	0,	0,	0	},
	{18,	9,	0,	0,	0,	0	},
	{19,	9,	0,	0,	0,	0	},
	{20,	6,	0,	0,	0,	0	},
	{21,	6,	0,	0,	0,	0	},
	{22,	44,	0,	0,	0,	0	},
	{23,	10,	7,	0,	0,	0	},
	{24,	26,	0,	0,	0,	0	},
	{25,	17,	0,	0,	0,	0	},
	{26,	17,	0,	0,	0,	0	},
	{27,	18,	0,	0,	0,	0	},
	{28,	1,	0,	0,	0,	0	},
	{29,	20,	0,	0,	0,	0	},
	{30,	22,	0,	0,	0,	0	},
	{31,	23,	0,	0,	0,	0	},
	{32,	22,	0,	0,	0,	0	},
	{33,	26,	0,	0,	0,	0	},
	{34,	24,	0,	0,	0,	0	},
	{35,	1,	0,	0,	0,	0	},
	{36,	1,	0,	0,	0,	0	},
	{37,	42,	0,	0,	0,	0	},
	{38,	43,	0,	0,	0,	0	},
	{39,	44,	0,	0,	0,	0	},
	{40,	1,	0,	0,	0,	0	},
	{41,	43,	0,	0,	0,	0	},
	{42,	44,	0,	0,	0,	0	},
	{43,	43,	0,	0,	0,	0	},
	{44,	45,	117,45,	114,26},
	{45,	1,	0,	0,	0,	0	},
	{46,	33,	6,	35,	5,	34},
	{47,	1,	0,	0,	0,	0	},
	{48,	43,	0,	0,	0,	0	},
	{49,	44,	0,	0,	0,	0	},
	{50,	1,	0,	0,	0,	0	},
	{51,	1,	0,	0,	0,	0	},
	{52,	0,	0,	0,	0,	0	},
	{53,	28,	0,	0,	0,	0	},
	{54,	28,	0,	0,	0,	0	},
	{55,	29,	0,	0,	0,	0	},
	{56,	29,	0,	0,	0,	0	},
	{57,	29,	0,	0,	0,	0	},
	{58,	31,	0,	0,	0,	0	},
	{59,	1,	0,	0,	0,	0	},
	{60,	37,	0,	0,	0,	0	},
	{61,	39,	0,	0,	0,	0	},
	{62,	38,	0,	0,	0,	0	},
	{63,	39,	0,	0,	0,	0	},
	{64,	39,	0,	0,	0,	0	},
	{65,	40,	0,	0,	0,	0	},
	{66,	1,	0,	0,	0,	0	},
	{67,	40,	0,	0,	0,	0	},
	{68,	39,	0,	0,	0,	0	},
	{69,	1,	0,	0,	0,	0	},
	{70,	49,	0,	0,	0,	0	},
	{71,	1,	0,	0,	0,	0	},
	{72,	1,	0,	0,	0,	0	},
	{73,	50,	0,	0,	0,	0	},
	{74,	1,	0,	0,	0,	0	},
	{75,	51,	0,	0,	0,	0	},
	{76,	1,	0,	0,	0,	0	},
	{77,	52,	7,	0,	0,	0	},
	{78,	63,	0,	0,	0,	0	},
	{79,	1,	0,	0,	0,	0	},
	{80,	41,	0,	0,	0,	0	},
	{81,	48,	0,	0,	0,	0	},
	{82,	21,	0,	0,	0,	0	},
	{83,	27,	0,	0,	0,	0	},
	{84,	1,	0,	0,	0,	0	},
	{85,	1,	0,	0,	0,	0	},
	{86,	0,	0,	0,	0,	0	},
	{87,	1,	0,	0,	0,	0	},
	{88,	32,	0,	0,	0,	0	},
	{89,	33,	6,	35,	5,	34},
	{90,	16,	0,	0,	0,	0	},
	{91,	57,	0,	0,	0,	0	},
	{92,	25,	0,	0,	0,	0	},
	{93,	0,	0,	0,	0,	0	},
	{94,	36,	0,	0,	0,	0	},
	{95,	19,	0,	0,	0,	0	},
	{96,	13,	0,	0,	0,	0	},
	{97,	14,	0,	0,	0,	0	},
	{98,	11,	0,	0,	0,	0	},
	{99,	15,	0,	0,	0,	0	},
	{100,	17,	0,	0,	0,	0	},
	{101,	38,	0,	0,	0,	0	},
	{102,	1,	0,	0,	0,	0	},
	{103,	0,	0,	0,	0,	0	},
	{104,	0,	0,	0,	0,	0	},
	{105,	30, 128,29,	0,	0	},
	{106,	0,	0,	0,	0,	0	},
	{107,	1,	0,	0,	0,	0	},
	{108,	1,	0,	0,	0,	0	},
	{109,	1,	0,	0,	0,	0	},
	{110,	2,	0,	0,	0,	0	},
	{111,	1,	0,	0,	0,	0	},
	{-1,	1,	0,	0,	0,	0	},
};

static const imuse_music_table _digStateMusicTable[] = {
	{0,		"STATE_NULL",						"",												"",							0},
	{1,		"stateNoChange",				"",												"",							0},
	{2,		"stateAstShip",					"Asteroid (amb-ship)",		"ASTERO~1.IMU",	3},
	{3,		"stateAstClose",				"Asteroid (amb-close)",		"ASTERO~2.IMU",	3},
	{4,		"stateAstInside",				"Asteroid (inside)",			"ASTERO~3.IMU",	3},
	{5,		"stateAstCore",					"Asteroid (core)",				"ASTERO~4.IMU",	3},
	{6,		"stateCanyonClose",			"Canyon (close)",					"CANYON~1.IMU",	3},
	{7,		"stateCanyonClose_m",		"Canyon (close-m)",				"CANYON~2.IMU",	3},
	{8,		"stateCanyonOver",			"Canyon (over)",					"CANYON~3.IMU",	3},
	{9,		"stateCanyonWreck",			"Canyon (wreck)",					"CANYON~4.IMU",	3},
	{10,	"stateNexusCanyon",			"Nexus (plan)",						"NEXUS(~1.IMU",	3},
	{11,	"stateNexusPlan",				"Nexus (plan)",						"NEXUS(~1.IMU",	3},
	{12,	"stateNexusRamp",				"Nexus (ramp)",						"NEXUS(~2.IMU",	3},
	{13,	"stateNexusMuseum",			"Nexus (museum)",					"NEXUS(~3.IMU",	3},
	{14,	"stateNexusMap",				"Nexus (map)",						"NEXUS(~4.IMU",	3},
	{15,	"stateNexusTomb",				"Nexus (tomb)",						"NE3706~5.IMU",	3},
	{16,	"stateNexusCath",				"Nexus (cath)",						"NE3305~5.IMU",	3},
	{17,	"stateNexusAirlock",		"Nexus (airlock)",				"NE2D3A~5.IMU",	3},
	{18,	"stateNexusPowerOff",		"Nexus (power)",					"NE8522~5.IMU",	3},
	{19,	"stateMuseumTramNear",	"Tram (mu-near)",					"TRAM(M~1.IMU",	3},
	{20,	"stateMuseumTramFar",		"Tram (mu-far)",					"TRAM(M~2.IMU",	3},
	{21,	"stateMuseumLockup",		"Museum (lockup)",				"MUSEUM~1.IMU",	3},
	{22,	"stateMuseumPool",			"Museum (amb-pool)",			"MUSEUM~2.IMU",	3},
	{23,	"stateMuseumSpire",			"Museum (amb-spire)",			"MUSEUM~3.IMU",	3},
	{24,	"stateMuseumMuseum",		"Museum (amb-mu)",				"MUSEUM~4.IMU",	3},
	{25,	"stateMuseumLibrary",		"Museum (library)",				"MUB575~5.IMU",	3},
	{26,	"stateMuseumCavern",		"Museum (cavern)",				"MUF9BE~5.IMU",	3},
	{27,	"stateTombTramNear",		"Tram (tomb-near)",				"TRAM(T~1.IMU",	3},
	{28,	"stateTombBase",				"Tomb (amb-base)",				"TOMB(A~1.IMU",	3},
	{29,	"stateTombSpire",				"Tomb (amb-spire)",				"TOMB(A~2.IMU",	3},
	{30,	"stateTombCave",				"Tomb (amb-cave)",				"TOMB(A~3.IMU",	3},
	{31,	"stateTombCrypt",				"Tomb (crypt)",						"TOMB(C~1.IMU",	3},
	{32,	"stateTombGuards",			"Tomb (crypt-guards)",		"TOMB(C~2.IMU",	3},
	{33,	"stateTombInner",				"Tomb (inner)",						"TOMB(I~1.IMU",	3},
	{34,	"stateTombCreator1",		"Tomb (creator 1)",				"TOMB(C~3.IMU",	3},
	{35,	"stateTombCreator2",		"Tomb (creator 2)",				"TOMB(C~4.IMU",	3},
	{36,	"statePlanTramNear",		"Tram (plan-near)",				"TRAM(P~1.IMU",	3},
	{37,	"statePlanTramFar",			"Tram (plan-far)",				"TRAM(P~2.IMU",	3},
	{38,	"statePlanBase",				"Plan (amb-base)",				"PLAN(A~1.IMU",	3},
	{39,	"statePlanSpire",				"Plan (amb-spire)",				"PLAN(A~2.IMU",	3},
	{40,	"statePlanDome",				"Plan (dome)",						"PLAN(D~1.IMU",	3},
	{41,	"stateMapTramNear",			"Tram (map-near)",				"TRAM(M~3.IMU",	3},
	{42,	"stateMapTramFar",			"Tram (map-far)",					"TRAM(M~4.IMU",	3},
	{43,	"stateMapCanyon",				"Map (amb-canyon)",				"MAP(AM~1.IMU",	3},
	{44,	"stateMapExposed",			"Map (amb-exposed)",			"MAP(AM~2.IMU",	3},
	{45,	"stateMapNestEmpty",		"Map (amb-nest)",					"MAP(AM~4.IMU",	3},
	{46,	"stateMapNestMonster",	"Map (monster)",					"MAP(MO~1.IMU",	3},
	{47,	"stateMapKlein",				"Map (klein)",						"MAP(KL~1.IMU",	3},
	{48,	"stateCathTramNear",		"Tram (cath-near)",				"TRAM(C~1.IMU",	3},
	{49,	"stateCathTramFar",			"Tram (cath-far)",				"TRAM(C~2.IMU",	3},
	{50,	"stateCathLab",					"Cath (amb-inside)",			"CATH(A~1.IMU",	3},
	{51,	"stateCathOutside",			"Cath (amb-outside)",			"CATH(A~2.IMU",	3},
	{52,	"stateWorldMuseum",			"World (museum)",					"WORLD(~1.IMU",	3},
	{53,	"stateWorldPlan",				"World (plan)",						"WORLD(~2.IMU",	3},
	{54,	"stateWorldTomb",				"World (tomb)",						"WORLD(~3.IMU",	3},
	{55,	"stateWorldMap",				"World (map)",						"WORLD(~4.IMU",	3},
	{56,	"stateWorldCath",				"World (cath)",						"WO3227~5.IMU",	3},
	{57,	"stateEye1",						"Eye 1",									"EYE1~1.IMU",		3},
	{58,	"stateEye2",						"Eye 2",									"EYE2~1.IMU",		3},
	{59,	"stateEye3",						"Eye 3",									"EYE3~1.IMU",		3},
	{60,	"stateEye4",						"Eye 4",									"EYE4~1.IMU",		3},
	{61,	"stateEye5",						"Eye 5",									"EYE5~1.IMU",		3},
	{62,	"stateEye6",						"Eye 6",									"EYE6~1.IMU",		3},
	{63,	"stateEye7",						"Eye 7",									"EYE7~1.IMU",		3},
	{-1,	"",											"",												"",							0},
};

static const imuse_music_table _digSeqMusicTable[] = {
	{2000,	"SEQ_NULL",							"",												"",							0},
	{2005,	"seqLogo",							"",												"",							0},
	{2010,	"seqIntro",							"",												"",							0},
	{2020,	"seqExplosion1b",				"",												"",							6},
	{2030,	"seqAstTunnel1a",				"Seq (ast tunnel 1a)",		"SEQ(AS~1.IMU",	3},
	{2031,	"seqAstTunnel2b",				"",												"",							6},
	{2032,	"seqAstTunnel3a",				"Seq (ast tunnel 3a)",		"SEQ(AS~2.IMU",	4},
	{2040,	"seqToPlanet1b",				"",												"",							5},
	{2045,	"seqArgBegin",					"Seq (arg begin)",				"SEQ(AR~1.IMU",	4},
	{2046,	"seqArgEnd",						"Seq (arg end)",					"SEQ(AR~2.IMU",	4},
	{2050,	"seqWreckGhost",				"Seq (ghost-wreck)",			"SEQ(GH~1.IMU",	4},
	{2060,	"seqCanyonGhost",				"Seq (ghost-canyon)",			"SEQ(GH~2.IMU",	4},
	{2070,	"seqBrinkFall",					"",												"",							0},
	{2080,	"seqPanUpCanyon",				"Seq (pan up canyon)",		"SEQ(PA~1.IMU",	4},
	{2091,	"seqAirlockTunnel1b",		"",												"",							6},
	{2100,	"seqTramToMu",					"",												"",							6},
	{2101,	"seqTramFromMu",				"",												"",							6},
	{2102,	"seqTramToTomb",				"",												"",							6},
	{2103,	"seqTramFromTomb",			"",												"",							6},
	{2104,	"seqTramToPlan",				"",												"",							6},
	{2105,	"seqTramFromPlan",			"",												"",							6},
	{2106,	"seqTramToMap",					"",												"",							6},
	{2107,	"seqTramFromMap",				"",												"",							6},
	{2108,	"seqTramToCath",				"",												"",							6},
	{2109,	"seqTramFromCath",			"",												"",							6},
	{2110,	"seqMuseumGhost",				"",												"",							0},
	{2120,	"seqSerpentAppears",		"",												"",							0},
	{2130,	"seqSerpentEats",				"",												"",							0},
	{2140,	"seqBrinkRes1b",				"",												"",							6},
	{2141,	"seqBrinkRes2a",				"Seq (brink's madness)",	"SEQ(BR~1.IMU",	4},
	{2150,	"seqLockupEntry",				"Seq (brink's madness)",	"SEQ(BR~1.IMU",	3},
	{2160,	"seqSerpentExplodes",		"",												"",							0},
	{2170,	"seqSwimUnderwater",		"Seq (descent)",					"SEQ(DE~1.IMU",	4},
	{2175,	"seqWavesPlunge",				"Seq (plunge)",						"SEQ(PL~1.IMU",	4},
	{2180,	"seqCryptOpens",				"",												"",							0},
	{2190,	"seqGuardsFight",				"",												"",							0},
	{2200,	"seqCreatorRes1.1a",		"Seq (creator res 1.1a)",	"SEQ(CR~1.IMU",	3},
	{2201,	"seqCreatorRes1.2b",		"",												"",							6},
	{2210,	"seqMaggieCapture1b",		"",												"",							6},
	{2220,	"seqStealCrystals",			"Seq (brink's madness)",	"SEQ(BR~1.IMU",	3},
	{2230,	"seqGetByMonster",			"",												"",							0},
	{2240,	"seqKillMonster1b",			"",												"",							6},
	{2250,	"seqCreatorRes2.1a",		"Seq (creator res 2.1a)",	"SEQ(CR~2.IMU",	3},
	{2251,	"seqCreatorRes2.2b",		"",												"",							6},
	{2252,	"seqCreatorRes2.3a",		"Seq (creator res 2.3a)",	"SEQ(CR~3.IMU",	4},
	{2260,	"seqMaggieInsists",			"",												"",							0},
	{2270,	"seqBrinkHelpCall",			"",												"",							0},
	{2280,	"seqBrinkCrevice1a",		"Seq (brink crevice 1a)",	"SEQ(BR~2.IMU",	3},
	{2281,	"seqBrinkCrevice2a",		"Seq (brink crevice 2a)",	"SEQ(BR~3.IMU",	3},
	{2290,	"seqCathAccess1b",			"",												"",							6},
	{2291,	"seqCathAccess2a",			"Seq (cath access 2a)",		"SEQ(CA~1.IMU",	4},
	{2300,	"seqBrinkAtGenerator",	"Seq (brink's madness)",	"SEQ(BR~1.IMU",	3},
	{2320,	"seqFightBrink1b",			"",												"",							6},
	{2340,	"seqMaggieDies1b",			"",												"",							6},
	{2346,	"seqMaggieRes1b",				"",												"",							6},
	{2347,	"seqMaggieRes2a",				"Seq (maggie res 2a)",		"SEQ(MA~1.IMU",	4},
	{2350,	"seqCreatureFalls",			"",												"",							0},
	{2360,	"seqFinale1b",					"",												"",							5},
	{2370,	"seqFinale2a",					"Seq (finale 2a)",				"SEQ(FI~1.IMU",	3},
	{2380,	"seqFinale3b1",					"",												"",							6},
	{2390,	"seqFinale3b2",					"",												"",							6},
	{2400,	"seqFinale4a",					"Seq (finale 4a)",				"SEQ(FI~2.IMU",	3},
	{2410,	"seqFinale5a",					"Seq (finale 5a)",				"SEQ(FI~3.IMU",	3},
	{2420,	"seqFinale6a",					"Seq (finale 6a)",				"SEQ(FI~4.IMU",	3},
	{2430,	"seqFinale7a",					"Seq (finale 7a)",				"SE3D2B~5.IMU",	3},
	{2440,	"seqFinale8b",					"",												"",							6},
	{2450,	"seqFinale9a",					"Seq (finale 9a)",				"SE313B~5.IMU",	4},
	{-1,		"",											"",												"",							0},
};

struct imuse_ft_music_table {
	int16 index;
	char audioname[15];
	int8 unk1;
	int8 volume;
	char name[30];
};

static const imuse_ft_music_table _ftStateMusicTable[] = {
	{0,		"",					0,	0,		"STATE_NULL"					},
	{1,		"",					4,	127,	"stateKstandOutside"	},
	{2,		"kinside",	2,	127,	"stateKstandInside"		},
	{3,		"moshop",		3,	64,		"stateMoesInside"			},
	{4,		"melcut",		2,	127,	"stateMoesOutside"		},
	{5,		"mellover",	2,	127,	"stateMellonAbove"		},
	{6,		"radloop",	3,	28,		"stateTrailerOutside"	},
	{7,		"radloop",	3,	58,		"stateTrailerInside"	},
	{8,		"radloop",	3,	127,	"stateTodShop"				},
	{9,		"junkgate",	2,	127,	"stateJunkGate"				},
	{10,	"junkover",	3,	127,	"stateJunkAbove"			},
	{11,	"gastower",	2,	127,	"stateGasTower"				},
	{12,	"",					4,	0,		"stateTowerAlarm"			},
	{13,	"melcut",		2,	127,	"stateCopsOnGround"		},
	{14,	"melcut",		2,	127,	"stateCopsAround"			},
	{15,	"melcut",		2,	127,	"stateMoesRuins"			},
	{16,	"melcut",		2,	127,	"stateKstandNight"		},
	{17,	"trukblu2",	2,	127,	"stateTruckerTalk"		},
	{18,	"stretch",	2,	127,	"stateMumblyPeg"			},
	{19,	"kstand",		2,	127,	"stateRanchOutside"		},
	{20,	"kinside",	2,	127,	"stateRanchInside"		},
	{21,	"desert",		2,	127,	"stateWreckedTruck"		},
	{22,	"opening",	2,	127,	"stateGorgeVista"			},
	{23,	"caveopen",	2,	127,	"stateCaveOpen"				},
	{24,	"cavecut1",	2,	127,	"stateCaveOuter"			},
	{25,	"cavecut1",	1,	127,	"stateCaveMiddle"			},
	{26,	"cave",			2,	127,	"stateCaveInner"			},
	{27,	"corville",	2,	127,	"stateCorvilleFront"	},
	{28,	"mines",		2,	127,	"stateMineField"			},
	{29,	"bunyman3",	2,	127,	"stateBunnyStore"			},
	{30,	"stretch",	2,	127,	"stateStretchBen"			},
	{31,	"saveme",		2,	127,	"stateBenPleas"				},
	{32,	"",					4,	0,		"stateBenConvinces"		},
	{33,	"derby",		3,	127,	"stateDemoDerby"			},
	{34,	"fire",			3,	127,	"stateLightMyFire"		},
	{35,	"derby",		3,	127,	"stateDerbyChase"			},
	{36,	"carparts",	2,	127,	"stateVultureCarParts"},
	{37,	"cavecut1",	2,	127,	"stateVulturesInside"	},
	{38,	"mines",		2,	127,	"stateFactoryRear"		},
	{39,	"croffice",	2,	127,	"stateCorleyOffice"		},
	{40,	"melcut",		2,	127,	"stateCorleyHall"			},
	{41,	"",					4,	0,		"stateProjRoom"				},
	{42,	"",					4,	0,		"stateMMRoom"					},
	{43,	"bumper",		2,	127,	"stateBenOnBumper"		},
	{44,	"benump",		2,	127,	"stateBenOnBack"			},
	{45,	"plane",		2,	127,	"stateInCargoPlane"		},
	{46,	"saveme",		2,	127,	"statePlaneControls"	},
	{47,	"",					4,	0,		"stateCliffHanger1"		},
	{48,	"",					4,	0,		"stateCliffHanger2"		},
	{-1,	"",					0,	0,		""										},
};

static const imuse_ft_music_table _ftSeqMusicTable[] = {
	{0,		"",					2,	127,	"SEQ_NULL"						},
	{1,		"",					0,	0,		"seqLogo"							},
	{2,		"",					0,	0,		"seqOpenFlick"				},
	{3,		"",					0,	0,		"seqBartender"				},
	{4,		"opening", 	2,	127,	"seqBenWakes"					},
	{5,		"",					0,	0,		"seqPhotoScram"				},
	{6,		"",					0,	0,		"seqClimbChain"				},
	{7,		"",					0,	0,		"seqDogChase"					},
	{8,		"barbeat",	2,	127,	"seqDogSquish"				},
	{9,		"barwarn",	2,	127,	"seqDogHoist"					},
	{10,	"",					0,	0,		"seqCopsArrive"				},
	{11,	"",					0,	0,		"seqCopsLand"					},
	{12,	"benwakes",	2,	127,	"seqCopsLeave"				},
	{13,	"",					0,	0,		"seqCopterFlyby"			},
	{14,	"",					0,	0,		"seqCopterCrash"			},
	{15,	"",					0,	0,		"seqMoGetsParts"			},
	{16,	"barwarn",	2,	127,	"seqMoFixesBike"			},
	{17,	"",					0,	0,		"seqFirstGoodbye"			},
	{18,	"",					0,	0,		"seqCopRoadblock"			},
	{19,	"",					0,	0,		"seqDivertCops"				},
	{20,	"swatben",	2,	127,	"seqMurder"						},
	{21,	"",					0,	0,		"seqCorleyDies"				},
	{22,	"",					0,	0,		"seqTooLateAtMoes"		},
	{23,	"",					0,	0,		"seqPicture"					},
	{24,	"dogattak",	2,	127,	"seqNewsReel"					},
	{25,	"",					0,	0,		"seqCopsInspect"			},
	{26,	"",					0,	0,		"seqHijack"						},
	{27,	"",					0,	0,		"seqNestolusAtRanch"	},
	{28,	"",					4,	0,		"seqRipLimo"					},
	{29,	"",					0,	0,		"seqGorgeTurn"				},
	{30,	"",					0,	0,		"seqStealRamp"				},
	{31,	"",					0,	0,		"seqCavefishTalk"			},
	{32,	"",					4,	0,		"seqArriveCorville"		},
	{33,	"",					0,	0,		"seqSingleBunny"			},
	{34,	"",					0,	0,		"seqBunnyArmy"				},
	{35,	"",					0,	0,		"seqArriveAtMines"		},
	{36,	"cops2",		2,	127,	"seqArriveAtVultures"	},
	{37,	"",					0,	0,		"seqMakePlan"					},
	{38,	"",					0,	0,		"seqShowPlan"					},
	{39,	"",					0,	0,		"seqDerbyStart"				},
	{40,	"cops2",		2,	127,	"seqLightBales"				},
	{41,	"",					0,	0,		"seqNestolusBBQ"			},
	{42,	"",					0,	0,		"seqCallSecurity"			},
	{43,	"",					0,	0,		"seqFilmFail"					},
	{44,	"cops2",		2,	127,	"seqFilmBurn"					},
	{45,	"",					0,	0,		"seqRipSpeech"				},
	{46,	"",					0,	0,		"seqExposeRip"				},
	{47,	"",					0,	0,		"seqRipEscape"				},
	{48,	"",					0,	0,		"seqRareMoment"				},
	{49,	"",					0,	0,		"seqFanBunnies"				},
	{50,	"",					0,	0,		"seqRipDead"					},
	{51,	"bunymrch",	2,	127,	"seqFuneral"					},
	{52,	"",					0,	0,		"seqCredits"					},
	{-1,	"",					0,	0,		""										},
};

void IMuseDigital::handler() {
	uint32 l = 0, i = 0;

	if (_pause == true)
		return;

	for (l = 0; l < MAX_DIGITAL_CHANNELS;l ++) {
		if (_channel[l]._used) {
			if (_channel[l]._toBeRemoved == true) {
				_scumm->_mixer->stop(l);
				if (_scumm->_mixer->_channels[l] == NULL) {
					free(_channel[l]._data);
					_channel[l]._used = false;
					_channel[l]._initialized = false;
				}
				continue;
			}

			if (_channel[l]._delay > 0) {
				_channel[l]._delay--;
				continue;
			}

			if (_channel[l]._volumeFade != -1) {
				if (_channel[l]._volumeFadeStep < 0) {
					if (_channel[l]._volume > _channel[l]._volumeFade) {
						_channel[l]._volume += _channel[l]._volumeFadeStep;
						_channel[l]._volumeRight += _channel[l]._volumeFadeStep;
						if (_channel[l]._volume < _channel[l]._volumeFade) {
							_channel[l]._volume = _channel[l]._volumeFade;
						}
						if (_channel[l]._volumeRight < _channel[l]._volumeFade) {
							_channel[l]._volumeRight = _channel[l]._volumeFade;
						}
						if ((_channel[l]._volume == 0) && (_channel[l]._volumeRight == 0)) {
							_channel[l]._toBeRemoved = true;
						}
					}
				} else if (_channel[l]._volumeFadeStep > 0) {
					if (_channel[l]._volume < _channel[l]._volumeFade) {
						_channel[l]._volume += _channel[l]._volumeFadeStep;
						_channel[l]._volumeRight += _channel[l]._volumeFadeStep;
						if (_channel[l]._volume > _channel[l]._volumeFade) {
							_channel[l]._volume = _channel[l]._volumeFade;
						}
						if (_channel[l]._volumeRight > _channel[l]._volumeFade) {
							_channel[l]._volumeRight = _channel[l]._volumeFade;
						}
					}
				}
			}

			if ((_channel[l]._jump[0]._numLoops == 0) && (_channel[l]._isJump == true)) {
				_channel[l]._isJump = false;
			}

			uint32 new_size = _channel[l]._mixerSize;
			uint32 mixer_size = new_size;

			if (_channel[l]._initialized == false) {
				mixer_size *= 2;
				new_size *= 2;
			}

			if (_channel[l]._isJump == false) {
				if (_channel[l]._offset + mixer_size > _channel[l]._size) {
					new_size = _channel[l]._size - _channel[l]._offset;
					if (_channel[l]._numLoops == 0) {
						_channel[l]._toBeRemoved = true;
						mixer_size = new_size;
					}
				}
			} else if (_channel[l]._isJump == true) {
				if (_channel[l]._jump[0]._numLoops != 500) {
					_channel[l]._jump[0]._numLoops--;
				}
				if (_channel[l]._offset + mixer_size >= _channel[l]._jump[0]._offset) {
					new_size = _channel[l]._jump[0]._offset - _channel[l]._offset;
				}
			}

			byte *buf = (byte*)malloc(mixer_size);

			memcpy(buf, _channel[l]._data + _channel[l]._offset, new_size);
			if ((new_size != mixer_size) && (_channel[l]._isJump == true)) {
				memcpy(buf + new_size, _channel[l]._data + _channel[l]._jump[0]._dest, mixer_size - new_size);
				_channel[l]._offset = _channel[l]._jump[0]._dest + (mixer_size - new_size);
			} else if ((_channel[l]._numLoops > 0) && (new_size != mixer_size)) {
				memcpy(buf + new_size, _channel[l]._data, mixer_size - new_size);
				_channel[l]._offset = mixer_size - new_size;
			} else {
				_channel[l]._offset += mixer_size;
			}

			if (_channel[l]._bits == 12) {
				for(i = 0; i < (mixer_size / 4); i++) {
					byte sample1 = buf[i * 4 + 0];
					byte sample2 = buf[i * 4 + 1];
					byte sample3 = buf[i * 4 + 2];
					byte sample4 = buf[i * 4 + 3];
					uint16 sample_a = (uint16)(((int16)((sample1 << 8) | sample2) * _channel[l]._volumeRight) >> 8);
					uint16 sample_b = (uint16)(((int16)((sample3 << 8) | sample4) * _channel[l]._volume) >> 8);
					buf[i * 4 + 0] = (byte)(sample_a >> 8);
					buf[i * 4 + 1] = (byte)(sample_a & 0xff);
					buf[i * 4 + 2] = (byte)(sample_b >> 8);
					buf[i * 4 + 3] = (byte)(sample_b & 0xff);
				}
			} else if (_channel[l]._bits == 8) {
				for(i = 0; i < (mixer_size / 2); i++) {
					buf[i * 2 + 0] = (byte)(((int8)(buf[i * 2 + 0] ^ 0x80) * _channel[l]._volumeRight) >> 8) ^ 0x80;
					buf[i * 2 + 1] = (byte)(((int8)(buf[i * 2 + 1] ^ 0x80) * _channel[l]._volume) >> 8) ^ 0x80;
				}
			}

			if (_scumm->_silentDigitalImuse == false) {
				if (_channel[l]._initialized == false) {
					_scumm->_mixer->playStream(NULL, l, buf, mixer_size,
					                           _channel[l]._freq, _channel[l]._mixerFlags, 3, 2000000);
					_channel[l]._initialized = true;
				} else {
					_scumm->_mixer->append(l, buf, mixer_size, _channel[l]._freq, _channel[l]._mixerFlags);
				}
			}
		}
	}
}

void IMuseDigital::startSound(int sound) {
	debug(2, "IMuseDigital::startSound(%d)", sound);
	int32 l;

	for(l = 0; l < MAX_DIGITAL_CHANNELS; l++) {
		if(_channel[l]._used == false) {
			byte *ptr = _scumm->getResourceAddress(rtSound, sound);
			byte *s_ptr = ptr;
			if(ptr == NULL) {
				warning("IMuseDigital::startSound(%d) NULL resource pointer", sound);
				return;
			}
			_channel[l]._idSound = sound;
			_channel[l]._offset = 0;
			_channel[l]._numRegions = 0;
			_channel[l]._numJumps = 0;
			_channel[l]._volumeRight = 127;
			_channel[l]._volume = 127;
			_channel[l]._volumeFade = -1;
			_channel[l]._volumeFadeParam = 0;
			_channel[l]._delay = 1;

			uint32 tag, size = 0, r, t;

			if (READ_UINT32_UNALIGNED(ptr) == MKID('Crea')) {
				_channel[l]._bits = 8;
				_channel[l]._channels = 2;
				_channel[l]._mixerSize = (22050 / 5) * 2;
				_channel[l]._mixerFlags = SoundMixer::FLAG_AUTOFREE | SoundMixer::FLAG_STEREO | SoundMixer::FLAG_REVERSE_STEREO | SoundMixer::FLAG_UNSIGNED;
				byte * t_ptr= _scumm->_sound->readCreativeVocFile(ptr, size, _channel[l]._freq, _channel[l]._numLoops);

				if (_channel[l]._freq == 22222) {
					_channel[l]._freq = 22050;
				} else if (_channel[l]._freq == 10989) {
					_channel[l]._freq = 11025;
				}
				
				if (_channel[l]._freq == 11025) {
					_channel[l]._mixerSize /= 2;
				}
				size *= 2;
				_channel[l]._data = (byte *)malloc(size);
				for (t = 0; t < size / 2; t++) {
					*(_channel[l]._data + t * 2 + 0) = *(t_ptr + t);
					*(_channel[l]._data + t * 2 + 1) = *(t_ptr + t);
				}
				free(t_ptr);
				_channel[l]._size = size;
			} else if (READ_UINT32_UNALIGNED(ptr) == MKID('iMUS')) {
				ptr += 16;
				for (;;) {
					tag = READ_BE_UINT32(ptr); ptr += 4;
					switch(tag) {
						case MKID_BE('FRMT'):
							ptr += 12;
							_channel[l]._bits = READ_BE_UINT32(ptr); ptr += 4;
							_channel[l]._freq = READ_BE_UINT32(ptr); ptr += 4;
							_channel[l]._channels = READ_BE_UINT32(ptr); ptr += 4;
						break;
						case MKID_BE('TEXT'):
							size = READ_BE_UINT32(ptr); ptr += size + 4;
						break;
						case MKID_BE('REGN'):
							ptr += 4;
							if (_channel[l]._numRegions >= MAX_IMUSE_REGIONS) {
								warning("IMuseDigital::startSound(%d) Not enough space for Region");
								ptr += 8;
								break;
							}
							_channel[l]._region[_channel[l]._numRegions]._offset = READ_BE_UINT32(ptr); ptr += 4;
							_channel[l]._region[_channel[l]._numRegions]._length = READ_BE_UINT32(ptr); ptr += 4;
							_channel[l]._numRegions++;
						break;
						case MKID_BE('STOP'):
							ptr += 4;
							_channel[l]._offsetStop = READ_BE_UINT32(ptr); ptr += 4;
						break;
						case MKID_BE('JUMP'):
							ptr += 4;
							if (_channel[l]._numJumps >= MAX_IMUSE_JUMPS) {
								warning("IMuseDigital::startSound(%d) Not enough space for Jump");
								ptr += 16;
								break;
							}
							_channel[l]._jump[_channel[l]._numJumps]._offset = READ_BE_UINT32(ptr); ptr += 4;
							_channel[l]._jump[_channel[l]._numJumps]._dest = READ_BE_UINT32(ptr); ptr += 4;
							_channel[l]._jump[_channel[l]._numJumps]._id = READ_BE_UINT32(ptr); ptr += 4;
							_channel[l]._jump[_channel[l]._numJumps]._numLoops = READ_BE_UINT32(ptr); ptr += 4;
							_channel[l]._isJump = true;
							_channel[l]._numJumps++;
						break;
						case MKID_BE('DATA'):
							size = READ_BE_UINT32(ptr); ptr += 4;
						break;
						default:
							error("IMuseDigital::startSound(%d) Unknown sfx header %c%c%c%c", tag>>24, tag>>16, tag>>8, tag);
					}
					if (tag == MKID_BE('DATA')) break;
				}

//				if ((sound == 131) || (sound == 123) || (sound == 122)) {
					_channel[l]._isJump = false;
					_channel[l]._numJumps = 0;
//				}

				uint32 header_size = ptr - s_ptr;
				_channel[l]._offsetStop -= header_size;
				if (_channel[l]._bits == 12) {
					_channel[l]._offsetStop = (_channel[l]._offsetStop / 3) * 4;
				}
				for (r = 0; r < _channel[l]._numRegions; r++) {
					_channel[l]._region[r]._offset -= header_size;
					if (_channel[l]._bits == 12) {
						_channel[l]._region[r]._offset = (_channel[l]._region[r]._offset / 3) * 4;
						_channel[l]._region[r]._length = (_channel[l]._region[r]._length / 3) * 4;
					}
				}
				if (_channel[l]._numJumps > 0) {
					for (r = 0; r < _channel[l]._numJumps; r++) {
						_channel[l]._jump[r]._offset -= header_size;
						_channel[l]._jump[r]._dest -= header_size;
						if (_channel[l]._bits == 12) {
							_channel[l]._jump[r]._offset = (_channel[l]._jump[r]._offset / 3) * 4;
							_channel[l]._jump[r]._dest = (_channel[l]._jump[r]._dest / 3) * 4;
						}
					}
				}
				_channel[l]._mixerSize = (22050 / 5) * 2;
				_channel[l]._mixerFlags = SoundMixer::FLAG_AUTOFREE | SoundMixer::FLAG_STEREO | SoundMixer::FLAG_REVERSE_STEREO;
				if (_channel[l]._bits == 12) {
					_channel[l]._mixerSize *= 2;
					_channel[l]._mixerFlags |= SoundMixer::FLAG_16BITS;
					_channel[l]._size = _scumm->_sound->decode12BitsSample(ptr, &_channel[l]._data, size, (_channel[l]._channels == 2) ? false : true);
				}
				if (_channel[l]._bits == 8) {
					_channel[l]._mixerFlags |= SoundMixer::FLAG_UNSIGNED;
					if (_channel[l]._channels == 1) {
						size *= 2;
						_channel[l]._channels = 2;
						_channel[l]._data = (byte *)malloc(size);
						for (t = 0; t < size / 2; t++) {
							*(_channel[l]._data + t * 2 + 0) = *(ptr + t);
							*(_channel[l]._data + t * 2 + 1) = *(ptr + t);
						}
					} else {
						_channel[l]._data = (byte *)malloc(size);
						memcpy(_channel[l]._data, ptr, size);
					}
					_channel[l]._size = size;
				}
				if (_channel[l]._freq == 11025) {
					_channel[l]._mixerSize /= 2;
				}
			}
			_channel[l]._toBeRemoved = false;
			_channel[l]._used = true;
			break;
		}
	}
}

void IMuseDigital::stopSound(int sound) {
	debug(2, "IMuseDigital::stopSound(%d)", sound);
	for (int32 l = 0; l < MAX_DIGITAL_CHANNELS; l++) {
		if ((_channel[l]._idSound == sound) && (_channel[l]._used == true)) {
			_channel[l]._toBeRemoved = true;
		}
	}
}

void IMuseDigital::stopAll() {
	for (int32 l = 0; l < MAX_DIGITAL_CHANNELS; l++) {
		if (_channel[l]._used == true) {
			_channel[l]._toBeRemoved = true;
		}
	}
}

void IMuseDigital::pause(bool p) {
	_pause = p;
}

int32 IMuseDigital::doCommand(int a, int b, int c, int d, int e, int f, int g, int h) {
	byte cmd = a & 0xFF;
	byte param = a >> 8;
	int32 sample = b, r;
	byte sub_cmd = c >> 8;
	int8 chan = -1, l;
	int8 tmp;

	if (!(cmd || param))
		return 1;

	if (param == 0) {
		switch (cmd) {
		case 12:
			switch (sub_cmd) {
			case 5:
				debug(2, "IMuseDigital::doCommand 12,5 sample(%d), param(%d)", sample, d);
				return 0;
			case 6: // volume control (0-127)
				debug(2, "IMuseDigital::doCommand setting volume sample(%d), volume(%d)", sample, d);
				for (l = 0; l < MAX_DIGITAL_CHANNELS; l++) {
					if ((_channel[l]._idSound == sample) && (_channel[l]._used == true)) {
						chan = l;
						break;
					}
				}
				if (chan == -1) {
					debug(2, "IMuseDigital::doCommand 12,6 sample(%d) not exist in channels", sample);
					return 1;
				}
				_channel[chan]._volume = d;
				_channel[chan]._volumeRight = d;
				if (_channel[chan]._volumeFade != -1) {
					tmp = ((_channel[chan]._volumeFade - _channel[chan]._volume) * 2) / _channel[chan]._volumeFadeParam;
					if ((tmp < 0) && (tmp > -2)) {
						tmp = -1;
					} else if ((tmp > 0) && (tmp < 2)) {
						tmp = 1;
					} else {
						tmp /= 2;
					}
				_channel[chan]._volumeFadeStep = tmp;
				}
				return 0;
			case 7: // right volume control (0-127)
				debug(2, "IMuseDigital::doCommand setting right volume sample(%d),volume(%d)", sample, d);
				for (l = 0; l < MAX_DIGITAL_CHANNELS; l++) {
					if ((_channel[l]._idSound == sample) && (_channel[l]._used == true)) {
						chan = l;
						break;
					}
				}
				if (chan == -1) {
					debug(2, "IMuseDigital::doCommand 12,7 sample(%d) not exist in channels", sample);
					return 1;
				}
				_channel[chan]._volumeRight = d;
				return 0;
			default:
				warning("IMuseDigital::doCommand 12 DEFAULT sub command %d", sub_cmd);
				return 1;
			}
		case 14:
			switch (sub_cmd) {
			case 6: // fade volume control
				debug(2, "IMuseDigital::doCommand fading volume sample(%d),fade(%d, %d)", sample, d, e);
				for (l = 0; l < MAX_DIGITAL_CHANNELS; l++) {
					if ((_channel[l]._idSound == sample) && (_channel[l]._used == true)) {
						chan = l;
						break;
					}
				}
				if (chan == -1) {
						debug(2, "IMuseDigital::doCommand 14,6 sample %d not exist in channels", sample);
					return 1;
				}
				_channel[chan]._volumeFade = d;
				_channel[chan]._volumeFadeParam = e;
				tmp = ((_channel[chan]._volumeFade - _channel[chan]._volume) * 2) / _channel[chan]._volumeFadeParam;
				if ((tmp < 0) && (tmp > -2)) {
					tmp = -1;
				} else if ((tmp > 0) && (tmp < 2)) {
					tmp = 1;
				} else {
					tmp /= 2;
				}
				_channel[chan]._volumeFadeStep = tmp;
				return 0;
			default:
				warning("IMuseDigital::doCommand 14 DEFAULT sub command %d", sub_cmd);
				return 1;
			}
		default:
			warning("IMuseDigital::doCommand DEFAULT command %d", cmd);
			return 1;
		}
	} else if (param == 16) {
		switch (cmd) {
		case 0: // play music (state)
			debug(2, "IMuseDigital::doCommand 0x1000 (%d)", b);
			if (_scumm->_gameId == GID_DIG) {
				for(l = 0;; l++) {
					if (_digStateMusicMap[l].room == -1) {
						return 1;
					}
					if (_digStateMusicMap[l].room == b) {
						int16 music = _digStateMusicMap[l].table_index;
						debug(2, "Play imuse music: %s, %s, %s", _digStateMusicTable[music].name, _digStateMusicTable[music].title, _digStateMusicTable[music].filename);
						if (_digStateMusicTable[music].filename[0] != 0) {
							_scumm->_sound->playBundleMusic((char*)&_digStateMusicTable[music].filename);
						}
						return 0;
					}
				}
			} else if (_scumm->_gameId == GID_FT) {
				for(l = 0;; l++) {
					if (_ftStateMusicTable[l].index == -1) {
						return 1;
					}
					if (_ftStateMusicTable[l].index == b) {
						debug(2, "Play imuse music: %s, %s", _ftStateMusicTable[l].name, _ftStateMusicTable[l].audioname);
						if (_ftStateMusicTable[l].audioname[0] != 0) {
							for(r = 0; r < _scumm->_numAudioNames; r++) {
								if (strcmp(_ftStateMusicTable[l].audioname, &_scumm->_audioNames[r * 9]) == 0) {
									startSound(r);
									doCommand(12, r, 1536, _ftStateMusicTable[l].volume, 0, 0, 0, 0);
								}
							}
						}
					}
				}
			}
			return 0;
		case 1: // play music (seq)
			debug(2, "IMuseDigital::doCommand 0x1001 (%d)", b);
			if (_scumm->_gameId == GID_DIG) {
				for(l = 0;; l++) {
					if (_digSeqMusicTable[l].index == -1) {
						return 1;
					}
					if ((_digSeqMusicTable[l].index == b)) {
						debug(2, "Play imuse music: %s, %s, %s", _digSeqMusicTable[l].name, _digSeqMusicTable[l].title, _digSeqMusicTable[l].filename);
						if (_digSeqMusicTable[l].filename[0] != 0) {
							_scumm->_sound->playBundleMusic((char*)&_digSeqMusicTable[l].filename);
						}
						return 0;
					}
				}
			} else if (_scumm->_gameId == GID_FT) {
				for(l = 0;; l++) {
					if (_ftSeqMusicTable[l].index == -1) {
						return 1;
					}
					if (_ftSeqMusicTable[l].index == b) {
						debug(2, "Play imuse music: %s, %s", _ftSeqMusicTable[l].name, _ftSeqMusicTable[l].audioname);
						if (_ftSeqMusicTable[l].audioname[0] != 0) {
							for(r = 0; r < _scumm->_numAudioNames; r++) {
								if (strcmp(_ftSeqMusicTable[l].audioname, &_scumm->_audioNames[r * 9]) == 0) {
									startSound(r);
									doCommand(12, r, 1536, _ftSeqMusicTable[l].volume, 0, 0, 0, 0);
								}
							}
						}
					}
				}
			}
			return 0;
		case 2: // dummy in DIG and CMI
			debug(2, "IMuseDigital::doCommand 0x1002 (%d)", b);
			return 0;
		case 3: // ??? (stream related)
			debug(2, "IMuseDigital::doCommand 0x1003 (%d,%d)", b, c);
			return 0;
		default:
			warning("IMuseDigital::doCommand (0x1xxx) DEFAULT command %d", cmd);
			return 1;
		}
	}

	return 1;
}

int IMuseDigital::getSoundStatus(int sound) {
	debug(2, "IMuseDigital::getSoundStatus(%d)", sound);
	for (int32 l = 0; l < MAX_DIGITAL_CHANNELS; l++) {
		if ((_channel[l]._idSound == sound) && (_channel[l]._used == true)) {
			return 1;
		}
	}

	return 0;
}