src/gba/gba-audio.c (view raw)
1/* Copyright (c) 2013-2014 Jeffrey Pfau
2 *
3 * This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
6#include "gba-audio.h"
7
8#include "gba.h"
9#include "gba-io.h"
10#include "gba-serialize.h"
11#include "gba-thread.h"
12#include "gba-video.h"
13
14const unsigned GBA_AUDIO_SAMPLES = 2048;
15const unsigned GBA_AUDIO_FIFO_SIZE = 8 * sizeof(int32_t);
16#define SWEEP_CYCLES (GBA_ARM7TDMI_FREQUENCY / 128)
17
18static bool _writeEnvelope(struct GBAAudioEnvelope* envelope, uint16_t value);
19static int32_t _updateSquareChannel(struct GBAAudioSquareControl* envelope, int duty);
20static void _updateEnvelope(struct GBAAudioEnvelope* envelope);
21static bool _updateSweep(struct GBAAudioChannel1* ch);
22static int32_t _updateChannel1(struct GBAAudioChannel1* ch);
23static int32_t _updateChannel2(struct GBAAudioChannel2* ch);
24static int32_t _updateChannel3(struct GBAAudioChannel3* ch);
25static int32_t _updateChannel4(struct GBAAudioChannel4* ch);
26static int _applyBias(struct GBAAudio* audio, int sample);
27static void _sample(struct GBAAudio* audio);
28
29void GBAAudioInit(struct GBAAudio* audio, size_t samples) {
30 CircleBufferInit(&audio->left, samples * sizeof(int32_t));
31 CircleBufferInit(&audio->right, samples * sizeof(int32_t));
32 CircleBufferInit(&audio->chA.fifo, GBA_AUDIO_FIFO_SIZE);
33 CircleBufferInit(&audio->chB.fifo, GBA_AUDIO_FIFO_SIZE);
34}
35
36void GBAAudioReset(struct GBAAudio* audio) {
37 audio->nextEvent = 0;
38 audio->nextCh1 = 0;
39 audio->nextCh2 = 0;
40 audio->nextCh3 = 0;
41 audio->nextCh4 = 0;
42 audio->ch1 = (struct GBAAudioChannel1) { .envelope = { .nextStep = INT_MAX }, .nextSweep = INT_MAX };
43 audio->ch2 = (struct GBAAudioChannel2) { .envelope = { .nextStep = INT_MAX } };
44 audio->ch3 = (struct GBAAudioChannel3) { .bank = { .bank = 0 } };
45 audio->ch4 = (struct GBAAudioChannel4) { .envelope = { .nextStep = INT_MAX } };
46 audio->chA.dmaSource = 0;
47 audio->chB.dmaSource = 0;
48 audio->chA.sample = 0;
49 audio->chB.sample = 0;
50 audio->eventDiff = 0;
51 audio->nextSample = 0;
52 audio->sampleRate = 0x8000;
53 audio->soundbias = 0x200;
54 audio->volumeRight = 0;
55 audio->volumeLeft = 0;
56 audio->ch1Right = false;
57 audio->ch2Right = false;
58 audio->ch3Right = false;
59 audio->ch4Right = false;
60 audio->ch1Left = false;
61 audio->ch2Left = false;
62 audio->ch3Left = false;
63 audio->ch4Left = false;
64 audio->volume = 0;
65 audio->volumeChA = false;
66 audio->volumeChB = false;
67 audio->chARight = false;
68 audio->chALeft = false;
69 audio->chATimer = false;
70 audio->chBRight = false;
71 audio->chBLeft = false;
72 audio->chBTimer = false;
73 audio->playingCh1 = false;
74 audio->playingCh2 = false;
75 audio->playingCh3 = false;
76 audio->playingCh4 = false;
77 audio->enable = false;
78 audio->sampleInterval = GBA_ARM7TDMI_FREQUENCY / audio->sampleRate;
79
80 CircleBufferClear(&audio->left);
81 CircleBufferClear(&audio->right);
82 CircleBufferClear(&audio->chA.fifo);
83 CircleBufferClear(&audio->chB.fifo);
84}
85
86void GBAAudioDeinit(struct GBAAudio* audio) {
87 CircleBufferDeinit(&audio->left);
88 CircleBufferDeinit(&audio->right);
89 CircleBufferDeinit(&audio->chA.fifo);
90 CircleBufferDeinit(&audio->chB.fifo);
91}
92
93void GBAAudioResizeBuffer(struct GBAAudio* audio, size_t samples) {
94 if (samples > GBA_AUDIO_SAMPLES) {
95 return;
96 }
97
98 GBASyncLockAudio(audio->p->sync);
99 int32_t buffer[GBA_AUDIO_SAMPLES];
100 int32_t dummy;
101 size_t read;
102 size_t i;
103
104 read = CircleBufferDump(&audio->left, buffer, sizeof(buffer));
105 CircleBufferDeinit(&audio->left);
106 CircleBufferInit(&audio->left, samples * sizeof(int32_t));
107 for (i = 0; i * sizeof(int32_t) < read; ++i) {
108 if (!CircleBufferWrite32(&audio->left, buffer[i])) {
109 CircleBufferRead32(&audio->left, &dummy);
110 CircleBufferWrite32(&audio->left, buffer[i]);
111 }
112 }
113
114 read = CircleBufferDump(&audio->right, buffer, sizeof(buffer));
115 CircleBufferDeinit(&audio->right);
116 CircleBufferInit(&audio->right, samples * sizeof(int32_t));
117 for (i = 0; i * sizeof(int32_t) < read; ++i) {
118 if (!CircleBufferWrite32(&audio->right, buffer[i])) {
119 CircleBufferRead32(&audio->right, &dummy);
120 CircleBufferWrite32(&audio->right, buffer[i]);
121 }
122 }
123
124 GBASyncConsumeAudio(audio->p->sync);
125}
126
127int32_t GBAAudioProcessEvents(struct GBAAudio* audio, int32_t cycles) {
128 audio->nextEvent -= cycles;
129 audio->eventDiff += cycles;
130 if (audio->nextEvent <= 0) {
131 audio->nextEvent = INT_MAX;
132 if (audio->enable) {
133 if (audio->playingCh1 && !audio->ch1.envelope.dead) {
134 audio->nextCh1 -= audio->eventDiff;
135 if (audio->ch1.envelope.nextStep != INT_MAX) {
136 audio->ch1.envelope.nextStep -= audio->eventDiff;
137 if (audio->ch1.envelope.nextStep <= 0) {
138 int8_t sample = audio->ch1.control.hi * 0x10 - 0x8;
139 _updateEnvelope(&audio->ch1.envelope);
140 if (audio->ch1.envelope.nextStep < audio->nextEvent) {
141 audio->nextEvent = audio->ch1.envelope.nextStep;
142 }
143 audio->ch1.sample = sample * audio->ch1.envelope.currentVolume;
144 }
145 }
146
147 if (audio->ch1.nextSweep != INT_MAX) {
148 audio->ch1.nextSweep -= audio->eventDiff;
149 if (audio->ch1.nextSweep <= 0) {
150 audio->playingCh1 = _updateSweep(&audio->ch1);
151 if (audio->ch1.nextSweep < audio->nextEvent) {
152 audio->nextEvent = audio->ch1.nextSweep;
153 }
154 }
155 }
156
157 if (audio->nextCh1 <= 0) {
158 audio->nextCh1 += _updateChannel1(&audio->ch1);
159 if (audio->nextCh1 < audio->nextEvent) {
160 audio->nextEvent = audio->nextCh1;
161 }
162 }
163
164 if (audio->ch1.control.stop) {
165 audio->ch1.control.endTime -= audio->eventDiff;
166 if (audio->ch1.control.endTime <= 0) {
167 audio->playingCh1 = 0;
168 }
169 }
170 }
171
172 if (audio->playingCh2 && !audio->ch2.envelope.dead) {
173 audio->nextCh2 -= audio->eventDiff;
174 if (audio->ch2.envelope.nextStep != INT_MAX) {
175 audio->ch2.envelope.nextStep -= audio->eventDiff;
176 if (audio->ch2.envelope.nextStep <= 0) {
177 int8_t sample = audio->ch2.control.hi * 0x10 - 0x8;
178 _updateEnvelope(&audio->ch2.envelope);
179 if (audio->ch2.envelope.nextStep < audio->nextEvent) {
180 audio->nextEvent = audio->ch2.envelope.nextStep;
181 }
182 audio->ch2.sample = sample * audio->ch2.envelope.currentVolume;
183 }
184 }
185
186 if (audio->nextCh2 <= 0) {
187 audio->nextCh2 += _updateChannel2(&audio->ch2);
188 if (audio->nextCh2 < audio->nextEvent) {
189 audio->nextEvent = audio->nextCh2;
190 }
191 }
192
193 if (audio->ch2.control.stop) {
194 audio->ch2.control.endTime -= audio->eventDiff;
195 if (audio->ch2.control.endTime <= 0) {
196 audio->playingCh2 = 0;
197 }
198 }
199 }
200
201 if (audio->playingCh3) {
202 audio->nextCh3 -= audio->eventDiff;
203 if (audio->nextCh3 <= 0) {
204 audio->nextCh3 += _updateChannel3(&audio->ch3);
205 if (audio->nextCh3 < audio->nextEvent) {
206 audio->nextEvent = audio->nextCh3;
207 }
208 }
209
210 if (audio->ch3.control.stop) {
211 audio->ch3.control.endTime -= audio->eventDiff;
212 if (audio->ch3.control.endTime <= 0) {
213 audio->playingCh3 = 0;
214 }
215 }
216 }
217
218 if (audio->playingCh4 && !audio->ch4.envelope.dead) {
219 audio->nextCh4 -= audio->eventDiff;
220 if (audio->ch4.envelope.nextStep != INT_MAX) {
221 audio->ch4.envelope.nextStep -= audio->eventDiff;
222 if (audio->ch4.envelope.nextStep <= 0) {
223 int8_t sample = (audio->ch4.sample >> 31) * 0x8;
224 _updateEnvelope(&audio->ch4.envelope);
225 if (audio->ch4.envelope.nextStep < audio->nextEvent) {
226 audio->nextEvent = audio->ch4.envelope.nextStep;
227 }
228 audio->ch4.sample = sample * audio->ch4.envelope.currentVolume;
229 }
230 }
231
232 if (audio->nextCh4 <= 0) {
233 audio->nextCh4 += _updateChannel4(&audio->ch4);
234 if (audio->nextCh4 < audio->nextEvent) {
235 audio->nextEvent = audio->nextCh4;
236 }
237 }
238
239 if (audio->ch4.control.stop) {
240 audio->ch4.control.endTime -= audio->eventDiff;
241 if (audio->ch4.control.endTime <= 0) {
242 audio->playingCh4 = 0;
243 }
244 }
245 }
246 }
247
248 audio->nextSample -= audio->eventDiff;
249 if (audio->nextSample <= 0) {
250 _sample(audio);
251 audio->nextSample += audio->sampleInterval;
252 }
253
254 if (audio->nextSample < audio->nextEvent) {
255 audio->nextEvent = audio->nextSample;
256 }
257 audio->eventDiff = 0;
258 }
259 return audio->nextEvent;
260}
261
262void GBAAudioScheduleFifoDma(struct GBAAudio* audio, int number, struct GBADMA* info) {
263 switch (info->dest) {
264 case BASE_IO | REG_FIFO_A_LO:
265 audio->chA.dmaSource = number;
266 break;
267 case BASE_IO | REG_FIFO_B_LO:
268 audio->chB.dmaSource = number;
269 break;
270 default:
271 GBALog(audio->p, GBA_LOG_GAME_ERROR, "Invalid FIFO destination: 0x%08X", info->dest);
272 return;
273 }
274 info->reg = GBADMARegisterSetDestControl(info->reg, DMA_FIXED);
275}
276
277void GBAAudioWriteSOUND1CNT_LO(struct GBAAudio* audio, uint16_t value) {
278 audio->ch1.sweep.shift = GBAAudioRegisterSquareSweepGetShift(value);
279 audio->ch1.sweep.direction = GBAAudioRegisterSquareSweepGetDirection(value);
280 audio->ch1.sweep.time = GBAAudioRegisterSquareSweepGetTime(value);
281 if (audio->ch1.sweep.time) {
282 audio->ch1.nextSweep = audio->ch1.sweep.time * SWEEP_CYCLES;
283 } else {
284 audio->ch1.nextSweep = INT_MAX;
285 }
286}
287
288void GBAAudioWriteSOUND1CNT_HI(struct GBAAudio* audio, uint16_t value) {
289 if (!_writeEnvelope(&audio->ch1.envelope, value)) {
290 audio->ch1.sample = 0;
291 }
292}
293
294void GBAAudioWriteSOUND1CNT_X(struct GBAAudio* audio, uint16_t value) {
295 audio->ch1.control.frequency = GBAAudioRegisterControlGetFrequency(value);
296 audio->ch1.control.stop = GBAAudioRegisterControlGetStop(value);
297 audio->ch1.control.endTime = (GBA_ARM7TDMI_FREQUENCY * (64 - audio->ch1.envelope.length)) >> 8;
298 if (GBAAudioRegisterControlIsRestart(value)) {
299 if (audio->ch1.sweep.time) {
300 audio->ch1.nextSweep = audio->ch1.sweep.time * SWEEP_CYCLES;
301 } else {
302 audio->ch1.nextSweep = INT_MAX;
303 }
304 if (!audio->playingCh1) {
305 audio->nextCh1 = 0;
306 }
307 audio->playingCh1 = 1;
308 if (audio->ch1.envelope.stepTime) {
309 audio->ch1.envelope.nextStep = 0;
310 } else {
311 audio->ch1.envelope.nextStep = INT_MAX;
312 }
313 audio->ch1.envelope.currentVolume = audio->ch1.envelope.initialVolume;
314 if (audio->ch1.envelope.stepTime) {
315 audio->ch1.envelope.nextStep = 0;
316 } else {
317 audio->ch1.envelope.nextStep = INT_MAX;
318 }
319 }
320}
321
322void GBAAudioWriteSOUND2CNT_LO(struct GBAAudio* audio, uint16_t value) {
323 if (!_writeEnvelope(&audio->ch2.envelope, value)) {
324 audio->ch2.sample = 0;
325 }
326}
327
328void GBAAudioWriteSOUND2CNT_HI(struct GBAAudio* audio, uint16_t value) {
329 audio->ch2.control.frequency = GBAAudioRegisterControlGetFrequency(value);
330 audio->ch2.control.stop = GBAAudioRegisterControlGetStop(value);
331 audio->ch2.control.endTime = (GBA_ARM7TDMI_FREQUENCY * (64 - audio->ch2.envelope.length)) >> 8;
332 if (GBAAudioRegisterControlIsRestart(value)) {
333 audio->playingCh2 = 1;
334 audio->ch2.envelope.currentVolume = audio->ch2.envelope.initialVolume;
335 if (audio->ch2.envelope.stepTime) {
336 audio->ch2.envelope.nextStep = 0;
337 } else {
338 audio->ch2.envelope.nextStep = INT_MAX;
339 }
340 audio->nextCh2 = 0;
341 }
342}
343
344void GBAAudioWriteSOUND3CNT_LO(struct GBAAudio* audio, uint16_t value) {
345 audio->ch3.bank.size = GBAAudioRegisterBankGetSize(value);
346 audio->ch3.bank.bank = GBAAudioRegisterBankGetBank(value);
347 audio->ch3.bank.enable = GBAAudioRegisterBankGetEnable(value);
348 if (audio->ch3.control.endTime >= 0) {
349 audio->playingCh3 = audio->ch3.bank.enable;
350 }
351}
352
353void GBAAudioWriteSOUND3CNT_HI(struct GBAAudio* audio, uint16_t value) {
354 audio->ch3.wave.length = GBAAudioRegisterBankWaveGetLength(value);
355 audio->ch3.wave.volume = GBAAudioRegisterBankWaveGetVolume(value);
356}
357
358void GBAAudioWriteSOUND3CNT_X(struct GBAAudio* audio, uint16_t value) {
359 audio->ch3.control.rate = GBAAudioRegisterControlGetRate(value);
360 audio->ch3.control.stop = GBAAudioRegisterControlGetStop(value);
361 audio->ch3.control.endTime = (GBA_ARM7TDMI_FREQUENCY * (256 - audio->ch3.wave.length)) >> 8;
362 if (GBAAudioRegisterControlIsRestart(value)) {
363 audio->playingCh3 = audio->ch3.bank.enable;
364 }
365}
366
367void GBAAudioWriteSOUND4CNT_LO(struct GBAAudio* audio, uint16_t value) {
368 if (!_writeEnvelope(&audio->ch4.envelope, value)) {
369 audio->ch4.sample = 0;
370 }
371}
372
373void GBAAudioWriteSOUND4CNT_HI(struct GBAAudio* audio, uint16_t value) {
374 audio->ch4.control.ratio = GBAAudioRegisterCh4ControlGetRatio(value);
375 audio->ch4.control.frequency = GBAAudioRegisterCh4ControlGetFrequency(value);
376 audio->ch4.control.power = GBAAudioRegisterCh4ControlGetPower(value);
377 audio->ch4.control.stop = GBAAudioRegisterCh4ControlGetStop(value);
378 audio->ch4.control.endTime = (GBA_ARM7TDMI_FREQUENCY * (64 - audio->ch4.envelope.length)) >> 8;
379 if (GBAAudioRegisterCh4ControlIsRestart(value)) {
380 audio->playingCh4 = 1;
381 audio->ch4.envelope.currentVolume = audio->ch4.envelope.initialVolume;
382 if (audio->ch4.envelope.stepTime) {
383 audio->ch4.envelope.nextStep = 0;
384 } else {
385 audio->ch4.envelope.nextStep = INT_MAX;
386 }
387 if (audio->ch4.control.power) {
388 audio->ch4.lfsr = 0x40;
389 } else {
390 audio->ch4.lfsr = 0x4000;
391 }
392 audio->nextCh4 = 0;
393 }
394}
395
396void GBAAudioWriteSOUNDCNT_LO(struct GBAAudio* audio, uint16_t value) {
397 audio->volumeRight = GBARegisterSOUNDCNT_LOGetVolumeRight(value);
398 audio->volumeLeft = GBARegisterSOUNDCNT_LOGetVolumeLeft(value);
399 audio->ch1Right = GBARegisterSOUNDCNT_LOGetCh1Right(value);
400 audio->ch2Right = GBARegisterSOUNDCNT_LOGetCh2Right(value);
401 audio->ch3Right = GBARegisterSOUNDCNT_LOGetCh3Right(value);
402 audio->ch4Right = GBARegisterSOUNDCNT_LOGetCh4Right(value);
403 audio->ch1Left = GBARegisterSOUNDCNT_LOGetCh1Left(value);
404 audio->ch2Left = GBARegisterSOUNDCNT_LOGetCh2Left(value);
405 audio->ch3Left = GBARegisterSOUNDCNT_LOGetCh3Left(value);
406 audio->ch4Left = GBARegisterSOUNDCNT_LOGetCh4Left(value);
407}
408
409void GBAAudioWriteSOUNDCNT_HI(struct GBAAudio* audio, uint16_t value) {
410 audio->volume = GBARegisterSOUNDCNT_HIGetVolume(value);
411 audio->volumeChA = GBARegisterSOUNDCNT_HIGetVolumeChA(value);
412 audio->volumeChB = GBARegisterSOUNDCNT_HIGetVolumeChB(value);
413 audio->chARight = GBARegisterSOUNDCNT_HIGetChARight(value);
414 audio->chALeft = GBARegisterSOUNDCNT_HIGetChALeft(value);
415 audio->chATimer = GBARegisterSOUNDCNT_HIGetChATimer(value);
416 audio->chBRight = GBARegisterSOUNDCNT_HIGetChBRight(value);
417 audio->chBLeft = GBARegisterSOUNDCNT_HIGetChBLeft(value);
418 audio->chBTimer = GBARegisterSOUNDCNT_HIGetChBTimer(value);
419 // TODO: Implement channel reset
420}
421
422void GBAAudioWriteSOUNDCNT_X(struct GBAAudio* audio, uint16_t value) {
423 audio->enable = GBARegisterSOUNDCNT_XGetEnable(value);
424}
425
426void GBAAudioWriteSOUNDBIAS(struct GBAAudio* audio, uint16_t value) {
427 audio->soundbias = value;
428}
429
430void GBAAudioWriteWaveRAM(struct GBAAudio* audio, int address, uint32_t value) {
431 audio->ch3.wavedata[address | (!audio->ch3.bank.bank * 4)] = value;
432}
433
434void GBAAudioWriteFIFO(struct GBAAudio* audio, int address, uint32_t value) {
435 struct CircleBuffer* fifo;
436 switch (address) {
437 case REG_FIFO_A_LO:
438 fifo = &audio->chA.fifo;
439 break;
440 case REG_FIFO_B_LO:
441 fifo = &audio->chB.fifo;
442 break;
443 default:
444 GBALog(audio->p, GBA_LOG_ERROR, "Bad FIFO write to address 0x%03x", address);
445 return;
446 }
447 int i;
448 for (i = 0; i < 4; ++i) {
449 while (!CircleBufferWrite8(fifo, value >> (8 * i))) {
450 int8_t dummy;
451 CircleBufferRead8(fifo, &dummy);
452 }
453 }
454}
455
456void GBAAudioSampleFIFO(struct GBAAudio* audio, int fifoId, int32_t cycles) {
457 struct GBAAudioFIFO* channel;
458 if (fifoId == 0) {
459 channel = &audio->chA;
460 } else if (fifoId == 1) {
461 channel = &audio->chB;
462 } else {
463 GBALog(audio->p, GBA_LOG_ERROR, "Bad FIFO write to address 0x%03x", fifoId);
464 return;
465 }
466 if (CircleBufferSize(&channel->fifo) <= 4 * sizeof(int32_t)) {
467 struct GBADMA* dma = &audio->p->memory.dma[channel->dmaSource];
468 dma->nextCount = 4;
469 dma->nextEvent = 0;
470 GBAMemoryUpdateDMAs(audio->p, -cycles);
471 }
472 CircleBufferRead8(&channel->fifo, &channel->sample);
473}
474
475unsigned GBAAudioCopy(struct GBAAudio* audio, void* left, void* right, unsigned nSamples) {
476 GBASyncLockAudio(audio->p->sync);
477 unsigned read = 0;
478 if (left) {
479 unsigned readL = CircleBufferRead(&audio->left, left, nSamples * sizeof(int32_t)) >> 2;
480 if (readL < nSamples) {
481 memset((int32_t*) left + readL, 0, nSamples - readL);
482 }
483 read = readL;
484 }
485 if (right) {
486 unsigned readR = CircleBufferRead(&audio->right, right, nSamples * sizeof(int32_t)) >> 2;
487 if (readR < nSamples) {
488 memset((int32_t*) right + readR, 0, nSamples - readR);
489 }
490 read = read >= readR ? read : readR;
491 }
492 GBASyncConsumeAudio(audio->p->sync);
493 return read;
494}
495
496unsigned GBAAudioResampleNN(struct GBAAudio* audio, float ratio, float* drift, struct GBAStereoSample* output, unsigned nSamples) {
497 int32_t left[GBA_AUDIO_SAMPLES];
498 int32_t right[GBA_AUDIO_SAMPLES];
499
500 // toRead is in GBA samples
501 // TODO: Do this with fixed-point math
502 unsigned toRead = ceilf(nSamples / ratio);
503 unsigned totalRead = 0;
504 while (nSamples) {
505 unsigned currentRead = GBA_AUDIO_SAMPLES;
506 if (currentRead > toRead) {
507 currentRead = toRead;
508 }
509 unsigned read = GBAAudioCopy(audio, left, right, currentRead);
510 toRead -= read;
511 unsigned i;
512 for (i = 0; i < read; ++i) {
513 *drift += ratio;
514 while (*drift >= 1.f) {
515 output->left = left[i];
516 output->right = right[i];
517 ++output;
518 ++totalRead;
519 --nSamples;
520 *drift -= 1.f;
521 if (!nSamples) {
522 return totalRead;
523 }
524 }
525 }
526 if (read < currentRead) {
527 memset(output, 0, nSamples * sizeof(struct GBAStereoSample));
528 break;
529 }
530 }
531 return totalRead;
532}
533
534bool _writeEnvelope(struct GBAAudioEnvelope* envelope, uint16_t value) {
535 envelope->length = GBAAudioRegisterEnvelopeGetLength(value);
536 envelope->duty = GBAAudioRegisterEnvelopeGetDuty(value);
537 envelope->stepTime = GBAAudioRegisterEnvelopeGetStepTime(value);
538 envelope->direction = GBAAudioRegisterEnvelopeGetDirection(value);
539 envelope->initialVolume = GBAAudioRegisterEnvelopeGetInitialVolume(value);
540 envelope->dead = 0;
541 if (envelope->stepTime) {
542 envelope->nextStep = 0;
543 } else {
544 envelope->nextStep = INT_MAX;
545 if (envelope->initialVolume == 0) {
546 envelope->dead = 1;
547 return false;
548 }
549 }
550 return true;
551}
552
553static int32_t _updateSquareChannel(struct GBAAudioSquareControl* control, int duty) {
554 control->hi = !control->hi;
555 int period = 16 * (2048 - control->frequency);
556 switch (duty) {
557 case 0:
558 return control->hi ? period : period * 7;
559 case 1:
560 return control->hi ? period * 2 : period * 6;
561 case 2:
562 return period * 4;
563 case 3:
564 return control->hi ? period * 6 : period * 2;
565 default:
566 // This should never be hit
567 return period * 4;
568 }
569}
570
571static void _updateEnvelope(struct GBAAudioEnvelope* envelope) {
572 if (envelope->direction) {
573 ++envelope->currentVolume;
574 } else {
575 --envelope->currentVolume;
576 }
577 if (envelope->currentVolume >= 15) {
578 envelope->currentVolume = 15;
579 envelope->nextStep = INT_MAX;
580 } else if (envelope->currentVolume <= 0) {
581 envelope->currentVolume = 0;
582 envelope->dead = 1;
583 envelope->nextStep = INT_MAX;
584 } else {
585 envelope->nextStep += envelope->stepTime * (GBA_ARM7TDMI_FREQUENCY >> 6);
586 }
587}
588
589static bool _updateSweep(struct GBAAudioChannel1* ch) {
590 if (ch->sweep.direction) {
591 int frequency = ch->control.frequency;
592 frequency -= frequency >> ch->sweep.shift;
593 if (frequency >= 0) {
594 ch->control.frequency = frequency;
595 }
596 } else {
597 int frequency = ch->control.frequency;
598 frequency += frequency >> ch->sweep.shift;
599 if (frequency < 2048) {
600 ch->control.frequency = frequency;
601 } else {
602 return false;
603 }
604 }
605 ch->nextSweep += ch->sweep.time * SWEEP_CYCLES;
606 return true;
607}
608
609static int32_t _updateChannel1(struct GBAAudioChannel1* ch) {
610 int timing = _updateSquareChannel(&ch->control, ch->envelope.duty);
611 ch->sample = ch->control.hi * 0x10 - 0x8;
612 ch->sample *= ch->envelope.currentVolume;
613 return timing;
614}
615
616static int32_t _updateChannel2(struct GBAAudioChannel2* ch) {
617 int timing = _updateSquareChannel(&ch->control, ch->envelope.duty);
618 ch->sample = ch->control.hi * 0x10 - 0x8;
619 ch->sample *= ch->envelope.currentVolume;
620 return timing;
621}
622
623static int32_t _updateChannel3(struct GBAAudioChannel3* ch) {
624 int i;
625 int start;
626 int end;
627 int volume;
628 switch (ch->wave.volume) {
629 case 0:
630 volume = 0;
631 break;
632 case 1:
633 volume = 4;
634 break;
635 case 2:
636 volume = 2;
637 break;
638 case 3:
639 volume = 1;
640 break;
641 default:
642 volume = 3;
643 break;
644 }
645 if (ch->bank.size) {
646 start = 7;
647 end = 0;
648 } else if (ch->bank.bank) {
649 start = 7;
650 end = 4;
651 } else {
652 start = 3;
653 end = 0;
654 }
655 uint32_t bitsCarry = ch->wavedata[end] & 0x0F000000;
656 uint32_t bits;
657 for (i = start; i >= end; --i) {
658 bits = ch->wavedata[i] & 0x0F000000;
659 ch->wavedata[i] = ((ch->wavedata[i] & 0xF0F0F0F0) >> 4) | ((ch->wavedata[i] & 0x000F0F0F) << 12);
660 ch->wavedata[i] |= bitsCarry >> 20;
661 bitsCarry = bits;
662 }
663 ch->sample = bitsCarry >> 24;
664 ch->sample -= 8;
665 ch->sample *= volume * 4;
666 return 8 * (2048 - ch->control.rate);
667}
668
669static int32_t _updateChannel4(struct GBAAudioChannel4* ch) {
670 int lsb = ch->lfsr & 1;
671 ch->sample = lsb * 0x10 - 0x8;
672 ch->sample *= ch->envelope.currentVolume;
673 ch->lfsr >>= 1;
674 ch->lfsr ^= (lsb * 0x60) << (ch->control.power ? 0 : 8);
675 int timing = ch->control.ratio ? 2 * ch->control.ratio : 1;
676 timing <<= ch->control.frequency;
677 timing *= 32;
678 return timing;
679}
680
681static int _applyBias(struct GBAAudio* audio, int sample) {
682 sample += GBARegisterSOUNDBIASGetBias(audio->soundbias);
683 if (sample >= 0x400) {
684 sample = 0x3FF;
685 } else if (sample < 0) {
686 sample = 0;
687 }
688 return (sample - GBARegisterSOUNDBIASGetBias(audio->soundbias)) << 6;
689}
690
691static void _sample(struct GBAAudio* audio) {
692 int32_t sampleLeft = 0;
693 int32_t sampleRight = 0;
694 int psgShift = 6 - audio->volume;
695
696 if (audio->ch1Left) {
697 sampleLeft += audio->ch1.sample;
698 }
699
700 if (audio->ch1Right) {
701 sampleRight += audio->ch1.sample;
702 }
703
704 if (audio->ch2Left) {
705 sampleLeft += audio->ch2.sample;
706 }
707
708 if (audio->ch2Right) {
709 sampleRight += audio->ch2.sample;
710 }
711
712 if (audio->ch3Left) {
713 sampleLeft += audio->ch3.sample;
714 }
715
716 if (audio->ch3Right) {
717 sampleRight += audio->ch3.sample;
718 }
719
720 if (audio->ch4Left) {
721 sampleLeft += audio->ch4.sample;
722 }
723
724 if (audio->ch4Right) {
725 sampleRight += audio->ch4.sample;
726 }
727
728 sampleLeft = (sampleLeft * (1 + audio->volumeLeft)) >> psgShift;
729 sampleRight = (sampleRight * (1 + audio->volumeRight)) >> psgShift;
730
731 if (audio->chALeft) {
732 sampleLeft += (audio->chA.sample << 2) >> !audio->volumeChA;
733 }
734
735 if (audio->chARight) {
736 sampleRight += (audio->chA.sample << 2) >> !audio->volumeChA;
737 }
738
739 if (audio->chBLeft) {
740 sampleLeft += (audio->chB.sample << 2) >> !audio->volumeChB;
741 }
742
743 if (audio->chBRight) {
744 sampleRight += (audio->chB.sample << 2) >> !audio->volumeChB;
745 }
746
747 sampleLeft = _applyBias(audio, sampleLeft);
748 sampleRight = _applyBias(audio, sampleRight);
749
750 GBASyncLockAudio(audio->p->sync);
751 CircleBufferWrite32(&audio->left, sampleLeft);
752 CircleBufferWrite32(&audio->right, sampleRight);
753 unsigned produced = CircleBufferSize(&audio->left);
754 struct GBAThread* thread = GBAThreadGetContext();
755 if (thread && thread->stream) {
756 thread->stream->postAudioFrame(thread->stream, sampleLeft, sampleRight);
757 }
758 GBASyncProduceAudio(audio->p->sync, produced >= CircleBufferCapacity(&audio->left) / sizeof(int32_t) * 3);
759}
760
761void GBAAudioSerialize(const struct GBAAudio* audio, struct GBASerializedState* state) {
762 state->audio.ch1Volume = audio->ch1.envelope.currentVolume;
763 state->audio.ch1Dead = audio->ch1.envelope.dead;
764 state->audio.ch1Hi = audio->ch1.control.hi;
765 state->audio.ch1.envelopeNextStep = audio->ch1.envelope.nextStep;
766 state->audio.ch1.waveNextStep = audio->ch1.control.nextStep;
767 state->audio.ch1.sweepNextStep = audio->ch1.nextSweep;
768 state->audio.ch1.endTime = audio->ch1.control.endTime;
769 state->audio.ch1.nextEvent = audio->nextCh1;
770
771 state->audio.ch2Volume = audio->ch2.envelope.currentVolume;
772 state->audio.ch2Dead = audio->ch2.envelope.dead;
773 state->audio.ch2Hi = audio->ch2.control.hi;
774 state->audio.ch2.envelopeNextStep = audio->ch2.envelope.nextStep;
775 state->audio.ch2.waveNextStep = audio->ch2.control.nextStep;
776 state->audio.ch2.endTime = audio->ch2.control.endTime;
777 state->audio.ch2.nextEvent = audio->nextCh2;
778
779 memcpy(state->audio.ch3.wavebanks, audio->ch3.wavedata, sizeof(state->audio.ch3.wavebanks));
780 state->audio.ch3.endTime = audio->ch3.control.endTime;
781 state->audio.ch3.nextEvent = audio->nextCh3;
782
783 state->audio.ch4Volume = audio->ch4.envelope.currentVolume;
784 state->audio.ch4Dead = audio->ch4.envelope.dead;
785 state->audio.ch4.envelopeNextStep = audio->ch4.envelope.nextStep;
786 state->audio.ch4.lfsr = audio->ch4.lfsr;
787 state->audio.ch4.endTime = audio->ch4.control.endTime;
788 state->audio.ch4.nextEvent = audio->nextCh4;
789
790 CircleBufferDump(&audio->chA.fifo, state->audio.fifoA, sizeof(state->audio.fifoA));
791 CircleBufferDump(&audio->chB.fifo, state->audio.fifoB, sizeof(state->audio.fifoB));
792 state->audio.fifoSize = CircleBufferSize(&audio->chA.fifo);
793
794 state->audio.nextEvent = audio->nextEvent;
795 state->audio.eventDiff = audio->eventDiff;
796 state->audio.nextSample = audio->nextSample;
797}
798
799void GBAAudioDeserialize(struct GBAAudio* audio, const struct GBASerializedState* state) {
800 audio->ch1.envelope.currentVolume = state->audio.ch1Volume;
801 audio->ch1.envelope.dead = state->audio.ch1Dead;
802 audio->ch1.control.hi = state->audio.ch1Hi;
803 audio->ch1.envelope.nextStep = state->audio.ch1.envelopeNextStep;
804 audio->ch1.control.nextStep = state->audio.ch1.waveNextStep;
805 audio->ch1.nextSweep = state->audio.ch1.sweepNextStep;
806 audio->ch1.control.endTime = state->audio.ch1.endTime;
807 audio->nextCh1 = state->audio.ch1.nextEvent;
808
809 audio->ch2.envelope.currentVolume = state->audio.ch2Volume;
810 audio->ch2.envelope.dead = state->audio.ch2Dead;
811 audio->ch2.control.hi = state->audio.ch2Hi;
812 audio->ch2.envelope.nextStep = state->audio.ch2.envelopeNextStep;
813 audio->ch2.control.nextStep = state->audio.ch2.waveNextStep;
814 audio->ch2.control.endTime = state->audio.ch2.endTime;
815 audio->nextCh2 = state->audio.ch2.nextEvent;
816
817 memcpy(audio->ch3.wavedata, state->audio.ch3.wavebanks, sizeof(audio->ch3.wavedata));
818 audio->ch3.control.endTime = state->audio.ch3.endTime;
819 audio->nextCh3 = state->audio.ch3.nextEvent;
820
821 audio->ch4.envelope.currentVolume = state->audio.ch4Volume;
822 audio->ch4.envelope.dead = state->audio.ch4Dead;
823 audio->ch4.envelope.nextStep = state->audio.ch4.envelopeNextStep;
824 audio->ch4.lfsr = state->audio.ch4.lfsr;
825 audio->ch4.control.endTime = state->audio.ch4.endTime;
826 audio->nextCh4 = state->audio.ch4.nextEvent;
827
828 CircleBufferClear(&audio->chA.fifo);
829 CircleBufferClear(&audio->chB.fifo);
830 int i;
831 for (i = 0; i < state->audio.fifoSize; ++i) {
832 CircleBufferWrite8(&audio->chA.fifo, state->audio.fifoA[i]);
833 CircleBufferWrite8(&audio->chB.fifo, state->audio.fifoB[i]);
834 }
835
836 audio->nextEvent = state->audio.nextEvent;
837 audio->eventDiff = state->audio.eventDiff;
838 audio->nextSample = state->audio.nextSample;
839}
840
841float GBAAudioCalculateRatio(struct GBAAudio* audio, float desiredFPS, float desiredSampleRate) {
842 return desiredSampleRate * GBA_ARM7TDMI_FREQUENCY / (VIDEO_TOTAL_LENGTH * desiredFPS * audio->sampleRate);
843}