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 * LoaderAMF.cpp
32 * MilkyPlay Module Loaders: Asylum Music Format 1.0 and DSMI AMF
33 *
34 * Thanks to Grom PE for the additional DMF loader which is a DSMI AMF variant
35 * used in the Tronic, game by Webfoot Technologies inc.
36 *
37 * Warning: This is an one-by-one conversion of an assembler version ;)
38 *
39 */
40
41 #include "Loaders.h"
42
identifyModule(const mp_ubyte * buffer)43 const char* LoaderAMF_1::identifyModule(const mp_ubyte* buffer)
44 {
45 // check for .AMF module
46 if (!memcmp(buffer,"ASYLUM Music Format",19))
47 {
48 return "AMF_1";
49 }
50
51 return NULL;
52 }
53
load(XMFileBase & f,XModule * module)54 mp_sint32 LoaderAMF_1::load(XMFileBase& f, XModule* module)
55 {
56 mp_ubyte buffer[2048];
57
58 module->cleanUp();
59
60 // this will make code much easier to read
61 TXMHeader* header = &module->header;
62 TXMInstrument* instr = module->instr;
63 TXMSample* smp = module->smp;
64 TXMPattern* phead = module->phead;
65
66 // we're already out of memory here
67 if (!phead || !instr || !smp)
68 return -7;
69
70 f.read(buffer,1,294);
71
72 memcpy(header->sig,buffer,6);
73
74 header->ordnum = buffer[36]; // song length
75 header->insnum = buffer[34]; // number of instruments
76 header->patnum = buffer[35]; // number of patterns
77 header->speed = buffer[33]; // default tickspeed
78 header->tempo = buffer[32]; // default tempo
79 header->mainvol = 255;
80 header->channum = 8;
81
82 header->flags = XModule::MODULE_PTNEWINSTRUMENT;
83
84 memcpy(header->ord,buffer+38,256); // order list
85
86 mp_sint32 i, s = 0;
87 for (i = 0; i < header->insnum; i++)
88 {
89 f.read(smp[s].name,1,22);
90 memcpy(instr[i].name,smp[s].name,22);
91
92 mp_ubyte finetune = f.readByte();
93 mp_ubyte volume = module->vol64to255(f.readByte());
94
95 f.readByte(); // skip something (maybe volume is a 16bit word?)
96
97 mp_uint32 size = f.readDword();
98
99 mp_uint32 loopstart = f.readDword();
100
101 mp_uint32 loopend = f.readDword();
102
103 module->convertc4spd(module->sfinetunes[finetune],&smp[s].finetune,&smp[s].relnote);
104
105 smp[s].flags = 1;
106 smp[s].samplen = size;
107 smp[s].loopstart = loopstart;
108 smp[s].looplen = loopend;
109 smp[s].vol = volume;
110
111 if (smp[s].samplen <= 2)
112 {
113 instr[i].samp = 0;
114 }
115 else
116 {
117 instr[i].samp = 1;
118 for (mp_sint32 j = 0; j < 120; j++)
119 instr[i].snum[j] = s;
120
121 if ((smp[s].loopstart+smp[s].looplen)>smp[s].samplen)
122 smp[s].looplen-=(smp[s].loopstart+smp[s].looplen)-smp[s].samplen;
123
124 if (smp[s].loopstart<=2) smp[s].loopstart=0;
125 if (smp[s].looplen<=2)
126 smp[s].looplen=0;
127 else smp[s].type=1;
128
129 s++;
130 }
131
132 }
133
134 header->smpnum = s;
135
136 f.read(buffer,1,2663-1442);
137
138 for (i = 0; i < header->patnum;i++)
139 {
140 f.read(buffer,1,2048);
141
142 phead[i].rows=64;
143 phead[i].effnum=1;
144 phead[i].channum = (mp_ubyte)header->channum;
145
146 phead[i].patternData = new mp_ubyte[phead[i].rows*header->channum*4];
147
148 // out of memory?
149 if (phead[i].patternData == NULL)
150 {
151 return -7;
152 }
153
154 memset(phead[i].patternData,0,phead[i].rows*header->channum*4);
155
156 mp_sint32 r,c,cnt=0;
157 for (r=0;r<64;r++) {
158 for (c=0;c<header->channum;c++) {
159 mp_ubyte note = buffer[cnt];
160 mp_ubyte ins = buffer[cnt+1];
161 mp_ubyte eff = buffer[cnt+2];
162 mp_ubyte op = buffer[cnt+3];
163
164 if (note)
165 note++;
166
167 if (eff==0xE)
168 {
169 eff=(op>>4)+0x30;
170 op&=0xf;
171
172 if (eff == 0x38)
173 {
174 eff = 0x08;
175 op<<=4;
176 }
177 }
178
179 if ((!eff)&&op)
180 eff=0x20;
181
182 // old style modules don't support last effect for:
183 // - portamento up/down
184 // - volume slide
185 if (eff==0x1&&(!op)) eff = 0;
186 if (eff==0x2&&(!op)) eff = 0;
187 if (eff==0xA&&(!op)) eff = 0;
188
189 if (eff==0x5&&(!op)) eff=0x3;
190 if (eff==0x6&&(!op)) eff=0x4;
191
192 if (eff==0xC) {
193 op = XModule::vol64to255(op);
194 }
195
196 phead[i].patternData[cnt]=note;
197 phead[i].patternData[cnt+1]=ins;
198 phead[i].patternData[cnt+2]=eff;
199 phead[i].patternData[cnt+3]=op;
200
201 cnt+=4;
202 }
203 }
204
205 }
206
207 mp_sint32 result = module->loadModuleSamples(f);
208 if (result != MP_OK)
209 return result;
210
211 strcpy(header->tracker,"..converted..");
212
213 module->setDefaultPanning();
214
215 module->postProcessSamples();
216
217 return MP_OK;
218 }
219
220 #if 0
221
222 const char* LoaderAMF_2::identifyModule(const mp_ubyte* buffer)
223 {
224 // check for .AMF module
225 if (!memcmp(buffer,"AMF", 3))
226 {
227 // check for version
228 if (buffer[3] < 0xA ||
229 buffer[3] > 0xE)
230 return NULL;
231
232 return "AMF_2";
233 }
234
235 return NULL;
236 }
237
238 // shamelessly copied from MikMod
239 struct AMFNoteSlot
240 {
241 mp_ubyte note,instr,fxcnt;
242 mp_ubyte effect[3];
243 mp_sbyte parameter[3];
244 };
245
246 #define CLEAN_UP \
247 for (j = 0; j < maxTracks; j++) \
248 delete[] tracks[j]; \
249 delete[] tracks; \
250 delete[] trackTable; \
251 delete[] rows; \
252 delete[] amfOrders;
253
254 mp_sint32 LoaderAMF_2::load(XMFileBase& f, XModule* module)
255 {
256 module->cleanUp();
257
258 // this will make code much easier to read
259 TXMHeader* header = &module->header;
260 TXMInstrument* instr = module->instr;
261 TXMSample* smp = module->smp;
262 TXMPattern* phead = module->phead;
263
264 // we're already out of memory here
265 if (!phead || !instr || !smp)
266 return -7;
267
268 // ---- read header info ----
269
270 f.read(header->sig, 1, 3);
271
272 mp_ubyte ver = f.readByte();
273
274 f.read(header->name, 1, 32);
275
276 header->insnum = f.readByte();
277 header->ordnum = header->patnum = f.readByte();
278
279 mp_uword numTracks = f.readWord();
280
281 header->channum = f.readByte();
282
283 mp_sint32 channelRemap[16];
284
285 if (ver >= 11)
286 {
287 mp_ubyte panpos[32];
288 f.read(panpos, 1, (ver >= 13) ? 32 : 16);
289 }
290 else
291 {
292 for (mp_sint32 i = 0; i < 16; i++)
293 channelRemap[i] = f.readByte();
294 }
295
296 if (ver >= 13)
297 {
298 // read BPM
299 header->speed = f.readByte();
300 // read speed
301 header->tempo = f.readByte();
302 }
303 else
304 {
305 header->speed = 125;
306 header->tempo = 6;
307 }
308
309 header->mainvol = 255;
310
311 mp_sint32 i,j,k;
312
313 for (i = 0; i < header->ordnum; i++)
314 header->ord[i] = i;
315
316 mp_uword* amfOrders = new mp_uword[header->channum*header->ordnum];
317 mp_uword* rows = new mp_uword[header->ordnum];
318
319 for (i = 0; i < header->ordnum; i++) {
320 rows[i] = 64;
321 if (ver >= 14)
322 rows[i] = f.readWord();
323 if (ver > 10)
324 f.readWords(amfOrders+(i*header->channum), header->channum);
325 else
326 {
327 for(j = 0; j < header->channum; j++)
328 amfOrders[i*header->channum+channelRemap[j]]=f.readWord();
329 }
330 }
331
332 // ---- read sample info ----
333
334 j = 0;
335 for (i = 0; i < header->insnum; i++)
336 {
337 mp_ubyte type = f.readByte();
338 f.read(instr[i].name, 1, 32);
339 mp_ubyte dosname[13];
340 f.read(dosname, 1, 13);
341 mp_sint32 offset = f.readDword();
342 mp_sint32 length = f.readDword();
343 mp_dword c2spd = f.readWord();
344 mp_ubyte vol = f.readByte();
345
346 mp_sint32 loopstart;
347 mp_sint32 loopend;
348 if (ver >= 10)
349 {
350 loopstart = f.readDword();
351 loopend = f.readDword();
352 }
353 else
354 {
355 loopstart = f.readWord();
356 loopend = length;
357 }
358
359 if (type)
360 {
361 memcpy(smp[j].name, dosname, 13);
362
363 module->convertc4spd(c2spd, &smp[j].finetune, &smp[j].relnote);
364
365 if (loopend - loopstart > 2)
366 smp[j].type = 1;
367
368 smp[j].flags = 1;
369 smp[j].samplen = length;
370 smp[j].loopstart = loopstart;
371 smp[j].looplen = loopend;
372 smp[j].vol = XModule::vol64to255(vol);
373
374 instr[i].samp = 1;
375 for (mp_sint32 k = 0; k < 120; k++)
376 instr[i].snum[k] = j;
377
378 j++;
379 }
380 }
381
382 header->smpnum = j;
383
384 mp_uword* trackTable = new mp_uword[numTracks];
385
386 mp_uword maxTracks = 0;
387
388 f.readWords(trackTable, numTracks);
389
390 for (i = 0; i < numTracks; i++)
391 if (trackTable[i] > maxTracks)
392 maxTracks = trackTable[i];
393
394 // ---- read tracks ----
395 AMFNoteSlot** tracks = new AMFNoteSlot*[maxTracks];
396 memset(tracks, 0, sizeof(AMFNoteSlot*)*maxTracks);
397
398 for (i = 0; i < maxTracks; i++)
399 {
400 tracks[i] = new AMFNoteSlot[64];
401 memset(tracks[i], 0, sizeof(AMFNoteSlot)*64);
402 AMFNoteSlot* track = tracks[i];
403
404 // shamelessly copied from MikMod
405 mp_sint32 tracksize;
406 mp_ubyte row,cmd;
407 mp_sbyte arg;
408
409 tracksize = f.readWord();
410 tracksize+=((mp_sint32)f.readByte()) << 16;
411
412 if (tracksize)
413 while(tracksize--)
414 {
415 row = f.readByte();
416 cmd = f.readByte();
417 arg = f.readByte();
418 // unexpected end of track
419 if (!tracksize)
420 {
421 if((row==0xff) && (cmd==0xff) && (arg==-1))
422 break;
423 /* the last triplet should be FF FF FF, but this is not
424 always the case... maybe a bug in m2amf ?
425 else
426 return 0;
427 */
428 }
429 // invalid row (probably unexpected end of row)
430 if (row>=64)
431 {
432 CLEAN_UP
433 return -8;
434 }
435 if (cmd<0x7f)
436 {
437 // note, vol
438 track[row].note=cmd+1;
439
440 if (track[row].fxcnt<3)
441 {
442 track[row].effect[track[row].fxcnt] = 0x03;
443 track[row].parameter[track[row].fxcnt] = (mp_ubyte)arg;
444 track[row].fxcnt++;
445 }
446 }
447 else if (cmd==0x7f)
448 {
449 // duplicate row
450 if ((arg<0)&&(row+arg>=0)) {
451 memcpy(track+row,track+(row+arg),sizeof(AMFNoteSlot));
452 }
453 }
454 else if (cmd==0x80)
455 {
456 // instr
457 track[row].instr=arg+1;
458 }
459 else if (cmd==0xff)
460 {
461 // apparently, some M2AMF version fail to estimate the
462 // size of the compressed patterns correctly, and end
463 // up with blanks, i.e. dead triplets. Those are marked
464 // with cmd == 0xff. Let's ignore them.
465 }
466 else if (track[row].fxcnt<3)
467 {
468 // effect, param
469 if (cmd > 0x97)
470 {
471 CLEAN_UP
472 return -8;
473 }
474 track[row].effect[track[row].fxcnt]=cmd&0x7f;
475 track[row].parameter[track[row].fxcnt]=arg;
476 track[row].fxcnt++;
477 }
478 else
479 {
480 CLEAN_UP
481 return -8;
482 }
483 }
484 }
485
486 // ---- convert tracks to patterns ----
487 for (i = 0; i < header->ordnum; i++)
488 {
489 phead[i].rows = rows[i];
490 phead[i].channum = (mp_ubyte)header->channum;
491 phead[i].effnum = 3;
492
493 mp_sint32 slotSize = (mp_sint32)(2+phead[i].effnum*2);
494 mp_sint32 patSize = (mp_sint32)phead[i].rows*(mp_sint32)header->channum*slotSize;
495 phead[i].patternData = new mp_ubyte[patSize];
496
497 // out of memory?
498 if (phead[i].patternData == NULL)
499 {
500 CLEAN_UP
501 return -7;
502 }
503
504 memset(phead[i].patternData, 0, patSize);
505
506 for (mp_sint32 row = 0; row < phead[i].rows; row++)
507 for (mp_sint32 chn = 0; chn < phead[i].channum; chn++)
508 {
509 j = amfOrders[i*phead[i].channum+chn];
510 if (j && j <= numTracks)
511 {
512 j = trackTable[j-1];
513 if (j && j <= maxTracks)
514 {
515 AMFNoteSlot* track = tracks[j-1];
516
517 mp_ubyte* dstSlot = phead[i].patternData+row*phead[i].channum*slotSize+chn*slotSize;
518
519 // convert note slot
520 if (track[row].note)
521 dstSlot[0] = track[row].note - 12;
522 dstSlot[1] = track[row].instr;
523
524 mp_sint32 l = 0;
525 for (k = 0; k < track[row].fxcnt; k++)
526 {
527 mp_ubyte nEff = 0;
528 mp_ubyte nOp = 0;
529 mp_sbyte op = track[row].parameter[k];
530
531 switch (track[row].effect[k])
532 {
533 // Set speed (ticks)
534 case 0x01:
535 nEff = 0x1C;
536 nOp = op;
537 break;
538
539 // Volume slide
540 case 2:
541 nEff = 0x0A;
542 if (op)
543 {
544 if (op>=0)
545 nOp = ((op&0xf)<<4);
546 else
547 nOp = (-op)&0xf;
548 }
549 break;
550
551 // set volume
552 case 0x03:
553 nEff = 0x0C;
554 nOp = XModule::vol64to255(op);
555 break;
556
557 // portamento up/down
558 case 0x04:
559 if (op >= 0)
560 {
561 nEff = 0x02;
562 nOp = op & 0xf;
563 }
564 else
565 {
566 nEff = 0x01;
567 nOp = (-op) & 0xf;
568 }
569 break;
570
571 // Porta to note
572 case 0x06:
573 nEff = 0x03;
574 nOp = op;
575 break;
576
577 // tremor
578 case 0x07:
579 nEff = 0x1D;
580 nOp = op;
581 break;
582
583 // arpeggio
584 case 0x08:
585 nEff = 0x20;
586 nOp = op;
587 break;
588
589 // vibrato
590 case 0x09:
591 nEff = 0x04;
592 nOp = op;
593 break;
594
595 // Porta + Volume slide
596 case 0xA:
597 nEff = 0x05;
598 if (op)
599 {
600 if (op>=0)
601 nOp = ((op&0xf)<<4);
602 else
603 nOp = (-op) & 0xf;
604 }
605 break;
606
607 // Vibrato + Volume slide
608 case 0xB:
609 nEff = 0x06;
610 if (op)
611 {
612 if (op>=0)
613 nOp = ((op&0xf)<<4);
614 else
615 nOp = (-op) & 0xf;
616 }
617 break;
618
619 // Pattern break (in hex)
620 case 0xC:
621 nEff = 0x0D;
622 nOp = (op/10)*16 + (op%10);
623 break;
624
625 // Pos. jump
626 case 0xD:
627 nEff = 0x0B;
628 nOp = op;
629 break;
630
631 // Retrig
632 case 0xF:
633 nEff = 0x1B;
634 nOp = op;
635 break;
636
637 // Sample offset
638 case 0x10:
639 nEff = 0x09;
640 nOp = op;
641 break;
642
643 // Fine Volume slide
644 case 0x11:
645 if (op)
646 {
647 if (op>=0)
648 {
649 nEff = 0x3A;
650 nOp = op & 0x0f;
651 }
652 else
653 {
654 nEff = 0x3B;
655 nOp = (-op) & 0x0f;
656 }
657 }
658 break;
659
660 // Fine Porta
661 case 0x12:
662 if (op)
663 {
664 if (op>=0)
665 {
666 nEff = 0x32;
667 nOp = op & 0x0f;
668 }
669 else
670 {
671 nEff = 0x31;
672 nOp = (-op) & 0x0f;
673 }
674 }
675 break;
676
677 // Note delay
678 case 0x13:
679 nEff = 0x3D;
680 nOp = op;
681 break;
682
683 // Note cut
684 case 0x14:
685 nEff = 0x3C;
686 nOp = op;
687 break;
688
689 // Set tempo (bpm)
690 case 0x15:
691 nEff = 0x16;
692 nOp = op;
693 break;
694
695 // Set panning
696 case 0x17:
697 if (op > 64)
698 {
699 nEff = 0x08;
700 nOp = XModule::vol64to255(op);
701 }
702 break;
703 }
704
705 // put volume in first command
706 // otherwise in second
707 if (l == 0 && nEff != 0x0C)
708 {
709 l = 1;
710 }
711 // if not first effect search for empty effect slot
712 else
713 {
714 for (mp_sint32 m = 0; m < phead[i].effnum; m++)
715 if (!dstSlot[2+m*2])
716 {
717 l = m;
718 break;
719 }
720 }
721
722 if (nEff)
723 {
724 dstSlot[2+l*2] = nEff;
725 dstSlot[2+l*2+1] = nOp;
726 }
727 }
728 }
729 }
730 }
731 }
732
733 CLEAN_UP
734
735 mp_sint32 result = module->loadModuleSamples(f, XModule::ST_UNSIGNED);
736 if (result != MP_OK)
737 return result;
738
739 // --- kick out duplicate patterns ---
740 mp_ubyte patReloc[255];
741 memset(patReloc, 0xFF, sizeof(patReloc));
742
743 for (i = 0; i < header->patnum; i++)
744 {
745 if (patReloc[i] == 0xFF)
746 {
747 for (j = 0; j < header->patnum; j++)
748 {
749 if ((j != i && patReloc[j] == 0xFF) &&
750 phead[i].rows == phead[j].rows &&
751 phead[i].channum == phead[j].channum &&
752 phead[i].effnum == phead[j].effnum)
753 {
754 mp_sint32 slotSize = (mp_sint32)(2+phead[i].effnum*2);
755 mp_sint32 patSize = (mp_sint32)phead[i].rows*(mp_sint32)header->channum*slotSize;
756
757 if (memcmp(phead[i].patternData, phead[j].patternData, patSize) == 0)
758 {
759 patReloc[j] = i;
760 }
761 }
762 }
763 }
764 }
765
766 for (i = 0; i < header->ordnum; i++)
767 {
768 if (patReloc[header->ord[i]] != 255)
769 header->ord[i] = patReloc[header->ord[i]];
770 }
771
772 module->removeUnusedPatterns(false);
773
774 strcpy(header->tracker,"..converted..");
775
776 module->setDefaultPanning();
777
778 module->postProcessSamples();
779
780 return MP_OK;
781 }
782
783 // ---------------
784
785 #else
786
identifyModule(const mp_ubyte * buffer)787 const char* LoaderAMF_2::identifyModule(const mp_ubyte* buffer)
788 {
789 // check for .AMF module
790 if (!memcmp(buffer,"DMF", 3))
791 {
792 // check for version
793 if (buffer[3] < 0xA ||
794 buffer[3] > 0xE)
795 return NULL;
796
797 return "AMF_2";
798 }
799
800 return NULL;
801 }
802
803 // shamelessly copied from MikMod
804 struct AMFNoteSlot
805 {
806 mp_ubyte note,instr,fxcnt;
807 mp_ubyte effect[3];
808 mp_sbyte parameter[3];
809 };
810
811 #define CLEAN_UP \
812 for (j = 0; j < maxTracks; j++) \
813 delete[] tracks[j]; \
814 delete[] tracks; \
815 delete[] trackTable; \
816 delete[] rows; \
817 delete[] amfOrders;
818
load(XMFileBase & f,XModule * module)819 mp_sint32 LoaderAMF_2::load(XMFileBase& f, XModule* module)
820 {
821 module->cleanUp();
822
823 // this will make code much easier to read
824 TXMHeader* header = &module->header;
825 TXMInstrument* instr = module->instr;
826 TXMSample* smp = module->smp;
827 TXMPattern* phead = module->phead;
828
829 // we're already out of memory here
830 if (!phead || !instr || !smp)
831 return MP_OUT_OF_MEMORY;
832
833 // ---- read header info ----
834
835 f.read(header->sig, 1, 3);
836
837 mp_ubyte ver = f.readByte();
838
839 // f.read(header->name, 1, 32);
840
841 header->insnum = f.readByte();
842 header->ordnum = header->patnum = f.readByte();
843
844 mp_uword numTracks = f.readWord();
845
846 header->channum = f.readByte();
847
848 mp_sint32 channelRemap[16];
849
850 if (ver >= 11)
851 {
852 mp_ubyte panpos[32];
853 f.read(panpos, 1, (ver >= 13) ? 32 : 16);
854 }
855 else
856 {
857 for (mp_sint32 i = 0; i < 16; i++)
858 channelRemap[i] = f.readByte();
859 }
860
861 if (ver >= 13)
862 {
863 // read BPM
864 header->speed = f.readByte();
865 // read speed
866 header->tempo = f.readByte();
867 }
868 else
869 {
870 header->speed = 125;
871 header->tempo = 6;
872 }
873
874 header->mainvol = 255;
875
876 mp_sint32 i,j,k;
877
878 for (i = 0; i < header->ordnum; i++)
879 header->ord[i] = i;
880
881 mp_uword* amfOrders = new mp_uword[header->channum*header->ordnum];
882 mp_uword* rows = new mp_uword[header->ordnum];
883
884 for (i = 0; i < header->ordnum; i++) {
885 rows[i] = 64;
886 if (ver >= 14)
887 rows[i] = f.readWord();
888 if (ver > 10)
889 f.readWords(amfOrders+(i*header->channum), header->channum);
890 else
891 {
892 for(j = 0; j < header->channum; j++)
893 amfOrders[i*header->channum+channelRemap[j]]=f.readWord();
894 }
895 }
896
897 // ---- read sample info ----
898
899 j = 0;
900
901 for (i = 0; i < header->insnum; i++)
902 {
903 mp_ubyte type = f.readByte();
904 // f.read(instr[i].name, 1, 32);
905 // mp_ubyte dosname[13];
906 // f.read(dosname, 1, 13);
907 // f.readByte(); // FIXME: where's missing byte?
908
909 mp_sint32 offset = f.readDword() >> 8;
910 mp_sint32 length = f.readDword() >> 8;
911 mp_ubyte vol = f.readByte();
912 mp_dword c2spd = f.readWord();
913
914 // f.seek(-1, f.SeekOffsetTypeCurrent); // Restore missing byte
915
916 mp_sint32 loopstart;
917 mp_sint32 loopend;
918 if (ver >= 10)
919 {
920 loopstart = f.readDword() >> 8;
921 loopend = f.readDword() >> 8;
922 }
923 else
924 {
925 loopstart = f.readWord();
926 loopend = length;
927 }
928
929 if (type)
930 {
931 // memcpy(smp[j].name, dosname, 13);
932
933 module->convertc4spd(c2spd, &smp[j].finetune, &smp[j].relnote);
934
935 if (loopend - loopstart > 2)
936 smp[j].type = 1;
937
938 smp[j].flags = 1;
939 smp[j].samplen = length;
940 smp[j].loopstart = loopstart;
941 smp[j].looplen = loopend;
942 smp[j].vol = XModule::vol64to255(vol);
943
944 instr[i].samp = 1;
945 for (mp_sint32 k = 0; k < 120; k++)
946 instr[i].snum[k] = j;
947
948 j++;
949 }
950 }
951
952 header->smpnum = j;
953
954 mp_uword* trackTable = new mp_uword[numTracks];
955
956 mp_uword maxTracks = 0;
957
958 f.readWords(trackTable, numTracks);
959
960 for (i = 0; i < numTracks; i++)
961 if (trackTable[i] > maxTracks)
962 maxTracks = trackTable[i];
963
964 // ---- read tracks ----
965 AMFNoteSlot** tracks = new AMFNoteSlot*[maxTracks];
966 memset(tracks, 0, sizeof(AMFNoteSlot*)*maxTracks);
967
968 for (i = 0; i < maxTracks; i++)
969 {
970 tracks[i] = new AMFNoteSlot[64];
971 memset(tracks[i], 0, sizeof(AMFNoteSlot)*64);
972 AMFNoteSlot* track = tracks[i];
973
974 // shamelessly copied from MikMod
975 mp_sint32 tracksize;
976 mp_ubyte row,cmd;
977 mp_sbyte arg;
978
979 tracksize = f.readWord();
980 tracksize+=((mp_sint32)f.readByte()) << 16;
981
982 if (tracksize)
983 while(tracksize--)
984 {
985 row = f.readByte();
986 cmd = f.readByte();
987 arg = f.readByte();
988 // unexpected end of track
989 if (!tracksize)
990 {
991 if((row==0xff) && (cmd==0xff) && (arg==-1))
992 break;
993 /* the last triplet should be FF FF FF, but this is not
994 always the case... maybe a bug in m2amf ?
995 else
996 return 0;
997 */
998 }
999 // invalid row (probably unexpected end of row)
1000 if (row>=64)
1001 {
1002 CLEAN_UP
1003 return MP_LOADER_FAILED;
1004 }
1005 if (cmd<0x7f)
1006 {
1007 // note, vol
1008 track[row].note=cmd+1;
1009
1010 if (track[row].fxcnt<3)
1011 {
1012 track[row].effect[track[row].fxcnt] = 0x03;
1013 track[row].parameter[track[row].fxcnt] = (mp_ubyte)arg;
1014 track[row].fxcnt++;
1015 }
1016 }
1017 else if (cmd==0x7f)
1018 {
1019 // duplicate row
1020 if ((arg<0)&&(row+arg>=0)) {
1021 memcpy(track+row,track+(row+arg),sizeof(AMFNoteSlot));
1022 }
1023 }
1024 else if (cmd==0x80)
1025 {
1026 // instr
1027 track[row].instr=arg+1;
1028 }
1029 else if (cmd==0xff)
1030 {
1031 // apparently, some M2AMF version fail to estimate the
1032 // size of the compressed patterns correctly, and end
1033 // up with blanks, i.e. dead triplets. Those are marked
1034 // with cmd == 0xff. Let's ignore them.
1035 }
1036 else if (track[row].fxcnt<3)
1037 {
1038 // effect, param
1039 if (cmd > 0x97)
1040 {
1041 CLEAN_UP
1042 return MP_LOADER_FAILED;
1043 }
1044 track[row].effect[track[row].fxcnt]=cmd&0x7f;
1045 track[row].parameter[track[row].fxcnt]=arg;
1046 track[row].fxcnt++;
1047 }
1048 else
1049 {
1050 CLEAN_UP
1051 return MP_LOADER_FAILED;
1052 }
1053 }
1054 }
1055
1056 // ---- convert tracks to patterns ----
1057 for (i = 0; i < header->ordnum; i++)
1058 {
1059 phead[i].rows = rows[i];
1060 phead[i].channum = (mp_ubyte)header->channum;
1061 phead[i].effnum = 3;
1062
1063 mp_sint32 slotSize = (mp_sint32)(2+phead[i].effnum*2);
1064 mp_sint32 patSize = (mp_sint32)phead[i].rows*(mp_sint32)header->channum*slotSize;
1065 phead[i].patternData = new mp_ubyte[patSize];
1066
1067 // out of memory?
1068 if (phead[i].patternData == NULL)
1069 {
1070 CLEAN_UP
1071 return MP_OUT_OF_MEMORY;
1072 }
1073
1074 memset(phead[i].patternData, 0, patSize);
1075
1076 for (mp_sint32 row = 0; row < phead[i].rows; row++)
1077 for (mp_sint32 chn = 0; chn < phead[i].channum; chn++)
1078 {
1079 j = amfOrders[i*phead[i].channum+chn];
1080 if (j && j <= numTracks)
1081 {
1082 j = trackTable[j-1];
1083 if (j && j <= maxTracks)
1084 {
1085 AMFNoteSlot* track = tracks[j-1];
1086
1087 mp_ubyte* dstSlot = phead[i].patternData+row*phead[i].channum*slotSize+chn*slotSize;
1088
1089 // convert note slot
1090 if (track[row].note)
1091 dstSlot[0] = track[row].note - 12;
1092 dstSlot[1] = track[row].instr;
1093
1094 mp_sint32 l = 0;
1095 for (k = 0; k < track[row].fxcnt; k++)
1096 {
1097 mp_ubyte nEff = 0;
1098 mp_ubyte nOp = 0;
1099 mp_sbyte op = track[row].parameter[k];
1100
1101 switch (track[row].effect[k])
1102 {
1103 // Set speed (ticks)
1104 case 0x01:
1105 nEff = 0x1C;
1106 nOp = op;
1107 break;
1108
1109 // Volume slide
1110 case 2:
1111 nEff = 0x0A;
1112 if (op)
1113 {
1114 if (op>=0)
1115 nOp = ((op&0xf)<<4);
1116 else
1117 nOp = (-op)&0xf;
1118 }
1119 break;
1120
1121 // set volume
1122 case 0x03:
1123 nEff = 0x0C;
1124 nOp = XModule::vol64to255(op);
1125 break;
1126
1127 // portamento up/down
1128 case 0x04:
1129 if (op >= 0)
1130 {
1131 nEff = 0x02;
1132 nOp = op & 0xf;
1133 }
1134 else
1135 {
1136 nEff = 0x01;
1137 nOp = (-op) & 0xf;
1138 }
1139 break;
1140
1141 // Porta to note
1142 case 0x06:
1143 nEff = 0x03;
1144 nOp = op;
1145 break;
1146
1147 // tremor
1148 case 0x07:
1149 nEff = 0x1D;
1150 nOp = op;
1151 break;
1152
1153 // arpeggio
1154 case 0x08:
1155 nEff = 0x20;
1156 nOp = op;
1157 break;
1158
1159 // vibrato
1160 case 0x09:
1161 nEff = 0x04;
1162 nOp = op;
1163 break;
1164
1165 // Porta + Volume slide
1166 case 0xA:
1167 nEff = 0x05;
1168 if (op)
1169 {
1170 if (op>=0)
1171 nOp = ((op&0xf)<<4);
1172 else
1173 nOp = (-op) & 0xf;
1174 }
1175 break;
1176
1177 // Vibrato + Volume slide
1178 case 0xB:
1179 nEff = 0x06;
1180 if (op)
1181 {
1182 if (op>=0)
1183 nOp = ((op&0xf)<<4);
1184 else
1185 nOp = (-op) & 0xf;
1186 }
1187 break;
1188
1189 // Pattern break (in hex)
1190 case 0xC:
1191 nEff = 0x0D;
1192 nOp = (op/10)*16 + (op%10);
1193 break;
1194
1195 // Pos. jump
1196 case 0xD:
1197 nEff = 0x0B;
1198 nOp = op;
1199 break;
1200
1201 // Retrig
1202 case 0xF:
1203 nEff = 0x1B;
1204 nOp = op;
1205 break;
1206
1207 // Sample offset
1208 case 0x10:
1209 nEff = 0x09;
1210 nOp = op;
1211 break;
1212
1213 // Fine Volume slide
1214 case 0x11:
1215 if (op)
1216 {
1217 if (op>=0)
1218 {
1219 nEff = 0x3A;
1220 nOp = op & 0x0f;
1221 }
1222 else
1223 {
1224 nEff = 0x3B;
1225 nOp = (-op) & 0x0f;
1226 }
1227 }
1228 break;
1229
1230 // Fine Porta
1231 case 0x12:
1232 if (op)
1233 {
1234 if (op>=0)
1235 {
1236 nEff = 0x32;
1237 nOp = op & 0x0f;
1238 }
1239 else
1240 {
1241 nEff = 0x31;
1242 nOp = (-op) & 0x0f;
1243 }
1244 }
1245 break;
1246
1247 // Note delay
1248 case 0x13:
1249 nEff = 0x3D;
1250 nOp = op;
1251 break;
1252
1253 // Note cut
1254 case 0x14:
1255 nEff = 0x3C;
1256 nOp = op;
1257 break;
1258
1259 // Set tempo (bpm)
1260 case 0x15:
1261 nEff = 0x16;
1262 nOp = op;
1263 break;
1264
1265 // Set panning
1266 case 0x17:
1267 if (op > 64)
1268 {
1269 nEff = 0x08;
1270 nOp = XModule::vol64to255(op);
1271 }
1272 break;
1273 }
1274
1275 // put volume in first command
1276 // otherwise in second
1277 if (l == 0 && nEff != 0x0C)
1278 {
1279 l = 1;
1280 }
1281 // if not first effect search for empty effect slot
1282 else
1283 {
1284 for (mp_sint32 m = 0; m < phead[i].effnum; m++)
1285 if (!dstSlot[2+m*2])
1286 {
1287 l = m;
1288 break;
1289 }
1290 }
1291
1292 if (nEff)
1293 {
1294 dstSlot[2+l*2] = nEff;
1295 dstSlot[2+l*2+1] = nOp;
1296 }
1297 }
1298 }
1299 }
1300 }
1301 }
1302
1303 CLEAN_UP
1304
1305 mp_sint32 result = module->loadModuleSamples(f, XModule::ST_DEFAULT);
1306 if (result != MP_OK)
1307 return result;
1308
1309 // --- kick out duplicate patterns ---
1310 mp_ubyte patReloc[255];
1311 memset(patReloc, 0xFF, sizeof(patReloc));
1312
1313 for (i = 0; i < header->patnum; i++)
1314 {
1315 if (patReloc[i] == 0xFF)
1316 {
1317 for (j = 0; j < header->patnum; j++)
1318 {
1319 if ((j != i && patReloc[j] == 0xFF) &&
1320 phead[i].rows == phead[j].rows &&
1321 phead[i].channum == phead[j].channum &&
1322 phead[i].effnum == phead[j].effnum)
1323 {
1324 mp_sint32 slotSize = (mp_sint32)(2+phead[i].effnum*2);
1325 mp_sint32 patSize = (mp_sint32)phead[i].rows*(mp_sint32)header->channum*slotSize;
1326
1327 if (memcmp(phead[i].patternData, phead[j].patternData, patSize) == 0)
1328 {
1329 patReloc[j] = i;
1330 }
1331 }
1332 }
1333 }
1334 }
1335
1336 for (i = 0; i < header->ordnum; i++)
1337 {
1338 if (patReloc[header->ord[i]] != 255)
1339 header->ord[i] = patReloc[header->ord[i]];
1340 }
1341
1342 module->removeUnusedPatterns(false);
1343
1344 strcpy(header->tracker,"..converted..");
1345
1346 module->setDefaultPanning();
1347
1348 module->postProcessSamples();
1349
1350 return MP_OK;
1351 }
1352
1353 #endif
1354