1 /* OpenCP Module Player
2 * copyright (c) '94-'21 Niklas Beisert <nbeisert@physik.tu-muenchen.de>
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17 *
18 * GMDPlay loader for DigiTrakker modules
19 *
20 * revision history: (please note changes here)
21 * -nb980510 Niklas Beisert <nbeisert@physik.tu-muenchen.de>
22 * -first release
23 */
24
25 #include "config.h"
26 #include <string.h>
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include "types.h"
30 #include "boot/plinkman.h"
31 #include "dev/mcp.h"
32 #include "filesel/filesystem.h"
33 #include "gmdplay.h"
34 #include "stuff/err.h"
35
36 static uint8_t *ibuf;
37 static uint8_t bitnum;
38 static uint32_t bitlen;
39
readbits(uint8_t n)40 static inline uint16_t readbits(uint8_t n)
41 {
42 uint16_t retval=0;
43 int offset = 0;
44 while (n)
45 {
46 int m=n;
47
48 if (!bitlen)
49 {
50 fprintf(stderr, "readbits: ran out of buffer\n");
51 return 0;
52 }
53
54 if (m>bitnum)
55 m=bitnum;
56 retval|=(*ibuf&((1L<<m)-1))<<offset;
57 *ibuf>>=m;
58 n-=m;
59 offset+=m;
60 if ( ! ( bitnum-=m ) )
61 {
62 bitlen--;
63 ibuf++;
64 bitnum=8;
65 }
66 }
67 return retval;
68 }
69
70
71
72
73 /*
74 static short vibsintab[256]=
75 { 0, 50, 100, 151, 201, 251, 301, 350,
76 400, 449, 498, 546, 595, 642, 690, 737,
77 784, 830, 876, 921, 965, 1009, 1053, 1096,
78 1138, 1179, 1220, 1260, 1299, 1338, 1375, 1412,
79 1448, 1483, 1517, 1551, 1583, 1615, 1645, 1674,
80 1703, 1730, 1757, 1782, 1806, 1829, 1851, 1872,
81 1892, 1911, 1928, 1945, 1960, 1974, 1987, 1998,
82 2009, 2018, 2026, 2033, 2038, 2042, 2046, 2047,
83 2048, 2047, 2046, 2042, 2038, 2033, 2026, 2018,
84 2009, 1998, 1987, 1974, 1960, 1945, 1928, 1911,
85 1892, 1872, 1851, 1829, 1806, 1782, 1757, 1730,
86 1703, 1674, 1645, 1615, 1583, 1551, 1517, 1483,
87 1448, 1412, 1375, 1338, 1299, 1260, 1220, 1179,
88 1138, 1096, 1053, 1009, 965, 921, 876, 830,
89 784, 737, 690, 642, 595, 546, 498, 449,
90 400, 350, 301, 251, 201, 151, 100, 50,
91 0, -50, -100, -151, -201, -251, -301, -350,
92 -400, -449, -498, -546, -595, -642, -690, -737,
93 -784, -830, -876, -921, -965, -1009, -1053, -1096,
94 -1138, -1179, -1220, -1260, -1299, -1338, -1375, -1412,
95 -1448, -1483, -1517, -1551, -1583, -1615, -1645, -1674,
96 -1703, -1730, -1757, -1782, -1806, -1829, -1851, -1872,
97 -1892, -1911, -1928, -1945, -1960, -1974, -1987, -1998,
98 -2009, -2018, -2026, -2033, -2038, -2042, -2046, -2047,
99 -2048, -2047, -2046, -2042, -2038, -2033, -2026, -2018,
100 -2009, -1998, -1987, -1974, -1960, -1945, -1928, -1911,
101 -1892, -1872, -1851, -1829, -1806, -1782, -1757, -1730,
102 -1703, -1674, -1645, -1615, -1583, -1551, -1517, -1483,
103 -1448, -1412, -1375, -1338, -1299, -1260, -1220, -1179,
104 -1138, -1096, -1053, -1009, -965, -921, -876, -830,
105 -784, -737, -690, -642, -595, -546, -498, -449,
106 -400, -350, -301, -251, -201, -151, -100, -50};
107 */
108
putcmd(unsigned char ** p,unsigned char c,unsigned char d)109 static inline void putcmd(unsigned char **p, unsigned char c, unsigned char d)
110 {
111 *(*p)++=c;
112 *(*p)++=d;
113 }
114
115 struct LoadMDLResources
116 {
117 struct gmdsample **msmps;
118 unsigned int *inssampnum;
119 };
120
FreeResources(struct LoadMDLResources * r)121 static void FreeResources (struct LoadMDLResources *r)
122 {
123 int j;
124 if (r->msmps)
125 {
126 for (j=0; j<255; j++)
127 {
128 if (r->msmps[j])
129 free(r->msmps[j]);
130 }
131 free(r->msmps);
132 r->msmps=0;
133 }
134 if (r->inssampnum)
135 {
136 free(r->inssampnum);
137 r->inssampnum=0;
138 }
139 }
140
_mpLoadMDL(struct gmdmodule * m,struct ocpfilehandle_t * file)141 static int _mpLoadMDL(struct gmdmodule *m, struct ocpfilehandle_t *file)
142 {
143 uint32_t waste32;
144 uint16_t waste16;
145 uint8_t waste8;
146
147 uint32_t blklen;
148 uint16_t blktype;
149
150 struct __attribute__((packed))
151 {
152 char name[32];
153 char composer[20];
154 uint16_t ordnum;
155 uint16_t repstart;
156 uint8_t mainvol;
157 uint8_t speed;
158 uint8_t bpm;
159 uint8_t pan[32];
160 } mdlhead;
161
162 unsigned int i,j,k;
163
164 uint8_t ordtab[256];
165 uint8_t patnum;
166
167 uint16_t ntracks;
168
169 uint8_t **trackends;
170 uint8_t **trackptrs;
171 uint8_t *trackbuf;
172 uint8_t (*patdata)[256][6];
173 uint8_t *temptrack;
174 int tpos;
175 uint8_t smpsav;
176 uint8_t packtype[255];
177
178 uint8_t inssav;
179 unsigned int smpnum;
180
181 struct LoadMDLResources r;
182 r.msmps = 0;
183 r.inssampnum = 0;
184
185 mpReset(m);
186
187 if (ocpfilehandle_read_uint32_le (file, &waste32))
188 {
189 fprintf(stderr, __FILE__ ": fread() failed #1\n");
190 return errFormStruc;
191 }
192 if (waste32!=0x4C444D44)
193 return errFormSig;
194
195 if (ocpfilehandle_read_uint8 (file, &waste8))
196 {
197 fprintf(stderr, __FILE__ ": fread() failed #2\n");
198 return errFormStruc;
199 }
200 if ((waste8&0x10)!=0x10)
201 {
202 fprintf(stderr, "Sorry, the file version is too old (load and resave it in DigiTrakker please)\n");
203 return errFormSig;
204 }
205
206 if (ocpfilehandle_read_uint16_le (file, &waste16))
207 {
208 fprintf(stderr, __FILE__ ": fread() failed #3\n");
209 return errFormStruc;
210 }
211 if (waste16!=0x4E49)
212 return errFormStruc;
213
214 if (ocpfilehandle_read_uint32_le (file, &blklen))
215 {
216 fprintf(stderr, __FILE__ ": fread() failed #4\n");
217 return errFormStruc;
218 }
219
220 if (file->read (file, &mdlhead, sizeof(mdlhead)) != sizeof(mdlhead))
221 {
222 fprintf(stderr, __FILE__ ": fread() failed #5\n");
223 return errFormStruc;
224 }
225 mdlhead.ordnum = uint16_little (mdlhead.ordnum);
226 mdlhead.repstart = uint16_little (mdlhead.repstart);
227
228 for (i=0; i<32; i++)
229 if (mdlhead.pan[i]&0x80)
230 break;
231 m->channum=i;
232 memcpy(m->name, mdlhead.name, 31);
233 m->name[31]=0;
234 memcpy(m->composer, mdlhead.composer, 20);
235 m->composer[20]=0;
236 m->ordnum=mdlhead.ordnum;
237 m->endord=m->ordnum;
238 m->loopord=mdlhead.repstart;
239 m->options=MOD_EXPOFREQ|MP_OFFSETDIV2;
240
241 if (mdlhead.ordnum>256)
242 return errFormSupp;
243
244 if (file->read (file, ordtab, mdlhead.ordnum) != mdlhead.ordnum)
245 {
246 fprintf(stderr, __FILE__ ": fread() failed #6\n");
247 return errFormStruc;
248 }
249 file->seek_cur (file, 8*m->channum);
250 file->seek_cur (file, blklen - 8 * m->channum - 91 - mdlhead.ordnum);
251
252 if (ocpfilehandle_read_uint16_le (file, &blktype))
253 {
254 fprintf(stderr, __FILE__ ": fread() failed #7\n");
255 return errFormStruc;
256 }
257 if (ocpfilehandle_read_uint32_le (file, &blklen))
258 {
259 fprintf(stderr, __FILE__ ": fread() failed #8\n");
260 return errFormStruc;
261 }
262 blklen = uint32_little (blklen);
263
264 if (blktype==0x454D)
265 {
266 file->seek_cur (file, blklen);
267 if (ocpfilehandle_read_uint16_le (file, &blktype))
268 {
269 fprintf(stderr, __FILE__ ": fread() failed #9\n");
270 return errFormStruc;
271 }
272 if (ocpfilehandle_read_uint32_le (file, &blklen))
273 {
274 fprintf(stderr, __FILE__ ": fread() failed #10\n");
275 return errFormStruc;
276 }
277 /* songmessage; every line is closed with the CR-char (13). A
278 * 0-byte stands at the end of the whole text.
279 */
280 }
281
282 if (blktype!=0x4150)
283 return errFormStruc;
284 if (ocpfilehandle_read_uint8 (file, &patnum))
285 {
286 fprintf(stderr, __FILE__ ": fread() failed #11\n");
287 return errFormStruc;
288 }
289 m->patnum=patnum+1;
290 m->tracknum=patnum*(m->channum+1)+1;
291
292 if (!mpAllocPatterns(m, m->patnum)||!mpAllocOrders(m, m->ordnum)||!mpAllocTracks(m, m->tracknum))
293 return errAllocMem;
294
295 for (j=0; j<patnum; j++)
296 {
297 uint8_t chnn;
298 int i;
299 if (ocpfilehandle_read_uint8 (file, &chnn))
300 {
301 fprintf(stderr, __FILE__ ": fread() failed #12\n");
302 return errFormStruc;
303 }
304
305 if (ocpfilehandle_read_uint8 (file, &waste8))
306 {
307 fprintf(stderr, __FILE__ ": fread() failed #13\n");
308 return errFormStruc;
309 }
310 m->patterns[j].patlen = waste8 + 1;
311
312 if (file->read (file, m->patterns[j].name, 16) != 16)
313 {
314 fprintf(stderr, __FILE__ ": fread() failed #14\n");
315 return errFormStruc;
316 }
317 m->patterns[j].name[16]=0;
318 memset(m->patterns[j].tracks, 0, 32*2);
319 if (file->read (file, m->patterns[j].tracks, 2 * chnn) != (2 * chnn))
320 {
321 fprintf(stderr, __FILE__ ": fread() failed #15\n");
322 return errFormStruc;
323 }
324 for(i=0;i<chnn;i++)
325 m->patterns[j].tracks[i] = uint16_little (m->patterns[j].tracks[i]);
326 }
327
328 if (ocpfilehandle_read_uint16_le (file, &waste16))
329 {
330 fprintf(stderr, __FILE__ ": fread() failed #16\n");
331 return errFormStruc;
332 }
333 if (waste16!=0x5254)
334 return errFormStruc;
335 if (ocpfilehandle_read_uint32_le (file, &blklen))
336 {
337 fprintf(stderr, __FILE__ ": fread() failed #17\n");
338 return errFormStruc;
339 }
340
341 if (ocpfilehandle_read_uint16_le (file, &ntracks))
342 {
343 fprintf(stderr, __FILE__ ": fread() failed #18\n");
344 return errFormStruc;
345 }
346
347 trackends=malloc(sizeof(uint8_t *)*ntracks+1);
348 trackptrs=malloc(sizeof(uint8_t *)*ntracks+1);
349 trackbuf=malloc(sizeof(uint8_t)*(blklen-2-2*ntracks));
350
351 patdata=malloc(sizeof(uint8_t)*m->channum*256*6);
352 temptrack=malloc(sizeof(uint8_t)*3000);
353
354 if (!trackends||!trackptrs||!trackbuf||!patdata||!temptrack)
355 return errAllocMem;
356
357 trackptrs[0]=trackbuf;
358 trackends[0]=trackbuf;
359 tpos=0;
360 for (i=0; i<ntracks; i++)
361 {
362 uint16_t l;
363 if (ocpfilehandle_read_uint16_le (file, &l))
364 {
365 fprintf(stderr, __FILE__ ": fread() failed #19\n");
366 return errFormStruc;
367 }
368 trackptrs[1+i]=trackbuf+tpos;
369 if (file->read (file, trackbuf+tpos, l) != l)
370 {
371 fprintf(stderr, __FILE__ ": fread() failed #20\n");
372 return errFormStruc;
373 }
374 tpos+=l;
375 trackends[1+i]=trackbuf+tpos;
376 }
377
378 for (i=0; i<m->ordnum; i++)
379 m->orders[i]=(ordtab[i]<patnum)?ordtab[i]:patnum;
380
381 for (i=0; i<32; i++)
382 m->patterns[patnum].tracks[i]=m->tracknum-1;
383 m->patterns[patnum].gtrack=m->tracknum-1;
384 m->patterns[patnum].patlen=64;
385
386 for (j=0; j<patnum; j++)
387 {
388 uint8_t *tp;
389 uint8_t *buf;
390 int row;
391 struct gmdtrack *trk;
392 uint16_t len;
393
394 memset(patdata, 0, m->channum*256*6);
395 for (i=0; i<m->channum; i++)
396 {
397 uint8_t *trkptr=trackptrs[m->patterns[j].tracks[i]];
398 uint8_t *endptr=trackends[m->patterns[j].tracks[i]];
399 int row=0;
400
401 while (trkptr<endptr)
402 {
403 uint8_t p=*trkptr++;
404 switch (p&3)
405 {
406 case 0:
407 row+=p>>2;
408 break;
409 case 1:
410 for (k=0; k<((p>>2)+(unsigned)1); k++)
411 memcpy(patdata[i][row+k], patdata[i][row-1], 6);
412 row+=p>>2;
413 break;
414 case 2:
415 memcpy(patdata[i][row], patdata[i][p>>2], 6);
416 break;
417 case 3:
418 for (k=0; k<6; k++)
419 if (p&(4<<k))
420 patdata[i][row][k]=*trkptr++;
421 break;
422 }
423 row++;
424 }
425 }
426
427 for (i=0; i<m->channum; i++)
428 m->patterns[j].tracks[i]=j*(m->channum+1)+i;
429 m->patterns[j].gtrack=j*(m->channum+1)+m->channum;
430
431 for (i=0; i<m->channum; i++)
432 {
433 uint8_t *tp=temptrack;
434 uint8_t *buf=patdata[i][0];
435
436 struct gmdtrack *trk;
437 uint16_t len;
438
439 int row;
440 for (row=0; row<m->patterns[j].patlen; row++, buf+=6)
441 {
442 uint8_t *cp=tp+2;
443
444 uint8_t command1=buf[3]&0xF;
445 uint8_t command2=buf[3]>>4;
446 uint8_t data1=buf[4];
447 uint8_t data2=buf[5];
448 int16_t ins=buf[1]-1;
449 int16_t nte=buf[0];
450 int16_t pan=-1;
451 int16_t vol=buf[2];
452 uint16_t ofs=0;
453 if (!vol)
454 vol=-1;
455
456 if (command1==0xE)
457 {
458 command1=(data1&0xF0)|0xE;
459 data1&=0xF;
460 if (command1==0xFE)
461 ofs=(data1<<8)|data2;
462 }
463 if (command2==0xE)
464 {
465 command2=(data2&0xF0)|0xE;
466 data2&=0xF;
467 }
468
469 if (!row&&(j==ordtab[0]))
470 putcmd(&cp, cmdPlayNote|cmdPlayPan, mdlhead.pan[i]*2);
471
472 if (command1==0x8)
473 pan=data1*2;
474
475 if (command2==0x8)
476 pan=data2*2;
477
478 if ((command1==0x3)&&nte&&(nte!=255))
479 nte|=128;
480
481 if ((ins!=-1)||nte||(vol!=-1)||(pan!=-1))
482 {
483 unsigned char *act=cp;
484 *cp++=cmdPlayNote;
485 if (ins!=-1)
486 {
487 *act|=cmdPlayIns;
488 *cp++=ins;
489 }
490 if (nte&&(nte!=255))
491 {
492 *act|=cmdPlayNte;
493 *cp++=nte+11;
494 }
495 if (vol!=-1)
496 {
497 *act|=cmdPlayVol;
498 *cp++=vol;
499 }
500 if (pan!=-1)
501 {
502 *act|=cmdPlayPan;
503 *cp++=pan;
504 }
505 if (command1==0xDE)
506 {
507 *act|=cmdPlayDelay;
508 *cp++=data1;
509 } else if (command2==0xDE)
510 {
511 *act|=cmdPlayDelay;
512 *cp++=data2;
513 }
514
515 if (nte==255)
516 putcmd(&cp, cmdKeyOff, 0);
517 }
518 /* E8x - Set Sample Status
519 * x=0 no loop, x=1 loop, unidirectional, x=3 loop, bidirectional
520 */
521 switch (command1)
522 {
523 case 0x1:
524 if (!data1)
525 putcmd(&cp, cmdSpecial, cmdContMixPitchSlideUp);
526 else
527 if (data1<0xE0)
528 putcmd(&cp, cmdPitchSlideUp, data1);
529 else
530 if (data1<0xF0)
531 putcmd(&cp, cmdRowPitchSlideUp, (data1&0xF)<<1);
532 else
533 putcmd(&cp, cmdRowPitchSlideUp, (data1&0xF)<<4);
534 break;
535 case 0x2:
536 if (!data1)
537 putcmd(&cp, cmdSpecial, cmdContMixPitchSlideDown);
538 else
539 if (data1<0xE0)
540 putcmd(&cp, cmdPitchSlideDown, data1);
541 else
542 if (data1<0xF0)
543 putcmd(&cp, cmdRowPitchSlideDown, (data1&0xF)<<1);
544 else
545 putcmd(&cp, cmdRowPitchSlideDown, (data1&0xF)<<4);
546 break;
547 case 0x3:
548 putcmd(&cp, cmdPitchSlideToNote, data1);
549 break;
550 case 0x4:
551 putcmd(&cp, cmdPitchVibrato, data1);
552 break;
553 case 0x5:
554 putcmd(&cp, cmdArpeggio, data1);
555 break;
556 case 0x1E:
557 putcmd(&cp, cmdRowPanSlide, -data1*2);
558 break;
559 case 0x2E:
560 putcmd(&cp, cmdRowPanSlide, data1*2);
561 break;
562 case 0x3E:
563 putcmd(&cp, cmdSpecial, data1?cmdGlissOn:cmdGlissOff);
564 break;
565 case 0x4E:
566 if (data1<4)
567 putcmd(&cp, cmdPitchVibratoSetWave, data1);
568 break;
569 case 0x7E:
570 if (data1<4)
571 putcmd(&cp, cmdVolVibratoSetWave, data1);
572 break;
573 case 0x9E:
574 putcmd(&cp, cmdRetrig, data1);
575 break;
576 case 0xCE:
577 putcmd(&cp, cmdNoteCut, data1);
578 break;
579 case 0xFE:
580 if (ofs&0xF00)
581 putcmd(&cp, cmdOffsetHigh, ofs>>8);
582 putcmd(&cp, cmdOffset, ofs);
583 break;
584 }
585
586 switch (command2)
587 {
588 case 0x1:
589 if (data2<0xE0)
590 putcmd(&cp, cmdVolSlideUp, data2);
591 else
592 if (data2<0xF0)
593 putcmd(&cp, cmdRowVolSlideUp, data2&0xF);
594 else
595 putcmd(&cp, cmdRowVolSlideUp, (data2&0xF)<<2);
596 break;
597 case 0x2:
598 if (data2<0xE0)
599 putcmd(&cp, cmdVolSlideDown, data2);
600 else
601 if (data2<0xF0)
602 putcmd(&cp, cmdRowVolSlideDown, data2&0xF);
603 else
604 putcmd(&cp, cmdRowVolSlideDown, (data2&0xF)<<2);
605 break;
606 case 0x4:
607 putcmd(&cp, cmdVolVibrato, data2);
608 break;
609 case 0x5:
610 putcmd(&cp, cmdTremor, data2);
611 break;
612 case 0x1E:
613 putcmd(&cp, cmdRowPanSlide, -data2*2);
614 break;
615 case 0x2E:
616 putcmd(&cp, cmdRowPanSlide, data2*2);
617 break;
618 case 0x3E:
619 putcmd(&cp, cmdSpecial, data1?cmdGlissOn:cmdGlissOff);
620 break;
621 case 0x4E:
622 if (data2<4)
623 putcmd(&cp, cmdPitchVibratoSetWave, data2);
624 break;
625 case 0x7E:
626 if (data2<4)
627 putcmd(&cp, cmdVolVibratoSetWave, data2);
628 break;
629 case 0x9E:
630 putcmd(&cp, cmdRetrig, data2);
631 break;
632 case 0xCE:
633 putcmd(&cp, cmdNoteCut, data2);
634 break;
635 }
636
637 if (cp!=(tp+2))
638 {
639 tp[0]=row;
640 tp[1]=cp-tp-2;
641 tp=cp;
642 }
643 }
644
645 trk=&m->tracks[j*(m->channum+1)+i];
646 len=tp-temptrack;
647
648 if (!len)
649 trk->ptr=trk->end=0;
650 else {
651 trk->ptr=malloc(sizeof(uint8_t)*len);
652 trk->end=trk->ptr+len;
653 if (!trk->ptr)
654 return errAllocMem;
655 memcpy(trk->ptr, temptrack, len);
656 }
657 }
658
659 tp=temptrack;
660 buf=**patdata;
661
662 for (row=0; row<m->patterns[j].patlen; row++, buf+=6)
663 {
664 uint8_t *cp=tp+2;
665
666 unsigned int q;
667
668 if (!row&&(j==ordtab[0]))
669 {
670 if (mdlhead.speed!=6)
671 putcmd(&cp, cmdTempo, mdlhead.speed);
672 if (mdlhead.bpm!=125)
673 putcmd(&cp, cmdSpeed, mdlhead.bpm);
674 if (mdlhead.mainvol!=255)
675 putcmd(&cp, cmdGlobVol, mdlhead.mainvol);
676 }
677
678 for (q=0; q<m->channum; q++)
679 {
680 uint8_t command1=buf[256*6*q+3]&0xF;
681 uint8_t command2=buf[256*6*q+3]>>4;
682 uint8_t data1=buf[256*6*q+4];
683 uint8_t data2=buf[256*6*q+5];
684
685 switch (command1)
686 {
687 case 0x7:
688 if (data1)
689 putcmd(&cp, cmdSpeed, data1);
690 break;
691 case 0xB:
692 putcmd(&cp, cmdGoto, data1);
693 break;
694 case 0xD:
695 putcmd(&cp, cmdBreak, (data1&0x0F)+(data1>>4)*10);
696 break;
697 case 0xE:
698 switch (data1>>4)
699 {
700 case 0x6:
701 putcmd(&cp, cmdSetChan, q);
702 putcmd(&cp, cmdPatLoop, data1&0xF);
703 break;
704 case 0xE:
705 putcmd(&cp, cmdPatDelay, data1&0xF);
706 break;
707 case 0xA:
708 putcmd(&cp, cmdGlobVolSlide, data1&0xF);
709 break;
710 case 0xB:
711 putcmd(&cp, cmdSetChan, q);
712 putcmd(&cp, cmdGlobVolSlide, -(data1&0xF));
713 break;
714 }
715 break;
716 case 0xF:
717 if (data1)
718 putcmd(&cp, cmdTempo, data1);
719 break;
720 case 0xC:
721 putcmd(&cp, cmdGlobVol, data1);
722 break;
723 }
724 switch (command2)
725 {
726 case 0x7:
727 if (data2)
728 putcmd(&cp, cmdSpeed, data2);
729 break;
730 case 0xB:
731 putcmd(&cp, cmdGoto, data2);
732 break;
733 case 0xD:
734 putcmd(&cp, cmdBreak, (data2&0x0F)+(data2>>4)*10);
735 break;
736 case 0xE:
737 switch (data2>>4)
738 {
739 case 0x6:
740 putcmd(&cp, cmdSetChan, q);
741 putcmd(&cp, cmdPatLoop, data2&0xF);
742 break;
743 case 0xE:
744 putcmd(&cp, cmdPatDelay, data2&0xF);
745 break;
746 case 0xA:
747 putcmd(&cp, cmdGlobVolSlide, data2&0xF);
748 break;
749 case 0xB:
750 putcmd(&cp, cmdSetChan, q);
751 putcmd(&cp, cmdGlobVolSlide, -(data2&0xF));
752 break;
753 }
754 break;
755 case 0xF:
756 if (data2)
757 putcmd(&cp, cmdTempo, data2);
758 break;
759 case 0xC:
760 putcmd(&cp, cmdGlobVol, data2);
761 break;
762 }
763 }
764
765 if (cp!=(tp+2))
766 {
767 tp[0]=row;
768 tp[1]=cp-tp-2;
769 tp=cp;
770 }
771 }
772
773 trk=&m->tracks[j*(m->channum+1)+m->channum];
774 len=tp-temptrack;
775
776 if (!len)
777 trk->ptr=trk->end=0;
778 else {
779 trk->ptr=malloc(sizeof(uint8_t)*len);
780 trk->end=trk->ptr+len;
781 if (!trk->ptr)
782 return errAllocMem;
783 memcpy(trk->ptr, temptrack, len);
784 }
785 }
786 free(temptrack);
787 free(trackends);
788 free(trackptrs);
789 free(trackbuf);
790 free(patdata);
791
792 if (ocpfilehandle_read_uint16_le (file, &waste16))
793 {
794 fprintf(stderr, __FILE__ ": fread() failed #21\n");
795 return errFormStruc;
796 }
797 if (waste16!=0x4949)
798 return errFormStruc;
799 if (ocpfilehandle_read_uint32_le (file, &blklen))
800 {
801 fprintf(stderr, __FILE__ ": fread() failed #22\n");
802 return errFormStruc;
803 }
804
805 inssav=0;
806 if (ocpfilehandle_read_uint8 (file, &inssav))
807 {
808 fprintf(stderr, __FILE__ ": fread() failed #23\n");
809 return errFormStruc;
810 }
811
812 m->instnum=255;
813 m->modsampnum=0;
814 m->envnum=192;
815
816 /* envelope **envs=new envelope *[255]; */
817 r.msmps=calloc(sizeof(struct gmdsample *), 255);
818 r.inssampnum=calloc(sizeof(int), 255);
819 /* int *insenvnum=new int [255]; */
820 if (/*!envs||!insenvnum||*/!r.inssampnum||!r.msmps||!mpAllocInstruments(m, m->instnum))
821 {
822 FreeResources(&r);
823 return errAllocMem;
824 }
825
826 /* memset(envs, 0, 4*255); */
827 /* memset(insenvnum, 0, 4*255); */
828
829 for (j=0; j<inssav; j++)
830 {
831 uint8_t insnum;
832 struct gmdinstrument *ip;
833 int note;
834
835 if (ocpfilehandle_read_uint8 (file, &insnum))
836 {
837 fprintf(stderr, __FILE__ ": fread() failed #24\n");
838 FreeResources(&r);
839 return errFormStruc;
840 }
841 insnum--;
842
843 ip=&m->instruments[insnum];
844
845 if (ocpfilehandle_read_uint8 (file, &waste8))
846 {
847 fprintf(stderr, __FILE__ ": fread() failed #25\n");
848 FreeResources(&r);
849 return errFormStruc;
850 }
851 r.inssampnum[j] = waste8;
852 if (file->read (file, ip->name, 32) != 32)
853 {
854 fprintf(stderr, __FILE__ ": fread() failed #26\n");
855 FreeResources(&r);
856 return errFormStruc;
857 }
858 ip->name[31]=0;
859 r.msmps[j]=malloc(sizeof(struct gmdsample)*r.inssampnum[j]);
860 /*
861 envs[insnum]=new envelope [r.inssampnum[j]];
862 */
863 if (!r.msmps[j]/*||!envs[insnum]*/)
864 {
865 FreeResources(&r);
866 return errAllocMem;
867 }
868
869 note=0;
870 for (i=0; i<r.inssampnum[j]; i++)
871 {
872 struct __attribute__((packed))
873 {
874 uint8_t smp;
875 uint8_t highnote;
876 uint8_t vol;
877 uint8_t volenv;
878 uint8_t pan;
879 uint8_t panenv;
880 uint16_t fadeout;
881 uint8_t vibspd;
882 uint8_t vibdep;
883 uint8_t vibswp;
884 uint8_t vibfrm;
885 uint8_t res1;
886 uint8_t pchenv;
887 } mdlmsmp;
888 struct gmdsample *sp;
889
890 if (file->read (file, &mdlmsmp, sizeof(mdlmsmp)) != sizeof(mdlmsmp))
891 {
892 fprintf(stderr, __FILE__ ": fread() failed #27\n");
893 FreeResources(&r);
894 return errFormStruc;
895 }
896 mdlmsmp.fadeout = uint16_little (mdlmsmp.fadeout);
897 if ((mdlmsmp.highnote+12)>128)
898 mdlmsmp.highnote=128-12;
899 while (note<(mdlmsmp.highnote+12))
900 ip->samples[note++]=m->modsampnum;
901 m->modsampnum++;
902
903 sp=&r.msmps[j][i];
904 *sp->name=0;
905 sp->handle=mdlmsmp.smp-1;
906 sp->normnote=0;
907 sp->stdvol=(mdlmsmp.volenv&0x40)?mdlmsmp.vol:-1;
908 sp->stdpan=(mdlmsmp.panenv&0x40)?mdlmsmp.pan*2:-1;
909 sp->opt=0;
910 sp->volfade=mdlmsmp.fadeout;
911 sp->vibspeed=0;
912 sp->vibdepth=mdlmsmp.vibdep*4;
913 sp->vibrate=mdlmsmp.vibspd<<7;
914 sp->vibsweep=0xFFFF/(mdlmsmp.vibswp+1);
915 sp->vibtype=mdlmsmp.vibfrm;
916 sp->pchint=4;
917 sp->volenv=(mdlmsmp.volenv&0x80)?(mdlmsmp.volenv&0x3F):0xFFFF;
918 sp->panenv=(mdlmsmp.panenv&0x80)?(64+(mdlmsmp.panenv&0x3F)):0xFFFF;
919 sp->pchenv=(mdlmsmp.pchenv&0x80)?(128+(mdlmsmp.pchenv&0x3F)):0xFFFF;;
920 /*
921 if (mdlmsmp.vibdep&&mdlmsmp.vibspd)
922 {
923 sp.vibenv=m.envnum++;
924
925 envelope &ep=envs[insnum][insenvnum[j]++];
926 ep.speed=0;
927 ep.opt=0;
928 ep.len=512;
929 ep.sustain=-1;
930 ep.loops=0;
931 ep.loope=512;
932 ep.env=new unsigned char [512];
933 if (!ep.env)
934 return errAllocMem;
935 unsigned char ph=0;
936 for (k=0; k<512; k++)
937 {
938 ph=k*mdlmsmp.vibspd/2;
939 switch (mdlmsmp.vibfrm)
940 {
941 case 0:
942 ep.env[k]=128+((mdlmsmp.vibdep*vibsintab[ph])>>10);
943 break;
944 case 1:
945 ep.env[k]=128+((mdlmsmp.vibdep*(64-(ph&128)))>>5);
946 break;
947 case 2:
948 ep.env[k]=128+((mdlmsmp.vibdep*(128-ph))>>6);
949 break;
950 case 3:
951 ep.env[k]=128+((mdlmsmp.vibdep*(ph-128))>>6);
952 break;
953 }
954 }
955 }
956 */
957 }
958 }
959
960 m->sampnum=255;
961 if (!mpAllocModSamples(m, m->modsampnum)||!mpAllocEnvelopes(m, m->envnum)||!mpAllocSamples(m, m->sampnum))
962 return errAllocMem;
963
964 smpnum=0;
965 /* int envnum=192; */
966 for (j=0; j<255; j++)
967 {
968 memcpy(m->modsamples+smpnum, r.msmps[j], sizeof (*m->modsamples)*r.inssampnum[j]);
969 smpnum+=r.inssampnum[j];
970 /*!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
971 * for (i=0; i<insenvnum[j]; i++)
972 * memcpy(&m.envelopes[envnum++], &envs[j][i], sizeof (*m.envelopes));*/
973 /* delete envs[j]; */
974 }
975 FreeResources(&r);
976 /* delete envs;*/
977 /* delete insenvnum;*/
978
979 if (ocpfilehandle_read_uint16_le (file, &blktype))
980 {
981 fprintf(stderr, __FILE__ ": fread() failed #28\n");
982 return errFormStruc;
983 }
984 if (ocpfilehandle_read_uint32_le (file, &blklen))
985 {
986 fprintf(stderr, __FILE__ ": fread() failed #29\n");
987 return errFormStruc;
988 }
989
990 if (blktype==0x4556)
991 {
992 uint8_t envnum;
993
994 if (ocpfilehandle_read_uint8 (file, &envnum))
995 {
996 fprintf(stderr, __FILE__ ": fread() failed #30\n");
997 return errFormStruc;
998 }
999 for (i=0; i<envnum; i++)
1000 {
1001 struct __attribute__((packed))
1002 {
1003 uint8_t num;
1004 uint8_t env[15][2];
1005 uint8_t sus;
1006 uint8_t loop;
1007 } env;
1008 struct gmdenvelope *e;
1009 int k,l;
1010
1011 if (file->read (file, &env, sizeof (env)) != sizeof (env))
1012 {
1013 fprintf(stderr, __FILE__ ": fread() failed #31\n");
1014 return errFormStruc;
1015 }
1016 if (env.env[0][0]!=1)
1017 continue;
1018 e=&m->envelopes[env.num];
1019
1020 e->type=((env.sus&16)?mpEnvSLoop:0)|((env.sus&32)?mpEnvLoop:0);
1021 e->speed=0;
1022 l=-1;
1023 for (j=0; j<15; j++)
1024 {
1025 if (!env.env[j][0])
1026 break;
1027 l+=env.env[j][0];
1028 if ((env.loop&15)==j)
1029 e->loops=l;
1030 if ((env.loop>>4)==j)
1031 e->loope=l;
1032 if ((env.sus&15)==j)
1033 {
1034 e->sloops=l;
1035 e->sloope=l+1;
1036 }
1037 }
1038 if ((e->type&mpEnvSLoop)&&(e->type&mpEnvLoop)&&(e->sloope>e->loope))
1039 {
1040 e->sloops=e->loops;
1041 e->sloope=e->loope;
1042 }
1043 e->len=l;
1044 e->env=malloc(sizeof(uint8_t)*(l+1));
1045 if (!e->env)
1046 return errAllocMem;
1047 l=1;
1048 e->env[0]=env.env[0][1]<<2;
1049 for (j=0; j<15; j++)
1050 {
1051 if (!env.env[j+1][0])
1052 break;
1053 for (k=1; k<=env.env[j+1][0]; k++)
1054 e->env[l++]=4*env.env[j][1]+4*k*(env.env[j+1][1]-env.env[j][1])/env.env[j+1][0];
1055 }
1056 }
1057
1058 if (ocpfilehandle_read_uint16_le (file, &blktype))
1059 {
1060 fprintf(stderr, __FILE__ ": fread() failed #32\n");
1061 return errFormStruc;
1062 }
1063 if (ocpfilehandle_read_uint32_le (file, &blklen))
1064 {
1065 fprintf(stderr, __FILE__ ": fread() failed #33\n");
1066 return errFormStruc;
1067 }
1068 }
1069
1070 if (blktype==0x4550)
1071 {
1072 uint8_t envnum;
1073 if (ocpfilehandle_read_uint8 (file, &envnum))
1074 {
1075 fprintf(stderr, __FILE__ ": fread() failed #34\n");
1076 return errFormStruc;
1077 }
1078 for (i=0; i<envnum; i++)
1079 {
1080 struct __attribute__((packed))
1081 {
1082 uint8_t num;
1083 uint8_t env[15][2];
1084 uint8_t sus;
1085 uint8_t loop;
1086 } env;
1087 struct gmdenvelope *e;
1088 int k,l;
1089
1090 if (file->read (file, &env, sizeof (env)) != sizeof (env))
1091 {
1092 fprintf(stderr, __FILE__ ": fread() failed #35\n");
1093 return errFormStruc;
1094 }
1095 if (env.env[0][0]!=1)
1096 continue;
1097 e=&m->envelopes[64+env.num];
1098
1099 e->type=((env.sus&16)?mpEnvSLoop:0)|((env.sus&32)?mpEnvLoop:0);
1100 e->speed=0;
1101 l=-1;
1102 for (j=0; j<15; j++)
1103 {
1104 if (!env.env[j][0])
1105 break;
1106 l+=env.env[j][0];
1107 if ((env.loop&15)==j)
1108 e->loops=l;
1109 if ((env.loop>>4)==j)
1110 e->loope=l;
1111 if ((env.sus&15)==j)
1112 {
1113 e->sloops=l;
1114 e->sloope=l+1;
1115 }
1116 }
1117 if ((e->type&mpEnvSLoop)&&(e->type&mpEnvLoop)&&(e->sloope>e->loope))
1118 {
1119 e->sloops=e->loops;
1120 e->sloope=e->loope;
1121 }
1122 e->len=l;
1123 e->env=malloc(sizeof(uint8_t)*(l+1));
1124 if (!e->env)
1125 return errAllocMem;
1126 l=1;
1127 e->env[0]=env.env[0][1]<<2;
1128 for (j=0; j<15; j++)
1129 {
1130 if (!env.env[j+1][0])
1131 break;
1132 for (k=1; k<=env.env[j+1][0]; k++)
1133 e->env[l++]=4*env.env[j][1]+4*k*(env.env[j+1][1]-env.env[j][1])/env.env[j+1][0];
1134 }
1135 }
1136
1137 if (ocpfilehandle_read_uint16_le (file, &blktype))
1138 {
1139 fprintf(stderr, __FILE__ ": fread() failed #36\n");
1140 return errFormStruc;
1141 }
1142 if (ocpfilehandle_read_uint32_le (file, &blklen))
1143 {
1144 fprintf(stderr, __FILE__ ": fread() failed #37\n");
1145 return errFormStruc;
1146 }
1147 }
1148
1149 if (blktype==0x4546)
1150 {
1151 uint8_t envnum;
1152 if (ocpfilehandle_read_uint8 (file, &envnum))
1153 {
1154 fprintf(stderr, __FILE__ ": fread() failed #38\n");
1155 return errFormStruc;
1156 }
1157
1158 for (i=0; i<envnum; i++)
1159 {
1160 struct __attribute__((packed))
1161 {
1162 uint8_t num;
1163 uint8_t env[15][2];
1164 uint8_t sus;
1165 uint8_t loop;
1166 } env;
1167
1168 struct gmdenvelope *e;
1169 int k,l;
1170
1171 if (file->read (file, &env, sizeof (env)) != sizeof (env))
1172 {
1173 fprintf(stderr, __FILE__ ": fread() failed #39\n");
1174 return errFormStruc;
1175 }
1176
1177 if (env.env[0][0]!=1)
1178 continue;
1179 e=&m->envelopes[128+env.num];
1180
1181 e->type=((env.sus&32)?mpEnvLoop:0)|((env.sus&16)?mpEnvSLoop:0);
1182 e->speed=0;
1183 l=-1;
1184 for (j=0; j<15; j++)
1185 {
1186 if (!env.env[j][0])
1187 break;
1188 l+=env.env[j][0];
1189 if ((env.loop&15)==j)
1190 e->loops=l;
1191 if ((env.loop>>4)==j)
1192 e->loope=l;
1193 if ((env.sus&15)==j)
1194 {
1195 e->sloops=l;
1196 e->sloope=l+1;
1197 }
1198 }
1199 if ((e->type&mpEnvSLoop)&&(e->type&mpEnvLoop)&&(e->sloope>e->loope))
1200 {
1201 e->sloops=e->loops;
1202 e->sloope=e->loope;
1203 }
1204 e->len=l;
1205 e->env=malloc(sizeof(uint8_t)*(l+1));
1206 if (!e->env)
1207 return errAllocMem;
1208 l=1;
1209 e->env[0]=env.env[0][1]<<2;
1210 for (j=0; j<15; j++)
1211 {
1212 if (!env.env[j+1][0])
1213 break;
1214 for (k=1; k<=env.env[j+1][0]; k++)
1215 e->env[l++]=4*env.env[j][1]+4*k*(env.env[j+1][1]-env.env[j][1])/env.env[j+1][0];
1216 }
1217 }
1218
1219 if (ocpfilehandle_read_uint16_le (file, &blktype))
1220 {
1221 fprintf(stderr, __FILE__ ": fread() failed #40\n");
1222 return errFormStruc;
1223 }
1224 if (ocpfilehandle_read_uint32_le (file, &blklen))
1225 {
1226 fprintf(stderr, __FILE__ ": fread() failed #41\n");
1227 return errFormStruc;
1228 }
1229 }
1230
1231 if (blktype!=0x5349)
1232 return errFormStruc;
1233
1234 if (ocpfilehandle_read_uint8 (file, &smpsav))
1235 {
1236 fprintf(stderr, __FILE__ ": fread() failed #42\n");
1237 return errFormStruc;
1238 }
1239 memset(packtype, 0xFF, 255);
1240
1241 for (i=0; i<smpsav; i++)
1242 {
1243 struct __attribute__((packed))
1244 {
1245 uint8_t num;
1246 char name[32];
1247 char filename[8];
1248 uint32_t rate;
1249 uint32_t len;
1250 uint32_t loopstart;
1251 uint32_t replen;
1252 uint8_t vol;
1253 uint8_t opt;
1254 } mdlsmp;
1255
1256 struct sampleinfo *sip;
1257
1258 if (file->read (file, &mdlsmp, sizeof (mdlsmp)) != sizeof (mdlsmp))
1259 {
1260 fprintf(stderr, __FILE__ ": fread() failed #43\n");
1261 return errFormStruc;
1262 }
1263 mdlsmp.rate = uint32_little (mdlsmp.rate);
1264 mdlsmp.len = uint32_little (mdlsmp.len);
1265 mdlsmp.loopstart = uint32_little (mdlsmp.loopstart);
1266 mdlsmp.replen = uint32_little (mdlsmp.replen);
1267
1268 mdlsmp.name[31]=0;
1269 if (mdlsmp.opt&1)
1270 {
1271 mdlsmp.len>>=1;
1272 mdlsmp.loopstart>>=1;
1273 mdlsmp.replen>>=1;
1274 }
1275
1276 for (j=0; j<m->modsampnum; j++)
1277 if (m->modsamples[j].handle==(mdlsmp.num-1))
1278 strcpy(m->modsamples[j].name, mdlsmp.name);
1279
1280 sip=&m->samples[mdlsmp.num-1];
1281
1282 sip->ptr=0;
1283 sip->length=mdlsmp.len;
1284 sip->loopstart=mdlsmp.loopstart;
1285 sip->loopend=mdlsmp.loopstart+mdlsmp.replen;
1286 sip->samprate=mdlsmp.rate;
1287 sip->type=((mdlsmp.opt&1)?mcpSamp16Bit:0)|(mdlsmp.replen?mcpSampLoop:0)|((mdlsmp.opt&2)?mcpSampBiDi:0);
1288
1289 packtype[mdlsmp.num-1]=(mdlsmp.opt>>2)&3;
1290 }
1291
1292 if (ocpfilehandle_read_uint16_le (file, &waste16))
1293 {
1294 fprintf(stderr, __FILE__ ": fread() failed #44\n");
1295 return errFormStruc;
1296 }
1297 if (waste16!=0x4153)
1298 return errFormStruc;
1299 if (ocpfilehandle_read_uint32_le (file, &blklen))
1300 {
1301 fprintf(stderr, __FILE__ ": fread() failed #45\n");
1302 return errFormStruc;
1303 }
1304
1305 for (i=0; i<255; i++)
1306 {
1307 struct sampleinfo *sip;
1308 int bit16;
1309 uint32_t packlen;
1310 uint8_t *packbuf;
1311 uint8_t dlt;
1312
1313 if (packtype[i]==255)
1314 continue;
1315
1316 sip=&m->samples[i];
1317 bit16=!!(sip->type&mcpSamp16Bit);
1318
1319 sip->ptr=malloc(sizeof(uint8_t)*((sip->length+8)<<bit16));
1320 if (!sip->ptr)
1321 return errAllocMem;
1322
1323 if (packtype[i]==0)
1324 {
1325 if (file->read (file, sip->ptr, sip->length<<bit16) != (sip->length<<bit16))
1326 {
1327 fprintf(stderr, __FILE__ ": fread() failed #46\n");
1328 return errFormStruc;
1329 }
1330 continue;
1331 }
1332
1333 if (ocpfilehandle_read_uint32_le (file, &packlen))
1334 {
1335 fprintf(stderr, __FILE__ ": fread() failed #47\n");
1336 return errFormStruc;
1337 }
1338 packbuf=malloc(sizeof(uint8_t)*(packlen+4));
1339
1340 if (!packbuf)
1341 return errAllocMem;
1342 if (file->read (file, packbuf, packlen) != packlen)
1343 {
1344 fprintf(stderr, __FILE__ ": fread() failed #48\n");
1345 free(packbuf);
1346 return errFormStruc;
1347 }
1348 bitnum=8;
1349 ibuf=packbuf;
1350 bitlen = packlen;
1351
1352 dlt=0;
1353 bit16=packtype[i]==2;
1354 for (j=0; j<sip->length; j++)
1355 {
1356 uint8_t lowbyte=lowbyte; /* supress warning.. safe to use below, since it depends on bit16 */
1357 uint8_t byte;
1358 uint8_t sign;
1359 if (bit16)
1360 lowbyte=readbits(8);
1361
1362 sign=readbits(1);
1363 if (readbits(1))
1364 byte=readbits(3);
1365 else {
1366 byte=8;
1367 while (!readbits(1))
1368 byte+=16;
1369 byte+=readbits(4);
1370 }
1371 if (sign)
1372 byte=~byte;
1373 dlt+=byte;
1374 if (!bit16)
1375 ((uint8_t *)sip->ptr)[j]=dlt;
1376 else
1377 ((uint16_t *)sip->ptr)[j]=(dlt<<8)|lowbyte;
1378 }
1379 free(packbuf);
1380 }
1381
1382 return errOk;
1383 }
1384
1385 struct gmdloadstruct mpLoadMDL = { _mpLoadMDL };
1386
1387 struct linkinfostruct dllextinfo = {.name = "gmdlmdl", .desc = "OpenCP Module Loader: *.MDL (c) 1994-21 Niklas Beisert, Stian Skjelstad", .ver = DLLVERSION, .size = 0};
1388