Mercurial > audlegacy-plugins
comparison src/adplug/core/rix.cxx @ 12:3da1b8942b8b trunk
[svn] - remove src/Input src/Output src/Effect src/General src/Visualization src/Container
author | nenolod |
---|---|
date | Mon, 18 Sep 2006 03:14:20 -0700 |
parents | src/Input/adplug/core/rix.cxx@13389e613d67 |
children | cae46214b8bf |
comparison
equal
deleted
inserted
replaced
11:cff1d04026ae | 12:3da1b8942b8b |
---|---|
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 } |