static int it_asy_read_sample_header(IT_SAMPLE *sample, DUMBFILE *f) {
int finetune, key_offset;
/**
21 22 Chars Sample 1 name. If the name is not a full
22 chars in length, it will be null
terminated.
If
the sample name begins with a '#' character (ASCII $23 (35)) then this is
assumed not to be an instrument name, and is probably a message.
*/
dumbfile_getnc((char *)sample->name, 22, f);
sample->name[22] = 0;
sample->filename[0] = 0;
/** Each finetune step changes the note 1/8th of a semitone. */
finetune = (signed char)(dumbfile_getc(f) << 4) >> 4; /* signed nibble */
sample->default_volume =
dumbfile_getc(f); // Should we be setting global_volume to this instead?
sample->global_volume = 64;
if (sample->default_volume > 64)
sample->default_volume = 64;
key_offset = (signed char)dumbfile_getc(f); /* base key offset */
sample->length = dumbfile_igetl(f);
sample->loop_start = dumbfile_igetl(f);
sample->loop_end = sample->loop_start + dumbfile_igetl(f);
if (sample->length <= 0) {
sample->flags = 0;
return 0;
}
sample->flags = IT_SAMPLE_EXISTS;
sample->default_pan = 0;
sample->C5_speed =
(int)(AMIGA_CLOCK / 214.0 *
pow(DUMB_SEMITONE_BASE, key_offset)); //( long )( 16726.0 * pow(
// DUMB_PITCH_BASE, finetune
//* 32 ) );
sample->finetune = finetune * 32;
// the above line might be wrong
if ((sample->loop_end - sample->loop_start > 2) &&
(sample->loop_end <= sample->length))
sample->flags |= IT_SAMPLE_LOOP;
sample->vibrato_speed = 0;
sample->vibrato_depth = 0;
sample->vibrato_rate = 0;
sample->vibrato_waveform = 0; // do we have to set _all_ these?
sample->max_resampling_quality = -1;
return dumbfile_error(f);
}
static int it_ptm_read_sample_header(IT_SAMPLE *sample, long *offset, DUMBFILE *f)
{
int flags;
flags = dumbfile_getc(f);
dumbfile_getnc((char *)sample->filename, 12, f);
sample->filename[12] = 0;
sample->default_volume = dumbfile_getc(f);
sample->C5_speed = dumbfile_igetw(f) << 1;
dumbfile_skip(f, 2); /* segment */
*offset = dumbfile_igetl(f);
sample->length = dumbfile_igetl(f);
sample->loop_start = dumbfile_igetl(f);
sample->loop_end = dumbfile_igetl(f);
/* GUSBegin, GUSLStart, GUSLEnd, GUSLoop, reserverd */
dumbfile_skip(f, 4+4+4+1+1);
dumbfile_getnc((char *)sample->name, 28, f);
sample->name[28] = 0;
/*
if (dumbfile_mgetl(f) != DUMB_ID('P','T','M','S'))
return -1;
*/
/* BLAH! Shit likes to have broken or missing sample IDs */
dumbfile_skip(f, 4);
if ((flags & 3) == 0) {
/* Looks like no sample */
sample->flags &= ~IT_SAMPLE_EXISTS;
return dumbfile_error(f);
}
sample->global_volume = 64;
sample->flags = IT_SAMPLE_EXISTS;
if (flags & 4) sample->flags |= IT_SAMPLE_LOOP;
if (flags & 8) sample->flags |= IT_SAMPLE_PINGPONG_LOOP;
if (flags & 16) {
sample->flags |= IT_SAMPLE_16BIT;
sample->length >>= 1;
sample->loop_start >>= 1;
sample->loop_end >>= 1;
}
static void *combining_load_signal(DUH *duh, DUMBFILE *file)
{
COMBINING_SIGNAL *signal;
int n_signals;
(void)duh;
n_signals = dumbfile_getc(file);
/* No point in combining only one signal! */
if (dumbfile_error(file) || n_signals <= 1)
return NULL;
signal = malloc(sizeof(*signal) + n_signals * sizeof(*signal->sig));
if (!signal)
return NULL;
signal->n_signals = n_signals;
{
int n;
for (n = 0; n < signal->n_signals; n++) {
signal->sig[n] = dumbfile_igetl(file);
if (dumbfile_error(file)) {
free(signal);
return NULL;
}
}
}
return signal;
}
static int it_s3m_read_sample_data(IT_SAMPLE *sample, int ffi, DUMBFILE *f)
{
long n;
long datasize = sample->length;
if (sample->flags & IT_SAMPLE_STEREO) datasize <<= 1;
sample->data = malloc(datasize * (sample->flags & IT_SAMPLE_16BIT ? 2 : 1));
if (!sample->data)
return -1;
if (sample->flags & IT_SAMPLE_STEREO) {
if (sample->flags & IT_SAMPLE_16BIT) {
for (n = 0; n < datasize; n += 2)
((short *)sample->data)[n] = dumbfile_igetw(f);
for (n = 1; n < datasize; n += 2)
((short *)sample->data)[n] = dumbfile_igetw(f);
} else {
for (n = 0; n < datasize; n += 2)
((signed char *)sample->data)[n] = dumbfile_getc(f);
for (n = 1; n < datasize; n += 2)
((signed char *)sample->data)[n] = dumbfile_getc(f);
}
} else if (sample->flags & IT_SAMPLE_16BIT)
for (n = 0; n < sample->length; n++)
((short *)sample->data)[n] = dumbfile_igetw(f);
else
for (n = 0; n < sample->length; n++)
((signed char *)sample->data)[n] = dumbfile_getc(f);
if (dumbfile_error(f))
return -1;
if (ffi != 1) {
/* Convert to signed. */
if (sample->flags & IT_SAMPLE_16BIT)
for (n = 0; n < datasize; n++)
((short *)sample->data)[n] ^= 0x8000;
else
for (n = 0; n < datasize; n++)
((signed char *)sample->data)[n] ^= 0x80;
}
return 0;
}
/* I (entheh) have two XM files saved by a very naughty program. After a
* 16-bit sample, it saved a rogue byte. The length of the sample was indeed
* an odd number, incremented to include the rogue byte.
*
* In this function we are converting sample lengths and loop points so they
* are measured in samples. This means we forget about the extra bytes, and
* they don't get skipped. So we fail trying to read the next instrument.
*
* To get around this, this function returns the number of rogue bytes that
* won't be accounted for by reading sample->length samples. It returns a
* negative number on failure.
*/
static int it_xm_read_sample_header(IT_SAMPLE *sample, DUMBFILE *f)
{
int type;
int relative_note_number; /* relative to C4 */
int finetune;
int roguebytes;
int roguebytesmask;
sample->length = dumbfile_igetl(f);
sample->loop_start = dumbfile_igetl(f);
sample->loop_end = sample->loop_start + dumbfile_igetl(f);
sample->global_volume = 64;
sample->default_volume = dumbfile_getc(f);
finetune = (signed char)dumbfile_getc(f); /* -128..127 <=> -1 semitone .. +127/128 of a semitone */
type = dumbfile_getc(f);
sample->default_pan = dumbfile_getc(f); /* 0-255 */
relative_note_number = (signed char)dumbfile_getc(f);
dumbfile_skip(f, 1); /* reserved */
dumbfile_getnc(sample->name, 22, f);
sample->name[22] = 0;
sample->filename[0] = 0;
if (dumbfile_error(f))
return -1;
sample->C5_speed = (long)(16726.0*pow(DUMB_SEMITONE_BASE, relative_note_number)*pow(DUMB_PITCH_BASE, finetune*2));
sample->flags = IT_SAMPLE_EXISTS;
roguebytes = (int)sample->length;
roguebytesmask = 3;
if (type & XM_SAMPLE_16BIT) {
sample->flags |= IT_SAMPLE_16BIT;
sample->length >>= 1;
sample->loop_start >>= 1;
sample->loop_end >>= 1;
} else
/* I (entheh) have two XM files saved by a very naughty program. After a
* 16-bit sample, it saved a rogue byte. The length of the sample was indeed
* an odd number, incremented to include the rogue byte.
*
* In this function we are converting sample lengths and loop points so they
* are measured in samples. This means we forget about the extra bytes, and
* they don't get skipped. So we fail trying to read the next instrument.
*
* To get around this, this function returns the number of rogue bytes that
* won't be accounted for by reading sample->length samples. It returns a
* negative number on failure.
*/
static int it_xm_read_sample_header(IT_SAMPLE *sample, DUMBFILE *f)
{
int type;
int relative_note_number; /* relative to C4 */
int finetune;
int roguebytes;
int roguebytesmask;
int reserved;
sample->length = dumbfile_igetl(f);
sample->loop_start = dumbfile_igetl(f);
sample->loop_end = sample->loop_start + dumbfile_igetl(f);
sample->global_volume = 64;
sample->default_volume = dumbfile_getc(f);
finetune = (signed char)dumbfile_getc(f); /* -128..127 <=> -1 semitone .. +127/128 of a semitone */
type = dumbfile_getc(f);
sample->default_pan = dumbfile_getc(f); /* 0-255 */
relative_note_number = (signed char)dumbfile_getc(f);
reserved = dumbfile_getc(f);
dumbfile_getnc((char *)sample->name, 22, f);
sample->name[22] = 0;
trim_whitespace((char *)sample->name, 22);
sample->filename[0] = 0;
if (dumbfile_error(f))
return -1;
sample->C5_speed = (long)(16726.0*pow(DUMB_SEMITONE_BASE, relative_note_number) /**pow(DUMB_PITCH_BASE, )*/ );
sample->finetune = finetune*2;
sample->flags = IT_SAMPLE_EXISTS;
if (reserved == 0xAD &&
(!(type & (XM_SAMPLE_16BIT | XM_SAMPLE_STEREO))))
{
/* F U Olivier Lapicque */
roguebytes = 4;
roguebytesmask = 4 << 2;
}
else
{
roguebytes = (int)sample->length;
roguebytesmask = 3;
}
if (type & XM_SAMPLE_16BIT) {
sample->flags |= IT_SAMPLE_16BIT;
sample->length >>= 1;
sample->loop_start >>= 1;
sample->loop_end >>= 1;
} else
unsigned long dumbfile_cgetul(DUMBFILE *f)
{
unsigned long rv = 0;
int v;
do {
v = dumbfile_getc(f);
if (v < 0)
return v;
rv <<= 7;
rv |= v & 0x7F;
} while (v & 0x80);
return rv;
}
uint32 DUMBEXPORT dumbfile_cgetul(DUMBFILE *f)
{
uint32 rv = 0;
int v;
do {
v = dumbfile_getc(f);
if (v < 0)
return v;
rv <<= 7;
rv |= v & 0x7F;
} while (v & 0x80);
return rv;
}
static int it_xm_read_instrument(IT_INSTRUMENT *instrument, XM_INSTRUMENT_EXTRA *extra, DUMBFILE *f)
{
unsigned long size, bytes_read;
unsigned short vol_points[24];
unsigned short pan_points[24];
int i, type;
const unsigned long max_size = 4 + 22 + 1 + 2 + 4 + 96 + 48 + 48 + 1 * 14 + 2 + 2;
unsigned long skip_end = 0;
/* Header size. Tends to be more than the actual size of the structure.
* So unread bytes must be skipped before reading the first sample
* header.
*/
if ( limit_xm_resize( f, 4 ) < 0 ) return -1;
size = dumbfile_igetl(f);
if ( size == 0 ) size = max_size;
else if ( size > max_size )
{
skip_end = size - max_size;
size = max_size;
}
if ( limit_xm_resize( f, size - 4 ) < 0 ) return -1;
dumbfile_getnc((char *)instrument->name, 22, f);
instrument->name[22] = 0;
trim_whitespace((char *)instrument->name, 22);
instrument->filename[0] = 0;
dumbfile_skip(f, 1); /* Instrument type. Should be 0, but seems random. */
extra->n_samples = dumbfile_igetw(f);
if (dumbfile_error(f) || (unsigned int)extra->n_samples > XM_MAX_SAMPLES_PER_INSTRUMENT)
return -1;
bytes_read = 4 + 22 + 1 + 2;
if (extra->n_samples) {
/* sample header size */
/*i = dumbfile_igetl(f);
if (!i || i > 0x28) i = 0x28;*/
dumbfile_skip(f, 4);
i = 0x28;
extra->sample_header_size = i;
/* sample map */
for (i = 0; i < 96; i++) {
instrument->map_sample[i] = dumbfile_getc(f) + 1;
instrument->map_note[i] = i;
}
if (dumbfile_error(f))
return 1;
/* volume/panning envelopes */
for (i = 0; i < 24; i++)
vol_points[i] = dumbfile_igetw(f);
for (i = 0; i < 24; i++)
pan_points[i] = dumbfile_igetw(f);
instrument->volume_envelope.n_nodes = dumbfile_getc(f);
instrument->pan_envelope.n_nodes = dumbfile_getc(f);
if (dumbfile_error(f))
return -1;
instrument->volume_envelope.sus_loop_start = dumbfile_getc(f);
instrument->volume_envelope.loop_start = dumbfile_getc(f);
instrument->volume_envelope.loop_end = dumbfile_getc(f);
instrument->pan_envelope.sus_loop_start = dumbfile_getc(f);
instrument->pan_envelope.loop_start = dumbfile_getc(f);
instrument->pan_envelope.loop_end = dumbfile_getc(f);
/* The envelope handler for XM files won't use sus_loop_end. */
type = dumbfile_getc(f);
instrument->volume_envelope.flags = 0;
if ((type & XM_ENVELOPE_ON) && instrument->volume_envelope.n_nodes)
instrument->volume_envelope.flags |= IT_ENVELOPE_ON;
if (type & XM_ENVELOPE_LOOP) instrument->volume_envelope.flags |= IT_ENVELOPE_LOOP_ON;
#if 1
if (type & XM_ENVELOPE_SUSTAIN) instrument->volume_envelope.flags |= IT_ENVELOPE_SUSTAIN_LOOP;
#else // This is now handled in itrender.c
/* let's avoid fading out when reaching the last envelope node */
if (!(type & XM_ENVELOPE_LOOP)) {
instrument->volume_envelope.loop_start = instrument->volume_envelope.n_nodes-1;
instrument->volume_envelope.loop_end = instrument->volume_envelope.n_nodes-1;
}
instrument->volume_envelope.flags |= IT_ENVELOPE_LOOP_ON;
#endif
type = dumbfile_getc(f);
instrument->pan_envelope.flags = 0;
if ((type & XM_ENVELOPE_ON) && instrument->pan_envelope.n_nodes)
instrument->pan_envelope.flags |= IT_ENVELOPE_ON;
if (type & XM_ENVELOPE_LOOP) instrument->pan_envelope.flags |= IT_ENVELOPE_LOOP_ON; // should this be here?
if (type & XM_ENVELOPE_SUSTAIN) instrument->pan_envelope.flags |= IT_ENVELOPE_SUSTAIN_LOOP;
if (it_xm_make_envelope(&instrument->volume_envelope, vol_points, 0) != 0) {
TRACE("XM error: volume envelope\n");
if (instrument->volume_envelope.flags & IT_ENVELOPE_ON) return -1;
}
if (it_xm_make_envelope(&instrument->pan_envelope, pan_points, -32) != 0) {
TRACE("XM error: pan envelope\n");
if (instrument->pan_envelope.flags & IT_ENVELOPE_ON) return -1;
}
instrument->pitch_envelope.flags = 0;
extra->vibrato_type = dumbfile_getc(f);
extra->vibrato_sweep = dumbfile_getc(f);
extra->vibrato_depth = dumbfile_getc(f);
extra->vibrato_speed = dumbfile_getc(f);
if (dumbfile_error(f) || extra->vibrato_type > 4) // XXX
return -1;
/** WARNING: lossy approximation */
instrument->fadeout = (dumbfile_igetw(f)*128 + 64)/0xFFF;
dumbfile_skip(f, 2); /* reserved */
bytes_read += 4 + 96 + 48 + 48 + 14*1 + 2 + 2;
} else
for (i = 0; i < 96; i++)
instrument->map_sample[i] = 0;
if (size > bytes_read && dumbfile_skip(f, size - bytes_read))
return -1;
if (skip_end && limit_xm_skip_end(f, skip_end))
return -1;
instrument->new_note_action = NNA_NOTE_CUT;
instrument->dup_check_type = DCT_OFF;
instrument->dup_check_action = DCA_NOTE_CUT;
instrument->pp_separation = 0;
instrument->pp_centre = 60; /* C-5 */
instrument->global_volume = 128;
instrument->default_pan = 32;
instrument->random_volume = 0;
instrument->random_pan = 0;
instrument->filter_cutoff = 0;
instrument->filter_resonance = 0;
return 0;
}
static int it_xm_read_pattern(IT_PATTERN *pattern, DUMBFILE *f, int n_channels, unsigned char *buffer, int version)
{
int size;
int pos;
int channel;
int row;
int effect, effectvalue;
IT_ENTRY *entry;
/* pattern header size */
if (dumbfile_igetl(f) != ( version == 0x0102 ? 0x08 : 0x09 ) ) {
TRACE("XM error: unexpected pattern header size\n");
return -1;
}
/* pattern data packing type */
if (dumbfile_getc(f) != 0) {
TRACE("XM error: unexpected pattern packing type\n");
return -1;
}
if ( version == 0x0102 )
pattern->n_rows = dumbfile_getc(f) + 1;
else
pattern->n_rows = dumbfile_igetw(f); /* 1..256 */
size = dumbfile_igetw(f);
pattern->n_entries = 0;
if (dumbfile_error(f))
return -1;
if (size == 0)
return 0;
if (size > 1280 * n_channels) {
TRACE("XM error: pattern data size > %d bytes\n", 1280 * n_channels);
return -1;
}
if (dumbfile_getnc((char *)buffer, size, f) < size)
return -1;
/* compute number of entries */
pattern->n_entries = 0;
pos = channel = row = 0;
while (pos < size) {
if (!(buffer[pos] & XM_ENTRY_PACKED) || (buffer[pos] & 31))
pattern->n_entries++;
channel++;
if (channel >= n_channels) {
channel = 0;
row++;
pattern->n_entries++;
}
if (buffer[pos] & XM_ENTRY_PACKED) {
static const char offset[] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5 };
pos += 1 + offset[buffer[pos] & 31];
} else {
pos += 5;
}
}
if (row > pattern->n_rows) {
TRACE("XM error: wrong number of rows in pattern data\n");
return -1;
}
/* Whoops, looks like some modules may be short, a few channels, maybe even rows... */
while (row < pattern->n_rows)
{
pattern->n_entries++;
row++;
}
pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry));
if (!pattern->entry)
return -1;
/* read the entries */
entry = pattern->entry;
pos = channel = row = 0;
while (pos < size) {
unsigned char mask;
if (buffer[pos] & XM_ENTRY_PACKED)
mask = buffer[pos++] & 31;
else
mask = 31;
if (mask) {
ASSERT(entry < pattern->entry + pattern->n_entries);
entry->channel = channel;
entry->mask = 0;
if (mask & XM_ENTRY_NOTE) {
int note = buffer[pos++]; /* 1-96 <=> C0-B7 */
entry->note = (note == XM_NOTE_OFF) ? (IT_NOTE_OFF) : (note-1);
entry->mask |= IT_ENTRY_NOTE;
}
if (mask & XM_ENTRY_INSTRUMENT) {
entry->instrument = buffer[pos++]; /* 1-128 */
entry->mask |= IT_ENTRY_INSTRUMENT;
}
if (mask & XM_ENTRY_VOLUME)
it_xm_convert_volume(buffer[pos++], entry);
effect = effectvalue = 0;
if (mask & XM_ENTRY_EFFECT) effect = buffer[pos++];
if (mask & XM_ENTRY_EFFECTVALUE) effectvalue = buffer[pos++];
_dumb_it_xm_convert_effect(effect, effectvalue, entry, 0);
entry++;
}
channel++;
if (channel >= n_channels) {
channel = 0;
row++;
IT_SET_END_ROW(entry);
entry++;
}
}
while (row < pattern->n_rows)
{
row++;
IT_SET_END_ROW(entry);
entry++;
}
return 0;
}
static int it_riff_dsmf_process_pattern( IT_PATTERN * pattern, DUMBFILE * f, int len )
{
int length, row;
unsigned flags;
long start, end;
int p, q, r;
IT_ENTRY * entry;
length = dumbfile_igetw( f );
if ( length > len ) return -1;
len = length - 2;
pattern->n_rows = 64;
pattern->n_entries = 64;
row = 0;
start = dumbfile_pos( f );
end = start + len;
while ( (row < 64) && !dumbfile_error( f ) && (dumbfile_pos( f ) < end) ) {
p = dumbfile_getc( f );
if ( ! p ) {
++ row;
continue;
}
flags = p & 0xF0;
if (flags) {
++ pattern->n_entries;
if (flags & 0x80) dumbfile_skip( f, 1 );
if (flags & 0x40) dumbfile_skip( f, 1 );
if (flags & 0x20) dumbfile_skip( f, 1 );
if (flags & 0x10) dumbfile_skip( f, 2 );
}
}
if ( pattern->n_entries == 64 ) return 0;
pattern->entry = malloc( pattern->n_entries * sizeof( * pattern->entry ) );
if ( ! pattern->entry ) return -1;
entry = pattern->entry;
row = 0;
if ( dumbfile_seek( f, start, DFS_SEEK_SET ) ) return -1;
while ( ( row < 64 ) && !dumbfile_error( f ) && ( dumbfile_pos( f ) < end ) )
{
p = dumbfile_getc( f );
if ( ! p )
{
IT_SET_END_ROW( entry );
++ entry;
++ row;
continue;
}
flags = p;
entry->channel = flags & 0x0F;
entry->mask = 0;
if ( flags & 0xF0 )
{
if ( flags & 0x80 )
{
q = dumbfile_getc( f );
if ( q )
{
entry->mask |= IT_ENTRY_NOTE;
entry->note = q - 1;
}
}
if ( flags & 0x40 )
{
q = dumbfile_getc( f );
if ( q )
{
entry->mask |= IT_ENTRY_INSTRUMENT;
entry->instrument = q;
}
}
if ( flags & 0x20 )
{
entry->mask |= IT_ENTRY_VOLPAN;
entry->volpan = dumbfile_getc( f );
}
if ( flags & 0x10 )
{
q = dumbfile_getc( f );
r = dumbfile_getc( f );
_dumb_it_xm_convert_effect( q, r, entry, 0 );
}
if (entry->mask) entry++;
}
}
while ( row < 64 )
{
IT_SET_END_ROW( entry );
++ entry;
++ row;
}
pattern->n_entries = entry - pattern->entry;
if ( ! pattern->n_entries ) return -1;
return 0;
}
static int it_riff_dsmf_process_sample( IT_SAMPLE * sample, DUMBFILE * f, int len )
{
int flags;
dumbfile_getnc( (char *) sample->filename, 13, f );
sample->filename[ 14 ] = 0;
flags = dumbfile_igetw( f );
sample->default_volume = dumbfile_getc( f );
sample->length = dumbfile_igetl( f );
sample->loop_start = dumbfile_igetl( f );
sample->loop_end = dumbfile_igetl( f );
dumbfile_skip( f, 32 - 28 );
sample->C5_speed = dumbfile_igetw( f ) * 2;
dumbfile_skip( f, 36 - 34 );
dumbfile_getnc( (char *) sample->name, 28, f );
sample->name[ 28 ] = 0;
/*if ( data[ 0x38 ] || data[ 0x39 ] || data[ 0x3A ] || data[ 0x3B ] )
return -1;*/
if ( ! sample->length ) {
sample->flags &= ~IT_SAMPLE_EXISTS;
return 0;
}
/*if ( flags & ~( 2 | 1 ) )
return -1;*/
if ( sample->length + 64 > len )
return -1;
sample->flags = IT_SAMPLE_EXISTS;
sample->default_pan = 0;
sample->global_volume = 64;
sample->vibrato_speed = 0;
sample->vibrato_depth = 0;
sample->vibrato_rate = 0;
sample->vibrato_waveform = IT_VIBRATO_SINE;
sample->finetune = 0;
sample->max_resampling_quality = -1;
if ( flags & 1 )
{
if (((unsigned int)sample->loop_end <= (unsigned int)sample->length) &&
((unsigned int)sample->loop_start < (unsigned int)sample->loop_end))
{
sample->length = sample->loop_end;
sample->flags |= IT_SAMPLE_LOOP;
if ( flags & 0x10 ) sample->flags |= IT_SAMPLE_PINGPONG_LOOP;
}
}
sample->data = malloc( sample->length );
if ( ! sample->data )
return -1;
dumbfile_getnc( sample->data, sample->length, f );
if ( ! ( flags & 2 ) )
{
for ( flags = 0; flags < sample->length; ++flags )
( ( signed char * ) sample->data ) [ flags ] ^= 0x80;
}
return 0;
}
static DUMB_IT_SIGDATA *it_riff_dsmf_load_sigdata( DUMBFILE * f, struct riff * stream )
{
DUMB_IT_SIGDATA *sigdata;
int n, o, found;
if ( ! stream ) goto error;
if ( stream->type != DUMB_ID( 'D', 'S', 'M', 'F' ) ) goto error;
sigdata = malloc(sizeof(*sigdata));
if ( ! sigdata ) goto error;
sigdata->n_patterns = 0;
sigdata->n_samples = 0;
sigdata->name[0] = 0;
found = 0;
for ( n = 0; (unsigned)n < stream->chunk_count; ++n )
{
struct riff_chunk * c = stream->chunks + n;
switch( c->type )
{
case DUMB_ID( 'S' ,'O' ,'N' ,'G' ):
/* initialization data */
if ( ( found ) || ( c->size < 192 ) ) goto error_sd;
found = 1;
break;
case DUMB_ID( 'P', 'A', 'T', 'T' ):
++ sigdata->n_patterns;
break;
case DUMB_ID( 'I', 'N', 'S', 'T' ):
++ sigdata->n_samples;
break;
}
}
if ( !found || !sigdata->n_samples || !sigdata->n_patterns ) goto error_sd;
if ( sigdata->n_samples > 255 || sigdata->n_patterns > 255 ) goto error_sd;
sigdata->song_message = NULL;
sigdata->order = NULL;
sigdata->instrument = NULL;
sigdata->sample = NULL;
sigdata->pattern = NULL;
sigdata->midi = NULL;
sigdata->checkpoint = NULL;
sigdata->mixing_volume = 48;
sigdata->pan_separation = 128;
sigdata->n_instruments = 0;
sigdata->n_orders = 0;
sigdata->restart_position = 0;
memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS);
for (n = 0; n < DUMB_IT_N_CHANNELS; n += 4) {
int sep = 32 * dumb_it_default_panning_separation / 100;
sigdata->channel_pan[n ] = 32 - sep;
sigdata->channel_pan[n+1] = 32 + sep;
sigdata->channel_pan[n+2] = 32 + sep;
sigdata->channel_pan[n+3] = 32 - sep;
}
for ( n = 0; (unsigned)n < stream->chunk_count; ++n )
{
struct riff_chunk * c = stream->chunks + n;
switch ( c->type )
{
case DUMB_ID( 'S', 'O', 'N', 'G' ):
if ( dumbfile_seek( f, c->offset, DFS_SEEK_SET ) ) goto error_usd;
dumbfile_getnc( (char *) sigdata->name, 28, f );
sigdata->name[ 28 ] = 0;
sigdata->flags = IT_STEREO | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX;
dumbfile_skip( f, 36 - 28 );
sigdata->n_orders = dumbfile_igetw( f );
//sigdata->n_samples = ptr[ 38 ] | ( ptr[ 39 ] << 8 ); // whatever
//sigdata->n_patterns = ptr[ 40 ] | ( ptr[ 41 ] << 8 );
dumbfile_skip( f, 42 - 38 );
sigdata->n_pchannels = dumbfile_igetw( f );
sigdata->global_volume = dumbfile_getc( f );
sigdata->mixing_volume = dumbfile_getc( f );
sigdata->speed = dumbfile_getc( f );
sigdata->tempo = dumbfile_getc( f );
for ( o = 0; o < 16; ++o )
{
sigdata->channel_pan[ o ] = dumbfile_getc( f ) / 2;
}
sigdata->order = malloc( 128 );
if ( ! sigdata->order ) goto error_usd;
dumbfile_getnc( (char *) sigdata->order, 128, f );
break;
}
}
sigdata->pattern = malloc( sigdata->n_patterns * sizeof( *sigdata->pattern ) );
if ( ! sigdata->pattern ) goto error_usd;
for ( n = 0; n < sigdata->n_patterns; ++n )
sigdata->pattern[ n ].entry = NULL;
sigdata->sample = malloc( sigdata->n_samples * sizeof( *sigdata->sample ) );
if ( ! sigdata->sample ) goto error_usd;
for ( n = 0; n < sigdata->n_samples; ++n )
{
IT_SAMPLE * sample = sigdata->sample + n;
sample->data = NULL;
}
sigdata->n_samples = 0;
sigdata->n_patterns = 0;
for ( n = 0; (unsigned)n < stream->chunk_count; ++n )
{
struct riff_chunk * c = stream->chunks + n;
switch ( c->type )
{
case DUMB_ID( 'P', 'A', 'T', 'T' ):
if ( dumbfile_seek( f, c->offset, DFS_SEEK_SET ) ) goto error_usd;
if ( it_riff_dsmf_process_pattern( sigdata->pattern + sigdata->n_patterns, f, c->size ) ) goto error_usd;
++ sigdata->n_patterns;
break;
case DUMB_ID( 'I', 'N', 'S', 'T' ):
if ( dumbfile_seek( f, c->offset, DFS_SEEK_SET ) ) goto error_usd;
if ( it_riff_dsmf_process_sample( sigdata->sample + sigdata->n_samples, f, c->size ) ) goto error_usd;
++ sigdata->n_samples;
break;
}
}
_dumb_it_fix_invalid_orders( sigdata );
return sigdata;
error_usd:
_dumb_it_unload_sigdata( sigdata );
goto error;
error_sd:
free( sigdata );
error:
return NULL;
}
static int it_s3m_read_sample_header(IT_SAMPLE *sample, long *offset,
unsigned char *pack, int cwtv,
DUMBFILE *f) {
unsigned char type;
int flags;
type = dumbfile_getc(f);
dumbfile_getnc((char *)sample->filename, 12, f);
sample->filename[12] = 0;
if (type > 1) {
/** WARNING: no adlib support */
dumbfile_skip(f, 3 + 12 + 1 + 1 + 2 + 2 + 2 + 12);
dumbfile_getnc((char *)sample->name, 28, f);
sample->name[28] = 0;
dumbfile_skip(f, 4);
sample->flags &= ~IT_SAMPLE_EXISTS;
return dumbfile_error(f);
}
*offset = dumbfile_getc(f) << 20;
*offset += dumbfile_igetw(f) << 4;
sample->length = dumbfile_igetl(f);
sample->loop_start = dumbfile_igetl(f);
sample->loop_end = dumbfile_igetl(f);
sample->default_volume = dumbfile_getc(f);
dumbfile_skip(f, 1);
flags = dumbfile_getc(f);
if (flags < 0 || (flags != 0 && flags != 4))
/* Sample is packed apparently (or error reading from file). We don't
* know how to read packed samples.
*/
return -1;
*pack = flags;
flags = dumbfile_getc(f);
sample->C5_speed = dumbfile_igetl(f) << 1;
/* Skip four unused bytes and three internal variables. */
dumbfile_skip(f, 4 + 2 + 2 + 4);
dumbfile_getnc((char *)sample->name, 28, f);
sample->name[28] = 0;
if (type == 0 || sample->length <= 0) {
/* Looks like no-existy. Anyway, there's for sure no 'SCRS' ... */
sample->flags &= ~IT_SAMPLE_EXISTS;
return dumbfile_error(f);
}
if (dumbfile_mgetl(f) != DUMB_ID('S', 'C', 'R', 'S'))
return -1;
sample->global_volume = 64;
sample->flags = IT_SAMPLE_EXISTS;
if (flags & 1)
sample->flags |= IT_SAMPLE_LOOP;
/* The ST3 TECH.DOC is unclear on this, but IMAGO Orpheus is not. Piece of
* crap. */
if (flags & 2) {
sample->flags |= IT_SAMPLE_STEREO;
if ((cwtv & 0xF000) == 0x2000) {
sample->length >>= 1;
sample->loop_start >>= 1;
sample->loop_end >>= 1;
}
static DUMB_IT_SIGDATA *it_asy_load_sigdata(DUMBFILE *f) {
DUMB_IT_SIGDATA *sigdata;
int i;
static const char sig_part[] = "ASYLUM Music Format";
static const char sig_rest[] =
" V1.0"; /* whee, string space optimization with format type below */
char signature[32];
if (dumbfile_getnc(signature, 32, f) != 32 ||
memcmp(signature, sig_part, 19) ||
memcmp(signature + 19, sig_rest, 5)) {
return NULL;
}
sigdata = malloc(sizeof(*sigdata));
if (!sigdata) {
return NULL;
}
sigdata->speed = dumbfile_getc(f); /* XXX seems to fit the files I have */
sigdata->tempo = dumbfile_getc(f); /* ditto */
sigdata->n_samples = dumbfile_getc(f); /* ditto */
sigdata->n_patterns = dumbfile_getc(f);
sigdata->n_orders = dumbfile_getc(f);
sigdata->restart_position = dumbfile_getc(f);
if (dumbfile_error(f) || !sigdata->n_samples || sigdata->n_samples > 64 ||
!sigdata->n_patterns || !sigdata->n_orders) {
free(sigdata);
return NULL;
}
if (sigdata->restart_position > sigdata->n_orders) /* XXX */
sigdata->restart_position = 0;
sigdata->order = malloc(sigdata->n_orders);
if (!sigdata->order) {
free(sigdata);
return NULL;
}
if (dumbfile_getnc((char *)sigdata->order, sigdata->n_orders, f) !=
sigdata->n_orders ||
dumbfile_skip(f, 256 - sigdata->n_orders)) {
free(sigdata->order);
free(sigdata);
return NULL;
}
sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample));
if (!sigdata->sample) {
free(sigdata->order);
free(sigdata);
return NULL;
}
sigdata->song_message = NULL;
sigdata->instrument = NULL;
sigdata->pattern = NULL;
sigdata->midi = NULL;
sigdata->checkpoint = NULL;
sigdata->n_instruments = 0;
for (i = 0; i < sigdata->n_samples; ++i)
sigdata->sample[i].data = NULL;
for (i = 0; i < sigdata->n_samples; ++i) {
if (it_asy_read_sample_header(&sigdata->sample[i], f)) {
_dumb_it_unload_sigdata(sigdata);
return NULL;
}
}
if (dumbfile_skip(f, 37 * (64 - sigdata->n_samples))) {
_dumb_it_unload_sigdata(sigdata);
return NULL;
}
sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern));
if (!sigdata->pattern) {
_dumb_it_unload_sigdata(sigdata);
return NULL;
}
for (i = 0; i < sigdata->n_patterns; ++i)
sigdata->pattern[i].entry = NULL;
/* Read in the patterns */
{
unsigned char *buffer =
malloc(64 * 8 * 4); /* 64 rows * 8 channels * 4 bytes */
if (!buffer) {
_dumb_it_unload_sigdata(sigdata);
return NULL;
}
for (i = 0; i < sigdata->n_patterns; ++i) {
if (it_asy_read_pattern(&sigdata->pattern[i], f, buffer) != 0) {
free(buffer);
_dumb_it_unload_sigdata(sigdata);
return NULL;
}
}
free(buffer);
}
/* And finally, the sample data */
for (i = 0; i < sigdata->n_samples; ++i) {
if (it_asy_read_sample_data(&sigdata->sample[i], f)) {
_dumb_it_unload_sigdata(sigdata);
return NULL;
}
}
/* Now let's initialise the remaining variables, and we're done! */
sigdata->flags = IT_WAS_AN_XM | IT_WAS_A_MOD | IT_OLD_EFFECTS |
IT_COMPATIBLE_GXX | IT_STEREO;
sigdata->global_volume = 128;
sigdata->mixing_volume = 48;
sigdata->pan_separation = 128;
sigdata->n_pchannels = 8;
sigdata->name[0] = 0;
memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS);
for (i = 0; i < DUMB_IT_N_CHANNELS; i += 4) {
int sep = 32 * dumb_it_default_panning_separation / 100;
sigdata->channel_pan[i + 0] = 32 - sep;
sigdata->channel_pan[i + 1] = 32 + sep;
sigdata->channel_pan[i + 2] = 32 + sep;
sigdata->channel_pan[i + 3] = 32 - sep;
}
if (_dumb_it_fix_invalid_orders(sigdata) < 0) {
_dumb_it_unload_sigdata(sigdata);
return NULL;
}
return sigdata;
}
static int it_s3m_read_sample_header(IT_SAMPLE *sample, long *offset, DUMBFILE *f)
{
unsigned char type;
int flags;
type = dumbfile_getc(f);
if (type > 1) {
/** WARNING: no adlib support */
}
dumbfile_getnc(sample->filename, 13, f);
sample->filename[13] = 0;
*offset = dumbfile_igetw(f) << 4;
sample->length = dumbfile_igetl(f);
sample->loop_start = dumbfile_igetl(f);
sample->loop_end = dumbfile_igetl(f);
sample->default_volume = dumbfile_getc(f);
dumbfile_skip(f, 1);
if (dumbfile_getc(f) != 0)
/* Sample is packed apparently (or error reading from file). We don't
* know how to read packed samples.
*/
return -1;
flags = dumbfile_getc(f);
sample->C5_speed = dumbfile_igetl(f) << 1;
/* Skip four unused bytes and three internal variables. */
dumbfile_skip(f, 4+2+2+4);
dumbfile_getnc(sample->name, 28, f);
sample->name[28] = 0;
if (type == 0) {
/* Looks like no-existy. Anyway, there's for sure no 'SCRS' ... */
sample->flags &= ~IT_SAMPLE_EXISTS;
return dumbfile_error(f);
}
if (dumbfile_mgetl(f) != DUMB_ID('S','C','R','S'))
return -1;
sample->global_volume = 64;
sample->flags = IT_SAMPLE_EXISTS;
if (flags & 1) sample->flags |= IT_SAMPLE_LOOP;
if (flags & 2) sample->flags |= IT_SAMPLE_STEREO;
if (flags & 4) sample->flags |= IT_SAMPLE_16BIT;
sample->default_pan = 0; // 0 = don't use, or 160 = centre?
if (sample->length <= 0)
sample->flags &= ~IT_SAMPLE_EXISTS;
else if (sample->flags & IT_SAMPLE_LOOP) {
if ((unsigned int)sample->loop_end > (unsigned int)sample->length)
sample->flags &= ~IT_SAMPLE_LOOP;
else if ((unsigned int)sample->loop_start >= (unsigned int)sample->loop_end)
sample->flags &= ~IT_SAMPLE_LOOP;
else
/* ScreamTracker seems not to save what comes after the loop end
* point, but rather to assume it is a duplicate of what comes at
* the loop start point. I am not completely sure of this though.
* It is easy to evade; simply truncate the sample.
*/
sample->length = sample->loop_end;
}
//Do we need to set all these?
sample->vibrato_speed = 0;
sample->vibrato_depth = 0;
sample->vibrato_rate = 0;
sample->vibrato_waveform = IT_VIBRATO_SINE;
return dumbfile_error(f);
}
static int it_s3m_read_pattern(IT_PATTERN *pattern, DUMBFILE *f, unsigned char *buffer)
{
int buflen = 0;
int bufpos = 0;
IT_ENTRY *entry;
unsigned char channel;
/* Haha, this is hilarious!
*
* Well, after some experimentation, it seems that different S3M writers
* define the format in different ways. The S3M docs say that the first
* two bytes hold the "length of [the] packed pattern", and the packed
* pattern data follow. Judging by the contents of ARMANI.S3M, packaged
* with ScreamTracker itself, the measure of length _includes_ the two
* bytes used to store the length; in other words, we should read
* (length - 2) more bytes. However, aryx.s3m, packaged with ModPlug
* Tracker, excludes these two bytes, so (length) more bytes must be
* read.
*
* Call me crazy, but I just find it insanely funny that the format was
* misunderstood in this way :D
*
* Now we can't just risk reading two extra bytes, because then we
* overshoot, and DUMBFILEs don't support backward seeking (for a good
* reason). Luckily, there is a way. We can read the data little by
* little, and stop when we have 64 rows in memory. Provided we protect
* against buffer overflow, this method should work with all sensibly
* written S3M files. If you find one for which it does not work, please
* let me know at [email protected] so I can look at it.
*/
/* Discard the length. */
dumbfile_skip(f, 2);
if (dumbfile_error(f))
return -1;
pattern->n_rows = 0;
pattern->n_entries = 0;
/* Read in the pattern data, little by little, and work out how many
* entries we need room for. Sorry, but this is just so funny...
*/
for (;;) {
unsigned char b = buffer[buflen++] = dumbfile_getc(f);
#if 1
static const unsigned char used[8] = {0, 2, 1, 3, 2, 4, 3, 5};
channel = b & 31;
b >>= 5;
pattern->n_entries++;
if (b) {
if (buflen + used[b] >= 65536) return -1;
dumbfile_getnc(buffer + buflen, used[b], f);
buflen += used[b];
} else {
/* End of row */
if (++pattern->n_rows == 64) break;
if (buflen >= 65536) return -1;
}
#else
if (b == 0) {
/* End of row */
pattern->n_entries++;
if (++pattern->n_rows == 64) break;
if (buflen >= 65536) return -1;
} else {
static const unsigned char used[8] = {0, 2, 1, 3, 2, 4, 3, 5};
channel = b & 31;
b >>= 5;
if (b) {
pattern->n_entries++;
if (buflen + used[b] >= 65536) return -1;
dumbfile_getnc(buffer + buflen, used[b], f);
buflen += used[b];
}
}
#endif
/* We have ensured that buflen < 65536 at this point, so it is safe
* to iterate and read at least one more byte without checking.
* However, now would be a good time to check for errors reading from
* the file.
*/
if (dumbfile_error(f))
return -1;
}
pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry));
if (!pattern->entry)
return -1;
entry = pattern->entry;
while (bufpos < buflen) {
unsigned char b = buffer[bufpos++];
#if 1
if (!(b & ~31))
#else
if (b == 0)
#endif
{
/* End of row */
IT_SET_END_ROW(entry);
entry++;
continue;
}
channel = b & 31;
if (b & 224) {
entry->mask = 0;
entry->channel = channel;
if (b & 32) {
unsigned char n = buffer[bufpos++];
if (n != 255) {
if (n == 254)
entry->note = IT_NOTE_CUT;
else
entry->note = (n >> 4) * 12 + (n & 15);
entry->mask |= IT_ENTRY_NOTE;
}
entry->instrument = buffer[bufpos++];
if (entry->instrument)
entry->mask |= IT_ENTRY_INSTRUMENT;
}
if (b & 64) {
entry->volpan = buffer[bufpos++];
if (entry->volpan != 255)
entry->mask |= IT_ENTRY_VOLPAN;
}
if (b & 128) {
entry->effect = buffer[bufpos++];
entry->effectvalue = buffer[bufpos++];
if (entry->effect != 255) {
entry->mask |= IT_ENTRY_EFFECT;
if (entry->effect == IT_BREAK_TO_ROW)
entry->effectvalue -= (entry->effectvalue >> 4) * 6;
}
static sigdata_t *sample_load_sigdata(DUH *duh, DUMBFILE *file)
{
SAMPLE_SIGDATA *sigdata;
long size;
long n;
int flags;
(void)duh;
size = dumbfile_igetl(file);
if (dumbfile_error(file) || size <= 0)
return NULL;
flags = dumbfile_getc(file);
if (flags < 0)
return NULL;
sigdata = malloc(sizeof(*sigdata));
if (!sigdata)
return NULL;
sigdata->samples = malloc(size * sizeof(sample_t));
if (!sigdata->samples) {
free(sigdata);
return NULL;
}
sigdata->size = size;
sigdata->flags = flags;
if (sigdata->flags & (SAMPFLAG_LOOP | SAMPFLAG_XLOOP)) {
sigdata->loop_start = dumbfile_igetl(file);
if (dumbfile_error(file) || (unsigned long)sigdata->loop_start >= (unsigned long)size) {
free(sigdata->samples);
free(sigdata);
return NULL;
}
if (sigdata->flags & SAMPFLAG_LOOP)
sigdata->loop_end = size;
else {
sigdata->loop_end = dumbfile_igetl(file);
if (dumbfile_error(file) || sigdata->loop_end <= sigdata->loop_start || sigdata->loop_end > size) {
free(sigdata->samples);
free(sigdata);
return NULL;
}
}
} else {
sigdata->loop_start = 0;
sigdata->loop_end = size;
}
if (sigdata->flags & SAMPFLAG_16BIT) {
for (n = 0; n < size; n++) {
int m = dumbfile_igetw(file);
if (m < 0) {
free(sigdata->samples);
free(sigdata);
return NULL;
}
sigdata->samples[n] = (int)(signed short)m << 8;
}
} else {
for (n = 0; n < size; n++) {
int m = dumbfile_getc(file);
if (m < 0) {
free(sigdata->samples);
free(sigdata);
return NULL;
}
sigdata->samples[n] = (int)(signed char)m << 16;
}
}
return sigdata;
}
