3 * Copyright (C) 2006 Exophase <exophase@gmail.com>
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation; either version 2 of
8 * the License, or (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 u32 global_enable_audio = 1;
25 direct_sound_struct direct_sound_channel[2];
26 gbc_sound_struct gbc_sound_channel[4];
28 u32 sound_frequency = 44100;
30 SDL_mutex *sound_mutex;
31 static SDL_cond *sound_cv;
34 u32 audio_buffer_size_number = 1;
36 u32 audio_buffer_size_number = 8;
40 static u32 audio_buffer_size;
41 static s16 sound_buffer[BUFFER_SIZE];
42 static u32 sound_buffer_base;
44 static u32 sound_last_cpu_ticks;
45 static fixed16_16 gbc_sound_tick_step;
47 static u32 sound_exit_flag;
49 // Queue 1, 2, or 4 samples to the top of the DS FIFO, wrap around circularly
51 #define sound_timer_queue(size, value) \
52 *((s##size *)(ds->fifo + ds->fifo_top)) = value; \
53 ds->fifo_top = (ds->fifo_top + 1) % 32; \
55 void sound_timer_queue8(u32 channel, u8 value)
57 direct_sound_struct *ds = direct_sound_channel + channel;
58 sound_timer_queue(8, value);
61 void sound_timer_queue16(u32 channel, u16 value)
63 direct_sound_struct *ds = direct_sound_channel + channel;
64 sound_timer_queue(8, value & 0xFF);
65 sound_timer_queue(8, value >> 8);
68 void sound_timer_queue32(u32 channel, u32 value)
70 direct_sound_struct *ds = direct_sound_channel + channel;
72 sound_timer_queue(8, value & 0xFF);
73 sound_timer_queue(8, (value >> 8) & 0xFF);
74 sound_timer_queue(8, (value >> 16) & 0xFF);
75 sound_timer_queue(8, value >> 24);
78 // Unqueue 1 sample from the base of the DS FIFO and place it on the audio
79 // buffer for as many samples as necessary. If the DS FIFO is 16 bytes or
80 // smaller and if DMA is enabled for the sound channel initiate a DMA transfer
83 #define render_sample_null() \
85 #define render_sample_left() \
86 sound_buffer[buffer_index] += current_sample + \
87 fp16_16_to_u32((next_sample - current_sample) * fifo_fractional) \
89 #define render_sample_right() \
90 sound_buffer[buffer_index + 1] += current_sample + \
91 fp16_16_to_u32((next_sample - current_sample) * fifo_fractional) \
93 #define render_sample_both() \
94 dest_sample = current_sample + \
95 fp16_16_to_u32((next_sample - current_sample) * fifo_fractional); \
96 sound_buffer[buffer_index] += dest_sample; \
97 sound_buffer[buffer_index + 1] += dest_sample \
99 #define render_samples(type) \
100 while(fifo_fractional <= 0xFFFF) \
102 render_sample_##type(); \
103 fifo_fractional += frequency_step; \
104 buffer_index = (buffer_index + 2) % BUFFER_SIZE; \
107 void sound_timer(fixed16_16 frequency_step, u32 channel)
109 direct_sound_struct *ds = direct_sound_channel + channel;
111 fixed16_16 fifo_fractional = ds->fifo_fractional;
112 u32 buffer_index = ds->buffer_index;
113 s16 current_sample, next_sample, dest_sample;
115 current_sample = ds->fifo[ds->fifo_base] << 4;
116 ds->fifo_base = (ds->fifo_base + 1) % 32;
117 next_sample = ds->fifo[ds->fifo_base] << 4;
121 if(ds->volume == DIRECT_SOUND_VOLUME_50)
123 current_sample >>= 1;
129 case DIRECT_SOUND_INACTIVE:
130 render_samples(null);
133 case DIRECT_SOUND_RIGHT:
134 render_samples(right);
137 case DIRECT_SOUND_LEFT:
138 render_samples(left);
141 case DIRECT_SOUND_LEFTRIGHT:
142 render_samples(both);
148 render_samples(null);
151 ds->buffer_index = buffer_index;
152 ds->fifo_fractional = fp16_16_fractional_part(fifo_fractional);
154 if(((ds->fifo_top - ds->fifo_base) % 32) <= 16)
156 if(dma[1].direct_sound_channel == channel)
157 dma_transfer(dma + 1);
159 if(dma[2].direct_sound_channel == channel)
160 dma_transfer(dma + 2);
164 void sound_reset_fifo(u32 channel)
166 direct_sound_struct *ds = direct_sound_channel;
168 memset(ds->fifo, 0, 32);
171 // Initial pattern data = 4bits (signed)
172 // Channel volume = 12bits
173 // Envelope volume = 14bits
174 // Master volume = 2bits
176 // Recalculate left and right volume as volume changes.
177 // To calculate the current sample, use (sample * volume) >> 16
179 // Square waves range from -8 (low) to 7 (high)
181 s8 square_pattern_duty[4][8] =
183 { 0xF8, 0xF8, 0xF8, 0xF8, 0x07, 0xF8, 0xF8, 0xF8 },
184 { 0xF8, 0xF8, 0xF8, 0xF8, 0x07, 0x07, 0xF8, 0xF8 },
185 { 0xF8, 0xF8, 0x07, 0x07, 0x07, 0x07, 0xF8, 0xF8 },
186 { 0x07, 0x07, 0x07, 0x07, 0xF8, 0xF8, 0x07, 0x07 },
191 u32 noise_table15[1024];
194 u32 gbc_sound_master_volume_table[4] = { 1, 2, 4, 0 };
196 u32 gbc_sound_channel_volume_table[8] =
208 u32 gbc_sound_envelope_volume_table[16] =
210 fixed_div(0, 15, 14),
211 fixed_div(1, 15, 14),
212 fixed_div(2, 15, 14),
213 fixed_div(3, 15, 14),
214 fixed_div(4, 15, 14),
215 fixed_div(5, 15, 14),
216 fixed_div(6, 15, 14),
217 fixed_div(7, 15, 14),
218 fixed_div(8, 15, 14),
219 fixed_div(9, 15, 14),
220 fixed_div(10, 15, 14),
221 fixed_div(11, 15, 14),
222 fixed_div(12, 15, 14),
223 fixed_div(13, 15, 14),
224 fixed_div(14, 15, 14),
225 fixed_div(15, 15, 14)
228 u32 gbc_sound_buffer_index = 0;
229 u32 gbc_sound_last_cpu_ticks = 0;
230 u32 gbc_sound_partial_ticks = 0;
232 u32 gbc_sound_master_volume_left;
233 u32 gbc_sound_master_volume_right;
234 u32 gbc_sound_master_volume;
236 #define update_volume_channel_envelope(channel) \
237 volume_##channel = gbc_sound_envelope_volume_table[envelope_volume] * \
238 gbc_sound_channel_volume_table[gbc_sound_master_volume_##channel] * \
239 gbc_sound_master_volume_table[gbc_sound_master_volume] \
241 #define update_volume_channel_noenvelope(channel) \
242 volume_##channel = gs->wave_volume * \
243 gbc_sound_channel_volume_table[gbc_sound_master_volume_##channel] * \
244 gbc_sound_master_volume_table[gbc_sound_master_volume] \
246 #define update_volume(type) \
247 update_volume_channel_##type(left); \
248 update_volume_channel_##type(right) \
250 #define update_tone_sweep() \
251 if(gs->sweep_status) \
253 u32 sweep_ticks = gs->sweep_ticks - 1; \
255 if(sweep_ticks == 0) \
257 u32 rate = gs->rate; \
259 if(gs->sweep_direction) \
260 rate = rate - (rate >> gs->sweep_shift); \
262 rate = rate + (rate >> gs->sweep_shift); \
267 frequency_step = float_to_fp16_16(((131072.0 / (2048 - rate)) * 8.0) / \
270 gs->frequency_step = frequency_step; \
273 sweep_ticks = gs->sweep_initial_ticks; \
275 gs->sweep_ticks = sweep_ticks; \
278 #define update_tone_nosweep() \
280 #define update_tone_envelope() \
281 if(gs->envelope_status) \
283 u32 envelope_ticks = gs->envelope_ticks - 1; \
284 envelope_volume = gs->envelope_volume; \
286 if(envelope_ticks == 0) \
288 if(gs->envelope_direction) \
290 if(envelope_volume != 15) \
291 envelope_volume = gs->envelope_volume + 1; \
295 if(envelope_volume != 0) \
296 envelope_volume = gs->envelope_volume - 1; \
299 update_volume(envelope); \
301 gs->envelope_volume = envelope_volume; \
302 gs->envelope_ticks = gs->envelope_initial_ticks; \
306 gs->envelope_ticks = envelope_ticks; \
310 #define update_tone_noenvelope() \
312 #define gbc_sound_synchronize() \
313 while(((gbc_sound_buffer_index - sound_buffer_base) % BUFFER_SIZE) > \
314 (audio_buffer_size * 2)) \
316 SDL_CondWait(sound_cv, sound_mutex); \
319 #define update_tone_counters(envelope_op, sweep_op) \
320 tick_counter += gbc_sound_tick_step; \
321 if(tick_counter > 0xFFFF) \
323 if(gs->length_status) \
325 u32 length_ticks = gs->length_ticks - 1; \
326 gs->length_ticks = length_ticks; \
328 if(length_ticks == 0) \
330 gs->active_flag = 0; \
335 update_tone_##envelope_op(); \
336 update_tone_##sweep_op(); \
338 tick_counter &= 0xFFFF; \
341 #define gbc_sound_render_sample_right() \
342 sound_buffer[buffer_index + 1] += (current_sample * volume_right) >> 22 \
344 #define gbc_sound_render_sample_left() \
345 sound_buffer[buffer_index] += (current_sample * volume_left) >> 22 \
347 #define gbc_sound_render_sample_both() \
348 gbc_sound_render_sample_right(); \
349 gbc_sound_render_sample_left() \
351 #define gbc_sound_render_samples(type, sample_length, envelope_op, sweep_op) \
352 for(i = 0; i < buffer_ticks; i++) \
355 sample_data[fp16_16_to_u32(sample_index) % sample_length]; \
356 gbc_sound_render_sample_##type(); \
358 sample_index += frequency_step; \
359 buffer_index = (buffer_index + 2) % BUFFER_SIZE; \
361 update_tone_counters(envelope_op, sweep_op); \
364 #define gbc_noise_wrap_full 32767
366 #define gbc_noise_wrap_half 126
368 #define get_noise_sample_full() \
370 ((s32)(noise_table15[fp16_16_to_u32(sample_index) >> 5] << \
371 (fp16_16_to_u32(sample_index) & 0x1F)) >> 31) & 0x0F \
373 #define get_noise_sample_half() \
375 ((s32)(noise_table7[fp16_16_to_u32(sample_index) >> 5] << \
376 (fp16_16_to_u32(sample_index) & 0x1F)) >> 31) & 0x0F \
378 #define gbc_sound_render_noise(type, noise_type, envelope_op, sweep_op) \
379 for(i = 0; i < buffer_ticks; i++) \
381 get_noise_sample_##noise_type(); \
382 gbc_sound_render_sample_##type(); \
384 sample_index += frequency_step; \
386 if(sample_index >= u32_to_fp16_16(gbc_noise_wrap_##noise_type)) \
387 sample_index -= u32_to_fp16_16(gbc_noise_wrap_##noise_type); \
389 buffer_index = (buffer_index + 2) % BUFFER_SIZE; \
390 update_tone_counters(envelope_op, sweep_op); \
393 #define gbc_sound_render_channel(type, sample_length, envelope_op, sweep_op) \
394 buffer_index = gbc_sound_buffer_index; \
395 sample_index = gs->sample_index; \
396 frequency_step = gs->frequency_step; \
397 tick_counter = gs->tick_counter; \
399 update_volume(envelope_op); \
403 case GBC_SOUND_INACTIVE: \
406 case GBC_SOUND_LEFT: \
407 gbc_sound_render_##type(left, sample_length, envelope_op, sweep_op); \
410 case GBC_SOUND_RIGHT: \
411 gbc_sound_render_##type(right, sample_length, envelope_op, sweep_op); \
414 case GBC_SOUND_LEFTRIGHT: \
415 gbc_sound_render_##type(both, sample_length, envelope_op, sweep_op); \
419 gs->sample_index = sample_index; \
420 gs->tick_counter = tick_counter; \
422 #define gbc_sound_load_wave_ram(bank) \
423 wave_bank = wave_samples + (bank * 32); \
424 for(i = 0, i2 = 0; i < 16; i++, i2 += 2) \
426 current_sample = wave_ram[i]; \
427 wave_bank[i2] = (((current_sample >> 4) & 0x0F) - 8); \
428 wave_bank[i2 + 1] = ((current_sample & 0x0F) - 8); \
431 void synchronize_sound()
433 SDL_LockMutex(sound_mutex);
435 gbc_sound_synchronize();
437 SDL_UnlockMutex(sound_mutex);
440 void update_gbc_sound(u32 cpu_ticks)
442 fixed16_16 buffer_ticks = float_to_fp16_16(((float)(cpu_ticks -
443 gbc_sound_last_cpu_ticks) * sound_frequency) / 16777216.0);
445 gbc_sound_struct *gs = gbc_sound_channel;
446 fixed16_16 sample_index, frequency_step;
447 fixed16_16 tick_counter;
449 s32 volume_left, volume_right;
452 u32 sound_status = address16(io_registers, 0x84) & 0xFFF0;
455 u8 *wave_ram = ((u8 *)io_registers) + 0x90;
457 gbc_sound_partial_ticks += fp16_16_fractional_part(buffer_ticks);
458 buffer_ticks = fp16_16_to_u32(buffer_ticks);
460 if(gbc_sound_partial_ticks > 0xFFFF)
463 gbc_sound_partial_ticks &= 0xFFFF;
466 SDL_LockMutex(sound_mutex);
469 if(((gbc_sound_buffer_index - sound_buffer_base) % BUFFER_SIZE) >
470 (audio_buffer_size * 3 / 2))
472 while(((gbc_sound_buffer_index - sound_buffer_base) % BUFFER_SIZE) >
473 (audio_buffer_size * 3 / 2))
475 SDL_CondWait(sound_cv, sound_mutex);
479 if(current_frameskip_type == auto_frameskip)
481 sceDisplayWaitVblankStart();
482 real_frame_count = 0;
483 virtual_frame_count = 0;
486 if(current_frameskip_type == auto_frameskip)
491 get_ticks_us(¤t_ticks);
493 next_ticks = ((current_ticks + 16666) / 16667) * 16667;
494 delay_us(next_ticks - current_ticks);
496 get_ticks_us(&frame_count_initial_timestamp);
498 /* prevent frameskip, or it will cause more audio,
499 * then more waiting here, then frame skip again, ... */
500 num_skipped_frames = 100;
508 gs = gbc_sound_channel + 0;
511 sound_status |= 0x01;
512 sample_data = gs->sample_data;
513 envelope_volume = gs->envelope_volume;
514 gbc_sound_render_channel(samples, 8, envelope, sweep);
517 gs = gbc_sound_channel + 1;
520 sound_status |= 0x02;
521 sample_data = gs->sample_data;
522 envelope_volume = gs->envelope_volume;
523 gbc_sound_render_channel(samples, 8, envelope, nosweep);
526 gs = gbc_sound_channel + 2;
527 if(gbc_sound_wave_update)
529 if(gs->wave_bank == 1)
531 gbc_sound_load_wave_ram(1);
535 gbc_sound_load_wave_ram(0);
538 gbc_sound_wave_update = 0;
541 if((gs->active_flag) && (gs->master_enable))
543 sound_status |= 0x04;
544 sample_data = wave_samples;
545 if(gs->wave_type == 0)
547 if(gs->wave_bank == 1)
550 gbc_sound_render_channel(samples, 32, noenvelope, nosweep);
554 gbc_sound_render_channel(samples, 64, noenvelope, nosweep);
558 gs = gbc_sound_channel + 3;
561 sound_status |= 0x08;
562 envelope_volume = gs->envelope_volume;
564 if(gs->noise_type == 1)
566 gbc_sound_render_channel(noise, half, envelope, nosweep);
570 gbc_sound_render_channel(noise, full, envelope, nosweep);
575 address16(io_registers, 0x84) = sound_status;
577 gbc_sound_last_cpu_ticks = cpu_ticks;
578 gbc_sound_buffer_index =
579 (gbc_sound_buffer_index + (buffer_ticks * 2)) % BUFFER_SIZE;
581 SDL_UnlockMutex(sound_mutex);
583 SDL_CondSignal(sound_cv);
586 #define sound_copy_normal() \
587 current_sample = source[i] \
589 #define sound_copy(source_offset, length, render_type) \
590 _length = (length) / 2; \
591 source = (s16 *)(sound_buffer + source_offset); \
592 for(i = 0; i < _length; i++) \
594 sound_copy_##render_type(); \
595 if(current_sample > 2047) \
596 current_sample = 2047; \
597 if(current_sample < -2048) \
598 current_sample = -2048; \
600 stream_base[i] = current_sample << 4; \
604 #define sound_copy_null(source_offset, length) \
605 _length = (length) / 2; \
606 source = (s16 *)(sound_buffer + source_offset); \
607 for(i = 0; i < _length; i++) \
609 stream_base[i] = 0; \
614 void sound_callback(void *userdata, Uint8 *stream, int length)
616 u32 sample_length = length / 2;
619 s16 *stream_base = (s16 *)stream;
623 SDL_LockMutex(sound_mutex);
625 while(((gbc_sound_buffer_index - sound_buffer_base) % BUFFER_SIZE) <
626 length && !sound_exit_flag)
628 SDL_CondWait(sound_cv, sound_mutex);
631 if(global_enable_audio)
633 if((sound_buffer_base + sample_length) >= BUFFER_SIZE)
635 u32 partial_length = (BUFFER_SIZE - sound_buffer_base) * 2;
636 sound_copy(sound_buffer_base, partial_length, normal);
637 source = (s16 *)sound_buffer;
638 sound_copy(0, length - partial_length, normal);
639 sound_buffer_base = (length - partial_length) / 2;
643 sound_copy(sound_buffer_base, length, normal);
644 sound_buffer_base += sample_length;
649 if((sound_buffer_base + sample_length) >= BUFFER_SIZE)
651 u32 partial_length = (BUFFER_SIZE - sound_buffer_base) * 2;
652 sound_copy_null(sound_buffer_base, partial_length);
653 source = (s16 *)sound_buffer;
654 sound_copy(0, length - partial_length, normal);
655 sound_buffer_base = (length - partial_length) / 2;
659 sound_copy_null(sound_buffer_base, length);
660 sound_buffer_base += sample_length;
664 SDL_CondSignal(sound_cv);
666 SDL_UnlockMutex(sound_mutex);
669 // Special thanks to blarrg for the LSFR frequency used in Meridian, as posted
670 // on the forum at http://meridian.overclocked.org:
671 // http://meridian.overclocked.org/cgi-bin/wwwthreads/showpost.pl?Board=merid
672 // angeneraldiscussion&Number=2069&page=0&view=expanded&mode=threaded&sb=4
673 // Hope you don't mind me borrowing it ^_-
675 void init_noise_table(u32 *table, u32 period, u32 bit_length)
677 u32 shift_register = 0xFF;
678 u32 mask = ~(1 << bit_length);
679 s32 table_pos, bit_pos;
681 u32 table_period = (period + 31) / 32;
683 // Bits are stored in reverse order so they can be more easily moved to
684 // bit 31, for sign extended shift down.
686 for(table_pos = 0; table_pos < table_period; table_pos++)
689 for(bit_pos = 31; bit_pos >= 0; bit_pos--)
691 current_entry |= (shift_register & 0x01) << bit_pos;
694 ((1 & (shift_register ^ (shift_register >> 1))) << bit_length) |
695 ((shift_register >> 1) & mask);
698 table[table_pos] = current_entry;
704 direct_sound_struct *ds = direct_sound_channel;
705 gbc_sound_struct *gs = gbc_sound_channel;
709 sound_buffer_base = 0;
710 sound_last_cpu_ticks = 0;
711 memset(sound_buffer, 0, audio_buffer_size);
713 for(i = 0; i < 2; i++, ds++)
715 ds->buffer_index = 0;
716 ds->status = DIRECT_SOUND_INACTIVE;
719 ds->fifo_fractional = 0;
720 ds->last_cpu_ticks = 0;
721 memset(ds->fifo, 0, 32);
724 gbc_sound_buffer_index = 0;
725 gbc_sound_last_cpu_ticks = 0;
726 gbc_sound_partial_ticks = 0;
728 gbc_sound_master_volume_left = 0;
729 gbc_sound_master_volume_right = 0;
730 gbc_sound_master_volume = 0;
731 memset(wave_samples, 0, 64);
733 for(i = 0; i < 4; i++, gs++)
735 gs->status = GBC_SOUND_INACTIVE;
736 gs->sample_data = square_pattern_duty[2];
743 gbc_sound_buffer_index =
744 (sound_buffer_base + audio_buffer_size) % BUFFER_SIZE;
747 SDL_CondSignal(sound_cv);
753 SDL_AudioSpec sound_settings;
756 audio_buffer_size = (audio_buffer_size_number * 1024) + 3072;
758 audio_buffer_size = 16 << audio_buffer_size_number;
759 // audio_buffer_size = 16384;
762 SDL_AudioSpec desired_spec =
768 audio_buffer_size / 4,
775 gbc_sound_tick_step =
776 float_to_fp16_16(256.0 / sound_frequency);
778 init_noise_table(noise_table15, 32767, 14);
779 init_noise_table(noise_table7, 127, 6);
783 sound_mutex = SDL_CreateMutex();
784 sound_cv = SDL_CreateCond();
786 SDL_OpenAudio(&desired_spec, &sound_settings);
787 sound_frequency = sound_settings.freq;
788 audio_buffer_size = sound_settings.size;
789 u32 i = audio_buffer_size / 16;
790 for (audio_buffer_size_number = 0; i && (i & 1) == 0; i >>= 1)
791 audio_buffer_size_number++;
793 printf("audio: freq %d, size %d\n", sound_frequency, audio_buffer_size);
799 #define sound_savestate_builder(type) \
800 void sound_##type##_savestate(file_tag_type savestate_file) \
802 file_##type##_variable(savestate_file, sound_on); \
803 file_##type##_variable(savestate_file, sound_buffer_base); \
804 file_##type##_variable(savestate_file, sound_last_cpu_ticks); \
805 file_##type##_variable(savestate_file, gbc_sound_buffer_index); \
806 file_##type##_variable(savestate_file, gbc_sound_last_cpu_ticks); \
807 file_##type##_variable(savestate_file, gbc_sound_partial_ticks); \
808 file_##type##_variable(savestate_file, gbc_sound_master_volume_left); \
809 file_##type##_variable(savestate_file, gbc_sound_master_volume_right); \
810 file_##type##_variable(savestate_file, gbc_sound_master_volume); \
811 file_##type##_array(savestate_file, wave_samples); \
812 file_##type##_array(savestate_file, direct_sound_channel); \
813 file_##type##_array(savestate_file, gbc_sound_channel); \
816 sound_savestate_builder(read);
817 sound_savestate_builder(write_mem);