#include <stdio.h>

#include <stdint.h>

#include <stdlib.h>

#include <stdarg.h>

#include <string.h>

#include <math.h>

#include "include/dosbox.h"

#include "include/cpu.h"

#include "include/control.h"

#include "include/render.h"

#include "include/keyboard.h"

#include "include/mouse.h"

#include "include/joystick.h"

#include "include/bios_disk.h"

#include "include/callback.h"

#include "include/dbp_serialize.h"

#include "include/dbp_threads.h"

#include "include/dbp_opengl.h"

#include "src/ints/int10.h"

#include "src/dos/drives.h"

#include "keyb2joypad.h"

#include "libretro-common/include/libretro.h"

#include "libretro-common/include/retro_timers.h"

#include <string>

#include <sstream>

#if defined(GEKKO) || defined(MIYOO) // From RetroArch/config.def.h

#define DBP_DEFAULT_SAMPLERATE 32000.0

#define DBP_DEFAULT_SAMPLERATE_STRING "32000"

#elif defined(_3DS)

#define DBP_DEFAULT_SAMPLERATE 32730.0

#define DBP_DEFAULT_SAMPLERATE_STRING "32730"

#else

#define DBP_DEFAULT_SAMPLERATE 48000.0

#define DBP_DEFAULT_SAMPLERATE_STRING "48000"

#endif

#include "core_options.h"

static retro_system_av_info av_info;

static enum DBP_State : Bit8u { DBPSTATE_BOOT, DBPSTATE_EXITED, DBPSTATE_SHUTDOWN, DBPSTATE_REBOOT, DBPSTATE_FIRST_FRAME, DBPSTATE_RUNNING } dbp_state;

static enum DBP_SerializeMode : Bit8u { DBPSERIALIZE_STATES, DBPSERIALIZE_REWIND, DBPSERIALIZE_DISABLED } dbp_serializemode;

static bool dbp_game_running, dbp_pause_events, dbp_paused_midframe, dbp_frame_pending, dbp_biosreboot, dbp_system_cached, dbp_system_scannable, dbp_refresh_memmaps;

static bool dbp_optionsupdatecallback, dbp_reboot_set64mem, dbp_use_network, dbp_had_game_running, dbp_strict_mode, dbp_legacy_save, dbp_wasloaded, dbp_skip_c_mount;

static signed char dbp_menu_time, dbp_conf_loading, dbp_reboot_machine;

static Bit8u dbp_alphablend_base;

static float dbp_auto_target, dbp_last_fastforward;

static Bit32u dbp_lastmenuticks, dbp_framecount, dbp_emu_waiting, dbp_paused_work;

static Semaphore semDoContinue, semDidPause;

static retro_throttle_state dbp_throttle;

static std::string dbp_crash_message;

static std::string dbp_content_path;

static std::string dbp_content_name;

static retro_time_t dbp_boot_time;

static size_t dbp_serializesize;

static Bit16s dbp_content_year, dbp_forcefps;

static Bit8u buffer_active, dbp_overscan;

static bool dbp_doublescan, dbp_padding;

static struct DBP_Buffer { Bit32u *video, width, height, cap, pad_x, pad_y, border_color; float ratio; } dbp_buffers[3];

#ifndef DBP_STANDALONE

static struct DBP_Audio { int16_t* audio; Bit32u length; } dbp_audio[2];

static Bit8u dbp_audio_active;

#endif

static double dbp_audio_remain;

static struct retro_hw_render_callback dbp_hw_render;

static void (*dbp_opengl_draw)(const DBP_Buffer& buf);

struct DBP_Image { std::string path, longpath; bool mounted = false, remount = false, image_disk = false, imgmount = false, imfat = false, imiso = false; char drive; int dirlen, dd; };

static std::vector<DBP_Image> dbp_images;

static std::vector<std::string> dbp_osimages, dbp_shellzips;

static StringToPointerHashMap<void> dbp_vdisk_filter;

static unsigned dbp_image_index;

