/*

* Adplug - Replayer for many OPL2/OPL3 audio file formats.

* Copyright (C) 1999 - 2008 Simon Peter, <dn.tlp@gmx.net>, et al.

*

* This library is free software; you can redistribute it and/or

* modify it under the terms of the GNU Lesser General Public

* License as published by the Free Software Foundation; either

* version 2.1 of the License, or (at your option) any later version.

*

* This library is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

* Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public

* License along with this library; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

*

* a2m-v2.cpp - Adlib Tracker II Player by Dmitry Smagin <dmitry.s.smagin@gmail.com>

* Originally by Stanislav Baranec <subz3ro.altair@gmail.com>

*

* NOTES:

* This player loads a2m and a2t modules versions 1 - 14.

* The code is adapted directly from FreePascal sources of the Adlib Tracker II

*

* REFERENCES:

* https://github.com/ijsf/at2

* http://www.adlibtracker.net/

*

*/

#include "a2m-v2.h"

#include "debug.h"

#include <climits>

#include <math.h>

static const uint8_t _panning[3] = { 0x30, 0x10, 0x20 };

static const uint8_t def_vibtrem_table[256] = {

0,24,49,74,97,120,141,161,180,197,212,224,235,244,250,253,255,

253,250,244,235,224,212,197,180,161,141,120,97,74,49,24,

0,24,49,74,97,120,141,161,180,197,212,224,235,244,250,253,255,

253,250,244,235,224,212,197,180,161,141,120,97,74,49,24,

0,24,49,74,97,120,141,161,180,197,212,224,235,244,250,253,255,

253,250,244,235,224,212,197,180,161,141,120,97,74,49,24,

0,24,49,74,97,120,141,161,180,197,212,224,235,244,250,253,255,

253,250,244,235,224,212,197,180,161,141,120,97,74,49,24,

0,24,49,74,97,120,141,161,180,197,212,224,235,244,250,253,255,

253,250,244,235,224,212,197,180,161,141,120,97,74,49,24,

0,24,49,74,97,120,141,161,180,197,212,224,235,244,250,253,255,

253,250,244,235,224,212,197,180,161,141,120,97,74,49,24,

0,24,49,74,97,120,141,161,180,197,212,224,235,244,250,253,255,

253,250,244,235,224,212,197,180,161,141,120,97,74,49,24,

0,24,49,74,97,120,141,161,180,197,212,224,235,244,250,253,255,

253,250,244,235,224,212,197,180,161,141,120,97,74,49,24

};

/*** public methods *************************************/

CPlayer *Ca2mv2Player::factory(Copl *newopl)

{

return new Ca2mv2Player(newopl);

}

Ca2mv2Player::Ca2mv2Player(Copl *newopl) : CPlayer(newopl)

{

songinfo = new tSONGINFO();

instrinfo = new tINSTR_INFO();

eventsinfo = new tEVENTS_INFO();

ch = new tCHDATA();

}

Ca2mv2Player::~Ca2mv2Player()

{

arpvib_tables_free();

patterns_free();

instruments_free();

delete songinfo;

delete instrinfo;

delete eventsinfo;

delete ch;

}

bool Ca2mv2Player::update()

{

newtimer();

return !songend;

}

void Ca2mv2Player::rewind(int subsong)

{

chip = 0;

opl->init();

opl->setchip(0);

init_player();

songend = false;

set_current_order(0);

if ((songinfo->pattern_order[current_order] > 0x7f))

return;

current_pattern = songinfo->pattern_order[current_order];

current_line = 0;

pattern_break = false;

pattern_delay = false;

tickXF = 0;

ticks = 0;

next_line = 0;

irq_mode = true;

play_status = isPlaying;

ticklooper = 0;

macro_ticklooper = 0;

speed = songinfo->speed;

macro_speedup = songinfo->macro_speedup;

update_timer(songinfo->tempo);

}

float Ca2mv2Player::getrefresh()

{

return (float)tempo * _macro_speedup();

}

std::string Ca2mv2Player::gettype() {

char tmpstr[42];

snprintf(tmpstr, sizeof (tmpstr), "Adlib Tracker 2 (%sversion %d)", (type == 1 ? "tiny module " : ""), ffver);

return std::string(tmpstr);

};

bool Ca2mv2Player::load(const std::string &filename, const CFileProvider &fp)

