static BOOL GetBlockHeader (void) { /* make sure we're at the right position for reading the next riff block, no matter how many bytes read */ _mm_fseek (modreader, blocklp + blockln, SEEK_SET); while (1) { _mm_read_UBYTES (blockid, 4, modreader); blockln = _mm_read_I_ULONG (modreader); if (_mm_eof (modreader)) { _mm_errno = MMERR_LOADING_HEADER; return 0; } if (memcmp (blockid, SONGID, 4) && memcmp (blockid, INSTID, 4) && memcmp (blockid, PATTID, 4)) { #ifdef MIKMOD_DEBUG fprintf (stderr, "\rDSM: Skipping unknown block type %4.4s\n", blockid); #endif _mm_fseek (modreader, blockln, SEEK_CUR); } else break; } blocklp = _mm_ftell (modreader); return 1; }
long _mm_getfsize(MMSTREAM *mmpat) { long fsize; _mm_fseek(mmpat, 0L, SEEK_END); fsize = _mm_ftell(mmpat); _mm_fseek(mmpat, 0L, SEEK_SET); return(fsize); }
static void pat_read_waveheader(MMSTREAM *mmpat, WaveHeader *hw, int layer) { long int pos, bestpos=0; LayerHeader hl; ULONG bestfreq, freqdist; int i; // read the very first and maybe only sample pat_read_layerheader(mmpat, &hl); if( hl.samples > 1 ) { if( layer ) { if( layer > hl.samples ) layer = hl.samples; // you don't fool me.... for( i=1; i<layer; i++ ) { _mm_read_UBYTES((BYTE *)hw, sizeof(WaveHeader), mmpat); _mm_fseek(mmpat, hw->wave_size, SEEK_CUR); } } else { bestfreq = C4mHz * 1000; // big enough for( i=0; i<hl.samples; i++ ) { pos = _mm_ftell(mmpat); _mm_read_UBYTES((BYTE *)hw, sizeof(WaveHeader), mmpat); if( hw->root_frequency > C4mHz ) freqdist = hw->root_frequency - C4mHz; else freqdist = 2 * (C4mHz - hw->root_frequency); if( freqdist < bestfreq ) { bestfreq = freqdist; bestpos = pos; } _mm_fseek(mmpat, hw->wave_size, SEEK_CUR); } // if invalid bestpos, assume the start. if( bestpos < 0 ) bestpos = 0; _mm_fseek(mmpat, bestpos, SEEK_SET); } } _mm_read_UBYTES((BYTE *)hw, sizeof(WaveHeader), mmpat); strncpy(hw->reserved, hl.reserved, 32); hw->reserved[31] = 0; if( hw->start_loop >= hw->wave_size ) { hw->start_loop = 0; hw->end_loop = 0; hw->modes &= ~PAT_LOOP; // mask off loop indicator } if( hw->end_loop > hw->wave_size ) hw->end_loop = hw->wave_size; }
BOOL GetBlockHeader(void) { /* make sure we're at the right position for reading the */ /* next riff block, no matter how many bytes read */ _mm_fseek(modfp, blocklp+blockln, SEEK_SET); while(1) { _mm_read_UBYTES(blockid,4,modfp); blockln = _mm_read_I_ULONG(modfp); if(_mm_feof(modfp)) { _mm_errno = MMERR_LOADING_HEADER; return 0; } if(memcmp(blockid,SONGID,4) && memcmp(blockid,INSTID,4) && memcmp(blockid,PATTID,4)) { /*printf("Skipping unknown block type %4.4s\n",&blockid); */ _mm_fseek(modfp, blockln, SEEK_CUR); } else break; } blocklp = _mm_ftell(modfp); return 1; }
BOOL FAR_Load (BOOL curious) { int t, u, tracks = 0; SAMPLE *q; FARSAMPLE s; FARNOTE *crow; UBYTE smap[8]; /* try to read module header (first part) */ _mm_read_UBYTES (mh1->id, 4, modreader); _mm_read_SBYTES (mh1->songname, 40, modreader); _mm_read_SBYTES (mh1->blah, 3, modreader); mh1->headerlen = _mm_read_I_UWORD (modreader); mh1->version = _mm_read_UBYTE (modreader); _mm_read_UBYTES (mh1->onoff, 16, modreader); _mm_read_UBYTES (mh1->edit1, 9, modreader); mh1->speed = _mm_read_UBYTE (modreader); _mm_read_UBYTES (mh1->panning, 16, modreader); _mm_read_UBYTES (mh1->edit2, 4, modreader); mh1->stlen = _mm_read_I_UWORD (modreader); /* init modfile data */ of.modtype = strdup (FAR_Version); of.songname = DupStr (mh1->songname, 40, 1); of.numchn = 16; of.initspeed = mh1->speed; of.inittempo = 80; of.reppos = 0; for (t = 0; t < 16; t++) of.panning[t] = mh1->panning[t] << 4; /* read songtext into comment field */ if (mh1->stlen) if (!ReadComment (mh1->stlen)) return 0; /* try to read module header (second part) */ _mm_read_UBYTES (mh2->orders, 256, modreader); mh2->numpat = _mm_read_UBYTE (modreader); mh2->snglen = _mm_read_UBYTE (modreader); mh2->loopto = _mm_read_UBYTE (modreader); _mm_read_I_UWORDS (mh2->patsiz, 256, modreader); of.numpos = mh2->snglen; if (!AllocPositions (of.numpos)) return 0; for (t = 0; t < of.numpos; t++) { if (mh2->orders[t] == 0xff) break; of.positions[t] = mh2->orders[t]; } /* count number of patterns stored in file */ of.numpat = 0; for (t = 0; t < 256; t++) if (mh2->patsiz[t]) if ((t + 1) > of.numpat) of.numpat = t + 1; of.numtrk = of.numpat * of.numchn; /* seek across eventual new data */ _mm_fseek (modreader, mh1->headerlen - (869 + mh1->stlen), SEEK_CUR); /* alloc track and pattern structures */ if (!AllocTracks ()) return 0; if (!AllocPatterns ()) return 0; for (t = 0; t < of.numpat; t++) { UBYTE rows = 0; memset (pat, 0, 256 * 16 * 4 * sizeof (FARNOTE)); if (mh2->patsiz[t]) { rows = _mm_read_UBYTE (modreader); /* tempo = */ _mm_read_UBYTE (modreader); crow = pat; /* file often allocates 64 rows even if there are less in pattern */ if (mh2->patsiz[t] < 2 + (rows * 16 * 4)) { _mm_errno = MMERR_LOADING_PATTERN; return 0; } for (u = (mh2->patsiz[t] - 2) / 4; u; u--, crow++) { crow->note = _mm_read_UBYTE (modreader); crow->ins = _mm_read_UBYTE (modreader); crow->vol = _mm_read_UBYTE (modreader); crow->eff = _mm_read_UBYTE (modreader); } if (_mm_eof (modreader)) { _mm_errno = MMERR_LOADING_PATTERN; return 0; } crow = pat; of.pattrows[t] = rows; for (u = 16; u; u--, crow++) if (!(of.tracks[tracks++] = FAR_ConvertTrack (crow, rows))) { _mm_errno = MMERR_LOADING_PATTERN; return 0; } } else tracks += 16; } /* read sample map */ if (!_mm_read_UBYTES (smap, 8, modreader)) { _mm_errno = MMERR_LOADING_HEADER; return 0; } /* count number of samples used */ of.numins = 0; for (t = 0; t < 64; t++) if (smap[t >> 3] & (1 << (t & 7))) of.numins = t + 1; of.numsmp = of.numins; /* alloc sample structs */ if (!AllocSamples ()) return 0; q = of.samples; for (t = 0; t < of.numsmp; t++) { q->speed = 8363; q->flags = SF_SIGNED; if (smap[t >> 3] & (1 << (t & 7))) { _mm_read_SBYTES (s.samplename, 32, modreader); s.length = _mm_read_I_ULONG (modreader); s.finetune = _mm_read_UBYTE (modreader); s.volume = _mm_read_UBYTE (modreader); s.reppos = _mm_read_I_ULONG (modreader); s.repend = _mm_read_I_ULONG (modreader); s.type = _mm_read_UBYTE (modreader); s.loop = _mm_read_UBYTE (modreader); q->samplename = DupStr (s.samplename, 32, 1); q->length = s.length; q->loopstart = s.reppos; q->loopend = s.repend; q->volume = s.volume << 2; if (s.type & 1) q->flags |= SF_16BITS; if (s.loop & 8) q->flags |= SF_LOOP; q->seekpos = _mm_ftell (modreader); _mm_fseek (modreader, q->length, SEEK_CUR); } else q->samplename = DupStr (NULL, 0, 0); q++; }
BOOL DSM_Load (BOOL curious) { int t; DSMINST s; SAMPLE *q; int cursmp = 0, curpat = 0, track = 0; blocklp = 0; blockln = 12; if (!GetBlockHeader ()) return 0; if (memcmp (blockid, SONGID, 4)) { _mm_errno = MMERR_LOADING_HEADER; return 0; } _mm_read_UBYTES (mh->songname, 28, modreader); mh->version = _mm_read_I_UWORD (modreader); mh->flags = _mm_read_I_UWORD (modreader); mh->reserved2 = _mm_read_I_ULONG (modreader); mh->numord = _mm_read_I_UWORD (modreader); mh->numsmp = _mm_read_I_UWORD (modreader); mh->numpat = _mm_read_I_UWORD (modreader); mh->numtrk = _mm_read_I_UWORD (modreader); mh->globalvol = _mm_read_UBYTE (modreader); mh->mastervol = _mm_read_UBYTE (modreader); mh->speed = _mm_read_UBYTE (modreader); mh->bpm = _mm_read_UBYTE (modreader); _mm_read_UBYTES (mh->panpos, DSM_MAXCHAN, modreader); _mm_read_UBYTES (mh->orders, DSM_MAXORDERS, modreader); /* set module variables */ of.initspeed = mh->speed; of.inittempo = mh->bpm; of.modtype = strdup (DSM_Version); of.numchn = mh->numtrk; of.numpat = mh->numpat; of.numtrk = of.numchn * of.numpat; of.songname = DupStr (mh->songname, 28, 1); /* make a cstr of songname */ of.reppos = 0; for (t = 0; t < DSM_MAXCHAN; t++) of.panning[t] = mh->panpos[t] == DSM_SURROUND ? PAN_SURROUND : mh->panpos[t] < 0x80 ? (mh->panpos[t] << 1) : 255; if (!AllocPositions (mh->numord)) return 0; of.numpos = 0; for (t = 0; t < mh->numord; t++) { of.positions[of.numpos] = mh->orders[t]; if (mh->orders[t] < 254) of.numpos++; } of.numins = of.numsmp = mh->numsmp; if (!AllocSamples ()) return 0; if (!AllocTracks ()) return 0; if (!AllocPatterns ()) return 0; while (cursmp < of.numins || curpat < of.numpat) { if (!GetBlockHeader ()) return 0; if (!memcmp (blockid, INSTID, 4) && cursmp < of.numins) { q = &of.samples[cursmp]; /* try to read sample info */ _mm_read_UBYTES (s.filename, 13, modreader); s.flags = _mm_read_I_UWORD (modreader); s.volume = _mm_read_UBYTE (modreader); s.length = _mm_read_I_ULONG (modreader); s.loopstart = _mm_read_I_ULONG (modreader); s.loopend = _mm_read_I_ULONG (modreader); s.reserved1 = _mm_read_I_ULONG (modreader); s.c2spd = _mm_read_I_UWORD (modreader); s.period = _mm_read_I_UWORD (modreader); _mm_read_UBYTES (s.samplename, 28, modreader); q->samplename = DupStr (s.samplename, 28, 1); q->seekpos = _mm_ftell (modreader); q->speed = s.c2spd; q->length = s.length; q->loopstart = s.loopstart; q->loopend = s.loopend; q->volume = s.volume; if (s.flags & 1) q->flags |= SF_LOOP; if (s.flags & 2) q->flags |= SF_SIGNED; /* (s.flags&4) means packed sample, but did they really exist in dsm ? */ cursmp++; } else if (!memcmp (blockid, PATTID, 4) && curpat < of.numpat) { DSM_ReadPattern (); for (t = 0; t < of.numchn; t++) if (!(of.tracks[track++] = DSM_ConvertTrack (&dsmbuf[t * 64]))) return 0; curpat++; } } return 1; }
BOOL OKT_Load(BOOL curious) { UBYTE id[4]; ULONG len; ULONG fp; BOOL seen_cmod = 0, seen_samp = 0, seen_slen = 0, seen_plen = 0, seen_patt = 0, seen_spee = 0; int patnum = 0, insnum = 0; /* skip OKTALYZER header */ _mm_fseek(modreader, 8, SEEK_SET); of.songname = strdup(""); of.modtype = strdup("Amiga Oktalyzer"); of.numpos = of.reppos = 0; /* default values */ of.initspeed = 6; of.inittempo = 125; while (1) { /* read block header */ _mm_read_UBYTES(id, 4, modreader); len = _mm_read_M_ULONG(modreader); if (_mm_eof(modreader)) break; fp = _mm_ftell(modreader); if (!memcmp(id, "CMOD", 4)) { if (!seen_cmod) { OKT_doCMOD(); seen_cmod = 1; } else { _mm_errno = MMERR_LOADING_HEADER; return 0; } } else if (!memcmp(id, "SAMP", 4)) { if (!seen_samp && OKT_doSAMP(len)) seen_samp = 1; else { _mm_errno = MMERR_LOADING_HEADER; return 0; } } else if (!memcmp(id, "SPEE", 4)) { if (!seen_spee) { OKT_doSPEE(); seen_spee = 1; } else { _mm_errno = MMERR_LOADING_HEADER; return 0; } } else if (!memcmp(id, "SLEN", 4)) { if (!seen_slen) { OKT_doSLEN(); seen_slen = 1; } else { _mm_errno = MMERR_LOADING_HEADER; return 0; } } else if (!memcmp(id, "PLEN", 4)) { if (!seen_plen) { OKT_doPLEN(); seen_plen = 1; } else { _mm_errno = MMERR_LOADING_HEADER; return 0; } } else if (!memcmp(id, "PATT", 4)) { if (!seen_plen) { _mm_errno = MMERR_LOADING_HEADER; return 0; } if (!seen_patt && OKT_doPATT()) seen_patt = 1; else { _mm_errno = MMERR_LOADING_HEADER; return 0; } } else if (!memcmp(id,"PBOD", 4)) { /* need to know numpat and numchn */ if (!seen_slen || !seen_cmod || (patnum >= of.numpat)) { _mm_errno = MMERR_LOADING_HEADER; return 0; } if (!OKT_doPBOD(patnum++)) { _mm_errno = MMERR_LOADING_PATTERN; return 0; } } else if (!memcmp(id,"SBOD",4)) { /* need to know numsmp */ if (!seen_samp) { _mm_errno = MMERR_LOADING_HEADER; return 0; } while ((insnum < of.numins) && !of.samples[insnum].length) insnum++; if (insnum >= of.numins) { _mm_errno = MMERR_LOADING_HEADER; return 0; } OKT_doSBOD(insnum++); } /* goto next block start position */ _mm_fseek(modreader, fp + len, SEEK_SET); } if (!seen_cmod || !seen_samp || !seen_patt || !seen_slen || !seen_plen || (patnum != of.numpat)) { _mm_errno = MMERR_LOADING_HEADER; return 0; } return 1; }
static void OKT_doSBOD(int insnum) { of.samples[insnum].seekpos = _mm_ftell(modreader); }