Mercurial > audlegacy-plugins

comparison src/Input/adplug/core/rix.cxx @ 0:13389e613d67 trunk

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