{

binistream *f = fp.open(filename);

if (!f)

return false;

if (!fp.extension(filename, ".a2m") && !fp.extension(filename, ".a2t")) {

fp.close(f);

return false;

}

// Read the whole file

unsigned long size = fp.filesize(f);

char *tune = (char *)calloc(1, size);

f->readString(tune, size);

fp.close(f);

bool result = a2_import(tune, size);

free(tune);

if (result)

rewind(0);

return result;

}

// Helpers for instruments ========================================================================

void Ca2mv2Player::instruments_free()

{

if (instrinfo->instruments) {

for (unsigned int i = 0; i < instrinfo->count; i++) {

if (instrinfo->instruments[i].fmreg) {

free(instrinfo->instruments[i].fmreg);

instrinfo->instruments[i].fmreg = NULL;

}

}

free(instrinfo->instruments);

instrinfo->instruments = NULL;

instrinfo->count = 0;

instrinfo->size = 0;

}

}

void Ca2mv2Player::instruments_allocate(size_t number)

{

if (editor_mode) {

number = 255; // Allocate max possible

}

instruments_free();

size_t size = number * sizeof(tINSTR_DATA_EXT);

instrinfo->instruments = (tINSTR_DATA_EXT *)calloc(1, size);

assert(instrinfo->instruments);

instrinfo->count = number;

instrinfo->size = size;

}

tINSTR_DATA_EXT *Ca2mv2Player::get_instr(uint8_t ins)

{

if (ins == 0 || ins > instrinfo->count ) {

return NULL;

}

return &instrinfo->instruments[ins - 1];

}

inline int8_t Ca2mv2Player::get_instr_fine_tune(uint8_t ins)

{

tINSTR_DATA_EXT *instrument = get_instr(ins);

return instrument ? instrument->instr_data.fine_tune : 0;

}

inline tINSTR_DATA *Ca2mv2Player::get_instr_data_by_ch(int chan)

{

tINSTR_DATA_EXT *instrument = get_instr(ch->voice_table[chan]);

return instrument ? &instrument->instr_data : NULL;

}

inline char Ca2mv2Player::get_fm_connect_by_chan(int chan)

{

tINSTR_DATA *instr = get_instr_data_by_ch(chan);

if (!instr) {

AdPlug_LogWrite("get_fm_connect_by_chan: instr not set for channel %d\n", chan);

}

return instr ? instr->fm.connect : 0;

}

inline tINSTR_DATA *Ca2mv2Player::get_instr_data(uint8_t ins)

{

tINSTR_DATA_EXT *instrument = get_instr(ins);

return instrument ? &instrument->instr_data : NULL;

}

// Fill tFM_INST_DATA from the raw byte array

void Ca2mv2Player::fmdata_fill_from_raw(tFM_INST_DATA *fm, uint8_t *src)

{

fm->multipM = src[0] & 0xf;

fm->ksrM = (src[0] >> 4) & 1;

fm->sustM = (src[0] >> 5) & 1;

fm->vibrM = (src[0] >> 6) & 1;

fm->tremM = (src[0] >> 7) & 1;

fm->multipC = src[1] & 0xf;

fm->ksrC = (src[1] >> 4) & 1;

fm->sustC = (src[1] >> 5) & 1;

fm->vibrC = (src[1] >> 6) & 1;

fm->tremC = (src[1] >> 7) & 1;

fm->volM = src[2] & 0x3f;

fm->kslM = (src[2] >> 6) & 3;

fm->volC = src[3] & 0x3f;

fm->kslC = (src[3] >> 6) & 3;

fm->decM = src[4] & 0xf;

fm->attckM = (src[4] >> 4) & 0xf;

fm->decC = src[5] & 0xf;

fm->attckC = (src[5] >> 4) & 0xf;

fm->relM = src[6] & 0xf;

fm->sustnM = (src[6] >> 4) & 0xf;

fm->relC = src[7] & 0xf;

fm->sustnC = (src[7] >> 4) & 0xf;

fm->wformM = src[8] & 7;

fm->wformC = src[9] & 7;

fm->connect = src[10] & 1;

fm->feedb = (src[10] >> 1) & 7;

}

// Fill uint8_t data[11] array from tFM_INST_DATA

void Ca2mv2Player::raw_fill_from_fmdata(uint8_t *dst, tFM_INST_DATA *fm)

