/* RetroArch - A frontend for libretro. * Copyright (C) 2010-2013 - Hans-Kristian Arntzen * * RetroArch is free software: you can redistribute it and/or modify it under the terms * of the GNU General Public License as published by the Free Software Found- * ation, either version 3 of the License, or (at your option) any later version. * * RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR * PURPOSE. See the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along with RetroArch. * If not, see . */ #include "boolean.h" #include "libretro.h" #include #include #include #include #include #include "driver.h" #include "file.h" #include "general.h" #include "dynamic.h" #include "performance.h" #include "audio/utils.h" #include "record/ffemu.h" #include "rewind.h" #include "movie.h" #include "compat/strl.h" #include "screenshot.h" #include "cheats.h" #include "compat/getopt_rarch.h" #include "compat/posix_string.h" #ifdef _WIN32 #ifdef _XBOX #include #else #define WIN32_LEAN_AND_MEAN #include #endif #include "msvc/msvc_compat.h" #endif #if defined(RARCH_CONSOLE) && !defined(RARCH_PERFORMANCE_MODE) #define RARCH_PERFORMANCE_MODE #endif // To avoid continous switching if we hold the button down, we require that the button must go from pressed, // unpressed back to pressed to be able to toggle between then. static void check_fast_forward_button(void) { bool new_button_state = input_key_pressed_func(RARCH_FAST_FORWARD_KEY); bool new_hold_button_state = input_key_pressed_func(RARCH_FAST_FORWARD_HOLD_KEY); static bool old_button_state = false; static bool old_hold_button_state = false; if (new_button_state && !old_button_state) { driver.nonblock_state = !driver.nonblock_state; driver_set_nonblock_state(driver.nonblock_state); } else if (old_hold_button_state != new_hold_button_state) { driver.nonblock_state = new_hold_button_state; driver_set_nonblock_state(driver.nonblock_state); } old_button_state = new_button_state; old_hold_button_state = new_hold_button_state; } #if defined(HAVE_SCREENSHOTS) && !defined(_XBOX) static bool take_screenshot_viewport(void) { struct rarch_viewport vp = {0}; video_viewport_info_func(&vp); if (!vp.width || !vp.height) return false; uint8_t *buffer = (uint8_t*)malloc(vp.width * vp.height * 3); if (!buffer) return false; if (!video_read_viewport_func(buffer)) { free(buffer); return false; } // Data read from viewport is in bottom-up order, suitable for BMP. if (!screenshot_dump(g_settings.screenshot_directory, buffer, vp.width, vp.height, vp.width * 3, true)) { free(buffer); return false; } free(buffer); return true; } static bool take_screenshot_raw(void) { const uint16_t *data = (const uint16_t*)g_extern.frame_cache.data; unsigned width = g_extern.frame_cache.width; unsigned height = g_extern.frame_cache.height; int pitch = g_extern.frame_cache.pitch; // Negative pitch is needed as screenshot takes bottom-up, // but we use top-down. return screenshot_dump(g_settings.screenshot_directory, data + (height - 1) * (pitch >> 1), width, height, -pitch, false); } static void take_screenshot(void) { if (!(*g_settings.screenshot_directory)) return; bool ret = false; if (g_extern.frame_cache.data) { if ((g_settings.video.gpu_screenshot || (g_extern.frame_cache.data == RETRO_HW_FRAME_BUFFER_VALID)) && driver.video->read_viewport && driver.video->viewport_info) ret = take_screenshot_viewport(); else if (g_extern.frame_cache.data && (g_extern.frame_cache.data != RETRO_HW_FRAME_BUFFER_VALID)) ret = take_screenshot_raw(); else RARCH_ERR("Cannot take screenshot. GPU rendering is used and read_viewport is not supported.\n"); } const char *msg = NULL; if (ret) { RARCH_LOG("Taking screenshot.\n"); msg = "Taking screenshot."; } else { RARCH_WARN("Failed to take screenshot ...\n"); msg = "Failed to take screenshot."; } msg_queue_clear(g_extern.msg_queue); if (g_extern.is_paused) { msg_queue_push(g_extern.msg_queue, msg, 1, 1); rarch_render_cached_frame(); } else msg_queue_push(g_extern.msg_queue, msg, 1, 180); } #endif static void readjust_audio_input_rate(void) { int avail = audio_write_avail_func(); //RARCH_LOG_OUTPUT("Audio buffer is %u%% full\n", // (unsigned)(100 - (avail * 100) / g_extern.audio_data.driver_buffer_size)); unsigned write_index = g_extern.measure_data.buffer_free_samples_count++ & (AUDIO_BUFFER_FREE_SAMPLES_COUNT - 1); g_extern.measure_data.buffer_free_samples[write_index] = avail; int half_size = g_extern.audio_data.driver_buffer_size / 2; int delta_mid = avail - half_size; double direction = (double)delta_mid / half_size; double adjust = 1.0 + g_settings.audio.rate_control_delta * direction; g_extern.audio_data.src_ratio = g_extern.audio_data.orig_src_ratio * adjust; //RARCH_LOG_OUTPUT("New rate: %lf, Orig rate: %lf\n", // g_extern.audio_data.src_ratio, g_extern.audio_data.orig_src_ratio); } #ifdef HAVE_FFMPEG static void deinit_recording(void); static void recording_dump_frame(const void *data, unsigned width, unsigned height, size_t pitch) { struct ffemu_video_data ffemu_data = {0}; if (g_extern.record_gpu_buffer) { struct rarch_viewport vp = {0}; video_viewport_info_func(&vp); if (!vp.width || !vp.height) { RARCH_WARN("Viewport size calculation failed! Will continue using raw data. This will probably not work right ...\n"); free(g_extern.record_gpu_buffer); g_extern.record_gpu_buffer = NULL; recording_dump_frame(data, width, height, pitch); return; } // User has resized. We're kinda fucked now. if (vp.width != g_extern.record_gpu_width || vp.height != g_extern.record_gpu_height) { static const char msg[] = "Recording terminated due to resize."; RARCH_WARN("%s\n", msg); msg_queue_clear(g_extern.msg_queue); msg_queue_push(g_extern.msg_queue, msg, 1, 180); deinit_recording(); g_extern.recording = false; return; } // Big bottleneck. // Since we might need to do read-backs asynchronously, it might take 3-4 times // before this returns true ... if (!video_read_viewport_func(g_extern.record_gpu_buffer)) return; ffemu_data.pitch = g_extern.record_gpu_width * 3; ffemu_data.width = g_extern.record_gpu_width; ffemu_data.height = g_extern.record_gpu_height; ffemu_data.data = g_extern.record_gpu_buffer + (ffemu_data.height - 1) * ffemu_data.pitch; ffemu_data.pitch = -ffemu_data.pitch; } else { ffemu_data.data = data; ffemu_data.pitch = pitch; ffemu_data.width = width; ffemu_data.height = height; ffemu_data.is_dupe = !data; } ffemu_push_video(g_extern.rec, &ffemu_data); } #endif static void video_frame(const void *data, unsigned width, unsigned height, size_t pitch) { if (!g_extern.video_active) return; if (g_extern.system.pix_fmt == RETRO_PIXEL_FORMAT_0RGB1555 && data) { RARCH_PERFORMANCE_INIT(video_frame_conv); RARCH_PERFORMANCE_START(video_frame_conv); driver.scaler.in_width = width; driver.scaler.in_height = height; driver.scaler.out_width = width; driver.scaler.out_height = height; driver.scaler.in_stride = pitch; driver.scaler.out_stride = width * sizeof(uint16_t); scaler_ctx_scale(&driver.scaler, driver.scaler_out, data); data = driver.scaler_out; pitch = driver.scaler.out_stride; RARCH_PERFORMANCE_STOP(video_frame_conv); } // Slightly messy code, // but we really need to do processing before blocking on VSync for best possible scheduling. #ifdef HAVE_FFMPEG if (g_extern.recording && (!g_extern.filter.active || !g_settings.video.post_filter_record || !data || g_extern.record_gpu_buffer)) recording_dump_frame(data, width, height, pitch); #endif const char *msg = msg_queue_pull(g_extern.msg_queue); driver.current_msg = msg; #ifdef HAVE_DYLIB if (g_extern.filter.active && data) { struct scaler_ctx *scaler = &g_extern.filter.scaler; scaler->in_width = scaler->out_width = width; scaler->in_height = scaler->out_height = height; scaler->in_stride = pitch; scaler->out_stride = width * sizeof(uint16_t); scaler_ctx_scale(scaler, g_extern.filter.scaler_out, data); unsigned owidth = width; unsigned oheight = height; g_extern.filter.psize(&owidth, &oheight); g_extern.filter.prender(g_extern.filter.colormap, g_extern.filter.buffer, g_extern.filter.pitch, g_extern.filter.scaler_out, scaler->out_stride, width, height); #ifdef HAVE_FFMPEG if (g_extern.recording && g_settings.video.post_filter_record) recording_dump_frame(g_extern.filter.buffer, owidth, oheight, g_extern.filter.pitch); #endif if (!video_frame_func(g_extern.filter.buffer, owidth, oheight, g_extern.filter.pitch, msg)) g_extern.video_active = false; } else if (!video_frame_func(data, width, height, pitch, msg)) g_extern.video_active = false; #else if (!video_frame_func(data, width, height, pitch, msg)) g_extern.video_active = false; #endif g_extern.frame_cache.data = data; g_extern.frame_cache.width = width; g_extern.frame_cache.height = height; g_extern.frame_cache.pitch = pitch; } void rarch_render_cached_frame(void) { #ifdef HAVE_FFMPEG // Cannot allow FFmpeg recording when pushing duped frames. bool recording = g_extern.recording; g_extern.recording = false; #endif const void *frame = g_extern.frame_cache.data; if (frame == RETRO_HW_FRAME_BUFFER_VALID) frame = NULL; // Dupe // Not 100% safe, since the library might have // freed the memory, but no known implementations do this :D // It would be really stupid at any rate ... video_frame(frame, g_extern.frame_cache.width, g_extern.frame_cache.height, g_extern.frame_cache.pitch); #ifdef HAVE_FFMPEG g_extern.recording = recording; #endif } static bool audio_flush(const int16_t *data, size_t samples) { #ifdef HAVE_FFMPEG if (g_extern.recording) { struct ffemu_audio_data ffemu_data = {0}; ffemu_data.data = data; ffemu_data.frames = samples / 2; ffemu_push_audio(g_extern.rec, &ffemu_data); } #endif if (g_extern.is_paused || g_extern.audio_data.mute) return true; if (!g_extern.audio_active) return false; const float *output_data = NULL; unsigned output_frames = 0; struct resampler_data src_data = {0}; RARCH_PERFORMANCE_INIT(audio_convert_s16); RARCH_PERFORMANCE_START(audio_convert_s16); audio_convert_s16_to_float(g_extern.audio_data.data, data, samples, g_extern.audio_data.volume_gain); RARCH_PERFORMANCE_STOP(audio_convert_s16); #if defined(HAVE_DYLIB) rarch_dsp_output_t dsp_output = {0}; rarch_dsp_input_t dsp_input = {0}; dsp_input.samples = g_extern.audio_data.data; dsp_input.frames = samples >> 1; if (g_extern.audio_data.dsp_plugin) g_extern.audio_data.dsp_plugin->process(g_extern.audio_data.dsp_handle, &dsp_output, &dsp_input); src_data.data_in = dsp_output.samples ? dsp_output.samples : g_extern.audio_data.data; src_data.input_frames = dsp_output.samples ? dsp_output.frames : (samples >> 1); #else src_data.data_in = g_extern.audio_data.data; src_data.input_frames = samples >> 1; #endif src_data.data_out = g_extern.audio_data.outsamples; if (g_extern.audio_data.rate_control) readjust_audio_input_rate(); src_data.ratio = g_extern.audio_data.src_ratio; if (g_extern.is_slowmotion) src_data.ratio *= g_settings.slowmotion_ratio; RARCH_PERFORMANCE_INIT(resampler_proc); RARCH_PERFORMANCE_START(resampler_proc); rarch_resampler_process(g_extern.audio_data.resampler, g_extern.audio_data.resampler_data, &src_data); RARCH_PERFORMANCE_STOP(resampler_proc); output_data = g_extern.audio_data.outsamples; output_frames = src_data.output_frames; if (g_extern.audio_data.use_float) { if (audio_write_func(output_data, output_frames * sizeof(float) * 2) < 0) { RARCH_ERR("Audio backend failed to write. Will continue without sound.\n"); return false; } } else { RARCH_PERFORMANCE_INIT(audio_convert_float); RARCH_PERFORMANCE_START(audio_convert_float); audio_convert_float_to_s16(g_extern.audio_data.conv_outsamples, output_data, output_frames * 2); RARCH_PERFORMANCE_STOP(audio_convert_float); if (audio_write_func(g_extern.audio_data.conv_outsamples, output_frames * sizeof(int16_t) * 2) < 0) { RARCH_ERR("Audio backend failed to write. Will continue without sound.\n"); return false; } } return true; } static void audio_sample_rewind(int16_t left, int16_t right) { g_extern.audio_data.rewind_buf[--g_extern.audio_data.rewind_ptr] = right; g_extern.audio_data.rewind_buf[--g_extern.audio_data.rewind_ptr] = left; } size_t audio_sample_batch_rewind(const int16_t *data, size_t frames) { size_t samples = frames << 1; for (size_t i = 0; i < samples; i++) g_extern.audio_data.rewind_buf[--g_extern.audio_data.rewind_ptr] = data[i]; return frames; } static void audio_sample(int16_t left, int16_t right) { g_extern.audio_data.conv_outsamples[g_extern.audio_data.data_ptr++] = left; g_extern.audio_data.conv_outsamples[g_extern.audio_data.data_ptr++] = right; if (g_extern.audio_data.data_ptr < g_extern.audio_data.chunk_size) return; g_extern.audio_active = audio_flush(g_extern.audio_data.conv_outsamples, g_extern.audio_data.data_ptr) && g_extern.audio_active; g_extern.audio_data.data_ptr = 0; } size_t audio_sample_batch(const int16_t *data, size_t frames) { if (frames > (AUDIO_CHUNK_SIZE_NONBLOCKING >> 1)) frames = AUDIO_CHUNK_SIZE_NONBLOCKING >> 1; g_extern.audio_active = audio_flush(data, frames << 1) && g_extern.audio_active; return frames; } #ifdef HAVE_OVERLAY static inline void input_poll_overlay(void) { driver.overlay_state = 0; unsigned device = input_overlay_full_screen(driver.overlay) ? RARCH_DEVICE_POINTER_SCREEN : RETRO_DEVICE_POINTER; bool polled = false; for (unsigned i = 0; input_input_state_func(NULL, 0, device, i, RETRO_DEVICE_ID_POINTER_PRESSED); i++) { int16_t x = input_input_state_func(NULL, 0, device, i, RETRO_DEVICE_ID_POINTER_X); int16_t y = input_input_state_func(NULL, 0, device, i, RETRO_DEVICE_ID_POINTER_Y); driver.overlay_state |= input_overlay_poll(driver.overlay, x, y); polled = true; } if (!polled) input_overlay_poll_clear(driver.overlay); } #endif void rarch_input_poll(void) { input_poll_func(); #ifdef HAVE_OVERLAY if (driver.overlay) // Poll overlay state input_poll_overlay(); #endif } // Turbo scheme: If turbo button is held, all buttons pressed except for D-pad will go into // a turbo mode. Until the button is released again, the input state will be modulated by a periodic pulse defined // by the configured duty cycle. static bool input_apply_turbo(unsigned port, unsigned id, bool res) { if (res && g_extern.turbo_frame_enable[port]) g_extern.turbo_enable[port] |= (1 << id); else if (!res) g_extern.turbo_enable[port] &= ~(1 << id); if (g_extern.turbo_enable[port] & (1 << id)) return res & ((g_extern.turbo_count % g_settings.input.turbo_period) < g_settings.input.turbo_duty_cycle); else return res; } static int16_t input_state(unsigned port, unsigned device, unsigned index, unsigned id) { device &= RETRO_DEVICE_MASK; #ifdef HAVE_BSV_MOVIE if (g_extern.bsv.movie && g_extern.bsv.movie_playback) { int16_t ret; if (bsv_movie_get_input(g_extern.bsv.movie, &ret)) return ret; else g_extern.bsv.movie_end = true; } #endif static const struct retro_keybind *binds[MAX_PLAYERS] = { g_settings.input.binds[0], g_settings.input.binds[1], g_settings.input.binds[2], g_settings.input.binds[3], g_settings.input.binds[4], g_settings.input.binds[5], g_settings.input.binds[6], g_settings.input.binds[7], }; int16_t res = 0; if (id < RARCH_FIRST_META_KEY || device == RETRO_DEVICE_KEYBOARD) res = input_input_state_func(binds, port, device, index, id); #ifdef HAVE_OVERLAY if (device == RETRO_DEVICE_JOYPAD && port == 0) res |= driver.overlay_state & (UINT64_C(1) << id) ? 1 : 0; #endif // Don't allow turbo for D-pad. if (device == RETRO_DEVICE_JOYPAD && (id < RETRO_DEVICE_ID_JOYPAD_UP || id > RETRO_DEVICE_ID_JOYPAD_RIGHT)) res = input_apply_turbo(port, id, res); #ifdef HAVE_BSV_MOVIE if (g_extern.bsv.movie && !g_extern.bsv.movie_playback) bsv_movie_set_input(g_extern.bsv.movie, res); #endif return res; } #ifdef _WIN32 #define RARCH_DEFAULT_CONF_PATH_STR "\n\t\tDefaults to retroarch.cfg in same directory as retroarch.exe." #else #define RARCH_DEFAULT_CONF_PATH_STR "\n\t\tBy default looks for config in $XDG_CONFIG_HOME/retroarch/retroarch.cfg,\n\t\t$HOME/.config/retroarch/retroarch.cfg,\n\t\tand $HOME/.retroarch.cfg." #endif #include "config.features.h" #define _PSUPP(var, name, desc) printf("\t%s:\n\t\t%s: %s\n", name, desc, _##var##_supp ? "yes" : "no") static void print_features(void) { puts(""); puts("Features:"); _PSUPP(sdl, "SDL", "SDL drivers"); _PSUPP(thread, "Threads", "Threading support"); _PSUPP(opengl, "OpenGL", "OpenGL driver"); _PSUPP(kms, "KMS", "KMS/EGL context support"); _PSUPP(egl, "EGL", "EGL context support"); _PSUPP(vg, "OpenVG", "OpenVG output support"); _PSUPP(xvideo, "XVideo", "XVideo output"); _PSUPP(alsa, "ALSA", "audio driver"); _PSUPP(oss, "OSS", "audio driver"); _PSUPP(jack, "Jack", "audio driver"); _PSUPP(rsound, "RSound", "audio driver"); _PSUPP(roar, "RoarAudio", "audio driver"); _PSUPP(pulse, "PulseAudio", "audio driver"); _PSUPP(dsound, "DirectSound", "audio driver"); _PSUPP(xaudio, "XAudio2", "audio driver"); _PSUPP(zlib, "zlib", "PNG encode/decode and .zip extraction"); _PSUPP(al, "OpenAL", "audio driver"); _PSUPP(dylib, "External", "External filter and plugin support"); _PSUPP(cg, "Cg", "Cg pixel shaders"); _PSUPP(libxml2, "libxml2", "libxml2 XML parsing"); _PSUPP(sdl_image, "SDL_image", "SDL_image image loading"); _PSUPP(fbo, "FBO", "OpenGL render-to-texture (multi-pass shaders)"); _PSUPP(dynamic, "Dynamic", "Dynamic run-time loading of libretro library"); _PSUPP(ffmpeg, "FFmpeg", "On-the-fly recording of gameplay with libavcodec"); _PSUPP(freetype, "FreeType", "TTF font rendering with FreeType"); _PSUPP(netplay, "Netplay", "Peer-to-peer netplay"); _PSUPP(python, "Python", "Script support in shaders"); } #undef _PSUPP static void print_compiler(FILE *file) { fprintf(file, "\nCompiler: "); #if defined(_MSC_VER) fprintf(file, "MSVC (%d) %u-bit\n", _MSC_VER, (unsigned)(CHAR_BIT * sizeof(size_t))); #elif defined(__SNC__) fprintf(file, "SNC (%d) %u-bit\n", __SN_VER__, (unsigned)(CHAR_BIT * sizeof(size_t))); #elif defined(_WIN32) && defined(__GNUC__) fprintf(file, "MinGW (%d.%d.%d) %u-bit\n", __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__, (unsigned)(CHAR_BIT * sizeof(size_t))); #elif defined(__clang__) fprintf(file, "Clang/LLVM (%s) %u-bit\n", __VERSION__, (unsigned)(CHAR_BIT * sizeof(size_t))); #elif defined(__GNUC__) fprintf(file, "GCC (%d.%d.%d) %u-bit\n", __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__, (unsigned)(CHAR_BIT * sizeof(size_t))); #else fprintf(file, "Unknown compiler %u-bit\n", (unsigned)(CHAR_BIT * sizeof(size_t))); #endif fprintf(file, "Built: %s\n", __DATE__); } static void print_help(void) { puts("==================================================================="); #if !defined(__BLACKBERRY_QNX__) && !defined(IOS) /* To get around error 'too many decimal points in number - expected ')' before numeric constant */ puts("RetroArch: Frontend for libretro -- v" PACKAGE_VERSION " --"); #endif print_compiler(stdout); puts("==================================================================="); puts("Usage: retroarch [rom file] [options...]"); puts("\t-h/--help: Show this help message."); puts("\t--menu: Do not require ROM or libretro core to be loaded, starts directly in menu."); puts("\t\tIf no arguments are passed to RetroArch, it is equivalent to using --menu as only argument."); puts("\t--features: Prints available features compiled into RetroArch."); puts("\t-s/--save: Path for save file (*.srm). Required when rom is input from stdin."); puts("\t-f/--fullscreen: Start RetroArch in fullscreen regardless of config settings."); puts("\t-S/--savestate: Path to use for save states. If not selected, *.state will be assumed."); puts("\t-c/--config: Path for config file." RARCH_DEFAULT_CONF_PATH_STR); puts("\t--appendconfig: Extra config files are loaded in, and take priority over config selected in -c (or default)."); puts("\t\tMultiple configs are delimited by ','."); #ifdef HAVE_DYNAMIC puts("\t-L/--libretro: Path to libretro implementation. Overrides any config setting."); #endif puts("\t-g/--gameboy: Path to Gameboy ROM. Load SuperGameBoy as the regular rom."); puts("\t-b/--bsx: Path to BSX rom. Load BSX BIOS as the regular rom."); puts("\t-B/--bsxslot: Path to BSX slotted rom. Load BSX BIOS as the regular rom."); puts("\t--sufamiA: Path to A slot of Sufami Turbo. Load Sufami base cart as regular rom."); puts("\t--sufamiB: Path to B slot of Sufami Turbo."); printf("\t-N/--nodevice: Disconnects controller device connected to port (1 to %d).\n", MAX_PLAYERS); printf("\t-A/--dualanalog: Connect a DualAnalog controller to port (1 to %d).\n", MAX_PLAYERS); printf("\t-m/--mouse: Connect a mouse into port of the device (1 to %d).\n", MAX_PLAYERS); puts("\t-p/--scope: Connect a virtual SuperScope into port 2. (SNES specific)."); puts("\t-j/--justifier: Connect a virtual Konami Justifier into port 2. (SNES specific)."); puts("\t-J/--justifiers: Daisy chain two virtual Konami Justifiers into port 2. (SNES specific)."); puts("\t-4/--multitap: Connect a SNES multitap to port 2. (SNES specific)."); #ifdef HAVE_BSV_MOVIE puts("\t-P/--bsvplay: Playback a BSV movie file."); puts("\t-R/--bsvrecord: Start recording a BSV movie file from the beginning."); puts("\t-M/--sram-mode: Takes an argument telling how SRAM should be handled in the session."); #endif puts("\t\t{no,}load-{no,}save describes if SRAM should be loaded, and if SRAM should be saved."); puts("\t\tDo note that noload-save implies that save files will be deleted and overwritten."); #ifdef HAVE_NETPLAY puts("\t-H/--host: Host netplay as player 1."); puts("\t-C/--connect: Connect to netplay as player 2."); puts("\t--port: Port used to netplay. Default is 55435."); puts("\t-F/--frames: Sync frames when using netplay."); puts("\t--spectate: Netplay will become spectating mode."); puts("\t\tHost can live stream the game content to players that connect."); puts("\t\tHowever, the client will not be able to play. Multiple clients can connect to the host."); puts("\t--nick: Picks a nickname for use with netplay. Not mandatory."); #endif #ifdef HAVE_NETWORK_CMD puts("\t--command: Sends a command over UDP to an already running RetroArch process."); puts("\t\tAvailable commands are listed if command is invalid."); #endif #ifdef HAVE_FFMPEG puts("\t-r/--record: Path to record video file.\n\t\tUsing .mkv extension is recommended."); puts("\t--recordconfig: Path to settings used during recording."); puts("\t--size: Overrides output video size when recording with FFmpeg (format: WIDTHxHEIGHT)."); #endif puts("\t-v/--verbose: Verbose logging."); puts("\t-U/--ups: Specifies path for UPS patch that will be applied to ROM."); puts("\t--bps: Specifies path for BPS patch that will be applied to ROM."); puts("\t--ips: Specifies path for IPS patch that will be applied to ROM."); puts("\t--no-patch: Disables all forms of rom patching."); puts("\t-X/--xml: Specifies path to XML memory map."); puts("\t-D/--detach: Detach RetroArch from the running console. Not relevant for all platforms.\n"); } static void set_basename(const char *path) { strlcpy(g_extern.fullpath, path, sizeof(g_extern.fullpath)); strlcpy(g_extern.basename, path, sizeof(g_extern.basename)); char *dst = strrchr(g_extern.basename, '.'); if (dst) *dst = '\0'; } static void set_paths(const char *path) { set_basename(path); if (!g_extern.has_set_save_path) fill_pathname_noext(g_extern.savefile_name_srm, g_extern.basename, ".srm", sizeof(g_extern.savefile_name_srm)); if (!g_extern.has_set_state_path) fill_pathname_noext(g_extern.savestate_name, g_extern.basename, ".state", sizeof(g_extern.savestate_name)); if (path_is_directory(g_extern.savefile_name_srm)) { fill_pathname_dir(g_extern.savefile_name_srm, g_extern.basename, ".srm", sizeof(g_extern.savefile_name_srm)); RARCH_LOG("Redirecting save file to \"%s\".\n", g_extern.savefile_name_srm); } if (path_is_directory(g_extern.savestate_name)) { fill_pathname_dir(g_extern.savestate_name, g_extern.basename, ".state", sizeof(g_extern.savestate_name)); RARCH_LOG("Redirecting save state to \"%s\".\n", g_extern.savestate_name); } // If this is already set, // do not overwrite it as this was initialized before in a menu or otherwise. if (!*g_settings.system_directory) fill_pathname_basedir(g_settings.system_directory, path, sizeof(g_settings.system_directory)); if (*g_extern.config_path && path_is_directory(g_extern.config_path)) { fill_pathname_dir(g_extern.config_path, g_extern.basename, ".cfg", sizeof(g_extern.config_path)); RARCH_LOG("Redirecting config file to \"%s\".\n", g_extern.config_path); if (!path_file_exists(g_extern.config_path)) { *g_extern.config_path = '\0'; RARCH_LOG("Did not find config file. Using system default.\n"); } } } static void verify_stdin_paths(void) { if (!*g_extern.savefile_name_srm) { RARCH_ERR("Need savefile path argument (--save) when reading rom from stdin.\n"); print_help(); rarch_fail(1, "verify_stdin_paths()"); } else if (!*g_extern.savestate_name) { RARCH_ERR("Need savestate path argument (--savestate) when reading rom from stdin.\n"); print_help(); rarch_fail(1, "verify_stdin_paths()"); } if (path_is_directory(g_extern.savefile_name_srm)) { RARCH_ERR("Cannot specify directory for path argument (--save) when reading from stdin.\n"); print_help(); rarch_fail(1, "verify_stdin_paths()"); } else if (path_is_directory(g_extern.savestate_name)) { RARCH_ERR("Cannot specify directory for path argument (--savestate) when reading from stdin.\n"); print_help(); rarch_fail(1, "verify_stdin_paths()"); } else if (path_is_directory(g_extern.config_path)) { RARCH_ERR("Cannot specify directory for config file (--config) when reading from stdin.\n"); print_help(); rarch_fail(1, "verify_stdin_paths()"); } driver.stdin_claimed = true; } static void parse_input(int argc, char *argv[]) { if (argc < 2) { g_extern.libretro_dummy = true; return; } g_extern.libretro_dummy = false; // Make sure we can call parse_input several times ... optind = 1; int val = 0; const struct option opts[] = { #ifdef HAVE_DYNAMIC { "libretro", 1, NULL, 'L' }, #endif { "menu", 0, &val, 'M' }, { "help", 0, NULL, 'h' }, { "save", 1, NULL, 's' }, { "fullscreen", 0, NULL, 'f' }, #ifdef HAVE_FFMPEG { "record", 1, NULL, 'r' }, { "recordconfig", 1, &val, 'R' }, { "size", 1, &val, 's' }, #endif { "verbose", 0, NULL, 'v' }, { "gameboy", 1, NULL, 'g' }, { "config", 1, NULL, 'c' }, { "appendconfig", 1, &val, 'C' }, { "mouse", 1, NULL, 'm' }, { "nodevice", 1, NULL, 'N' }, { "scope", 0, NULL, 'p' }, { "justifier", 0, NULL, 'j' }, { "justifiers", 0, NULL, 'J' }, { "dualanalog", 1, NULL, 'A' }, { "savestate", 1, NULL, 'S' }, { "bsx", 1, NULL, 'b' }, { "bsxslot", 1, NULL, 'B' }, { "multitap", 0, NULL, '4' }, { "sufamiA", 1, NULL, 'Y' }, { "sufamiB", 1, NULL, 'Z' }, #ifdef HAVE_BSV_MOVIE { "bsvplay", 1, NULL, 'P' }, { "bsvrecord", 1, NULL, 'R' }, { "sram-mode", 1, NULL, 'M' }, #endif #ifdef HAVE_NETPLAY { "host", 0, NULL, 'H' }, { "connect", 1, NULL, 'C' }, { "frames", 1, NULL, 'F' }, { "port", 1, &val, 'p' }, { "spectate", 0, &val, 'S' }, { "nick", 1, &val, 'N' }, #endif #ifdef HAVE_NETWORK_CMD { "command", 1, &val, 'c' }, #endif { "ups", 1, NULL, 'U' }, { "bps", 1, &val, 'B' }, { "ips", 1, &val, 'I' }, { "no-patch", 0, &val, 'n' }, { "xml", 1, NULL, 'X' }, { "detach", 0, NULL, 'D' }, { "features", 0, &val, 'f' }, { NULL, 0, NULL, 0 } }; #ifdef HAVE_FFMPEG #define FFMPEG_RECORD_ARG "r:" #else #define FFMPEG_RECORD_ARG #endif #ifdef HAVE_DYNAMIC #define DYNAMIC_ARG "L:" #else #define DYNAMIC_ARG #endif #ifdef HAVE_NETPLAY #define NETPLAY_ARG "HC:F:" #else #define NETPLAY_ARG #endif #ifdef HAVE_BSV_MOVIE #define BSV_MOVIE_ARG "P:R:M:" #else #define BSV_MOVIE_ARG #endif const char *optstring = "hs:fvS:m:p4jJA:g:b:c:B:Y:Z:U:DN:X:" BSV_MOVIE_ARG NETPLAY_ARG DYNAMIC_ARG FFMPEG_RECORD_ARG; #ifdef RARCH_CONSOLE // hack - done for reentrancy reasons g_extern.has_set_save_path = false; g_extern.has_set_state_path = false; #endif for (;;) { val = 0; int c = getopt_long(argc, argv, optstring, opts, NULL); int port; if (c == -1) break; switch (c) { case 'h': print_help(); exit(0); case '4': g_extern.has_multitap = true; break; case 'j': g_extern.has_justifier = true; break; case 'J': g_extern.has_justifiers = true; break; case 'A': port = strtol(optarg, NULL, 0); if (port < 1 || port > MAX_PLAYERS) { RARCH_ERR("Connect dualanalog to a valid port.\n"); print_help(); rarch_fail(1, "parse_input()"); } g_extern.has_dualanalog[port - 1] = true; break; case 's': strlcpy(g_extern.savefile_name_srm, optarg, sizeof(g_extern.savefile_name_srm)); g_extern.has_set_save_path = true; break; case 'f': g_extern.force_fullscreen = true; break; case 'g': strlcpy(g_extern.gb_rom_path, optarg, sizeof(g_extern.gb_rom_path)); g_extern.game_type = RARCH_CART_SGB; break; case 'b': strlcpy(g_extern.bsx_rom_path, optarg, sizeof(g_extern.bsx_rom_path)); g_extern.game_type = RARCH_CART_BSX; break; case 'B': strlcpy(g_extern.bsx_rom_path, optarg, sizeof(g_extern.bsx_rom_path)); g_extern.game_type = RARCH_CART_BSX_SLOTTED; break; case 'Y': strlcpy(g_extern.sufami_rom_path[0], optarg, sizeof(g_extern.sufami_rom_path[0])); g_extern.game_type = RARCH_CART_SUFAMI; break; case 'Z': strlcpy(g_extern.sufami_rom_path[1], optarg, sizeof(g_extern.sufami_rom_path[1])); g_extern.game_type = RARCH_CART_SUFAMI; break; case 'S': strlcpy(g_extern.savestate_name, optarg, sizeof(g_extern.savestate_name)); g_extern.has_set_state_path = true; break; case 'v': g_extern.verbose = true; break; case 'm': port = strtol(optarg, NULL, 0); if (port < 1 || port > MAX_PLAYERS) { RARCH_ERR("Connect mouse to a valid port.\n"); print_help(); rarch_fail(1, "parse_input()"); } g_extern.has_mouse[port - 1] = true; break; case 'N': port = strtol(optarg, NULL, 0); if (port < 1 || port > MAX_PLAYERS) { RARCH_ERR("Disconnect device from a valid port.\n"); print_help(); rarch_fail(1, "parse_input()"); } g_extern.disconnect_device[port - 1] = true; break; case 'p': g_extern.has_scope = true; break; case 'c': strlcpy(g_extern.config_path, optarg, sizeof(g_extern.config_path)); break; #ifdef HAVE_FFMPEG case 'r': strlcpy(g_extern.record_path, optarg, sizeof(g_extern.record_path)); g_extern.recording = true; break; #endif #ifdef HAVE_DYNAMIC case 'L': strlcpy(g_settings.libretro, optarg, sizeof(g_settings.libretro)); break; #endif #ifdef HAVE_BSV_MOVIE case 'P': case 'R': strlcpy(g_extern.bsv.movie_start_path, optarg, sizeof(g_extern.bsv.movie_start_path)); g_extern.bsv.movie_start_playback = c == 'P'; g_extern.bsv.movie_start_recording = c == 'R'; break; case 'M': if (strcmp(optarg, "noload-nosave") == 0) { g_extern.sram_load_disable = true; g_extern.sram_save_disable = true; } else if (strcmp(optarg, "noload-save") == 0) g_extern.sram_load_disable = true; else if (strcmp(optarg, "load-nosave") == 0) g_extern.sram_save_disable = true; else if (strcmp(optarg, "load-save") != 0) { RARCH_ERR("Invalid argument in --sram-mode.\n"); print_help(); rarch_fail(1, "parse_input()"); } break; #endif #ifdef HAVE_NETPLAY case 'H': g_extern.netplay_enable = true; break; case 'C': g_extern.netplay_enable = true; strlcpy(g_extern.netplay_server, optarg, sizeof(g_extern.netplay_server)); break; case 'F': g_extern.netplay_sync_frames = strtol(optarg, NULL, 0); break; #endif case 'U': strlcpy(g_extern.ups_name, optarg, sizeof(g_extern.ups_name)); g_extern.ups_pref = true; break; case 'X': strlcpy(g_extern.xml_name, optarg, sizeof(g_extern.xml_name)); break; case 'D': #if defined(_WIN32) && !defined(_XBOX) FreeConsole(); #endif break; case 0: switch (val) { case 'M': g_extern.libretro_dummy = true; break; #ifdef HAVE_NETPLAY case 'p': g_extern.netplay_port = strtoul(optarg, NULL, 0); break; case 'S': g_extern.netplay_is_spectate = true; break; case 'N': strlcpy(g_extern.netplay_nick, optarg, sizeof(g_extern.netplay_nick)); break; #endif #ifdef HAVE_NETWORK_CMD case 'c': if (network_cmd_send(optarg)) exit(0); else rarch_fail(1, "network_cmd_send()"); break; #endif case 'C': strlcpy(g_extern.append_config_path, optarg, sizeof(g_extern.append_config_path)); break; case 'B': strlcpy(g_extern.bps_name, optarg, sizeof(g_extern.bps_name)); g_extern.bps_pref = true; break; case 'I': strlcpy(g_extern.ips_name, optarg, sizeof(g_extern.ips_name)); g_extern.ips_pref = true; break; case 'n': g_extern.block_patch = true; break; #ifdef HAVE_FFMPEG case 's': { errno = 0; char *ptr; g_extern.record_width = strtoul(optarg, &ptr, 0); if ((*ptr != 'x') || errno) { RARCH_ERR("Wrong format for --size.\n"); print_help(); rarch_fail(1, "parse_input()"); } ptr++; g_extern.record_height = strtoul(ptr, &ptr, 0); if ((*ptr != '\0') || errno) { RARCH_ERR("Wrong format for --size.\n"); print_help(); rarch_fail(1, "parse_input()"); } break; } case 'R': strlcpy(g_extern.record_config, optarg, sizeof(g_extern.record_config)); break; #endif case 'f': print_features(); exit(0); default: break; } break; case '?': print_help(); rarch_fail(1, "parse_input()"); default: RARCH_ERR("Error parsing arguments.\n"); rarch_fail(1, "parse_input()"); } } if (g_extern.libretro_dummy) { if (optind < argc) { RARCH_ERR("--menu was used, but ROM file was passed as well.\n"); rarch_fail(1, "parse_input()"); } } else if (optind < argc) set_paths(argv[optind]); else verify_stdin_paths(); } static void init_controllers(void) { for (unsigned i = 0; i < MAX_PLAYERS; i++) { if (g_extern.disconnect_device[i]) { RARCH_LOG("Disconnecting device from port %u.\n", i + 1); pretro_set_controller_port_device(i, RETRO_DEVICE_NONE); } else if (g_extern.has_dualanalog[i]) { RARCH_LOG("Connecting dualanalog to port %u.\n", i + 1); pretro_set_controller_port_device(i, RETRO_DEVICE_ANALOG); } else if (g_extern.has_mouse[i]) { RARCH_LOG("Connecting mouse to port %u.\n", i + 1); pretro_set_controller_port_device(i, RETRO_DEVICE_MOUSE); } } if (g_extern.has_justifier) { RARCH_LOG("Connecting Justifier to port 2.\n"); pretro_set_controller_port_device(1, RETRO_DEVICE_LIGHTGUN_JUSTIFIER); } else if (g_extern.has_justifiers) { RARCH_LOG("Connecting Justifiers to port 2.\n"); pretro_set_controller_port_device(1, RETRO_DEVICE_LIGHTGUN_JUSTIFIERS); } else if (g_extern.has_multitap) { RARCH_LOG("Connecting Multitap to port 2.\n"); pretro_set_controller_port_device(1, RETRO_DEVICE_JOYPAD_MULTITAP); } else if (g_extern.has_scope) { RARCH_LOG("Connecting scope to port 2.\n"); pretro_set_controller_port_device(1, RETRO_DEVICE_LIGHTGUN_SUPER_SCOPE); } } static inline void load_save_files(void) { switch (g_extern.game_type) { case RARCH_CART_NORMAL: load_ram_file(g_extern.savefile_name_srm, RETRO_MEMORY_SAVE_RAM); load_ram_file(g_extern.savefile_name_rtc, RETRO_MEMORY_RTC); break; case RARCH_CART_SGB: load_ram_file(g_extern.savefile_name_srm, RETRO_MEMORY_SNES_GAME_BOY_RAM); load_ram_file(g_extern.savefile_name_rtc, RETRO_MEMORY_SNES_GAME_BOY_RTC); break; case RARCH_CART_BSX: case RARCH_CART_BSX_SLOTTED: load_ram_file(g_extern.savefile_name_srm, RETRO_MEMORY_SNES_BSX_RAM); load_ram_file(g_extern.savefile_name_psrm, RETRO_MEMORY_SNES_BSX_PRAM); break; case RARCH_CART_SUFAMI: load_ram_file(g_extern.savefile_name_asrm, RETRO_MEMORY_SNES_SUFAMI_TURBO_A_RAM); load_ram_file(g_extern.savefile_name_bsrm, RETRO_MEMORY_SNES_SUFAMI_TURBO_B_RAM); break; default: break; } } static inline void save_files(void) { switch (g_extern.game_type) { case RARCH_CART_NORMAL: RARCH_LOG("Saving regular SRAM.\n"); RARCH_LOG("SRM: %s\n", g_extern.savefile_name_srm); RARCH_LOG("RTC: %s\n", g_extern.savefile_name_rtc); save_ram_file(g_extern.savefile_name_srm, RETRO_MEMORY_SAVE_RAM); save_ram_file(g_extern.savefile_name_rtc, RETRO_MEMORY_RTC); break; case RARCH_CART_SGB: RARCH_LOG("Saving Gameboy SRAM.\n"); RARCH_LOG("SRM: %s\n", g_extern.savefile_name_srm); RARCH_LOG("RTC: %s\n", g_extern.savefile_name_rtc); save_ram_file(g_extern.savefile_name_srm, RETRO_MEMORY_SNES_GAME_BOY_RAM); save_ram_file(g_extern.savefile_name_rtc, RETRO_MEMORY_SNES_GAME_BOY_RTC); break; case RARCH_CART_BSX: case RARCH_CART_BSX_SLOTTED: RARCH_LOG("Saving BSX (P)RAM.\n"); RARCH_LOG("SRM: %s\n", g_extern.savefile_name_srm); RARCH_LOG("PSRM: %s\n", g_extern.savefile_name_psrm); save_ram_file(g_extern.savefile_name_srm, RETRO_MEMORY_SNES_BSX_RAM); save_ram_file(g_extern.savefile_name_psrm, RETRO_MEMORY_SNES_BSX_PRAM); break; case RARCH_CART_SUFAMI: RARCH_LOG("Saving Sufami turbo A/B RAM.\n"); RARCH_LOG("ASRM: %s\n", g_extern.savefile_name_asrm); RARCH_LOG("BSRM: %s\n", g_extern.savefile_name_bsrm); save_ram_file(g_extern.savefile_name_asrm, RETRO_MEMORY_SNES_SUFAMI_TURBO_A_RAM); save_ram_file(g_extern.savefile_name_bsrm, RETRO_MEMORY_SNES_SUFAMI_TURBO_B_RAM); break; default: break; } } #ifdef HAVE_FFMPEG static void init_recording(void) { if (!g_extern.recording) return; if (!g_settings.video.gpu_record && g_extern.system.hw_render_callback.context_type) { RARCH_WARN("Libretro core is hardware rendered. Must use post-shaded FFmpeg recording as well.\n"); return; } double fps = g_extern.system.av_info.timing.fps; double samplerate = g_extern.system.av_info.timing.sample_rate; RARCH_LOG("Custom timing given: FPS: %.4f, Sample rate: %.4f\n", (float)fps, (float)samplerate); struct ffemu_params params = {0}; const struct retro_system_av_info *info = &g_extern.system.av_info; params.out_width = info->geometry.base_width; params.out_height = info->geometry.base_height; params.fb_width = info->geometry.max_width; params.fb_height = info->geometry.max_height; params.channels = 2; params.filename = g_extern.record_path; params.fps = fps; params.samplerate = samplerate; params.pix_fmt = g_extern.system.pix_fmt == RETRO_PIXEL_FORMAT_XRGB8888 ? FFEMU_PIX_ARGB8888 : FFEMU_PIX_RGB565; params.config = *g_extern.record_config ? g_extern.record_config : NULL; if (g_settings.video.gpu_record && driver.video->read_viewport) { struct rarch_viewport vp = {0}; video_viewport_info_func(&vp); if (!vp.width || !vp.height) { RARCH_ERR("Failed to get viewport information from video driver. " "Cannot start recording ...\n"); g_extern.recording = false; return; } params.out_width = vp.width; params.out_height = vp.height; params.fb_width = next_pow2(vp.width); params.fb_height = next_pow2(vp.height); if (g_settings.video.force_aspect && (g_extern.system.aspect_ratio > 0.0f)) params.aspect_ratio = g_extern.system.aspect_ratio; else params.aspect_ratio = (float)vp.width / vp.height; params.pix_fmt = FFEMU_PIX_BGR24; g_extern.record_gpu_width = vp.width; g_extern.record_gpu_height = vp.height; RARCH_LOG("Detected viewport of %u x %u\n", vp.width, vp.height); g_extern.record_gpu_buffer = (uint8_t*)malloc(vp.width * vp.height * 3); if (!g_extern.record_gpu_buffer) { RARCH_ERR("Failed to allocate GPU record buffer.\n"); g_extern.recording = false; return; } } else { if (g_extern.record_width || g_extern.record_height) { params.out_width = g_extern.record_width; params.out_height = g_extern.record_height; } if (g_settings.video.force_aspect && (g_extern.system.aspect_ratio > 0.0f)) params.aspect_ratio = g_extern.system.aspect_ratio; else params.aspect_ratio = (float)params.out_width / params.out_height; if (g_settings.video.post_filter_record && g_extern.filter.active) { g_extern.filter.psize(¶ms.out_width, ¶ms.out_height); params.pix_fmt = FFEMU_PIX_ARGB8888; unsigned max_width = params.fb_width; unsigned max_height = params.fb_height; g_extern.filter.psize(&max_width, &max_height); params.fb_width = next_pow2(max_width); params.fb_height = next_pow2(max_height); } } RARCH_LOG("Recording with FFmpeg to %s @ %ux%u. (FB size: %ux%u pix_fmt: %u)\n", g_extern.record_path, params.out_width, params.out_height, params.fb_width, params.fb_height, (unsigned)params.pix_fmt); g_extern.rec = ffemu_new(¶ms); if (!g_extern.rec) { RARCH_ERR("Failed to start FFmpeg recording.\n"); g_extern.recording = false; free(g_extern.record_gpu_buffer); g_extern.record_gpu_buffer = NULL; } } static void deinit_recording(void) { if (!g_extern.recording) return; ffemu_finalize(g_extern.rec); ffemu_free(g_extern.rec); g_extern.rec = NULL; free(g_extern.record_gpu_buffer); g_extern.record_gpu_buffer = NULL; } #endif void rarch_init_msg_queue(void) { if (g_extern.msg_queue) return; rarch_assert(g_extern.msg_queue = msg_queue_new(8)); } void rarch_deinit_msg_queue(void) { if (g_extern.msg_queue) { msg_queue_free(g_extern.msg_queue); g_extern.msg_queue = NULL; } } static void init_cheats(void) { if (*g_settings.cheat_database) g_extern.cheat = cheat_manager_new(g_settings.cheat_database); } static void deinit_cheats(void) { if (g_extern.cheat) cheat_manager_free(g_extern.cheat); } void rarch_init_rewind(void) { if (!g_settings.rewind_enable || g_extern.state_manager) return; g_extern.state_size = pretro_serialize_size(); if (!g_extern.state_size) { RARCH_ERR("Implementation does not support save states. Cannot use rewind.\n"); return; } // Make sure we allocate at least 4-byte multiple. size_t aligned_state_size = (g_extern.state_size + 3) & ~3; g_extern.state_buf = calloc(1, aligned_state_size); if (!g_extern.state_buf) { RARCH_ERR("Failed to allocate memory for rewind buffer.\n"); return; } if (!pretro_serialize(g_extern.state_buf, g_extern.state_size)) { RARCH_ERR("Failed to perform initial serialization for rewind.\n"); free(g_extern.state_buf); g_extern.state_buf = NULL; return; } RARCH_LOG("Initing rewind buffer with size: %u MB\n", (unsigned)(g_settings.rewind_buffer_size / 1000000)); g_extern.state_manager = state_manager_new(aligned_state_size, g_settings.rewind_buffer_size, g_extern.state_buf); if (!g_extern.state_manager) RARCH_WARN("Failed to init rewind buffer. Rewinding will be disabled.\n"); } void rarch_deinit_rewind(void) { if (g_extern.state_manager) state_manager_free(g_extern.state_manager); g_extern.state_manager = NULL; free(g_extern.state_buf); g_extern.state_buf = NULL; } #ifdef HAVE_BSV_MOVIE static void init_movie(void) { if (g_extern.bsv.movie_start_playback) { g_extern.bsv.movie = bsv_movie_init(g_extern.bsv.movie_start_path, RARCH_MOVIE_PLAYBACK); if (!g_extern.bsv.movie) { RARCH_ERR("Failed to load movie file: \"%s\".\n", g_extern.bsv.movie_start_path); rarch_fail(1, "init_movie()"); } g_extern.bsv.movie_playback = true; msg_queue_push(g_extern.msg_queue, "Starting movie playback.", 2, 180); RARCH_LOG("Starting movie playback.\n"); g_settings.rewind_granularity = 1; } else if (g_extern.bsv.movie_start_recording) { char msg[PATH_MAX]; snprintf(msg, sizeof(msg), "Starting movie record to \"%s\".", g_extern.bsv.movie_start_path); g_extern.bsv.movie = bsv_movie_init(g_extern.bsv.movie_start_path, RARCH_MOVIE_RECORD); msg_queue_clear(g_extern.msg_queue); msg_queue_push(g_extern.msg_queue, g_extern.bsv.movie ? msg : "Failed to start movie record.", 1, 180); if (g_extern.bsv.movie) { RARCH_LOG("Starting movie record to \"%s\".\n", g_extern.bsv.movie_start_path); g_settings.rewind_granularity = 1; } else RARCH_ERR("Failed to start movie record.\n"); } } static void deinit_movie(void) { if (g_extern.bsv.movie) bsv_movie_free(g_extern.bsv.movie); } #endif #define RARCH_DEFAULT_PORT 55435 #ifdef HAVE_NETPLAY static void init_netplay(void) { if (!g_extern.netplay_enable) return; #ifdef HAVE_BSV_MOVIE if (g_extern.bsv.movie_start_playback) { RARCH_WARN("Movie playback has started. Cannot start netplay.\n"); return; } #endif struct retro_callbacks cbs = {0}; cbs.frame_cb = video_frame; cbs.sample_cb = audio_sample; cbs.sample_batch_cb = audio_sample_batch; cbs.state_cb = input_state; if (*g_extern.netplay_server) { RARCH_LOG("Connecting to netplay host...\n"); g_extern.netplay_is_client = true; } else RARCH_LOG("Waiting for client...\n"); g_extern.netplay = netplay_new(g_extern.netplay_is_client ? g_extern.netplay_server : NULL, g_extern.netplay_port ? g_extern.netplay_port : RARCH_DEFAULT_PORT, g_extern.netplay_sync_frames, &cbs, g_extern.netplay_is_spectate, g_extern.netplay_nick); if (!g_extern.netplay) { g_extern.netplay_is_client = false; RARCH_WARN("Failed to init netplay ...\n"); if (g_extern.msg_queue) { msg_queue_push(g_extern.msg_queue, "Failed to init netplay ...", 0, 180); } } } static void deinit_netplay(void) { if (g_extern.netplay) netplay_free(g_extern.netplay); } #endif #ifdef HAVE_COMMAND static void init_command(void) { if (!g_settings.stdin_cmd_enable && !g_settings.network_cmd_enable) return; if (g_settings.stdin_cmd_enable && driver.stdin_claimed) { RARCH_WARN("stdin command interface is desired, but input driver has already claimed stdin.\n" "Cannot use this command interface.\n"); } driver.command = rarch_cmd_new(g_settings.stdin_cmd_enable && !driver.stdin_claimed, g_settings.network_cmd_enable, g_settings.network_cmd_port); if (!driver.command) RARCH_ERR("Failed to initialize command interface.\n"); } static void deinit_command(void) { if (driver.command) { rarch_cmd_free(driver.command); driver.command = NULL; } } #endif static void init_libretro_cbs_plain(void) { pretro_set_video_refresh(video_frame); pretro_set_audio_sample(audio_sample); pretro_set_audio_sample_batch(audio_sample_batch); pretro_set_input_state(input_state); pretro_set_input_poll(rarch_input_poll); } static void init_libretro_cbs(void) { init_libretro_cbs_plain(); #ifdef HAVE_NETPLAY if (g_extern.netplay) { pretro_set_video_refresh(g_extern.netplay_is_spectate ? video_frame : video_frame_net); pretro_set_audio_sample(g_extern.netplay_is_spectate ? audio_sample : audio_sample_net); pretro_set_audio_sample_batch(g_extern.netplay_is_spectate ? audio_sample_batch : audio_sample_batch_net); pretro_set_input_state(g_extern.netplay_is_spectate ? (g_extern.netplay_is_client ? input_state_spectate_client : input_state_spectate) : input_state_net); } #endif } #if defined(HAVE_THREADS) && !defined(RARCH_CONSOLE) static void init_autosave(void) { int ram_types[2] = {-1, -1}; const char *ram_paths[2] = {NULL, NULL}; switch (g_extern.game_type) { case RARCH_CART_BSX: case RARCH_CART_BSX_SLOTTED: ram_types[0] = RETRO_MEMORY_SNES_BSX_RAM; ram_types[1] = RETRO_MEMORY_SNES_BSX_PRAM; ram_paths[0] = g_extern.savefile_name_srm; ram_paths[1] = g_extern.savefile_name_psrm; break; case RARCH_CART_SUFAMI: ram_types[0] = RETRO_MEMORY_SNES_SUFAMI_TURBO_A_RAM; ram_types[1] = RETRO_MEMORY_SNES_SUFAMI_TURBO_B_RAM; ram_paths[0] = g_extern.savefile_name_asrm; ram_paths[1] = g_extern.savefile_name_bsrm; break; case RARCH_CART_SGB: ram_types[0] = RETRO_MEMORY_SNES_GAME_BOY_RAM; ram_types[1] = RETRO_MEMORY_SNES_GAME_BOY_RTC; ram_paths[0] = g_extern.savefile_name_srm; ram_paths[1] = g_extern.savefile_name_rtc; break; default: ram_types[0] = RETRO_MEMORY_SAVE_RAM; ram_types[1] = RETRO_MEMORY_RTC; ram_paths[0] = g_extern.savefile_name_srm; ram_paths[1] = g_extern.savefile_name_rtc; } if (g_settings.autosave_interval > 0) { for (unsigned i = 0; i < sizeof(g_extern.autosave) / sizeof(g_extern.autosave[0]); i++) { if (ram_paths[i] && *ram_paths[i] && pretro_get_memory_size(ram_types[i]) > 0) { g_extern.autosave[i] = autosave_new(ram_paths[i], pretro_get_memory_data(ram_types[i]), pretro_get_memory_size(ram_types[i]), g_settings.autosave_interval); if (!g_extern.autosave[i]) RARCH_WARN("Could not initialize autosave.\n"); } } } } static void deinit_autosave(void) { for (unsigned i = 0; i < sizeof(g_extern.autosave) / sizeof(g_extern.autosave[0]); i++) { if (g_extern.autosave[i]) autosave_free(g_extern.autosave[i]); } } #endif static void set_savestate_auto_index(void) { if (!g_settings.savestate_auto_index) return; // Find the file in the same directory as g_extern.savestate_name with the largest numeral suffix. // E.g. /foo/path/game.state, will try to find /foo/path/game.state%d, where %d is the largest number available. char state_dir[PATH_MAX]; char state_base[PATH_MAX]; fill_pathname_basedir(state_dir, g_extern.savestate_name, sizeof(state_dir)); fill_pathname_base(state_base, g_extern.savestate_name, sizeof(state_base)); unsigned max_index = 0; struct string_list *dir_list = dir_list_new(state_dir, NULL, false); if (!dir_list) return; for (size_t i = 0; i < dir_list->size; i++) { const char *dir_elem = dir_list->elems[i].data; char elem_base[PATH_MAX]; fill_pathname_base(elem_base, dir_elem, sizeof(elem_base)); if (strstr(elem_base, state_base) != elem_base) continue; const char *end = dir_elem + strlen(dir_elem); while ((end > dir_elem) && isdigit(end[-1])) end--; unsigned index = strtoul(end, NULL, 0); if (index > max_index) max_index = index; } dir_list_free(dir_list); g_extern.state_slot = max_index; RARCH_LOG("Found last state slot: #%u\n", g_extern.state_slot); } static void fill_pathnames(void) { switch (g_extern.game_type) { case RARCH_CART_BSX: case RARCH_CART_BSX_SLOTTED: // BSX PSRM if (!g_extern.has_set_save_path) { fill_pathname(g_extern.savefile_name_srm, g_extern.bsx_rom_path, ".srm", sizeof(g_extern.savefile_name_srm)); } fill_pathname(g_extern.savefile_name_psrm, g_extern.savefile_name_srm, ".psrm", sizeof(g_extern.savefile_name_psrm)); if (!g_extern.has_set_state_path) { fill_pathname(g_extern.savestate_name, g_extern.bsx_rom_path, ".state", sizeof(g_extern.savestate_name)); } break; case RARCH_CART_SUFAMI: if (g_extern.has_set_save_path && *g_extern.sufami_rom_path[0] && *g_extern.sufami_rom_path[1]) RARCH_WARN("Sufami Turbo SRAM paths will be inferred from their respective paths to avoid conflicts.\n"); // SUFAMI ARAM fill_pathname(g_extern.savefile_name_asrm, g_extern.sufami_rom_path[0], ".srm", sizeof(g_extern.savefile_name_asrm)); // SUFAMI BRAM fill_pathname(g_extern.savefile_name_bsrm, g_extern.sufami_rom_path[1], ".srm", sizeof(g_extern.savefile_name_bsrm)); if (!g_extern.has_set_state_path) { fill_pathname(g_extern.savestate_name, *g_extern.sufami_rom_path[0] ? g_extern.sufami_rom_path[0] : g_extern.sufami_rom_path[1], ".state", sizeof(g_extern.savestate_name)); } break; case RARCH_CART_SGB: if (!g_extern.has_set_save_path) { fill_pathname(g_extern.savefile_name_srm, g_extern.gb_rom_path, ".srm", sizeof(g_extern.savefile_name_srm)); } if (!g_extern.has_set_state_path) { fill_pathname(g_extern.savestate_name, g_extern.gb_rom_path, ".state", sizeof(g_extern.savestate_name)); } fill_pathname(g_extern.savefile_name_rtc, g_extern.savefile_name_srm, ".rtc", sizeof(g_extern.savefile_name_rtc)); break; default: // Infer .rtc save path from save ram path. fill_pathname(g_extern.savefile_name_rtc, g_extern.savefile_name_srm, ".rtc", sizeof(g_extern.savefile_name_rtc)); } #ifdef HAVE_BSV_MOVIE fill_pathname(g_extern.bsv.movie_path, g_extern.savefile_name_srm, "", sizeof(g_extern.bsv.movie_path)); #endif if (*g_extern.basename) { if (!(*g_extern.ups_name)) fill_pathname_noext(g_extern.ups_name, g_extern.basename, ".ups", sizeof(g_extern.ups_name)); if (!(*g_extern.bps_name)) fill_pathname_noext(g_extern.bps_name, g_extern.basename, ".bps", sizeof(g_extern.bps_name)); if (!(*g_extern.ips_name)) fill_pathname_noext(g_extern.ips_name, g_extern.basename, ".ips", sizeof(g_extern.ips_name)); if (!(*g_extern.xml_name)) fill_pathname_noext(g_extern.xml_name, g_extern.basename, ".xml", sizeof(g_extern.xml_name)); #ifdef HAVE_SCREENSHOTS if (!*g_settings.screenshot_directory) fill_pathname_basedir(g_settings.screenshot_directory, g_extern.basename, sizeof(g_settings.screenshot_directory)); #endif } } static void load_auto_state(void) { #ifdef HAVE_NETPLAY if (g_extern.netplay_enable && !g_extern.netplay_is_spectate) return; #endif if (!g_settings.savestate_auto_load) return; char savestate_name_auto[PATH_MAX]; fill_pathname_noext(savestate_name_auto, g_extern.savestate_name, ".auto", sizeof(savestate_name_auto)); if (path_file_exists(savestate_name_auto)) { RARCH_LOG("Found auto savestate in: %s\n", savestate_name_auto); bool ret = load_state(savestate_name_auto); char msg[PATH_MAX]; snprintf(msg, sizeof(msg), "Auto-loading savestate from \"%s\" %s.", savestate_name_auto, ret ? "succeeded" : "failed"); msg_queue_push(g_extern.msg_queue, msg, 1, 180); RARCH_LOG("%s\n", msg); } } static void save_auto_state(void) { if (!g_settings.savestate_auto_save) return; char savestate_name_auto[PATH_MAX]; fill_pathname_noext(savestate_name_auto, g_extern.savestate_name, ".auto", sizeof(savestate_name_auto)); bool ret = save_state(savestate_name_auto); RARCH_LOG("Auto save state to \"%s\" %s.\n", savestate_name_auto, ret ? "succeeded" : "failed"); } void rarch_load_state(void) { char load_path[PATH_MAX]; if (g_extern.state_slot > 0) snprintf(load_path, sizeof(load_path), "%s%u", g_extern.savestate_name, g_extern.state_slot); else snprintf(load_path, sizeof(load_path), "%s", g_extern.savestate_name); char msg[512]; if (load_state(load_path)) snprintf(msg, sizeof(msg), "Loaded state from slot #%u.", g_extern.state_slot); else snprintf(msg, sizeof(msg), "Failed to load state from \"%s\".", load_path); msg_queue_clear(g_extern.msg_queue); msg_queue_push(g_extern.msg_queue, msg, 2, 180); } void rarch_save_state(void) { if (g_settings.savestate_auto_index) g_extern.state_slot++; char save_path[PATH_MAX]; if (g_extern.state_slot > 0) snprintf(save_path, sizeof(save_path), "%s%u", g_extern.savestate_name, g_extern.state_slot); else snprintf(save_path, sizeof(save_path), "%s", g_extern.savestate_name); char msg[512]; if (save_state(save_path)) snprintf(msg, sizeof(msg), "Saved state to slot #%u.", g_extern.state_slot); else snprintf(msg, sizeof(msg), "Failed to save state to \"%s\".", save_path); msg_queue_clear(g_extern.msg_queue); msg_queue_push(g_extern.msg_queue, msg, 2, 180); } // Save or load state here. static void check_savestates(bool immutable) { static bool old_should_savestate = false; bool should_savestate = input_key_pressed_func(RARCH_SAVE_STATE_KEY); if (should_savestate && !old_should_savestate) rarch_save_state(); old_should_savestate = should_savestate; if (!immutable) { static bool old_should_loadstate = false; bool should_loadstate = input_key_pressed_func(RARCH_LOAD_STATE_KEY); if (!should_savestate && should_loadstate && !old_should_loadstate) rarch_load_state(); old_should_loadstate = should_loadstate; } } #if !defined(RARCH_PERFORMANCE_MODE) bool rarch_check_fullscreen(void) { // If we go fullscreen we drop all drivers and reinit to be safe. static bool was_pressed = false; bool pressed = input_key_pressed_func(RARCH_FULLSCREEN_TOGGLE_KEY); bool toggle = pressed && !was_pressed; if (toggle) { g_settings.video.fullscreen = !g_settings.video.fullscreen; uninit_drivers(); init_drivers(); // Poll input to avoid possibly stale data to corrupt things. if (driver.input) input_poll_func(); } was_pressed = pressed; return toggle; } #endif void rarch_state_slot_increase(void) { g_extern.state_slot++; if (g_extern.msg_queue) msg_queue_clear(g_extern.msg_queue); char msg[256]; #ifdef HAVE_BSV_MOVIE snprintf(msg, sizeof(msg), "Save state/movie slot: %u", g_extern.state_slot); #else snprintf(msg, sizeof(msg), "Save state slot: %u", g_extern.state_slot); #endif if (g_extern.msg_queue) msg_queue_push(g_extern.msg_queue, msg, 1, 180); RARCH_LOG("%s\n", msg); } void rarch_state_slot_decrease(void) { if (g_extern.state_slot > 0) g_extern.state_slot--; if (g_extern.msg_queue) msg_queue_clear(g_extern.msg_queue); char msg[256]; #ifdef HAVE_BSV_MOVIE snprintf(msg, sizeof(msg), "Save state/movie slot: %u", g_extern.state_slot); #else snprintf(msg, sizeof(msg), "Save state slot: %u", g_extern.state_slot); #endif if (g_extern.msg_queue) msg_queue_push(g_extern.msg_queue, msg, 1, 180); RARCH_LOG("%s\n", msg); } static void check_stateslots(void) { // Save state slots static bool old_should_slot_increase = false; bool should_slot_increase = input_key_pressed_func(RARCH_STATE_SLOT_PLUS); if (should_slot_increase && !old_should_slot_increase) rarch_state_slot_increase(); old_should_slot_increase = should_slot_increase; static bool old_should_slot_decrease = false; bool should_slot_decrease = input_key_pressed_func(RARCH_STATE_SLOT_MINUS); if (should_slot_decrease && !old_should_slot_decrease) rarch_state_slot_decrease(); old_should_slot_decrease = should_slot_decrease; } static inline void flush_rewind_audio(void) { if (g_extern.frame_is_reverse) // We just rewound. Flush rewind audio buffer. { g_extern.audio_active = audio_flush(g_extern.audio_data.rewind_buf + g_extern.audio_data.rewind_ptr, g_extern.audio_data.rewind_size - g_extern.audio_data.rewind_ptr) && g_extern.audio_active; } } static inline void setup_rewind_audio(void) { // Push audio ready to be played. g_extern.audio_data.rewind_ptr = g_extern.audio_data.rewind_size; for (unsigned i = 0; i < g_extern.audio_data.data_ptr; i += 2) { g_extern.audio_data.rewind_buf[--g_extern.audio_data.rewind_ptr] = g_extern.audio_data.conv_outsamples[i + 1]; g_extern.audio_data.rewind_buf[--g_extern.audio_data.rewind_ptr] = g_extern.audio_data.conv_outsamples[i + 0]; } g_extern.audio_data.data_ptr = 0; } static void check_rewind(void) { flush_rewind_audio(); g_extern.frame_is_reverse = false; static bool first = true; if (first) { first = false; return; } if (!g_extern.state_manager) return; if (input_key_pressed_func(RARCH_REWIND)) { msg_queue_clear(g_extern.msg_queue); void *buf; if (state_manager_pop(g_extern.state_manager, &buf)) { g_extern.frame_is_reverse = true; setup_rewind_audio(); msg_queue_push(g_extern.msg_queue, "Rewinding.", 0, g_extern.is_paused ? 1 : 30); pretro_unserialize(buf, g_extern.state_size); #ifdef HAVE_BSV_MOVIE if (g_extern.bsv.movie) bsv_movie_frame_rewind(g_extern.bsv.movie); #endif } else msg_queue_push(g_extern.msg_queue, "Reached end of rewind buffer.", 0, 30); } else { static unsigned cnt = 0; cnt = (cnt + 1) % (g_settings.rewind_granularity ? g_settings.rewind_granularity : 1); // Avoid possible SIGFPE. #ifdef HAVE_BSV_MOVIE if (cnt == 0 || g_extern.bsv.movie) #else if (cnt == 0) #endif { pretro_serialize(g_extern.state_buf, g_extern.state_size); state_manager_push(g_extern.state_manager, g_extern.state_buf); } } pretro_set_audio_sample(g_extern.frame_is_reverse ? audio_sample_rewind : audio_sample); pretro_set_audio_sample_batch(g_extern.frame_is_reverse ? audio_sample_batch_rewind : audio_sample_batch); } static void check_slowmotion(void) { g_extern.is_slowmotion = input_key_pressed_func(RARCH_SLOWMOTION); if (g_extern.is_slowmotion) { msg_queue_clear(g_extern.msg_queue); msg_queue_push(g_extern.msg_queue, g_extern.frame_is_reverse ? "Slow motion rewind." : "Slow motion.", 0, 30); } } #ifdef HAVE_BSV_MOVIE static void movie_record_toggle(void) { if (g_extern.bsv.movie) { msg_queue_clear(g_extern.msg_queue); msg_queue_push(g_extern.msg_queue, "Stopping movie record.", 2, 180); RARCH_LOG("Stopping movie record.\n"); bsv_movie_free(g_extern.bsv.movie); g_extern.bsv.movie = NULL; } else { g_settings.rewind_granularity = 1; char path[PATH_MAX]; if (g_extern.state_slot > 0) { snprintf(path, sizeof(path), "%s%u.bsv", g_extern.bsv.movie_path, g_extern.state_slot); } else { snprintf(path, sizeof(path), "%s.bsv", g_extern.bsv.movie_path); } char msg[PATH_MAX]; snprintf(msg, sizeof(msg), "Starting movie record to \"%s\".", path); g_extern.bsv.movie = bsv_movie_init(path, RARCH_MOVIE_RECORD); msg_queue_clear(g_extern.msg_queue); msg_queue_push(g_extern.msg_queue, g_extern.bsv.movie ? msg : "Failed to start movie record.", 1, 180); if (g_extern.bsv.movie) RARCH_LOG("Starting movie record to \"%s\".\n", path); else RARCH_ERR("Failed to start movie record.\n"); } } static void check_movie_record(bool pressed) { if (pressed) movie_record_toggle(); } static void check_movie_playback(bool pressed) { if (g_extern.bsv.movie_end || pressed) { msg_queue_push(g_extern.msg_queue, "Movie playback ended.", 1, 180); RARCH_LOG("Movie playback ended.\n"); bsv_movie_free(g_extern.bsv.movie); g_extern.bsv.movie = NULL; g_extern.bsv.movie_end = false; g_extern.bsv.movie_playback = false; } } static void check_movie(void) { static bool old_button = false; bool new_button = input_key_pressed_func(RARCH_MOVIE_RECORD_TOGGLE); bool pressed = new_button && !old_button; if (g_extern.bsv.movie_playback) check_movie_playback(pressed); else check_movie_record(pressed); old_button = new_button; } #endif #if !defined(RARCH_PERFORMANCE_MODE) static void check_pause(void) { static bool old_state = false; bool new_state = input_key_pressed_func(RARCH_PAUSE_TOGGLE); // FRAMEADVANCE will set us into pause mode. new_state |= !g_extern.is_paused && input_key_pressed_func(RARCH_FRAMEADVANCE); static bool old_focus = true; bool focus = true; if (g_settings.pause_nonactive) focus = video_focus_func(); if (focus && new_state && !old_state) { g_extern.is_paused = !g_extern.is_paused; if (g_extern.is_paused) { RARCH_LOG("Paused.\n"); if (driver.audio_data) audio_stop_func(); } else { RARCH_LOG("Unpaused.\n"); if (driver.audio_data) { if (!audio_start_func()) { RARCH_ERR("Failed to resume audio driver. Will continue without audio.\n"); g_extern.audio_active = false; } } } } else if (focus && !old_focus) { RARCH_LOG("Unpaused.\n"); g_extern.is_paused = false; if (driver.audio_data && !audio_start_func()) { RARCH_ERR("Failed to resume audio driver. Will continue without audio.\n"); g_extern.audio_active = false; } } else if (!focus && old_focus) { RARCH_LOG("Paused.\n"); g_extern.is_paused = true; if (driver.audio_data) audio_stop_func(); } old_focus = focus; old_state = new_state; } static void check_oneshot(void) { static bool old_state = false; bool new_state = input_key_pressed_func(RARCH_FRAMEADVANCE); g_extern.is_oneshot = (new_state && !old_state); old_state = new_state; // Rewind buttons works like FRAMEREWIND when paused. We will one-shot in that case. static bool old_rewind_state = false; bool new_rewind_state = input_key_pressed_func(RARCH_REWIND); g_extern.is_oneshot |= new_rewind_state && !old_rewind_state; old_rewind_state = new_rewind_state; } #endif void rarch_game_reset(void) { RARCH_LOG("Resetting game.\n"); msg_queue_clear(g_extern.msg_queue); msg_queue_push(g_extern.msg_queue, "Reset.", 1, 120); pretro_reset(); init_controllers(); // bSNES since v073r01 resets controllers to JOYPAD after a reset, so just enforce it here. } static void check_reset(void) { static bool old_state = false; bool new_state = input_key_pressed_func(RARCH_RESET); if (new_state && !old_state) rarch_game_reset(); old_state = new_state; } static void check_turbo(void) { g_extern.turbo_count++; static const struct retro_keybind *binds[MAX_PLAYERS] = { g_settings.input.binds[0], g_settings.input.binds[1], g_settings.input.binds[2], g_settings.input.binds[3], g_settings.input.binds[4], g_settings.input.binds[5], g_settings.input.binds[6], g_settings.input.binds[7], }; for (unsigned i = 0; i < MAX_PLAYERS; i++) g_extern.turbo_frame_enable[i] = input_input_state_func(binds, i, RETRO_DEVICE_JOYPAD, 0, RARCH_TURBO_ENABLE); } static void check_shader_dir(void) { static bool old_pressed_next; static bool old_pressed_prev; if (!g_extern.shader_dir.list || !driver.video->set_shader) return; bool should_apply = false; bool pressed_next = input_key_pressed_func(RARCH_SHADER_NEXT); bool pressed_prev = input_key_pressed_func(RARCH_SHADER_PREV); if (pressed_next && !old_pressed_next) { should_apply = true; g_extern.shader_dir.ptr = (g_extern.shader_dir.ptr + 1) % g_extern.shader_dir.list->size; } else if (pressed_prev && !old_pressed_prev) { should_apply = true; if (g_extern.shader_dir.ptr == 0) g_extern.shader_dir.ptr = g_extern.shader_dir.list->size - 1; else g_extern.shader_dir.ptr--; } if (should_apply) { const char *shader = g_extern.shader_dir.list->elems[g_extern.shader_dir.ptr].data; enum rarch_shader_type type = RARCH_SHADER_NONE; const char *ext = strrchr(shader, '.'); if (ext) { if (strcmp(ext, ".shader") == 0) type = RARCH_SHADER_GLSL; else if (strcmp(ext, ".cg") == 0 || strcmp(ext, ".cgp") == 0) type = RARCH_SHADER_CG; } if (type == RARCH_SHADER_NONE) return; msg_queue_clear(g_extern.msg_queue); char msg[512]; snprintf(msg, sizeof(msg), "Shader #%u: \"%s\".", (unsigned)g_extern.shader_dir.ptr, shader); msg_queue_push(g_extern.msg_queue, msg, 1, 120); RARCH_LOG("Applying shader \"%s\".\n", shader); if (!video_set_shader_func(type, shader)) RARCH_WARN("Failed to apply shader.\n"); } old_pressed_next = pressed_next; old_pressed_prev = pressed_prev; } static void check_cheats(void) { if (!g_extern.cheat) return; static bool old_pressed_prev; static bool old_pressed_next; static bool old_pressed_toggle; bool pressed_next = input_key_pressed_func(RARCH_CHEAT_INDEX_PLUS); bool pressed_prev = input_key_pressed_func(RARCH_CHEAT_INDEX_MINUS); bool pressed_toggle = input_key_pressed_func(RARCH_CHEAT_TOGGLE); if (pressed_next && !old_pressed_next) cheat_manager_index_next(g_extern.cheat); else if (pressed_prev && !old_pressed_prev) cheat_manager_index_prev(g_extern.cheat); else if (pressed_toggle && !old_pressed_toggle) cheat_manager_toggle(g_extern.cheat); old_pressed_prev = pressed_prev; old_pressed_next = pressed_next; old_pressed_toggle = pressed_toggle; } static void check_disk(void) { const struct retro_disk_control_callback *control = &g_extern.system.disk_control; if (!control->get_num_images) return; static bool old_pressed_eject; static bool old_pressed_next; bool pressed_eject = input_key_pressed_func(RARCH_DISK_EJECT_TOGGLE); bool pressed_next = input_key_pressed_func(RARCH_DISK_NEXT); bool error = false; char msg[256]; *msg = '\0'; if (pressed_eject && !old_pressed_eject) { bool new_state = !control->get_eject_state(); if (control->set_eject_state(new_state)) snprintf(msg, sizeof(msg), "%s virtual disk tray.", new_state ? "Ejected" : "Closed"); else { error = true; snprintf(msg, sizeof(msg), "Failed to %s virtual disk tray.", new_state ? "eject" : "close"); } } else if (pressed_next && !old_pressed_next) { unsigned num_disks = control->get_num_images(); unsigned current = control->get_image_index(); if (num_disks && num_disks != UINT_MAX) { // Use "no disk" state when index == num_disks. unsigned next_index = current >= num_disks ? 0 : ((current + 1) % (num_disks + 1)); if (control->set_image_index(next_index)) { if (next_index < num_disks) snprintf(msg, sizeof(msg), "Setting disk %u of %u in tray.", next_index + 1, num_disks); else snprintf(msg, sizeof(msg), "Removed disk from tray."); } else { if (next_index < num_disks) snprintf(msg, sizeof(msg), "Failed to set disk %u of %u.", next_index + 1, num_disks); else snprintf(msg, sizeof(msg), "Failed to remove disk from tray."); error = true; } } else { snprintf(msg, sizeof(msg), "Got invalid disk index from libretro."); error = true; } } if (*msg) { if (error) RARCH_ERR("%s\n", msg); else RARCH_LOG("%s\n", msg); msg_queue_clear(g_extern.msg_queue); msg_queue_push(g_extern.msg_queue, msg, 1, 180); } old_pressed_eject = pressed_eject; old_pressed_next = pressed_next; } #if defined(HAVE_SCREENSHOTS) && !defined(_XBOX) static void check_screenshot(void) { static bool old_pressed; bool pressed = input_key_pressed_func(RARCH_SCREENSHOT); if (pressed && !old_pressed) take_screenshot(); old_pressed = pressed; } #endif #ifdef HAVE_DYLIB static void check_dsp_config(void) { if (!g_extern.audio_data.dsp_plugin || !g_extern.audio_data.dsp_plugin->config) return; static bool old_pressed; bool pressed = input_key_pressed_func(RARCH_DSP_CONFIG); if (pressed && !old_pressed) g_extern.audio_data.dsp_plugin->config(g_extern.audio_data.dsp_handle); old_pressed = pressed; } #endif #if !defined(RARCH_PERFORMANCE_MODE) static void check_mute(void) { if (!g_extern.audio_active) return; static bool old_pressed; bool pressed = input_key_pressed_func(RARCH_MUTE); if (pressed && !old_pressed) { g_extern.audio_data.mute = !g_extern.audio_data.mute; const char *msg = g_extern.audio_data.mute ? "Audio muted." : "Audio unmuted."; msg_queue_clear(g_extern.msg_queue); msg_queue_push(g_extern.msg_queue, msg, 1, 180); RARCH_LOG("%s\n", msg); } old_pressed = pressed; } static void check_volume(void) { if (!g_extern.audio_active) return; float db_change = 0.0f; bool pressed_up = input_key_pressed_func(RARCH_VOLUME_UP); bool pressed_down = input_key_pressed_func(RARCH_VOLUME_DOWN); if (!pressed_up && !pressed_down) return; if (pressed_up) db_change += 0.5f; if (pressed_down) db_change -= 0.5f; g_extern.audio_data.volume_db += db_change; if (g_extern.audio_data.volume_db > 12.0f) g_extern.audio_data.volume_db = 12.0f; else if (g_extern.audio_data.volume_db < -80.0f) g_extern.audio_data.volume_db = -80.0f; char msg[256]; snprintf(msg, sizeof(msg), "Volume: %.1f dB", g_extern.audio_data.volume_db); msg_queue_clear(g_extern.msg_queue); msg_queue_push(g_extern.msg_queue, msg, 1, 180); RARCH_LOG("%s\n", msg); g_extern.audio_data.volume_gain = db_to_gain(g_extern.audio_data.volume_db); } #endif #ifdef HAVE_NETPLAY static void check_netplay_flip(void) { static bool old_pressed; bool pressed = input_key_pressed_func(RARCH_NETPLAY_FLIP); if (pressed && !old_pressed) netplay_flip_players(g_extern.netplay); old_pressed = pressed; } #endif static void check_block_hotkey(void) { driver.block_hotkey = false; // If we haven't bound anything to this, // always allow hotkeys. static const struct retro_keybind *bind = &g_settings.input.binds[0][RARCH_ENABLE_HOTKEY]; if (bind->key == RETROK_UNKNOWN && bind->joykey == NO_BTN && bind->joyaxis == AXIS_NONE) return; driver.block_hotkey = !input_key_pressed_func(RARCH_ENABLE_HOTKEY); } #ifdef HAVE_OVERLAY void rarch_check_overlay(void) { if (!driver.overlay) return; static bool old_pressed; bool pressed = input_key_pressed_func(RARCH_OVERLAY_NEXT); if (pressed && !old_pressed) input_overlay_next(driver.overlay); old_pressed = pressed; } #endif #ifndef RARCH_CONSOLE static void check_grab_mouse_toggle(void) { static bool old_pressed; bool pressed = input_key_pressed_func(RARCH_GRAB_MOUSE_TOGGLE) && driver.input->grab_mouse; static bool grab_mouse_state; if (pressed && !old_pressed) { grab_mouse_state = !grab_mouse_state; RARCH_LOG("Grab mouse state: %s.\n", grab_mouse_state ? "yes" : "no"); driver.input->grab_mouse(driver.input_data, grab_mouse_state); if (driver.video_poke && driver.video_poke->show_mouse) driver.video_poke->show_mouse(driver.video_data, !grab_mouse_state); } old_pressed = pressed; } #endif static void do_state_checks(void) { check_block_hotkey(); #if defined(HAVE_SCREENSHOTS) && !defined(_XBOX) check_screenshot(); #endif #if !defined(RARCH_PERFORMANCE_MODE) check_mute(); check_volume(); #endif check_turbo(); #ifndef RARCH_CONSOLE check_grab_mouse_toggle(); #endif #ifdef HAVE_OVERLAY rarch_check_overlay(); #endif #ifdef HAVE_NETPLAY if (!g_extern.netplay) { #endif #if !defined(RARCH_PERFORMANCE_MODE) check_pause(); check_oneshot(); if (rarch_check_fullscreen() && g_extern.is_paused) rarch_render_cached_frame(); if (g_extern.is_paused && !g_extern.is_oneshot) return; #endif check_fast_forward_button(); check_stateslots(); #ifdef HAVE_BSV_MOVIE check_savestates(g_extern.bsv.movie); #else check_savestates(false); #endif check_rewind(); check_slowmotion(); #ifdef HAVE_BSV_MOVIE check_movie(); #endif check_shader_dir(); check_cheats(); check_disk(); #ifdef HAVE_DYLIB check_dsp_config(); #endif check_reset(); #ifdef HAVE_NETPLAY } else { check_netplay_flip(); #if !defined(RARCH_PERFORMANCE_MODE) rarch_check_fullscreen(); #endif } #endif } static void init_state(void) { g_extern.video_active = true; g_extern.audio_active = true; g_extern.game_type = RARCH_CART_NORMAL; } void rarch_main_clear_state(void) { memset(&g_settings, 0, sizeof(g_settings)); if (g_extern.log_file) fclose(g_extern.log_file); memset(&g_extern, 0, sizeof(g_extern)); init_state(); } #ifdef HAVE_ZLIB #define DEFAULT_EXT "ZIP|zip" #else #define DEFAULT_EXT "" #endif void rarch_init_system_info(void) { struct retro_system_info *info = &g_extern.system.info; pretro_get_system_info(info); if (!info->library_name) info->library_name = "Unknown"; if (!info->library_version) info->library_version = "v0"; #ifdef RARCH_CONSOLE snprintf(g_extern.title_buf, sizeof(g_extern.title_buf), "%s %s", info->library_name, info->library_version); #else snprintf(g_extern.title_buf, sizeof(g_extern.title_buf), "RetroArch : %s %s", info->library_name, info->library_version); #endif strlcpy(g_extern.system.valid_extensions, info->valid_extensions ? info->valid_extensions : DEFAULT_EXT, sizeof(g_extern.system.valid_extensions)); g_extern.system.block_extract = info->block_extract; } static void init_system_av_info(void) { pretro_get_system_av_info(&g_extern.system.av_info); } static void verify_api_version(void) { RARCH_LOG("Version of libretro API: %u\n", pretro_api_version()); RARCH_LOG("Compiled against API: %u\n", RETRO_API_VERSION); if (pretro_api_version() != RETRO_API_VERSION) RARCH_WARN("RetroArch is compiled against a different version of libretro than this libretro implementation.\n"); } // Make sure we haven't compiled for something we cannot run. // Ideally, code would get swapped out depending on CPU support, but this will do for now. static void validate_cpu_features(void) { struct rarch_cpu_features cpu; rarch_get_cpu_features(&cpu); #define FAIL_CPU(simd_type) do { \ RARCH_ERR(simd_type " code is compiled in, but CPU does not support this feature. Cannot continue.\n"); \ rarch_fail(1, "validate_cpu_features()"); \ } while(0) #ifdef __SSE__ if (!(cpu.simd & RARCH_SIMD_SSE)) FAIL_CPU("SSE"); #endif #ifdef __SSE2__ if (!(cpu.simd & RARCH_SIMD_SSE2)) FAIL_CPU("SSE2"); #endif #ifdef __AVX__ if (!(cpu.simd & RARCH_SIMD_AVX)) FAIL_CPU("AVX"); #endif } int rarch_main_init(int argc, char *argv[]) { init_state(); int sjlj_ret; if ((sjlj_ret = setjmp(g_extern.error_sjlj_context)) > 0) { RARCH_ERR("Fatal error received in: \"%s\"\n", g_extern.error_string); return sjlj_ret; } g_extern.error_in_init = true; parse_input(argc, argv); if (g_extern.verbose) { RARCH_LOG_OUTPUT("=== Build ======================================="); print_compiler(stderr); RARCH_LOG_OUTPUT("=================================================\n"); } validate_cpu_features(); config_load(); init_libretro_sym(g_extern.libretro_dummy); rarch_init_system_info(); init_drivers_pre(); verify_api_version(); pretro_init(); g_extern.use_sram = !g_extern.libretro_dummy; bool allow_cheats = true; if (!g_extern.libretro_dummy) { fill_pathnames(); if (!init_rom_file(g_extern.game_type)) goto error; set_savestate_auto_index(); if (!g_extern.sram_load_disable) load_save_files(); else RARCH_LOG("Skipping SRAM load.\n"); load_auto_state(); #ifdef HAVE_BSV_MOVIE init_movie(); #endif #ifdef HAVE_NETPLAY init_netplay(); #endif } init_system_av_info(); init_drivers(); #ifdef HAVE_COMMAND init_command(); #endif #ifdef HAVE_NETPLAY if (!g_extern.netplay) #endif rarch_init_rewind(); init_libretro_cbs(); init_controllers(); #ifdef HAVE_FFMPEG init_recording(); #endif #ifdef HAVE_NETPLAY g_extern.use_sram = g_extern.use_sram && !g_extern.sram_save_disable && !g_extern.netplay_is_client; #else g_extern.use_sram = g_extern.use_sram && !g_extern.sram_save_disable; #endif if (!g_extern.use_sram) RARCH_LOG("SRAM will not be saved.\n"); #if defined(HAVE_THREADS) && !defined(RARCH_CONSOLE) if (g_extern.use_sram) init_autosave(); #endif #ifdef HAVE_NETPLAY allow_cheats &= !g_extern.netplay; #endif #ifdef HAVE_BSV_MOVIE allow_cheats &= !g_extern.bsv.movie; #endif if (allow_cheats) init_cheats(); g_extern.error_in_init = false; g_extern.main_is_init = true; return 0; error: pretro_unload_game(); pretro_deinit(); uninit_drivers(); uninit_libretro_sym(); g_extern.main_is_init = false; return 1; } static inline bool check_enter_rgui(void) { static bool old_rmenu_toggle = true; // Always go into menu if dummy core is loaded. bool rmenu_toggle = input_key_pressed_func(RARCH_MENU_TOGGLE) || (g_extern.libretro_dummy && !old_rmenu_toggle); if (rmenu_toggle && !old_rmenu_toggle) { if (g_extern.menu_toggle_behavior == 0) g_extern.lifecycle_mode_state |= (1ULL << MODE_MENU_INGAME); g_extern.lifecycle_mode_state |= (1ULL << MODE_MENU); g_extern.delay_timer[0] = g_extern.frame_count + 30; // FIXME: Purge. Should do something similar in RGUI as well. old_rmenu_toggle = true; return true; } else { old_rmenu_toggle = rmenu_toggle; return false; } } bool rarch_main_iterate(void) { #ifdef HAVE_DYLIB // DSP plugin GUI events. if (g_extern.audio_data.dsp_handle && g_extern.audio_data.dsp_plugin->events) g_extern.audio_data.dsp_plugin->events(g_extern.audio_data.dsp_handle); #endif // SHUTDOWN on consoles should exit RetroArch completely. if (g_extern.system.shutdown) { g_extern.lifecycle_mode_state |= (1ULL << MODE_EXIT); return false; } // Time to drop? if (input_key_pressed_func(RARCH_QUIT_KEY) || !video_alive_func()) { g_extern.lifecycle_mode_state |= (1ULL << MODE_EXIT); return false; } if (check_enter_rgui()) return false; // Enter menu, don't exit. #ifdef HAVE_COMMAND if (driver.command) rarch_cmd_pre_frame(driver.command); #endif // Checks for stuff like fullscreen, save states, etc. do_state_checks(); // Run libretro for one frame. #if defined(HAVE_THREADS) && !defined(RARCH_CONSOLE) lock_autosave(); #endif #ifdef HAVE_NETPLAY if (g_extern.netplay) netplay_pre_frame(g_extern.netplay); #endif #ifdef HAVE_BSV_MOVIE if (g_extern.bsv.movie) bsv_movie_set_frame_start(g_extern.bsv.movie); #endif pretro_run(); #ifdef HAVE_BSV_MOVIE if (g_extern.bsv.movie) bsv_movie_set_frame_end(g_extern.bsv.movie); #endif #ifdef HAVE_NETPLAY if (g_extern.netplay) netplay_post_frame(g_extern.netplay); #endif #if defined(HAVE_THREADS) && !defined(RARCH_CONSOLE) unlock_autosave(); #endif #ifdef HAVE_RMENU if (input_key_pressed_func(RARCH_FRAMEADVANCE)) { g_extern.lifecycle_state &= ~(1ULL << RARCH_FRAMEADVANCE); g_extern.lifecycle_mode_state |= (1ULL << MODE_MENU); g_extern.lifecycle_mode_state |= (1ULL << MODE_MENU_INGAME); return false; } #endif return true; } void rarch_main_deinit(void) { #ifdef HAVE_NETPLAY deinit_netplay(); #endif #ifdef HAVE_COMMAND deinit_command(); #endif #if defined(HAVE_THREADS) && !defined(RARCH_CONSOLE) if (g_extern.use_sram) deinit_autosave(); #endif #ifdef HAVE_FFMPEG deinit_recording(); #endif if (g_extern.use_sram) save_files(); #ifdef HAVE_NETPLAY if (!g_extern.netplay) #endif rarch_deinit_rewind(); deinit_cheats(); #ifdef HAVE_BSV_MOVIE deinit_movie(); #endif if (!g_extern.libretro_dummy) save_auto_state(); pretro_unload_game(); pretro_deinit(); uninit_drivers(); uninit_libretro_sym(); if (g_extern.rom_file_temporary) { RARCH_LOG("Removing tempoary ROM file: %s.\n", g_extern.last_rom); if (remove(g_extern.last_rom) < 0) RARCH_ERR("Failed to remove temporary file: %s.\n", g_extern.last_rom); g_extern.rom_file_temporary = false; } if (g_extern.system.core_options) { core_option_flush(g_extern.system.core_options); core_option_free(g_extern.system.core_options); } g_extern.system.core_options = NULL; g_extern.main_is_init = false; } #define MAX_ARGS 32 int rarch_main_init_wrap(const struct rarch_main_wrap *args) { if (g_extern.main_is_init) rarch_main_deinit(); int argc = 0; char *argv[MAX_ARGS] = {NULL}; char *argv_copy[MAX_ARGS]; argv[argc++] = strdup("retroarch"); if (args->rom_path) argv[argc++] = strdup(args->rom_path); if (args->sram_path) { argv[argc++] = strdup("-s"); argv[argc++] = strdup(args->sram_path); } if (args->state_path) { argv[argc++] = strdup("-S"); argv[argc++] = strdup(args->state_path); } if (args->config_path) { argv[argc++] = strdup("-c"); argv[argc++] = strdup(args->config_path); } #ifdef HAVE_DYNAMIC if (args->libretro_path) { argv[argc++] = strdup("-L"); argv[argc++] = strdup(args->libretro_path); } #endif if (args->verbose) argv[argc++] = strdup("-v"); #ifdef HAVE_FILE_LOGGER for (int i = 0; i < argc; i++) RARCH_LOG("arg #%d: %s\n", i, argv[i]); #endif // The pointers themselves are not const, and can be messed around with by getopt_long(). memcpy(argv_copy, argv, sizeof(argv)); int ret = rarch_main_init(argc, argv); for (unsigned i = 0; i < ARRAY_SIZE(argv_copy); i++) free(argv_copy[i]); return ret; } bool rarch_main_idle_iterate(void) { #ifdef HAVE_COMMAND if (driver.command) rarch_cmd_pre_frame(driver.command); #endif if (input_key_pressed_func(RARCH_QUIT_KEY) || !video_alive_func()) return false; do_state_checks(); rarch_input_poll(); rarch_sleep(10); return true; }