AvPlayer: Patch all guest calls (#1346)

src/core/libraries/avplayer/avplayer_impl.cpp

@@ -6,8 +6,10 @@
 #include "avplayer_impl.h"
 
 #include "common/logging/log.h"
+#include "common/singleton.h"
 #include "core/libraries/error_codes.h"
 #include "core/libraries/kernel/libkernel.h"
+#include "core/linker.h"
 
 using namespace Libraries::Kernel;
 
@@ -17,28 +19,32 @@ void* PS4_SYSV_ABI AvPlayer::Allocate(void* handle, u32 alignment, u32 size) {
     const auto* const self = reinterpret_cast<AvPlayer*>(handle);
     const auto allocate = self->m_init_data_original.memory_replacement.allocate;
     const auto ptr = self->m_init_data_original.memory_replacement.object_ptr;
-    return allocate(ptr, alignment, size);
+    const auto* linker = Common::Singleton<Core::Linker>::Instance();
+    return linker->ExecuteGuest(allocate, ptr, alignment, size);
 }
 
 void PS4_SYSV_ABI AvPlayer::Deallocate(void* handle, void* memory) {
     const auto* const self = reinterpret_cast<AvPlayer*>(handle);
     const auto deallocate = self->m_init_data_original.memory_replacement.deallocate;
     const auto ptr = self->m_init_data_original.memory_replacement.object_ptr;
-    return deallocate(ptr, memory);
+    const auto* linker = Common::Singleton<Core::Linker>::Instance();
+    return linker->ExecuteGuest(deallocate, ptr, memory);
 }
 
 void* PS4_SYSV_ABI AvPlayer::AllocateTexture(void* handle, u32 alignment, u32 size) {
     const auto* const self = reinterpret_cast<AvPlayer*>(handle);
     const auto allocate = self->m_init_data_original.memory_replacement.allocate_texture;
     const auto ptr = self->m_init_data_original.memory_replacement.object_ptr;
-    return allocate(ptr, alignment, size);
+    const auto* linker = Common::Singleton<Core::Linker>::Instance();
+    return linker->ExecuteGuest(allocate, ptr, alignment, size);
 }
 
 void PS4_SYSV_ABI AvPlayer::DeallocateTexture(void* handle, void* memory) {
     const auto* const self = reinterpret_cast<AvPlayer*>(handle);
     const auto deallocate = self->m_init_data_original.memory_replacement.deallocate_texture;
     const auto ptr = self->m_init_data_original.memory_replacement.object_ptr;
-    return deallocate(ptr, memory);
+    const auto* linker = Common::Singleton<Core::Linker>::Instance();
+    return linker->ExecuteGuest(deallocate, ptr, memory);
 }
 
 int PS4_SYSV_ABI AvPlayer::OpenFile(void* handle, const char* filename) {
@@ -47,7 +53,8 @@ int PS4_SYSV_ABI AvPlayer::OpenFile(void* handle, const char* filename) {
 
     const auto open = self->m_init_data_original.file_replacement.open;
     const auto ptr = self->m_init_data_original.file_replacement.object_ptr;
-    return open(ptr, filename);
+    const auto* linker = Common::Singleton<Core::Linker>::Instance();
+    return linker->ExecuteGuest(open, ptr, filename);
 }
 
 int PS4_SYSV_ABI AvPlayer::CloseFile(void* handle) {
@@ -56,7 +63,8 @@ int PS4_SYSV_ABI AvPlayer::CloseFile(void* handle) {
 
     const auto close = self->m_init_data_original.file_replacement.close;
     const auto ptr = self->m_init_data_original.file_replacement.object_ptr;
-    return close(ptr);
+    const auto* linker = Common::Singleton<Core::Linker>::Instance();
+    return linker->ExecuteGuest(close, ptr);
 }
 
 int PS4_SYSV_ABI AvPlayer::ReadOffsetFile(void* handle, u8* buffer, u64 position, u32 length) {
@@ -65,7 +73,8 @@ int PS4_SYSV_ABI AvPlayer::ReadOffsetFile(void* handle, u8* buffer, u64 position
 
     const auto read_offset = self->m_init_data_original.file_replacement.readOffset;
     const auto ptr = self->m_init_data_original.file_replacement.object_ptr;
-    return read_offset(ptr, buffer, position, length);
+    const auto* linker = Common::Singleton<Core::Linker>::Instance();
+    return linker->ExecuteGuest(read_offset, ptr, buffer, position, length);
 }
 
 u64 PS4_SYSV_ABI AvPlayer::SizeFile(void* handle) {
@@ -74,7 +83,8 @@ u64 PS4_SYSV_ABI AvPlayer::SizeFile(void* handle) {
 
     const auto size = self->m_init_data_original.file_replacement.size;
     const auto ptr = self->m_init_data_original.file_replacement.object_ptr;
-    return size(ptr);
+    const auto* linker = Common::Singleton<Core::Linker>::Instance();
+    return linker->ExecuteGuest(size, ptr);
 }
 
 SceAvPlayerInitData AvPlayer::StubInitData(const SceAvPlayerInitData& data) {

src/core/libraries/avplayer/avplayer_state.cpp

@@ -87,7 +87,12 @@ void PS4_SYSV_ABI AvPlayerState::AutoPlayEventCallback(void* opaque, SceAvPlayer
         return;
     }
 
-    // Pass other events to the game
+    DefaultEventCallback(opaque, event_id, 0, event_data);
+}
+
+void AvPlayerState::DefaultEventCallback(void* opaque, SceAvPlayerEvents event_id, s32 source_id,
+                                         void* event_data) {
+    auto const self = reinterpret_cast<AvPlayerState*>(opaque);
     const auto callback = self->m_event_replacement.event_callback;
     const auto ptr = self->m_event_replacement.object_ptr;
     if (callback != nullptr) {
@@ -102,8 +107,10 @@ AvPlayerState::AvPlayerState(const SceAvPlayerInitData& init_data)
     if (m_event_replacement.event_callback == nullptr || init_data.auto_start) {
         m_auto_start = true;
         m_init_data.event_replacement.event_callback = &AvPlayerState::AutoPlayEventCallback;
-        m_init_data.event_replacement.object_ptr = this;
+    } else {
+        m_init_data.event_replacement.event_callback = &AvPlayerState::DefaultEventCallback;
     }
+    m_init_data.event_replacement.object_ptr = this;
     if (init_data.default_language != nullptr) {
         std::memcpy(m_default_language, init_data.default_language, sizeof(m_default_language));
     }
@@ -367,8 +374,7 @@ void AvPlayerState::EmitEvent(SceAvPlayerEvents event_id, void* event_data) {
     const auto callback = m_init_data.event_replacement.event_callback;
     if (callback) {
         const auto ptr = m_init_data.event_replacement.object_ptr;
-        const auto* linker = Common::Singleton<Core::Linker>::Instance();
+        callback(ptr, event_id, 0, event_data);
-        linker->ExecuteGuest(callback, ptr, event_id, 0, event_data);
     }
 }
 

src/core/libraries/avplayer/avplayer_state.h

@@ -42,6 +42,9 @@ private:
     static void PS4_SYSV_ABI AutoPlayEventCallback(void* handle, SceAvPlayerEvents event_id,
                                                    s32 source_id, void* event_data);
 
+    static void PS4_SYSV_ABI DefaultEventCallback(void* handle, SceAvPlayerEvents event_id,
+                                                  s32 source_id, void* event_data);
+
     void OnWarning(u32 id) override;
     void OnError() override;
     void OnEOF() override;