/*  _______         ____    __         ___    ___ * \    _  \       \    /  \  /       \   \  /   /       '   '  ' *  |  | \  \       |  |    ||         |   \/   |         .      . *  |  |  |  |      |  |    ||         ||\  /|  | *  |  |  |  |      |  |    ||         || \/ |  |         '  '  ' *  |  |  |  |      |  |    ||         ||    |  |         .      . *  |  |_/  /        \  \__//          ||    |  | * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque *                                                      /  \ *                                                     / .  \ * readstm.c - Code to read a ScreamTracker 2         / / \  \ *             module from an open file.             | <  /   \_ *                                                   |  \/ /\   / * By Christopher Snowhill.                           \_  /  > / *                                                      | \ / / *                                                      |  ' / *                                                       \__/ */ // IT_STEREO... :o#include <stdlib.h>#include <string.h>#include <limits.h> #include "dumb.h"#include "internal/it.h" #ifdef _MSC_VER#define strnicmp _strnicmp#else#if defined(unix) || defined(__unix__) || defined(__unix)#include <strings.h>#endif#define strnicmp strncasecmp#endif static int it_stm_read_sample_header(IT_SAMPLE *sample, DUMBFILE *f,                                     unsigned short *offset) {    dumbfile_getnc((char *)sample->filename, 12, f);    sample->filename[12] = 0;     memcpy(sample->name, sample->filename, 13);     dumbfile_skip(f, 2);     *offset = dumbfile_igetw(f);     sample->length = dumbfile_igetw(f);    sample->loop_start = dumbfile_igetw(f);    sample->loop_end = dumbfile_igetw(f);     sample->default_volume = dumbfile_getc(f);     dumbfile_skip(f, 1);     sample->C5_speed = dumbfile_igetw(f) << 3;     dumbfile_skip(f, 6);     if (sample->length < 4 || !sample->default_volume) {        /* Looks like no-existy. */        sample->flags &= ~IT_SAMPLE_EXISTS;        sample->length = 0;        *offset = 0;        return dumbfile_error(f);    }     sample->flags = IT_SAMPLE_EXISTS;    sample->global_volume = 64;    sample->default_pan = 0; // 0 = don't use, or 160 = centre?     if ((sample->loop_start < sample->length) &&        (sample->loop_end > sample->loop_start) &&        (sample->loop_end != 0xFFFF)) {        sample->flags |= IT_SAMPLE_LOOP;        if (sample->loop_end > sample->length)            sample->loop_end = sample->length;    }     // 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;    sample->finetune = 0;    sample->max_resampling_quality = -1;     return dumbfile_error(f);} static int it_stm_read_sample_data(IT_SAMPLE *sample, DUMBFILE *f) {    if (!sample->length)        return 0;     sample->data = malloc(sample->length);    if (!sample->data)        return -1;     dumbfile_getnc(sample->data, sample->length, f);     return dumbfile_error(f);} static int it_stm_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 * 4 * 4, f) != 64 * 4 * 4)        return -1;     pattern->n_entries = 64;    pos = 0;    for (row = 0; row < 64; ++row) {        for (channel = 0; channel < 4; ++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 < 4; ++channel) {            if (buffer[pos + 0] | buffer[pos + 1] | buffer[pos + 2] |                buffer[pos + 3]) {                unsigned note;                note = buffer[pos + 0];                entry->channel = channel;                entry->mask = 0;                entry->instrument = buffer[pos + 1] >> 3;                entry->volpan =                    (buffer[pos + 1] & 0x07) + (buffer[pos + 2] >> 1);                entry->effect = buffer[pos + 2] & 0x0F;                entry->effectvalue = buffer[pos + 3];                if (entry->instrument && entry->instrument < 32)                    entry->mask |= IT_ENTRY_INSTRUMENT;                if (note < 251) {                    entry->mask |= IT_ENTRY_NOTE;                    entry->note = (note >> 4) * 12 + (note & 0x0F);                }                if (entry->volpan <= 64)                    entry->mask |= IT_ENTRY_VOLPAN;                entry->mask |= IT_ENTRY_EFFECT;                switch (entry->effect) {                case IT_SET_SPEED:                    /* taken care of in the renderer */                    break;                 case IT_BREAK_TO_ROW:                    entry->effectvalue -= (entry->effectvalue >> 4) * 6;                    break;                 case IT_JUMP_TO_ORDER:                case IT_VOLUME_SLIDE:                case IT_PORTAMENTO_DOWN:                case IT_PORTAMENTO_UP:                case IT_TONE_PORTAMENTO:                case IT_VIBRATO:                case IT_TREMOR:                case IT_ARPEGGIO:                case IT_VOLSLIDE_VIBRATO:                case IT_VOLSLIDE_TONEPORTA:                    break;                 default:                    entry->mask &= ~IT_ENTRY_EFFECT;                    break;                }                if (entry->mask)                    ++entry;            }            pos += 4;        }        IT_SET_END_ROW(entry);        ++entry;    }     pattern->n_entries = (int)(entry - pattern->entry);     return 0;} static DUMB_IT_SIGDATA *it_stm_load_sigdata(DUMBFILE *f, int *version) {    DUMB_IT_SIGDATA *sigdata;     char tracker_name[8];     unsigned short sample_offset[31];     int n;     sigdata = malloc(sizeof(*sigdata));    if (!sigdata)        return NULL;     /* Skip song name. */    dumbfile_getnc((char *)sigdata->name, 20, f);    sigdata->name[20] = 0;     dumbfile_getnc(tracker_name, 8, f);    n = dumbfile_getc(f);    if (n != 0x02 && n != 0x1A && n != 0x1B) {        free(sigdata);        return NULL;    }    if (dumbfile_getc(f) != 2) /* only support modules */    {        free(sigdata);        return NULL;    }    if (strnicmp(tracker_name, "!Scream!", 8) &&        strnicmp(tracker_name, "BMOD2STM", 8) &&        strnicmp(tracker_name, "WUZAMOD!", 8)) {        free(sigdata);        return NULL;    }     *version = dumbfile_mgetw(f);     sigdata->song_message = NULL;    sigdata->order = NULL;    sigdata->instrument = NULL;    sigdata->sample = NULL;    sigdata->pattern = NULL;    sigdata->midi = NULL;    sigdata->checkpoint = NULL;     sigdata->n_instruments = 0;    sigdata->n_samples = 31;    sigdata->n_pchannels = 4;     sigdata->tempo = 125;    sigdata->mixing_volume = 48;    sigdata->pan_separation = 128;     /** WARNING: which ones? */    sigdata->flags = IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_WAS_AN_S3M |                     IT_WAS_AN_STM | IT_STEREO;     n = dumbfile_getc(f);    if (n < 32)        n = 32;    sigdata->speed = n;    sigdata->n_patterns = dumbfile_getc(f);    sigdata->global_volume = dumbfile_getc(f) << 1;    if (sigdata->global_volume > 128)        sigdata->global_volume = 128;     dumbfile_skip(f, 13);     if (dumbfile_error(f) || sigdata->n_patterns < 1 ||        sigdata->n_patterns > 99) {        _dumb_it_unload_sigdata(sigdata);        return NULL;    }     sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample));    if (!sigdata->sample) {        _dumb_it_unload_sigdata(sigdata);        return NULL;    }    for (n = 0; n < sigdata->n_samples; n++)        sigdata->sample[n].data = NULL;     if (sigdata->n_patterns) {        sigdata->pattern =            malloc(sigdata->n_patterns * sizeof(*sigdata->pattern));        if (!sigdata->pattern) {            _dumb_it_unload_sigdata(sigdata);            return NULL;        }        for (n = 0; n < sigdata->n_patterns; n++)            sigdata->pattern[n].entry = NULL;    }     memset(sigdata->channel_volume, 64, 4);    n = 32 * dumb_it_default_panning_separation / 100;    sigdata->channel_pan[0] = 32 + n;    sigdata->channel_pan[1] = 32 - n;    sigdata->channel_pan[2] = 32 + n;    sigdata->channel_pan[3] = 32 - n;     for (n = 0; n < sigdata->n_samples; ++n) {        if (it_stm_read_sample_header(&sigdata->sample[n], f,                                      &sample_offset[n])) {            _dumb_it_unload_sigdata(sigdata);            return NULL;        }    }     sigdata->order = malloc(128);    if (!sigdata->order) {        _dumb_it_unload_sigdata(sigdata);        return NULL;    }     /* Orders, byte each, length = sigdata->n_orders (should be even) */    dumbfile_getnc((char *)sigdata->order, *version >= 0x200 ? 128 : 64, f);    if (*version < 0x200)        memset(sigdata->order + 64, 0xFF, 64);    sigdata->restart_position = 0;     for (n = 127; n >= 0; --n) {        if (sigdata->order[n] < sigdata->n_patterns)            break;    }    if (n < 0) {        _dumb_it_unload_sigdata(sigdata);        return NULL;    }    sigdata->n_orders = n + 1;     for (n = 0; n < 128; ++n) {        if (sigdata->order[n] >= 99)            sigdata->order[n] = 0xFF;    }     if (sigdata->n_patterns) {        unsigned char *buffer = malloc(64 * 4 * 4);        if (!buffer) {            _dumb_it_unload_sigdata(sigdata);            return NULL;        }        for (n = 0; n < sigdata->n_patterns; ++n) {            if (it_stm_read_pattern(&sigdata->pattern[n], f, buffer)) {                free(buffer);                _dumb_it_unload_sigdata(sigdata);                return NULL;            }        }        free(buffer);    }     for (n = 0; n < sigdata->n_samples; ++n) {        if (sample_offset[n]) {            if (dumbfile_seek(f, sample_offset[n] * 16, DFS_SEEK_SET) ||                it_stm_read_sample_data(&sigdata->sample[n], f)) {                _dumb_it_unload_sigdata(sigdata);                return NULL;            }        } else {            sigdata->sample[n].flags = 0;            sigdata->sample[n].length = 0;        }    }     if (_dumb_it_fix_invalid_orders(sigdata) < 0) {        _dumb_it_unload_sigdata(sigdata);        return NULL;    }     return sigdata;} DUH *dumb_read_stm_quick(DUMBFILE *f) {    sigdata_t *sigdata;    int ver;     DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it;     sigdata = it_stm_load_sigdata(f, &ver);     if (!sigdata)        return NULL;     {        char version[16];        const char *tag[2][2];        tag[0][0] = "TITLE";        tag[0][1] = (const char *)(((DUMB_IT_SIGDATA *)sigdata)->name);        tag[1][0] = "FORMAT";        version[0] = 'S';        version[1] = 'T';        version[2] = 'M';        version[3] = ' ';        version[4] = 'v';        version[5] = '0' + ((ver >> 8) & 15);        version[6] = '.';        if ((ver & 255) > 99) {            version[7] = '0' + ((ver & 255) / 100);            version[8] = '0' + (((ver & 255) / 10) % 10);            version[9] = '0' + ((ver & 255) % 10);            version[10] = 0;        } else {            version[7] = '0' + ((ver & 255) / 10);            version[8] = '0' + ((ver & 255) % 10);            version[9] = 0;        }        tag[1][1] = version;        return make_duh(-1, 2, (const char *const(*)[2])tag, 1, &descptr,                        &sigdata);    }}