github/chiaki
1
0
Fork 0
mirror of https://git.sr.ht/~thestr4ng3r/chiaki synced 2025-08-14 10:46:51 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

Refactor IO class as singleton

Browse source
This commit is contained in:
h0neybadger 2020-12-27 15:57:19 +01:00 • committed by Florian Märkl
commit d31fb46ae8
No known key found for this signature in database
GPG key ID: 125BC8A5A6A1E857
8 changed files with 462 additions and 379 deletions
Download patch file Download diff file Expand all files Collapse all files

57
switch/include/gui.h
View file

@ -11,55 +11,55 @@
#include <borealis.hpp>
#include <thread>
#include <map>
#include <thread>
#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<void()> success_cb = nullptr);
static void Register(Host *host, std::function<void()> 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 *, HostInterface *> 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

23
switch/include/host.h
View file

@ -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<void()> chiaki_regist_event_type_finished_canceled = nullptr;
std::function<void()> chiaki_regist_event_type_finished_failed = nullptr;
std::function<void()> chiaki_regist_event_type_finished_success = nullptr;
std::function<void()> chiaki_event_connected_cb = nullptr;
std::function<void(bool)> chiaki_even_login_pin_request_cb = nullptr;
std::function<void(ChiakiQuitEvent *)> 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<void()> chiaki_regist_event_type_finished_canceled);
void SetRegistEventTypeFinishedFailed(std::function<void()> chiaki_regist_event_type_finished_failed);
void SetRegistEventTypeFinishedSuccess(std::function<void()> chiaki_regist_event_type_finished_success);
void SetEventConnectedCallback(std::function<void()> chiaki_event_connected_cb);
void SetEventLoginPinRequestCallback(std::function<void(bool)> chiaki_even_login_pin_request_cb);
void SetEventQuitCallback(std::function<void(ChiakiQuitEvent *)> chiaki_event_quit_cb);
bool IsRegistered();
bool IsDiscovered();
bool IsReady();

68
switch/include/io.h
View file

@ -3,15 +3,14 @@
#ifndef CHIAKI_IO_H
#define CHIAKI_IO_H
#include <functional>
#include <cstdint>
#include <SDL2/SDL.h>
#include <cstdint>
#include <functional>
#include <glad.h> // glad library (OpenGL loader)
#include <chiaki/session.h>
/*
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 <libswscale/swscale.h>
}
#include <chiaki/log.h>
#include <chiaki/controller.h>
#include <chiaki/log.h>
#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<bool()> chiaki_event_connected_cb = nullptr;
std::function<bool(bool)> chiaki_even_login_pin_request_cb = nullptr;
std::function<bool(ChiakiQuitEvent *)> 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<bool()> chiaki_event_connected_cb)
{
this->chiaki_event_connected_cb = chiaki_event_connected_cb;
};
void SetEventLoginPinRequestCallback(std::function<bool(bool)> chiaki_even_login_pin_request_cb)
{
this->chiaki_even_login_pin_request_cb = chiaki_even_login_pin_request_cb;
};
void SetEventQuitCallback(std::function<bool(ChiakiQuitEvent *)> 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

205
switch/src/gui.cpp
View file

@ -1,7 +1,7 @@
// SPDX-License-Identifier: LicenseRef-AGPL-3.0-only-OpenSSL
#include <chiaki/log.h>
#include "gui.h"
#include <chiaki/log.h>
#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<void()> success_cb)
void HostInterface::Register(Host *host, std::function<void()> 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<std::string, Host> * hosts = this->settings->GetHostsMap();
std::map<std::string, Host> *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()
{
}

174
switch/src/host.cpp
View file

@ -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<void()> chiaki_regist
this->chiaki_regist_event_type_finished_success = chiaki_regist_event_type_finished_success;
}
void Host::SetEventConnectedCallback(std::function<void()> chiaki_event_connected_cb)
{
this->chiaki_event_connected_cb = chiaki_event_connected_cb;
}
void Host::SetEventLoginPinRequestCallback(std::function<void(bool)> chiaki_even_login_pin_request_cb)
{
this->chiaki_even_login_pin_request_cb = chiaki_even_login_pin_request_cb;
}
void Host::SetEventQuitCallback(std::function<void(ChiakiQuitEvent *)> chiaki_event_quit_cb)
{
this->chiaki_event_quit_cb = chiaki_event_quit_cb;
}
bool Host::IsRegistered()
{
return this->registered;

304
switch/src/io.cpp
View file

@ -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; l<height; l++)
for(int l = 0; l < height; l++)
memcpy(buf + width * l * planes[i][2],
frame->data[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;
}

3
switch/src/main.cpp
View file

@ -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");

7
switch/src/settings.cpp
View file

@ -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
}