{

dst[0] = (fm->multipM & 0xf) |

((fm->ksrM & 1) << 4) |

((fm->sustM & 1) << 5) |

((fm->vibrM & 1) << 6) |

((fm->tremM & 1) << 7);

dst[1] = (fm->multipC & 0xf) |

((fm->ksrC & 1) << 4) |

((fm->sustC & 1) << 5) |

((fm->vibrC & 1) << 6) |

((fm->tremC & 1) << 7);

dst[2] = (fm->volM & 0x3f) | ((fm->kslM & 3) << 6);

dst[3] = (fm->volC & 0x3f) | ((fm->kslC & 3) << 6);

dst[4] = (fm->decM & 0xf) | ((fm->attckM & 0xf) << 4);

dst[5] = (fm->decC & 0xf) | ((fm->attckC & 0xf) << 4);

dst[6] = (fm->relM & 0xf) | ((fm->sustnM & 0xf) << 4);

dst[7] = (fm->relC & 0xf) | ((fm->sustnC & 0xf) << 4);

dst[8] = fm->wformM & 7;

dst[9] = fm->wformC & 7;

dst[10] = (fm->connect & 1) | ((fm->feedb & 7) << 1);

}

// Helpers for macro tables =======================================================================

/* If FMREG length byte is 0, infer span from macro cells when any cell has duration, freq_slide,

* or macro_flags. Also allocate fmreg when header bytes [1..5] are non-zero even if length stays 0

* — Pascal still binds arpeggio/vibrato indices from the FMREG header (top-2act instr 19: vibrato

* table 1 with empty macro cells). */

uint8_t Ca2mv2Player::fmreg_infer_length_from_cells(const uint8_t *src)

{

uint8_t inferred = 0;

for (unsigned int e = 0; e < 255; e++) {

const uint8_t *cell = &src[6 + e * tREGISTER_TABLE_DEF_V9_14_SIZE];

uint8_t dur = cell[14];

int16_t fs = (int16_t)(cell[11] | (cell[12] << 8));

uint8_t mf = (uint8_t)(cell[10] & 0xf0);

if (dur != 0 || fs != 0 || mf != 0)

inferred = (uint8_t)(e + 1);

}

return inferred;

}

void Ca2mv2Player::fmreg_table_allocate(size_t n, uint8_t *src)

{

n = editor_mode ? 255 : n;

// Note: for editor_mode allocate max entries possible

for (unsigned int i = 0; i < n; i++, src += tFMREG_TABLE_V9_14_SIZE) {

uint8_t real_length = src[0];

if (real_length == 0) {

uint8_t inferred = fmreg_infer_length_from_cells(src);

if (inferred)

real_length = inferred;

}

/* Loop/keyoff/arp/vib header — Pascal keeps instr_macros[] row even when length=0 and no cells */

bool header_links = (src[1] | src[2] | src[3] | src[4] | src[5]) != 0;

/* Pascal: when src[0]==0, macro_poll_proc immediately terminates (fmreg_pos→finished_flag),

* never processing cell data. Only allocate if original length is non-zero or header links exist. */

if (editor_mode || src[0] || header_links) {

tINSTR_DATA_EXT *instrument = get_instr(i + 1);

assert(instrument);

if (!instrument)

continue;

instrument->fmreg = (tFMREG_TABLE *)calloc(1, sizeof(tFMREG_TABLE));

assert(instrument->fmreg);

// Copy field by field — use src[0] (original), not real_length (inferred)

instrument->fmreg->length = src[0];

instrument->fmreg->loop_begin = src[1]; // loop_begin

instrument->fmreg->loop_length = src[2]; // loop_length

instrument->fmreg->keyoff_pos = src[3]; // keyoff_pos

instrument->fmreg->arpeggio_table = src[4]; // arpeggio_table

instrument->fmreg->vibrato_table = src[5]; // vibrato_table

uint8_t *rts = &src[6];

for (unsigned int e = 0; e < 255; e++, rts += tREGISTER_TABLE_DEF_V9_14_SIZE) {

tREGISTER_TABLE_DEF *rtd = &instrument->fmreg->data[e];

fmdata_fill_from_raw(&rtd->fm, rts);

rtd->freq_slide = (int16_t)(rts[11] | (rts[12] << 8));

rtd->panning = rts[13]; // panning

rtd->duration = rts[14]; // duration

rtd->macro_flags = rts[10] & 0xf0;

if (rtd->macro_flags)

AdPlug_LogWrite("instr(%02x).macro_flags: 0x%x\n", i + 1, rtd->macro_flags);

}

}

}

}