struct DBP_InputBind

};

enum { DBP_MAX_PORTS = 8, DBP_KEYBOARD_PORT, DBP_PORT_MASK = 0x7, DBP_SHIFT_PORT_BIT = 0x80, DBP_NO_PORT = 255, DBP_JOY_ANALOG_RANGE = 0x8000 }; // analog stick range is -0x8000 to 0x8000

static const char* DBP_KBDNAMES[KBD_LAST+1] =

{

"None","1","2","3","4","5","6","7","8","9","0","Q","W","E","R","T","Y","U","I","O","P","A","S","D","F","G","H","J","K","L","Z","X","C","V","B","N","M",

"F1","F2","F3","F4","F5","F6","F7","F8","F9","F10","F11","F12","Esc","Tab","Backspace","Enter","Space","Left-Alt","Right-Alt","Left-Ctrl","Right-Ctrl","Left-Shift","Right-Shift",

"Caps-Lock","Scroll-Lock","Num-Lock","Grave `","Minus -","Equals =","Backslash","Left-Bracket [","Right-Bracket ]","Semicolon ;","Quote '","Period .","Comma ,","Slash /","Backslash \\",

"Print-Screen","Pause","Insert","Home","Page-Up","Delete","End","Page-Down","Left","Up","Down","Right","NP-1","NP-2","NP-3","NP-4","NP-5","NP-6","NP-7","NP-8","NP-9","NP-0",

"NP-Divide /","NP-Multiply *","NP-Minus -","NP-Plus +","NP-Enter","NP-Period .",""

};

static const char* DBP_YMLKeyCommands[KBD_LAST+3] =

{

"","1","2","3","4","5","6","7","8","9","0","q","w","e","r","t","y","u","i","o","p","a","s","d","f","g","h","j","k","l","z","x","c","v","b","n","m",

"f1","f2","f3","f4","f5","f6","f7","f8","f9","f10","f11","f12","esc","tab","backspace","enter","space","leftalt","rightalt","leftctrl","rightctrl","leftshift","rightshift",

"capslock","scrolllock","numlock","grave","minus","equals","backslash","leftbracket","rightbracket","semicolon","quote","period","comma","slash","extra_lt_gt",

"printscreen","pause","insert","home","pageup","delete","end","pagedown","left","up","down","right","kp1","kp2","kp3","kp4","kp5","kp6","kp7","kp8","kp9","kp0",

"kpdivide","kpmultiply","kpminus","kpplus","kpenter","kpperiod",

"wait","waitmodechange","delay"

};

static std::vector<DBP_InputBind> dbp_input_binds;

static Bit8u dbp_port_mode[DBP_MAX_PORTS], dbp_binds_changed, dbp_actionwheel_inputs;

static Bit16s dbp_mouse_x, dbp_mouse_y;

static int dbp_joy_analog_deadzone = (int)(0.15f * (float)DBP_JOY_ANALOG_RANGE);

#define DBP_GET_JOY_ANALOG_VALUE(V) ((V >= -dbp_joy_analog_deadzone && V <= dbp_joy_analog_deadzone) ? 0.0f : \

((float)((V > dbp_joy_analog_deadzone) ? (V - dbp_joy_analog_deadzone) : (V + dbp_joy_analog_deadzone)) / (float)(DBP_JOY_ANALOG_RANGE - dbp_joy_analog_deadzone)))

enum DBP_Event_Type : Bit8u

#define DBP_GETKEYDEVNAME(KEY) ((KEY) == KBD_NONE ? NULL : (KEY) < KBD_LAST ? DBPDEV_Keyboard : DBP_SpecialMappings[(KEY)-DBP_SPECIALMAPPINGS_KEY].dev)

#define DBP_GETKEYNAME(KEY) ((KEY) < KBD_LAST ? DBP_KBDNAMES[(KEY)] : DBP_SpecialMappings[(KEY)-DBP_SPECIALMAPPINGS_KEY].name)

_DBPET_MAX

};

