From d31fb46ae82f179a0153e2a5de8f13897ede7112 Mon Sep 17 00:00:00 2001 From: h0neybadger Date: Sun, 27 Dec 2020 15:57:19 +0100 Subject: [PATCH] Refactor IO class as singleton --- switch/include/gui.h | 57 ++++---- switch/include/host.h | 23 +-- switch/include/io.h | 68 ++++----- switch/src/gui.cpp | 205 +++++++++++++-------------- switch/src/host.cpp | 174 ++++++++++++++--------- switch/src/io.cpp | 304 ++++++++++++++++++++++++---------------- switch/src/main.cpp | 3 +- switch/src/settings.cpp | 7 +- 8 files changed, 462 insertions(+), 379 deletions(-) diff --git a/switch/include/gui.h b/switch/include/gui.h index 8af07ca..afd2bab 100644 --- a/switch/include/gui.h +++ b/switch/include/gui.h @@ -11,55 +11,55 @@ #include -#include #include +#include -#include "host.h" -#include "settings.h" #include "discoverymanager.h" +#include "host.h" #include "io.h" +#include "settings.h" class HostInterface : public brls::List { private: - IO * io; - Host * host; - Settings * settings; + IO *io; + Host *host; + Settings *settings; bool connected = false; + public: - HostInterface(IO * io, Host * host, Settings * settings); + HostInterface(Host *host); ~HostInterface(); - static void Register(IO * io, Host * host, - Settings * settings, std::function success_cb = nullptr); + static void Register(Host *host, std::function success_cb = nullptr); void Register(); - void Wakeup(brls::View * view); - void Connect(brls::View * view); + void Wakeup(brls::View *view); + void Connect(brls::View *view); void ConnectSession(); void Disconnect(); - bool Stream(); - bool CloseStream(ChiakiQuitEvent * quit); + void Stream(); + void CloseStream(ChiakiQuitEvent *quit); }; class MainApplication { private: - Settings * settings; - ChiakiLog * log; - DiscoveryManager * discoverymanager; - IO * io; - brls::TabFrame * rootFrame; + Settings *settings; + ChiakiLog *log; + DiscoveryManager *discoverymanager; + IO *io; + brls::TabFrame *rootFrame; std::map host_menuitems; // add_host local settings std::string remote_display_name = ""; std::string remote_addr = ""; ChiakiTarget remote_ps_version = CHIAKI_TARGET_PS5_1; - bool BuildConfigurationMenu(brls::List *, Host * host = nullptr); + bool BuildConfigurationMenu(brls::List *, Host *host = nullptr); void BuildAddHostConfigurationMenu(brls::List *); - public: - MainApplication(DiscoveryManager * discoverymanager, IO * io); + public: + MainApplication(DiscoveryManager *discoverymanager); ~MainApplication(); bool Load(); }; @@ -67,24 +67,23 @@ class MainApplication class PSRemotePlay : public brls::View { private: - brls::AppletFrame * frame; + brls::AppletFrame *frame; // to display stream on screen - IO * io; + IO *io; // to send gamepad inputs - Host * host; - brls::Label * label; - ChiakiControllerState state = { 0 }; + Host *host; + brls::Label *label; + ChiakiControllerState state = {0}; // FPS calculation // double base_time; // int frame_counter = 0; // int fps = 0; public: - PSRemotePlay(IO * io, Host * host); + PSRemotePlay(Host *host); ~PSRemotePlay(); - void draw(NVGcontext * vg, int x, int y, unsigned width, unsigned height, brls::Style * style, brls::FrameContext * ctx) override; + void draw(NVGcontext *vg, int x, int y, unsigned width, unsigned height, brls::Style *style, brls::FrameContext *ctx) override; }; #endif // CHIAKI_GUI_H - diff --git a/switch/include/host.h b/switch/include/host.h index 1966c1e..ae6f05e 100644 --- a/switch/include/host.h +++ b/switch/include/host.h @@ -19,11 +19,11 @@ class DiscoveryManager; static void Discovery(ChiakiDiscoveryHost *, void *); -static void InitAudioCB(unsigned int channels, unsigned int rate, void * user); -static bool VideoCB(uint8_t * buf, size_t buf_size, void * user); -static void AudioCB(int16_t * buf, size_t samples_count, void * user); -static void RegistEventCB(ChiakiRegistEvent * event, void * user); -static void EventCB(ChiakiEvent * event, void * user); +static void InitAudioCB(unsigned int channels, unsigned int rate, void *user); +static bool VideoCB(uint8_t *buf, size_t buf_size, void *user); +static void AudioCB(int16_t *buf, size_t samples_count, void *user); +static void EventCB(ChiakiEvent *event, void *user); +static void RegistEventCB(ChiakiRegistEvent *event, void *user); enum RegistError { @@ -37,8 +37,8 @@ class Settings; class Host { private: - ChiakiLog * log = nullptr; - Settings * settings = nullptr; + ChiakiLog *log = nullptr; + Settings *settings = nullptr; //video config ChiakiVideoResolutionPreset video_resolution = CHIAKI_VIDEO_RESOLUTION_PRESET_720p; ChiakiVideoFPSPreset video_fps = CHIAKI_VIDEO_FPS_PRESET_60; @@ -52,6 +52,9 @@ class Host std::function chiaki_regist_event_type_finished_canceled = nullptr; std::function chiaki_regist_event_type_finished_failed = nullptr; std::function chiaki_regist_event_type_finished_success = nullptr; + std::function chiaki_event_connected_cb = nullptr; + std::function chiaki_even_login_pin_request_cb = nullptr; + std::function chiaki_event_quit_cb = nullptr; // internal state bool discovered = false; @@ -95,7 +98,8 @@ class Host void StartSession(); void SendFeedbackState(ChiakiControllerState *); void RegistCB(ChiakiRegistEvent *); - bool GetVideoResolution(int * ret_width, int * ret_height); + void ConnectionEventCB(ChiakiEvent *); + bool GetVideoResolution(int *ret_width, int *ret_height); std::string GetHostName(); std::string GetHostAddr(); ChiakiTarget GetChiakiTarget(); @@ -104,6 +108,9 @@ class Host void SetRegistEventTypeFinishedCanceled(std::function chiaki_regist_event_type_finished_canceled); void SetRegistEventTypeFinishedFailed(std::function chiaki_regist_event_type_finished_failed); void SetRegistEventTypeFinishedSuccess(std::function chiaki_regist_event_type_finished_success); + void SetEventConnectedCallback(std::function chiaki_event_connected_cb); + void SetEventLoginPinRequestCallback(std::function chiaki_even_login_pin_request_cb); + void SetEventQuitCallback(std::function chiaki_event_quit_cb); bool IsRegistered(); bool IsDiscovered(); bool IsReady(); diff --git a/switch/include/io.h b/switch/include/io.h index 932a2b3..8427684 100644 --- a/switch/include/io.h +++ b/switch/include/io.h @@ -3,15 +3,14 @@ #ifndef CHIAKI_IO_H #define CHIAKI_IO_H -#include -#include #include +#include +#include #include // glad library (OpenGL loader) #include - /* https://github.com/devkitPro/switch-glad/blob/master/include/glad/glad.h https://glad.dav1d.de/#profile=core&language=c&specification=gl&api=gl%3D4.3&extensions=GL_EXT_texture_compression_s3tc&extensions=GL_EXT_texture_filter_anisotropic @@ -37,8 +36,8 @@ extern "C" #include } -#include #include +#include #include "exception.h" @@ -47,8 +46,11 @@ extern "C" class IO { + protected: + IO(); + static IO * instance; private: - ChiakiLog * log; + ChiakiLog *log; int video_width; int video_height; bool quit = false; @@ -57,15 +59,12 @@ class IO // default nintendo switch res int screen_width = 1280; int screen_height = 720; - std::function chiaki_event_connected_cb = nullptr; - std::function chiaki_even_login_pin_request_cb = nullptr; - std::function chiaki_event_quit_cb = nullptr; - AVCodec * codec; - AVCodecContext * codec_context; - AVFrame * frame; + AVCodec *codec; + AVCodecContext *codec_context; + AVFrame *frame; SDL_AudioDeviceID sdl_audio_device_id = 0; SDL_Event sdl_event; - SDL_Joystick * sdl_joystick_ptr[SDL_JOYSTICK_COUNT] = {0}; + SDL_Joystick *sdl_joystick_ptr[SDL_JOYSTICK_COUNT] = {0}; GLuint vao; GLuint vbo; GLuint tex[PLANES_COUNT]; @@ -73,49 +72,38 @@ class IO GLuint vert; GLuint frag; GLuint prog; - private: bool InitAVCodec(); bool InitOpenGl(); bool InitOpenGlTextures(); bool InitOpenGlShader(); void OpenGlDraw(); #ifdef DEBUG_OPENGL - void CheckGLError(const char * func, const char * file, int line); - void DumpShaderError(GLuint prog, const char * func, const char * file, int line); - void DumpProgramError(GLuint prog, const char * func, const char * file, int line); + void CheckGLError(const char *func, const char *file, int line); + void DumpShaderError(GLuint prog, const char *func, const char *file, int line); + void DumpProgramError(GLuint prog, const char *func, const char *file, int line); #endif - GLuint CreateAndCompileShader(GLenum type, const char * source); - void SetOpenGlYUVPixels(AVFrame * frame); - bool ReadGameKeys(SDL_Event * event, ChiakiControllerState * state); - bool ReadGameTouchScreen(ChiakiControllerState * state); + GLuint CreateAndCompileShader(GLenum type, const char *source); + void SetOpenGlYUVPixels(AVFrame *frame); + bool ReadGameKeys(SDL_Event *event, ChiakiControllerState *state); + bool ReadGameTouchScreen(ChiakiControllerState *state); + public: - IO(ChiakiLog * log); + // singleton configuration + IO(const IO&) = delete; + void operator=(const IO&) = delete; + static IO * GetInstance(); + ~IO(); void SetMesaConfig(); - bool VideoCB(uint8_t * buf, size_t buf_size); - void SetEventConnectedCallback(std::function chiaki_event_connected_cb) - { - this->chiaki_event_connected_cb = chiaki_event_connected_cb; - }; - void SetEventLoginPinRequestCallback(std::function chiaki_even_login_pin_request_cb) - { - this->chiaki_even_login_pin_request_cb = chiaki_even_login_pin_request_cb; - }; - void SetEventQuitCallback(std::function chiaki_event_quit_cb) - { - this->chiaki_event_quit_cb = chiaki_event_quit_cb; - }; + bool VideoCB(uint8_t *buf, size_t buf_size); void InitAudioCB(unsigned int channels, unsigned int rate); - void AudioCB(int16_t * buf, size_t samples_count); - void EventCB(ChiakiEvent *event); + void AudioCB(int16_t *buf, size_t samples_count); bool InitVideo(int video_width, int video_height, int screen_width, int screen_height); bool FreeVideo(); bool InitJoystick(); bool FreeJoystick(); - bool ReadUserKeyboard(char * buffer, size_t buffer_size); - bool MainLoop(ChiakiControllerState * state); + bool ReadUserKeyboard(char *buffer, size_t buffer_size); + bool MainLoop(ChiakiControllerState *state); }; #endif //CHIAKI_IO_H - - diff --git a/switch/src/gui.cpp b/switch/src/gui.cpp index 3755cfe..6d4ef2a 100644 --- a/switch/src/gui.cpp +++ b/switch/src/gui.cpp @@ -1,7 +1,7 @@ // SPDX-License-Identifier: LicenseRef-AGPL-3.0-only-OpenSSL -#include #include "gui.h" +#include #define SCREEN_W 1280 #define SCREEN_H 720 @@ -9,34 +9,39 @@ // TODO using namespace brls::i18n::literals; // for _i18n -#define DIALOG(dialog, r) \ - brls::Dialog* d_##dialog = new brls::Dialog(r); \ - brls::GenericEvent::Callback cb_##dialog = [d_##dialog](brls::View* view) \ - { \ - d_##dialog->close(); \ - }; \ - d_##dialog->addButton("Ok", cb_##dialog); \ - d_##dialog->setCancelable(false); \ - d_##dialog->open(); \ +#define DIALOG(dialog, r) \ + brls::Dialog *d_##dialog = new brls::Dialog(r); \ + brls::GenericEvent::Callback cb_##dialog = [d_##dialog](brls::View *view) { \ + d_##dialog->close(); \ + }; \ + d_##dialog->addButton("Ok", cb_##dialog); \ + d_##dialog->setCancelable(false); \ + d_##dialog->open(); \ brls::Logger::info("Dialog: {0}", r); - -HostInterface::HostInterface(IO * io, Host * host, Settings * settings) - : io(io), host(host), settings(settings) +HostInterface::HostInterface(Host *host) + : host(host) { - brls::ListItem* connect = new brls::ListItem("Connect"); + this->settings = Settings::GetInstance(); + this->io = IO::GetInstance(); + + brls::ListItem *connect = new brls::ListItem("Connect"); connect->getClickEvent()->subscribe(std::bind(&HostInterface::Connect, this, std::placeholders::_1)); this->addView(connect); - brls::ListItem* wakeup = new brls::ListItem("Wakeup"); + brls::ListItem *wakeup = new brls::ListItem("Wakeup"); wakeup->getClickEvent()->subscribe(std::bind(&HostInterface::Wakeup, this, std::placeholders::_1)); this->addView(wakeup); // message delimiter - brls::Label* info = new brls::Label(brls::LabelStyle::REGULAR, - "Host configuration", true); + brls::Label *info = new brls::Label(brls::LabelStyle::REGULAR, + "Host configuration", true); this->addView(info); + // push opengl chiaki stream + // when the host is connected + this->host->SetEventConnectedCallback(std::bind(&HostInterface::Stream, this)); + this->host->SetEventQuitCallback(std::bind(&HostInterface::CloseStream, this, std::placeholders::_1)); } HostInterface::~HostInterface() @@ -44,8 +49,11 @@ HostInterface::~HostInterface() Disconnect(); } -void HostInterface::Register(IO * io, Host * host, Settings * settings, std::function success_cb) +void HostInterface::Register(Host *host, std::function success_cb) { + Settings *settings = Settings::GetInstance(); + IO *io = IO::GetInstance(); + // user must provide psn id for registration std::string account_id = settings->GetPSNAccountID(host); std::string online_id = settings->GetPSNOnlineID(host); @@ -65,35 +73,32 @@ void HostInterface::Register(IO * io, Host * host, Settings * settings, std::fun } // add HostConnected function to regist_event_type_finished_success - auto event_type_finished_success_cb = [settings, success_cb]() - { - // save RP keys - settings->WriteFile(); - if(success_cb != nullptr) - { - // FIXME: may raise a connection refused - // when the connection is triggered - // just after the register success - sleep(2); - success_cb(); - } - // decrement block input token number - brls::Application::unblockInputs(); + auto event_type_finished_success_cb = [settings, success_cb]() { + // save RP keys + settings->WriteFile(); + if(success_cb != nullptr) + { + // FIXME: may raise a connection refused + // when the connection is triggered + // just after the register success + sleep(2); + success_cb(); + } + // decrement block input token number + brls::Application::unblockInputs(); }; host->SetRegistEventTypeFinishedSuccess(event_type_finished_success_cb); - auto event_type_finished_failed_cb = []() - { - // unlock user inputs - brls::Application::unblockInputs(); - brls::Application::notify("Registration failed"); + auto event_type_finished_failed_cb = []() { + // unlock user inputs + brls::Application::unblockInputs(); + brls::Application::notify("Registration failed"); }; host->SetRegistEventTypeFinishedFailed(event_type_finished_failed_cb); // the host is not registered yet - brls::Dialog* peprpc = new brls::Dialog("Please enter your PlayStation registration PIN code"); - brls::GenericEvent::Callback cb_peprpc = [host, io, peprpc](brls::View* view) - { + brls::Dialog *peprpc = new brls::Dialog("Please enter your PlayStation registration PIN code"); + brls::GenericEvent::Callback cb_peprpc = [host, io, peprpc](brls::View *view) { bool pin_provided = false; char pin_input[9] = {0}; std::string error_message; @@ -133,11 +138,10 @@ void HostInterface::Register(IO * io, Host * host, Settings * settings, std::fun void HostInterface::Register() { // use Connect just after the registration to save user inputs - HostInterface::Register(this->io, this->host, - this->settings, std::bind(&HostInterface::ConnectSession, this)); + HostInterface::Register(this->host, std::bind(&HostInterface::ConnectSession, this)); } -void HostInterface::Wakeup(brls::View * view) +void HostInterface::Wakeup(brls::View *view) { if(!this->host->HasRPkey()) { @@ -158,7 +162,7 @@ void HostInterface::Wakeup(brls::View * view) } } -void HostInterface::Connect(brls::View * view) +void HostInterface::Connect(brls::View *view) { // check that all requirements are met if(!this->host->IsDiscovered() && !this->host->HasRPkey()) @@ -194,11 +198,6 @@ void HostInterface::ConnectSession() // user inputs are restored with the CloseStream brls::Application::blockInputs(); - // push opengl chiaki stream - // when the host is connected - this->io->SetEventConnectedCallback(std::bind(&HostInterface::Stream, this)); - this->io->SetEventQuitCallback(std::bind(&HostInterface::CloseStream, this, std::placeholders::_1)); - // connect host sesssion this->host->InitSession(this->io); this->host->StartSession(); @@ -212,10 +211,11 @@ void HostInterface::Disconnect() this->host->StopSession(); this->connected = false; } + this->host->FiniSession(); } -bool HostInterface::Stream() +void HostInterface::Stream() { this->connected = true; // https://github.com/natinusala/borealis/issues/59 @@ -226,11 +226,10 @@ bool HostInterface::Stream() // brls::Application::setDisplayFramerate(true); // push raw opengl stream over borealis - brls::Application::pushView(new PSRemotePlay(this->io, this->host)); - return true; + brls::Application::pushView(new PSRemotePlay(this->host)); } -bool HostInterface::CloseStream(ChiakiQuitEvent * quit) +void HostInterface::CloseStream(ChiakiQuitEvent *quit) { // session QUIT call back brls::Application::unblockInputs(); @@ -244,14 +243,14 @@ bool HostInterface::CloseStream(ChiakiQuitEvent * quit) */ brls::Application::notify(chiaki_quit_reason_string(quit->reason)); Disconnect(); - return false; } -MainApplication::MainApplication(DiscoveryManager * discoverymanager, IO * io) - : discoverymanager(discoverymanager), io(io) +MainApplication::MainApplication(DiscoveryManager *discoverymanager) + : discoverymanager(discoverymanager) { this->settings = Settings::GetInstance(); this->log = this->settings->GetLogger(); + this->io = IO::GetInstance(); } MainApplication::~MainApplication() @@ -268,7 +267,7 @@ bool MainApplication::Load() brls::Logger::setLogLevel(brls::LogLevel::DEBUG); brls::i18n::loadTranslations(); - if (!brls::Application::init("Chiaki Remote play")) + if(!brls::Application::init("Chiaki Remote play")) { brls::Logger::error("Unable to init Borealis application"); return false; @@ -293,8 +292,8 @@ bool MainApplication::Load() this->rootFrame->setTitle("Chiaki: Open Source PlayStation Remote Play Client"); this->rootFrame->setIcon(BOREALIS_ASSET("icon.jpg")); - brls::List* config = new brls::List(); - brls::List* add_host = new brls::List(); + brls::List *config = new brls::List(); + brls::List *add_host = new brls::List(); BuildConfigurationMenu(config); BuildAddHostConfigurationMenu(add_host); @@ -306,16 +305,15 @@ bool MainApplication::Load() // Add the root view to the stack brls::Application::pushView(this->rootFrame); - std::map * hosts = this->settings->GetHostsMap(); + std::map *hosts = this->settings->GetHostsMap(); while(brls::Application::mainLoop()) { for(auto it = hosts->begin(); it != hosts->end(); it++) { // add host to the gui only if the host is registered or discovered - if(this->host_menuitems.find(&it->second) == this->host_menuitems.end() - && (it->second.HasRPkey() == true || it->second.IsDiscovered() == true)) + if(this->host_menuitems.find(&it->second) == this->host_menuitems.end() && (it->second.HasRPkey() == true || it->second.IsDiscovered() == true)) { - HostInterface * new_host = new HostInterface(this->io, &it->second, this->settings); + HostInterface *new_host = new HostInterface(&it->second); this->host_menuitems[&it->second] = new_host; // create host if udefined BuildConfigurationMenu(new_host, &it->second); @@ -326,13 +324,12 @@ bool MainApplication::Load() return true; } -bool MainApplication::BuildConfigurationMenu(brls::List * ls, Host * host) +bool MainApplication::BuildConfigurationMenu(brls::List *ls, Host *host) { std::string psn_account_id_string = this->settings->GetPSNAccountID(host); - brls::ListItem* psn_account_id = new brls::ListItem("PSN Account ID", "PS5 or PS4 v7.0 and greater (base64 account_id)"); + brls::ListItem *psn_account_id = new brls::ListItem("PSN Account ID", "PS5 or PS4 v7.0 and greater (base64 account_id)"); psn_account_id->setValue(psn_account_id_string.c_str()); - auto psn_account_id_cb = [this, host, psn_account_id](brls::View * view) - { + auto psn_account_id_cb = [this, host, psn_account_id](brls::View *view) { char account_id[CHIAKI_PSN_ACCOUNT_ID_SIZE * 2] = {0}; bool input = this->io->ReadUserKeyboard(account_id, sizeof(account_id)); if(input) @@ -349,10 +346,9 @@ bool MainApplication::BuildConfigurationMenu(brls::List * ls, Host * host) ls->addView(psn_account_id); std::string psn_online_id_string = this->settings->GetPSNOnlineID(host); - brls::ListItem* psn_online_id = new brls::ListItem("PSN Online ID"); + brls::ListItem *psn_online_id = new brls::ListItem("PSN Online ID"); psn_online_id->setValue(psn_online_id_string.c_str()); - auto psn_online_id_cb = [this, host, psn_online_id](brls::View * view) - { + auto psn_online_id_cb = [this, host, psn_online_id](brls::View *view) { char online_id[256] = {0}; bool input = this->io->ReadUserKeyboard(online_id, sizeof(online_id)); if(input) @@ -383,11 +379,10 @@ bool MainApplication::BuildConfigurationMenu(brls::List * ls, Host * host) break; } - brls::SelectListItem* resolution = new brls::SelectListItem( - "Resolution", { "720p", "540p", "360p" }, value); + brls::SelectListItem *resolution = new brls::SelectListItem( + "Resolution", {"720p", "540p", "360p"}, value); - auto resolution_cb = [this, host](int result) - { + auto resolution_cb = [this, host](int result) { ChiakiVideoResolutionPreset value = CHIAKI_VIDEO_RESOLUTION_PRESET_720p; switch(result) { @@ -418,11 +413,10 @@ bool MainApplication::BuildConfigurationMenu(brls::List * ls, Host * host) break; } - brls::SelectListItem* fps = new brls::SelectListItem( - "FPS", { "60", "30"}, value); + brls::SelectListItem *fps = new brls::SelectListItem( + "FPS", {"60", "30"}, value); - auto fps_cb = [this, host](int result) - { + auto fps_cb = [this, host](int result) { ChiakiVideoFPSPreset value = CHIAKI_VIDEO_FPS_PRESET_60; switch(result) { @@ -443,49 +437,47 @@ bool MainApplication::BuildConfigurationMenu(brls::List * ls, Host * host) if(host != nullptr) { // message delimiter - brls::Label* info = new brls::Label(brls::LabelStyle::REGULAR, - "Host information", true); + brls::Label *info = new brls::Label(brls::LabelStyle::REGULAR, + "Host information", true); ls->addView(info); std::string host_name_string = this->settings->GetHostName(host); - brls::ListItem* host_name = new brls::ListItem("PS Hostname"); + brls::ListItem *host_name = new brls::ListItem("PS Hostname"); host_name->setValue(host_name_string.c_str()); ls->addView(host_name); std::string host_addr_string = settings->GetHostAddr(host); - brls::ListItem* host_addr = new brls::ListItem("PS4 Address"); + brls::ListItem *host_addr = new brls::ListItem("PS4 Address"); host_addr->setValue(host_addr_string.c_str()); ls->addView(host_addr); std::string host_rp_regist_key_string = settings->GetHostRPRegistKey(host); - brls::ListItem* host_rp_regist_key = new brls::ListItem("RP Register Key"); + brls::ListItem *host_rp_regist_key = new brls::ListItem("RP Register Key"); host_rp_regist_key->setValue(host_rp_regist_key_string.c_str()); ls->addView(host_rp_regist_key); std::string host_rp_key_string = settings->GetHostRPKey(host); - brls::ListItem* host_rp_key = new brls::ListItem("RP Key"); + brls::ListItem *host_rp_key = new brls::ListItem("RP Key"); host_rp_key->setValue(host_rp_key_string.c_str()); ls->addView(host_rp_key); std::string host_rp_key_type_string = std::to_string(settings->GetHostRPKeyType(host)); - brls::ListItem* host_rp_key_type = new brls::ListItem("RP Key type"); + brls::ListItem *host_rp_key_type = new brls::ListItem("RP Key type"); host_rp_key_type->setValue(host_rp_key_type_string.c_str()); ls->addView(host_rp_key_type); - } return true; } -void MainApplication::BuildAddHostConfigurationMenu(brls::List * add_host) +void MainApplication::BuildAddHostConfigurationMenu(brls::List *add_host) { // create host for wan connection // brls::Label* add_host_label = new brls::Label(brls::LabelStyle::REGULAR, // "Add Host configuration", true); - brls::ListItem* display_name = new brls::ListItem("Display name"); - auto display_name_cb = [this, display_name](brls::View * view) - { + brls::ListItem *display_name = new brls::ListItem("Display name"); + auto display_name_cb = [this, display_name](brls::View *view) { char name[16] = {0}; bool input = this->io->ReadUserKeyboard(name, sizeof(name)); if(input) @@ -499,9 +491,8 @@ void MainApplication::BuildAddHostConfigurationMenu(brls::List * add_host) display_name->getClickEvent()->subscribe(display_name_cb); add_host->addView(display_name); - brls::ListItem* address = new brls::ListItem("Remote IP/name"); - auto address_cb = [this, address](brls::View * view) - { + brls::ListItem *address = new brls::ListItem("Remote IP/name"); + auto address_cb = [this, address](brls::View *view) { char addr[256] = {0}; bool input = this->io->ReadUserKeyboard(addr, sizeof(addr)); if(input) @@ -515,15 +506,13 @@ void MainApplication::BuildAddHostConfigurationMenu(brls::List * add_host) address->getClickEvent()->subscribe(address_cb); add_host->addView(address); - // TODO // brls::ListItem* port = new brls::ListItem("Remote session port", "tcp/udp 9295"); // brls::ListItem* port = new brls::ListItem("Remote stream port", "udp 9296"); // brls::ListItem* port = new brls::ListItem("Remote Senkusha port", "udp 9297"); - brls::SelectListItem* ps_version = new brls::SelectListItem("PlayStation Version", - { "PS5", "PS4 > 8", "7 < PS4 < 8", "PS4 < 7"}); - auto ps_version_cb = [this, ps_version](int result) - { + brls::SelectListItem *ps_version = new brls::SelectListItem("PlayStation Version", + {"PS5", "PS4 > 8", "7 < PS4 < 8", "PS4 < 7"}); + auto ps_version_cb = [this, ps_version](int result) { switch(result) { case 0: @@ -547,9 +536,8 @@ void MainApplication::BuildAddHostConfigurationMenu(brls::List * add_host) ps_version->getValueSelectedEvent()->subscribe(ps_version_cb); add_host->addView(ps_version); - brls::ListItem* register_host = new brls::ListItem("Register"); - auto register_host_cb = [this](brls::View * view) - { + brls::ListItem *register_host = new brls::ListItem("Register"); + auto register_host_cb = [this](brls::View *view) { bool err = false; if(this->remote_display_name.length() <= 0) { @@ -572,29 +560,31 @@ void MainApplication::BuildAddHostConfigurationMenu(brls::List * add_host) if(err) return; - Host * host = this->settings->GetOrCreateHost(&this->remote_display_name); + Host *host = this->settings->GetOrCreateHost(&this->remote_display_name); host->SetHostAddr(this->remote_addr); host->SetChiakiTarget(this->remote_ps_version); - HostInterface::Register(this->io, host, this->settings); + HostInterface::Register(host); }; register_host->getClickEvent()->subscribe(register_host_cb); add_host->addView(register_host); } -PSRemotePlay::PSRemotePlay(IO * io, Host * host) - : io(io), host(host) +PSRemotePlay::PSRemotePlay(Host *host) + : host(host) { + this->io = IO::GetInstance(); + // store joycon/touchpad keys - for(int x=0; x < CHIAKI_CONTROLLER_TOUCHES_MAX; x++) + for(int x = 0; x < CHIAKI_CONTROLLER_TOUCHES_MAX; x++) // start touchpad as "untouched" this->state.touches[x].id = -1; // this->base_time=glfwGetTime(); } -void PSRemotePlay::draw(NVGcontext* vg, int x, int y, unsigned width, unsigned height, brls::Style* style, brls::FrameContext* ctx) +void PSRemotePlay::draw(NVGcontext *vg, int x, int y, unsigned width, unsigned height, brls::Style *style, brls::FrameContext *ctx) { this->io->MainLoop(&this->state); this->host->SendFeedbackState(&this->state); @@ -622,4 +612,3 @@ void PSRemotePlay::draw(NVGcontext* vg, int x, int y, unsigned width, unsigned h PSRemotePlay::~PSRemotePlay() { } - diff --git a/switch/src/host.cpp b/switch/src/host.cpp index 4dae777..0770ca0 100644 --- a/switch/src/host.cpp +++ b/switch/src/host.cpp @@ -7,33 +7,33 @@ #include "host.h" #include "io.h" -static void InitAudioCB(unsigned int channels, unsigned int rate, void * user) +static void InitAudioCB(unsigned int channels, unsigned int rate, void *user) { - IO * io = (IO *)user; + IO *io = (IO *)user; io->InitAudioCB(channels, rate); } -static bool VideoCB(uint8_t * buf, size_t buf_size, void * user) +static bool VideoCB(uint8_t *buf, size_t buf_size, void *user) { - IO * io = (IO *)user; + IO *io = (IO *)user; return io->VideoCB(buf, buf_size); } -static void AudioCB(int16_t * buf, size_t samples_count, void * user) +static void AudioCB(int16_t *buf, size_t samples_count, void *user) { - IO * io = (IO *)user; + IO *io = (IO *)user; io->AudioCB(buf, samples_count); } -static void EventCB(ChiakiEvent * event, void * user) +static void EventCB(ChiakiEvent *event, void *user) { - IO * io = (IO *)user; - io->EventCB(event); + Host *host = (Host *)user; + host->ConnectionEventCB(event); } -static void RegistEventCB(ChiakiRegistEvent * event, void * user) +static void RegistEventCB(ChiakiRegistEvent *event, void *user) { - Host * host = (Host *)user; + Host *host = (Host *)user; host->RegistCB(event); } @@ -132,7 +132,7 @@ int Host::Register(std::string pin) return HOST_REGISTER_OK; } -int Host::InitSession(IO * user) +int Host::InitSession(IO *user) { chiaki_connect_video_profile_preset(&(this->video_profile), this->video_resolution, this->video_fps); @@ -158,7 +158,7 @@ int Host::InitSession(IO * user) chiaki_opus_decoder_get_sink(&this->opus_decoder, &audio_sink); chiaki_session_set_audio_sink(&(this->session), &audio_sink); chiaki_session_set_video_sample_cb(&(this->session), VideoCB, user); - chiaki_session_set_event_cb(&(this->session), EventCB, user); + chiaki_session_set_event_cb(&(this->session), EventCB, this); return 0; } @@ -166,6 +166,7 @@ int Host::FiniSession() { if(this->session_init) { + this->session_init = false; chiaki_session_join(&this->session); chiaki_session_fini(&this->session); chiaki_opus_decoder_fini(&this->opus_decoder); @@ -188,13 +189,35 @@ void Host::StartSession() } } -void Host::SendFeedbackState(ChiakiControllerState * state) +void Host::SendFeedbackState(ChiakiControllerState *state) { // send controller/joystick key chiaki_session_set_controller_state(&this->session, state); } -void Host::RegistCB(ChiakiRegistEvent * event) +void Host::ConnectionEventCB(ChiakiEvent *event) +{ + switch(event->type) + { + case CHIAKI_EVENT_CONNECTED: + CHIAKI_LOGI(this->log, "EventCB CHIAKI_EVENT_CONNECTED"); + if(this->chiaki_event_connected_cb != nullptr) + this->chiaki_event_connected_cb(); + break; + case CHIAKI_EVENT_LOGIN_PIN_REQUEST: + CHIAKI_LOGI(this->log, "EventCB CHIAKI_EVENT_LOGIN_PIN_REQUEST"); + if(this->chiaki_even_login_pin_request_cb != nullptr) + this->chiaki_even_login_pin_request_cb(event->login_pin_request.pin_incorrect); + break; + case CHIAKI_EVENT_QUIT: + CHIAKI_LOGI(this->log, "EventCB CHIAKI_EVENT_QUIT"); + if(this->chiaki_event_quit_cb != nullptr) + this->chiaki_event_quit_cb(&event->quit); + break; + } +} + +void Host::RegistCB(ChiakiRegistEvent *event) { // Chiaki callback fuction // fuction called by lib chiaki regist @@ -205,71 +228,71 @@ void Host::RegistCB(ChiakiRegistEvent * event) this->registered = false; switch(event->type) { - case CHIAKI_REGIST_EVENT_TYPE_FINISHED_CANCELED: - CHIAKI_LOGI(this->log, "Register event CHIAKI_REGIST_EVENT_TYPE_FINISHED_CANCELED"); - if(this->chiaki_regist_event_type_finished_canceled != nullptr) + case CHIAKI_REGIST_EVENT_TYPE_FINISHED_CANCELED: + CHIAKI_LOGI(this->log, "Register event CHIAKI_REGIST_EVENT_TYPE_FINISHED_CANCELED"); + if(this->chiaki_regist_event_type_finished_canceled != nullptr) + { + this->chiaki_regist_event_type_finished_canceled(); + } + break; + case CHIAKI_REGIST_EVENT_TYPE_FINISHED_FAILED: + CHIAKI_LOGI(this->log, "Register event CHIAKI_REGIST_EVENT_TYPE_FINISHED_FAILED"); + if(this->chiaki_regist_event_type_finished_failed != nullptr) + { + this->chiaki_regist_event_type_finished_failed(); + } + break; + case CHIAKI_REGIST_EVENT_TYPE_FINISHED_SUCCESS: { - this->chiaki_regist_event_type_finished_canceled(); - } - break; - case CHIAKI_REGIST_EVENT_TYPE_FINISHED_FAILED: - CHIAKI_LOGI(this->log, "Register event CHIAKI_REGIST_EVENT_TYPE_FINISHED_FAILED"); - if(this->chiaki_regist_event_type_finished_failed != nullptr) - { - this->chiaki_regist_event_type_finished_failed(); - } - break; - case CHIAKI_REGIST_EVENT_TYPE_FINISHED_SUCCESS: - { - ChiakiRegisteredHost * r_host = event->registered_host; - CHIAKI_LOGI(this->log, "Register event CHIAKI_REGIST_EVENT_TYPE_FINISHED_SUCCESS"); - // copy values form ChiakiRegisteredHost object - this->ap_ssid = r_host->ap_ssid; - this->ap_key = r_host->ap_key; - this->ap_name = r_host->ap_name; - memcpy(&(this->server_mac), &(r_host->server_mac), sizeof(this->server_mac)); - this->server_nickname = r_host->server_nickname; - memcpy(&(this->rp_regist_key), &(r_host->rp_regist_key), sizeof(this->rp_regist_key)); - this->rp_key_type = r_host->rp_key_type; - memcpy(&(this->rp_key), &(r_host->rp_key), sizeof(this->rp_key)); - // mark host as registered - this->registered = true; - this->rp_key_data = true; - CHIAKI_LOGI(this->log, "Register Success %s", this->host_name.c_str()); + ChiakiRegisteredHost *r_host = event->registered_host; + CHIAKI_LOGI(this->log, "Register event CHIAKI_REGIST_EVENT_TYPE_FINISHED_SUCCESS"); + // copy values form ChiakiRegisteredHost object + this->ap_ssid = r_host->ap_ssid; + this->ap_key = r_host->ap_key; + this->ap_name = r_host->ap_name; + memcpy(&(this->server_mac), &(r_host->server_mac), sizeof(this->server_mac)); + this->server_nickname = r_host->server_nickname; + memcpy(&(this->rp_regist_key), &(r_host->rp_regist_key), sizeof(this->rp_regist_key)); + this->rp_key_type = r_host->rp_key_type; + memcpy(&(this->rp_key), &(r_host->rp_key), sizeof(this->rp_key)); + // mark host as registered + this->registered = true; + this->rp_key_data = true; + CHIAKI_LOGI(this->log, "Register Success %s", this->host_name.c_str()); - if(this->chiaki_regist_event_type_finished_success != nullptr) - this->chiaki_regist_event_type_finished_success(); + if(this->chiaki_regist_event_type_finished_success != nullptr) + this->chiaki_regist_event_type_finished_success(); - break; - } + break; + } } // close registration socket chiaki_regist_stop(&this->regist); chiaki_regist_fini(&this->regist); } -bool Host::GetVideoResolution(int * ret_width, int * ret_height) +bool Host::GetVideoResolution(int *ret_width, int *ret_height) { switch(this->video_resolution) { - case CHIAKI_VIDEO_RESOLUTION_PRESET_360p: - *ret_width = 640; - *ret_height = 360; - break; - case CHIAKI_VIDEO_RESOLUTION_PRESET_540p: - *ret_width = 950; - *ret_height = 540; - break; - case CHIAKI_VIDEO_RESOLUTION_PRESET_720p: - *ret_width = 1280; - *ret_height = 720; - break; - case CHIAKI_VIDEO_RESOLUTION_PRESET_1080p: - *ret_width = 1920; - *ret_height = 1080; - break; - default: - return false; + case CHIAKI_VIDEO_RESOLUTION_PRESET_360p: + *ret_width = 640; + *ret_height = 360; + break; + case CHIAKI_VIDEO_RESOLUTION_PRESET_540p: + *ret_width = 950; + *ret_height = 540; + break; + case CHIAKI_VIDEO_RESOLUTION_PRESET_720p: + *ret_width = 1280; + *ret_height = 720; + break; + case CHIAKI_VIDEO_RESOLUTION_PRESET_1080p: + *ret_width = 1920; + *ret_height = 1080; + break; + default: + return false; } return true; } @@ -314,6 +337,21 @@ void Host::SetRegistEventTypeFinishedSuccess(std::function chiaki_regist this->chiaki_regist_event_type_finished_success = chiaki_regist_event_type_finished_success; } +void Host::SetEventConnectedCallback(std::function chiaki_event_connected_cb) +{ + this->chiaki_event_connected_cb = chiaki_event_connected_cb; +} + +void Host::SetEventLoginPinRequestCallback(std::function chiaki_even_login_pin_request_cb) +{ + this->chiaki_even_login_pin_request_cb = chiaki_even_login_pin_request_cb; +} + +void Host::SetEventQuitCallback(std::function chiaki_event_quit_cb) +{ + this->chiaki_event_quit_cb = chiaki_event_quit_cb; +} + bool Host::IsRegistered() { return this->registered; diff --git a/switch/src/io.cpp b/switch/src/io.cpp index 97c433a..d7c28f7 100644 --- a/switch/src/io.cpp +++ b/switch/src/io.cpp @@ -7,6 +7,7 @@ #endif #include "io.h" +#include "settings.h" // https://github.com/torvalds/linux/blob/41ba50b0572e90ed3d24fe4def54567e9050bc47/drivers/hid/hid-sony.c#L2742 #define DS4_TRACKPAD_MAX_X 1920 @@ -24,7 +25,7 @@ // use OpenGl to decode YUV // the aim is to spare CPU load on nintendo switch -static const char* shader_vert_glsl = R"glsl( +static const char *shader_vert_glsl = R"glsl( #version 150 core in vec2 pos_attr; out vec2 uv_var; @@ -60,12 +61,23 @@ static const float vert_pos[] = { 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f, - 1.0f, 1.0f -}; + 1.0f, 1.0f}; -IO::IO(ChiakiLog * log) - : log(log) +IO *IO::instance = nullptr; + +IO *IO::GetInstance() { + if(instance == nullptr) + { + instance = new IO; + } + return instance; +} + +IO::IO() +{ + Settings *settings = Settings::GetInstance(); + this->log = settings->GetLogger(); } IO::~IO() @@ -99,11 +111,15 @@ void IO::SetMesaConfig() } #ifdef DEBUG_OPENGL -#define D(x){ (x); CheckGLError(__func__, __FILE__, __LINE__); } -void IO::CheckGLError(const char* func, const char* file, int line) +#define D(x) \ + { \ + (x); \ + CheckGLError(__func__, __FILE__, __LINE__); \ + } +void IO::CheckGLError(const char *func, const char *file, int line) { GLenum err; - while( (err = glGetError()) != GL_NO_ERROR ) + while((err = glGetError()) != GL_NO_ERROR) { CHIAKI_LOGE(this->log, "glGetError: %x function: %s from %s line %d", err, func, file, line); //GL_INVALID_VALUE, 0x0501 @@ -115,37 +131,51 @@ void IO::CheckGLError(const char* func, const char* file, int line) } } -#define DS(x){ DumpShaderError(x, __func__, __FILE__, __LINE__); } -void IO::DumpShaderError(GLuint shader, const char* func, const char* file, int line) +#define DS(x) \ + { \ + DumpShaderError(x, __func__, __FILE__, __LINE__); \ + } +void IO::DumpShaderError(GLuint shader, const char *func, const char *file, int line) { - GLchar str[512+1]; + GLchar str[512 + 1]; GLsizei len = 0; glGetShaderInfoLog(shader, 512, &len, str); - if (len > 512) len = 512; + if(len > 512) + len = 512; str[len] = '\0'; CHIAKI_LOGE(this->log, "glGetShaderInfoLog: %s function: %s from %s line %d", str, func, file, line); } -#define DP(x){ DumpProgramError(x, __func__, __FILE__, __LINE__); } -void IO::DumpProgramError(GLuint prog, const char* func, const char* file, int line) +#define DP(x) \ + { \ + DumpProgramError(x, __func__, __FILE__, __LINE__); \ + } +void IO::DumpProgramError(GLuint prog, const char *func, const char *file, int line) { - GLchar str[512+1]; + GLchar str[512 + 1]; GLsizei len = 0; glGetProgramInfoLog(prog, 512, &len, str); - if (len > 512) len = 512; + if(len > 512) + len = 512; str[len] = '\0'; CHIAKI_LOGE(this->log, "glGetProgramInfoLog: %s function: %s from %s line %d", str, func, file, line); } #else // do nothing -#define D(x){ (x); } -#define DS(x){ } -#define DP(x){ } +#define D(x) \ + { \ + (x); \ + } +#define DS(x) \ + { \ + } +#define DP(x) \ + { \ + } #endif - -bool IO::VideoCB(uint8_t * buf, size_t buf_size) +bool IO::VideoCB(uint8_t *buf, size_t buf_size) { // callback function to decode video buffer @@ -153,7 +183,7 @@ bool IO::VideoCB(uint8_t * buf, size_t buf_size) av_init_packet(&packet); packet.data = buf; packet.size = buf_size; - AVFrame * frame = av_frame_alloc(); + AVFrame *frame = av_frame_alloc(); if(!frame) { CHIAKI_LOGE(this->log, "UpdateFrame Failed to alloc AVFrame"); @@ -204,7 +234,6 @@ send_packet: return true; } - void IO::InitAudioCB(unsigned int channels, unsigned int rate) { SDL_AudioSpec want, have, test; @@ -241,12 +270,12 @@ void IO::InitAudioCB(unsigned int channels, unsigned int rate) } } -void IO::AudioCB(int16_t * buf, size_t samples_count) +void IO::AudioCB(int16_t *buf, size_t samples_count) { - for(int x=0; x < samples_count*2; x++) + for(int x = 0; x < samples_count * 2; x++) { // boost audio volume - int sample = buf[x]*1.80; + int sample = buf[x] * 1.80; // Hard clipping (audio compression) // truncate value that overflow/underflow int16 if(sample > INT16_MAX) @@ -260,9 +289,9 @@ void IO::AudioCB(int16_t * buf, size_t samples_count) CHIAKI_LOGD(this->log, "Audio Hard clipping INT16_MIN > %d", sample); } else - buf[x] = (int16_t) sample; + buf[x] = (int16_t)sample; } - int success = SDL_QueueAudio(this->sdl_audio_device_id, buf, sizeof(int16_t)*samples_count*2); + int success = SDL_QueueAudio(this->sdl_audio_device_id, buf, sizeof(int16_t) * samples_count * 2); if(success != 0) CHIAKI_LOGE(this->log, "SDL_QueueAudio failed: %s\n", SDL_GetError()); } @@ -289,33 +318,6 @@ bool IO::InitVideo(int video_width, int video_height, int screen_width, int scre return true; } -void IO::EventCB(ChiakiEvent *event) -{ - switch(event->type) - { - case CHIAKI_EVENT_CONNECTED: - CHIAKI_LOGI(this->log, "EventCB CHIAKI_EVENT_CONNECTED"); - if(this->chiaki_event_connected_cb != nullptr) - this->quit = !this->chiaki_event_connected_cb(); - else - this->quit = false; - break; - case CHIAKI_EVENT_LOGIN_PIN_REQUEST: - CHIAKI_LOGI(this->log, "EventCB CHIAKI_EVENT_LOGIN_PIN_REQUEST"); - if(this->chiaki_even_login_pin_request_cb != nullptr) - this->quit = !this->chiaki_even_login_pin_request_cb(event->login_pin_request.pin_incorrect); - break; - case CHIAKI_EVENT_QUIT: - CHIAKI_LOGI(this->log, "EventCB CHIAKI_EVENT_QUIT"); - if(this->chiaki_event_quit_cb != nullptr) - this->quit = !this->chiaki_event_quit_cb(&event->quit); - else - this->quit = true; - break; - } -} - - bool IO::FreeVideo() { bool ret = true; @@ -344,12 +346,12 @@ bool IO::ReadUserKeyboard(char *buffer, size_t buffer_size) SwkbdConfig kbd; Result rc = swkbdCreate(&kbd, 0); - if (R_SUCCEEDED(rc)) + if(R_SUCCEEDED(rc)) { swkbdConfigMakePresetDefault(&kbd); rc = swkbdShow(&kbd, buffer, buffer_size); - if (R_SUCCEEDED(rc)) + if(R_SUCCEEDED(rc)) { CHIAKI_LOGI(this->log, "Got user input: %s\n", buffer); } @@ -377,7 +379,7 @@ bool IO::ReadGameTouchScreen(ChiakiControllerState *state) bool ret = false; if(!touch_count) { - for(int i=0; i < CHIAKI_CONTROLLER_TOUCHES_MAX; i++) + for(int i = 0; i < CHIAKI_CONTROLLER_TOUCHES_MAX; i++) { if(state->touches[i].id != -1) { @@ -393,7 +395,7 @@ bool IO::ReadGameTouchScreen(ChiakiControllerState *state) } touchPosition touch; - for(int i=0; i < touch_count && i < CHIAKI_CONTROLLER_TOUCHES_MAX; i++) + for(int i = 0; i < touch_count && i < CHIAKI_CONTROLLER_TOUCHES_MAX; i++) { hidTouchRead(&touch, i); @@ -403,11 +405,10 @@ bool IO::ReadGameTouchScreen(ChiakiControllerState *state) uint16_t y = touch.py * (DS4_TRACKPAD_MAX_Y / SWITCH_TOUCHSCREEN_MAX_Y); // use nintendo switch border's 5% to - if(x <= (SWITCH_TOUCHSCREEN_MAX_X * 0.05) || x >= (SWITCH_TOUCHSCREEN_MAX_X * 0.95) - || y <= (SWITCH_TOUCHSCREEN_MAX_Y * 0.05) || y >= (SWITCH_TOUCHSCREEN_MAX_Y * 0.95)) + if(x <= (SWITCH_TOUCHSCREEN_MAX_X * 0.05) || x >= (SWITCH_TOUCHSCREEN_MAX_X * 0.95) || y <= (SWITCH_TOUCHSCREEN_MAX_Y * 0.05) || y >= (SWITCH_TOUCHSCREEN_MAX_Y * 0.95)) { state->buttons |= CHIAKI_CONTROLLER_BUTTON_TOUCHPAD; // touchscreen - // printf("CHIAKI_CONTROLLER_BUTTON_TOUCHPAD\n"); + // printf("CHIAKI_CONTROLLER_BUTTON_TOUCHPAD\n"); } else { @@ -459,7 +460,7 @@ bool IO::ReadGameKeys(SDL_Event *event, ChiakiControllerState *state) else ret = false; } - else if (event->jaxis.which == 1) + else if(event->jaxis.which == 1) { // right joystick if(event->jaxis.axis == 0) @@ -479,26 +480,58 @@ bool IO::ReadGameKeys(SDL_Event *event, ChiakiControllerState *state) // event->jbutton.which, event->jbutton.button); switch(event->jbutton.button) { - case 0: state->buttons |= CHIAKI_CONTROLLER_BUTTON_MOON; break; // KEY_A - case 1: state->buttons |= CHIAKI_CONTROLLER_BUTTON_CROSS; break; // KEY_B - case 2: state->buttons |= CHIAKI_CONTROLLER_BUTTON_PYRAMID; break; // KEY_X - case 3: state->buttons |= CHIAKI_CONTROLLER_BUTTON_BOX; break; // KEY_Y - case 12: state->buttons |= CHIAKI_CONTROLLER_BUTTON_DPAD_LEFT; break; // KEY_DLEFT - case 14: state->buttons |= CHIAKI_CONTROLLER_BUTTON_DPAD_RIGHT; break; // KEY_DRIGHT - case 13: state->buttons |= CHIAKI_CONTROLLER_BUTTON_DPAD_UP; break; // KEY_DUP - case 15: state->buttons |= CHIAKI_CONTROLLER_BUTTON_DPAD_DOWN; break; // KEY_DDOWN - case 6: state->buttons |= CHIAKI_CONTROLLER_BUTTON_L1; break; // KEY_L - case 7: state->buttons |= CHIAKI_CONTROLLER_BUTTON_R1; break; // KEY_R - case 8: state->l2_state = 0xff; break; // KEY_ZL - case 9: state->r2_state = 0xff; break; // KEY_ZR - case 4: state->buttons |= CHIAKI_CONTROLLER_BUTTON_L3; break; // KEY_LSTICK - case 5: state->buttons |= CHIAKI_CONTROLLER_BUTTON_R3; break; // KEY_RSTICK - case 10: state->buttons |= CHIAKI_CONTROLLER_BUTTON_OPTIONS; break; // KEY_PLUS + case 0: + state->buttons |= CHIAKI_CONTROLLER_BUTTON_MOON; + break; // KEY_A + case 1: + state->buttons |= CHIAKI_CONTROLLER_BUTTON_CROSS; + break; // KEY_B + case 2: + state->buttons |= CHIAKI_CONTROLLER_BUTTON_PYRAMID; + break; // KEY_X + case 3: + state->buttons |= CHIAKI_CONTROLLER_BUTTON_BOX; + break; // KEY_Y + case 12: + state->buttons |= CHIAKI_CONTROLLER_BUTTON_DPAD_LEFT; + break; // KEY_DLEFT + case 14: + state->buttons |= CHIAKI_CONTROLLER_BUTTON_DPAD_RIGHT; + break; // KEY_DRIGHT + case 13: + state->buttons |= CHIAKI_CONTROLLER_BUTTON_DPAD_UP; + break; // KEY_DUP + case 15: + state->buttons |= CHIAKI_CONTROLLER_BUTTON_DPAD_DOWN; + break; // KEY_DDOWN + case 6: + state->buttons |= CHIAKI_CONTROLLER_BUTTON_L1; + break; // KEY_L + case 7: + state->buttons |= CHIAKI_CONTROLLER_BUTTON_R1; + break; // KEY_R + case 8: + state->l2_state = 0xff; + break; // KEY_ZL + case 9: + state->r2_state = 0xff; + break; // KEY_ZR + case 4: + state->buttons |= CHIAKI_CONTROLLER_BUTTON_L3; + break; // KEY_LSTICK + case 5: + state->buttons |= CHIAKI_CONTROLLER_BUTTON_R3; + break; // KEY_RSTICK + case 10: + state->buttons |= CHIAKI_CONTROLLER_BUTTON_OPTIONS; + break; // KEY_PLUS // FIXME - // case 11: state->buttons |= CHIAKI_CONTROLLER_BUTTON_SHARE; break; // KEY_MINUS - case 11: state->buttons |= CHIAKI_CONTROLLER_BUTTON_PS; break; // KEY_MINUS + // case 11: state->buttons |= CHIAKI_CONTROLLER_BUTTON_SHARE; break; // KEY_MINUS + case 11: + state->buttons |= CHIAKI_CONTROLLER_BUTTON_PS; + break; // KEY_MINUS default: - ret = false; + ret = false; } break; case SDL_JOYBUTTONUP: @@ -506,25 +539,57 @@ bool IO::ReadGameKeys(SDL_Event *event, ChiakiControllerState *state) // event->jbutton.which, event->jbutton.button); switch(event->jbutton.button) { - case 0: state->buttons ^= CHIAKI_CONTROLLER_BUTTON_MOON; break; // KEY_A - case 1: state->buttons ^= CHIAKI_CONTROLLER_BUTTON_CROSS; break; // KEY_B - case 2: state->buttons ^= CHIAKI_CONTROLLER_BUTTON_PYRAMID; break; // KEY_X - case 3: state->buttons ^= CHIAKI_CONTROLLER_BUTTON_BOX; break; // KEY_Y - case 12: state->buttons ^= CHIAKI_CONTROLLER_BUTTON_DPAD_LEFT; break; // KEY_DLEFT - case 14: state->buttons ^= CHIAKI_CONTROLLER_BUTTON_DPAD_RIGHT; break; // KEY_DRIGHT - case 13: state->buttons ^= CHIAKI_CONTROLLER_BUTTON_DPAD_UP; break; // KEY_DUP - case 15: state->buttons ^= CHIAKI_CONTROLLER_BUTTON_DPAD_DOWN; break; // KEY_DDOWN - case 6: state->buttons ^= CHIAKI_CONTROLLER_BUTTON_L1; break; // KEY_L - case 7: state->buttons ^= CHIAKI_CONTROLLER_BUTTON_R1; break; // KEY_R - case 8: state->l2_state = 0x00; break; // KEY_ZL - case 9: state->r2_state = 0x00; break; // KEY_ZR - case 4: state->buttons ^= CHIAKI_CONTROLLER_BUTTON_L3; break; // KEY_LSTICK - case 5: state->buttons ^= CHIAKI_CONTROLLER_BUTTON_R3; break; // KEY_RSTICK - case 10: state->buttons ^= CHIAKI_CONTROLLER_BUTTON_OPTIONS; break; // KEY_PLUS - //case 11: state->buttons ^= CHIAKI_CONTROLLER_BUTTON_SHARE; break; // KEY_MINUS - case 11: state->buttons ^= CHIAKI_CONTROLLER_BUTTON_PS; break; // KEY_MINUS + case 0: + state->buttons ^= CHIAKI_CONTROLLER_BUTTON_MOON; + break; // KEY_A + case 1: + state->buttons ^= CHIAKI_CONTROLLER_BUTTON_CROSS; + break; // KEY_B + case 2: + state->buttons ^= CHIAKI_CONTROLLER_BUTTON_PYRAMID; + break; // KEY_X + case 3: + state->buttons ^= CHIAKI_CONTROLLER_BUTTON_BOX; + break; // KEY_Y + case 12: + state->buttons ^= CHIAKI_CONTROLLER_BUTTON_DPAD_LEFT; + break; // KEY_DLEFT + case 14: + state->buttons ^= CHIAKI_CONTROLLER_BUTTON_DPAD_RIGHT; + break; // KEY_DRIGHT + case 13: + state->buttons ^= CHIAKI_CONTROLLER_BUTTON_DPAD_UP; + break; // KEY_DUP + case 15: + state->buttons ^= CHIAKI_CONTROLLER_BUTTON_DPAD_DOWN; + break; // KEY_DDOWN + case 6: + state->buttons ^= CHIAKI_CONTROLLER_BUTTON_L1; + break; // KEY_L + case 7: + state->buttons ^= CHIAKI_CONTROLLER_BUTTON_R1; + break; // KEY_R + case 8: + state->l2_state = 0x00; + break; // KEY_ZL + case 9: + state->r2_state = 0x00; + break; // KEY_ZR + case 4: + state->buttons ^= CHIAKI_CONTROLLER_BUTTON_L3; + break; // KEY_LSTICK + case 5: + state->buttons ^= CHIAKI_CONTROLLER_BUTTON_R3; + break; // KEY_RSTICK + case 10: + state->buttons ^= CHIAKI_CONTROLLER_BUTTON_OPTIONS; + break; // KEY_PLUS + //case 11: state->buttons ^= CHIAKI_CONTROLLER_BUTTON_SHARE; break; // KEY_MINUS + case 11: + state->buttons ^= CHIAKI_CONTROLLER_BUTTON_PS; + break; // KEY_MINUS default: - ret = false; + ret = false; } break; default: @@ -582,7 +647,7 @@ bool IO::InitOpenGlTextures() D(glGenTextures(PLANES_COUNT, this->tex)); D(glGenBuffers(PLANES_COUNT, this->pbo)); uint8_t uv_default[] = {0x7f, 0x7f}; - for(int i=0; i < PLANES_COUNT; i++) + for(int i = 0; i < PLANES_COUNT; i++) { D(glBindTexture(GL_TEXTURE_2D, this->tex[i])); D(glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)); @@ -595,7 +660,7 @@ bool IO::InitOpenGlTextures() D(glUseProgram(this->prog)); // bind only as many planes as we need const char *plane_names[] = {"plane1", "plane2", "plane3"}; - for(int i=0; i < PLANES_COUNT; i++) + for(int i = 0; i < PLANES_COUNT; i++) D(glUniform1i(glGetUniformLocation(this->prog, plane_names[i]), i)); D(glGenVertexArrays(1, &this->vao)); @@ -615,14 +680,14 @@ bool IO::InitOpenGlTextures() return true; } -GLuint IO::CreateAndCompileShader(GLenum type, const char* source) +GLuint IO::CreateAndCompileShader(GLenum type, const char *source) { GLint success; GLchar msg[512]; GLuint handle; D(handle = glCreateShader(type)); - if (!handle) + if(!handle) { CHIAKI_LOGE(this->log, "%u: cannot create shader", type); DP(this->prog); @@ -632,7 +697,7 @@ GLuint IO::CreateAndCompileShader(GLenum type, const char* source) D(glCompileShader(handle)); D(glGetShaderiv(handle, GL_COMPILE_STATUS, &success)); - if (!success) + if(!success) { D(glGetShaderInfoLog(handle, sizeof(msg), nullptr, msg)); CHIAKI_LOGE(this->log, "%u: %s\n", type, msg); @@ -658,7 +723,7 @@ bool IO::InitOpenGlShader() GLint success; D(glGetProgramiv(this->prog, GL_LINK_STATUS, &success)); - if (!success) + if(!success) { char buf[512]; glGetProgramInfoLog(this->prog, sizeof(buf), nullptr, buf); @@ -672,15 +737,15 @@ bool IO::InitOpenGlShader() return true; } -inline void IO::SetOpenGlYUVPixels(AVFrame * frame) +inline void IO::SetOpenGlYUVPixels(AVFrame *frame) { D(glUseProgram(this->prog)); int planes[][3] = { // { width_divide, height_divider, data_per_pixel } - { 1, 1, 1 }, // Y - { 2, 2, 1 }, // U - { 2, 2, 1 } // V + {1, 1, 1}, // Y + {2, 2, 1}, // U + {2, 2, 1} // V }; this->mtx.lock(); @@ -689,7 +754,7 @@ inline void IO::SetOpenGlYUVPixels(AVFrame * frame) int width = frame->width / planes[i][0]; int height = frame->height / planes[i][1]; int size = width * height * planes[i][2]; - uint8_t * buf; + uint8_t *buf; D(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, this->pbo[i])); D(glBufferData(GL_PIXEL_UNPACK_BUFFER, size, nullptr, GL_STREAM_DRAW)); @@ -700,7 +765,7 @@ inline void IO::SetOpenGlYUVPixels(AVFrame * frame) D(glGetBufferParameteriv(GL_PIXEL_UNPACK_BUFFER, GL_BUFFER_SIZE, &data)); CHIAKI_LOGE(this->log, "AVOpenGLFrame failed to map PBO"); CHIAKI_LOGE(this->log, "Info buf == %p. size %d frame %d * %d, divs %d, %d, pbo %d GL_BUFFER_SIZE %x", - buf, size, frame->width, frame->height, planes[i][0], planes[i][1], pbo[i], data); + buf, size, frame->width, frame->height, planes[i][0], planes[i][1], pbo[i], data); continue; } @@ -712,10 +777,10 @@ inline void IO::SetOpenGlYUVPixels(AVFrame * frame) else { // UV - for(int l=0; ldata[i] + frame->linesize[i] * l, - width * planes[i][2]); + frame->data[i] + frame->linesize[i] * l, + width * planes[i][2]); } D(glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER)); D(glBindTexture(GL_TEXTURE_2D, tex[i])); @@ -736,7 +801,7 @@ inline void IO::OpenGlDraw() //avcodec_flush_buffers(this->codec_context); D(glBindVertexArray(this->vao)); - for(int i=0; i< PLANES_COUNT; i++) + for(int i = 0; i < PLANES_COUNT; i++) { D(glActiveTexture(GL_TEXTURE0 + i)); D(glBindTexture(GL_TEXTURE_2D, this->tex[i])); @@ -753,10 +818,10 @@ bool IO::InitJoystick() // open CONTROLLER_PLAYER_1 and CONTROLLER_PLAYER_2 // when railed, both joycons are mapped to joystick #0, // else joycons are individually mapped to joystick #0, joystick #1, ... - for (int i = 0; i < SDL_JOYSTICK_COUNT; i++) + for(int i = 0; i < SDL_JOYSTICK_COUNT; i++) { this->sdl_joystick_ptr[i] = SDL_JoystickOpen(i); - if (sdl_joystick_ptr[i] == nullptr) + if(sdl_joystick_ptr[i] == nullptr) { CHIAKI_LOGE(this->log, "SDL_JoystickOpen: %s\n", SDL_GetError()); return false; @@ -767,7 +832,7 @@ bool IO::InitJoystick() bool IO::FreeJoystick() { - for (int i = 0; i < SDL_JOYSTICK_COUNT; i++) + for(int i = 0; i < SDL_JOYSTICK_COUNT; i++) { if(SDL_JoystickGetAttached(sdl_joystick_ptr[i])) SDL_JoystickClose(sdl_joystick_ptr[i]); @@ -775,7 +840,7 @@ bool IO::FreeJoystick() return true; } -bool IO::MainLoop(ChiakiControllerState * state) +bool IO::MainLoop(ChiakiControllerState *state) { D(glUseProgram(this->prog)); @@ -798,4 +863,3 @@ bool IO::MainLoop(ChiakiControllerState * state) return !this->quit; } - diff --git a/switch/src/main.cpp b/switch/src/main.cpp index bdba8a8..c12d413 100644 --- a/switch/src/main.cpp +++ b/switch/src/main.cpp @@ -134,9 +134,8 @@ int main(int argc, char * argv[]) } // build sdl OpenGl and AV decoders graphical interface - IO io = IO(log); // open Input Output class DiscoveryManager discoverymanager = DiscoveryManager(); - MainApplication app = MainApplication(&discoverymanager, &io); + MainApplication app = MainApplication(&discoverymanager); app.Load(); CHIAKI_LOGI(log, "Quit applet"); diff --git a/switch/src/settings.cpp b/switch/src/settings.cpp index b1878ca..f0eb3e3 100644 --- a/switch/src/settings.cpp +++ b/switch/src/settings.cpp @@ -6,11 +6,10 @@ Settings::Settings() { -#if defined(__SWITCH__) && !defined(CHIAKI_ENABLE_SWITCH_NXLINK) - // null log for switch version - chiaki_log_init(&this->log, CHIAKI_LOG_ALL ^ CHIAKI_LOG_VERBOSE, chiaki_log_cb_print, NULL); +#if defined(__SWITCH__) + chiaki_log_init(&this->log, CHIAKI_LOG_ALL ^ CHIAKI_LOG_VERBOSE ^ CHIAKI_LOG_DEBUG, chiaki_log_cb_print, NULL); #else - chiaki_log_init(&this->log, CHIAKI_LOG_ALL ^ CHIAKI_LOG_VERBOSE, chiaki_log_cb_print, NULL); + chiaki_log_init(&this->log, CHIAKI_LOG_ALL, chiaki_log_cb_print, NULL); #endif }