void Ca2mv2Player::disabled_fmregs_import(size_t n, bool dis_fmregs[255][28])

{

n = editor_mode ? 255 : n;

// shrink bool[255][28] to uint32_t[255], use bits as enable/disable flag

for (unsigned int i = 0; i < n; i++) {

uint32_t result = 0; // all enabled by default

for (unsigned int bit = 0; bit < 28; bit++) {

result |= (dis_fmregs[i][bit] & 1) << bit;

}

tINSTR_DATA_EXT *instrument = get_instr(i + 1);

assert(instrument);

if (!instrument)

continue;

instrument->dis_fmreg_cols = result;

}

}

void Ca2mv2Player::arpvib_tables_free()

{

if (!vibrato_table || !arpeggio_table)

return;

for (unsigned int i = 0; i < arpvib_count; i++) {

free(vibrato_table[i]);

free(arpeggio_table[i]);

vibrato_table[i] = 0;

arpeggio_table[i] = 0;

}

delete[] vibrato_table;

vibrato_table = NULL;

delete[] arpeggio_table;

arpeggio_table = NULL;

arpvib_count = 0;

}

void Ca2mv2Player::arpvib_tables_allocate(size_t n, uint8_t *src)

{

arpvib_tables_free();

// Note: for editor_mode allocate max entries possible

n = editor_mode ? 255 : n;

vibrato_table = new tVIBRATO_TABLE *[n]();

arpeggio_table = new tARPEGGIO_TABLE *[n]();

arpvib_count = n;

for (unsigned int i = 0; i < n; i++, src += tARPVIB_TABLE_V9_14_SIZE) {

if (editor_mode || src[0] /*arpeggio.length*/) {

arpeggio_table[i] = (tARPEGGIO_TABLE *)calloc(1, sizeof(tARPEGGIO_TABLE));

// Copy field by field

arpeggio_table[i]->length = src[0] /*arpeggio.length*/;

arpeggio_table[i]->speed = src[1] /*arpeggio.speed*/;

arpeggio_table[i]->loop_begin = src[2] /*arpeggio.loop_begin*/;

arpeggio_table[i]->loop_length = src[3] /*arpeggio.loop_length*/;

arpeggio_table[i]->keyoff_pos = src[4] /*arpeggio.keyoff_pos*/;

memcpy(arpeggio_table[i]->data, &src[5] /*arpeggio.data*/, 255);

}

if (editor_mode || src[260] /*vibrato.length*/) {

vibrato_table[i] = (tVIBRATO_TABLE *)calloc(1, sizeof(tVIBRATO_TABLE));

// Copy field by field

vibrato_table[i]->length = src[260] /*vibrato.length*/;

vibrato_table[i]->speed = src[261] /*vibrato.speed*/;

vibrato_table[i]->delay = src[262] /*vibrato.delay*/;

vibrato_table[i]->loop_begin = src[263] /*vibrato.loop_begin*/;

vibrato_table[i]->loop_length = src[264] /*vibrato.loop_length*/;

vibrato_table[i]->keyoff_pos = src[265] /*vibrato.keyoff_pos*/;

memcpy(vibrato_table[i]->data, &src[266] /*vibrato.data*/, 255);

}

}

}

tARPEGGIO_TABLE *Ca2mv2Player::get_arpeggio_table(uint8_t arp_table)

{

return arp_table && arpeggio_table && arpeggio_table[arp_table - 1] ? arpeggio_table[arp_table - 1] : NULL;

}

tVIBRATO_TABLE *Ca2mv2Player::get_vibrato_table(uint8_t vib_table)

{

return vib_table && vibrato_table && vibrato_table[vib_table - 1] ? vibrato_table[vib_table - 1] : NULL;

}

tFMREG_TABLE *Ca2mv2Player::get_fmreg_table(uint8_t fmreg_ins)

{

tINSTR_DATA_EXT *instrument = get_instr(fmreg_ins);

return instrument && instrument->fmreg ? instrument->fmreg : NULL;

}

// Helpers for patterns ===========================================================================

// event = pattern * (channels * rows) + ch * rows + row

tADTRACK2_EVENT *Ca2mv2Player::get_event_p(int pattern, int channel, int row)