static const char *DBPDEV_Keyboard = "Keyboard", *DBPDEV_Mouse = "Mouse", *DBPDEV_Joystick = "Joystick";

static const struct DBP_SpecialMapping { int16_t evt, meta; const char *dev, *name, *ymlid; } DBP_SpecialMappings[] =

{

{ DBPET_JOYMY, -1, DBPDEV_Mouse, "Move Up", "mouse_move_up" }, // 200

{ DBPET_JOYMY, 1, DBPDEV_Mouse, "Move Down", "mouse_move_down" }, // 201

{ DBPET_JOYMX, -1, DBPDEV_Mouse, "Move Left", "mouse_move_left" }, // 202

{ DBPET_JOYMX, 1, DBPDEV_Mouse, "Move Right", "mouse_move_right" }, // 203

{ DBPET_MOUSEDOWN, 0, DBPDEV_Mouse, "Left Click", "mouse_left_click" }, // 204

{ DBPET_MOUSEDOWN, 1, DBPDEV_Mouse, "Right Click", "mouse_right_click" }, // 205

{ DBPET_MOUSEDOWN, 2, DBPDEV_Mouse, "Middle Click", "mouse_middle_click" }, // 206

{ DBPET_MOUSESETSPEED, 1, DBPDEV_Mouse, "Speed Up", "mouse_speed_up" }, // 207

{ DBPET_MOUSESETSPEED, -1, DBPDEV_Mouse, "Slow Down", "mouse_speed_down" }, // 208

{ DBPET_JOY1Y, -1, DBPDEV_Joystick, "Up", "joy_up" }, // 209

{ DBPET_JOY1Y, 1, DBPDEV_Joystick, "Down", "joy_down" }, // 210

{ DBPET_JOY1X, -1, DBPDEV_Joystick, "Left", "joy_left" }, // 211

{ DBPET_JOY1X, 1, DBPDEV_Joystick, "Right", "joy_right" }, // 212

{ DBPET_JOY1DOWN, 0, DBPDEV_Joystick, "Button 1", "joy_button1" }, // 213

{ DBPET_JOY1DOWN, 1, DBPDEV_Joystick, "Button 2", "joy_button2" }, // 214

{ DBPET_JOY2DOWN, 0, DBPDEV_Joystick, "Button 3", "joy_button3" }, // 215

{ DBPET_JOY2DOWN, 1, DBPDEV_Joystick, "Button 4", "joy_button4" }, // 216

{ DBPET_JOYHATSETBIT, 8, DBPDEV_Joystick, "Hat Up", "joy_hat_up" }, // 217

{ DBPET_JOYHATSETBIT, 2, DBPDEV_Joystick, "Hat Down", "joy_hat_down" }, // 218

{ DBPET_JOYHATSETBIT, 1, DBPDEV_Joystick, "Hat Left", "joy_hat_left" }, // 219

{ DBPET_JOYHATSETBIT, 4, DBPDEV_Joystick, "Hat Right", "joy_hat_right" }, // 220

{ DBPET_JOY2Y, -1, DBPDEV_Joystick, "Joy 2 Up", "joy_2_up" }, // 221

{ DBPET_JOY2Y, 1, DBPDEV_Joystick, "Joy 2 Down", "joy_2_down" }, // 222

{ DBPET_JOY2X, -1, DBPDEV_Joystick, "Joy 2 Left", "joy_2_left" }, // 223

{ DBPET_JOY2X, 1, DBPDEV_Joystick, "Joy 2 Right", "joy_2_right" }, // 224

{ DBPET_TOGGLEOSD, 0, NULL, "Open Menu / Keyboard" }, // 225

{ DBPET_ACTIONWHEEL, 0, NULL, "Action Wheel", "wheel" }, // 226

{ DBPET_SHIFTPORT, 0, NULL, "Port #1 while holding" }, // 227

{ DBPET_SHIFTPORT, 1, NULL, "Port #2 while holding" }, // 228

{ DBPET_SHIFTPORT, 2, NULL, "Port #3 while holding" }, // 229

{ DBPET_SHIFTPORT, 3, NULL, "Port #4 while holding" }, // 230

};

