?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
audio: OPLSetIRQHandler is not used anywhere
[qemu/ar7.git] / hw / audio / fmopl.c
blobf91e700bf9ed312344a3f872d066e35b1f206ae1
1 /*
2 **
3 ** File: fmopl.c -- software implementation of FM sound generator
4 **
5 ** Copyright (C) 1999,2000 Tatsuyuki Satoh , MultiArcadeMachineEmurator development
6 **
7 ** Version 0.37a
8 **
9 */
10
11 /*
12 preliminary :
13 Problem :
14 note:
15 */
16
17 /* This version of fmopl.c is a fork of the MAME one, relicensed under the LGPL.
18 *
19 * This library is free software; you can redistribute it and/or
20 * modify it under the terms of the GNU Lesser General Public
21 * License as published by the Free Software Foundation; either
22 * version 2.1 of the License, or (at your option) any later version.
23 *
24 * This library is distributed in the hope that it will be useful,
25 * but WITHOUT ANY WARRANTY; without even the implied warranty of
26 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
27 * Lesser General Public License for more details.
28 *
29 * You should have received a copy of the GNU Lesser General Public
30 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
31 */
32
33 #include "qemu/osdep.h"
34 #include <math.h>
35 //#include "driver.h" /* use M.A.M.E. */
36 #include "fmopl.h"
37
38 #ifndef PI
39 #define PI 3.14159265358979323846
40 #endif
41
42 #ifndef ARRAY_SIZE
43 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
44 #endif
45
46 /* -------------------- for debug --------------------- */
47 /* #define OPL_OUTPUT_LOG */
48 #ifdef OPL_OUTPUT_LOG
49 static FILE *opl_dbg_fp = NULL;
50 static FM_OPL *opl_dbg_opl[16];
51 static int opl_dbg_maxchip,opl_dbg_chip;
52 #endif
53
54 /* -------------------- preliminary define section --------------------- */
55 /* attack/decay rate time rate */
56 #define OPL_ARRATE 141280 /* RATE 4 = 2826.24ms @ 3.6MHz */
57 #define OPL_DRRATE 1956000 /* RATE 4 = 39280.64ms @ 3.6MHz */
58
59 #define DELTAT_MIXING_LEVEL (1) /* DELTA-T ADPCM MIXING LEVEL */
60
61 #define FREQ_BITS 24 /* frequency turn */
62
63 /* counter bits = 20 , octerve 7 */
64 #define FREQ_RATE (1<<(FREQ_BITS-20))
65 #define TL_BITS (FREQ_BITS+2)
66
67 /* final output shift , limit minimum and maximum */
68 #define OPL_OUTSB (TL_BITS+3-16) /* OPL output final shift 16bit */
69 #define OPL_MAXOUT (0x7fff<<OPL_OUTSB)
70 #define OPL_MINOUT (-0x8000<<OPL_OUTSB)
71
72 /* -------------------- quality selection --------------------- */
73
74 /* sinwave entries */
75 /* used static memory = SIN_ENT * 4 (byte) */
76 #define SIN_ENT 2048
77
78 /* output level entries (envelope,sinwave) */
79 /* envelope counter lower bits */
80 #define ENV_BITS 16
81 /* envelope output entries */
82 #define EG_ENT 4096
83 /* used dynamic memory = EG_ENT*4*4(byte)or EG_ENT*6*4(byte) */
84 /* used static memory = EG_ENT*4 (byte) */
85
86 #define EG_OFF ((2*EG_ENT)<<ENV_BITS) /* OFF */
87 #define EG_DED EG_OFF
88 #define EG_DST (EG_ENT<<ENV_BITS) /* DECAY START */
89 #define EG_AED EG_DST
90 #define EG_AST 0 /* ATTACK START */
91
92 #define EG_STEP (96.0/EG_ENT) /* OPL is 0.1875 dB step */
93
94 /* LFO table entries */
95 #define VIB_ENT 512
96 #define VIB_SHIFT (32-9)
97 #define AMS_ENT 512
98 #define AMS_SHIFT (32-9)
99
100 #define VIB_RATE 256
101
102 /* -------------------- local defines , macros --------------------- */
103
104 /* register number to channel number , slot offset */
105 #define SLOT1 0
106 #define SLOT2 1
107
108 /* envelope phase */
109 #define ENV_MOD_RR 0x00
110 #define ENV_MOD_DR 0x01
111 #define ENV_MOD_AR 0x02
112
113 /* -------------------- tables --------------------- */
114 static const int slot_array[32]=
115 {
116 0, 2, 4, 1, 3, 5,-1,-1,
117 6, 8,10, 7, 9,11,-1,-1,
118 12,14,16,13,15,17,-1,-1,
119 -1,-1,-1,-1,-1,-1,-1,-1
120 };
121
122 /* key scale level */
123 /* table is 3dB/OCT , DV converts this in TL step at 6dB/OCT */
124 #define DV (EG_STEP/2)
125 static const uint32_t KSL_TABLE[8*16]=
126 {
127 /* OCT 0 */
128 0.000/DV, 0.000/DV, 0.000/DV, 0.000/DV,
129 0.000/DV, 0.000/DV, 0.000/DV, 0.000/DV,
130 0.000/DV, 0.000/DV, 0.000/DV, 0.000/DV,
131 0.000/DV, 0.000/DV, 0.000/DV, 0.000/DV,
132 /* OCT 1 */
133 0.000/DV, 0.000/DV, 0.000/DV, 0.000/DV,
134 0.000/DV, 0.000/DV, 0.000/DV, 0.000/DV,
135 0.000/DV, 0.750/DV, 1.125/DV, 1.500/DV,
136 1.875/DV, 2.250/DV, 2.625/DV, 3.000/DV,
137 /* OCT 2 */
138 0.000/DV, 0.000/DV, 0.000/DV, 0.000/DV,
139 0.000/DV, 1.125/DV, 1.875/DV, 2.625/DV,
140 3.000/DV, 3.750/DV, 4.125/DV, 4.500/DV,
141 4.875/DV, 5.250/DV, 5.625/DV, 6.000/DV,
142 /* OCT 3 */
143 0.000/DV, 0.000/DV, 0.000/DV, 1.875/DV,
144 3.000/DV, 4.125/DV, 4.875/DV, 5.625/DV,
145 6.000/DV, 6.750/DV, 7.125/DV, 7.500/DV,
146 7.875/DV, 8.250/DV, 8.625/DV, 9.000/DV,
147 /* OCT 4 */
148 0.000/DV, 0.000/DV, 3.000/DV, 4.875/DV,
149 6.000/DV, 7.125/DV, 7.875/DV, 8.625/DV,
150 9.000/DV, 9.750/DV,10.125/DV,10.500/DV,
151 10.875/DV,11.250/DV,11.625/DV,12.000/DV,
152 /* OCT 5 */
153 0.000/DV, 3.000/DV, 6.000/DV, 7.875/DV,
154 9.000/DV,10.125/DV,10.875/DV,11.625/DV,
155 12.000/DV,12.750/DV,13.125/DV,13.500/DV,
156 13.875/DV,14.250/DV,14.625/DV,15.000/DV,
157 /* OCT 6 */
158 0.000/DV, 6.000/DV, 9.000/DV,10.875/DV,
159 12.000/DV,13.125/DV,13.875/DV,14.625/DV,
160 15.000/DV,15.750/DV,16.125/DV,16.500/DV,
161 16.875/DV,17.250/DV,17.625/DV,18.000/DV,
162 /* OCT 7 */
163 0.000/DV, 9.000/DV,12.000/DV,13.875/DV,
164 15.000/DV,16.125/DV,16.875/DV,17.625/DV,
165 18.000/DV,18.750/DV,19.125/DV,19.500/DV,
166 19.875/DV,20.250/DV,20.625/DV,21.000/DV
167 };
168 #undef DV
169
170 /* sustain lebel table (3db per step) */
171 /* 0 - 15: 0, 3, 6, 9,12,15,18,21,24,27,30,33,36,39,42,93 (dB)*/
172 #define SC(db) (db*((3/EG_STEP)*(1<<ENV_BITS)))+EG_DST
173 static const int32_t SL_TABLE[16]={
174 SC( 0),SC( 1),SC( 2),SC(3 ),SC(4 ),SC(5 ),SC(6 ),SC( 7),
175 SC( 8),SC( 9),SC(10),SC(11),SC(12),SC(13),SC(14),SC(31)
176 };
177 #undef SC
178
179 #define TL_MAX (EG_ENT*2) /* limit(tl + ksr + envelope) + sinwave */
180 /* TotalLevel : 48 24 12 6 3 1.5 0.75 (dB) */
181 /* TL_TABLE[ 0 to TL_MAX ] : plus section */
182 /* TL_TABLE[ TL_MAX to TL_MAX+TL_MAX-1 ] : minus section */
183 static int32_t *TL_TABLE;
184
185 /* pointers to TL_TABLE with sinwave output offset */
186 static int32_t **SIN_TABLE;
187
188 /* LFO table */
189 static int32_t *AMS_TABLE;
190 static int32_t *VIB_TABLE;
191
192 /* envelope output curve table */
193 /* attack + decay + OFF */
194 static int32_t ENV_CURVE[2*EG_ENT+1];
195
196 /* multiple table */
197 #define ML 2
198 static const uint32_t MUL_TABLE[16]= {
199 /* 1/2, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15 */
200 0.50*ML, 1.00*ML, 2.00*ML, 3.00*ML, 4.00*ML, 5.00*ML, 6.00*ML, 7.00*ML,
201 8.00*ML, 9.00*ML,10.00*ML,10.00*ML,12.00*ML,12.00*ML,15.00*ML,15.00*ML
202 };
203 #undef ML
204
205 /* dummy attack / decay rate ( when rate == 0 ) */
206 static int32_t RATE_0[16]=
207 {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
208
209 /* -------------------- static state --------------------- */
210
211 /* lock level of common table */
212 static int num_lock = 0;
213
214 /* work table */
215 static void *cur_chip = NULL; /* current chip point */
216 /* currenct chip state */
217 /* static OPLSAMPLE *bufL,*bufR; */
218 static OPL_CH *S_CH;
219 static OPL_CH *E_CH;
220 static OPL_SLOT *SLOT7_1, *SLOT7_2, *SLOT8_1, *SLOT8_2;
221
222 static int32_t outd[1];
223 static int32_t ams;
224 static int32_t vib;
225 static int32_t *ams_table;
226 static int32_t *vib_table;
227 static int32_t amsIncr;
228 static int32_t vibIncr;
229 static int32_t feedback2; /* connect for SLOT 2 */
230
231 /* log output level */
232 #define LOG_ERR 3 /* ERROR */
233 #define LOG_WAR 2 /* WARNING */
234 #define LOG_INF 1 /* INFORMATION */
235
236 //#define LOG_LEVEL LOG_INF
237 #define LOG_LEVEL LOG_ERR
238
239 //#define LOG(n,x) if( (n)>=LOG_LEVEL ) logerror x
240 #define LOG(n,x)
241
242 /* --------------------- subroutines --------------------- */
243
244 static inline int Limit( int val, int max, int min ) {
245 if ( val > max )
246 val = max;
247 else if ( val < min )
248 val = min;
249
250 return val;
251 }
252
253 /* status set and IRQ handling */
254 static inline void OPL_STATUS_SET(FM_OPL *OPL,int flag)
255 {
256 /* set status flag */
257 OPL->status |= flag;
258 if(!(OPL->status & 0x80))
259 {
260 if(OPL->status & OPL->statusmask)
261 { /* IRQ on */
262 OPL->status |= 0x80;
263 /* callback user interrupt handler (IRQ is OFF to ON) */
264 if(OPL->IRQHandler) (OPL->IRQHandler)(OPL->IRQParam,1);
265 }
266 }
267 }
268
269 /* status reset and IRQ handling */
270 static inline void OPL_STATUS_RESET(FM_OPL *OPL,int flag)
271 {
272 /* reset status flag */
273 OPL->status &=~flag;
274 if((OPL->status & 0x80))
275 {
276 if (!(OPL->status & OPL->statusmask) )
277 {
278 OPL->status &= 0x7f;
279 /* callback user interrupt handler (IRQ is ON to OFF) */
280 if(OPL->IRQHandler) (OPL->IRQHandler)(OPL->IRQParam,0);
281 }
282 }
283 }
284
285 /* IRQ mask set */
286 static inline void OPL_STATUSMASK_SET(FM_OPL *OPL,int flag)
287 {
288 OPL->statusmask = flag;
289 /* IRQ handling check */
290 OPL_STATUS_SET(OPL,0);
291 OPL_STATUS_RESET(OPL,0);
292 }
293
294 /* ----- key on ----- */
295 static inline void OPL_KEYON(OPL_SLOT *SLOT)
296 {
297 /* sin wave restart */
298 SLOT->Cnt = 0;
299 /* set attack */
300 SLOT->evm = ENV_MOD_AR;
301 SLOT->evs = SLOT->evsa;
302 SLOT->evc = EG_AST;
303 SLOT->eve = EG_AED;
304 }
305 /* ----- key off ----- */
306 static inline void OPL_KEYOFF(OPL_SLOT *SLOT)
307 {
308 if( SLOT->evm > ENV_MOD_RR)
309 {
310 /* set envelope counter from envleope output */
311 SLOT->evm = ENV_MOD_RR;
312 if( !(SLOT->evc&EG_DST) )
313 //SLOT->evc = (ENV_CURVE[SLOT->evc>>ENV_BITS]<<ENV_BITS) + EG_DST;
314 SLOT->evc = EG_DST;
315 SLOT->eve = EG_DED;
316 SLOT->evs = SLOT->evsr;
317 }
318 }
319
320 /* ---------- calcrate Envelope Generator & Phase Generator ---------- */
321 /* return : envelope output */
322 static inline uint32_t OPL_CALC_SLOT( OPL_SLOT *SLOT )
323 {
324 /* calcrate envelope generator */
325 if( (SLOT->evc+=SLOT->evs) >= SLOT->eve )
326 {
327 switch( SLOT->evm ){
328 case ENV_MOD_AR: /* ATTACK -> DECAY1 */
329 /* next DR */
330 SLOT->evm = ENV_MOD_DR;
331 SLOT->evc = EG_DST;
332 SLOT->eve = SLOT->SL;
333 SLOT->evs = SLOT->evsd;
334 break;
335 case ENV_MOD_DR: /* DECAY -> SL or RR */
336 SLOT->evc = SLOT->SL;
337 SLOT->eve = EG_DED;
338 if(SLOT->eg_typ)
339 {
340 SLOT->evs = 0;
341 }
342 else
343 {
344 SLOT->evm = ENV_MOD_RR;
345 SLOT->evs = SLOT->evsr;
346 }
347 break;
348 case ENV_MOD_RR: /* RR -> OFF */
349 SLOT->evc = EG_OFF;
350 SLOT->eve = EG_OFF+1;
351 SLOT->evs = 0;
352 break;
353 }
354 }
355 /* calcrate envelope */
356 return SLOT->TLL+ENV_CURVE[SLOT->evc>>ENV_BITS]+(SLOT->ams ? ams : 0);
357 }
358
359 /* set algorithm connection */
360 static void set_algorithm( OPL_CH *CH)
361 {
362 int32_t *carrier = &outd[0];
363 CH->connect1 = CH->CON ? carrier : &feedback2;
364 CH->connect2 = carrier;
365 }
366
367 /* ---------- frequency counter for operater update ---------- */
368 static inline void CALC_FCSLOT(OPL_CH *CH,OPL_SLOT *SLOT)
369 {
370 int ksr;
371
372 /* frequency step counter */
373 SLOT->Incr = CH->fc * SLOT->mul;
374 ksr = CH->kcode >> SLOT->KSR;
375
376 if( SLOT->ksr != ksr )
377 {
378 SLOT->ksr = ksr;
379 /* attack , decay rate recalcration */
380 SLOT->evsa = SLOT->AR[ksr];
381 SLOT->evsd = SLOT->DR[ksr];
382 SLOT->evsr = SLOT->RR[ksr];
383 }
384 SLOT->TLL = SLOT->TL + (CH->ksl_base>>SLOT->ksl);
385 }
386
387 /* set multi,am,vib,EG-TYP,KSR,mul */
388 static inline void set_mul(FM_OPL *OPL,int slot,int v)
389 {
390 OPL_CH *CH = &OPL->P_CH[slot/2];
391 OPL_SLOT *SLOT = &CH->SLOT[slot&1];
392
393 SLOT->mul = MUL_TABLE[v&0x0f];
394 SLOT->KSR = (v&0x10) ? 0 : 2;
395 SLOT->eg_typ = (v&0x20)>>5;
396 SLOT->vib = (v&0x40);
397 SLOT->ams = (v&0x80);
398 CALC_FCSLOT(CH,SLOT);
399 }
400
401 /* set ksl & tl */
402 static inline void set_ksl_tl(FM_OPL *OPL,int slot,int v)
403 {
404 OPL_CH *CH = &OPL->P_CH[slot/2];
405 OPL_SLOT *SLOT = &CH->SLOT[slot&1];
406 int ksl = v>>6; /* 0 / 1.5 / 3 / 6 db/OCT */
407
408 SLOT->ksl = ksl ? 3-ksl : 31;
409 SLOT->TL = (v&0x3f)*(0.75/EG_STEP); /* 0.75db step */
410
411 if( !(OPL->mode&0x80) )
412 { /* not CSM latch total level */
413 SLOT->TLL = SLOT->TL + (CH->ksl_base>>SLOT->ksl);
414 }
415 }
416
417 /* set attack rate & decay rate */
418 static inline void set_ar_dr(FM_OPL *OPL,int slot,int v)
419 {
420 OPL_CH *CH = &OPL->P_CH[slot/2];
421 OPL_SLOT *SLOT = &CH->SLOT[slot&1];
422 int ar = v>>4;
423 int dr = v&0x0f;
424
425 SLOT->AR = ar ? &OPL->AR_TABLE[ar<<2] : RATE_0;
426 SLOT->evsa = SLOT->AR[SLOT->ksr];
427 if( SLOT->evm == ENV_MOD_AR ) SLOT->evs = SLOT->evsa;
428
429 SLOT->DR = dr ? &OPL->DR_TABLE[dr<<2] : RATE_0;
430 SLOT->evsd = SLOT->DR[SLOT->ksr];
431 if( SLOT->evm == ENV_MOD_DR ) SLOT->evs = SLOT->evsd;
432 }
433
434 /* set sustain level & release rate */
435 static inline void set_sl_rr(FM_OPL *OPL,int slot,int v)
436 {
437 OPL_CH *CH = &OPL->P_CH[slot/2];
438 OPL_SLOT *SLOT = &CH->SLOT[slot&1];
439 int sl = v>>4;
440 int rr = v & 0x0f;
441
442 SLOT->SL = SL_TABLE[sl];
443 if( SLOT->evm == ENV_MOD_DR ) SLOT->eve = SLOT->SL;
444 SLOT->RR = &OPL->DR_TABLE[rr<<2];
445 SLOT->evsr = SLOT->RR[SLOT->ksr];
446 if( SLOT->evm == ENV_MOD_RR ) SLOT->evs = SLOT->evsr;
447 }
448
449 /* operator output calcrator */
450 #define OP_OUT(slot,env,con) slot->wavetable[((slot->Cnt+con)/(0x1000000/SIN_ENT))&(SIN_ENT-1)][env]
451 /* ---------- calcrate one of channel ---------- */
452 static inline void OPL_CALC_CH( OPL_CH *CH )
453 {
454 uint32_t env_out;
455 OPL_SLOT *SLOT;
456
457 feedback2 = 0;
458 /* SLOT 1 */
459 SLOT = &CH->SLOT[SLOT1];
460 env_out=OPL_CALC_SLOT(SLOT);
461 if( env_out < EG_ENT-1 )
462 {
463 /* PG */
464 if(SLOT->vib) SLOT->Cnt += (SLOT->Incr*vib/VIB_RATE);
465 else SLOT->Cnt += SLOT->Incr;
466 /* connectoion */
467 if(CH->FB)
468 {
469 int feedback1 = (CH->op1_out[0]+CH->op1_out[1])>>CH->FB;
470 CH->op1_out[1] = CH->op1_out[0];
471 *CH->connect1 += CH->op1_out[0] = OP_OUT(SLOT,env_out,feedback1);
472 }
473 else
474 {
475 *CH->connect1 += OP_OUT(SLOT,env_out,0);
476 }
477 }else
478 {
479 CH->op1_out[1] = CH->op1_out[0];
480 CH->op1_out[0] = 0;
481 }
482 /* SLOT 2 */
483 SLOT = &CH->SLOT[SLOT2];
484 env_out=OPL_CALC_SLOT(SLOT);
485 if( env_out < EG_ENT-1 )
486 {
487 /* PG */
488 if(SLOT->vib) SLOT->Cnt += (SLOT->Incr*vib/VIB_RATE);
489 else SLOT->Cnt += SLOT->Incr;
490 /* connectoion */
491 outd[0] += OP_OUT(SLOT,env_out, feedback2);
492 }
493 }
494
495 /* ---------- calcrate rhythm block ---------- */
496 #define WHITE_NOISE_db 6.0
497 static inline void OPL_CALC_RH( OPL_CH *CH )
498 {
499 uint32_t env_tam,env_sd,env_top,env_hh;
500 int whitenoise = (rand()&1)*(WHITE_NOISE_db/EG_STEP);
501 int32_t tone8;
502
503 OPL_SLOT *SLOT;
504 int env_out;
505
506 /* BD : same as FM serial mode and output level is large */
507 feedback2 = 0;
508 /* SLOT 1 */
509 SLOT = &CH[6].SLOT[SLOT1];
510 env_out=OPL_CALC_SLOT(SLOT);
511 if( env_out < EG_ENT-1 )
512 {
513 /* PG */
514 if(SLOT->vib) SLOT->Cnt += (SLOT->Incr*vib/VIB_RATE);
515 else SLOT->Cnt += SLOT->Incr;
516 /* connectoion */
517 if(CH[6].FB)
518 {
519 int feedback1 = (CH[6].op1_out[0]+CH[6].op1_out[1])>>CH[6].FB;
520 CH[6].op1_out[1] = CH[6].op1_out[0];
521 feedback2 = CH[6].op1_out[0] = OP_OUT(SLOT,env_out,feedback1);
522 }
523 else
524 {
525 feedback2 = OP_OUT(SLOT,env_out,0);
526 }
527 }else
528 {
529 feedback2 = 0;
530 CH[6].op1_out[1] = CH[6].op1_out[0];
531 CH[6].op1_out[0] = 0;
532 }
533 /* SLOT 2 */
534 SLOT = &CH[6].SLOT[SLOT2];
535 env_out=OPL_CALC_SLOT(SLOT);
536 if( env_out < EG_ENT-1 )
537 {
538 /* PG */
539 if(SLOT->vib) SLOT->Cnt += (SLOT->Incr*vib/VIB_RATE);
540 else SLOT->Cnt += SLOT->Incr;
541 /* connectoion */
542 outd[0] += OP_OUT(SLOT,env_out, feedback2)*2;
543 }
544
545 // SD (17) = mul14[fnum7] + white noise
546 // TAM (15) = mul15[fnum8]
547 // TOP (18) = fnum6(mul18[fnum8]+whitenoise)
548 // HH (14) = fnum7(mul18[fnum8]+whitenoise) + white noise
549 env_sd =OPL_CALC_SLOT(SLOT7_2) + whitenoise;
550 env_tam=OPL_CALC_SLOT(SLOT8_1);
551 env_top=OPL_CALC_SLOT(SLOT8_2);
552 env_hh =OPL_CALC_SLOT(SLOT7_1) + whitenoise;
553
554 /* PG */
555 if(SLOT7_1->vib) SLOT7_1->Cnt += (2*SLOT7_1->Incr*vib/VIB_RATE);
556 else SLOT7_1->Cnt += 2*SLOT7_1->Incr;
557 if(SLOT7_2->vib) SLOT7_2->Cnt += ((CH[7].fc*8)*vib/VIB_RATE);
558 else SLOT7_2->Cnt += (CH[7].fc*8);
559 if(SLOT8_1->vib) SLOT8_1->Cnt += (SLOT8_1->Incr*vib/VIB_RATE);
560 else SLOT8_1->Cnt += SLOT8_1->Incr;
561 if(SLOT8_2->vib) SLOT8_2->Cnt += ((CH[8].fc*48)*vib/VIB_RATE);
562 else SLOT8_2->Cnt += (CH[8].fc*48);
563
564 tone8 = OP_OUT(SLOT8_2,whitenoise,0 );
565
566 /* SD */
567 if( env_sd < EG_ENT-1 )
568 outd[0] += OP_OUT(SLOT7_1,env_sd, 0)*8;
569 /* TAM */
570 if( env_tam < EG_ENT-1 )
571 outd[0] += OP_OUT(SLOT8_1,env_tam, 0)*2;
572 /* TOP-CY */
573 if( env_top < EG_ENT-1 )
574 outd[0] += OP_OUT(SLOT7_2,env_top,tone8)*2;
575 /* HH */
576 if( env_hh < EG_ENT-1 )
577 outd[0] += OP_OUT(SLOT7_2,env_hh,tone8)*2;
578 }
579
580 /* ----------- initialize time tabls ----------- */
581 static void init_timetables( FM_OPL *OPL , int ARRATE , int DRRATE )
582 {
583 int i;
584 double rate;
585
586 /* make attack rate & decay rate tables */
587 for (i = 0;i < 4;i++) OPL->AR_TABLE[i] = OPL->DR_TABLE[i] = 0;
588 for (i = 4;i <= 60;i++){
589 rate = OPL->freqbase; /* frequency rate */
590 if( i < 60 ) rate *= 1.0+(i&3)*0.25; /* b0-1 : x1 , x1.25 , x1.5 , x1.75 */
591 rate *= 1<<((i>>2)-1); /* b2-5 : shift bit */
592 rate *= (double)(EG_ENT<<ENV_BITS);
593 OPL->AR_TABLE[i] = rate / ARRATE;
594 OPL->DR_TABLE[i] = rate / DRRATE;
595 }
596 for (i = 60; i < ARRAY_SIZE(OPL->AR_TABLE); i++)
597 {
598 OPL->AR_TABLE[i] = EG_AED-1;
599 OPL->DR_TABLE[i] = OPL->DR_TABLE[60];
600 }
601 #if 0
602 for (i = 0;i < 64 ;i++){ /* make for overflow area */
603 LOG(LOG_WAR, ("rate %2d , ar %f ms , dr %f ms\n", i,
604 ((double)(EG_ENT<<ENV_BITS) / OPL->AR_TABLE[i]) * (1000.0 / OPL->rate),
605 ((double)(EG_ENT<<ENV_BITS) / OPL->DR_TABLE[i]) * (1000.0 / OPL->rate) ));
606 }
607 #endif
608 }
609
610 /* ---------- generic table initialize ---------- */
611 static int OPLOpenTable( void )
612 {
613 int s,t;
614 double rate;
615 int i,j;
616 double pom;
617
618 /* allocate dynamic tables */
619 if( (TL_TABLE = malloc(TL_MAX*2*sizeof(int32_t))) == NULL)
620 return 0;
621 if( (SIN_TABLE = malloc(SIN_ENT*4 *sizeof(int32_t *))) == NULL)
622 {
623 free(TL_TABLE);
624 return 0;
625 }
626 if( (AMS_TABLE = malloc(AMS_ENT*2 *sizeof(int32_t))) == NULL)
627 {
628 free(TL_TABLE);
629 free(SIN_TABLE);
630 return 0;
631 }
632 if( (VIB_TABLE = malloc(VIB_ENT*2 *sizeof(int32_t))) == NULL)
633 {
634 free(TL_TABLE);
635 free(SIN_TABLE);
636 free(AMS_TABLE);
637 return 0;
638 }
639 /* make total level table */
640 for (t = 0;t < EG_ENT-1 ;t++){
641 rate = ((1<<TL_BITS)-1)/pow(10,EG_STEP*t/20); /* dB -> voltage */
642 TL_TABLE[ t] = (int)rate;
643 TL_TABLE[TL_MAX+t] = -TL_TABLE[t];
644 /* LOG(LOG_INF,("TotalLevel(%3d) = %x\n",t,TL_TABLE[t]));*/
645 }
646 /* fill volume off area */
647 for ( t = EG_ENT-1; t < TL_MAX ;t++){
648 TL_TABLE[t] = TL_TABLE[TL_MAX+t] = 0;
649 }
650
651 /* make sinwave table (total level offet) */
652 /* degree 0 = degree 180 = off */
653 SIN_TABLE[0] = SIN_TABLE[SIN_ENT/2] = &TL_TABLE[EG_ENT-1];
654 for (s = 1;s <= SIN_ENT/4;s++){
655 pom = sin(2*PI*s/SIN_ENT); /* sin */
656 pom = 20*log10(1/pom); /* decibel */
657 j = pom / EG_STEP; /* TL_TABLE steps */
658
659 /* degree 0 - 90 , degree 180 - 90 : plus section */
660 SIN_TABLE[ s] = SIN_TABLE[SIN_ENT/2-s] = &TL_TABLE[j];
661 /* degree 180 - 270 , degree 360 - 270 : minus section */
662 SIN_TABLE[SIN_ENT/2+s] = SIN_TABLE[SIN_ENT -s] = &TL_TABLE[TL_MAX+j];
663 /* LOG(LOG_INF,("sin(%3d) = %f:%f db\n",s,pom,(double)j * EG_STEP));*/
664 }
665 for (s = 0;s < SIN_ENT;s++)
666 {
667 SIN_TABLE[SIN_ENT*1+s] = s<(SIN_ENT/2) ? SIN_TABLE[s] : &TL_TABLE[EG_ENT];
668 SIN_TABLE[SIN_ENT*2+s] = SIN_TABLE[s % (SIN_ENT/2)];
669 SIN_TABLE[SIN_ENT*3+s] = (s/(SIN_ENT/4))&1 ? &TL_TABLE[EG_ENT] : SIN_TABLE[SIN_ENT*2+s];
670 }
671
672 /* envelope counter -> envelope output table */
673 for (i=0; i<EG_ENT; i++)
674 {
675 /* ATTACK curve */
676 pom = pow( ((double)(EG_ENT-1-i)/EG_ENT) , 8 ) * EG_ENT;
677 /* if( pom >= EG_ENT ) pom = EG_ENT-1; */
678 ENV_CURVE[i] = (int)pom;
679 /* DECAY ,RELEASE curve */
680 ENV_CURVE[(EG_DST>>ENV_BITS)+i]= i;
681 }
682 /* off */
683 ENV_CURVE[EG_OFF>>ENV_BITS]= EG_ENT-1;
684 /* make LFO ams table */
685 for (i=0; i<AMS_ENT; i++)
686 {
687 pom = (1.0+sin(2*PI*i/AMS_ENT))/2; /* sin */
688 AMS_TABLE[i] = (1.0/EG_STEP)*pom; /* 1dB */
689 AMS_TABLE[AMS_ENT+i] = (4.8/EG_STEP)*pom; /* 4.8dB */
690 }
691 /* make LFO vibrate table */
692 for (i=0; i<VIB_ENT; i++)
693 {
694 /* 100cent = 1seminote = 6% ?? */
695 pom = (double)VIB_RATE*0.06*sin(2*PI*i/VIB_ENT); /* +-100sect step */
696 VIB_TABLE[i] = VIB_RATE + (pom*0.07); /* +- 7cent */
697 VIB_TABLE[VIB_ENT+i] = VIB_RATE + (pom*0.14); /* +-14cent */
698 /* LOG(LOG_INF,("vib %d=%d\n",i,VIB_TABLE[VIB_ENT+i])); */
699 }
700 return 1;
701 }
702
703
704 static void OPLCloseTable( void )
705 {
706 free(TL_TABLE);
707 free(SIN_TABLE);
708 free(AMS_TABLE);
709 free(VIB_TABLE);
710 }
711
712 /* CSM Key Control */
713 static inline void CSMKeyControll(OPL_CH *CH)
714 {
715 OPL_SLOT *slot1 = &CH->SLOT[SLOT1];
716 OPL_SLOT *slot2 = &CH->SLOT[SLOT2];
717 /* all key off */
718 OPL_KEYOFF(slot1);
719 OPL_KEYOFF(slot2);
720 /* total level latch */
721 slot1->TLL = slot1->TL + (CH->ksl_base>>slot1->ksl);
722 slot1->TLL = slot1->TL + (CH->ksl_base>>slot1->ksl);
723 /* key on */
724 CH->op1_out[0] = CH->op1_out[1] = 0;
725 OPL_KEYON(slot1);
726 OPL_KEYON(slot2);
727 }
728
729 /* ---------- opl initialize ---------- */
730 static void OPL_initialize(FM_OPL *OPL)
731 {
732 int fn;
733
734 /* frequency base */
735 OPL->freqbase = (OPL->rate) ? ((double)OPL->clock / OPL->rate) / 72 : 0;
736 /* Timer base time */
737 OPL->TimerBase = 1.0/((double)OPL->clock / 72.0 );
738 /* make time tables */
739 init_timetables( OPL , OPL_ARRATE , OPL_DRRATE );
740 /* make fnumber -> increment counter table */
741 for( fn=0 ; fn < 1024 ; fn++ )
742 {
743 OPL->FN_TABLE[fn] = OPL->freqbase * fn * FREQ_RATE * (1<<7) / 2;
744 }
745 /* LFO freq.table */
746 OPL->amsIncr = OPL->rate ? (double)AMS_ENT*(1<<AMS_SHIFT) / OPL->rate * 3.7 * ((double)OPL->clock/3600000) : 0;
747 OPL->vibIncr = OPL->rate ? (double)VIB_ENT*(1<<VIB_SHIFT) / OPL->rate * 6.4 * ((double)OPL->clock/3600000) : 0;
748 }
749
750 /* ---------- write a OPL registers ---------- */
751 static void OPLWriteReg(FM_OPL *OPL, int r, int v)
752 {
753 OPL_CH *CH;
754 int slot;
755 int block_fnum;
756
757 switch(r&0xe0)
758 {
759 case 0x00: /* 00-1f:control */
760 switch(r&0x1f)
761 {
762 case 0x01:
763 /* wave selector enable */
764 OPL->wavesel = v&0x20;
765 if(!OPL->wavesel)
766 {
767 /* preset compatible mode */
768 int c;
769 for(c=0;c<OPL->max_ch;c++)
770 {
771 OPL->P_CH[c].SLOT[SLOT1].wavetable = &SIN_TABLE[0];
772 OPL->P_CH[c].SLOT[SLOT2].wavetable = &SIN_TABLE[0];
773 }
774 }
775 return;
776 case 0x02: /* Timer 1 */
777 OPL->T[0] = (256-v)*4;
778 break;
779 case 0x03: /* Timer 2 */
780 OPL->T[1] = (256-v)*16;
781 return;
782 case 0x04: /* IRQ clear / mask and Timer enable */
783 if(v&0x80)
784 { /* IRQ flag clear */
785 OPL_STATUS_RESET(OPL,0x7f);
786 }
787 else
788 { /* set IRQ mask ,timer enable*/
789 uint8_t st1 = v&1;
790 uint8_t st2 = (v>>1)&1;
791 /* IRQRST,T1MSK,t2MSK,EOSMSK,BRMSK,x,ST2,ST1 */
792 OPL_STATUS_RESET(OPL,v&0x78);
793 OPL_STATUSMASK_SET(OPL,((~v)&0x78)|0x01);
794 /* timer 2 */
795 if(OPL->st[1] != st2)
796 {
797 double interval = st2 ? (double)OPL->T[1]*OPL->TimerBase : 0.0;
798 OPL->st[1] = st2;
799 if (OPL->TimerHandler) (OPL->TimerHandler)(OPL->TimerParam+1,interval);
800 }
801 /* timer 1 */
802 if(OPL->st[0] != st1)
803 {
804 double interval = st1 ? (double)OPL->T[0]*OPL->TimerBase : 0.0;
805 OPL->st[0] = st1;
806 if (OPL->TimerHandler) (OPL->TimerHandler)(OPL->TimerParam+0,interval);
807 }
808 }
809 return;
810 }
811 break;
812 case 0x20: /* am,vib,ksr,eg type,mul */
813 slot = slot_array[r&0x1f];
814 if(slot == -1) return;
815 set_mul(OPL,slot,v);
816 return;
817 case 0x40:
818 slot = slot_array[r&0x1f];
819 if(slot == -1) return;
820 set_ksl_tl(OPL,slot,v);
821 return;
822 case 0x60:
823 slot = slot_array[r&0x1f];
824 if(slot == -1) return;
825 set_ar_dr(OPL,slot,v);
826 return;
827 case 0x80:
828 slot = slot_array[r&0x1f];
829 if(slot == -1) return;
830 set_sl_rr(OPL,slot,v);
831 return;
832 case 0xa0:
833 switch(r)
834 {
835 case 0xbd:
836 /* amsep,vibdep,r,bd,sd,tom,tc,hh */
837 {
838 uint8_t rkey = OPL->rhythm^v;
839 OPL->ams_table = &AMS_TABLE[v&0x80 ? AMS_ENT : 0];
840 OPL->vib_table = &VIB_TABLE[v&0x40 ? VIB_ENT : 0];
841 OPL->rhythm = v&0x3f;
842 if(OPL->rhythm&0x20)
843 {
844 #if 0
845 usrintf_showmessage("OPL Rhythm mode select");
846 #endif
847 /* BD key on/off */
848 if(rkey&0x10)
849 {
850 if(v&0x10)
851 {
852 OPL->P_CH[6].op1_out[0] = OPL->P_CH[6].op1_out[1] = 0;
853 OPL_KEYON(&OPL->P_CH[6].SLOT[SLOT1]);
854 OPL_KEYON(&OPL->P_CH[6].SLOT[SLOT2]);
855 }
856 else
857 {
858 OPL_KEYOFF(&OPL->P_CH[6].SLOT[SLOT1]);
859 OPL_KEYOFF(&OPL->P_CH[6].SLOT[SLOT2]);
860 }
861 }
862 /* SD key on/off */
863 if(rkey&0x08)
864 {
865 if(v&0x08) OPL_KEYON(&OPL->P_CH[7].SLOT[SLOT2]);
866 else OPL_KEYOFF(&OPL->P_CH[7].SLOT[SLOT2]);
867 }/* TAM key on/off */
868 if(rkey&0x04)
869 {
870 if(v&0x04) OPL_KEYON(&OPL->P_CH[8].SLOT[SLOT1]);
871 else OPL_KEYOFF(&OPL->P_CH[8].SLOT[SLOT1]);
872 }
873 /* TOP-CY key on/off */
874 if(rkey&0x02)
875 {
876 if(v&0x02) OPL_KEYON(&OPL->P_CH[8].SLOT[SLOT2]);
877 else OPL_KEYOFF(&OPL->P_CH[8].SLOT[SLOT2]);
878 }
879 /* HH key on/off */
880 if(rkey&0x01)
881 {
882 if(v&0x01) OPL_KEYON(&OPL->P_CH[7].SLOT[SLOT1]);
883 else OPL_KEYOFF(&OPL->P_CH[7].SLOT[SLOT1]);
884 }
885 }
886 }
887 return;
888 }
889 /* keyon,block,fnum */
890 if( (r&0x0f) > 8) return;
891 CH = &OPL->P_CH[r&0x0f];
892 if(!(r&0x10))
893 { /* a0-a8 */
894 block_fnum = (CH->block_fnum&0x1f00) | v;
895 }
896 else
897 { /* b0-b8 */
898 int keyon = (v>>5)&1;
899 block_fnum = ((v&0x1f)<<8) | (CH->block_fnum&0xff);
900 if(CH->keyon != keyon)
901 {
902 if( (CH->keyon=keyon) )
903 {
904 CH->op1_out[0] = CH->op1_out[1] = 0;
905 OPL_KEYON(&CH->SLOT[SLOT1]);
906 OPL_KEYON(&CH->SLOT[SLOT2]);
907 }
908 else
909 {
910 OPL_KEYOFF(&CH->SLOT[SLOT1]);
911 OPL_KEYOFF(&CH->SLOT[SLOT2]);
912 }
913 }
914 }
915 /* update */
916 if(CH->block_fnum != block_fnum)
917 {
918 int blockRv = 7-(block_fnum>>10);
919 int fnum = block_fnum&0x3ff;
920 CH->block_fnum = block_fnum;
921
922 CH->ksl_base = KSL_TABLE[block_fnum>>6];
923 CH->fc = OPL->FN_TABLE[fnum]>>blockRv;
924 CH->kcode = CH->block_fnum>>9;
925 if( (OPL->mode&0x40) && CH->block_fnum&0x100) CH->kcode |=1;
926 CALC_FCSLOT(CH,&CH->SLOT[SLOT1]);
927 CALC_FCSLOT(CH,&CH->SLOT[SLOT2]);
928 }
929 return;
930 case 0xc0:
931 /* FB,C */
932 if( (r&0x0f) > 8) return;
933 CH = &OPL->P_CH[r&0x0f];
934 {
935 int feedback = (v>>1)&7;
936 CH->FB = feedback ? (8+1) - feedback : 0;
937 CH->CON = v&1;
938 set_algorithm(CH);
939 }
940 return;
941 case 0xe0: /* wave type */
942 slot = slot_array[r&0x1f];
943 if(slot == -1) return;
944 CH = &OPL->P_CH[slot/2];
945 if(OPL->wavesel)
946 {
947 /* LOG(LOG_INF,("OPL SLOT %d wave select %d\n",slot,v&3)); */
948 CH->SLOT[slot&1].wavetable = &SIN_TABLE[(v&0x03)*SIN_ENT];
949 }
950 return;
951 }
952 }
953
954 /* lock/unlock for common table */
955 static int OPL_LockTable(void)
956 {
957 num_lock++;
958 if(num_lock>1) return 0;
959 /* first time */
960 cur_chip = NULL;
961 /* allocate total level table (128kb space) */
962 if( !OPLOpenTable() )
963 {
964 num_lock--;
965 return -1;
966 }
967 return 0;
968 }
969
970 static void OPL_UnLockTable(void)
971 {
972 if(num_lock) num_lock--;
973 if(num_lock) return;
974 /* last time */
975 cur_chip = NULL;
976 OPLCloseTable();
977 }
978
979 /*******************************************************************************/
980 /* YM3812 local section */
981 /*******************************************************************************/
982
983 /* ---------- update one of chip ----------- */
984 void YM3812UpdateOne(FM_OPL *OPL, int16_t *buffer, int length)
985 {
986 int i;
987 int data;
988 int16_t *buf = buffer;
989 uint32_t amsCnt = OPL->amsCnt;
990 uint32_t vibCnt = OPL->vibCnt;
991 uint8_t rhythm = OPL->rhythm&0x20;
992 OPL_CH *CH,*R_CH;
993
994 if( (void *)OPL != cur_chip ){
995 cur_chip = (void *)OPL;
996 /* channel pointers */
997 S_CH = OPL->P_CH;
998 E_CH = &S_CH[9];
999 /* rhythm slot */
1000 SLOT7_1 = &S_CH[7].SLOT[SLOT1];
1001 SLOT7_2 = &S_CH[7].SLOT[SLOT2];
1002 SLOT8_1 = &S_CH[8].SLOT[SLOT1];
1003 SLOT8_2 = &S_CH[8].SLOT[SLOT2];
1004 /* LFO state */
1005 amsIncr = OPL->amsIncr;
1006 vibIncr = OPL->vibIncr;
1007 ams_table = OPL->ams_table;
1008 vib_table = OPL->vib_table;
1009 }
1010 R_CH = rhythm ? &S_CH[6] : E_CH;
1011 for( i=0; i < length ; i++ )
1012 {
1013 /* channel A channel B channel C */
1014 /* LFO */
1015 ams = ams_table[(amsCnt+=amsIncr)>>AMS_SHIFT];
1016 vib = vib_table[(vibCnt+=vibIncr)>>VIB_SHIFT];
1017 outd[0] = 0;
1018 /* FM part */
1019 for(CH=S_CH ; CH < R_CH ; CH++)
1020 OPL_CALC_CH(CH);
1021 /* Rythn part */
1022 if(rhythm)
1023 OPL_CALC_RH(S_CH);
1024 /* limit check */
1025 data = Limit( outd[0] , OPL_MAXOUT, OPL_MINOUT );
1026 /* store to sound buffer */
1027 buf[i] = data >> OPL_OUTSB;
1028 }
1029
1030 OPL->amsCnt = amsCnt;
1031 OPL->vibCnt = vibCnt;
1032 #ifdef OPL_OUTPUT_LOG
1033 if(opl_dbg_fp)
1034 {
1035 for(opl_dbg_chip=0;opl_dbg_chip<opl_dbg_maxchip;opl_dbg_chip++)
1036 if( opl_dbg_opl[opl_dbg_chip] == OPL) break;
1037 fprintf(opl_dbg_fp,"%c%c%c",0x20+opl_dbg_chip,length&0xff,length/256);
1038 }
1039 #endif
1040 }
1041
1042 /* ---------- reset one of chip ---------- */
1043 void OPLResetChip(FM_OPL *OPL)
1044 {
1045 int c,s;
1046 int i;
1047
1048 /* reset chip */
1049 OPL->mode = 0; /* normal mode */
1050 OPL_STATUS_RESET(OPL,0x7f);
1051 /* reset with register write */
1052 OPLWriteReg(OPL,0x01,0); /* wabesel disable */
1053 OPLWriteReg(OPL,0x02,0); /* Timer1 */
1054 OPLWriteReg(OPL,0x03,0); /* Timer2 */
1055 OPLWriteReg(OPL,0x04,0); /* IRQ mask clear */
1056 for(i = 0xff ; i >= 0x20 ; i-- ) OPLWriteReg(OPL,i,0);
1057 /* reset operator parameter */
1058 for( c = 0 ; c < OPL->max_ch ; c++ )
1059 {
1060 OPL_CH *CH = &OPL->P_CH[c];
1061 /* OPL->P_CH[c].PAN = OPN_CENTER; */
1062 for(s = 0 ; s < 2 ; s++ )
1063 {
1064 /* wave table */
1065 CH->SLOT[s].wavetable = &SIN_TABLE[0];
1066 /* CH->SLOT[s].evm = ENV_MOD_RR; */
1067 CH->SLOT[s].evc = EG_OFF;
1068 CH->SLOT[s].eve = EG_OFF+1;
1069 CH->SLOT[s].evs = 0;
1070 }
1071 }
1072 }
1073
1074 /* ---------- Create one of vietual YM3812 ---------- */
1075 /* 'rate' is sampling rate and 'bufsiz' is the size of the */
1076 FM_OPL *OPLCreate(int clock, int rate)
1077 {
1078 char *ptr;
1079 FM_OPL *OPL;
1080 int state_size;
1081 int max_ch = 9; /* normaly 9 channels */
1082
1083 if( OPL_LockTable() ==-1) return NULL;
1084 /* allocate OPL state space */
1085 state_size = sizeof(FM_OPL);
1086 state_size += sizeof(OPL_CH)*max_ch;
1087 /* allocate memory block */
1088 ptr = malloc(state_size);
1089 if(ptr==NULL) return NULL;
1090 /* clear */
1091 memset(ptr,0,state_size);
1092 OPL = (FM_OPL *)ptr; ptr+=sizeof(FM_OPL);
1093 OPL->P_CH = (OPL_CH *)ptr; ptr+=sizeof(OPL_CH)*max_ch;
1094 /* set channel state pointer */
1095 OPL->clock = clock;
1096 OPL->rate = rate;
1097 OPL->max_ch = max_ch;
1098 /* init grobal tables */
1099 OPL_initialize(OPL);
1100 /* reset chip */
1101 OPLResetChip(OPL);
1102 #ifdef OPL_OUTPUT_LOG
1103 if(!opl_dbg_fp)
1104 {
1105 opl_dbg_fp = fopen("opllog.opl","wb");
1106 opl_dbg_maxchip = 0;
1107 }
1108 if(opl_dbg_fp)
1109 {
1110 opl_dbg_opl[opl_dbg_maxchip] = OPL;
1111 fprintf(opl_dbg_fp,"%c%c%c%c%c%c",0x00+opl_dbg_maxchip,
1112 type,
1113 clock&0xff,
1114 (clock/0x100)&0xff,
1115 (clock/0x10000)&0xff,
1116 (clock/0x1000000)&0xff);
1117 opl_dbg_maxchip++;
1118 }
1119 #endif
1120 return OPL;
1121 }
1122
1123 /* ---------- Destroy one of vietual YM3812 ---------- */
1124 void OPLDestroy(FM_OPL *OPL)
1125 {
1126 #ifdef OPL_OUTPUT_LOG
1127 if(opl_dbg_fp)
1128 {
1129 fclose(opl_dbg_fp);
1130 opl_dbg_fp = NULL;
1131 }
1132 #endif
1133 OPL_UnLockTable();
1134 free(OPL);
1135 }
1136
1137 /* ---------- Option handlers ---------- */
1138
1139 void OPLSetTimerHandler(FM_OPL *OPL,OPL_TIMERHANDLER TimerHandler,int channelOffset)
1140 {
1141 OPL->TimerHandler = TimerHandler;
1142 OPL->TimerParam = channelOffset;
1143 }
1144 void OPLSetUpdateHandler(FM_OPL *OPL,OPL_UPDATEHANDLER UpdateHandler,int param)
1145 {
1146 OPL->UpdateHandler = UpdateHandler;
1147 OPL->UpdateParam = param;
1148 }
1149 /* ---------- YM3812 I/O interface ---------- */
1150 int OPLWrite(FM_OPL *OPL,int a,int v)
1151 {
1152 if( !(a&1) )
1153 { /* address port */
1154 OPL->address = v & 0xff;
1155 }
1156 else
1157 { /* data port */
1158 if(OPL->UpdateHandler) OPL->UpdateHandler(OPL->UpdateParam,0);
1159 #ifdef OPL_OUTPUT_LOG
1160 if(opl_dbg_fp)
1161 {
1162 for(opl_dbg_chip=0;opl_dbg_chip<opl_dbg_maxchip;opl_dbg_chip++)
1163 if( opl_dbg_opl[opl_dbg_chip] == OPL) break;
1164 fprintf(opl_dbg_fp,"%c%c%c",0x10+opl_dbg_chip,OPL->address,v);
1165 }
1166 #endif
1167 OPLWriteReg(OPL,OPL->address,v);
1168 }
1169 return OPL->status>>7;
1170 }
1171
1172 unsigned char OPLRead(FM_OPL *OPL,int a)
1173 {
1174 if( !(a&1) )
1175 { /* status port */
1176 return OPL->status & (OPL->statusmask|0x80);
1177 }
1178 /* data port */
1179 switch(OPL->address)
1180 {
1181 case 0x05: /* KeyBoard IN */
1182 return 0;
1183 #if 0
1184 case 0x0f: /* ADPCM-DATA */
1185 return 0;
1186 #endif
1187 case 0x19: /* I/O DATA */
1188 return 0;
1189 case 0x1a: /* PCM-DATA */
1190 return 0;
1191 }
1192 return 0;
1193 }
1194
1195 int OPLTimerOver(FM_OPL *OPL,int c)
1196 {
1197 if( c )
1198 { /* Timer B */
1199 OPL_STATUS_SET(OPL,0x20);
1200 }
1201 else
1202 { /* Timer A */
1203 OPL_STATUS_SET(OPL,0x40);
1204 /* CSM mode key,TL control */
1205 if( OPL->mode & 0x80 )
1206 { /* CSM mode total level latch and auto key on */
1207 int ch;
1208 if(OPL->UpdateHandler) OPL->UpdateHandler(OPL->UpdateParam,0);
1209 for(ch=0;ch<9;ch++)
1210 CSMKeyControll( &OPL->P_CH[ch] );
1211 }
1212 }
1213 /* reload timer */
1214 if (OPL->TimerHandler) (OPL->TimerHandler)(OPL->TimerParam+c,(double)OPL->T[c]*OPL->TimerBase);
1215 return OPL->status>>7;
1216 }
AR7 emulation for QEMU