16/adplug/adplug/src/a2m.cpp

   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 <cstring>
  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
  57 CPlayer *Ca2mLoader::factory(Copl *newopl)
  58 {
  59   return new Ca2mLoader(newopl);
  60 }
  61
  62 bool Ca2mLoader::load(const std::string &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, *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
 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
 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
 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
 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
 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
 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
 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
 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 }