#define DBP_SPECIALMAPPING(key) DBP_SpecialMappings[(key)-DBP_SPECIALMAPPINGS_KEY]

enum { DBP_SPECIALMAPPINGS_KEY = 200, DBP_SPECIALMAPPINGS_MAX = 200+(sizeof(DBP_SpecialMappings)/sizeof(DBP_SpecialMappings[0])) };

enum { DBP_SPECIALMAPPINGS_OSD = 225, DBP_SPECIALMAPPINGS_ACTIONWHEEL = 226 };

enum { DBP_EVENT_QUEUE_SIZE = 256, DBP_DOWN_COUNT_MASK = 127, DBP_DOWN_BY_KEYBOARD = 128 };

static struct DBP_Event { DBP_Event_Type type; Bit8u port; int val, val2; } dbp_event_queue[DBP_EVENT_QUEUE_SIZE];

static int dbp_event_queue_write_cursor;

static int dbp_event_queue_read_cursor;

static int dbp_keys_down_count;

static unsigned char dbp_keys_down[KBD_LAST + 21];

static unsigned short dbp_keymap_dos2retro[KBD_LAST];

static unsigned char dbp_keymap_retro2dos[RETROK_LAST];

struct DBP_Interceptor

};

static DBP_Interceptor *dbp_intercept, *dbp_intercept_next;

static void DBP_SetIntercept(DBP_Interceptor* intercept) { if (!dbp_intercept) dbp_intercept = intercept; dbp_intercept_next = intercept; }

#ifndef ANDROID

static void retro_fallback_log(enum retro_log_level level, const char *fmt, ...)

}

#else

extern "C" int __android_log_write(int prio, const char *tag, const char *text);

static void retro_fallback_log(enum retro_log_level level, const char *fmt, ...) { static char buf[8192]; va_list va; va_start(va, fmt); vsprintf(buf, fmt, va); va_end(va); __android_log_write(2, "DBP", buf); }

#endif

extern retro_time_t dbp_cpu_features_get_time_usec(void);

static retro_perf_get_time_usec_t time_cb = dbp_cpu_features_get_time_usec;

static retro_log_printf_t log_cb = retro_fallback_log;

static retro_environment_t environ_cb;

static retro_video_refresh_t video_cb;

static retro_audio_sample_batch_t audio_batch_cb;

static retro_input_poll_t input_poll_cb;

static retro_input_state_t input_state_cb;

static enum DBP_Perf : Bit8u { DBP_PERF_NONE, DBP_PERF_SIMPLE, DBP_PERF_DETAILED } dbp_perf;

static Bit32u dbp_perf_uniquedraw, dbp_perf_count, dbp_perf_totaltime;

#ifdef DBP_ENABLE_WAITSTATS

static Bit32u dbp_wait_pause, dbp_wait_finish, dbp_wait_paused, dbp_wait_continue;

#endif

#ifdef DBP_ENABLE_FPS_COUNTERS

static Bit32u dbp_lastfpstick, dbp_fpscount_retro, dbp_fpscount_gfxstart, dbp_fpscount_gfxend, dbp_fpscount_event, dbp_fpscount_skip_run, dbp_fpscount_skip_render;

#define DBP_FPSCOUNT(DBP_FPSCOUNT_VARNAME) DBP_FPSCOUNT_VARNAME++;

#else

#define DBP_FPSCOUNT(DBP_FPSCOUNT_VARNAME)

#endif

void setup_retro_notify(retro_message_ext& msg, int duration, retro_log_level lvl, char const* format, va_list ap)

}

void retro_notify(int duration, retro_log_level lvl, char const* format,...)

}

static retro_message_ext* dbp_message_queue;

void emuthread_notify(int duration, LOG_SEVERITIES lvl, char const* format,...)

}

static void run_emuthread_notify()

}