{

static tADTRACK2_EVENT null_event = { 0 };

return (

pattern < eventsinfo->patterns

? &eventsinfo->events[

pattern * eventsinfo->channels * eventsinfo->rows +

channel * eventsinfo->rows + row]

: &null_event

);

}

void Ca2mv2Player::patterns_free()

{

if (eventsinfo->events && eventsinfo->size) {

free(eventsinfo->events);

eventsinfo->events = NULL;

eventsinfo->size = 0;

}

}

void Ca2mv2Player::patterns_allocate(int patterns, int channels, int rows)

{

if (editor_mode) { // allocate max possible

patterns = 128;

channels = 20;

rows = 256;

}

patterns_free();

size_t size = patterns * channels * rows * sizeof(tADTRACK2_EVENT);

eventsinfo->events = (tADTRACK2_EVENT *)calloc(1, size);

assert(eventsinfo->events);

eventsinfo->patterns = patterns;

eventsinfo->channels = channels;

eventsinfo->rows = rows;

eventsinfo->size = size;

}

// End of patterns helpers ========================================================================

inline bool note_in_range(uint8_t note)

{

uint8_t n = note & (uint8_t)~keyoff_flag;

/* Pascal output_note: NOT (note in [1..12*8+1]) uses the inclusive upper bound 97 (a2player.pas). */

return n >= 1 && n <= (uint8_t)(12 * 8 + 1);

}

inline uint16_t Ca2mv2Player::regoffs_n(int chan)

{

static const uint16_t _ch_n[2][20] = {

{ // mm

0x003,0x000,0x004,0x001,0x005,0x002,0x006,0x007,0x008,0x103,

0x100,0x104,0x101,0x105,0x102,0x106,0x107,0x108,BYTE_NULL,BYTE_NULL

}, { // pm

0x003,0x000,0x004,0x001,0x005,0x002,0x106,0x107,0x108,0x103,

0x100,0x104,0x101,0x105,0x102,0x006,0x007,0x008,0x008,0x007

}

};

return _ch_n[!!percussion_mode][chan];

}

inline uint16_t Ca2mv2Player::regoffs_m(int chan)

{

static const uint16_t _ch_m[2][20] = {

{ // mm

0x008,0x000,0x009,0x001,0x00a,0x002,0x010,0x011,0x012,0x108,

0x100,0x109,0x101,0x10a,0x102,0x110,0x111,0x112,BYTE_NULL,BYTE_NULL

}, { // pm

0x008,0x000,0x009,0x001,0x00a,0x002,0x110,0x111,0x112,0x108,

0x100,0x109,0x101,0x10a,0x102,0x010,0x014,0x012,0x015,0x011

}

};

return _ch_m[!!percussion_mode][chan];

}

inline uint16_t Ca2mv2Player::regoffs_c(int chan)

{

static const uint16_t _ch_c[2][20] = {

{

0x00b,0x003,0x00c,0x004,0x00d,0x005,0x013,0x014,0x015,0x10b,

0x103,0x10c,0x104,0x10d,0x105,0x113,0x114,0x115,BYTE_NULL,BYTE_NULL

}, {

0x00b,0x003,0x00c,0x004,0x00d,0x005,0x113,0x114,0x115,0x10b,

0x103,0x10c,0x104,0x10d,0x105,0x013,BYTE_NULL,BYTE_NULL,BYTE_NULL,BYTE_NULL

}

};

return _ch_c[!!percussion_mode][chan];

}

#define FreqStart 0x156

#define FreqEnd 0x2ae

#define FreqRange (FreqEnd - FreqStart)

/* Round a/b to nearest integer (matching Pascal's Round(a/b) for positive ints) */

#define ROUND_DIV(a, b) (((a) + (b) / 2) / (b))

/* PLAYER */

void Ca2mv2Player::opl2out(uint16_t reg, uint16_t data)

{

if (chip != 0) {

chip = 0;

opl->setchip(chip);

}

opl->write(reg, data);

}

void Ca2mv2Player::opl3out(uint16_t reg, uint8_t data)

{

int _chip = reg < 0x100 ? 0 : 1;

if (chip != _chip) {

chip = _chip;

opl->setchip(chip);

}

opl->write(reg & 0xff, data);

}

void Ca2mv2Player::opl3exp(uint16_t data)

{

if (chip != 1) {

chip = 1;

opl->setchip(chip);

}

opl->write(data & 0xff, (data >> 8) & 0xff);

}

