From a57b378116c7d54d8460f4fbcc7724f9af69ea08 Mon Sep 17 00:00:00 2001 From: Lioncash Date: Wed, 18 Jan 2017 12:13:02 -0500 Subject: [PATCH 1/3] DSPEmulator: Amend variable casing --- Source/Core/Core/DSPEmulator.h | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/Source/Core/Core/DSPEmulator.h b/Source/Core/Core/DSPEmulator.h index 6778e67198..23758ab3ab 100644 --- a/Source/Core/Core/DSPEmulator.h +++ b/Source/Core/Core/DSPEmulator.h @@ -19,14 +19,14 @@ public: virtual void Shutdown() = 0; virtual void DoState(PointerWrap& p) = 0; - virtual void PauseAndLock(bool doLock, bool unpauseOnUnlock = true) = 0; + virtual void PauseAndLock(bool do_lock, bool unpause_on_unlock = true) = 0; - virtual void DSP_WriteMailBoxHigh(bool _CPUMailbox, unsigned short) = 0; - virtual void DSP_WriteMailBoxLow(bool _CPUMailbox, unsigned short) = 0; - virtual unsigned short DSP_ReadMailBoxHigh(bool _CPUMailbox) = 0; - virtual unsigned short DSP_ReadMailBoxLow(bool _CPUMailbox) = 0; - virtual unsigned short DSP_ReadControlRegister() = 0; - virtual unsigned short DSP_WriteControlRegister(unsigned short) = 0; + virtual void DSP_WriteMailBoxHigh(bool cpu_mailbox, u16 value) = 0; + virtual void DSP_WriteMailBoxLow(bool cpu_mailbox, u16 value) = 0; + virtual u16 DSP_ReadMailBoxHigh(bool cpu_mailbox) = 0; + virtual u16 DSP_ReadMailBoxLow(bool cpu_mailbox) = 0; + virtual u16 DSP_ReadControlRegister() = 0; + virtual u16 DSP_WriteControlRegister(u16 value) = 0; virtual void DSP_Update(int cycles) = 0; virtual void DSP_StopSoundStream() = 0; virtual u32 DSP_UpdateRate() = 0; From 0f70650e93f195c93e9445722c7f2074ccd7f96a Mon Sep 17 00:00:00 2001 From: Lioncash Date: Wed, 18 Jan 2017 12:18:58 -0500 Subject: [PATCH 2/3] DSPHLE: Amend variable casing --- Source/Core/Core/HW/DSPHLE/DSPHLE.cpp | 160 +++++++++++++------------- Source/Core/Core/HW/DSPHLE/DSPHLE.h | 44 +++---- 2 files changed, 102 insertions(+), 102 deletions(-) diff --git a/Source/Core/Core/HW/DSPHLE/DSPHLE.cpp b/Source/Core/Core/HW/DSPHLE/DSPHLE.cpp index 119ace0a20..0cf7756efd 100644 --- a/Source/Core/Core/HW/DSPHLE/DSPHLE.cpp +++ b/Source/Core/Core/HW/DSPHLE/DSPHLE.cpp @@ -23,16 +23,16 @@ DSPHLE::DSPHLE() bool DSPHLE::Initialize(bool wii, bool dsp_thread) { m_wii = wii; - m_pUCode = nullptr; - m_lastUCode = nullptr; - m_bHalt = false; - m_bAssertInt = false; + m_ucode = nullptr; + m_last_ucode = nullptr; + m_halt = false; + m_assert_interrupt = false; SetUCode(UCODE_ROM); - m_DSPControl.DSPHalt = 1; - m_DSPControl.DSPInit = 1; + m_dsp_control.DSPHalt = 1; + m_dsp_control.DSPInit = 1; - m_dspState.Reset(); + m_dsp_state.Reset(); return true; } @@ -43,14 +43,14 @@ void DSPHLE::DSP_StopSoundStream() void DSPHLE::Shutdown() { - delete m_pUCode; - m_pUCode = nullptr; + delete m_ucode; + m_ucode = nullptr; } void DSPHLE::DSP_Update(int cycles) { - if (m_pUCode != nullptr) - m_pUCode->Update(); + if (m_ucode != nullptr) + m_ucode->Update(); } u32 DSPHLE::DSP_UpdateRate() @@ -60,56 +60,56 @@ u32 DSPHLE::DSP_UpdateRate() return SystemTimers::GetTicksPerSecond() / 1000; } -void DSPHLE::SendMailToDSP(u32 _uMail) +void DSPHLE::SendMailToDSP(u32 mail) { - if (m_pUCode != nullptr) + if (m_ucode != nullptr) { - DEBUG_LOG(DSP_MAIL, "CPU writes 0x%08x", _uMail); - m_pUCode->HandleMail(_uMail); + DEBUG_LOG(DSP_MAIL, "CPU writes 0x%08x", mail); + m_ucode->HandleMail(mail); } } UCodeInterface* DSPHLE::GetUCode() { - return m_pUCode; + return m_ucode; } -void DSPHLE::SetUCode(u32 _crc) +void DSPHLE::SetUCode(u32 crc) { - delete m_pUCode; + delete m_ucode; - m_pUCode = nullptr; - m_MailHandler.Clear(); - m_pUCode = UCodeFactory(_crc, this, m_wii); - m_pUCode->Initialize(); + m_ucode = nullptr; + m_mail_handler.Clear(); + m_ucode = UCodeFactory(crc, this, m_wii); + m_ucode->Initialize(); } // TODO do it better? // Assumes that every odd call to this func is by the persistent ucode. // Even callers are deleted. -void DSPHLE::SwapUCode(u32 _crc) +void DSPHLE::SwapUCode(u32 crc) { - m_MailHandler.Clear(); + m_mail_handler.Clear(); - if (m_lastUCode == nullptr) + if (m_last_ucode == nullptr) { - m_lastUCode = m_pUCode; - m_pUCode = UCodeFactory(_crc, this, m_wii); - m_pUCode->Initialize(); + m_last_ucode = m_ucode; + m_ucode = UCodeFactory(crc, this, m_wii); + m_ucode->Initialize(); } else { - delete m_pUCode; - m_pUCode = m_lastUCode; - m_lastUCode = nullptr; + delete m_ucode; + m_ucode = m_last_ucode; + m_last_ucode = nullptr; } } void DSPHLE::DoState(PointerWrap& p) { - bool isHLE = true; - p.Do(isHLE); - if (isHLE != true && p.GetMode() == PointerWrap::MODE_READ) + bool is_hle = true; + p.Do(is_hle); + if (!is_hle && p.GetMode() == PointerWrap::MODE_READ) { Core::DisplayMessage("State is incompatible with current DSP engine. Aborting load state.", 3000); @@ -117,33 +117,33 @@ void DSPHLE::DoState(PointerWrap& p) return; } - p.DoPOD(m_DSPControl); - p.DoPOD(m_dspState); + p.DoPOD(m_dsp_control); + p.DoPOD(m_dsp_state); - int ucode_crc = UCodeInterface::GetCRC(m_pUCode); + int ucode_crc = UCodeInterface::GetCRC(m_ucode); int ucode_crc_beforeLoad = ucode_crc; - int lastucode_crc = UCodeInterface::GetCRC(m_lastUCode); - int lastucode_crc_beforeLoad = lastucode_crc; + int last_ucode_crc = UCodeInterface::GetCRC(m_last_ucode); + int last_ucode_crc_before_load = last_ucode_crc; p.Do(ucode_crc); - p.Do(lastucode_crc); + p.Do(last_ucode_crc); // if a different type of ucode was being used when the savestate was created, // we have to reconstruct the old type of ucode so that we have a valid thing to call DoState on. UCodeInterface* ucode = - (ucode_crc == ucode_crc_beforeLoad) ? m_pUCode : UCodeFactory(ucode_crc, this, m_wii); - UCodeInterface* lastucode = (lastucode_crc != lastucode_crc_beforeLoad) ? - m_lastUCode : - UCodeFactory(lastucode_crc, this, m_wii); + (ucode_crc == ucode_crc_beforeLoad) ? m_ucode : UCodeFactory(ucode_crc, this, m_wii); + UCodeInterface* last_ucode = (last_ucode_crc != last_ucode_crc_before_load) ? + m_last_ucode : + UCodeFactory(last_ucode_crc, this, m_wii); if (ucode) ucode->DoState(p); - if (lastucode) - lastucode->DoState(p); + if (last_ucode) + last_ucode->DoState(p); // if a different type of ucode was being used when the savestate was created, // discard it if we're not loading, otherwise discard the old one and keep the new one. - if (ucode != m_pUCode) + if (ucode != m_ucode) { if (p.GetMode() != PointerWrap::MODE_READ) { @@ -151,32 +151,32 @@ void DSPHLE::DoState(PointerWrap& p) } else { - delete m_pUCode; - m_pUCode = ucode; + delete m_ucode; + m_ucode = ucode; } } - if (lastucode != m_lastUCode) + if (last_ucode != m_last_ucode) { if (p.GetMode() != PointerWrap::MODE_READ) { - delete lastucode; + delete last_ucode; } else { - delete m_lastUCode; - m_lastUCode = lastucode; + delete m_last_ucode; + m_last_ucode = last_ucode; } } - m_MailHandler.DoState(p); + m_mail_handler.DoState(p); } // Mailbox functions -unsigned short DSPHLE::DSP_ReadMailBoxHigh(bool _CPUMailbox) +u16 DSPHLE::DSP_ReadMailBoxHigh(bool cpu_mailbox) { - if (_CPUMailbox) + if (cpu_mailbox) { - return (m_dspState.CPUMailbox >> 16) & 0xFFFF; + return (m_dsp_state.cpu_mailbox >> 16) & 0xFFFF; } else { @@ -184,11 +184,11 @@ unsigned short DSPHLE::DSP_ReadMailBoxHigh(bool _CPUMailbox) } } -unsigned short DSPHLE::DSP_ReadMailBoxLow(bool _CPUMailbox) +u16 DSPHLE::DSP_ReadMailBoxLow(bool cpu_mailbox) { - if (_CPUMailbox) + if (cpu_mailbox) { - return m_dspState.CPUMailbox & 0xFFFF; + return m_dsp_state.cpu_mailbox & 0xFFFF; } else { @@ -196,60 +196,60 @@ unsigned short DSPHLE::DSP_ReadMailBoxLow(bool _CPUMailbox) } } -void DSPHLE::DSP_WriteMailBoxHigh(bool _CPUMailbox, unsigned short _Value) +void DSPHLE::DSP_WriteMailBoxHigh(bool cpu_mailbox, u16 value) { - if (_CPUMailbox) + if (cpu_mailbox) { - m_dspState.CPUMailbox = (m_dspState.CPUMailbox & 0xFFFF) | (_Value << 16); + m_dsp_state.cpu_mailbox = (m_dsp_state.cpu_mailbox & 0xFFFF) | (value << 16); } else { - PanicAlert("CPU can't write %08x to DSP mailbox", _Value); + PanicAlert("CPU can't write %08x to DSP mailbox", value); } } -void DSPHLE::DSP_WriteMailBoxLow(bool _CPUMailbox, unsigned short _Value) +void DSPHLE::DSP_WriteMailBoxLow(bool cpu_mailbox, u16 value) { - if (_CPUMailbox) + if (cpu_mailbox) { - m_dspState.CPUMailbox = (m_dspState.CPUMailbox & 0xFFFF0000) | _Value; - SendMailToDSP(m_dspState.CPUMailbox); + m_dsp_state.cpu_mailbox = (m_dsp_state.cpu_mailbox & 0xFFFF0000) | value; + SendMailToDSP(m_dsp_state.cpu_mailbox); // Mail sent so clear MSB to show that it is progressed - m_dspState.CPUMailbox &= 0x7FFFFFFF; + m_dsp_state.cpu_mailbox &= 0x7FFFFFFF; } else { - PanicAlert("CPU can't write %08x to DSP mailbox", _Value); + PanicAlert("CPU can't write %08x to DSP mailbox", value); } } // Other DSP functions -u16 DSPHLE::DSP_WriteControlRegister(unsigned short _Value) +u16 DSPHLE::DSP_WriteControlRegister(u16 value) { - DSP::UDSPControl Temp(_Value); + DSP::UDSPControl temp(value); - if (Temp.DSPReset) + if (temp.DSPReset) { SetUCode(UCODE_ROM); - Temp.DSPReset = 0; + temp.DSPReset = 0; } - if (Temp.DSPInit == 0) + if (temp.DSPInit == 0) { // copy 128 byte from ARAM 0x000000 to IMEM SetUCode(UCODE_INIT_AUDIO_SYSTEM); - Temp.DSPInitCode = 0; + temp.DSPInitCode = 0; } - m_DSPControl.Hex = Temp.Hex; - return m_DSPControl.Hex; + m_dsp_control.Hex = temp.Hex; + return m_dsp_control.Hex; } u16 DSPHLE::DSP_ReadControlRegister() { - return m_DSPControl.Hex; + return m_dsp_control.Hex; } -void DSPHLE::PauseAndLock(bool doLock, bool unpauseOnUnlock) +void DSPHLE::PauseAndLock(bool do_lock, bool unpause_on_unlock) { } } // namespace HLE diff --git a/Source/Core/Core/HW/DSPHLE/DSPHLE.h b/Source/Core/Core/HW/DSPHLE/DSPHLE.h index 6c86944ab6..03d12b9eb3 100644 --- a/Source/Core/Core/HW/DSPHLE/DSPHLE.h +++ b/Source/Core/Core/HW/DSPHLE/DSPHLE.h @@ -26,51 +26,51 @@ public: void Shutdown() override; bool IsLLE() override { return false; } void DoState(PointerWrap& p) override; - void PauseAndLock(bool doLock, bool unpauseOnUnlock = true) override; + void PauseAndLock(bool do_lock, bool unpause_on_unlock = true) override; - void DSP_WriteMailBoxHigh(bool _CPUMailbox, unsigned short) override; - void DSP_WriteMailBoxLow(bool _CPUMailbox, unsigned short) override; - unsigned short DSP_ReadMailBoxHigh(bool _CPUMailbox) override; - unsigned short DSP_ReadMailBoxLow(bool _CPUMailbox) override; - unsigned short DSP_ReadControlRegister() override; - unsigned short DSP_WriteControlRegister(unsigned short) override; + void DSP_WriteMailBoxHigh(bool cpu_mailbox, u16 value) override; + void DSP_WriteMailBoxLow(bool cpu_mailbox, u16 value) override; + u16 DSP_ReadMailBoxHigh(bool cpu_mailbox) override; + u16 DSP_ReadMailBoxLow(bool cpu_mailbox) override; + u16 DSP_ReadControlRegister() override; + u16 DSP_WriteControlRegister(u16 value) override; void DSP_Update(int cycles) override; void DSP_StopSoundStream() override; u32 DSP_UpdateRate() override; - CMailHandler& AccessMailHandler() { return m_MailHandler; } + CMailHandler& AccessMailHandler() { return m_mail_handler; } // Formerly DSPHandler UCodeInterface* GetUCode(); - void SetUCode(u32 _crc); - void SwapUCode(u32 _crc); + void SetUCode(u32 crc); + void SwapUCode(u32 crc); private: - void SendMailToDSP(u32 _uMail); + void SendMailToDSP(u32 mail); // Fake mailbox utility struct DSPState { - u32 CPUMailbox; - u32 DSPMailbox; + u32 cpu_mailbox; + u32 dsp_mailbox; void Reset() { - CPUMailbox = 0x00000000; - DSPMailbox = 0x00000000; + cpu_mailbox = 0x00000000; + dsp_mailbox = 0x00000000; } DSPState() { Reset(); } }; - DSPState m_dspState; + DSPState m_dsp_state; - UCodeInterface* m_pUCode; - UCodeInterface* m_lastUCode; + UCodeInterface* m_ucode; + UCodeInterface* m_last_ucode; - DSP::UDSPControl m_DSPControl; - CMailHandler m_MailHandler; + DSP::UDSPControl m_dsp_control; + CMailHandler m_mail_handler; - bool m_bHalt; - bool m_bAssertInt; + bool m_halt; + bool m_assert_interrupt; }; } // namespace HLE } // namespace DSP From cf1c194b8838415f6cdb9dddec1b55ab587ecb40 Mon Sep 17 00:00:00 2001 From: Lioncash Date: Wed, 18 Jan 2017 12:31:26 -0500 Subject: [PATCH 3/3] DSPLLE: Amend variable casing --- Source/Core/Core/HW/DSPLLE/DSPLLE.cpp | 86 +++++++++++++-------------- Source/Core/Core/HW/DSPLLE/DSPLLE.h | 24 ++++---- 2 files changed, 55 insertions(+), 55 deletions(-) diff --git a/Source/Core/Core/HW/DSPLLE/DSPLLE.cpp b/Source/Core/Core/HW/DSPLLE/DSPLLE.cpp index 18c5eae8c8..5d51a0bbdf 100644 --- a/Source/Core/Core/HW/DSPLLE/DSPLLE.cpp +++ b/Source/Core/Core/HW/DSPLLE/DSPLLE.cpp @@ -31,9 +31,9 @@ namespace DSP { namespace LLE { -static Common::Event dspEvent; -static Common::Event ppcEvent; -static bool requestDisableThread; +static Common::Event s_dsp_event; +static Common::Event s_ppc_event; +static bool s_request_disable_thread; DSPLLE::DSPLLE() = default; @@ -83,12 +83,12 @@ void DSPLLE::DSPThread(DSPLLE* dsp_lle) { Common::SetCurrentThreadName("DSP thread"); - while (dsp_lle->m_bIsRunning.IsSet()) + while (dsp_lle->m_is_running.IsSet()) { const int cycles = static_cast(dsp_lle->m_cycle_count.load()); if (cycles > 0) { - std::lock_guard dsp_thread_lock(dsp_lle->m_csDSPThreadActive); + std::lock_guard dsp_thread_lock(dsp_lle->m_dsp_thread_mutex); if (g_dsp_jit) { DSPCore_RunCycles(cycles); @@ -101,8 +101,8 @@ void DSPLLE::DSPThread(DSPLLE* dsp_lle) } else { - ppcEvent.Set(); - dspEvent.Wait(); + s_ppc_event.Set(); + s_dsp_event.Wait(); } } } @@ -156,7 +156,7 @@ static bool FillDSPInitOptions(DSPInitOptions* opts) bool DSPLLE::Initialize(bool wii, bool dsp_thread) { - requestDisableThread = false; + s_request_disable_thread = false; DSPInitOptions opts; if (!FillDSPInitOptions(&opts)) @@ -169,7 +169,7 @@ bool DSPLLE::Initialize(bool wii, bool dsp_thread) dsp_thread = false; m_wii = wii; - m_bDSPThread = dsp_thread; + m_is_dsp_on_thread = dsp_thread; // DSPLLE directly accesses the fastmem arena. // TODO: The fastmem arena is only supposed to be used by the JIT: @@ -181,8 +181,8 @@ bool DSPLLE::Initialize(bool wii, bool dsp_thread) if (dsp_thread) { - m_bIsRunning.Set(true); - m_hDSPThread = std::thread(DSPThread, this); + m_is_running.Set(true); + m_dsp_thread = std::thread(DSPThread, this); } Host_RefreshDSPDebuggerWindow(); @@ -191,12 +191,12 @@ bool DSPLLE::Initialize(bool wii, bool dsp_thread) void DSPLLE::DSP_StopSoundStream() { - if (m_bDSPThread) + if (m_is_dsp_on_thread) { - m_bIsRunning.Clear(); - ppcEvent.Set(); - dspEvent.Set(); - m_hDSPThread.join(); + m_is_running.Clear(); + s_ppc_event.Set(); + s_dsp_event.Set(); + m_dsp_thread.join(); } } @@ -205,13 +205,13 @@ void DSPLLE::Shutdown() DSPCore_Shutdown(); } -u16 DSPLLE::DSP_WriteControlRegister(u16 _uFlag) +u16 DSPLLE::DSP_WriteControlRegister(u16 value) { - DSP::Interpreter::WriteCR(_uFlag); + DSP::Interpreter::WriteCR(value); - if (_uFlag & 2) + if (value & 2) { - if (!m_bDSPThread) + if (!m_is_dsp_on_thread) { DSPCore_CheckExternalInterrupt(); DSPCore_CheckExceptions(); @@ -220,7 +220,7 @@ u16 DSPLLE::DSP_WriteControlRegister(u16 _uFlag) { // External interrupt pending: this is the zelda ucode. // Disable the DSP thread because there is no performance gain. - requestDisableThread = true; + s_request_disable_thread = true; DSPCore_SetExternalInterrupt(true); } @@ -234,19 +234,19 @@ u16 DSPLLE::DSP_ReadControlRegister() return DSP::Interpreter::ReadCR(); } -u16 DSPLLE::DSP_ReadMailBoxHigh(bool _CPUMailbox) +u16 DSPLLE::DSP_ReadMailBoxHigh(bool cpu_mailbox) { - return gdsp_mbox_read_h(_CPUMailbox ? MAILBOX_CPU : MAILBOX_DSP); + return gdsp_mbox_read_h(cpu_mailbox ? MAILBOX_CPU : MAILBOX_DSP); } -u16 DSPLLE::DSP_ReadMailBoxLow(bool _CPUMailbox) +u16 DSPLLE::DSP_ReadMailBoxLow(bool cpu_mailbox) { - return gdsp_mbox_read_l(_CPUMailbox ? MAILBOX_CPU : MAILBOX_DSP); + return gdsp_mbox_read_l(cpu_mailbox ? MAILBOX_CPU : MAILBOX_DSP); } -void DSPLLE::DSP_WriteMailBoxHigh(bool _CPUMailbox, u16 _uHighMail) +void DSPLLE::DSP_WriteMailBoxHigh(bool cpu_mailbox, u16 value) { - if (_CPUMailbox) + if (cpu_mailbox) { if (gdsp_mbox_peek(MAILBOX_CPU) & 0x80000000) { @@ -254,13 +254,13 @@ void DSPLLE::DSP_WriteMailBoxHigh(bool _CPUMailbox, u16 _uHighMail) } #if PROFILE - if ((_uHighMail) == 0xBABE) + if (value == 0xBABE) { ProfilerStart(); } #endif - gdsp_mbox_write_h(MAILBOX_CPU, _uHighMail); + gdsp_mbox_write_h(MAILBOX_CPU, value); } else { @@ -268,11 +268,11 @@ void DSPLLE::DSP_WriteMailBoxHigh(bool _CPUMailbox, u16 _uHighMail) } } -void DSPLLE::DSP_WriteMailBoxLow(bool _CPUMailbox, u16 _uLowMail) +void DSPLLE::DSP_WriteMailBoxLow(bool cpu_mailbox, u16 value) { - if (_CPUMailbox) + if (cpu_mailbox) { - gdsp_mbox_write_l(MAILBOX_CPU, _uLowMail); + gdsp_mbox_write_l(MAILBOX_CPU, value); } else { @@ -305,19 +305,19 @@ void DSPLLE::DSP_Update(int cycles) soundStream->Update(); } */ - if (m_bDSPThread) + if (m_is_dsp_on_thread) { - if (requestDisableThread || Core::g_want_determinism) + if (s_request_disable_thread || Core::g_want_determinism) { DSP_StopSoundStream(); - m_bDSPThread = false; - requestDisableThread = false; + m_is_dsp_on_thread = false; + s_request_disable_thread = false; SConfig::GetInstance().bDSPThread = false; } } // If we're not on a thread, run cycles here. - if (!m_bDSPThread) + if (!m_is_dsp_on_thread) { // ~1/6th as many cycles as the period PPC-side. DSPCore_RunCycles(dsp_cycles); @@ -325,9 +325,9 @@ void DSPLLE::DSP_Update(int cycles) else { // Wait for DSP thread to complete its cycle. Note: this logic should be thought through. - ppcEvent.Wait(); + s_ppc_event.Wait(); m_cycle_count.fetch_add(dsp_cycles); - dspEvent.Set(); + s_dsp_event.Set(); } } @@ -336,12 +336,12 @@ u32 DSPLLE::DSP_UpdateRate() return 12600; // TO BE TWEAKED } -void DSPLLE::PauseAndLock(bool doLock, bool unpauseOnUnlock) +void DSPLLE::PauseAndLock(bool do_lock, bool unpause_on_unlock) { - if (doLock) - m_csDSPThreadActive.lock(); + if (do_lock) + m_dsp_thread_mutex.lock(); else - m_csDSPThreadActive.unlock(); + m_dsp_thread_mutex.unlock(); } } // namespace LLE } // namespace DSP diff --git a/Source/Core/Core/HW/DSPLLE/DSPLLE.h b/Source/Core/Core/HW/DSPLLE/DSPLLE.h index dc740df774..dc951d52a7 100644 --- a/Source/Core/Core/HW/DSPLLE/DSPLLE.h +++ b/Source/Core/Core/HW/DSPLLE/DSPLLE.h @@ -27,25 +27,25 @@ public: void Shutdown() override; bool IsLLE() override { return true; } void DoState(PointerWrap& p) override; - void PauseAndLock(bool doLock, bool unpauseOnUnlock = true) override; + void PauseAndLock(bool do_lock, bool unpause_on_unlock = true) override; - void DSP_WriteMailBoxHigh(bool _CPUMailbox, unsigned short) override; - void DSP_WriteMailBoxLow(bool _CPUMailbox, unsigned short) override; - unsigned short DSP_ReadMailBoxHigh(bool _CPUMailbox) override; - unsigned short DSP_ReadMailBoxLow(bool _CPUMailbox) override; - unsigned short DSP_ReadControlRegister() override; - unsigned short DSP_WriteControlRegister(unsigned short) override; + void DSP_WriteMailBoxHigh(bool cpu_mailbox, u16 value) override; + void DSP_WriteMailBoxLow(bool cpu_mailbox, u16 value) override; + u16 DSP_ReadMailBoxHigh(bool cpu_mailbox) override; + u16 DSP_ReadMailBoxLow(bool cpu_mailbox) override; + u16 DSP_ReadControlRegister() override; + u16 DSP_WriteControlRegister(u16 value) override; void DSP_Update(int cycles) override; void DSP_StopSoundStream() override; u32 DSP_UpdateRate() override; private: - static void DSPThread(DSPLLE* lpParameter); + static void DSPThread(DSPLLE* dsp_lle); - std::thread m_hDSPThread; - std::mutex m_csDSPThreadActive; - bool m_bDSPThread = false; - Common::Flag m_bIsRunning; + std::thread m_dsp_thread; + std::mutex m_dsp_thread_mutex; + bool m_is_dsp_on_thread = false; + Common::Flag m_is_running; std::atomic m_cycle_count{}; }; } // namespace LLE