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