/* loads3m.c
*
* Generic Module Player Screamtracker 3 Module loader
*
* $Id: loads3m.c,v 1.15 1997/01/25 15:23:16 pekangas Exp $
*
* Copyright 1996,1997 Housemarque Inc.
*
* This file is part of the MIDAS Sound System, and may only be
* used, modified and distributed under the terms of the MIDAS
* Sound System license, LICENSE.TXT. By continuing to use,
* modify or distribute this file you indicate that you have
* read the license and understand and accept it fully.
*/
#include "lang.h"
#include "mtypes.h"
#include "errors.h"
#include "mglobals.h"
#include "mmem.h"
#include "file.h"
#include "sdevice.h"
#include "gmplayer.h"
#ifndef NOEMS
#include "ems.h"
#endif
#include "mutils.h"
/*#define CHECK_THE_HEAP*/
#ifdef CHECK_THE_HEAP
#include <malloc.h>
#endif
RCSID(const char *loads3m_rcsid = "$Id: loads3m.c,v 1.15 1997/01/25 15:23:16 pekangas Exp $";)
/* Pass error code in variable "error" on, used in gmpLoadS3M(). */
#define PASSERR() { LoadError(); PASSERROR(ID_gmpLoadS3M) }
/****************************************************************************\
*
* Function: TestHeap(void)
*
* Description: Test if the heap is corrupted. Watcom C ONLY! Implemented here
* because the Watcom _heapchk() often reports the heap is OK
* even though it isn't.
*
* Returns: MIDAS error code
*
\****************************************************************************/
#if defined(CHECKTHEHEAP) && defined(__WC32__)
/* Maximum valid block in heap: */
#define MAXBLK (2048*1024)
int TestHeap(void)
{
static struct _heapinfo hinfo;
int hstatus;
unsigned len;
hinfo._pentry = NULL;
while ( 1 )
{
hstatus = _heapwalk(&hinfo);
if ( hstatus != _HEAPOK )
break;
len = hinfo._size;
if ( (len == 0) || (len > MAXBLK) || (len & 3) )
return errHeapCorrupted;
}
if ( (hstatus == _HEAPEND) || (hstatus == _HEAPEMPTY) )
return OK;
return errHeapCorrupted;
}
#define CHECKHEAP \
{ \
if ( TestHeap() != OK ) \
{ \
puts("HEAP CORRUPTED!"); \
ERROR(errHeapCorrupted, ID_gmpLoadXM); \
LoadError(); \
return errHeapCorrupted; \
} \
}
#else
#define CHECKHEAP
#endif
/****************************************************************************\
* struct s3mHeader
* ----------------
* Description: Scream Tracker 3 module file header
\****************************************************************************/
typedef struct
{
char name[28]; /* song name */
U8 num1A; /* 0x1A */
U8 type; /* file type */
U16 unused1;
U16 songLength; /* number of orders */
U16 numInsts; /* number of instruments */
U16 numPatts; /* number of patterns */
U16 flags;
/*
struct
{
int st2Vibrato : 1;
int st2Tempo : 1;
int ptSlides : 1;
int zeroVolOpt : 1;
int ptLimits : 1;
int filter : 1;
int fastVolSlide : 1;
int unused : 9;
} flags;
*/
U16 trackerVer; /* tracker version */
U16 formatVer; /* file format version */
char SCRM[4]; /* "SCRM" */
U8 masterVol; /* master volume */
U8 speed; /* initial speed */
U8 tempo; /* initial tempo */
U8 masterMult; /* master multiplier (bits 0-3),stereo (bit 4) */
U8 ultraClicks; /* Ultraclick removal info */
U8 panningMagic; /* 0FCh if panning infos exist */
U8 unused2[8];
U16 special; /* pointer to special custom data */
U8 chanSettings[32]; /* channel settings */
} s3mHeader;
/****************************************************************************\
* struct s3mPattern
* ----------------
* Description: Screamtracker 3 Module pattern
\****************************************************************************/
typedef struct
{
U16 pattDataSize; /* pattern data size */
U8 data[EMPTYARRAY]; /* packed pattern data */
} s3mPattern;
/****************************************************************************\
* struct s3mInstHdr
* -----------------
* Description: Scream Tracker 3 module instrument file header
\****************************************************************************/
typedef struct
{
U8 type; /* instrument type */
char dosName[12]; /* DOS filename (8+3) */
char zero; /* 0 */
U16 samplePtr; /* paragraph ptr to sample data */
U32 length; /* sample length */
U32 loopStart; /* sample loop start */
U32 loopEnd; /* sample loop end */
U8 volume; /* volume */
U8 disk; /* instrument disk number */
U8 pack; /* sample packing info (0 = raw,1 = DP30ADPCM1) */
U8 flags; /* bit0 = loop, bit1 = stereo,bit2 = 16-bit */
U32 c2Rate; /* C2 sampling rate */
U32 unused;
U16 gusPos; /* position in GUS memory / 32 */
U16 int512;
U32 intLastUsed;
char iname[28]; /* instrument name */
char SCRS[4]; /* "SCRS" if sample */
} s3mInstHdr;
/* Conversion table from Screamtracker command number to GMP ones: */
static uchar s3mCommands[26] =
{
gmpcSetSpeed, /* A - Set speed */
gmpcPositionJump, /* B - Position jump */
gmpcPatternBreak, /* C - Pattern break */
gmpcVolumeSlide, /* D - Volume slide */
gmpcSlideDown, /* E - Slide down */
gmpcSlideUp, /* F - Slide up */
gmpcTonePortamento, /* G - Tone portamento */
gmpcVibrato, /* H - Vibrato */
gmpcNone, /* I - Tremor */
gmpcArpeggio, /* J - Arpeggio */
gmpcVibVSlide, /* K - Vibrato + volume slide */
gmpcTPortVSlide, /* L - Tone portamento + volume slide */
gmpcNone, /* M - Unused */
gmpcNone, /* N - Unused */
gmpcSampleOffset, /* O - Set sample offset */
gmpcNone, /* P - Unused */
gmpcS3MRetrig, /* Q - ST3 extended retrig */
gmpcTremolo, /* R - Tremolo */
gmpcNone, /* S - S-commands (table below) */
gmpcSetTempo, /* T - Set tempo */
gmpcNone, /* U - Fine vibrato */
gmpcSetMVolume, /* V - Set master volume */
gmpcMusicSync, /* W - Music synchronization (extension) */
gmpcSetPanning, /* X - Set panning (extension) */
gmpcNone, /* Y - Unused */
gmpcSetPanning16 /* Z - Set panning (extension) */
};
/* Conversion table from Screamtracker S-command numbers to GMP commands: */
static uchar s3mSCommands[16] =
{
gmpcNone, /* S0 - Set filter */
gmpcNone, /* S1 - Set glissando control */
gmpcNone, /* S2 - Set finetune */
gmpcNone, /* S3 - Set vibrato waveform */
gmpcNone, /* S4 - Set tremolo waveform */
gmpcNone, /* S5 - Unused */
gmpcNone, /* S6 - Unused */
gmpcNone, /* S7 - Unused */
gmpcSetPanning16, /* S8 - Set panning */
gmpcNone, /* S9 - Unused */
gmpcNone, /* SA - Stereo control (obsolete) */
gmpcPatternLoop, /* SB - Pattern loop */
gmpcNoteCut, /* SC - Note cut */
gmpcNoteDelay, /* SD - Note delay */
gmpcPatternDelay, /* SE - Pattern delay */
gmpcNone /* SF - Invert loop (unused in ST3) */
};
/****************************************************************************\
* Module loader buffers and file handle. These variables are static
* instead of local so that a separate deallocation can be used which
* will be called before exiting in error situations
\****************************************************************************/
static fileHandle f; /* file handle for module file */
static int fileOpened; /* 1 if module file has been opened */
static gmpModule *module; /* pointer to GMP module structure */
static s3mHeader *header; /* pointer to S3M module header */
static uchar *instUsed; /* instrument used flags */
static s3mPattern *s3mPatt; /* pointer to S3M pattern data */
static gmpPattern *convPatt; /* pointer to converted pattern data*/
static U16 *instPtrs; /* instrument paragraph pointers */
static U16 *pattPtrs; /* pattern paragraph pointers */
static uchar *smpBuf; /* sample loading buffer */
static unsigned numChans; /* number of channels in module */
static unsigned maxChan; /* maximum enabled channel */
static unsigned maxInstUsed; /* maximum instrument used */
static s3mInstHdr s3mi;
/****************************************************************************\
*
* Function: int ConvertPattern(s3mPattern *srcPatt, gmpPattern *destPatt,
* unsigned *convLen);
*
* Description: Converts a pattern from S3M to GMP internal format.
* Also updates instUsed flags.
*
* Input: s3mPattern *srcPatt pointer to pattern in S3M format
* gmpPattern *destPatt pointer to destination GMP pattern
* unsigned *convLen pointer to converted pattern length
*
* Returns: MIDAS error code. Converted pattern length (in bytes,
* including header) is written to *convLen.
*
\****************************************************************************/
static int ConvertPattern(s3mPattern *srcPatt, gmpPattern *destPatt,
unsigned *convLen)
{
uchar *src = &srcPatt->data[0];
uchar *dest = &destPatt->data[0];
int row;
unsigned len;
U8 note, inst, command, infobyte, vol, compInfo;
U8 s3mComp;
/*
Packed data consits of following entries:
BYTE:what 0=end of row
&31=channel
&32=follows; BYTE:note, BYTE:instrument
&64=follows; BYTE:volume
&128=follows; BYTE:command, BYTE:info
*/
/* Check if the pattern is empty: */
if ( (srcPatt->pattDataSize == 0) || (srcPatt == NULL) )
{
/* Write row end marker for each row: */
for ( row = 0; row < 64; row++ )
*(dest++) = 0;
/* Write number of rows to pattern header: */
destPatt->rows = 64;
/* Write converted pattern length to header and return it in
*convLen: */
*convLen = destPatt->length = 64 + sizeof(gmpPattern);
return OK;
}
for ( row = 0; row < 64; row++ )
{
while ( *src != 0 )
{
/* No data for this channel yet: */
compInfo = 0;
note = 0xFF;
inst = 0xFF;
command = 0;
infobyte = 0;
vol = 0;
/* Get note number/compression info from pattern data: */
s3mComp = *src++;
/* Check if there is a new note and instrument: */
if ( s3mComp & 32 )
{
/* Check that the note is not key off and convert it to GMP
internal format: */
if ( ( *src < 0x7f ) || ( *src == 0xfe ) || ( *src == 0xff ) )
note = *src;
src++;
/* Get the instrument number: */
if ( *src <= module->numInsts )
inst = (*src) - 1;
src++;
/* Check if the instrument number if above maximum instrument
number used: */
if ( inst <= 100 )
{
if ( inst < module->numInsts )
{
if ( inst > maxInstUsed )
maxInstUsed = inst;
/* Mark instrument used: */
instUsed[inst] = 1;
}
}
/* Mark that there is a new note and/or instrument: */
compInfo |= 32;
if ( numChans <= (unsigned) (s3mComp & 31) )
numChans = (s3mComp & 31) + 1;
}
/* Check if there is a volume column byte: */
if ( s3mComp & 64 )
{
/* Get the volume column byte: */
vol = *(src++);
if ( vol > 63 ) vol = 63;
/* Mark that there is a volume column byte: */
compInfo |= 64;
}
/* Check if there is a command: */
if ( s3mComp & 128 )
{
/* Get the command number: */
command = *(src++);
/* Get the infobyte: */
infobyte = *(src++);
}
/* If there is a command or an infobyte we need to write the
command to the destination pattern: */
if ( (command > 0) && (command < 26 ) )
{
switch ( command )
{
case 19:
/* Command S - check actual command number: */
command = s3mSCommands[infobyte >> 4];
infobyte = infobyte & 0x0F;
break;
default:
/* Convert command to GMP command number: */
command = s3mCommands[command - 1];
break;
}
/* Mark that there is a command: */
if ( command != gmpcNone )
compInfo |= 128;
}
/* If the compression information is nonzero, there is some
data for this channel: */
if ( ( compInfo & 0xE0 ) != 0 )
{
/* Set channel number to lower 5 bits of the compression info
and write it to destination: */
compInfo |= ( s3mComp & 31 );
if ( (unsigned) (s3mComp & 31) <= maxChan )
{
*(dest++) = compInfo;
/* Check if there a note+instrument pair: */
if ( compInfo & 32 )
{
/* Write note and instrument numbers: */
*(dest++) = note;
*(dest++) = inst;
}
/* Check if there is a volume column byte: */
if ( compInfo & 64 )
{
/* Write the volume column byte: */
*(dest++) = vol;
}
/* Check if there is a command: */
if ( compInfo & 128 )
{
/* Write command and command infobyte: */
*(dest++) = command;
*(dest++) = infobyte;
}
}
}
}
/* Write row end marker: */
*(dest++) = 0;
src++;
}
/* Write number of rows to pattern header: */
destPatt->rows = 64;
/* Calculate converted pattern length: */
len = (unsigned) (dest - ((uchar*) destPatt));
/* Write converted pattern length to header and return it in *convLen: */
destPatt->length = len;
*convLen = len;
return OK;
}
/****************************************************************************\
*
* Function: void LoadError(void)
*
* Description: Stops loading the module, deallocates all buffers and closes
* the file.
*
\****************************************************************************/
#define condFree(x) { if ( x != NULL ) if ( memFree(x) != OK) return; }
static void LoadError(void)
{
/* Close file if opened. Do not process errors. */
if ( fileOpened )
if ( fileClose(f) != OK )
return;
/* Attempt to deallocate module if allocated. Do not process errors. */
if ( module != NULL )
if ( gmpFreeModule(module) != OK )
return;
/* Deallocate structures if allocated: */
condFree(header)
condFree(instUsed)
condFree(smpBuf)
}
/****************************************************************************\
*
* Function: int gmpLoadS3M(char *fileName, int addSD, mpModule **module)
*
* Description: Loads a Scream Tracker 3 module to memory in Generic Module
* Player module format
*
* Input: char *fileName module file name
* int addSD 1 if module samples should be added to
* the current Sound Device, 0 if not
* int (*SampleCallback)(...) pointer to callback function that
* will be called after sample has been
* added to Sound Device, but before
* sample data is deallocated
* mpModule **module pointer to GMP module pointer
*
* Returns: MIDAS error code
*
\****************************************************************************/
int CALLING gmpLoadS3M(char *fileName, int addSD, int
(CALLING *SampleCallback)(sdSample *sdsmp, gmpSample *gmpsmp),
gmpModule **_module)
{
int error; /* MIDAS error code */
gmpInstrument *inst;
uchar *panningInfos;
unsigned i;
ulong maxSample;
static unsigned convPattLen;
unsigned slength;
gmpSample *sample;
uchar *temp;
static sdSample sdSmp;
int n;
#ifndef NOEMS
uchar *patt;
#endif
int panValue;
unsigned numS3MPatterns;
unsigned numUsedPatterns;
/* point buffers to NULL and set fileOpened to 0 so that LoadError()
can be called at any point: */
fileOpened = 0;
module = NULL;
header = NULL;
instUsed = NULL;
s3mPatt = NULL;
convPatt = NULL;
instPtrs = NULL;
pattPtrs = NULL;
smpBuf = NULL;
/* Clear other loader variables: */
maxInstUsed = 0;
/* Allocate memory for Screamtracker module header: */
if ( (error = memAlloc(sizeof(s3mHeader), (void**) &header)) != OK )
PASSERR()
/* Open module file: */
if ( (error = fileOpen(fileName, fileOpenRead, &f)) != OK )
PASSERR()
fileOpened = 1;
/* Allocate memory for the module structure: */
if ( (error = memAlloc(sizeof(gmpModule), (void**) &module)) != OK )
PASSERR()
/* Clear module structure so that it can safely be deallocated with
gmpFreeModule() at any point: */
module->panning = NULL;
module->songData = NULL;
module->instruments = NULL;
module->patterns = NULL;
/* read Screamtracker module header: */
if ( (error = fileRead(f, header, sizeof(s3mHeader))) != OK )
PASSERR()
numChans = 0;
/* Check the module signature: */
if ( !(mMemEqual(&header->SCRM[0], "SCRM", 4) ) )
{
ERROR(errInvalidModule, ID_gmpLoadS3M);
LoadError();
return errInvalidModule;
}
/* Copy song name: */
mMemCopy(&module->name[0], &header->name[0], 28);
module->name[28] = 0; /* force terminating '\0' */
module->songLength = header->songLength; /* copy song length */
module->numInsts = header->numInsts; /* set number of instruments */
numS3MPatterns = header->numPatts; /* store number of patterns */
module->numPatts = 0; /* not really known yet! */
module->playMode = gmpST3; /* set ST3 playing mode */
module->masterVolume = header->masterVol; /* copy master volume */
module->speed = header->speed; /* initial speed */
module->tempo = header->tempo; /* initial tempo */
/* Copy some flags */
module->playFlags.ptLimits = ( header->flags & 0x10 ) >> 4;
module->playFlags.fastVolSlides = ( header->flags & 0x40 ) >> 6;
if ( header->trackerVer < 0x1320 )
module->playFlags.fastVolSlides = 1;
module->restart = 0;
#ifdef DEBUGMESSAGES
puts("Header ready");
#endif
CHECKHEAP
/* Allocate memory for song data: */
if ( (error = memAlloc(sizeof(ushort) * module->songLength,
(void**) &module->songData)) != OK )
PASSERR()
/* read song data: */
if ( (error = fileRead(f, module->songData, sizeof(uchar) *
module->songLength)) != OK )
PASSERR()
/* Calculate real song length: (exclude 0xFF bytes from end) */
for ( n = (module->songLength - 1); module->songData[n] == 0xFF; n-- );
module->songLength = n + 1;
/* Convert song data and find the highest pattern number used: */
temp = (uchar*) module->songData;
numUsedPatterns = 0;
for ( n = module->songLength - 1; n >= 0 ; n-- )
{
switch ( temp[n] )
{
case 0xfe:
module->songData[n] = 0xfffe;
break;
case 0xff:
module->songData[n] = 0xffff;
break;
default:
module->songData[n] = temp[n];
if ( temp[n] >= numUsedPatterns )
numUsedPatterns = temp[n] + 1;
}
}
module->numPatts = numUsedPatterns;
/* check that song length is nonzero: */
if ( module->songLength == 0 )
{
ERROR(errInvalidModule, ID_gmpLoadS3M);
LoadError();
return errInvalidModule;
}
#ifdef DEBUGMESSAGES
puts("Song data ready");
printf("Num.patts: %i\n", module->numPatts);
#endif
CHECKHEAP
/* Allocate memory for pattern pointers: */
if ( (error = memAlloc(4 * module->numPatts,
(void**) &module->patterns)) != OK )
PASSERR()
/* Set all pattern pointers to NULL to mark them unallocated: */
for ( i = 0; i < module->numPatts; i++ )
module->patterns[i] = NULL;
/* Allocate memory for instrument pointers: */
if ( (error = memAlloc(sizeof(gmpInstrument*) * module->numInsts,
(void**) &module->instruments)) != OK )
PASSERR()
/* Set all instrument pointers to NULL to mark them unallocated: */
for ( i = 0; i < module->numInsts; i++ )
module->instruments[i] = NULL;
/* Allocate memory for instrument used flags: */
if ( (error = memAlloc(module->numInsts, (void**)&instUsed)) != OK )
PASSERR()
/* Mark all instruments unused: */
for ( i = 0; i < module->numInsts; i++ )
instUsed[i] = 0;
/* Allocate memory for instrument paragraph pointers: */
if ( (error = memAlloc(sizeof(U16) * module->numInsts, (void**)
&instPtrs)) != OK )
PASSERR()
/* Read instrument pointers: */
if ( (error = fileRead(f, instPtrs, sizeof(U16) * module->numInsts))
!= OK )
PASSERR()
/* Allocate memory for S3M file pattern pointers: */
if ( (error = memAlloc(sizeof(U16) * numS3MPatterns, (void**)
&pattPtrs)) != OK )
PASSERR()
/* Read pattern pointers: */
if ( (error = fileRead(f, pattPtrs, sizeof(U16) * numS3MPatterns))
!= OK )
PASSERR()
#ifdef DEBUGMESSAGES
puts("Misc. pointers ready");
#endif
CHECKHEAP
/* Allocate memory for channel initial panning positions: */
if ( (error = memAlloc(32 * sizeof(int), (void**) &module->panning))
!= OK )
PASSERR()
if ( header->panningMagic == 0xFC )
{
/* Allocate memory for panning infos: */
if ( (error = memAlloc(32 * sizeof(uchar),
(void**) &panningInfos)) != OK )
PASSERR()
/* Read panning infos: */
if ( ( error = fileRead(f, panningInfos, 32 * sizeof(uchar)) ) != OK )
PASSERR()
/* Convert panning values: */
for (i = 0; i < 32; i++)
{
if ( header->chanSettings[i] > 15 )
{
module->panning[i] = 0x40;
}
else
{
maxChan = i;
if ( panningInfos[i] & 0x20 )
{
panValue = panningInfos[i] & 0xF;
if ( panValue < 7 )
{
module->panning[i] = 8 * panValue;
}
else
{
if ( panValue > 8 )
module->panning[i] = 0x80 - (15 - panValue) * 8;
else
module->panning[i] = 0x40;
}
}
else
{
if (header->chanSettings[i] < 8)
module->panning[i] = 0x00;
else
module->panning[i] = 0x80;
}
}
}
/* Free panning infos: */
if ( (error = memFree(panningInfos)) != OK )
PASSERR()
panningInfos = NULL;
}
else
{
/* copy default channel panning settings: */
for (i = 0; i < 32; i++)
{
if (header->chanSettings[i] > 15)
module->panning[i] = 0;
else
{
maxChan = i;
if (header->chanSettings[i] < 8)
module->panning[i] = 0x00;
else
module->panning[i] = 0x80;
}
}
}
#ifdef DEBUGMESSAGES
puts("Panning ready");
#endif
CHECKHEAP
/* Find maximum sample length: */
maxSample = 0;
for ( i = 0; i < module->numInsts; i++ )
{
/* Seek to instrument header in file: */
if ( (error = fileSeek(f, 16L * instPtrs[i], fileSeekAbsolute))
!= OK )
PASSERR()
/* Read instrument header from file: */
if ( (error = fileRead(f, &s3mi, sizeof(s3mInstHdr))) != OK )
PASSERR()
if ( maxSample < s3mi.length )
maxSample = s3mi.length;
}
/* Check that the maximum sample length is below the Sound Device limit:*/
if ( maxSample > SMPMAX )
{
ERROR(errInvalidInst, ID_gmpLoadS3M);
LoadError();
return errInvalidInst;
}
#ifdef DEBUGMESSAGES
puts("Max. sample ready");
printf("Max. sample: %i\n", maxSample);
#endif
CHECKHEAP
/* Allocate memory for pattern loading buffer: */
if ( (error = memAlloc(32 * 64 * 6 + sizeof(s3mPattern),
(void**) &s3mPatt)) != OK )
PASSERR()
/* Allocate memory for pattern conversion buffer: (maximum GMP pattern
data size is 6 bytes per row per channel plus header) */
if ( (error = memAlloc(32 * 64 * 6 + sizeof(gmpPattern),
(void**) &convPatt)) != OK )
PASSERR()
#ifdef DEBUGMESSAGES
puts("Ready for conversion");
#endif
CHECKHEAP
/* Load and convert all patterns: */
for ( i = 0; i < module->numPatts; i++ )
{
if ( (i < numS3MPatterns) && (pattPtrs[i] != 0) )
{
#ifdef DEBUGMESSAGES
puts("Seek");
#endif
CHECKHEAP
/* Seek to pattern beginning in file: */
if ( (error = fileSeek(f, 16L * pattPtrs[i], fileSeekAbsolute))
!= OK )
PASSERR()
#ifdef DEBUGMESSAGES
puts("Read pattern length");
#endif
CHECKHEAP
/* Read pattern length from file: */
if ( (error = fileRead(f, &s3mPatt->pattDataSize, sizeof(U16))) != OK )
PASSERR()
#ifdef DEBUGMESSAGES
printf("Patt.len: %i\n", s3mPatt->pattDataSize);
puts("Read pattern data");
#endif
CHECKHEAP
/* Read pattern data from file: */
if ( (error = fileRead(f, &s3mPatt->data[0], s3mPatt->pattDataSize)) != OK )
PASSERR()
}
else
{
s3mPatt->pattDataSize = 0;
#ifdef DEBUGMESSAGES
puts("Empty pattern");
#endif
}
#ifdef DEBUGMESSAGES
puts("Convert pattern");
#endif
CHECKHEAP
/* Convert the pattern data, checking the instruments used: */
if ( (error = ConvertPattern(s3mPatt, convPatt, &convPattLen))
!= OK )
PASSERR()
#if 0
#ifndef NOEMS
if ( mUseEMS == 1 ) /* is EMS memory used? */
{
/* Allocate EMS for converted pattern data for current pattern in
module: */
if ( (error = emsAlloc(convPattLen, (emsBlock**)
&module->patterns[i])) != OK )
PASSERR()
/* Map the allocated EMS block to conventional memory: */
if ( (error = emsMap((emsBlock*) module->patterns[i],
(void**) &patt)) != OK)
PASSERR()
/* Copy the converted pattern data to the EMS block: */
mMemCopy(patt, convPatt, convPattLen);
}
else
#endif
#endif
{
#ifdef DEBUGMESSAGES
printf("Alloc mem: %i\n", convPattLen);
#endif
CHECKHEAP
/* Allocate memory for converted pattern data for current pattern
in module: */
if ( (error = memAlloc(convPattLen, (void**)&module->patterns[i]))
!= OK )
PASSERR()
#ifdef DEBUGMESSAGES
puts("Copy pattern");
#endif
CHECKHEAP
/* Copy the converted pattern data: */
mMemCopy(module->patterns[i], convPatt, convPattLen);
}
#ifdef DEBUGMESSAGES
printf("Pattern %i, Conv.len: %i\n", i, convPattLen);
#endif
CHECKHEAP
}
maxChan++;
/* store number of channels */
module->numChannels = ( maxChan < numChans ) ? maxChan : numChans;
#ifdef DEBUGMESSAGES
printf("Num.channels: %i\n", module->numChannels);
#endif
CHECKHEAP
/* Deallocate pattern paragraph pointers: */
if ( (error = memFree(pattPtrs)) != OK )
PASSERR()
pattPtrs = NULL;
/* Deallocate pattern conversion buffer: */
if ( (error = memFree(convPatt)) != OK )
PASSERR()
convPatt = NULL;
/* Deallocate pattern loading buffer: */
if ( (error = memFree(s3mPatt)) != OK )
PASSERR()
s3mPatt = NULL;
#ifdef DEBUGMESSAGES
puts("Pattern conversion ready");
#endif
CHECKHEAP
/* If samples should be added to Sound Device, allocate memory for sample
loading buffer: */
if ( addSD )
{
if ( (error = memAlloc(maxSample, (void**) &smpBuf)) != OK )
PASSERR()
}
if ( maxInstUsed > module->numInsts )
module->numInsts = maxInstUsed;
#ifdef DEBUGMESSAGES
printf("Max.inst. used: %i\n", maxInstUsed);
#endif
CHECKHEAP
/* Load all samples and convert sample and instrument data: */
for ( i = 0; i < module->numInsts; i++ )
{
/* Seek to instrument header in file: */
if ( (error = fileSeek(f, 16L * instPtrs[i], fileSeekAbsolute))
!= OK )
PASSERR()
/* Read instrument header from file: */
if ( (error = fileRead(f, &s3mi, sizeof(s3mInstHdr))) != OK )
PASSERR()
/* Allocate memory for this instrument structure: (add space for one
sample if the instrument is used) */
if ( instUsed[i] )
{
if ( (error = memAlloc(sizeof(gmpInstrument) + sizeof(gmpSample),
(void**) &module->instruments[i])) != OK )
PASSERR()
}
else
{
if ( (error = memAlloc(sizeof(gmpInstrument),
(void**) &module->instruments[i])) != OK )
PASSERR()
}
/* Point inst to current instrument structure: */
inst = module->instruments[i];
/* Mark there are no sample for the instrument: */
inst->numSamples = 0;
/* Copy instrument name: */
mMemCopy(&inst->name[0], &s3mi.iname[0], 28);
inst->name[28] = 0; /* force terminating '\0' */
/* Mark the instrument has no sample number table for keyboard
notes: */
inst->noteSamples = NULL;
/* Mark the instrument has no volume or panning envelopes: */
inst->volEnvelope = NULL;
inst->panEnvelope = NULL;
/* Mark the instrument has no FT2 auto-vibrato: */
inst->vibType = inst->vibSweep = inst->vibDepth = inst->vibRate = 0;
/* Check if the instrument is used in the module: */
if ( instUsed[i] )
{
/* The instrument is used - mark it used and point sample to its
sample information: */
inst->used = 1;
inst->numSamples = 1;
sample = &inst->samples[0];
/* Mark there is no sample data and the sample has not been added
to Sound Device: */
sample->sample = NULL;
sample->sdHandle = 0;
/* Copy sample loop start and calculate loop end: */
sample->loop1Start = s3mi.loopStart;
sample->loop1End = s3mi.loopEnd;
slength = s3mi.length;
if ( ( s3mi.flags & 1 ) && ( s3mi.loopStart != s3mi.loopEnd ) )
{
/* Looping sample - set loop types and limit sample length
to loop end: */
sample->loopMode = sdLoop1;
sample->loop1Type = loopUnidir;
if ( slength > sample->loop1End )
slength = sample->loop1End;
}
else
{
/* Sample not looping: */
sample->loopMode = sdLoopNone;
sample->loop1Type = loopNone;
}
/* Set sample length: */
sample->sampleLength = slength;
/* Copy sample default volume: */
sample->volume = s3mi.volume;
/* No finetune used: */
sample->finetune = 0;
/* Copy sample base tune: */
sample->baseTune = s3mi.c2Rate;
/* Set sample default panning position to middle: */
sample->panning = panMiddle;
/* Check if there is sample data for this sample: */
if ( slength != 0 )
{
/* If sample data should not be added to Sound Device, allocate
memory for the sample data and point smpBuf there: */
if ( !addSD )
{
smpBuf = NULL;
if ( (error = memAlloc(slength, (void**)&smpBuf)) != OK )
PASSERR()
sample->sample = smpBuf;
}
else
{
/* Sample is added to the Sound Device - sample data is not
available: */
sample->sample = NULL;
}
/* Seek to instrument in file: */
if ( (error = fileSeek(f, 16L * s3mi.samplePtr, fileSeekAbsolute))
!= OK )
PASSERR()
/* There is sample data - load sample: */
if ( (error = fileRead(f, smpBuf, slength)) != OK )
PASSERR()
/* Set Sound Device sample type: */
sdSmp.sampleType = smp8bit;
sample->sampleType = smp8bit;
/* Set Sound Device sample position in memory: */
sdSmp.samplePos = sdSmpConv;
/* Point Sound Device sample data to sample loading buffer: */
sdSmp.sample = smpBuf;
/* Point smpBuf to NULL if the sample is not added to Sound
Device to mark it should not be deallocated: */
if ( !addSD )
smpBuf = NULL;
}
else
{
/* Mark there is no sample data: */
sdSmp.sampleType = smpNone;
sdSmp.samplePos = sdSmpNone;
sdSmp.sample = NULL;
}
sdSmp.sampleLength = slength;
sdSmp.loopMode = sample->loopMode;
sdSmp.loop1Start = sample->loop1Start;
sdSmp.loop1End = sample->loop1End;
sdSmp.loop1Type = sample->loop1Type;
/* Set up the rest of Sound Device sample structure so that the sample
can be added to the Sound Device: */
if ( addSD )
{
/* Add the sample to Sound Device and store the Sound Device
sample handle in sample->sdHandle: */
if ( (error = gmpSD->AddSample(&sdSmp, 1, &sample->sdHandle))
!= OK)
PASSERR()
/* Call sample callback if used: */
if ( SampleCallback != NULL )
{
if ( (error = SampleCallback(&sdSmp, sample)) != OK )
PASSERR()
}
}
else
{
/* Sample data has not been added to Sound Device: */
sample->sdHandle = 0;
}
}
else
{
/* Sample is not used - there is no sample data: */
inst->used = 0;
inst->numSamples = 0;
}
#ifdef DEBUGMESSAGES
printf("Inst: %i, Len: %i\n", i, slength);
#endif
CHECKHEAP
}
/* Deallocate sample loading buffer if allocated: */
if ( addSD )
{
if ( (error = memFree(smpBuf)) != OK )
PASSERR()
}
smpBuf = NULL;
/* Deallocate instrument paragraph pointers: */
if ( (error = memFree(instPtrs)) != OK )
PASSERR()
instPtrs = NULL;
/* Deallocate instrument use flags: */
if ( (error = memFree(instUsed)) != OK )
PASSERR()
instUsed = NULL;
#ifdef DEBUGMESSAGES
puts("Samples ready");
#endif
CHECKHEAP
/* Now we are finished loading. Close module file: */
if ( (error = fileClose(f)) != OK)
PASSERR()
fileOpened = 0;
/* Deallocate Screamtracker module header: */
if ( (error = memFree(header)) != OK )
PASSERR();
/* Return module pointer in *module: */
*_module = module;
#ifdef DEBUGMESSAGES
puts("Load Ok");
#endif
CHECKHEAP
return OK;
}
/*
* $Log: loads3m.c,v $
* Revision 1.15 1997/01/25 15:23:16 pekangas
* The file is now closed properly if loading terminates to an error
*
* Revision 1.14 1997/01/16 18:41:59 pekangas
* Changed copyright messages to Housemarque
*
* Revision 1.13 1996/12/30 23:38:08 jpaana
* Cleaned up LoadError
*
* Revision 1.12 1996/09/08 21:00:42 pekangas
* Fixed Set Tempo -command
*
* Revision 1.11 1996/09/05 06:28:28 pekangas
* Changed S8 command to SetPanning16 (was SetPanning) (thanks Zapper)
*
* Revision 1.10 1996/09/01 15:42:31 pekangas
* Changed to use new style slides (no more signed infobytes)
*
* Revision 1.9 1996/08/06 19:18:48 pekangas
* Fixed to produce legal gmpModules so that mod2gm works
*
* Revision 1.8 1996/08/02 19:46:10 pekangas
* Kluged to skip all instruments above module->numInsts to prevent crashes
*
* Revision 1.7 1996/07/16 17:35:35 pekangas
* Fixed song data conversion loop
*
* Revision 1.6 1996/07/13 20:19:32 pekangas
* Eliminated Visual C warnings
*
* Revision 1.5 1996/07/13 18:30:19 pekangas
* Fixed to compile with Visual C
*
* Revision 1.4 1996/06/14 16:23:28 pekangas
* Removed heap checking to speed up loading
*
* Revision 1.3 1996/05/24 17:03:24 pekangas
* Fixed to work with Watcom C again - using EMPTYARRAY
*
* Revision 1.2 1996/05/24 16:20:36 jpaana
* Fixed to work with gcc
*
* Revision 1.1 1996/05/22 20:49:33 pekangas
* Initial revision
*
*/
