bool module_renderer::ReadXM(const uint8_t *lpStream, const uint32_t dwMemLength) //-------------------------------------------------------------------- { XMFILEHEADER xmheader; XMSAMPLEHEADER xmsh; XMSAMPLESTRUCT xmss; uint32_t dwMemPos; bool bMadeWithModPlug = false, bProbablyMadeWithModPlug = false, bProbablyMPT109 = false, bIsFT2 = false; m_nChannels = 0; if ((!lpStream) || (dwMemLength < 0xAA)) return false; // the smallest XM I know is 174 Bytes if (_strnicmp((LPCSTR)lpStream, "Extended Module", 15)) return false; // look for null-terminated song name - that's most likely a tune made with modplug for(int i = 0; i < 20; i++) if(lpStream[17 + i] == 0) bProbablyMadeWithModPlug = true; assign_without_padding(this->song_name, reinterpret_cast<const char *>(lpStream + 17), 20); // load and convert header memcpy(&xmheader, lpStream + 58, sizeof(XMFILEHEADER)); xmheader.size = LittleEndian(xmheader.size); xmheader.xmversion = LittleEndianW(xmheader.xmversion); xmheader.orders = LittleEndianW(xmheader.orders); xmheader.restartpos = LittleEndianW(xmheader.restartpos); xmheader.channels = LittleEndianW(xmheader.channels); xmheader.patterns = LittleEndianW(xmheader.patterns); xmheader.instruments = LittleEndianW(xmheader.instruments); xmheader.flags = LittleEndianW(xmheader.flags); xmheader.speed = LittleEndianW(xmheader.speed); xmheader.tempo = LittleEndianW(xmheader.tempo); m_nType = MOD_TYPE_XM; m_nMinPeriod = 27; m_nMaxPeriod = 54784; if (xmheader.orders > MAX_ORDERS) return false; if ((!xmheader.channels) || (xmheader.channels > MAX_BASECHANNELS)) return false; if (xmheader.channels > 32) bMadeWithModPlug = true; m_nRestartPos = xmheader.restartpos; m_nChannels = xmheader.channels; m_nInstruments = bad_min(xmheader.instruments, MAX_INSTRUMENTS - 1); m_nSamples = 0; m_nDefaultSpeed = CLAMP(xmheader.speed, 1, 31); m_nDefaultTempo = CLAMP(xmheader.tempo, 32, 512); if(xmheader.flags & 1) m_dwSongFlags |= SONG_LINEARSLIDES; if(xmheader.flags & 0x1000) m_dwSongFlags |= SONG_EXFILTERRANGE; Order.ReadAsByte(lpStream + 80, xmheader.orders, dwMemLength - 80); dwMemPos = xmheader.size + 60; // set this here already because XMs compressed with BoobieSqueezer will exit the function early SetModFlag(MSF_COMPATIBLE_PLAY, true); if(xmheader.xmversion >= 0x0104) { if (dwMemPos + 8 >= dwMemLength) return true; dwMemPos = ReadXMPatterns(lpStream, dwMemLength, dwMemPos, &xmheader, this); if(dwMemPos == 0) return true; } vector<bool> samples_used; // for removing unused samples modplug::tracker::sampleindex_t unused_samples = 0; // dito // Reading instruments for (modplug::tracker::instrumentindex_t iIns = 1; iIns <= m_nInstruments; iIns++) { XMINSTRUMENTHEADER pih; uint8_t flags[32]; uint32_t samplesize[32]; UINT samplemap[32]; uint16_t nsamples; if (dwMemPos + sizeof(uint32_t) >= dwMemLength) return true; uint32_t ihsize = LittleEndian(*((uint32_t *)(lpStream + dwMemPos))); if (dwMemPos + ihsize > dwMemLength) return true; MemsetZero(pih); memcpy(&pih, lpStream + dwMemPos, bad_min(sizeof(pih), ihsize)); if ((Instruments[iIns] = new modinstrument_t) == nullptr) continue; memcpy(Instruments[iIns], &m_defaultInstrument, sizeof(modinstrument_t)); Instruments[iIns]->nPluginVelocityHandling = PLUGIN_VELOCITYHANDLING_CHANNEL; Instruments[iIns]->nPluginVolumeHandling = PLUGIN_VOLUMEHANDLING_IGNORE; memcpy(Instruments[iIns]->name, pih.name, 22); SpaceToNullStringFixed<22>(Instruments[iIns]->name); memset(&xmsh, 0, sizeof(XMSAMPLEHEADER)); if ((nsamples = pih.samples) > 0) { /* we have samples, so let's read the rest of this instrument the header that is being read here is not the sample header, though, it's rather the instrument settings. */ if (dwMemPos + ihsize >= dwMemLength) return true; memcpy(&xmsh, lpStream + dwMemPos + sizeof(XMINSTRUMENTHEADER), bad_min(ihsize - sizeof(XMINSTRUMENTHEADER), sizeof(XMSAMPLEHEADER))); xmsh.shsize = LittleEndian(xmsh.shsize); if(xmsh.shsize == 0 && bProbablyMadeWithModPlug) bMadeWithModPlug = true; for (int i = 0; i < 24; ++i) { xmsh.venv[i] = LittleEndianW(xmsh.venv[i]); xmsh.penv[i] = LittleEndianW(xmsh.penv[i]); } xmsh.volfade = LittleEndianW(xmsh.volfade); xmsh.midiprogram = LittleEndianW(xmsh.midiprogram); xmsh.pitchwheelrange = LittleEndianW(xmsh.pitchwheelrange); if(xmsh.midichannel != 0 || xmsh.midienabled != 0 || xmsh.midiprogram != 0 || xmsh.mutecomputer != 0 || xmsh.pitchwheelrange != 0) bIsFT2 = true; // definitely not MPT. (or any other tracker) } if (LittleEndian(pih.size)) dwMemPos += LittleEndian(pih.size); else dwMemPos += sizeof(XMINSTRUMENTHEADER); memset(samplemap, 0, sizeof(samplemap)); if (nsamples > 32) return true; UINT newsamples = m_nSamples; for (UINT nmap = 0; nmap < nsamples; nmap++) { UINT n = m_nSamples + nmap + 1; if (n >= MAX_SAMPLES) { n = m_nSamples; while (n > 0) { if (!Samples[n].sample_data) { for (UINT xmapchk=0; xmapchk < nmap; xmapchk++) { if (samplemap[xmapchk] == n) goto alreadymapped; } for (UINT clrs=1; clrs<iIns; clrs++) if (Instruments[clrs]) { modinstrument_t *pks = Instruments[clrs]; for (UINT ks=0; ks<128; ks++) { if (pks->Keyboard[ks] == n) pks->Keyboard[ks] = 0; } } break; } alreadymapped: n--; } #ifndef FASTSOUNDLIB // Damn! Too many samples: look for duplicates if (!n) { if (!unused_samples) { unused_samples = DetectUnusedSamples(samples_used); if (!unused_samples) unused_samples = modplug::tracker::SampleIndexInvalid; } if ((unused_samples) && (unused_samples != modplug::tracker::SampleIndexInvalid)) { for (UINT iext=m_nSamples; iext>=1; iext--) if (!samples_used[iext]) { unused_samples--; samples_used[iext] = true; DestroySample(iext); n = iext; for (UINT mapchk=0; mapchk<nmap; mapchk++) { if (samplemap[mapchk] == n) samplemap[mapchk] = 0; } for (UINT clrs=1; clrs<iIns; clrs++) if (Instruments[clrs]) { modinstrument_t *pks = Instruments[clrs]; for (UINT ks=0; ks<128; ks++) { if (pks->Keyboard[ks] == n) pks->Keyboard[ks] = 0; } } MemsetZero(Samples[n]); break; } } } #endif // FASTSOUNDLIB } if (newsamples < n) newsamples = n; samplemap[nmap] = n; } m_nSamples = newsamples; // Reading Volume Envelope modinstrument_t *pIns = Instruments[iIns]; pIns->midi_program = pih.type; pIns->fadeout = xmsh.volfade; pIns->default_pan = 128; pIns->pitch_pan_center = 5*12; SetDefaultInstrumentValues(pIns); pIns->nPluginVelocityHandling = PLUGIN_VELOCITYHANDLING_CHANNEL; pIns->nPluginVolumeHandling = PLUGIN_VOLUMEHANDLING_IGNORE; if (xmsh.vtype & 1) pIns->volume_envelope.flags |= ENV_ENABLED; if (xmsh.vtype & 2) pIns->volume_envelope.flags |= ENV_SUSTAIN; if (xmsh.vtype & 4) pIns->volume_envelope.flags |= ENV_LOOP; if (xmsh.ptype & 1) pIns->panning_envelope.flags |= ENV_ENABLED; if (xmsh.ptype & 2) pIns->panning_envelope.flags |= ENV_SUSTAIN; if (xmsh.ptype & 4) pIns->panning_envelope.flags |= ENV_LOOP; if (xmsh.vnum > 12) xmsh.vnum = 12; if (xmsh.pnum > 12) xmsh.pnum = 12; pIns->volume_envelope.num_nodes = xmsh.vnum; if (!xmsh.vnum) pIns->volume_envelope.flags &= ~ENV_ENABLED; if (!xmsh.pnum) pIns->panning_envelope.flags &= ~ENV_ENABLED; pIns->panning_envelope.num_nodes = xmsh.pnum; pIns->volume_envelope.sustain_start = pIns->volume_envelope.sustain_end = xmsh.vsustain; if (xmsh.vsustain >= 12) pIns->volume_envelope.flags &= ~ENV_SUSTAIN; pIns->volume_envelope.loop_start = xmsh.vloops; pIns->volume_envelope.loop_end = xmsh.vloope; if (pIns->volume_envelope.loop_end >= 12) pIns->volume_envelope.loop_end = 0; if (pIns->volume_envelope.loop_start >= pIns->volume_envelope.loop_end) pIns->volume_envelope.flags &= ~ENV_LOOP; pIns->panning_envelope.sustain_start = pIns->panning_envelope.sustain_end = xmsh.psustain; if (xmsh.psustain >= 12) pIns->panning_envelope.flags &= ~ENV_SUSTAIN; pIns->panning_envelope.loop_start = xmsh.ploops; pIns->panning_envelope.loop_end = xmsh.ploope; if (pIns->panning_envelope.loop_end >= 12) pIns->panning_envelope.loop_end = 0; if (pIns->panning_envelope.loop_start >= pIns->panning_envelope.loop_end) pIns->panning_envelope.flags &= ~ENV_LOOP; pIns->global_volume = 64; for (UINT ienv=0; ienv<12; ienv++) { pIns->volume_envelope.Ticks[ienv] = (uint16_t)xmsh.venv[ienv*2]; pIns->volume_envelope.Values[ienv] = (uint8_t)xmsh.venv[ienv*2+1]; pIns->panning_envelope.Ticks[ienv] = (uint16_t)xmsh.penv[ienv*2]; pIns->panning_envelope.Values[ienv] = (uint8_t)xmsh.penv[ienv*2+1]; if (ienv) { if (pIns->volume_envelope.Ticks[ienv] < pIns->volume_envelope.Ticks[ienv-1]) { pIns->volume_envelope.Ticks[ienv] &= 0xFF; pIns->volume_envelope.Ticks[ienv] += pIns->volume_envelope.Ticks[ienv-1] & 0xFF00; if (pIns->volume_envelope.Ticks[ienv] < pIns->volume_envelope.Ticks[ienv-1]) pIns->volume_envelope.Ticks[ienv] += 0x100; } if (pIns->panning_envelope.Ticks[ienv] < pIns->panning_envelope.Ticks[ienv-1]) { pIns->panning_envelope.Ticks[ienv] &= 0xFF; pIns->panning_envelope.Ticks[ienv] += pIns->panning_envelope.Ticks[ienv-1] & 0xFF00; if (pIns->panning_envelope.Ticks[ienv] < pIns->panning_envelope.Ticks[ienv-1]) pIns->panning_envelope.Ticks[ienv] += 0x100; } } } for (UINT j=0; j<96; j++) { pIns->NoteMap[j+12] = j+1+12; if (xmsh.snum[j] < nsamples) pIns->Keyboard[j+12] = samplemap[xmsh.snum[j]]; } // Reading samples for (UINT ins=0; ins<nsamples; ins++) { if ((dwMemPos + sizeof(xmss) > dwMemLength) || (dwMemPos + xmsh.shsize > dwMemLength)) return true; memcpy(&xmss, lpStream + dwMemPos, sizeof(xmss)); xmss.samplen = LittleEndian(xmss.samplen); xmss.loopstart = LittleEndian(xmss.loopstart); xmss.looplen = LittleEndian(xmss.looplen); dwMemPos += sizeof(XMSAMPLESTRUCT); // was: dwMemPos += xmsh.shsize; (this fixes IFULOVE.XM) flags[ins] = (xmss.type & 0x10) ? RS_PCM16D : RS_PCM8D; if (xmss.type & 0x20) flags[ins] = (xmss.type & 0x10) ? RS_STPCM16D : RS_STPCM8D; samplesize[ins] = xmss.samplen; if (!samplemap[ins]) continue; if (xmss.type & 0x10) { xmss.looplen >>= 1; xmss.loopstart >>= 1; xmss.samplen >>= 1; } if (xmss.type & 0x20) { xmss.looplen >>= 1; xmss.loopstart >>= 1; xmss.samplen >>= 1; } if (xmss.samplen > MAX_SAMPLE_LENGTH) xmss.samplen = MAX_SAMPLE_LENGTH; if (xmss.loopstart >= xmss.samplen) xmss.type &= ~3; xmss.looplen += xmss.loopstart; if (xmss.looplen > xmss.samplen) xmss.looplen = xmss.samplen; if (!xmss.looplen) xmss.type &= ~3; UINT imapsmp = samplemap[ins]; memcpy(m_szNames[imapsmp], xmss.name, 22); SpaceToNullStringFixed<22>(m_szNames[imapsmp]); modsample_t *pSmp = &Samples[imapsmp]; pSmp->length = (xmss.samplen > MAX_SAMPLE_LENGTH) ? MAX_SAMPLE_LENGTH : xmss.samplen; pSmp->loop_start = xmss.loopstart; pSmp->loop_end = xmss.looplen; if (pSmp->loop_end > pSmp->length) pSmp->loop_end = pSmp->length; if (pSmp->loop_start >= pSmp->loop_end) { pSmp->loop_start = pSmp->loop_end = 0; } if (xmss.type & 3) pSmp->flags |= CHN_LOOP; if (xmss.type & 2) pSmp->flags |= CHN_PINGPONGLOOP; pSmp->default_volume = xmss.vol << 2; if (pSmp->default_volume > 256) pSmp->default_volume = 256; pSmp->global_volume = 64; if ((xmss.res == 0xAD) && (!(xmss.type & 0x30))) { flags[ins] = RS_ADPCM4; samplesize[ins] = (samplesize[ins]+1)/2 + 16; } pSmp->nFineTune = xmss.finetune; pSmp->RelativeTone = (int)xmss.relnote; pSmp->default_pan = xmss.pan; pSmp->flags |= CHN_PANNING; pSmp->vibrato_type = xmsh.vibtype; pSmp->vibrato_sweep = xmsh.vibsweep; pSmp->vibrato_depth = xmsh.vibdepth; pSmp->vibrato_rate = xmsh.vibrate; memcpy(pSmp->legacy_filename, xmss.name, 22); SpaceToNullStringFixed<21>(pSmp->legacy_filename); if ((xmss.type & 3) == 3) // MPT 1.09 and maybe newer / older versions set both flags for bidi loops bProbablyMPT109 = true; }
bool module_renderer::ReadITProject(const uint8_t * lpStream, const uint32_t dwMemLength) //----------------------------------------------------------------------- { UINT i,n,nsmp; uint32_t id,len,size; uint32_t dwMemPos = 0; uint32_t version; ASSERT_CAN_READ(12); // Check file ID memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); if(id != ITP_FILE_ID) return false; dwMemPos += sizeof(uint32_t); memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); version = id; dwMemPos += sizeof(uint32_t); // bad_max supported version if(version > ITP_VERSION) { return false; } m_nType = MOD_TYPE_IT; // Song name // name string length memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); len = id; dwMemPos += sizeof(uint32_t); // name string ASSERT_CAN_READ(len); if (len <= MAX_SAMPLENAME) { assign_without_padding(this->song_name, reinterpret_cast<const char *>(lpStream + dwMemPos), len); dwMemPos += len; } else return false; // Song comments // comment string length ASSERT_CAN_READ(4); memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); dwMemPos += sizeof(uint32_t); if(id > UINT16_MAX) return false; // allocate and copy comment string ASSERT_CAN_READ(id); if(id > 0) { ReadMessage(lpStream + dwMemPos, id - 1, leCR); } dwMemPos += id; // Song global config ASSERT_CAN_READ(5*4); // m_dwSongFlags memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); m_dwSongFlags = (id & SONG_FILE_FLAGS); dwMemPos += sizeof(uint32_t); if(!(m_dwSongFlags & SONG_ITPROJECT)) return false; // m_nDefaultGlobalVolume memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); m_nDefaultGlobalVolume = id; dwMemPos += sizeof(uint32_t); // m_nSamplePreAmp memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); m_nSamplePreAmp = id; dwMemPos += sizeof(uint32_t); // m_nDefaultSpeed memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); m_nDefaultSpeed = id; dwMemPos += sizeof(uint32_t); // m_nDefaultTempo memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); m_nDefaultTempo = id; dwMemPos += sizeof(uint32_t); // Song channels data ASSERT_CAN_READ(2*4); // m_nChannels memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); m_nChannels = (modplug::tracker::chnindex_t)id; dwMemPos += sizeof(uint32_t); if(m_nChannels > 127) return false; // channel name string length (=MAX_CHANNELNAME) memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); len = id; dwMemPos += sizeof(uint32_t); if(len > MAX_CHANNELNAME) return false; // Channels' data for(i=0; i<m_nChannels; i++){ ASSERT_CAN_READ(3*4 + len); // ChnSettings[i].nPan memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); ChnSettings[i].nPan = id; dwMemPos += sizeof(uint32_t); // ChnSettings[i].dwFlags memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); ChnSettings[i].dwFlags = id; dwMemPos += sizeof(uint32_t); // ChnSettings[i].nVolume memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); ChnSettings[i].nVolume = id; dwMemPos += sizeof(uint32_t); // ChnSettings[i].szName memcpy(&ChnSettings[i].szName[0],lpStream+dwMemPos,len); SetNullTerminator(ChnSettings[i].szName); dwMemPos += len; } // Song mix plugins // size of mix plugins data ASSERT_CAN_READ(4); memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); dwMemPos += sizeof(uint32_t); // mix plugins ASSERT_CAN_READ(id); dwMemPos += LoadMixPlugins(lpStream+dwMemPos, id); // Song midi config // midi cfg data length ASSERT_CAN_READ(4); memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); dwMemPos += sizeof(uint32_t); // midi cfg ASSERT_CAN_READ(id); if (id <= sizeof(m_MidiCfg)) { memcpy(&m_MidiCfg, lpStream + dwMemPos, id); SanitizeMacros(); dwMemPos += id; } // Song Instruments // m_nInstruments ASSERT_CAN_READ(4); memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); m_nInstruments = (modplug::tracker::instrumentindex_t)id; if(m_nInstruments > MAX_INSTRUMENTS) return false; dwMemPos += sizeof(uint32_t); // path string length (=_MAX_PATH) ASSERT_CAN_READ(4); memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); len = id; if(len > _MAX_PATH) return false; dwMemPos += sizeof(uint32_t); // instruments' paths for(i=0; i<m_nInstruments; i++){ ASSERT_CAN_READ(len); memcpy(&m_szInstrumentPath[i][0],lpStream+dwMemPos,len); SetNullTerminator(m_szInstrumentPath[i]); dwMemPos += len; } // Song Orders // size of order array (=MAX_ORDERS) ASSERT_CAN_READ(4); memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); size = id; if(size > MAX_ORDERS) return false; dwMemPos += sizeof(uint32_t); // order data ASSERT_CAN_READ(size); Order.ReadAsByte(lpStream+dwMemPos, size, dwMemLength-dwMemPos); dwMemPos += size; // Song Patterns ASSERT_CAN_READ(3*4); // number of patterns (=MAX_PATTERNS) memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); size = id; dwMemPos += sizeof(uint32_t); if(size > MAX_PATTERNS) return false; // m_nPatternNames memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); const modplug::tracker::patternindex_t numNamedPats = id; dwMemPos += sizeof(uint32_t); // pattern name string length (=MAX_PATTERNNAME) memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); const uint32_t patNameLen = id; dwMemPos += sizeof(uint32_t); // m_lpszPatternNames ASSERT_CAN_READ(numNamedPats * patNameLen); char *patNames = (char *)(lpStream + dwMemPos); dwMemPos += numNamedPats * patNameLen; // modcommand data length ASSERT_CAN_READ(4); memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); n = id; if(n != 6) return false; dwMemPos += sizeof(uint32_t); for(modplug::tracker::patternindex_t npat=0; npat<size; npat++) { // Patterns[npat].GetNumRows() ASSERT_CAN_READ(4); memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); if(id > MAX_PATTERN_ROWS) return false; const modplug::tracker::rowindex_t nRows = id; dwMemPos += sizeof(uint32_t); // Try to allocate & read only sized patterns if(nRows) { // Allocate pattern if(Patterns.Insert(npat, nRows)) { dwMemPos += m_nChannels * Patterns[npat].GetNumRows() * n; continue; } if(npat < numNamedPats && patNameLen > 0) { Patterns[npat].SetName(patNames, patNameLen); patNames += patNameLen; } // Pattern data long datasize = m_nChannels * Patterns[npat].GetNumRows() * n; //if (streamPos+datasize<=dwMemLength) { if(Patterns[npat].ReadITPdata(lpStream, dwMemPos, datasize, dwMemLength)) { ErrorBox(IDS_ERR_FILEOPEN, NULL); return false; } //memcpy(Patterns[npat],lpStream+streamPos,datasize); //streamPos += datasize; //} } } // Load embeded samples ITSAMPLESTRUCT pis; // Read original number of samples ASSERT_CAN_READ(4); memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); if(id > MAX_SAMPLES) return false; m_nSamples = (modplug::tracker::sampleindex_t)id; dwMemPos += sizeof(uint32_t); // Read number of embeded samples ASSERT_CAN_READ(4); memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); if(id > MAX_SAMPLES) return false; n = id; dwMemPos += sizeof(uint32_t); // Read samples for(i=0; i<n; i++){ ASSERT_CAN_READ(4 + sizeof(ITSAMPLESTRUCT) + 4); // Sample id number memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); nsmp = id; dwMemPos += sizeof(uint32_t); if(nsmp < 1 || nsmp >= MAX_SAMPLES) return false; // Sample struct memcpy(&pis,lpStream+dwMemPos,sizeof(ITSAMPLESTRUCT)); dwMemPos += sizeof(ITSAMPLESTRUCT); // Sample length memcpy(&id,lpStream+dwMemPos,sizeof(uint32_t)); len = id; dwMemPos += sizeof(uint32_t); if(dwMemPos >= dwMemLength || len > dwMemLength - dwMemPos) return false; // Copy sample struct data (ut-oh... this code looks very familiar!) if(pis.id == LittleEndian(IT_IMPS)) { modsample_t *pSmp = &Samples[nsmp]; memcpy(pSmp->legacy_filename, pis.filename, 12); pSmp->flags = 0; pSmp->length = 0; pSmp->loop_start = pis.loopbegin; pSmp->loop_end = pis.loopend; pSmp->sustain_start = pis.susloopbegin; pSmp->sustain_end = pis.susloopend; pSmp->c5_samplerate = pis.C5Speed; if(!pSmp->c5_samplerate) pSmp->c5_samplerate = 8363; if(pis.C5Speed < 256) pSmp->c5_samplerate = 256; pSmp->default_volume = pis.vol << 2; if(pSmp->default_volume > 256) pSmp->default_volume = 256; pSmp->global_volume = pis.gvl; if(pSmp->global_volume > 64) pSmp->global_volume = 64; if(pis.flags & 0x10) pSmp->flags |= CHN_LOOP; if(pis.flags & 0x20) pSmp->flags |= CHN_SUSTAINLOOP; if(pis.flags & 0x40) pSmp->flags |= CHN_PINGPONGLOOP; if(pis.flags & 0x80) pSmp->flags |= CHN_PINGPONGSUSTAIN; pSmp->default_pan = (pis.dfp & 0x7F) << 2; if(pSmp->default_pan > 256) pSmp->default_pan = 256; if(pis.dfp & 0x80) pSmp->flags |= CHN_PANNING; pSmp->vibrato_type = autovibit2xm[pis.vit & 7]; pSmp->vibrato_rate = pis.vis; pSmp->vibrato_depth = pis.vid & 0x7F; pSmp->vibrato_sweep = pis.vir; if(pis.length){ pSmp->length = pis.length; if (pSmp->length > MAX_SAMPLE_LENGTH) pSmp->length = MAX_SAMPLE_LENGTH; UINT flags = (pis.cvt & 1) ? RS_PCM8S : RS_PCM8U; if (pis.flags & 2){ flags += 5; if (pis.flags & 4) flags |= RSF_STEREO; pSmp->flags |= CHN_16BIT; } else{ if (pis.flags & 4) flags |= RSF_STEREO; } // Read sample data ReadSample(&Samples[nsmp], flags, (LPSTR)(lpStream+dwMemPos), len); dwMemPos += len; memcpy(m_szNames[nsmp], pis.name, 26); } } } // Load instruments CMappedFile f; LPBYTE lpFile; for(modplug::tracker::instrumentindex_t i = 0; i < m_nInstruments; i++) { if(m_szInstrumentPath[i][0] == '\0' || !f.Open(m_szInstrumentPath[i])) continue; len = f.GetLength(); lpFile = f.Lock(len); if(!lpFile) { f.Close(); continue; } ReadInstrumentFromFile(i+1, lpFile, len); f.Unlock(); f.Close(); } // Extra info data __int32 fcode = 0; const uint8_t * ptr = lpStream + bad_min(dwMemPos, dwMemLength); if (dwMemPos <= dwMemLength - 4) { fcode = (*((__int32 *)ptr)); } // Embed instruments' header [v1.01] if(version >= 0x00000101 && m_dwSongFlags & SONG_ITPEMBEDIH && fcode == 'EBIH') { // jump embeded instrument header tag ptr += sizeof(__int32); // set first instrument's header as current i = 1; // parse file while( uintptr_t(ptr - lpStream) <= dwMemLength - 4 && i <= m_nInstruments ) { fcode = (*((__int32 *)ptr)); // read field code switch( fcode ) { case 'MPTS': goto mpts; //:) // reached end of instrument headers case 'SEP@': case 'MPTX': ptr += sizeof(__int32); // jump code i++; // switch to next instrument break; default: ptr += sizeof(__int32); // jump field code ReadExtendedInstrumentProperty(Instruments[i], fcode, ptr, lpStream + dwMemLength); break; } } } //HACK: if we fail on i <= m_nInstruments above, arrive here without having set fcode as appropriate, // hence the code duplication. if ( (uintptr_t)(ptr - lpStream) <= dwMemLength - 4 ) { fcode = (*((__int32 *)ptr)); } // Song extensions mpts: if( fcode == 'MPTS' ) LoadExtendedSongProperties(MOD_TYPE_IT, ptr, lpStream, dwMemLength); m_nMaxPeriod = 0xF000; m_nMinPeriod = 8; if(m_dwLastSavedWithVersion < MAKE_VERSION_NUMERIC(1, 17, 2, 50)) { SetModFlag(MSF_COMPATIBLE_PLAY, false); SetModFlag(MSF_MIDICC_BUGEMULATION, true); SetModFlag(MSF_OLDVOLSWING, true); } return true; }
bool CSoundFile::ReadITQ(FileReader &file, ModLoadingFlags loadFlags) //------------------------------------------------------------------ { file.Rewind(); ITFileHeader fileHeader; if(!file.ReadConvertEndianness(fileHeader) || (memcmp(fileHeader.id, "ITQM", 4)) || fileHeader.insnum > 0xFF || fileHeader.smpnum >= MAX_SAMPLES || !file.CanRead(fileHeader.ordnum + (fileHeader.insnum + fileHeader.smpnum + fileHeader.patnum) * 4)) { return false; } else if(loadFlags == onlyVerifyHeader) { return true; } InitializeGlobals(); bool interpretModPlugMade = false; // OpenMPT crap at the end of file file.Seek(file.GetLength() - 4); size_t mptStartPos = file.ReadUint32LE(); if(mptStartPos >= file.GetLength() || mptStartPos < 0x100) { mptStartPos = file.GetLength(); } if(!memcmp(fileHeader.id, "tpm.", 4)) { // Legacy MPTM files (old 1.17.02.xx releases) ChangeModTypeTo(MOD_TYPE_MPT); } else { if(mptStartPos <= file.GetLength() - 3 && fileHeader.cwtv > 0x888 && fileHeader.cwtv <= 0xFFF) { file.Seek(mptStartPos); ChangeModTypeTo(file.ReadMagic("228") ? MOD_TYPE_MPT : MOD_TYPE_IT); } else { ChangeModTypeTo(MOD_TYPE_IT); } if(GetType() == MOD_TYPE_IT) { // Which tracker was used to made this? if((fileHeader.cwtv & 0xF000) == 0x5000) { // OpenMPT Version number (Major.Minor) // This will only be interpreted as "made with ModPlug" (i.e. disable compatible playback etc) if the "reserved" field is set to "OMPT" - else, compatibility was used. m_dwLastSavedWithVersion = (fileHeader.cwtv & 0x0FFF) << 16; if(!memcmp(fileHeader.reserved, "OMPT", 4)) interpretModPlugMade = true; } else if(fileHeader.cmwt == 0x888 || fileHeader.cwtv == 0x888) { // OpenMPT 1.17 and 1.18 (raped IT format) // Exact version number will be determined later. interpretModPlugMade = true; } else if(fileHeader.cwtv == 0x0217 && fileHeader.cmwt == 0x0200 && !memcmp(fileHeader.reserved, "\0\0\0\0", 4)) { if(memchr(fileHeader.chnpan, 0xFF, sizeof(fileHeader.chnpan)) != NULL) { // ModPlug Tracker 1.16 (semi-raped IT format) m_dwLastSavedWithVersion = MAKE_VERSION_NUMERIC(1, 16, 00, 00); madeWithTracker = "ModPlug tracker 1.09 - 1.16"; } else { // OpenMPT 1.17 disguised as this in compatible mode, // but never writes 0xFF in the pan map for unused channels (which is an invalid value). m_dwLastSavedWithVersion = MAKE_VERSION_NUMERIC(1, 17, 00, 00); madeWithTracker = "OpenMPT 1.17 (compatibility export)"; } interpretModPlugMade = true; } else if(fileHeader.cwtv == 0x0214 && fileHeader.cmwt == 0x0202 && !memcmp(fileHeader.reserved, "\0\0\0\0", 4)) { // ModPlug Tracker b3.3 - 1.09, instruments 557 bytes apart m_dwLastSavedWithVersion = MAKE_VERSION_NUMERIC(1, 09, 00, 00); madeWithTracker = "ModPlug tracker b3.3 - 1.09"; interpretModPlugMade = true; } } else // case: type == MOD_TYPE_MPT { if (fileHeader.cwtv >= verMptFileVerLoadLimit) { AddToLog(str_LoadingIncompatibleVersion); return false; } else if (fileHeader.cwtv > verMptFileVer) { AddToLog(str_LoadingMoreRecentVersion); } } } if(GetType() == MOD_TYPE_IT) mptStartPos = file.GetLength(); // Read row highlights if((fileHeader.special & ITFileHeader::embedPatternHighlights)) { // MPT 1.09, 1.07 and most likely other old MPT versions leave this blank (0/0), but have the "special" flag set. // Newer versions of MPT and OpenMPT 1.17 *always* write 4/16 here. // Thus, we will just ignore those old versions. if(m_dwLastSavedWithVersion == 0 || m_dwLastSavedWithVersion >= MAKE_VERSION_NUMERIC(1, 17, 03, 02)) { m_nDefaultRowsPerBeat = fileHeader.highlight_minor; m_nDefaultRowsPerMeasure = fileHeader.highlight_major; } #ifdef _DEBUG if((fileHeader.highlight_minor | fileHeader.highlight_major) == 0) { Log("IT Header: Row highlight is 0"); } #endif } m_SongFlags.set(SONG_LINEARSLIDES, (fileHeader.flags & ITFileHeader::linearSlides) != 0); m_SongFlags.set(SONG_ITOLDEFFECTS, (fileHeader.flags & ITFileHeader::itOldEffects) != 0); m_SongFlags.set(SONG_ITCOMPATGXX, (fileHeader.flags & ITFileHeader::itCompatGxx) != 0); m_SongFlags.set(SONG_EMBEDMIDICFG, (fileHeader.flags & ITFileHeader::reqEmbeddedMIDIConfig) || (fileHeader.special & ITFileHeader::embedMIDIConfiguration)); m_SongFlags.set(SONG_EXFILTERRANGE, (fileHeader.flags & ITFileHeader::extendedFilterRange) != 0); mpt::String::Read<mpt::String::spacePadded>(songName, fileHeader.songname); // Global Volume m_nDefaultGlobalVolume = fileHeader.globalvol << 1; if(m_nDefaultGlobalVolume > MAX_GLOBAL_VOLUME) m_nDefaultGlobalVolume = MAX_GLOBAL_VOLUME; if(fileHeader.speed) m_nDefaultSpeed = fileHeader.speed; m_nDefaultTempo = std::max(uint8(32), fileHeader.tempo); // Tempo 31 is possible. due to conflicts with the rest of the engine, let's just clamp it to 32. m_nSamplePreAmp = std::min(fileHeader.mv, uint8(128)); // Reading Channels Pan Positions for(CHANNELINDEX i = 0; i < 64; i++) if(fileHeader.chnpan[i] != 0xFF) { ChnSettings[i].Reset(); ChnSettings[i].nVolume = Clamp(fileHeader.chnvol[i], uint8(0), uint8(64)); if(fileHeader.chnpan[i] & 0x80) ChnSettings[i].dwFlags.set(CHN_MUTE); uint8 n = fileHeader.chnpan[i] & 0x7F; if(n <= 64) ChnSettings[i].nPan = n * 4; if(n == 100) ChnSettings[i].dwFlags.set(CHN_SURROUND); } // Reading orders file.Seek(sizeof(ITFileHeader)); if(GetType() == MOD_TYPE_IT) { Order.ReadAsByte(file, fileHeader.ordnum); } else { if(fileHeader.cwtv > 0x88A && fileHeader.cwtv <= 0x88D) { Order.Deserialize(file); } else { Order.ReadAsByte(file, fileHeader.ordnum); // Replacing 0xFF and 0xFE with new corresponding indexes Order.Replace(0xFE, Order.GetIgnoreIndex()); Order.Replace(0xFF, Order.GetInvalidPatIndex()); } } // Reading instrument, sample and pattern offsets std::vector<uint32> insPos, smpPos, patPos; file.ReadVectorLE(insPos, fileHeader.insnum); file.ReadVectorLE(smpPos, fileHeader.smpnum); file.ReadVectorLE(patPos, fileHeader.patnum); // Find the first parapointer. // This is used for finding out whether the edit history is actually stored in the file or not, // as some early versions of Schism Tracker set the history flag, but didn't save anything. // We will consider the history invalid if it ends after the first parapointer. uint32 minPtr = Util::MaxValueOfType(minPtr); for(uint16 n = 0; n < fileHeader.insnum; n++) { if(insPos[n] > 0) { minPtr = std::min(minPtr, insPos[n]); } } for(uint16 n = 0; n < fileHeader.smpnum; n++) { if(smpPos[n] > 0) { minPtr = std::min(minPtr, smpPos[n]); } } for(uint16 n = 0; n < fileHeader.patnum; n++) { if(patPos[n] > 0) { minPtr = std::min(minPtr, patPos[n]); } } if(fileHeader.special & ITFileHeader::embedSongMessage) { minPtr = std::min(minPtr, fileHeader.msgoffset); } // Reading IT Edit History Info // This is only supposed to be present if bit 1 of the special flags is set. // However, old versions of Schism and probably other trackers always set this bit // even if they don't write the edit history count. So we have to filter this out... // This is done by looking at the parapointers. If the history data end after // the first parapointer, we assume that it's actually no history data. if(fileHeader.special & ITFileHeader::embedEditHistory) { const uint16 nflt = file.ReadUint16LE(); if(file.CanRead(nflt * sizeof(ITHistoryStruct)) && file.GetPosition() + nflt * sizeof(ITHistoryStruct) <= minPtr) { m_FileHistory.reserve(nflt); for(size_t n = 0; n < nflt; n++) { FileHistory mptHistory; ITHistoryStruct itHistory; file.ReadConvertEndianness(itHistory); itHistory.ConvertToMPT(mptHistory); m_FileHistory.push_back(mptHistory); } } else { // Oops, we were not supposed to read this. file.SkipBack(2); } } else if(fileHeader.highlight_major == 0 && fileHeader.highlight_minor == 0 && fileHeader.cmwt == 0x0214 && fileHeader.cwtv == 0x0214 && !memcmp(fileHeader.reserved, "\0\0\0\0", 4) && (fileHeader.special & (ITFileHeader::embedEditHistory | ITFileHeader::embedPatternHighlights)) == 0) { // Another non-conforming application is unmo3 < v2.4.0.1, which doesn't set the special bit // at all, but still writes the two edit history length bytes (zeroes)... if(file.ReadUint16LE() != 0) { // These were not zero bytes -> We're in the wrong place! file.SkipBack(2); madeWithTracker = "UNMO3"; } } // Reading MIDI Output & Macros if(m_SongFlags[SONG_EMBEDMIDICFG] && file.Read(m_MidiCfg)) { m_MidiCfg.Sanitize(); } // Ignore MIDI data. Fixes some files like denonde.it that were made with old versions of Impulse Tracker (which didn't support Zxx filters) and have Zxx effects in the patterns. if(fileHeader.cwtv < 0x0214) { MemsetZero(m_MidiCfg.szMidiSFXExt); MemsetZero(m_MidiCfg.szMidiZXXExt); m_SongFlags.set(SONG_EMBEDMIDICFG); } if(file.ReadMagic("MODU")) { madeWithTracker = "BeRoTracker"; } // Read pattern names: "PNAM" FileReader patNames; if(file.ReadMagic("PNAM")) { patNames = file.GetChunk(file.ReadUint32LE()); } m_nChannels = GetModSpecifications().channelsMin; // Read channel names: "CNAM" if(file.ReadMagic("CNAM")) { FileReader chnNames = file.GetChunk(file.ReadUint32LE()); const CHANNELINDEX readChns = std::min(MAX_BASECHANNELS, static_cast<CHANNELINDEX>(chnNames.GetLength() / MAX_CHANNELNAME)); m_nChannels = readChns; for(CHANNELINDEX i = 0; i < readChns; i++) { chnNames.ReadString<mpt::String::maybeNullTerminated>(ChnSettings[i].szName, MAX_CHANNELNAME); } } // Read mix plugins information if(file.CanRead(9)) { LoadMixPlugins(file); } // Read Song Message if(fileHeader.special & ITFileHeader::embedSongMessage) { if(fileHeader.msglength > 0 && file.Seek(fileHeader.msgoffset)) { // Generally, IT files should use CR for line endings. However, ChibiTracker uses LF. One could do... // if(itHeader.cwtv == 0x0214 && itHeader.cmwt == 0x0214 && itHeader.reserved == ITFileHeader::chibiMagic) --> Chibi detected. // But we'll just use autodetection here: songMessage.Read(file, fileHeader.msglength, SongMessage::leAutodetect); } } // Reading Instruments m_nInstruments = 0; if(fileHeader.flags & ITFileHeader::instrumentMode) { m_nInstruments = std::min(fileHeader.insnum, INSTRUMENTINDEX(MAX_INSTRUMENTS - 1)); } for(INSTRUMENTINDEX i = 0; i < GetNumInstruments(); i++) { if(insPos[i] > 0 && file.Seek(insPos[i]) && file.CanRead(fileHeader.cmwt < 0x200 ? sizeof(ITOldInstrument) : sizeof(ITInstrument))) { ModInstrument *instrument = AllocateInstrument(i + 1); if(instrument != nullptr) { ITInstrToMPT(file, *instrument, fileHeader.cmwt); // MIDI Pitch Wheel Depth is a global setting in IT. Apply it to all instruments. instrument->midiPWD = fileHeader.pwd; } } } // In order to properly compute the position, in file, of eventual extended settings // such as "attack" we need to keep the "real" size of the last sample as those extra // setting will follow this sample in the file FileReader::off_t lastSampleOffset = 0; if(fileHeader.smpnum > 0) { lastSampleOffset = smpPos[fileHeader.smpnum - 1] + sizeof(ITSample); } //// #ITQ // Reading Samples m_nSamples = std::min(fileHeader.smpnum, SAMPLEINDEX(MAX_SAMPLES - 1)); size_t nbytes = 0; // size of sample data in file for(SAMPLEINDEX i = 0; i < GetNumSamples(); i++) { ITQSample sampleHeader; if(smpPos[i] > 0 && file.Seek(smpPos[i]) && file.ReadConvertEndianness(sampleHeader)) { if(!memcmp(sampleHeader.id, "ITQS", 4)) { size_t sampleOffset = sampleHeader.ConvertToMPT(Samples[i + 1]); mpt::String::Read<mpt::String::spacePadded>(m_szNames[i + 1], sampleHeader.name); if((loadFlags & loadSampleData) && file.Seek(sampleOffset)) { Samples[i+1].originalSize = sampleHeader.nbytes; sampleHeader.GetSampleFormatITQ(fileHeader.cwtv).ReadSample(Samples[i + 1], file); lastSampleOffset = std::max(lastSampleOffset, file.GetPosition()); } } } } m_nSamples = std::max(SAMPLEINDEX(1), GetNumSamples()); m_nMinPeriod = 8; m_nMaxPeriod = 0xF000; PATTERNINDEX numPats = std::min(static_cast<PATTERNINDEX>(patPos.size()), GetModSpecifications().patternsMax); if(numPats != patPos.size()) { // Hack: Notify user here if file contains more patterns than what can be read. AddToLog(mpt::String::Print(str_PatternSetTruncationNote, patPos.size(), numPats)); } if(!(loadFlags & loadPatternData)) { numPats = 0; } // Checking for number of used channels, which is not explicitely specified in the file. for(PATTERNINDEX pat = 0; pat < numPats; pat++) { if(patPos[pat] == 0 || !file.Seek(patPos[pat])) continue; uint16 len = file.ReadUint16LE(); ROWINDEX numRows = file.ReadUint16LE(); if(numRows < GetModSpecifications().patternRowsMin || numRows > GetModSpecifications().patternRowsMax || !file.Skip(4)) continue; FileReader patternData = file.GetChunk(len); ROWINDEX row = 0; std::vector<uint8> chnMask(GetNumChannels()); while(row < numRows && patternData.AreBytesLeft()) { uint8 b = patternData.ReadUint8(); if(!b) { row++; continue; } CHANNELINDEX ch = (b & IT_bitmask_patternChanField_c); // 0x7f We have some data grab a byte keeping only 7 bits if(ch) { ch = (ch - 1);// & IT_bitmask_patternChanMask_c; // 0x3f mask of the byte again, keeping only 6 bits } if(ch >= chnMask.size()) { chnMask.resize(ch + 1, 0); } if(b & IT_bitmask_patternChanEnabled_c) // 0x80 check if the upper bit is enabled. { chnMask[ch] = patternData.ReadUint8(); // set the channel mask for this channel. } // Channel used if(chnMask[ch] & 0x0F) // if this channel is used set m_nChannels { if(ch >= GetNumChannels() && ch < MAX_BASECHANNELS) { m_nChannels = ch + 1; } } // Now we actually update the pattern-row entry the note,instrument etc. // Note if(chnMask[ch] & 1) patternData.Skip(1); // Instrument if(chnMask[ch] & 2) patternData.Skip(1); // Volume if(chnMask[ch] & 4) patternData.Skip(1); // Effect if(chnMask[ch] & 8) patternData.Skip(2); } } // Compute extra instruments settings position if(lastSampleOffset > 0) { file.Seek(lastSampleOffset); } // Load instrument and song extensions. LoadExtendedInstrumentProperties(file, &interpretModPlugMade); if(interpretModPlugMade) { m_nMixLevels = mixLevels_original; } // We need to do this here, because if there no samples (so lastSampleOffset = 0), we need to look after the last pattern (sample data normally follows pattern data). // And we need to do this before reading the patterns because m_nChannels might be modified by LoadExtendedSongProperties. *sigh* LoadExtendedSongProperties(GetType(), file, &interpretModPlugMade); m_nTempoMode = tempo_mode_modern; // Reading Patterns Patterns.ResizeArray(std::max(MAX_PATTERNS, numPats)); for(PATTERNINDEX pat = 0; pat < numPats; pat++) { if(patPos[pat] == 0 || !file.Seek(patPos[pat])) { // Empty 64-row pattern if(Patterns.Insert(pat, 64)) { AddToLog(mpt::String::Print("Allocating patterns failed starting from pattern %1", pat)); break; } // Now (after the Insert() call), we can read the pattern name. CopyPatternName(Patterns[pat], patNames); continue; } uint16 len = file.ReadUint16LE(); ROWINDEX numRows = file.ReadUint16LE(); if(numRows < GetModSpecifications().patternRowsMin || numRows > GetModSpecifications().patternRowsMax || !file.Skip(4) || Patterns.Insert(pat, numRows)) continue; FileReader patternData = file.GetChunk(len); // Now (after the Insert() call), we can read the pattern name. CopyPatternName(Patterns[pat], patNames); std::vector<uint8> chnMask(GetNumChannels()); std::vector<ModCommand> lastValue(GetNumChannels(), ModCommand::Empty()); ModCommand *m = Patterns[pat]; ROWINDEX row = 0; while(row < numRows && patternData.AreBytesLeft()) { uint8 b = patternData.ReadUint8(); if(!b) { row++; m += GetNumChannels(); continue; } CHANNELINDEX ch = b & IT_bitmask_patternChanField_c; // 0x7f if(ch) { ch = (ch - 1); //& IT_bitmask_patternChanMask_c; // 0x3f } if(ch >= chnMask.size()) { chnMask.resize(ch + 1, 0); lastValue.resize(ch + 1, ModCommand::Empty()); ASSERT(chnMask.size() <= GetNumChannels()); } if(b & IT_bitmask_patternChanEnabled_c) // 0x80 { chnMask[ch] = patternData.ReadUint8(); } // Now we grab the data for this particular row/channel. if((chnMask[ch] & 0x10) && (ch < m_nChannels)) { m[ch].note = lastValue[ch].note; } if((chnMask[ch] & 0x20) && (ch < m_nChannels)) { m[ch].instr = lastValue[ch].instr; } if((chnMask[ch] & 0x40) && (ch < m_nChannels)) { m[ch].volcmd = lastValue[ch].volcmd; m[ch].vol = lastValue[ch].vol; } if((chnMask[ch] & 0x80) && (ch < m_nChannels)) { m[ch].command = lastValue[ch].command; m[ch].param = lastValue[ch].param; } if(chnMask[ch] & 1) // Note { uint8 note = patternData.ReadUint8(); if(ch < m_nChannels) { if(note < 0x80) note++; if(!(GetType() & MOD_TYPE_MPT)) { if(note > NOTE_MAX && note < 0xFD) note = NOTE_FADE; else if(note == 0xFD) note = NOTE_NONE; } m[ch].note = note; lastValue[ch].note = note; } } if(chnMask[ch] & 2) { uint8 instr = patternData.ReadUint8(); if(ch < m_nChannels) { m[ch].instr = instr; lastValue[ch].instr = instr; } } if(chnMask[ch] & 4) { uint8 vol = patternData.ReadUint8(); if(ch < m_nChannels) { // 0-64: Set Volume if(vol <= 64) { m[ch].volcmd = VOLCMD_VOLUME; m[ch].vol = vol; } else // 128-192: Set Panning if(vol >= 128 && vol <= 192) { m[ch].volcmd = VOLCMD_PANNING; m[ch].vol = vol - 128; } else // 65-74: Fine Volume Up if(vol < 75) { m[ch].volcmd = VOLCMD_FINEVOLUP; m[ch].vol = vol - 65; } else // 75-84: Fine Volume Down if(vol < 85) { m[ch].volcmd = VOLCMD_FINEVOLDOWN; m[ch].vol = vol - 75; } else // 85-94: Volume Slide Up if(vol < 95) { m[ch].volcmd = VOLCMD_VOLSLIDEUP; m[ch].vol = vol - 85; } else // 95-104: Volume Slide Down if(vol < 105) { m[ch].volcmd = VOLCMD_VOLSLIDEDOWN; m[ch].vol = vol - 95; } else // 105-114: Pitch Slide Up if(vol < 115) { m[ch].volcmd = VOLCMD_PORTADOWN; m[ch].vol = vol - 105; } else // 115-124: Pitch Slide Down if(vol < 125) { m[ch].volcmd = VOLCMD_PORTAUP; m[ch].vol = vol - 115; } else // 193-202: Portamento To if(vol >= 193 && vol <= 202) { m[ch].volcmd = VOLCMD_TONEPORTAMENTO; m[ch].vol = vol - 193; } else // 203-212: Vibrato depth if(vol >= 203 && vol <= 212) { m[ch].volcmd = VOLCMD_VIBRATODEPTH; m[ch].vol = vol - 203; // Old versions of ModPlug saved this as vibrato speed instead, so let's fix that. if(m[ch].vol && m_dwLastSavedWithVersion && m_dwLastSavedWithVersion <= MAKE_VERSION_NUMERIC(1, 17, 02, 54)) m[ch].volcmd = VOLCMD_VIBRATOSPEED; } else // 213-222: Unused (was velocity) // 223-232: Offset if(vol >= 223 && vol <= 232) { m[ch].volcmd = VOLCMD_OFFSET; m[ch].vol = vol - 223; } lastValue[ch].volcmd = m[ch].volcmd; lastValue[ch].vol = m[ch].vol; } } // Reading command/param if(chnMask[ch] & 8) { uint8 cmd = patternData.ReadUint8(); uint8 param = patternData.ReadUint8(); if(ch < m_nChannels) { if(cmd) { m[ch].command = cmd; m[ch].param = param; S3MConvert(m[ch], true); lastValue[ch].command = m[ch].command; lastValue[ch].param = m[ch].param; } } } } } UpgradeModFlags(); if(!m_dwLastSavedWithVersion && fileHeader.cwtv == 0x0888) { // There are some files with OpenMPT extensions, but the "last saved with" field contains 0. // Was there an OpenMPT version that wrote 0 there, or are they hacked? m_dwLastSavedWithVersion = MAKE_VERSION_NUMERIC(1, 17, 00, 00); } if(m_dwLastSavedWithVersion && madeWithTracker.empty()) { madeWithTracker = "OpenMPT " + MptVersion::ToStr(m_dwLastSavedWithVersion); if(memcmp(fileHeader.reserved, "OMPT", 4) && (fileHeader.cwtv & 0xF000) == 0x5000) { madeWithTracker += " (compatibility export)"; } else if(MptVersion::IsTestBuild(m_dwLastSavedWithVersion)) { madeWithTracker += " (test build)"; } } else { switch(fileHeader.cwtv >> 12) { case 0: if(!madeWithTracker.empty()) { // BeRoTracker has been detected above. } else if(fileHeader.cwtv == 0x0214 && fileHeader.cmwt == 0x0200 && fileHeader.flags == 9 && fileHeader.special == 0 && fileHeader.highlight_major == 0 && fileHeader.highlight_minor == 0 && fileHeader.insnum == 0 && fileHeader.patnum + 1 == fileHeader.ordnum && fileHeader.globalvol == 128 && fileHeader.mv == 100 && fileHeader.speed == 1 && fileHeader.sep == 128 && fileHeader.pwd == 0 && fileHeader.msglength == 0 && fileHeader.msgoffset == 0 && !memcmp(fileHeader.reserved, "\0\0\0\0", 4)) { madeWithTracker = "OpenSPC conversion"; } else if(fileHeader.cwtv == 0x0214 && fileHeader.cmwt == 0x0200 && !memcmp(fileHeader.reserved, "\0\0\0\0", 4)) { // ModPlug Tracker 1.00a5, instruments 560 bytes apart m_dwLastSavedWithVersion = MAKE_VERSION_NUMERIC(1, 00, 00, A5); madeWithTracker = "ModPlug tracker 1.00a5"; interpretModPlugMade = true; } else if(fileHeader.cwtv == 0x0214 && fileHeader.cmwt == 0x0214 && !memcmp(fileHeader.reserved, "CHBI", 4)) { madeWithTracker = "ChibiTracker"; } else if(fileHeader.cwtv == 0x0214 && fileHeader.cmwt == 0x0214 && !(fileHeader.special & 3) && !memcmp(fileHeader.reserved, "\0\0\0\0", 4) && !strcmp(Samples[1].filename, "XXXXXXXX.YYY")) { madeWithTracker = "CheeseTracker"; } else { if(fileHeader.cmwt > 0x0214) { madeWithTracker = "Impulse Tracker 2.15"; } else if(fileHeader.cwtv > 0x0214) { // Patched update of IT 2.14 (0x0215 - 0x0217 == p1 - p3) // p4 (as found on modland) adds the ITVSOUND driver, but doesn't seem to change // anything as far as file saving is concerned. madeWithTracker = mpt::String::Print("Impulse Tracker 2.14p%1", fileHeader.cwtv - 0x0214); } else { madeWithTracker = mpt::String::Print("Impulse Tracker %1.%2", (fileHeader.cwtv & 0x0F00) >> 8, mpt::fmt::hex0<2>((fileHeader.cwtv & 0xFF))); } } break; case 1: madeWithTracker = GetSchismTrackerVersion(fileHeader.cwtv); break; case 6: madeWithTracker = "BeRoTracker"; break; case 7: madeWithTracker = mpt::String::Print("ITMCK %1.%2.%3", (fileHeader.cwtv >> 8) & 0x0F, (fileHeader.cwtv >> 4) & 0x0F, fileHeader.cwtv & 0x0F); break; } } if(GetType() == MOD_TYPE_IT) { // Set appropriate mod flags if the file was not made with MPT. if(!interpretModPlugMade) { SetModFlag(MSF_MIDICC_BUGEMULATION, false); SetModFlag(MSF_OLDVOLSWING, false); SetModFlag(MSF_COMPATIBLE_PLAY, true); } } else { //START - mpt specific: //Using member cwtv on pifh as the version number. const uint16 version = fileHeader.cwtv; if(version > 0x889 && file.Seek(mptStartPos)) { std::istringstream iStrm(std::string(file.GetRawData(), file.BytesLeft())); if(version >= 0x88D) { srlztn::SsbRead ssb(iStrm); ssb.BeginRead("mptm", MptVersion::num); ssb.ReadItem(GetTuneSpecificTunings(), "0", 1, &ReadTuningCollection); ssb.ReadItem(*this, "1", 1, &ReadTuningMap); ssb.ReadItem(Order, "2", 1, &ReadModSequenceOld); ssb.ReadItem(Patterns, FileIdPatterns, strlen(FileIdPatterns), &ReadModPatterns); ssb.ReadItem(Order, FileIdSequences, strlen(FileIdSequences), &ReadModSequences); if(ssb.m_Status & srlztn::SNT_FAILURE) { AddToLog("Unknown error occured while deserializing file."); } } else //Loading for older files. { if(GetTuneSpecificTunings().Deserialize(iStrm)) { AddToLog("Error occured - loading failed while trying to load tune specific tunings."); } else { ReadTuningMap(iStrm, *this); } } } //version condition(MPT) } return true; }