furnace/src/engine/engine.h

1214 lines
32 KiB
C
Raw Normal View History

2022-02-15 03:12:20 +00:00
/**
* Furnace Tracker - multi-system chiptune tracker
2023-01-20 00:18:40 +00:00
* Copyright (C) 2021-2023 tildearrow and contributors
2022-02-15 03:12:20 +00:00
*
* 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.
*/
#ifndef _ENGINE_H
#define _ENGINE_H
#include "config.h"
#include "instrument.h"
#include "song.h"
#include "dispatch.h"
2023-03-13 09:20:54 +00:00
#include "export.h"
#include "dataErrors.h"
#include "safeWriter.h"
#include "cmdStream.h"
#include "../audio/taAudio.h"
#include "blip_buf.h"
#include <atomic>
2022-03-19 08:42:44 +00:00
#include <functional>
#include <initializer_list>
#include <thread>
2021-12-11 08:34:43 +00:00
#include <mutex>
2021-12-19 21:52:04 +00:00
#include <map>
#include <unordered_map>
#include <deque>
2022-02-18 17:58:36 +00:00
#define addWarning(x) \
if (warnings.empty()) { \
warnings+=x; \
} else { \
warnings+=(String("\n")+x); \
}
#define BUSY_BEGIN softLocked=false; isBusy.lock();
#define BUSY_BEGIN_SOFT softLocked=true; isBusy.lock();
#define BUSY_END isBusy.unlock(); softLocked=false;
2023-03-14 01:01:01 +00:00
#define EXTERN_BUSY_BEGIN e->softLocked=false; e->isBusy.lock();
#define EXTERN_BUSY_BEGIN_SOFT e->softLocked=true; e->isBusy.lock();
#define EXTERN_BUSY_END e->isBusy.unlock(); e->softLocked=false;
2023-04-07 21:54:05 +00:00
#define DIV_VERSION "dev152"
#define DIV_ENGINE_VERSION 152
2022-03-14 22:16:43 +00:00
// for imports
#define DIV_VERSION_MOD 0xff01
#define DIV_VERSION_FC 0xff02
2023-03-13 00:11:05 +00:00
#define DIV_VERSION_S3M 0xff03
#define DIV_VERSION_FTM 0xff04
2022-03-14 22:16:43 +00:00
2022-07-26 23:23:01 +00:00
// "Namco C163"
#define DIV_C163_DEFAULT_NAME "Namco 163"
enum DivStatusView {
DIV_STATUS_NOTHING=0,
DIV_STATUS_PATTERN,
DIV_STATUS_COMMANDS
};
2021-06-09 08:33:03 +00:00
enum DivAudioEngines {
DIV_AUDIO_JACK=0,
2022-01-23 04:50:49 +00:00
DIV_AUDIO_SDL=1,
2022-08-16 16:24:18 +00:00
DIV_AUDIO_NULL=126,
DIV_AUDIO_DUMMY=127
2021-06-09 08:33:03 +00:00
};
enum DivAudioExportModes {
DIV_EXPORT_MODE_ONE=0,
DIV_EXPORT_MODE_MANY_SYS,
DIV_EXPORT_MODE_MANY_CHAN
};
2022-02-03 23:38:57 +00:00
enum DivHaltPositions {
DIV_HALT_NONE=0,
DIV_HALT_TICK,
DIV_HALT_ROW,
DIV_HALT_PATTERN,
DIV_HALT_BREAKPOINT
};
2022-09-26 06:27:36 +00:00
enum DivMIDIModes {
DIV_MIDI_MODE_OFF=0,
DIV_MIDI_MODE_NOTE,
DIV_MIDI_MODE_LIGHT_SHOW
};
struct DivChannelState {
std::vector<DivDelayedCommand> delayed;
2022-03-14 06:23:31 +00:00
int note, oldNote, lastIns, pitch, portaSpeed, portaNote;
int volume, volSpeed, cut, rowDelay, volMax;
int delayOrder, delayRow, retrigSpeed, retrigTick;
2022-06-14 09:41:31 +00:00
int vibratoDepth, vibratoRate, vibratoPos, vibratoPosGiant, vibratoDir, vibratoFine;
int tremoloDepth, tremoloRate, tremoloPos;
2023-01-05 08:08:57 +00:00
unsigned char arp, arpStage, arpTicks, panL, panR, panRL, panRR;
bool doNote, legato, portaStop, keyOn, keyOff, nowYouCanStop, stopOnOff;
bool arpYield, delayLocked, inPorta, scheduledSlideReset, shorthandPorta, wasShorthandPorta, noteOnInhibit, resetArp;
bool wentThroughNote, goneThroughNote;
2021-05-14 08:23:40 +00:00
2022-04-09 06:50:44 +00:00
int midiNote, curMidiNote, midiPitch;
size_t midiAge;
2022-04-09 06:50:44 +00:00
bool midiAftertouch;
2021-05-14 08:23:40 +00:00
DivChannelState():
note(-1),
oldNote(-1),
2022-03-14 06:23:31 +00:00
lastIns(-1),
2021-05-14 08:23:40 +00:00
pitch(0),
portaSpeed(-1),
portaNote(-1),
volume(0x7f00),
volSpeed(0),
cut(-1),
rowDelay(0),
2021-12-16 20:51:19 +00:00
volMax(0),
delayOrder(0),
delayRow(0),
retrigSpeed(0),
retrigTick(0),
2021-05-14 08:23:40 +00:00
vibratoDepth(0),
vibratoRate(0),
vibratoPos(0),
2022-06-14 09:41:31 +00:00
vibratoPosGiant(0),
vibratoDir(0),
2021-05-18 08:02:47 +00:00
vibratoFine(15),
2021-05-14 08:23:40 +00:00
tremoloDepth(0),
tremoloRate(0),
tremoloPos(0),
arp(0),
arpStage(-1),
2021-05-18 07:53:59 +00:00
arpTicks(1),
2022-04-30 04:41:14 +00:00
panL(255),
panR(255),
2023-01-05 08:08:57 +00:00
panRL(0),
panRR(0),
doNote(false),
legato(false),
portaStop(false),
keyOn(false),
2022-01-19 06:36:20 +00:00
keyOff(false),
nowYouCanStop(true),
stopOnOff(false),
arpYield(false),
2021-12-19 05:27:04 +00:00
delayLocked(false),
2022-01-19 06:27:32 +00:00
inPorta(false),
2022-02-03 06:30:03 +00:00
scheduledSlideReset(false),
shorthandPorta(false),
wasShorthandPorta(false),
noteOnInhibit(false),
resetArp(false),
wentThroughNote(false),
goneThroughNote(false),
2022-03-31 08:33:05 +00:00
midiNote(-1),
2022-04-09 06:50:44 +00:00
curMidiNote(-1),
midiPitch(-1),
midiAge(0),
2022-04-09 06:50:44 +00:00
midiAftertouch(false) {}
};
2021-12-28 23:23:57 +00:00
struct DivNoteEvent {
int channel, ins, note, volume;
bool on;
DivNoteEvent(int c, int i, int n, int v, bool o):
channel(c),
ins(i),
note(n),
volume(v),
on(o) {}
};
struct DivDispatchContainer {
DivDispatch* dispatch;
blip_buffer_t* bb[DIV_MAX_OUTPUTS];
2022-08-07 22:32:39 +00:00
size_t bbInLen, runtotal, runLeft, runPos, lastAvail;
int temp[DIV_MAX_OUTPUTS], prevSample[DIV_MAX_OUTPUTS];
short* bbInMapped[DIV_MAX_OUTPUTS];
short* bbIn[DIV_MAX_OUTPUTS];
short* bbOut[DIV_MAX_OUTPUTS];
2022-04-09 23:25:25 +00:00
bool lowQuality, dcOffCompensation;
2023-01-03 19:39:31 +00:00
double rateMemory;
2022-01-08 21:03:32 +00:00
void setRates(double gotRate);
2022-01-17 06:42:26 +00:00
void setQuality(bool lowQual);
2023-01-04 22:01:14 +00:00
void grow(size_t size);
void acquire(size_t offset, size_t count);
void flush(size_t count);
void fillBuf(size_t runtotal, size_t offset, size_t size);
2022-01-08 21:03:32 +00:00
void clear();
void init(DivSystem sys, DivEngine* eng, int chanCount, double gotRate, const DivConfig& flags);
2022-01-08 21:03:32 +00:00
void quit();
DivDispatchContainer():
dispatch(NULL),
bbInLen(0),
2022-08-07 22:32:39 +00:00
runtotal(0),
runLeft(0),
runPos(0),
lastAvail(0),
2022-04-09 23:25:25 +00:00
lowQuality(false),
2023-01-03 19:39:31 +00:00
dcOffCompensation(false),
rateMemory(0.0) {
2023-01-03 06:09:46 +00:00
memset(bb,0,DIV_MAX_OUTPUTS*sizeof(blip_buffer_t*));
memset(temp,0,DIV_MAX_OUTPUTS*sizeof(int));
memset(prevSample,0,DIV_MAX_OUTPUTS*sizeof(int));
2023-01-03 06:09:46 +00:00
memset(bbIn,0,DIV_MAX_OUTPUTS*sizeof(short*));
memset(bbInMapped,0,DIV_MAX_OUTPUTS*sizeof(short*));
memset(bbOut,0,DIV_MAX_OUTPUTS*sizeof(short*));
}
};
typedef int EffectValConversion(unsigned char,unsigned char);
struct EffectHandler {
DivDispatchCmds dispatchCmd;
const char* description;
EffectValConversion* val;
EffectValConversion* val2;
EffectHandler(
DivDispatchCmds dispatchCmd_,
const char* description_,
EffectValConversion val_=NULL,
EffectValConversion val2_=NULL
):
dispatchCmd(dispatchCmd_),
description(description_),
val(val_),
val2(val2_) {}
};
struct DivDoNotHandleEffect {
};
typedef std::unordered_map<unsigned char,const EffectHandler> EffectHandlerMap;
struct DivSysDef {
const char* name;
const char* nameJ;
const char* description;
unsigned char id;
unsigned char id_DMF;
int channels;
bool isFM, isSTD, isCompound;
unsigned int vgmVersion;
unsigned int sampleFormatMask;
const char* chanNames[DIV_MAX_CHANS];
const char* chanShortNames[DIV_MAX_CHANS];
int chanTypes[DIV_MAX_CHANS];
// 0: primary
// 1: alternate (usually PCM)
DivInstrumentType chanInsType[DIV_MAX_CHANS][2];
const EffectHandlerMap effectHandlers;
const EffectHandlerMap postEffectHandlers;
DivSysDef(
const char* sysName, const char* sysNameJ, unsigned char fileID, unsigned char fileID_DMF, int chans,
bool isFMChip, bool isSTDChip, unsigned int vgmVer, bool compound, unsigned int formatMask, const char* desc,
std::initializer_list<const char*> chNames,
std::initializer_list<const char*> chShortNames,
std::initializer_list<int> chTypes,
std::initializer_list<DivInstrumentType> chInsType1,
std::initializer_list<DivInstrumentType> chInsType2={},
const EffectHandlerMap fxHandlers_={},
const EffectHandlerMap postFxHandlers_={}):
name(sysName),
nameJ(sysNameJ),
description(desc),
id(fileID),
id_DMF(fileID_DMF),
channels(chans),
isFM(isFMChip),
isSTD(isSTDChip),
isCompound(compound),
vgmVersion(vgmVer),
sampleFormatMask(formatMask),
effectHandlers(fxHandlers_),
postEffectHandlers(postFxHandlers_) {
memset(chanNames,0,DIV_MAX_CHANS*sizeof(void*));
memset(chanShortNames,0,DIV_MAX_CHANS*sizeof(void*));
memset(chanTypes,0,DIV_MAX_CHANS*sizeof(int));
for (int i=0; i<DIV_MAX_CHANS; i++) {
chanInsType[i][0]=DIV_INS_NULL;
chanInsType[i][1]=DIV_INS_NULL;
}
int index=0;
for (const char* i: chNames) {
chanNames[index++]=i;
if (index>=DIV_MAX_CHANS) break;
}
index=0;
for (const char* i: chShortNames) {
chanShortNames[index++]=i;
if (index>=DIV_MAX_CHANS) break;
}
index=0;
for (int i: chTypes) {
chanTypes[index++]=i;
if (index>=DIV_MAX_CHANS) break;
}
index=0;
for (DivInstrumentType i: chInsType1) {
chanInsType[index++][0]=i;
if (index>=DIV_MAX_CHANS) break;
}
index=0;
for (DivInstrumentType i: chInsType2) {
chanInsType[index++][1]=i;
if (index>=DIV_MAX_CHANS) break;
}
}
};
enum DivChanTypes {
DIV_CH_FM=0,
DIV_CH_PULSE=1,
DIV_CH_NOISE=2,
DIV_CH_WAVE=3,
DIV_CH_PCM=4,
DIV_CH_OP=5
};
2022-08-04 05:51:47 +00:00
extern const char* cmdName[];
class DivEngine {
DivDispatchContainer disCont[DIV_MAX_CHIPS];
TAAudio* output;
TAAudioDesc want, got;
String exportPath;
std::thread* exportThread;
int chans;
bool active;
2022-01-17 06:42:26 +00:00
bool lowQuality;
bool playing;
2021-12-28 23:23:57 +00:00
bool freelance;
2022-10-22 08:46:39 +00:00
bool shallStop, shallStopSched;
bool endOfSong;
bool consoleMode;
bool extValuePresent;
bool repeatPattern;
2022-01-04 05:02:41 +00:00
bool metronome;
bool exporting;
bool stopExport;
2022-02-03 23:38:57 +00:00
bool halted;
bool forceMono;
2022-07-25 23:41:47 +00:00
bool clampSamples;
bool cmdStreamEnabled;
bool softLocked;
bool firstTick;
2022-03-31 08:33:05 +00:00
bool skipping;
2022-04-01 07:21:10 +00:00
bool midiIsDirect;
bool lowLatency;
bool systemsRegistered;
bool hasLoadedSomething;
2022-09-26 06:27:36 +00:00
bool midiOutClock;
bool midiOutProgramChange;
2022-09-26 06:27:36 +00:00
int midiOutMode;
2022-03-24 03:05:09 +00:00
int softLockCount;
2023-02-05 07:56:39 +00:00
int subticks, ticks, curRow, curOrder, prevRow, prevOrder, remainingLoops, totalLoops, lastLoopPos, exportLoopCount, nextSpeed, elapsedBars, elapsedBeats, curSpeed;
size_t curSubSongIndex;
2023-01-03 06:09:46 +00:00
size_t bufferPos;
2022-03-16 04:30:15 +00:00
double divider;
int cycles;
double clockDrift;
int stepPlay;
int changeOrd, changePos, totalSeconds, totalTicks, totalTicksR, totalCmds, lastCmds, cmdsPerSecond, globalPitch;
2022-11-10 04:52:10 +00:00
unsigned char extValue, pendingMetroTick;
2023-02-05 07:56:39 +00:00
DivGroovePattern speeds;
2022-05-18 05:05:25 +00:00
short tempoAccum;
DivStatusView view;
2022-02-03 23:38:57 +00:00
DivHaltPositions haltOn;
2022-01-08 06:57:37 +00:00
DivChannelState chan[DIV_MAX_CHANS];
2021-06-09 08:33:03 +00:00
DivAudioEngines audioEngine;
DivAudioExportModes exportMode;
2022-06-06 08:05:55 +00:00
double exportFadeOut;
DivConfig conf;
std::deque<DivNoteEvent> pendingNotes;
2022-09-10 06:39:42 +00:00
// bitfield
unsigned char walked[8192];
2022-01-08 06:57:37 +00:00
bool isMuted[DIV_MAX_CHANS];
std::mutex isBusy, saveLock;
2021-12-19 08:16:24 +00:00
String configPath;
2021-12-19 21:52:04 +00:00
String configFile;
String lastError;
2022-01-29 06:22:32 +00:00
String warnings;
2022-02-14 02:42:57 +00:00
std::vector<String> audioDevs;
std::vector<String> midiIns;
std::vector<String> midiOuts;
std::vector<DivCommand> cmdStream;
std::vector<DivInstrumentType> possibleInsTypes;
static DivSysDef* sysDefs[DIV_MAX_CHIP_DEFS];
static DivSystem sysFileMapFur[DIV_MAX_CHIP_DEFS];
static DivSystem sysFileMapDMF[DIV_MAX_CHIP_DEFS];
DivCSPlayer* cmdStreamInt;
struct SamplePreview {
2022-09-30 22:47:17 +00:00
double rate;
int sample;
int wave;
int pos;
int pBegin, pEnd;
bool dir;
SamplePreview():
2022-09-30 22:47:17 +00:00
rate(0.0),
sample(-1),
wave(-1),
pos(0),
pBegin(-1),
pEnd(-1),
dir(false) {}
} sPreview;
short vibTable[64];
2023-02-04 21:08:20 +00:00
short tremTable[128];
int reversePitchTable[4096];
int pitchTable[4096];
2022-07-21 20:21:29 +00:00
char c163NameCS[1024];
int midiBaseChan;
2022-06-03 23:05:07 +00:00
bool midiPoly;
size_t midiAgeCounter;
2022-01-08 21:03:32 +00:00
blip_buffer_t* samp_bb;
size_t samp_bbInLen;
int samp_temp, samp_prevSample;
short* samp_bbIn;
short* samp_bbOut;
2022-01-04 05:02:41 +00:00
unsigned char* metroTick;
size_t metroTickLen;
float* metroBuf;
size_t metroBufLen;
2022-01-04 05:29:59 +00:00
float metroFreq, metroPos;
2022-01-04 05:02:41 +00:00
float metroAmp;
2022-04-13 07:29:07 +00:00
float metroVol;
2021-12-08 07:57:41 +00:00
size_t totalProcessed;
2022-03-28 23:19:47 +00:00
// MIDI stuff
2022-04-01 06:50:01 +00:00
std::function<int(const TAMidiMessage&)> midiCallback=[](const TAMidiMessage&) -> int {return -2;};
2022-03-28 20:24:09 +00:00
void processRow(int i, bool afterDelay);
void nextOrder();
void nextRow();
void performVGMWrite(SafeWriter* w, DivSystem sys, DivRegWrite& write, int streamOff, double* loopTimer, double* loopFreq, int* loopSample, bool* sampleDir, bool isSecond, int* pendingFreq, int* playingSample, bool directStream);
// returns true if end of song.
bool nextTick(bool noAccum=false, bool inhibitLowLat=false);
bool perSystemEffect(int ch, unsigned char effect, unsigned char effectVal);
bool perSystemPostEffect(int ch, unsigned char effect, unsigned char effectVal);
2022-01-08 21:03:32 +00:00
void recalcChans();
void reset();
void playSub(bool preserveDrift, int goalRow=0);
2023-03-13 19:17:05 +00:00
void testFunction();
bool loadDMF(unsigned char* file, size_t len);
bool loadFur(unsigned char* file, size_t len);
2022-03-14 14:50:52 +00:00
bool loadMod(unsigned char* file, size_t len);
2023-03-13 00:11:05 +00:00
bool loadS3M(unsigned char* file, size_t len);
bool loadFTM(unsigned char* file, size_t len);
bool loadFC(unsigned char* file, size_t len);
2022-04-03 18:53:34 +00:00
void loadDMP(SafeReader& reader, std::vector<DivInstrument*>& ret, String& stripPath);
void loadTFI(SafeReader& reader, std::vector<DivInstrument*>& ret, String& stripPath);
void loadVGI(SafeReader& reader, std::vector<DivInstrument*>& ret, String& stripPath);
void loadS3I(SafeReader& reader, std::vector<DivInstrument*>& ret, String& stripPath);
void loadSBI(SafeReader& reader, std::vector<DivInstrument*>& ret, String& stripPath);
void loadOPLI(SafeReader& reader, std::vector<DivInstrument*>& ret, String& stripPath);
void loadOPNI(SafeReader& reader, std::vector<DivInstrument*>& ret, String& stripPath);
void loadY12(SafeReader& reader, std::vector<DivInstrument*>& ret, String& stripPath);
2022-04-14 11:33:20 +00:00
void loadBNK(SafeReader& reader, std::vector<DivInstrument*>& ret, String& stripPath);
void loadGYB(SafeReader& reader, std::vector<DivInstrument*>& ret, String& stripPath);
2022-04-03 18:53:34 +00:00
void loadOPM(SafeReader& reader, std::vector<DivInstrument*>& ret, String& stripPath);
2022-04-10 12:16:33 +00:00
void loadFF(SafeReader& reader, std::vector<DivInstrument*>& ret, String& stripPath);
2022-05-09 07:49:56 +00:00
void loadWOPL(SafeReader& reader, std::vector<DivInstrument*>& ret, String& stripPath);
void loadWOPN(SafeReader& reader, std::vector<DivInstrument*>& ret, String& stripPath);
2022-04-03 18:53:34 +00:00
int loadSampleROM(String path, ssize_t expectedSize, unsigned char*& ret);
bool initAudioBackend();
bool deinitAudioBackend(bool dueToSwitchMaster=false);
void registerSystems();
void initSongWithDesc(const char* description, bool inBase64=true, bool oldVol=false);
void exchangeIns(int one, int two);
2022-04-28 08:36:15 +00:00
void swapChannels(int src, int dest);
void stompChannel(int ch);
// change song (UNSAFE)
void changeSong(size_t songIndex);
2023-03-12 09:10:46 +00:00
// check whether an asset directory is complete
void checkAssetDir(std::vector<DivAssetDir>& dir, size_t entries);
2023-03-13 19:17:05 +00:00
// add every export method here
friend class DivROMExport;
friend class DivExportAmigaValidation;
public:
2021-05-12 22:19:18 +00:00
DivSong song;
DivOrders* curOrders;
DivChannelData* curPat;
DivSubSong* curSubSong;
DivInstrument* tempIns;
2022-01-27 05:29:16 +00:00
DivSystem sysOfChan[DIV_MAX_CHANS];
int dispatchOfChan[DIV_MAX_CHANS];
int dispatchChanOfChan[DIV_MAX_CHANS];
2022-02-10 08:15:39 +00:00
bool keyHit[DIV_MAX_CHANS];
float* oscBuf[DIV_MAX_OUTPUTS];
2022-01-27 22:49:00 +00:00
float oscSize;
int oscReadPos, oscWritePos;
int tickMult;
std::atomic<size_t> processTime;
2022-01-27 05:29:16 +00:00
void runExportThread();
void nextBuf(float** in, float** out, int inChans, int outChans, unsigned int size);
DivInstrument* getIns(int index, DivInstrumentType fallbackType=DIV_INS_FM);
DivWavetable* getWave(int index);
2022-02-25 03:52:20 +00:00
DivSample* getSample(int index);
DivDispatch* getDispatch(int index);
// parse old system setup description
String decodeSysDesc(String desc);
2021-12-24 23:23:01 +00:00
// start fresh
2022-11-13 21:57:47 +00:00
void createNew(const char* description, String sysName, bool inBase64=true);
2023-02-23 10:56:48 +00:00
void createNewFromDefaults();
// load a file.
2021-12-16 07:21:43 +00:00
bool load(unsigned char* f, size_t length);
// play a binary command stream.
bool playStream(unsigned char* f, size_t length);
// save as .dmf.
SafeWriter* saveDMF(unsigned char version);
// save as .fur.
2022-03-21 19:11:28 +00:00
// if notPrimary is true then the song will not be altered
SafeWriter* saveFur(bool notPrimary=false);
2022-01-17 04:21:27 +00:00
// build a ROM file (TODO).
// specify system to build ROM for.
2023-03-13 19:17:05 +00:00
std::vector<DivROMExportOutput> buildROM(DivROMExportOptions sys);
// dump to VGM.
// set trailingTicks to:
// - 0 to add one tick of trailing
// - x to add x+1 ticks of trailing
// - -1 to auto-determine trailing
// - -2 to add a whole loop of trailing
SafeWriter* saveVGM(bool* sysToExport=NULL, bool loop=true, int version=0x171, bool patternHints=false, bool directStream=false, int trailingTicks=-1);
2022-05-26 05:24:21 +00:00
// dump to ZSM.
SafeWriter* saveZSM(unsigned int zsmrate=60, bool loop=true);
// dump command stream.
SafeWriter* saveCommand(bool binary=false);
// export to an audio file
2022-06-06 08:05:55 +00:00
bool saveAudio(const char* path, int loops, DivAudioExportModes mode, double fadeOutTime=0.0);
// wait for audio export to finish
void waitAudioFile();
// stop audio file export
bool haltAudioFile();
2022-01-18 04:59:52 +00:00
// notify instrument parameter change
void notifyInsChange(int ins);
2022-01-18 05:25:10 +00:00
// notify wavetable change
void notifyWaveChange(int wave);
// dispatch a command
int dispatchCmd(DivCommand c);
// get system IDs
2022-11-13 20:41:40 +00:00
static DivSystem systemFromFileFur(unsigned char val);
static unsigned char systemToFileFur(DivSystem val);
static DivSystem systemFromFileDMF(unsigned char val);
static unsigned char systemToFileDMF(DivSystem val);
2022-11-13 21:25:50 +00:00
// convert old flags
static void convertOldFlags(unsigned int oldFlags, DivConfig& newFlags, DivSystem sys);
2022-07-19 22:01:19 +00:00
// benchmark (returns time in seconds)
double benchmarkPlayback();
double benchmarkSeek();
// returns the minimum VGM version which may carry the specified system, or 0 if none.
int minVGMVersion(DivSystem which);
// determine and setup config dir
void initConfDir();
2021-12-19 21:52:04 +00:00
// save config
bool saveConf();
// load config
bool loadConf();
// get a config value
bool getConfBool(String key, bool fallback);
int getConfInt(String key, int fallback);
float getConfFloat(String key, float fallback);
double getConfDouble(String key, double fallback);
String getConfString(String key, String fallback);
// set a config value
void setConf(String key, bool value);
void setConf(String key, int value);
void setConf(String key, float value);
void setConf(String key, double value);
2022-09-10 23:53:27 +00:00
void setConf(String key, const char* value);
2021-12-19 21:52:04 +00:00
void setConf(String key, String value);
2023-02-06 23:52:51 +00:00
// get whether config value exists
bool hasConf(String key);
// calculate base frequency/period
double calcBaseFreq(double clock, double divider, int note, bool period);
2022-04-25 03:45:59 +00:00
// calculate base frequency in f-num/block format
int calcBaseFreqFNumBlock(double clock, double divider, int note, int bits);
2022-04-25 03:45:59 +00:00
// calculate frequency/period
2022-12-17 07:07:24 +00:00
int calcFreq(int base, int pitch, int arp, bool arpFixed, bool period=false, int octave=0, int pitch2=0, double clock=1.0, double divider=1.0, int blockBits=0);
// calculate arpeggio
int calcArp(int note, int arp, int offset=0);
// convert panning formats
int convertPanSplitToLinear(unsigned int val, unsigned char bits, int range);
2022-04-30 04:41:14 +00:00
int convertPanSplitToLinearLR(unsigned char left, unsigned char right, int range);
unsigned int convertPanLinearToSplit(int val, unsigned char bits, int range);
2022-01-25 20:06:29 +00:00
// find song loop position
2022-01-27 06:04:26 +00:00
void walkSong(int& loopOrder, int& loopRow, int& loopEnd);
2022-01-25 20:06:29 +00:00
// play
void play();
// play to row
void playToRow(int row);
2022-02-06 05:42:07 +00:00
// play by one row
void stepOne(int row);
2021-12-11 08:34:43 +00:00
// stop
void stop();
// reset playback state
void syncReset();
2022-09-30 22:47:17 +00:00
// sample preview query
bool isPreviewingSample();
int getSamplePreviewPos();
double getSamplePreviewRate();
// trigger sample preview
void previewSample(int sample, int note=-1, int pStart=-1, int pEnd=-1);
2022-01-20 21:51:31 +00:00
void stopSamplePreview();
// trigger wave preview
void previewWave(int wave, int note);
void stopWavePreview();
2022-11-06 07:06:51 +00:00
// trigger sample preview
void previewSampleNoLock(int sample, int note=-1, int pStart=-1, int pEnd=-1);
void stopSamplePreviewNoLock();
// trigger wave preview
void previewWaveNoLock(int wave, int note);
void stopWavePreviewNoLock();
2021-12-19 08:16:24 +00:00
// get config path
String getConfigPath();
// get sys channel count
int getChannelCount(DivSystem sys);
2022-01-08 06:57:37 +00:00
// get channel count
int getTotalChannelCount();
// get instrument types available for use
std::vector<DivInstrumentType>& getPossibleInsTypes();
2022-01-20 18:48:20 +00:00
// get effect description
2022-04-19 23:44:05 +00:00
const char* getEffectDesc(unsigned char effect, int chan, bool notNull=false);
2022-01-20 18:48:20 +00:00
2021-12-23 22:09:33 +00:00
// get channel type
// - 0: FM
// - 1: pulse
// - 2: noise
// - 3: wave/other
// - 4: PCM
// - 5: FM operator
int getChannelType(int ch);
2022-01-16 03:11:40 +00:00
// get preferred instrument type
DivInstrumentType getPreferInsType(int ch);
// get alternate instrument type
DivInstrumentType getPreferInsSecondType(int ch);
// get song system name
String getSongSystemLegacyName(DivSong& ds, bool isMultiSystemAcceptable=true);
2021-12-15 22:32:08 +00:00
// get sys name
const char* getSystemName(DivSystem sys);
// get japanese system name
const char* getSystemNameJ(DivSystem sys);
2022-08-16 16:24:18 +00:00
2022-08-27 00:30:13 +00:00
// get sys definition
const DivSysDef* getSystemDef(DivSystem sys);
2022-08-28 15:54:20 +00:00
// convert sample rate format
int fileToDivRate(int frate);
int divToFileRate(int drate);
// get effective sample rate
int getEffectiveSampleRate(int rate);
2021-12-15 22:32:08 +00:00
// is FM system
bool isFMSystem(DivSystem sys);
2021-12-18 03:14:41 +00:00
// is STD system
bool isSTDSystem(DivSystem sys);
2021-12-18 08:25:42 +00:00
// is channel muted
bool isChannelMuted(int chan);
// toggle mute
void toggleMute(int chan);
// toggle solo
void toggleSolo(int chan);
// set mute status
void muteChannel(int chan, bool mute);
// unmute all
void unmuteAll();
2021-12-13 18:10:56 +00:00
// get channel name
const char* getChannelName(int chan);
// get channel short name
const char* getChannelShortName(int chan);
2021-12-13 22:09:46 +00:00
// get channel max volume
int getMaxVolumeChan(int chan);
2021-12-11 08:34:43 +00:00
// get current order
unsigned char getOrder();
2021-12-13 22:09:46 +00:00
// get current row
int getRow();
2022-11-10 06:26:59 +00:00
// get beat/bar
int getElapsedBars();
int getElapsedBeats();
// get current subsong
size_t getCurrentSubSong();
2023-02-05 07:56:39 +00:00
// get speeds
const DivGroovePattern& getSpeeds();
2021-12-21 07:30:09 +00:00
// get Hz
2022-03-16 04:30:15 +00:00
float getHz();
2021-12-21 07:30:09 +00:00
// get current Hz
2022-03-16 04:30:15 +00:00
float getCurHz();
2021-12-21 07:30:09 +00:00
// get time
int getTotalTicks(); // 1/1000000th of a second
int getTotalSeconds();
2021-12-21 07:30:09 +00:00
// get repeat pattern
bool getRepeatPattern();
// set repeat pattern
void setRepeatPattern(bool value);
// has ext value
bool hasExtValue();
// get ext value
unsigned char getExtValue();
2021-12-13 22:09:46 +00:00
// is playing
bool isPlaying();
2022-08-16 16:24:18 +00:00
// is running
bool isRunning();
2021-12-13 22:09:46 +00:00
2022-02-06 05:42:07 +00:00
// is stepping
bool isStepping();
// is exporting
bool isExporting();
// add instrument
int addInstrument(int refChan=0, DivInstrumentType fallbackType=DIV_INS_STD);
// add instrument from pointer
int addInstrumentPtr(DivInstrument* which);
// get instrument from file
// if the returned vector is empty then there was an error.
std::vector<DivInstrument*> instrumentFromFile(const char* path, bool loadAssets=true);
2022-01-19 07:59:44 +00:00
// load temporary instrument
void loadTempIns(DivInstrument* which);
// delete instrument
void delInstrument(int index);
// add wavetable
int addWave();
// add wavetable from pointer
int addWavePtr(DivWavetable* which);
// get wavetable from file
DivWavetable* waveFromFile(const char* path, bool loadRaw=true);
2022-01-11 21:25:55 +00:00
// delete wavetable
void delWave(int index);
// add sample
int addSample();
// add sample from pointer
int addSamplePtr(DivSample* which);
// get sample from file
DivSample* sampleFromFile(const char* path);
// get raw sample
DivSample* sampleFromFileRaw(const char* path, DivSampleDepth depth, int channels, bool bigEndian, bool unsign, bool swapNibbles);
// delete sample
void delSample(int index);
2021-12-22 22:39:16 +00:00
// add order
void addOrder(int pos, bool duplicate, bool where);
2021-12-22 22:39:16 +00:00
2022-02-12 08:59:05 +00:00
// deep clone orders
void deepCloneOrder(int pos, bool where);
2022-02-12 08:59:05 +00:00
2021-12-22 22:39:16 +00:00
// delete order
void deleteOrder(int pos);
2021-12-22 22:39:16 +00:00
// move order up
void moveOrderUp(int& pos);
2021-12-22 22:39:16 +00:00
// move order down
void moveOrderDown(int& pos);
2021-12-22 22:39:16 +00:00
// move thing up
bool moveInsUp(int which);
bool moveWaveUp(int which);
bool moveSampleUp(int which);
// move thing down
bool moveInsDown(int which);
bool moveWaveDown(int which);
bool moveSampleDown(int which);
2023-01-06 23:44:20 +00:00
// automatic patchbay
void autoPatchbay();
2023-01-10 20:58:15 +00:00
void autoPatchbayP();
2023-01-06 23:44:20 +00:00
2023-01-09 00:23:17 +00:00
// connect in patchbay
// returns false if connection already made
bool patchConnect(unsigned int src, unsigned int dest);
// disconnect in patchbay
// returns false if connection doesn't exist
bool patchDisconnect(unsigned int src, unsigned int dest);
2023-01-12 08:56:18 +00:00
// disconnect all in patchbay
void patchDisconnectAll(unsigned int portSet);
2021-12-28 23:23:57 +00:00
// play note
void noteOn(int chan, int ins, int note, int vol=-1);
// stop note
void noteOff(int chan);
void autoNoteOn(int chan, int ins, int note, int vol=-1);
void autoNoteOff(int chan, int note, int vol=-1);
2022-04-16 05:10:52 +00:00
void autoNoteOffAll();
2022-08-16 16:24:18 +00:00
2022-06-03 23:05:07 +00:00
// set whether autoNoteIn is mono or poly
void setAutoNotePoly(bool poly);
2021-12-11 08:34:43 +00:00
// go to order
void setOrder(unsigned char order);
// update system flags
void updateSysFlags(int system, bool restart);
2022-01-28 23:12:56 +00:00
2021-12-15 22:32:08 +00:00
// set Hz
2022-03-16 04:30:15 +00:00
void setSongRate(float hz, bool pal);
2021-12-15 22:32:08 +00:00
// set remaining loops. -1 means loop forever.
void setLoops(int loops);
2022-01-27 05:29:16 +00:00
// get channel state
DivChannelState* getChanState(int chan);
// get dispatch channel state
void* getDispatchChanState(int chan);
2022-08-16 16:24:18 +00:00
// get register pool
2022-02-22 09:01:57 +00:00
unsigned char* getRegisterPool(int sys, int& size, int& depth);
2022-01-27 05:29:16 +00:00
// get macro interpreter
DivMacroInt* getMacroInt(int chan);
// get sample position
DivSamplePos getSamplePos(int chan);
// get osc buffer
DivDispatchOscBuffer* getOscBuffer(int chan);
// enable command stream dumping
void enableCommandStream(bool enable);
// get command stream
void getCommandStream(std::vector<DivCommand>& where);
2021-06-09 08:33:03 +00:00
// set the audio system.
void setAudio(DivAudioEngines which);
// set the view mode.
void setView(DivStatusView which);
2022-02-14 02:42:57 +00:00
// get available audio devices
std::vector<String>& getAudioDevices();
// get available MIDI inputs
std::vector<String>& getMidiIns();
// get available MIDI inputs
std::vector<String>& getMidiOuts();
2022-02-14 02:42:57 +00:00
// rescan audio devices
void rescanAudioDevices();
// set the console mode.
void setConsoleMode(bool enable);
2022-08-16 16:24:18 +00:00
2022-01-04 05:02:41 +00:00
// get metronome
bool getMetronome();
// set metronome
void setMetronome(bool enable);
2022-04-13 07:29:07 +00:00
// set metronome volume (1.0 = 100%)
void setMetronomeVol(float vol);
2023-01-03 06:09:46 +00:00
// get buffer position
int getBufferPos();
2022-02-03 23:38:57 +00:00
// halt now
void halt();
// resume from halt
void resume();
// halt on next something
void haltWhen(DivHaltPositions when);
// is engine halted
bool isHalted();
// get register cheatsheet
const char** getRegisterSheet(int sys);
// load sample ROMs
int loadSampleROMs();
// get the sample format mask
unsigned int getSampleFormatMask();
2022-03-19 08:42:44 +00:00
// UNSAFE render samples - only execute when locked
void renderSamples();
// public render samples
void renderSamplesP();
2022-04-28 08:36:15 +00:00
// public swap channels
void swapChannelsP(int src, int dest);
// public change song
void changeSongP(size_t index);
// add subsong
int addSubSong();
// remove subsong
bool removeSubSong(int index);
2022-06-01 23:50:30 +00:00
// move subsong
void moveSubSongUp(size_t index);
void moveSubSongDown(size_t index);
2022-05-17 06:42:21 +00:00
// clear all subsong data
void clearSubSongs();
2021-12-18 03:14:41 +00:00
// change system
2022-04-28 08:36:15 +00:00
void changeSystem(int index, DivSystem which, bool preserveOrder=true);
2022-01-08 21:03:32 +00:00
// add system
2022-01-08 23:18:23 +00:00
bool addSystem(DivSystem which);
2022-01-08 21:03:32 +00:00
// remove system
2022-04-28 08:36:15 +00:00
bool removeSystem(int index, bool preserveOrder=true);
2022-08-19 21:25:32 +00:00
// move system
bool swapSystem(int src, int dest, bool preserveOrder=true);
2022-08-28 15:54:20 +00:00
2022-02-01 23:08:19 +00:00
// write to register on system
void poke(int sys, unsigned int addr, unsigned short val);
// write to register on system
void poke(int sys, std::vector<DivRegWrite>& wlist);
2021-12-18 03:14:41 +00:00
// get last error
String getLastError();
2022-01-29 06:22:32 +00:00
// get warnings
String getWarnings();
2022-08-16 16:24:18 +00:00
2022-10-02 06:02:01 +00:00
// get debug info
String getPlaybackDebugInfo();
2022-01-17 06:42:26 +00:00
// switch master
bool switchMaster(bool full=false);
// set MIDI base channel
void setMidiBaseChan(int chan);
2022-04-01 07:21:10 +00:00
// set MIDI direct channel map
void setMidiDirect(bool value);
2022-03-28 20:24:09 +00:00
// set MIDI input callback
2022-03-28 23:19:47 +00:00
// if the specified function returns -2, note feedback will be inhibited.
void setMidiCallback(std::function<int(const TAMidiMessage&)> what);
2022-03-28 20:24:09 +00:00
// send MIDI message
bool sendMidiMessage(TAMidiMessage& msg);
2022-03-19 08:42:44 +00:00
// perform secure/sync operation
void synchronized(const std::function<void()>& what);
// perform secure/sync song operation
void lockSave(const std::function<void()>& what);
// perform secure/sync song operation (and lock audio too)
void lockEngine(const std::function<void()>& what);
2022-02-06 02:26:24 +00:00
// get audio desc want
TAAudioDesc& getAudioDescWant();
// get audio desc
TAAudioDesc& getAudioDescGot();
2021-12-13 19:51:35 +00:00
// init dispatch
void initDispatch();
// quit dispatch
void quitDispatch();
2022-12-18 06:55:21 +00:00
// pre-initialize the engine.
void preInit();
// initialize the engine.
bool init();
2021-12-13 22:09:46 +00:00
// terminate the engine.
bool quit();
unsigned char* yrw801ROM;
unsigned char* tg100ROM;
unsigned char* mu5ROM;
DivEngine():
output(NULL),
exportThread(NULL),
chans(0),
active(false),
2022-01-17 06:42:26 +00:00
lowQuality(false),
playing(false),
2021-12-28 23:23:57 +00:00
freelance(false),
2022-09-29 05:27:40 +00:00
shallStop(false),
2022-10-22 08:46:39 +00:00
shallStopSched(false),
endOfSong(false),
consoleMode(false),
extValuePresent(false),
repeatPattern(false),
2022-01-04 05:02:41 +00:00
metronome(false),
exporting(false),
stopExport(false),
2022-02-03 23:38:57 +00:00
halted(false),
forceMono(false),
cmdStreamEnabled(false),
softLocked(false),
firstTick(false),
2022-03-31 08:33:05 +00:00
skipping(false),
2022-04-01 07:21:10 +00:00
midiIsDirect(false),
lowLatency(false),
systemsRegistered(false),
hasLoadedSomething(false),
2022-09-26 06:27:36 +00:00
midiOutClock(false),
midiOutProgramChange(false),
2022-09-26 06:27:36 +00:00
midiOutMode(DIV_MIDI_MODE_NOTE),
2022-03-24 03:05:09 +00:00
softLockCount(0),
subticks(0),
ticks(0),
curRow(0),
curOrder(0),
prevRow(0),
prevOrder(0),
remainingLoops(-1),
2022-06-06 08:05:55 +00:00
totalLoops(0),
lastLoopPos(0),
exportLoopCount(0),
nextSpeed(3),
2022-11-10 06:26:59 +00:00
elapsedBars(0),
elapsedBeats(0),
2023-02-05 07:56:39 +00:00
curSpeed(0),
curSubSongIndex(0),
2023-01-03 06:09:46 +00:00
bufferPos(0),
divider(60),
cycles(0),
clockDrift(0),
2022-02-06 05:42:07 +00:00
stepPlay(0),
changeOrd(-1),
changePos(0),
totalSeconds(0),
totalTicks(0),
totalTicksR(0),
totalCmds(0),
lastCmds(0),
cmdsPerSecond(0),
2022-04-14 23:25:59 +00:00
globalPitch(0),
extValue(0),
2022-11-10 04:52:10 +00:00
pendingMetroTick(0),
2022-05-18 05:05:25 +00:00
tempoAccum(0),
2021-12-13 22:09:46 +00:00
view(DIV_STATUS_NOTHING),
2022-02-03 23:38:57 +00:00
haltOn(DIV_HALT_NONE),
2022-01-23 04:50:49 +00:00
audioEngine(DIV_AUDIO_NULL),
2022-04-14 23:25:59 +00:00
exportMode(DIV_EXPORT_MODE_ONE),
2022-06-06 08:05:55 +00:00
exportFadeOut(0.0),
cmdStreamInt(NULL),
midiBaseChan(0),
2022-06-03 23:05:07 +00:00
midiPoly(true),
midiAgeCounter(0),
2022-04-14 23:25:59 +00:00
samp_bb(NULL),
2022-01-08 21:03:32 +00:00
samp_bbInLen(0),
samp_temp(0),
samp_prevSample(0),
2022-04-14 23:25:59 +00:00
samp_bbIn(NULL),
samp_bbOut(NULL),
2022-01-04 05:02:41 +00:00
metroTick(NULL),
metroTickLen(0),
metroBuf(NULL),
metroBufLen(0),
2022-01-04 05:29:59 +00:00
metroFreq(0),
2022-01-04 05:02:41 +00:00
metroPos(0),
metroAmp(0.0f),
2022-04-13 07:29:07 +00:00
metroVol(1.0f),
2021-12-10 09:22:13 +00:00
totalProcessed(0),
curOrders(NULL),
curPat(NULL),
tempIns(NULL),
2022-01-27 22:49:00 +00:00
oscSize(1),
oscReadPos(0),
oscWritePos(0),
tickMult(1),
processTime(0),
yrw801ROM(NULL),
tg100ROM(NULL),
mu5ROM(NULL) {
2022-04-14 23:25:59 +00:00
memset(isMuted,0,DIV_MAX_CHANS*sizeof(bool));
memset(keyHit,0,DIV_MAX_CHANS*sizeof(bool));
memset(dispatchChanOfChan,0,DIV_MAX_CHANS*sizeof(int));
memset(dispatchOfChan,0,DIV_MAX_CHANS*sizeof(int));
memset(sysOfChan,0,DIV_MAX_CHANS*sizeof(int));
memset(vibTable,0,64*sizeof(short));
2023-02-04 21:08:20 +00:00
memset(tremTable,0,128*sizeof(short));
2022-04-14 23:25:59 +00:00
memset(reversePitchTable,0,4096*sizeof(int));
memset(pitchTable,0,4096*sizeof(int));
memset(sysDefs,0,DIV_MAX_CHIP_DEFS*sizeof(void*));
2022-09-10 06:39:42 +00:00
memset(walked,0,8192);
memset(oscBuf,0,DIV_MAX_OUTPUTS*(sizeof(float*)));
for (int i=0; i<DIV_MAX_CHIP_DEFS; i++) {
sysFileMapFur[i]=DIV_SYSTEM_NULL;
sysFileMapDMF[i]=DIV_SYSTEM_NULL;
}
changeSong(0);
2022-04-14 23:25:59 +00:00
}
};
#endif