static const char* retro_get_variable(const char* key, const char* default_value)

{

retro_variable var = { key };

return (environ_cb && environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var) && var.value ? var.value : default_value);

}

void DBP_DOSBOX_ForceShutdown(const Bitu = 0);

void DBP_CPU_ModifyCycles(const char* val, const char* params = NULL);

void DBP_KEYBOARD_ReleaseKeys();

void DBP_CGA_SetModelAndComposite(bool new_model, Bitu new_comp_mode);

void DBP_Hercules_SetPalette(Bit8u pal);

void DBP_SetMountSwappingRequested();

Bit32u DBP_MIXER_GetFrequency();

Bit32u DBP_MIXER_DoneSamplesCount();

void DBP_MIXER_ScrapAudio();

void MIXER_CallBack(void *userdata, uint8_t *stream, int len);

bool MSCDEX_HasDrive(char driveLetter);

int MSCDEX_AddDrive(char driveLetter, const char* physicalPath, Bit8u& subUnit);

int MSCDEX_RemoveDrive(char driveLetter);

void IDE_RefreshCDROMs();

void IDE_SetupControllers(bool alwaysHaveCDROM);

void NET_SetupEthernet();

bool MIDI_TSF_SwitchSF(const char*);

const char* DBP_MIDI_StartupError(Section* midisec, const char*& arg);

static void DBP_ForceReset(bool forcemenu = false);

static void DBP_QueueEvent(DBP_Event_Type type, Bit8u port, int val = 0, int val2 = 0)

}

static void DBP_ReleaseKeyEvents(bool onlyPhysicalKeys)

}

void DBP_InputBind::Update(Bit16s val, bool is_analog_button)

}

static void DBP_ReportCoreMemoryMaps()

}

enum DBP_ThreadCtlMode { TCM_PAUSE_FRAME, TCM_ON_PAUSE_FRAME, TCM_RESUME_FRAME, TCM_FINISH_FRAME, TCM_ON_FINISH_FRAME, TCM_NEXT_FRAME, TCM_SHUTDOWN, TCM_ON_SHUTDOWN };

static void DBP_ThreadControl(DBP_ThreadCtlMode m)

}

static inline Bit32s DBP_CyclesForYear(int year, int year_max = 0x7FFFFFF)

}

static void DBP_SetCyclesByYear(int year, int year_max)

}

void DBP_SetRealModeCycles()

}

static int DBP_NeedFrameSkip(bool in_emulation)

}

bool DBP_Image_IsCD(const DBP_Image& image)

}

const char* DBP_Image_Label(const DBP_Image& image)

{

return (image.longpath.length() ? image.longpath : image.path).c_str() + image.dirlen;

}

static unsigned DBP_AppendImage(const char* in_path, bool sorted)

}

static bool DBP_ExtractPathInfo(const char* path, const char ** out_path_file = NULL, size_t* out_namelen = NULL, const char ** out_ext = NULL, const char ** out_fragment = NULL, char* out_letter = NULL)

}

static bool DBP_IsMounted(char drive)

}

void DBP_Unmount(char drive)

}

enum DBP_SaveFileType { SFT_GAMESAVE, SFT_SAVENAMEREDIRECT, SFT_VIRTUALDISK, SFT_DIFFDISK, _SFT_LAST_SAVE_DIRECTORY, SFT_SYSTEMDIR, SFT_NEWOSIMAGE };

static std::string DBP_GetSaveFile(DBP_SaveFileType type, const char** out_filename = NULL, Bit32u* out_diskhash = NULL)

}

FILE* DBP_FileOpenContentOrSystem(const char* fname)

{

std::string tmp;

const char *p = fname, *content = dbp_content_path.c_str(), *content_fs = strrchr(content, '/'), *content_bs = strrchr(content, '\\');

const char* content_dir_end = ((content_fs || content_bs) ? (content_fs > content_bs ? content_fs : content_bs) + 1 : content + dbp_content_path.length());

if (content_dir_end != content) p = tmp.append(content, (content_dir_end - content)).append((size_t)(!content_fs && !content_bs), CROSS_FILESPLIT).append(fname).c_str();

if (FILE* f = fopen_wrap(p, "rb")) return f;

return fopen_wrap((tmp = DBP_GetSaveFile(SFT_SYSTEMDIR)).append(fname).c_str(), "rb");

}

