344 lines
11 KiB
C
344 lines
11 KiB
C
/* _______ ____ __ ___ ___
|
|
* \ _ \ \ / \ / \ \ / / ' ' '
|
|
* | | \ \ | | || | \/ | . .
|
|
* | | | | | | || ||\ /| |
|
|
* | | | | | | || || \/ | | ' ' '
|
|
* | | | | | | || || | | . .
|
|
* | |_/ / \ \__// || | |
|
|
* /_______/ynamic \____/niversal /__\ /____\usic /| . . ibliotheque
|
|
* / \
|
|
* / . \
|
|
* readasy.c - Code to read an ASYLUM Music Format / / \ \
|
|
* module from an open file. | < / \_
|
|
* | \/ /\ /
|
|
* By Christopher Snowhill. \_ / > /
|
|
* | \ / /
|
|
* | ' /
|
|
* \__/
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <math.h>
|
|
|
|
#include "dumb.h"
|
|
#include "internal/it.h"
|
|
|
|
static int it_asy_read_pattern(IT_PATTERN *pattern, DUMBFILE *f,
|
|
unsigned char *buffer) {
|
|
int pos;
|
|
int channel;
|
|
int row;
|
|
IT_ENTRY *entry;
|
|
|
|
pattern->n_rows = 64;
|
|
|
|
if (dumbfile_getnc((char *)buffer, 64 * 8 * 4, f) != 64 * 8 * 4)
|
|
return -1;
|
|
|
|
/* compute number of entries */
|
|
pattern->n_entries = 64; /* Account for the row end markers */
|
|
pos = 0;
|
|
for (row = 0; row < 64; ++row) {
|
|
for (channel = 0; channel < 8; ++channel) {
|
|
if (buffer[pos + 0] | buffer[pos + 1] | buffer[pos + 2] |
|
|
buffer[pos + 3])
|
|
++pattern->n_entries;
|
|
pos += 4;
|
|
}
|
|
}
|
|
|
|
pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry));
|
|
if (!pattern->entry)
|
|
return -1;
|
|
|
|
entry = pattern->entry;
|
|
pos = 0;
|
|
for (row = 0; row < 64; ++row) {
|
|
for (channel = 0; channel < 8; ++channel) {
|
|
if (buffer[pos + 0] | buffer[pos + 1] | buffer[pos + 2] |
|
|
buffer[pos + 3]) {
|
|
entry->channel = channel;
|
|
entry->mask = 0;
|
|
|
|
if (buffer[pos + 0] && buffer[pos + 0] < 96) {
|
|
entry->note = buffer[pos + 0];
|
|
entry->mask |= IT_ENTRY_NOTE;
|
|
}
|
|
|
|
if (buffer[pos + 1] && buffer[pos + 1] <= 64) {
|
|
entry->instrument = buffer[pos + 1];
|
|
entry->mask |= IT_ENTRY_INSTRUMENT;
|
|
}
|
|
|
|
_dumb_it_xm_convert_effect(buffer[pos + 2], buffer[pos + 3],
|
|
entry, 1);
|
|
|
|
// fixup
|
|
switch (entry->effect) {
|
|
case IT_SET_PANNING:
|
|
entry->effectvalue <<= 1;
|
|
break;
|
|
}
|
|
|
|
if (entry->mask)
|
|
++entry;
|
|
}
|
|
pos += 4;
|
|
}
|
|
IT_SET_END_ROW(entry);
|
|
++entry;
|
|
}
|
|
|
|
pattern->n_entries = (int)(entry - pattern->entry);
|
|
|
|
return 0;
|
|
}
|
|
|
|
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_asy_read_sample_data(IT_SAMPLE *sample, DUMBFILE *f) {
|
|
long truncated_size;
|
|
|
|
/* let's get rid of the sample data coming after the end of the loop */
|
|
if ((sample->flags & IT_SAMPLE_LOOP) && sample->loop_end < sample->length) {
|
|
truncated_size = sample->length - sample->loop_end;
|
|
sample->length = sample->loop_end;
|
|
} else {
|
|
truncated_size = 0;
|
|
}
|
|
|
|
sample->data = malloc(sample->length);
|
|
|
|
if (!sample->data)
|
|
return -1;
|
|
|
|
if (sample->length)
|
|
dumbfile_getnc(sample->data, sample->length, f);
|
|
|
|
dumbfile_skip(f, truncated_size);
|
|
|
|
return dumbfile_error(f);
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
DUH *dumb_read_asy_quick(DUMBFILE *f) {
|
|
sigdata_t *sigdata;
|
|
|
|
DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it;
|
|
|
|
sigdata = it_asy_load_sigdata(f);
|
|
|
|
if (!sigdata)
|
|
return NULL;
|
|
|
|
{
|
|
const char *tag[2][2];
|
|
tag[0][0] = "TITLE";
|
|
tag[0][1] = (const char *)(((DUMB_IT_SIGDATA *)sigdata)->name);
|
|
tag[1][0] = "FORMAT";
|
|
tag[1][1] = "ASYLUM Music Format";
|
|
return make_duh(-1, 2, (const char *const(*)[2])tag, 1, &descptr,
|
|
&sigdata);
|
|
}
|
|
}
|