ref: ef707958359b91d9cc34a29f4f5328a069a4c1ce
dir: /src/it/readasy.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); } }