static void DBP_SetDriveLabelFromContentPath(DOS_Drive* drive, const char *path, char letter = 'C', const char *path_file = NULL, const char *ext = NULL, bool forceAppendExtension = false)

}

static bool DBP_IsDiskCDISO(imageDisk* id)

}

static DOS_Drive* DBP_Mount(unsigned image_index = 0, bool unmount_existing = true, char remount_letter = 0, const char* boot = NULL)

{

DBP_Image* dbpimage = (!boot ? &dbp_images[image_index] : NULL);

const char *path = (dbpimage ? dbpimage->path.c_str() : boot), *path_file, *ext, *fragment; char letter;

if (!DBP_ExtractPathInfo(path, &path_file, NULL, &ext, &fragment, &letter)) return NULL;

if (remount_letter) letter = remount_letter;

std::string path_no_fragment;

if (dbpimage && dbpimage->imgmount)

{

// somewhat dangerous to set ext as not part of path but it is OK for the IMG and ISO code paths below

if (dbpimage->imfat) ext = "IMG";

if (dbpimage->imiso) ext = "ISO";

if (!remount_letter) letter = remount_letter = dbpimage->drive;

}

else if (fragment)

{

path_no_fragment.assign(path, fragment - path);

ext = path_no_fragment.c_str() + (ext - path);

path_file = path_no_fragment.c_str() + (path_file - path);

path = path_no_fragment.c_str();

}

DOS_Drive *drive = NULL;

imageDisk* disk = NULL;

CDROM_Interface* cdrom = NULL;

Bit8u media_byte = 0;

const char* error_type = "content";

if (!strcasecmp(ext, "ZIP") || !strcasecmp(ext, "DOSZ") || !strcasecmp(ext, "DOSC"))

{

if (!letter) letter = (boot ? 'C' : 'D');

if (!unmount_existing && Drives[letter-'A']) return NULL;

std::string* ziperr = NULL;

if ((ext[3]|0x20) != 'c')

drive = zipDrive::MountWithDependencies(path, ziperr, dbp_strict_mode, dbp_legacy_save);

else

{

// When loading a DOSC file, load the corresponding DOSZ file, but strip out a [VARIANT] specifier at the end.

std::string dosz_path(path);

dosz_path.back() = (ext[3] == 'c' ? 'z' : 'Z'); // swap dosc -> dosz with same capitalization

if (const char* dosc_variant = (ext[-2] == ']' ? strrchr(path_file, '[') : NULL))

{

while (dosc_variant > path_file && dosc_variant[-1] == ' ') dosc_variant--;

size_t dosc_variant_len = (ext - 1 - dosc_variant);

dosz_path.erase(dosc_variant - path, dosc_variant_len);

}

drive = zipDrive::MountWithDependencies(dosz_path.c_str(), ziperr, dbp_strict_mode, dbp_legacy_save, path);

}

if (!drive)

{

if (ziperr) { emuthread_notify(0, LOG_ERROR, "%s", ziperr->c_str()); delete ziperr; }

error_type = "ZIP";

goto TRY_DIRECTORY;

}

DBP_SetDriveLabelFromContentPath(drive, path, letter, path_file, ext);

if (boot && letter == 'C') return drive;

}

else if (!strcasecmp(ext, "IMG") || !strcasecmp(ext, "IMA") || !strcasecmp(ext, "VHD") || !strcasecmp(ext, "JRC"))

{

fatDrive* fat = new fatDrive(path, 512, 0, 0, 0, 0);

if (!fat->loadedDisk || (!fat->created_successfully && letter >= 'A'+MAX_DISK_IMAGES))

{

FAT_TRY_ISO: