diff --git a/CMakeLists.txt b/CMakeLists.txt index a749acd37..0a3758ff1 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -809,6 +809,7 @@ src/engine/platform/dummy.cpp src/engine/export/abstract.cpp src/engine/export/amigaValidation.cpp +src/engine/export/sapr.cpp src/engine/export/tiuna.cpp src/engine/export/zsm.cpp diff --git a/src/engine/export.cpp b/src/engine/export.cpp index 5a3700097..59201faa4 100644 --- a/src/engine/export.cpp +++ b/src/engine/export.cpp @@ -20,6 +20,7 @@ #include "engine.h" #include "export/amigaValidation.h" +#include "export/sapr.h" #include "export/tiuna.h" #include "export/zsm.h" @@ -35,6 +36,9 @@ DivROMExport* DivEngine::buildROM(DivROMExportOptions sys) { case DIV_ROM_ZSM: exporter=new DivExportZSM; break; + case DIV_ROM_SAP_R: + exporter=new DivExportSAPR; + break; default: exporter=new DivROMExport; break; diff --git a/src/engine/export.h b/src/engine/export.h index f9439fc95..497116995 100644 --- a/src/engine/export.h +++ b/src/engine/export.h @@ -31,6 +31,7 @@ enum DivROMExportOptions { DIV_ROM_AMIGA_VALIDATION, DIV_ROM_ZSM, DIV_ROM_TIUNA, + DIV_ROM_SAP_R, DIV_ROM_MAX }; diff --git a/src/engine/export/sapr.cpp b/src/engine/export/sapr.cpp new file mode 100644 index 000000000..25defaecc --- /dev/null +++ b/src/engine/export/sapr.cpp @@ -0,0 +1,503 @@ +/** + * Furnace Tracker - multi-system chiptune tracker + * Copyright (C) 2021-2024 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 "sapr.h" +#include "../engine.h" +#include "../ta-log.h" +#include +#include +#include +#include +#include + +void DivExportSAPR::run() { + int loopOrder, loopOrderRow, loopEnd; + int tick=0; + SafeWriter* w; + std::map allCmds[2]; + + // config + String baseLabel=conf.getString("baseLabel","song"); + int firstBankSize=conf.getInt("firstBankSize",3072); + int otherBankSize=conf.getInt("otherBankSize",4096-48); + int tiaIdx=conf.getInt("sysToExport",-1); + + e->stop(); + e->repeatPattern=false; + e->shallStop=false; + e->setOrder(0); + e->synchronizedSoft([&]() { + // determine loop point + // bool stopped=false; + loopOrder=0; + loopOrderRow=0; + loopEnd=0; + e->walkSong(loopOrder,loopOrderRow,loopEnd); + logAppendf("loop point: %d %d",loopOrder,loopOrderRow); + + w=new SafeWriter; + w->init(); + + if (tiaIdx<0 || tiaIdx>=e->song.systemLen) { + tiaIdx=-1; + for (int i=0; isong.systemLen; i++) { + if (e->song.system[i]==DIV_SYSTEM_TIA) { + tiaIdx=i; + break; + } + } + if (tiaIdx<0) { + logAppend("ERROR: selected TIA system not found"); + failed=true; + running=false; + return; + } + } else if (e->song.system[tiaIdx]!=DIV_SYSTEM_TIA) { + logAppend("ERROR: selected chip is not a TIA!"); + failed=true; + running=false; + return; + } + + e->disCont[tiaIdx].dispatch->toggleRegisterDump(true); + + // write patterns + // bool writeLoop=false; + logAppend("recording sequence..."); + bool done=false; + e->playSub(false); + + // int loopTick=-1; + SAPRLast last[2]; + SAPRNew news[2]; + while (!done) { + // TODO implement loop + // if (loopTick<0 && loopOrder==curOrder && loopOrderRow==curRow + // && (ticks-((tempoAccum+virtualTempoN)/virtualTempoD))<=0 + // ) { + // writeLoop=true; + // loopTick=tick; + // // invalidate last register state so it always force an absolute write after loop + // for (int i=0; i<2; i++) { + // last[i]=SAPRLast(); + // last[i].pitch=-1; + // last[i].ins=-1; + // last[i].vol=-1; + // } + // } + if (e->nextTick(false,true) || !e->playing) { + // stopped=!playing; + done=true; + break; + } + for (int i=0; i<2; i++) { + news[i]=SAPRNew(); + } + // get register dumps + std::vector& writes=e->disCont[tiaIdx].dispatch->getRegisterWrites(); + for (const DivRegWrite& i: writes) { + switch (i.addr) { + case 0xfffe0000: + case 0xfffe0001: + news[i.addr&1].pitch=i.val; + break; + case 0xfffe0002: + news[0].sync=i.val; + break; + case 0x15: + case 0x16: + news[i.addr-0x15].ins=i.val; + break; + case 0x19: + case 0x1a: + news[i.addr-0x19].vol=i.val; + break; + default: break; + } + } + writes.clear(); + // collect changes + for (int i=0; i<2; i++) { + SAPRCmd cmds; + bool hasCmd=false; + if (news[i].pitch>=0 && (last[i].forcePitch || news[i].pitch!=last[i].pitch)) { + int dt=news[i].pitch-last[i].pitch; + if (!last[i].forcePitch && abs(dt)<=16) { + if (dt<0) cmds.pitchChange=15-dt; + else cmds.pitchChange=dt-1; + } + else cmds.pitchSet=news[i].pitch; + last[i].pitch=news[i].pitch; + last[i].forcePitch=false; + hasCmd=true; + } + if (news[i].ins>=0 && news[i].ins!=last[i].ins) { + cmds.ins=news[i].ins; + last[i].ins=news[i].ins; + hasCmd=true; + } + if (news[i].vol>=0 && news[i].vol!=last[i].vol) { + cmds.vol=(news[i].vol-last[i].vol)&0xf; + last[i].vol=news[i].vol; + hasCmd=true; + } + if (news[i].sync>=0) { + cmds.sync=news[i].sync; + hasCmd=true; + } + if (hasCmd) allCmds[i][tick]=cmds; + } + e->cmdStream.clear(); + tick++; + } + for (int i=0; isong.systemLen; i++) { + e->disCont[i].dispatch->getRegisterWrites().clear(); + e->disCont[i].dispatch->toggleRegisterDump(false); + } + + e->remainingLoops=-1; + e->playing=false; + e->freelance=false; + e->extValuePresent=false; + }); + + if (failed) return; + + // render commands + logAppend("rendering commands..."); + std::vector renderedCmds; + w->writeText(fmt::format( + "; Generated by Furnace " DIV_VERSION "\n" + "; Name: {}\n" + "; Author: {}\n" + "; Album: {}\n" + "; Subsong #{}: {}\n\n", + e->song.name,e->song.author,e->song.category,e->curSubSongIndex+1,e->curSubSong->name + )); + for (int i=0; i<2; i++) { + SAPRCmd lastCmd; + int lastTick=0; + int lastWait=0; + // bool looped=false; + for (auto& kv: allCmds[i]) { + // if (!looped && !stopped && loopTick>=0 && kv.first>=loopTick) { + // writeCmd(w,&lastCmd,&lastWait,loopTick-lastTick); + // w->writeText(".loop\n"); + // lastTick=loopTick; + // looped=true; + // } + writeCmd(renderedCmds,lastCmd,i,lastWait,lastTick,kv.first); + lastTick=kv.first; + lastCmd=kv.second; + } + writeCmd(renderedCmds,lastCmd,i,lastWait,lastTick,tick); + // if (stopped || loopTick<0) w->writeText(".loop\n db 0\n"); + } + // compress commands + std::vector confirmedMatches; + std::vector callTicks; + int cmId=0; + int cmdSize=renderedCmds.size(); + bool* processed=new bool[cmdSize]; + memset(processed,0,cmdSize*sizeof(bool)); + logAppend("compressing! this may take a while."); + int maxCmId=(MAX(firstBankSize/1024,1))*256; + int lastMaxPMVal=100000; + logAppendf("max cmId: %d",maxCmId); + logAppendf("commands: %d",cmdSize); + while (firstBankSize>768 && cmId potentialMatches; + for (int i=0; i=cmdSize-1) break; + progress[1].amount=(float)i/(float)(cmdSize-1); + std::vector match; + int ch=renderedCmds[i].ch; + for (int j=i+1; j=cmdSize) break; + int k=0; + int ticks=0; + int size=0; + while ( + (i+k)2) match.push_back(SAPRMatch(j,j+k,size,0)); + if (k==0) k++; + j+=k; + } + if (match.empty()) { + i++; + continue; + } + // find a length that results in most bytes saved + SAPRMatches matches; + int curSize=0; + int curLength=1; + int curTicks=0; + while (true) { + int bytesSaved=-4; + bool found=false; + for (const SAPRMatch& j: match) { + if ((j.endPos-j.pos)>=curLength) { + if (!found) { + found=true; + curSize+=renderedCmds[i+curLength-1].size; + curTicks+=renderedCmds[i+curLength-1].ticks; + } + bytesSaved+=curSize-2; + } + } + if (!found) break; + if (bytesSaved>matches.bytesSaved) { + matches.length=curLength; + matches.bytesSaved=bytesSaved; + matches.ticks=curTicks; + } + curLength++; + } + if (matches.bytesSaved>0) { + matches.pos.push_back(i); + for (const SAPRMatch& j: match) { + if ((j.endPos-j.pos)>=matches.length) { + matches.pos.push_back(j.pos); + } + } + potentialMatches[i]=matches; + } + i++; + } + if (potentialMatches.empty()) { + logAppend("potentialMatches is empty"); + break; + } + int maxPMIdx=0; + int maxPMVal=0; + for (const auto& i: potentialMatches) { + if (i.second.bytesSaved>maxPMVal) { + maxPMVal=i.second.bytesSaved; + maxPMIdx=i.first; + } + } + int maxPMLen=potentialMatches[maxPMIdx].length; + for (const int i: potentialMatches[maxPMIdx].pos) { + confirmedMatches.push_back({i,i+maxPMLen,0,cmId}); + memset(processed+i,1,maxPMLen); + //std::fill(processed.begin()+i,processed.begin()+(i+maxPMLen),true); + } + callTicks.push_back(potentialMatches[maxPMIdx].ticks); + logAppendf("CM %04x added: pos=%d,len=%d,matches=%d,saved=%d",cmId,maxPMIdx,maxPMLen,potentialMatches[maxPMIdx].pos.size(),maxPMVal); + lastMaxPMVal=maxPMVal; + cmId++; + } + progress[0].amount=1.0f; + progress[1].amount=1.0f; + logAppend("generating data..."); + delete[] processed; + std::sort(confirmedMatches.begin(),confirmedMatches.end(),[](const SAPRMatch& l, const SAPRMatch& r){ + return l.pos256 that don't fill up a page + // as they tends to increase the final size due to page alignment + int cmIdLen=cmId>256?(cmId&~255):cmId; + // overlap check + for (int i=1; i<(int)confirmedMatches.size(); i++) { + if (confirmedMatches[i-1].endPos<=confirmedMatches[i].pos) continue; + logAppend("ERROR: impossible overlap found in matches list, please report"); + failed=true; + running=false; + return; + } + + // write commands + int totalSize=0; + int cnt=cmIdLen; + w->writeText(fmt::format(" .section {0}_bank0\n .align $100\n{0}_calltable",baseLabel)); + while (cnt>0) { + int cnt2=MIN(cnt,256); + w->writeText("\n .byte "); + for (int j=0; jwriteText(fmt::format("<{}_c{},",baseLabel,cmIdLen-cnt+j)); + } + for (int j=cnt2; j<256; j++) { + w->writeText("0,"); + } + w->seek(-1,SEEK_CUR); + w->writeText("\n .byte "); + for (int j=0; jwriteText(fmt::format(">{}_c{},",baseLabel,cmIdLen-cnt+j)); + } + for (int j=cnt2; j<256; j++) { + w->writeText("0,"); + } + w->seek(-1,SEEK_CUR); + w->writeText("\n .byte "); + for (int j=0; jwriteText(fmt::format("{}_c{}>>13,",baseLabel,cmIdLen-cnt+j)); + } + for (int j=cnt2; j<256; j++) { + w->writeText("0,"); + } + w->seek(-1,SEEK_CUR); + w->writeText("\n .byte "); + for (int j=0; jwriteText(fmt::format("{},",callTicks[cmIdLen-cnt+j]&0xff)); + } + w->seek(-1,SEEK_CUR); + totalSize+=768+cnt2; + cnt-=cnt2; + } + w->writeC('\n'); + if (totalSize>firstBankSize) { + logAppend("ERROR: first bank is not large enough to contain call table"); + failed=true; + running=false; + return; + } + + int curBank=0; + int bankSize=totalSize; + int maxBankSize=firstBankSize; + int curCh=-1; + std::vector callVisited=std::vector(cmIdLen,false); + auto cmIter=confirmedMatches.begin(); + for (int i=0; i<(int)renderedCmds.size(); i++) { + int writeCall=-1; + SAPRBytes cmd=renderedCmds[i]; + if (cmIter!=confirmedMatches.end() && i==cmIter->pos) { + if (cmIter->idid]) { + unsigned char idLo=cmIter->id&0xff; + unsigned char idHi=cmIter->id>>8; + cmd=SAPRBytes(cmd.ch,0,2,{idHi,idLo}); + i=cmIter->endPos-1; + } else { + writeCall=cmIter->id; + callVisited[writeCall]=true; + } + } + cmIter++; + } + if (cmd.ch!=curCh) { + if (curCh>=0) { + w->writeText(" .text x\"e0\"\n"); + totalSize++; + bankSize++; + } + if (bankSize+cmd.size>=maxBankSize) { + maxBankSize=otherBankSize; + curBank++; + w->writeText(fmt::format(" .endsection\n\n .section {}_bank{}",baseLabel,curBank)); + bankSize=0; + } + w->writeText(fmt::format("\n{}_ch{}\n",baseLabel,cmd.ch)); + curCh=cmd.ch; + } + if (bankSize+cmd.size+1>=maxBankSize) { + maxBankSize=otherBankSize; + curBank++; + w->writeText(fmt::format(" .text x\"c0\"\n .endsection\n\n .section {}_bank{}\n",baseLabel,curBank)); + totalSize++; + bankSize=0; + } + if (writeCall>=0) { + w->writeText(fmt::format("{}_c{}\n",baseLabel,writeCall)); + } + w->writeText(" .text x\""); + for (int j=0; jwriteText(fmt::format("{:02x}",cmd.buf[j])); + } + w->writeText("\"\n"); + totalSize+=cmd.size; + bankSize+=cmd.size; + } + w->writeText(" .text x\"e0\"\n .endsection\n"); + totalSize++; + logAppendf("total size: %d bytes (%d banks)",totalSize,curBank+1); + + output.push_back(DivROMExportOutput("export.asm",w)); + + logAppend("finished!"); + + running=false; +} + +bool DivExportSAPR::go(DivEngine* eng) { + progress[0].name="Compression"; + progress[0].amount=0.0f; + progress[1].name="Confirmed Matches"; + progress[1].amount=0.0f; + + e=eng; + running=true; + failed=false; + mustAbort=false; + exportThread=new std::thread(&DivExportSAPR::run,this); + return true; +} + +void DivExportSAPR::wait() { + if (exportThread!=NULL) { + exportThread->join(); + delete exportThread; + } +} + +void DivExportSAPR::abort() { + mustAbort=true; + wait(); +} + +bool DivExportSAPR::isRunning() { + return running; +} + +bool DivExportSAPR::hasFailed() { + return failed; +} + +DivROMExportProgress DivExportSAPR::getProgress(int index) { + if (index<0 || index>2) return progress[2]; + return progress[index]; +} diff --git a/src/engine/export/sapr.h b/src/engine/export/sapr.h new file mode 100644 index 000000000..14a2dd8b0 --- /dev/null +++ b/src/engine/export/sapr.h @@ -0,0 +1,38 @@ +/** + * Furnace Tracker - multi-system chiptune tracker + * Copyright (C) 2021-2024 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 "../export.h" + +#include + +class DivExportSAPR: public DivROMExport { + DivEngine* e; + std::thread* exportThread; + DivROMExportProgress progress[3]; + bool running, failed, mustAbort; + void run(); + public: + bool go(DivEngine* e); + bool isRunning(); + bool hasFailed(); + void abort(); + void wait(); + DivROMExportProgress getProgress(int index=0); + ~DivExportSAPR() {} +}; diff --git a/src/engine/exportDef.cpp b/src/engine/exportDef.cpp index 00ee94a36..74daa3a5c 100644 --- a/src/engine/exportDef.cpp +++ b/src/engine/exportDef.cpp @@ -60,4 +60,18 @@ void DivEngine::registerROMExports() { }, false, DIV_REQPOL_ANY ); + + romExportDefs[DIV_ROM_SAP_R]=new DivROMExportDef( + "Atari 8-bit SAP-R", "asiekierka", + "SAP type R export for POKEY songs.\n" + "register dump-based, unlike normal SAP.\n" + "for playback, you may use:\n" + "- Altirra\n" + "- lzss-sap (https://github.com/dmsc/lzss-sap/)", + "SAP files", ".sap", + { + DIV_SYSTEM_POKEY + }, + false, DIV_REQPOL_EXACT + ); }