1 // The file has been modified to be built in the blueMSX environment.
2
3 /*
4 **
5 ** File: fmopl.c -- software implementation of FM sound generator
6 **
7 ** Copyright (C) 1999,2000 Tatsuyuki Satoh
8 **
9 **
10 */
11
12 #include <stdio.h>
13 #include <stdlib.h>
14 #include <string.h>
15 #include <stdarg.h>
16 #include <math.h>
17 #include "Fmopl.h"
18 #include "Switches.h"
19 #include "SaveState.h"
20 #include "Board.h"
21
22 #ifndef PI
23 #define PI 3.14159265358979323846
24 #endif
25
26 extern void y8950TimerSet(void* ref, int timer, int count);
27 extern void y8950TimerStart(void* ref, int timer, int start);
28 extern int y8950GetNoteOn(void* ref, int row);
29
30 /* -------------------- preliminary define section --------------------- */
31 /* attack/decay rate time rate */
32 #define OPL_ARRATE 141280 /* RATE 4 = 2826.24ms @ 3.6MHz */
33 #define OPL_DRRATE 1956000 /* RATE 4 = 39280.64ms @ 3.6MHz */
34
35 #define DELTAT_MIXING_LEVEL (1) /* DELTA-T ADPCM MIXING LEVEL */
36
37 #define FREQ_BITS 24 /* frequency turn */
38
39 /* counter bits = 20 , octerve 7 */
40 #define FREQ_RATE (1<<(FREQ_BITS-20))
41 #define TL_BITS (FREQ_BITS+2)
42
43 /* final output shift , limit minimum and maximum */
44 #define OPL_OUTSB (TL_BITS+3-16) /* OPL output final shift 16bit */
45 #define OPL_MAXOUT (0x7fff<<OPL_OUTSB)
46 #define OPL_MINOUT (-0x8000<<OPL_OUTSB)
47
48 /* -------------------- quality selection --------------------- */
49
50 /* sinwave entries */
51 /* used static memory = SIN_ENT * 4 (byte) */
52 #define SIN_ENT 2048
53
54 /* output level entries (envelope,sinwave) */
55 /* envelope counter lower bits */
56 #define ENV_BITS 16
57 /* envelope output entries */
58 #define EG_ENT 4096
59 /* used dynamic memory = EG_ENT*4*4(byte)or EG_ENT*6*4(byte) */
60 /* used static memory = EG_ENT*4 (byte) */
61
62 #define EG_OFF ((2*EG_ENT)<<ENV_BITS) /* OFF */
63 #define EG_DED EG_OFF
64 #define EG_DST (EG_ENT<<ENV_BITS) /* DECAY START */
65 #define EG_AED EG_DST
66 #define EG_AST 0 /* ATTACK START */
67
68 #define EG_STEP (96.0/EG_ENT) /* OPL is 0.1875 dB step */
69
70 /* LFO table entries */
71 #define VIB_ENT 512
72 #define VIB_SHIFT (32-9)
73 #define AMS_ENT 512
74 #define AMS_SHIFT (32-9)
75
76 #define VIB_RATE 256
77
78 /* -------------------- local defines , macros --------------------- */
79
80 /* register number to channel number , slot offset */
81 #define SLOT1 0
82 #define SLOT2 1
83
84 /* envelope phase */
85 #define ENV_MOD_RR 0x00
86 #define ENV_MOD_DR 0x01
87 #define ENV_MOD_AR 0x02
88
89 /* -------------------- tables --------------------- */
90 static const int slot_array[32]=
91 {
92 0, 2, 4, 1, 3, 5,-1,-1,
93 6, 8,10, 7, 9,11,-1,-1,
94 12,14,16,13,15,17,-1,-1,
95 -1,-1,-1,-1,-1,-1,-1,-1
96 };
97
98 /* key scale level */
99 /* table is 3dB/OCT , DV converts this in TL step at 6dB/OCT */
100 #define DV (EG_STEP/2)
101 static const UINT32 KSL_TABLE[8*16]=
102 {
103 /* OCT 0 */
104 (UINT32)(0.000/DV), (UINT32)(0.000/DV), (UINT32)(0.000/DV), (UINT32)(0.000/DV),
105 (UINT32)(0.000/DV), (UINT32)(0.000/DV), (UINT32)(0.000/DV), (UINT32)(0.000/DV),
106 (UINT32)(0.000/DV), (UINT32)(0.000/DV), (UINT32)(0.000/DV), (UINT32)(0.000/DV),
107 (UINT32)(0.000/DV), (UINT32)(0.000/DV), (UINT32)(0.000/DV), (UINT32)(0.000/DV),
108 /* OCT 1 */
109 (UINT32)(0.000/DV), (UINT32)(0.000/DV), (UINT32)(0.000/DV), (UINT32)(0.000/DV),
110 (UINT32)(0.000/DV), (UINT32)(0.000/DV), (UINT32)(0.000/DV), (UINT32)(0.000/DV),
111 (UINT32)(0.000/DV), (UINT32)(0.750/DV), (UINT32)(1.125/DV), (UINT32)(1.500/DV),
112 (UINT32)(1.875/DV), (UINT32)(2.250/DV), (UINT32)(2.625/DV), (UINT32)(3.000/DV),
113 /* OCT 2 */
114 (UINT32)(0.000/DV), (UINT32)(0.000/DV), (UINT32)(0.000/DV), (UINT32)(0.000/DV),
115 (UINT32)(0.000/DV), (UINT32)(1.125/DV), (UINT32)(1.875/DV), (UINT32)(2.625/DV),
116 (UINT32)(3.000/DV), (UINT32)(3.750/DV), (UINT32)(4.125/DV), (UINT32)(4.500/DV),
117 (UINT32)(4.875/DV), (UINT32)(5.250/DV), (UINT32)(5.625/DV), (UINT32)(6.000/DV),
118 /* OCT 3 */
119 (UINT32)(0.000/DV), (UINT32)(0.000/DV), (UINT32)(0.000/DV), (UINT32)(1.875/DV),
120 (UINT32)(3.000/DV), (UINT32)(4.125/DV), (UINT32)(4.875/DV), (UINT32)(5.625/DV),
121 (UINT32)(6.000/DV), (UINT32)(6.750/DV), (UINT32)(7.125/DV), (UINT32)(7.500/DV),
122 (UINT32)(7.875/DV), (UINT32)(8.250/DV), (UINT32)(8.625/DV), (UINT32)(9.000/DV),
123 /* OCT 4 */
124 (UINT32)(0.000/DV), (UINT32)(0.000/DV), (UINT32)(3.000/DV), (UINT32)(4.875/DV),
125 (UINT32)(6.000/DV), (UINT32)(7.125/DV), (UINT32)(7.875/DV), (UINT32)(8.625/DV),
126 (UINT32)(9.000/DV), (UINT32)(9.750/DV),(UINT32)(10.125/DV),(UINT32)(10.500/DV),
127 (UINT32)(10.875/DV),(UINT32)(11.250/DV),(UINT32)(11.625/DV),(UINT32)(12.000/DV),
128 /* OCT 5 */
129 (UINT32)(0.000/DV), (UINT32)(3.000/DV), (UINT32)(6.000/DV), (UINT32)(7.875/DV),
130 (UINT32)(9.000/DV),(UINT32)(10.125/DV),(UINT32)(10.875/DV),(UINT32)(11.625/DV),
131 (UINT32)(12.000/DV),(UINT32)(12.750/DV),(UINT32)(13.125/DV),(UINT32)(13.500/DV),
132 (UINT32)(13.875/DV),(UINT32)(14.250/DV),(UINT32)(14.625/DV),(UINT32)(15.000/DV),
133 /* OCT 6 */
134 (UINT32)(0.000/DV), (UINT32)(6.000/DV), (UINT32)(9.000/DV),(UINT32)(10.875/DV),
135 (UINT32)(12.000/DV),(UINT32)(13.125/DV),(UINT32)(13.875/DV),(UINT32)(14.625/DV),
136 (UINT32)(15.000/DV),(UINT32)(15.750/DV),(UINT32)(16.125/DV),(UINT32)(16.500/DV),
137 (UINT32)(16.875/DV),(UINT32)(17.250/DV),(UINT32)(17.625/DV),(UINT32)(18.000/DV),
138 /* OCT 7 */
139 (UINT32)(0.000/DV), (UINT32)(9.000/DV),(UINT32)(12.000/DV),(UINT32)(13.875/DV),
140 (UINT32)(15.000/DV),(UINT32)(16.125/DV),(UINT32)(16.875/DV),(UINT32)(17.625/DV),
141 (UINT32)(18.000/DV),(UINT32)(18.750/DV),(UINT32)(19.125/DV),(UINT32)(19.500/DV),
142 (UINT32)(19.875/DV),(UINT32)(20.250/DV),(UINT32)(20.625/DV),(UINT32)(21.000/DV)
143 };
144 #undef DV
145
146 /* sustain lebel table (3db per step) */
147 /* 0 - 15: 0, 3, 6, 9,12,15,18,21,24,27,30,33,36,39,42,93 (dB)*/
148 #define SC(db) (INT32)((db*((3/EG_STEP)*(1<<ENV_BITS)))+EG_DST)
149 static const INT32 SL_TABLE[16]={
150 SC( 0),SC( 1),SC( 2),SC(3 ),SC(4 ),SC(5 ),SC(6 ),SC( 7),
151 SC( 8),SC( 9),SC(10),SC(11),SC(12),SC(13),SC(14),SC(31)
152 };
153 #undef SC
154
155 #define TL_MAX (EG_ENT*2) /* limit(tl + ksr + envelope) + sinwave */
156 /* TotalLevel : 48 24 12 6 3 1.5 0.75 (dB) */
157 /* TL_TABLE[ 0 to TL_MAX ] : plus section */
158 /* TL_TABLE[ TL_MAX to TL_MAX+TL_MAX-1 ] : minus section */
159 static INT32 *TL_TABLE;
160
161 /* pointers to TL_TABLE with sinwave output offset */
162 static INT32 **SIN_TABLE;
163
164 /* LFO table */
165 INT32 *AMS_TABLE;
166 INT32 *VIB_TABLE;
167
168 /* envelope output curve table */
169 /* attack + decay + OFF */
170 static INT32 ENV_CURVE[2*EG_ENT+1];
171
172 /* multiple table */
173 #define ML 2
174 static const UINT32 MUL_TABLE[16]= {
175 /* 1/2, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15 */
176 (UINT32)(0.50*ML), (UINT32)(1.00*ML), (UINT32)(2.00*ML), (UINT32)(3.00*ML),
177 (UINT32)(4.00*ML), (UINT32)(5.00*ML), (UINT32)(6.00*ML), (UINT32)(7.00*ML),
178 (UINT32)(8.00*ML), (UINT32)(9.00*ML),(UINT32)(10.00*ML),(UINT32)(10.00*ML),
179 (UINT32)(12.00*ML),(UINT32)(12.00*ML),(UINT32)(15.00*ML),(UINT32)(15.00*ML)
180 };
181 #undef ML
182
183 /* dummy attack / decay rate ( when rate == 0 ) */
184 static INT32 RATE_0[16]=
185 {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
186
187 /* -------------------- static state --------------------- */
188
189 /* lock level of common table */
190
191 /* work table */
192 void *cur_chip = NULL; /* current chip point */
193 /* currenct chip state */
194 /* static OPLSAMPLE *bufL,*bufR; */
195 OPL_CH *S_CH;
196 OPL_CH *E_CH;
197 OPL_SLOT *SLOT7_1,*SLOT7_2,*SLOT8_1,*SLOT8_2;
198
199 int num_lock = 0;
200 INT32 *ams_table;
201 INT32 *vib_table;
202 INT32 amsIncr;
203 INT32 vibIncr;
204 INT32 outd;
205 INT32 ams;
206 INT32 vib;
207 INT32 feedback2; /* connect for SLOT 2 */
208
209 /* --------------------- subroutines --------------------- */
210
Limit(int val,int max,int min)211 int Limit( int val, int max, int min ) {
212 if ( val > max )
213 val = max;
214 else if ( val < min )
215 val = min;
216
217 return val;
218 }
219
220 /* status set and IRQ handling */
OPL_STATUS_SET(FM_OPL * OPL,int flag)221 void OPL_STATUS_SET(FM_OPL *OPL,int flag)
222 {
223 /* set status flag */
224 OPL->status |= flag;
225
226 if(!(OPL->status & 0x80))
227 {
228 if(OPL->status & OPL->statusmask)
229 { /* IRQ on */
230 OPL->status |= 0x80;
231 boardSetInt(0x10);
232 }
233 }
234 }
235
236 /* status reset and IRQ handling */
OPL_STATUS_RESET(FM_OPL * OPL,int flag)237 void OPL_STATUS_RESET(FM_OPL *OPL,int flag)
238 {
239 /* reset status flag */
240 OPL->status &=~flag;
241 if((OPL->status & 0x80))
242 {
243 if (!(OPL->status & OPL->statusmask) )
244 {
245 OPL->status &= 0x7f;
246 boardClearInt(0x10);
247 }
248 }
249 }
250
251 /* IRQ mask set */
OPL_STATUSMASK_SET(FM_OPL * OPL,int flag)252 void OPL_STATUSMASK_SET(FM_OPL *OPL,int flag)
253 {
254 OPL->statusmask = flag;
255 /* IRQ handling check */
256 OPL_STATUS_SET(OPL,0);
257 OPL_STATUS_RESET(OPL,0);
258 }
259
260 /* ----- key on ----- */
OPL_KEYON(OPL_SLOT * SLOT)261 void OPL_KEYON(OPL_SLOT *SLOT)
262 {
263 /* sin wave restart */
264 SLOT->Cnt = 0;
265 /* set attack */
266 SLOT->evm = ENV_MOD_AR;
267 SLOT->evs = SLOT->evsa;
268 SLOT->evc = EG_AST;
269 SLOT->eve = EG_AED;
270 }
271 /* ----- key off ----- */
OPL_KEYOFF(OPL_SLOT * SLOT)272 void OPL_KEYOFF(OPL_SLOT *SLOT)
273 {
274 if( SLOT->evm > ENV_MOD_RR)
275 {
276 /* set envelope counter from envleope output */
277 SLOT->evm = ENV_MOD_RR;
278 if( !(SLOT->evc&EG_DST) )
279 /*SLOT->evc = (ENV_CURVE[SLOT->evc>>ENV_BITS]<<ENV_BITS) + EG_DST; */
280 SLOT->evc = EG_DST;
281 SLOT->eve = EG_DED;
282 SLOT->evs = SLOT->evsr;
283 }
284 }
285
286 /* ---------- calcrate Envelope Generator & Phase Generator ---------- */
287 /* return : envelope output */
OPL_CALC_SLOT(OPL_SLOT * SLOT)288 UINT32 OPL_CALC_SLOT( OPL_SLOT *SLOT )
289 {
290 /* calcrate envelope generator */
291 if( (SLOT->evc+=SLOT->evs) >= SLOT->eve )
292 {
293 switch( SLOT->evm ){
294 case ENV_MOD_AR: /* ATTACK -> DECAY1 */
295 /* next DR */
296 SLOT->evm = ENV_MOD_DR;
297 SLOT->evc = EG_DST;
298 SLOT->eve = SLOT->SL;
299 SLOT->evs = SLOT->evsd;
300 break;
301 case ENV_MOD_DR: /* DECAY -> SL or RR */
302 SLOT->evc = SLOT->SL;
303 SLOT->eve = EG_DED;
304 if(SLOT->eg_typ)
305 {
306 SLOT->evs = 0;
307 }
308 else
309 {
310 SLOT->evm = ENV_MOD_RR;
311 SLOT->evs = SLOT->evsr;
312 }
313 break;
314 case ENV_MOD_RR: /* RR -> OFF */
315 SLOT->evc = EG_OFF;
316 SLOT->eve = EG_OFF+1;
317 SLOT->evs = 0;
318 break;
319 }
320 }
321 /* calcrate envelope */
322 return SLOT->TLL+ENV_CURVE[SLOT->evc>>ENV_BITS]+(SLOT->ams ? ams : 0);
323 }
324
325 /* ---------- frequency counter for operater update ---------- */
CALC_FCSLOT(FM_OPL * OPL,OPL_CH * CH,OPL_SLOT * SLOT)326 void CALC_FCSLOT(FM_OPL *OPL,OPL_CH *CH,OPL_SLOT *SLOT)
327 {
328 int ksr;
329
330 /* frequency step counter */
331 SLOT->Incr = CH->fc * SLOT->mul;
332 ksr = CH->kcode >> SLOT->KSR;
333
334 if( SLOT->ksr != ksr )
335 {
336 SLOT->ksr = ksr;
337 /* attack , decay rate recalcration */
338 SLOT->evsa = (SLOT->AR ? &OPL->AR_TABLE[SLOT->AR<<2] : RATE_0)[ksr];
339 SLOT->evsd = (SLOT->DR ? &OPL->DR_TABLE[SLOT->DR<<2] : RATE_0)[ksr];
340 SLOT->evsr = (&OPL->DR_TABLE[SLOT->RR])[ksr];
341 }
342 SLOT->TLL = SLOT->TL + (CH->ksl_base>>SLOT->ksl);
343 }
344
345 /* set multi,am,vib,EG-TYP,KSR,mul */
set_mul(FM_OPL * OPL,int slot,int v)346 void set_mul(FM_OPL *OPL,int slot,int v)
347 {
348 OPL_CH *CH = &OPL->P_CH[slot/2];
349 OPL_SLOT *SLOT = &CH->SLOT[slot&1];
350
351 SLOT->mul = MUL_TABLE[v&0x0f];
352 SLOT->KSR = (v&0x10) ? 0 : 2;
353 SLOT->eg_typ = (v&0x20)>>5;
354 SLOT->vib = (v&0x40);
355 SLOT->ams = (v&0x80);
356 CALC_FCSLOT(OPL,CH,SLOT);
357 }
358
359 /* set ksl & tl */
set_ksl_tl(FM_OPL * OPL,int slot,int v)360 void set_ksl_tl(FM_OPL *OPL,int slot,int v)
361 {
362 OPL_CH *CH = &OPL->P_CH[slot/2];
363 OPL_SLOT *SLOT = &CH->SLOT[slot&1];
364 int ksl = v>>6; /* 0 / 1.5 / 3 / 6 db/OCT */
365
366 SLOT->ksl = ksl ? 3-ksl : 31;
367 SLOT->TL = (INT32)((v&0x3f)*(0.75/EG_STEP)); /* 0.75db step */
368
369 if( !(OPL->mode&0x80) )
370 { /* not CSM latch total level */
371 SLOT->TLL = SLOT->TL + (CH->ksl_base>>SLOT->ksl);
372 }
373 }
374
375 /* set attack rate & decay rate */
set_ar_dr(FM_OPL * OPL,int slot,int v)376 void set_ar_dr(FM_OPL *OPL,int slot,int v)
377 {
378 OPL_CH *CH = &OPL->P_CH[slot/2];
379 OPL_SLOT *SLOT = &CH->SLOT[slot&1];
380 int ar = v>>4;
381 int dr = v&0x0f;
382
383 SLOT->AR = ar;
384 SLOT->evsa = (SLOT->AR ? &OPL->AR_TABLE[SLOT->AR<<2] : RATE_0)[SLOT->ksr];
385 if( SLOT->evm == ENV_MOD_AR ) SLOT->evs = SLOT->evsa;
386
387 SLOT->DR = dr;
388 SLOT->evsd = (SLOT->DR ? &OPL->DR_TABLE[SLOT->DR<<2] : RATE_0)[SLOT->ksr];
389 if( SLOT->evm == ENV_MOD_DR ) SLOT->evs = SLOT->evsd;
390 }
391
392 /* set sustain level & release rate */
set_sl_rr(FM_OPL * OPL,int slot,int v)393 void set_sl_rr(FM_OPL *OPL,int slot,int v)
394 {
395 OPL_CH *CH = &OPL->P_CH[slot/2];
396 OPL_SLOT *SLOT = &CH->SLOT[slot&1];
397 int sl = v>>4;
398 int rr = v & 0x0f;
399
400 SLOT->SL = SL_TABLE[sl];
401 if( SLOT->evm == ENV_MOD_DR ) SLOT->eve = SLOT->SL;
402 SLOT->RR = rr << 2;
403 SLOT->evsr = (&OPL->DR_TABLE[SLOT->RR])[SLOT->ksr];
404 if( SLOT->evm == ENV_MOD_RR ) SLOT->evs = SLOT->evsr;
405 }
406
407 /* operator output calcrator */
408 #define OP_OUT(slot,env,con) (&SIN_TABLE[slot->wavetableidx])[((slot->Cnt+con)/(0x1000000/SIN_ENT))&(SIN_ENT-1)][env]
409 /* ---------- calcrate one of channel ---------- */
OPL_CALC_CH(OPL_CH * CH)410 void OPL_CALC_CH( OPL_CH *CH )
411 {
412 UINT32 env_out;
413 OPL_SLOT *SLOT;
414
415 feedback2 = 0;
416 /* SLOT 1 */
417 SLOT = &CH->SLOT[SLOT1];
418 env_out=OPL_CALC_SLOT(SLOT);
419 if( env_out < EG_ENT-1 )
420 {
421 /* PG */
422 if(SLOT->vib) SLOT->Cnt += (SLOT->Incr*vib/VIB_RATE);
423 else SLOT->Cnt += SLOT->Incr;
424 /* connectoion */
425 if(CH->FB)
426 {
427 int feedback1 = (CH->op1_out[0]+CH->op1_out[1])>>CH->FB;
428 CH->op1_out[1] = CH->op1_out[0];
429 *(CH->CON ? &outd : &feedback2) += CH->op1_out[0] = OP_OUT(SLOT,env_out,feedback1);
430 }
431 else
432 {
433 *(CH->CON ? &outd : &feedback2) += OP_OUT(SLOT,env_out,0);
434 }
435 }else
436 {
437 CH->op1_out[1] = CH->op1_out[0];
438 CH->op1_out[0] = 0;
439 }
440 /* SLOT 2 */
441 SLOT = &CH->SLOT[SLOT2];
442 env_out=OPL_CALC_SLOT(SLOT);
443 if( env_out < EG_ENT-1 )
444 {
445 /* PG */
446 if(SLOT->vib) SLOT->Cnt += (SLOT->Incr*vib/VIB_RATE);
447 else SLOT->Cnt += SLOT->Incr;
448 /* connectoion */
449 outd += OP_OUT(SLOT,env_out, feedback2);
450 }
451 }
452
453 /* ---------- calcrate rythm block ---------- */
454 #define WHITE_NOISE_db 6.0
OPL_CALC_RH(OPL_CH * CH)455 void OPL_CALC_RH( OPL_CH *CH )
456 {
457 UINT32 env_tam,env_sd,env_top,env_hh;
458 int whitenoise = (int)((rand()&1)*(WHITE_NOISE_db/EG_STEP));
459 INT32 tone8;
460
461 OPL_SLOT *SLOT;
462 int env_out;
463
464 /* BD : same as FM serial mode and output level is large */
465 feedback2 = 0;
466 /* SLOT 1 */
467 SLOT = &CH[6].SLOT[SLOT1];
468 env_out=OPL_CALC_SLOT(SLOT);
469 if( env_out < EG_ENT-1 )
470 {
471 /* PG */
472 if(SLOT->vib) SLOT->Cnt += (SLOT->Incr*vib/VIB_RATE);
473 else SLOT->Cnt += SLOT->Incr;
474 /* connectoion */
475 if(CH[6].FB)
476 {
477 int feedback1 = (CH[6].op1_out[0]+CH[6].op1_out[1])>>CH[6].FB;
478 CH[6].op1_out[1] = CH[6].op1_out[0];
479 feedback2 = CH[6].op1_out[0] = OP_OUT(SLOT,env_out,feedback1);
480 }
481 else
482 {
483 feedback2 = OP_OUT(SLOT,env_out,0);
484 }
485 }else
486 {
487 feedback2 = 0;
488 CH[6].op1_out[1] = CH[6].op1_out[0];
489 CH[6].op1_out[0] = 0;
490 }
491 /* SLOT 2 */
492 SLOT = &CH[6].SLOT[SLOT2];
493 env_out=OPL_CALC_SLOT(SLOT);
494 if( env_out < EG_ENT-1 )
495 {
496 /* PG */
497 if(SLOT->vib) SLOT->Cnt += (SLOT->Incr*vib/VIB_RATE);
498 else SLOT->Cnt += SLOT->Incr;
499 /* connectoion */
500 outd += OP_OUT(SLOT,env_out, feedback2)*2;
501 }
502
503 /* SD (17) = mul14[fnum7] + white noise */
504 /* TAM (15) = mul15[fnum8] */
505 /* TOP (18) = fnum6(mul18[fnum8]+whitenoise) */
506 /* HH (14) = fnum7(mul18[fnum8]+whitenoise) + white noise */
507 env_sd =OPL_CALC_SLOT(SLOT7_2) + whitenoise;
508 env_tam=OPL_CALC_SLOT(SLOT8_1);
509 env_top=OPL_CALC_SLOT(SLOT8_2);
510 env_hh =OPL_CALC_SLOT(SLOT7_1) + whitenoise;
511
512 /* PG */
513 if(SLOT7_1->vib) SLOT7_1->Cnt += (2*SLOT7_1->Incr*vib/VIB_RATE);
514 else SLOT7_1->Cnt += 2*SLOT7_1->Incr;
515 if(SLOT7_2->vib) SLOT7_2->Cnt += ((CH[7].fc*8)*vib/VIB_RATE);
516 else SLOT7_2->Cnt += (CH[7].fc*8);
517 if(SLOT8_1->vib) SLOT8_1->Cnt += (SLOT8_1->Incr*vib/VIB_RATE);
518 else SLOT8_1->Cnt += SLOT8_1->Incr;
519 if(SLOT8_2->vib) SLOT8_2->Cnt += ((CH[8].fc*48)*vib/VIB_RATE);
520 else SLOT8_2->Cnt += (CH[8].fc*48);
521
522 tone8 = OP_OUT(SLOT8_2,whitenoise,0 );
523
524 /* SD */
525 if( env_sd < EG_ENT-1 )
526 outd += OP_OUT(SLOT7_1,env_sd, 0)*8;
527 /* TAM */
528 if( env_tam < EG_ENT-1 )
529 outd += OP_OUT(SLOT8_1,env_tam, 0)*2;
530 /* TOP-CY */
531 if( env_top < EG_ENT-1 )
532 outd += OP_OUT(SLOT7_2,env_top,tone8)*2;
533 /* HH */
534 if( env_hh < EG_ENT-1 )
535 outd += OP_OUT(SLOT7_2,env_hh,tone8)*2;
536 }
537
538 /* ----------- initialize time tabls ----------- */
init_timetables(FM_OPL * OPL,int ARRATE,int DRRATE)539 static void init_timetables( FM_OPL *OPL , int ARRATE , int DRRATE )
540 {
541 int i;
542 DoubleT rate;
543
544 /* make attack rate & decay rate tables */
545 for (i = 0;i < 4;i++) OPL->AR_TABLE[i] = OPL->DR_TABLE[i] = 0;
546 for (i = 4;i <= 60;i++){
547 rate = OPL->freqbase; /* frequency rate */
548 if( i < 60 ) rate *= 1.0+(i&3)*0.25; /* b0-1 : x1 , x1.25 , x1.5 , x1.75 */
549 rate *= 1<<((i>>2)-1); /* b2-5 : shift bit */
550 rate *= (DoubleT)(EG_ENT<<ENV_BITS);
551 OPL->AR_TABLE[i] = (INT32)(rate / ARRATE);
552 OPL->DR_TABLE[i] = (INT32)(rate / DRRATE);
553 }
554 for (i = 60;i < 76;i++)
555 {
556 OPL->AR_TABLE[i] = EG_AED-1;
557 OPL->DR_TABLE[i] = OPL->DR_TABLE[60];
558 }
559 }
560
561 /* ---------- generic table initialize ---------- */
OPLOpenTable(void)562 static int OPLOpenTable( void )
563 {
564 int s,t;
565 DoubleT rate;
566 int i,j;
567 DoubleT pom;
568
569 /* allocate dynamic tables */
570 if( (TL_TABLE = malloc(TL_MAX*2*sizeof(INT32))) == NULL)
571 return 0;
572 if( (SIN_TABLE = malloc(SIN_ENT*4 *sizeof(INT32 *))) == NULL)
573 {
574 free(TL_TABLE);
575 return 0;
576 }
577 if( (AMS_TABLE = malloc(AMS_ENT*2 *sizeof(INT32))) == NULL)
578 {
579 free(TL_TABLE);
580 free(SIN_TABLE);
581 return 0;
582 }
583 if( (VIB_TABLE = malloc(VIB_ENT*2 *sizeof(INT32))) == NULL)
584 {
585 free(TL_TABLE);
586 free(SIN_TABLE);
587 free(AMS_TABLE);
588 return 0;
589 }
590 /* make total level table */
591 for (t = 0;t < EG_ENT-1 ;t++){
592 rate = ((1<<TL_BITS)-1)/pow(10,EG_STEP*t/20); /* dB -> voltage */
593 TL_TABLE[ t] = (int)rate;
594 TL_TABLE[TL_MAX+t] = -TL_TABLE[t];
595 }
596 /* fill volume off area */
597 for ( t = EG_ENT-1; t < TL_MAX ;t++){
598 TL_TABLE[t] = TL_TABLE[TL_MAX+t] = 0;
599 }
600
601 /* make sinwave table (total level offet) */
602 /* degree 0 = degree 180 = off */
603 SIN_TABLE[0] = SIN_TABLE[SIN_ENT/2] = &TL_TABLE[EG_ENT-1];
604 for (s = 1;s <= SIN_ENT/4;s++){
605 pom = sin(2*PI*s/SIN_ENT); /* sin */
606 pom = 20*log10(1/pom); /* decibel */
607 j = (int)(pom / EG_STEP); /* TL_TABLE steps */
608
609 /* degree 0 - 90 , degree 180 - 90 : plus section */
610 SIN_TABLE[ s] = SIN_TABLE[SIN_ENT/2-s] = &TL_TABLE[j];
611 /* degree 180 - 270 , degree 360 - 270 : minus section */
612 SIN_TABLE[SIN_ENT/2+s] = SIN_TABLE[SIN_ENT -s] = &TL_TABLE[TL_MAX+j];
613 }
614 for (s = 0;s < SIN_ENT;s++)
615 {
616 SIN_TABLE[SIN_ENT*1+s] = s<(SIN_ENT/2) ? SIN_TABLE[s] : &TL_TABLE[EG_ENT];
617 SIN_TABLE[SIN_ENT*2+s] = SIN_TABLE[s % (SIN_ENT/2)];
618 SIN_TABLE[SIN_ENT*3+s] = (s/(SIN_ENT/4))&1 ? &TL_TABLE[EG_ENT] : SIN_TABLE[SIN_ENT*2+s];
619 }
620
621 /* envelope counter -> envelope output table */
622 for (i=0; i<EG_ENT; i++)
623 {
624 /* ATTACK curve */
625 pom = pow( ((DoubleT)(EG_ENT-1-i)/EG_ENT) , 8 ) * EG_ENT;
626 /* if( pom >= EG_ENT ) pom = EG_ENT-1; */
627 ENV_CURVE[i] = (int)pom;
628 /* DECAY ,RELEASE curve */
629 ENV_CURVE[(EG_DST>>ENV_BITS)+i]= i;
630 }
631 /* off */
632 ENV_CURVE[EG_OFF>>ENV_BITS]= EG_ENT-1;
633 /* make LFO ams table */
634 for (i=0; i<AMS_ENT; i++)
635 {
636 pom = (1.0+sin(2*PI*i/AMS_ENT))/2; /* sin */
637 AMS_TABLE[i] = (INT32)((1.0/EG_STEP)*pom); /* 1dB */
638 AMS_TABLE[AMS_ENT+i] = (INT32)((4.8/EG_STEP)*pom); /* 4.8dB */
639 }
640 /* make LFO vibrate table */
641 for (i=0; i<VIB_ENT; i++)
642 {
643 /* 100cent = 1seminote = 6% ?? */
644 pom = (DoubleT)VIB_RATE*0.06*sin(2*PI*i/VIB_ENT); /* +-100sect step */
645 VIB_TABLE[i] = (INT32)(VIB_RATE + (pom*0.07)); /* +- 7cent */
646 VIB_TABLE[VIB_ENT+i] = (INT32)(VIB_RATE + (pom*0.14)); /* +-14cent */
647 }
648 return 1;
649 }
650
651
OPLCloseTable(void)652 static void OPLCloseTable( void )
653 {
654 free(TL_TABLE);
655 free(SIN_TABLE);
656 free(AMS_TABLE);
657 free(VIB_TABLE);
658 }
659
660 /* CSM Key Controll */
CSMKeyControll(OPL_CH * CH)661 void CSMKeyControll(OPL_CH *CH)
662 {
663 OPL_SLOT *slot1 = &CH->SLOT[SLOT1];
664 OPL_SLOT *slot2 = &CH->SLOT[SLOT2];
665 /* all key off */
666 OPL_KEYOFF(slot1);
667 OPL_KEYOFF(slot2);
668 /* total level latch */
669 slot1->TLL = slot1->TL + (CH->ksl_base>>slot1->ksl);
670 slot1->TLL = slot1->TL + (CH->ksl_base>>slot1->ksl);
671 /* key on */
672 CH->op1_out[0] = CH->op1_out[1] = 0;
673 OPL_KEYON(slot1);
674 OPL_KEYON(slot2);
675 }
676
677 /* ---------- opl initialize ---------- */
OPL_initalize(FM_OPL * OPL)678 static void OPL_initalize(FM_OPL *OPL)
679 {
680 int fn;
681
682 #if 0
683 /* frequency base */
684 OPL->freqbase = (OPL->rate) ? ((DoubleT)OPL->clock / OPL->rate) / 72 : 0;
685 /* Timer base time */
686 OPL->TimerBase = 1.0/((DoubleT)OPL->clock / 72.0 );
687 #else
688 if (OPL->baseRate == OPL->clock / 72) {
689 OPL->freqbase = OPL->baseRate / OPL->rate;
690 OPL->TimerBase = 1.0 / OPL->baseRate;
691 }
692 else {
693 OPL->freqbase = (OPL->rate) ? ((DoubleT)OPL->clock / OPL->rate) / 72 : 0;
694 OPL->TimerBase = 1.0/((DoubleT)OPL->clock / 72.0 );
695 }
696 #endif
697 /* make time tables */
698 init_timetables( OPL , OPL_ARRATE , OPL_DRRATE );
699 /* make fnumber -> increment counter table */
700 for( fn=0 ; fn < 1024 ; fn++ )
701 {
702 OPL->FN_TABLE[fn] = (UINT32)(OPL->freqbase * fn * FREQ_RATE * (1<<7) / 2);
703 }
704 /* LFO freq.table */
705 OPL->amsIncr = (INT32)(OPL->rate ? (DoubleT)AMS_ENT*(1<<AMS_SHIFT) / OPL->rate * 3.7 * ((DoubleT)OPL->clock/3600000) : 0);
706 OPL->vibIncr = (INT32)(OPL->rate ? (DoubleT)VIB_ENT*(1<<VIB_SHIFT) / OPL->rate * 6.4 * ((DoubleT)OPL->clock/3600000) : 0);
707 }
708
709 /* ---------- write a OPL registers ---------- */
OPLWriteReg(FM_OPL * OPL,int r,int v)710 void OPLWriteReg(FM_OPL *OPL, int r, int v)
711 {
712 OPL_CH *CH;
713 int slot;
714 int block_fnum;
715
716 OPL->regs[r&0xff] = v;
717
718 switch(r&0xe0)
719 {
720 case 0x00: /* 00-1f:controll */
721 switch(r&0x1f)
722 {
723 case 0x01:
724 /* wave selector enable */
725 if(OPL->type&OPL_TYPE_WAVESEL)
726 {
727 OPL->wavesel = v&0x20;
728 if(!OPL->wavesel)
729 {
730 /* preset compatible mode */
731 int c;
732 for(c=0;c<OPL->max_ch;c++)
733 {
734 OPL->P_CH[c].SLOT[SLOT1].wavetableidx = 0;
735 OPL->P_CH[c].SLOT[SLOT2].wavetableidx = 0;
736 }
737 }
738 }
739 return;
740 case 0x02: /* Timer 1 */
741 y8950TimerSet(OPL->ref, 0, 1 * (256 - v));
742 break;
743 case 0x03: /* Timer 2 */
744 y8950TimerSet(OPL->ref, 1, 4 * (256 - v));
745 return;
746 case 0x04: /* IRQ clear / mask and Timer enable */
747 if(v&0x80)
748 { /* IRQ flag clear */
749 OPL_STATUS_RESET(OPL,0x7f);
750 }
751 else
752 { /* set IRQ mask ,timer enable*/
753 /* IRQRST,T1MSK,t2MSK,EOSMSK,BRMSK,x,ST2,ST1 */
754 OPL_STATUS_RESET(OPL,v&0x78);
755 OPL_STATUSMASK_SET(OPL,((~v)&0x78)|0x01);
756
757 y8950TimerStart(OPL->ref, 0, v & 1);
758 y8950TimerStart(OPL->ref, 1, v & 2);
759 }
760 return;
761 case 0x06: /* Key Board OUT */
762 if(OPL->type&OPL_TYPE_KEYBOARD)
763 {
764 OPL->reg6 = v;
765 }
766 return;
767 case 0x07: /* DELTA-T controll : START,REC,MEMDATA,REPT,SPOFF,x,x,RST */
768 if(OPL->type&OPL_TYPE_ADPCM)
769 YM_DELTAT_ADPCM_Write(OPL->deltat,r-0x07,v);
770 return;
771 case 0x08: /* MODE,DELTA-T : CSM,NOTESEL,x,x,smpl,da/ad,64k,rom */
772 OPL->mode = v;
773 v&=0x1f; /* for DELTA-T unit */
774 case 0x09: /* START ADD */
775 case 0x0a:
776 case 0x0b: /* STOP ADD */
777 case 0x0c:
778 case 0x0d: /* PRESCALE */
779 case 0x0e:
780 case 0x0f: /* ADPCM data */
781 case 0x10: /* DELTA-N */
782 case 0x11: /* DELTA-N */
783 case 0x12: /* EG-CTRL */
784 if(OPL->type&OPL_TYPE_ADPCM)
785 YM_DELTAT_ADPCM_Write(OPL->deltat,r-0x07,v);
786 return;
787 case 0x15: /* DAC data */
788 OPL->reg15 = v;
789 if (OPL->mode & 0x04) {
790 static int damp[] = { 256, 279, 304, 332, 362, 395, 431, 470 };
791 int sample = (short)(256 * OPL->reg15 + OPL->reg16) * 128 / damp[OPL->reg17];
792 OPL->dacSampleVolume = sample;
793 OPL->dacEnabled = 1;
794 }
795 case 0x16:
796 OPL->reg16 = v & 0xc0;
797 return;
798 case 0x17:
799 OPL->reg17 = v & 0x07;
800 return;
801 case 0x18: /* I/O CTRL (Direction) */
802 if(OPL->type&OPL_TYPE_IO)
803 OPL->portDirection = v&0x0f;
804 return;
805 case 0x19: /* I/O DATA */
806 if(OPL->type&OPL_TYPE_IO)
807 {
808 OPL->portLatch = v;
809 }
810 return;
811 case 0x1a: /* PCM data */
812 return;
813 }
814 break;
815 case 0x20: /* am,vib,ksr,eg type,mul */
816 slot = slot_array[r&0x1f];
817 if(slot == -1) return;
818 set_mul(OPL,slot,v);
819 return;
820 case 0x40:
821 slot = slot_array[r&0x1f];
822 if(slot == -1) return;
823 set_ksl_tl(OPL,slot,v);
824 return;
825 case 0x60:
826 slot = slot_array[r&0x1f];
827 if(slot == -1) return;
828 set_ar_dr(OPL,slot,v);
829 return;
830 case 0x80:
831 slot = slot_array[r&0x1f];
832 if(slot == -1) return;
833 set_sl_rr(OPL,slot,v);
834 return;
835 case 0xa0:
836 switch(r)
837 {
838 case 0xbd:
839 /* amsep,vibdep,r,bd,sd,tom,tc,hh */
840 {
841 UINT8 rkey = OPL->rythm^v;
842 OPL->ams_table_idx = v&0x80 ? AMS_ENT : 0;
843 OPL->vib_table_idx = v&0x40 ? VIB_ENT : 0;
844 OPL->rythm = v&0x3f;
845 if(OPL->rythm&0x20)
846 {
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(OPL,CH,&CH->SLOT[SLOT1]);
927 CALC_FCSLOT(OPL,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 }
939 return;
940 case 0xe0: /* wave type */
941 slot = slot_array[r&0x1f];
942 if(slot == -1) return;
943 CH = &OPL->P_CH[slot/2];
944 if(OPL->wavesel)
945 {
946 /* LOG(LOG_INF,("OPL SLOT %d wave select %d\n",slot,v&3)); */
947 CH->SLOT[slot&1].wavetableidx = (v&0x03)*SIN_ENT;
948 }
949 return;
950 }
951 }
952
953 /* lock/unlock for common table */
OPL_LockTable(void)954 static int OPL_LockTable(void)
955 {
956 num_lock++;
957 if(num_lock>1) return 0;
958 /* first time */
959 cur_chip = NULL;
960 /* allocate total level table (128kb space) */
961 if( !OPLOpenTable() )
962 {
963 num_lock--;
964 return -1;
965 }
966 return 0;
967 }
968
OPL_UnLockTable(void)969 static void OPL_UnLockTable(void)
970 {
971 if(num_lock) num_lock--;
972 if(num_lock) return;
973 /* last time */
974 cur_chip = NULL;
975 OPLCloseTable();
976 }
977
978
Y8950UpdateOne(FM_OPL * OPL)979 int Y8950UpdateOne(FM_OPL *OPL)
980 {
981 int data;
982 int count;
983 UINT32 amsCnt = OPL->amsCnt;
984 UINT32 vibCnt = OPL->vibCnt;
985 UINT8 rythm = OPL->rythm&0x20;
986 OPL_CH *CH,*R_CH;
987 YM_DELTAT *DELTAT = OPL->deltat;
988
989 /* setup DELTA-T unit */
990 YM_DELTAT_DECODE_PRESET(DELTAT);
991
992 if( (void *)OPL != cur_chip ){
993 cur_chip = (void *)OPL;
994 /* channel pointers */
995 S_CH = OPL->P_CH;
996 E_CH = &S_CH[9];
997 /* rythm slot */
998 SLOT7_1 = &S_CH[7].SLOT[SLOT1];
999 SLOT7_2 = &S_CH[7].SLOT[SLOT2];
1000 SLOT8_1 = &S_CH[8].SLOT[SLOT1];
1001 SLOT8_2 = &S_CH[8].SLOT[SLOT2];
1002 /* LFO state */
1003 amsIncr = OPL->amsIncr;
1004 vibIncr = OPL->vibIncr;
1005 ams_table = &AMS_TABLE[OPL->ams_table_idx];
1006 vib_table = &VIB_TABLE[OPL->vib_table_idx];
1007 }
1008
1009 R_CH = rythm ? &S_CH[6] : E_CH;
1010 /* channel A channel B channel C */
1011 /* LFO */
1012 ams = ams_table[(amsCnt+=amsIncr)>>AMS_SHIFT];
1013 vib = vib_table[(vibCnt+=vibIncr)>>VIB_SHIFT];
1014 /* FM part */
1015 outd = 0;
1016 count = OPL->rate / OPL->baseRate;
1017 while (count--) {
1018 for(CH=S_CH ; CH < R_CH ; CH++)
1019 OPL_CALC_CH(CH);
1020 /* Rythn part */
1021 if(rythm)
1022 OPL_CALC_RH(S_CH);
1023 }
1024 outd /= OPL->rate / OPL->baseRate;
1025
1026 OPL->dacCtrlVolume = OPL->dacSampleVolume - OPL->dacOldSampleVolume + 0x3fe7 * OPL->dacCtrlVolume / 0x4000;
1027 OPL->dacOldSampleVolume = OPL->dacSampleVolume;
1028 OPL->dacDaVolume += 2 * (OPL->dacCtrlVolume - OPL->dacDaVolume) / 3;
1029 OPL->dacEnabled = OPL->dacDaVolume;
1030 outd += OPL->dacDaVolume << 14;
1031
1032 /* deltaT ADPCM */
1033 if( DELTAT->flag )
1034 YM_DELTAT_ADPCM_CALC(DELTAT);
1035 /* limit check */
1036 data = outd;//Limit( outd , OPL_MAXOUT, OPL_MINOUT );
1037 OPL->amsCnt = amsCnt;
1038 OPL->vibCnt = vibCnt;
1039 /* deltaT START flag */
1040 if( !DELTAT->flag )
1041 OPL->status &= 0xfe;
1042 /* return result */
1043 return (data / (1 << (OPL_OUTSB - 3))) * 9 / 10;
1044 }
1045
1046 /* ---------- reset one of chip ---------- */
OPLResetChip(FM_OPL * OPL)1047 void OPLResetChip(FM_OPL *OPL)
1048 {
1049 int c,s;
1050 int i;
1051
1052 /* reset chip */
1053 OPL->mode = 0; /* normal mode */
1054 OPL_STATUS_RESET(OPL,0x7f);
1055 /* reset with register write */
1056 memset(OPL->regs, 0, sizeof(OPL->regs));
1057 OPLWriteReg(OPL,0x01,0); /* wabesel disable */
1058 OPLWriteReg(OPL,0x02,0); /* Timer1 */
1059 OPLWriteReg(OPL,0x03,0); /* Timer2 */
1060 OPLWriteReg(OPL,0x04,0); /* IRQ mask clear */
1061 for(i = 0xff ; i >= 0x20 ; i-- ) OPLWriteReg(OPL,i,0);
1062 /* reset OPerator paramater */
1063 for( c = 0 ; c < OPL->max_ch ; c++ )
1064 {
1065 OPL_CH *CH = &OPL->P_CH[c];
1066 /* OPL->P_CH[c].PAN = OPN_CENTER; */
1067 for(s = 0 ; s < 2 ; s++ )
1068 {
1069 /* wave table */
1070 CH->SLOT[s].wavetableidx = 0;
1071 /* CH->SLOT[s].evm = ENV_MOD_RR; */
1072 CH->SLOT[s].evc = EG_OFF;
1073 CH->SLOT[s].eve = EG_OFF+1;
1074 CH->SLOT[s].evs = 0;
1075 }
1076 }
1077 OPL->statusmask = 0;
1078 if(OPL->type&OPL_TYPE_ADPCM)
1079 {
1080 YM_DELTAT *DELTAT = OPL->deltat;
1081
1082 DELTAT->freqbase = OPL->freqbase;
1083 DELTAT->output_pointer = &outd;
1084 #ifdef MSX_AUDIO
1085 DELTAT->portshift = 2;
1086 #else
1087 DELTAT->portshift = 5;
1088 #endif
1089 DELTAT->output_range = DELTAT_MIXING_LEVEL<<TL_BITS;
1090 YM_DELTAT_ADPCM_Reset(DELTAT,0);
1091 }
1092
1093 OPL->dacSampleVolume = 0;
1094 OPL->dacOldSampleVolume = 0;
1095 OPL->dacSampleVolumeSum = 0;
1096 OPL->dacCtrlVolume = 0;
1097 OPL->dacDaVolume = 0;
1098 OPL->dacEnabled = 0;
1099
1100 OPL->reg6 = 0;
1101 OPL->reg15 = 0;
1102 OPL->reg16 = 0;
1103 OPL->reg17 = 0;
1104 }
1105
1106
OPLSetOversampling(FM_OPL * OPL,int oversampling)1107 void OPLSetOversampling(FM_OPL *OPL, int oversampling)
1108 {
1109 OPL->rate = OPL->baseRate * oversampling;
1110 OPL_initalize(OPL);
1111 }
1112
1113
1114 /* ---------- Create one of vietual YM3812 ---------- */
1115 /* 'rate' is sampling rate and 'bufsiz' is the size of the */
OPLCreate(int type,int clock,int rate,int sampleram,void * ref)1116 FM_OPL *OPLCreate(int type, int clock, int rate, int sampleram, void* ref)
1117 {
1118 char *ptr;
1119 FM_OPL *OPL;
1120 int state_size;
1121 int max_ch = 9; /* normaly 9 channels */
1122
1123 if( OPL_LockTable() ==-1) return NULL;
1124 /* allocate OPL state space */
1125 state_size = sizeof(FM_OPL);
1126 state_size += sizeof(OPL_CH)*max_ch;
1127 if(type&OPL_TYPE_ADPCM) state_size+= sizeof(YM_DELTAT);
1128 /* allocate memory block */
1129 ptr = malloc(state_size);
1130 if(ptr==NULL) return NULL;
1131 /* clear */
1132 memset(ptr,0,state_size);
1133 OPL = (FM_OPL *)ptr; ptr+=sizeof(FM_OPL);
1134 OPL->P_CH = (OPL_CH *)ptr; ptr+=sizeof(OPL_CH)*max_ch;
1135 if(type&OPL_TYPE_ADPCM) {
1136 OPL->deltat = (YM_DELTAT *)ptr;
1137 OPL->deltat->memory = malloc(sampleram*1024*sizeof(UINT8)); /* size of sample bank */
1138 memset(OPL->deltat->memory, 0xff, 1024 * sampleram);
1139 OPL->deltat->memory_size = sampleram*1024;
1140 }
1141 ptr+=sizeof(YM_DELTAT);
1142
1143 YM_DELTAT_DECODE_PRESET(OPL->deltat);
1144
1145 /* set channel state pointer */
1146
1147 OPL->deltat->OPL = OPL;
1148
1149 OPL->ref = ref;
1150 OPL->type = type;
1151 OPL->clock = clock;
1152 OPL->rate = rate;
1153 OPL->baseRate = rate;
1154 OPL->max_ch = max_ch;
1155 /* init grobal tables */
1156 OPL_initalize(OPL);
1157 /* reset chip */
1158 OPLResetChip(OPL);
1159 return OPL;
1160 }
1161
1162 /* ---------- Destroy one of vietual YM3812 ---------- */
OPLDestroy(FM_OPL * OPL)1163 void OPLDestroy(FM_OPL *OPL)
1164 {
1165 OPL_UnLockTable();
1166 free(OPL->deltat->memory);
1167 free(OPL);
1168 }
1169
1170 /* ---------- YM3812 I/O interface ---------- */
OPLWrite(FM_OPL * OPL,int a,int v)1171 int OPLWrite(FM_OPL *OPL,int a,int v)
1172 {
1173 if( !(a&1) )
1174 { /* address port */
1175 OPL->address = v & 0xff;
1176 }
1177 else
1178 { /* data port */
1179 OPLWriteReg(OPL,OPL->address,v);
1180 }
1181 return OPL->status>>7;
1182 }
1183
OPLRead(FM_OPL * OPL,int a)1184 unsigned char OPLRead(FM_OPL *OPL,int a)
1185 {
1186 if( !(a&1) )
1187 {
1188 /* buffer ready */
1189 OPL_STATUS_SET(OPL,0x08);
1190
1191 /* end of sample flag */
1192 if(OPL->deltat->eos)
1193 OPL_STATUS_SET(OPL,0x10);
1194 else OPL_STATUS_RESET(OPL,0x10);
1195
1196 return (OPL->status & (0x80 | OPL->statusmask)) | 6;
1197 }
1198
1199 /* data port */
1200 switch(OPL->address)
1201 {
1202 case 0x05: /* KeyBoard IN */
1203 if(OPL->type&OPL_TYPE_KEYBOARD)
1204 {
1205 return y8950GetNoteOn(OPL->ref, OPL->reg6);
1206 }
1207 return 0xff;
1208 case 0x14:
1209 return YM_DELTAT_ADPCM_Read2(OPL->deltat);
1210 case 0x0f: /* ADPCM-DATA */
1211 return YM_DELTAT_ADPCM_Read(OPL->deltat);
1212 case 0x13:
1213 case 0x1a:
1214 return 0;
1215 case 0x19: /* I/O DATA */
1216 if(OPL->type&OPL_TYPE_IO)
1217 {
1218 }
1219 return ~(switchGetAudio() ? 0 : 0x04);
1220 }
1221 return 0xff;
1222 }
1223
OPLPeek(FM_OPL * OPL,int a)1224 unsigned char OPLPeek(FM_OPL *OPL,int a)
1225 {
1226 if(!(a & 1)) {
1227 return (OPL->status & (0x80 | OPL->statusmask)) | 6;
1228 }
1229
1230 /* data port */
1231 switch(OPL->address) {
1232 case 0x05: /* KeyBoard IN */
1233 return 0xff;
1234 case 0x14:
1235 return YM_DELTAT_ADPCM_Peek2(OPL->deltat);
1236 case 0x0f: /* ADPCM-DATA */
1237 return YM_DELTAT_ADPCM_Peek(OPL->deltat);
1238 case 0x13:
1239 case 0x1a:
1240 return 0;
1241 case 0x19: /* I/O DATA */
1242 return ~(switchGetAudio() ? 0 : 0x04);
1243 }
1244 return 0xff;
1245 }
1246
OPLTimerOver(FM_OPL * OPL,int c)1247 int OPLTimerOver(FM_OPL *OPL,int c)
1248 {
1249 if( c )
1250 { /* Timer B */
1251 OPL_STATUS_SET(OPL,0x20);
1252 }
1253 else
1254 { /* Timer A */
1255 OPL_STATUS_SET(OPL,0x40);
1256 /* CSM mode key,TL controll */
1257 if( OPL->mode & 0x80 )
1258 { /* CSM mode total level latch and auto key on */
1259 int ch;
1260 for(ch=0;ch<9;ch++)
1261 CSMKeyControll( &OPL->P_CH[ch] );
1262 }
1263 }
1264 /* reload timer */
1265 return OPL->status>>7;
1266 }
1267
Y8950LoadState(FM_OPL * OPL)1268 void Y8950LoadState(FM_OPL *OPL)
1269 {
1270 SaveState* state = saveStateOpenForRead("fmopl");
1271 char tag[32];
1272 int i;
1273 int j;
1274
1275 OPL->type = (UInt8)saveStateGet(state, "type", 0);
1276 OPL->address = (UInt8)saveStateGet(state, "address", 0);
1277 OPL->status = (UInt8)saveStateGet(state, "status", 0);
1278 OPL->statusmask = (UInt8)saveStateGet(state, "statusmask", 0);
1279 OPL->mode = saveStateGet(state, "mode", 0);
1280 OPL->max_ch = saveStateGet(state, "max_ch", 0);
1281 OPL->rythm = (UInt8)saveStateGet(state, "rythm", 0);
1282 OPL->portDirection = (UInt8)saveStateGet(state, "portDirection", 0);
1283 OPL->portLatch = (UInt8)saveStateGet(state, "portLatch", 0);
1284 OPL->ams_table_idx = saveStateGet(state, "ams_table_idx", 0);
1285 OPL->vib_table_idx = saveStateGet(state, "vib_table_idx", 0);
1286 OPL->amsCnt = saveStateGet(state, "amsCnt", 0);
1287 OPL->amsIncr = saveStateGet(state, "amsIncr", 0);
1288 OPL->vibCnt = saveStateGet(state, "vibCnt", 0);
1289 OPL->vibIncr = saveStateGet(state, "vibIncr", 0);
1290 OPL->wavesel = (UInt8)saveStateGet(state, "wavesel", 0);
1291 OPL->dacSampleVolume = saveStateGet(state, "dacSampleVolume", 0);
1292 OPL->dacOldSampleVolume = saveStateGet(state, "dacOldSampleVolume", 0);
1293 OPL->dacSampleVolumeSum = saveStateGet(state, "dacSampleVolumeSum", 0);
1294 OPL->dacCtrlVolume = saveStateGet(state, "dacCtrlVolume", 0);
1295 OPL->dacDaVolume = saveStateGet(state, "dacDaVolume", 0);
1296 OPL->dacEnabled = saveStateGet(state, "dacEnabled", 0);
1297 OPL->reg6 = saveStateGet(state, "reg6", 0);
1298 OPL->reg15 = saveStateGet(state, "reg15", 0);
1299 OPL->reg16 = saveStateGet(state, "reg16", 0);
1300 OPL->reg17 = saveStateGet(state, "reg17", 0);
1301
1302 for (i = 0; i < sizeof(OPL->AR_TABLE) / sizeof(OPL->AR_TABLE[0]); i++) {
1303 sprintf(tag, "AR_TABLE%d", i);
1304 OPL->AR_TABLE[i] = saveStateGet(state, tag, 0);
1305
1306 sprintf(tag, "DR_TABLE%d", i);
1307 OPL->DR_TABLE[i] = saveStateGet(state, tag, 0);
1308 }
1309
1310 for (i = 0; i < sizeof(OPL->FN_TABLE) / sizeof(OPL->FN_TABLE[0]); i++) {
1311 sprintf(tag, "FN_TABLE%d", i);
1312 OPL->FN_TABLE[i] = saveStateGet(state, tag, 0);
1313 }
1314
1315 for (i = 0; i < OPL->max_ch; i++) {
1316 sprintf(tag, "CON%d", i);
1317 OPL->P_CH[i].CON = (UInt8)saveStateGet(state, tag, 0);
1318
1319 sprintf(tag, "FB%d", i);
1320 OPL->P_CH[i].FB = (UInt8)saveStateGet(state, tag, 0);
1321
1322 sprintf(tag, "op1_out%d_0", i);
1323 OPL->P_CH[i].op1_out[0] = saveStateGet(state, tag, 0);
1324
1325 sprintf(tag, "op1_out%d_1", i);
1326 OPL->P_CH[i].op1_out[1] = saveStateGet(state, tag, 0);
1327
1328 sprintf(tag, "block_fnum%d", i);
1329 OPL->P_CH[i].block_fnum = saveStateGet(state, tag, 0);
1330
1331 sprintf(tag, "kcode%d", i);
1332 OPL->P_CH[i].kcode = (UInt8)saveStateGet(state, tag, 0);
1333
1334 sprintf(tag, "fc%d", i);
1335 OPL->P_CH[i].fc = saveStateGet(state, tag, 0);
1336
1337 sprintf(tag, "ksl_base%d", i);
1338 OPL->P_CH[i].ksl_base = saveStateGet(state, tag, 0);
1339
1340 sprintf(tag, "keyon%d", i);
1341 OPL->P_CH[i].keyon = (UInt8)saveStateGet(state, tag, 0);
1342
1343 for (j = 0; j < 2; j++) {
1344 sprintf(tag, "TL%d_%d", i, j);
1345 OPL->P_CH[i].SLOT[j].TL = saveStateGet(state, tag, 0);
1346
1347 sprintf(tag, "TLL%d_%d", i, j);
1348 OPL->P_CH[i].SLOT[j].TLL = saveStateGet(state, tag, 0);
1349
1350 sprintf(tag, "KSR%d_%d", i, j);
1351 OPL->P_CH[i].SLOT[j].KSR = (UInt8)saveStateGet(state, tag, 0);
1352
1353 sprintf(tag, "AR%d_%d", i, j);
1354 OPL->P_CH[i].SLOT[j].AR = saveStateGet(state, tag, 0);
1355
1356 sprintf(tag, "DR%d_%d", i, j);
1357 OPL->P_CH[i].SLOT[j].DR = saveStateGet(state, tag, 0);
1358
1359 sprintf(tag, "SL%d_%d", i, j);
1360 OPL->P_CH[i].SLOT[j].SL = saveStateGet(state, tag, 0);
1361
1362 sprintf(tag, "RR%d_%d", i, j);
1363 OPL->P_CH[i].SLOT[j].RR = saveStateGet(state, tag, 0);
1364
1365 sprintf(tag, "ksl%d_%d", i, j);
1366 OPL->P_CH[i].SLOT[j].ksl = (UInt8)saveStateGet(state, tag, 0);
1367
1368 sprintf(tag, "ksr%d_%d", i, j);
1369 OPL->P_CH[i].SLOT[j].ksr = (UInt8)saveStateGet(state, tag, 0);
1370
1371 sprintf(tag, "mul%d_%d", i, j);
1372 OPL->P_CH[i].SLOT[j].mul = saveStateGet(state, tag, 0);
1373
1374 sprintf(tag, "Cnt%d_%d", i, j);
1375 OPL->P_CH[i].SLOT[j].Cnt = saveStateGet(state, tag, 0);
1376
1377 sprintf(tag, "Incr%d_%d", i, j);
1378 OPL->P_CH[i].SLOT[j].Incr = saveStateGet(state, tag, 0);
1379
1380 sprintf(tag, "eg_typ%d_%d", i, j);
1381 OPL->P_CH[i].SLOT[j].eg_typ = (UInt8)saveStateGet(state, tag, 0);
1382
1383 sprintf(tag, "evm%d_%d", i, j);
1384 OPL->P_CH[i].SLOT[j].evm = (UInt8)saveStateGet(state, tag, 0);
1385
1386 sprintf(tag, "evc%d_%d", i, j);
1387 OPL->P_CH[i].SLOT[j].evc = saveStateGet(state, tag, 0);
1388
1389 sprintf(tag, "eve%d_%d", i, j);
1390 OPL->P_CH[i].SLOT[j].eve = saveStateGet(state, tag, 0);
1391
1392 sprintf(tag, "evs%d_%d", i, j);
1393 OPL->P_CH[i].SLOT[j].evs = saveStateGet(state, tag, 0);
1394
1395 sprintf(tag, "evsa%d_%d", i, j);
1396 OPL->P_CH[i].SLOT[j].evsa = saveStateGet(state, tag, 0);
1397
1398 sprintf(tag, "evsd%d_%d", i, j);
1399 OPL->P_CH[i].SLOT[j].evsd = saveStateGet(state, tag, 0);
1400
1401 sprintf(tag, "evsr%d_%d", i, j);
1402 OPL->P_CH[i].SLOT[j].evsr = saveStateGet(state, tag, 0);
1403
1404 sprintf(tag, "ams%d_%d", i, j);
1405 OPL->P_CH[i].SLOT[j].ams = (UInt8)saveStateGet(state, tag, 0);
1406
1407 sprintf(tag, "vib%d_%d", i, j);
1408 OPL->P_CH[i].SLOT[j].vib = (UInt8)saveStateGet(state, tag, 0);
1409
1410 sprintf(tag, "wavetableidx%d_%d", i, j);
1411 OPL->P_CH[i].SLOT[j].wavetableidx = saveStateGet(state, tag, 0);
1412 }
1413 }
1414
1415 saveStateClose(state);
1416 }
1417
Y8950SaveState(FM_OPL * OPL)1418 void Y8950SaveState(FM_OPL *OPL)
1419 {
1420 SaveState* state = saveStateOpenForWrite("fmopl");
1421 char tag[32];
1422 int i;
1423 int j;
1424
1425 saveStateSet(state, "type", OPL->type);
1426 saveStateSet(state, "address", OPL->address);
1427 saveStateSet(state, "status", OPL->status);
1428 saveStateSet(state, "statusmask", OPL->statusmask);
1429 saveStateSet(state, "mode", OPL->mode);
1430 saveStateSet(state, "max_ch", OPL->max_ch);
1431 saveStateSet(state, "rythm", OPL->rythm);
1432 saveStateSet(state, "portDirection", OPL->portDirection);
1433 saveStateSet(state, "portLatch", OPL->portLatch);
1434 saveStateSet(state, "ams_table_idx", OPL->ams_table_idx);
1435 saveStateSet(state, "vib_table_idx", OPL->vib_table_idx);
1436 saveStateSet(state, "amsCnt", OPL->amsCnt);
1437 saveStateSet(state, "amsIncr", OPL->amsIncr);
1438 saveStateSet(state, "vibCnt", OPL->vibCnt);
1439 saveStateSet(state, "vibIncr", OPL->vibIncr);
1440 saveStateSet(state, "wavesel", OPL->wavesel);
1441 saveStateSet(state, "dacSampleVolume", OPL->dacSampleVolume);
1442 saveStateSet(state, "dacOldSampleVolume", OPL->dacOldSampleVolume);
1443 saveStateSet(state, "dacSampleVolumeSum", OPL->dacSampleVolumeSum);
1444 saveStateSet(state, "dacCtrlVolume", OPL->dacCtrlVolume);
1445 saveStateSet(state, "dacDaVolume", OPL->dacDaVolume);
1446 saveStateSet(state, "dacEnabled", OPL->dacEnabled);
1447 saveStateSet(state, "reg6", OPL->reg6);
1448 saveStateSet(state, "reg15", OPL->reg15);
1449 saveStateSet(state, "reg16", OPL->reg16);
1450 saveStateSet(state, "reg17", OPL->reg17);
1451
1452 for (i = 0; i < sizeof(OPL->AR_TABLE) / sizeof(OPL->AR_TABLE[0]); i++) {
1453 sprintf(tag, "AR_TABLE%d", i);
1454 saveStateSet(state, tag, OPL->AR_TABLE[i]);
1455
1456 sprintf(tag, "DR_TABLE%d", i);
1457 saveStateSet(state, tag, OPL->DR_TABLE[i]);
1458 }
1459
1460 for (i = 0; i < sizeof(OPL->FN_TABLE) / sizeof(OPL->FN_TABLE[0]); i++) {
1461 sprintf(tag, "FN_TABLE%d", i);
1462 saveStateSet(state, tag, OPL->FN_TABLE[i]);
1463 }
1464
1465 for (i = 0; i < OPL->max_ch; i++) {
1466 sprintf(tag, "CON%d", i);
1467 saveStateSet(state, tag, OPL->P_CH[i].CON);
1468
1469 sprintf(tag, "FB%d", i);
1470 saveStateSet(state, tag, OPL->P_CH[i].FB);
1471
1472 sprintf(tag, "op1_out%d_0", i);
1473 saveStateSet(state, tag, OPL->P_CH[i].op1_out[0]);
1474
1475 sprintf(tag, "op1_out%d_1", i);
1476 saveStateSet(state, tag, OPL->P_CH[i].op1_out[1]);
1477
1478 sprintf(tag, "block_fnum%d", i);
1479 saveStateSet(state, tag, OPL->P_CH[i].block_fnum);
1480
1481 sprintf(tag, "kcode%d", i);
1482 saveStateSet(state, tag, OPL->P_CH[i].kcode);
1483
1484 sprintf(tag, "fc%d", i);
1485 saveStateSet(state, tag, OPL->P_CH[i].fc);
1486
1487 sprintf(tag, "ksl_base%d", i);
1488 saveStateSet(state, tag, OPL->P_CH[i].ksl_base);
1489
1490 sprintf(tag, "keyon%d", i);
1491 saveStateSet(state, tag, OPL->P_CH[i].keyon);
1492
1493 for (j = 0; j < 2; j++) {
1494 sprintf(tag, "TL%d_%d", i, j);
1495 saveStateSet(state, tag, OPL->P_CH[i].SLOT[j].TL);
1496
1497 sprintf(tag, "TLL%d_%d", i, j);
1498 saveStateSet(state, tag, OPL->P_CH[i].SLOT[j].TLL);
1499
1500 sprintf(tag, "KSR%d_%d", i, j);
1501 saveStateSet(state, tag, OPL->P_CH[i].SLOT[j].KSR);
1502
1503 sprintf(tag, "AR%d_%d", i, j);
1504 saveStateSet(state, tag, OPL->P_CH[i].SLOT[j].AR);
1505
1506 sprintf(tag, "DR%d_%d", i, j);
1507 saveStateSet(state, tag, OPL->P_CH[i].SLOT[j].DR);
1508
1509 sprintf(tag, "SL%d_%d", i, j);
1510 saveStateSet(state, tag, OPL->P_CH[i].SLOT[j].SL);
1511
1512 sprintf(tag, "RR%d_%d", i, j);
1513 saveStateSet(state, tag, OPL->P_CH[i].SLOT[j].RR);
1514
1515 sprintf(tag, "ksl%d_%d", i, j);
1516 saveStateSet(state, tag, OPL->P_CH[i].SLOT[j].ksl);
1517
1518 sprintf(tag, "ksr%d_%d", i, j);
1519 saveStateSet(state, tag, OPL->P_CH[i].SLOT[j].ksr);
1520
1521 sprintf(tag, "mul%d_%d", i, j);
1522 saveStateSet(state, tag, OPL->P_CH[i].SLOT[j].mul);
1523
1524 sprintf(tag, "Cnt%d_%d", i, j);
1525 saveStateSet(state, tag, OPL->P_CH[i].SLOT[j].Cnt);
1526
1527 sprintf(tag, "Incr%d_%d", i, j);
1528 saveStateSet(state, tag, OPL->P_CH[i].SLOT[j].Incr);
1529
1530 sprintf(tag, "eg_typ%d_%d", i, j);
1531 saveStateSet(state, tag, OPL->P_CH[i].SLOT[j].eg_typ);
1532
1533 sprintf(tag, "evm%d_%d", i, j);
1534 saveStateSet(state, tag, OPL->P_CH[i].SLOT[j].evm);
1535
1536 sprintf(tag, "evc%d_%d", i, j);
1537 saveStateSet(state, tag, OPL->P_CH[i].SLOT[j].evc);
1538
1539 sprintf(tag, "eve%d_%d", i, j);
1540 saveStateSet(state, tag, OPL->P_CH[i].SLOT[j].eve);
1541
1542 sprintf(tag, "evs%d_%d", i, j);
1543 saveStateSet(state, tag, OPL->P_CH[i].SLOT[j].evs);
1544
1545 sprintf(tag, "evsa%d_%d", i, j);
1546 saveStateSet(state, tag, OPL->P_CH[i].SLOT[j].evsa);
1547
1548 sprintf(tag, "evsd%d_%d", i, j);
1549 saveStateSet(state, tag, OPL->P_CH[i].SLOT[j].evsd);
1550
1551 sprintf(tag, "evsr%d_%d", i, j);
1552 saveStateSet(state, tag, OPL->P_CH[i].SLOT[j].evsr);
1553
1554 sprintf(tag, "ams%d_%d", i, j);
1555 saveStateSet(state, tag, OPL->P_CH[i].SLOT[j].ams);
1556
1557 sprintf(tag, "vib%d_%d", i, j);
1558 saveStateSet(state, tag, OPL->P_CH[i].SLOT[j].vib);
1559
1560 sprintf(tag, "wavetableidx%d_%d", i, j);
1561 saveStateSet(state, tag, OPL->P_CH[i].SLOT[j].wavetableidx);
1562 }
1563 }
1564
1565 saveStateClose(state);
1566 }
1567
1568