src/gba/gba-audio.c (view raw)
1#include "gba-audio.h"
2
3#include "gba.h"
4#include "gba-io.h"
5#include "gba-serialize.h"
6#include "gba-thread.h"
7
8#include <limits.h>
9#include <math.h>
10
11const unsigned GBA_AUDIO_SAMPLES = 512;
12const unsigned GBA_AUDIO_FIFO_SIZE = 8 * sizeof(int32_t);
13#define SWEEP_CYCLES (GBA_ARM7TDMI_FREQUENCY / 128)
14
15static int32_t _updateSquareChannel(struct GBAAudioSquareControl* envelope, int duty);
16static void _updateEnvelope(struct GBAAudioEnvelope* envelope);
17static int _updateSweep(struct GBAAudioChannel1* ch);
18static int32_t _updateChannel1(struct GBAAudioChannel1* ch);
19static int32_t _updateChannel2(struct GBAAudioChannel2* ch);
20static int32_t _updateChannel3(struct GBAAudioChannel3* ch);
21static int32_t _updateChannel4(struct GBAAudioChannel4* ch);
22static void _sample(struct GBAAudio* audio);
23
24void GBAAudioInit(struct GBAAudio* audio) {
25 audio->nextEvent = 0;
26 audio->nextCh1 = 0;
27 audio->nextCh2 = 0;
28 audio->nextCh3 = 0;
29 audio->nextCh4 = 0;
30 audio->ch1.sweep.time = 0;
31 audio->ch1.envelope.nextStep = INT_MAX;
32 audio->ch1.control.nextStep = 0;
33 audio->ch1.control.endTime = 0;
34 audio->ch1.nextSweep = INT_MAX;
35 audio->ch1.sample = 0;
36 audio->ch2.envelope.nextStep = INT_MAX;
37 audio->ch2.control.nextStep = 0;
38 audio->ch2.control.endTime = 0;
39 audio->ch2.sample = 0;
40 audio->ch3.bank.packed = 0;
41 audio->ch3.control.endTime = 0;
42 audio->ch3.sample = 0;
43 audio->ch4.sample = 0;
44 audio->ch4.envelope.nextStep = INT_MAX;
45 audio->eventDiff = 0;
46 audio->nextSample = 0;
47 audio->sampleRate = 0x8000;
48 audio->soundcntLo = 0;
49 audio->soundcntHi = 0;
50 audio->soundcntX = 0;
51 audio->sampleInterval = GBA_ARM7TDMI_FREQUENCY / audio->sampleRate;
52
53 CircleBufferInit(&audio->left, GBA_AUDIO_SAMPLES * sizeof(int32_t));
54 CircleBufferInit(&audio->right, GBA_AUDIO_SAMPLES * sizeof(int32_t));
55 CircleBufferInit(&audio->chA.fifo, GBA_AUDIO_FIFO_SIZE);
56 CircleBufferInit(&audio->chB.fifo, GBA_AUDIO_FIFO_SIZE);
57}
58
59void GBAAudioDeinit(struct GBAAudio* audio) {
60 CircleBufferDeinit(&audio->left);
61 CircleBufferDeinit(&audio->right);
62 CircleBufferDeinit(&audio->chA.fifo);
63 CircleBufferDeinit(&audio->chB.fifo);
64}
65
66int32_t GBAAudioProcessEvents(struct GBAAudio* audio, int32_t cycles) {
67 audio->nextEvent -= cycles;
68 audio->eventDiff += cycles;
69 while (audio->nextEvent <= 0) {
70 audio->nextEvent = INT_MAX;
71 if (audio->enable) {
72 if (audio->playingCh1 && !audio->ch1.envelope.dead) {
73 audio->nextCh1 -= audio->eventDiff;
74 if (audio->ch1.envelope.nextStep != INT_MAX) {
75 audio->ch1.envelope.nextStep -= audio->eventDiff;
76 if (audio->ch1.envelope.nextStep <= 0) {
77 int8_t sample = audio->ch1.control.hi * 0x10 - 0x8;
78 _updateEnvelope(&audio->ch1.envelope);
79 if (audio->ch1.envelope.nextStep < audio->nextEvent) {
80 audio->nextEvent = audio->ch1.envelope.nextStep;
81 }
82 audio->ch1.sample = sample * audio->ch1.envelope.currentVolume;
83 }
84 }
85
86 if (audio->ch1.nextSweep != INT_MAX) {
87 audio->ch1.nextSweep -= audio->eventDiff;
88 if (audio->ch1.nextSweep <= 0) {
89 audio->playingCh1 = _updateSweep(&audio->ch1);
90 if (audio->ch1.nextSweep < audio->nextEvent) {
91 audio->nextEvent = audio->ch1.nextSweep;
92 }
93 }
94 }
95
96 if (audio->nextCh1 <= 0) {
97 audio->nextCh1 += _updateChannel1(&audio->ch1);
98 if (audio->nextCh1 < audio->nextEvent) {
99 audio->nextEvent = audio->nextCh1;
100 }
101 }
102
103 if (audio->ch1.control.stop) {
104 audio->ch1.control.endTime -= audio->eventDiff;
105 if (audio->ch1.control.endTime <= 0) {
106 audio->playingCh1 = 0;
107 }
108 }
109 }
110
111 if (audio->playingCh2 && !audio->ch2.envelope.dead) {
112 audio->nextCh2 -= audio->eventDiff;
113 if (audio->ch2.envelope.nextStep != INT_MAX) {
114 audio->ch2.envelope.nextStep -= audio->eventDiff;
115 if (audio->ch2.envelope.nextStep <= 0) {
116 int8_t sample = audio->ch2.control.hi * 0x10 - 0x8;
117 _updateEnvelope(&audio->ch2.envelope);
118 if (audio->ch2.envelope.nextStep < audio->nextEvent) {
119 audio->nextEvent = audio->ch2.envelope.nextStep;
120 }
121 audio->ch2.sample = sample * audio->ch2.envelope.currentVolume;
122 }
123 }
124
125 if (audio->nextCh2 <= 0) {
126 audio->nextCh2 += _updateChannel2(&audio->ch2);
127 if (audio->nextCh2 < audio->nextEvent) {
128 audio->nextEvent = audio->nextCh2;
129 }
130 }
131
132 if (audio->ch2.control.stop) {
133 audio->ch2.control.endTime -= audio->eventDiff;
134 if (audio->ch2.control.endTime <= 0) {
135 audio->playingCh2 = 0;
136 }
137 }
138 }
139
140 if (audio->playingCh3) {
141 audio->nextCh3 -= audio->eventDiff;
142 if (audio->nextCh3 <= 0) {
143 audio->nextCh3 += _updateChannel3(&audio->ch3);
144 if (audio->nextCh3 < audio->nextEvent) {
145 audio->nextEvent = audio->nextCh3;
146 }
147 }
148
149 if (audio->ch3.control.stop) {
150 audio->ch3.control.endTime -= audio->eventDiff;
151 if (audio->ch3.control.endTime <= 0) {
152 audio->playingCh3 = 0;
153 }
154 }
155 }
156
157 if (audio->playingCh4 && !audio->ch4.envelope.dead) {
158 audio->nextCh4 -= audio->eventDiff;
159 if (audio->ch4.envelope.nextStep != INT_MAX) {
160 audio->ch4.envelope.nextStep -= audio->eventDiff;
161 if (audio->ch4.envelope.nextStep <= 0) {
162 int8_t sample = (audio->ch4.sample >> 31) * 0x8;
163 _updateEnvelope(&audio->ch4.envelope);
164 if (audio->ch4.envelope.nextStep < audio->nextEvent) {
165 audio->nextEvent = audio->ch4.envelope.nextStep;
166 }
167 audio->ch4.sample = sample * audio->ch4.envelope.currentVolume;
168 }
169 }
170
171 if (audio->nextCh4 <= 0) {
172 audio->nextCh4 += _updateChannel4(&audio->ch4);
173 if (audio->nextCh4 < audio->nextEvent) {
174 audio->nextEvent = audio->nextCh4;
175 }
176 }
177
178 if (audio->ch4.control.stop) {
179 audio->ch4.control.endTime -= audio->eventDiff;
180 if (audio->ch4.control.endTime <= 0) {
181 audio->playingCh4 = 0;
182 }
183 }
184 }
185 }
186
187 audio->nextSample -= audio->eventDiff;
188 if (audio->nextSample <= 0) {
189 _sample(audio);
190 audio->nextSample += audio->sampleInterval;
191 }
192
193 if (audio->nextSample < audio->nextEvent) {
194 audio->nextEvent = audio->nextSample;
195 }
196 audio->eventDiff = 0;
197 }
198 return audio->nextEvent;
199}
200
201void GBAAudioScheduleFifoDma(struct GBAAudio* audio, int number, struct GBADMA* info) {
202 switch (info->dest) {
203 case BASE_IO | REG_FIFO_A_LO:
204 audio->chA.dmaSource = number;
205 break;
206 case BASE_IO | REG_FIFO_B_LO:
207 audio->chB.dmaSource = number;
208 break;
209 default:
210 GBALog(audio->p, GBA_LOG_GAME_ERROR, "Invalid FIFO destination: 0x%08X", info->dest);
211 return;
212 }
213 info->dstControl = DMA_FIXED;
214}
215
216void GBAAudioWriteSOUND1CNT_LO(struct GBAAudio* audio, uint16_t value) {
217 audio->ch1.sweep.packed = value;
218 if (audio->ch1.sweep.time) {
219 audio->ch1.nextSweep = audio->ch1.sweep.time * SWEEP_CYCLES;
220 } else {
221 audio->ch1.nextSweep = INT_MAX;
222 }
223}
224
225void GBAAudioWriteSOUND1CNT_HI(struct GBAAudio* audio, uint16_t value) {
226 audio->ch1.envelope.packed = value;
227 audio->ch1.envelope.dead = 0;
228 if (audio->ch1.envelope.stepTime) {
229 audio->ch1.envelope.nextStep = 0;
230 } else {
231 audio->ch1.envelope.nextStep = INT_MAX;
232 if (audio->ch1.envelope.initialVolume == 0) {
233 audio->ch1.envelope.dead = 1;
234 audio->ch1.sample = 0;
235 }
236 }
237}
238
239void GBAAudioWriteSOUND1CNT_X(struct GBAAudio* audio, uint16_t value) {
240 audio->ch1.control.packed = value;
241 audio->ch1.control.endTime = (GBA_ARM7TDMI_FREQUENCY * (64 - audio->ch1.envelope.length)) >> 8;
242 if (audio->ch1.control.restart) {
243 if (audio->ch1.sweep.time) {
244 audio->ch1.nextSweep = audio->ch1.sweep.time * SWEEP_CYCLES;
245 } else {
246 audio->ch1.nextSweep = INT_MAX;
247 }
248 if (!audio->playingCh1) {
249 audio->nextCh1 = 0;
250 }
251 audio->playingCh1 = 1;
252 if (audio->ch1.envelope.stepTime) {
253 audio->ch1.envelope.nextStep = 0;
254 } else {
255 audio->ch1.envelope.nextStep = INT_MAX;
256 }
257 audio->ch1.envelope.currentVolume = audio->ch1.envelope.initialVolume;
258 if (audio->ch1.envelope.stepTime) {
259 audio->ch1.envelope.nextStep = 0;
260 } else {
261 audio->ch1.envelope.nextStep = INT_MAX;
262 }
263 }
264}
265
266void GBAAudioWriteSOUND2CNT_LO(struct GBAAudio* audio, uint16_t value) {
267 audio->ch2.envelope.packed = value;
268 audio->ch2.envelope.dead = 0;
269 if (audio->ch2.envelope.stepTime) {
270 audio->ch2.envelope.nextStep = 0;
271 } else {
272 audio->ch2.envelope.nextStep = INT_MAX;
273 if (audio->ch2.envelope.initialVolume == 0) {
274 audio->ch2.envelope.dead = 1;
275 audio->ch2.sample = 0;
276 }
277 }
278}
279
280void GBAAudioWriteSOUND2CNT_HI(struct GBAAudio* audio, uint16_t value) {
281 audio->ch2.control.packed = value;
282 audio->ch1.control.endTime = (GBA_ARM7TDMI_FREQUENCY * (64 - audio->ch2.envelope.length)) >> 8;
283 if (audio->ch2.control.restart) {
284 audio->playingCh2 = 1;
285 audio->ch2.envelope.currentVolume = audio->ch2.envelope.initialVolume;
286 if (audio->ch2.envelope.stepTime) {
287 audio->ch2.envelope.nextStep = 0;
288 } else {
289 audio->ch2.envelope.nextStep = INT_MAX;
290 }
291 audio->nextCh2 = 0;
292 }
293}
294
295void GBAAudioWriteSOUND3CNT_LO(struct GBAAudio* audio, uint16_t value) {
296 audio->ch3.bank.packed = value;
297 if (audio->ch3.control.endTime >= 0) {
298 audio->playingCh3 = audio->ch3.bank.enable;
299 }
300}
301
302void GBAAudioWriteSOUND3CNT_HI(struct GBAAudio* audio, uint16_t value) {
303 audio->ch3.wave.packed = value;
304}
305
306void GBAAudioWriteSOUND3CNT_X(struct GBAAudio* audio, uint16_t value) {
307 audio->ch3.control.packed = value;
308 audio->ch3.control.endTime = (GBA_ARM7TDMI_FREQUENCY * (256 - audio->ch3.wave.length)) >> 8;
309 if (audio->ch3.control.restart) {
310 audio->playingCh3 = audio->ch3.bank.enable;
311 }
312}
313
314void GBAAudioWriteSOUND4CNT_LO(struct GBAAudio* audio, uint16_t value) {
315 audio->ch4.envelope.packed = value;
316 audio->ch4.envelope.dead = 0;
317 if (audio->ch4.envelope.stepTime) {
318 audio->ch4.envelope.nextStep = 0;
319 } else {
320 audio->ch4.envelope.nextStep = INT_MAX;
321 if (audio->ch4.envelope.initialVolume == 0) {
322 audio->ch4.envelope.dead = 1;
323 audio->ch4.sample = 0;
324 }
325 }
326}
327
328void GBAAudioWriteSOUND4CNT_HI(struct GBAAudio* audio, uint16_t value) {
329 audio->ch4.control.packed = value;
330 audio->ch4.control.endTime = (GBA_ARM7TDMI_FREQUENCY * (64 - audio->ch4.envelope.length)) >> 8;
331 if (audio->ch4.control.restart) {
332 audio->playingCh4 = 1;
333 audio->ch4.envelope.currentVolume = audio->ch4.envelope.initialVolume;
334 if (audio->ch4.envelope.stepTime) {
335 audio->ch4.envelope.nextStep = 0;
336 } else {
337 audio->ch4.envelope.nextStep = INT_MAX;
338 }
339 if (audio->ch4.control.power) {
340 audio->ch4.lfsr = 0x40;
341 } else {
342 audio->ch4.lfsr = 0x4000;
343 }
344 audio->nextCh4 = 0;
345 }
346}
347
348void GBAAudioWriteSOUNDCNT_LO(struct GBAAudio* audio, uint16_t value) {
349 audio->soundcntLo = value;
350}
351
352void GBAAudioWriteSOUNDCNT_HI(struct GBAAudio* audio, uint16_t value) {
353 audio->soundcntHi = value;
354}
355
356void GBAAudioWriteSOUNDCNT_X(struct GBAAudio* audio, uint16_t value) {
357 audio->soundcntX = (value & 0x80) | (audio->soundcntX & 0x0F);
358}
359
360void GBAAudioWriteWaveRAM(struct GBAAudio* audio, int address, uint32_t value) {
361 audio->ch3.wavedata[address | (!audio->ch3.bank.bank * 4)] = value;
362}
363
364void GBAAudioWriteFIFO(struct GBAAudio* audio, int address, uint32_t value) {
365 struct CircleBuffer* fifo;
366 switch (address) {
367 case REG_FIFO_A_LO:
368 fifo = &audio->chA.fifo;
369 break;
370 case REG_FIFO_B_LO:
371 fifo = &audio->chB.fifo;
372 break;
373 default:
374 GBALog(audio->p, GBA_LOG_ERROR, "Bad FIFO write to address 0x%03x", address);
375 return;
376 }
377 while (!CircleBufferWrite32(fifo, value)) {
378 int32_t dummy;
379 CircleBufferRead32(fifo, &dummy);
380 }
381}
382
383void GBAAudioSampleFIFO(struct GBAAudio* audio, int fifoId, int32_t cycles) {
384 struct GBAAudioFIFO* channel;
385 if (fifoId == 0) {
386 channel = &audio->chA;
387 } else if (fifoId == 1) {
388 channel = &audio->chB;
389 } else {
390 GBALog(audio->p, GBA_LOG_ERROR, "Bad FIFO write to address 0x%03x", fifoId);
391 return;
392 }
393 if (CircleBufferSize(&channel->fifo) <= 4 * sizeof(int32_t)) {
394 struct GBADMA* dma = &audio->p->memory.dma[channel->dmaSource];
395 dma->nextCount = 4;
396 dma->nextEvent = 0;
397 GBAMemoryUpdateDMAs(&audio->p->memory, -cycles);
398 }
399 CircleBufferRead8(&channel->fifo, &channel->sample);
400}
401
402unsigned GBAAudioCopy(struct GBAAudio* audio, void* left, void* right, unsigned nSamples) {
403 GBASyncLockAudio(audio->p->sync);
404 unsigned read = 0;
405 if (left) {
406 unsigned readL = CircleBufferRead(&audio->left, left, nSamples * sizeof(int32_t)) >> 2;
407 if (readL < nSamples) {
408 memset((int32_t*) left + readL, 0, nSamples - readL);
409 }
410 read = readL;
411 }
412 if (right) {
413 unsigned readR = CircleBufferRead(&audio->right, right, nSamples * sizeof(int32_t)) >> 2;
414 if (readR < nSamples) {
415 memset((int32_t*) right + readR, 0, nSamples - readR);
416 }
417 read = read >= readR ? read : readR;
418 }
419 GBASyncConsumeAudio(audio->p->sync);
420 return read;
421}
422
423unsigned GBAAudioResampleNN(struct GBAAudio* audio, float ratio, float* drift, struct GBAStereoSample* output, unsigned nSamples) {
424 int32_t left[GBA_AUDIO_SAMPLES];
425 int32_t right[GBA_AUDIO_SAMPLES];
426
427 // toRead is in GBA samples
428 // TODO: Do this with fixed-point math
429 unsigned toRead = ceilf(nSamples / ratio);
430 unsigned totalRead = 0;
431 while (nSamples) {
432 unsigned currentRead = GBA_AUDIO_SAMPLES;
433 if (currentRead > toRead) {
434 currentRead = toRead;
435 }
436 unsigned read = GBAAudioCopy(audio, left, right, currentRead);
437 toRead -= read;
438 unsigned i;
439 for (i = 0; i < read; ++i) {
440 *drift += ratio;
441 while (*drift >= 1.f) {
442 output->left = left[i];
443 output->right = right[i];
444 ++output;
445 ++totalRead;
446 --nSamples;
447 *drift -= 1.f;
448 if (!nSamples) {
449 return totalRead;
450 }
451 }
452 }
453 if (read < currentRead) {
454 memset(output, 0, nSamples * sizeof(struct GBAStereoSample));
455 break;
456 }
457 }
458 return totalRead;
459}
460
461static int32_t _updateSquareChannel(struct GBAAudioSquareControl* control, int duty) {
462 control->hi = !control->hi;
463 int period = 16 * (2048 - control->frequency);
464 switch (duty) {
465 case 0:
466 return control->hi ? period : period * 7;
467 case 1:
468 return control->hi ? period * 2 : period * 6;
469 case 2:
470 return period * 4;
471 case 3:
472 return control->hi ? period * 6 : period * 2;
473 default:
474 // This should never be hit
475 return period * 4;
476 }
477}
478
479static void _updateEnvelope(struct GBAAudioEnvelope* envelope) {
480 if (envelope->direction) {
481 ++envelope->currentVolume;
482 } else {
483 --envelope->currentVolume;
484 }
485 if (envelope->currentVolume >= 15) {
486 envelope->currentVolume = 15;
487 envelope->nextStep = INT_MAX;
488 } else if (envelope->currentVolume <= 0) {
489 envelope->currentVolume = 0;
490 envelope->dead = 1;
491 envelope->nextStep = INT_MAX;
492 } else {
493 envelope->nextStep += envelope->stepTime * (GBA_ARM7TDMI_FREQUENCY >> 6);
494 }
495}
496
497static int _updateSweep(struct GBAAudioChannel1* ch) {
498 if (ch->sweep.direction) {
499 int frequency = ch->control.frequency;
500 frequency -= frequency >> ch->sweep.shift;
501 if (frequency >= 0) {
502 ch->control.frequency = frequency;
503 }
504 } else {
505 int frequency = ch->control.frequency;
506 frequency += frequency >> ch->sweep.shift;
507 if (frequency < 2048) {
508 ch->control.frequency = frequency;
509 } else {
510 return 0;
511 }
512 }
513 ch->nextSweep += ch->sweep.time * SWEEP_CYCLES;
514 return 1;
515}
516
517static int32_t _updateChannel1(struct GBAAudioChannel1* ch) {
518 int timing = _updateSquareChannel(&ch->control, ch->envelope.duty);
519 ch->sample = ch->control.hi * 0x10 - 0x8;
520 ch->sample *= ch->envelope.currentVolume;
521 return timing;
522}
523
524static int32_t _updateChannel2(struct GBAAudioChannel2* ch) {
525 int timing = _updateSquareChannel(&ch->control, ch->envelope.duty);
526 ch->sample = ch->control.hi * 0x10 - 0x8;
527 ch->sample *= ch->envelope.currentVolume;
528 return timing;
529}
530
531static int32_t _updateChannel3(struct GBAAudioChannel3* ch) {
532 int i;
533 int start;
534 int end;
535 int volume;
536 switch (ch->wave.volume) {
537 case 0:
538 volume = 0;
539 break;
540 case 1:
541 volume = 4;
542 break;
543 case 2:
544 volume = 2;
545 break;
546 case 3:
547 volume = 1;
548 break;
549 default:
550 volume = 3;
551 break;
552 }
553 if (ch->bank.size) {
554 start = 7;
555 end = 0;
556 } else if (ch->bank.bank) {
557 start = 7;
558 end = 4;
559 } else {
560 start = 3;
561 end = 0;
562 }
563 uint32_t bitsCarry = ch->wavedata[end] & 0xF0000000;
564 uint32_t bits;
565 for (i = start; i >= end; --i) {
566 bits = ch->wavedata[i] & 0xF0000000;
567 ch->wavedata[i] <<= 4;
568 ch->wavedata[i] |= bitsCarry >> 28;
569 bitsCarry = bits;
570 }
571 ch->sample = ((bitsCarry >> 26) - 0x20) * volume;
572 return 8 * (2048 - ch->control.rate);
573}
574
575static int32_t _updateChannel4(struct GBAAudioChannel4* ch) {
576 int lsb = ch->lfsr & 1;
577 ch->sample = lsb * 0x10 - 0x8;
578 ch->sample *= ch->envelope.currentVolume;
579 ch->lfsr >>= 1;
580 ch->lfsr ^= (lsb * 0x60) << (ch->control.power ? 0 : 8);
581 int timing = ch->control.ratio ? 2 * ch->control.ratio : 1;
582 timing <<= ch->control.frequency;
583 timing *= 32;
584 return timing;
585}
586
587static void _sample(struct GBAAudio* audio) {
588 int32_t sampleLeft = 0;
589 int32_t sampleRight = 0;
590 int psgShift = 6 - audio->volume;
591
592 if (audio->ch1Left) {
593 sampleLeft += audio->ch1.sample;
594 }
595
596 if (audio->ch1Right) {
597 sampleRight += audio->ch1.sample;
598 }
599
600 if (audio->ch2Left) {
601 sampleLeft += audio->ch2.sample;
602 }
603
604 if (audio->ch2Right) {
605 sampleRight += audio->ch2.sample;
606 }
607
608 if (audio->ch3Left) {
609 sampleLeft += audio->ch3.sample;
610 }
611
612 if (audio->ch3Right) {
613 sampleRight += audio->ch3.sample;
614 }
615
616 if (audio->ch4Left) {
617 sampleLeft += audio->ch4.sample;
618 }
619
620 if (audio->ch4Right) {
621 sampleRight += audio->ch4.sample;
622 }
623
624 sampleLeft = (sampleLeft * (1 + audio->volumeLeft)) >> psgShift;
625 sampleRight = (sampleRight * (1 + audio->volumeRight)) >> psgShift;
626
627 if (audio->chALeft) {
628 sampleLeft += (audio->chA.sample << 2) >> !audio->volumeChA;
629 }
630
631 if (audio->chARight) {
632 sampleRight += (audio->chA.sample << 2) >> !audio->volumeChA;
633 }
634
635 if (audio->chBLeft) {
636 sampleLeft += (audio->chB.sample << 2) >> !audio->volumeChB;
637 }
638
639 if (audio->chBRight) {
640 sampleRight += (audio->chB.sample << 2) >> !audio->volumeChB;
641 }
642
643 GBASyncLockAudio(audio->p->sync);
644 CircleBufferWrite32(&audio->left, sampleLeft << 5);
645 CircleBufferWrite32(&audio->right, sampleRight << 5);
646 unsigned produced = CircleBufferSize(&audio->left);
647 GBASyncProduceAudio(audio->p->sync, produced >= GBA_AUDIO_SAMPLES * 3);
648}
649
650void GBAAudioSerialize(const struct GBAAudio* audio, struct GBASerializedState* state) {
651 state->audio.ch1Volume = audio->ch1.envelope.currentVolume;
652 state->audio.ch1Dead = audio->ch1.envelope.dead;
653 state->audio.ch1Hi = audio->ch1.control.hi;
654 state->audio.ch1.envelopeNextStep = audio->ch1.envelope.nextStep;
655 state->audio.ch1.waveNextStep = audio->ch1.control.nextStep;
656 state->audio.ch1.sweepNextStep = audio->ch1.nextSweep;
657 state->audio.ch1.endTime = audio->ch1.control.endTime;
658 state->audio.ch1.nextEvent = audio->nextCh1;
659
660 state->audio.ch2Volume = audio->ch2.envelope.currentVolume;
661 state->audio.ch2Dead = audio->ch2.envelope.dead;
662 state->audio.ch2Hi = audio->ch2.control.hi;
663 state->audio.ch2.envelopeNextStep = audio->ch2.envelope.nextStep;
664 state->audio.ch2.waveNextStep = audio->ch2.control.nextStep;
665 state->audio.ch2.endTime = audio->ch2.control.endTime;
666 state->audio.ch2.nextEvent = audio->nextCh2;
667
668 memcpy(state->audio.ch3.wavebanks, audio->ch3.wavedata, sizeof(state->audio.ch3.wavebanks));
669 state->audio.ch3.endTime = audio->ch3.control.endTime;
670 state->audio.ch3.nextEvent = audio->nextCh3;
671
672 state->audio.ch4Volume = audio->ch4.envelope.currentVolume;
673 state->audio.ch4Dead = audio->ch4.envelope.dead;
674 state->audio.ch4.envelopeNextStep = audio->ch4.envelope.nextStep;
675 state->audio.ch4.lfsr = audio->ch4.lfsr;
676 state->audio.ch4.endTime = audio->ch4.control.endTime;
677 state->audio.ch4.nextEvent = audio->nextCh4;
678
679 state->audio.nextEvent = audio->nextEvent;
680 state->audio.eventDiff = audio->eventDiff;
681 state->audio.nextSample = audio->nextSample;
682}
683
684void GBAAudioDeserialize(struct GBAAudio* audio, const struct GBASerializedState* state) {
685 audio->ch1.envelope.currentVolume = state->audio.ch1Volume;
686 audio->ch1.envelope.dead = state->audio.ch1Dead;
687 audio->ch1.control.hi = state->audio.ch1Hi;
688 audio->ch1.envelope.nextStep = state->audio.ch1.envelopeNextStep;
689 audio->ch1.control.nextStep = state->audio.ch1.waveNextStep;
690 audio->ch1.nextSweep = state->audio.ch1.sweepNextStep;
691 audio->ch1.control.endTime = state->audio.ch1.endTime;
692 audio->nextCh1 = state->audio.ch1.nextEvent;
693
694 audio->ch2.envelope.currentVolume = state->audio.ch2Volume;
695 audio->ch2.envelope.dead = state->audio.ch2Dead;
696 audio->ch2.control.hi = state->audio.ch2Hi;
697 audio->ch2.envelope.nextStep = state->audio.ch2.envelopeNextStep;
698 audio->ch2.control.nextStep = state->audio.ch2.waveNextStep;
699 audio->ch2.control.endTime = state->audio.ch2.endTime;
700 audio->nextCh2 = state->audio.ch2.nextEvent;
701
702 memcpy(audio->ch3.wavedata, state->audio.ch3.wavebanks, sizeof(audio->ch3.wavedata));
703 audio->ch3.control.endTime = state->audio.ch3.endTime;
704 audio->nextCh3 = state->audio.ch3.nextEvent;
705
706 audio->ch4.envelope.currentVolume = state->audio.ch4Volume;
707 audio->ch4.envelope.dead = state->audio.ch4Dead;
708 audio->ch4.envelope.nextStep = state->audio.ch4.envelopeNextStep;
709 audio->ch4.lfsr = state->audio.ch4.lfsr;
710 audio->ch4.control.endTime = state->audio.ch4.endTime;
711 audio->nextCh4 = state->audio.ch4.nextEvent;
712
713 audio->nextEvent = state->audio.nextEvent;
714 audio->eventDiff = state->audio.eventDiff;
715 audio->nextSample = state->audio.nextSample;
716}