move warm too
[gpsp.git] / sound.c
1 /* gameplaySP
2  *
3  * Copyright (C) 2006 Exophase <exophase@gmail.com>
4  *
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.
9  *
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.
14  *
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
18  */
19
20
21 #include "common.h"
22 #include <SDL.h>
23 u32 global_enable_audio = 1;
24
25 direct_sound_struct direct_sound_channel[2];
26 gbc_sound_struct gbc_sound_channel[4];
27
28 u32 sound_frequency = 44100;
29
30 SDL_AudioSpec sound_settings;
31 SDL_mutex *sound_mutex;
32 SDL_cond *sound_cv;
33
34 #ifndef PSP_BUILD
35 u32 audio_buffer_size_number = 7;
36 #else
37 u32 audio_buffer_size_number = 1;
38 #endif
39
40 u32 audio_buffer_size;
41 u32 sound_on = 0;
42 s16 sound_buffer[BUFFER_SIZE];
43 u32 sound_buffer_base = 0;
44
45 u32 sound_last_cpu_ticks = 0;
46 fixed16_16 gbc_sound_tick_step;
47
48 // Queue 1, 2, or 4 samples to the top of the DS FIFO, wrap around circularly
49
50 #define sound_timer_queue(size, value)                                        \
51   *((s##size *)(ds->fifo + ds->fifo_top)) = value;                            \
52   ds->fifo_top = (ds->fifo_top + 1) % 32;                                     \
53
54 void sound_timer_queue8(u32 channel, u8 value)
55 {
56   direct_sound_struct *ds = direct_sound_channel + channel;
57   sound_timer_queue(8, value);
58 }
59
60 void sound_timer_queue16(u32 channel, u16 value)
61 {
62   direct_sound_struct *ds = direct_sound_channel + channel;
63   sound_timer_queue(8, value & 0xFF);
64   sound_timer_queue(8, value >> 8);
65 }
66
67 void sound_timer_queue32(u32 channel, u32 value)
68 {
69   direct_sound_struct *ds = direct_sound_channel + channel;
70
71   sound_timer_queue(8, value & 0xFF);
72   sound_timer_queue(8, (value >> 8) & 0xFF);
73   sound_timer_queue(8, (value >> 16) & 0xFF);
74   sound_timer_queue(8, value >> 24);
75 }
76
77 // Unqueue 1 sample from the base of the DS FIFO and place it on the audio
78 // buffer for as many samples as necessary. If the DS FIFO is 16 bytes or
79 // smaller and if DMA is enabled for the sound channel initiate a DMA transfer
80 // to the DS FIFO.
81
82 #define render_sample_null()                                                  \
83
84 #define render_sample_left()                                                  \
85   sound_buffer[buffer_index] += current_sample +                              \
86    fp16_16_to_u32((next_sample - current_sample) * fifo_fractional)           \
87
88 #define render_sample_right()                                                 \
89   sound_buffer[buffer_index + 1] += current_sample +                          \
90    fp16_16_to_u32((next_sample - current_sample) * fifo_fractional)           \
91
92 #define render_sample_both()                                                  \
93   dest_sample = current_sample +                                              \
94    fp16_16_to_u32((next_sample - current_sample) * fifo_fractional);          \
95   sound_buffer[buffer_index] += dest_sample;                                  \
96   sound_buffer[buffer_index + 1] += dest_sample                               \
97
98 #define render_samples(type)                                                  \
99   while(fifo_fractional <= 0xFFFF)                                            \
100   {                                                                           \
101     render_sample_##type();                                                   \
102     fifo_fractional += frequency_step;                                        \
103     buffer_index = (buffer_index + 2) % BUFFER_SIZE;                          \
104   }                                                                           \
105
106 void sound_timer(fixed16_16 frequency_step, u32 channel)
107 {
108   direct_sound_struct *ds = direct_sound_channel + channel;
109
110   fixed16_16 fifo_fractional = ds->fifo_fractional;
111   u32 buffer_index = ds->buffer_index;
112   s16 current_sample, next_sample, dest_sample;
113
114   current_sample = ds->fifo[ds->fifo_base] << 4;
115   ds->fifo_base = (ds->fifo_base + 1) % 32;
116   next_sample = ds->fifo[ds->fifo_base] << 4;
117
118   if(sound_on == 1)
119   {
120     if(ds->volume == DIRECT_SOUND_VOLUME_50)
121     {
122       current_sample >>= 1;
123       next_sample >>= 1;
124     }
125
126     switch(ds->status)
127     {
128       case DIRECT_SOUND_INACTIVE:
129         render_samples(null);
130         break;
131
132       case DIRECT_SOUND_RIGHT:
133         render_samples(right);
134         break;
135
136       case DIRECT_SOUND_LEFT:
137         render_samples(left);
138         break;
139
140       case DIRECT_SOUND_LEFTRIGHT:
141         render_samples(both);
142         break;
143     }
144   }
145   else
146   {
147     render_samples(null);
148   }
149
150   ds->buffer_index = buffer_index;
151   ds->fifo_fractional = fp16_16_fractional_part(fifo_fractional);
152
153   if(((ds->fifo_top - ds->fifo_base) % 32) <= 16)
154   {
155     if(dma[1].direct_sound_channel == channel)
156       dma_transfer(dma + 1);
157
158     if(dma[2].direct_sound_channel == channel)
159       dma_transfer(dma + 2);
160   }
161 }
162
163 void sound_reset_fifo(u32 channel)
164 {
165   direct_sound_struct *ds = direct_sound_channel;
166
167   memset(ds->fifo, 0, 32);
168 }
169
170 // Initial pattern data = 4bits (signed)
171 // Channel volume = 12bits
172 // Envelope volume = 14bits
173 // Master volume = 2bits
174
175 // Recalculate left and right volume as volume changes.
176 // To calculate the current sample, use (sample * volume) >> 16
177
178 // Square waves range from -8 (low) to 7 (high)
179
180 s8 square_pattern_duty[4][8] =
181 {
182   { 0xF8, 0xF8, 0xF8, 0xF8, 0x07, 0xF8, 0xF8, 0xF8 },
183   { 0xF8, 0xF8, 0xF8, 0xF8, 0x07, 0x07, 0xF8, 0xF8 },
184   { 0xF8, 0xF8, 0x07, 0x07, 0x07, 0x07, 0xF8, 0xF8 },
185   { 0x07, 0x07, 0x07, 0x07, 0xF8, 0xF8, 0x07, 0x07 },
186 };
187
188 s8 wave_samples[64];
189
190 u32 noise_table15[1024];
191 u32 noise_table7[4];
192
193 u32 gbc_sound_master_volume_table[4] = { 1, 2, 4, 0 };
194
195 u32 gbc_sound_channel_volume_table[8] =
196 {
197   fixed_div(0, 7, 12),
198   fixed_div(1, 7, 12),
199   fixed_div(2, 7, 12),
200   fixed_div(3, 7, 12),
201   fixed_div(4, 7, 12),
202   fixed_div(5, 7, 12),
203   fixed_div(6, 7, 12),
204   fixed_div(7, 7, 12)
205 };
206
207 u32 gbc_sound_envelope_volume_table[16] =
208 {
209   fixed_div(0, 15, 14),
210   fixed_div(1, 15, 14),
211   fixed_div(2, 15, 14),
212   fixed_div(3, 15, 14),
213   fixed_div(4, 15, 14),
214   fixed_div(5, 15, 14),
215   fixed_div(6, 15, 14),
216   fixed_div(7, 15, 14),
217   fixed_div(8, 15, 14),
218   fixed_div(9, 15, 14),
219   fixed_div(10, 15, 14),
220   fixed_div(11, 15, 14),
221   fixed_div(12, 15, 14),
222   fixed_div(13, 15, 14),
223   fixed_div(14, 15, 14),
224   fixed_div(15, 15, 14)
225 };
226
227 u32 gbc_sound_buffer_index = 0;
228 u32 gbc_sound_last_cpu_ticks = 0;
229 u32 gbc_sound_partial_ticks = 0;
230
231 u32 gbc_sound_master_volume_left;
232 u32 gbc_sound_master_volume_right;
233 u32 gbc_sound_master_volume;
234
235 #define update_volume_channel_envelope(channel)                               \
236   volume_##channel = gbc_sound_envelope_volume_table[envelope_volume] *       \
237    gbc_sound_channel_volume_table[gbc_sound_master_volume_##channel] *        \
238    gbc_sound_master_volume_table[gbc_sound_master_volume]                     \
239
240 #define update_volume_channel_noenvelope(channel)                             \
241   volume_##channel = gs->wave_volume *                                        \
242    gbc_sound_channel_volume_table[gbc_sound_master_volume_##channel] *        \
243    gbc_sound_master_volume_table[gbc_sound_master_volume]                     \
244
245 #define update_volume(type)                                                   \
246   update_volume_channel_##type(left);                                         \
247   update_volume_channel_##type(right)                                         \
248
249 #define update_tone_sweep()                                                   \
250   if(gs->sweep_status)                                                        \
251   {                                                                           \
252     u32 sweep_ticks = gs->sweep_ticks - 1;                                    \
253                                                                               \
254     if(sweep_ticks == 0)                                                      \
255     {                                                                         \
256       u32 rate = gs->rate;                                                    \
257                                                                               \
258       if(gs->sweep_direction)                                                 \
259         rate = rate - (rate >> gs->sweep_shift);                              \
260       else                                                                    \
261         rate = rate + (rate >> gs->sweep_shift);                              \
262                                                                               \
263       if(rate > 2048)                                                         \
264         rate = 2048;                                                          \
265                                                                               \
266       frequency_step = float_to_fp16_16(((131072.0 / (2048 - rate)) * 8.0) /  \
267        sound_frequency);                                                      \
268                                                                               \
269       gs->frequency_step = frequency_step;                                    \
270       gs->rate = rate;                                                        \
271                                                                               \
272       sweep_ticks = gs->sweep_initial_ticks;                                  \
273     }                                                                         \
274     gs->sweep_ticks = sweep_ticks;                                            \
275   }                                                                           \
276
277 #define update_tone_nosweep()                                                 \
278
279 #define update_tone_envelope()                                                \
280   if(gs->envelope_status)                                                     \
281   {                                                                           \
282     u32 envelope_ticks = gs->envelope_ticks - 1;                              \
283     envelope_volume = gs->envelope_volume;                                    \
284                                                                               \
285     if(envelope_ticks == 0)                                                   \
286     {                                                                         \
287       if(gs->envelope_direction)                                              \
288       {                                                                       \
289         if(envelope_volume != 15)                                             \
290           envelope_volume = gs->envelope_volume + 1;                          \
291       }                                                                       \
292       else                                                                    \
293       {                                                                       \
294         if(envelope_volume != 0)                                              \
295           envelope_volume = gs->envelope_volume - 1;                          \
296       }                                                                       \
297                                                                               \
298       update_volume(envelope);                                                \
299                                                                               \
300       gs->envelope_volume = envelope_volume;                                  \
301       gs->envelope_ticks = gs->envelope_initial_ticks;                        \
302     }                                                                         \
303     else                                                                      \
304     {                                                                         \
305       gs->envelope_ticks = envelope_ticks;                                    \
306     }                                                                         \
307   }                                                                           \
308
309 #define update_tone_noenvelope()                                              \
310
311 #define gbc_sound_synchronize()                                               \
312   while(((gbc_sound_buffer_index - sound_buffer_base) % BUFFER_SIZE) >        \
313    (audio_buffer_size * 2))                                                   \
314   {                                                                           \
315     SDL_CondWait(sound_cv, sound_mutex);                                      \
316   }                                                                           \
317
318 #define update_tone_counters(envelope_op, sweep_op)                           \
319   tick_counter += gbc_sound_tick_step;                                        \
320   if(tick_counter > 0xFFFF)                                                   \
321   {                                                                           \
322     if(gs->length_status)                                                     \
323     {                                                                         \
324       u32 length_ticks = gs->length_ticks - 1;                                \
325       gs->length_ticks = length_ticks;                                        \
326                                                                               \
327       if(length_ticks == 0)                                                   \
328       {                                                                       \
329         gs->active_flag = 0;                                                  \
330         break;                                                                \
331       }                                                                       \
332     }                                                                         \
333                                                                               \
334     update_tone_##envelope_op();                                              \
335     update_tone_##sweep_op();                                                 \
336                                                                               \
337     tick_counter &= 0xFFFF;                                                   \
338   }                                                                           \
339
340 #define gbc_sound_render_sample_right()                                       \
341   sound_buffer[buffer_index + 1] += (current_sample * volume_right) >> 22     \
342
343 #define gbc_sound_render_sample_left()                                        \
344   sound_buffer[buffer_index] += (current_sample * volume_left) >> 22          \
345
346 #define gbc_sound_render_sample_both()                                        \
347   gbc_sound_render_sample_right();                                            \
348   gbc_sound_render_sample_left()                                              \
349
350 #define gbc_sound_render_samples(type, sample_length, envelope_op, sweep_op)  \
351   for(i = 0; i < buffer_ticks; i++)                                           \
352   {                                                                           \
353     current_sample =                                                          \
354      sample_data[fp16_16_to_u32(sample_index) % sample_length];               \
355     gbc_sound_render_sample_##type();                                         \
356                                                                               \
357     sample_index += frequency_step;                                           \
358     buffer_index = (buffer_index + 2) % BUFFER_SIZE;                          \
359                                                                               \
360     update_tone_counters(envelope_op, sweep_op);                              \
361   }                                                                           \
362
363 #define gbc_noise_wrap_full 32767
364
365 #define gbc_noise_wrap_half 126
366
367 #define get_noise_sample_full()                                               \
368   current_sample =                                                            \
369    ((s32)(noise_table15[fp16_16_to_u32(sample_index) >> 5] <<                 \
370    (fp16_16_to_u32(sample_index) & 0x1F)) >> 31) & 0x0F                       \
371
372 #define get_noise_sample_half()                                               \
373   current_sample =                                                            \
374    ((s32)(noise_table7[fp16_16_to_u32(sample_index) >> 5] <<                  \
375    (fp16_16_to_u32(sample_index) & 0x1F)) >> 31) & 0x0F                       \
376
377 #define gbc_sound_render_noise(type, noise_type, envelope_op, sweep_op)       \
378   for(i = 0; i < buffer_ticks; i++)                                           \
379   {                                                                           \
380     get_noise_sample_##noise_type();                                          \
381     gbc_sound_render_sample_##type();                                         \
382                                                                               \
383     sample_index += frequency_step;                                           \
384                                                                               \
385     if(sample_index >= u32_to_fp16_16(gbc_noise_wrap_##noise_type))           \
386       sample_index -= u32_to_fp16_16(gbc_noise_wrap_##noise_type);            \
387                                                                               \
388     buffer_index = (buffer_index + 2) % BUFFER_SIZE;                          \
389     update_tone_counters(envelope_op, sweep_op);                              \
390   }                                                                           \
391
392 #define gbc_sound_render_channel(type, sample_length, envelope_op, sweep_op)  \
393   buffer_index = gbc_sound_buffer_index;                                      \
394   sample_index = gs->sample_index;                                            \
395   frequency_step = gs->frequency_step;                                        \
396   tick_counter = gs->tick_counter;                                            \
397                                                                               \
398   update_volume(envelope_op);                                                 \
399                                                                               \
400   switch(gs->status)                                                          \
401   {                                                                           \
402     case GBC_SOUND_INACTIVE:                                                  \
403       break;                                                                  \
404                                                                               \
405     case GBC_SOUND_LEFT:                                                      \
406       gbc_sound_render_##type(left, sample_length, envelope_op, sweep_op);    \
407       break;                                                                  \
408                                                                               \
409     case GBC_SOUND_RIGHT:                                                     \
410       gbc_sound_render_##type(right, sample_length, envelope_op, sweep_op);   \
411       break;                                                                  \
412                                                                               \
413     case GBC_SOUND_LEFTRIGHT:                                                 \
414       gbc_sound_render_##type(both, sample_length, envelope_op, sweep_op);    \
415       break;                                                                  \
416   }                                                                           \
417                                                                               \
418   gs->sample_index = sample_index;                                            \
419   gs->tick_counter = tick_counter;                                            \
420
421 #define gbc_sound_load_wave_ram(bank)                                         \
422   wave_bank = wave_samples + (bank * 32);                                     \
423   for(i = 0, i2 = 0; i < 16; i++, i2 += 2)                                    \
424   {                                                                           \
425     current_sample = wave_ram[i];                                             \
426     wave_bank[i2] = (((current_sample >> 4) & 0x0F) - 8);                     \
427     wave_bank[i2 + 1] = ((current_sample & 0x0F) - 8);                        \
428   }                                                                           \
429
430 void synchronize_sound()
431 {
432   SDL_LockMutex(sound_mutex);
433
434   gbc_sound_synchronize();
435
436   SDL_UnlockMutex(sound_mutex);
437 }
438
439 void update_gbc_sound(u32 cpu_ticks)
440 {
441   fixed16_16 buffer_ticks = float_to_fp16_16(((float)(cpu_ticks -
442    gbc_sound_last_cpu_ticks) * sound_frequency) / 16777216.0);
443   u32 i, i2;
444   gbc_sound_struct *gs = gbc_sound_channel;
445   fixed16_16 sample_index, frequency_step;
446   fixed16_16 tick_counter;
447   u32 buffer_index;
448   s32 volume_left, volume_right;
449   u32 envelope_volume;
450   s32 current_sample;
451   u32 sound_status = address16(io_registers, 0x84) & 0xFFF0;
452   s8 *sample_data;
453   s8 *wave_bank;
454   u8 *wave_ram = ((u8 *)io_registers) + 0x90;
455
456   gbc_sound_partial_ticks += fp16_16_fractional_part(buffer_ticks);
457   buffer_ticks = fp16_16_to_u32(buffer_ticks);
458
459   if(gbc_sound_partial_ticks > 0xFFFF)
460   {
461     buffer_ticks += 1;
462     gbc_sound_partial_ticks &= 0xFFFF;
463   }
464
465   SDL_LockMutex(sound_mutex);
466   if(synchronize_flag)
467   {
468     if(((gbc_sound_buffer_index - sound_buffer_base) % BUFFER_SIZE) >
469      (audio_buffer_size * 3 / 2))
470     {
471       while(((gbc_sound_buffer_index - sound_buffer_base) % BUFFER_SIZE) >
472        (audio_buffer_size * 3 / 2))
473       {
474         SDL_CondWait(sound_cv, sound_mutex);
475       }
476
477 #ifdef PSP_BUILD
478       if(current_frameskip_type == auto_frameskip)
479       {
480         sceDisplayWaitVblankStart();
481         real_frame_count = 0;
482         virtual_frame_count = 0;
483       }
484 #endif
485
486 /*
487
488 #ifdef GP2X_BUILD
489       if(current_frameskip_type == auto_frameskip)
490       {
491         u64 current_ticks;
492         u64 next_ticks;
493         get_ticks_us(&current_ticks);
494
495         next_ticks = ((current_ticks + 16666) / 16667) * 16667;
496         delay_us(next_ticks - current_ticks);
497
498         get_ticks_us(&frame_count_initial_timestamp);
499         real_frame_count = 0;
500         virtual_frame_count = 0;
501       }
502 #endif
503
504 */
505     }
506   }
507   if(sound_on == 1)
508   {
509     gs = gbc_sound_channel + 0;
510     if(gs->active_flag)
511     {
512       sound_status |= 0x01;
513       sample_data = gs->sample_data;
514       envelope_volume = gs->envelope_volume;
515       gbc_sound_render_channel(samples, 8, envelope, sweep);
516     }
517
518     gs = gbc_sound_channel + 1;
519     if(gs->active_flag)
520     {
521       sound_status |= 0x02;
522       sample_data = gs->sample_data;
523       envelope_volume = gs->envelope_volume;
524       gbc_sound_render_channel(samples, 8, envelope, nosweep);
525     }
526
527     gs = gbc_sound_channel + 2;
528     if(gbc_sound_wave_update)
529     {
530       if(gs->wave_bank == 1)
531       {
532         gbc_sound_load_wave_ram(1);
533       }
534       else
535       {
536         gbc_sound_load_wave_ram(0);
537       }
538
539       gbc_sound_wave_update = 0;
540     }
541
542     if((gs->active_flag) && (gs->master_enable))
543     {
544       sound_status |= 0x04;
545       sample_data = wave_samples;
546       if(gs->wave_type == 0)
547       {
548         if(gs->wave_bank == 1)
549           sample_data += 32;
550
551         gbc_sound_render_channel(samples, 32, noenvelope, nosweep);
552       }
553       else
554       {
555         gbc_sound_render_channel(samples, 64, noenvelope, nosweep);
556       }
557     }
558
559     gs = gbc_sound_channel + 3;
560     if(gs->active_flag)
561     {
562       sound_status |= 0x08;
563       envelope_volume = gs->envelope_volume;
564
565       if(gs->noise_type == 1)
566       {
567         gbc_sound_render_channel(noise, half, envelope, nosweep);
568       }
569       else
570       {
571         gbc_sound_render_channel(noise, full, envelope, nosweep);
572       }
573     }
574   }
575
576   address16(io_registers, 0x84) = sound_status;
577
578   gbc_sound_last_cpu_ticks = cpu_ticks;
579   gbc_sound_buffer_index =
580    (gbc_sound_buffer_index + (buffer_ticks * 2)) % BUFFER_SIZE;
581
582   SDL_UnlockMutex(sound_mutex);
583
584   SDL_CondSignal(sound_cv);
585 }
586
587 #define sound_copy_normal()                                                   \
588   current_sample = source[i]                                                  \
589
590 #define sound_copy(source_offset, length, render_type)                        \
591   _length = (length) / 2;                                                     \
592   source = (s16 *)(sound_buffer + source_offset);                             \
593   for(i = 0; i < _length; i++)                                                \
594   {                                                                           \
595     sound_copy_##render_type();                                               \
596     if(current_sample > 2047)                                                 \
597       current_sample = 2047;                                                  \
598     if(current_sample < -2048)                                                \
599       current_sample = -2048;                                                 \
600                                                                               \
601     stream_base[i] = current_sample << 4;                                     \
602     source[i] = 0;                                                            \
603   }                                                                           \
604
605 #define sound_copy_null(source_offset, length)                                \
606   _length = (length) / 2;                                                     \
607   source = (s16 *)(sound_buffer + source_offset);                             \
608   for(i = 0; i < _length; i++)                                                \
609   {                                                                           \
610     stream_base[i] = 0;                                                       \
611     source[i] = 0;                                                            \
612   }                                                                           \
613
614
615 void sound_callback(void *userdata, Uint8 *stream, int length)
616 {
617   u32 sample_length = length / 2;
618   u32 _length;
619   u32 i;
620   s16 *stream_base = (s16 *)stream;
621   s16 *source;
622   s32 current_sample;
623
624   SDL_LockMutex(sound_mutex);
625
626   while(((gbc_sound_buffer_index - sound_buffer_base) % BUFFER_SIZE) <
627    length)
628   {
629     SDL_CondWait(sound_cv, sound_mutex);
630   }
631
632   if(global_enable_audio)
633   {
634     if((sound_buffer_base + sample_length) >= BUFFER_SIZE)
635     {
636       u32 partial_length = (BUFFER_SIZE - sound_buffer_base) * 2;
637       sound_copy(sound_buffer_base, partial_length, normal);
638       source = (s16 *)sound_buffer;
639       sound_copy(0, length - partial_length, normal);
640       sound_buffer_base = (length - partial_length) / 2;
641     }
642     else
643     {
644       sound_copy(sound_buffer_base, length, normal);
645       sound_buffer_base += sample_length;
646     }
647   }
648   else
649   {
650     if((sound_buffer_base + sample_length) >= BUFFER_SIZE)
651     {
652       u32 partial_length = (BUFFER_SIZE - sound_buffer_base) * 2;
653       sound_copy_null(sound_buffer_base, partial_length);
654       source = (s16 *)sound_buffer;
655       sound_copy(0, length - partial_length, normal);
656       sound_buffer_base = (length - partial_length) / 2;
657     }
658     else
659     {
660       sound_copy_null(sound_buffer_base, length);
661       sound_buffer_base += sample_length;
662     }
663   }
664
665   SDL_CondSignal(sound_cv);
666
667   SDL_UnlockMutex(sound_mutex);
668 }
669
670 // Special thanks to blarrg for the LSFR frequency used in Meridian, as posted
671 // on the forum at http://meridian.overclocked.org:
672 // http://meridian.overclocked.org/cgi-bin/wwwthreads/showpost.pl?Board=merid
673 // angeneraldiscussion&Number=2069&page=0&view=expanded&mode=threaded&sb=4
674 // Hope you don't mind me borrowing it ^_-
675
676 void init_noise_table(u32 *table, u32 period, u32 bit_length)
677 {
678   u32 shift_register = 0xFF;
679   u32 mask = ~(1 << bit_length);
680   s32 table_pos, bit_pos;
681   u32 current_entry;
682   u32 table_period = (period + 31) / 32;
683
684   // Bits are stored in reverse order so they can be more easily moved to
685   // bit 31, for sign extended shift down.
686
687   for(table_pos = 0; table_pos < table_period; table_pos++)
688   {
689     current_entry = 0;
690     for(bit_pos = 31; bit_pos >= 0; bit_pos--)
691     {
692       current_entry |= (shift_register & 0x01) << bit_pos;
693
694       shift_register =
695        ((1 & (shift_register ^ (shift_register >> 1))) << bit_length) |
696        ((shift_register >> 1) & mask);
697     }
698
699     table[table_pos] = current_entry;
700   }
701 }
702
703 void reset_sound()
704 {
705   direct_sound_struct *ds = direct_sound_channel;
706   gbc_sound_struct *gs = gbc_sound_channel;
707   u32 i;
708
709   sound_on = 0;
710   sound_buffer_base = 0;
711   sound_last_cpu_ticks = 0;
712   memset(sound_buffer, 0, audio_buffer_size);
713
714   for(i = 0; i < 2; i++, ds++)
715   {
716     ds->buffer_index = 0;
717     ds->status = DIRECT_SOUND_INACTIVE;
718     ds->fifo_top = 0;
719     ds->fifo_base = 0;
720     ds->fifo_fractional = 0;
721     ds->last_cpu_ticks = 0;
722     memset(ds->fifo, 0, 32);
723   }
724
725   gbc_sound_buffer_index = 0;
726   gbc_sound_last_cpu_ticks = 0;
727   gbc_sound_partial_ticks = 0;
728
729   gbc_sound_master_volume_left = 0;
730   gbc_sound_master_volume_right = 0;
731   gbc_sound_master_volume = 0;
732   memset(wave_samples, 0, 64);
733
734   for(i = 0; i < 4; i++, gs++)
735   {
736     gs->status = GBC_SOUND_INACTIVE;
737     gs->sample_data = square_pattern_duty[2];
738     gs->active_flag = 0;
739   }
740 }
741
742 void sound_exit()
743 {
744   gbc_sound_buffer_index =
745    (sound_buffer_base + audio_buffer_size) % BUFFER_SIZE;
746   SDL_PauseAudio(1);
747   SDL_CondSignal(sound_cv);
748 }
749
750 void init_sound()
751 {
752 #ifdef PSP_BUILD
753   audio_buffer_size = (audio_buffer_size_number * 1024) + 3072;
754 #elif defined(TAVI_BUILD) || defined(ARM_ARCH)
755   audio_buffer_size = 16 << audio_buffer_size_number;
756 //  audio_buffer_size = 16384;
757 #else
758   audio_buffer_size = 16384;
759 #endif
760
761   SDL_AudioSpec desired_spec =
762   {
763     sound_frequency,
764     AUDIO_S16,
765     2,
766     0,
767     audio_buffer_size / 4,
768     0,
769     0,
770     sound_callback,
771     NULL
772   };
773
774   gbc_sound_tick_step =
775    float_to_fp16_16(256.0 / sound_frequency);
776
777   init_noise_table(noise_table15, 32767, 14);
778   init_noise_table(noise_table7, 127, 6);
779
780   reset_sound();
781
782   SDL_OpenAudio(&desired_spec, &sound_settings);
783   sound_frequency = sound_settings.freq;
784   sound_mutex = SDL_CreateMutex();
785   sound_cv = SDL_CreateCond();
786   SDL_PauseAudio(0);
787 }
788
789 #define sound_savestate_builder(type)                                       \
790 void sound_##type##_savestate(file_tag_type savestate_file)                 \
791 {                                                                           \
792   file_##type##_variable(savestate_file, sound_on);                         \
793   file_##type##_variable(savestate_file, sound_buffer_base);                \
794   file_##type##_variable(savestate_file, sound_last_cpu_ticks);             \
795   file_##type##_variable(savestate_file, gbc_sound_buffer_index);           \
796   file_##type##_variable(savestate_file, gbc_sound_last_cpu_ticks);         \
797   file_##type##_variable(savestate_file, gbc_sound_partial_ticks);          \
798   file_##type##_variable(savestate_file, gbc_sound_master_volume_left);     \
799   file_##type##_variable(savestate_file, gbc_sound_master_volume_right);    \
800   file_##type##_variable(savestate_file, gbc_sound_master_volume);          \
801   file_##type##_array(savestate_file, wave_samples);                        \
802   file_##type##_array(savestate_file, direct_sound_channel);                \
803   file_##type##_array(savestate_file, gbc_sound_channel);                   \
804 }                                                                           \
805
806 sound_savestate_builder(read);
807 sound_savestate_builder(write_mem);
808