1 // license:BSD-3-Clause
2 // copyright-holders:Wilbert Pol, Anthony Kruize
3 // thanks-to:Shay Green
4 /**************************************************************************************
5 * Game Boy sound emulation (c) Anthony Kruize (trandor@labyrinth.net.au)
6 *
7 * Anyways, sound on the Game Boy consists of 4 separate 'channels'
8 * Sound1 = Quadrangular waves with SWEEP and ENVELOPE functions (NR10,11,12,13,14)
9 * Sound2 = Quadrangular waves with ENVELOPE functions (NR21,22,23,24)
10 * Sound3 = Wave patterns from WaveRAM (NR30,31,32,33,34)
11 * Sound4 = White noise with an envelope (NR41,42,43,44)
12 *
13 * Each sound channel has 2 modes, namely ON and OFF... whoa
14 *
15 * These tend to be the two most important equations in
16 * converting between Hertz and GB frequency registers:
17 * (Sounds will have a 2.4% higher frequency on Super GB.)
18 * gb = 2048 - (131072 / Hz)
19 * Hz = 131072 / (2048 - gb)
20 *
21 * Changes:
22 *
23 * 10/2/2002 AK - Preliminary sound code.
24 * 13/2/2002 AK - Added a hack for mode 4, other fixes.
25 * 23/2/2002 AK - Use lookup tables, added sweep to mode 1. Re-wrote the square
26 * wave generation.
27 * 13/3/2002 AK - Added mode 3, better lookup tables, other adjustments.
28 * 15/3/2002 AK - Mode 4 can now change frequencies.
29 * 31/3/2002 AK - Accidently forgot to handle counter/consecutive for mode 1.
30 * 3/4/2002 AK - Mode 1 sweep can still occur if shift is 0. Don't let frequency
31 * go past the maximum allowed value. Fixed Mode 3 length table.
32 * Slight adjustment to Mode 4's period table generation.
33 * 5/4/2002 AK - Mode 4 is done correctly, using a polynomial counter instead
34 * of being a total hack.
35 * 6/4/2002 AK - Slight tweak to mode 3's frequency calculation.
36 * 13/4/2002 AK - Reset envelope value when sound is initialized.
37 * 21/4/2002 AK - Backed out the mode 3 frequency calculation change.
38 * Merged init functions into gameboy_sound_w().
39 * 14/5/2002 AK - Removed magic numbers in the fixed point math.
40 * 12/6/2002 AK - Merged SOUNDx structs into one SOUND struct.
41 * 26/10/2002 AK - Finally fixed channel 3!
42 * xx/4-5/2016 WP - Rewrote sound core. Most of the code is not optimized yet.
43
44 TODO:
45 - Implement different behavior of CGB-02.
46 - Implement different behavior of CGB-05.
47 - Perform more tests on real hardware to figure out when the frequency counters are
48 reloaded.
49 - Perform more tests on real hardware to understand when changes to the noise divisor
50 and shift kick in.
51 - Optimize the channel update methods.
52
53 ***************************************************************************************/
54
55 #include "emu.h"
56 #include "gb.h"
57
58
59 /***************************************************************************
60 CONSTANTS
61 ***************************************************************************/
62
63
64 /* Represents wave duties of 12.5%, 25%, 50% and 75% */
65 const int gameboy_sound_device::wave_duty_table[4][8] =
66 {
67 { -1, -1, -1, -1, -1, -1, -1, 1},
68 { 1, -1, -1, -1, -1, -1, -1, 1},
69 { 1, -1, -1, -1, -1, 1, 1, 1},
70 { -1, 1, 1, 1, 1, 1, 1, -1}
71 };
72
73 // device type definitions
74 DEFINE_DEVICE_TYPE(DMG_APU, dmg_apu_device, "dmg_apu", "LR35902 APU")
75 //DEFINE_DEVICE_TYPE(CGB02_APU, cgb02_apu_device, "cgb02_apu", fullname)
76 DEFINE_DEVICE_TYPE(CGB04_APU, cgb04_apu_device, "cgb04_apu", "CGB04 APU")
77 //DEFINE_DEVICE_TYPE(CGB05_APU, cgb05_apu_device, "cgb05_apu", fullname)
78
79 //**************************************************************************
80 // LIVE DEVICE
81 //**************************************************************************
82
83 //-------------------------------------------------
84 // gameboy_sound_device - constructor
85 //-------------------------------------------------
86
gameboy_sound_device(const machine_config & mconfig,device_type type,const char * tag,device_t * owner,uint32_t clock)87 gameboy_sound_device::gameboy_sound_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, uint32_t clock)
88 : device_t(mconfig, type, tag, owner, clock)
89 , device_sound_interface(mconfig, *this)
90 {
91 }
92
93
dmg_apu_device(const machine_config & mconfig,const char * tag,device_t * owner,uint32_t clock)94 dmg_apu_device::dmg_apu_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
95 : gameboy_sound_device(mconfig, DMG_APU, tag, owner, clock)
96 {
97 }
98
99
cgb04_apu_device(const machine_config & mconfig,const char * tag,device_t * owner,uint32_t clock)100 cgb04_apu_device::cgb04_apu_device(const machine_config &mconfig, const char *tag, device_t *owner, uint32_t clock)
101 : gameboy_sound_device(mconfig, CGB04_APU, tag, owner, clock)
102 {
103 }
104
105
106 //-------------------------------------------------
107 // device_start - device-specific startup
108 //-------------------------------------------------
109
110 #define SAVE_CHANNEL(snd) \
111 save_item(NAME(snd.reg)); \
112 save_item(NAME(snd.on)); \
113 save_item(NAME(snd.channel)); \
114 save_item(NAME(snd.length)); \
115 save_item(NAME(snd.length_mask)); \
116 save_item(NAME(snd.length_counting)); \
117 save_item(NAME(snd.length_enabled)); \
118 save_item(NAME(snd.cycles_left)); \
119 save_item(NAME(snd.duty)); \
120 save_item(NAME(snd.envelope_enabled)); \
121 save_item(NAME(snd.envelope_value)); \
122 save_item(NAME(snd.envelope_direction)); \
123 save_item(NAME(snd.envelope_time)); \
124 save_item(NAME(snd.envelope_count)); \
125 save_item(NAME(snd.signal)); \
126 save_item(NAME(snd.frequency)); \
127 save_item(NAME(snd.frequency_counter)); \
128 save_item(NAME(snd.sweep_enabled)); \
129 save_item(NAME(snd.sweep_neg_mode_used)); \
130 save_item(NAME(snd.sweep_shift)); \
131 save_item(NAME(snd.sweep_direction)); \
132 save_item(NAME(snd.sweep_time)); \
133 save_item(NAME(snd.sweep_count)); \
134 save_item(NAME(snd.level)); \
135 save_item(NAME(snd.offset)); \
136 save_item(NAME(snd.duty_count)); \
137 save_item(NAME(snd.current_sample)); \
138 save_item(NAME(snd.sample_reading)); \
139 save_item(NAME(snd.noise_short)); \
140 save_item(NAME(snd.noise_lfsr));
141
142
device_start()143 void gameboy_sound_device::device_start()
144 {
145 m_channel = stream_alloc(0, 2, SAMPLE_RATE_OUTPUT_ADAPTIVE);
146 m_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(gameboy_sound_device::timer_callback),this));
147 m_timer->adjust(clocks_to_attotime(FRAME_CYCLES/128), 0, clocks_to_attotime(FRAME_CYCLES/128));
148
149 save_item(NAME(m_last_updated));
150 save_item(NAME(m_snd_regs));
151 // sound control
152 save_item(NAME(m_snd_control.on));
153 save_item(NAME(m_snd_control.vol_left));
154 save_item(NAME(m_snd_control.vol_right));
155 save_item(NAME(m_snd_control.mode1_left));
156 save_item(NAME(m_snd_control.mode1_right));
157 save_item(NAME(m_snd_control.mode2_left));
158 save_item(NAME(m_snd_control.mode2_right));
159 save_item(NAME(m_snd_control.mode3_left));
160 save_item(NAME(m_snd_control.mode3_right));
161 save_item(NAME(m_snd_control.mode4_left));
162 save_item(NAME(m_snd_control.mode4_right));
163 save_item(NAME(m_snd_control.cycles));
164
165 SAVE_CHANNEL(m_snd_1);
166 SAVE_CHANNEL(m_snd_2);
167 SAVE_CHANNEL(m_snd_3);
168 SAVE_CHANNEL(m_snd_4);
169 }
170
171
172 //-------------------------------------------------
173 // device_clock_changed
174 //-------------------------------------------------
175
device_clock_changed()176 void gameboy_sound_device::device_clock_changed()
177 {
178 m_timer->adjust(clocks_to_attotime(FRAME_CYCLES / 128), 0, clocks_to_attotime(FRAME_CYCLES / 128));
179 }
180
181
182 //-------------------------------------------------
183 // device_reset
184 //-------------------------------------------------
185
device_reset()186 void gameboy_sound_device::device_reset()
187 {
188 memset(&m_snd_1, 0, sizeof(m_snd_1));
189 memset(&m_snd_2, 0, sizeof(m_snd_2));
190 memset(&m_snd_3, 0, sizeof(m_snd_3));
191 memset(&m_snd_4, 0, sizeof(m_snd_4));
192
193 m_snd_1.channel = 1;
194 m_snd_1.length_mask = 0x3F;
195 m_snd_2.channel = 2;
196 m_snd_2.length_mask = 0x3F;
197 m_snd_3.channel = 3;
198 m_snd_3.length_mask = 0xFF;
199 m_snd_4.channel = 4;
200 m_snd_4.length_mask = 0x3F;
201
202 sound_w_internal(NR52, 0x00);
203 m_snd_regs[AUD3W0] = 0xac;
204 m_snd_regs[AUD3W1] = 0xdd;
205 m_snd_regs[AUD3W2] = 0xda;
206 m_snd_regs[AUD3W3] = 0x48;
207 m_snd_regs[AUD3W4] = 0x36;
208 m_snd_regs[AUD3W5] = 0x02;
209 m_snd_regs[AUD3W6] = 0xcf;
210 m_snd_regs[AUD3W7] = 0x16;
211 m_snd_regs[AUD3W8] = 0x2c;
212 m_snd_regs[AUD3W9] = 0x04;
213 m_snd_regs[AUD3WA] = 0xe5;
214 m_snd_regs[AUD3WB] = 0x2c;
215 m_snd_regs[AUD3WC] = 0xac;
216 m_snd_regs[AUD3WD] = 0xdd;
217 m_snd_regs[AUD3WE] = 0xda;
218 m_snd_regs[AUD3WF] = 0x48;
219 }
220
221
device_reset()222 void cgb04_apu_device::device_reset()
223 {
224 gameboy_sound_device::device_reset();
225
226 m_snd_regs[AUD3W0] = 0x00;
227 m_snd_regs[AUD3W1] = 0xFF;
228 m_snd_regs[AUD3W2] = 0x00;
229 m_snd_regs[AUD3W3] = 0xFF;
230 m_snd_regs[AUD3W4] = 0x00;
231 m_snd_regs[AUD3W5] = 0xFF;
232 m_snd_regs[AUD3W6] = 0x00;
233 m_snd_regs[AUD3W7] = 0xFF;
234 m_snd_regs[AUD3W8] = 0x00;
235 m_snd_regs[AUD3W9] = 0xFF;
236 m_snd_regs[AUD3WA] = 0x00;
237 m_snd_regs[AUD3WB] = 0xFF;
238 m_snd_regs[AUD3WC] = 0x00;
239 m_snd_regs[AUD3WD] = 0xFF;
240 m_snd_regs[AUD3WE] = 0x00;
241 m_snd_regs[AUD3WF] = 0xFF;
242 }
243
244
245 /***************************************************************************
246 IMPLEMENTATION
247 ***************************************************************************/
248
TIMER_CALLBACK_MEMBER(gameboy_sound_device::timer_callback)249 TIMER_CALLBACK_MEMBER(gameboy_sound_device::timer_callback)
250 {
251 m_channel->update();
252 update_state();
253 }
254
255
tick_length(struct SOUND & snd)256 void gameboy_sound_device::tick_length(struct SOUND &snd)
257 {
258 if (snd.length_enabled)
259 {
260 snd.length = (snd.length + 1) & snd.length_mask;
261 if (snd.length == 0)
262 {
263 snd.on = false;
264 snd.length_counting = false;
265 }
266 }
267 }
268
269
calculate_next_sweep(struct SOUND & snd)270 int32_t gameboy_sound_device::calculate_next_sweep(struct SOUND &snd)
271 {
272 snd.sweep_neg_mode_used = (snd.sweep_direction < 0);
273 int32_t new_frequency = snd.frequency + snd.sweep_direction * (snd.frequency >> snd.sweep_shift);
274
275 if (new_frequency > 0x7FF)
276 {
277 snd.on = false;
278 }
279
280 return new_frequency;
281 }
282
283
apply_next_sweep(struct SOUND & snd)284 void gameboy_sound_device::apply_next_sweep(struct SOUND &snd)
285 {
286 int32_t new_frequency = calculate_next_sweep(snd);
287
288 if (snd.on && snd.sweep_shift > 0)
289 {
290 snd.frequency = new_frequency;
291 snd.reg[3] = snd.frequency & 0xFF;
292 }
293 }
294
295
tick_sweep(struct SOUND & snd)296 void gameboy_sound_device::tick_sweep(struct SOUND &snd)
297 {
298 snd.sweep_count = (snd.sweep_count - 1) & 0x07;
299 if (snd.sweep_count == 0)
300 {
301 snd.sweep_count = snd.sweep_time;
302
303 if (snd.sweep_enabled && snd.sweep_time > 0)
304 {
305 apply_next_sweep(snd);
306 calculate_next_sweep(snd);
307 }
308 }
309 }
310
311
tick_envelope(struct SOUND & snd)312 void gameboy_sound_device::tick_envelope(struct SOUND &snd)
313 {
314 if (snd.envelope_enabled)
315 {
316 snd.envelope_count = (snd.envelope_count - 1) & 0x07;
317
318 if (snd.envelope_count == 0)
319 {
320 snd.envelope_count = snd.envelope_time;
321
322 if (snd.envelope_count)
323 {
324 int8_t new_envelope_value = snd.envelope_value + snd.envelope_direction;
325
326 if (new_envelope_value >= 0 && new_envelope_value <= 15)
327 {
328 snd.envelope_value = new_envelope_value;
329 }
330 else
331 {
332 snd.envelope_enabled = false;
333 }
334 }
335 }
336 }
337 }
338
339
dac_enabled(struct SOUND & snd)340 bool gameboy_sound_device::dac_enabled(struct SOUND &snd)
341 {
342 return (snd.channel != 3) ? snd.reg[2] & 0xF8 : snd.reg[0] & 0x80;
343 }
344
345
update_square_channel(struct SOUND & snd,uint64_t cycles)346 void gameboy_sound_device::update_square_channel(struct SOUND &snd, uint64_t cycles)
347 {
348 if (snd.on)
349 {
350 // compensate for leftover cycles
351 if (snd.cycles_left > 0)
352 {
353 // Emit sample(s)
354 if (cycles <= snd.cycles_left)
355 {
356 snd.cycles_left -= cycles;
357 cycles = 0;
358 }
359 else
360 {
361 cycles -= snd.cycles_left;
362 snd.cycles_left = 0;
363 }
364 }
365
366 if (cycles & 3)
367 {
368 snd.cycles_left = 4 - (cycles & 3);
369 }
370 cycles >>= 2;
371 uint16_t distance = 0x800 - snd.frequency_counter;
372 if (cycles >= distance)
373 {
374 cycles -= distance;
375 distance = 0x800 - snd.frequency;
376 uint64_t counter = 1 + cycles / distance;
377
378 snd.duty_count = (snd.duty_count + counter) & 0x07;
379 snd.signal = wave_duty_table[snd.duty][snd.duty_count];
380
381 snd.frequency_counter = snd.frequency + cycles % distance;
382 }
383 else
384 {
385 snd.frequency_counter += cycles;
386 }
387 }
388 }
389
390
update_wave_channel(struct SOUND & snd,uint64_t cycles)391 void dmg_apu_device::update_wave_channel(struct SOUND &snd, uint64_t cycles)
392 {
393 if (snd.on)
394 {
395 // compensate for leftover cycles
396 if (snd.cycles_left > 0)
397 {
398 if (cycles <= snd.cycles_left)
399 {
400 // Emit samples
401 snd.cycles_left -= cycles;
402 cycles = 0;
403 }
404 else
405 {
406 // Emit samples
407
408 cycles -= snd.cycles_left;
409 snd.cycles_left = 0;
410 }
411 }
412
413 while (cycles > 0)
414 {
415 // Emit current sample
416
417 // cycles -= 2
418 if (cycles < 2)
419 {
420 snd.cycles_left = 2 - cycles;
421 cycles = 0;
422 }
423 else
424 {
425 cycles -= 2;
426
427 // Calculate next state
428 snd.frequency_counter = (snd.frequency_counter + 1) & 0x7FF;
429 snd.sample_reading = false;
430 if (snd.frequency_counter == 0x7ff)
431 {
432 snd.offset = (snd.offset + 1) & 0x1F;
433 }
434 if (snd.frequency_counter == 0)
435 {
436 // Read next sample
437 snd.sample_reading = true;
438 snd.current_sample = m_snd_regs[AUD3W0 + (snd.offset/2)];
439 if (!(snd.offset & 0x01))
440 {
441 snd.current_sample >>= 4;
442 }
443 snd.current_sample = (snd.current_sample & 0x0F) - 8;
444
445 snd.signal = snd.level ? snd.current_sample / (1 << (snd.level - 1)) : 0;
446
447 // Reload frequency counter
448 snd.frequency_counter = snd.frequency;
449 }
450 }
451 }
452 }
453 }
454
455
update_wave_channel(struct SOUND & snd,uint64_t cycles)456 void cgb04_apu_device::update_wave_channel(struct SOUND &snd, uint64_t cycles)
457 {
458 if (snd.on)
459 {
460 // compensate for left over cycles
461 if (snd.cycles_left > 0)
462 {
463 if (cycles <= snd.cycles_left)
464 {
465 // Emit samples
466 snd.cycles_left -= cycles;
467 cycles = 0;
468 }
469 else
470 {
471 // Emit samples
472
473 cycles -= snd.cycles_left;
474 snd.cycles_left = 0;
475 }
476 }
477
478 if (cycles & 1)
479 {
480 snd.cycles_left = 1;
481 }
482 cycles >>= 1;
483 uint16_t distance = 0x800 - snd.frequency_counter;
484 if (cycles >= distance)
485 {
486 cycles -= distance;
487 distance = 0x800 - snd.frequency;
488 // How many times the condition snd.frequency_counter == 0 is true
489 uint64_t counter = 1 + cycles / distance;
490
491 snd.offset = (snd.offset + counter) & 0x1F;
492 snd.current_sample = m_snd_regs[AUD3W0 + snd.offset / 2];
493 if (!(snd.offset & 1))
494 {
495 snd.current_sample >>= 4;
496 }
497 snd.current_sample = (snd.current_sample & 0x0F) - 8;
498 snd.signal = snd.level ? snd.current_sample / (1 << (snd.level - 1)) : 0;
499
500 cycles %= distance;
501 snd.sample_reading = cycles ? false : true;
502
503 snd.frequency_counter = snd.frequency + cycles;
504 }
505 else
506 {
507 snd.frequency_counter += cycles;
508 }
509 }
510 }
511
512
update_noise_channel(struct SOUND & snd,uint64_t cycles)513 void gameboy_sound_device::update_noise_channel(struct SOUND &snd, uint64_t cycles)
514 {
515 if (cycles >= snd.cycles_left)
516 {
517 cycles -= snd.cycles_left;
518 uint64_t period = noise_period_cycles();
519 uint64_t counter = 1 + cycles / period, i = 0;
520 uint16_t start = snd.noise_lfsr;
521 while (i < counter) {
522 /* Using a Polynomial Counter (aka Linear Feedback Shift Register)
523 Mode 4 has a 15 bit counter so we need to shift the
524 bits around accordingly */
525 uint16_t feedback = ((snd.noise_lfsr >> 1) ^ snd.noise_lfsr) & 1;
526 snd.noise_lfsr = (snd.noise_lfsr >> 1) | (feedback << 14);
527 if (snd.noise_short)
528 {
529 snd.noise_lfsr = (snd.noise_lfsr & ~(1 << 6)) | (feedback << 6);
530 }
531 i += 1;
532 if (snd.noise_lfsr == start)
533 {
534 counter %= i;
535 i = 0;
536 }
537 }
538 snd.signal = (snd.noise_lfsr & 1) ? -1 : 1;
539 snd.cycles_left = period - cycles % period;
540 }
541 else
542 {
543 snd.cycles_left -= cycles;
544 }
545 }
546
547
update_state()548 void gameboy_sound_device::update_state()
549 {
550 attotime now = machine().time();
551
552 // No time travelling
553 if (now <= m_last_updated)
554 {
555 return;
556 }
557
558 if (m_snd_control.on)
559 {
560 uint64_t cycles = attotime_to_clocks(now - m_last_updated);
561
562 uint64_t old_cycles = m_snd_control.cycles;
563 m_snd_control.cycles += cycles;
564
565 if ((old_cycles / FRAME_CYCLES) != (m_snd_control.cycles / FRAME_CYCLES))
566 {
567 // Left over cycles in current frame
568 uint64_t cycles_current_frame = FRAME_CYCLES - (old_cycles & (FRAME_CYCLES - 1));
569
570 update_square_channel(m_snd_1, cycles_current_frame);
571 update_square_channel(m_snd_2, cycles_current_frame);
572 update_wave_channel(m_snd_3, cycles_current_frame);
573 update_noise_channel(m_snd_4, cycles_current_frame);
574
575 cycles -= cycles_current_frame;
576
577 // Switch to next frame
578 switch ((m_snd_control.cycles / FRAME_CYCLES) & 0x07)
579 {
580 case 0:
581 // length
582 tick_length(m_snd_1);
583 tick_length(m_snd_2);
584 tick_length(m_snd_3);
585 tick_length(m_snd_4);
586 break;
587 case 2:
588 // sweep
589 tick_sweep(m_snd_1);
590 // length
591 tick_length(m_snd_1);
592 tick_length(m_snd_2);
593 tick_length(m_snd_3);
594 tick_length(m_snd_4);
595 break;
596 case 4:
597 // length
598 tick_length(m_snd_1);
599 tick_length(m_snd_2);
600 tick_length(m_snd_3);
601 tick_length(m_snd_4);
602 break;
603 case 6:
604 // sweep
605 tick_sweep(m_snd_1);
606 // length
607 tick_length(m_snd_1);
608 tick_length(m_snd_2);
609 tick_length(m_snd_3);
610 tick_length(m_snd_4);
611 break;
612 case 7:
613 // update envelope
614 tick_envelope(m_snd_1);
615 tick_envelope(m_snd_2);
616 tick_envelope(m_snd_4);
617 break;
618 }
619 }
620
621 update_square_channel(m_snd_1, cycles);
622 update_square_channel(m_snd_2, cycles);
623 update_wave_channel(m_snd_3, cycles);
624 update_noise_channel(m_snd_4, cycles);
625 }
626
627 m_last_updated = now;
628 }
629
630
noise_period_cycles()631 uint64_t gameboy_sound_device::noise_period_cycles()
632 {
633 static const int divisor[8] = { 8, 16,32, 48, 64, 80, 96, 112 };
634 return divisor[m_snd_4.reg[3] & 7] << (m_snd_4.reg[3] >> 4);
635 }
636
637
wave_r(offs_t offset)638 u8 dmg_apu_device::wave_r(offs_t offset)
639 {
640 m_channel->update();
641 update_state();
642
643 if (m_snd_3.on)
644 {
645 return m_snd_3.sample_reading ? m_snd_regs[AUD3W0 + (m_snd_3.offset/2)] : 0xFF;
646 }
647
648 return m_snd_regs[AUD3W0 + offset];
649 }
650
651
wave_r(offs_t offset)652 u8 cgb04_apu_device::wave_r(offs_t offset)
653 {
654 m_channel->update();
655 update_state();
656
657 if (m_snd_3.on)
658 {
659 return m_snd_regs[AUD3W0 + (m_snd_3.offset/2)];
660 }
661
662 return m_snd_regs[AUD3W0 + offset];
663 }
664
665
sound_r(offs_t offset)666 u8 gameboy_sound_device::sound_r(offs_t offset)
667 {
668 static const uint8_t read_mask[0x40] =
669 {
670 0x80,0x3F,0x00,0xFF,0xBF,0xFF,0x3F,0x00,0xFF,0xBF,0x7F,0xFF,0x9F,0xFF,0xBF,0xFF,
671 0xFF,0x00,0x00,0xBF,0x00,0x00,0x70,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
672 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
673 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
674 };
675
676 // Make sure we are up to date.
677 m_channel->update();
678 update_state();
679
680 if (m_snd_control.on)
681 {
682 if (offset == NR52)
683 {
684 return (m_snd_regs[NR52]&0xf0) | (m_snd_1.on ? 1 : 0) | (m_snd_2.on ? 2 : 0) | (m_snd_3.on ? 4 : 0) | (m_snd_4.on ? 8 : 0) | 0x70;
685 }
686 return m_snd_regs[offset] | read_mask[offset & 0x3F];
687 }
688 else
689 {
690 return read_mask[offset & 0x3F];
691 }
692 }
693
694
wave_w(offs_t offset,u8 data)695 void dmg_apu_device::wave_w(offs_t offset, u8 data)
696 {
697 m_channel->update();
698 update_state();
699
700 if (m_snd_3.on)
701 {
702 if (m_snd_3.sample_reading)
703 {
704 m_snd_regs[AUD3W0 + (m_snd_3.offset/2)] = data;
705 }
706 }
707 else
708 {
709 m_snd_regs[AUD3W0 + offset] = data;
710 }
711 }
712
713
wave_w(offs_t offset,u8 data)714 void cgb04_apu_device::wave_w(offs_t offset, u8 data)
715 {
716 m_channel->update();
717 update_state();
718
719 if (m_snd_3.on)
720 {
721 m_snd_regs[AUD3W0 + (m_snd_3.offset/2)] = data;
722 }
723 else
724 {
725 m_snd_regs[AUD3W0 + offset] = data;
726 }
727 }
728
729
sound_w(offs_t offset,u8 data)730 void dmg_apu_device::sound_w(offs_t offset, u8 data)
731 {
732 /* change in registers so update first */
733 m_channel->update();
734 update_state();
735
736 /* Only register NR52 is accessible if the sound controller is disabled */
737 if (!m_snd_control.on && offset != NR52 && offset != NR11 && offset != NR21 && offset != NR31 && offset != NR41)
738 return;
739
740 sound_w_internal(offset, data);
741 }
742
743
sound_w(offs_t offset,u8 data)744 void cgb04_apu_device::sound_w(offs_t offset, u8 data)
745 {
746 /* change in registers so update first */
747 m_channel->update();
748 update_state();
749
750 /* Only register NR52 is accessible if the sound controller is disabled */
751 if (!m_snd_control.on && offset != NR52)
752 return;
753
754 sound_w_internal(offset, data);
755 }
756
757
corrupt_wave_ram()758 void dmg_apu_device::corrupt_wave_ram()
759 {
760 if (m_snd_3.offset < 8)
761 {
762 m_snd_regs[AUD3W0] = m_snd_regs[AUD3W0 + (m_snd_3.offset/2)];
763 }
764 else
765 {
766 for (int i = 0; i < 4; i++)
767 {
768 m_snd_regs[AUD3W0 + i] = m_snd_regs[AUD3W0 + ((m_snd_3.offset / 2) & ~0x03) + i];
769 }
770 }
771 }
772
773
sound_w_internal(int offset,uint8_t data)774 void gameboy_sound_device::sound_w_internal( int offset, uint8_t data )
775 {
776 /* Store the value */
777 uint8_t old_data = m_snd_regs[offset];
778
779 if (m_snd_control.on)
780 {
781 m_snd_regs[offset] = data;
782 }
783
784 switch (offset)
785 {
786 /*MODE 1 */
787 case NR10: /* Sweep (R/W) */
788 m_snd_1.reg[0] = data;
789 m_snd_1.sweep_shift = data & 0x7;
790 m_snd_1.sweep_direction = (data & 0x8) ? -1 : 1;
791 m_snd_1.sweep_time = (data & 0x70) >> 4;
792 if ((old_data & 0x08) && !(data & 0x08) && m_snd_1.sweep_neg_mode_used)
793 {
794 m_snd_1.on = false;
795 }
796 break;
797 case NR11: /* Sound length/Wave pattern duty (R/W) */
798 m_snd_1.reg[1] = data;
799 if (m_snd_control.on)
800 {
801 m_snd_1.duty = (data & 0xc0) >> 6;
802 }
803 m_snd_1.length = data & 0x3f;
804 m_snd_1.length_counting = true;
805 break;
806 case NR12: /* Envelope (R/W) */
807 m_snd_1.reg[2] = data;
808 m_snd_1.envelope_value = data >> 4;
809 m_snd_1.envelope_direction = (data & 0x8) ? 1 : -1;
810 m_snd_1.envelope_time = data & 0x07;
811 if (!dac_enabled(m_snd_1))
812 {
813 m_snd_1.on = false;
814 }
815 break;
816 case NR13: /* Frequency lo (R/W) */
817 m_snd_1.reg[3] = data;
818 // Only enabling the frequency line breaks blarggs's sound test #5
819 // This condition may not be correct
820 if (!m_snd_1.sweep_enabled)
821 {
822 m_snd_1.frequency = ((m_snd_1.reg[4] & 0x7) << 8) | m_snd_1.reg[3];
823 }
824 break;
825 case NR14: /* Frequency hi / Initialize (R/W) */
826 m_snd_1.reg[4] = data;
827 {
828 bool length_was_enabled = m_snd_1.length_enabled;
829
830 m_snd_1.length_enabled = (data & 0x40) ? true : false;
831 m_snd_1.frequency = ((m_snd_regs[NR14] & 0x7) << 8) | m_snd_1.reg[3];
832
833 if (!length_was_enabled && !(m_snd_control.cycles & FRAME_CYCLES) && m_snd_1.length_counting)
834 {
835 if (m_snd_1.length_enabled)
836 {
837 tick_length(m_snd_1);
838 }
839 }
840
841 if (data & 0x80)
842 {
843 m_snd_1.on = true;
844 m_snd_1.envelope_enabled = true;
845 m_snd_1.envelope_value = m_snd_1.reg[2] >> 4;
846 m_snd_1.envelope_count = m_snd_1.envelope_time;
847 m_snd_1.sweep_count = m_snd_1.sweep_time;
848 m_snd_1.sweep_neg_mode_used = false;
849 m_snd_1.signal = 0;
850 m_snd_1.length_counting = true;
851 m_snd_1.frequency = ((m_snd_1.reg[4] & 0x7) << 8) | m_snd_1.reg[3];
852 m_snd_1.frequency_counter = m_snd_1.frequency;
853 m_snd_1.cycles_left = 0;
854 m_snd_1.duty_count = 0;
855 m_snd_1.sweep_enabled = (m_snd_1.sweep_shift != 0) || (m_snd_1.sweep_time != 0);
856 if (!dac_enabled(m_snd_1))
857 {
858 m_snd_1.on = false;
859 }
860 if (m_snd_1.sweep_shift > 0)
861 {
862 calculate_next_sweep(m_snd_1);
863 }
864
865 if (m_snd_1.length == 0 && m_snd_1.length_enabled && !(m_snd_control.cycles & FRAME_CYCLES))
866 {
867 tick_length(m_snd_1);
868 }
869 }
870 else
871 {
872 // This condition may not be correct
873 if (!m_snd_1.sweep_enabled)
874 {
875 m_snd_1.frequency = ((m_snd_1.reg[4] & 0x7) << 8) | m_snd_1.reg[3];
876 }
877 }
878 }
879 break;
880
881 /*MODE 2 */
882 case NR21: /* Sound length/Wave pattern duty (R/W) */
883 m_snd_2.reg[1] = data;
884 if (m_snd_control.on)
885 {
886 m_snd_2.duty = (data & 0xc0) >> 6;
887 }
888 m_snd_2.length = data & 0x3f;
889 m_snd_2.length_counting = true;
890 break;
891 case NR22: /* Envelope (R/W) */
892 m_snd_2.reg[2] = data;
893 m_snd_2.envelope_value = data >> 4;
894 m_snd_2.envelope_direction = (data & 0x8) ? 1 : -1;
895 m_snd_2.envelope_time = data & 0x07;
896 if (!dac_enabled(m_snd_2))
897 {
898 m_snd_2.on = false;
899 }
900 break;
901 case NR23: /* Frequency lo (R/W) */
902 m_snd_2.reg[3] = data;
903 m_snd_2.frequency = ((m_snd_2.reg[4] & 0x7) << 8) | m_snd_2.reg[3];
904 break;
905 case NR24: /* Frequency hi / Initialize (R/W) */
906 m_snd_2.reg[4] = data;
907 {
908 bool length_was_enabled = m_snd_2.length_enabled;
909
910 m_snd_2.length_enabled = (data & 0x40) ? true : false;
911
912 if (!length_was_enabled && !(m_snd_control.cycles & FRAME_CYCLES) && m_snd_2.length_counting)
913 {
914 if (m_snd_2.length_enabled)
915 {
916 tick_length(m_snd_2);
917 }
918 }
919
920 if (data & 0x80)
921 {
922 m_snd_2.on = true;
923 m_snd_2.envelope_enabled = true;
924 m_snd_2.envelope_value = m_snd_2.reg[2] >> 4;
925 m_snd_2.envelope_count = m_snd_2.envelope_time;
926 m_snd_2.frequency = ((m_snd_2.reg[4] & 0x7) << 8) | m_snd_2.reg[3];
927 m_snd_2.frequency_counter = m_snd_2.frequency;
928 m_snd_2.cycles_left = 0;
929 m_snd_2.duty_count = 0;
930 m_snd_2.signal = 0;
931 m_snd_2.length_counting = true;
932
933 if (!dac_enabled(m_snd_2))
934 {
935 m_snd_2.on = false;
936 }
937
938 if (m_snd_2.length == 0 && m_snd_2.length_enabled && !(m_snd_control.cycles & FRAME_CYCLES))
939 {
940 tick_length(m_snd_2);
941 }
942 }
943 else
944 {
945 m_snd_2.frequency = ((m_snd_2.reg[4] & 0x7) << 8) | m_snd_2.reg[3];
946 }
947 }
948 break;
949
950 /*MODE 3 */
951 case NR30: /* Sound On/Off (R/W) */
952 m_snd_3.reg[0] = data;
953 if (!dac_enabled(m_snd_3))
954 {
955 m_snd_3.on = false;
956 }
957 break;
958 case NR31: /* Sound Length (R/W) */
959 m_snd_3.reg[1] = data;
960 m_snd_3.length = data;
961 m_snd_3.length_counting = true;
962 break;
963 case NR32: /* Select Output Level */
964 m_snd_3.reg[2] = data;
965 m_snd_3.level = (data & 0x60) >> 5;
966 break;
967 case NR33: /* Frequency lo (W) */
968 m_snd_3.reg[3] = data;
969 m_snd_3.frequency = ((m_snd_3.reg[4] & 0x7) << 8) | m_snd_3.reg[3];
970 break;
971 case NR34: /* Frequency hi / Initialize (W) */
972 m_snd_3.reg[4] = data;
973 {
974 bool length_was_enabled = m_snd_3.length_enabled;
975
976 m_snd_3.length_enabled = (data & 0x40) ? true : false;
977
978 if (!length_was_enabled && !(m_snd_control.cycles & FRAME_CYCLES) && m_snd_3.length_counting)
979 {
980 if (m_snd_3.length_enabled)
981 {
982 tick_length(m_snd_3);
983 }
984 }
985
986 if (data & 0x80)
987 {
988 if (m_snd_3.on && m_snd_3.frequency_counter == 0x7ff)
989 {
990 corrupt_wave_ram();
991 }
992 m_snd_3.on = true;
993 m_snd_3.offset = 0;
994 m_snd_3.duty = 1;
995 m_snd_3.duty_count = 0;
996 m_snd_3.length_counting = true;
997 m_snd_3.frequency = ((m_snd_3.reg[4] & 0x7) << 8) | m_snd_3.reg[3];
998 m_snd_3.frequency_counter = m_snd_3.frequency;
999 // There is a tiny bit of delay in starting up the wave channel(?)
1000 //
1001 // Results from older code where corruption of wave ram was triggered when sample_reading == true:
1002 // 4 breaks test 09 (read wram), fixes test 10 (write trigger), breaks test 12 (write wram)
1003 // 6 fixes test 09 (read wram), breaks test 10 (write trigger), fixes test 12 (write wram)
1004 m_snd_3.cycles_left = 0 + 6;
1005 m_snd_3.sample_reading = false;
1006
1007 if (!dac_enabled(m_snd_3))
1008 {
1009 m_snd_3.on = false;
1010 }
1011
1012 if (m_snd_3.length == 0 && m_snd_3.length_enabled && !(m_snd_control.cycles & FRAME_CYCLES))
1013 {
1014 tick_length(m_snd_3);
1015 }
1016 }
1017 else
1018 {
1019 m_snd_3.frequency = ((m_snd_3.reg[4] & 0x7) << 8) | m_snd_3.reg[3];
1020 }
1021 }
1022 break;
1023
1024 /*MODE 4 */
1025 case NR41: /* Sound Length (R/W) */
1026 m_snd_4.reg[1] = data;
1027 m_snd_4.length = data & 0x3f;
1028 m_snd_4.length_counting = true;
1029 break;
1030 case NR42: /* Envelope (R/W) */
1031 m_snd_4.reg[2] = data;
1032 m_snd_4.envelope_value = data >> 4;
1033 m_snd_4.envelope_direction = (data & 0x8) ? 1 : -1;
1034 m_snd_4.envelope_time = data & 0x07;
1035 if (!dac_enabled(m_snd_4))
1036 {
1037 m_snd_4.on = false;
1038 }
1039 break;
1040 case NR43: /* Polynomial Counter/Frequency */
1041 m_snd_4.reg[3] = data;
1042 m_snd_4.noise_short = (data & 0x8);
1043 break;
1044 case NR44: /* Counter/Consecutive / Initialize (R/W) */
1045 m_snd_4.reg[4] = data;
1046 {
1047 bool length_was_enabled = m_snd_4.length_enabled;
1048
1049 m_snd_4.length_enabled = (data & 0x40) ? true : false;
1050
1051 if (!length_was_enabled && !(m_snd_control.cycles & FRAME_CYCLES) && m_snd_4.length_counting)
1052 {
1053 if (m_snd_4.length_enabled)
1054 {
1055 tick_length(m_snd_4);
1056 }
1057 }
1058
1059 if (data & 0x80)
1060 {
1061 m_snd_4.on = true;
1062 m_snd_4.envelope_enabled = true;
1063 m_snd_4.envelope_value = m_snd_4.reg[2] >> 4;
1064 m_snd_4.envelope_count = m_snd_4.envelope_time;
1065 m_snd_4.frequency_counter = 0;
1066 m_snd_4.cycles_left = noise_period_cycles();
1067 m_snd_4.signal = -1;
1068 m_snd_4.noise_lfsr = 0x7fff;
1069 m_snd_4.length_counting = true;
1070
1071 if (!dac_enabled(m_snd_4))
1072 {
1073 m_snd_4.on = false;
1074 }
1075
1076 if (m_snd_4.length == 0 && m_snd_4.length_enabled && !(m_snd_control.cycles & FRAME_CYCLES))
1077 {
1078 tick_length(m_snd_4);
1079 }
1080 }
1081 }
1082 break;
1083
1084 /* CONTROL */
1085 case NR50: /* Channel Control / On/Off / Volume (R/W) */
1086 m_snd_control.vol_left = data & 0x7;
1087 m_snd_control.vol_right = (data & 0x70) >> 4;
1088 break;
1089 case NR51: /* Selection of Sound Output Terminal */
1090 m_snd_control.mode1_right = data & 0x1;
1091 m_snd_control.mode1_left = (data & 0x10) >> 4;
1092 m_snd_control.mode2_right = (data & 0x2) >> 1;
1093 m_snd_control.mode2_left = (data & 0x20) >> 5;
1094 m_snd_control.mode3_right = (data & 0x4) >> 2;
1095 m_snd_control.mode3_left = (data & 0x40) >> 6;
1096 m_snd_control.mode4_right = (data & 0x8) >> 3;
1097 m_snd_control.mode4_left = (data & 0x80) >> 7;
1098 break;
1099 case NR52: // Sound On/Off (R/W)
1100 // Only bit 7 is writable, writing to bits 0-3 does NOT enable or disable sound. They are read-only.
1101 if (!(data & 0x80))
1102 {
1103 // On DMG the length counters are not affected and not clocked
1104 // powering off should actually clear all registers
1105 apu_power_off();
1106 }
1107 else
1108 {
1109 if (!m_snd_control.on)
1110 {
1111 // When switching on, the next step should be 0.
1112 m_snd_control.cycles |= 7 * FRAME_CYCLES;
1113 }
1114 }
1115 m_snd_control.on = (data & 0x80) ? true : false;
1116 m_snd_regs[NR52] = data & 0x80;
1117 break;
1118 }
1119 }
1120
1121
apu_power_off()1122 void dmg_apu_device::apu_power_off()
1123 {
1124 sound_w_internal(NR10, 0x00);
1125 m_snd_1.duty = 0;
1126 m_snd_regs[NR11] = 0;
1127 sound_w_internal(NR12, 0x00);
1128 sound_w_internal(NR13, 0x00);
1129 sound_w_internal(NR14, 0x00);
1130 m_snd_1.length_counting = false;
1131 m_snd_1.sweep_neg_mode_used = false;
1132
1133 m_snd_regs[NR21] = 0;
1134 sound_w_internal(NR22, 0x00);
1135 sound_w_internal(NR23, 0x00);
1136 sound_w_internal(NR24, 0x00);
1137 m_snd_2.length_counting = false;
1138
1139 sound_w_internal(NR30, 0x00);
1140 sound_w_internal(NR32, 0x00);
1141 sound_w_internal(NR33, 0x00);
1142 sound_w_internal(NR34, 0x00);
1143 m_snd_3.length_counting = false;
1144 m_snd_3.current_sample = 0;
1145
1146 m_snd_regs[NR41] = 0;
1147 sound_w_internal(NR42, 0x00);
1148 sound_w_internal(NR43, 0x00);
1149 sound_w_internal(NR44, 0x00);
1150 m_snd_4.length_counting = false;
1151 m_snd_4.cycles_left = noise_period_cycles();
1152
1153 m_snd_1.on = false;
1154 m_snd_2.on = false;
1155 m_snd_3.on = false;
1156 m_snd_4.on = false;
1157
1158 m_snd_control.wave_ram_locked = false;
1159
1160 for (int i = NR44 + 1; i < NR52; i++)
1161 {
1162 sound_w_internal(i, 0x00);
1163 }
1164 }
1165
1166
apu_power_off()1167 void cgb04_apu_device::apu_power_off()
1168 {
1169 sound_w_internal(NR10, 0x00);
1170 m_snd_1.duty = 0;
1171 sound_w_internal(NR11, 0x00);
1172 sound_w_internal(NR12, 0x00);
1173 sound_w_internal(NR13, 0x00);
1174 sound_w_internal(NR14, 0x00);
1175 m_snd_1.length_counting = false;
1176 m_snd_1.sweep_neg_mode_used = false;
1177
1178 sound_w_internal(NR21, 0x00);
1179 sound_w_internal(NR22, 0x00);
1180 sound_w_internal(NR23, 0x00);
1181 sound_w_internal(NR24, 0x00);
1182 m_snd_2.length_counting = false;
1183
1184 sound_w_internal(NR30, 0x00);
1185 sound_w_internal(NR31, 0x00);
1186 sound_w_internal(NR32, 0x00);
1187 sound_w_internal(NR33, 0x00);
1188 sound_w_internal(NR34, 0x00);
1189 m_snd_3.length_counting = false;
1190 m_snd_3.current_sample = 0;
1191
1192 sound_w_internal(NR41, 0x00);
1193 sound_w_internal(NR42, 0x00);
1194 sound_w_internal(NR43, 0x00);
1195 sound_w_internal(NR44, 0x00);
1196 m_snd_4.length_counting = false;
1197 m_snd_4.cycles_left = noise_period_cycles();
1198
1199 m_snd_1.on = false;
1200 m_snd_2.on = false;
1201 m_snd_3.on = false;
1202 m_snd_4.on = false;
1203
1204 m_snd_control.wave_ram_locked = false;
1205
1206 for (int i = NR44 + 1; i < NR52; i++)
1207 {
1208 sound_w_internal(i, 0x00);
1209 }
1210 }
1211
1212
1213 //-------------------------------------------------
1214 // sound_stream_update - handle a stream update
1215 //-------------------------------------------------
1216
sound_stream_update(sound_stream & stream,std::vector<read_stream_view> const & inputs,std::vector<write_stream_view> & outputs)1217 void gameboy_sound_device::sound_stream_update(sound_stream &stream, std::vector<read_stream_view> const &inputs, std::vector<write_stream_view> &outputs)
1218 {
1219 auto &outputl = outputs[0];
1220 auto &outputr = outputs[1];
1221 for (int sampindex = 0; sampindex < outputl.samples(); sampindex++)
1222 {
1223 s32 sample;
1224 s32 left = 0;
1225 s32 right = 0;
1226
1227 /* Mode 1 - Wave with Envelope and Sweep */
1228 if (m_snd_1.on)
1229 {
1230 sample = m_snd_1.signal * m_snd_1.envelope_value;
1231
1232 if (m_snd_control.mode1_left)
1233 left += sample;
1234 if (m_snd_control.mode1_right)
1235 right += sample;
1236 }
1237
1238 /* Mode 2 - Wave with Envelope */
1239 if (m_snd_2.on)
1240 {
1241 sample = m_snd_2.signal * m_snd_2.envelope_value;
1242 if (m_snd_control.mode2_left)
1243 left += sample;
1244 if (m_snd_control.mode2_right)
1245 right += sample;
1246 }
1247
1248 /* Mode 3 - Wave patterns from WaveRAM */
1249 if (m_snd_3.on)
1250 {
1251 sample = m_snd_3.signal;
1252 if (m_snd_control.mode3_left)
1253 left += sample;
1254 if (m_snd_control.mode3_right)
1255 right += sample;
1256 }
1257
1258 /* Mode 4 - Noise with Envelope */
1259 if (m_snd_4.on)
1260 {
1261 sample = m_snd_4.signal * m_snd_4.envelope_value;
1262 if (m_snd_control.mode4_left)
1263 left += sample;
1264 if (m_snd_control.mode4_right)
1265 right += sample;
1266 }
1267
1268 /* Adjust for master volume */
1269 left *= m_snd_control.vol_left;
1270 right *= m_snd_control.vol_right;
1271
1272 /* Update the buffers */
1273 outputl.put_int(sampindex, left, 32768 / 64);
1274 outputr.put_int(sampindex, right, 32768 / 64);
1275 }
1276 }
1277