[VM][EVENT][DEVICE] Add new APIs for recording sound.

[csp-qt/common_source_project-fm7.git] / source / src / vm / libcpu_newdev / device.h

diff --git a/source/src/vm/libcpu_newdev/device.h b/source/src/vm/libcpu_newdev/device.h
index 3a659b2..d695a46 100644 (file)
--- a/source/src/vm/libcpu_newdev/device.h
+++ b/source/src/vm/libcpu_newdev/device.h
@@ -65,6 +65,28 @@ public:
 
        virtual void initialize() { }
        virtual void release();
+
+       virtual void clear_sound_in_source(int bank);
+       // this function may be before (or after) initialize().
+       virtual int add_sound_in_source(int rate, int samples, int channels);
+       // this function may be before (or after) initialize().
+       virtual int release_sound_in_source(int bank);
+       virtual bool is_sound_in_source_exists(int bank);
+       virtual int increment_sound_in_passed_data(int bank, double passed_usec);
+       virtual int get_sound_in_buffers_count();
+       virtual int get_sound_in_samples(int bank);
+       virtual int get_sound_in_rate(int bank);
+       virtual int get_sound_in_channels(int bank);
+       // this function may be before (or after) initialize().
+       virtual int16_t* get_sound_in_buf_ptr(int bank);
+
+       virtual int write_sound_in_buffer(int bank, int32_t* src, int samples);
+       // Add sampled values to sample buffer;value may be -32768 to +32767.
+       // this function may be before (or after) initialize().
+       virtual int get_sound_in_latest_data(int bank, int32_t* dst, int expect_channels);
+       virtual int get_sound_in_data(int bank, int32_t* dst, int expect_samples, int expect_rate, int expect_channels);
+       virtual void set_high_pass_filter_freq(int freq, double quality) { } // If freq < 0 disable HPF.
+       virtual void set_low_pass_filter_freq(int freq, double quality) { }  // If freq <= 0 disable LPF.
        
        virtual void update_config() {}
        virtual void save_state(FILEIO* state_fio) {}
@@ -451,6 +473,10 @@ public:
        // z80 daisy chain
        virtual void set_context_intr(DEVICE* device, uint32_t bit) {}
        virtual void set_context_child(DEVICE* device) {}
+       virtual DEVICE *get_context_child()
+       {
+               return NULL;
+       }
        
        // interrupt device to device
        virtual void set_intr_iei(bool val) {}
@@ -498,7 +524,7 @@ public:
        {
                return false;
        }
-       virtual bool bios_ret_z80(uint16_t PC, pair_t* af, pair_t* bc, pair_t* de, pair_t* hl, pair_t* ix, pair_t* iy, uint8_t* iff1)   {
+       virtual bool bios_ret_z80(uint16_t PC, pair32_t* af, pair32_t* bc, pair32_t* de, pair32_t* hl, pair32_t* ix, pair32_t* iy, uint8_t* iff1)       {
                return false;
        }
        // misc
@@ -515,6 +541,8 @@ public:
                event_manager = device;
        }
        virtual int get_event_manager_id();
+       virtual bool is_primary_cpu(DEVICE* device);
+       virtual void update_extra_event(int clock);
        virtual void register_event(DEVICE* device, int event_id, double usec, bool loop, int* register_id);
        virtual void register_event_by_clock(DEVICE* device, int event_id, uint64_t clock, bool loop, int* register_id);
        virtual void cancel_event(DEVICE* device, int register_id);
@@ -561,14 +589,16 @@ public:
        virtual void mix(int32_t* buffer, int cnt) {}
        virtual void set_volume(int ch, int decibel_l, int decibel_r) {} // +1 equals +0.5dB (same as fmgen)
        virtual void set_device_name(const _TCHAR *format, ...);
-       virtual void out_debug_log(const char *fmt, ...);
-       virtual void force_out_debug_log(const char *fmt, ...);
 
        // debugger
        // DEBUGGER is enabled by default.
