OPNA: ExtCh system copy-paste

CMakeLists.txt

@@ -356,6 +356,7 @@ src/engine/platform/tx81z.cpp
 src/engine/platform/ym2203.cpp
 src/engine/platform/ym2203ext.cpp
 src/engine/platform/ym2608.cpp
+src/engine/platform/ym2608ext.cpp
 src/engine/platform/ym2610.cpp
 src/engine/platform/ym2610ext.cpp
 src/engine/platform/ym2610b.cpp

TODO.md

@@ -1,6 +1,5 @@
 # to-do for 0.6pre1
 
-- finish ExtCh on OPNA
 - RF5C68 system
 - ZX beeper system overlay percussion
 - ADPCM chips

src/engine/dispatchContainer.cpp

@@ -32,6 +32,7 @@
 #include "platform/ym2203.h"
 #include "platform/ym2203ext.h"
 #include "platform/ym2608.h"
+#include "platform/ym2608ext.h"
 #include "platform/ym2610.h"
 #include "platform/ym2610ext.h"
 #include "platform/ym2610b.h"
@@ -247,6 +248,9 @@ void DivDispatchContainer::init(DivSystem sys, DivEngine* eng, int chanCount, do
     case DIV_SYSTEM_PC98:
       dispatch=new DivPlatformYM2608;
       break;
+    case DIV_SYSTEM_PC98_EXT:
+      dispatch=new DivPlatformYM2608Ext;
+      break;
     case DIV_SYSTEM_OPLL:
     case DIV_SYSTEM_OPLL_DRUMS:
     case DIV_SYSTEM_VRC7:

src/engine/platform/ym2608ext.cpp

@@ -0,0 +1,574 @@
+/**
+ * Furnace Tracker - multi-system chiptune tracker
+ * Copyright (C) 2021-2022 tildearrow and contributors
+ *
+ * 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.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "ym2608ext.h"
+#include "../engine.h"
+#include <math.h>
+
+#include "ym2610shared.h"
+#include "fmshared_OPN.h"
+
+int DivPlatformYM2608Ext::dispatch(DivCommand c) {
+  if (c.chan<2) {
+    return DivPlatformYM2608::dispatch(c);
+  }
+  if (c.chan>5) {
+    c.chan-=3;
+    return DivPlatformYM2608::dispatch(c);
+  }
+  int ch=c.chan-2;
+  int ordch=orderedOps[ch];
+  switch (c.cmd) {
+    case DIV_CMD_NOTE_ON: {
+      DivInstrument* ins=parent->getIns(opChan[ch].ins,DIV_INS_FM);
+      
+      unsigned short baseAddr=chanOffs[2]|opOffs[ordch];
+      DivInstrumentFM::Operator op=ins->fm.op[ordch];
+      // TODO: how does this work?!
+      if (isOpMuted[ch]) {
+        rWrite(baseAddr+0x40,127);
+      } else {
+        if (opChan[ch].insChanged) {
+          rWrite(baseAddr+0x40,127-(((127-op.tl)*(opChan[ch].vol&0x7f))/127));
+        }
+      }
+      if (opChan[ch].insChanged) {
+        rWrite(baseAddr+0x30,(op.mult&15)|(dtTable[op.dt&7]<<4));
+        rWrite(baseAddr+0x50,(op.ar&31)|(op.rs<<6));
+        rWrite(baseAddr+0x60,(op.dr&31)|(op.am<<7));
+        rWrite(baseAddr+0x70,op.d2r&31);
+        rWrite(baseAddr+0x80,(op.rr&15)|(op.sl<<4));
+        rWrite(baseAddr+0x90,op.ssgEnv&15);
+      }
+      if (opChan[ch].insChanged) { // TODO how does this work?
+        rWrite(chanOffs[2]+0xb0,(ins->fm.alg&7)|(ins->fm.fb<<3));
+        rWrite(chanOffs[2]+0xb4,(opChan[ch].pan<<6)|(ins->fm.fms&7)|((ins->fm.ams&3)<<4));
+      }
+      opChan[ch].insChanged=false;
+
+      if (c.value!=DIV_NOTE_NULL) {
+        opChan[ch].baseFreq=NOTE_FNUM_BLOCK(c.value,11);
+        opChan[ch].portaPause=false;
+        opChan[ch].freqChanged=true;
+      }
+      opChan[ch].keyOn=true;
+      opChan[ch].active=true;
+      break;
+    }
+    case DIV_CMD_NOTE_OFF:
+      opChan[ch].keyOff=true;
+      opChan[ch].keyOn=false;
+      opChan[ch].active=false;
+      break;
+    case DIV_CMD_VOLUME: {
+      opChan[ch].vol=c.value;
+      DivInstrument* ins=parent->getIns(opChan[ch].ins,DIV_INS_FM);
+      unsigned short baseAddr=chanOffs[2]|opOffs[ordch];
+      DivInstrumentFM::Operator op=ins->fm.op[ordch];
+      if (isOpMuted[ch]) {
+        rWrite(baseAddr+0x40,127);
+      } else {
+        rWrite(baseAddr+0x40,127-(((127-op.tl)*(opChan[ch].vol&0x7f))/127));
+      }
+      break;
+    }
+    case DIV_CMD_GET_VOLUME: {
+      return opChan[ch].vol;
+      break;
+    }
+    case DIV_CMD_INSTRUMENT:
+      if (opChan[ch].ins!=c.value || c.value2==1) {
+        opChan[ch].insChanged=true;
+      }
+      opChan[ch].ins=c.value;
+      break;
+    case DIV_CMD_PANNING: {
+      if (c.value==0 && c.value2==0) {
+        opChan[ch].pan=3;
+      } else {
+        opChan[ch].pan=(c.value2>0)|((c.value>0)<<1);
+      }
+      DivInstrument* ins=parent->getIns(opChan[ch].ins,DIV_INS_FM);
+      if (parent->song.sharedExtStat) {
+        for (int i=0; i<4; i++) {
+          if (ch==i) continue;
+          opChan[i].pan=opChan[ch].pan;
+        }
+      }
+      rWrite(chanOffs[2]+0xb4,(opChan[ch].pan<<6)|(ins->fm.fms&7)|((ins->fm.ams&3)<<4));
+      break;
+    }
+    case DIV_CMD_PITCH: {
+      opChan[ch].pitch=c.value;
+      opChan[ch].freqChanged=true;
+      break;
+    }
+    case DIV_CMD_NOTE_PORTA: {
+      if (parent->song.linearPitch==2) {
+        int destFreq=NOTE_FREQUENCY(c.value2);
+        bool return2=false;
+        if (destFreq>opChan[ch].baseFreq) {
+          opChan[ch].baseFreq+=c.value;
+          if (opChan[ch].baseFreq>=destFreq) {
+            opChan[ch].baseFreq=destFreq;
+            return2=true;
+          }
+        } else {
+          opChan[ch].baseFreq-=c.value;
+          if (opChan[ch].baseFreq<=destFreq) {
+            opChan[ch].baseFreq=destFreq;
+            return2=true;
+          }
+        }
+        opChan[ch].freqChanged=true;
+        if (return2) {
+          //opChan[ch].inPorta=false;
+          return 2;
+        }
+        break;
+      }
+      int boundaryBottom=parent->calcBaseFreq(chipClock,CHIP_FREQBASE,0,false);
+      int boundaryTop=parent->calcBaseFreq(chipClock,CHIP_FREQBASE,12,false);
+      int destFreq=NOTE_FNUM_BLOCK(c.value2,11);
+      int newFreq;
+      bool return2=false;
+      if (opChan[ch].portaPause) {
+        opChan[ch].baseFreq=opChan[ch].portaPauseFreq;
+      }
+      if (destFreq>opChan[ch].baseFreq) {
+        newFreq=opChan[ch].baseFreq+c.value;
+        if (newFreq>=destFreq) {
+          newFreq=destFreq;
+          return2=true;
+        }
+      } else {
+        newFreq=opChan[ch].baseFreq-c.value;
+        if (newFreq<=destFreq) {
+          newFreq=destFreq;
+          return2=true;
+        }
+      }
+      // what the heck!
+      if (!opChan[ch].portaPause) {
+        if ((newFreq&0x7ff)>boundaryTop && (newFreq&0xf800)<0x3800) {
+          if (parent->song.fbPortaPause) {
+            opChan[ch].portaPauseFreq=(boundaryBottom)|((newFreq+0x800)&0xf800);
+            opChan[ch].portaPause=true;
+            break;
+          } else {
+            newFreq=(newFreq>>1)|((newFreq+0x800)&0xf800);
+          }
+        }
+        if ((newFreq&0x7ff)<boundaryBottom && (newFreq&0xf800)>0) {
+          if (parent->song.fbPortaPause) {
+            opChan[ch].portaPauseFreq=newFreq=(boundaryTop-1)|((newFreq-0x800)&0xf800);
+            opChan[ch].portaPause=true;
+            break;
+          } else {
+            newFreq=(newFreq<<1)|((newFreq-0x800)&0xf800);
+          }
+        }
+      }
+      opChan[ch].portaPause=false;
+      opChan[ch].freqChanged=true;
+      opChan[ch].baseFreq=newFreq;
+      if (return2) return 2;
+      break;
+    }
+    case DIV_CMD_LEGATO: {
+      opChan[ch].baseFreq=NOTE_FNUM_BLOCK(c.value,11);
+      opChan[ch].freqChanged=true;
+      break;
+    }
+    case DIV_CMD_FM_LFO: {
+      rWrite(0x22,(c.value&7)|((c.value>>4)<<3));
+      break;
+    }
+    case DIV_CMD_FM_MULT: { // TODO
+      unsigned short baseAddr=chanOffs[2]|opOffs[orderedOps[c.value]];
+      DivInstrument* ins=parent->getIns(opChan[ch].ins,DIV_INS_FM);
+      DivInstrumentFM::Operator op=ins->fm.op[orderedOps[c.value]];
+      rWrite(baseAddr+0x30,(c.value2&15)|(dtTable[op.dt&7]<<4));
+      break;
+    }
+    case DIV_CMD_FM_TL: { // TODO
+      unsigned short baseAddr=chanOffs[2]|opOffs[orderedOps[c.value]];
+      DivInstrument* ins=parent->getIns(opChan[ch].ins,DIV_INS_FM);
+      if (isOutput[ins->fm.alg][c.value]) {
+        rWrite(baseAddr+0x40,127-(((127-c.value2)*(opChan[ch].vol&0x7f))/127));
+      } else {
+        rWrite(baseAddr+0x40,c.value2);
+      }
+      break;
+    }
+    case DIV_CMD_FM_AR: {
+      if (c.value<0)  {
+        for (int i=0; i<4; i++) {
+          DivInstrumentFM::Operator& op=chan[2].state.op[i];
+          op.ar=c.value2&31;
+          unsigned short baseAddr=chanOffs[2]|opOffs[i];
+          rWrite(baseAddr+0x50,(op.ar&31)|(op.rs<<6));
+        }
+      } else {
+        DivInstrumentFM::Operator& op=chan[2].state.op[orderedOps[c.value]];
+        op.ar=c.value2&31;
+        unsigned short baseAddr=chanOffs[2]|opOffs[orderedOps[c.value]];
+        rWrite(baseAddr+0x50,(op.ar&31)|(op.rs<<6));
+      }
+      break;
+    }
+    case DIV_CMD_FM_RS: {
+      if (c.value<0)  {
+        for (int i=0; i<4; i++) {
+          DivInstrumentFM::Operator& op=chan[2].state.op[i];
+          op.rs=c.value2&3;
+          unsigned short baseAddr=chanOffs[2]|opOffs[i];
+          rWrite(baseAddr+ADDR_RS_AR,(op.ar&31)|(op.rs<<6));
+        }
+      } else if (c.value<4) {
+        DivInstrumentFM::Operator& op=chan[2].state.op[orderedOps[c.value]];
+        op.rs=c.value2&3;
+        unsigned short baseAddr=chanOffs[2]|opOffs[orderedOps[c.value]];
+        rWrite(baseAddr+ADDR_RS_AR,(op.ar&31)|(op.rs<<6));
+      }
+      break;
+    }
+    case DIV_CMD_FM_AM: {
+      if (c.value<0)  {
+        for (int i=0; i<4; i++) {
+          DivInstrumentFM::Operator& op=chan[2].state.op[i];
+          op.am=c.value2&1;
+          unsigned short baseAddr=chanOffs[2]|opOffs[i];
+          rWrite(baseAddr+ADDR_AM_DR,(op.dr&31)|(op.am<<7));
+        }
+      } else if (c.value<4) {
+        DivInstrumentFM::Operator& op=chan[2].state.op[orderedOps[c.value]];
+        op.am=c.value2&1;
+        unsigned short baseAddr=chanOffs[2]|opOffs[orderedOps[c.value]];
+        rWrite(baseAddr+ADDR_AM_DR,(op.dr&31)|(op.am<<7));
+      }
+      break;
+    }
+    case DIV_CMD_FM_DR: {
+      if (c.value<0)  {
+        for (int i=0; i<4; i++) {
+          DivInstrumentFM::Operator& op=chan[2].state.op[i];
+          op.dr=c.value2&31;
+          unsigned short baseAddr=chanOffs[2]|opOffs[i];
+          rWrite(baseAddr+ADDR_AM_DR,(op.dr&31)|(op.am<<7));
+        }
+      } else if (c.value<4) {
+        DivInstrumentFM::Operator& op=chan[2].state.op[orderedOps[c.value]];
+        op.dr=c.value2&31;
+        unsigned short baseAddr=chanOffs[2]|opOffs[orderedOps[c.value]];
+        rWrite(baseAddr+ADDR_AM_DR,(op.dr&31)|(op.am<<7));
+      }
+      break;
+    }
+    case DIV_CMD_FM_SL: {
+      if (c.value<0)  {
+        for (int i=0; i<4; i++) {
+          DivInstrumentFM::Operator& op=chan[2].state.op[i];
+          op.sl=c.value2&15;
+          unsigned short baseAddr=chanOffs[2]|opOffs[i];
+          rWrite(baseAddr+ADDR_SL_RR,(op.rr&15)|(op.sl<<4));
+        }
+      } else if (c.value<4) {
+        DivInstrumentFM::Operator& op=chan[2].state.op[orderedOps[c.value]];
+        op.sl=c.value2&15;
+        unsigned short baseAddr=chanOffs[2]|opOffs[orderedOps[c.value]];
+        rWrite(baseAddr+ADDR_SL_RR,(op.rr&15)|(op.sl<<4));
+      }
+      break;
+    }
+    case DIV_CMD_FM_RR: {
+      if (c.value<0)  {
+        for (int i=0; i<4; i++) {
+          DivInstrumentFM::Operator& op=chan[2].state.op[i];
+          op.rr=c.value2&15;
+          unsigned short baseAddr=chanOffs[2]|opOffs[i];
+          rWrite(baseAddr+ADDR_SL_RR,(op.rr&15)|(op.sl<<4));
+        }
+      } else if (c.value<4) {
+        DivInstrumentFM::Operator& op=chan[2].state.op[orderedOps[c.value]];
+        op.rr=c.value2&15;
+        unsigned short baseAddr=chanOffs[2]|opOffs[orderedOps[c.value]];
+        rWrite(baseAddr+ADDR_SL_RR,(op.rr&15)|(op.sl<<4));
+      }
+      break;
+    }
+    case DIV_CMD_FM_D2R: {
+      if (c.value<0)  {
+        for (int i=0; i<4; i++) {
+          DivInstrumentFM::Operator& op=chan[2].state.op[i];
+          op.d2r=c.value2&31;
+          unsigned short baseAddr=chanOffs[2]|opOffs[i];
+          rWrite(baseAddr+ADDR_DT2_D2R,op.d2r&31);
+        }
+      } else if (c.value<4) {
+        DivInstrumentFM::Operator& op=chan[2].state.op[orderedOps[c.value]];
+        op.d2r=c.value2&31;
+        unsigned short baseAddr=chanOffs[2]|opOffs[orderedOps[c.value]];
+        rWrite(baseAddr+ADDR_DT2_D2R,op.d2r&31);
+      }
+      break;
+    }
+    case DIV_CMD_FM_DT: {
+      if (c.value<0)  {
+        for (int i=0; i<4; i++) {
+          DivInstrumentFM::Operator& op=chan[2].state.op[i];
+          op.dt=c.value&7;
+          unsigned short baseAddr=chanOffs[2]|opOffs[i];
+          rWrite(baseAddr+ADDR_MULT_DT,(op.mult&15)|(dtTable[op.dt&7]<<4));
+        }
+      } else if (c.value<4) {
+        DivInstrumentFM::Operator& op=chan[2].state.op[orderedOps[c.value]];
+        op.dt=c.value2&7;
+        unsigned short baseAddr=chanOffs[2]|opOffs[orderedOps[c.value]];
+        rWrite(baseAddr+ADDR_MULT_DT,(op.mult&15)|(dtTable[op.dt&7]<<4));
+      }
+      break;
+    }
+    case DIV_CMD_FM_SSG: {
+      if (c.value<0)  {
+        for (int i=0; i<4; i++) {
+          DivInstrumentFM::Operator& op=chan[2].state.op[i];
+          op.ssgEnv=8^(c.value2&15);
+          unsigned short baseAddr=chanOffs[2]|opOffs[i];
+          rWrite(baseAddr+ADDR_SSG,op.ssgEnv&15);
+        }
+      } else if (c.value<4) {
+        DivInstrumentFM::Operator& op=chan[2].state.op[orderedOps[c.value]];
+        op.ssgEnv=8^(c.value2&15);
+        unsigned short baseAddr=chanOffs[2]|opOffs[orderedOps[c.value]];
+        rWrite(baseAddr+ADDR_SSG,op.ssgEnv&15);
+      }
+      break;
+    }
+    case DIV_CMD_GET_VOLMAX:
+      return 127;
+      break;
+    case DIV_ALWAYS_SET_VOLUME:
+      return 0;
+      break;
+    case DIV_CMD_PRE_PORTA:
+      break;
+    default:
+      //printf("WARNING: unimplemented command %d\n",c.cmd);
+      break;
+  }
+  return 1;
+}
+
+static int opChanOffsL[4]={
+  0xa9, 0xaa, 0xa8, 0xa2
+};
+
+static int opChanOffsH[4]={
+  0xad, 0xae, 0xac, 0xa6
+};
+
+void DivPlatformYM2608Ext::tick(bool sysTick) {
+  if (extMode) {
+    bool writeSomething=false;
+    unsigned char writeMask=2;
+    for (int i=0; i<4; i++) {
+      writeMask|=opChan[i].active<<(4+i);
+      if (opChan[i].keyOn || opChan[i].keyOff) {
+        writeSomething=true;
+        writeMask&=~(1<<(4+i));
+        opChan[i].keyOff=false;
+      }
+    }
+    if (writeSomething) {
+      immWrite(0x28,writeMask);
+    }
+  }
+
+  DivPlatformYM2608::tick(sysTick);
+
+  bool writeNoteOn=false;
+  unsigned char writeMask=2;
+  if (extMode) for (int i=0; i<4; i++) {
+    if (opChan[i].freqChanged) {
+      if (parent->song.linearPitch==2) {
+        opChan[i].freq=parent->calcFreq(opChan[i].baseFreq,opChan[i].pitch,false,4,opChan[i].pitch2,chipClock,CHIP_FREQBASE,11);
+      } else {
+        int fNum=parent->calcFreq(opChan[i].baseFreq&0x7ff,opChan[i].pitch,false,4,opChan[i].pitch2);
+        int block=(opChan[i].baseFreq&0xf800)>>11;
+        if (fNum<0) fNum=0;
+        if (fNum>2047) {
+          while (block<7) {
+            fNum>>=1;
+            block++;
+          }
+          if (fNum>2047) fNum=2047;
+        }
+        opChan[i].freq=(block<<11)|fNum;
+      }
+      if (opChan[i].freq>0x3fff) opChan[i].freq=0x3fff;
+      immWrite(opChanOffsH[i],opChan[i].freq>>8);
+      immWrite(opChanOffsL[i],opChan[i].freq&0xff);
+    }
+    writeMask|=opChan[i].active<<(4+i);
+    if (opChan[i].keyOn) {
+      writeNoteOn=true;
+      writeMask|=1<<(4+i);
+      opChan[i].keyOn=false;
+    }
+  }
+  if (writeNoteOn) {
+    immWrite(0x28,writeMask);
+  }
+}
+
+void DivPlatformYM2608Ext::muteChannel(int ch, bool mute) {
+  if (ch<2) {
+    DivPlatformYM2608::muteChannel(ch,mute);
+    return;
+  }
+  if (ch>5) {
+    DivPlatformYM2608::muteChannel(ch-3,mute);
+    return;
+  }
+  isOpMuted[ch-2]=mute;
+  
+  int ordch=orderedOps[ch-2];
+  DivInstrument* ins=parent->getIns(opChan[ch-2].ins,DIV_INS_FM);
+  unsigned short baseAddr=chanOffs[2]|opOffs[ordch];
+  DivInstrumentFM::Operator op=ins->fm.op[ordch];
+  if (isOpMuted[ch-2]) {
+    rWrite(baseAddr+0x40,127);
+  } else if (isOutput[ins->fm.alg][ordch]) {
+    rWrite(baseAddr+0x40,127-(((127-op.tl)*(opChan[ch-2].vol&0x7f))/127));
+  } else {
+    rWrite(baseAddr+0x40,op.tl);
+  }
+}
+
+void DivPlatformYM2608Ext::forceIns() {
+  for (int i=0; i<6; i++) {
+    for (int j=0; j<4; j++) {
+      unsigned short baseAddr=chanOffs[i]|opOffs[j];
+      DivInstrumentFM::Operator& op=chan[i].state.op[j];
+      if (i==2) { // extended channel
+        if (isOpMuted[j]) {
+          rWrite(baseAddr+0x40,127);
+        } else if (isOutput[chan[i].state.alg][j]) {
+          rWrite(baseAddr+0x40,127-(((127-op.tl)*(opChan[j].vol&0x7f))/127));
+        } else {
+          rWrite(baseAddr+0x40,op.tl);
+        }
+      } else {
+        if (isMuted[i]) {
+          rWrite(baseAddr+ADDR_TL,127);
+        } else {
+          if (isOutput[chan[i].state.alg][j]) {
+            rWrite(baseAddr+ADDR_TL,127-(((127-op.tl)*(chan[i].outVol&0x7f))/127));
+          } else {
+            rWrite(baseAddr+ADDR_TL,op.tl);
+          }
+        }
+      }
+      rWrite(baseAddr+ADDR_MULT_DT,(op.mult&15)|(dtTable[op.dt&7]<<4));
+      rWrite(baseAddr+ADDR_RS_AR,(op.ar&31)|(op.rs<<6));
+      rWrite(baseAddr+ADDR_AM_DR,(op.dr&31)|(op.am<<7));
+      rWrite(baseAddr+ADDR_DT2_D2R,op.d2r&31);
+      rWrite(baseAddr+ADDR_SL_RR,(op.rr&15)|(op.sl<<4));
+      rWrite(baseAddr+ADDR_SSG,op.ssgEnv&15);
+    }
+    rWrite(chanOffs[i]+ADDR_FB_ALG,(chan[i].state.alg&7)|(chan[i].state.fb<<3));
+    rWrite(chanOffs[i]+ADDR_LRAF,(isMuted[i]?0:(chan[i].pan<<6))|(chan[i].state.fms&7)|((chan[i].state.ams&3)<<4));
+    if (chan[i].active) {
+      chan[i].keyOn=true;
+      chan[i].freqChanged=true;
+    }
+  }
+  for (int i=6; i<16; i++) {
+    chan[i].insChanged=true;
+  }
+  ay->forceIns();
+  ay->flushWrites();
+  for (DivRegWrite& i: ay->getRegisterWrites()) {
+    immWrite(i.addr&15,i.val);
+  }
+  ay->getRegisterWrites().clear();
+  for (int i=0; i<4; i++) {
+    opChan[i].insChanged=true;
+    if (opChan[i].active) {
+      opChan[i].keyOn=true;
+      opChan[i].freqChanged=true;
+    }
+  }
+}
+
+void* DivPlatformYM2608Ext::getChanState(int ch) {
+  if (ch>=6) return &chan[ch-3];
+  if (ch>=2) return &opChan[ch-2];
+  return &chan[ch];
+}
+
+DivDispatchOscBuffer* DivPlatformYM2608Ext::getOscBuffer(int ch) {
+  if (ch>=6) return oscBuf[ch-3];
+  if (ch<3) return oscBuf[ch];
+  return NULL;
+}
+
+void DivPlatformYM2608Ext::reset() {
+  DivPlatformYM2608::reset();
+
+  for (int i=0; i<4; i++) {
+    opChan[i]=DivPlatformYM2608Ext::OpChannel();
+    opChan[i].vol=127;
+  }
+
+  // channel 2 mode
+  immWrite(0x27,0x40);
+  extMode=true;
+}
+
+bool DivPlatformYM2608Ext::keyOffAffectsArp(int ch) {
+  return (ch>8);
+}
+
+void DivPlatformYM2608Ext::notifyInsChange(int ins) {
+  DivPlatformYM2608::notifyInsChange(ins);
+  for (int i=0; i<4; i++) {
+    if (opChan[i].ins==ins) {
+      opChan[i].insChanged=true;
+    }
+  }
+}
+
+int DivPlatformYM2608Ext::init(DivEngine* parent, int channels, int sugRate, unsigned int flags) {
+  DivPlatformYM2608::init(parent,channels,sugRate,flags);
+  for (int i=0; i<4; i++) {
+    isOpMuted[i]=false;
+  }
+
+  reset();
+  return 19;
+}
+
+void DivPlatformYM2608Ext::quit() {
+  DivPlatformYM2608::quit();
+}
+
+DivPlatformYM2608Ext::~DivPlatformYM2608Ext() {
+}

src/engine/platform/ym2608ext.h

@@ -0,0 +1,51 @@
+/**
+ * Furnace Tracker - multi-system chiptune tracker
+ * Copyright (C) 2021-2022 tildearrow and contributors
+ *
+ * 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.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "../dispatch.h"
+
+#include "ym2608.h"
+
+class DivPlatformYM2608Ext: public DivPlatformYM2608 {
+  struct OpChannel {
+    DivMacroInt std;
+    unsigned char freqH, freqL;
+    int freq, baseFreq, pitch, pitch2, portaPauseFreq, ins;
+    signed char konCycles;
+    bool active, insChanged, freqChanged, keyOn, keyOff, portaPause;
+    int vol;
+    unsigned char pan;
+    OpChannel(): freqH(0), freqL(0), freq(0), baseFreq(0), pitch(0), pitch2(0), portaPauseFreq(0), ins(-1), active(false), insChanged(true), freqChanged(false), keyOn(false), keyOff(false), portaPause(false), vol(0), pan(3) {}
+  };
+  OpChannel opChan[4];
+  bool isOpMuted[4];
+  friend void putDispatchChan(void*,int,int);
+  public:
+    int dispatch(DivCommand c);
+    void* getChanState(int chan);
+    DivDispatchOscBuffer* getOscBuffer(int chan);
+    void reset();
+    void forceIns();
+    void tick(bool sysTick=true);
+    void muteChannel(int ch, bool mute);
+    bool keyOffAffectsArp(int ch);
+    void notifyInsChange(int ins);
+    int init(DivEngine* parent, int channels, int sugRate, unsigned int flags);
+    void quit();
+    ~DivPlatformYM2608Ext();
+};

src/gui/editControls.cpp

@@ -20,6 +20,57 @@
 #include "gui.h"
 #include "IconsFontAwesome4.h"
 
+void FurnaceGUI::drawMobileControls() {
+  if (ImGui::Begin("Mobile Controls",NULL,ImGuiWindowFlags_NoScrollbar|ImGuiWindowFlags_NoScrollWithMouse)) {
+    float availX=ImGui::GetContentRegionAvail().x;
+    ImVec2 buttonSize=ImVec2(availX,availX);
+
+    if (ImGui::Button(ICON_FA_CHEVRON_RIGHT "##MobileMenu",buttonSize)) {
+    }
+
+    ImGui::Separator();
+
+    ImGui::PushStyleColor(ImGuiCol_Button,TOGGLE_COLOR(e->isPlaying()));
+    if (ImGui::Button(ICON_FA_PLAY "##Play",buttonSize)) {
+      play();
+    }
+    ImGui::PopStyleColor();
+    if (ImGui::Button(ICON_FA_STOP "##Stop",buttonSize)) {
+      stop();
+    }
+    if (ImGui::Button(ICON_FA_ARROW_DOWN "##StepOne",buttonSize)) {
+      e->stepOne(cursor.y);
+      pendingStepUpdate=true;
+    }
+
+    bool repeatPattern=e->getRepeatPattern();
+    ImGui::PushStyleColor(ImGuiCol_Button,TOGGLE_COLOR(repeatPattern));
+    if (ImGui::Button(ICON_FA_REPEAT "##RepeatPattern",buttonSize)) {
+      e->setRepeatPattern(!repeatPattern);
+    }
+    ImGui::PopStyleColor();
+
+    ImGui::PushStyleColor(ImGuiCol_Button,TOGGLE_COLOR(edit));
+    if (ImGui::Button(ICON_FA_CIRCLE "##Edit",buttonSize)) {
+      edit=!edit;
+    }
+    ImGui::PopStyleColor();
+
+    bool metro=e->getMetronome();
+    ImGui::PushStyleColor(ImGuiCol_Button,TOGGLE_COLOR(metro));
+    if (ImGui::Button(ICON_FA_BELL_O "##Metronome",buttonSize)) {
+      e->setMetronome(!metro);
+    }
+    ImGui::PopStyleColor();
+
+    if (ImGui::Button("Get me out of here")) {
+      toggleMobileUI(false);
+    }
+  }
+  if (ImGui::IsWindowFocused(ImGuiFocusedFlags_ChildWindows)) curWindow=GUI_WINDOW_EDIT_CONTROLS;
+  ImGui::End();
+}
+
 void FurnaceGUI::drawEditControls() {
   if (nextWindow==GUI_WINDOW_EDIT_CONTROLS) {
     editControlsOpen=true;

src/gui/gui.cpp

@@ -3043,14 +3043,7 @@ bool FurnaceGUI::loop() {
       ImGui::DockSpace(dockID);
       ImGui::End();
 
-      if (ImGui::Begin("Mobile Controls")) {
-        ImGui::Text("Hi!");
-        if (ImGui::Button("Get me out of here")) {
-          toggleMobileUI(false);
-        }
-      }
-      ImGui::End();
-      
+      drawMobileControls();
       drawPattern();
       drawPiano();
     } else {

src/gui/gui.h

@@ -1266,6 +1266,7 @@ class FurnaceGUI {
 
   void toggleMobileUI(bool enable, bool force=false);
 
+  void drawMobileControls();
   void drawEditControls();
   void drawSongInfo();
   void drawOrders();