Move IN_MEMORY_C ifdefs to memory.c

1 files changed, 0 insertions, 195 deletions

diff --git a/sound.h b/sound.h
index 0725292..72257e8 100644
--- a/sound.h
+++ b/sound.h
@@ -125,201 +125,6 @@ void sound_read_savestate(file_tag_type savestate_file);
 
 void render_audio(void);
 
-#ifdef IN_MEMORY_C
-
-#define gbc_sound_tone_control_low(channel, address)                          \
-{                                                                             \
-  u32 initial_volume = (value >> 12) & 0x0F;                                  \
-  u32 envelope_ticks = ((value >> 8) & 0x07) * 4;                             \
-  gbc_sound_channel[channel].length_ticks = 64 - (value & 0x3F);              \
-  gbc_sound_channel[channel].sample_data =                                    \
-   square_pattern_duty[(value >> 6) & 0x03];                                  \
-  gbc_sound_channel[channel].envelope_direction = (value >> 11) & 0x01;       \
-  gbc_sound_channel[channel].envelope_initial_volume = initial_volume;        \
-  gbc_sound_channel[channel].envelope_volume = initial_volume;                \
-  gbc_sound_channel[channel].envelope_initial_ticks = envelope_ticks;         \
-  gbc_sound_channel[channel].envelope_ticks = envelope_ticks;                 \
-  gbc_sound_channel[channel].envelope_status = (envelope_ticks != 0);         \
-  gbc_sound_channel[channel].envelope_volume = initial_volume;                \
-  gbc_sound_update = 1;                                                       \
-  address16(io_registers, address) = value;                                   \
-}                                                                             \
-
-#define gbc_sound_tone_control_high(channel, address)                         \
-{                                                                             \
-  u32 rate = value & 0x7FF;                                                   \
-  gbc_sound_channel[channel].rate = rate;                                     \
-  gbc_sound_channel[channel].frequency_step =                                 \
-   float_to_fp16_16(((131072.0 / (2048 - rate)) * 8.0) / sound_frequency);    \
-  gbc_sound_channel[channel].length_status = (value >> 14) & 0x01;            \
-  if(value & 0x8000)                                                          \
-  {                                                                           \
-    gbc_sound_channel[channel].active_flag = 1;                               \
-    gbc_sound_channel[channel].sample_index -= float_to_fp16_16(1.0 / 12.0);  \
-    gbc_sound_channel[channel].envelope_ticks =                               \
-     gbc_sound_channel[channel].envelope_initial_ticks;                       \
-    gbc_sound_channel[channel].envelope_volume =                              \
-     gbc_sound_channel[channel].envelope_initial_volume;                      \
-  }                                                                           \
-                                                                              \
-  gbc_sound_update = 1;                                                       \
-  address16(io_registers, address) = value;                                   \
-}                                                                             \
-
-#define gbc_sound_tone_control_sweep()                                        \
-{                                                                             \
-  u32 sweep_ticks = ((value >> 4) & 0x07) * 2;                                \
-  gbc_sound_channel[0].sweep_shift = value & 0x07;                            \
-  gbc_sound_channel[0].sweep_direction = (value >> 3) & 0x01;                 \
-  gbc_sound_channel[0].sweep_status = (value != 8);                           \
-  gbc_sound_channel[0].sweep_ticks = sweep_ticks;                             \
-  gbc_sound_channel[0].sweep_initial_ticks = sweep_ticks;                     \
-  gbc_sound_update = 1;                                                       \
-  address16(io_registers, 0x60) = value;                                      \
-}                                                                             \
-
-#define gbc_sound_wave_control()                                              \
-{                                                                             \
-  gbc_sound_channel[2].wave_type = (value >> 5) & 0x01;                       \
-  gbc_sound_channel[2].wave_bank = (value >> 6) & 0x01;                       \
-  if(value & 0x80)                                                            \
-  {                                                                           \
-    gbc_sound_channel[2].master_enable = 1;                                   \
-  }                                                                           \
-  else                                                                        \
-  {                                                                           \
-    gbc_sound_channel[2].master_enable = 0;                                   \
-  }                                                                           \
-                                                                              \
-  gbc_sound_update = 1;                                                       \
-  address16(io_registers, 0x70) = value;                                      \
-}                                                                             \
-
-static u32 gbc_sound_wave_volume[4] = { 0, 16384, 8192, 4096 };
-
-#define gbc_sound_tone_control_low_wave()                                     \
-{                                                                             \
-  gbc_sound_channel[2].length_ticks = 256 - (value & 0xFF);                   \
-  if((value >> 15) & 0x01)                                                    \
-  {                                                                           \
-    gbc_sound_channel[2].wave_volume = 12288;                                 \
-  }                                                                           \
-  else                                                                        \
-  {                                                                           \
-    gbc_sound_channel[2].wave_volume =                                        \
-     gbc_sound_wave_volume[(value >> 13) & 0x03];                             \
-  }                                                                           \
-  gbc_sound_update = 1;                                                       \
-  address16(io_registers, 0x72) = value;                                      \
-}                                                                             \
-
-#define gbc_sound_tone_control_high_wave()                                    \
-{                                                                             \
-  u32 rate = value & 0x7FF;                                                   \
-  gbc_sound_channel[2].rate = rate;                                           \
-  gbc_sound_channel[2].frequency_step =                                       \
-   float_to_fp16_16((2097152.0 / (2048 - rate)) / sound_frequency);           \
-  gbc_sound_channel[2].length_status = (value >> 14) & 0x01;                  \
-  if(value & 0x8000)                                                          \
-  {                                                                           \
-    gbc_sound_channel[2].sample_index = 0;                                    \
-    gbc_sound_channel[2].active_flag = 1;                                     \
-  }                                                                           \
-  gbc_sound_update = 1;                                                       \
-  address16(io_registers, 0x74) = value;                                      \
-}                                                                             \
-
-#define gbc_sound_noise_control()                                             \
-{                                                                             \
-  u32 dividing_ratio = value & 0x07;                                          \
-  u32 frequency_shift = (value >> 4) & 0x0F;                                  \
-  if(dividing_ratio == 0)                                                     \
-  {                                                                           \
-    gbc_sound_channel[3].frequency_step =                                     \
-     float_to_fp16_16(1048576.0 / (1 << (frequency_shift + 1)) /              \
-     sound_frequency);                                                        \
-  }                                                                           \
-  else                                                                        \
-  {                                                                           \
-    gbc_sound_channel[3].frequency_step =                                     \
-     float_to_fp16_16(524288.0 / (dividing_ratio *                            \
-     (1 << (frequency_shift + 1))) / sound_frequency);                        \
-  }                                                                           \
-  gbc_sound_channel[3].noise_type = (value >> 3) & 0x01;                      \
-  gbc_sound_channel[3].length_status = (value >> 14) & 0x01;                  \
-  if(value & 0x8000)                                                          \
-  {                                                                           \
-    gbc_sound_channel[3].sample_index = 0;                                    \
-    gbc_sound_channel[3].active_flag = 1;                                     \
-    gbc_sound_channel[3].envelope_ticks =                                     \
-     gbc_sound_channel[3].envelope_initial_ticks;                             \
-    gbc_sound_channel[3].envelope_volume =                                    \
-     gbc_sound_channel[3].envelope_initial_volume;                            \
-  }                                                                           \
-  gbc_sound_update = 1;                                                       \
-  address16(io_registers, 0x7C) = value;                                      \
-}                                                                             \
-
-#define gbc_trigger_sound_channel(channel)                                    \
-  gbc_sound_master_volume_right = value & 0x07;                               \
-  gbc_sound_master_volume_left = (value >> 4) & 0x07;                         \
-  gbc_sound_channel[channel].status = ((value >> (channel + 8)) & 0x01) |     \
-   ((value >> (channel + 11)) & 0x03)                                         \
-
-#define gbc_trigger_sound()                                                   \
-{                                                                             \
-  gbc_trigger_sound_channel(0);                                               \
-  gbc_trigger_sound_channel(1);                                               \
-  gbc_trigger_sound_channel(2);                                               \
-  gbc_trigger_sound_channel(3);                                               \
-  address16(io_registers, 0x80) = value;                                      \
-}                                                                             \
-
-#define trigger_sound()                                                       \
-{                                                                             \
-  timer[0].direct_sound_channels = (((value >> 10) & 0x01) == 0) |            \
-   ((((value >> 14) & 0x01) == 0) << 1);                                      \
-  timer[1].direct_sound_channels = (((value >> 10) & 0x01) == 1) |            \
-   ((((value >> 14) & 0x01) == 1) << 1);                                      \
-  direct_sound_channel[0].volume = (value >> 2) & 0x01;                       \
-  direct_sound_channel[0].status = (value >> 8) & 0x03;                       \
-  direct_sound_channel[1].volume = (value >> 3) & 0x01;                       \
-  direct_sound_channel[1].status = (value >> 12) & 0x03;                      \
-  gbc_sound_master_volume = value & 0x03;                                     \
-                                                                              \
-  if((value >> 11) & 0x01)                                                    \
-    sound_reset_fifo(0);                                                      \
-  if((value >> 15) & 0x01)                                                    \
-    sound_reset_fifo(1);                                                      \
-  address16(io_registers, 0x82) = value;                                      \
-}                                                                             \
-
-#define sound_on()                                                            \
-  if(value & 0x80)                                                            \
-  {                                                                           \
-    if(sound_on != 1)                                                         \
-    {                                                                         \
-      sound_on = 1;                                                           \
-    }                                                                         \
-  }                                                                           \
-  else                                                                        \
-  {                                                                           \
-    u32 i;                                                                    \
-    for(i = 0; i < 4; i++)                                                    \
-    {                                                                         \
-      gbc_sound_channel[i].active_flag = 0;                                   \
-    }                                                                         \
-    sound_on = 0;                                                             \
-  }                                                                           \
-  address16(io_registers, 0x84) =                                             \
-    (address16(io_registers, 0x84) & 0x000F) | (value & 0xFFF0);              \
-
-#define sound_update_frequency_step(timer_number)                             \
-  timer[timer_number].frequency_step =                                        \
-   float_to_fp8_24(GBC_BASE_RATE / (timer_reload * sound_frequency))          \
-
-#endif // IN_MEMORY_C
-
 void reset_sound();
 void sound_exit();