Mercurial > vba-clojure

comparison src/gb/gbSound.cpp @ 1:f9f4f1b99eed

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
importing src directory
author Robert McIntyre <rlm@mit.edu>
date Sat, 03 Mar 2012 10:31:27 -0600
parents
children 7ef5c73ea8fa
comparison
equal deleted inserted replaced
0:8ced16adf2e1 1:f9f4f1b99eed
1 #ifdef WIN32
2 # include "../win32/stdafx.h"
3 # include "../win32/VBA.h"
4 #endif
5
6 #include <cstring>
7 #include <cassert>
8
9 #include "../common/System.h"
10 #include "../common/Util.h"
11 //#include "../Blip_Buffer.h"
12 #include "gbGlobals.h"
13 #include "gbSound.h"
14
15 #ifndef countof
16 #define countof(a) (sizeof(a) / sizeof(a[0]))
17 #endif
18
19 extern u8 soundBuffer[6][735];
20 extern u16 soundFinalWave[1470];
21 extern u16 soundFrameSound[735 * 30 * 2];
22 extern int32 soundVolume;
23
24 soundtick_t GB_USE_TICKS_AS = 24; // (1048576.0/44100.0); // FIXME: (4194304.0/70224.0)(fps) vs 60.0fps?
25
26 #define SOUND_MAGIC 0x60000000
27 #define SOUND_MAGIC_2 0x30000000
28 #define NOISE_MAGIC (2097152.0 / 44100.0)
29
30 extern int32 speed;
31
32 extern u8 soundWavePattern[4][32];
33
34 extern u32 soundBufferLen;
35 extern u32 soundBufferTotalLen;
36 extern int32 soundQuality;
37 extern int32 soundPaused;
38 extern int32 soundPlay;
39 extern soundtick_t soundTicks;
40 extern soundtick_t SOUND_CLOCK_TICKS;
41 extern u32 soundNextPosition;
42
43 extern int32 soundLevel1;
44 extern int32 soundLevel2;
45 extern int32 soundBalance;
46 extern int32 soundMasterOn;
47 extern u32 soundIndex;
48 extern u32 soundBufferIndex;
49 extern int32 soundFrameSoundWritten;
50 int32 soundVIN = 0;
51 extern int32 soundDebug;
52
53 extern int32 sound1On;
54 extern int32 sound1ATL;
55 extern int32 sound1Skip;
56 extern int32 sound1Index;
57 extern int32 sound1Continue;
58 extern int32 sound1EnvelopeVolume;
59 extern int32 sound1EnvelopeATL;
60 extern int32 sound1EnvelopeUpDown;
61 extern int32 sound1EnvelopeATLReload;
62 extern int32 sound1SweepATL;
63 extern int32 sound1SweepATLReload;
64 extern int32 sound1SweepSteps;
65 extern int32 sound1SweepUpDown;
66 extern int32 sound1SweepStep;
67 extern u8 * sound1Wave;
68
69 extern int32 sound2On;
70 extern int32 sound2ATL;
71 extern int32 sound2Skip;
72 extern int32 sound2Index;
73 extern int32 sound2Continue;
74 extern int32 sound2EnvelopeVolume;
75 extern int32 sound2EnvelopeATL;
76 extern int32 sound2EnvelopeUpDown;
77 extern int32 sound2EnvelopeATLReload;
78 extern u8 * sound2Wave;
79
80 extern int32 sound3On;
81 extern int32 sound3ATL;
82 extern int32 sound3Skip;
83 extern int32 sound3Index;
84 extern int32 sound3Continue;
85 extern int32 sound3OutputLevel;
86 extern int32 sound3Last;
87
88 extern int32 sound4On;
89 extern int32 sound4Clock;
90 extern int32 sound4ATL;
91 extern int32 sound4Skip;
92 extern int32 sound4Index;
93 extern int32 sound4ShiftRight;
94 extern int32 sound4ShiftSkip;
95 extern int32 sound4ShiftIndex;
96 extern int32 sound4NSteps;
97 extern int32 sound4CountDown;
98 extern int32 sound4Continue;
99 extern int32 sound4EnvelopeVolume;
100 extern int32 sound4EnvelopeATL;
101 extern int32 sound4EnvelopeUpDown;
102 extern int32 sound4EnvelopeATLReload;
103
104 extern int32 soundEnableFlag;
105 extern int32 soundMutedFlag;
106
107 extern int32 soundFreqRatio[8];
108 extern int32 soundShiftClock[16];
109
110 extern s16 soundFilter[4000];
111 extern s16 soundLeft[5];
112 extern s16 soundRight[5];
113 extern int32 soundEchoIndex;
114 extern bool8 soundEcho;
115 extern bool8 soundLowPass;
116 extern bool8 soundReverse;
117 extern bool8 soundOffFlag;
118
119 bool8 gbDigitalSound = false;
120
121 void gbSoundEvent(register u16 address, register int data)
122 {
123 int freq = 0;
124
125 gbMemory[address] = data;
126
127 #ifndef FINAL_VERSION
128 if (soundDebug)
129 {
130 // don't translate. debug only
131 log("Sound event: %08lx %02x\n", address, data);
132 }
133 #endif
134 switch (address)
135 {
136 case NR10:
137 sound1SweepATL = sound1SweepATLReload = 344 * ((data >> 4) & 7);
138 sound1SweepSteps = data & 7;
139 sound1SweepUpDown = data & 0x08;
140 sound1SweepStep = 0;
141 break;
142 case NR11:
143 sound1Wave = soundWavePattern[data >> 6];
144 sound1ATL = 172 * (64 - (data & 0x3f));
145 break;
146 case NR12:
147 sound1EnvelopeVolume = data >> 4;
148 sound1EnvelopeUpDown = data & 0x08;
149 sound1EnvelopeATLReload = sound1EnvelopeATL = 689 * (data & 7);
150 break;
151 case NR13:
152 freq = (((int)(gbMemory[NR14] & 7)) << 8) | data;
153 sound1ATL = 172 * (64 - (gbMemory[NR11] & 0x3f));
154 freq = 2048 - freq;
155 if (freq)
156 {
157 sound1Skip = SOUND_MAGIC / freq;
158 }
159 else
160 sound1Skip = 0;
161 break;
162 case NR14:
163 freq = (((int)(data & 7) << 8) | gbMemory[NR13]);
164 freq = 2048 - freq;
165 sound1ATL = 172 * (64 - (gbMemory[NR11] & 0x3f));
166 sound1Continue = data & 0x40;
167 if (freq)
168 {
169 sound1Skip = SOUND_MAGIC / freq;
170 }
171 else
172 sound1Skip = 0;
173 if (data & 0x80)
174 {
175 gbMemory[NR52] |= 1;
176 sound1EnvelopeVolume = gbMemory[NR12] >> 4;
177 sound1EnvelopeUpDown = gbMemory[NR12] & 0x08;
178 sound1ATL = 172 * (64 - (gbMemory[NR11] & 0x3f));
179 sound1EnvelopeATLReload = sound1EnvelopeATL = 689 * (gbMemory[NR12] & 7);
180 sound1SweepATL = sound1SweepATLReload = 344 * ((gbMemory[NR10] >> 4) & 7);
181 sound1SweepSteps = gbMemory[NR10] & 7;
182 sound1SweepUpDown = gbMemory[NR10] & 0x08;
183 sound1SweepStep = 0;
184
185 sound1Index = 0;
186 sound1On = 1;
187 }
188 break;
189 case NR21:
190 sound2Wave = soundWavePattern[data >> 6];
191 sound2ATL = 172 * (64 - (data & 0x3f));
192 break;
193 case NR22:
194 sound2EnvelopeVolume = data >> 4;
195 sound2EnvelopeUpDown = data & 0x08;
196 sound2EnvelopeATLReload = sound2EnvelopeATL = 689 * (data & 7);
197 break;
198 case NR23:
199 freq = (((int)(gbMemory[NR24] & 7)) << 8) | data;
200 sound2ATL = 172 * (64 - (gbMemory[NR21] & 0x3f));
201 freq = 2048 - freq;
202 if (freq)
203 {
204 sound2Skip = SOUND_MAGIC / freq;
205 }
206 else
207 sound2Skip = 0;
208 break;
209 case NR24:
210 freq = (((int)(data & 7) << 8) | gbMemory[NR23]);
211 freq = 2048 - freq;
212 sound2ATL = 172 * (64 - (gbMemory[NR21] & 0x3f));
213 sound2Continue = data & 0x40;
214 if (freq)
215 {
216 sound2Skip = SOUND_MAGIC / freq;
217 }
218 else
219 sound2Skip = 0;
220 if (data & 0x80)
221 {
222 gbMemory[NR52] |= 2;
223 sound2EnvelopeVolume = gbMemory[NR22] >> 4;
224 sound2EnvelopeUpDown = gbMemory[NR22] & 0x08;
225 sound2ATL = 172 * (64 - (gbMemory[NR21] & 0x3f));
226 sound2EnvelopeATLReload = sound2EnvelopeATL = 689 * (gbMemory[NR22] & 7);
227
228 sound2Index = 0;
229 sound2On = 1;
230 }
231 break;
232 case NR30:
233 if (!(data & 0x80))
234 {
235 gbMemory[NR52] &= 0xfb;
236 sound3On = 0;
237 }
238 break;
239 case NR31:
240 sound3ATL = 172 * (256 - data);
241 break;
242 case NR32:
243 sound3OutputLevel = (data >> 5) & 3;
244 break;
245 case NR33:
246 freq = 2048 - (((int)(gbMemory[NR34] & 7) << 8) | data);
247 if (freq)
248 {
249 sound3Skip = SOUND_MAGIC_2 / freq;
250 }
251 else
252 sound3Skip = 0;
253 break;
254 case NR34:
255 freq = 2048 - (((data & 7) << 8) | (int)gbMemory[NR33]);
256 if (freq)
257 {
258 sound3Skip = SOUND_MAGIC_2 / freq;
259 }
260 else
261 {
262 sound3Skip = 0;
263 }
264 sound3Continue = data & 0x40;
265 if ((data & 0x80) && (gbMemory[NR30] & 0x80))
266 {
267 gbMemory[NR52] |= 4;
268 sound3ATL = 172 * (256 - gbMemory[NR31]);
269 sound3Index = 0;
270 sound3On = 1;
271 }
272 break;
273 case NR41:
274 sound4ATL = 172 * (64 - (data & 0x3f));
275 break;
276 case NR42:
277 sound4EnvelopeVolume = data >> 4;
278 sound4EnvelopeUpDown = data & 0x08;
279 sound4EnvelopeATLReload = sound4EnvelopeATL = 689 * (data & 7);
280 break;
281 case NR43:
282 freq = soundFreqRatio[data & 7];
283 sound4NSteps = data & 0x08;
284
285 sound4Skip = freq * NOISE_MAGIC;
286
287 sound4Clock = data >> 4;
288
289 freq = freq / soundShiftClock[sound4Clock];
290
291 sound4ShiftSkip = freq * NOISE_MAGIC;
292
293 break;
294 case NR44:
295 sound4Continue = data & 0x40;
296 if (data & 0x80)
297 {
298 gbMemory[NR52] |= 8;
299 sound4EnvelopeVolume = gbMemory[NR42] >> 4;
300 sound4EnvelopeUpDown = gbMemory[NR42] & 0x08;
301 sound4ATL = 172 * (64 - (gbMemory[NR41] & 0x3f));
302 sound4EnvelopeATLReload = sound4EnvelopeATL = 689 * (gbMemory[NR42] & 7);
303
304 sound4On = 1;
305
306 sound4Index = 0;
307 sound4ShiftIndex = 0;
308
309 freq = soundFreqRatio[gbMemory[NR43] & 7];
310
311 sound4Skip = freq * NOISE_MAGIC;
312
313 sound4NSteps = gbMemory[NR43] & 0x08;
314
315 freq = freq / soundShiftClock[gbMemory[NR43] >> 4];
316
317 sound4ShiftSkip = freq * NOISE_MAGIC;
318 if (sound4NSteps)
319 sound4ShiftRight = 0x7f;
320 else
321 sound4ShiftRight = 0x7fff;
322 }
323 break;
324 case NR50:
325 soundVIN = data & 0x88;
326 soundLevel1 = data & 7;
327 soundLevel2 = (data >> 4) & 7;
328 break;
329 case NR51:
330 soundBalance = (data & soundEnableFlag);
331 gbMemory[address] = data;
332 break;
333 case NR52:
334 soundMasterOn = data & 0x80;
335 if (!(data & 0x80))
336 {
337 sound1On = 0;
338 sound2On = 0;
339 sound3On = 0;
340 sound4On = 0;
341 }
342 break;
343 }
344
345 gbDigitalSound = true;
346
347 if (sound1On && sound1EnvelopeVolume != 0)
348 gbDigitalSound = false;
349 if (sound2On && sound2EnvelopeVolume != 0)
350 gbDigitalSound = false;
351 if (sound3On && sound3OutputLevel != 0)
352 gbDigitalSound = false;
353 if (sound4On && sound4EnvelopeVolume != 0)
354 gbDigitalSound = false;
355 }
356
357 void gbSoundChannel1()
358 {
359 int vol = sound1EnvelopeVolume;
360
361 int freq = 0;
362
363 int value = 0;
364
365 if (sound1On && (sound1ATL || !sound1Continue))
366 {
367 sound1Index += soundQuality * sound1Skip;
368 sound1Index &= 0x1fffffff;
369
370 value = ((s8)sound1Wave[sound1Index >> 24]) * vol;
371 }
372
373 soundBuffer[0][soundIndex] = value;
374
375 if (sound1On)
376 {
377 if (sound1ATL)
378 {
379 sound1ATL -= soundQuality;
380
381 if (sound1ATL <= 0 && sound1Continue)
382 {
383 gbMemory[NR52] &= 0xfe;
384 sound1On = 0;
385 }
386 }
387
388 if (sound1EnvelopeATL)
389 {
390 sound1EnvelopeATL -= soundQuality;
391
392 if (sound1EnvelopeATL <= 0)
393 {
394 if (sound1EnvelopeUpDown)
395 {
396 if (sound1EnvelopeVolume < 15)
397 sound1EnvelopeVolume++;
398 }
399 else
400 {
401 if (sound1EnvelopeVolume)
402 sound1EnvelopeVolume--;
403 }
404
405 sound1EnvelopeATL += sound1EnvelopeATLReload;
406 }
407 }
408
409 if (sound1SweepATL)
410 {
411 sound1SweepATL -= soundQuality;
412
413 if (sound1SweepATL <= 0)
414 {
415 freq = (((int)(gbMemory[NR14] & 7) << 8) | gbMemory[NR13]);
416
417 int updown = 1;
418
419 if (sound1SweepUpDown)
420 updown = -1;
421
422 int newfreq = 0;
423 if (sound1SweepSteps)
424 {
425 newfreq = freq + updown * freq / (1 << sound1SweepSteps);
426 if (newfreq == freq)
427 newfreq = 0;
428 }
429 else
430 newfreq = freq;
431
432 if (newfreq < 0)
433 {
434 sound1SweepATL += sound1SweepATLReload;
435 }
436 else if (newfreq > 2047)
437 {
438 sound1SweepATL = 0;
439 sound1On = 0;
440 gbMemory[NR52] &= 0xfe;
441 }
442 else
443 {
444 sound1SweepATL += sound1SweepATLReload;
445 sound1Skip = SOUND_MAGIC / (2048 - newfreq);
446
447 gbMemory[NR13] = newfreq & 0xff;
448 gbMemory[NR14] = (gbMemory[NR14] & 0xf8) | ((newfreq >> 8) & 7);
449 }
450 }
451 }
452 }
453 }
454
455 void gbSoundChannel2()
456 {
457 // int freq = 0;
458 int vol = sound2EnvelopeVolume;
459
460 int value = 0;
461
462 if (sound2On && (sound2ATL || !sound2Continue))
463 {
464 sound2Index += soundQuality * sound2Skip;
465 sound2Index &= 0x1fffffff;
466
467 value = ((s8)sound2Wave[sound2Index >> 24]) * vol;
468 }
469
470 soundBuffer[1][soundIndex] = value;
471
472 if (sound2On)
473 {
474 if (sound2ATL)
475 {
476 sound2ATL -= soundQuality;
477
478 if (sound2ATL <= 0 && sound2Continue)
479 {
480 gbMemory[NR52] &= 0xfd;
481 sound2On = 0;
482 }
483 }
484
485 if (sound2EnvelopeATL)
486 {
487 sound2EnvelopeATL -= soundQuality;
488
489 if (sound2EnvelopeATL <= 0)
490 {
491 if (sound2EnvelopeUpDown)
492 {
493 if (sound2EnvelopeVolume < 15)
494 sound2EnvelopeVolume++;
495 }
496 else
497 {
498 if (sound2EnvelopeVolume)
499 sound2EnvelopeVolume--;
500 }
501 sound2EnvelopeATL += sound2EnvelopeATLReload;
502 }
503 }
504 }
505 }
506
507 void gbSoundChannel3()
508 {
509 int value = sound3Last;
510
511 if (sound3On && (sound3ATL || !sound3Continue))
512 {
513 sound3Index += soundQuality * sound3Skip;
514 sound3Index &= 0x1fffffff;
515
516 value = gbMemory[0xff30 + (sound3Index >> 25)];
517
518 if ((sound3Index & 0x01000000))
519 {
520 value &= 0x0f;
521 }
522 else
523 {
524 value >>= 4;
525 }
526
527 value -= 8;
528 value *= 2;
529
530 switch (sound3OutputLevel)
531 {
532 case 0:
533 value = 0;
534 break;
535 case 1:
536 break;
537 case 2:
538 value = (value >> 1);
539 break;
540 case 3:
541 value = (value >> 2);
542 break;
543 }
544 //value += 1;
545 sound3Last = value;
546 }
547
548 soundBuffer[2][soundIndex] = value;
549
550 if (sound3On)
551 {
552 if (sound3ATL)
553 {
554 sound3ATL -= soundQuality;
555
556 if (sound3ATL <= 0 && sound3Continue)
557 {
558 gbMemory[NR52] &= 0xfb;
559 sound3On = 0;
560 }
561 }
562 }
563 }
564
565 void gbSoundChannel4()
566 {
567 int vol = sound4EnvelopeVolume;
568
569 int value = 0;
570
571 if (sound4Clock <= 0x0c)
572 {
573 if (sound4On && (sound4ATL || !sound4Continue))
574 {
575 #define NOISE_ONE_SAMP_SCALE 0x200000
576
577 sound4Index += soundQuality * sound4Skip;
578 sound4ShiftIndex += soundQuality * sound4ShiftSkip;
579
580 if (sound4NSteps)
581 {
582 while (sound4ShiftIndex >= NOISE_ONE_SAMP_SCALE)
583 {
584 sound4ShiftRight = (((sound4ShiftRight << 6) ^
585 (sound4ShiftRight << 5)) & 0x40) |
586 (sound4ShiftRight >> 1);
587 sound4ShiftIndex -= NOISE_ONE_SAMP_SCALE;
588 }
589 }
590 else
591 {
592 while (sound4ShiftIndex >= NOISE_ONE_SAMP_SCALE)
593 {
594 sound4ShiftRight = (((sound4ShiftRight << 14) ^
595 (sound4ShiftRight << 13)) & 0x4000) |
596 (sound4ShiftRight >> 1);
597
598 sound4ShiftIndex -= NOISE_ONE_SAMP_SCALE;
599 }
600 }
601
602 sound4Index %= NOISE_ONE_SAMP_SCALE;
603 sound4ShiftIndex %= NOISE_ONE_SAMP_SCALE;
604
605 value = ((sound4ShiftRight & 1) * 2 - 1) * vol;
606 }
607 else
608 {
609 value = 0;
610 }
611 }
612
613 soundBuffer[3][soundIndex] = value;
614
615 if (sound4On)
616 {
617 if (sound4ATL)
618 {
619 sound4ATL -= soundQuality;
620
621 if (sound4ATL <= 0 && sound4Continue)
622 {
623 gbMemory[NR52] &= 0xfd;
624 sound4On = 0;
625 }
626 }
627
628 if (sound4EnvelopeATL)
629 {
630 sound4EnvelopeATL -= soundQuality;
631
632 if (sound4EnvelopeATL <= 0)
633 {
634 if (sound4EnvelopeUpDown)
635 {
636 if (sound4EnvelopeVolume < 15)
637 sound4EnvelopeVolume++;
638 }
639 else
640 {
641 if (sound4EnvelopeVolume)
642 sound4EnvelopeVolume--;
643 }
644 sound4EnvelopeATL += sound4EnvelopeATLReload;
645 }
646 }
647 }
648 }
649
650 void gbSoundMix()
651 {
652 int res = 0;
653
654 if (gbMemory)
655 soundBalance = (gbMemory[NR51] & soundEnableFlag & ~soundMutedFlag);
656
657 if (soundBalance & 16)
658 {
659 res += ((s8)soundBuffer[0][soundIndex]);
660 }
661 if (soundBalance & 32)
662 {
663 res += ((s8)soundBuffer[1][soundIndex]);
664 }
665 if (soundBalance & 64)
666 {
667 res += ((s8)soundBuffer[2][soundIndex]);
668 }
669 if (soundBalance & 128)
670 {
671 res += ((s8)soundBuffer[3][soundIndex]);
672 }
673
674 if (gbDigitalSound)
675 res = soundLevel1 * 256;
676 else
677 res *= soundLevel1 * 60;
678
679 if (soundEcho)
680 {
681 res *= 2;
682 res += soundFilter[soundEchoIndex];
683 res /= 2;
684 soundFilter[soundEchoIndex++] = res;
685 }
686
687 if (soundLowPass)
688 {
689 soundLeft[4] = soundLeft[3];
690 soundLeft[3] = soundLeft[2];
691 soundLeft[2] = soundLeft[1];
692 soundLeft[1] = soundLeft[0];
693 soundLeft[0] = res;
694 res = (soundLeft[4] + 2 * soundLeft[3] + 8 * soundLeft[2] + 2 * soundLeft[1] +
695 soundLeft[0]) / 14;
696 }
697
698 bool noSpecialEffects = false;
699 #if (defined(WIN32) && !defined(SDL))
700 if (theApp.soundRecording || theApp.aviRecording || theApp.nvAudioLog)
701 noSpecialEffects = true;
702 #endif
703
704 if (!noSpecialEffects)
705 {
706 switch (soundVolume)
707 {
708 case 0:
709 case 1:
710 case 2:
711 case 3:
712 res *= (soundVolume + 1);
713 break;
714 case 4:
715 res >>= 2;
716 break;
717 case 5:
718 res >>= 1;
719 break;
720 }
721 }
722
723 if (res > 32767)
724 res = 32767;
725 if (res < -32768)
726 res = -32768;
727
728 if (soundReverse && !noSpecialEffects)
729 {
730 soundFinalWave[++soundBufferIndex] = res;
731 if ((soundFrameSoundWritten + 1) >= countof(soundFrameSound))
732 /*assert(false)*/;
733 else
734 soundFrameSound[++soundFrameSoundWritten] = res;
735 }
736 else
737 {
738 soundFinalWave[soundBufferIndex++] = res;
739 if (soundFrameSoundWritten >= countof(soundFrameSound))
740 /*assert(false)*/;
741 else
742 soundFrameSound[soundFrameSoundWritten++] = res;
743 }
744
745 res = 0;
746
747 if (soundBalance & 1)
748 {
749 res += ((s8)soundBuffer[0][soundIndex]);
750 }
751 if (soundBalance & 2)
752 {
753 res += ((s8)soundBuffer[1][soundIndex]);
754 }
755 if (soundBalance & 4)
756 {
757 res += ((s8)soundBuffer[2][soundIndex]);
758 }
759 if (soundBalance & 8)
760 {
761 res += ((s8)soundBuffer[3][soundIndex]);
762 }
763
764 if (gbDigitalSound)
765 res = soundLevel2 * 256;
766 else
767 res *= soundLevel2 * 60;
768
769 if (soundEcho)
770 {
771 res *= 2;
772 res += soundFilter[soundEchoIndex];
773 res /= 2;
774 soundFilter[soundEchoIndex++] = res;
775
776 if (soundEchoIndex >= 4000)
777 soundEchoIndex = 0;
778 }
779
780 if (soundLowPass)
781 {
782 soundRight[4] = soundRight[3];
783 soundRight[3] = soundRight[2];
784 soundRight[2] = soundRight[1];
785 soundRight[1] = soundRight[0];
786 soundRight[0] = res;
787 res = (soundRight[4] + 2 * soundRight[3] + 8 * soundRight[2] + 2 * soundRight[1] +
788 soundRight[0]) / 14;
789 }
790
791 if (!noSpecialEffects)
792 {
793 switch (soundVolume)
794 {
795 case 0:
796 case 1:
797 case 2:
798 case 3:
799 res *= (soundVolume + 1);
800 break;
801 case 4:
802 res >>= 2;
803 break;
804 case 5:
805 res >>= 1;
806 break;
807 }
808 }
809
810 if (res > 32767)
811 res = 32767;
812 if (res < -32768)
813 res = -32768;
814
815 if (soundReverse && !noSpecialEffects)
816 {
817 soundFinalWave[-1 + soundBufferIndex++] = res;
818 if ((soundFrameSoundWritten) >= countof(soundFrameSound))
819 /*assert(false)*/;
820 else
821 soundFrameSound[-1 + soundFrameSoundWritten++] = res;
822 }
823 else
824 {
825 soundFinalWave[soundBufferIndex++] = res;
826 if ((soundFrameSoundWritten + 1) >= countof(soundFrameSound))
827 /*assert(false)*/;
828 else
829 soundFrameSound[soundFrameSoundWritten++] = res;
830 }
831 }
832
833 void gbSoundTick()
834 {
835 if (systemSoundOn)
836 {
837 if (soundMasterOn)
838 {
839 gbSoundChannel1();
840 gbSoundChannel2();
841 gbSoundChannel3();
842 gbSoundChannel4();
843
844 gbSoundMix();
845 }
846 else
847 {
848 soundFinalWave[soundBufferIndex++] = 0;
849 soundFinalWave[soundBufferIndex++] = 0;
850 if ((soundFrameSoundWritten + 1) >= countof(soundFrameSound))
851 /*assert(false)*/;
852 else
853 {
854 soundFrameSound[soundFrameSoundWritten++] = 0;
855 soundFrameSound[soundFrameSoundWritten++] = 0;
856 }
857 }
858
859 soundIndex++;
860
861 if (2 * soundBufferIndex >= soundBufferLen)
862 {
863 if (systemSoundOn)
864 {
865 if (soundPaused)
866 {
867 extern void soundResume();
868 soundResume();
869 }
870
871 systemSoundWriteToBuffer();
872 }
873 soundIndex = 0;
874 soundBufferIndex = 0;
875 }
876 }
877 }
878
879 void gbSoundReset()
880 {
881 soundPaused = 1;
882 soundPlay = 0;
883 SOUND_CLOCK_TICKS = soundQuality * GB_USE_TICKS_AS;
884 // soundTicks = SOUND_CLOCK_TICKS;
885 soundTicks = 0;
886 soundNextPosition = 0;
887 soundMasterOn = 1;
888 soundIndex = 0;
889 soundBufferIndex = 0;
890 soundLevel1 = 7;
891 soundLevel2 = 7;
892 soundVIN = 0;
893
894 sound1On = 0;
895 sound1ATL = 0;
896 sound1Skip = 0;
897 sound1Index = 0;
898 sound1Continue = 0;
899 sound1EnvelopeVolume = 0;
900 sound1EnvelopeATL = 0;
901 sound1EnvelopeUpDown = 0;
902 sound1EnvelopeATLReload = 0;
903 sound1SweepATL = 0;
904 sound1SweepATLReload = 0;
905 sound1SweepSteps = 0;
906 sound1SweepUpDown = 0;
907 sound1SweepStep = 0;
908 sound1Wave = soundWavePattern[2];
909
910 sound2On = 0;
911 sound2ATL = 0;
912 sound2Skip = 0;
913 sound2Index = 0;
914 sound2Continue = 0;
915 sound2EnvelopeVolume = 0;
916 sound2EnvelopeATL = 0;
917 sound2EnvelopeUpDown = 0;
918 sound2EnvelopeATLReload = 0;
919 sound2Wave = soundWavePattern[2];
920
921 sound3On = 0;
922 sound3ATL = 0;
923 sound3Skip = 0;
924 sound3Index = 0;
925 sound3Continue = 0;
926 sound3OutputLevel = 0;
927
928 sound4On = 0;
929 sound4Clock = 0;
930 sound4ATL = 0;
931 sound4Skip = 0;
932 sound4Index = 0;
933 sound4ShiftRight = 0x7f;
934 sound4NSteps = 0;
935 sound4CountDown = 0;
936 sound4Continue = 0;
937 sound4EnvelopeVolume = 0;
938 sound4EnvelopeATL = 0;
939 sound4EnvelopeUpDown = 0;
940 sound4EnvelopeATLReload = 0;
941
942 // don't translate
943 if (soundDebug)
944 {
945 log("*** Sound Init ***\n");
946 }
947
948 gbSoundEvent(0xff10, 0x80);
949 gbSoundEvent(0xff11, 0xbf);
950 gbSoundEvent(0xff12, 0xf3);
951 gbSoundEvent(0xff14, 0xbf);
952 gbSoundEvent(0xff16, 0x3f);
953 gbSoundEvent(0xff17, 0x00);
954 gbSoundEvent(0xff19, 0xbf);
955
956 gbSoundEvent(0xff1a, 0x7f);
957 gbSoundEvent(0xff1b, 0xff);
958 gbSoundEvent(0xff1c, 0xbf);
959 gbSoundEvent(0xff1e, 0xbf);
960
961 gbSoundEvent(0xff20, 0xff);
962 gbSoundEvent(0xff21, 0x00);
963 gbSoundEvent(0xff22, 0x00);
964 gbSoundEvent(0xff23, 0xbf);
965 gbSoundEvent(0xff24, 0x77);
966 gbSoundEvent(0xff25, 0xf3);
967
968 gbSoundEvent(0xff26, 0xf0);
969
970 // don't translate
971 if (soundDebug)
972 {
973 log("*** Sound Init Complete ***\n");
974 }
975
976 sound1On = 0;
977 sound2On = 0;
978 sound3On = 0;
979 sound4On = 0;
980
981 int addr = 0xff30;
982
983 while (addr < 0xff40)
984 {
985 gbMemory[addr++] = 0x00;
986 gbMemory[addr++] = 0xff;
987 }
988
989 memset(soundFinalWave, 0x00, soundBufferLen);
990
991 memset(soundFilter, 0, sizeof(soundFilter));
992 soundEchoIndex = 0;
993 }
994
995 extern bool soundInit();
996 extern void soundShutdown();
997
998 void gbSoundSetQuality(int quality)
999 {
1000 if (soundQuality != quality && systemSoundCanChangeQuality())
1001 {
1002 if (!soundOffFlag)
1003 soundShutdown();
1004 soundQuality = quality;
1005 soundNextPosition = 0;
1006 if (!soundOffFlag)
1007 soundInit();
1008 SOUND_CLOCK_TICKS = (gbSpeed ? 2 : 1) * GB_USE_TICKS_AS * soundQuality;
1009 soundIndex = 0;
1010 soundBufferIndex = 0;
1011 }
1012 else
1013 {
1014 soundNextPosition = 0;
1015 SOUND_CLOCK_TICKS = (gbSpeed ? 2 : 1) * GB_USE_TICKS_AS * soundQuality;
1016 soundIndex = 0;
1017 soundBufferIndex = 0;
1018 }
1019 }
1020
1021 static int32 soundTicks_int32;
1022 static int32 SOUND_CLOCK_TICKS_int32;
1023 variable_desc gbSoundSaveStruct[] = {
1024 { &soundPaused, sizeof(int32) },
1025 { &soundPlay, sizeof(int32) },
1026 { &soundTicks_int32, sizeof(int32) },
1027 { &SOUND_CLOCK_TICKS_int32, sizeof(int32) },
1028 { &soundLevel1, sizeof(int32) },
1029 { &soundLevel2, sizeof(int32) },
1030 { &soundBalance, sizeof(int32) },
1031 { &soundMasterOn, sizeof(int32) },
1032 { &soundIndex, sizeof(int32) },
1033 { &soundVIN, sizeof(int32) },
1034 { &sound1On, sizeof(int32) },
1035 { &sound1ATL, sizeof(int32) },
1036 { &sound1Skip, sizeof(int32) },
1037 { &sound1Index, sizeof(int32) },
1038 { &sound1Continue, sizeof(int32) },
1039 { &sound1EnvelopeVolume, sizeof(int32) },
1040 { &sound1EnvelopeATL, sizeof(int32) },
1041 { &sound1EnvelopeATLReload, sizeof(int32) },
1042 { &sound1EnvelopeUpDown, sizeof(int32) },
1043 { &sound1SweepATL, sizeof(int32) },
1044 { &sound1SweepATLReload, sizeof(int32) },
1045 { &sound1SweepSteps, sizeof(int32) },
1046 { &sound1SweepUpDown, sizeof(int32) },
1047 { &sound1SweepStep, sizeof(int32) },
1048 { &sound2On, sizeof(int32) },
1049 { &sound2ATL, sizeof(int32) },
1050 { &sound2Skip, sizeof(int32) },
1051 { &sound2Index, sizeof(int32) },
1052 { &sound2Continue, sizeof(int32) },
1053 { &sound2EnvelopeVolume, sizeof(int32) },
1054 { &sound2EnvelopeATL, sizeof(int32) },
1055 { &sound2EnvelopeATLReload, sizeof(int32) },
1056 { &sound2EnvelopeUpDown, sizeof(int32) },
1057 { &sound3On, sizeof(int32) },
1058 { &sound3ATL, sizeof(int32) },
1059 { &sound3Skip, sizeof(int32) },
1060 { &sound3Index, sizeof(int32) },
1061 { &sound3Continue, sizeof(int32) },
1062 { &sound3OutputLevel, sizeof(int32) },
1063 { &sound4On, sizeof(int32) },
1064 { &sound4ATL, sizeof(int32) },
1065 { &sound4Skip, sizeof(int32) },
1066 { &sound4Index, sizeof(int32) },
1067 { &sound4Clock, sizeof(int32) },
1068 { &sound4ShiftRight, sizeof(int32) },
1069 { &sound4ShiftSkip, sizeof(int32) },
1070 { &sound4ShiftIndex, sizeof(int32) },
1071 { &sound4NSteps, sizeof(int32) },
1072 { &sound4CountDown, sizeof(int32) },
1073 { &sound4Continue, sizeof(int32) },
1074 { &sound4EnvelopeVolume, sizeof(int32) },
1075 { &sound4EnvelopeATL, sizeof(int32) },
1076 { &sound4EnvelopeATLReload, sizeof(int32) },
1077 { &sound4EnvelopeUpDown, sizeof(int32) },
1078 { &soundEnableFlag, sizeof(int32) },
1079 { NULL, 0 }
1080 };
1081
1082 //variable_desc gbSoundSaveStructV2[] = {
1083 // { &soundTicks, sizeof(soundtick_t) },
1084 // { &SOUND_CLOCK_TICKS, sizeof(soundtick_t) },
1085 // { &GB_USE_TICKS_AS, sizeof(soundtick_t) },
1086 // { NULL, 0 }
1087 //};
1088
1089 void gbSoundSaveGame(gzFile gzFile)
1090 {
1091 soundTicks_int32 = (int32) soundTicks;
1092 SOUND_CLOCK_TICKS_int32 = (int32) SOUND_CLOCK_TICKS;
1093
1094 utilWriteData(gzFile, gbSoundSaveStruct);
1095
1096 utilGzWrite(gzFile, soundBuffer, 4 * 735);
1097 utilGzWrite(gzFile, soundFinalWave, 2 * 735);
1098 utilGzWrite(gzFile, &soundQuality, sizeof(int32));
1099
1100 //utilWriteData(gzFile, gbSoundSaveStructV2);
1101 }
1102
1103 void gbSoundReadGame(int version, gzFile gzFile)
1104 {
1105 int32 oldSoundPaused = soundPaused;
1106 int32 oldSoundEnableFlag = soundEnableFlag;
1107 utilReadData(gzFile, gbSoundSaveStruct);
1108 soundPaused = oldSoundPaused;
1109 soundEnableFlag = oldSoundEnableFlag;
1110
1111 soundBufferIndex = soundIndex * 2;
1112
1113 utilGzRead(gzFile, soundBuffer, 4 * 735);
1114 utilGzRead(gzFile, soundFinalWave, 2 * 735);
1115
1116 if (version >= 7)
1117 {
1118 int quality = 1;
1119 utilGzRead(gzFile, &quality, sizeof(int32));
1120 gbSoundSetQuality(quality);
1121 }
1122 else
1123 {
1124 soundQuality = -1;
1125 gbSoundSetQuality(1);
1126 }
1127
1128 sound1Wave = soundWavePattern[gbMemory[NR11] >> 6];
1129 sound2Wave = soundWavePattern[gbMemory[NR21] >> 6];
1130
1131 //if(version >= 14) {
1132 // utilReadData(gzFile, gbSoundSaveStructV2);
1133 //}
1134 //else {
1135 soundTicks = (soundtick_t) soundTicks_int32;
1136 SOUND_CLOCK_TICKS = (soundtick_t) SOUND_CLOCK_TICKS_int32;
1137 //}
1138 }
1139