1 /*
2 * Copyright (C) 2002-2010 The DOSBox Team
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17 */
18
19 //
20 // Chocolate Doom-related discussion:
21 //
22 // This is the DosBox OPL emulator code (src/hardware/dbopl.cpp) r3635,
23 // converted to C. The bulk of the work was done using the minus-minus
24 // script in the Chocolate Doom SVN repository, then the result tweaked
25 // by hand until working.
26 //
27
28
29 /*
30 DOSBox implementation of a combined Yamaha YMF262 and Yamaha YM3812 emulator.
31 Enabling the opl3 bit will switch the emulator to stereo opl3 output instead of regular mono opl2
32 Except for the table generation it's all integer math
33 Can choose different types of generators, using muls and bigger tables, try different ones for slower platforms
34 The generation was based on the MAME implementation but tried to have it use less memory and be faster in general
35 MAME uses much bigger envelope tables and this will be the biggest cause of it sounding different at times
36
37 //TODO Don't delay first operator 1 sample in opl3 mode
38 //TODO Maybe not use class method pointers but a regular function pointers with operator as first parameter
39 //TODO Fix panning for the Percussion channels, would any opl3 player use it and actually really change it though?
40 //TODO Check if having the same accuracy in all frequency multipliers sounds better or not
41
42 //DUNNO Keyon in 4op, switch to 2op without keyoff.
43 */
44
45 /* $Id: dbopl.cpp,v 1.10 2009-06-10 19:54:51 harekiet Exp $ */
46
47 #include <math.h>
48 #include <stdlib.h>
49 #include <string.h>
50 //#include "dosbox.h"
51 #include "dbopl.h"
52
53 #ifdef _MSC_VER
54 #define inline __inline
55 #endif
56
57 #define GCC_UNLIKELY(x) x
58
59 #define TRUE 1
60 #define FALSE 0
61
62 #ifndef PI
63 #define PI 3.14159265358979323846
64 #endif
65
66 #define OPLRATE ((double)(14318180.0 / 288.0))
67 #define TREMOLO_TABLE 52
68
69 //Try to use most precision for frequencies
70 //Else try to keep different waves in synch
71 //#define WAVE_PRECISION 1
72 #ifndef WAVE_PRECISION
73 //Wave bits available in the top of the 32bit range
74 //Original adlib uses 10.10, we use 10.22
75 #define WAVE_BITS 10
76 #else
77 //Need some extra bits at the top to have room for octaves and frequency multiplier
78 //We support to 8 times lower rate
79 //128 * 15 * 8 = 15350, 2^13.9, so need 14 bits
80 #define WAVE_BITS 14
81 #endif
82 #define WAVE_SH ( 32 - WAVE_BITS )
83 #define WAVE_MASK ( ( 1 << WAVE_SH ) - 1 )
84
85 //Use the same accuracy as the waves
86 #define LFO_SH ( WAVE_SH - 10 )
87 //LFO is controlled by our tremolo 256 sample limit
88 #define LFO_MAX ( 256 << ( LFO_SH ) )
89
90
91 //Maximum amount of attenuation bits
92 //Envelope goes to 511, 9 bits
93 #if (DBOPL_WAVE == WAVE_TABLEMUL )
94 //Uses the value directly
95 #define ENV_BITS ( 9 )
96 #else
97 //Add 3 bits here for more accuracy and would have to be shifted up either way
98 #define ENV_BITS ( 9 )
99 #endif
100 //Limits of the envelope with those bits and when the envelope goes silent
101 #define ENV_MIN 0
102 #define ENV_EXTRA ( ENV_BITS - 9 )
103 #define ENV_MAX ( 511 << ENV_EXTRA )
104 #define ENV_LIMIT ( ( 12 * 256) >> ( 3 - ENV_EXTRA ) )
105 #define ENV_SILENT( _X_ ) ( (_X_) >= ENV_LIMIT )
106
107 //Attack/decay/release rate counter shift
108 #define RATE_SH 24
109 #define RATE_MASK ( ( 1 << RATE_SH ) - 1 )
110 //Has to fit within 16bit lookuptable
111 #define MUL_SH 16
112
113 //Check some ranges
114 #if ENV_EXTRA > 3
115 #error Too many envelope bits
116 #endif
117
118 static inline void Operator__SetState(Operator *self, Bit8u s );
119 static inline Bit32u Chip__ForwardNoise(Chip *self);
120
121 // C++'s template<> sure is useful sometimes.
122
123 static Channel* Channel__BlockTemplate(Channel *self, Chip* chip,
124 Bit32u samples, Bit32s* output,
125 SynthMode mode );
126 #define BLOCK_TEMPLATE(mode) \
127 static Channel* Channel__BlockTemplate_ ## mode(Channel *self, Chip* chip, \
128 Bit32u samples, Bit32s* output) \
129 { \
130 return Channel__BlockTemplate(self, chip, samples, output, mode); \
131 }
132
133 BLOCK_TEMPLATE(sm2AM)
134 BLOCK_TEMPLATE(sm2FM)
135 BLOCK_TEMPLATE(sm3AM)
136 BLOCK_TEMPLATE(sm3FM)
137 BLOCK_TEMPLATE(sm3FMFM)
138 BLOCK_TEMPLATE(sm3AMFM)
139 BLOCK_TEMPLATE(sm3FMAM)
140 BLOCK_TEMPLATE(sm3AMAM)
141 BLOCK_TEMPLATE(sm2Percussion)
142 BLOCK_TEMPLATE(sm3Percussion)
143
144 //How much to substract from the base value for the final attenuation
145 static const Bit8u KslCreateTable[16] = {
146 //0 will always be be lower than 7 * 8
147 64, 32, 24, 19,
148 16, 12, 11, 10,
149 8, 6, 5, 4,
150 3, 2, 1, 0,
151 };
152
153 #define M(_X_) ((Bit8u)( (_X_) * 2))
154 static const Bit8u FreqCreateTable[16] = {
155 M(0.5), M(1 ), M(2 ), M(3 ), M(4 ), M(5 ), M(6 ), M(7 ),
156 M(8 ), M(9 ), M(10), M(10), M(12), M(12), M(15), M(15)
157 };
158 #undef M
159
160 //We're not including the highest attack rate, that gets a special value
161 static const Bit8u AttackSamplesTable[13] = {
162 69, 55, 46, 40,
163 35, 29, 23, 20,
164 19, 15, 11, 10,
165 9
166 };
167 //On a real opl these values take 8 samples to reach and are based upon larger tables
168 static const Bit8u EnvelopeIncreaseTable[13] = {
169 4, 5, 6, 7,
170 8, 10, 12, 14,
171 16, 20, 24, 28,
172 32,
173 };
174
175 #if ( DBOPL_WAVE == WAVE_HANDLER ) || ( DBOPL_WAVE == WAVE_TABLELOG )
176 static Bit16u ExpTable[ 256 ];
177 #endif
178
179 #if ( DBOPL_WAVE == WAVE_HANDLER )
180 //PI table used by WAVEHANDLER
181 static Bit16u SinTable[ 512 ];
182 #endif
183
184 #if ( DBOPL_WAVE > WAVE_HANDLER )
185 //Layout of the waveform table in 512 entry intervals
186 //With overlapping waves we reduce the table to half it's size
187
188 // | |//\\|____|WAV7|//__|/\ |____|/\/\|
189 // |\\//| | |WAV7| | \/| | |
190 // |06 |0126|17 |7 |3 |4 |4 5 |5 |
191
192 //6 is just 0 shifted and masked
193
194 static Bit16s WaveTable[ 8 * 512 ];
195 //Distance into WaveTable the wave starts
196 static const Bit16u WaveBaseTable[8] = {
197 0x000, 0x200, 0x200, 0x800,
198 0xa00, 0xc00, 0x100, 0x400,
199
200 };
201 //Mask the counter with this
202 static const Bit16u WaveMaskTable[8] = {
203 1023, 1023, 511, 511,
204 1023, 1023, 512, 1023,
205 };
206
207 //Where to start the counter on at keyon
208 static const Bit16u WaveStartTable[8] = {
209 512, 0, 0, 0,
210 0, 512, 512, 256,
211 };
212 #endif
213
214 #if ( DBOPL_WAVE == WAVE_TABLEMUL )
215 static Bit16u MulTable[ 384 ];
216 #endif
217
218 static Bit8u KslTable[ 8 * 16 ];
219 static Bit8u TremoloTable[ TREMOLO_TABLE ];
220 //Start of a channel behind the chip struct start
221 static Bit16u ChanOffsetTable[32];
222 //Start of an operator behind the chip struct start
223 static Bit16u OpOffsetTable[64];
224
225 //The lower bits are the shift of the operator vibrato value
226 //The highest bit is right shifted to generate -1 or 0 for negation
227 //So taking the highest input value of 7 this gives 3, 7, 3, 0, -3, -7, -3, 0
228 static const Bit8s VibratoTable[ 8 ] = {
229 1 - 0x00, 0 - 0x00, 1 - 0x00, 30 - 0x00,
230 1 - 0x80, 0 - 0x80, 1 - 0x80, 30 - 0x80
231 };
232
233 //Shift strength for the ksl value determined by ksl strength
234 static const Bit8u KslShiftTable[4] = {
235 31,1,2,0
236 };
237
238 //Generate a table index and table shift value using input value from a selected rate
EnvelopeSelect(Bit8u val,Bit8u * index,Bit8u * shift)239 static void EnvelopeSelect( Bit8u val, Bit8u *index, Bit8u *shift ) {
240 if ( val < 13 * 4 ) { //Rate 0 - 12
241 *shift = 12 - ( val >> 2 );
242 *index = val & 3;
243 } else if ( val < 15 * 4 ) { //rate 13 - 14
244 *shift = 0;
245 *index = val - 12 * 4;
246 } else { //rate 15 and up
247 *shift = 0;
248 *index = 12;
249 }
250 }
251
252 #if ( DBOPL_WAVE == WAVE_HANDLER )
253 /*
254 Generate the different waveforms out of the sine/exponetial table using handlers
255 */
MakeVolume(Bitu wave,Bitu volume)256 static inline Bits MakeVolume( Bitu wave, Bitu volume ) {
257 Bitu total = wave + volume;
258 Bitu index = total & 0xff;
259 Bitu sig = ExpTable[ index ];
260 Bitu exp = total >> 8;
261 #if 0
262 //Check if we overflow the 31 shift limit
263 if ( exp >= 32 ) {
264 LOG_MSG( "WTF %d %d", total, exp );
265 }
266 #endif
267 return (sig >> exp);
268 };
269
WaveForm0(Bitu i,Bitu volume)270 static Bits DB_FASTCALL WaveForm0( Bitu i, Bitu volume ) {
271 Bits neg = 0 - (( i >> 9) & 1);//Create ~0 or 0
272 Bitu wave = SinTable[i & 511];
273 return (MakeVolume( wave, volume ) ^ neg) - neg;
274 }
WaveForm1(Bitu i,Bitu volume)275 static Bits DB_FASTCALL WaveForm1( Bitu i, Bitu volume ) {
276 Bit32u wave = SinTable[i & 511];
277 wave |= ( ( (i ^ 512 ) & 512) - 1) >> ( 32 - 12 );
278 return MakeVolume( wave, volume );
279 }
WaveForm2(Bitu i,Bitu volume)280 static Bits DB_FASTCALL WaveForm2( Bitu i, Bitu volume ) {
281 Bitu wave = SinTable[i & 511];
282 return MakeVolume( wave, volume );
283 }
WaveForm3(Bitu i,Bitu volume)284 static Bits DB_FASTCALL WaveForm3( Bitu i, Bitu volume ) {
285 Bitu wave = SinTable[i & 255];
286 wave |= ( ( (i ^ 256 ) & 256) - 1) >> ( 32 - 12 );
287 return MakeVolume( wave, volume );
288 }
WaveForm4(Bitu i,Bitu volume)289 static Bits DB_FASTCALL WaveForm4( Bitu i, Bitu volume ) {
290 //Twice as fast
291 i <<= 1;
292 Bits neg = 0 - (( i >> 9) & 1);//Create ~0 or 0
293 Bitu wave = SinTable[i & 511];
294 wave |= ( ( (i ^ 512 ) & 512) - 1) >> ( 32 - 12 );
295 return (MakeVolume( wave, volume ) ^ neg) - neg;
296 }
WaveForm5(Bitu i,Bitu volume)297 static Bits DB_FASTCALL WaveForm5( Bitu i, Bitu volume ) {
298 //Twice as fast
299 i <<= 1;
300 Bitu wave = SinTable[i & 511];
301 wave |= ( ( (i ^ 512 ) & 512) - 1) >> ( 32 - 12 );
302 return MakeVolume( wave, volume );
303 }
WaveForm6(Bitu i,Bitu volume)304 static Bits DB_FASTCALL WaveForm6( Bitu i, Bitu volume ) {
305 Bits neg = 0 - (( i >> 9) & 1);//Create ~0 or 0
306 return (MakeVolume( 0, volume ) ^ neg) - neg;
307 }
WaveForm7(Bitu i,Bitu volume)308 static Bits DB_FASTCALL WaveForm7( Bitu i, Bitu volume ) {
309 //Negative is reversed here
310 Bits neg = (( i >> 9) & 1) - 1;
311 Bitu wave = (i << 3);
312 //When negative the volume also runs backwards
313 wave = ((wave ^ neg) - neg) & 4095;
314 return (MakeVolume( wave, volume ) ^ neg) - neg;
315 }
316
317 static const WaveHandler WaveHandlerTable[8] = {
318 WaveForm0, WaveForm1, WaveForm2, WaveForm3,
319 WaveForm4, WaveForm5, WaveForm6, WaveForm7
320 };
321
322 #endif
323
324 /*
325 Operator
326 */
327
328 //We zero out when rate == 0
Operator__UpdateAttack(Operator * self,const Chip * chip)329 static inline void Operator__UpdateAttack(Operator *self, const Chip* chip ) {
330 Bit8u rate = self->reg60 >> 4;
331 if ( rate ) {
332 Bit8u val = (rate << 2) + self->ksr;
333 self->attackAdd = chip->attackRates[ val ];
334 self->rateZero &= ~(1 << ATTACK);
335 } else {
336 self->attackAdd = 0;
337 self->rateZero |= (1 << ATTACK);
338 }
339 }
Operator__UpdateDecay(Operator * self,const Chip * chip)340 static inline void Operator__UpdateDecay(Operator *self, const Chip* chip ) {
341 Bit8u rate = self->reg60 & 0xf;
342 if ( rate ) {
343 Bit8u val = (rate << 2) + self->ksr;
344 self->decayAdd = chip->linearRates[ val ];
345 self->rateZero &= ~(1 << DECAY);
346 } else {
347 self->decayAdd = 0;
348 self->rateZero |= (1 << DECAY);
349 }
350 }
Operator__UpdateRelease(Operator * self,const Chip * chip)351 static inline void Operator__UpdateRelease(Operator *self, const Chip* chip ) {
352 Bit8u rate = self->reg80 & 0xf;
353 if ( rate ) {
354 Bit8u val = (rate << 2) + self->ksr;
355 self->releaseAdd = chip->linearRates[ val ];
356 self->rateZero &= ~(1 << RELEASE);
357 if ( !(self->reg20 & MASK_SUSTAIN ) ) {
358 self->rateZero &= ~( 1 << SUSTAIN );
359 }
360 } else {
361 self->rateZero |= (1 << RELEASE);
362 self->releaseAdd = 0;
363 if ( !(self->reg20 & MASK_SUSTAIN ) ) {
364 self->rateZero |= ( 1 << SUSTAIN );
365 }
366 }
367 }
368
Operator__UpdateAttenuation(Operator * self)369 static inline void Operator__UpdateAttenuation(Operator *self) {
370 Bit8u kslBase = (Bit8u)((self->chanData >> SHIFT_KSLBASE) & 0xff);
371 Bit32u tl = self->reg40 & 0x3f;
372 Bit8u kslShift = KslShiftTable[ self->reg40 >> 6 ];
373 //Make sure the attenuation goes to the right bits
374 self->totalLevel = tl << ( ENV_BITS - 7 ); //Total level goes 2 bits below max
375 self->totalLevel += ( kslBase << ENV_EXTRA ) >> kslShift;
376 }
377
Operator__UpdateFrequency(Operator * self)378 static void Operator__UpdateFrequency(Operator *self) {
379 Bit32u freq = self->chanData & (( 1 << 10 ) - 1);
380 Bit32u block = (self->chanData >> 10) & 0xff;
381 #ifdef WAVE_PRECISION
382 block = 7 - block;
383 self->waveAdd = ( freq * self->freqMul ) >> block;
384 #else
385 self->waveAdd = ( freq << block ) * self->freqMul;
386 #endif
387 if ( self->reg20 & MASK_VIBRATO ) {
388 self->vibStrength = (Bit8u)(freq >> 7);
389
390 #ifdef WAVE_PRECISION
391 self->vibrato = ( self->vibStrength * self->freqMul ) >> block;
392 #else
393 self->vibrato = ( self->vibStrength << block ) * self->freqMul;
394 #endif
395 } else {
396 self->vibStrength = 0;
397 self->vibrato = 0;
398 }
399 }
400
Operator__UpdateRates(Operator * self,const Chip * chip)401 static void Operator__UpdateRates(Operator *self, const Chip* chip ) {
402 //Mame seems to reverse this where enabling ksr actually lowers
403 //the rate, but pdf manuals says otherwise?
404 Bit8u newKsr = (Bit8u)((self->chanData >> SHIFT_KEYCODE) & 0xff);
405 if ( !( self->reg20 & MASK_KSR ) ) {
406 newKsr >>= 2;
407 }
408 if ( self->ksr == newKsr )
409 return;
410 self->ksr = newKsr;
411 Operator__UpdateAttack( self, chip );
412 Operator__UpdateDecay( self, chip );
413 Operator__UpdateRelease( self, chip );
414 }
415
Operator__RateForward(Operator * self,Bit32u add)416 static inline Bit32s Operator__RateForward(Operator *self, Bit32u add ) {
417 Bit32s ret;
418 self->rateIndex += add;
419 /*Bit32s*/ ret = self->rateIndex >> RATE_SH;
420 self->rateIndex = self->rateIndex & RATE_MASK;
421 return ret;
422 }
423
Operator__TemplateVolume(Operator * self,OperatorState yes)424 static Bits Operator__TemplateVolume(Operator *self, OperatorState yes) {
425 Bit32s vol = self->volume;
426 Bit32s change;
427 switch ( yes ) {
428 case OFF:
429 return ENV_MAX;
430 case ATTACK:
431 change = Operator__RateForward( self, self->attackAdd );
432 if ( !change )
433 return vol;
434 vol += ( (~vol) * change ) >> 3;
435 if ( vol < ENV_MIN ) {
436 self->volume = ENV_MIN;
437 self->rateIndex = 0;
438 Operator__SetState( self, DECAY );
439 return ENV_MIN;
440 }
441 break;
442 case DECAY:
443 vol += Operator__RateForward( self, self->decayAdd );
444 if ( GCC_UNLIKELY(vol >= self->sustainLevel) ) {
445 //Check if we didn't overshoot max attenuation, then just go off
446 if ( GCC_UNLIKELY(vol >= ENV_MAX) ) {
447 self->volume = ENV_MAX;
448 Operator__SetState( self, OFF );
449 return ENV_MAX;
450 }
451 //Continue as sustain
452 self->rateIndex = 0;
453 Operator__SetState( self, SUSTAIN );
454 }
455 break;
456 case SUSTAIN:
457 if ( self->reg20 & MASK_SUSTAIN ) {
458 return vol;
459 }
460 //In sustain phase, but not sustaining, do regular release
461 case RELEASE:
462 vol += Operator__RateForward( self, self->releaseAdd );;
463 if ( GCC_UNLIKELY(vol >= ENV_MAX) ) {
464 self->volume = ENV_MAX;
465 Operator__SetState( self, OFF );
466 return ENV_MAX;
467 }
468 break;
469 }
470 self->volume = vol;
471 return vol;
472 }
473
474 #define TEMPLATE_VOLUME(mode) \
475 static Bits Operator__TemplateVolume ## mode(Operator *self) \
476 { \
477 return Operator__TemplateVolume(self, mode); \
478 }
479
480 TEMPLATE_VOLUME(OFF)
481 TEMPLATE_VOLUME(RELEASE)
482 TEMPLATE_VOLUME(SUSTAIN)
483 TEMPLATE_VOLUME(ATTACK)
484 TEMPLATE_VOLUME(DECAY)
485
486 static const VolumeHandler VolumeHandlerTable[5] = {
487 &Operator__TemplateVolumeOFF,
488 &Operator__TemplateVolumeRELEASE,
489 &Operator__TemplateVolumeSUSTAIN,
490 &Operator__TemplateVolumeDECAY,
491 &Operator__TemplateVolumeATTACK,
492 };
493
Operator__ForwardVolume(Operator * self)494 static inline Bitu Operator__ForwardVolume(Operator *self) {
495 return self->currentLevel + (self->volHandler)(self);
496 }
497
498
Operator__ForwardWave(Operator * self)499 static inline Bitu Operator__ForwardWave(Operator *self) {
500 self->waveIndex += self->waveCurrent;
501 return self->waveIndex >> WAVE_SH;
502 }
503
Operator__Write20(Operator * self,const Chip * chip,Bit8u val)504 static void Operator__Write20(Operator *self, const Chip* chip, Bit8u val ) {
505 Bit8u change = (self->reg20 ^ val );
506 if ( !change )
507 return;
508 self->reg20 = val;
509 //Shift the tremolo bit over the entire register, saved a branch, YES!
510 self->tremoloMask = (Bit8s)(val) >> 7;
511 self->tremoloMask &= ~(( 1 << ENV_EXTRA ) -1);
512 //Update specific features based on changes
513 if ( change & MASK_KSR ) {
514 Operator__UpdateRates( self, chip );
515 }
516 //With sustain enable the volume doesn't change
517 if ( self->reg20 & MASK_SUSTAIN || ( !self->releaseAdd ) ) {
518 self->rateZero |= ( 1 << SUSTAIN );
519 } else {
520 self->rateZero &= ~( 1 << SUSTAIN );
521 }
522 //Frequency multiplier or vibrato changed
523 if ( change & (0xf | MASK_VIBRATO) ) {
524 self->freqMul = chip->freqMul[ val & 0xf ];
525 Operator__UpdateFrequency(self);
526 }
527 }
528
Operator__Write40(Operator * self,const Chip * chip,Bit8u val)529 static void Operator__Write40(Operator *self, const Chip *chip, Bit8u val ) {
530 if (!(self->reg40 ^ val ))
531 return;
532 self->reg40 = val;
533 Operator__UpdateAttenuation( self );
534 }
535
Operator__Write60(Operator * self,const Chip * chip,Bit8u val)536 static void Operator__Write60(Operator *self, const Chip* chip, Bit8u val ) {
537 Bit8u change = self->reg60 ^ val;
538 self->reg60 = val;
539 if ( change & 0x0f ) {
540 Operator__UpdateDecay( self, chip );
541 }
542 if ( change & 0xf0 ) {
543 Operator__UpdateAttack( self, chip );
544 }
545 }
546
Operator__Write80(Operator * self,const Chip * chip,Bit8u val)547 static void Operator__Write80(Operator *self, const Chip* chip, Bit8u val ) {
548 Bit8u change = (self->reg80 ^ val );
549 Bit8u sustain;
550 if ( !change )
551 return;
552 self->reg80 = val;
553 sustain = val >> 4;
554 //Turn 0xf into 0x1f
555 sustain |= ( sustain + 1) & 0x10;
556 self->sustainLevel = sustain << ( ENV_BITS - 5 );
557 if ( change & 0x0f ) {
558 Operator__UpdateRelease( self, chip );
559 }
560 }
561
Operator__WriteE0(Operator * self,const Chip * chip,Bit8u val)562 static void Operator__WriteE0(Operator *self, const Chip* chip, Bit8u val ) {
563 Bit8u waveForm;
564 if ( !(self->regE0 ^ val) )
565 return;
566 //in opl3 mode you can always selet 7 waveforms regardless of waveformselect
567 waveForm = val & ( ( 0x3 & chip->waveFormMask ) | (0x7 & chip->opl3Active ) );
568 self->regE0 = val;
569 #if( DBOPL_WAVE == WAVE_HANDLER )
570 self->waveHandler = WaveHandlerTable[ waveForm ];
571 #else
572 self->waveBase = WaveTable + WaveBaseTable[ waveForm ];
573 self->waveStart = WaveStartTable[ waveForm ] << WAVE_SH;
574 self->waveMask = WaveMaskTable[ waveForm ];
575 #endif
576 }
577
Operator__SetState(Operator * self,Bit8u s)578 static inline void Operator__SetState(Operator *self, Bit8u s ) {
579 self->state = s;
580 self->volHandler = VolumeHandlerTable[ s ];
581 }
582
Operator__Silent(Operator * self)583 static inline int Operator__Silent(Operator *self) {
584 if ( !ENV_SILENT( self->totalLevel + self->volume ) )
585 return FALSE;
586 if ( !(self->rateZero & ( 1 << self->state ) ) )
587 return FALSE;
588 return TRUE;
589 }
590
Operator__Prepare(Operator * self,const Chip * chip)591 static inline void Operator__Prepare(Operator *self, const Chip* chip ) {
592 self->currentLevel = self->totalLevel + (chip->tremoloValue & self->tremoloMask);
593 self->waveCurrent = self->waveAdd;
594 if ( self->vibStrength >> chip->vibratoShift ) {
595 Bit32s add = self->vibrato >> chip->vibratoShift;
596 //Sign extend over the shift value
597 Bit32s neg = chip->vibratoSign;
598 //Negate the add with -1 or 0
599 add = ( add ^ neg ) - neg;
600 self->waveCurrent += add;
601 }
602 }
603
Operator__KeyOn(Operator * self,Bit8u mask)604 static void Operator__KeyOn(Operator *self, Bit8u mask ) {
605 if ( !self->keyOn ) {
606 //Restart the frequency generator
607 #if( DBOPL_WAVE > WAVE_HANDLER )
608 self->waveIndex = self->waveStart;
609 #else
610 self->waveIndex = 0;
611 #endif
612 self->rateIndex = 0;
613 Operator__SetState( self, ATTACK );
614 }
615 self->keyOn |= mask;
616 }
617
Operator__KeyOff(Operator * self,Bit8u mask)618 static void Operator__KeyOff(Operator *self, Bit8u mask ) {
619 self->keyOn &= ~mask;
620 if ( !self->keyOn ) {
621 if ( self->state != OFF ) {
622 Operator__SetState( self, RELEASE );
623 }
624 }
625 }
626
Operator__GetWave(Operator * self,Bitu index,Bitu vol)627 static inline Bits Operator__GetWave(Operator *self, Bitu index, Bitu vol ) {
628 #if( DBOPL_WAVE == WAVE_HANDLER )
629 return self->waveHandler( index, vol << ( 3 - ENV_EXTRA ) );
630 #elif( DBOPL_WAVE == WAVE_TABLEMUL )
631 return(self->waveBase[ index & self->waveMask ] * MulTable[ vol >> ENV_EXTRA ]) >> MUL_SH;
632 #elif( DBOPL_WAVE == WAVE_TABLELOG )
633 Bit32s wave = self->waveBase[ index & self->waveMask ];
634 Bit32u total = ( wave & 0x7fff ) + vol << ( 3 - ENV_EXTRA );
635 Bit32s sig = ExpTable[ total & 0xff ];
636 Bit32u exp = total >> 8;
637 Bit32s neg = wave >> 16;
638 return((sig ^ neg) - neg) >> exp;
639 #else
640 #error "No valid wave routine"
641 #endif
642 }
643
Operator__GetSample(Operator * self,Bits modulation)644 static inline Bits Operator__GetSample(Operator *self, Bits modulation ) {
645 Bitu vol = Operator__ForwardVolume(self);
646 if ( ENV_SILENT( vol ) ) {
647 //Simply forward the wave
648 self->waveIndex += self->waveCurrent;
649 return 0;
650 } else {
651 Bitu index = Operator__ForwardWave(self);
652 index += modulation;
653 return Operator__GetWave( self, index, vol );
654 }
655 }
656
Operator__Operator(Operator * self)657 static void Operator__Operator(Operator *self) {
658 self->chanData = 0;
659 self->freqMul = 0;
660 self->waveIndex = 0;
661 self->waveAdd = 0;
662 self->waveCurrent = 0;
663 self->keyOn = 0;
664 self->ksr = 0;
665 self->reg20 = 0;
666 self->reg40 = 0;
667 self->reg60 = 0;
668 self->reg80 = 0;
669 self->regE0 = 0;
670 Operator__SetState( self, OFF );
671 self->rateZero = (1 << OFF);
672 self->sustainLevel = ENV_MAX;
673 self->currentLevel = ENV_MAX;
674 self->totalLevel = ENV_MAX;
675 self->volume = ENV_MAX;
676 self->releaseAdd = 0;
677 }
678
679 /*
680 Channel
681 */
682
Channel__Channel(Channel * self)683 static void Channel__Channel(Channel *self) {
684 Operator__Operator(&self->op[0]);
685 Operator__Operator(&self->op[1]);
686 self->old[0] = self->old[1] = 0;
687 self->chanData = 0;
688 self->regB0 = 0;
689 self->regC0 = 0;
690 self->maskLeft = -1;
691 self->maskRight = -1;
692 self->feedback = 31;
693 self->fourMask = 0;
694 self->synthHandler = Channel__BlockTemplate_sm2FM;
695 };
696
Channel__Op(Channel * self,Bitu index)697 static inline Operator* Channel__Op( Channel *self, Bitu index ) {
698 return &( ( self + (index >> 1) )->op[ index & 1 ]);
699 }
700
Channel__SetChanData(Channel * self,const Chip * chip,Bit32u data)701 static void Channel__SetChanData(Channel *self, const Chip* chip, Bit32u data ) {
702 Bit32u change = self->chanData ^ data;
703 self->chanData = data;
704 Channel__Op( self, 0 )->chanData = data;
705 Channel__Op( self, 1 )->chanData = data;
706 //Since a frequency update triggered this, always update frequency
707 Operator__UpdateFrequency(Channel__Op( self, 0 ));
708 Operator__UpdateFrequency(Channel__Op( self, 1 ));
709 if ( change & ( 0xff << SHIFT_KSLBASE ) ) {
710 Operator__UpdateAttenuation(Channel__Op( self, 0 ));
711 Operator__UpdateAttenuation(Channel__Op( self, 1 ));
712 }
713 if ( change & ( 0xff << SHIFT_KEYCODE ) ) {
714 Operator__UpdateRates(Channel__Op( self, 0 ), chip);
715 Operator__UpdateRates(Channel__Op( self, 1 ), chip);
716 }
717 }
718
Channel__UpdateFrequency(Channel * self,const Chip * chip,Bit8u fourOp)719 static void Channel__UpdateFrequency(Channel *self, const Chip* chip, Bit8u fourOp ) {
720 //Extrace the frequency bits
721 Bit32u data = self->chanData & 0xffff;
722 Bit32u kslBase = KslTable[ data >> 6 ];
723 Bit32u keyCode = ( data & 0x1c00) >> 9;
724 if ( chip->reg08 & 0x40 ) {
725 keyCode |= ( data & 0x100)>>8; /* notesel == 1 */
726 } else {
727 keyCode |= ( data & 0x200)>>9; /* notesel == 0 */
728 }
729 //Add the keycode and ksl into the highest bits of chanData
730 data |= (keyCode << SHIFT_KEYCODE) | ( kslBase << SHIFT_KSLBASE );
731 Channel__SetChanData( self + 0, chip, data );
732 if ( fourOp & 0x3f ) {
733 Channel__SetChanData( self + 1, chip, data );
734 }
735 }
736
Channel__WriteA0(Channel * self,const Chip * chip,Bit8u val)737 static void Channel__WriteA0(Channel *self, const Chip* chip, Bit8u val ) {
738 Bit32u change;
739 Bit8u fourOp = chip->reg104 & chip->opl3Active & self->fourMask;
740 //Don't handle writes to silent fourop channels
741 if ( fourOp > 0x80 )
742 return;
743 change = (self->chanData ^ val ) & 0xff;
744 if ( change ) {
745 self->chanData ^= change;
746 Channel__UpdateFrequency( self, chip, fourOp );
747 }
748 }
749
Channel__WriteB0(Channel * self,const Chip * chip,Bit8u val)750 static void Channel__WriteB0(Channel *self, const Chip* chip, Bit8u val ) {
751 Bitu change;
752 Bit8u fourOp = chip->reg104 & chip->opl3Active & self->fourMask;
753 //Don't handle writes to silent fourop channels
754 if ( fourOp > 0x80 )
755 return;
756 change = (self->chanData ^ ( val << 8 ) ) & 0x1f00;
757 if ( change ) {
758 self->chanData ^= change;
759 Channel__UpdateFrequency( self, chip, fourOp );
760 }
761 //Check for a change in the keyon/off state
762 if ( !(( val ^ self->regB0) & 0x20))
763 return;
764 self->regB0 = val;
765 if ( val & 0x20 ) {
766 Operator__KeyOn( Channel__Op(self, 0), 0x1 );
767 Operator__KeyOn( Channel__Op(self, 1), 0x1 );
768 if ( fourOp & 0x3f ) {
769 Operator__KeyOn( Channel__Op(self + 1, 0), 1 );
770 Operator__KeyOn( Channel__Op(self + 1, 1), 1 );
771 }
772 } else {
773 Operator__KeyOff( Channel__Op(self, 0), 0x1 );
774 Operator__KeyOff( Channel__Op(self, 1), 0x1 );
775 if ( fourOp & 0x3f ) {
776 Operator__KeyOff( Channel__Op(self + 1, 0), 1 );
777 Operator__KeyOff( Channel__Op(self + 1, 1), 1 );
778 }
779 }
780 }
781
Channel__WriteC0(Channel * self,const Chip * chip,Bit8u val)782 static void Channel__WriteC0(Channel *self, const Chip* chip, Bit8u val ) {
783 Bit8u synth;
784 Bit8u change = val ^ self->regC0;
785 if ( !change )
786 return;
787 self->regC0 = val;
788 self->feedback = ( val >> 1 ) & 7;
789 if ( self->feedback ) {
790 //We shift the input to the right 10 bit wave index value
791 self->feedback = 9 - self->feedback;
792 } else {
793 self->feedback = 31;
794 }
795 //Select the new synth mode
796 if ( chip->opl3Active ) {
797 //4-op mode enabled for this channel
798 if ( (chip->reg104 & self->fourMask) & 0x3f ) {
799 Channel* chan0, *chan1;
800 //Check if it's the 2nd channel in a 4-op
801 if ( !(self->fourMask & 0x80 ) ) {
802 chan0 = self;
803 chan1 = self + 1;
804 } else {
805 chan0 = self - 1;
806 chan1 = self;
807 }
808
809 synth = ( (chan0->regC0 & 1) << 0 )| (( chan1->regC0 & 1) << 1 );
810 switch ( synth ) {
811 case 0:
812 chan0->synthHandler = Channel__BlockTemplate_sm3FMFM;
813 break;
814 case 1:
815 chan0->synthHandler = Channel__BlockTemplate_sm3AMFM;
816 break;
817 case 2:
818 chan0->synthHandler = Channel__BlockTemplate_sm3FMAM ;
819 break;
820 case 3:
821 chan0->synthHandler = Channel__BlockTemplate_sm3AMAM ;
822 break;
823 }
824 //Disable updating percussion channels
825 } else if ((self->fourMask & 0x40) && ( chip->regBD & 0x20) ) {
826
827 //Regular dual op, am or fm
828 } else if ( val & 1 ) {
829 self->synthHandler = Channel__BlockTemplate_sm3AM;
830 } else {
831 self->synthHandler = Channel__BlockTemplate_sm3FM;
832 }
833 self->maskLeft = ( val & 0x10 ) ? -1 : 0;
834 self->maskRight = ( val & 0x20 ) ? -1 : 0;
835 //opl2 active
836 } else {
837 //Disable updating percussion channels
838 if ( (self->fourMask & 0x40) && ( chip->regBD & 0x20 ) ) {
839
840 //Regular dual op, am or fm
841 } else if ( val & 1 ) {
842 self->synthHandler = Channel__BlockTemplate_sm2AM;
843 } else {
844 self->synthHandler = Channel__BlockTemplate_sm2FM;
845 }
846 }
847 }
848
Channel__ResetC0(Channel * self,const Chip * chip)849 static void Channel__ResetC0(Channel *self, const Chip* chip ) {
850 Bit8u val = self->regC0;
851 self->regC0 ^= 0xff;
852 Channel__WriteC0( self, chip, val );
853 };
854
Channel__GeneratePercussion(Channel * self,Chip * chip,Bit32s * output,int opl3Mode)855 static inline void Channel__GeneratePercussion(Channel *self, Chip* chip,
856 Bit32s* output, int opl3Mode ) {
857 Bit32u noiseBit, c2, c5, phaseBit, hhVol, sdVol, tcVol;
858 Bit32s sample;
859 Channel* chan = self;
860
861 //BassDrum
862 Bit32s mod = (Bit32u)((self->old[0] + self->old[1])) >> self->feedback;
863 self->old[0] = self->old[1];
864 self->old[1] = Operator__GetSample( Channel__Op(self, 0), mod );
865
866 //When bassdrum is in AM mode first operator is ignoed
867 if ( chan->regC0 & 1 ) {
868 mod = 0;
869 } else {
870 mod = self->old[0];
871 }
872 sample = Operator__GetSample( Channel__Op(self, 1), mod );
873
874 //Precalculate stuff used by other outputs
875 noiseBit = Chip__ForwardNoise(chip) & 0x1;
876 c2 = Operator__ForwardWave(Channel__Op(self, 2));
877 c5 = Operator__ForwardWave(Channel__Op(self, 5));
878 phaseBit = (((c2 & 0x88) ^ ((c2<<5) & 0x80)) | ((c5 ^ (c5<<2)) & 0x20)) ? 0x02 : 0x00;
879
880 //Hi-Hat
881 hhVol = Operator__ForwardVolume(Channel__Op(self, 2));
882 if ( !ENV_SILENT( hhVol ) ) {
883 Bit32u hhIndex = (phaseBit<<8) | (0x34 << ( phaseBit ^ (noiseBit << 1 )));
884 sample += Operator__GetWave( Channel__Op(self, 2), hhIndex, hhVol );
885 }
886 //Snare Drum
887 sdVol = Operator__ForwardVolume( Channel__Op(self, 3) );
888 if ( !ENV_SILENT( sdVol ) ) {
889 Bit32u sdIndex = ( 0x100 + (c2 & 0x100) ) ^ ( noiseBit << 8 );
890 sample += Operator__GetWave( Channel__Op(self, 3), sdIndex, sdVol );
891 }
892 //Tom-tom
893 sample += Operator__GetSample( Channel__Op(self, 4), 0 );
894
895 //Top-Cymbal
896 tcVol = Operator__ForwardVolume(Channel__Op(self, 5));
897 if ( !ENV_SILENT( tcVol ) ) {
898 Bit32u tcIndex = (1 + phaseBit) << 8;
899 sample += Operator__GetWave( Channel__Op(self, 5), tcIndex, tcVol );
900 }
901 sample <<= 1;
902 if ( opl3Mode ) {
903 output[0] += sample;
904 output[1] += sample;
905 } else {
906 output[0] += sample;
907 }
908 }
909
Channel__BlockTemplate(Channel * self,Chip * chip,Bit32u samples,Bit32s * output,SynthMode mode)910 Channel* Channel__BlockTemplate(Channel *self, Chip* chip,
911 Bit32u samples, Bit32s* output,
912 SynthMode mode ) {
913 Bitu i;
914
915 switch( mode ) {
916 case sm2AM:
917 case sm3AM:
918 if ( Operator__Silent(Channel__Op(self, 0))
919 && Operator__Silent(Channel__Op(self, 1))) {
920 self->old[0] = self->old[1] = 0;
921 return(self + 1);
922 }
923 break;
924 case sm2FM:
925 case sm3FM:
926 if ( Operator__Silent(Channel__Op(self, 1))) {
927 self->old[0] = self->old[1] = 0;
928 return (self + 1);
929 }
930 break;
931 case sm3FMFM:
932 if ( Operator__Silent(Channel__Op(self, 3))) {
933 self->old[0] = self->old[1] = 0;
934 return (self + 2);
935 }
936 break;
937 case sm3AMFM:
938 if ( Operator__Silent( Channel__Op(self, 0) )
939 && Operator__Silent( Channel__Op(self, 3) )) {
940 self->old[0] = self->old[1] = 0;
941 return (self + 2);
942 }
943 break;
944 case sm3FMAM:
945 if ( Operator__Silent( Channel__Op(self, 1))
946 && Operator__Silent( Channel__Op(self, 3))) {
947 self->old[0] = self->old[1] = 0;
948 return (self + 2);
949 }
950 break;
951 case sm3AMAM:
952 if ( Operator__Silent( Channel__Op(self, 0) )
953 && Operator__Silent( Channel__Op(self, 2) )
954 && Operator__Silent( Channel__Op(self, 3) )) {
955 self->old[0] = self->old[1] = 0;
956 return (self + 2);
957 }
958 break;
959
960 default:
961 abort();
962 }
963 //Init the operators with the the current vibrato and tremolo values
964 Operator__Prepare( Channel__Op( self, 0 ), chip );
965 Operator__Prepare( Channel__Op( self, 1 ), chip );
966 if ( mode > sm4Start ) {
967 Operator__Prepare( Channel__Op( self, 2 ), chip );
968 Operator__Prepare( Channel__Op( self, 3 ), chip );
969 }
970 if ( mode > sm6Start ) {
971 Operator__Prepare( Channel__Op( self, 4 ), chip );
972 Operator__Prepare( Channel__Op( self, 5 ), chip );
973 }
974 for ( i = 0; i < samples; i++ ) {
975 Bit32s mod, sample, out0;
976 Bits next;
977 //Early out for percussion handlers
978 if ( mode == sm2Percussion ) {
979 Channel__GeneratePercussion( self, chip, output + i, FALSE );
980 continue; //Prevent some unitialized value bitching
981 } else if ( mode == sm3Percussion ) {
982 Channel__GeneratePercussion( self, chip, output + i * 2, TRUE );
983 continue; //Prevent some unitialized value bitching
984 }
985
986 //Do unsigned shift so we can shift out all bits but still stay in 10 bit range otherwise
987 mod = (Bit32u)((self->old[0] + self->old[1])) >> self->feedback;
988 self->old[0] = self->old[1];
989 self->old[1] = Operator__GetSample( Channel__Op(self, 0), mod );
990 sample = 0;
991 out0 = self->old[0];
992 if ( mode == sm2AM || mode == sm3AM ) {
993 sample = out0 + Operator__GetSample( Channel__Op(self, 1), 0 );
994 } else if ( mode == sm2FM || mode == sm3FM ) {
995 sample = Operator__GetSample( Channel__Op(self, 1), out0 );
996 } else if ( mode == sm3FMFM ) {
997 next = Operator__GetSample( Channel__Op(self, 1), out0 );
998 next = Operator__GetSample( Channel__Op(self, 2), next );
999 sample = Operator__GetSample( Channel__Op(self, 3), next );
1000 } else if ( mode == sm3AMFM ) {
1001 sample = out0;
1002 next = Operator__GetSample( Channel__Op(self, 1), 0 );
1003 next = Operator__GetSample( Channel__Op(self, 2), next );
1004 sample += Operator__GetSample( Channel__Op(self, 3), next );
1005 } else if ( mode == sm3FMAM ) {
1006 sample = Operator__GetSample( Channel__Op(self, 1), out0 );
1007 next = Operator__GetSample( Channel__Op(self, 2), 0 );
1008 sample += Operator__GetSample( Channel__Op(self, 3), next );
1009 } else if ( mode == sm3AMAM ) {
1010 sample = out0;
1011 next = Operator__GetSample( Channel__Op(self, 1), 0 );
1012 sample += Operator__GetSample( Channel__Op(self, 2), next );
1013 sample += Operator__GetSample( Channel__Op(self, 3), 0 );
1014 }
1015 switch( mode ) {
1016 case sm2AM:
1017 case sm2FM:
1018 output[ i ] += sample;
1019 break;
1020 case sm3AM:
1021 case sm3FM:
1022 case sm3FMFM:
1023 case sm3AMFM:
1024 case sm3FMAM:
1025 case sm3AMAM:
1026 output[ i * 2 + 0 ] += sample & self->maskLeft;
1027 output[ i * 2 + 1 ] += sample & self->maskRight;
1028 break;
1029 default:
1030 abort();
1031 }
1032 }
1033 switch( mode ) {
1034 case sm2AM:
1035 case sm2FM:
1036 case sm3AM:
1037 case sm3FM:
1038 return ( self + 1 );
1039 case sm3FMFM:
1040 case sm3AMFM:
1041 case sm3FMAM:
1042 case sm3AMAM:
1043 return ( self + 2 );
1044 case sm2Percussion:
1045 case sm3Percussion:
1046 return( self + 3 );
1047 default:
1048 abort();
1049 }
1050 return 0;
1051 }
1052
1053 /*
1054 Chip
1055 */
1056
Chip__Chip(Chip * self)1057 void Chip__Chip(Chip *self) {
1058 int i;
1059
1060 for (i=0; i<18; ++i) {
1061 Channel__Channel(&self->chan[i]);
1062 }
1063
1064 self->reg08 = 0;
1065 self->reg04 = 0;
1066 self->regBD = 0;
1067 self->reg104 = 0;
1068 self->opl3Active = 0;
1069 }
1070
Chip__ForwardNoise(Chip * self)1071 static inline Bit32u Chip__ForwardNoise(Chip *self) {
1072 Bitu count;
1073 self->noiseCounter += self->noiseAdd;
1074 count = self->noiseCounter >> LFO_SH;
1075 self->noiseCounter &= WAVE_MASK;
1076 for ( ; count > 0; --count ) {
1077 //Noise calculation from mame
1078 self->noiseValue ^= ( 0x800302 ) & ( 0 - (self->noiseValue & 1 ) );
1079 self->noiseValue >>= 1;
1080 }
1081 return self->noiseValue;
1082 }
1083
Chip__ForwardLFO(Chip * self,Bit32u samples)1084 static inline Bit32u Chip__ForwardLFO(Chip *self, Bit32u samples ) {
1085 Bit32u todo, count;
1086 //Current vibrato value, runs 4x slower than tremolo
1087 self->vibratoSign = ( VibratoTable[ self->vibratoIndex >> 2] ) >> 7;
1088 self->vibratoShift = ( VibratoTable[ self->vibratoIndex >> 2] & 7) + self->vibratoStrength;
1089 self->tremoloValue = TremoloTable[ self->tremoloIndex ] >> self->tremoloStrength;
1090
1091 //Check hom many samples there can be done before the value changes
1092 todo = LFO_MAX - self->lfoCounter;
1093 count = (todo + self->lfoAdd - 1) / self->lfoAdd;
1094 if ( count > samples ) {
1095 count = samples;
1096 self->lfoCounter += count * self->lfoAdd;
1097 } else {
1098 self->lfoCounter += count * self->lfoAdd;
1099 self->lfoCounter &= (LFO_MAX - 1);
1100 //Maximum of 7 vibrato value * 4
1101 self->vibratoIndex = ( self->vibratoIndex + 1 ) & 31;
1102 //Clip tremolo to the the table size
1103 if ( self->tremoloIndex + 1 < TREMOLO_TABLE )
1104 ++self->tremoloIndex;
1105 else
1106 self->tremoloIndex = 0;
1107 }
1108 return count;
1109 }
1110
1111
Chip__WriteBD(Chip * self,Bit8u val)1112 static void Chip__WriteBD(Chip *self, Bit8u val ) {
1113 Bit8u change = self->regBD ^ val;
1114 if ( !change )
1115 return;
1116 self->regBD = val;
1117 //TODO could do this with shift and xor?
1118 self->vibratoStrength = (val & 0x40) ? 0x00 : 0x01;
1119 self->tremoloStrength = (val & 0x80) ? 0x00 : 0x02;
1120 if ( val & 0x20 ) {
1121 //Drum was just enabled, make sure channel 6 has the right synth
1122 if ( change & 0x20 ) {
1123 if ( self->opl3Active ) {
1124 self->chan[6].synthHandler
1125 = Channel__BlockTemplate_sm3Percussion;
1126 } else {
1127 self->chan[6].synthHandler
1128 = Channel__BlockTemplate_sm2Percussion;
1129 }
1130 }
1131 //Bass Drum
1132 if ( val & 0x10 ) {
1133 Operator__KeyOn( &self->chan[6].op[0], 0x2 );
1134 Operator__KeyOn( &self->chan[6].op[1], 0x2 );
1135 } else {
1136 Operator__KeyOff( &self->chan[6].op[0], 0x2 );
1137 Operator__KeyOff( &self->chan[6].op[1], 0x2 );
1138 }
1139 //Hi-Hat
1140 if ( val & 0x1 ) {
1141 Operator__KeyOn( &self->chan[7].op[0], 0x2 );
1142 } else {
1143 Operator__KeyOff( &self->chan[7].op[0], 0x2 );
1144 }
1145 //Snare
1146 if ( val & 0x8 ) {
1147 Operator__KeyOn( &self->chan[7].op[1], 0x2 );
1148 } else {
1149 Operator__KeyOff( &self->chan[7].op[1], 0x2 );
1150 }
1151 //Tom-Tom
1152 if ( val & 0x4 ) {
1153 Operator__KeyOn( &self->chan[8].op[0], 0x2 );
1154 } else {
1155 Operator__KeyOff( &self->chan[8].op[0], 0x2 );
1156 }
1157 //Top Cymbal
1158 if ( val & 0x2 ) {
1159 Operator__KeyOn( &self->chan[8].op[1], 0x2 );
1160 } else {
1161 Operator__KeyOff( &self->chan[8].op[1], 0x2 );
1162 }
1163 //Toggle keyoffs when we turn off the percussion
1164 } else if ( change & 0x20 ) {
1165 //Trigger a reset to setup the original synth handler
1166 Channel__ResetC0( &self->chan[6], self );
1167 Operator__KeyOff( &self->chan[6].op[0], 0x2 );
1168 Operator__KeyOff( &self->chan[6].op[1], 0x2 );
1169 Operator__KeyOff( &self->chan[7].op[0], 0x2 );
1170 Operator__KeyOff( &self->chan[7].op[1], 0x2 );
1171 Operator__KeyOff( &self->chan[8].op[0], 0x2 );
1172 Operator__KeyOff( &self->chan[8].op[1], 0x2 );
1173 }
1174 }
1175
1176
1177 #define REGOP( _FUNC_ ) \
1178 index = ( ( reg >> 3) & 0x20 ) | ( reg & 0x1f ); \
1179 if ( OpOffsetTable[ index ] ) { \
1180 Operator* regOp = (Operator*)( ((char *)self ) + OpOffsetTable[ index ] ); \
1181 Operator__ ## _FUNC_ (regOp, self, val); \
1182 }
1183
1184 #define REGCHAN( _FUNC_ ) \
1185 index = ( ( reg >> 4) & 0x10 ) | ( reg & 0xf ); \
1186 if ( ChanOffsetTable[ index ] ) { \
1187 Channel* regChan = (Channel*)( ((char *)self ) + ChanOffsetTable[ index ] ); \
1188 Channel__ ## _FUNC_ (regChan, self, val); \
1189 }
1190
Chip__WriteReg(Chip * self,Bit32u reg,Bit8u val)1191 void Chip__WriteReg(Chip *self, Bit32u reg, Bit8u val ) {
1192 Bitu index;
1193 switch ( (reg & 0xf0) >> 4 ) {
1194 case 0x00 >> 4:
1195 if ( reg == 0x01 ) {
1196 self->waveFormMask = ( val & 0x20 ) ? 0x7 : 0x0;
1197 } else if ( reg == 0x104 ) {
1198 //Only detect changes in lowest 6 bits
1199 if ( !((self->reg104 ^ val) & 0x3f) )
1200 return;
1201 //Always keep the highest bit enabled, for checking > 0x80
1202 self->reg104 = 0x80 | ( val & 0x3f );
1203 } else if ( reg == 0x105 ) {
1204 int i;
1205
1206 //MAME says the real opl3 doesn't reset anything on opl3 disable/enable till the next write in another register
1207 if ( !((self->opl3Active ^ val) & 1 ) )
1208 return;
1209 self->opl3Active = ( val & 1 ) ? 0xff : 0;
1210 //Update the 0xc0 register for all channels to signal the switch to mono/stereo handlers
1211 for ( i = 0; i < 18;i++ ) {
1212 Channel__ResetC0( &self->chan[i], self );
1213 }
1214 } else if ( reg == 0x08 ) {
1215 self->reg08 = val;
1216 }
1217 case 0x10 >> 4:
1218 break;
1219 case 0x20 >> 4:
1220 case 0x30 >> 4:
1221 REGOP( Write20 );
1222 break;
1223 case 0x40 >> 4:
1224 case 0x50 >> 4:
1225 REGOP( Write40 );
1226 break;
1227 case 0x60 >> 4:
1228 case 0x70 >> 4:
1229 REGOP( Write60 );
1230 break;
1231 case 0x80 >> 4:
1232 case 0x90 >> 4:
1233 REGOP( Write80 );
1234 break;
1235 case 0xa0 >> 4:
1236 REGCHAN( WriteA0 );
1237 break;
1238 case 0xb0 >> 4:
1239 if ( reg == 0xbd ) {
1240 Chip__WriteBD( self, val );
1241 } else {
1242 REGCHAN( WriteB0 );
1243 }
1244 break;
1245 case 0xc0 >> 4:
1246 REGCHAN( WriteC0 );
1247 case 0xd0 >> 4:
1248 break;
1249 case 0xe0 >> 4:
1250 case 0xf0 >> 4:
1251 REGOP( WriteE0 );
1252 break;
1253 }
1254 }
1255
Chip__WriteAddr(Chip * self,Bit32u port,Bit8u val)1256 Bit32u Chip__WriteAddr(Chip *self, Bit32u port, Bit8u val ) {
1257 switch ( port & 3 ) {
1258 case 0:
1259 return val;
1260 case 2:
1261 if ( self->opl3Active || (val == 0x05) )
1262 return 0x100 | val;
1263 else
1264 return val;
1265 }
1266 return 0;
1267 }
1268
Chip__GenerateBlock2(Chip * self,Bitu total,Bit32s * output)1269 void Chip__GenerateBlock2(Chip *self, Bitu total, Bit32s* output ) {
1270 while ( total > 0 ) {
1271 Channel *ch;
1272 int count;
1273
1274 Bit32u samples = Chip__ForwardLFO( self, total );
1275 memset(output, 0, sizeof(Bit32s) * samples);
1276 count = 0;
1277 for ( ch = self->chan; ch < self->chan + 9; ) {
1278 count++;
1279 ch = (ch->synthHandler)( ch, self, samples, output );
1280 }
1281 total -= samples;
1282 output += samples;
1283 }
1284 }
1285
Chip__GenerateBlock3(Chip * self,Bitu total,Bit32s * output)1286 void Chip__GenerateBlock3(Chip *self, Bitu total, Bit32s* output ) {
1287 while ( total > 0 ) {
1288 int count;
1289 Channel *ch;
1290
1291 Bit32u samples = Chip__ForwardLFO( self, total );
1292 memset(output, 0, sizeof(Bit32s) * samples *2);
1293 count = 0;
1294 for ( ch = self->chan; ch < self->chan + 18; ) {
1295 count++;
1296 ch = (ch->synthHandler)( ch, self, samples, output );
1297 }
1298 total -= samples;
1299 output += samples * 2;
1300 }
1301 }
1302
Chip__Setup(Chip * self,Bit32u rate)1303 void Chip__Setup(Chip *self, Bit32u rate ) {
1304 double original = OPLRATE;
1305 Bit32u i;
1306 // double original = rate;
1307 double scale = original / (double)rate;
1308
1309 //Noise counter is run at the same precision as general waves
1310 self->noiseAdd = (Bit32u)( 0.5 + scale * ( 1 << LFO_SH ) );
1311 self->noiseCounter = 0;
1312 self->noiseValue = 1; //Make sure it triggers the noise xor the first time
1313 //The low frequency oscillation counter
1314 //Every time his overflows vibrato and tremoloindex are increased
1315 self->lfoAdd = (Bit32u)( 0.5 + scale * ( 1 << LFO_SH ) );
1316 self->lfoCounter = 0;
1317 self->vibratoIndex = 0;
1318 self->tremoloIndex = 0;
1319
1320 //With higher octave this gets shifted up
1321 //-1 since the freqCreateTable = *2
1322 {
1323 #ifdef WAVE_PRECISION
1324 double freqScale = ( 1 << 7 ) * scale * ( 1 << ( WAVE_SH - 1 - 10));
1325 for ( i = 0; i < 16; i++ ) {
1326 self->freqMul[i] = (Bit32u)( 0.5 + freqScale * FreqCreateTable[ i ] );
1327 }
1328 #else
1329 Bit32u freqScale = (Bit32u)( 0.5 + scale * ( 1 << ( WAVE_SH - 1 - 10)));
1330 for ( i = 0; i < 16; i++ ) {
1331 self->freqMul[i] = freqScale * FreqCreateTable[ i ];
1332 }
1333 #endif
1334 }
1335
1336 //-3 since the real envelope takes 8 steps to reach the single value we supply
1337 for ( i = 0; i < 76; i++ ) {
1338 Bit8u index, shift;
1339 EnvelopeSelect( (Bit8u) i, &index, &shift );
1340 self->linearRates[i] = (Bit32u)( scale * (EnvelopeIncreaseTable[ index ] << ( RATE_SH + ENV_EXTRA - shift - 3 )));
1341 }
1342 //Generate the best matching attack rate
1343 for ( i = 0; i < 62; i++ ) {
1344 Bit8u index, shift;
1345 Bit32s original, guessAdd, bestAdd, bestDiff;
1346 Bit32u passes;
1347 EnvelopeSelect( (Bit8u) i, &index, &shift );
1348 //Original amount of samples the attack would take
1349 original = (Bit32u)( (AttackSamplesTable[ index ] << shift) / scale);
1350
1351 guessAdd = (Bit32u)( scale * (EnvelopeIncreaseTable[ index ] << ( RATE_SH - shift - 3 )));
1352 bestAdd = guessAdd;
1353 bestDiff = 1 << 30;
1354
1355 for ( passes = 0; passes < 16; passes ++ ) {
1356 Bit32s diff, lDiff;
1357 Bit32s volume = ENV_MAX;
1358 Bit32s samples = 0;
1359 Bit32u count = 0;
1360 while ( volume > 0 && samples < original * 2 ) {
1361 Bit32s change;
1362 count += guessAdd;
1363 change = count >> RATE_SH;
1364 count &= RATE_MASK;
1365 if ( GCC_UNLIKELY(change) ) { // less than 1 %
1366 volume += ( ~volume * change ) >> 3;
1367 }
1368 samples++;
1369
1370 }
1371 diff = original - samples;
1372 lDiff = labs( diff );
1373 //Init last on first pass
1374 if ( lDiff < bestDiff ) {
1375 bestDiff = lDiff;
1376 bestAdd = guessAdd;
1377 if ( !bestDiff )
1378 break;
1379 }
1380 //Below our target
1381 if ( diff < 0 ) {
1382 //Better than the last time
1383 Bit32s mul = ((original - diff) << 12) / original;
1384 guessAdd = ((guessAdd * mul) >> 12);
1385 guessAdd++;
1386 } else if ( diff > 0 ) {
1387 Bit32s mul = ((original - diff) << 12) / original;
1388 guessAdd = (guessAdd * mul) >> 12;
1389 guessAdd--;
1390 }
1391 }
1392 self->attackRates[i] = bestAdd;
1393 }
1394 for ( i = 62; i < 76; i++ ) {
1395 //This should provide instant volume maximizing
1396 self->attackRates[i] = 8 << RATE_SH;
1397 }
1398 //Setup the channels with the correct four op flags
1399 //Channels are accessed through a table so they appear linear here
1400 self->chan[ 0].fourMask = 0x00 | ( 1 << 0 );
1401 self->chan[ 1].fourMask = 0x80 | ( 1 << 0 );
1402 self->chan[ 2].fourMask = 0x00 | ( 1 << 1 );
1403 self->chan[ 3].fourMask = 0x80 | ( 1 << 1 );
1404 self->chan[ 4].fourMask = 0x00 | ( 1 << 2 );
1405 self->chan[ 5].fourMask = 0x80 | ( 1 << 2 );
1406
1407 self->chan[ 9].fourMask = 0x00 | ( 1 << 3 );
1408 self->chan[10].fourMask = 0x80 | ( 1 << 3 );
1409 self->chan[11].fourMask = 0x00 | ( 1 << 4 );
1410 self->chan[12].fourMask = 0x80 | ( 1 << 4 );
1411 self->chan[13].fourMask = 0x00 | ( 1 << 5 );
1412 self->chan[14].fourMask = 0x80 | ( 1 << 5 );
1413
1414 //mark the percussion channels
1415 self->chan[ 6].fourMask = 0x40;
1416 self->chan[ 7].fourMask = 0x40;
1417 self->chan[ 8].fourMask = 0x40;
1418
1419 //Clear Everything in opl3 mode
1420 Chip__WriteReg( self, 0x105, 0x1 );
1421 for ( i = 0; i < 512; i++ ) {
1422 if ( i == 0x105 )
1423 continue;
1424 Chip__WriteReg( self, i, 0xff );
1425 Chip__WriteReg( self, i, 0x0 );
1426 }
1427 Chip__WriteReg( self, 0x105, 0x0 );
1428 //Clear everything in opl2 mode
1429 for ( i = 0; i < 255; i++ ) {
1430 Chip__WriteReg( self, i, 0xff );
1431 Chip__WriteReg( self, i, 0x0 );
1432 }
1433 }
1434
1435 static int doneTables = FALSE;
DBOPL_InitTables(void)1436 void DBOPL_InitTables( void ) {
1437 int i, oct;
1438 Chip *chip = NULL;
1439
1440 if ( doneTables )
1441 return;
1442 doneTables = TRUE;
1443 #if ( DBOPL_WAVE == WAVE_HANDLER ) || ( DBOPL_WAVE == WAVE_TABLELOG )
1444 //Exponential volume table, same as the real adlib
1445 for ( i = 0; i < 256; i++ ) {
1446 //Save them in reverse
1447 ExpTable[i] = (int)( 0.5 + ( pow(2.0, ( 255 - i) * ( 1.0 /256 ) )-1) * 1024 );
1448 ExpTable[i] += 1024; //or remove the -1 oh well :)
1449 //Preshift to the left once so the final volume can shift to the right
1450 ExpTable[i] *= 2;
1451 }
1452 #endif
1453 #if ( DBOPL_WAVE == WAVE_HANDLER )
1454 //Add 0.5 for the trunc rounding of the integer cast
1455 //Do a PI sinetable instead of the original 0.5 PI
1456 for ( i = 0; i < 512; i++ ) {
1457 SinTable[i] = (Bit16s)( 0.5 - log10( sin( (i + 0.5) * (PI / 512.0) ) ) / log10(2.0)*256 );
1458 }
1459 #endif
1460 #if ( DBOPL_WAVE == WAVE_TABLEMUL )
1461 //Multiplication based tables
1462 for ( i = 0; i < 384; i++ ) {
1463 int s = i * 8;
1464 //TODO maybe keep some of the precision errors of the original table?
1465 double val = ( 0.5 + ( pow(2.0, -1.0 + ( 255 - s) * ( 1.0 /256 ) )) * ( 1 << MUL_SH ));
1466 MulTable[i] = (Bit16u)(val);
1467 }
1468
1469 //Sine Wave Base
1470 for ( i = 0; i < 512; i++ ) {
1471 WaveTable[ 0x0200 + i ] = (Bit16s)(sin( (i + 0.5) * (PI / 512.0) ) * 4084);
1472 WaveTable[ 0x0000 + i ] = -WaveTable[ 0x200 + i ];
1473 }
1474 //Exponential wave
1475 for ( i = 0; i < 256; i++ ) {
1476 WaveTable[ 0x700 + i ] = (Bit16s)( 0.5 + ( pow(2.0, -1.0 + ( 255 - i * 8) * ( 1.0 /256 ) ) ) * 4085 );
1477 WaveTable[ 0x6ff - i ] = -WaveTable[ 0x700 + i ];
1478 }
1479 #endif
1480 #if ( DBOPL_WAVE == WAVE_TABLELOG )
1481 //Sine Wave Base
1482 for ( i = 0; i < 512; i++ ) {
1483 WaveTable[ 0x0200 + i ] = (Bit16s)( 0.5 - log10( sin( (i + 0.5) * (PI / 512.0) ) ) / log10(2.0)*256 );
1484 WaveTable[ 0x0000 + i ] = ((Bit16s)0x8000) | WaveTable[ 0x200 + i];
1485 }
1486 //Exponential wave
1487 for ( i = 0; i < 256; i++ ) {
1488 WaveTable[ 0x700 + i ] = i * 8;
1489 WaveTable[ 0x6ff - i ] = ((Bit16s)0x8000) | i * 8;
1490 }
1491 #endif
1492
1493 // | |//\\|____|WAV7|//__|/\ |____|/\/\|
1494 // |\\//| | |WAV7| | \/| | |
1495 // |06 |0126|27 |7 |3 |4 |4 5 |5 |
1496
1497 #if (( DBOPL_WAVE == WAVE_TABLELOG ) || ( DBOPL_WAVE == WAVE_TABLEMUL ))
1498 for ( i = 0; i < 256; i++ ) {
1499 //Fill silence gaps
1500 WaveTable[ 0x400 + i ] = WaveTable[0];
1501 WaveTable[ 0x500 + i ] = WaveTable[0];
1502 WaveTable[ 0x900 + i ] = WaveTable[0];
1503 WaveTable[ 0xc00 + i ] = WaveTable[0];
1504 WaveTable[ 0xd00 + i ] = WaveTable[0];
1505 //Replicate sines in other pieces
1506 WaveTable[ 0x800 + i ] = WaveTable[ 0x200 + i ];
1507 //double speed sines
1508 WaveTable[ 0xa00 + i ] = WaveTable[ 0x200 + i * 2 ];
1509 WaveTable[ 0xb00 + i ] = WaveTable[ 0x000 + i * 2 ];
1510 WaveTable[ 0xe00 + i ] = WaveTable[ 0x200 + i * 2 ];
1511 WaveTable[ 0xf00 + i ] = WaveTable[ 0x200 + i * 2 ];
1512 }
1513 #endif
1514
1515 //Create the ksl table
1516 for ( oct = 0; oct < 8; oct++ ) {
1517 int base = oct * 8;
1518 for ( i = 0; i < 16; i++ ) {
1519 int val = base - KslCreateTable[i];
1520 if ( val < 0 )
1521 val = 0;
1522 //*4 for the final range to match attenuation range
1523 KslTable[ oct * 16 + i ] = val * 4;
1524 }
1525 }
1526 //Create the Tremolo table, just increase and decrease a triangle wave
1527 for ( i = 0; i < TREMOLO_TABLE / 2; i++ ) {
1528 Bit8u val = i << ENV_EXTRA;
1529 TremoloTable[i] = val;
1530 TremoloTable[TREMOLO_TABLE - 1 - i] = val;
1531 }
1532 //Create a table with offsets of the channels from the start of the chip
1533 for ( i = 0; i < 32; i++ ) {
1534 Bitu blah;
1535 Bitu index = i & 0xf;
1536 if ( index >= 9 ) {
1537 ChanOffsetTable[i] = 0;
1538 continue;
1539 }
1540 //Make sure the four op channels follow eachother
1541 if ( index < 6 ) {
1542 index = (index % 3) * 2 + ( index / 3 );
1543 }
1544 //Add back the bits for highest ones
1545 if ( i >= 16 )
1546 index += 9;
1547 blah = (Bitu) ( &(chip->chan[ index ]) );
1548 ChanOffsetTable[i] = (Bit16u) blah;
1549 }
1550 //Same for operators
1551 for ( i = 0; i < 64; i++ ) {
1552 Bitu chNum, opNum, blah;
1553 Channel* chan = NULL;
1554 if ( i % 8 >= 6 || ( (i / 8) % 4 == 3 ) ) {
1555 OpOffsetTable[i] = 0;
1556 continue;
1557 }
1558 chNum = (i / 8) * 3 + (i % 8) % 3;
1559 //Make sure we use 16 and up for the 2nd range to match the chanoffset gap
1560 if ( chNum >= 12 )
1561 chNum += 16 - 12;
1562 opNum = ( i % 8 ) / 3;
1563 blah = (Bitu) ( &(chan->op[opNum]) );
1564 OpOffsetTable[i] = (Bit16u) (ChanOffsetTable[ chNum ] + blah);
1565 }
1566 #if 0
1567 //Stupid checks if table's are correct
1568 for ( Bitu i = 0; i < 18; i++ ) {
1569 Bit32u find = (Bit16u)( &(chip->chan[ i ]) );
1570 for ( Bitu c = 0; c < 32; c++ ) {
1571 if ( ChanOffsetTable[c] == find ) {
1572 find = 0;
1573 break;
1574 }
1575 }
1576 if ( find ) {
1577 find = find;
1578 }
1579 }
1580 for ( Bitu i = 0; i < 36; i++ ) {
1581 Bit32u find = (Bit16u)( &(chip->chan[ i / 2 ].op[i % 2]) );
1582 for ( Bitu c = 0; c < 64; c++ ) {
1583 if ( OpOffsetTable[c] == find ) {
1584 find = 0;
1585 break;
1586 }
1587 }
1588 if ( find ) {
1589 find = find;
1590 }
1591 }
1592 #endif
1593 }
1594
1595
1596