1 /*
2 * Adplug - Replayer for many OPL2/OPL3 audio file formats.
3 * Copyright (C) 1999 - 2007 Simon Peter, <dn.tlp@gmx.net>, et al.
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 *
19 * a2m.cpp - A2M Loader by Simon Peter <dn.tlp@gmx.net>
20 *
21 * NOTES:
22 * This loader detects and loads version 1, 4, 5 & 8 files.
23 *
24 * version 1-4 files:
25 * Following commands are ignored: FF1 - FF9, FAx - FEx
26 *
27 * version 5-8 files:
28 * Instrument panning is ignored. Flags byte is ignored.
29 * Following commands are ignored: Gxy, Hxy, Kxy - &xy
30 */
31
32 #include <string.h>
33 #include "a2m.h"
34
35 const unsigned int Ca2mLoader::MAXFREQ = 2000,
36 Ca2mLoader::MINCOPY = ADPLUG_A2M_MINCOPY,
37 Ca2mLoader::MAXCOPY = ADPLUG_A2M_MAXCOPY,
38 Ca2mLoader::COPYRANGES = ADPLUG_A2M_COPYRANGES,
39 Ca2mLoader::CODESPERRANGE = ADPLUG_A2M_CODESPERRANGE,
40 Ca2mLoader::TERMINATE = 256,
41 Ca2mLoader::FIRSTCODE = ADPLUG_A2M_FIRSTCODE,
42 Ca2mLoader::MAXCHAR = FIRSTCODE + COPYRANGES * CODESPERRANGE - 1,
43 Ca2mLoader::SUCCMAX = MAXCHAR + 1,
44 Ca2mLoader::TWICEMAX = ADPLUG_A2M_TWICEMAX,
45 Ca2mLoader::ROOT = 1, Ca2mLoader::MAXBUF = 42 * 1024,
46 Ca2mLoader::MAXDISTANCE = 21389, Ca2mLoader::MAXSIZE = 21389 + MAXCOPY;
47
48 const unsigned short Ca2mLoader::bitvalue[14] =
49 {1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192};
50
51 const signed short Ca2mLoader::copybits[COPYRANGES] =
52 {4, 6, 8, 10, 12, 14};
53
54 const signed short Ca2mLoader::copymin[COPYRANGES] =
55 {0, 16, 80, 336, 1360, 5456};
56
factory(Copl * newopl)57 CPlayer *Ca2mLoader::factory(Copl *newopl)
58 {
59 return new Ca2mLoader(newopl);
60 }
61
load(const char * filename,const CFileProvider & fp)62 bool Ca2mLoader::load(const char *filename, const CFileProvider &fp)
63 {
64 binistream *f = fp.open(filename); if(!f) return false;
65 char id[10];
66 int i,j,k,t;
67 unsigned int l;
68 unsigned char *org = 0, *orgptr, flags = 0, numpats, version;
69 unsigned long crc, alength;
70 unsigned short len[9], *secdata, *secptr;
71 const unsigned char convfx[16] = {0,1,2,23,24,3,5,4,6,9,17,13,11,19,7,14};
72 const unsigned char convinf1[16] = {0,1,2,6,7,8,9,4,5,3,10,11,12,13,14,15};
73 const unsigned char newconvfx[] = {0,1,2,3,4,5,6,23,24,21,10,11,17,13,7,19,
74 255,255,22,25,255,15,255,255,255,255,255,
75 255,255,255,255,255,255,255,255,14,255};
76
77 // read header
78 f->readString(id, 10); crc = f->readInt(4);
79 version = f->readInt(1); numpats = f->readInt(1);
80
81 // file validation section
82 if(strncmp(id,"_A2module_",10) || (version != 1 && version != 5 &&
83 version != 4 && version != 8)) {
84 fp.close(f);
85 return false;
86 }
87
88 // load, depack & convert section
89 nop = numpats; length = 128; restartpos = 0;
90 if(version < 5) {
91 for(i=0;i<5;i++) len[i] = f->readInt(2);
92 t = 9;
93 } else { // version >= 5
94 for(i=0;i<9;i++) len[i] = f->readInt(2);
95 t = 18;
96 }
97
98 // block 0
99 secdata = new unsigned short [len[0] / 2];
100 if(version == 1 || version == 5) {
101 for(i=0;i<len[0]/2;i++) secdata[i] = f->readInt(2);
102 org = new unsigned char [MAXBUF]; orgptr = org;
103 sixdepak(secdata,org,len[0]);
104 } else {
105 orgptr = (unsigned char *)secdata;
106 for(i=0;i<len[0];i++) orgptr[i] = f->readInt(1);
107 }
108 memcpy(songname,orgptr,43); orgptr += 43;
109 memcpy(author,orgptr,43); orgptr += 43;
110 memcpy(instname,orgptr,250*33); orgptr += 250*33;
111
112 for(i=0;i<250;i++) { // instruments
113 inst[i].data[0] = *(orgptr+i*13+10);
114 inst[i].data[1] = *(orgptr+i*13);
115 inst[i].data[2] = *(orgptr+i*13+1);
116 inst[i].data[3] = *(orgptr+i*13+4);
117 inst[i].data[4] = *(orgptr+i*13+5);
118 inst[i].data[5] = *(orgptr+i*13+6);
119 inst[i].data[6] = *(orgptr+i*13+7);
120 inst[i].data[7] = *(orgptr+i*13+8);
121 inst[i].data[8] = *(orgptr+i*13+9);
122 inst[i].data[9] = *(orgptr+i*13+2);
123 inst[i].data[10] = *(orgptr+i*13+3);
124
125 if(version < 5)
126 inst[i].misc = *(orgptr+i*13+11);
127 else { // version >= 5 -> OPL3 format
128 int pan = *(orgptr+i*13+11);
129
130 if(pan)
131 inst[i].data[0] |= (pan & 3) << 4; // set pan
132 else
133 inst[i].data[0] |= 48; // enable both speakers
134 }
135
136 inst[i].slide = *(orgptr+i*13+12);
137 }
138
139 orgptr += 250*13;
140 memcpy(order,orgptr,128); orgptr += 128;
141 bpm = *orgptr; orgptr++;
142 initspeed = *orgptr; orgptr++;
143 if(version >= 5) flags = *orgptr;
144 if(version == 1 || version == 5) delete [] org;
145 delete [] secdata;
146
147 // blocks 1-4 or 1-8
148 alength = len[1];
149 for(i = 0; i < (version < 5 ? numpats / 16 : numpats / 8); i++)
150 alength += len[i+2];
151
152 secdata = new unsigned short [alength / 2];
153 if(version == 1 || version == 5) {
154 for(l=0;l<alength/2;l++) secdata[l] = f->readInt(2);
155 org = new unsigned char [MAXBUF * (numpats / (version == 1 ? 16 : 8) + 1)];
156 orgptr = org; secptr = secdata;
157 orgptr += sixdepak(secptr,orgptr,len[1]); secptr += len[1] / 2;
158 if(version == 1) {
159 if(numpats > 16)
160 orgptr += sixdepak(secptr,orgptr,len[2]); secptr += len[2] / 2;
161 if(numpats > 32)
162 orgptr += sixdepak(secptr,orgptr,len[3]); secptr += len[3] / 2;
163 if(numpats > 48)
164 sixdepak(secptr,orgptr,len[4]);
165 } else {
166 if(numpats > 8)
167 orgptr += sixdepak(secptr,orgptr,len[2]); secptr += len[2] / 2;
168 if(numpats > 16)
169 orgptr += sixdepak(secptr,orgptr,len[3]); secptr += len[3] / 2;
170 if(numpats > 24)
171 orgptr += sixdepak(secptr,orgptr,len[4]); secptr += len[4] / 2;
172 if(numpats > 32)
173 orgptr += sixdepak(secptr,orgptr,len[5]); secptr += len[5] / 2;
174 if(numpats > 40)
175 orgptr += sixdepak(secptr,orgptr,len[6]); secptr += len[6] / 2;
176 if(numpats > 48)
177 orgptr += sixdepak(secptr,orgptr,len[7]); secptr += len[7] / 2;
178 if(numpats > 56)
179 sixdepak(secptr,orgptr,len[8]);
180 }
181 delete [] secdata;
182 } else {
183 org = (unsigned char *)secdata;
184 for(l=0;l<alength;l++) org[l] = f->readInt(1);
185 }
186
187 if(version < 5) {
188 for(i=0;i<numpats;i++)
189 for(j=0;j<64;j++)
190 for(k=0;k<9;k++) {
191 struct Tracks *track = &tracks[i * 9 + k][j];
192 unsigned char *o = &org[i*64*t*4+j*t*4+k*4];
193
194 track->note = o[0] == 255 ? 127 : o[0];
195 track->inst = o[1];
196 track->command = convfx[o[2]];
197 track->param2 = o[3] & 0x0f;
198 if(track->command != 14)
199 track->param1 = o[3] >> 4;
200 else {
201 track->param1 = convinf1[o[3] >> 4];
202 if(track->param1 == 15 && !track->param2) { // convert key-off
203 track->command = 8;
204 track->param1 = 0;
205 track->param2 = 0;
206 }
207 }
208 if(track->command == 14) {
209 switch(track->param1) {
210 case 2: // convert define waveform
211 track->command = 25;
212 track->param1 = track->param2;
213 track->param2 = 0xf;
214 break;
215 case 8: // convert volume slide up
216 track->command = 26;
217 track->param1 = track->param2;
218 track->param2 = 0;
219 break;
220 case 9: // convert volume slide down
221 track->command = 26;
222 track->param1 = 0;
223 break;
224 }
225 }
226 }
227 } else { // version >= 5
228 realloc_patterns(64, 64, 18);
229
230 for(i=0;i<numpats;i++)
231 for(j=0;j<18;j++)
232 for(k=0;k<64;k++) {
233 struct Tracks *track = &tracks[i * 18 + j][k];
234 unsigned char *o = &org[i*64*t*4+j*64*4+k*4];
235
236 track->note = o[0] == 255 ? 127 : o[0];
237 track->inst = o[1];
238 track->command = newconvfx[o[2]];
239 track->param1 = o[3] >> 4;
240 track->param2 = o[3] & 0x0f;
241
242 // Convert '&' command
243 if(o[2] == 36)
244 switch(track->param1) {
245 case 0: // pattern delay (frames)
246 track->command = 29;
247 track->param1 = 0;
248 // param2 already set correctly
249 break;
250
251 case 1: // pattern delay (rows)
252 track->command = 14;
253 track->param1 = 8;
254 // param2 already set correctly
255 break;
256 }
257 }
258 }
259
260 init_trackord();
261
262 if(version == 1 || version == 5)
263 delete [] org;
264 else
265 delete [] secdata;
266
267 // Process flags
268 if(version >= 5) {
269 CmodPlayer::flags |= Opl3; // All versions >= 5 are OPL3
270 if(flags & 8) CmodPlayer::flags |= Tremolo; // Tremolo depth
271 if(flags & 16) CmodPlayer::flags |= Vibrato; // Vibrato depth
272 }
273
274 fp.close(f);
275 rewind(0);
276 return true;
277 }
278
getrefresh()279 float Ca2mLoader::getrefresh()
280 {
281 if(tempo != 18)
282 return (float) (tempo);
283 else
284 return 18.2f;
285 }
286
287 /*** private methods *************************************/
288
inittree()289 void Ca2mLoader::inittree()
290 {
291 unsigned short i;
292
293 for(i=2;i<=TWICEMAX;i++) {
294 dad[i] = i / 2;
295 freq[i] = 1;
296 }
297
298 for(i=1;i<=MAXCHAR;i++) {
299 leftc[i] = 2 * i;
300 rghtc[i] = 2 * i + 1;
301 }
302 }
303
updatefreq(unsigned short a,unsigned short b)304 void Ca2mLoader::updatefreq(unsigned short a,unsigned short b)
305 {
306 do {
307 freq[dad[a]] = freq[a] + freq[b];
308 a = dad[a];
309 if(a != ROOT)
310 if(leftc[dad[a]] == a)
311 b = rghtc[dad[a]];
312 else
313 b = leftc[dad[a]];
314 } while(a != ROOT);
315
316 if(freq[ROOT] == MAXFREQ)
317 for(a=1;a<=TWICEMAX;a++)
318 freq[a] >>= 1;
319 }
320
updatemodel(unsigned short code)321 void Ca2mLoader::updatemodel(unsigned short code)
322 {
323 unsigned short a=code+SUCCMAX,b,c,code1,code2;
324
325 freq[a]++;
326 if(dad[a] != ROOT) {
327 code1 = dad[a];
328 if(leftc[code1] == a)
329 updatefreq(a,rghtc[code1]);
330 else
331 updatefreq(a,leftc[code1]);
332
333 do {
334 code2 = dad[code1];
335 if(leftc[code2] == code1)
336 b = rghtc[code2];
337 else
338 b = leftc[code2];
339
340 if(freq[a] > freq[b]) {
341 if(leftc[code2] == code1)
342 rghtc[code2] = a;
343 else
344 leftc[code2] = a;
345
346 if(leftc[code1] == a) {
347 leftc[code1] = b;
348 c = rghtc[code1];
349 } else {
350 rghtc[code1] = b;
351 c = leftc[code1];
352 }
353
354 dad[b] = code1;
355 dad[a] = code2;
356 updatefreq(b,c);
357 a = b;
358 }
359
360 a = dad[a];
361 code1 = dad[a];
362 } while(code1 != ROOT);
363 }
364 }
365
inputcode(unsigned short bits)366 unsigned short Ca2mLoader::inputcode(unsigned short bits)
367 {
368 unsigned short i,code=0;
369
370 for(i=1;i<=bits;i++) {
371 if(!ibitcount) {
372 if(ibitcount == MAXBUF)
373 ibufcount = 0;
374 ibitbuffer = wdbuf[ibufcount];
375 ibufcount++;
376 ibitcount = 15;
377 } else
378 ibitcount--;
379
380 if(ibitbuffer > 0x7fff)
381 code |= bitvalue[i-1];
382 ibitbuffer <<= 1;
383 }
384
385 return code;
386 }
387
uncompress()388 unsigned short Ca2mLoader::uncompress()
389 {
390 unsigned short a=1;
391
392 do {
393 if(!ibitcount) {
394 if(ibufcount == MAXBUF)
395 ibufcount = 0;
396 ibitbuffer = wdbuf[ibufcount];
397 ibufcount++;
398 ibitcount = 15;
399 } else
400 ibitcount--;
401
402 if(ibitbuffer > 0x7fff)
403 a = rghtc[a];
404 else
405 a = leftc[a];
406 ibitbuffer <<= 1;
407 } while(a <= MAXCHAR);
408
409 a -= SUCCMAX;
410 updatemodel(a);
411 return a;
412 }
413
decode()414 void Ca2mLoader::decode()
415 {
416 unsigned short i,j,k,t,c,count=0,dist,len,index;
417
418 inittree();
419 c = uncompress();
420
421 while(c != TERMINATE) {
422 if(c < 256) {
423 obuf[obufcount] = (unsigned char)c;
424 obufcount++;
425 if(obufcount == MAXBUF) {
426 output_size = MAXBUF;
427 obufcount = 0;
428 }
429
430 buf[count] = (unsigned char)c;
431 count++;
432 if(count == MAXSIZE)
433 count = 0;
434 } else {
435 t = c - FIRSTCODE;
436 index = t / CODESPERRANGE;
437 len = t + MINCOPY - index * CODESPERRANGE;
438 dist = inputcode(copybits[index]) + len + copymin[index];
439
440 j = count;
441 k = count - dist;
442 if(count < dist)
443 k += MAXSIZE;
444
445 for(i=0;i<=len-1;i++) {
446 obuf[obufcount] = buf[k];
447 obufcount++;
448 if(obufcount == MAXBUF) {
449 output_size = MAXBUF;
450 obufcount = 0;
451 }
452
453 buf[j] = buf[k];
454 j++; k++;
455 if(j == MAXSIZE) j = 0;
456 if(k == MAXSIZE) k = 0;
457 }
458
459 count += len;
460 if(count >= MAXSIZE)
461 count -= MAXSIZE;
462 }
463 c = uncompress();
464 }
465 output_size = obufcount;
466 }
467
sixdepak(unsigned short * source,unsigned char * dest,unsigned short size)468 unsigned short Ca2mLoader::sixdepak(unsigned short *source, unsigned char *dest,
469 unsigned short size)
470 {
471 if((unsigned int)size + 4096 > MAXBUF)
472 return 0;
473
474 buf = new unsigned char [MAXSIZE];
475 input_size = size;
476 ibitcount = 0; ibitbuffer = 0;
477 obufcount = 0; ibufcount = 0;
478 wdbuf = source; obuf = dest;
479
480 decode();
481 delete [] buf;
482 return output_size;
483 }
484