source/src/vm/familybasic/apu.h

   1 /*
   2         Nintendo Family BASIC Emulator 'eFamilyBASIC'
   3
   4         Origin : nester
   5         Author : Takeda.Toshiya
   6         Date   : 2010.08.11-
   7
   8         [ APU ]
   9 */
  10
  11 #ifndef _APU_H_
  12 #define _APU_H_
  13
  14 #include "../vm.h"
  15 #include "../../emu.h"
  16 #include "../device.h"
  17
  18 #define APUQUEUE_SIZE   4096
  19 #define APUQUEUE_MASK   (APUQUEUE_SIZE - 1)
  20
  21 class APU : public DEVICE
  22 {
  23 private:
  24         DEVICE *d_cpu, *d_mem;
  25
  26         // rectangle
  27         typedef struct {
  28                 uint8_t regs[4];
  29                 bool enabled;
  30                 int32_t phaseacc;
  31                 int32_t freq;
  32                 int32_t output_vol;
  33                 bool fixed_envelope;
  34                 bool holdnote;
  35                 uint8_t volume;
  36                 int32_t sweep_phase;
  37                 int32_t sweep_delay;
  38                 bool sweep_on;
  39                 uint8_t sweep_shifts;
  40                 uint8_t sweep_length;
  41                 bool sweep_inc;
  42                 int32_t freq_limit;
  43                 bool sweep_complement;
  44                 int32_t env_phase;
  45                 int32_t env_delay;
  46                 uint8_t env_vol;
  47                 int vbl_length;
  48                 uint8_t adder;
  49                 int duty_flip;
  50                 bool enabled_cur;
  51                 bool holdnote_cur;
  52                 int vbl_length_cur;
  53         } rectangle_t;
  54
  55         // triangle
  56         typedef struct {
  57                 uint8_t regs[3];
  58                 bool enabled;
  59                 int32_t freq;
  60                 int32_t phaseacc;
  61                 int32_t output_vol;
  62                 uint8_t adder;
  63                 bool holdnote;
  64                 bool counter_started;
  65                 int write_latency;
  66                 int vbl_length;
  67                 int linear_length;
  68                 bool enabled_cur;
  69                 bool holdnote_cur;
  70                 bool counter_started_cur;
  71                 int vbl_length_cur;
  72         } triangle_t;
  73
  74         // noise
  75         typedef struct {
  76                 uint8_t regs[3];
  77                 bool enabled;
  78                 int32_t freq;
  79                 int32_t phaseacc;
  80                 int32_t output_vol;
  81                 int32_t env_phase;
  82                 int32_t env_delay;
  83                 uint8_t env_vol;
  84                 bool fixed_envelope;
  85                 bool holdnote;
  86                 uint8_t volume;
  87                 int vbl_length;
  88                 uint8_t xor_tap;
  89                 bool enabled_cur;
  90                 bool holdnote_cur;
  91                 int vbl_length_cur;
  92
  93                 int shift_reg;
  94                 int noise_bit;
  95         } noise_t;
  96
  97         // dmc
  98         typedef struct {
  99                 uint8_t regs[4];
 100                 bool enabled;
 101                 int32_t freq;
 102                 int32_t phaseacc;
 103                 int32_t output_vol;
 104                 uint32_t address;
 105                 uint32_t cached_addr;
 106                 int dma_length;
 107                 int cached_dmalength;
 108                 uint8_t cur_byte;
 109                 bool looping;
 110                 bool irq_gen;
 111                 bool irq_occurred;
 112                 int32_t freq_cur;
 113                 int32_t phaseacc_cur;
 114                 int dma_length_cur;
 115                 int cached_dmalength_cur;
 116                 bool enabled_cur;
 117                 bool looping_cur;
 118                 bool irq_gen_cur;
 119                 bool irq_occurred_cur;
 120         } dmc_t;
 121
 122         // queue
 123         typedef struct {
 124                 uint32_t timestamp, addr;
 125                 uint32_t data;
 126         } queue_t;
 127
 128         rectangle_t rectangle[2];
 129         triangle_t triangle;
 130         noise_t noise;
 131         dmc_t dmc;
 132
 133         int32_t cycle_rate;
 134         int32_t decay_lut[16];
 135         int vbl_lut[32];
 136         int trilength_lut[128];
 137
 138         uint32_t enable_reg;
 139         uint32_t enable_reg_cur;
 140         int count_rate;
 141
 142         queue_t queue[APUQUEUE_SIZE];
 143         int q_head, q_tail;
 144         uint32_t elapsed_cycles;
 145         double ave, max, min;
 146
 147         int32_t create_rectangle(rectangle_t *chan);
 148         int32_t create_triangle(triangle_t *chan);
 149         int32_t create_noise(noise_t *chan);
 150         inline void dmc_reload(dmc_t *chan);
 151         int32_t create_dmc(dmc_t *chan);
 152         void enqueue(queue_t *d);
 153         queue_t* dequeue();
 154         void write_data_sync(uint32_t addr, uint32_t data);
 155         void write_data_cur(uint32_t addr, uint32_t data);
 156
 157         int volume_l, volume_r;
 158
 159         void decl_state_rectangle(int num);
 160         void decl_state_triangle();
 161         void decl_state_noise();
 162         void decl_state_dmc();
 163         void decl_state_queue(int num);
 164
 165 public:
 166         APU(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
 167         {
 168                 volume_l = volume_r = 1024;
 169                 set_device_name(_T("APU"));
 170         }
 171         ~APU() {}
 172
 173         // common functions
 174         void initialize();
 175         void reset();
 176         void write_data8(uint32_t addr, uint32_t data);
 177         uint32_t read_data8(uint32_t addr);
 178         void event_frame();
 179         void event_vline(int v, int clock);
 180         void mix(int32_t* buffer, int cnt);
 181         void set_volume(int ch, int decibel_l, int decibel_r);
 182         void decl_state();
 183         void save_state(FILEIO* state_fio);
 184         bool load_state(FILEIO* state_fio);
 185
 186         // unique functions
 187         void set_context_cpu(DEVICE* device)
 188         {
 189                 d_cpu = device;
 190         }
 191         void set_context_memory(DEVICE* device)
 192         {
 193                 d_mem = device;
 194         }
 195         void initialize_sound(int rate, int samples);
 196 };
 197
 198 #endif
 199