mirror of
https://github.com/azahar-emu/azahar.git
synced 2026-06-06 02:33:44 -04:00
288 lines
8.8 KiB
C++
288 lines
8.8 KiB
C++
// Copyright Citra Emulator Project / Azahar Emulator Project
|
|
// Licensed under GPLv2 or any later version
|
|
// Refer to the license.txt file included.
|
|
|
|
#include <cstring>
|
|
|
|
#include "audio_core/audio_types.h"
|
|
#include "audio_core/libretro_sink.h"
|
|
#include "common/scm_rev.h"
|
|
#include "core/3ds.h"
|
|
#include "emu_window/libretro_window.h"
|
|
#include "environment.h"
|
|
|
|
#ifdef HAVE_LIBRETRO_VFS
|
|
#include "streams/file_stream.h"
|
|
#endif
|
|
|
|
using namespace LibRetro;
|
|
|
|
namespace LibRetro {
|
|
|
|
namespace {
|
|
|
|
static retro_video_refresh_t video_cb;
|
|
static retro_audio_sample_batch_t audio_batch_cb;
|
|
static retro_environment_t environ_cb;
|
|
static retro_input_poll_t input_poll_cb;
|
|
static retro_input_state_t input_state_cb;
|
|
|
|
} // namespace
|
|
|
|
bool GetSoftwareFramebuffer(retro_framebuffer* fb, int width, int height) {
|
|
fb->data = nullptr;
|
|
fb->width = width;
|
|
fb->height = height;
|
|
fb->pitch = 0;
|
|
fb->format = RETRO_PIXEL_FORMAT_XRGB8888;
|
|
fb->access_flags = RETRO_MEMORY_ACCESS_WRITE;
|
|
fb->memory_flags = 0;
|
|
return environ_cb(RETRO_ENVIRONMENT_GET_CURRENT_SOFTWARE_FRAMEBUFFER, fb);
|
|
}
|
|
|
|
void UploadVideoFrame(const void* data, unsigned width, unsigned height, size_t pitch) {
|
|
return video_cb(data, width, height, pitch);
|
|
}
|
|
|
|
bool SetHWSharedContext() {
|
|
return environ_cb(RETRO_ENVIRONMENT_SET_HW_SHARED_CONTEXT, NULL);
|
|
}
|
|
|
|
void PollInput() {
|
|
return input_poll_cb();
|
|
}
|
|
|
|
bool GetSensorInterface(struct retro_sensor_interface* sensor_interface) {
|
|
return environ_cb(RETRO_ENVIRONMENT_GET_SENSOR_INTERFACE, sensor_interface);
|
|
}
|
|
|
|
bool GetMicrophoneInterface(struct retro_microphone_interface* mic_interface) {
|
|
return environ_cb(RETRO_ENVIRONMENT_GET_MICROPHONE_INTERFACE, mic_interface);
|
|
}
|
|
|
|
Settings::GraphicsAPI GetPreferredRenderer() {
|
|
// On Android, we really want to default to Vulkan if we can, so we'll ignore the frontend's
|
|
// recommendation if possible...
|
|
#if defined(ANDROID) && defined(ENABLE_VULKAN)
|
|
return Settings::GraphicsAPI::Vulkan;
|
|
#endif
|
|
// ...Otherwise negotiate with the RetroArch frontend as usual
|
|
|
|
// Attempt to use the renderer recommended by the frontend if possible
|
|
retro_hw_context_type context_type = RETRO_HW_CONTEXT_OPENGL;
|
|
environ_cb(RETRO_ENVIRONMENT_GET_PREFERRED_HW_RENDER, &context_type);
|
|
switch (context_type) {
|
|
#ifdef ENABLE_OPENGL
|
|
case RETRO_HW_CONTEXT_OPENGL:
|
|
case RETRO_HW_CONTEXT_OPENGL_CORE:
|
|
case RETRO_HW_CONTEXT_OPENGLES2:
|
|
case RETRO_HW_CONTEXT_OPENGLES3:
|
|
case RETRO_HW_CONTEXT_OPENGLES_VERSION:
|
|
return Settings::GraphicsAPI::OpenGL;
|
|
#endif
|
|
#ifdef ENABLE_VULKAN
|
|
case RETRO_HW_CONTEXT_VULKAN:
|
|
return Settings::GraphicsAPI::Vulkan;
|
|
#endif
|
|
default:
|
|
break;
|
|
}
|
|
// We can't get a recommendation from the frontend, so fall back to whatever's available
|
|
#if defined(ENABLE_VULKAN)
|
|
return Settings::GraphicsAPI::Vulkan;
|
|
#elif defined(ENABLE_OPENGL)
|
|
return Settings::GraphicsAPI::OpenGL;
|
|
#else
|
|
return Settings::GraphicsAPI::Software;
|
|
#endif
|
|
}
|
|
|
|
bool SetVariables(const retro_variable vars[]) {
|
|
return environ_cb(RETRO_ENVIRONMENT_SET_VARIABLES, (void*)vars);
|
|
}
|
|
|
|
bool SetCoreOptionsV2(const retro_core_options_v2* options) {
|
|
return environ_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS_V2, (void*)options);
|
|
}
|
|
|
|
bool SetCoreOptionsV1(const retro_core_option_definition* options) {
|
|
return environ_cb(RETRO_ENVIRONMENT_SET_CORE_OPTIONS, (void*)options);
|
|
}
|
|
|
|
bool GetCoreOptionsVersion(unsigned* version) {
|
|
return environ_cb(RETRO_ENVIRONMENT_GET_CORE_OPTIONS_VERSION, version);
|
|
}
|
|
|
|
bool SetMemoryMaps(const retro_memory_map* map) {
|
|
return environ_cb(RETRO_ENVIRONMENT_SET_MEMORY_MAPS, (void*)map);
|
|
}
|
|
|
|
bool SetControllerInfo(const retro_controller_info info[]) {
|
|
return environ_cb(RETRO_ENVIRONMENT_SET_CONTROLLER_INFO, (void*)info);
|
|
}
|
|
|
|
bool SetPixelFormat(const retro_pixel_format fmt) {
|
|
return environ_cb(RETRO_ENVIRONMENT_SET_PIXEL_FORMAT, (void*)&fmt);
|
|
}
|
|
|
|
bool SetHWRenderer(retro_hw_render_callback* cb) {
|
|
return environ_cb(RETRO_ENVIRONMENT_SET_HW_RENDER, cb);
|
|
}
|
|
|
|
bool GetHWRenderInterface(void** interface) {
|
|
return environ_cb(RETRO_ENVIRONMENT_GET_HW_RENDER_INTERFACE, interface) && !!*interface;
|
|
}
|
|
|
|
bool SetHWRenderContextNegotiationInterface(void** interface) {
|
|
return environ_cb(RETRO_ENVIRONMENT_SET_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE, interface) &&
|
|
!!*interface;
|
|
}
|
|
|
|
bool SetAudioCallback(retro_audio_callback* cb) {
|
|
return environ_cb(RETRO_ENVIRONMENT_SET_AUDIO_CALLBACK, cb);
|
|
}
|
|
|
|
bool SetFrameTimeCallback(retro_frame_time_callback* cb) {
|
|
return environ_cb(RETRO_ENVIRONMENT_SET_FRAME_TIME_CALLBACK, cb);
|
|
}
|
|
|
|
bool SetGeometry(retro_system_av_info* cb) {
|
|
return environ_cb(RETRO_ENVIRONMENT_SET_GEOMETRY, cb);
|
|
}
|
|
|
|
bool SetInputDescriptors(const retro_input_descriptor desc[]) {
|
|
return environ_cb(RETRO_ENVIRONMENT_SET_INPUT_DESCRIPTORS, (void*)desc);
|
|
}
|
|
|
|
bool HasUpdatedConfig() {
|
|
bool updated = false;
|
|
return environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE_UPDATE, &updated) && updated;
|
|
}
|
|
|
|
bool Shutdown() {
|
|
return environ_cb(RETRO_ENVIRONMENT_SHUTDOWN, NULL);
|
|
}
|
|
|
|
/// Displays the specified message to the screen.
|
|
bool DisplayMessage(const char* sg) {
|
|
retro_message msg;
|
|
msg.msg = sg;
|
|
msg.frames = 60 * 10;
|
|
return environ_cb(RETRO_ENVIRONMENT_SET_MESSAGE, &msg);
|
|
}
|
|
|
|
bool SetSerializationQuirks(uint64_t quirks) {
|
|
return environ_cb(RETRO_ENVIRONMENT_SET_SERIALIZATION_QUIRKS, &quirks);
|
|
}
|
|
|
|
std::string FetchVariable(std::string key, std::string def) {
|
|
struct retro_variable var = {nullptr};
|
|
var.key = key.c_str();
|
|
if (!environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) || var.value == nullptr) {
|
|
// Fetching variable failed.
|
|
LOG_ERROR(Frontend, "Fetching variable {} failed.", key);
|
|
return def;
|
|
}
|
|
return std::string(var.value);
|
|
}
|
|
|
|
std::string GetSaveDir() {
|
|
char* var = nullptr;
|
|
if (!environ_cb(RETRO_ENVIRONMENT_GET_SAVE_DIRECTORY, &var) || var == nullptr) {
|
|
// Fetching variable failed.
|
|
LOG_ERROR(Frontend, "No save directory provided by LibRetro.");
|
|
return std::string();
|
|
}
|
|
return std::string(var);
|
|
}
|
|
|
|
std::string GetSystemDir() {
|
|
char* var = nullptr;
|
|
if (!environ_cb(RETRO_ENVIRONMENT_GET_SYSTEM_DIRECTORY, &var) || var == nullptr) {
|
|
// Fetching variable failed.
|
|
LOG_ERROR(Frontend, "No system directory provided by LibRetro.");
|
|
return std::string();
|
|
}
|
|
return std::string(var);
|
|
}
|
|
|
|
retro_log_printf_t GetLoggingBackend() {
|
|
retro_log_callback callback{};
|
|
if (!environ_cb(RETRO_ENVIRONMENT_GET_LOG_INTERFACE, &callback)) {
|
|
return nullptr;
|
|
}
|
|
return callback.log;
|
|
}
|
|
|
|
int16_t CheckInput(unsigned port, unsigned device, unsigned index, unsigned id) {
|
|
return input_state_cb(port, device, index, id);
|
|
}
|
|
|
|
#ifdef HAVE_LIBRETRO_VFS
|
|
void SetVFSCallback(struct retro_vfs_interface_info* vfs_iface_info) {
|
|
if (environ_cb(RETRO_ENVIRONMENT_GET_VFS_INTERFACE, vfs_iface_info))
|
|
filestream_vfs_init(vfs_iface_info);
|
|
}
|
|
#endif
|
|
|
|
#ifdef IOS
|
|
bool CanUseJIT() {
|
|
bool can_jit = false;
|
|
return environ_cb(RETRO_ENVIRONMENT_GET_JIT_CAPABLE, &can_jit) && can_jit;
|
|
}
|
|
#endif
|
|
|
|
}; // namespace LibRetro
|
|
|
|
void retro_get_system_info(struct retro_system_info* info) {
|
|
memset(info, 0, sizeof(*info));
|
|
info->library_name = "Azahar";
|
|
info->library_version = Common::g_build_fullname;
|
|
info->need_fullpath = true;
|
|
info->valid_extensions = "3ds|3dsx|z3dsx|elf|axf|cci|zcci|cxi|zcxi|app";
|
|
}
|
|
|
|
void LibRetro::SubmitAudio(const int16_t* data, size_t frames) {
|
|
audio_batch_cb(data, frames);
|
|
}
|
|
|
|
void retro_set_audio_sample(retro_audio_sample_t cb) {
|
|
// We don't need single audio sample callbacks.
|
|
}
|
|
|
|
void retro_set_audio_sample_batch(retro_audio_sample_batch_t cb) {
|
|
LibRetro::audio_batch_cb = cb;
|
|
}
|
|
|
|
void retro_set_input_poll(retro_input_poll_t cb) {
|
|
LibRetro::input_poll_cb = cb;
|
|
}
|
|
|
|
void retro_set_video_refresh(retro_video_refresh_t cb) {
|
|
LibRetro::video_cb = cb;
|
|
}
|
|
void retro_set_environment(retro_environment_t cb) {
|
|
LibRetro::environ_cb = cb;
|
|
LibRetro::OnConfigureEnvironment();
|
|
}
|
|
|
|
void retro_set_controller_port_device(unsigned port, unsigned device) {}
|
|
|
|
void retro_set_input_state(retro_input_state_t cb) {
|
|
input_state_cb = cb;
|
|
}
|
|
|
|
void retro_get_system_av_info(struct retro_system_av_info* info) {
|
|
info->timing.fps = 60.0;
|
|
info->timing.sample_rate = AudioCore::native_sample_rate;
|
|
|
|
// Compute geometry from current settings so the frontend allocates the
|
|
// correct framebuffer on first use.
|
|
auto geom = ComputeLayoutGeometry();
|
|
info->geometry.base_width = geom.width;
|
|
info->geometry.base_height = geom.height;
|
|
// Max must cover the largest possible layout (SideScreen at 10x = 7200).
|
|
info->geometry.max_width = (Core::kScreenBottomWidth + Core::kScreenTopWidth) * 10;
|
|
info->geometry.max_height = (Core::kScreenTopHeight + Core::kScreenBottomHeight) * 10;
|
|
info->geometry.aspect_ratio = (float)geom.width / (float)geom.height;
|
|
}
|