16/adplug/adplug/src/rix.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  * rix.cpp - Softstar RIX OPL Format Player by palxex <palxex.ys168.com>
  20  *                                             BSPAL <BSPAL.ys168.com>
  21  */
  22
  23 #include <cstring>
  24 #include "rix.h"
  25 #include "debug.h"
  26
  27 const unsigned char CrixPlayer::adflag[] = {0,0,0,1,1,1,0,0,0,1,1,1,0,0,0,1,1,1};
  28 const unsigned char CrixPlayer::reg_data[] = {0,1,2,3,4,5,8,9,10,11,12,13,16,17,18,19,20,21};
  29 const unsigned char CrixPlayer::ad_C0_offs[] = {0,1,2,0,1,2,3,4,5,3,4,5,6,7,8,6,7,8};
  30 const unsigned char CrixPlayer::modify[] = {0,3,1,4,2,5,6,9,7,10,8,11,12,15,13,16,14,17,12,\
  31                                             15,16,0,14,0,17,0,13,0};
  32 const unsigned char CrixPlayer::bd_reg_data[] = {
  33   0x00,0x00,0x00,0x00,0x00,0x00,0x10,0x08,0x04,0x02,0x01,
  34   0x00,0x01,0x01,0x03,0x0F,0x05,0x00,0x01,0x03,0x0F,0x00,
  35   0x00,0x00,0x01,0x00,0x00,0x01,0x01,0x0F,0x07,0x00,0x02,
  36   0x04,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x0A,
  37   0x04,0x00,0x08,0x0C,0x0B,0x00,0x00,0x00,0x01,0x00,0x00,
  38   0x00,0x00,0x0D,0x04,0x00,0x06,0x0F,0x00,0x00,0x00,0x00,
  39   0x01,0x00,0x00,0x0C,0x00,0x0F,0x0B,0x00,0x08,0x05,0x00,
  40   0x00,0x00,0x00,0x00,0x00,0x00,0x04,0x00,0x0F,0x0B,0x00,
  41   0x07,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,
  42   0x0F,0x0B,0x00,0x05,0x05,0x00,0x00,0x00,0x00,0x00,0x00,
  43   0x00,0x01,0x00,0x0F,0x0B,0x00,0x07,0x05,0x00,0x00,0x00,
  44   0x00,0x00,0x00};
  45 unsigned char CrixPlayer::for40reg[] = {0x7F,0x7F,0x7F,0x7F,0x7F,0x7F,0x7F,0x7F,0x7F,
  46                                         0x7F,0x7F,0x7F,0x7F,0x7F,0x7F,0x7F,0x7F,0x7F};
  47 unsigned short CrixPlayer::mus_time = 0x4268;
  48
  49 /*** public methods *************************************/
  50
  51 CPlayer *CrixPlayer::factory(Copl *newopl)
  52 {
  53   return new CrixPlayer(newopl);
  54 }
  55
  56 CrixPlayer::CrixPlayer(Copl *newopl)
  57   : CPlayer(newopl), flag_mkf(0), file_buffer(0), buf_addr(0)
  58 {
  59 }
  60
  61 CrixPlayer::~CrixPlayer()
  62 {
  63   if(file_buffer)
  64     delete [] file_buffer;
  65 }
  66
  67 bool CrixPlayer::load(const std::string &filename, const CFileProvider &fp)
  68 {
  69   binistream *f = fp.open(filename); if(!f) return false;
  70   unsigned long i=0;
  71
  72   if(stricmp(filename.substr(filename.length()-4,4).c_str(),".mkf")==0)
  73   {
  74           flag_mkf=1;
  75           f->seek(0);
  76           int offset=f->readInt(4);
  77           f->seek(offset);
  78   }
  79   if(f->readInt(2)!=0x55aa){ fp.close(f);return false; }
  80   file_buffer = new unsigned char [fp.filesize(f) + 1];
  81   f->seek(0);
  82   while(!f->eof())
  83         file_buffer[i++]=f->readInt(1);
  84   length=i;
  85   fp.close(f);
  86   if(!flag_mkf)
  87           buf_addr=file_buffer;
  88   rewind(0);
  89   return true;
  90 }
  91
  92 bool CrixPlayer::update()
  93 {
  94         int_08h_entry();
  95         return !play_end;
  96 }
  97
  98 void CrixPlayer::rewind(int subsong)
  99 {
 100   I = 0; T = 0;
 101   mus_block = 0;
 102   ins_block = 0;
 103   rhythm = 0;
 104   music_on = 0;
 105   pause_flag = 0;
 106   band = 0;
 107   band_low = 0;
 108   e0_reg_flag = 0;
 109   bd_modify = 0;
 110   sustain = 0;
 111   play_end = 0;
 112   pos = index = 0;
 113
 114   memset(f_buffer, 0, sizeof(unsigned short) * 300);
 115   memset(a0b0_data2, 0, sizeof(unsigned short) * 11);
 116   memset(a0b0_data3, 0, 18);
 117   memset(a0b0_data4, 0, 18);
 118   memset(a0b0_data5, 0, 96);
 119   memset(addrs_head, 0, 96);
 120   memset(insbuf, 0, 28 * sizeof(unsigned short));
 121   memset(displace, 0, 11 * sizeof(unsigned short));
 122   memset(reg_bufs, 0, 18 * sizeof(ADDT));
 123
 124   if(flag_mkf)
 125   {
 126           unsigned int *buf_index=(unsigned int *)file_buffer;
 127           int offset1=buf_index[subsong],offset2;
 128           while((offset2=buf_index[++subsong])==offset1);
 129           length=offset2-offset1+1;
 130           buf_addr=file_buffer+offset1;
 131   }
 132   opl->init();
 133   opl->write(1,32);     // go to OPL2 mode
 134   set_new_int();
 135   data_initial();
 136 }
 137
 138 unsigned int CrixPlayer::getsubsongs()
 139 {
 140         if(flag_mkf)
 141         {
 142                 unsigned int *buf_index=(unsigned int *)file_buffer;
 143                 int songs=buf_index[0]/4,i=0;
 144                 for(i=0;i<songs;i++)
 145                         if(buf_index[i+1]==buf_index[i])
 146                                 songs--;
 147                 return songs;
 148         }
 149         else
 150                 return 1;
 151 }
 152
 153 float CrixPlayer::getrefresh()
 154 {
 155         return 70.0f;
 156 }
 157
 158 /*------------------Implemention----------------------------*/
 159 inline void CrixPlayer::set_new_int()
 160 {
 161 //   if(!ad_initial()) exit(1);
 162   ad_initial();
 163 }
 164 /*----------------------------------------------------------*/
 165 inline void CrixPlayer::Pause()
 166 {
 167   register unsigned short i;
 168   pause_flag = 1;
 169   for(i=0;i<11;i++)
 170     switch_ad_bd(i);
 171 }
 172 /*----------------------------------------------------------*/
 173 inline void CrixPlayer::ad_a0b0l_reg_(unsigned short index,unsigned short p2,unsigned short p3)
 174 {
 175 //   unsigned short i = p2+a0b0_data2[index];
 176   a0b0_data4[index] = p3;
 177   a0b0_data3[index] = p2;
 178 }
 179 inline void CrixPlayer::data_initial()
 180 {
 181   rhythm = buf_addr[2];
 182   mus_block = (buf_addr[0x0D]<<8)+buf_addr[0x0C];
 183   ins_block = (buf_addr[0x09]<<8)+buf_addr[0x08];
 184   I = mus_block+1;
 185   if(rhythm != 0)
 186     {
 187       //                ad_a0b0_reg(6);
 188       //                ad_a0b0_reg(7);
 189       //                ad_a0b0_reg(8);
 190       ad_a0b0l_reg_(8,0x18,0);
 191       ad_a0b0l_reg_(7,0x1F,0);
 192     }
 193   bd_modify = 0;
 194   //    ad_bd_reg();
 195   band = 0; music_on = 1;
 196 }
 197 /*----------------------------------------------------------*/
 198 inline unsigned short CrixPlayer::ad_initial()
 199 {
 200   register unsigned short i,j,k = 0;
 201   for(i=0;i<25;i++)
 202   {
 203         f_buffer[i*12]=(unsigned int)((i*24+10000)*0.27461678223+4)>>3;
 204         for(int t=1;t<12;t++)
 205                 f_buffer[i*12+t]=f_buffer[i*12+t-1]*1.06;
 206   }
 207   for(i=0;i<8;i++)
 208     for(j=0;j<12;j++)
 209       {
 210                         a0b0_data5[k] = i;
 211                         addrs_head[k] = j;
 212                         k++;
 213       }
 214   //ad_bd_reg();
 215   //ad_08_reg();
 216   //for(i=0;i<9;i++) ad_a0b0_reg(i);
 217   e0_reg_flag = 0x20;
 218   //for(i=0;i<18;i++) ad_bop(0xE0+reg_data[i],0);
 219   //ad_bop(1,e0_reg_flag);
 220   return 1;//ad_test();
 221 }
 222 /*----------------------------------------------------------*/
 223 inline void CrixPlayer::ad_bop(unsigned short reg,unsigned short value)
 224 {
 225   if(reg == 2 || reg == 3)
 226     AdPlug_LogWrite("switch OPL2/3 mode!\n");
 227   opl->write(reg & 0xff, value & 0xff);
 228 }
 229 /*--------------------------------------------------------------*/
 230 inline void CrixPlayer::int_08h_entry()
 231   {
 232     unsigned short band_sus = 1;
 233     while(band_sus)
 234       {
 235         if(sustain <= 0)
 236           {
 237             band_sus = rix_proc();
 238             if(band_sus) sustain += band_sus;
 239             else
 240               {
 241                 play_end=1;
 242                 break;
 243               }
 244           }
 245         else
 246           {
 247             if(band_sus) sustain -= 14; /* aging */
 248             break;
 249           }
 250       }
 251   }
 252 /*--------------------------------------------------------------*/
 253 inline unsigned short CrixPlayer::rix_proc()
 254 {
 255   unsigned char ctrl = 0;
 256   if(music_on == 0||pause_flag == 1) return 0;
 257   band = 0;
 258   while(buf_addr[I] != 0x80 && I<length-1)
 259     {
 260       band_low = buf_addr[I-1];
 261       ctrl = buf_addr[I]; I+=2;
 262       switch(ctrl&0xF0)
 263         {
 264         case 0x90:  rix_get_ins(); rix_90_pro(ctrl&0x0F); break;
 265         case 0xA0:  rix_A0_pro(ctrl&0x0F,((unsigned short)band_low)<<6); break;
 266         case 0xB0:  rix_B0_pro(ctrl&0x0F,band_low); break;
 267         case 0xC0:  switch_ad_bd(ctrl&0x0F);
 268           if(band_low != 0) rix_C0_pro(ctrl&0x0F,band_low);
 269           break;
 270         default:    band = (ctrl<<8)+band_low; break;
 271         }
 272       if(band != 0) return band;
 273     }
 274   music_ctrl();
 275   I = mus_block+1;
 276   band = 0; music_on = 1;
 277   return 0;
 278 }
 279 /*--------------------------------------------------------------*/
 280 inline void CrixPlayer::rix_get_ins()
 281 {
 282   int           i;
 283   unsigned char *baddr = (&buf_addr[ins_block])+(band_low<<6);
 284
 285   for(i = 0; i < 28; i++)
 286     insbuf[i] = (baddr[i * 2 + 1] << 8) + baddr[i * 2];
 287 }
 288 /*--------------------------------------------------------------*/
 289 inline void CrixPlayer::rix_90_pro(unsigned short ctrl_l)
 290 {
 291   if(rhythm == 0 || ctrl_l < 6)
 292     {
 293       ins_to_reg(modify[ctrl_l*2],insbuf,insbuf[26]);
 294       ins_to_reg(modify[ctrl_l*2+1],insbuf+13,insbuf[27]);
 295       return;
 296     }
 297   else if(ctrl_l > 6)
 298                 {
 299                   ins_to_reg(modify[ctrl_l*2+6],insbuf,insbuf[26]);
 300                   return;
 301                 }
 302   else
 303                 {
 304                   ins_to_reg(12,insbuf,insbuf[26]);
 305                   ins_to_reg(15,insbuf+13,insbuf[27]);
 306                   return;
 307                 }
 308 }
 309 /*--------------------------------------------------------------*/
 310 inline void CrixPlayer::rix_A0_pro(unsigned short ctrl_l,unsigned short index)
 311 {
 312   if(rhythm == 0 || ctrl_l <= 6)
 313     {
 314       prepare_a0b0(ctrl_l,index>0x3FFF?0x3FFF:index);
 315       ad_a0b0l_reg(ctrl_l,a0b0_data3[ctrl_l],a0b0_data4[ctrl_l]);
 316     }
 317   else return;
 318 }
 319 /*--------------------------------------------------------------*/
 320 inline void CrixPlayer::prepare_a0b0(unsigned short index,unsigned short v)  /* important !*/
 321 {
 322   short high = 0,low = 0; unsigned int res;
 323   int res1 = (v-0x2000)*0x19;
 324   if(res1 == (int)0xff) return;
 325   low = res1/0x2000;
 326   if(low < 0)
 327     {
 328       low = 0x18-low; high = (signed short)low<0?0xFFFF:0;
 329       res = high; res<<=16; res+=low;
 330       low = ((signed short)res)/(signed short)0xFFE7;
 331       a0b0_data2[index] = low;
 332       low = res;
 333       res = low - 0x18;
 334       high = (signed short)res%0x19;
 335       low = (signed short)res/0x19;
 336       if(high != 0) {low = 0x19; low = low-high;}
 337     }
 338   else
 339     {
 340       res = high = low;
 341       low = (signed short)res/(signed short)0x19;
 342       a0b0_data2[index] = low;
 343       res = high;
 344       low = (signed short)res%(signed short)0x19;
 345     }
 346   low = (signed short)low*(signed short)0x18;
 347   displace[index] = low;
 348 }
 349 /*--------------------------------------------------------------*/
 350 inline void CrixPlayer::ad_a0b0l_reg(unsigned short index,unsigned short p2,unsigned short p3)
 351 {
 352   unsigned short data; unsigned short i = p2+a0b0_data2[index];
 353   a0b0_data4[index] = p3;
 354   a0b0_data3[index] = p2;
 355   i = ((signed short)i<=0x5F?i:0x5F);
 356   i = ((signed short)i>=0?i:0);
 357   data = f_buffer[addrs_head[i]+displace[index]/2];
 358   ad_bop(0xA0+index,data);
 359   data = a0b0_data5[i]*4+(p3<1?0:0x20)+((data>>8)&3);
 360   ad_bop(0xB0+index,data);
 361 }
 362 /*--------------------------------------------------------------*/
 363 inline void CrixPlayer::rix_B0_pro(unsigned short ctrl_l,unsigned short index)
 364 {
 365   register int temp = 0;
 366   if(rhythm == 0 || ctrl_l < 6) temp = modify[ctrl_l*2+1];
 367   else
 368     {
 369       temp = ctrl_l > 6?ctrl_l*2:ctrl_l*2+1;
 370       temp = modify[temp+6];
 371     }
 372   for40reg[temp] = index>0x7F?0x7F:index;
 373   ad_40_reg(temp);
 374 }
 375 /*--------------------------------------------------------------*/
 376 inline void CrixPlayer::rix_C0_pro(unsigned short ctrl_l,unsigned short index)
 377 {
 378   register unsigned short i = index>=12?index-12:0;
 379   if(ctrl_l < 6 || rhythm == 0)
 380     {
 381       ad_a0b0l_reg(ctrl_l,i,1);
 382       return;
 383     }
 384   else
 385     {
 386       if(ctrl_l != 6)
 387         {
 388           if(ctrl_l == 8)
 389             {
 390               ad_a0b0l_reg(ctrl_l,i,0);
 391               ad_a0b0l_reg(7,i+7,0);
 392             }
 393         }
 394       else ad_a0b0l_reg(ctrl_l,i,0);
 395       bd_modify |= bd_reg_data[ctrl_l];
 396       ad_bd_reg();
 397       return;
 398     }
 399 }
 400 /*--------------------------------------------------------------*/
 401 inline void CrixPlayer::switch_ad_bd(unsigned short index)
 402 {
 403
 404   if(rhythm == 0 || index < 6) ad_a0b0l_reg(index,a0b0_data3[index],0);
 405   else
 406     {
 407       bd_modify &= (~bd_reg_data[index]),
 408         ad_bd_reg();
 409     }
 410 }
 411 /*--------------------------------------------------------------*/
 412 inline void CrixPlayer::ins_to_reg(unsigned short index,unsigned short* insb,unsigned short value)
 413 {
 414   register unsigned short i;
 415   for(i=0;i<13;i++) reg_bufs[index].v[i] = insb[i];
 416   reg_bufs[index].v[13] = value&3;
 417   ad_bd_reg(),ad_08_reg(),
 418     ad_40_reg(index),ad_C0_reg(index),ad_60_reg(index),
 419     ad_80_reg(index),ad_20_reg(index),ad_E0_reg(index);
 420 }
 421 /*--------------------------------------------------------------*/
 422 inline void CrixPlayer::ad_E0_reg(unsigned short index)
 423 {
 424   unsigned short data = e0_reg_flag == 0?0:(reg_bufs[index].v[13]&3);
 425   ad_bop(0xE0+reg_data[index],data);
 426 }
 427 /*--------------------------------------------------------------*/
 428 inline void CrixPlayer::ad_20_reg(unsigned short index)
 429 {
 430   unsigned short data = (reg_bufs[index].v[9] < 1?0:0x80);
 431   data += (reg_bufs[index].v[10] < 1?0:0x40);
 432   data += (reg_bufs[index].v[5] < 1?0:0x20);
 433   data += (reg_bufs[index].v[11] < 1?0:0x10);
 434   data += (reg_bufs[index].v[1]&0x0F);
 435   ad_bop(0x20+reg_data[index],data);
 436 }
 437 /*--------------------------------------------------------------*/
 438 inline void CrixPlayer::ad_80_reg(unsigned short index)
 439 {
 440   unsigned short data = (reg_bufs[index].v[7]&0x0F),temp = reg_bufs[index].v[4];
 441   data |= (temp << 4);
 442   ad_bop(0x80+reg_data[index],data);
 443 }
 444 /*--------------------------------------------------------------*/
 445 inline void CrixPlayer::ad_60_reg(unsigned short index)
 446 {
 447   unsigned short data = reg_bufs[index].v[6]&0x0F,temp = reg_bufs[index].v[3];
 448   data |= (temp << 4);
 449   ad_bop(0x60+reg_data[index],data);
 450 }
 451 /*--------------------------------------------------------------*/
 452 inline void CrixPlayer::ad_C0_reg(unsigned short index)
 453 {
 454   unsigned short data = reg_bufs[index].v[2];
 455   if(adflag[index] == 1) return;
 456   data *= 2,
 457     data |= (reg_bufs[index].v[12] < 1?1:0);
 458   ad_bop(0xC0+ad_C0_offs[index],data);
 459 }
 460 /*--------------------------------------------------------------*/
 461 inline void CrixPlayer::ad_40_reg(unsigned short index)
 462 {
 463   unsigned int res = 0;
 464   unsigned short data = 0,temp = reg_bufs[index].v[0];
 465   data = 0x3F - (0x3F & reg_bufs[index].v[8]),
 466     data *= for40reg[index],
 467     data *= 2,
 468     data += 0x7F,
 469     res = data;
 470   data = res/0xFE,
 471     data -= 0x3F,
 472     data = -data,
 473     data |= temp<<6;
 474   ad_bop(0x40+reg_data[index],data);
 475 }
 476 /*--------------------------------------------------------------*/
 477 inline void CrixPlayer::ad_bd_reg()
 478 {
 479   unsigned short data = rhythm < 1? 0:0x20;
 480   data |= bd_modify;
 481   ad_bop(0xBD,data);
 482 }
 483 /*--------------------------------------------------------------*/
 484 inline void CrixPlayer::ad_a0b0_reg(unsigned short index)
 485 {
 486   ad_bop(0xA0+index,0);
 487   ad_bop(0xB0+index,0);
 488 }
 489 /*--------------------------------------------------------------*/
 490 inline void CrixPlayer::music_ctrl()
 491 {
 492   register int i;
 493   for(i=0;i<11;i++)
 494     switch_ad_bd(i);
 495 }