1 /*
2 * Copyright (c) 2009, The MilkyTracker Team.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 * - Redistributions of source code must retain the above copyright notice,
9 * this list of conditions and the following disclaimer.
10 * - Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * - Neither the name of the <ORGANIZATION> nor the names of its contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
18 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
21 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
25 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27 * POSSIBILITY OF SUCH DAMAGE.
28 */
29
30 /*
31 * LoaderMDL.cpp
32 * MilkyPlay Module Loader: Digitracker 3
33 * --------------------------------
34 * Version History:
35 * --------------------------------
36 * 01/16/05: Added loader for version 0.0 (no joke)
37 * ??/??/04: Make it working with platform independent file loading routines
38 * ??/??/98: First version of this MDL loader
39 */
40 #include "Loaders.h"
41
42 struct tmdlins {
43 mp_ubyte sampnum;
44 mp_ubyte playrangeend;
45 mp_ubyte vol;
46 mp_ubyte volenv;
47 mp_ubyte pan;
48 mp_ubyte panenv;
49 mp_uint32 volfade;
50 mp_ubyte vibspeed;
51 mp_ubyte vibdepth;
52 mp_ubyte vibsweep;
53 mp_ubyte vibform;
54 mp_ubyte reserved;
55 mp_ubyte freqenv;
56 };
57
58 struct tmdlsamp {
59 mp_ubyte sampnum;
60 mp_ubyte smpname[32];
61 mp_ubyte filename[8];
62 mp_uint32 c4spd;
63 mp_uint32 samplen;
64 mp_uint32 loopstart;
65 mp_uint32 looplen;
66 mp_ubyte reserved;
67 mp_ubyte infobyte;
68 mp_sbyte *smp;
69 };
70
cvol(mp_ubyte vol)71 static inline mp_uint32 cvol(mp_ubyte vol)
72 {
73 return (((mp_sint32)(vol-1))*65795)>>16;
74 }
75
cpan(mp_ubyte pan)76 static inline mp_uint32 cpan(mp_ubyte pan)
77 {
78 return (((mp_uint32)pan)*131589)>>16;
79 }
80
identifyModule(const mp_ubyte * buffer)81 const char* LoaderMDL::identifyModule(const mp_ubyte* buffer)
82 {
83 // check for .MDL module
84 if (!memcmp(buffer,"DMDL",4))
85 {
86 return "MDL";
87 }
88
89 return NULL;
90 }
91
load(XMFileBase & f,XModule * module)92 mp_sint32 LoaderMDL::load(XMFileBase& f, XModule* module)
93 {
94 mp_uint32 i,e;
95
96 mp_ubyte dummy[256];
97
98 module->cleanUp();
99
100 TXMHeader* header = &module->header;
101 TXMInstrument* instr = module->instr;
102 TXMSample* smp = module->smp;
103 TXMPattern* phead = module->phead;
104
105 // we're already out of memory here
106 if (!phead || !instr || !smp)
107 return MP_OUT_OF_MEMORY;
108
109 mp_ubyte sig[5];
110 f.read(&sig,1,5);
111
112 if (memcmp(sig,"DMDL",4)) {
113 return MP_LOADER_FAILED;
114 }
115
116 mp_ubyte hVer = sig[4]>>4;
117
118 if (hVer > 1) {
119 return MP_LOADER_FAILED;
120 }
121
122 memcpy(header->sig,sig,4);
123 strcpy(header->tracker,"Digitracker 3");
124
125 mp_uint32 numtracks=0;
126 mp_uint32 numins=0;
127 mp_uint32 numsamples=0;
128 mp_ubyte *tracks = NULL;
129
130 // waste some memory
131 tmdlins *mdlins = new tmdlins[16*256];
132 tmdlsamp *mdlsamp = new tmdlsamp[256];
133 mp_uint32 *trackseq = new mp_uint32[256*32];
134
135 if (mdlins == NULL || mdlsamp == NULL || trackseq == NULL)
136 {
137 if (mdlins) delete[] mdlins;
138 if (mdlsamp) delete[] mdlsamp;
139 if (trackseq) delete[] trackseq;
140
141 return MP_OUT_OF_MEMORY;
142 }
143
144 memset(mdlins,0,sizeof(tmdlins)*16*256);
145 memset(mdlsamp,0,sizeof(tmdlsamp)*256);
146 memset(trackseq,0,256*32*4);
147
148 header->ver=sig[4];
149
150 mp_ubyte blockhead[6];
151
152 while (f.read(&blockhead,1,6)) {
153
154 mp_ubyte id[3];
155 memcpy(id,blockhead,2);
156 id[2]=0;
157 mp_uint32 blocklen = LittleEndian::GET_DWORD(blockhead+2);
158
159 if (!memcmp(&blockhead,"IN",2)) {
160 f.read(&header->name,1,32);
161 f.read(&dummy,1,20);
162 mp_uword ordnum = 0;
163 f.readWords(&ordnum,1);
164 if(ordnum > MP_MAXORDERS) {
165 return MP_LOADER_FAILED;
166 }
167 header->ordnum = ordnum;
168 f.readWords(&header->restart,1);
169 header->mainvol = f.readByte();
170 header->tempo = f.readByte();
171 header->speed = f.readByte();
172 f.read(&dummy,1,32);
173 mp_uint32 c=32;
174 while ((dummy[c-1]&128)) c--;
175 header->channum=c;
176
177 for (i=0;i<c;i++) header->pan[i]=cpan(dummy[i]&127);
178
179 f.read(&header->ord,1,header->ordnum);
180 for (i=0;i<c;i++)
181 f.read(&dummy,1,8);
182 }
183 else if (!memcmp(&blockhead,"PA",2)) {
184 header->patnum = f.readByte();
185 for (mp_sint32 p=0;p<header->patnum;p++) {
186 mp_ubyte numch = 0;
187 mp_sint32 numrows=0;
188
189 if (hVer == 1)
190 {
191 numch = f.readByte();
192 numrows = f.readByte();
193 f.read(&dummy,1,16);
194 }
195 else if (hVer == 0)
196 {
197 numch = 32;
198 numrows = 63;
199 }
200
201 for (mp_sint32 c=0;c<numch;c++) {
202 mp_uint32 tr=0;
203 tr = f.readWord();
204 trackseq[p*32+c]=tr;
205 }
206
207 //if ((mp_uword)numch>header->channum) numch=(char)header->channum;
208 numch=(mp_ubyte)header->channum;
209
210 numrows++;
211
212 phead[p].rows=numrows;
213 phead[p].effnum=3;
214 phead[p].channum=numch < (mp_ubyte)header->channum ? numch : (mp_ubyte)header->channum;
215 phead[p].patternData=new mp_ubyte[phead[p].rows*phead[p].channum*8];
216
217 // out of memory?
218 if (phead[p].patternData == NULL)
219 {
220 if (mdlins) delete[] mdlins;
221 if (mdlsamp) delete[] mdlsamp;
222 if (trackseq) delete[] trackseq;
223
224 return MP_OUT_OF_MEMORY;
225 }
226
227 memset(phead[p].patternData,0,phead[p].rows*phead[p].channum*8);
228
229 }
230 }
231 else if (!memcmp(&blockhead,"TR",2)) {
232 mp_ubyte *buffer = new mp_ubyte[2048];
233 numtracks = f.readWord();
234 tracks = new mp_ubyte[(mp_uint32)numtracks*256*6];
235
236 if (buffer == NULL || tracks == NULL)
237 {
238 if (mdlins) delete[] mdlins;
239 if (mdlsamp) delete[] mdlsamp;
240 if (trackseq) delete[] trackseq;
241 if (buffer) delete[] buffer;
242 if (tracks) delete[] tracks;
243
244 return MP_OUT_OF_MEMORY;
245 }
246
247 for (mp_uint32 t=0;t<numtracks;t++) {
248 mp_uint32 tracksize = f.readWord();
249 memset(buffer,0,2048);
250 f.read(buffer,1,tracksize);
251 //tracks[t]=new mp_ubyte[256*6];
252
253 memset(tracks+t*256*6,0,256*6);
254
255 mp_ubyte *track = tracks+t*256*6;
256 //mp_ubyte *track = tracks[t];
257
258 mp_uint32 d=0,p=0;
259 while (d<tracksize) {
260 mp_ubyte b=buffer[d++];
261 mp_uint32 pb=b&3;
262 mp_uint32 op=b>>2;
263
264 switch (pb) {
265 case 0: {
266 for (i=0;i<(op+1);i++) {
267 memset(track+(p*6),0,6);
268 p++;
269 }
270 break;
271 };
272 case 1: {
273 mp_sint32 lp=p-1;
274 for (i=0;i<(op+1);i++) {
275 memcpy(track+(p*6),track+(lp*6),6);
276 p++;
277 }
278 break;
279 };
280 case 2: {
281 memcpy(track+(p*6),track+(op*6),6);
282 p++;
283 break;
284 };
285 case 3: {
286 if ((op&1)) track[p*6]=buffer[d++];
287 if ((op&2)) track[p*6+1]=buffer[d++];
288 if ((op&4)) track[p*6+2]=buffer[d++];
289 if ((op&8)) track[p*6+3]=buffer[d++];
290 if ((op&16)) track[p*6+4]=buffer[d++];
291 if ((op&32)) track[p*6+5]=buffer[d++];
292 p++;
293 break;
294 };
295 }
296 }
297
298 // something went wrong here
299 if (d!=tracksize) {
300 if (mdlins) delete[] mdlins;
301 if (mdlsamp) delete[] mdlsamp;
302 if (trackseq) delete[] trackseq;
303 if (buffer) delete[] buffer;
304 if (tracks) delete[] tracks;
305
306 return MP_LOADER_FAILED;
307 }
308
309 }
310 delete[] buffer;
311 }
312 else if (!memcmp(&blockhead,"II",2)) {
313 mp_uint32 insnum = 0,numsamples = 0;
314 numins = f.readByte();
315 for (i=0;i<numins;i++) {
316 insnum = f.readByte();
317 numsamples = f.readByte();
318
319 if (!insnum) {
320 if (mdlins) delete[] mdlins;
321 if (mdlsamp) delete[] mdlsamp;
322 if (trackseq) delete[] trackseq;
323
324 return MP_LOADER_FAILED;
325 }
326
327 f.read(&instr[insnum-1].name,1,32);
328
329 instr[insnum-1].samp=numsamples;
330
331 for (mp_uint32 s=0;s<numsamples;s++) {
332 mdlins[(insnum-1)*16+s].sampnum = f.readByte();
333 mdlins[(insnum-1)*16+s].playrangeend = f.readByte();
334 mdlins[(insnum-1)*16+s].vol = f.readByte();
335 mdlins[(insnum-1)*16+s].volenv = f.readByte();
336 mdlins[(insnum-1)*16+s].pan = f.readByte();
337 mdlins[(insnum-1)*16+s].panenv = f.readByte();
338 mdlins[(insnum-1)*16+s].volfade = f.readWord();
339 mdlins[(insnum-1)*16+s].vibspeed = f.readByte();
340 mdlins[(insnum-1)*16+s].vibspeed = f.readByte();
341 mdlins[(insnum-1)*16+s].vibsweep = f.readByte();
342 mdlins[(insnum-1)*16+s].vibform = f.readByte();
343 mdlins[(insnum-1)*16+s].reserved = f.readByte();
344 mdlins[(insnum-1)*16+s].freqenv = f.readByte();
345 }
346 }
347 header->insnum=insnum;
348 }
349 else if (!memcmp(&blockhead,"IS",2)) {
350 numsamples = f.readByte();
351 for (mp_uint32 s=0;s<numsamples;s++) {
352 mdlsamp[s].sampnum = f.readByte();
353 f.read(&mdlsamp[s].smpname,1,32);
354
355 f.read(&mdlsamp[s].filename,1,8);
356
357 if (hVer == 1)
358 mdlsamp[s].c4spd = f.readDword();
359 else if (hVer == 0)
360 mdlsamp[s].c4spd = f.readWord();
361
362 mdlsamp[s].samplen = f.readDword();
363 mdlsamp[s].loopstart = f.readDword();
364 mdlsamp[s].looplen = f.readDword();
365 mdlsamp[s].reserved = f.readByte();
366 mdlsamp[s].infobyte = f.readByte();
367 }
368 }
369 else if (!memcmp(&blockhead,"SA",2)) {
370 for (mp_uint32 s=0;s<numsamples;s++) {
371
372 mp_ubyte pb = (mdlsamp[s].infobyte>>2)&3;
373
374 switch (pb) {
375 case 0: {
376 if (!(mdlsamp[s].infobyte&1)) {
377 mdlsamp[s].smp = (mp_sbyte*)module->allocSampleMem(mdlsamp[s].samplen);
378
379 // out of memory
380 if (mdlsamp[s].smp==NULL)
381 {
382 if (mdlins) delete[] mdlins;
383 if (mdlsamp) delete[] mdlsamp;
384 if (trackseq) delete[] trackseq;
385 if (tracks) delete[] tracks;
386
387 return MP_OUT_OF_MEMORY;
388 }
389
390 if (!module->loadSample(f,mdlsamp[s].smp,mdlsamp[s].samplen,mdlsamp[s].samplen))
391 {
392 if (mdlins) delete[] mdlins;
393 if (mdlsamp) delete[] mdlsamp;
394 if (trackseq) delete[] trackseq;
395 if (tracks) delete[] tracks;
396
397 return MP_OUT_OF_MEMORY;
398 }
399
400 }
401 else {
402 mdlsamp[s].smp = (mp_sbyte*)module->allocSampleMem(mdlsamp[s].samplen);
403
404 // out of memory
405 if (mdlsamp[s].smp==NULL)
406 {
407 if (mdlins) delete[] mdlins;
408 if (mdlsamp) delete[] mdlsamp;
409 if (trackseq) delete[] trackseq;
410 if (tracks) delete[] tracks;
411
412 return MP_OUT_OF_MEMORY;
413 }
414
415 if (!module->loadSample(f,mdlsamp[s].smp,mdlsamp[s].samplen,mdlsamp[s].samplen>>1,XModule::ST_16BIT))
416 {
417 if (mdlins) delete[] mdlins;
418 if (mdlsamp) delete[] mdlsamp;
419 if (trackseq) delete[] trackseq;
420 if (tracks) delete[] tracks;
421
422 return MP_OUT_OF_MEMORY;
423 }
424
425 //mp_uint32 samplen = mdlsamp[s].samplen>>1;
426 //mp_uint32 loopstart = mdlsamp[s].loopstart>>1;
427 //mp_uint32 looplen = mdlsamp[s].looplen>>1;
428 }
429 }; break;
430 case 1: {
431 mp_sint32 size = (mp_sint32)f.readDword();
432
433 mdlsamp[s].smp = (mp_sbyte*)module->allocSampleMem(mdlsamp[s].samplen);
434
435 // out of memory
436 if (mdlsamp[s].smp==NULL)
437 {
438 if (mdlins) delete[] mdlins;
439 if (mdlsamp) delete[] mdlsamp;
440 if (trackseq) delete[] trackseq;
441 if (tracks) delete[] tracks;
442
443 return MP_OUT_OF_MEMORY;
444 }
445
446 if (!module->loadSample(f,mdlsamp[s].smp,size,mdlsamp[s].samplen,XModule::ST_PACKING_MDL))
447 {
448 if (mdlins) delete[] mdlins;
449 if (mdlsamp) delete[] mdlsamp;
450 if (trackseq) delete[] trackseq;
451 if (tracks) delete[] tracks;
452
453 return MP_OUT_OF_MEMORY;
454 }
455
456 }; break;
457 case 2: {
458 mp_sint32 size = (mp_sint32)f.readDword();
459
460 mdlsamp[s].smp = (mp_sbyte*)module->allocSampleMem(mdlsamp[s].samplen);
461
462 // out of memory
463 if (mdlsamp[s].smp==NULL)
464 {
465 if (mdlins) delete[] mdlins;
466 if (mdlsamp) delete[] mdlsamp;
467 if (trackseq) delete[] trackseq;
468 if (tracks) delete[] tracks;
469
470 return MP_OUT_OF_MEMORY;
471 }
472
473 mp_uint32 samplen = mdlsamp[s].samplen>>1;
474 //mp_uint32 loopstart = mdlsamp[s].loopstart>>1;
475 //mp_uint32 looplen = mdlsamp[s].looplen>>1;
476
477 if (!module->loadSample(f,mdlsamp[s].smp,size,samplen,XModule::ST_PACKING_MDL | XModule::ST_16BIT))
478 {
479 if (mdlins) delete[] mdlins;
480 if (mdlsamp) delete[] mdlsamp;
481 if (trackseq) delete[] trackseq;
482 if (tracks) delete[] tracks;
483
484 return MP_OUT_OF_MEMORY;
485 }
486
487 }; break;
488 }
489 }
490 }
491 else if (!memcmp(&blockhead,"VE",2)) {
492 mp_uint32 numenvs = f.readByte();
493
494 mp_ubyte *envelopes = new mp_ubyte[numenvs*33];
495
496 // out of memory
497 if (envelopes==NULL)
498 {
499 if (mdlins) delete[] mdlins;
500 if (mdlsamp) delete[] mdlsamp;
501 if (trackseq) delete[] trackseq;
502 if (tracks) delete[] tracks;
503
504 return MP_OUT_OF_MEMORY;
505 }
506
507 f.read(envelopes,33,numenvs);
508
509 mp_ubyte *env=envelopes;
510
511 mp_ubyte num;
512 mp_uint32 envnum = 0;
513
514 mp_uint32 lastEnv = 0;
515 for (e=0;e<numenvs;e++)
516 {
517 envnum=env[e*33];
518 if (envnum>lastEnv)
519 lastEnv = envnum;
520 }
521
522 module->venvs = new TEnvelope[lastEnv+1];
523 if (module->venvs == NULL)
524 {
525 if (mdlins) delete[] mdlins;
526 if (mdlsamp) delete[] mdlsamp;
527 if (trackseq) delete[] trackseq;
528 if (tracks) delete[] tracks;
529
530 return MP_OUT_OF_MEMORY;
531 }
532 memset(module->venvs, 0, sizeof(TEnvelope)*(lastEnv+1));
533 module->numVEnvsAlloc = lastEnv+1;
534 module->numVEnvs = lastEnv+1;
535
536 for (e=0;e<numenvs;e++) {
537 envnum=env[0];
538
539 ASSERT(envnum<lastEnv+1);
540
541 num=0;
542 mp_uint32 x=0;
543 mp_uint32 y;
544 while (env[((mp_uint32)num*2)+1]&&(num<15)) {
545 x+=env[((mp_uint32)num*2)+1];
546 y=(((mp_uint32)env[((mp_uint32)num*2)+2])*266306)>>16;
547 module->venvs[envnum].env[num][0]=x-1;
548 module->venvs[envnum].env[num][1]=y;
549 num++;
550 }
551 module->venvs[envnum].num=num;
552 module->venvs[envnum].sustain=env[31]&0xf;
553 module->venvs[envnum].loops=env[32]&0xf;
554 module->venvs[envnum].loope=env[32]>>4;
555
556 module->venvs[envnum].type=1;
557 if ((env[31]&16)) module->venvs[envnum].type|=2;
558 if ((env[31]&32)) module->venvs[envnum].type|=4;
559
560 env+=33;
561 }
562
563 header->volenvnum=envnum+1;
564
565 delete[] envelopes;
566
567 }
568 else if (!memcmp(&blockhead,"PE",2)) {
569 mp_uint32 numenvs = f.readByte();
570
571 mp_ubyte *envelopes = new mp_ubyte[numenvs*33];
572
573 // out of memory
574 if (envelopes==NULL)
575 {
576 if (mdlins) delete[] mdlins;
577 if (mdlsamp) delete[] mdlsamp;
578 if (trackseq) delete[] trackseq;
579 if (tracks) delete[] tracks;
580
581 return MP_OUT_OF_MEMORY;
582 }
583
584 f.read(envelopes,33,numenvs);
585
586 mp_ubyte *env=envelopes;
587
588 mp_ubyte num;
589 mp_uint32 envnum = 0;
590
591 mp_uint32 lastEnv = 0;
592 for (e=0;e<numenvs;e++)
593 {
594 envnum=env[e*33];
595 if (envnum>lastEnv)
596 lastEnv = envnum;
597 }
598
599 module->penvs = new TEnvelope[lastEnv+1];
600 if (module->penvs == NULL)
601 {
602 if (mdlins) delete[] mdlins;
603 if (mdlsamp) delete[] mdlsamp;
604 if (trackseq) delete[] trackseq;
605 if (tracks) delete[] tracks;
606
607 return MP_OUT_OF_MEMORY;
608 }
609 memset(module->penvs, 0, sizeof(TEnvelope)*(lastEnv+1));
610 module->numPEnvsAlloc = lastEnv+1;
611 module->numPEnvs = lastEnv+1;
612
613 for (e=0;e<numenvs;e++) {
614 envnum=env[0];
615
616 ASSERT(envnum<lastEnv+1);
617
618 num=0;
619 mp_uint32 x=0;
620 mp_uint32 y;
621 while (env[((mp_uint32)num*2)+1]&&(num<15)) {
622 x+=env[((mp_uint32)num*2)+1];
623 y=(((mp_uint32)env[((mp_uint32)num*2)+2])*266306)>>16;
624 module->penvs[envnum].env[num][0]=x-1;
625 module->penvs[envnum].env[num][1]=y;
626 num++;
627 }
628 module->penvs[envnum].num=num;
629 module->penvs[envnum].sustain=env[31]&0xf;
630 module->penvs[envnum].loops=env[32]&0xf;
631 module->penvs[envnum].loope=env[32]>>4;
632
633 module->penvs[envnum].type=1;
634 if ((env[31]&16)) module->penvs[envnum].type|=2;
635 if ((env[31]&32)) module->penvs[envnum].type|=4;
636
637 env+=33;
638 }
639
640 header->panenvnum=envnum+1;
641
642 delete[] envelopes;
643
644 }
645 else if (!memcmp(&blockhead,"FE",2)) {
646 mp_uint32 numenvs = f.readByte();
647
648 mp_ubyte *envelopes = new mp_ubyte[numenvs*33];
649
650 // out of memory
651 if (envelopes==NULL)
652 {
653 if (mdlins) delete[] mdlins;
654 if (mdlsamp) delete[] mdlsamp;
655 if (trackseq) delete[] trackseq;
656 if (tracks) delete[] tracks;
657
658 return MP_OUT_OF_MEMORY;
659 }
660
661 f.read(envelopes,33,numenvs);
662
663 mp_ubyte *env=envelopes;
664
665 mp_ubyte num;
666 mp_uint32 envnum = 0;
667
668 mp_uint32 lastEnv = 0;
669 for (e=0;e<numenvs;e++)
670 {
671 envnum=env[e*33];
672 if (envnum>lastEnv)
673 lastEnv = envnum;
674 }
675
676 module->fenvs = new TEnvelope[lastEnv+1];
677 if (module->fenvs == NULL)
678 {
679 if (mdlins) delete[] mdlins;
680 if (mdlsamp) delete[] mdlsamp;
681 if (trackseq) delete[] trackseq;
682 if (tracks) delete[] tracks;
683
684 return MP_OUT_OF_MEMORY;
685 }
686 memset(module->fenvs, 0, sizeof(TEnvelope)*(lastEnv+1));
687 module->numFEnvsAlloc = lastEnv+1;
688 module->numFEnvs = lastEnv+1;
689
690 for (e=0;e<numenvs;e++) {
691 envnum=env[0];
692
693 ASSERT(envnum<lastEnv+1);
694
695 num=0;
696 mp_uint32 x=0;
697 mp_uint32 y;
698 while (env[((mp_uint32)num*2)+1]&&(num<15)) {
699 x+=env[((mp_uint32)num*2)+1];
700 y=(((mp_uint32)env[((mp_uint32)num*2)+2])*266306)>>16;
701 module->fenvs[envnum].env[num][0]=x-1;
702 module->fenvs[envnum].env[num][1]=y;
703 num++;
704 }
705 module->fenvs[envnum].num=num;
706 module->fenvs[envnum].sustain=env[31]&0xf;
707 module->fenvs[envnum].loops=env[32]&0xf;
708 module->fenvs[envnum].loope=env[32]>>4;
709
710 module->fenvs[envnum].type=1;
711 if ((env[31]&16)) module->fenvs[envnum].type|=2;
712 if ((env[31]&32)) module->fenvs[envnum].type|=4;
713
714 env+=33;
715 }
716
717 header->frqenvnum=envnum+1;
718
719 delete[] envelopes;
720
721 }
722 else if (!memcmp(&blockhead,"ME",2)) {
723
724 // MDL doc says song message is always 0 terminated,
725 // well allocate one more byte to make sure it's really, really 0-terminated
726 module->allocateSongMessage(blocklen+1);
727
728 if (module->message == NULL)
729 {
730 if (mdlins) delete[] mdlins;
731 if (mdlsamp) delete[] mdlsamp;
732 if (trackseq) delete[] trackseq;
733 if (tracks) delete[] tracks;
734 return MP_OUT_OF_MEMORY;
735 }
736
737 // read song message
738 f.read(module->message, 1, blocklen);
739 }
740 else {
741 /*mp_ubyte *buffer = new mp_ubyte[blocklen];
742
743 if (buffer == NULL)
744 {
745 // out of memory
746 if (mdlins) delete[] mdlins;
747 if (mdlsamp) delete[] mdlsamp;
748 if (trackseq) delete[] trackseq;
749 if (tracks) delete[] tracks;
750
751 return MP_OUT_OF_MEMORY;
752 }
753
754 f.read(buffer,1,blocklen);
755
756 delete[] buffer;*/
757
758 f.seekWithBaseOffset(f.posWithBaseOffset() + blocklen);
759 }
760
761 }
762
763 // ---------------------------------------------------------------
764 // build new song structure
765 // ---------------------------------------------------------------
766
767 if (hVer == 1)
768 {
769
770 // create static envelope for samples samples without volume envelope
771 TEnvelope venv;
772
773 //venvs[header->volenvnum].type=5;
774 //venvs[header->volenvnum].num=2;
775 //venvs[header->volenvnum].loops=0;
776 //venvs[header->volenvnum].loope=1;
777 //venvs[header->volenvnum].env[0][0]=0;
778 //venvs[header->volenvnum].env[0][1]=256;
779 //venvs[header->volenvnum].env[1][0]=128;
780 //venvs[header->volenvnum].env[1][1]=256;
781
782 venv.type=5;
783 venv.num=2;
784 venv.loops=0;
785 venv.loope=1;
786 venv.env[0][0]=0;
787 venv.env[0][1]=256;
788 venv.env[1][0]=128;
789 venv.env[1][1]=256;
790
791 if (!module->addVolumeEnvelope(venv))
792 {
793 if (mdlins) delete[] mdlins;
794 if (mdlsamp) delete[] mdlsamp;
795 if (trackseq) delete[] trackseq;
796 if (tracks) delete[] tracks;
797
798 return MP_OUT_OF_MEMORY;
799 }
800
801 header->volenvnum++;
802
803 mp_uint32 sampcnt=0;
804 for (i=0;i<header->insnum;i++) {
805 //cprintf("%i\r\n",instr[i].samp);
806 if (instr[i].samp) {
807 mp_sint32 bs=0;
808 for (mp_uint32 s=0;s<instr[i].samp;s++) {
809 //cprintf("%i, %i\r\n",bs,mdlins[i*16+s].playrangeend);
810 //getch();
811 mp_uint32 l;
812 for (l=bs;l<=mdlins[i*16+s].playrangeend;l++) instr[i].snum[l]=sampcnt;
813 bs=l;
814 for (l=0;l<numsamples;l++) {
815 if (mdlins[i*16+s].sampnum==mdlsamp[l].sampnum) {
816 smp[sampcnt].samplen=mdlsamp[l].samplen;
817 smp[sampcnt].loopstart=mdlsamp[l].loopstart;
818 smp[sampcnt].looplen=mdlsamp[l].looplen;
819
820 if ((mdlins[i*16+s].volenv&64)) smp[sampcnt].flags|=1;
821 if ((mdlins[i*16+s].panenv&64)) smp[sampcnt].flags|=2;
822
823 if ((mdlins[i*16+s].volenv&128)) smp[sampcnt].venvnum=(mdlins[i*16+s].volenv&63)+1;
824 else smp[sampcnt].venvnum=header->volenvnum;
825 if ((mdlins[i*16+s].panenv&128)) smp[sampcnt].penvnum=(mdlins[i*16+s].panenv&63)+1;
826 if ((mdlins[i*16+s].freqenv&128)) smp[sampcnt].fenvnum=(mdlins[i*16+s].freqenv&63)+1;
827
828 smp[sampcnt].vol=cvol(mdlins[i*16+s].vol);
829 XModule::convertc4spd(mdlsamp[l].c4spd,&smp[sampcnt].finetune,&smp[sampcnt].relnote);
830 if (mdlsamp[l].looplen&&(mdlsamp[l].infobyte&2)) smp[sampcnt].type=2;
831 else if (mdlsamp[l].looplen&&(!(mdlsamp[l].infobyte&2))) smp[sampcnt].type=1;
832
833 if ((mdlsamp[l].infobyte&1)) {
834 smp[sampcnt].samplen>>=1;
835 smp[sampcnt].loopstart>>=1;
836 smp[sampcnt].looplen>>=1;
837 smp[sampcnt].type|=16;
838 }
839
840 smp[sampcnt].pan=cpan(mdlins[i*16+s].pan);
841 smp[sampcnt].vibtype=mdlins[i*16+s].vibform;
842 smp[sampcnt].vibsweep=mdlins[i*16+s].vibsweep;
843 smp[sampcnt].vibdepth=mdlins[i*16+s].vibdepth;
844 smp[sampcnt].vibrate=mdlins[i*16+s].vibspeed;
845 smp[sampcnt].volfade=mdlins[i*16+s].volfade;
846 smp[sampcnt].sample=mdlsamp[l].smp;
847 memcpy(&smp[sampcnt].name,&mdlsamp[l].smpname,32);
848
849 sampcnt++;
850 continue;
851 }
852 }
853 }
854 }
855 }
856
857 header->smpnum=sampcnt;
858
859 }
860 else if (hVer == 0)
861 {
862
863 header->insnum = 0;
864
865 for (mp_uint32 s = 0; s < numsamples; s++)
866 {
867 if(mdlsamp[s].sampnum == 0)
868 continue;
869 i = mdlsamp[s].sampnum - 1;
870
871 if ((i+1) > header->insnum)
872 header->insnum = i + 1;
873
874 instr[i].samp = 1;
875
876 for (mp_sint32 j = 0; j < 120; j++)
877 instr[i].snum[j] = s;
878
879 memcpy(instr[i].name, mdlsamp[s].smpname, 32);
880 memcpy(smp[s].name, mdlsamp[s].filename, 8);
881
882 XModule::convertc4spd(mdlsamp[s].c4spd,&smp[s].finetune,&smp[s].relnote);
883
884 smp[s].vol=cvol(mdlsamp[s].reserved);
885
886 smp[s].flags = 1;
887
888 smp[s].samplen = mdlsamp[s].samplen;
889 smp[s].loopstart = mdlsamp[s].loopstart;
890 smp[s].looplen= mdlsamp[s].looplen;
891
892 if (mdlsamp[s].looplen&&(mdlsamp[s].infobyte&2)) smp[s].type=2;
893 else if (mdlsamp[s].looplen&&(!(mdlsamp[s].infobyte&2))) smp[s].type=1;
894
895 if ((mdlsamp[s].infobyte&1)) {
896 smp[s].samplen>>=1;
897 smp[s].loopstart>>=1;
898 smp[s].looplen>>=1;
899 smp[s].type|=16;
900 }
901
902 smp[s].sample = mdlsamp[s].smp;
903
904 /*mdlsamp[s].samplen = f.readDword();
905 mdlsamp[s].loopstart = f.readDword();
906 mdlsamp[s].looplen = f.readDword();
907 mdlsamp[s].reserved = f.readByte();
908 mdlsamp[s].infobyte = f.readByte();*/
909 }
910
911 header->smpnum = numsamples;
912
913 }
914
915 for (i=0;i<header->patnum;i++) {
916
917 mp_ubyte* pattern = phead[i].patternData;
918 mp_uint32 numrows = phead[i].rows;
919 mp_uint32 numch = phead[i].channum;
920
921 for (mp_uint32 r=0;r<numrows;r++) {
922
923 for (mp_uint32 c=0;c<numch;c++) {
924
925 mp_uint32 tnum = trackseq[i*32+c];
926 if (tnum) {
927
928 mp_ubyte *track=tracks+((tnum-1)*256*6)+r*6;
929 //mp_ubyte *track=tracks[tnum-1]+r*6;
930
931 mp_uint32 pos=r*(numch*8)+(c*8);
932
933 if (track[0]<=120) pattern[pos]=track[0];
934 else pattern[pos]=XModule::NOTE_OFF;
935
936 pattern[pos+1]=track[1];
937 if (track[2]) {
938 if (pattern[pos] != XModule::NOTE_OFF)
939 {
940 pattern[pos+2]=0xC;
941 pattern[pos+3]=cvol(track[2]);
942 }
943 }
944
945 mp_ubyte eff1 = track[3]&0xf;
946 mp_ubyte eff2 = track[3]>>4;
947
948 switch (eff1) {
949 case 0x1 : {
950 pattern[pos+4]=0x43;
951 pattern[pos+5]=track[4];
952 }; break;
953 case 0x2 : {
954 pattern[pos+4]=0x44;
955 pattern[pos+5]=track[4];
956 }; break;
957 case 0x3 : {
958 pattern[pos+4]=0x03;
959 pattern[pos+5]=track[4];
960 }; break;
961 case 0x4 : {
962 pattern[pos+4]=0x04;
963 pattern[pos+5]=track[4];
964 }; break;
965 case 0x5 : {
966 pattern[pos+4]=0x20;
967 pattern[pos+5]=track[4];
968 }; break;
969 case 0x7 : {
970 pattern[pos+4]=0x16;
971 pattern[pos+5]=track[4];
972 }; break;
973 case 0x8 : {
974 pattern[pos+4]=0x08;
975 pattern[pos+5]=cpan(track[4]);
976 }; break;
977 case 0xB : {
978 pattern[pos+4]=0x0B;
979 pattern[pos+5]=track[4];
980 }; break;
981 case 0xC : {
982 pattern[pos+4]=0x10;
983 pattern[pos+5]=cvol(track[4]);
984 }; break;
985 case 0xD : {
986 pattern[pos+4]=0x0D;
987 pattern[pos+5]=track[4];
988 }; break;
989 case 0xE : {
990 switch (track[4]>>4) {
991 case 0x1 : {
992 pattern[pos+4]=0x1E;
993 pattern[pos+5]=track[4];
994 }; break;
995 case 0x2 : {
996 pattern[pos+4]=0x1E;
997 pattern[pos+5]=track[4];
998 }; break;
999 case 0x6 : {
1000 pattern[pos+4]=0x36;
1001 pattern[pos+5]=track[4]&0xf;
1002 }; break;
1003 case 0x7 : {
1004 pattern[pos+4]=0x37;
1005 pattern[pos+5]=track[4]&0xf;
1006 }; break;
1007 case 0x9 : {
1008 pattern[pos+4]=0x39;
1009 pattern[pos+5]=track[4]&0xf;
1010 }; break;
1011 case 0xA : {
1012 pattern[pos+4]=0x1E;
1013 pattern[pos+5]=track[4];
1014 }; break;
1015 case 0xB : {
1016 pattern[pos+4]=0x1E;
1017 pattern[pos+5]=track[4];
1018 }; break;
1019 case 0xC : {
1020 pattern[pos+4]=0x3C;
1021 pattern[pos+5]=track[4]&0xf;
1022 }; break;
1023 case 0xD : {
1024 pattern[pos+4]=0x3D;
1025 pattern[pos+5]=track[4]&0xf;
1026 }; break;
1027 case 0xE : {
1028 pattern[pos+4]=0x3E;
1029 pattern[pos+5]=track[4]&0xf;
1030 }; break;
1031 case 0xF : {
1032 pattern[pos+4]=0x1F;
1033 pattern[pos+5]=track[5];
1034 pattern[pos+6]=0;
1035 pattern[pos+7]=track[4]&0xf;
1036 }; break;
1037 }
1038 }; break;
1039 case 0xF : {
1040 pattern[pos+4]=0x1C;
1041 pattern[pos+5]=track[4];
1042 }; break;
1043 default : {
1044 if (eff1) {
1045 //cprintf("Eff1: %i, %i\r\n",eff1,track[4]);
1046 //getch();
1047 }
1048 }; break;
1049 }
1050
1051 switch (eff2) {
1052 case 0x1 : {
1053 pattern[pos+6]=0x45;
1054 pattern[pos+7]=track[5];
1055 }; break;
1056 case 0x2 : {
1057 pattern[pos+6]=0x46;
1058 pattern[pos+7]=track[5];
1059 }; break;
1060 case 0x3 : {
1061 pattern[pos+6]=0x1B;
1062 pattern[pos+7]=track[5];
1063 }; break;
1064 case 0x4 : {
1065 pattern[pos+6]=0x07;
1066 pattern[pos+7]=track[5];
1067 }; break;
1068 case 0x7 : {
1069 pattern[pos+6]=0x16;
1070 pattern[pos+7]=track[5];
1071 }; break;
1072 case 0x8 : {
1073 pattern[pos+6]=0x08;
1074 pattern[pos+7]=cpan(track[5]);
1075 }; break;
1076 case 0xB : {
1077 pattern[pos+6]=0x0B;
1078 pattern[pos+7]=track[5];
1079 }; break;
1080 case 0xC : {
1081 pattern[pos+6]=0x10;
1082 pattern[pos+7]=cvol(track[5]);
1083 }; break;
1084 case 0xD : {
1085 pattern[pos+6]=0x0D;
1086 pattern[pos+7]=track[5];
1087 }; break;
1088 case 0xE : {
1089 switch (track[5]>>4) {
1090 case 0x1 : {
1091 pattern[pos+6]=0x1E;
1092 pattern[pos+7]=track[5];
1093 }; break;
1094 case 0x2 : {
1095 pattern[pos+6]=0x1E;
1096 pattern[pos+7]=track[5];
1097 }; break;
1098 case 0x6 : {
1099 pattern[pos+6]=0x36;
1100 pattern[pos+7]=track[5]&0xf;
1101 }; break;
1102 case 0x7 : {
1103 pattern[pos+6]=0x37;
1104 pattern[pos+7]=track[5]&0xf;
1105 }; break;
1106 case 0x9 : {
1107 pattern[pos+6]=0x39;
1108 pattern[pos+7]=track[5]&0xf;
1109 }; break;
1110 case 0xA : {
1111 pattern[pos+6]=0x1E;
1112 pattern[pos+7]=track[5];
1113 }; break;
1114 case 0xB : {
1115 pattern[pos+6]=0x1E;
1116 pattern[pos+7]=track[5];
1117 }; break;
1118 case 0xC : {
1119 pattern[pos+6]=0x3C;
1120 pattern[pos+7]=track[5]&0xf;
1121 }; break;
1122 case 0xD : {
1123 pattern[pos+6]=0x3D;
1124 pattern[pos+7]=track[5]&0xf;
1125 }; break;
1126 case 0xE : {
1127 pattern[pos+6]=0x3E;
1128 pattern[pos+7]=track[5]&0xf;
1129 }; break;
1130 case 0xF : {
1131 pattern[pos+4]=0x1F;
1132 pattern[pos+5]=track[4];
1133 pattern[pos+6]=0;
1134 pattern[pos+7]=track[5]&0xf;
1135 }; break;
1136 }
1137 }; break;
1138 case 0xF : {
1139 pattern[pos+6]=0x1C;
1140 pattern[pos+7]=track[5];
1141 }; break;
1142 default : {
1143 if (eff2) {
1144 //cprintf("Eff2: %i, %i\r\n",eff2,track[5]);
1145 //getch();
1146 }
1147 }; break;
1148
1149 }
1150
1151 }
1152
1153 }
1154
1155 }
1156
1157 }
1158
1159 //cprintf("%i\r\n",phead[1].channum);
1160
1161 //for (mp_sint32 r=0;r<64;r++) {
1162 //mp_sint32 o=(24*8)*r-2;
1163 //for (i=15;i<16;i++) {
1164 // cprintf("n: %x, i: %x\r\n",phead[1].pattern[i*8+6+o],phead[1].pattern[i*8+7+o]);
1165 // getch();
1166 //}
1167 //}
1168
1169 delete[] tracks;
1170 delete[] trackseq;
1171 delete[] mdlins;
1172 delete[] mdlsamp;
1173
1174 module->postProcessSamples();
1175
1176 return MP_OK;
1177 }
1178