static uint16_t nFreq(uint8_t note)

{

static uint16_t Fnum[12] = {0x157,0x16b,0x181,0x198,0x1b0,0x1ca,0x1e5,

0x202,0x220,0x241,0x263,0x287};

if (note >= 12 * 8)

return (7 << 10) | FreqEnd;

return (note / 12 << 10) | Fnum[note % 12];

}

static uint16_t calc_freq_shift_up(uint16_t freq, uint16_t shift)

{

uint16_t oc = (freq >> 10) & 7;

uint16_t fr = (freq & 0x3ff) + shift;

if (fr >= FreqEnd) {

if (oc == 7) {

fr = FreqEnd;

} else {

oc++;

fr -= FreqRange;

}

}

return (uint16_t)((oc << 10) + fr);

}

static uint16_t calc_freq_shift_down(uint16_t freq, uint16_t shift)

{

uint16_t oc = (freq >> 10) & 7;

uint16_t fr = (freq & 0x3ff) - shift;

if (fr <= FreqStart) {

if (oc == 0) {

fr = FreqStart;

} else {

oc--;

fr += FreqRange;

}

}

return (uint16_t)((oc << 10) + fr);

}

/* == calc_vibtrem_shift() in AT2 */

uint16_t Ca2mv2Player::calc_vibrato_shift(uint8_t depth, uint8_t position)

{

/* depth: 0..F, max result: FF*F=EF1 */

uint16_t X = (uint16_t)depth * vibtrem_table[position & (vibtrem_table_size - 1)];

uint16_t rotated = (X << 1) | (X >> 15);

uint16_t result = ((rotated >> 8) & 0xFF) | ((rotated & 1) << 8);

return result;

}

void Ca2mv2Player::change_freq(int chan, uint16_t freq)

{

if (is_4op_chan(chan) && is_4op_chan_hi(chan)) {

ch->freq_table[chan + 1] = ch->freq_table[chan];

chan++;

}

ch->freq_table[chan] &= ~0x1fff;

ch->freq_table[chan] |= (freq & 0x1fff);

uint16_t n = regoffs_n(chan);

opl3out(0xa0 + n, ch->freq_table[chan] & 0xFF);

opl3out(0xb0 + n, (ch->freq_table[chan] >> 8) & 0xFF);

if (is_4op_chan(chan) && is_4op_chan_lo(chan)) {

ch->freq_table[chan - 1] = ch->freq_table[chan];

}

}

bool Ca2mv2Player::is_chan_adsr_data_empty(int chan)

{

tFM_INST_DATA *fmpar = &ch->fmpar_table[chan];

uint8_t data[11];

raw_fill_from_fmdata(data, fmpar);

return (

!data[4] &&

!data[5] &&

!data[6] &&

!data[7]

);

}

bool Ca2mv2Player::is_ins_adsr_data_empty(int ins)

{

tINSTR_DATA *i = get_instr_data(ins);

if (!i)

return true;

uint8_t data[11];

raw_fill_from_fmdata(data, &i->fm);

return (

!data[4] &&

!data[5] &&

!data[6] &&

!data[7]

);

}

static bool is_data_empty(char *data, unsigned int size)

{

while (size--) {

if (*(char *)data++)

return false;

}

return true;

}

static inline uint16_t max(uint16_t value, uint16_t maximum)

{

return (value > maximum ? maximum : value);

}

static inline uint16_t min(uint16_t value, uint16_t minimum)

{

return (value < minimum ? minimum : value);

}

void Ca2mv2Player::change_frequency(int chan, uint16_t freq)

{

ch->macro_table[chan].vib_paused = true;

change_freq(chan, freq);

if (is_4op_chan(chan)) {

int i = is_4op_chan_hi(chan) ? 1 : -1;

ch->macro_table[chan + i].vib_count = 1;

ch->macro_table[chan + i].vib_pos = 0;

ch->macro_table[chan + i].vib_freq = freq;

ch->macro_table[chan + i].vib_paused = false;

}

ch->macro_table[chan].vib_count = 1;

ch->macro_table[chan].vib_pos = 0;

ch->macro_table[chan].vib_freq = freq;

ch->macro_table[chan].vib_paused = false;

}

inline uint16_t Ca2mv2Player::_macro_speedup()

{

return macro_speedup ? macro_speedup : 1;

}

