diff options
Diffstat (limited to 'lib/rbcodec/codecs/libgme/ym2612_emu.c')
-rw-r--r-- | lib/rbcodec/codecs/libgme/ym2612_emu.c | 1374 |
1 files changed, 1374 insertions, 0 deletions
diff --git a/lib/rbcodec/codecs/libgme/ym2612_emu.c b/lib/rbcodec/codecs/libgme/ym2612_emu.c new file mode 100644 index 0000000000..60df30a33c --- /dev/null +++ b/lib/rbcodec/codecs/libgme/ym2612_emu.c | |||
@@ -0,0 +1,1374 @@ | |||
1 | // Game_Music_Emu $vers. http://www.slack.net/~ant/ | ||
2 | |||
3 | // Based on Gens 2.10 ym2612.c | ||
4 | |||
5 | #include <stdlib.h> | ||
6 | #include <string.h> | ||
7 | #include <limits.h> | ||
8 | #include <stdio.h> | ||
9 | #include <math.h> | ||
10 | |||
11 | #include "ym2612_emu.h" | ||
12 | |||
13 | /* Copyright (C) 2002 Stéphane Dallongeville (gens AT consolemul.com) */ | ||
14 | /* Copyright (C) 2004-2007 Shay Green. This module is free software; you | ||
15 | can redistribute it and/or modify it under the terms of the GNU Lesser | ||
16 | General Public License as published by the Free Software Foundation; either | ||
17 | version 2.1 of the License, or (at your option) any later version. This | ||
18 | module is distributed in the hope that it will be useful, but WITHOUT ANY | ||
19 | WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS | ||
20 | FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more | ||
21 | details. You should have received a copy of the GNU Lesser General Public | ||
22 | License along with this module; if not, write to the Free Software Foundation, | ||
23 | Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ | ||
24 | |||
25 | // This is mostly the original source in its C style and all. | ||
26 | // | ||
27 | // Somewhat optimized and simplified. Uses a template to generate the many | ||
28 | // variants of Update_Chan. Rewrote header file. In need of full rewrite by | ||
29 | // someone more familiar with FM sound and the YM2612. Has some inaccuracies | ||
30 | // compared to the Sega Genesis sound, particularly being mixed at such a | ||
31 | // high sample accuracy (the Genesis sounds like it has only 8 bit samples). | ||
32 | // - Shay | ||
33 | |||
34 | // Ported again to c by gama. | ||
35 | // Not sure if performance is better than the original c version. | ||
36 | |||
37 | #if !defined(YM2612_CALCUL_TABLES) | ||
38 | #include "ymtables.h" | ||
39 | #endif | ||
40 | |||
41 | #ifdef YM2612_CALCUL_TABLES | ||
42 | #define FREQ_TAB_LOOKUP g->LFO_FREQ_TAB | ||
43 | #define ENV_TAB_LOOKUP g->LFO_ENV_TAB | ||
44 | #else | ||
45 | #define FREQ_TAB_LOOKUP lfo_freq_coeff | ||
46 | #define ENV_TAB_LOOKUP lfo_env_coeff | ||
47 | #endif | ||
48 | |||
49 | const int output_bits = 14; | ||
50 | |||
51 | static const unsigned char DT_DEF_TAB [4 * 32] = | ||
52 | { | ||
53 | // FD = 0 | ||
54 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | ||
55 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, | ||
56 | |||
57 | // FD = 1 | ||
58 | 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, | ||
59 | 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 7, 8, 8, 8, 8, | ||
60 | |||
61 | // FD = 2 | ||
62 | 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, | ||
63 | 5, 6, 6, 7, 8, 8, 9, 10, 11, 12, 13, 14, 16, 16, 16, 16, | ||
64 | |||
65 | // FD = 3 | ||
66 | 2, 2, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 6, 6, 7, | ||
67 | 8 , 8, 9, 10, 11, 12, 13, 14, 16, 17, 19, 20, 22, 22, 22, 22 | ||
68 | }; | ||
69 | |||
70 | static const unsigned char FKEY_TAB [16] = | ||
71 | { | ||
72 | 0, 0, 0, 0, | ||
73 | 0, 0, 0, 1, | ||
74 | 2, 3, 3, 3, | ||
75 | 3, 3, 3, 3 | ||
76 | }; | ||
77 | |||
78 | static const unsigned char LFO_AMS_TAB [4] = | ||
79 | { | ||
80 | 31, 4, 1, 0 | ||
81 | }; | ||
82 | |||
83 | static const unsigned char LFO_FMS_TAB [8] = | ||
84 | { | ||
85 | LFO_FMS_BASE * 0, LFO_FMS_BASE * 1, | ||
86 | LFO_FMS_BASE * 2, LFO_FMS_BASE * 3, | ||
87 | LFO_FMS_BASE * 4, LFO_FMS_BASE * 6, | ||
88 | LFO_FMS_BASE * 12, LFO_FMS_BASE * 24 | ||
89 | }; | ||
90 | |||
91 | int in0, in1, in2, in3; // current phase calculation | ||
92 | // int en0, en1, en2, en3; // current enveloppe calculation | ||
93 | |||
94 | static inline void set_seg( struct slot_t* s, int seg ) | ||
95 | { | ||
96 | s->env_xor = 0; | ||
97 | s->env_max = INT_MAX; | ||
98 | s->SEG = seg; | ||
99 | if ( seg & 4 ) | ||
100 | { | ||
101 | s->env_xor = ENV_MASK; | ||
102 | s->env_max = ENV_MASK; | ||
103 | } | ||
104 | } | ||
105 | |||
106 | static inline void YM2612_Special_Update(void) { } | ||
107 | |||
108 | static void KEY_ON( struct channel_* ch, struct tables_t *g, int nsl ) | ||
109 | { | ||
110 | struct slot_t *SL = &(ch->SLOT [nsl]); // on recupere le bon pointeur de slot | ||
111 | |||
112 | if (SL->Ecurp == RELEASE) // la touche est-elle rel'chee ? | ||
113 | { | ||
114 | SL->Fcnt = 0; | ||
115 | |||
116 | // Fix Ecco 2 splash sound | ||
117 | |||
118 | SL->Ecnt = (g->DECAY_TO_ATTACK [g->ENV_TAB [SL->Ecnt >> ENV_LBITS]] + ENV_ATTACK) & SL->ChgEnM; | ||
119 | SL->ChgEnM = ~0; | ||
120 | |||
121 | // SL->Ecnt = g.DECAY_TO_ATTACK [g.ENV_TAB [SL->Ecnt >> ENV_LBITS]] + ENV_ATTACK; | ||
122 | // SL->Ecnt = 0; | ||
123 | |||
124 | SL->Einc = SL->EincA; | ||
125 | SL->Ecmp = ENV_DECAY; | ||
126 | SL->Ecurp = ATTACK; | ||
127 | } | ||
128 | } | ||
129 | |||
130 | |||
131 | static void KEY_OFF( struct channel_* ch, struct tables_t *g, int nsl ) | ||
132 | { | ||
133 | struct slot_t *SL = &(ch->SLOT [nsl]); // on recupere le bon pointeur de slot | ||
134 | |||
135 | if (SL->Ecurp != RELEASE) // la touche est-elle appuyee ? | ||
136 | { | ||
137 | if (SL->Ecnt < ENV_DECAY) // attack phase ? | ||
138 | { | ||
139 | SL->Ecnt = (g->ENV_TAB [SL->Ecnt >> ENV_LBITS] << ENV_LBITS) + ENV_DECAY; | ||
140 | } | ||
141 | |||
142 | SL->Einc = SL->EincR; | ||
143 | SL->Ecmp = ENV_END; | ||
144 | SL->Ecurp = RELEASE; | ||
145 | } | ||
146 | } | ||
147 | |||
148 | |||
149 | static int SLOT_SET( struct Ym2612_Impl* impl, int Adr, int data ) | ||
150 | { | ||
151 | int nch = Adr & 3; | ||
152 | if ( nch == 3 ) | ||
153 | return 1; | ||
154 | |||
155 | struct tables_t *g = &impl->g; | ||
156 | struct state_t *YM2612 = &impl->YM2612; | ||
157 | struct channel_* ch = &YM2612->CHANNEL [nch + (Adr & 0x100 ? 3 : 0)]; | ||
158 | struct slot_t* sl = &ch->SLOT [(Adr >> 2) & 3]; | ||
159 | |||
160 | switch ( Adr & 0xF0 ) | ||
161 | { | ||
162 | case 0x30: | ||
163 | if ( (sl->MUL = (data & 0x0F)) != 0 ) sl->MUL <<= 1; | ||
164 | else sl->MUL = 1; | ||
165 | |||
166 | sl->DT = (int*) g->DT_TAB [(data >> 4) & 7]; | ||
167 | |||
168 | ch->SLOT [0].Finc = -1; | ||
169 | |||
170 | break; | ||
171 | |||
172 | case 0x40: | ||
173 | sl->TL = data & 0x7F; | ||
174 | |||
175 | // SOR2 do a lot of TL adjustement and this fix R.Shinobi jump sound... | ||
176 | YM2612_Special_Update(); | ||
177 | |||
178 | #if ((ENV_HBITS - 7) < 0) | ||
179 | sl->TLL = sl->TL >> (7 - ENV_HBITS); | ||
180 | #else | ||
181 | sl->TLL = sl->TL << (ENV_HBITS - 7); | ||
182 | #endif | ||
183 | |||
184 | break; | ||
185 | |||
186 | case 0x50: | ||
187 | sl->KSR_S = 3 - (data >> 6); | ||
188 | |||
189 | ch->SLOT [0].Finc = -1; | ||
190 | |||
191 | if (data &= 0x1F) sl->AR = (int*) &g->AR_TAB [data << 1]; | ||
192 | else sl->AR = (int*) &g->NULL_RATE [0]; | ||
193 | |||
194 | sl->EincA = sl->AR [sl->KSR]; | ||
195 | if (sl->Ecurp == ATTACK) sl->Einc = sl->EincA; | ||
196 | break; | ||
197 | |||
198 | case 0x60: | ||
199 | if ( (sl->AMSon = (data & 0x80)) != 0 ) sl->AMS = ch->AMS; | ||
200 | else sl->AMS = 31; | ||
201 | |||
202 | if (data &= 0x1F) sl->DR = (int*) &g->DR_TAB [data << 1]; | ||
203 | else sl->DR = (int*) &g->NULL_RATE [0]; | ||
204 | |||
205 | sl->EincD = sl->DR [sl->KSR]; | ||
206 | if (sl->Ecurp == DECAY) sl->Einc = sl->EincD; | ||
207 | break; | ||
208 | |||
209 | case 0x70: | ||
210 | if (data &= 0x1F) sl->SR = (int*) &g->DR_TAB [data << 1]; | ||
211 | else sl->SR = (int*) &g->NULL_RATE [0]; | ||
212 | |||
213 | sl->EincS = sl->SR [sl->KSR]; | ||
214 | if ((sl->Ecurp == SUBSTAIN) && (sl->Ecnt < ENV_END)) sl->Einc = sl->EincS; | ||
215 | break; | ||
216 | |||
217 | case 0x80: | ||
218 | sl->SLL = g->SL_TAB [data >> 4]; | ||
219 | |||
220 | sl->RR = (int*) &g->DR_TAB [((data & 0xF) << 2) + 2]; | ||
221 | |||
222 | sl->EincR = sl->RR [sl->KSR]; | ||
223 | if ((sl->Ecurp == RELEASE) && (sl->Ecnt < ENV_END)) sl->Einc = sl->EincR; | ||
224 | break; | ||
225 | |||
226 | case 0x90: | ||
227 | // SSG-EG envelope shapes : | ||
228 | /* | ||
229 | E At Al H | ||
230 | |||
231 | 1 0 0 0 \\\\ | ||
232 | 1 0 0 1 \___ | ||
233 | 1 0 1 0 \/\/ | ||
234 | 1 0 1 1 \ | ||
235 | 1 1 0 0 //// | ||
236 | 1 1 0 1 / | ||
237 | 1 1 1 0 /\/\ | ||
238 | 1 1 1 1 /___ | ||
239 | |||
240 | E = SSG-EG enable | ||
241 | At = Start negate | ||
242 | Al = Altern | ||
243 | H = Hold */ | ||
244 | |||
245 | set_seg( sl, (data & 8) ? (data & 0x0F) : 0 ); | ||
246 | break; | ||
247 | } | ||
248 | |||
249 | return 0; | ||
250 | } | ||
251 | |||
252 | |||
253 | static int CHANNEL_SET( struct state_t* YM2612, int Adr, int data ) | ||
254 | { | ||
255 | int num = Adr & 3; | ||
256 | if ( num == 3 ) | ||
257 | return 1; | ||
258 | |||
259 | struct channel_* ch = &YM2612->CHANNEL [num + (Adr & 0x100 ? 3 : 0)]; | ||
260 | |||
261 | switch ( Adr & 0xFC ) | ||
262 | { | ||
263 | case 0xA0: | ||
264 | YM2612_Special_Update(); | ||
265 | |||
266 | ch->FNUM [0] = (ch->FNUM [0] & 0x700) + data; | ||
267 | ch->KC [0] = (ch->FOCT [0] << 2) | FKEY_TAB [ch->FNUM [0] >> 7]; | ||
268 | |||
269 | ch->SLOT [0].Finc = -1; | ||
270 | break; | ||
271 | |||
272 | case 0xA4: | ||
273 | YM2612_Special_Update(); | ||
274 | |||
275 | ch->FNUM [0] = (ch->FNUM [0] & 0x0FF) + ((data & 0x07) << 8); | ||
276 | ch->FOCT [0] = (data & 0x38) >> 3; | ||
277 | ch->KC [0] = (ch->FOCT [0] << 2) | FKEY_TAB [ch->FNUM [0] >> 7]; | ||
278 | |||
279 | ch->SLOT [0].Finc = -1; | ||
280 | break; | ||
281 | |||
282 | case 0xA8: | ||
283 | if ( Adr < 0x100 ) | ||
284 | { | ||
285 | num++; | ||
286 | |||
287 | YM2612_Special_Update(); | ||
288 | |||
289 | YM2612->CHANNEL [2].FNUM [num] = (YM2612->CHANNEL [2].FNUM [num] & 0x700) + data; | ||
290 | YM2612->CHANNEL [2].KC [num] = (YM2612->CHANNEL [2].FOCT [num] << 2) | | ||
291 | FKEY_TAB [YM2612->CHANNEL [2].FNUM [num] >> 7]; | ||
292 | |||
293 | YM2612->CHANNEL [2].SLOT [0].Finc = -1; | ||
294 | } | ||
295 | break; | ||
296 | |||
297 | case 0xAC: | ||
298 | if ( Adr < 0x100 ) | ||
299 | { | ||
300 | num++; | ||
301 | |||
302 | YM2612_Special_Update(); | ||
303 | |||
304 | YM2612->CHANNEL [2].FNUM [num] = (YM2612->CHANNEL [2].FNUM [num] & 0x0FF) + ((data & 0x07) << 8); | ||
305 | YM2612->CHANNEL [2].FOCT [num] = (data & 0x38) >> 3; | ||
306 | YM2612->CHANNEL [2].KC [num] = (YM2612->CHANNEL [2].FOCT [num] << 2) | | ||
307 | FKEY_TAB [YM2612->CHANNEL [2].FNUM [num] >> 7]; | ||
308 | |||
309 | YM2612->CHANNEL [2].SLOT [0].Finc = -1; | ||
310 | } | ||
311 | break; | ||
312 | |||
313 | case 0xB0: | ||
314 | if ( ch->ALGO != (data & 7) ) | ||
315 | { | ||
316 | // Fix VectorMan 2 heli sound (level 1) | ||
317 | YM2612_Special_Update(); | ||
318 | |||
319 | ch->ALGO = data & 7; | ||
320 | |||
321 | ch->SLOT [0].ChgEnM = 0; | ||
322 | ch->SLOT [1].ChgEnM = 0; | ||
323 | ch->SLOT [2].ChgEnM = 0; | ||
324 | ch->SLOT [3].ChgEnM = 0; | ||
325 | } | ||
326 | |||
327 | ch->FB = 9 - ((data >> 3) & 7); // Real thing ? | ||
328 | |||
329 | // if (ch->FB = ((data >> 3) & 7)) ch->FB = 9 - ch->FB; // Thunder force 4 (music stage 8), Gynoug, Aladdin bug sound... | ||
330 | // else ch->FB = 31; | ||
331 | break; | ||
332 | |||
333 | case 0xB4: { | ||
334 | YM2612_Special_Update(); | ||
335 | |||
336 | ch->LEFT = 0 - ((data >> 7) & 1); | ||
337 | ch->RIGHT = 0 - ((data >> 6) & 1); | ||
338 | |||
339 | ch->AMS = LFO_AMS_TAB [(data >> 4) & 3]; | ||
340 | ch->FMS = LFO_FMS_TAB [data & 7]; | ||
341 | |||
342 | int i; | ||
343 | for ( i = 0; i < 4; i++ ) | ||
344 | { | ||
345 | struct slot_t* sl = &ch->SLOT [i]; | ||
346 | sl->AMS = (sl->AMSon ? ch->AMS : 31); | ||
347 | } | ||
348 | break; | ||
349 | } | ||
350 | } | ||
351 | |||
352 | return 0; | ||
353 | } | ||
354 | |||
355 | |||
356 | static int YM_SET( struct Ym2612_Impl* impl, int Adr, int data ) | ||
357 | { | ||
358 | struct state_t* YM2612 = &impl->YM2612; | ||
359 | struct tables_t* g = &impl->g; | ||
360 | switch ( Adr ) | ||
361 | { | ||
362 | case 0x22: | ||
363 | if (data & 8) // LFO enable | ||
364 | { | ||
365 | // Cool Spot music 1, LFO modified severals time which | ||
366 | // distord the sound, have to check that on a real genesis... | ||
367 | |||
368 | g->LFOinc = g->LFO_INC_TAB [data & 7]; | ||
369 | } | ||
370 | else | ||
371 | { | ||
372 | g->LFOinc = g->LFOcnt = 0; | ||
373 | } | ||
374 | break; | ||
375 | |||
376 | case 0x24: | ||
377 | YM2612->TimerA = (YM2612->TimerA & 0x003) | (((int) data) << 2); | ||
378 | |||
379 | if (YM2612->TimerAL != (1024 - YM2612->TimerA) << 12) | ||
380 | { | ||
381 | YM2612->TimerAcnt = YM2612->TimerAL = (1024 - YM2612->TimerA) << 12; | ||
382 | } | ||
383 | break; | ||
384 | |||
385 | case 0x25: | ||
386 | YM2612->TimerA = (YM2612->TimerA & 0x3FC) | (data & 3); | ||
387 | |||
388 | if (YM2612->TimerAL != (1024 - YM2612->TimerA) << 12) | ||
389 | { | ||
390 | YM2612->TimerAcnt = YM2612->TimerAL = (1024 - YM2612->TimerA) << 12; | ||
391 | } | ||
392 | break; | ||
393 | |||
394 | case 0x26: | ||
395 | YM2612->TimerB = data; | ||
396 | |||
397 | if (YM2612->TimerBL != (256 - YM2612->TimerB) << (4 + 12)) | ||
398 | { | ||
399 | YM2612->TimerBcnt = YM2612->TimerBL = (256 - YM2612->TimerB) << (4 + 12); | ||
400 | } | ||
401 | break; | ||
402 | |||
403 | case 0x27: | ||
404 | // Parametre divers | ||
405 | // b7 = CSM MODE | ||
406 | // b6 = 3 slot mode | ||
407 | // b5 = reset b | ||
408 | // b4 = reset a | ||
409 | // b3 = timer enable b | ||
410 | // b2 = timer enable a | ||
411 | // b1 = load b | ||
412 | // b0 = load a | ||
413 | |||
414 | if ((data ^ YM2612->Mode) & 0x40) | ||
415 | { | ||
416 | // We changed the channel 2 mode, so recalculate phase step | ||
417 | // This fix the punch sound in Street of Rage 2 | ||
418 | |||
419 | YM2612_Special_Update(); | ||
420 | |||
421 | YM2612->CHANNEL [2].SLOT [0].Finc = -1; // recalculate phase step | ||
422 | } | ||
423 | |||
424 | // if ((data & 2) && (YM2612->Status & 2)) YM2612->TimerBcnt = YM2612->TimerBL; | ||
425 | // if ((data & 1) && (YM2612->Status & 1)) YM2612->TimerAcnt = YM2612->TimerAL; | ||
426 | |||
427 | // YM2612->Status &= (~data >> 4); // Reset du Status au cas ou c'est demande | ||
428 | YM2612->Status &= (~data >> 4) & (data >> 2); // Reset Status | ||
429 | |||
430 | YM2612->Mode = data; | ||
431 | break; | ||
432 | |||
433 | case 0x28: { | ||
434 | int nch = data & 3; | ||
435 | if ( nch == 3 ) | ||
436 | return 1; | ||
437 | if ( data & 4 ) | ||
438 | nch += 3; | ||
439 | struct channel_* ch = &YM2612->CHANNEL [nch]; | ||
440 | |||
441 | YM2612_Special_Update(); | ||
442 | |||
443 | if (data & 0x10) KEY_ON(ch, g, S0); // On appuie sur la touche pour le slot 1 | ||
444 | else KEY_OFF(ch, g, S0); // On rel'che la touche pour le slot 1 | ||
445 | if (data & 0x20) KEY_ON(ch, g, S1); // On appuie sur la touche pour le slot 3 | ||
446 | else KEY_OFF(ch, g, S1); // On rel'che la touche pour le slot 3 | ||
447 | if (data & 0x40) KEY_ON(ch, g, S2); // On appuie sur la touche pour le slot 2 | ||
448 | else KEY_OFF(ch, g, S2); // On rel'che la touche pour le slot 2 | ||
449 | if (data & 0x80) KEY_ON(ch, g, S3); // On appuie sur la touche pour le slot 4 | ||
450 | else KEY_OFF(ch, g, S3); // On rel'che la touche pour le slot 4 | ||
451 | break; | ||
452 | } | ||
453 | |||
454 | case 0x2B: | ||
455 | if (YM2612->DAC ^ (data & 0x80)) YM2612_Special_Update(); | ||
456 | |||
457 | YM2612->DAC = data & 0x80; // activation/desactivation du DAC | ||
458 | break; | ||
459 | } | ||
460 | |||
461 | return 0; | ||
462 | } | ||
463 | |||
464 | void impl_reset( struct Ym2612_Impl* impl ); | ||
465 | static void impl_set_rate( struct Ym2612_Impl* impl, int sample_rate, int clock_rate ) | ||
466 | { | ||
467 | assert( sample_rate ); | ||
468 | assert( !clock_rate || clock_rate > sample_rate ); | ||
469 | |||
470 | int i; | ||
471 | |||
472 | // 144 = 12 * (prescale * 2) = 12 * 6 * 2 | ||
473 | // prescale set to 6 by default | ||
474 | |||
475 | int Frequency = (clock_rate ? (int)((FP_ONE_CLOCK * clock_rate) / sample_rate / 144) : (int)FP_ONE_CLOCK); | ||
476 | if ( abs( Frequency - FP_ONE_CLOCK ) < 1 ) | ||
477 | Frequency = FP_ONE_CLOCK; | ||
478 | impl->YM2612.TimerBase = Frequency; | ||
479 | |||
480 | /* double Frequence = (double)Frequency / FP_ONE_CLOCK; */ | ||
481 | |||
482 | // Tableau TL : | ||
483 | // [0 - 4095] = +output [4095 - ...] = +output overflow (fill with 0) | ||
484 | // [12288 - 16383] = -output [16384 - ...] = -output overflow (fill with 0) | ||
485 | |||
486 | #ifdef YM2612_USE_TL_TAB | ||
487 | for ( i = 0; i < TL_LENGHT; i++ ) | ||
488 | { | ||
489 | if (i >= PG_CUT_OFF) // YM2612 cut off sound after 78 dB (14 bits output ?) | ||
490 | { | ||
491 | impl->g.TL_TAB [TL_LENGHT + i] = impl->g.TL_TAB [i] = 0; | ||
492 | } | ||
493 | else | ||
494 | { | ||
495 | // Decibel -> Voltage | ||
496 | #ifdef YM2612_CALCUL_TABLES | ||
497 | impl->g.TL_TAB [i] = (int) (MAX_OUT / pow( 10.0, ENV_STEP / 20.0f * i )); | ||
498 | #else | ||
499 | impl->g.TL_TAB [i] = tl_coeff [i]; | ||
500 | #endif | ||
501 | impl->g.TL_TAB [TL_LENGHT + i] = -impl->g.TL_TAB [i]; | ||
502 | } | ||
503 | } | ||
504 | #endif | ||
505 | |||
506 | // Tableau SIN : | ||
507 | // impl->g.SIN_TAB [x] [y] = sin(x) * y; | ||
508 | // x = phase and y = volume | ||
509 | |||
510 | impl->g.SIN_TAB [0] = impl->g.SIN_TAB [SIN_LENGHT / 2] = PG_CUT_OFF; | ||
511 | |||
512 | for ( i = 1; i <= SIN_LENGHT / 4; i++ ) | ||
513 | { | ||
514 | // Sinus in dB | ||
515 | #ifdef YM2612_CALCUL_TABLES | ||
516 | double x = 20 * log10( 1 / sin( 2.0 * PI * i / SIN_LENGHT ) ); // convert to dB | ||
517 | |||
518 | int j = (int) (x / ENV_STEP); // Get TL range | ||
519 | |||
520 | if (j > PG_CUT_OFF) j = (int) PG_CUT_OFF; | ||
521 | #else | ||
522 | int j = sindb_coeff [i-1]; | ||
523 | #endif | ||
524 | |||
525 | impl->g.SIN_TAB [i] = impl->g.SIN_TAB [(SIN_LENGHT / 2) - i] = j; | ||
526 | impl->g.SIN_TAB [(SIN_LENGHT / 2) + i] = impl->g.SIN_TAB [SIN_LENGHT - i] = TL_LENGHT + j; | ||
527 | } | ||
528 | |||
529 | #ifdef YM2612_CALCUL_TABLES | ||
530 | // Tableau LFO (LFO wav) : | ||
531 | for ( i = 0; i < LFO_LENGHT; i++ ) | ||
532 | { | ||
533 | double x = 1 + sin( 2.0 * PI * i * (1.0 / LFO_LENGHT) ); // Sinus | ||
534 | x *= 11.8 / ENV_STEP / 2; // ajusted to MAX enveloppe modulation | ||
535 | |||
536 | impl->g.LFO_ENV_TAB [i] = (int) x; | ||
537 | |||
538 | x = sin( 2.0 * PI * i * (1.0 / LFO_LENGHT) ); // Sinus | ||
539 | x *= (1 << (LFO_HBITS - 1)) - 1; | ||
540 | |||
541 | impl->g.LFO_FREQ_TAB [i] = (int) x; | ||
542 | } | ||
543 | #endif | ||
544 | |||
545 | // Tableau Enveloppe : | ||
546 | // impl->g.ENV_TAB [0] -> impl->g.ENV_TAB [ENV_LENGHT - 1] = attack curve | ||
547 | // impl->g.ENV_TAB [ENV_LENGHT] -> impl->g.ENV_TAB [2 * ENV_LENGHT - 1] = decay curve | ||
548 | |||
549 | for ( i = 0; i < ENV_LENGHT; i++ ) | ||
550 | { | ||
551 | // Attack curve (x^8 - music level 2 Vectorman 2) | ||
552 | #if defined(ROCKBOX) | ||
553 | int k; | ||
554 | int prescale = (31 - 2*ENV_HBITS); /* used to gain higher precision */ | ||
555 | int x = ENV_LENGHT * (1 << prescale); | ||
556 | for ( k = 0; k < 8; ++k) | ||
557 | { | ||
558 | x = ( x * ((ENV_LENGHT - 1) - i) ) / ENV_LENGHT; | ||
559 | } | ||
560 | x >>= prescale; | ||
561 | #else | ||
562 | double x = pow( ((ENV_LENGHT - 1) - i) / (double) ENV_LENGHT, 8.0 ); | ||
563 | x *= ENV_LENGHT; | ||
564 | #endif | ||
565 | |||
566 | impl->g.ENV_TAB [i] = (int) x; | ||
567 | |||
568 | // Decay curve (just linear) | ||
569 | impl->g.ENV_TAB [ENV_LENGHT + i] = i; | ||
570 | } | ||
571 | for ( i = 0; i < 8; i++ ) | ||
572 | impl->g.ENV_TAB [i + ENV_LENGHT * 2] = 0; | ||
573 | |||
574 | impl->g.ENV_TAB [ENV_END >> ENV_LBITS] = ENV_LENGHT - 1; // for the stopped state | ||
575 | |||
576 | // Tableau pour la conversion Attack -> Decay and Decay -> Attack | ||
577 | |||
578 | int j = ENV_LENGHT - 1; | ||
579 | for ( i = 0; i < ENV_LENGHT; i++ ) | ||
580 | { | ||
581 | while ( j && impl->g.ENV_TAB [j] < i ) | ||
582 | j--; | ||
583 | |||
584 | impl->g.DECAY_TO_ATTACK [i] = j << ENV_LBITS; | ||
585 | } | ||
586 | |||
587 | // Tableau pour le Substain Level | ||
588 | |||
589 | for ( i = 0; i < 15; i++ ) | ||
590 | { | ||
591 | int x = i * 3 * (int)( (1 << ENV_LBITS) / ENV_STEP); // 3 and not 6 (Mickey Mania first music for test) | ||
592 | |||
593 | impl->g.SL_TAB [i] = x + ENV_DECAY; | ||
594 | } | ||
595 | |||
596 | impl->g.SL_TAB [15] = ((ENV_LENGHT - 1) << ENV_LBITS) + ENV_DECAY; // special case : volume off | ||
597 | |||
598 | // Tableau Frequency Step | ||
599 | |||
600 | { | ||
601 | // * 1 / 2 because MUL = value * 2 | ||
602 | #if SIN_LBITS + SIN_HBITS - (21 - 7) < 0 | ||
603 | /* double const factor = Frequence / 2.0 / (1 << ((21 - 7) - SIN_LBITS - SIN_HBITS)); */ | ||
604 | int const factor = (int)(Frequency / 2 / (1 << ((21 - 7) - SIN_LBITS - SIN_HBITS)) / FP_ONE_CLOCK); | ||
605 | #else | ||
606 | /* double const factor = Frequence / 2.0 * (1 << (SIN_LBITS + SIN_HBITS - (21 - 7))); */ | ||
607 | int const factor = (int)(Frequency / 2 * (1 << (SIN_LBITS + SIN_HBITS - (21 - 7))) / FP_ONE_CLOCK); | ||
608 | #endif | ||
609 | for ( i = 0; i < 2048; i++ ) | ||
610 | { | ||
611 | impl->g.FINC_TAB [i] = i * factor; | ||
612 | } | ||
613 | } | ||
614 | |||
615 | // Tableaux Attack & Decay Rate | ||
616 | |||
617 | for ( i = 0; i < 4; i++ ) | ||
618 | { | ||
619 | impl->g.AR_TAB [i] = 0; | ||
620 | impl->g.DR_TAB [i] = 0; | ||
621 | } | ||
622 | |||
623 | for ( i = 0; i < 60; i++ ) | ||
624 | { | ||
625 | long long x = | ||
626 | (4LL + ((i & 3))) * // bits 0-1 : 4*(x1.00, x1.25, x1.50, x1.75) | ||
627 | (ENV_LENGHT << ENV_LBITS) * // on ajuste pour le tableau impl->g.ENV_TAB | ||
628 | Frequency * | ||
629 | (1 << (i >> 2)) / // bits 2-5 : shift bits (x2^0 - x2^15) | ||
630 | FP_ONE_CLOCK / 4; | ||
631 | |||
632 | long long x_AR = x / AR_RATE; | ||
633 | long long x_DR = x / DR_RATE; | ||
634 | |||
635 | impl->g.AR_TAB [i + 4] = (unsigned int) ( x_AR > ((1LL<<32) - 1) ? ((1LL<<32) - 1) : x_AR ); | ||
636 | impl->g.DR_TAB [i + 4] = (unsigned int) ( x_DR > ((1LL<<32) - 1) ? ((1LL<<32) - 1) : x_DR ); | ||
637 | } | ||
638 | |||
639 | for ( i = 64; i < 96; i++ ) | ||
640 | { | ||
641 | impl->g.AR_TAB [i] = impl->g.AR_TAB [63]; | ||
642 | impl->g.DR_TAB [i] = impl->g.DR_TAB [63]; | ||
643 | |||
644 | impl->g.NULL_RATE [i - 64] = 0; | ||
645 | } | ||
646 | |||
647 | for ( i = 96; i < 128; i++ ) | ||
648 | impl->g.AR_TAB [i] = 0; | ||
649 | |||
650 | // Tableau Detune | ||
651 | { | ||
652 | #if SIN_LBITS + SIN_HBITS - 21 < 0 | ||
653 | /* double const factor = 1.0 / (1 << (21 - SIN_LBITS - SIN_HBITS)) * Frequence; */ | ||
654 | int const factor = Frequency / (1 << (21 - SIN_LBITS - SIN_HBITS)) / FP_ONE_CLOCK; | ||
655 | #else | ||
656 | /* double const factor = (1 << (SIN_LBITS + SIN_HBITS - 21)) * Frequence; */ | ||
657 | int const factor = Frequency * (1 << (SIN_LBITS + SIN_HBITS - 21)) / FP_ONE_CLOCK; | ||
658 | #endif | ||
659 | for ( i = 0; i < 4; i++ ) | ||
660 | { | ||
661 | int j; | ||
662 | for ( j = 0; j < 32; j++ ) | ||
663 | { | ||
664 | /* double y = DT_DEF_TAB [(i << 5) + j] * factor; */ | ||
665 | int y = DT_DEF_TAB [(i << 5) + j] * factor; | ||
666 | |||
667 | impl->g.DT_TAB [i + 0] [j] = (int) y; | ||
668 | impl->g.DT_TAB [i + 4] [j] = (int) -y; | ||
669 | } | ||
670 | } | ||
671 | } | ||
672 | |||
673 | // Tableau LFO | ||
674 | impl->g.LFO_INC_TAB [0] = (int) (3.98 * (1 << (LFO_HBITS + LFO_LBITS))) / sample_rate; | ||
675 | impl->g.LFO_INC_TAB [1] = (int) (5.56 * (1 << (LFO_HBITS + LFO_LBITS))) / sample_rate; | ||
676 | impl->g.LFO_INC_TAB [2] = (int) (6.02 * (1 << (LFO_HBITS + LFO_LBITS))) / sample_rate; | ||
677 | impl->g.LFO_INC_TAB [3] = (int) (6.37 * (1 << (LFO_HBITS + LFO_LBITS))) / sample_rate; | ||
678 | impl->g.LFO_INC_TAB [4] = (int) (6.88 * (1 << (LFO_HBITS + LFO_LBITS))) / sample_rate; | ||
679 | impl->g.LFO_INC_TAB [5] = (int) (9.63 * (1 << (LFO_HBITS + LFO_LBITS))) / sample_rate; | ||
680 | impl->g.LFO_INC_TAB [6] = (int) (48.1 * (1 << (LFO_HBITS + LFO_LBITS))) / sample_rate; | ||
681 | impl->g.LFO_INC_TAB [7] = (int) (72.2 * (1 << (LFO_HBITS + LFO_LBITS))) / sample_rate; | ||
682 | |||
683 | impl_reset( impl ); | ||
684 | } | ||
685 | |||
686 | const char* Ym2612_set_rate( struct Ym2612_Emu* this, int sample_rate, int clock_rate ) | ||
687 | { | ||
688 | // Only set rates if necessary | ||
689 | #if defined(ROCKBOX) | ||
690 | static int last_sample_rate = 0, last_clock_rate = 0; | ||
691 | if (last_sample_rate == sample_rate && last_clock_rate == clock_rate) return 0; | ||
692 | #endif | ||
693 | memset( &this->impl.YM2612, 0, sizeof this->impl.YM2612 ); | ||
694 | impl_set_rate( &this->impl, sample_rate, clock_rate ); | ||
695 | |||
696 | return 0; | ||
697 | } | ||
698 | |||
699 | static inline void write0( struct Ym2612_Impl* impl, int opn_addr, int data ) | ||
700 | { | ||
701 | assert( (unsigned) data <= 0xFF ); | ||
702 | |||
703 | if ( opn_addr < 0x30 ) | ||
704 | { | ||
705 | impl->YM2612.REG [0] [opn_addr] = data; | ||
706 | YM_SET( impl, opn_addr, data ); | ||
707 | } | ||
708 | else if ( impl->YM2612.REG [0] [opn_addr] != data ) | ||
709 | { | ||
710 | impl->YM2612.REG [0] [opn_addr] = data; | ||
711 | |||
712 | if ( opn_addr < 0xA0 ) | ||
713 | SLOT_SET( impl, opn_addr, data ); | ||
714 | else | ||
715 | CHANNEL_SET( &impl->YM2612, opn_addr, data ); | ||
716 | } | ||
717 | } | ||
718 | |||
719 | static inline void write1( struct Ym2612_Impl* impl, int opn_addr, int data ) | ||
720 | { | ||
721 | assert( (unsigned) data <= 0xFF ); | ||
722 | |||
723 | if ( opn_addr >= 0x30 && impl->YM2612.REG [1] [opn_addr] != data ) | ||
724 | { | ||
725 | impl->YM2612.REG [1] [opn_addr] = data; | ||
726 | |||
727 | if ( opn_addr < 0xA0 ) | ||
728 | SLOT_SET( impl, opn_addr + 0x100, data ); | ||
729 | else | ||
730 | CHANNEL_SET( &impl->YM2612, opn_addr + 0x100, data ); | ||
731 | } | ||
732 | } | ||
733 | |||
734 | void impl_reset( struct Ym2612_Impl* impl ) | ||
735 | { | ||
736 | impl->g.LFOcnt = 0; | ||
737 | impl->YM2612.TimerA = 0; | ||
738 | impl->YM2612.TimerAL = 0; | ||
739 | impl->YM2612.TimerAcnt = 0; | ||
740 | impl->YM2612.TimerB = 0; | ||
741 | impl->YM2612.TimerBL = 0; | ||
742 | impl->YM2612.TimerBcnt = 0; | ||
743 | impl->YM2612.DAC = 0; | ||
744 | |||
745 | impl->YM2612.Status = 0; | ||
746 | |||
747 | int i; | ||
748 | for ( i = 0; i < ym2612_channel_count; i++ ) | ||
749 | { | ||
750 | struct channel_* ch = &impl->YM2612.CHANNEL [i]; | ||
751 | |||
752 | ch->LEFT = ~0; | ||
753 | ch->RIGHT = ~0; | ||
754 | ch->ALGO = 0; | ||
755 | ch->FB = 31; | ||
756 | ch->FMS = 0; | ||
757 | ch->AMS = 0; | ||
758 | |||
759 | int j; | ||
760 | for ( j = 0 ;j < 4 ; j++ ) | ||
761 | { | ||
762 | ch->S0_OUT [j] = 0; | ||
763 | ch->FNUM [j] = 0; | ||
764 | ch->FOCT [j] = 0; | ||
765 | ch->KC [j] = 0; | ||
766 | |||
767 | ch->SLOT [j].Fcnt = 0; | ||
768 | ch->SLOT [j].Finc = 0; | ||
769 | ch->SLOT [j].Ecnt = ENV_END; // Put it at the end of Decay phase... | ||
770 | ch->SLOT [j].Einc = 0; | ||
771 | ch->SLOT [j].Ecmp = 0; | ||
772 | ch->SLOT [j].Ecurp = RELEASE; | ||
773 | |||
774 | ch->SLOT [j].ChgEnM = 0; | ||
775 | } | ||
776 | } | ||
777 | |||
778 | for ( i = 0; i < 0x100; i++ ) | ||
779 | { | ||
780 | impl->YM2612.REG [0] [i] = -1; | ||
781 | impl->YM2612.REG [1] [i] = -1; | ||
782 | } | ||
783 | |||
784 | for ( i = 0xB6; i >= 0xB4; i-- ) | ||
785 | { | ||
786 | write0( impl, i, 0xC0 ); | ||
787 | write1( impl, i, 0xC0 ); | ||
788 | } | ||
789 | |||
790 | for ( i = 0xB2; i >= 0x22; i-- ) | ||
791 | { | ||
792 | write0( impl, i, 0 ); | ||
793 | write1( impl, i, 0 ); | ||
794 | } | ||
795 | |||
796 | write0( impl, 0x2A, 0x80 ); | ||
797 | } | ||
798 | |||
799 | void Ym2612_reset( struct Ym2612_Emu* this ) | ||
800 | { | ||
801 | impl_reset( &this->impl ); | ||
802 | } | ||
803 | |||
804 | void Ym2612_write0( struct Ym2612_Emu* this, int addr, int data ) | ||
805 | { | ||
806 | write0( &this->impl, addr, data ); | ||
807 | } | ||
808 | |||
809 | void Ym2612_write1( struct Ym2612_Emu* this, int addr, int data ) | ||
810 | { | ||
811 | write1( &this->impl, addr, data ); | ||
812 | } | ||
813 | |||
814 | void Ym2612_mute_voices( struct Ym2612_Emu* this, int mask ) { this->impl.mute_mask = mask; } | ||
815 | |||
816 | static void update_envelope_( struct slot_t* sl ) | ||
817 | { | ||
818 | switch ( sl->Ecurp ) | ||
819 | { | ||
820 | case 0: | ||
821 | // Env_Attack_Next | ||
822 | |||
823 | // Verified with Gynoug even in HQ (explode SFX) | ||
824 | sl->Ecnt = ENV_DECAY; | ||
825 | |||
826 | sl->Einc = sl->EincD; | ||
827 | sl->Ecmp = sl->SLL; | ||
828 | sl->Ecurp = DECAY; | ||
829 | break; | ||
830 | |||
831 | case 1: | ||
832 | // Env_Decay_Next | ||
833 | |||
834 | // Verified with Gynoug even in HQ (explode SFX) | ||
835 | sl->Ecnt = sl->SLL; | ||
836 | |||
837 | sl->Einc = sl->EincS; | ||
838 | sl->Ecmp = ENV_END; | ||
839 | sl->Ecurp = SUBSTAIN; | ||
840 | break; | ||
841 | |||
842 | case 2: | ||
843 | // Env_Substain_Next(slot_t *SL) | ||
844 | if (sl->SEG & 8) // SSG envelope type | ||
845 | { | ||
846 | int release = sl->SEG & 1; | ||
847 | |||
848 | if ( !release ) | ||
849 | { | ||
850 | // re KEY ON | ||
851 | |||
852 | // sl->Fcnt = 0; | ||
853 | // sl->ChgEnM = ~0; | ||
854 | |||
855 | sl->Ecnt = 0; | ||
856 | sl->Einc = sl->EincA; | ||
857 | sl->Ecmp = ENV_DECAY; | ||
858 | sl->Ecurp = ATTACK; | ||
859 | } | ||
860 | |||
861 | set_seg( sl, (sl->SEG << 1) & 4 ); | ||
862 | |||
863 | if ( !release ) | ||
864 | break; | ||
865 | } | ||
866 | // fall through | ||
867 | |||
868 | case 3: | ||
869 | // Env_Release_Next | ||
870 | sl->Ecnt = ENV_END; | ||
871 | sl->Einc = 0; | ||
872 | sl->Ecmp = ENV_END + 1; | ||
873 | break; | ||
874 | |||
875 | // default: no op | ||
876 | } | ||
877 | } | ||
878 | |||
879 | static inline void update_envelope( struct slot_t* sl ) | ||
880 | { | ||
881 | int ecmp = sl->Ecmp; | ||
882 | if ( (sl->Ecnt += sl->Einc) >= ecmp ) | ||
883 | update_envelope_( sl ); | ||
884 | } | ||
885 | |||
886 | |||
887 | typedef void (*ym2612_update_chan_t)( struct tables_t*, struct channel_*, short*, int ); | ||
888 | |||
889 | #define GET_CURRENT_PHASE \ | ||
890 | int in0 = ch->SLOT[S0].Fcnt; \ | ||
891 | int in1 = ch->SLOT[S1].Fcnt; \ | ||
892 | int in2 = ch->SLOT[S2].Fcnt; \ | ||
893 | int in3 = ch->SLOT[S3].Fcnt; \ | ||
894 | |||
895 | #define GET_CURRENT_LFO \ | ||
896 | int YM2612_LFOinc = g->LFOinc; \ | ||
897 | int YM2612_LFOcnt = g->LFOcnt + YM2612_LFOinc; | ||
898 | |||
899 | #define CALC_EN( x ) \ | ||
900 | int temp##x = ENV_TAB [ch->SLOT [S##x].Ecnt >> ENV_LBITS] + ch->SLOT [S##x].TLL; \ | ||
901 | int en##x = ((temp##x ^ ch->SLOT [S##x].env_xor) + (env_LFO >> ch->SLOT [S##x].AMS)) & \ | ||
902 | ((temp##x - ch->SLOT [S##x].env_max) >> 31); | ||
903 | |||
904 | #define GET_ENV \ | ||
905 | int const env_LFO = ENV_TAB_LOOKUP [YM2612_LFOcnt >> LFO_LBITS & LFO_MASK]; \ | ||
906 | short const* const ENV_TAB = g->ENV_TAB; \ | ||
907 | CALC_EN( 0 ) \ | ||
908 | CALC_EN( 1 ) \ | ||
909 | CALC_EN( 2 ) \ | ||
910 | CALC_EN( 3 ) | ||
911 | |||
912 | #ifndef YM2612_USE_TL_TAB | ||
913 | static inline int tl_level( int i ) | ||
914 | { | ||
915 | if (i >= (PG_CUT_OFF + TL_LENGHT)) { | ||
916 | return 0; | ||
917 | } else if (i >= TL_LENGHT) { | ||
918 | return -tl_coeff [i - TL_LENGHT]; | ||
919 | } else if (i >= PG_CUT_OFF) { | ||
920 | return 0; | ||
921 | } else | ||
922 | return tl_coeff [i]; | ||
923 | } | ||
924 | #define SINT( i, o ) (tl_level (g->SIN_TAB [(i)] + (o))) | ||
925 | #else | ||
926 | #define SINT( i, o ) (g->TL_TAB [g->SIN_TAB [(i)] + (o)]) | ||
927 | #endif | ||
928 | |||
929 | #define DO_FEEDBACK \ | ||
930 | int CH_S0_OUT_0 = ch->S0_OUT [0]; \ | ||
931 | { \ | ||
932 | int temp = in0 + ((CH_S0_OUT_0 + CH_S0_OUT_1) >> ch->FB); \ | ||
933 | CH_S0_OUT_1 = CH_S0_OUT_0; \ | ||
934 | CH_S0_OUT_0 = SINT( (temp >> SIN_LBITS) & SIN_MASK, en0 ); \ | ||
935 | } \ | ||
936 | |||
937 | #define DO_LIMIT \ | ||
938 | CH_OUTd >>= MAX_OUT_BITS - output_bits + 2; \ | ||
939 | |||
940 | #define UPDATE_PHASE_CYCLE \ | ||
941 | unsigned freq_LFO = ((FREQ_TAB_LOOKUP [YM2612_LFOcnt >> LFO_LBITS & LFO_MASK] * \ | ||
942 | ch->FMS) >> (LFO_HBITS - 1 + 1)) + (1 << (LFO_FMS_LBITS - 1)); \ | ||
943 | YM2612_LFOcnt += YM2612_LFOinc; \ | ||
944 | in0 += (ch->SLOT [S0].Finc * freq_LFO) >> (LFO_FMS_LBITS - 1); \ | ||
945 | in1 += (ch->SLOT [S1].Finc * freq_LFO) >> (LFO_FMS_LBITS - 1); \ | ||
946 | in2 += (ch->SLOT [S2].Finc * freq_LFO) >> (LFO_FMS_LBITS - 1); \ | ||
947 | in3 += (ch->SLOT [S3].Finc * freq_LFO) >> (LFO_FMS_LBITS - 1); | ||
948 | |||
949 | #define UPDATE_ENV \ | ||
950 | int t0 = buf [0] + (CH_OUTd & ch->LEFT); \ | ||
951 | int t1 = buf [1] + (CH_OUTd & ch->RIGHT); \ | ||
952 | update_envelope( &ch->SLOT [0] ); \ | ||
953 | update_envelope( &ch->SLOT [1] ); \ | ||
954 | update_envelope( &ch->SLOT [2] ); \ | ||
955 | update_envelope( &ch->SLOT [3] ); | ||
956 | |||
957 | #define DO_OUTPUT_0 \ | ||
958 | ch->S0_OUT [0] = CH_S0_OUT_0; \ | ||
959 | buf [0] = t0; \ | ||
960 | buf [1] = t1; \ | ||
961 | buf += 2; \ | ||
962 | |||
963 | #define DO_OUTPUT_1 \ | ||
964 | ch->S0_OUT [1] = CH_S0_OUT_1; | ||
965 | |||
966 | #define UPDATE_PHASE \ | ||
967 | ch->SLOT [S0].Fcnt = in0; \ | ||
968 | ch->SLOT [S1].Fcnt = in1; \ | ||
969 | ch->SLOT [S2].Fcnt = in2; \ | ||
970 | ch->SLOT [S3].Fcnt = in3; | ||
971 | |||
972 | static void ym2612_update_chan0( struct tables_t* g, struct channel_* ch, | ||
973 | short* buf, int length ) | ||
974 | { | ||
975 | int not_end = ch->SLOT [S3].Ecnt - ENV_END; | ||
976 | int CH_S0_OUT_1 = ch->S0_OUT [1]; | ||
977 | |||
978 | GET_CURRENT_PHASE | ||
979 | GET_CURRENT_LFO | ||
980 | |||
981 | if ( !not_end ) | ||
982 | return; | ||
983 | |||
984 | do | ||
985 | { | ||
986 | GET_ENV | ||
987 | DO_FEEDBACK | ||
988 | |||
989 | int CH_OUTd; | ||
990 | int temp = in1 + CH_S0_OUT_1; | ||
991 | temp = in2 + SINT( (temp >> SIN_LBITS) & SIN_MASK, en1 ); | ||
992 | temp = in3 + SINT( (temp >> SIN_LBITS) & SIN_MASK, en2 ); | ||
993 | CH_OUTd = SINT( (temp >> SIN_LBITS) & SIN_MASK, en3 ); | ||
994 | |||
995 | DO_LIMIT | ||
996 | UPDATE_PHASE_CYCLE | ||
997 | UPDATE_ENV | ||
998 | DO_OUTPUT_0 | ||
999 | } | ||
1000 | while ( --length ); | ||
1001 | DO_OUTPUT_1 | ||
1002 | UPDATE_PHASE | ||
1003 | } | ||
1004 | |||
1005 | static void ym2612_update_chan1( struct tables_t* g, struct channel_* ch, | ||
1006 | short* buf, int length ) | ||
1007 | { | ||
1008 | int not_end = ch->SLOT [S3].Ecnt - ENV_END; | ||
1009 | int CH_S0_OUT_1 = ch->S0_OUT [1]; | ||
1010 | |||
1011 | GET_CURRENT_PHASE | ||
1012 | GET_CURRENT_LFO | ||
1013 | |||
1014 | if ( !not_end ) | ||
1015 | return; | ||
1016 | |||
1017 | do | ||
1018 | { | ||
1019 | GET_ENV | ||
1020 | DO_FEEDBACK | ||
1021 | |||
1022 | int CH_OUTd; | ||
1023 | int temp = in2 + CH_S0_OUT_1 + SINT( (in1 >> SIN_LBITS) & SIN_MASK, en1 ); | ||
1024 | temp = in3 + SINT( (temp >> SIN_LBITS) & SIN_MASK, en2 ); | ||
1025 | CH_OUTd = SINT( (temp >> SIN_LBITS) & SIN_MASK, en3 ); | ||
1026 | |||
1027 | DO_LIMIT | ||
1028 | UPDATE_PHASE_CYCLE | ||
1029 | UPDATE_ENV | ||
1030 | DO_OUTPUT_0 | ||
1031 | } | ||
1032 | while ( --length ); | ||
1033 | DO_OUTPUT_1 | ||
1034 | UPDATE_PHASE | ||
1035 | } | ||
1036 | |||
1037 | static void ym2612_update_chan2( struct tables_t* g, struct channel_* ch, | ||
1038 | short* buf, int length ) | ||
1039 | { | ||
1040 | int not_end = ch->SLOT [S3].Ecnt - ENV_END; | ||
1041 | int CH_S0_OUT_1 = ch->S0_OUT [1]; | ||
1042 | |||
1043 | GET_CURRENT_PHASE | ||
1044 | GET_CURRENT_LFO | ||
1045 | |||
1046 | if ( !not_end ) | ||
1047 | return; | ||
1048 | |||
1049 | do | ||
1050 | { | ||
1051 | GET_ENV | ||
1052 | DO_FEEDBACK | ||
1053 | |||
1054 | int CH_OUTd; | ||
1055 | int temp = in2 + SINT( (in1 >> SIN_LBITS) & SIN_MASK, en1 ); | ||
1056 | temp = in3 + CH_S0_OUT_1 + SINT( (temp >> SIN_LBITS) & SIN_MASK, en2 ); | ||
1057 | CH_OUTd = SINT( (temp >> SIN_LBITS) & SIN_MASK, en3 ); | ||
1058 | |||
1059 | DO_LIMIT | ||
1060 | UPDATE_PHASE_CYCLE | ||
1061 | UPDATE_ENV | ||
1062 | DO_OUTPUT_0 | ||
1063 | } | ||
1064 | while ( --length ); | ||
1065 | DO_OUTPUT_1 | ||
1066 | UPDATE_PHASE | ||
1067 | } | ||
1068 | |||
1069 | static void ym2612_update_chan3( struct tables_t* g, struct channel_* ch, | ||
1070 | short* buf, int length ) | ||
1071 | { | ||
1072 | int not_end = ch->SLOT [S3].Ecnt - ENV_END; | ||
1073 | int CH_S0_OUT_1 = ch->S0_OUT [1]; | ||
1074 | |||
1075 | GET_CURRENT_PHASE | ||
1076 | GET_CURRENT_LFO | ||
1077 | |||
1078 | if ( !not_end ) | ||
1079 | return; | ||
1080 | |||
1081 | do | ||
1082 | { | ||
1083 | GET_ENV | ||
1084 | DO_FEEDBACK | ||
1085 | |||
1086 | int CH_OUTd; | ||
1087 | int temp = in1 + CH_S0_OUT_1; | ||
1088 | temp = in3 + SINT( (temp >> SIN_LBITS) & SIN_MASK, en1 ) + | ||
1089 | SINT( (in2 >> SIN_LBITS) & SIN_MASK, en2 ); | ||
1090 | CH_OUTd = SINT( (temp >> SIN_LBITS) & SIN_MASK, en3 ); | ||
1091 | |||
1092 | DO_LIMIT | ||
1093 | UPDATE_PHASE_CYCLE | ||
1094 | UPDATE_ENV | ||
1095 | DO_OUTPUT_0 | ||
1096 | } | ||
1097 | while ( --length ); | ||
1098 | DO_OUTPUT_1 | ||
1099 | UPDATE_PHASE | ||
1100 | } | ||
1101 | |||
1102 | static void ym2612_update_chan4( struct tables_t* g, struct channel_* ch, | ||
1103 | short* buf, int length ) | ||
1104 | { | ||
1105 | int not_end = ch->SLOT [S3].Ecnt - ENV_END; | ||
1106 | not_end |= ch->SLOT [S1].Ecnt - ENV_END; | ||
1107 | |||
1108 | int CH_S0_OUT_1 = ch->S0_OUT [1]; | ||
1109 | |||
1110 | GET_CURRENT_PHASE | ||
1111 | GET_CURRENT_LFO | ||
1112 | |||
1113 | if ( !not_end ) | ||
1114 | return; | ||
1115 | |||
1116 | do | ||
1117 | { | ||
1118 | GET_ENV | ||
1119 | DO_FEEDBACK | ||
1120 | |||
1121 | int CH_OUTd; | ||
1122 | int temp = in3 + SINT( (in2 >> SIN_LBITS) & SIN_MASK, en2 ); | ||
1123 | CH_OUTd = SINT( (temp >> SIN_LBITS) & SIN_MASK, en3 ) + | ||
1124 | SINT( ((in1 + CH_S0_OUT_1) >> SIN_LBITS) & SIN_MASK, en1 ); | ||
1125 | |||
1126 | DO_LIMIT | ||
1127 | UPDATE_PHASE_CYCLE | ||
1128 | UPDATE_ENV | ||
1129 | DO_OUTPUT_0 | ||
1130 | } | ||
1131 | while ( --length ); | ||
1132 | DO_OUTPUT_1 | ||
1133 | UPDATE_PHASE | ||
1134 | } | ||
1135 | |||
1136 | static void ym2612_update_chan5( struct tables_t* g, struct channel_* ch, | ||
1137 | short* buf, int length ) | ||
1138 | { | ||
1139 | int not_end = ch->SLOT [S3].Ecnt - ENV_END; | ||
1140 | not_end |= ch->SLOT [S2].Ecnt - ENV_END; | ||
1141 | not_end |= ch->SLOT [S1].Ecnt - ENV_END; | ||
1142 | |||
1143 | int CH_S0_OUT_1 = ch->S0_OUT [1]; | ||
1144 | |||
1145 | GET_CURRENT_PHASE | ||
1146 | GET_CURRENT_LFO | ||
1147 | |||
1148 | if ( !not_end ) | ||
1149 | return; | ||
1150 | |||
1151 | do | ||
1152 | { | ||
1153 | GET_ENV | ||
1154 | DO_FEEDBACK | ||
1155 | |||
1156 | int CH_OUTd; | ||
1157 | int temp = CH_S0_OUT_1; | ||
1158 | CH_OUTd = SINT( ((in3 + temp) >> SIN_LBITS) & SIN_MASK, en3 ) + | ||
1159 | SINT( ((in1 + temp) >> SIN_LBITS) & SIN_MASK, en1 ) + | ||
1160 | SINT( ((in2 + temp) >> SIN_LBITS) & SIN_MASK, en2 ); | ||
1161 | |||
1162 | DO_LIMIT | ||
1163 | UPDATE_PHASE_CYCLE | ||
1164 | UPDATE_ENV | ||
1165 | DO_OUTPUT_0 | ||
1166 | } | ||
1167 | while ( --length ); | ||
1168 | DO_OUTPUT_1 | ||
1169 | UPDATE_PHASE | ||
1170 | } | ||
1171 | |||
1172 | static void ym2612_update_chan6( struct tables_t* g, struct channel_* ch, | ||
1173 | short* buf, int length ) | ||
1174 | { | ||
1175 | int not_end = ch->SLOT [S3].Ecnt - ENV_END; | ||
1176 | not_end |= ch->SLOT [S2].Ecnt - ENV_END; | ||
1177 | not_end |= ch->SLOT [S1].Ecnt - ENV_END; | ||
1178 | |||
1179 | int CH_S0_OUT_1 = ch->S0_OUT [1]; | ||
1180 | |||
1181 | GET_CURRENT_PHASE | ||
1182 | GET_CURRENT_LFO | ||
1183 | |||
1184 | if ( !not_end ) | ||
1185 | return; | ||
1186 | |||
1187 | do | ||
1188 | { | ||
1189 | GET_ENV | ||
1190 | DO_FEEDBACK | ||
1191 | |||
1192 | int CH_OUTd; | ||
1193 | CH_OUTd = SINT( (in3 >> SIN_LBITS) & SIN_MASK, en3 ) + | ||
1194 | SINT( ((in1 + CH_S0_OUT_1) >> SIN_LBITS) & SIN_MASK, en1 ) + | ||
1195 | SINT( (in2 >> SIN_LBITS) & SIN_MASK, en2 ); | ||
1196 | |||
1197 | DO_LIMIT | ||
1198 | UPDATE_PHASE_CYCLE | ||
1199 | UPDATE_ENV | ||
1200 | DO_OUTPUT_0 | ||
1201 | } | ||
1202 | while ( --length ); | ||
1203 | DO_OUTPUT_1 | ||
1204 | UPDATE_PHASE | ||
1205 | } | ||
1206 | |||
1207 | static void ym2612_update_chan7( struct tables_t* g, struct channel_* ch, | ||
1208 | short* buf, int length ) | ||
1209 | { | ||
1210 | int not_end = ch->SLOT [S3].Ecnt - ENV_END; | ||
1211 | not_end |= ch->SLOT [S0].Ecnt - ENV_END; | ||
1212 | not_end |= ch->SLOT [S2].Ecnt - ENV_END; | ||
1213 | not_end |= ch->SLOT [S1].Ecnt - ENV_END; | ||
1214 | |||
1215 | int CH_S0_OUT_1 = ch->S0_OUT [1]; | ||
1216 | |||
1217 | GET_CURRENT_PHASE | ||
1218 | GET_CURRENT_LFO | ||
1219 | |||
1220 | if ( !not_end ) | ||
1221 | return; | ||
1222 | |||
1223 | do | ||
1224 | { | ||
1225 | GET_ENV | ||
1226 | DO_FEEDBACK | ||
1227 | |||
1228 | int CH_OUTd; | ||
1229 | CH_OUTd = SINT( (in3 >> SIN_LBITS) & SIN_MASK, en3 ) + | ||
1230 | SINT( (in1 >> SIN_LBITS) & SIN_MASK, en1 ) + | ||
1231 | SINT( (in2 >> SIN_LBITS) & SIN_MASK, en2 ) + CH_S0_OUT_1; | ||
1232 | |||
1233 | DO_LIMIT | ||
1234 | UPDATE_PHASE_CYCLE | ||
1235 | UPDATE_ENV | ||
1236 | DO_OUTPUT_0 | ||
1237 | } | ||
1238 | while ( --length ); | ||
1239 | DO_OUTPUT_1 | ||
1240 | UPDATE_PHASE | ||
1241 | } | ||
1242 | |||
1243 | static void (*UPDATE_CHAN[8])(struct tables_t* g, struct channel_* ch, | ||
1244 | short* buf, int length) = | ||
1245 | { | ||
1246 | (void *)ym2612_update_chan0, | ||
1247 | (void *)ym2612_update_chan1, | ||
1248 | (void *)ym2612_update_chan2, | ||
1249 | (void *)ym2612_update_chan3, | ||
1250 | (void *)ym2612_update_chan4, | ||
1251 | (void *)ym2612_update_chan5, | ||
1252 | (void *)ym2612_update_chan6, | ||
1253 | (void *)ym2612_update_chan7 | ||
1254 | }; | ||
1255 | |||
1256 | static void run_timer( struct Ym2612_Impl* impl, int length ) | ||
1257 | { | ||
1258 | int const step = 6; | ||
1259 | int remain = length; | ||
1260 | do | ||
1261 | { | ||
1262 | int n = step; | ||
1263 | if ( n > remain ) | ||
1264 | n = remain; | ||
1265 | remain -= n; | ||
1266 | |||
1267 | int i = n * impl->YM2612.TimerBase; | ||
1268 | if (impl->YM2612.Mode & 1) // Timer A ON ? | ||
1269 | { | ||
1270 | // if ((impl->YM2612.TimerAcnt -= 14073) <= 0) // 13879=NTSC (old: 14475=NTSC 14586=PAL) | ||
1271 | if ((impl->YM2612.TimerAcnt -= i) <= 0) | ||
1272 | { | ||
1273 | // timer a overflow | ||
1274 | |||
1275 | impl->YM2612.Status |= (impl->YM2612.Mode & 0x04) >> 2; | ||
1276 | impl->YM2612.TimerAcnt += impl->YM2612.TimerAL; | ||
1277 | |||
1278 | if (impl->YM2612.Mode & 0x80) | ||
1279 | { | ||
1280 | KEY_ON( &impl->YM2612.CHANNEL [2], &impl->g, 0 ); | ||
1281 | KEY_ON( &impl->YM2612.CHANNEL [2], &impl->g, 1 ); | ||
1282 | KEY_ON( &impl->YM2612.CHANNEL [2], &impl->g, 2 ); | ||
1283 | KEY_ON( &impl->YM2612.CHANNEL [2], &impl->g, 3 ); | ||
1284 | } | ||
1285 | } | ||
1286 | } | ||
1287 | |||
1288 | if (impl->YM2612.Mode & 2) // Timer B ON ? | ||
1289 | { | ||
1290 | // if ((impl->YM2612.TimerBcnt -= 14073) <= 0) // 13879=NTSC (old: 14475=NTSC 14586=PAL) | ||
1291 | if ((impl->YM2612.TimerBcnt -= i) <= 0) | ||
1292 | { | ||
1293 | // timer b overflow | ||
1294 | impl->YM2612.Status |= (impl->YM2612.Mode & 0x08) >> 2; | ||
1295 | impl->YM2612.TimerBcnt += impl->YM2612.TimerBL; | ||
1296 | } | ||
1297 | } | ||
1298 | } | ||
1299 | while ( remain > 0 ); | ||
1300 | } | ||
1301 | |||
1302 | static void impl_run( struct Ym2612_Impl* impl, int pair_count, short out [] ) | ||
1303 | { | ||
1304 | if ( pair_count <= 0 ) | ||
1305 | return; | ||
1306 | |||
1307 | if ( impl->YM2612.Mode & 3 ) | ||
1308 | run_timer( impl, pair_count ); | ||
1309 | |||
1310 | // Mise à jour des pas des compteurs-frequences s'ils ont ete modifies | ||
1311 | |||
1312 | int chi; | ||
1313 | for ( chi = 0; chi < ym2612_channel_count; chi++ ) | ||
1314 | { | ||
1315 | struct channel_* ch = &impl->YM2612.CHANNEL [chi]; | ||
1316 | if ( ch->SLOT [0].Finc != -1 ) | ||
1317 | continue; | ||
1318 | |||
1319 | int i2 = 0; | ||
1320 | if ( chi == 2 && (impl->YM2612.Mode & 0x40) ) | ||
1321 | i2 = 2; | ||
1322 | |||
1323 | int i; | ||
1324 | for ( i = 0; i < 4; i++ ) | ||
1325 | { | ||
1326 | // static int seq [4] = { 2, 1, 3, 0 }; | ||
1327 | // if ( i2 ) i2 = seq [i]; | ||
1328 | |||
1329 | struct slot_t* sl = &ch->SLOT [i]; | ||
1330 | int finc = impl->g.FINC_TAB [ch->FNUM [i2]] >> (7 - ch->FOCT [i2]); | ||
1331 | int ksr = ch->KC [i2] >> sl->KSR_S; // keycode attenuation | ||
1332 | sl->Finc = (finc + sl->DT [ch->KC [i2]]) * sl->MUL; | ||
1333 | if (sl->KSR != ksr) // si le KSR a change alors | ||
1334 | { // les differents taux pour l'enveloppe sont mis à jour | ||
1335 | sl->KSR = ksr; | ||
1336 | |||
1337 | sl->EincA = sl->AR [ksr]; | ||
1338 | sl->EincD = sl->DR [ksr]; | ||
1339 | sl->EincS = sl->SR [ksr]; | ||
1340 | sl->EincR = sl->RR [ksr]; | ||
1341 | |||
1342 | if (sl->Ecurp == ATTACK) | ||
1343 | { | ||
1344 | sl->Einc = sl->EincA; | ||
1345 | } | ||
1346 | else if (sl->Ecurp == DECAY) | ||
1347 | { | ||
1348 | sl->Einc = sl->EincD; | ||
1349 | } | ||
1350 | else if (sl->Ecnt < ENV_END) | ||
1351 | { | ||
1352 | if (sl->Ecurp == SUBSTAIN) | ||
1353 | sl->Einc = sl->EincS; | ||
1354 | else if (sl->Ecurp == RELEASE) | ||
1355 | sl->Einc = sl->EincR; | ||
1356 | } | ||
1357 | } | ||
1358 | |||
1359 | if ( i2 ) | ||
1360 | i2 = (i2 ^ 2) ^ (i2 >> 1); | ||
1361 | } | ||
1362 | } | ||
1363 | |||
1364 | int i; | ||
1365 | for ( i = 0; i < ym2612_channel_count; i++ ) | ||
1366 | { | ||
1367 | if ( !(impl->mute_mask & (1 << i)) && (i != 5 || !impl->YM2612.DAC) ) | ||
1368 | UPDATE_CHAN [impl->YM2612.CHANNEL [i].ALGO]( &impl->g, &impl->YM2612.CHANNEL [i], out, pair_count ); | ||
1369 | } | ||
1370 | |||
1371 | impl->g.LFOcnt += impl->g.LFOinc * pair_count; | ||
1372 | } | ||
1373 | |||
1374 | void Ym2612_run( struct Ym2612_Emu* this, int pair_count, short out [] ) { impl_run( &this->impl, pair_count, out ); } | ||