From 621ee10eae0546d4ec3f9e911e113aa9ee609c22 Mon Sep 17 00:00:00 2001 From: Subv Date: Tue, 26 May 2015 11:00:26 -0500 Subject: [PATCH] Applets: Add infrastructure to allow custom drawing and input handling in Applets. --- src/core/hle/applets/applet.cpp | 38 +++++++++++++++++++++++++++ src/core/hle/applets/applet.h | 43 +++++++++++++++++++++--------- src/core/hle/applets/swkbd.cpp | 45 +++++++++++++++++++++++++++----- src/core/hle/applets/swkbd.h | 16 ++++++++++++ src/core/hle/service/apt/apt.cpp | 45 +++++++++++++++++++------------- src/core/hle/service/gsp_gpu.cpp | 4 +-- src/core/hle/service/gsp_gpu.h | 10 +++++++ 7 files changed, 162 insertions(+), 39 deletions(-) diff --git a/src/core/hle/applets/applet.cpp b/src/core/hle/applets/applet.cpp index 1f447e5fc..689f5adc8 100644 --- a/src/core/hle/applets/applet.cpp +++ b/src/core/hle/applets/applet.cpp @@ -5,15 +5,35 @@ #include "common/assert.h" #include "common/logging/log.h" +#include "core/core_timing.h" #include "core/hle/applets/applet.h" #include "core/hle/applets/swkbd.h" //////////////////////////////////////////////////////////////////////////////////////////////////// +// Specializes std::hash for AppletId, so that we can use it in std::unordered_map. +// Workaround for libstdc++ bug: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=60970 +namespace std { + template <> + struct hash { + typedef Service::APT::AppletId argument_type; + typedef std::size_t result_type; + + result_type operator()(const argument_type& id_code) const { + typedef std::underlying_type::type Type; + return std::hash()(static_cast(id_code)); + } + }; +} + namespace HLE { namespace Applets { static std::unordered_map> applets; +static u32 applet_update_event = -1; ///< The CoreTiming event identifier for the Applet update callback. +/// The interval at which the Applet update callback will be called. +static const u64 applet_update_interval_microseconds = 16666; +std::shared_ptr g_current_applet = nullptr; ///< The applet that is currently executing ResultCode Applet::Create(Service::APT::AppletId id) { switch (id) { @@ -36,5 +56,23 @@ std::shared_ptr Applet::Get(Service::APT::AppletId id) { return nullptr; } +/// Handles updating the current Applet every time it's called. +static void AppletUpdateEvent(u64, int cycles_late) { + if (g_current_applet && g_current_applet->IsRunning()) + g_current_applet->Update(); + + CoreTiming::ScheduleEvent(usToCycles(applet_update_interval) - cycles_late, + applet_update_event); +} + +void Init() { + applet_update_event = CoreTiming::RegisterEvent("HLE Applet Update Event", AppletUpdateEvent); + CoreTiming::ScheduleEvent(usToCycles(applet_update_interval), applet_update_event); +} + +void Shutdown() { + CoreTiming::UnscheduleEvent(applet_update_event, 0); +} + } } // namespace diff --git a/src/core/hle/applets/applet.h b/src/core/hle/applets/applet.h index 221348d9c..f50f7d604 100644 --- a/src/core/hle/applets/applet.h +++ b/src/core/hle/applets/applet.h @@ -12,42 +12,59 @@ namespace HLE { namespace Applets { -class Applet { +class Applet : public std::enable_shared_from_this { public: virtual ~Applet() {}; Applet(Service::APT::AppletId id) : id(id) {}; /** - * Creates an instance of the Applet subclass identified by the parameter + * Creates an instance of the Applet subclass identified by the parameter. * and stores it in a global map. - * @param id Id of the applet to create - * @returns ResultCode Whether the operation was successful or not + * @param id Id of the applet to create. + * @returns ResultCode Whether the operation was successful or not. */ static ResultCode Create(Service::APT::AppletId id); /** - * Retrieves the Applet instance identified by the specified id - * @param id Id of the Applet to retrieve - * @returns Requested Applet or nullptr if not found + * Retrieves the Applet instance identified by the specified id. + * @param id Id of the Applet to retrieve. + * @returns Requested Applet or nullptr if not found. */ static std::shared_ptr Get(Service::APT::AppletId id); /** - * Handles a parameter from the application - * @param parameter Parameter data to handle - * @returns ResultCode Whether the operation was successful or not + * Handles a parameter from the application. + * @param parameter Parameter data to handle. + * @returns ResultCode Whether the operation was successful or not. */ virtual ResultCode ReceiveParameter(Service::APT::MessageParameter const& parameter) = 0; /** - * Handles the Applet start event, triggered from the application - * @param parameter Parameter data to handle - * @returns ResultCode Whether the operation was successful or not + * Handles the Applet start event, triggered from the application. + * @param parameter Parameter data to handle. + * @returns ResultCode Whether the operation was successful or not. */ virtual ResultCode Start(Service::APT::AppletStartupParameter const& parameter) = 0; + /** + * Whether the applet is currently executing instead of the host application or not. + */ + virtual bool IsRunning() = 0; + + /** + * Handles an update tick for the Applet, lets it update the screen, send commands, etc. + */ + virtual void Update() = 0; + Service::APT::AppletId id; ///< Id of this Applet }; +/// Initializes the HLE applets +void Init(); + +/// Shuts down the HLE applets +void Shutdown(); + +extern std::shared_ptr g_current_applet; ///< Applet that is currently executing } } // namespace diff --git a/src/core/hle/applets/swkbd.cpp b/src/core/hle/applets/swkbd.cpp index 224aeb096..b800e0eb4 100644 --- a/src/core/hle/applets/swkbd.cpp +++ b/src/core/hle/applets/swkbd.cpp @@ -6,13 +6,16 @@ #include "common/logging/log.h" #include "core/hle/applets/swkbd.h" +#include "core/hle/service/hid/hid.h" +#include "core/hle/service/gsp_gpu.h" +#include "video_core/video_core.h" //////////////////////////////////////////////////////////////////////////////////////////////////// namespace HLE { namespace Applets { -SoftwareKeyboard::SoftwareKeyboard(Service::APT::AppletId id) : Applet(id) { +SoftwareKeyboard::SoftwareKeyboard(Service::APT::AppletId id) : Applet(id), started(false) { // Create the SharedMemory that will hold the framebuffer data // TODO(Subv): What size should we use here? using Kernel::MemoryPermission; @@ -47,17 +50,45 @@ ResultCode SoftwareKeyboard::Start(Service::APT::AppletStartupParameter const& p // TODO(Subv): Verify if this is the correct behavior memset(text_memory->GetPointer(), 0, text_memory->size); + DrawScreenKeyboard(); + + // Update the current applet so we can get update events + started = true; + g_current_applet = shared_from_this(); + return RESULT_SUCCESS; +} + +void SoftwareKeyboard::Update() { + // TODO(Subv): Handle input using the touch events from the HID module + // TODO(Subv): Remove this hardcoded text - const wchar_t str[] = L"Subv"; - memcpy(text_memory->GetPointer(), str, 4 * sizeof(wchar_t)); - + std::u16string text = Common::UTF8ToUTF16("Citra"); + memcpy(text_memory->GetPointer(), text.c_str(), text.length() * sizeof(char16_t)); + // TODO(Subv): Ask for input and write it to the shared memory // TODO(Subv): Find out what are the possible values for the return code, // some games seem to check for a hardcoded 2 config.return_code = 2; - config.text_length = 5; + config.text_length = 6; config.text_offset = 0; + // TODO(Subv): We're finalizing the applet immediately after it's started, + // but we should defer this call until after all the input has been collected. + Finalize(); +} + +void SoftwareKeyboard::DrawScreenKeyboard() { + auto bottom_screen = GSP_GPU::GetFrameBufferInfo(0, 1); + auto info = bottom_screen->framebuffer_info[bottom_screen->index]; + + // TODO(Subv): Draw the HLE keyboard, for now just zero-fill the framebuffer + memset(Memory::GetPointer(info.address_left), 0, info.stride * 320); + + GSP_GPU::SetBufferSwap(1, info); +} + +void SoftwareKeyboard::Finalize() { + // Let the application know that we're closing Service::APT::MessageParameter message; message.buffer_size = sizeof(SoftwareKeyboardConfig); message.data = reinterpret_cast(&config); @@ -66,7 +97,9 @@ ResultCode SoftwareKeyboard::Start(Service::APT::AppletStartupParameter const& p message.sender_id = static_cast(id); Service::APT::SendParameter(message); - return RESULT_SUCCESS; + started = false; + // Unset the current applet, we are not running anymore + g_current_applet = nullptr; } } diff --git a/src/core/hle/applets/swkbd.h b/src/core/hle/applets/swkbd.h index d7199690c..5970390c6 100644 --- a/src/core/hle/applets/swkbd.h +++ b/src/core/hle/applets/swkbd.h @@ -51,6 +51,19 @@ public: ResultCode ReceiveParameter(Service::APT::MessageParameter const& parameter) override; ResultCode Start(Service::APT::AppletStartupParameter const& parameter) override; + void Update() override; + bool IsRunning() override { return started; } + + /** + * Draws a keyboard to the current bottom screen framebuffer. + */ + void DrawScreenKeyboard(); + + /** + * Sends the LibAppletClosing signal to the application, + * along with the relevant data buffers. + */ + void Finalize(); /// TODO(Subv): Find out what this is actually used for. // It is believed that the application stores the current screen image here. @@ -61,6 +74,9 @@ public: /// Configuration of this instance of the SoftwareKeyboard, as received from the application SoftwareKeyboardConfig config; + + /// Whether this applet is currently running instead of the host application or not. + bool started; }; } diff --git a/src/core/hle/service/apt/apt.cpp b/src/core/hle/service/apt/apt.cpp index 0c3889e83..783fad7ca 100644 --- a/src/core/hle/service/apt/apt.cpp +++ b/src/core/hle/service/apt/apt.cpp @@ -68,7 +68,7 @@ void Initialize(Service::Interface* self) { cmd_buff[1] = RESULT_SUCCESS.raw; // No error - LOG_WARNING(Service_APT, "called app_id=0x%08X, flags=0x%08X", app_id, flags); + LOG_DEBUG(Service_APT, "called app_id=0x%08X, flags=0x%08X", app_id, flags); } void GetSharedFont(Service::Interface* self) { @@ -95,7 +95,6 @@ void GetSharedFont(Service::Interface* self) { void NotifyToWait(Service::Interface* self) { u32* cmd_buff = Kernel::GetCommandBuffer(); u32 app_id = cmd_buff[1]; - cmd_buff[1] = RESULT_SUCCESS.raw; // No error LOG_WARNING(Service_APT, "(STUBBED) app_id=%u", app_id); } @@ -108,7 +107,7 @@ void GetLockHandle(Service::Interface* self) { // Not sure what these parameters are used for, but retail apps check that they are 0 after // GetLockHandle has been called. - cmd_buff[2] = 0; + cmd_buff[2] = 0; // Applet Attributes, this value is passed to Enable. cmd_buff[3] = 0; cmd_buff[4] = 0; @@ -118,10 +117,10 @@ void GetLockHandle(Service::Interface* self) { void Enable(Service::Interface* self) { u32* cmd_buff = Kernel::GetCommandBuffer(); - u32 unk = cmd_buff[1]; // TODO(bunnei): What is this field used for? + u32 attributes = cmd_buff[1]; cmd_buff[1] = RESULT_SUCCESS.raw; // No error parameter_event->Signal(); // Let the application know that it has been started - LOG_WARNING(Service_APT, "(STUBBED) called unk=0x%08X", unk); + LOG_WARNING(Service_APT, "(STUBBED) called attributes=0x%08X", attributes); } void GetAppletManInfo(Service::Interface* self) { @@ -160,19 +159,20 @@ void InquireNotification(Service::Interface* self) { void SendParameter(Service::Interface* self) { u32* cmd_buff = Kernel::GetCommandBuffer(); - u32 src_app_id = cmd_buff[1]; - u32 dst_app_id = cmd_buff[2]; - u32 signal_type = cmd_buff[3]; - u32 buffer_size = cmd_buff[4]; - u32 value = cmd_buff[5]; - u32 handle = cmd_buff[6]; - u32 size = cmd_buff[7]; - u32 buffer = cmd_buff[8]; + u32 src_app_id = cmd_buff[1]; + u32 dst_app_id = cmd_buff[2]; + u32 signal_type = cmd_buff[3]; + u32 buffer_size = cmd_buff[4]; + u32 value = cmd_buff[5]; + u32 handle = cmd_buff[6]; + u32 size = cmd_buff[7]; + u32 buffer = cmd_buff[8]; std::shared_ptr dest_applet = HLE::Applets::Applet::Get(static_cast(dst_app_id)); if (dest_applet == nullptr) { LOG_ERROR(Service_APT, "Unknown applet id=0x%08X", dst_app_id); + cmd_buff[1] = -1; // TODO(Subv): Find the right error code return; } @@ -286,7 +286,7 @@ void AppletUtility(Service::Interface* self) { u32* cmd_buff = Kernel::GetCommandBuffer(); // These are from 3dbrew - I'm not really sure what they're used for. - u32 unk = cmd_buff[1]; + u32 command = cmd_buff[1]; u32 buffer1_size = cmd_buff[2]; u32 buffer2_size = cmd_buff[3]; u32 buffer1_addr = cmd_buff[5]; @@ -294,8 +294,8 @@ void AppletUtility(Service::Interface* self) { cmd_buff[1] = RESULT_SUCCESS.raw; // No error - LOG_WARNING(Service_APT, "(STUBBED) called unk=0x%08X, buffer1_size=0x%08X, buffer2_size=0x%08X, " - "buffer1_addr=0x%08X, buffer2_addr=0x%08X", unk, buffer1_size, buffer2_size, + LOG_WARNING(Service_APT, "(STUBBED) called command=0x%08X, buffer1_size=0x%08X, buffer2_size=0x%08X, " + "buffer1_addr=0x%08X, buffer2_addr=0x%08X", command, buffer1_size, buffer2_size, buffer1_addr, buffer2_addr); } @@ -329,14 +329,20 @@ void GetAppCpuTimeLimit(Service::Interface* self) { void PrepareToStartLibraryApplet(Service::Interface* self) { u32* cmd_buff = Kernel::GetCommandBuffer(); - cmd_buff[1] = HLE::Applets::Applet::Create(static_cast(cmd_buff[1])).raw; + AppletId applet_id = static_cast(cmd_buff[1]); + cmd_buff[1] = HLE::Applets::Applet::Create(applet_id).raw; + LOG_DEBUG(Service_APT, "called applet_id=%08X", applet_id); } void StartLibraryApplet(Service::Interface* self) { u32* cmd_buff = Kernel::GetCommandBuffer(); - std::shared_ptr applet = HLE::Applets::Applet::Get(static_cast(cmd_buff[1])); + AppletId applet_id = static_cast(cmd_buff[1]); + std::shared_ptr applet = HLE::Applets::Applet::Get(applet_id); + LOG_DEBUG(Service_APT, "called applet_id=%08X", applet_id); + if (applet == nullptr) { + LOG_ERROR(Service_APT, "unknown applet id=%08X", applet_id); cmd_buff[1] = -1; // TODO(Subv): Find the right error code return; } @@ -354,6 +360,8 @@ void Init() { AddService(new APT_S_Interface); AddService(new APT_U_Interface); + HLE::Applets::Init(); + // Load the shared system font (if available). // The expected format is a decrypted, uncompressed BCFNT file with the 0x80 byte header // generated by the APT:U service. The best way to get is by dumping it from RAM. We've provided @@ -398,6 +406,7 @@ void Shutdown() { lock = nullptr; notification_event = nullptr; parameter_event = nullptr; + HLE::Applets::Shutdown(); } } // namespace APT diff --git a/src/core/hle/service/gsp_gpu.cpp b/src/core/hle/service/gsp_gpu.cpp index f56bbe50f..f175085e8 100644 --- a/src/core/hle/service/gsp_gpu.cpp +++ b/src/core/hle/service/gsp_gpu.cpp @@ -42,7 +42,7 @@ static inline u8* GetCommandBuffer(u32 thread_id) { return g_shared_memory->GetPointer(0x800 + (thread_id * sizeof(CommandBuffer))); } -static inline FrameBufferUpdate* GetFrameBufferInfo(u32 thread_id, u32 screen_index) { +FrameBufferUpdate* GetFrameBufferInfo(u32 thread_id, u32 screen_index) { DEBUG_ASSERT_MSG(screen_index < 2, "Invalid screen index"); // For each thread there are two FrameBufferUpdate fields @@ -205,7 +205,7 @@ static void ReadHWRegs(Service::Interface* self) { } } -static void SetBufferSwap(u32 screen_id, const FrameBufferInfo& info) { +void SetBufferSwap(u32 screen_id, const FrameBufferInfo& info) { u32 base_address = 0x400000; PAddr phys_address_left = Memory::VirtualToPhysicalAddress(info.address_left); PAddr phys_address_right = Memory::VirtualToPhysicalAddress(info.address_right); diff --git a/src/core/hle/service/gsp_gpu.h b/src/core/hle/service/gsp_gpu.h index d9e9a1a60..9fcf6f06f 100644 --- a/src/core/hle/service/gsp_gpu.h +++ b/src/core/hle/service/gsp_gpu.h @@ -173,4 +173,14 @@ public: */ void SignalInterrupt(InterruptId interrupt_id); +void SetBufferSwap(u32 screen_id, const FrameBufferInfo& info); + +/** + * Retrieves the framebuffer info stored in the GSP shared memory for the + * specified screen index and thread id. + * @param thread_id GSP thread id of the process that accesses the structure that we are requesting. + * @param screen_index Index of the screen we are requesting (Top = 0, Bottom = 1). + * @returns FramebufferUpdate Information about the specified framebuffer. + */ +FrameBufferUpdate* GetFrameBufferInfo(u32 thread_id, u32 screen_index); } // namespace