void Ca2mv2Player::set_clock_rate(uint8_t clock_rate)

{

}

void Ca2mv2Player::update_timer(int Hz)

{

if (Hz == 0) {

set_clock_rate(0);

return;

} else {

tempo = Hz;

}

if (tempo == 18 && timer_fix) {

IRQ_freq = ((float)tempo + 0.2) * 20.0;

} else {

IRQ_freq = 250;

}

while (IRQ_freq % (tempo * _macro_speedup()) != 0) {

IRQ_freq++;

}

if (IRQ_freq > MAX_IRQ_FREQ)

IRQ_freq = MAX_IRQ_FREQ;

while ((IRQ_freq + IRQ_freq_shift + playback_speed_shift > MAX_IRQ_FREQ) && (playback_speed_shift > 0))

playback_speed_shift--;

while ((IRQ_freq + IRQ_freq_shift + playback_speed_shift > MAX_IRQ_FREQ) && (IRQ_freq_shift > 0))

IRQ_freq_shift--;

set_clock_rate(1193180 / max(IRQ_freq + IRQ_freq_shift + playback_speed_shift, MAX_IRQ_FREQ));

}

void Ca2mv2Player::update_playback_speed(int speed_shift)

{

if (!speed_shift)

return;

if ((speed_shift > 0) && (IRQ_freq + playback_speed_shift + speed_shift > MAX_IRQ_FREQ)) {

while (IRQ_freq + IRQ_freq_shift + playback_speed_shift + speed_shift > MAX_IRQ_FREQ)

speed_shift--;

} else if ((speed_shift < 0) && (IRQ_freq + IRQ_freq_shift + playback_speed_shift + speed_shift < MIN_IRQ_FREQ)) {

while (IRQ_freq + IRQ_freq_shift + playback_speed_shift + speed_shift < MIN_IRQ_FREQ)

speed_shift++;

}

playback_speed_shift += speed_shift;

update_timer(tempo);

}

void Ca2mv2Player::key_on(int chan)

{

int i = is_4op_chan(chan) && is_4op_chan_hi(chan) ? 1 : 0;

opl3out(0xb0 + regoffs_n(chan + i), 0);

}

void Ca2mv2Player::key_off(int chan)

{

ch->freq_table[chan] &= ~0x2000;

change_frequency(chan, ch->freq_table[chan]);

ch->event_table[chan].note |= keyoff_flag;

}

void Ca2mv2Player::release_sustaining_sound(int chan)

{

uint16_t m = regoffs_m(chan);

uint16_t c = regoffs_c(chan);

opl3out(0x40 + m, 63);

opl3out(0x40 + c, 63);

// clear adsrw_mod and adsrw_car (match Pascal's FillChar zeroing all fields)

ch->fmpar_table[chan].decM = 0;

ch->fmpar_table[chan].attckM = 0;

ch->fmpar_table[chan].relM = 0;

ch->fmpar_table[chan].sustnM = 0;

ch->fmpar_table[chan].wformM = 0;

ch->fmpar_table[chan].decC = 0;

ch->fmpar_table[chan].attckC = 0;

ch->fmpar_table[chan].relC = 0;

ch->fmpar_table[chan].sustnC = 0;

ch->fmpar_table[chan].wformC = 0;

key_on(chan);

opl3out(0x60 + m, BYTE_NULL);

opl3out(0x60 + c, BYTE_NULL);

opl3out(0x80 + m, BYTE_NULL);

opl3out(0x80 + c, BYTE_NULL);

key_off(chan);

ch->event_table[chan].instr_def = 0;

ch->reset_chan[chan] = true;

}

// inverted volume here

static uint8_t scale_volume(uint8_t volume, uint8_t scale_factor)

{

return 63 - (((63 - volume) * (63 - scale_factor) + 31) / 63);

}

// former _4op_data_flag()

t4OP_DATA Ca2mv2Player::get_4op_data(uint8_t chan)

