Mercurial > audlegacy-plugins

comparison src/modplug/load_mdl.cxx @ 2218:6907fc39b53f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
That didn't merge properly. I'll try again at some other point.
author William Pitcock <nenolod@atheme.org>
date Fri, 07 Dec 2007 12:13:37 -0600
parents 3673c7ec4ea2
children 107c1fed3d92
comparison
equal deleted inserted replaced
2217:6a4d667a9183 2218:6907fc39b53f
74 case 0xB0: param = data & 0x0F; command = CMD_GLOBALVOLSLIDE; break; 74 case 0xB0: param = data & 0x0F; command = CMD_GLOBALVOLSLIDE; break;
75 case 0xF0: param = ((data >> 8) & 0x0F) | 0xA0; break; 75 case 0xF0: param = ((data >> 8) & 0x0F) | 0xA0; break;
76 } 76 }
77 break; 77 break;
78 case 0x0F: command = CMD_SPEED; break; 78 case 0x0F: command = CMD_SPEED; break;
79 79 case 0x10: if ((param & 0xF0) != 0xE0) { command = CMD_VOLUMESLIDE; if ((param & 0xF0) == 0xF0) param = ((param << 4) | 0x0F); else param >>= 2; } break;
80 case 0x10: 80 case 0x20: if ((param & 0xF0) != 0xE0) { command = CMD_VOLUMESLIDE; if ((param & 0xF0) != 0xF0) param >>= 2; } break;
81 if ((param & 0xF0) != 0xE0) {
82 command = CMD_VOLUMESLIDE;
83 if ((param & 0xF0) == 0xF0) {
84 param = ((param << 4) | 0x0F);
85 } else {
86 param >>= 2;
87 if (param > 0xF)
88 param = 0xF;
89 param <<= 4;
90 }
91 }
92 break;
93 case 0x20:
94 if ((param & 0xF0) != 0xE0) {
95 command = CMD_VOLUMESLIDE;
96 if ((param & 0xF0) != 0xF0) {
97 param >>= 2;
98 if (param > 0xF)
99 param = 0xF;
100 }
101 }
102 break;
103
104 case 0x30: command = CMD_RETRIG; break; 81 case 0x30: command = CMD_RETRIG; break;
105 case 0x40: command = CMD_TREMOLO; break; 82 case 0x40: command = CMD_TREMOLO; break;
106 case 0x50: command = CMD_TREMOR; break; 83 case 0x50: command = CMD_TREMOR; break;
107 case 0xEF: if (param > 0xFF) param = 0xFF; command = CMD_OFFSET; break; 84 case 0xEF: if (param > 0xFF) param = 0xFF; command = CMD_OFFSET; break;
108 } 85 }
215 BYTE inspanenv[MAX_INSTRUMENTS]; 192 BYTE inspanenv[MAX_INSTRUMENTS];
216 LPCBYTE pvolenv, ppanenv, ppitchenv; 193 LPCBYTE pvolenv, ppanenv, ppitchenv;
217 UINT nvolenv, npanenv, npitchenv; 194 UINT nvolenv, npanenv, npitchenv;
218 195
219 if ((!lpStream) || (dwMemLength < 1024)) return FALSE; 196 if ((!lpStream) || (dwMemLength < 1024)) return FALSE;
220 if ((bswapLE32(pmsh->id) != 0x4C444D44) || ((pmsh->version & 0xF0) > 0x10)) return FALSE; 197 if ((pmsh->id != 0x4C444D44) || ((pmsh->version & 0xF0) > 0x10)) return FALSE;
221 memset(patterntracks, 0, sizeof(patterntracks)); 198 memset(patterntracks, 0, sizeof(patterntracks));
222 memset(smpinfo, 0, sizeof(smpinfo)); 199 memset(smpinfo, 0, sizeof(smpinfo));
223 memset(insvolenv, 0, sizeof(insvolenv)); 200 memset(insvolenv, 0, sizeof(insvolenv));
224 memset(inspanenv, 0, sizeof(inspanenv)); 201 memset(inspanenv, 0, sizeof(inspanenv));
225 dwMemPos = 5; 202 dwMemPos = 5;
226 dwTrackPos = 0; 203 dwTrackPos = 0;
227 pvolenv = ppanenv = ppitchenv = NULL; 204 pvolenv = ppanenv = ppitchenv = NULL;
228 nvolenv = npanenv = npitchenv = 0; 205 nvolenv = npanenv = npitchenv = 0;
229 m_nSamples = m_nInstruments = 0; 206 m_nSamples = m_nInstruments = 0;
230 m_dwSongFlags |= SONG_INSTRUMENTMODE;
231 while (dwMemPos+6 < dwMemLength) 207 while (dwMemPos+6 < dwMemLength)
232 { 208 {
233 block = *((WORD *)(lpStream+dwMemPos)); 209 block = *((WORD *)(lpStream+dwMemPos));
234 blocklen = *((DWORD *)(lpStream+dwMemPos+2)); 210 blocklen = *((DWORD *)(lpStream+dwMemPos+2));
235 block = bswapLE16(block);
236 blocklen = bswapLE32(blocklen);
237 dwMemPos += 6; 211 dwMemPos += 6;
238 if (dwMemPos + blocklen > dwMemLength) 212 if (dwMemPos + blocklen > dwMemLength)
239 { 213 {
240 if (dwMemPos == 11) return FALSE; 214 if (dwMemPos == 11) return FALSE;
241 break; 215 break;
244 { 218 {
245 // IN: infoblock 219 // IN: infoblock
246 case 0x4E49: 220 case 0x4E49:
247 pmib = (MDLINFOBLOCK *)(lpStream+dwMemPos); 221 pmib = (MDLINFOBLOCK *)(lpStream+dwMemPos);
248 memcpy(m_szNames[0], pmib->songname, 32); 222 memcpy(m_szNames[0], pmib->songname, 32);
249 norders = bswapLE16(pmib->norders); 223 norders = pmib->norders;
250 if (norders > MAX_ORDERS) norders = MAX_ORDERS; 224 if (norders > MAX_ORDERS) norders = MAX_ORDERS;
251 m_nRestartPos = bswapLE16(pmib->repeatpos); 225 m_nRestartPos = pmib->repeatpos;
252 m_nDefaultGlobalVolume = pmib->globalvol; 226 m_nDefaultGlobalVolume = pmib->globalvol;
253 if (m_nDefaultGlobalVolume == 255)
254 m_nDefaultGlobalVolume++;
255 m_nDefaultTempo = pmib->tempo; 227 m_nDefaultTempo = pmib->tempo;
256 m_nDefaultSpeed = pmib->speed; 228 m_nDefaultSpeed = pmib->speed;
257 m_nChannels = 4; 229 m_nChannels = 4;
258 for (i=0; i<32; i++) 230 for (i=0; i<32; i++)
259 { 231 {
288 { 260 {
289 if (dwPos+18 >= dwMemLength) break; 261 if (dwPos+18 >= dwMemLength) break;
290 pmpd = (MDLPATTERNDATA *)(lpStream + dwPos); 262 pmpd = (MDLPATTERNDATA *)(lpStream + dwPos);
291 if (pmpd->channels > 32) break; 263 if (pmpd->channels > 32) break;
292 PatternSize[i] = pmpd->lastrow+1; 264 PatternSize[i] = pmpd->lastrow+1;
293 PatternAllocSize[i] = pmpd->lastrow+1;
294 if (m_nChannels < pmpd->channels) m_nChannels = pmpd->channels; 265 if (m_nChannels < pmpd->channels) m_nChannels = pmpd->channels;
295 dwPos += 18 + 2*pmpd->channels; 266 dwPos += 18 + 2*pmpd->channels;
296 for (j=0; j<pmpd->channels; j++) 267 for (j=0; j<pmpd->channels; j++)
297 { 268 {
298 patterntracks[i*32+j] = bswapLE16(pmpd->data[j]); 269 patterntracks[i*32+j] = pmpd->data[j];
299 } 270 }
300 } 271 }
301 break; 272 break;
302 // TR: Track Data 273 // TR: Track Data
303 case 0x5254: 274 case 0x5254:
304 if (dwTrackPos) break; 275 if (dwTrackPos) break;
305 ntracks = *((WORD *)(lpStream+dwMemPos)); 276 ntracks = *((WORD *)(lpStream+dwMemPos));
306 ntracks = bswapLE16(ntracks);
307 dwTrackPos = dwMemPos+2; 277 dwTrackPos = dwMemPos+2;
308 break; 278 break;
309 // II: Instruments 279 // II: Instruments
310 case 0x4949: 280 case 0x4949:
311 ninstruments = lpStream[dwMemPos]; 281 ninstruments = lpStream[dwMemPos];
320 UINT note = 12; 290 UINT note = 12;
321 if ((Headers[nins] = new INSTRUMENTHEADER) == NULL) break; 291 if ((Headers[nins] = new INSTRUMENTHEADER) == NULL) break;
322 INSTRUMENTHEADER *penv = Headers[nins]; 292 INSTRUMENTHEADER *penv = Headers[nins];
323 memset(penv, 0, sizeof(INSTRUMENTHEADER)); 293 memset(penv, 0, sizeof(INSTRUMENTHEADER));
324 memcpy(penv->name, lpStream+dwPos+2, 32); 294 memcpy(penv->name, lpStream+dwPos+2, 32);
325 penv->nGlobalVol = 128; 295 penv->nGlobalVol = 64;
326 penv->nPPC = 5*12; 296 penv->nPPC = 5*12;
327 for (j=0; j<lpStream[dwPos+1]; j++) 297 for (j=0; j<lpStream[dwPos+1]; j++)
328 { 298 {
329 const BYTE *ps = lpStream+dwPos+34+14*j; 299 const BYTE *ps = lpStream+dwPos+34+14*j;
330 while ((note < (UINT)(ps[1]+12)) && (note < 120)) 300 while ((note < (UINT)(ps[1]+12)) && (note < 120))
393 if (m_nSamples < nins) m_nSamples = nins; 363 if (m_nSamples < nins) m_nSamples = nins;
394 MODINSTRUMENT *pins = &Ins[nins]; 364 MODINSTRUMENT *pins = &Ins[nins];
395 memcpy(m_szNames[nins], lpStream+dwPos+1, 32); 365 memcpy(m_szNames[nins], lpStream+dwPos+1, 32);
396 memcpy(pins->name, lpStream+dwPos+33, 8); 366 memcpy(pins->name, lpStream+dwPos+33, 8);
397 pins->nC4Speed = *((DWORD *)(lpStream+dwPos+41)); 367 pins->nC4Speed = *((DWORD *)(lpStream+dwPos+41));
398 pins->nC4Speed = bswapLE32(pins->nC4Speed);
399 pins->nLength = *((DWORD *)(lpStream+dwPos+45)); 368 pins->nLength = *((DWORD *)(lpStream+dwPos+45));
400 pins->nLength = bswapLE32(pins->nLength);
401 pins->nLoopStart = *((DWORD *)(lpStream+dwPos+49)); 369 pins->nLoopStart = *((DWORD *)(lpStream+dwPos+49));
402 pins->nLoopStart = bswapLE32(pins->nLoopStart);
403 pins->nLoopEnd = pins->nLoopStart + *((DWORD *)(lpStream+dwPos+53)); 370 pins->nLoopEnd = pins->nLoopStart + *((DWORD *)(lpStream+dwPos+53));
404 pins->nLoopEnd = bswapLE32(pins->nLoopEnd);
405 if (pins->nLoopEnd > pins->nLoopStart) pins->uFlags |= CHN_LOOP; 371 if (pins->nLoopEnd > pins->nLoopStart) pins->uFlags |= CHN_LOOP;
406 pins->nGlobalVol = 64; 372 pins->nGlobalVol = 64;
407 if (lpStream[dwPos+58] & 0x01) 373 if (lpStream[dwPos+58] & 0x01)
408 { 374 {
409 pins->uFlags |= CHN_16BIT; 375 pins->uFlags |= CHN_16BIT;
426 { 392 {
427 dwPos += ReadSample(pins, flags, (LPSTR)(lpStream+dwPos), dwMemLength - dwPos); 393 dwPos += ReadSample(pins, flags, (LPSTR)(lpStream+dwPos), dwMemLength - dwPos);
428 } else 394 } else
429 { 395 {
430 DWORD dwLen = *((DWORD *)(lpStream+dwPos)); 396 DWORD dwLen = *((DWORD *)(lpStream+dwPos));
431 dwLen = bswapLE32(dwLen);
432 dwPos += 4; 397 dwPos += 4;
433 if ((dwPos+dwLen <= dwMemLength) && (dwLen > 4)) 398 if ((dwPos+dwLen <= dwMemLength) && (dwLen > 4))
434 { 399 {
435 flags = (pins->uFlags & CHN_16BIT) ? RS_MDL16 : RS_MDL8; 400 flags = (pins->uFlags & CHN_16BIT) ? RS_MDL16 : RS_MDL8;
436 ReadSample(pins, flags, (LPSTR)(lpStream+dwPos), dwLen); 401 ReadSample(pins, flags, (LPSTR)(lpStream+dwPos), dwLen);
464 { 429 {
465 LPCBYTE pve = pvolenv; 430 LPCBYTE pve = pvolenv;
466 for (UINT nve=0; nve<nvolenv; nve++, pve+=33) if (pve[0]+1 == insvolenv[iIns]) 431 for (UINT nve=0; nve<nvolenv; nve++, pve+=33) if (pve[0]+1 == insvolenv[iIns])
467 { 432 {
468 WORD vtick = 1; 433 WORD vtick = 1;
469 penv->VolEnv.nNodes = 15; 434 penv->nVolEnv = 15;
470 for (UINT iv=0; iv<15; iv++) 435 for (UINT iv=0; iv<15; iv++)
471 { 436 {
472 if (iv) vtick += pve[iv*2+1]; 437 if (iv) vtick += pve[iv*2+1];
473 penv->VolEnv.Ticks[iv] = vtick; 438 penv->VolPoints[iv] = vtick;
474 penv->VolEnv.Values[iv] = pve[iv*2+2]; 439 penv->VolEnv[iv] = pve[iv*2+2];
475 if (!pve[iv*2+1]) 440 if (!pve[iv*2+1])
476 { 441 {
477 penv->VolEnv.nNodes = iv+1; 442 penv->nVolEnv = iv+1;
478 break; 443 break;
479 } 444 }
480 } 445 }
481 penv->VolEnv.nSustainStart = penv->VolEnv.nSustainEnd = pve[31] & 0x0F; 446 penv->nVolSustainBegin = penv->nVolSustainEnd = pve[31] & 0x0F;
482 if (pve[31] & 0x10) penv->dwFlags |= ENV_VOLSUSTAIN; 447 if (pve[31] & 0x10) penv->dwFlags |= ENV_VOLSUSTAIN;
483 if (pve[31] & 0x20) penv->dwFlags |= ENV_VOLLOOP; 448 if (pve[31] & 0x20) penv->dwFlags |= ENV_VOLLOOP;
484 penv->VolEnv.nLoopStart = pve[32] & 0x0F; 449 penv->nVolLoopStart = pve[32] & 0x0F;
485 penv->VolEnv.nLoopEnd = pve[32] >> 4; 450 penv->nVolLoopEnd = pve[32] >> 4;
486 } 451 }
487 } 452 }
488 // Setup panning envelope 453 // Setup panning envelope
489 if ((npanenv) && (ppanenv) && (inspanenv[iIns])) 454 if ((npanenv) && (ppanenv) && (inspanenv[iIns]))
490 { 455 {
491 LPCBYTE ppe = ppanenv; 456 LPCBYTE ppe = ppanenv;
492 for (UINT npe=0; npe<npanenv; npe++, ppe+=33) if (ppe[0]+1 == inspanenv[iIns]) 457 for (UINT npe=0; npe<npanenv; npe++, ppe+=33) if (ppe[0]+1 == inspanenv[iIns])
493 { 458 {
494 WORD vtick = 1; 459 WORD vtick = 1;
495 penv->PanEnv.nNodes = 15; 460 penv->nPanEnv = 15;
496 for (UINT iv=0; iv<15; iv++) 461 for (UINT iv=0; iv<15; iv++)
497 { 462 {
498 if (iv) vtick += ppe[iv*2+1]; 463 if (iv) vtick += ppe[iv*2+1];
499 penv->PanEnv.Ticks[iv] = vtick; 464 penv->PanPoints[iv] = vtick;
500 penv->PanEnv.Values[iv] = ppe[iv*2+2]; 465 penv->PanEnv[iv] = ppe[iv*2+2];
501 if (!ppe[iv*2+1]) 466 if (!ppe[iv*2+1])
502 { 467 {
503 penv->PanEnv.nNodes = iv+1; 468 penv->nPanEnv = iv+1;
504 break; 469 break;
505 } 470 }
506 } 471 }
507 if (ppe[31] & 0x10) penv->dwFlags |= ENV_PANSUSTAIN; 472 if (ppe[31] & 0x10) penv->dwFlags |= ENV_PANSUSTAIN;
508 if (ppe[31] & 0x20) penv->dwFlags |= ENV_PANLOOP; 473 if (ppe[31] & 0x20) penv->dwFlags |= ENV_PANLOOP;
509 penv->PanEnv.nLoopStart = ppe[32] & 0x0F; 474 penv->nPanLoopStart = ppe[32] & 0x0F;
510 penv->PanEnv.nLoopEnd = ppe[32] >> 4; 475 penv->nPanLoopEnd = ppe[32] >> 4;
511 } 476 }
512 } 477 }
513 } 478 }
514 m_dwSongFlags |= SONG_LINEARSLIDES; 479 m_dwSongFlags |= SONG_LINEARSLIDES;
515 m_nType = MOD_TYPE_MDL; 480 m_nType = MOD_TYPE_MDL;