From d3ad5fc663cbbfa4c01fbfbf5cfe6f7df82e7d10 Mon Sep 17 00:00:00 2001
From: Norbert Lange
Date: Mon, 8 Jun 2009 18:33:20 +0000
Subject: Initital commit modifying buildsystem and adding a TFMX Module-Player
Changes in Paula.cpp/Paula.h + soundfx.cpp:
Added (easy) queueing of samples by implementing methods that act similar
like writes to the Amiga-Chipset would.
Added counting of DMA-Interrupts, that is how often a sample finished
playing.
Added a base for the interrupt-interval, in most cases this will be the
Cia-clockrate. Derived classes can then set the interval without scaling to
the samplerate
Changes in common/scummsys.h:
Only disable warnings with pragmas for MS Compilers that cant do so
otherwise. Newer MSVC Versions can and should disable warnings in the
Project-Settings.
Files in tfmx:
Some files for debugging. Wont ever be commited back into trunk so those
will contain some messy and hackish code
Added: tfmx.h/tfmx.cpp
Player for TFMX-Modules.
Rest: main.cpp etc.
Modified buildsystem to include new directory, modified main.cpp so it
calls tfmxmain (tfmxplayer.cpp) instead of starting the GUI.
svn-id: r41382
---
Makefile.common | 1 +
base/main.cpp | 36 +
common/scummsys.h | 2 +
dists/msvc9/scummvm-tfmx.sln | 20 +
dists/msvc9/scummvm-tfmx.vcproj | 1784 +++++++++++++++++++++++++++++++++++++++
sound/mods/paula.cpp | 41 +-
sound/mods/paula.h | 74 +-
sound/mods/soundfx.cpp | 11 +-
sound/mods/tfmx.cpp | 798 +++++++++++++++++
sound/mods/tfmx.h | 233 +++++
sound/module.mk | 1 +
tfmx/module.mk | 8 +
tfmx/tfmxdebug.cpp | 190 +++++
tfmx/tfmxdebug.h | 13 +
tfmx/tfmxplayer.cpp | 201 +++++
15 files changed, 3385 insertions(+), 28 deletions(-)
create mode 100644 dists/msvc9/scummvm-tfmx.sln
create mode 100644 dists/msvc9/scummvm-tfmx.vcproj
create mode 100644 sound/mods/tfmx.cpp
create mode 100644 sound/mods/tfmx.h
create mode 100644 tfmx/module.mk
create mode 100644 tfmx/tfmxdebug.cpp
create mode 100644 tfmx/tfmxdebug.h
create mode 100644 tfmx/tfmxplayer.cpp
diff --git a/Makefile.common b/Makefile.common
index c081e2beb3..6e9062592e 100644
--- a/Makefile.common
+++ b/Makefile.common
@@ -25,6 +25,7 @@ MODULES += \
engines \
gui \
graphics \
+ tfmx \
sound \
backends \
common \
diff --git a/base/main.cpp b/base/main.cpp
index a091c5885a..5744ec41f0 100644
--- a/base/main.cpp
+++ b/base/main.cpp
@@ -295,6 +295,40 @@ static void setupKeymapper(OSystem &system) {
}
+#if 1
+void tfmxmain(int argc, const char * const argv[]);
+
+extern "C" int scummvm_main(int argc, const char * const argv[]) {
+ Common::String specialDebug;
+ Common::String command;
+
+ // Verify that the backend has been initialized (i.e. g_system has been set).
+ assert(g_system);
+ OSystem &system = *g_system;
+
+ // Register config manager defaults
+ Base::registerDefaults();
+
+ // Load the plugins.
+ PluginManager::instance().loadPlugins();
+
+ // Init the backend. Must take place after all config data (including
+ // the command line params) was read.
+ system.initBackend();
+
+ // pass control to my own main-function, including arguments
+ tfmxmain(argc,argv);
+
+ PluginManager::instance().unloadPlugins();
+ PluginManager::destroy();
+ Common::ConfigManager::destroy();
+ Common::SearchManager::destroy();
+ GUI::GuiManager::destroy();
+
+ return 0;
+}
+#else
+
extern "C" int scummvm_main(int argc, const char * const argv[]) {
Common::String specialDebug;
Common::String command;
@@ -415,3 +449,5 @@ extern "C" int scummvm_main(int argc, const char * const argv[]) {
return 0;
}
+
+#endif
diff --git a/common/scummsys.h b/common/scummsys.h
index a9c5fb3266..4fa3c80f71 100644
--- a/common/scummsys.h
+++ b/common/scummsys.h
@@ -44,6 +44,7 @@
#ifdef _MSC_VER
#pragma once
+ #if (_MSC_VER < 1300)
#pragma warning( disable : 4068 ) // turn off "unknown pragma" warning
#pragma warning( disable : 4103 ) // turn off "alignement changed after including header" warning. We use pack-start.h file
#pragma warning( disable : 4244 ) // turn off "conversion type" warning
@@ -54,6 +55,7 @@
#pragma warning( disable : 4610 ) // turn off "struct can never be instantiated - user defined constructor required"
#pragma warning( disable : 4701 ) // turn off "potentially uninitialized variables" warning
#pragma warning( disable : 4800 ) // turn off "forcing value to bool 'true' or 'false' (performance warning)"
+ #endif
// vsnprintf is already defined in Visual Studio 2008
#if (_MSC_VER < 1500)
diff --git a/dists/msvc9/scummvm-tfmx.sln b/dists/msvc9/scummvm-tfmx.sln
new file mode 100644
index 0000000000..b00821d4b7
--- /dev/null
+++ b/dists/msvc9/scummvm-tfmx.sln
@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 10.00
+# Visual Studio 2008
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "scummvm", "scummvm-tfmx.vcproj", "{8434CB15-D08F-427D-9E6D-581AE5B28440}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Win32 = Debug|Win32
+ Release|Win32 = Release|Win32
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {8434CB15-D08F-427D-9E6D-581AE5B28440}.Debug|Win32.ActiveCfg = Debug|Win32
+ {8434CB15-D08F-427D-9E6D-581AE5B28440}.Debug|Win32.Build.0 = Debug|Win32
+ {8434CB15-D08F-427D-9E6D-581AE5B28440}.Release|Win32.ActiveCfg = Release|Win32
+ {8434CB15-D08F-427D-9E6D-581AE5B28440}.Release|Win32.Build.0 = Release|Win32
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+EndGlobal
diff --git a/dists/msvc9/scummvm-tfmx.vcproj b/dists/msvc9/scummvm-tfmx.vcproj
new file mode 100644
index 0000000000..63bf94a448
--- /dev/null
+++ b/dists/msvc9/scummvm-tfmx.vcproj
@@ -0,0 +1,1784 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/sound/mods/paula.cpp b/sound/mods/paula.cpp
index 545390ff93..64d387cdc9 100644
--- a/sound/mods/paula.cpp
+++ b/sound/mods/paula.cpp
@@ -27,8 +27,8 @@
namespace Audio {
-Paula::Paula(bool stereo, int rate, int interruptFreq) :
- _stereo(stereo), _rate(rate), _intFreq(interruptFreq) {
+Paula::Paula(bool stereo, int rate, uint interruptFreq) :
+ _stereo(stereo), _rate(rate), _periodScale((kPalSystemClock / 2.0) / rate), _intFreq(interruptFreq) {
clearVoices();
_voice[0].panning = 63;
@@ -36,10 +36,11 @@ Paula::Paula(bool stereo, int rate, int interruptFreq) :
_voice[2].panning = 191;
_voice[3].panning = 63;
- if (_intFreq <= 0)
+ if (_intFreq == 0)
_intFreq = _rate;
- _curInt = _intFreq;
+ _curInt = 0;
+ _timerBase = 1;
_playing = false;
_end = true;
}
@@ -55,8 +56,10 @@ void Paula::clearVoice(byte voice) {
_voice[voice].length = 0;
_voice[voice].lengthRepeat = 0;
_voice[voice].period = 0;
+ _voice[voice].periodRepeat = 0;
_voice[voice].volume = 0;
_voice[voice].offset = 0;
+ _voice[voice].dmaCount = 0;
}
int Paula::readBuffer(int16 *buffer, const int numSamples) {
@@ -95,18 +98,17 @@ int Paula::readBufferIntern(int16 *buffer, const int numSamples) {
// Handle 'interrupts'. This gives subclasses the chance to adjust the channel data
// (e.g. insert new samples, do pitch bending, whatever).
- if (_curInt == _intFreq) {
+ if (_curInt == 0) {
+ _curInt = _intFreq;
interrupt();
- _curInt = 0;
}
// Compute how many samples to generate: at most the requested number of samples,
// of course, but we may stop earlier when an 'interrupt' is expected.
- const int nSamples = MIN(samples, _intFreq - _curInt);
+ const uint nSamples = MIN((uint)samples, _curInt);
// Loop over the four channels of the emulated Paula chip
for (int voice = 0; voice < NUM_VOICES; voice++) {
-
// No data, or paused -> skip channel
if (!_voice[voice].data || (_voice[voice].period <= 0))
continue;
@@ -115,8 +117,7 @@ int Paula::readBufferIntern(int16 *buffer, const int numSamples) {
// the requested output sampling rate (typicall 44.1 kHz or 22.05 kHz)
// as well as the "period" of the channel we are processing right now,
// to compute the correct output 'rate'.
- const double frequency = (7093789.2 / 2.0) / _voice[voice].period;
- frac_t rate = doubleToFrac(frequency / _rate);
+ frac_t rate = doubleToFrac(_periodScale / _voice[voice].period);
// Cap the volume
_voice[voice].volume = MIN((byte) 0x40, _voice[voice].volume);
@@ -126,6 +127,7 @@ int Paula::readBufferIntern(int16 *buffer, const int numSamples) {
frac_t offset = _voice[voice].offset;
frac_t sLen = intToFrac(_voice[voice].length);
const int8 *data = _voice[voice].data;
+ int dmaCount = _voice[voice].dmaCount;
int16 *p = buffer;
int end = 0;
int neededSamples = nSamples;
@@ -141,21 +143,27 @@ int Paula::readBufferIntern(int16 *buffer, const int numSamples) {
// If we have not yet generated enough samples, and looping is active: loop!
if (neededSamples > 0 && _voice[voice].lengthRepeat > 2) {
-
// At this point we know that we have used up all samples in the buffer, so reset it.
_voice[voice].data = data = _voice[voice].dataRepeat;
_voice[voice].length = _voice[voice].lengthRepeat;
sLen = intToFrac(_voice[voice].length);
+ if (_voice[voice].period != _voice[voice].periodRepeat) {
+ _voice[voice].period = _voice[voice].periodRepeat;
+ rate = doubleToFrac(_periodScale / _rate);
+ }
+
// If the "rate" exceeds the sample rate, we would have to perform constant
// wrap arounds. So, apply the first step of the euclidean algorithm to
// achieve the same more efficiently: Take rate modulo sLen
+ // TODO: This messes up dmaCount
if (sLen < rate)
rate %= sLen;
// Repeat as long as necessary.
while (neededSamples > 0) {
- offset = 0;
+ offset &= FRAC_LO_MASK;
+ dmaCount++;
// Compute the number of samples to generate (see above) and mix 'em.
end = MIN(neededSamples, (int)((sLen - offset + rate - 1) / rate));
@@ -164,12 +172,19 @@ int Paula::readBufferIntern(int16 *buffer, const int numSamples) {
}
}
+ // TODO correctly handle setting registers after last 2 bytes red from channel
+ if (offset > sLen) {
+ offset &= FRAC_LO_MASK;
+ dmaCount++;
+ }
+
// Write back the cached data
_voice[voice].offset = offset;
+ _voice[voice].dmaCount = dmaCount;
}
buffer += _stereo ? nSamples * 2 : nSamples;
- _curInt += nSamples;
+ _curInt -= nSamples;
samples -= nSamples;
}
return numSamples;
diff --git a/sound/mods/paula.h b/sound/mods/paula.h
index e3c6002451..5e32dc8580 100644
--- a/sound/mods/paula.h
+++ b/sound/mods/paula.h
@@ -40,12 +40,27 @@ namespace Audio {
class Paula : public AudioStream {
public:
static const int NUM_VOICES = 4;
+ enum {
+ kPalSystemClock = 7093790,
+ kNtscSystemClock = 7159090,
+ kPalCiaClock = kPalSystemClock / 10,
+ kNtscCiaClock = kNtscSystemClock / 10
+ };
- Paula(bool stereo = false, int rate = 44100, int interruptFreq = 0);
+ Paula(bool stereo = false, int rate = 44100, uint interruptFreq = 0);
~Paula();
bool playing() const { return _playing; }
- void setInterruptFreq(int freq) { _curInt = _intFreq = freq; }
+ void setTimerBaseValue( uint32 ticksPerSecond ) { _timerBase = ticksPerSecond; }
+ uint32 getTimerBaseValue() { return _timerBase; }
+ void setSingleInterrupt(uint sampleDelay) { assert(sampleDelay < _intFreq); _curInt = sampleDelay; }
+ void setSingleInterruptUnscaled(uint timerDelay) {
+ setSingleInterrupt((uint)(((double)timerDelay * getRate()) / _timerBase));
+ }
+ void setInterruptFreq(uint sampleDelay) { _intFreq = sampleDelay; _curInt = 0; }
+ void setInterruptFreqUnscaled(uint timerDelay) {
+ setInterruptFreq((uint)(((double)timerDelay * getRate()) / _timerBase));
+ }
void clearVoice(byte voice);
void clearVoices() { for (int i = 0; i < NUM_VOICES; ++i) clearVoice(i); }
void startPlay(void) { _playing = true; }
@@ -65,9 +80,11 @@ protected:
uint32 length;
uint32 lengthRepeat;
int16 period;
+ int16 periodRepeat;
byte volume;
frac_t offset;
byte panning; // For stereo mixing: 0 = far left, 255 = far right
+ int dmaCount;
};
bool _end;
@@ -90,9 +107,24 @@ protected:
_voice[channel].panning = panning;
}
+ void disableChannel(byte channel) {
+ assert(channel < NUM_VOICES);
+ _voice[channel].data = 0;
+ }
+
+ void enableChannel(byte channel) {
+ assert(channel < NUM_VOICES);
+ Channel &ch = _voice[channel];
+ ch.data = ch.dataRepeat;
+ ch.length = ch.lengthRepeat;
+ // actually first 2 bytes are dropped?
+ ch.offset = intToFrac(0);
+ ch.period = ch.periodRepeat;
+ }
+
void setChannelPeriod(byte channel, int16 period) {
assert(channel < NUM_VOICES);
- _voice[channel].period = period;
+ _voice[channel].periodRepeat = period;
}
void setChannelVolume(byte channel, byte volume) {
@@ -100,6 +132,17 @@ protected:
_voice[channel].volume = volume;
}
+ void setChannelSampleStart(byte channel, const int8 *data) {
+ assert(channel < NUM_VOICES);
+ _voice[channel].dataRepeat = data;
+ }
+
+ void setChannelSampleLen(byte channel, uint32 length) {
+ assert(channel < NUM_VOICES);
+ assert(length < 32768/2);
+ _voice[channel].lengthRepeat = 2 * length;
+ }
+
void setChannelData(uint8 channel, const int8 *data, const int8 *dataRepeat, uint32 length, uint32 lengthRepeat, int32 offset = 0) {
assert(channel < NUM_VOICES);
@@ -110,11 +153,14 @@ protected:
assert(lengthRepeat < 32768);
Channel &ch = _voice[channel];
- ch.data = data;
+
+ ch.dataRepeat = data;
+ ch.lengthRepeat = length;
+ enableChannel(channel);
+ ch.offset = intToFrac(offset);
+
ch.dataRepeat = dataRepeat;
- ch.length = length;
ch.lengthRepeat = lengthRepeat;
- ch.offset = intToFrac(offset);
}
void setChannelOffset(byte channel, frac_t offset) {
@@ -128,13 +174,25 @@ protected:
return _voice[channel].offset;
}
+ int getChannelDmaCount(byte channel) {
+ assert(channel < NUM_VOICES);
+ return _voice[channel].dmaCount;
+ }
+
+ void setChannelDmaCount(byte channel, int dmaVal = 0) {
+ assert(channel < NUM_VOICES);
+ _voice[channel].dmaCount = dmaVal;
+ }
+
private:
Channel _voice[NUM_VOICES];
const bool _stereo;
const int _rate;
- int _intFreq;
- int _curInt;
+ const double _periodScale;
+ uint _intFreq;
+ uint _curInt;
+ uint32 _timerBase;
bool _playing;
template
diff --git a/sound/mods/soundfx.cpp b/sound/mods/soundfx.cpp
index 101d8a077d..3af8ca19c6 100644
--- a/sound/mods/soundfx.cpp
+++ b/sound/mods/soundfx.cpp
@@ -46,8 +46,7 @@ public:
enum {
NUM_CHANNELS = 4,
- NUM_INSTRUMENTS = 15,
- CIA_FREQ = 715909
+ NUM_INSTRUMENTS = 15
};
SoundFx(int rate, bool stereo);
@@ -75,12 +74,12 @@ protected:
uint16 _curPos;
uint8 _ordersTable[128];
uint8 *_patternData;
- int _eventsFreq;
uint16 _effects[NUM_CHANNELS];
};
SoundFx::SoundFx(int rate, bool stereo)
: Paula(stereo, rate) {
+ setTimerBaseValue(kPalCiaClock);
_ticks = 0;
_delay = 0;
memset(_instruments, 0, sizeof(_instruments));
@@ -89,7 +88,6 @@ SoundFx::SoundFx(int rate, bool stereo)
_curPos = 0;
memset(_ordersTable, 0, sizeof(_ordersTable));
_patternData = 0;
- _eventsFreq = 0;
memset(_effects, 0, sizeof(_effects));
}
@@ -167,8 +165,7 @@ void SoundFx::play() {
_curPos = 0;
_curOrder = 0;
_ticks = 0;
- _eventsFreq = CIA_FREQ / _delay;
- setInterruptFreq(getRate() / _eventsFreq);
+ setInterruptFreqUnscaled(_delay);
startPaula();
}
@@ -252,7 +249,7 @@ void SoundFx::handleTick() {
}
void SoundFx::disablePaulaChannel(uint8 channel) {
- setChannelPeriod(channel, 0);
+ disableChannel(channel);
}
void SoundFx::setupPaulaChannel(uint8 channel, const int8 *data, uint16 len, uint16 repeatPos, uint16 repeatLen) {
diff --git a/sound/mods/tfmx.cpp b/sound/mods/tfmx.cpp
new file mode 100644
index 0000000000..96f3f051e3
--- /dev/null
+++ b/sound/mods/tfmx.cpp
@@ -0,0 +1,798 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#include "common/scummsys.h"
+#include "common/endian.h"
+#include "common/stream.h"
+#include "common/util.h"
+#include "common/debug.h"
+
+#include "sound/mods/tfmx.h"
+
+#include "tfmx/tfmxdebug.h"
+
+namespace Audio {
+
+const uint16 Tfmx::noteIntervalls[64] = {
+ 1710, 1614, 1524, 1438, 1357, 1281, 1209, 1141, 1077, 1017, 960, 908,
+ 856, 810, 764, 720, 680, 642, 606, 571, 539, 509, 480, 454,
+ 428, 404, 381, 360, 340, 320, 303, 286, 270, 254, 240, 227,
+ 214, 202, 191, 180, 170, 160, 151, 143, 135, 127, 120, 113,
+ 214, 202, 191, 180, 170, 160, 151, 143, 135, 127, 120, 113,
+ 214, 202, 191, 180 };
+
+
+
+Tfmx::Tfmx(int rate, bool stereo)
+: Paula(stereo, rate), _resource() {
+ _playerCtx.enabled = false;
+ _playerCtx.song = -1;
+
+ for (int i = 0; i < kNumVoices; ++i)
+ _channelCtx[i].paulaChannel = i;
+}
+
+Tfmx::~Tfmx() {
+}
+
+void Tfmx::interrupt() {
+ assert(!_end);
+ for (int i = 0; i < kNumVoices; ++i) {
+ ChannelContext &channel = _channelCtx[i];
+
+ if (channel.countDmaInterrupts) {
+ // wait for DMA Interupts to happen
+ int doneDma = getChannelDmaCount(channel.paulaChannel);
+ if (doneDma > channel.dmaCount) {
+ debug("channel %d, DMA done", i);
+ channel.countDmaInterrupts = false;
+ channel.macroRun = true;
+ }
+ }
+
+ // TODO: Sometimes a macro will be executed here
+
+ // apply timebased effects on Parameters
+ effects(channel);
+
+ // see if we have to run the macro-program
+ if (channel.macroRun) {
+ if (channel.macroWait == 0) {
+ // run macro
+ while (macroStep(channel))
+ ;
+ } else
+ --channel.macroWait;
+ }
+ // FIXME handle Volume
+ Paula::setChannelVolume(channel.paulaChannel, 0x40);
+ }
+
+ // Patterns are only processed each _playerCtx.timerCount + 1 tick
+ if (_playerCtx.song >= 0 && !_playerCtx.patternCount--) {
+ _playerCtx.patternCount = _playerCtx.patternSkip;
+ advancePatterns();
+ }
+}
+
+void Tfmx::effects(ChannelContext &channel) {
+ if (channel.sfxLockTime >= 0)
+ --channel.sfxLockTime;
+ else
+ channel.sfxLocked = false;
+
+ // TODO: macroNote pending?
+ if (0) {
+ channel.sfxLocked = false;
+ // TODO: macronote
+ }
+
+ // vibratio
+
+ // porta
+
+ // envelope
+}
+
+FORCEINLINE bool Tfmx::macroStep(ChannelContext &channel) {
+ const byte *const macroPtr = (byte *)(_resource.getMacroPtr(channel.macroOffset) + channel.macroStep);
+ ++channel.macroStep;
+ //int channelNo = ((byte*)&channel-(byte*)_channelCtx)/sizeof(ChannelContext);
+
+ displayMacroStep(macroPtr);
+
+ int32 temp = 0;
+
+ switch (macroPtr[0]) {
+ case 0x00: // Reset + DMA Off. Parameters: deferWait, addset, vol
+ channel.envReset = 0;
+ channel.vibReset = 0;
+ channel.portaRate = 0;
+ // FT
+ case 0x13: // DMA Off. Parameters: deferWait, addset, vol
+ // TODO: implement PArameters
+ Paula::disableChannel(channel.paulaChannel);
+ channel.deferWait = macroPtr[1] >= 1;
+ if (channel.deferWait) {
+ // if set, then we expect a DMA On in the same tick.
+ Paula::setChannelPeriod(channel.paulaChannel, 4);
+ Paula::setChannelSampleLen(channel.paulaChannel, 1);
+ // in this state we then need to allow some commands that normally
+ // would halt the macroprogamm to continue instead.
+ // those commands are: Wait, WaitDMA, AddPrevNote, AddNote, SetNote,
+ // DMA On is affected aswell
+ // TODO remember time disabled?.
+ } else {
+ //TODO ?
+ }
+ return true;
+
+ case 0x01: // DMA On
+ channel.countDmaInterrupts = false;
+ if (channel.deferWait) {
+ // TODO
+ // there is actually a small delay in the player, but I think that
+ // only allows to clear DMA-State on real Hardware
+ }
+ Paula::enableChannel(channel.paulaChannel);
+ channel.deferWait = false;
+ return true;
+
+ case 0x02: // SetBeginn. Parameters: SampleOffset(L)
+ channel.sampleStart = READ_BE_UINT32(macroPtr) & 0xFFFFFF;
+ Paula::setChannelSampleStart(channel.paulaChannel, _resource.getSamplePtr(channel.sampleStart));
+ return true;
+
+ case 0x03: // SetLength. Parameters: SampleLength(W)
+ channel.sampleLen = READ_BE_UINT16(¯oPtr[2]);
+ Paula::setChannelSampleLen(channel.paulaChannel, channel.sampleLen);
+ return true;
+
+ case 0x04: // Wait. Parameters: Ticks to wait(W).
+ // TODO: some unkown Parameter? (macroPtr[1] & 1)
+ channel.macroWait = READ_BE_UINT16(¯oPtr[2]);
+ return false;
+
+ case 0x10: // Loop Key Up. Parameters: Loopcount, MacroStep(W)
+ if (!channel.keyUp)
+ return true;
+ // FT
+ case 0x05: // Loop. Parameters: Loopcount, MacroStep(W)
+ // debug("Step %d, Loopcount: %02X", channel.macroStep, channel.macroLoopCount);
+ if (channel.macroLoopCount != 0) {
+ if (channel.macroLoopCount == 0xFF)
+ channel.macroLoopCount = macroPtr[1];
+ channel.macroStep = READ_BE_UINT16(¯oPtr[2]);
+ }
+ --channel.macroLoopCount;
+ return true;
+
+ case 0x06: // Jump. Parameters: MacroIndex, MacroStep(W)
+ channel.macroOffset = _macroOffset[macroPtr[1] % kMaxMacroOffsets];
+ channel.macroStep = READ_BE_UINT16(¯oPtr[2]);
+ channel.macroLoopCount = 0xFF;
+ return true;
+
+ case 0x07: // Stop Macro
+ channel.macroRun = false;
+ return false;
+
+ case 0x1F: // AddPrevNote. Parameters: Note, Finetune(W)
+ case 0x08: // AddNote. Parameters: Note, Finetune(W)
+ temp = (macroPtr[0] == 0x08) ? channel.note : channel.prevNote;
+ // Fallthrough to SetNote
+ case 0x09: { // SetNote. Parameters: Note, Finetune(W)
+ const uint16 noteInt = noteIntervalls[(temp + macroPtr[1]) & 0x3F];
+ const uint16 finetune = READ_BE_UINT16(¯oPtr[2]) + channel.fineTune + 0x0100;
+ channel.portaDestPeriod = (uint16)((noteInt * finetune) >> 8);
+ if (!channel.portaRate) {
+ channel.period = channel.portaDestPeriod;
+ Paula::setChannelPeriod(channel.paulaChannel, channel.portaDestPeriod);
+ }
+ return channel.deferWait;
+ }
+
+ case 0x0A: // Clear Effects
+ channel.envReset = 0;
+ channel.vibReset = 0;
+ channel.portaRate = 0;
+ return true;
+
+ case 0x0B: // Portamento. Parameters: count, speed
+ macroPtr[1];
+ macroPtr[3];
+ return true;
+
+ case 0x0C: // Vibrato. Parameters: Speed, intensity
+ macroPtr[1];
+ macroPtr[3];
+ return true;
+
+ case 0x0D: // Add Volume. Parameters: unknown, volume
+ macroPtr[2];
+ macroPtr[3];
+ return true;
+
+ case 0x0E: // Set Volume. Parameters: unknown, volume
+ macroPtr[2];
+ macroPtr[3];
+ return true;
+
+ case 0x0F: // Envelope. Parameters: speed, count, endvol
+ macroPtr[1];
+ macroPtr[2];
+ macroPtr[3];
+ return true;
+
+ case 0x11: // AddBegin. Parameters: times, Offset(W)
+ // TODO: implement Parameter
+ macroPtr[1];
+// debug("prev: %06X, after: %06X", channel.sampleStart, channel.sampleStart + (int16)READ_BE_UINT16(¯oPtr[2]));
+ channel.sampleStart += (int16)READ_BE_UINT16(¯oPtr[2]);
+ Paula::setChannelSampleStart(channel.paulaChannel, _resource.getSamplePtr(channel.sampleStart));
+ return true;
+
+ case 0x12: // AddLen. Parameters: added Length(W)
+ channel.sampleLen += READ_BE_UINT16(¯oPtr[2]);
+ Paula::setChannelSampleLen(channel.paulaChannel, channel.sampleLen);
+ return true;
+
+ case 0x14: // Wait key up. Parameters: wait cycles(W)
+ if (!channel.keyUp || channel.macroLoopCount == 0) {
+ channel.macroLoopCount = 0xFF;
+ return true;
+ } else if (channel.macroLoopCount == 0xFF)
+ channel.macroLoopCount = macroPtr[3];
+ --channel.macroLoopCount;
+ return false;
+
+ case 0x15: // Subroutine. Parameters: MacroIndex, Macrostep(W)
+ channel.macroReturnOffset = channel.macroOffset;
+ channel.macroReturnStep = channel.macroStep;
+
+ channel.macroOffset = _macroOffset[macroPtr[1] % kMaxMacroOffsets];
+ channel.macroStep = READ_BE_UINT16(¯oPtr[2]);
+ // TODO: MI does some weird stuff there. Figure out which varioables need to be set
+ return true;
+
+ case 0x16: // Return from Sub.
+ channel.macroOffset = channel.macroReturnOffset;
+ channel.macroStep = channel.macroReturnStep;
+ return true;
+
+ case 0x17: // set Period. Parameters: Period(W)
+ channel.portaDestPeriod = READ_BE_UINT16(¯oPtr[2]);
+ if (!channel.portaRate) {
+ channel.period = channel.portaDestPeriod;
+ Paula::setChannelPeriod( channel.paulaChannel, channel.portaDestPeriod);
+ }
+ return true;
+
+ case 0x18: // Sampleloop. Parameters: Offset from Samplestart(W)
+ // TODO: MI loads 24 bit, but thats useless?
+ temp = READ_BE_UINT16(¯oPtr[2]);
+ assert(!(temp & 1));
+ channel.sampleStart += temp & 0xFFFE;
+ channel.sampleLen -= (temp / 2);
+ Paula::setChannelSampleStart(channel.paulaChannel, _resource.getSamplePtr(channel.sampleStart));
+ Paula::setChannelSampleLen(channel.paulaChannel, channel.sampleLen);
+ return true;
+
+ case 0x19: // set one-shot Sample
+ channel.sampleStart = 0;
+ channel.sampleLen = 1;
+ Paula::setChannelSampleStart(channel.paulaChannel, _resource.getSamplePtr(0));
+ Paula::setChannelSampleLen(channel.paulaChannel, 1);
+ return true;
+
+ case 0x1A: // Wait on DMA. Parameters: Cycles-1(W) to wait
+ channel.dmaCount = READ_BE_UINT16(¯oPtr[2]);
+ channel.countDmaInterrupts = true;
+ channel.macroRun = false;
+ Paula::setChannelDmaCount(channel.paulaChannel);
+ return channel.deferWait;
+
+ case 0x1B: // Random play. Parameters: macro/speed/mode
+ macroPtr[1];
+ macroPtr[2];
+ macroPtr[3];
+ return true;
+
+ case 0x1C: // Splitkey. Parameters: key/macrostep(W)
+ macroPtr[1];
+ READ_BE_UINT16(¯oPtr[2]);
+ return true;
+
+ case 0x1D: // Splitvolume. Parameters: volume/macrostep
+ macroPtr[1];
+ READ_BE_UINT16(¯oPtr[2]);
+ return true;
+
+ case 0x1E: // Addvol+note. Parameters: note/CONST./volume
+ return true;
+
+ case 0x20: // Signal. Parameters: signalnumber/value
+ return true;
+
+ case 0x21: // Play macro. Parameters: macro/chan/detune
+ return true;
+#if defined(TFMX_NOT_IMPLEMENTED)
+ // used by Gem`X according to the docs
+ case 0x22: // SID setbeg. Parameters: sample-startadress
+ return true;
+ case 0x23: // SID setlen. Parameters: buflen/sourcelen
+ return true;
+ case 0x24: // SID op3 ofs. Parameters: offset
+ return true;
+ case 0x25: // SID op3 frq. Parameters: speed/amplitude
+ return true;
+ case 0x26: // SID op2 ofs. Parameters: offset
+ return true;
+ case 0x27: // SID op2 frq. Parameters: speed/amplitude
+ return true;
+ case 0x28: // ID op1. Parameters: speed/amplitude/TC
+ return true;
+ case 0x29: // SID stop. Parameters: flag (1=clear all)
+ return true;
+ // 30-34 used by Carribean Disaster
+#endif
+ default:
+ return channel.deferWait;
+ }
+}
+
+void Tfmx::advancePatterns() {
+doTrackstep:
+ if (_playerCtx.pendingTrackstep) {
+ while (trackStep())
+ ;
+ _playerCtx.pendingTrackstep = false;
+ }
+
+ for (int i = 0; i < kNumChannels; ++i) {
+ assert(!_playerCtx.pendingTrackstep);
+
+ const uint8 pattCmd = _patternCtx[i].command;
+ if (pattCmd < 0x90) { // execute Patternstep
+ // FIXME: 0x90 is very likely a bug, 0x80 would make more sense
+ assert(pattCmd < 0x80);
+
+ if (_patternCtx[i].wait == 0) {
+ // issue all Steps for this tick
+ while (patternStep(_patternCtx[i]))
+ ;
+ } else
+ --_patternCtx[i].wait;
+
+ } else if (pattCmd == 0xFE) { // Stop voice in pattern.expose
+ _patternCtx[i].command = 0xFF;
+ stopChannel(_channelCtx[_patternCtx[i].expose % kNumVoices]);
+ } // else this pattern-Channel is stopped
+
+ if (_playerCtx.pendingTrackstep) {
+ // we load the next Trackstep Command and then process all Channels again
+ // TODO Optionally disable looping
+ if (_trackCtx.startInd == _trackCtx.stopInd)
+ _trackCtx.posInd = _trackCtx.startInd;
+ else
+ ++_trackCtx.posInd;
+ goto doTrackstep;
+ }
+ }
+}
+
+FORCEINLINE bool Tfmx::patternStep(PatternContext &pattern) {
+ const byte *const patternPtr = (byte *)(_resource.getPatternPtr(pattern.offset) + pattern.step);
+ ++pattern.step;
+
+ debug("Pattern %04X +%d", pattern.offset, pattern.step-1);
+ displayPatternstep(patternPtr);
+
+ const byte pattCmd = patternPtr[0];
+
+ if (pattCmd < 0xF0) { // Playnote
+ const byte flags = pattCmd >> 6; // 0-1 means note, 2 means wait, 3 means portamento
+ byte noteCmd = pattCmd + pattern.expose;
+ byte param3 = patternPtr[3];
+ if (flags == 2) {
+ // Store wait-value in context and delete it the (note)command
+ pattern.wait = param3;
+ param3 = 0;
+ }
+ if (flags != 3)
+ noteCmd &= 0x3F;
+ noteCommand(noteCmd, patternPtr[1], patternPtr[2], param3);
+ return (flags != 2);
+
+ } else { // Patterncommand
+ switch (pattCmd & 0xF) {
+ case 0: // End Pattern + Next Trackstep
+ pattern.command = 0xFF;
+ _playerCtx.pendingTrackstep = true;
+ return false;
+
+ case 1: // Loop Pattern. Parameters: Loopcount, PatternStep(W)
+ if (pattern.loopCount != 0) {
+ if (pattern.loopCount == 0xFF)
+ pattern.loopCount = patternPtr[1];
+ pattern.step = READ_BE_UINT16(&patternPtr[2]);
+ }
+ --pattern.loopCount;
+ return true;
+
+ case 2: // Jump. Parameters: PatternIndex, PatternStep(W)
+ pattern.offset = _patternOffset[patternPtr[1]];
+ pattern.step = READ_BE_UINT16(&patternPtr[2]);
+ return true;
+
+ case 3: // Wait. Paramters: ticks to wait
+ pattern.wait = patternPtr[1];
+ // TODO check for 0?
+ return false;
+
+ case 14: // Stop custompattern
+ // TODO ?
+ // FT
+ case 4: // Stop this pattern
+ pattern.command = 0xFF;
+ // TODO: try figuring out if this was the last Channel?
+ return false;
+
+ case 5: // Kup^-Set key up
+ case 6: // Vibrato
+ case 7: // Envelope
+ case 12: // Lock
+ noteCommand(pattCmd, patternPtr[1], patternPtr[2], patternPtr[3]);
+ return true;
+
+ case 8: // Subroutine
+ return true;
+ case 9: // Return from Subroutine
+ return true;
+ case 10: // fade master volume
+ return true;
+
+ case 11: { // play pattern. Parameters: patternCmd, channel, expose
+ PatternContext &target = _patternCtx[patternPtr[2] % kNumChannels];
+
+ target.command = patternPtr[1];
+ target.offset = _patternOffset[patternPtr[1] % kMaxPatternOffsets];
+ target.expose = patternPtr[3];
+ target.step = 0;
+ target.wait = 0;
+ target.loopCount = 0xFF;
+ }
+ return true;
+ case 13: // Cue
+ return true;
+ case 15: // NOP
+ return true;
+ }
+ }
+
+ return true;
+}
+
+bool Tfmx::trackStep() {
+ const uint16 *const trackData = _resource.getTrackPtr(_trackCtx.posInd);
+
+ debug( "TStep %04X", _trackCtx.posInd);
+ displayTrackstep(trackData);
+
+ if (trackData[0] != FROM_BE_16(0xEFFE)) {
+ // 8 commands for Patterns
+ for (int i = 0; i < 8; ++i) {
+ const uint patCmd = READ_BE_UINT16(&trackData[i]);
+
+ // First byte is pattern number
+ const uint patNum = (patCmd >> 8);
+
+ // if highest bit is set then keep previous pattern
+ if (patNum < 0x80) {
+ _patternCtx[i].command = (uint8)patNum;
+ _patternCtx[i].step = 0;
+ _patternCtx[i].wait = 0;
+ _patternCtx[i].loopCount = 0xFF;
+ _patternCtx[i].offset = _patternOffset[patNum];
+ }
+
+ // second byte expose is always set
+ _patternCtx[i].expose = patCmd & 0xFF;
+ }
+ return false;
+
+ } else {
+ // 16 byte Trackstep Command
+ int temp;
+ switch (READ_BE_UINT16(&trackData[1])) {
+ case 0: // Stop Player. No Parameters
+ _playerCtx.enabled = 0;
+ stopPaula();
+ return false;
+
+ case 1: // Branch/Loop section of tracksteps. Parameters: branch target, loopcount
+ // this depends on the current loopCounter
+ temp = _trackCtx.loopCount;
+ if (temp > 0) {
+ // if trackloop is positive, we decrease one loop and continue at start of loop
+ --_trackCtx.loopCount;
+ _trackCtx.posInd = READ_BE_UINT16(&trackData[2]);
+ } else if (temp == 0) {
+ // if trackloop is 0, we reached last iteration and continue with next trackstep
+ _trackCtx.loopCount = (uint16)-1;
+ } else /*if (_context.TrackLoop < 0)*/ {
+ // if TrackLoop is negative then we reached the loop instruction the first time
+ // and we setup the Loop
+ _trackCtx.posInd = READ_BE_UINT16(&trackData[2]);
+ _trackCtx.loopCount = READ_BE_UINT16(&trackData[3]);
+ }
+ break;
+
+ case 2: // Set Tempo. Parameters: tempo, divisor
+ _playerCtx.patternCount = _playerCtx.patternSkip = READ_BE_UINT16(&trackData[2]); // tempo
+ temp = READ_BE_UINT16(&trackData[3]); // divisor
+
+ if (!(temp & 0x8000) && (temp & 0x1FF))
+ setInterruptFreqUnscaled(temp & 0x1FF);
+ break;
+
+ case 3: // Unknown, stops player aswell
+ case 4: // Fade
+ default:
+ debug("Unknown Command: %02X", READ_BE_UINT16(&trackData[1]));
+ // MI-Player handles this by stopping the player, we just continue
+ }
+ ++_trackCtx.posInd;
+ return true;
+ }
+}
+
+void Tfmx::noteCommand(const uint8 note, const uint8 param1, const uint8 param2, const uint8 param3) {
+ ChannelContext &channel = _channelCtx[param2 % kNumVoices];
+
+ if (note == 0xFC) { // Lock
+ channel.sfxLocked = (param1 != 0);
+ channel.sfxLockTime = param3; // only 1 byte read!
+ return;
+ }
+ if (channel.sfxLocked)
+ return;
+
+ if (note < 0xC0) { // Play Note
+ channel.prevNote = channel.note;
+ channel.note = note;
+ channel.macroOffset = _macroOffset[param1 % kMaxMacroOffsets];
+ channel.relVol = (param2 >> 4) & 0xF;
+ channel.fineTune = (int16)param3;
+
+ initMacroProgramm(channel);
+ channel.keyUp = true;
+
+ } else if (note < 0xF0) { // do that porta stuff
+ channel.portaReset = param1;
+ channel.portaTime = 1;
+ if (!channel.portaRate)
+ channel.portaPeriod = channel.portaDestPeriod;
+ channel.portaRate = param3;
+
+ channel.note = note & 0x3F;
+ channel.portaDestPeriod = noteIntervalls[channel.note];
+ } else switch (note & 0xF) { // Command
+ case 5: // Key Up Release
+ channel.keyUp = false;
+ break;
+ case 6: // Vibratio
+ channel.vibReset = param1 & 0xFE;
+ channel.vibTime = param1 / 2;
+ channel.vibFlag = 1;
+ channel.vibOffset = 0;
+ break;
+ case 7: // Envelope
+ channel.envRate = param1;
+ channel.envReset = channel.envTime = (param2 >> 4) + 1;
+ channel.envEndVolume = param3;
+ break;
+ }
+}
+
+bool Tfmx::load(Common::SeekableReadStream &musicData, Common::SeekableReadStream &sampleData) {
+ bool res;
+
+ assert(0 == _resource._mdatData);
+ assert(0 == _resource._sampleData);
+
+ // TODO: Sanity checks if we have a valid TFMX-Module
+ // TODO: check for Stream-Errors (other than using asserts)
+
+ // 0x0000: 10 Bytes Header "TFMX-SONG "
+ // 0x000A: int16 ?
+ // 0x000C: int32 ?
+ musicData.read(_resource.header, 10);
+ _resource.headerFlags = musicData.readUint16BE();
+ _resource.headerUnknown = musicData.readUint32BE();
+
+ // This might affect timing
+ // bool isPalModule = (_resource.headerFlags & 2) != 0;
+
+ // 0x0010: 6*40 Textfield
+ musicData.read(_resource.textField, 6 * 40);
+
+ /* 0x0100: Songstart x 32*/
+ for (int i = 0; i < kNumSubsongs; ++i)
+ _subsong[i].songstart = musicData.readUint16BE();
+
+ /* 0x0140: Songend x 32*/
+ for (int i = 0; i < kNumSubsongs; ++i)
+ _subsong[i].songend = musicData.readUint16BE();
+
+ /* 0x0180: Tempo x 32*/
+ for (int i = 0; i < kNumSubsongs; ++i)
+ _subsong[i].tempo = musicData.readUint16BE();
+
+ /* 0x01c0: unused ? */
+ musicData.skip(16);
+
+ /* 0x01d0: trackstep, pattern data p, macro data p */
+ uint32 offTrackstep = musicData.readUint32BE();
+ uint32 offPatternP = musicData.readUint32BE();
+ uint32 offMacroP = musicData.readUint32BE();
+
+ // This is how MI`s TFMX-Player tests for unpacked Modules.
+ if (offTrackstep == 0) {
+ offTrackstep = 0x600 + 0x200;
+ offPatternP = 0x200 + 0x200;
+ offMacroP = 0x400 + 0x200;
+ }
+
+ _resource._trackstepOffset = offTrackstep;
+
+ // Read in pattern starting offsets
+ musicData.seek(offPatternP);
+ for (int i = 0; i < kMaxPatternOffsets; ++i)
+ _patternOffset[i] = musicData.readUint32BE();
+
+ res = musicData.err();
+ assert(!res);
+
+ // Read in macro starting offsets
+ musicData.seek(offMacroP);
+ for (int i = 0; i < kMaxMacroOffsets; ++i)
+ _macroOffset[i] = musicData.readUint32BE();
+
+ res = musicData.err();
+ assert(!res);
+
+ // Read in whole mdat-file
+ int32 size = musicData.size();
+ assert(size != -1);
+ // TODO: special routine if size = -1?
+
+ _resource._mdatData = new byte[size];
+ assert(_resource._mdatData);
+ _resource._mdatLen = size;
+ musicData.seek(0);
+ musicData.read(_resource._mdatData, size);
+
+ res = musicData.err();
+ assert(!res);
+ musicData.readByte();
+ res = musicData.eos();
+ assert(res);
+
+
+ // TODO: It would be possible to analyze the pointers and be able to
+ // seperate the file in trackstep, patterns and macro blocks
+ // Modules could do weird stuff like having those blocks mixed though.
+ // TODO: Analyze pointers if they are correct offsets,
+ // so that accesses can be unchecked later
+
+ // Read in whole sample-file
+ size = sampleData.size();
+ assert(size >= 4);
+ assert(size != -1);
+ // TODO: special routine if size = -1?
+
+ _resource._sampleData = new byte[size];
+ assert(_resource._sampleData);
+ _resource._sampleLen = size;
+ sampleData.seek(0);
+ sampleData.read(_resource._sampleData, size);
+ for (int i = 0; i < 4; ++i)
+ _resource._sampleData[i] = 0;
+
+ res = sampleData.err();
+ assert(!res);
+ sampleData.readByte();
+ res = sampleData.eos();
+ assert(res);
+
+ return true;
+}
+
+
+void Tfmx::doMacro(int macro, int note) {
+ assert(0 <= macro && macro < kMaxMacroOffsets);
+ assert(0 <= note && note < 0xC0);
+
+ _playerCtx.song = -1;
+ _playerCtx.volume = 0x40;
+
+ const int channel = 0;
+ _channelCtx[channel].sfxLocked = false;
+ _channelCtx[channel].note = 0;
+
+ for (int i = 0; i < kNumVoices; ++i) {
+ _channelCtx[i].sfxLocked = false;
+ stopChannel(_channelCtx[i]);
+ }
+
+ noteCommand(note, macro, channel, 0);
+
+ setTimerBaseValue(kPalCiaClock);
+ setInterruptFreqUnscaled(kPalDefaultCiaVal);
+ startPaula();
+}
+
+void Tfmx::doSong(int songPos) {
+ assert(0 <= songPos && songPos < kNumSubsongs);
+
+ _playerCtx.song = (int8)songPos;
+ _playerCtx.volume = 0x40;
+
+ _trackCtx.loopCount = -1;
+ _trackCtx.startInd = _trackCtx.posInd = _subsong[songPos].songstart;
+ _trackCtx.stopInd = _subsong[songPos].songend;
+
+ const uint16 tempo = _subsong[songPos].tempo;
+ uint16 ciaIntervall;
+
+ if (tempo >= 0x10) {
+ ciaIntervall = (uint16)(kCiaBaseInterval / tempo);
+ _playerCtx.patternSkip = 0;
+ } else {
+ ciaIntervall = kPalDefaultCiaVal;
+ _playerCtx.patternSkip = tempo;
+ }
+
+ _playerCtx.patternCount = 0;
+
+ _playerCtx.pendingTrackstep = true;
+
+ for (int i = 0; i < kNumChannels; ++i) {
+ _patternCtx[i].command = 0xFF;
+ _patternCtx[i].expose = 0;
+ }
+
+ for (int i = 0; i < kNumVoices; ++i) {
+ _channelCtx[i].sfxLocked = false;
+ stopChannel(_channelCtx[i]);
+ }
+
+ setTimerBaseValue(kPalCiaClock);
+ setInterruptFreqUnscaled(ciaIntervall);
+ startPaula();
+}
+
+}
diff --git a/sound/mods/tfmx.h b/sound/mods/tfmx.h
new file mode 100644
index 0000000000..fa132d5618
--- /dev/null
+++ b/sound/mods/tfmx.h
@@ -0,0 +1,233 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * 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.
+ *
+ * $URL$
+ * $Id$
+ *
+ */
+
+#ifndef SOUND_MODS_TFMX_H
+#define SOUND_MODS_TFMX_H
+
+#include "sound/mods/paula.h"
+
+namespace {
+#ifndef NDEBUG
+inline void boundaryCheck(const void *bufStart, size_t bufLen, const void *address, size_t accessLen = 1) {
+ assert(bufStart <= address && (const byte *)address + accessLen <= (const byte *)bufStart + bufLen);
+}
+#else
+inline void boundaryCheck(const void *, size_t, void *, size_t = 1) {}
+#endif
+}
+
+namespace Audio {
+
+class Tfmx : public Paula {
+public:
+ Tfmx(int rate, bool stereo);
+ virtual ~Tfmx();
+
+ void interrupt();
+ void doSong(int songPos);
+ void doMacro(int macro, int note);
+ bool load(Common::SeekableReadStream &musicData, Common::SeekableReadStream &sampleData);
+
+// Note: everythings public so the debug-Routines work.
+// private:
+ enum {kPalDefaultCiaVal = 11822, kNtscDefaultCiaVal = 14320, kCiaBaseInterval = 0x1B51F8};
+ enum {kNumVoices = 4, kNumChannels = 8, kNumSubsongs = 32, kMaxPatternOffsets = 128, kMaxMacroOffsets = 128};
+
+ static const uint16 noteIntervalls[64];
+
+ struct Resource {
+ uint32 _trackstepOffset; //!< Offset in mdat
+
+ byte *_mdatData; //!< Currently the whole mdat-File
+ byte *_sampleData; //!< Currently the whole sample-File
+
+ uint32 _mdatLen;
+ uint32 _sampleLen;
+
+ byte header[10];
+ uint16 headerFlags;
+ uint32 headerUnknown;
+ char textField[6 * 40];
+
+ const uint16 *getTrackPtr(uint16 trackstep = 0) {
+ uint16 *trackData = (uint16 *)(_mdatData + _trackstepOffset + 16 * trackstep);
+
+ boundaryCheck(_mdatData, _mdatLen, trackData, 16);
+ return trackData;
+ }
+
+ const uint32 *getPatternPtr(uint32 offset) {
+ uint32 *pattData = (uint32 *)(_mdatData + offset);
+
+ boundaryCheck(_mdatData, _mdatLen, pattData, 4);
+ return pattData;
+ }
+
+ const uint32 *getMacroPtr(uint32 offset) {
+ uint32 *macroData = (uint32 *)(_mdatData + offset);
+
+ boundaryCheck(_mdatData, _mdatLen, macroData, 4);
+ return macroData;
+ }
+
+ const int8 *getSamplePtr(const uint32 offset) {
+ int8 *sampleData = (int8 *)(_sampleData + offset);
+
+ boundaryCheck(_sampleData, _sampleLen, sampleData, 2);
+ return sampleData;
+ }
+ Resource() : _mdatData(), _mdatLen(), _sampleData(), _sampleLen() {}
+
+ ~Resource() {
+ delete[] _mdatData;
+ delete[] _sampleData;
+ }
+ } _resource;
+
+ uint32 _patternOffset[kMaxPatternOffsets]; //!< Offset in mdat
+ uint32 _macroOffset[kMaxMacroOffsets]; //!< Offset in mdat
+
+ struct Subsong {
+ uint16 songstart; //!< Index in Trackstep-Table
+ uint16 songend; //!< Last index in Trackstep-Table
+ uint16 tempo;
+ } _subsong[kNumSubsongs];
+
+ struct ChannelContext {
+ byte paulaChannel;
+
+ uint16 macroWait;
+ uint32 macroOffset;
+ uint32 macroReturnOffset;
+ uint16 macroStep;
+ uint32 macroReturnStep;
+ uint8 macroLoopCount;
+ bool macroRun;
+
+ bool sfxLocked;
+ int16 sfxLockTime;
+ bool keyUp;
+
+ bool deferWait;
+ bool countDmaInterrupts;
+ uint16 dmaCount;
+
+ uint32 sampleStart;
+ uint16 sampleLen;
+ uint16 period;
+
+ int8 volume;
+ uint8 relVol;
+ uint8 note;
+ uint8 prevNote;
+ uint16 fineTune;
+
+ uint16 portaDestPeriod;
+ uint16 portaPeriod;
+ uint8 portaReset;
+ uint8 portaTime;
+ int16 portaRate;
+
+ uint8 envReset;
+ uint8 envTime;
+ uint8 envRate;
+ uint8 envEndVolume;
+
+ int16 vibOffset;
+ int8 vibWidth;
+ uint8 vibFlag;
+ uint8 vibReset;
+ uint8 vibTime;
+
+ uint8 addBeginTime;
+ uint8 addBeginReset;
+ int32 addBegin;
+ } _channelCtx[kNumVoices];
+
+ struct PatternContext {
+ uint32 offset; // patternStart, Offset from mdat
+ uint32 savedOffset; // for subroutine calls
+ uint16 step; // distance from patternStart
+ uint16 savedStep;
+
+ uint8 command;
+ int8 expose;
+ uint8 loopCount;
+ uint8 wait; //!< how many ticks to wait before next Command
+ } _patternCtx[kNumChannels];
+
+ struct TrackStepContext {
+ uint16 startInd;
+ uint16 stopInd;
+ uint16 posInd;
+ int16 loopCount;
+ } _trackCtx;
+
+ struct PlayerContext {
+ bool enabled;
+// bool end;
+ int8 song; //!< >= 0 if Song is running (means process Patterns)
+
+ bool pendingTrackstep;
+
+ uint16 patternCount;
+ uint16 patternSkip; //!< skip that amount of CIA-Interrupts
+
+ int8 volume; //!< Master Volume
+
+/* int8 fadeDest;
+ int8 fadeTime;
+ int8 fadeReset;
+ int8 fadeSlope; */
+ } _playerCtx;
+
+ void initMacroProgramm(ChannelContext &channel) {
+ channel.macroStep = 0;
+ channel.macroWait = 0;
+ channel.macroRun = true;
+ channel.macroLoopCount = 0xFF;
+ channel.countDmaInterrupts = false;
+ }
+
+ void stopChannel(ChannelContext &channel) {
+ if (!channel.sfxLocked) {
+ channel.macroRun = false;
+ channel.countDmaInterrupts = false;
+ Paula::disableChannel(channel.paulaChannel);
+ }
+ }
+
+ void effects(ChannelContext &channel);
+ FORCEINLINE bool macroStep(ChannelContext &channel);
+ void advancePatterns();
+ FORCEINLINE bool patternStep(PatternContext &pattern);
+ bool trackStep();
+ void noteCommand(uint8 note, uint8 param1, uint8 param2, uint8 param3);
+
+};
+
+}
+
+#endif
diff --git a/sound/module.mk b/sound/module.mk
index dba9501a38..0c24e0cf0e 100644
--- a/sound/module.mk
+++ b/sound/module.mk
@@ -29,6 +29,7 @@ MODULE_OBJS := \
mods/paula.o \
mods/rjp1.o \
mods/soundfx.o \
+ mods/tfmx.o \
softsynth/adlib.o \
softsynth/opl/dosbox.o \
softsynth/opl/mame.o \
diff --git a/tfmx/module.mk b/tfmx/module.mk
new file mode 100644
index 0000000000..41d114bfb0
--- /dev/null
+++ b/tfmx/module.mk
@@ -0,0 +1,8 @@
+MODULE := tfmx
+
+MODULE_OBJS := \
+ tfmxplayer.o \
+ tfmxdebug.o
+
+# Include common rules
+include $(srcdir)/rules.mk
diff --git a/tfmx/tfmxdebug.cpp b/tfmx/tfmxdebug.cpp
new file mode 100644
index 0000000000..f6ef03dc08
--- /dev/null
+++ b/tfmx/tfmxdebug.cpp
@@ -0,0 +1,190 @@
+#include "common/scummsys.h"
+#include "common/endian.h"
+#include "common/debug.h"
+#include "common/stream.h"
+#include "common/util.h"
+
+#include "sound/mods/tfmx.h"
+
+#include "tfmx/tfmxdebug.h"
+
+
+const char *pattcmds[]={
+ "End --Next track step--",
+ "Loop[count / step.w]",
+ "Cont[patternno./ step.w]",
+ "Wait[count 00-FF--------",
+ "Stop--Stop this pattern-",
+ "Kup^-Set key up/channel]",
+ "Vibr[speed / rate.b]",
+ "Enve[speed /endvolume.b]",
+ "GsPt[patternno./ step.w]",
+ "RoPt-Return old pattern-",
+ "Fade[speed /endvolume.b]",
+ "PPat[patt./track+transp]",
+ "Lock---------ch./time.b]",
+ "----------No entry------",
+ "Stop-Stop custompattern-",
+ "NOP!-no operation-------"
+};
+
+const char *macrocmds[]={
+ "DMAoff+Resetxx/xx/xx flag/addset/vol ",
+ "DMAon (start sample at selected begin) ",
+ "SetBegin xxxxxx sample-startadress",
+ "SetLen ..xxxx sample-length ",
+ "Wait ..xxxx count (VBI''s) ",
+ "Loop xx/xxxx count/step ",
+ "Cont xx/xxxx macro-number/step ",
+ "-------------STOP----------------------",
+ "AddNote xx/xxxx note/detune ",
+ "SetNote xx/xxxx note/detune ",
+ "Reset Vibrato-Portamento-Envelope ",
+ "Portamento xx/../xx count/speed ",
+ "Vibrato xx/../xx speed/intensity ",
+ "AddVolume ....xx volume 00-3F ",
+ "SetVolume ....xx volume 00-3F ",
+ "Envelope xx/xx/xx speed/count/endvol",
+ "Loop key up xx/xxxx count/step ",
+ "AddBegin xx/xxxx count/add to start",
+ "AddLen ..xxxx add to sample-len ",
+ "DMAoff stop sample but no clear ",
+ "Wait key up ....xx count (VBI''s) ",
+ "Go submacro xx/xxxx macro-number/step ",
+ "--------Return to old macro------------",
+ "Setperiod ..xxxx DMA period ",
+ "Sampleloop ..xxxx relative adress ",
+ "-------Set one shot sample-------------",
+ "Wait on DMA ..xxxx count (Wavecycles)",
+ "Random play xx/xx/xx macro/speed/mode ",
+ "Splitkey xx/xxxx key/macrostep ",
+ "Splitvolume xx/xxxx volume/macrostep ",
+ "Addvol+note xx/fe/xx note/CONST./volume",
+ "SetPrevNote xx/xxxx note/detune ",
+ "Signal xx/xxxx signalnumber/value",
+ "Play macro xx/.x/xx macro/chan/detune ",
+ "SID setbeg xxxxxx sample-startadress",
+ "SID setlen xx/xxxx buflen/sourcelen ",
+ "SID op3 ofs xxxxxx offset ",
+ "SID op3 frq xx/xxxx speed/amplitude ",
+ "SID op2 ofs xxxxxx offset ",
+ "SID op2 frq xx/xxxx speed/amplitude ",
+ "SID op1 xx/xx/xx speed/amplitude/TC",
+ "SID stop xx.... flag (1=clear all)"
+};
+
+const char *const trackstepFmt[] = {
+ "---Stop Player----",
+ "Loop step/count ",
+ "Tempo tempo/ciaDiv",
+ "Timeshare ?/? ",
+ "Fade start/end "
+ "Unknown (cc) "
+};
+
+void displayPatternstep(const void *const vptr) {
+ const byte *const patData = (const byte *const)vptr;
+
+ const byte command = patData[0];
+
+ if (command < 0xF0) { // Playnote
+ const byte flags = command >> 6; // 0-1 means note+detune, 2 means wait, 3 means portamento?
+ char *flagsSt[] = {"Note ", "Note ", "Wait ", "Porta"};
+ debug("%s %02X%02X%02X%02X", flagsSt[flags], patData[0], patData[1], patData[2], patData[3]);
+ } else {
+ debug("%s %02X%02X%02X",pattcmds[command&0xF], patData[1], patData[2], patData[3]);
+ }
+
+}
+
+void displayTrackstep(const void *const vptr) {
+ const uint16 *const trackData = (const uint16 *const)vptr;
+
+ if (trackData[0] == FROM_BE_16(0xEFFE)) {
+ // 16 byte Trackstep Command
+ const uint16 command = READ_BE_UINT16(&trackData[1]);
+ const uint16 param1 = READ_BE_UINT16(&trackData[2]);
+ const uint16 param2 = READ_BE_UINT16(&trackData[3]);
+
+
+ if (command >= ARRAYSIZE(trackstepFmt))
+ debug("Unknown (%04X) : %04X %04X", command, param1, param2);
+ else
+ debug("%s: %04X %04X", trackstepFmt[command], param1, param2);
+ } else {
+ const byte *const ptr = (const byte *const)vptr;
+ // 8 commands for Patterns
+ debug("%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X-%02X%02X",
+ ptr[0], ptr[1], ptr[2], ptr[3], ptr[4], ptr[5], ptr[6], ptr[7],
+ ptr[8], ptr[9], ptr[10], ptr[11], ptr[12], ptr[13], ptr[14], ptr[15]);
+ }
+}
+
+void displayMacroStep(const void *const vptr) {
+ const byte *const macroData = (const byte *const)vptr;
+
+ if (macroData[0] < ARRAYSIZE(macrocmds))
+ debug("%s %02X%02X%02X", macrocmds[macroData[0]], macroData[1], macroData[2], macroData[3]);
+ else
+ debug("Unkown Macro #%02X %02X%02X%02X", macroData[0], macroData[1], macroData[2], macroData[3]);
+}
+
+void dumpTracksteps(Audio::Tfmx &player, uint16 first, uint16 last) {
+ for ( ; first <= last; ++first) {
+ displayTrackstep(player._resource.getTrackPtr(first));
+ }
+}
+
+void dumpTrackstepsBySong(Audio::Tfmx &player, int song) {
+ dumpTracksteps(player, player._subsong[song].songstart, player._subsong[song].songend);
+}
+
+void dumpMacro(Audio::Tfmx &player, uint16 macroIndex, uint16 len, uint16 start) {
+ const uint32 * macroPtr = player._resource.getMacroPtr(player._macroOffset[macroIndex]);
+ bool untilMacroStop = (len == 0);
+ while (len--) {
+ displayMacroStep(macroPtr++);
+ }
+ while (untilMacroStop) {
+ untilMacroStop = *(const byte *)macroPtr != 7;
+ displayMacroStep(macroPtr++);
+ }
+}
+
+void dumpPattern(Audio::Tfmx &player, uint16 pattIndex, uint16 len, uint16 start) {
+ const uint32 * pattPtr = player._resource.getPatternPtr(player._patternOffset[pattIndex]);
+ if (len == 0)
+ len = (player._patternOffset[pattIndex+1] - player._patternOffset[pattIndex])/4;
+ bool untilMacroStop = (len == 0);
+ while (len--) {
+ displayPatternstep(pattPtr++);
+ }
+ while (untilMacroStop) {
+ byte cmd = *(const byte *)pattPtr;
+ untilMacroStop = cmd != 0 && cmd != 4;
+ displayPatternstep(pattPtr++);
+ }
+}
+
+void countAllMacros1(Audio::Tfmx &player, uint16 macroIndex, int *list) {
+ const uint32 * macroPtr = player._resource.getMacroPtr(player._macroOffset[macroIndex]);
+ bool untilMacroStop = true;
+ while (untilMacroStop) {
+ const int type = *(const byte *)macroPtr++;
+ untilMacroStop = type != 7;
+ list[type]++;
+ }
+}
+
+void countAllMacros(Audio::Tfmx &player) {
+ int list[256] = {0};
+ for (int i = 0; i < 128; ++i)
+ countAllMacros1(player, i, list);
+ byte fakeMacro[4] = {0};
+ for (int i = 0; i < 256; ++i) {
+ fakeMacro[0] = (byte)i;
+ if (list[i] > 0)
+ displayMacroStep(fakeMacro);
+ }
+
+}
diff --git a/tfmx/tfmxdebug.h b/tfmx/tfmxdebug.h
new file mode 100644
index 0000000000..dba283b673
--- /dev/null
+++ b/tfmx/tfmxdebug.h
@@ -0,0 +1,13 @@
+#ifndef TFMXDEBUG_H
+#define TFMXDEBUG_H
+
+void displayTrackstep(const void *const vptr);
+void displayPatternstep(const void *const vptr);
+void displayMacroStep(const void *const vptr);
+void dumpTracksteps(Audio::Tfmx &player, uint16 first, uint16 last);
+void dumpTrackstepsBySong(Audio::Tfmx &player, int song);
+void dumpMacro(Audio::Tfmx &player, uint16 macroIndex, uint16 len = 0, uint16 start = 0);
+void dumpPattern(Audio::Tfmx &player, uint16 pattIndex, uint16 len = 0, uint16 start = 0);
+void countAllMacros(Audio::Tfmx &player);
+
+#endif // TFMXDEBUG_H
\ No newline at end of file
diff --git a/tfmx/tfmxplayer.cpp b/tfmx/tfmxplayer.cpp
new file mode 100644
index 0000000000..dce7d6180c
--- /dev/null
+++ b/tfmx/tfmxplayer.cpp
@@ -0,0 +1,201 @@
+#include "common/scummsys.h"
+#include "common/system.h"
+#include "common/stream.h"
+#include "common/file.h"
+#include "common/fs.h"
+#include "common/endian.h"
+#include "common/debug.h"
+
+#include "sound/mixer.h"
+#include "sound/mods/protracker.h"
+#include "sound/mods/tfmx.h"
+
+#include "tfmx/tfmxdebug.h"
+
+#define FILEDIR ""
+
+using namespace Common;
+
+void simplePlaybacktest(int argc, const char *const argv[]) {
+ const char *modFilename = "mod.protracker";
+ if (argc == 2)
+ modFilename = argv[1];
+
+
+ // get Mixer, assume this never fails
+ Audio::Mixer *mixer = g_system->getMixer();
+
+ FSNode fileDir(FILEDIR);
+ debug( "searching for Files in Directory: %s", fileDir.getPath().c_str());
+
+ FSNode musicFile = fileDir.getChild(modFilename);
+
+ SeekableReadStream *fileIn = musicFile.createReadStream();
+ if (0 == fileIn) {
+ debug( "cant open File %s", musicFile.getName().c_str());
+ return;
+ }
+
+ Audio::AudioStream *stream = Audio::makeProtrackerStream(fileIn);
+ delete fileIn;
+ if (0 == stream) {
+ debug( "cant open File %s as Protacker-Stream", musicFile.getName().c_str());
+ return;
+ }
+
+ Audio::SoundHandle soundH;
+
+ mixer->playInputStream(Audio::Mixer::kMusicSoundType, &soundH, stream);
+ while (mixer->isSoundHandleActive(soundH))
+ g_system->delayMillis(1000);
+
+
+ //mixer->stopAll();
+}
+
+#define MUSICFILE "mdat.monkey"
+#define SAMPLEFILE "smpl.monkey"
+
+//#define MUSICFILE "mdat.tworld_1"
+//#define SAMPLEFILE "smpl.tworld_1"
+Audio::Tfmx *loadTfmxfile(const char *mdatName, const char *sampleName) {
+ FSNode fileDir(FILEDIR);
+ FSNode musicNode = fileDir.getChild(mdatName);
+ FSNode sampleNode = fileDir.getChild(sampleName);
+ SeekableReadStream *musicIn = musicNode.createReadStream();
+ if (0 == musicIn) {
+ debug("Couldnt load file %s", MUSICFILE);
+ return 0;
+ }
+
+ SeekableReadStream *sampleIn = sampleNode.createReadStream();
+ if (0 == sampleIn) {
+ debug("Couldnt load file %s", SAMPLEFILE);
+ delete musicIn;
+ return 0;
+ }
+
+ Audio::Tfmx *player = new Audio::Tfmx(44100, true);
+ player->load(*musicIn, *sampleIn);
+ delete musicIn;
+ delete sampleIn;
+
+ return player;
+}
+
+void runFlac(int chan, int bits, int sr, const char *fileName);
+
+void tfmxmain(const int argc, const char *const argv[]) {
+ debug("Started Scumm&VM");
+ debug("Sound celebrating utility for monkey melodies & Various Malfunctions");
+ debug("");
+
+ //simplePlaybacktest(argc, argv);
+
+ Audio::Tfmx *player = loadTfmxfile(MUSICFILE, SAMPLEFILE);
+ if (!player) {
+ debug("couldnt create TFMX-Player");
+ return;
+ }
+
+ int i = 1;
+ int playflag = 0;
+
+
+ if (i < argc && argv[i][0] == '-' && strlen(argv[i]) == 2) {
+ int param;
+ switch (argv[i++][1]) {
+ case 'm':
+ if (i < argc) {
+ param = atoi(argv[i]);
+ debug( "play Macro %02X", param);
+ dumpMacro(*player, 0x11);
+ playflag = 1;
+ player->doMacro(param,0x40);
+ ++i;
+ }
+ break;
+ case 's':
+ if (i < argc) {
+ param = atoi(argv[i]);
+ debug( "play Song %02X", param);
+ dumpTrackstepsBySong(*player, param);
+ playflag = 1;
+ player->doSong(param);
+ ++i;
+ }
+ }
+ }
+
+ if (!playflag) {
+ playflag = 1;
+ //player->doMacro(20,0x40);
+ player->doSong(4);
+ dumpTrackstepsBySong(*player, 4);
+ }
+
+
+
+
+#if 0
+ int16 buf[2 * 1024];
+
+ while( true)
+ player->readBuffer(buf, ARRAYSIZE(buf));
+#endif
+ int maxsecs = 60;
+ if (playflag == 1) {
+ // get Mixer, assume this never fails
+ Audio::Mixer *mixer = g_system->getMixer();
+
+ Audio::SoundHandle soundH;
+
+ mixer->playInputStream(Audio::Mixer::kMusicSoundType, &soundH, player);
+ while (mixer->isSoundHandleActive(soundH) && --maxsecs)
+ g_system->delayMillis(1000);
+// player->AllOff();
+
+// while (mixer->isSoundHandleActive(soundH));
+
+ mixer->stopHandle(soundH);
+ player = 0;
+ }
+
+ if (playflag == 2) {
+ Common::FSNode file("out.raw");
+ WriteStream *wav = file.createWriteStream();
+ int16 buf[2 * 1024];
+ int32 maxsamples = (maxsecs <= 0) ? 0 : maxsecs * 44100;
+ while (!player->endOfData() && maxsamples > 0) {
+ int read = player->readBuffer(buf, ARRAYSIZE(buf));
+ wav->write(buf, read * 2);
+ maxsamples -= read/2;
+ }
+ delete wav;
+
+ runFlac(2, 16, 44100, "out.raw");
+ }
+
+#ifdef _MSC_VER
+ printf("\npress a key");
+ getc(stdin);
+#endif
+
+ delete player;
+}
+
+void runFlac( int chan, int bits, int sr, const char *fileName) {
+ const char *format = "flac --endian="
+#ifdef SCUMM_BIG_ENDIAN
+ "big"
+#else
+ "little"
+#endif
+ " --channels=%d -f --bps=%d --sample-rate=%d --sign=signed --force-raw-format %s";
+ char cmd[1024];
+ sprintf(cmd, format, chan, bits, sr, fileName);
+ debug(cmd);
+ system(cmd);
+}
+
+
--
cgit v1.2.3