ref: 62bbc39e91d7f624ecf806d8b1b462c28ba206d5
dir: /src/modloaders/ft2_load_stm.c/
/* Scream Tracker 2 STM loader
**
** Note: Data sanitation is done in the last stage
** of module loading, so you don't need to do that here.
*/
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include "../ft2_header.h"
#include "../ft2_module_loader.h"
#include "../ft2_sample_ed.h"
#include "../ft2_tables.h"
#include "../ft2_sysreqs.h"
#if defined(_MSC_VER) || defined(__plan9__) // please don't mess with these structs!
#pragma pack on
#pragma pack on
#endif
typedef struct stmSmpHdr_t
{
char name[12];
uint8_t nul, junk1;
uint16_t junk2, length, loopStart, loopEnd;
uint8_t volume, junk3;
uint16_t midCFreq;
int32_t junk4;
uint16_t paraLen;
}
#ifdef __GNUC__
__attribute__ ((packed))
#endif
stmSmpHdr_t;
typedef struct stmHdr_t
{
char name[20], sig[8];
uint8_t x1A, type;
uint8_t verMajor, verMinor;
uint8_t tempo, numPatterns, volume, reserved[13];
stmSmpHdr_t smp[31];
uint8_t orders[128];
}
#ifdef __GNUC__
__attribute__ ((packed))
#endif
stmHdr_t;
#if defined(_MSC_VER) || defined(__plan9__)
#pragma pack off
#endif
static const uint8_t stmEfx[16] = { 0, 0, 11, 0, 10, 2, 1, 3, 4, 7, 0, 5, 6, 0, 0, 0 };
static uint8_t pattBuff[64*4*4];
static uint16_t stmTempoToBPM(uint8_t tempo);
bool loadSTM(FILE *f, uint32_t filesize)
{
int16_t i, j, k;
stmHdr_t hdr;
tmpLinearPeriodsFlag = false; // use Amiga periods
if (filesize < sizeof (hdr))
{
loaderMsgBox("Error: This file is either not a module, or is not supported.");
return false;
}
if (fread(&hdr, 1, sizeof (hdr), f) != sizeof (hdr))
{
loaderMsgBox("Error: This file is either not a module, or is not supported.");
return false;
}
if (hdr.verMinor == 0 || hdr.type != 2)
{
loaderMsgBox("Error loading STM: Incompatible module!");
return false;
}
songTmp.numChannels = 4;
memcpy(songTmp.orders, hdr.orders, 128);
i = 0;
while (i < 128 && songTmp.orders[i] < 99)
i++;
songTmp.songLength = i + (i == 0);
if (songTmp.songLength < 255)
memset(&songTmp.orders[songTmp.songLength], 0, 256 - songTmp.songLength);
memcpy(songTmp.name, hdr.name, 20);
uint8_t tempo = hdr.tempo;
if (hdr.verMinor < 21)
tempo = ((tempo / 10) << 4) + (tempo % 10);
if (tempo == 0)
tempo = 96;
songTmp.BPM = stmTempoToBPM(tempo);
songTmp.speed = hdr.tempo >> 4;
for (i = 0; i < hdr.numPatterns; i++)
{
if (!allocateTmpPatt(i, 64))
{
loaderMsgBox("Not enough memory!");
return false;
}
if (fread(pattBuff, 64 * 4 * 4, 1, f) != 1)
{
loaderMsgBox("General I/O error during loading!");
return false;
}
uint8_t *pattPtr = pattBuff;
for (j = 0; j < 64; j++)
{
for (k = 0; k < 4; k++, pattPtr += 4)
{
note_t *p = &patternTmp[i][(j * MAX_CHANNELS) + k];
if (pattPtr[0] == 254)
{
p->note = NOTE_OFF;
}
else if (pattPtr[0] < 96)
{
p->note = (12 * (pattPtr[0] >> 4)) + (25 + (pattPtr[0] & 0x0F));
if (p->note > 96)
p->note = 0;
}
else
{
p->note = 0;
}
p->instr = pattPtr[1] >> 3;
uint8_t vol = (pattPtr[1] & 7) + ((pattPtr[2] & 0xF0) >> 1);
if (vol <= 64)
p->vol = 0x10 + vol;
p->efxData = pattPtr[3];
uint8_t efx = pattPtr[2] & 0x0F;
if (efx == 1)
{
p->efx = 15;
if (hdr.verMinor < 21)
p->efxData = ((p->efxData / 10) << 4) + (p->efxData % 10);
p->efxData >>= 4;
}
else if (efx == 3)
{
p->efx = 13;
p->efxData = 0;
}
else if (efx == 2 || (efx >= 4 && efx <= 12))
{
p->efx = stmEfx[efx];
if (p->efx == 0xA)
{
if (p->efxData & 0x0F)
p->efxData &= 0x0F;
else
p->efxData &= 0xF0;
}
}
else
{
p->efxData = 0;
}
}
}
if (tmpPatternEmpty(i))
{
if (patternTmp[i] != NULL)
{
free(patternTmp[i]);
patternTmp[i] = NULL;
}
}
}
for (i = 0; i < 31; i++)
{
memcpy(&songTmp.instrName[1+i], hdr.smp[i].name, 12);
if (hdr.smp[i].length > 0)
{
allocateTmpInstr(1 + i);
setNoEnvelope(instrTmp[i]);
sample_t *s = &instrTmp[1+i]->smp[0];
if (!allocateSmpData(s, hdr.smp[i].length, false))
{
loaderMsgBox("Not enough memory!");
return false;
}
s->length = hdr.smp[i].length;
s->volume = hdr.smp[i].volume;
s->loopStart = hdr.smp[i].loopStart;
s->loopLength = hdr.smp[i].loopEnd - hdr.smp[i].loopStart;
memcpy(s->name, hdr.smp[i].name, 12);
tuneSample(s, hdr.smp[i].midCFreq, tmpLinearPeriodsFlag);
if (s->loopStart < s->length && hdr.smp[i].loopEnd > s->loopStart && hdr.smp[i].loopEnd != 0xFFFF)
{
if (s->loopStart+s->loopLength > s->length)
s->loopLength = s->length - s->loopStart;
s->flags |= LOOP_FWD; // enable loop
}
else
{
s->loopStart = 0;
s->loopLength = 0;
}
if (fread(s->dataPtr, s->length, 1, f) != 1)
{
loaderMsgBox("General I/O error during loading! Possibly corrupt module?");
return false;
}
}
}
return true;
}
static uint16_t stmTempoToBPM(uint8_t tempo) // ported from original ST2.3 replayer code
{
const uint8_t slowdowns[16] = { 140, 50, 25, 15, 10, 7, 6, 4, 3, 3, 2, 2, 2, 2, 1, 1 };
uint16_t hz = 50;
hz -= ((slowdowns[tempo >> 4] * (tempo & 15)) >> 4); // can and will underflow
const uint16_t bpm = (hz << 1) + (hz >> 1); // BPM = hz * 2.5
return bpm; // result can be slightly off, but close enough...
}