{

t4OP_DATA d = { false, 0, 0, 0, 0, 0 };

if (!is_4op_chan(chan))

return d;

d.mode = true;

if (is_4op_chan_hi(chan)) {

d.ch1 = chan;

d.ch2 = chan + 1;

} else {

d.ch1 = chan - 1;

d.ch2 = chan;

}

d.ins1 = ch->event_table[d.ch1].instr_def;

if (d.ins1 == 0) d.ins1 = ch->voice_table[d.ch1];

d.ins2 = ch->event_table[d.ch2].instr_def;

if (d.ins2 == 0) d.ins2 = ch->voice_table[d.ch2];

if (d.ins1 && d.ins2) {

tINSTR_DATA *id1 = get_instr_data(d.ins1);

tINSTR_DATA *id2 = get_instr_data(d.ins2);

if (id1 && id2)

d.conn = (id1->fm.connect << 1) | id2->fm.connect;

}

return d;

}

bool Ca2mv2Player::_4op_vol_valid_chan(int chan)

{

t4OP_DATA d = get_4op_data(chan);

return d.mode && ch->vol4op_lock[chan] && d.ins1 && d.ins2;

}

// inverted volume here

void Ca2mv2Player::set_ins_volume(uint8_t modulator, uint8_t carrier, uint8_t chan)

{

tINSTR_DATA *instr = get_instr_data_by_ch(chan);

uint8_t volM = instr ? instr->fm.volM : 0;

uint8_t volC = instr ? instr->fm.volC : 0;

uint8_t conn = instr ? instr->fm.connect : 0;

uint16_t m = regoffs_m(chan);

uint16_t c = regoffs_c(chan);

// Note: fmpar[].volM/volC has pure unscaled volume,

// modulator_vol/carrier_vol have scaled but without overall_volume

if (modulator != BYTE_NULL) {

uint8_t regm;

bool is_perc_chan = conn ||

(percussion_mode && chan >= 16); // in [17..20]

ch->fmpar_table[chan].volM = modulator;

if (is_perc_chan) { // in [17..20]

if (volume_scaling)

modulator = scale_volume(volM, modulator);

modulator = scale_volume(modulator, scale_volume(63 - global_volume, 63 - fade_out_volume));

regm = scale_volume(modulator, 63 - overall_volume) + (ch->fmpar_table[chan].kslM << 6);

} else {

regm = modulator + (ch->fmpar_table[chan].kslM << 6);

}

opl3out(0x40 + m, regm);

ch->modulator_vol[chan] = 63 - modulator;

}

if (carrier != BYTE_NULL) {

uint8_t regc;

ch->fmpar_table[chan].volC = carrier;

if (volume_scaling)

carrier = scale_volume(volC, carrier);

carrier = scale_volume(carrier, scale_volume(63 - global_volume, 63 - fade_out_volume));

regc = scale_volume(carrier, 63 - overall_volume) + (ch->fmpar_table[chan].kslC << 6);

opl3out(0x40 + c, regc);

ch->carrier_vol[chan] = 63 - carrier;

}

}

// Used by set_ins_volume_4op() only

void Ca2mv2Player::set_volume(uint8_t modulator, uint8_t carrier, uint8_t chan)

{

tINSTR_DATA *instr = get_instr_data_by_ch(chan);

uint8_t volM = instr ? instr->fm.volM : 0;

uint8_t volC = instr ? instr->fm.volC : 0;

uint16_t m = regoffs_m(chan);

uint16_t c = regoffs_c(chan);

if (modulator != BYTE_NULL) {

uint8_t regm;

ch->fmpar_table[chan].volM = modulator;

modulator = scale_volume(volM, modulator);

modulator = scale_volume(modulator, scale_volume(63 - global_volume, 63 - fade_out_volume));

regm = scale_volume(modulator, 63 - overall_volume) + (ch->fmpar_table[chan].kslM << 6);

opl3out(0x40 + m, regm);

ch->modulator_vol[chan] = 63 - modulator;

}

if (carrier != BYTE_NULL) {

uint8_t regc;

ch->fmpar_table[chan].volC = carrier;

carrier = scale_volume(volC, carrier);

carrier = scale_volume(carrier, scale_volume(63 - global_volume, 63 - fade_out_volume));

regc = scale_volume(carrier, 63 - overall_volume) + (ch->fmpar_table[chan].kslC << 6);

opl3out(0x40 + c, regc);

ch->carrier_vol[chan] = 63 - carrier;

}

}

void Ca2mv2Player::set_ins_volume_4op(uint8_t volume, uint8_t chan)

{

t4OP_DATA d = get_4op_data(chan);

if (!_4op_vol_valid_chan(chan))

return;

uint8_t volM1 = BYTE_NULL;

uint8_t volC1 = BYTE_NULL;

uint8_t volM2 = BYTE_NULL;