+       virtual bool is_cpu();
+       virtual bool is_debugger();
+       virtual bool is_debugger_available();
        virtual void *get_debugger();
        virtual uint32_t get_debug_prog_addr_mask();
        virtual uint32_t get_debug_data_addr_mask();
+       virtual uint64_t get_debug_data_addr_space();
        virtual void write_debug_data8(uint32_t addr, uint32_t data);
        virtual uint32_t read_debug_data8(uint32_t addr);
        virtual void write_debug_data16(uint32_t addr, uint32_t data);
@@ -582,9 +612,55 @@ public:
        virtual void write_debug_io32(uint32_t addr, uint32_t data);
        virtual uint32_t read_debug_io32(uint32_t addr);
        virtual bool write_debug_reg(const _TCHAR *reg, uint32_t data);
-       virtual void get_debug_regs_info(_TCHAR *buffer, size_t buffer_len);
+       virtual uint32_t read_debug_reg(const _TCHAR *reg);
+       virtual bool get_debug_regs_info(_TCHAR *buffer, size_t buffer_len);
        virtual int debug_dasm(uint32_t pc, _TCHAR *buffer, size_t buffer_len);
-       
+/*
+       These functions are used for debugging non-cpu device
+       Insert debugger between standard read/write functions and these functions for checking breakpoints
+
+       void DEVICE::write_data8(uint32_t addr, uint32_t data)
+       {
+               if(debugger != NULL && debugger->now_device_debugging) {
+                       // debugger->mem = this;
+                       // debugger->mem->write_via_debugger_data8(addr, data)
+                       debugger->write_via_debugger_data8(addr, data);
+               } else {
+                       this->write_via_debugger_data8(addr, data);
+               }
+       }
+       void DEVICE::write_via_debugger_data8(uint32_t addr, uint32_t data)
+       {
+               // write memory
+       }
+*/
+       virtual void write_via_debugger_data8(uint32_t addr, uint32_t data);
+       virtual uint32_t read_via_debugger_data8(uint32_t addr);
+       virtual void write_via_debugger_data16(uint32_t addr, uint32_t data);
+       virtual uint32_t read_via_debugger_data16(uint32_t addr);
+       virtual void write_via_debugger_data32(uint32_t addr, uint32_t data);
+       virtual uint32_t read_via_debugger_data32(uint32_t addr);
+       virtual void write_via_debugger_data8w(uint32_t addr, uint32_t data, int* wait);
+       virtual uint32_t read_via_debugger_data8w(uint32_t addr, int* wait);
+       virtual void write_via_debugger_data16w(uint32_t addr, uint32_t data, int* wait);
+       virtual uint32_t read_via_debugger_data16w(uint32_t addr, int* wait);
+       virtual void write_via_debugger_data32w(uint32_t addr, uint32_t data, int* wait);
+       virtual uint32_t read_via_debugger_data32w(uint32_t addr, int* wait);
+       virtual void write_via_debugger_io8(uint32_t addr, uint32_t data);
+       virtual uint32_t read_via_debugger_io8(uint32_t addr);
+       virtual void write_via_debugger_io16(uint32_t addr, uint32_t data);
+       virtual uint32_t read_via_debugger_io16(uint32_t addr);
+       virtual void write_via_debugger_io32(uint32_t addr, uint32_t data);
+       virtual uint32_t read_via_debugger_io32(uint32_t addr);
+       virtual void write_via_debugger_io8w(uint32_t addr, uint32_t data, int* wait);
+       virtual uint32_t read_via_debugger_io8w(uint32_t addr, int* wait);
+       virtual void write_via_debugger_io16w(uint32_t addr, uint32_t data, int* wait);
+       virtual uint32_t read_via_debugger_io16w(uint32_t addr, int* wait);
+       virtual void write_via_debugger_io32w(uint32_t addr, uint32_t data, int* wait);
+       virtual uint32_t read_via_debugger_io32w(uint32_t addr, int* wait);
+       virtual void out_debug_log(const char *fmt, ...);
+       virtual void force_out_debug_log(const char *fmt, ...);
+
        // misc
        const _TCHAR *get_lib_common_vm_version(void);