Commit what we need for libretro-common

Makefile.common

@@ -10,9 +10,8 @@ INCFLAGS += -I$(CORE_DIR)/libretro/include
 endif
 
 SOURCES_C := \
-	$(LIBRETRO_COMM_DIR)/libco/libco.c
-
-SOURCES_C += $(LIBRETRO_COMM_DIR)/compat/compat_strl.c \
+	$(LIBRETRO_COMM_DIR)/libco/libco.c \
+	$(LIBRETRO_COMM_DIR)/compat/compat_strl.c \
 	$(LIBRETRO_COMM_DIR)/compat/compat_strcasestr.c \
 	$(LIBRETRO_COMM_DIR)/compat/fopen_utf8.c \
 	$(LIBRETRO_COMM_DIR)/encodings/encoding_utf.c \

libretro/libretro-common/compat/compat_posix_string.c

@@ -0,0 +1,104 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (compat_posix_string.c).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <ctype.h>
+
+#include <compat/posix_string.h>
+
+#ifdef _WIN32
+
+#undef strcasecmp
+#undef strdup
+#undef isblank
+#undef strtok_r
+#include <ctype.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <compat/strl.h>
+
+#include <string.h>
+
+int retro_strcasecmp__(const char *a, const char *b)
+{
+   while (*a && *b)
+   {
+      int a_ = tolower(*a);
+      int b_ = tolower(*b);
+
+      if (a_ != b_)
+         return a_ - b_;
+
+      a++;
+      b++;
+   }
+
+   return tolower(*a) - tolower(*b);
+}
+
+char *retro_strdup__(const char *orig)
+{
+   size_t len = strlen(orig) + 1;
+   char *ret  = (char*)malloc(len);
+   if (!ret)
+      return NULL;
+
+   strlcpy(ret, orig, len);
+   return ret;
+}
+
+int retro_isblank__(int c)
+{
+   return (c == ' ') || (c == '\t');
+}
+
+char *retro_strtok_r__(char *str, const char *delim, char **saveptr)
+{
+   char *first = NULL;
+   if (!saveptr || !delim)
+      return NULL;
+
+   if (str)
+      *saveptr = str;
+
+   do
+   {
+      char *ptr = NULL;
+      first = *saveptr;
+      while (*first && strchr(delim, *first))
+         *first++ = '\0';
+
+      if (*first == '\0')
+         return NULL;
+
+      ptr = first + 1;
+
+      while (*ptr && !strchr(delim, *ptr))
+         ptr++;
+
+      *saveptr = ptr + (*ptr ? 1 : 0);
+      *ptr     = '\0';
+   } while (strlen(first) == 0);
+
+   return first;
+}
+
+#endif

libretro/libretro-common/compat/compat_snprintf.c

@@ -0,0 +1,83 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (compat_snprintf.c).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+/* THIS FILE HAS NOT BEEN VALIDATED ON PLATFORMS BESIDES MSVC */
+#ifdef _MSC_VER
+
+#include <stdio.h>
+#include <stdarg.h>
+
+#if _MSC_VER < 1800
+#define va_copy(dst, src) ((dst) = (src))
+#endif
+
+#if _MSC_VER < 1300
+#define _vscprintf c89_vscprintf_retro__
+
+static int c89_vscprintf_retro__(const char *fmt, va_list pargs)
+{
+   int retval;
+   va_list argcopy;
+   va_copy(argcopy, pargs);
+   retval = vsnprintf(NULL, 0, fmt, argcopy);
+   va_end(argcopy);
+   return retval;
+}
+#endif
+
+/* http://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010 */
+
+int c99_vsnprintf_retro__(char *s, size_t len, const char *fmt, va_list ap)
+{
+   int count = -1;
+
+   if (len != 0)
+   {
+#if (_MSC_VER <= 1310)
+      count = _vsnprintf(s, len - 1, fmt, ap);
+#else
+      count = _vsnprintf_s(s, len, len - 1, fmt, ap);
+#endif
+   }
+
+   if (count == -1)
+       count = _vscprintf(fmt, ap);
+
+   /* there was no room for a NULL, so truncate the last character */
+   if (count == len && len)
+      s[len - 1] = '\0';
+
+   return count;
+}
+
+int c99_snprintf_retro__(char *s, size_t len, const char *fmt, ...)
+{
+   int count;
+   va_list ap;
+
+   va_start(ap, fmt);
+   count = c99_vsnprintf_retro__(s, len, fmt, ap);
+   va_end(ap);
+
+   return count;
+}
+#endif

libretro/libretro-common/compat/compat_strcasestr.c

@@ -0,0 +1,58 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (compat_strcasestr.c).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <ctype.h>
+
+#include <compat/strcasestr.h>
+
+/* Pretty much strncasecmp. */
+static int casencmp(const char *a, const char *b, size_t n)
+{
+   size_t i;
+
+   for (i = 0; i < n; i++)
+   {
+      int a_lower = tolower(a[i]);
+      int b_lower = tolower(b[i]);
+      if (a_lower != b_lower)
+         return a_lower - b_lower;
+   }
+
+   return 0;
+}
+
+char *strcasestr_retro__(const char *haystack, const char *needle)
+{
+   size_t i, search_off;
+   size_t hay_len    = strlen(haystack);
+   size_t needle_len = strlen(needle);
+
+   if (needle_len > hay_len)
+      return NULL;
+
+   search_off = hay_len - needle_len;
+   for (i = 0; i <= search_off; i++)
+      if (!casencmp(haystack + i, needle, needle_len))
+         return (char*)haystack + i;
+
+   return NULL;
+}

libretro/libretro-common/compat/compat_strl.c

@@ -0,0 +1,69 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (compat_strl.c).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <ctype.h>
+
+#include <compat/strl.h>
+
+/* Implementation of strlcpy()/strlcat() based on OpenBSD. */
+
+#ifndef __MACH__
+
+size_t strlcpy(char *dest, const char *source, size_t size)
+{
+   size_t src_size = 0;
+   size_t        n = size;
+
+   if (n)
+      while (--n && (*dest++ = *source++)) src_size++;
+
+   if (!n)
+   {
+      if (size) *dest = '\0';
+      while (*source++) src_size++;
+   }
+
+   return src_size;
+}
+
+size_t strlcat(char *dest, const char *source, size_t size)
+{
+   size_t len = strlen(dest);
+
+   dest += len;
+
+   if (len > size)
+      size = 0;
+   else
+      size -= len;
+
+   return len + strlcpy(dest, source, size);
+}
+#endif
+
+char *strldup(const char *s, size_t n)
+{
+   char *dst = (char*)malloc(sizeof(char) * (n + 1));
+   strlcpy(dst, s, n);
+   return dst;
+}

libretro/libretro-common/compat/fopen_utf8.c

@@ -0,0 +1,58 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (fopen_utf8.c).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <compat/fopen_utf8.h>
+#include <encodings/utf.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0500 || defined(_XBOX)
+#ifndef LEGACY_WIN32
+#define LEGACY_WIN32
+#endif
+#endif
+
+#ifdef _WIN32
+#undef fopen
+
+void *fopen_utf8(const char * filename, const char * mode)
+{
+#if defined(LEGACY_WIN32)
+   FILE             *ret = NULL;
+   char * filename_local = utf8_to_local_string_alloc(filename);
+
+   if (!filename_local)
+      return NULL;
+   ret = fopen(filename_local, mode);
+   if (filename_local)
+      free(filename_local);
+   return ret;
+#else
+   wchar_t * filename_w = utf8_to_utf16_string_alloc(filename);
+   wchar_t * mode_w = utf8_to_utf16_string_alloc(mode);
+   FILE* ret = _wfopen(filename_w, mode_w);
+   free(filename_w);
+   free(mode_w);
+   return ret;
+#endif
+}
+#endif

libretro/libretro-common/encodings/encoding_utf.c

@@ -0,0 +1,512 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (encoding_utf.c).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <string.h>
+
+#include <boolean.h>
+#include <compat/strl.h>
+#include <retro_inline.h>
+
+#include <encodings/utf.h>
+
+#if defined(_WIN32) && !defined(_XBOX)
+#include <windows.h>
+#elif defined(_XBOX)
+#include <xtl.h>
+#endif
+
+#define UTF8_WALKBYTE(string) (*((*(string))++))
+
+static unsigned leading_ones(uint8_t c)
+{
+   unsigned ones = 0;
+   while (c & 0x80)
+   {
+      ones++;
+      c <<= 1;
+   }
+
+   return ones;
+}
+
+/* Simple implementation. Assumes the sequence is
+ * properly synchronized and terminated. */
+
+size_t utf8_conv_utf32(uint32_t *out, size_t out_chars,
+      const char *in, size_t in_size)
+{
+   unsigned i;
+   size_t ret = 0;
+   while (in_size && out_chars)
+   {
+      unsigned extra, shift;
+      uint32_t c;
+      uint8_t first = *in++;
+      unsigned ones = leading_ones(first);
+
+      if (ones > 6 || ones == 1) /* Invalid or desync. */
+         break;
+
+      extra = ones ? ones - 1 : ones;
+      if (1 + extra > in_size) /* Overflow. */
+         break;
+
+      shift = (extra - 1) * 6;
+      c     = (first & ((1 << (7 - ones)) - 1)) << (6 * extra);
+
+      for (i = 0; i < extra; i++, in++, shift -= 6)
+         c |= (*in & 0x3f) << shift;
+
+      *out++ = c;
+      in_size -= 1 + extra;
+      out_chars--;
+      ret++;
+   }
+
+   return ret;
+}
+
+bool utf16_conv_utf8(uint8_t *out, size_t *out_chars,
+     const uint16_t *in, size_t in_size)
+{
+   size_t out_pos            = 0;
+   size_t in_pos             = 0;
+   static const 
+      uint8_t utf8_limits[5] = { 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
+
+   for (;;)
+   {
+      unsigned num_adds;
+      uint32_t value;
+
+      if (in_pos == in_size)
+      {
+         *out_chars = out_pos;
+         return true;
+      }
+      value = in[in_pos++];
+      if (value < 0x80)
+      {
+         if (out)
+            out[out_pos] = (char)value;
+         out_pos++;
+         continue;
+      }
+
+      if (value >= 0xD800 && value < 0xE000)
+      {
+         uint32_t c2;
+
+         if (value >= 0xDC00 || in_pos == in_size)
+            break;
+         c2 = in[in_pos++];
+         if (c2 < 0xDC00 || c2 >= 0xE000)
+            break;
+         value = (((value - 0xD800) << 10) | (c2 - 0xDC00)) + 0x10000;
+      }
+
+      for (num_adds = 1; num_adds < 5; num_adds++)
+         if (value < (((uint32_t)1) << (num_adds * 5 + 6)))
+            break;
+      if (out)
+         out[out_pos] = (char)(utf8_limits[num_adds - 1]
+               + (value >> (6 * num_adds)));
+      out_pos++;
+      do
+      {
+         num_adds--;
+         if (out)
+            out[out_pos] = (char)(0x80
+                  + ((value >> (6 * num_adds)) & 0x3F));
+         out_pos++;
+      }while (num_adds != 0);
+   }
+
+   *out_chars = out_pos;
+   return false;
+}
+
+/* Acts mostly like strlcpy.
+ *
+ * Copies the given number of UTF-8 characters,
+ * but at most d_len bytes.
+ *
+ * Always NULL terminates.
+ * Does not copy half a character.
+ *
+ * Returns number of bytes. 's' is assumed valid UTF-8.
+ * Use only if 'chars' is considerably less than 'd_len'. */
+size_t utf8cpy(char *d, size_t d_len, const char *s, size_t chars)
+{
+   const uint8_t *sb     = (const uint8_t*)s;
+   const uint8_t *sb_org = sb;
+
+   if (!s)
+      return 0;
+
+   while (*sb && chars-- > 0)
+   {
+      sb++;
+      while ((*sb & 0xC0) == 0x80)
+         sb++;
+   }
+
+   if ((size_t)(sb - sb_org) > d_len-1 /* NUL */)
+   {
+      sb = sb_org + d_len-1;
+      while ((*sb & 0xC0) == 0x80)
+         sb--;
+   }
+
+   memcpy(d, sb_org, sb-sb_org);
+   d[sb-sb_org] = '\0';
+
+   return sb-sb_org;
+}
+
+const char *utf8skip(const char *str, size_t chars)
+{
+   const uint8_t *strb = (const uint8_t*)str;
+
+   if (!chars)
+      return str;
+
+   do
+   {
+      strb++;
+      while ((*strb & 0xC0)==0x80)
+         strb++;
+      chars--;
+   }while (chars);
+
+   return (const char*)strb;
+}
+
+size_t utf8len(const char *string)
+{
+   size_t ret = 0;
+
+   if (!string)
+      return 0;
+
+   while (*string)
+   {
+      if ((*string & 0xC0) != 0x80)
+         ret++;
+      string++;
+   }
+   return ret;
+}
+
+/* Does not validate the input, returns garbage if it's not UTF-8. */
+uint32_t utf8_walk(const char **string)
+{
+   uint8_t first = UTF8_WALKBYTE(string);
+   uint32_t ret  = 0;
+
+   if (first < 128)
+      return first;
+
+   ret    = (ret << 6) | (UTF8_WALKBYTE(string) & 0x3F);
+   if (first >= 0xE0)
+   {
+      ret = (ret << 6) | (UTF8_WALKBYTE(string) & 0x3F);
+      if (first >= 0xF0)
+      {
+         ret = (ret << 6) | (UTF8_WALKBYTE(string) & 0x3F);
+         return ret | (first & 7) << 18;
+      }
+      return ret | (first & 15) << 12;
+   }
+
+   return ret | (first & 31) << 6;
+}
+
+static bool utf16_to_char(uint8_t **utf_data,
+      size_t *dest_len, const uint16_t *in)
+{
+   unsigned len    = 0;
+
+   while (in[len] != '\0')
+      len++;
+
+   utf16_conv_utf8(NULL, dest_len, in, len);
+   *dest_len  += 1;
+   *utf_data   = (uint8_t*)malloc(*dest_len);
+   if (*utf_data == 0)
+      return false;
+
+   return utf16_conv_utf8(*utf_data, dest_len, in, len);
+}
+
+bool utf16_to_char_string(const uint16_t *in, char *s, size_t len)
+{
+   size_t     dest_len  = 0;
+   uint8_t *utf16_data  = NULL;
+   bool            ret  = utf16_to_char(&utf16_data, &dest_len, in);
+
+   if (ret)
+   {
+      utf16_data[dest_len] = 0;
+      strlcpy(s, (const char*)utf16_data, len);
+   }
+
+   free(utf16_data);
+   utf16_data = NULL;
+
+   return ret;
+}
+
+#if defined(_WIN32) && !defined(_XBOX) && !defined(UNICODE)
+/* Returned pointer MUST be freed by the caller if non-NULL. */
+static char *mb_to_mb_string_alloc(const char *str,
+      enum CodePage cp_in, enum CodePage cp_out)
+{
+   wchar_t *path_buf_wide = NULL;
+   int path_buf_wide_len  = MultiByteToWideChar(cp_in, 0, str, -1, NULL, 0);
+
+   /* Windows 95 will return 0 from these functions with 
+    * a UTF8 codepage set without MSLU.
+    *
+    * From an unknown MSDN version (others omit this info):
+    *   - CP_UTF8 Windows 98/Me, Windows NT 4.0 and later: 
+    *   Translate using UTF-8. When this is set, dwFlags must be zero.
+    *   - Windows 95: Under the Microsoft Layer for Unicode, 
+    *   MultiByteToWideChar also supports CP_UTF7 and CP_UTF8.
+    */
+
+   if (!path_buf_wide_len)
+      return strdup(str);
+
+   path_buf_wide = (wchar_t*)
+      calloc(path_buf_wide_len + sizeof(wchar_t), sizeof(wchar_t));
+
+   if (path_buf_wide)
+   {
+      MultiByteToWideChar(cp_in, 0,
+            str, -1, path_buf_wide, path_buf_wide_len);
+
+      if (*path_buf_wide)
+      {
+         int path_buf_len = WideCharToMultiByte(cp_out, 0,
+               path_buf_wide, -1, NULL, 0, NULL, NULL);
+
+         if (path_buf_len)
+         {
+            char *path_buf = (char*)
+               calloc(path_buf_len + sizeof(char), sizeof(char));
+
+            if (path_buf)
+            {
+               WideCharToMultiByte(cp_out, 0,
+                     path_buf_wide, -1, path_buf,
+                     path_buf_len, NULL, NULL);
+
+               free(path_buf_wide);
+
+               if (*path_buf)
+                  return path_buf;
+
+               free(path_buf);
+               return NULL;
+            }
+         }
+         else
+         {
+            free(path_buf_wide);
+            return strdup(str);
+         }
+      }
+
+      free(path_buf_wide);
+   }
+
+   return NULL;
+}
+#endif
+
+/* Returned pointer MUST be freed by the caller if non-NULL. */
+char* utf8_to_local_string_alloc(const char *str)
+{
+   if (str && *str)
+   {
+#if defined(_WIN32) && !defined(_XBOX) && !defined(UNICODE)
+      return mb_to_mb_string_alloc(str, CODEPAGE_UTF8, CODEPAGE_LOCAL);
+#else
+      /* assume string needs no modification if not on Windows */
+      return strdup(str);
+#endif
+   }
+   return NULL;
+}
+
+/* Returned pointer MUST be freed by the caller if non-NULL. */
+char* local_to_utf8_string_alloc(const char *str)
+{
+   if (str && *str)
+   {
+#if defined(_WIN32) && !defined(_XBOX) && !defined(UNICODE)
+      return mb_to_mb_string_alloc(str, CODEPAGE_LOCAL, CODEPAGE_UTF8);
+#else
+      /* assume string needs no modification if not on Windows */
+      return strdup(str);
+#endif
+   }
+   return NULL;
+}
+
+/* Returned pointer MUST be freed by the caller if non-NULL. */
+wchar_t* utf8_to_utf16_string_alloc(const char *str)
+{
+#ifdef _WIN32
+   int len        = 0;
+   int out_len    = 0;
+#else
+   size_t len     = 0;
+   size_t out_len = 0;
+#endif
+   wchar_t *buf   = NULL;
+
+   if (!str || !*str)
+      return NULL;
+
+#ifdef _WIN32
+   len = MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0);
+
+   if (len)
+   {
+      buf = (wchar_t*)calloc(len, sizeof(wchar_t));
+
+      if (!buf)
+         return NULL;
+
+      out_len = MultiByteToWideChar(CP_UTF8, 0, str, -1, buf, len);
+   }
+   else
+   {
+      /* fallback to ANSI codepage instead */
+      len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
+
+      if (len)
+      {
+         buf = (wchar_t*)calloc(len, sizeof(wchar_t));
+
+         if (!buf)
+            return NULL;
+
+         out_len = MultiByteToWideChar(CP_ACP, 0, str, -1, buf, len);
+      }
+   }
+
+   if (out_len < 0)
+   {
+      free(buf);
+      return NULL;
+   }
+#else
+   /* NOTE: For now, assume non-Windows platforms' locale is already UTF-8. */
+   len = mbstowcs(NULL, str, 0) + 1;
+
+   if (len)
+   {
+      buf = (wchar_t*)calloc(len, sizeof(wchar_t));
+
+      if (!buf)
+         return NULL;
+
+      out_len = mbstowcs(buf, str, len);
+   }
+
+   if (out_len == (size_t)-1)
+   {
+      free(buf);
+      return NULL;
+   }
+#endif
+
+   return buf;
+}
+
+/* Returned pointer MUST be freed by the caller if non-NULL. */
+char* utf16_to_utf8_string_alloc(const wchar_t *str)
+{
+#ifdef _WIN32
+   int len        = 0;
+#else
+   size_t len     = 0;
+#endif
+   char *buf      = NULL;
+
+   if (!str || !*str)
+      return NULL;
+
+#ifdef _WIN32
+   {
+      UINT code_page = CP_UTF8;
+      len            = WideCharToMultiByte(code_page,
+            0, str, -1, NULL, 0, NULL, NULL);
+
+      /* fallback to ANSI codepage instead */
+      if (!len)
+      {
+         code_page   = CP_ACP;
+         len         = WideCharToMultiByte(code_page,
+               0, str, -1, NULL, 0, NULL, NULL);
+      }
+
+      buf = (char*)calloc(len, sizeof(char));
+
+      if (!buf)
+         return NULL;
+
+      if (WideCharToMultiByte(code_page,
+            0, str, -1, buf, len, NULL, NULL) < 0)
+      {
+         free(buf);
+         return NULL;
+      }
+   }
+#else
+   /* NOTE: For now, assume non-Windows platforms' 
+    * locale is already UTF-8. */
+   len = wcstombs(NULL, str, 0) + 1;
+
+   if (len)
+   {
+      buf = (char*)calloc(len, sizeof(char));
+
+      if (!buf)
+         return NULL;
+
+      if (wcstombs(buf, str, len) == (size_t)-1)
+      {
+         free(buf);
+         return NULL;
+      }
+   }
+#endif
+
+   return buf;
+}

libretro/libretro-common/file/file_path_io.c

@@ -0,0 +1,224 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (file_path_io.c).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <errno.h>
+
+#include <sys/stat.h>
+
+#include <boolean.h>
+#include <file/file_path.h>
+#include <retro_assert.h>
+#include <string/stdstring.h>
+#define VFS_FRONTEND
+#include <vfs/vfs_implementation.h>
+
+/* TODO: There are probably some unnecessary things on this huge include list now but I'm too afraid to touch it */
+#ifdef __APPLE__
+#include <CoreFoundation/CoreFoundation.h>
+#endif
+#ifdef __HAIKU__
+#include <kernel/image.h>
+#endif
+#ifndef __MACH__
+#include <compat/strl.h>
+#include <compat/posix_string.h>
+#endif
+#include <compat/strcasestr.h>
+#include <retro_miscellaneous.h>
+#include <encodings/utf.h>
+
+#if defined(_WIN32)
+#ifdef _MSC_VER
+#define setmode _setmode
+#endif
+#include <sys/stat.h>
+#ifdef _XBOX
+#include <xtl.h>
+#define INVALID_FILE_ATTRIBUTES -1
+#else
+#include <io.h>
+#include <fcntl.h>
+#include <direct.h>
+#include <windows.h>
+#if defined(_MSC_VER) && _MSC_VER <= 1200
+#define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
+#endif
+#endif
+#elif defined(VITA)
+#define SCE_ERROR_ERRNO_EEXIST 0x80010011
+#include <psp2/io/fcntl.h>
+#include <psp2/io/dirent.h>
+#include <psp2/io/stat.h>
+#else
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#endif
+
+#if defined(PSP)
+#include <pspkernel.h>
+#endif
+
+#if defined(__CELLOS_LV2__) && !defined(__PSL1GHT__)
+#include <cell/cell_fs.h>
+#endif
+
+#if defined(VITA)
+#define FIO_S_ISDIR SCE_S_ISDIR
+#endif
+
+#if (defined(__CELLOS_LV2__) && !defined(__PSL1GHT__)) || defined(__QNX__) || defined(PSP) || defined(PS2)
+#include <unistd.h> /* stat() is defined here */
+#endif
+
+#if !defined(RARCH_CONSOLE) && defined(RARCH_INTERNAL)
+#ifdef __WINRT__
+#include <uwp/uwp_func.h>
+#endif
+#endif
+
+/* Assume W-functions do not work below Win2K and Xbox platforms */
+#if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0500 || defined(_XBOX)
+
+#ifndef LEGACY_WIN32
+#define LEGACY_WIN32
+#endif
+
+#endif
+
+/* TODO/FIXME - globals */
+static retro_vfs_stat_t path_stat_cb   = retro_vfs_stat_impl;
+static retro_vfs_mkdir_t path_mkdir_cb = retro_vfs_mkdir_impl;
+
+void path_vfs_init(const struct retro_vfs_interface_info* vfs_info)
+{
+   const struct retro_vfs_interface* 
+      vfs_iface           = vfs_info->iface;
+
+   path_stat_cb           = retro_vfs_stat_impl;
+   path_mkdir_cb          = retro_vfs_mkdir_impl;
+
+   if (vfs_info->required_interface_version < PATH_REQUIRED_VFS_VERSION || !vfs_iface)
+      return;
+
+   path_stat_cb           = vfs_iface->stat;
+   path_mkdir_cb          = vfs_iface->mkdir;
+}
+
+int path_stat(const char *path)
+{
+   return path_stat_cb(path, NULL);
+}
+
+/**
+ * path_is_directory:
+ * @path               : path
+ *
+ * Checks if path is a directory.
+ *
+ * Returns: true (1) if path is a directory, otherwise false (0).
+ */
+bool path_is_directory(const char *path)
+{
+   return (path_stat_cb(path, NULL) & RETRO_VFS_STAT_IS_DIRECTORY) != 0;
+}
+
+bool path_is_character_special(const char *path)
+{
+   return (path_stat_cb(path, NULL) & RETRO_VFS_STAT_IS_CHARACTER_SPECIAL) != 0;
+}
+
+bool path_is_valid(const char *path)
+{
+   return (path_stat_cb(path, NULL) & RETRO_VFS_STAT_IS_VALID) != 0;
+}
+
+int32_t path_get_size(const char *path)
+{
+   int32_t filesize = 0;
+   if (path_stat_cb(path, &filesize) != 0)
+      return filesize;
+
+   return -1;
+}
+
+/**
+ * path_mkdir:
+ * @dir                : directory
+ *
+ * Create directory on filesystem.
+ *
+ * Returns: true (1) if directory could be created, otherwise false (0).
+ **/
+bool path_mkdir(const char *dir)
+{
+   bool         sret  = false;
+   bool norecurse     = false;
+   char     *basedir  = NULL;
+
+   if (!(dir && *dir))
+      return false;
+
+   /* Use heap. Real chance of stack 
+    * overflow if we recurse too hard. */
+   basedir            = strdup(dir);
+
+   if (!basedir)
+	   return false;
+
+   path_parent_dir(basedir);
+
+   if (!*basedir || !strcmp(basedir, dir))
+   {
+      free(basedir);
+      return false;
+   }
+
+   if (path_is_directory(basedir))
+      norecurse = true;
+   else
+   {
+      sret      = path_mkdir(basedir);
+
+      if (sret)
+         norecurse = true;
+   }
+
+   free(basedir);
+
+   if (norecurse)
+   {
+      int ret = path_mkdir_cb(dir);
+
+      /* Don't treat this as an error. */
+      if (ret == -2 && path_is_directory(dir))
+         return true;
+
+      return (ret == 0);
+   }
+
+   return sret;
+}

libretro/libretro-common/include/boolean.h

@@ -0,0 +1,39 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (boolean.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __LIBRETRO_SDK_BOOLEAN_H
+#define __LIBRETRO_SDK_BOOLEAN_H
+
+#ifndef __cplusplus
+
+#if defined(_MSC_VER) && _MSC_VER < 1800 && !defined(SN_TARGET_PS3)
+/* Hack applied for MSVC when compiling in C89 mode as it isn't C99 compliant. */
+#define bool unsigned char
+#define true 1
+#define false 0
+#else
+#include <stdbool.h>
+#endif
+
+#endif
+
+#endif

libretro/libretro-common/include/clamping.h

@@ -0,0 +1,65 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (clamping.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef _LIBRETRO_SDK_CLAMPING_H
+#define _LIBRETRO_SDK_CLAMPING_H
+
+#include <stdint.h>
+#include <retro_inline.h>
+
+/**
+ * clamp_float:
+ * @val           : initial value
+ * @lower         : lower limit that value should be clamped against
+ * @upper         : upper limit that value should be clamped against
+ *
+ * Clamps a floating point value.
+ *
+ * Returns: a clamped value of initial float value @val.
+ */
+static INLINE float clamp_float(float val, float lower, float upper)
+{
+   if (val < lower)
+      return lower;
+   if (val > upper)
+      return upper;
+   return val;
+}
+
+/**
+ * clamp_8bit:
+ * @val           : initial value
+ *
+ * Clamps an unsigned 8-bit value.
+ *
+ * Returns: a clamped value of initial unsigned 8-bit value @val.
+ */
+static INLINE uint8_t clamp_8bit(int val)
+{
+   if (val > 255)
+      return 255;
+   if (val < 0)
+      return 0;
+   return (uint8_t)val;
+}
+
+#endif

libretro/libretro-common/include/compat/apple_compat.h

@@ -0,0 +1,84 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (apple_compat.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __APPLE_COMPAT_H
+#define __APPLE_COMPAT_H
+
+#ifdef __APPLE__
+#include <AvailabilityMacros.h>
+#endif
+
+#ifdef __OBJC__
+
+#if (MAC_OS_X_VERSION_MAX_ALLOWED <= MAC_OS_X_VERSION_10_4)
+typedef int NSInteger;
+typedef unsigned NSUInteger;
+typedef float CGFloat;
+#endif
+
+#ifndef __has_feature
+/* Compatibility with non-Clang compilers. */
+#define __has_feature(x) 0
+#endif
+
+#ifndef CF_RETURNS_RETAINED
+#if __has_feature(attribute_cf_returns_retained)
+#define CF_RETURNS_RETAINED __attribute__((cf_returns_retained))
+#else
+#define CF_RETURNS_RETAINED
+#endif
+#endif
+
+#ifndef NS_INLINE
+#define NS_INLINE inline
+#endif
+
+NS_INLINE CF_RETURNS_RETAINED CFTypeRef CFBridgingRetainCompat(id X)
+{
+#if __has_feature(objc_arc)
+   return (__bridge_retained CFTypeRef)X;
+#else
+   return X;
+#endif
+}
+
+#endif
+
+#ifdef IOS
+#ifndef __IPHONE_5_0
+#warning "This project uses features only available in iOS SDK 5.0 and later."
+#endif
+
+#ifdef __OBJC__
+#import <UIKit/UIKit.h>
+#import <GLKit/GLKit.h>
+#import <Foundation/Foundation.h>
+#endif
+
+#else
+
+#ifdef __OBJC__
+#include <objc/objc-runtime.h>
+#endif
+#endif
+
+#endif

libretro/libretro-common/include/compat/fopen_utf8.h

@@ -0,0 +1,34 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (fopen_utf8.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __LIBRETRO_SDK_COMPAT_FOPEN_UTF8_H
+#define __LIBRETRO_SDK_COMPAT_FOPEN_UTF8_H
+
+#ifdef _WIN32
+/* Defined to error rather than fopen_utf8, to make it clear to everyone reading the code that not worrying about utf16 is fine */
+/* TODO: enable */
+/* #define fopen (use fopen_utf8 instead) */
+void *fopen_utf8(const char * filename, const char * mode);
+#else
+#define fopen_utf8 fopen
+#endif
+#endif

libretro/libretro-common/include/compat/intrinsics.h

@@ -0,0 +1,85 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (intrinsics.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __LIBRETRO_SDK_COMPAT_INTRINSICS_H
+#define __LIBRETRO_SDK_COMPAT_INTRINSICS_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <string.h>
+
+#include <retro_common_api.h>
+#include <retro_inline.h>
+
+#if defined(_MSC_VER) && !defined(_XBOX)
+#if (_MSC_VER > 1310)
+#include <intrin.h>
+#endif
+#endif
+
+RETRO_BEGIN_DECLS
+
+/* Count Leading Zero, unsigned 16bit input value */
+static INLINE unsigned compat_clz_u16(uint16_t val)
+{
+#if defined(__GNUC__)
+   return __builtin_clz(val << 16 | 0x8000);
+#else
+   unsigned ret = 0;
+
+   while(!(val & 0x8000) && ret < 16)
+   {
+      val <<= 1;
+      ret++;
+   }
+
+   return ret;
+#endif
+}
+
+/* Count Trailing Zero */
+static INLINE int compat_ctz(unsigned x)
+{
+#if defined(__GNUC__) && !defined(RARCH_CONSOLE)
+   return __builtin_ctz(x);
+#elif _MSC_VER >= 1400 && !defined(_XBOX) && !defined(__WINRT__)
+   unsigned long r = 0;
+   _BitScanReverse((unsigned long*)&r, x);
+   return (int)r;
+#else
+/* Only checks at nibble granularity,
+ * because that's what we need. */
+   if (x & 0x000f)
+      return 0;
+   if (x & 0x00f0)
+      return 4;
+   if (x & 0x0f00)
+      return 8;
+   if (x & 0xf000)
+      return 12;
+   return 16;
+#endif
+}
+
+RETRO_END_DECLS
+
+#endif

libretro/libretro-common/include/compat/msvc.h

@@ -0,0 +1,126 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (msvc.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __LIBRETRO_SDK_COMPAT_MSVC_H
+#define __LIBRETRO_SDK_COMPAT_MSVC_H
+
+#ifdef _MSC_VER
+
+#ifdef __cplusplus
+extern "C"  {
+#endif
+
+/* Pre-MSVC 2015 compilers don't implement snprintf, vsnprintf in a cross-platform manner. */
+#if _MSC_VER < 1900
+   #include <stdio.h>
+   #include <stdarg.h>
+   #include <stdlib.h>
+
+   #ifndef snprintf
+      #define snprintf c99_snprintf_retro__
+   #endif
+   int c99_snprintf_retro__(char *outBuf, size_t size, const char *format, ...);
+
+   #ifndef vsnprintf
+      #define vsnprintf c99_vsnprintf_retro__
+   #endif
+   int c99_vsnprintf_retro__(char *outBuf, size_t size, const char *format, va_list ap);
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#undef UNICODE /* Do not bother with UNICODE at this time. */
+#include <direct.h>
+#include <stddef.h>
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+
+/* Python headers defines ssize_t and sets HAVE_SSIZE_T.
+ * Cannot duplicate these efforts.
+ */
+#ifndef HAVE_SSIZE_T
+#if defined(_WIN64)
+typedef __int64 ssize_t;
+#elif defined(_WIN32)
+typedef int ssize_t;
+#endif
+#endif
+
+#define mkdir(dirname, unused) _mkdir(dirname)
+#define strtoull _strtoui64
+#undef strcasecmp
+#define strcasecmp _stricmp
+#undef strncasecmp
+#define strncasecmp _strnicmp
+
+/* Disable some of the annoying warnings. */
+#pragma warning(disable : 4800)
+#pragma warning(disable : 4805)
+#pragma warning(disable : 4244)
+#pragma warning(disable : 4305)
+#pragma warning(disable : 4146)
+#pragma warning(disable : 4267)
+#pragma warning(disable : 4723)
+#pragma warning(disable : 4996)
+
+/* roundf and va_copy is available since MSVC 2013 */
+#if _MSC_VER < 1800
+#define roundf(in) (in >= 0.0f ? floorf(in + 0.5f) : ceilf(in - 0.5f))
+#define va_copy(x, y) ((x) = (y))
+#endif
+
+#if _MSC_VER <= 1310
+   #ifndef __cplusplus
+      /* VC6 math.h doesn't define some functions when in C mode.
+       * Trying to define a prototype gives "undefined reference".
+       * But providing an implementation then gives "function already has body".
+       * So the equivalent of the implementations from math.h are used as
+       * defines here instead, and it seems to work.
+       */
+      #define cosf(x) ((float)cos((double)x))
+      #define powf(x, y) ((float)pow((double)x, (double)y))
+      #define sinf(x) ((float)sin((double)x))
+      #define ceilf(x) ((float)ceil((double)x))
+      #define floorf(x) ((float)floor((double)x))
+      #define sqrtf(x) ((float)sqrt((double)x))
+      #define fabsf(x)    ((float)fabs((double)(x)))
+   #endif
+
+   #ifndef _strtoui64
+      #define _strtoui64(x, y, z) (_atoi64(x))
+   #endif
+
+#endif
+
+#ifndef PATH_MAX
+#define PATH_MAX _MAX_PATH
+#endif
+
+#ifndef SIZE_MAX
+#define SIZE_MAX _UI32_MAX
+#endif
+
+#endif
+#endif

libretro/libretro-common/include/compat/msvc/stdint.h

@@ -0,0 +1,255 @@
+/* ISO C9x  compliant stdint.h for Microsoft Visual Studio
+ * Based on ISO/IEC 9899:TC2 Committee draft (May 6, 2005) WG14/N1124
+ *
+ * Copyright (c) 2006-2008 Alexander Chemeris
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * 3. The name of the author may be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __RARCH_STDINT_H
+#define __RARCH_STDINT_H
+
+#if _MSC_VER && (_MSC_VER < 1600)
+/* Pre-MSVC 2010 needs an implementation of stdint.h. */
+
+#if _MSC_VER > 1000
+#pragma once
+#endif
+
+#include <limits.h>
+
+/* For Visual Studio 6 in C++ mode and for many Visual Studio versions when
+ * compiling for ARM we should wrap <wchar.h> include with 'extern "C++" {}'
+ * or compiler give many errors like this:
+ *
+ * error C2733: second C linkage of overloaded function 'wmemchr' not allowed
+ */
+#ifdef __cplusplus
+#if _MSC_VER <= 1200
+extern "C++" {
+#else
+extern "C" {
+#endif
+#endif
+#  include <wchar.h>
+#ifdef __cplusplus
+}
+#endif
+
+/* Define _W64 macros to mark types changing their size, like intptr_t. */
+#ifndef _W64
+#  if !defined(__midl) && (defined(_X86_) || defined(_M_IX86)) && _MSC_VER >= 1300
+#     define _W64 __w64
+#  else
+#     define _W64
+#  endif
+#endif
+
+/* 7.18.1 Integer types. */
+
+/* 7.18.1.1 Exact-width integer types. */
+
+/* Visual Studio 6 and Embedded Visual C++ 4 doesn't
+ * realize that, e.g. char has the same size as __int8
+ * so we give up on __intX for them.
+ */
+#if (_MSC_VER < 1300)
+   typedef signed char       int8_t;
+   typedef signed short      int16_t;
+   typedef signed int        int32_t;
+   typedef unsigned char     uint8_t;
+   typedef unsigned short    uint16_t;
+   typedef unsigned int      uint32_t;
+#else
+   typedef signed __int8     int8_t;
+   typedef signed __int16    int16_t;
+   typedef signed __int32    int32_t;
+   typedef unsigned __int8   uint8_t;
+   typedef unsigned __int16  uint16_t;
+   typedef unsigned __int32  uint32_t;
+#endif
+typedef signed __int64       int64_t;
+typedef unsigned __int64     uint64_t;
+
+/* 7.18.1.2 Minimum-width integer types. */
+typedef int8_t    int_least8_t;
+typedef int16_t   int_least16_t;
+typedef int32_t   int_least32_t;
+typedef int64_t   int_least64_t;
+typedef uint8_t   uint_least8_t;
+typedef uint16_t  uint_least16_t;
+typedef uint32_t  uint_least32_t;
+typedef uint64_t  uint_least64_t;
+
+/* 7.18.1.3 Fastest minimum-width integer types. */
+typedef int8_t    int_fast8_t;
+typedef int16_t   int_fast16_t;
+typedef int32_t   int_fast32_t;
+typedef int64_t   int_fast64_t;
+typedef uint8_t   uint_fast8_t;
+typedef uint16_t  uint_fast16_t;
+typedef uint32_t  uint_fast32_t;
+typedef uint64_t  uint_fast64_t;
+
+/* 7.18.1.4 Integer types capable of holding object pointers. */
+#ifdef _WIN64 /* [ */
+   typedef signed __int64    intptr_t;
+   typedef unsigned __int64  uintptr_t;
+#else /* _WIN64 ][ */
+   typedef _W64 signed int   intptr_t;
+   typedef _W64 unsigned int uintptr_t;
+#endif /* _WIN64 ] */
+
+/* 7.18.1.5 Greatest-width integer types. */
+typedef int64_t   intmax_t;
+typedef uint64_t  uintmax_t;
+
+/* 7.18.2 Limits of specified-width integer types. */
+
+#if !defined(__cplusplus) || defined(__STDC_LIMIT_MACROS)
+/* [   See footnote 220 at page 257 and footnote 221 at page 259. */
+
+/* 7.18.2.1 Limits of exact-width integer types. */
+#define INT8_MIN     ((int8_t)_I8_MIN)
+#define INT8_MAX     _I8_MAX
+#define INT16_MIN    ((int16_t)_I16_MIN)
+#define INT16_MAX    _I16_MAX
+#define INT32_MIN    ((int32_t)_I32_MIN)
+#define INT32_MAX    _I32_MAX
+#define INT64_MIN    ((int64_t)_I64_MIN)
+#define INT64_MAX    _I64_MAX
+#define UINT8_MAX    _UI8_MAX
+#define UINT16_MAX   _UI16_MAX
+#define UINT32_MAX   _UI32_MAX
+#define UINT64_MAX   _UI64_MAX
+
+/* 7.18.2.2 Limits of minimum-width integer types. */
+#define INT_LEAST8_MIN    INT8_MIN
+#define INT_LEAST8_MAX    INT8_MAX
+#define INT_LEAST16_MIN   INT16_MIN
+#define INT_LEAST16_MAX   INT16_MAX
+#define INT_LEAST32_MIN   INT32_MIN
+#define INT_LEAST32_MAX   INT32_MAX
+#define INT_LEAST64_MIN   INT64_MIN
+#define INT_LEAST64_MAX   INT64_MAX
+#define UINT_LEAST8_MAX   UINT8_MAX
+#define UINT_LEAST16_MAX  UINT16_MAX
+#define UINT_LEAST32_MAX  UINT32_MAX
+#define UINT_LEAST64_MAX  UINT64_MAX
+
+/* 7.18.2.3 Limits of fastest minimum-width integer types. */
+#define INT_FAST8_MIN    INT8_MIN
+#define INT_FAST8_MAX    INT8_MAX
+#define INT_FAST16_MIN   INT16_MIN
+#define INT_FAST16_MAX   INT16_MAX
+#define INT_FAST32_MIN   INT32_MIN
+#define INT_FAST32_MAX   INT32_MAX
+#define INT_FAST64_MIN   INT64_MIN
+#define INT_FAST64_MAX   INT64_MAX
+#define UINT_FAST8_MAX   UINT8_MAX
+#define UINT_FAST16_MAX  UINT16_MAX
+#define UINT_FAST32_MAX  UINT32_MAX
+#define UINT_FAST64_MAX  UINT64_MAX
+
+/* 7.18.2.4 Limits of integer types capable of holding object pointers. */
+#ifdef _WIN64 /* [ */
+#  define INTPTR_MIN   INT64_MIN
+#  define INTPTR_MAX   INT64_MAX
+#  define UINTPTR_MAX  UINT64_MAX
+#else /* _WIN64 ][ */
+#  define INTPTR_MIN   INT32_MIN
+#  define INTPTR_MAX   INT32_MAX
+#  define UINTPTR_MAX  UINT32_MAX
+#endif /* _WIN64 ] */
+
+/* 7.18.2.5 Limits of greatest-width integer types */
+#define INTMAX_MIN   INT64_MIN
+#define INTMAX_MAX   INT64_MAX
+#define UINTMAX_MAX  UINT64_MAX
+
+/* 7.18.3 Limits of other integer types */
+
+#ifdef _WIN64 /* [ */
+#  define PTRDIFF_MIN  _I64_MIN
+#  define PTRDIFF_MAX  _I64_MAX
+#else  /* _WIN64 ][ */
+#  define PTRDIFF_MIN  _I32_MIN
+#  define PTRDIFF_MAX  _I32_MAX
+#endif  /* _WIN64 ] */
+
+#define SIG_ATOMIC_MIN  INT_MIN
+#define SIG_ATOMIC_MAX  INT_MAX
+
+#ifndef SIZE_MAX /* [ */
+#  ifdef _WIN64 /* [ */
+#     define SIZE_MAX  _UI64_MAX
+#  else /* _WIN64 ][ */
+#     define SIZE_MAX  _UI32_MAX
+#  endif /* _WIN64 ] */
+#endif /* SIZE_MAX ] */
+
+/* WCHAR_MIN and WCHAR_MAX are also defined in <wchar.h> */
+#ifndef WCHAR_MIN /* [ */
+#  define WCHAR_MIN  0
+#endif  /* WCHAR_MIN ] */
+#ifndef WCHAR_MAX // [
+#  define WCHAR_MAX  _UI16_MAX
+#endif  /* WCHAR_MAX ] */
+
+#define WINT_MIN  0
+#define WINT_MAX  _UI16_MAX
+
+#endif /* __STDC_LIMIT_MACROS ] */
+
+/* 7.18.4 Limits of other integer types */
+
+#if !defined(__cplusplus) || defined(__STDC_CONSTANT_MACROS)
+/* [   See footnote 224 at page 260 */
+
+/* 7.18.4.1 Macros for minimum-width integer constants */
+
+#define INT8_C(val)  val##i8
+#define INT16_C(val) val##i16
+#define INT32_C(val) val##i32
+#define INT64_C(val) val##i64
+
+#define UINT8_C(val)  val##ui8
+#define UINT16_C(val) val##ui16
+#define UINT32_C(val) val##ui32
+#define UINT64_C(val) val##ui64
+
+/* 7.18.4.2 Macros for greatest-width integer constants */
+#define INTMAX_C   INT64_C
+#define UINTMAX_C  UINT64_C
+
+#endif
+/* __STDC_CONSTANT_MACROS ] */
+
+#else
+/* Sanity for everything else. */
+#include <stdint.h>
+#endif
+
+#endif

libretro/libretro-common/include/compat/posix_string.h

@@ -0,0 +1,60 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (posix_string.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __LIBRETRO_SDK_COMPAT_POSIX_STRING_H
+#define __LIBRETRO_SDK_COMPAT_POSIX_STRING_H
+
+#include <retro_common_api.h>
+
+#ifdef _MSC_VER
+#include <compat/msvc.h>
+#endif
+
+RETRO_BEGIN_DECLS
+
+#ifdef _WIN32
+#undef strtok_r
+#define strtok_r(str, delim, saveptr) retro_strtok_r__(str, delim, saveptr)
+
+char *strtok_r(char *str, const char *delim, char **saveptr);
+#endif
+
+#ifdef _MSC_VER
+#undef strcasecmp
+#undef strdup
+#define strcasecmp(a, b) retro_strcasecmp__(a, b)
+#define strdup(orig)     retro_strdup__(orig)
+int strcasecmp(const char *a, const char *b);
+char *strdup(const char *orig);
+
+/* isblank is available since MSVC 2013 */
+#if _MSC_VER < 1800
+#undef isblank
+#define isblank(c)       retro_isblank__(c)
+int isblank(int c);
+#endif
+
+#endif
+
+RETRO_END_DECLS
+
+#endif

libretro/libretro-common/include/compat/strcasestr.h

@@ -0,0 +1,48 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (strcasestr.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __LIBRETRO_SDK_COMPAT_STRCASESTR_H
+#define __LIBRETRO_SDK_COMPAT_STRCASESTR_H
+
+#include <string.h>
+
+#if defined(RARCH_INTERNAL) && defined(HAVE_CONFIG_H)
+#include "../../../config.h"
+#endif
+
+#ifndef HAVE_STRCASESTR
+
+#include <retro_common_api.h>
+
+RETRO_BEGIN_DECLS
+
+/* Avoid possible naming collisions during link
+ * since we prefer to use the actual name. */
+#define strcasestr(haystack, needle) strcasestr_retro__(haystack, needle)
+
+char *strcasestr(const char *haystack, const char *needle);
+
+RETRO_END_DECLS
+
+#endif
+
+#endif

libretro/libretro-common/include/compat/strl.h

@@ -0,0 +1,59 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (strl.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __LIBRETRO_SDK_COMPAT_STRL_H
+#define __LIBRETRO_SDK_COMPAT_STRL_H
+
+#include <string.h>
+#include <stddef.h>
+
+#if defined(RARCH_INTERNAL) && defined(HAVE_CONFIG_H)
+#include "../../../config.h"
+#endif
+
+#include <retro_common_api.h>
+
+RETRO_BEGIN_DECLS
+
+#ifdef __MACH__
+#ifndef HAVE_STRL
+#define HAVE_STRL
+#endif
+#endif
+
+#ifndef HAVE_STRL
+/* Avoid possible naming collisions during link since
+ * we prefer to use the actual name. */
+#define strlcpy(dst, src, size) strlcpy_retro__(dst, src, size)
+
+#define strlcat(dst, src, size) strlcat_retro__(dst, src, size)
+
+size_t strlcpy(char *dest, const char *source, size_t size);
+size_t strlcat(char *dest, const char *source, size_t size);
+
+#endif
+
+char *strldup(const char *s, size_t n);
+
+RETRO_END_DECLS
+
+#endif

libretro/libretro-common/include/encodings/utf.h

@@ -0,0 +1,67 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (utf.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef _LIBRETRO_ENCODINGS_UTF_H
+#define _LIBRETRO_ENCODINGS_UTF_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+#include <boolean.h>
+
+#include <retro_common_api.h>
+
+RETRO_BEGIN_DECLS
+
+enum CodePage
+{
+   CODEPAGE_LOCAL = 0, /* CP_ACP */
+   CODEPAGE_UTF8  = 65001 /* CP_UTF8 */
+};
+
+size_t utf8_conv_utf32(uint32_t *out, size_t out_chars,
+      const char *in, size_t in_size);
+
+bool utf16_conv_utf8(uint8_t *out, size_t *out_chars,
+      const uint16_t *in, size_t in_size);
+
+size_t utf8len(const char *string);
+
+size_t utf8cpy(char *d, size_t d_len, const char *s, size_t chars);
+
+const char *utf8skip(const char *str, size_t chars);
+
+uint32_t utf8_walk(const char **string);
+
+bool utf16_to_char_string(const uint16_t *in, char *s, size_t len);
+
+char* utf8_to_local_string_alloc(const char *str);
+
+char* local_to_utf8_string_alloc(const char *str);
+
+wchar_t* utf8_to_utf16_string_alloc(const char *str);
+
+char* utf16_to_utf8_string_alloc(const wchar_t *str);
+
+RETRO_END_DECLS
+
+#endif

libretro/libretro-common/include/encodings/win32.h

@@ -0,0 +1,63 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (utf.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef _LIBRETRO_ENCODINGS_WIN32_H
+#define _LIBRETRO_ENCODINGS_WIN32_H
+
+#ifndef _XBOX
+#ifdef _WIN32
+/*#define UNICODE
+#include <tchar.h>
+#include <wchar.h>*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <encodings/utf.h>
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+#endif
+
+#ifdef UNICODE
+#define CHAR_TO_WCHAR_ALLOC(s, ws) \
+   size_t ws##_size = (NULL != s && s[0] ? strlen(s) : 0) + 1; \
+   wchar_t *ws = (wchar_t*)calloc(ws##_size, 2); \
+   if (NULL != s && s[0]) \
+      MultiByteToWideChar(CP_UTF8, 0, s, -1, ws, ws##_size / sizeof(wchar_t));
+
+#define WCHAR_TO_CHAR_ALLOC(ws, s) \
+   size_t s##_size = ((NULL != ws && ws[0] ? wcslen((const wchar_t*)ws) : 0) / 2) + 1; \
+   char *s = (char*)calloc(s##_size, 1); \
+   if (NULL != ws && ws[0]) \
+      utf16_to_char_string((const uint16_t*)ws, s, s##_size);
+
+#else
+#define CHAR_TO_WCHAR_ALLOC(s, ws) char *ws = (NULL != s && s[0] ? strdup(s) : NULL);
+#define WCHAR_TO_CHAR_ALLOC(ws, s) char *s = (NULL != ws && ws[0] ? strdup(ws) : NULL);
+#endif
+
+#endif

libretro/libretro-common/include/file/file_path.h

@@ -0,0 +1,531 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (file_path.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __LIBRETRO_SDK_FILE_PATH_H
+#define __LIBRETRO_SDK_FILE_PATH_H
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stddef.h>
+#include <sys/types.h>
+
+#include <libretro.h>
+#include <retro_common_api.h>
+
+#include <boolean.h>
+
+RETRO_BEGIN_DECLS
+
+#define PATH_REQUIRED_VFS_VERSION 3
+
+void path_vfs_init(const struct retro_vfs_interface_info* vfs_info);
+
+/* Order in this enum is equivalent to negative sort order in filelist
+ *  (i.e. DIRECTORY is on top of PLAIN_FILE) */
+enum
+{
+   RARCH_FILETYPE_UNSET,
+   RARCH_PLAIN_FILE,
+   RARCH_COMPRESSED_FILE_IN_ARCHIVE,
+   RARCH_COMPRESSED_ARCHIVE,
+   RARCH_DIRECTORY,
+   RARCH_FILE_UNSUPPORTED
+};
+
+/**
+ * path_is_compressed_file:
+ * @path               : path
+ *
+ * Checks if path is a compressed file.
+ *
+ * Returns: true (1) if path is a compressed file, otherwise false (0).
+ **/
+bool path_is_compressed_file(const char *path);
+
+/**
+ * path_contains_compressed_file:
+ * @path               : path
+ *
+ * Checks if path contains a compressed file.
+ *
+ * Currently we only check for hash symbol (#) inside the pathname.
+ * If path is ever expanded to a general URI, we should check for that here.
+ *
+ * Example:  Somewhere in the path there might be a compressed file
+ * E.g.: /path/to/file.7z#mygame.img
+ *
+ * Returns: true (1) if path contains compressed file, otherwise false (0).
+ **/
+#define path_contains_compressed_file(path) (path_get_archive_delim((path)) != NULL)
+
+/**
+ * path_get_archive_delim:
+ * @path               : path
+ *
+ * Gets delimiter of an archive file. Only the first '#'
+ * after a compression extension is considered.
+ *
+ * Returns: pointer to the delimiter in the path if it contains
+ * a compressed file, otherwise NULL.
+ */
+const char *path_get_archive_delim(const char *path);
+
+/**
+ * path_get_extension:
+ * @path               : path
+ *
+ * Gets extension of file. Only '.'s
+ * after the last slash are considered.
+ *
+ * Returns: extension part from the path.
+ */
+const char *path_get_extension(const char *path);
+
+/**
+ * path_remove_extension:
+ * @path               : path
+ *
+ * Mutates path by removing its extension. Removes all
+ * text after and including the last '.'.
+ * Only '.'s after the last slash are considered.
+ *
+ * Returns:
+ * 1) If path has an extension, returns path with the
+ *    extension removed.
+ * 2) If there is no extension, returns NULL.
+ * 3) If path is empty or NULL, returns NULL
+ */
+char *path_remove_extension(char *path);
+
+/**
+ * path_basename:
+ * @path               : path
+ *
+ * Get basename from @path.
+ *
+ * Returns: basename from path.
+ **/
+const char *path_basename(const char *path);
+
+/**
+ * path_basedir:
+ * @path               : path
+ *
+ * Extracts base directory by mutating path.
+ * Keeps trailing '/'.
+ **/
+void path_basedir(char *path);
+
+/**
+ * path_parent_dir:
+ * @path               : path
+ *
+ * Extracts parent directory by mutating path.
+ * Assumes that path is a directory. Keeps trailing '/'.
+ * If the path was already at the root directory, returns empty string
+ **/
+void path_parent_dir(char *path);
+
+/**
+ * path_resolve_realpath:
+ * @buf                : input and output buffer for path
+ * @size               : size of buffer
+ * @resolve_symlinks   : whether to resolve symlinks or not
+ *
+ * Resolves use of ".", "..", multiple slashes etc in absolute paths.
+ *
+ * Relative paths are rebased on the current working dir.
+ *
+ * Returns: @buf if successful, NULL otherwise.
+ * Note: Not implemented on consoles
+ * Note: Symlinks are only resolved on Unix-likes
+ * Note: The current working dir might not be what you expect,
+ *       e.g. on Android it is "/"
+ *       Use of fill_pathname_resolve_relative() should be prefered
+ **/
+char *path_resolve_realpath(char *buf, size_t size, bool resolve_symlinks);
+
+/**
+ * path_relative_to:
+ * @out                : buffer to write the relative path to
+ * @path               : path to be expressed relatively
+ * @base               : relative to this
+ * @size               : size of output buffer
+ *
+ * Turns @path into a path relative to @base and writes it to @out.
+ *
+ * @base is assumed to be a base directory, i.e. a path ending with '/' or '\'.
+ * Both @path and @base are assumed to be absolute paths without "." or "..".
+ *
+ * E.g. path /a/b/e/f.cgp with base /a/b/c/d/ turns into ../../e/f.cgp
+ **/
+size_t path_relative_to(char *out, const char *path, const char *base, size_t size);
+
+/**
+ * path_is_absolute:
+ * @path               : path
+ *
+ * Checks if @path is an absolute path or a relative path.
+ *
+ * Returns: true if path is absolute, false if path is relative.
+ **/
+bool path_is_absolute(const char *path);
+
+/**
+ * fill_pathname:
+ * @out_path           : output path
+ * @in_path            : input  path
+ * @replace            : what to replace
+ * @size               : buffer size of output path
+ *
+ * FIXME: Verify
+ *
+ * Replaces filename extension with 'replace' and outputs result to out_path.
+ * The extension here is considered to be the string from the last '.'
+ * to the end.
+ *
+ * Only '.'s after the last slash are considered as extensions.
+ * If no '.' is present, in_path and replace will simply be concatenated.
+ * 'size' is buffer size of 'out_path'.
+ * E.g.: in_path = "/foo/bar/baz/boo.c", replace = ".asm" =>
+ * out_path = "/foo/bar/baz/boo.asm"
+ * E.g.: in_path = "/foo/bar/baz/boo.c", replace = ""     =>
+ * out_path = "/foo/bar/baz/boo"
+ */
+void fill_pathname(char *out_path, const char *in_path,
+      const char *replace, size_t size);
+
+/**
+ * fill_dated_filename:
+ * @out_filename       : output filename
+ * @ext                : extension of output filename
+ * @size               : buffer size of output filename
+ *
+ * Creates a 'dated' filename prefixed by 'RetroArch', and
+ * concatenates extension (@ext) to it.
+ *
+ * E.g.:
+ * out_filename = "RetroArch-{month}{day}-{Hours}{Minutes}.{@ext}"
+ **/
+size_t fill_dated_filename(char *out_filename,
+      const char *ext, size_t size);
+
+/**
+ * fill_str_dated_filename:
+ * @out_filename       : output filename
+ * @in_str             : input string
+ * @ext                : extension of output filename
+ * @size               : buffer size of output filename
+ *
+ * Creates a 'dated' filename prefixed by the string @in_str, and
+ * concatenates extension (@ext) to it.
+ *
+ * E.g.:
+ * out_filename = "RetroArch-{year}{month}{day}-{Hour}{Minute}{Second}.{@ext}"
+ **/
+void fill_str_dated_filename(char *out_filename,
+      const char *in_str, const char *ext, size_t size);
+
+/**
+ * fill_pathname_noext:
+ * @out_path           : output path
+ * @in_path            : input  path
+ * @replace            : what to replace
+ * @size               : buffer size of output path
+ *
+ * Appends a filename extension 'replace' to 'in_path', and outputs
+ * result in 'out_path'.
+ *
+ * Assumes in_path has no extension. If an extension is still
+ * present in 'in_path', it will be ignored.
+ *
+ */
+size_t fill_pathname_noext(char *out_path, const char *in_path,
+      const char *replace, size_t size);
+
+/**
+ * find_last_slash:
+ * @str : input path
+ *
+ * Gets a pointer to the last slash in the input path.
+ *
+ * Returns: a pointer to the last slash in the input path.
+ **/
+char *find_last_slash(const char *str);
+
+/**
+ * fill_pathname_dir:
+ * @in_dir             : input directory path
+ * @in_basename        : input basename to be appended to @in_dir
+ * @replace            : replacement to be appended to @in_basename
+ * @size               : size of buffer
+ *
+ * Appends basename of 'in_basename', to 'in_dir', along with 'replace'.
+ * Basename of in_basename is the string after the last '/' or '\\',
+ * i.e the filename without directories.
+ *
+ * If in_basename has no '/' or '\\', the whole 'in_basename' will be used.
+ * 'size' is buffer size of 'in_dir'.
+ *
+ * E.g..: in_dir = "/tmp/some_dir", in_basename = "/some_content/foo.c",
+ * replace = ".asm" => in_dir = "/tmp/some_dir/foo.c.asm"
+ **/
+size_t fill_pathname_dir(char *in_dir, const char *in_basename,
+      const char *replace, size_t size);
+
+/**
+ * fill_pathname_base:
+ * @out                : output path
+ * @in_path            : input path
+ * @size               : size of output path
+ *
+ * Copies basename of @in_path into @out_path.
+ **/
+size_t fill_pathname_base(char *out_path, const char *in_path, size_t size);
+
+void fill_pathname_base_noext(char *out_dir,
+      const char *in_path, size_t size);
+
+size_t fill_pathname_base_ext(char *out,
+      const char *in_path, const char *ext,
+      size_t size);
+
+/**
+ * fill_pathname_basedir:
+ * @out_dir            : output directory
+ * @in_path            : input path
+ * @size               : size of output directory
+ *
+ * Copies base directory of @in_path into @out_path.
+ * If in_path is a path without any slashes (relative current directory),
+ * @out_path will get path "./".
+ **/
+void fill_pathname_basedir(char *out_path, const char *in_path, size_t size);
+
+void fill_pathname_basedir_noext(char *out_dir,
+      const char *in_path, size_t size);
+
+/**
+ * fill_pathname_parent_dir_name:
+ * @out_dir            : output directory
+ * @in_dir             : input directory
+ * @size               : size of output directory
+ *
+ * Copies only the parent directory name of @in_dir into @out_dir.
+ * The two buffers must not overlap. Removes trailing '/'.
+ * Returns true on success, false if a slash was not found in the path.
+ **/
+bool fill_pathname_parent_dir_name(char *out_dir,
+      const char *in_dir, size_t size);
+
+/**
+ * fill_pathname_parent_dir:
+ * @out_dir            : output directory
+ * @in_dir             : input directory
+ * @size               : size of output directory
+ *
+ * Copies parent directory of @in_dir into @out_dir.
+ * Assumes @in_dir is a directory. Keeps trailing '/'.
+ * If the path was already at the root directory, @out_dir will be an empty string.
+ **/
+void fill_pathname_parent_dir(char *out_dir,
+      const char *in_dir, size_t size);
+
+/**
+ * fill_pathname_resolve_relative:
+ * @out_path           : output path
+ * @in_refpath         : input reference path
+ * @in_path            : input path
+ * @size               : size of @out_path
+ *
+ * Joins basedir of @in_refpath together with @in_path.
+ * If @in_path is an absolute path, out_path = in_path.
+ * E.g.: in_refpath = "/foo/bar/baz.a", in_path = "foobar.cg",
+ * out_path = "/foo/bar/foobar.cg".
+ **/
+void fill_pathname_resolve_relative(char *out_path, const char *in_refpath,
+      const char *in_path, size_t size);
+
+/**
+ * fill_pathname_join:
+ * @out_path           : output path
+ * @dir                : directory
+ * @path               : path
+ * @size               : size of output path
+ *
+ * Joins a directory (@dir) and path (@path) together.
+ * Makes sure not to get  two consecutive slashes
+ * between directory and path.
+ **/
+size_t fill_pathname_join(char *out_path, const char *dir,
+      const char *path, size_t size);
+
+size_t fill_pathname_join_special_ext(char *out_path,
+      const char *dir,  const char *path,
+      const char *last, const char *ext,
+      size_t size);
+
+size_t fill_pathname_join_concat_noext(char *out_path,
+      const char *dir, const char *path,
+      const char *concat,
+      size_t size);
+
+size_t fill_pathname_join_concat(char *out_path,
+      const char *dir, const char *path,
+      const char *concat,
+      size_t size);
+
+void fill_pathname_join_noext(char *out_path,
+      const char *dir, const char *path, size_t size);
+
+/**
+ * fill_pathname_join_delim:
+ * @out_path           : output path
+ * @dir                : directory
+ * @path               : path
+ * @delim              : delimiter
+ * @size               : size of output path
+ *
+ * Joins a directory (@dir) and path (@path) together
+ * using the given delimiter (@delim).
+ **/
+size_t fill_pathname_join_delim(char *out_path, const char *dir,
+      const char *path, const char delim, size_t size);
+
+size_t fill_pathname_join_delim_concat(char *out_path, const char *dir,
+      const char *path, const char delim, const char *concat,
+      size_t size);
+
+/**
+ * fill_short_pathname_representation:
+ * @out_rep            : output representation
+ * @in_path            : input path
+ * @size               : size of output representation
+ *
+ * Generates a short representation of path. It should only
+ * be used for displaying the result; the output representation is not
+ * binding in any meaningful way (for a normal path, this is the same as basename)
+ * In case of more complex URLs, this should cut everything except for
+ * the main image file.
+ *
+ * E.g.: "/path/to/game.img" -> game.img
+ *       "/path/to/myarchive.7z#folder/to/game.img" -> game.img
+ */
+size_t fill_short_pathname_representation(char* out_rep,
+      const char *in_path, size_t size);
+
+void fill_short_pathname_representation_noext(char* out_rep,
+      const char *in_path, size_t size);
+
+void fill_pathname_expand_special(char *out_path,
+      const char *in_path, size_t size);
+
+void fill_pathname_abbreviate_special(char *out_path,
+      const char *in_path, size_t size);
+
+/**
+ * path_basedir:
+ * @path               : path
+ *
+ * Extracts base directory by mutating path.
+ * Keeps trailing '/'.
+ **/
+void path_basedir_wrapper(char *path);
+
+/**
+ * path_char_is_slash:
+ * @c                  : character
+ *
+ * Checks if character (@c) is a slash.
+ *
+ * Returns: true (1) if character is a slash, otherwise false (0).
+ */
+#ifdef _WIN32
+#define PATH_CHAR_IS_SLASH(c) (((c) == '/') || ((c) == '\\'))
+#else
+#define PATH_CHAR_IS_SLASH(c) ((c) == '/')
+#endif
+
+/**
+ * path_default_slash and path_default_slash_c:
+ *
+ * Gets the default slash separator.
+ *
+ * Returns: default slash separator.
+ */
+#ifdef _WIN32
+#define PATH_DEFAULT_SLASH() "\\"
+#define PATH_DEFAULT_SLASH_C() '\\'
+#else
+#define PATH_DEFAULT_SLASH() "/"
+#define PATH_DEFAULT_SLASH_C() '/'
+#endif
+
+/**
+ * fill_pathname_slash:
+ * @path               : path
+ * @size               : size of path
+ *
+ * Assumes path is a directory. Appends a slash
+ * if not already there.
+ **/
+void fill_pathname_slash(char *path, size_t size);
+
+#if !defined(RARCH_CONSOLE) && defined(RARCH_INTERNAL)
+void fill_pathname_application_path(char *buf, size_t size);
+void fill_pathname_application_dir(char *buf, size_t size);
+void fill_pathname_home_dir(char *buf, size_t size);
+#endif
+
+/**
+ * path_mkdir:
+ * @dir                : directory
+ *
+ * Create directory on filesystem.
+ *
+ * Returns: true (1) if directory could be created, otherwise false (0).
+ **/
+bool path_mkdir(const char *dir);
+
+/**
+ * path_is_directory:
+ * @path               : path
+ *
+ * Checks if path is a directory.
+ *
+ * Returns: true (1) if path is a directory, otherwise false (0).
+ */
+bool path_is_directory(const char *path);
+
+bool path_is_character_special(const char *path);
+
+int path_stat(const char *path);
+
+bool path_is_valid(const char *path);
+
+int32_t path_get_size(const char *path);
+
+bool is_path_accessible_using_standard_io(const char *path);
+
+RETRO_END_DECLS
+
+#endif

libretro/libretro-common/include/libco.h

@@ -0,0 +1,79 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (libco.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef LIBCO_H
+#define LIBCO_H
+
+#include <retro_common_api.h>
+
+#ifdef LIBCO_C
+  #ifdef LIBCO_MP
+    #define thread_local __thread
+  #else
+    #define thread_local
+  #endif
+#endif
+
+RETRO_BEGIN_DECLS
+
+typedef void* cothread_t;
+
+/**
+ * co_active:
+ *
+ * Gets the currently active context.
+ *
+ * Returns: active context.
+ **/
+cothread_t co_active(void);
+
+/**
+ * co_create:
+ * @int                : stack size
+ * @funcptr            : thread entry function callback
+ *
+ * Create a co_thread.
+ *
+ * Returns: cothread if successful, otherwise NULL.
+ */
+cothread_t co_create(unsigned int, void (*)(void));
+
+/**
+ * co_delete:
+ * @cothread           : cothread object
+ *
+ * Frees a co_thread.
+ */
+void co_delete(cothread_t cothread);
+
+/**
+ * co_switch:
+ * @cothread           : cothread object to switch to
+ *
+ * Do a context switch to @cothread.
+ */
+void co_switch(cothread_t cothread);
+
+RETRO_END_DECLS
+
+/* ifndef LIBCO_H */
+#endif

libretro/libretro-common/include/memalign.h

@@ -0,0 +1,40 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (memalign.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef _LIBRETRO_MEMALIGN_H
+#define _LIBRETRO_MEMALIGN_H
+
+#include <stddef.h>
+
+#include <retro_common_api.h>
+
+RETRO_BEGIN_DECLS
+
+void *memalign_alloc(size_t boundary, size_t size);
+
+void *memalign_alloc_aligned(size_t size);
+
+void memalign_free(void *ptr);
+
+RETRO_END_DECLS
+
+#endif

libretro/libretro-common/include/memmap.h

@@ -0,0 +1,52 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (memmap.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef _LIBRETRO_MEMMAP_H
+#define _LIBRETRO_MEMMAP_H
+
+#include <stdio.h>
+#include <stdint.h>
+
+#if defined(__CELLOS_LV2__) || defined(PSP) || defined(PS2) || defined(GEKKO) || defined(VITA) || defined(_XBOX) || defined(_3DS) || defined(WIIU) || defined(SWITCH) || defined(HAVE_LIBNX)
+/* No mman available */
+#elif defined(_WIN32) && !defined(_XBOX)
+#include <windows.h>
+#include <errno.h>
+#include <io.h>
+#else
+#define HAVE_MMAN
+#include <sys/mman.h>
+#endif
+
+#if !defined(HAVE_MMAN) || defined(_WIN32)
+void* mmap(void *addr, size_t len, int mmap_prot, int mmap_flags, int fildes, size_t off);
+
+int munmap(void *addr, size_t len);
+
+int mprotect(void *addr, size_t len, int prot);
+#endif
+
+int memsync(void *start, void *end);
+
+int memprotect(void *addr, size_t len);
+
+#endif

libretro/libretro-common/include/retro_assert.h

@@ -0,0 +1,37 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (retro_assert.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __RETRO_ASSERT_H
+#define __RETRO_ASSERT_H
+
+#include <assert.h>
+
+#ifdef RARCH_INTERNAL
+#include <stdio.h>
+#define retro_assert(cond) do { \
+   if (!(cond)) { printf("Assertion failed at %s:%d.\n", __FILE__, __LINE__); abort(); } \
+} while(0)
+#else
+#define retro_assert(cond) assert(cond)
+#endif
+
+#endif

libretro/libretro-common/include/retro_common.h

@@ -0,0 +1,36 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (retro_common.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef _LIBRETRO_COMMON_RETRO_COMMON_H
+#define _LIBRETRO_COMMON_RETRO_COMMON_H
+
+/*
+This file is designed to normalize the libretro-common compiling environment.
+It is not to be used in public API headers, as they should be designed as leanly as possible.
+Nonetheless.. in the meantime, if you do something like use ssize_t, which is not fully portable,
+in a public API, you may need this.
+*/
+
+/* conditional compilation is handled inside here */
+#include <compat/msvc.h>
+
+#endif

libretro/libretro-common/include/retro_common_api.h

@@ -0,0 +1,119 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (retro_common_api.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef _LIBRETRO_COMMON_RETRO_COMMON_API_H
+#define _LIBRETRO_COMMON_RETRO_COMMON_API_H
+
+/*
+This file is designed to normalize the libretro-common compiling environment
+for public API headers. This should be leaner than a normal compiling environment,
+since it gets #included into other project's sources.
+*/
+
+/* ------------------------------------ */
+
+/*
+Ordinarily we want to put #ifdef __cplusplus extern "C" in C library
+headers to enable them to get used by c++ sources.
+However, we want to support building this library as C++ as well, so a
+special technique is called for.
+*/
+
+#define RETRO_BEGIN_DECLS
+#define RETRO_END_DECLS
+
+#ifdef __cplusplus
+
+#ifdef CXX_BUILD
+/* build wants everything to be built as c++, so no extern "C" */
+#else
+#undef RETRO_BEGIN_DECLS
+#undef RETRO_END_DECLS
+#define RETRO_BEGIN_DECLS extern "C" {
+#define RETRO_END_DECLS }
+#endif
+
+#else
+
+/* header is included by a C source file, so no extern "C" */
+
+#endif
+
+/*
+IMO, this non-standard ssize_t should not be used.
+However, it's a good example of how to handle something like this.
+*/
+#ifdef _MSC_VER
+#ifndef HAVE_SSIZE_T
+#define HAVE_SSIZE_T
+#if defined(_WIN64)
+typedef __int64 ssize_t;
+#elif defined(_WIN32)
+typedef int ssize_t;
+#endif
+#endif
+#elif defined(__MACH__)
+#include <sys/types.h>
+#endif
+
+#ifdef _MSC_VER
+#if _MSC_VER >= 1800
+#include <inttypes.h>
+#else
+#ifndef PRId64
+#define PRId64 "I64d"
+#define PRIu64 "I64u"
+#define PRIuPTR "Iu"
+#endif
+#endif
+#else
+/* C++11 says this one isn't needed, but apparently (some versions of) mingw require it anyways */
+/* https://stackoverflow.com/questions/8132399/how-to-printf-uint64-t-fails-with-spurious-trailing-in-format */
+/* https://github.com/libretro/RetroArch/issues/6009 */
+#ifndef __STDC_FORMAT_MACROS
+#define __STDC_FORMAT_MACROS 1
+#endif
+#include <inttypes.h>
+#endif
+#ifndef PRId64
+#error "inttypes.h is being screwy"
+#endif
+#define STRING_REP_INT64 "%" PRId64
+#define STRING_REP_UINT64 "%" PRIu64
+#define STRING_REP_USIZE "%" PRIuPTR
+
+/*
+I would like to see retro_inline.h moved in here; possibly boolean too.
+
+rationale: these are used in public APIs, and it is easier to find problems
+and write code that works the first time portably when theyre included uniformly
+than to do the analysis from scratch each time you think you need it, for each feature.
+
+Moreover it helps force you to make hard decisions: if you EVER bring in boolean.h,
+then you should pay the price everywhere, so you can see how much grief it will cause.
+
+Of course, another school of thought is that you should do as little damage as possible
+in as few places as possible...
+*/
+
+/* _LIBRETRO_COMMON_RETRO_COMMON_API_H */
+#endif

libretro/libretro-common/include/retro_dirent.h

@@ -0,0 +1,78 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (retro_dirent.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __RETRO_DIRENT_H
+#define __RETRO_DIRENT_H
+
+#include <libretro.h>
+#include <retro_common_api.h>
+#include <retro_miscellaneous.h>
+
+#include <boolean.h>
+
+RETRO_BEGIN_DECLS
+
+#define DIRENT_REQUIRED_VFS_VERSION 3
+
+void dirent_vfs_init(const struct retro_vfs_interface_info* vfs_info);
+
+typedef struct RDIR RDIR;
+
+/**
+ *
+ * retro_opendir:
+ * @name         : path to the directory to open.
+ *
+ * Opens a directory for reading. Tidy up with retro_closedir.
+ *
+ * Returns: RDIR pointer on success, NULL if name is not a
+ * valid directory, null itself or the empty string.
+ */
+struct RDIR *retro_opendir(const char *name);
+
+struct RDIR *retro_opendir_include_hidden(const char *name, bool include_hidden);
+
+int retro_readdir(struct RDIR *rdir);
+
+/* Deprecated, returns false, left for compatibility */
+bool retro_dirent_error(struct RDIR *rdir);
+
+const char *retro_dirent_get_name(struct RDIR *rdir);
+
+/**
+ *
+ * retro_dirent_is_dir:
+ * @rdir         : pointer to the directory entry.
+ * @unused       : deprecated, included for compatibility reasons, pass NULL
+ *
+ * Is the directory listing entry a directory?
+ *
+ * Returns: true if directory listing entry is
+ * a directory, false if not.
+ */
+bool retro_dirent_is_dir(struct RDIR *rdir, const char *unused);
+
+void retro_closedir(struct RDIR *rdir);
+
+RETRO_END_DECLS
+
+#endif

libretro/libretro-common/include/retro_endianness.h

@@ -0,0 +1,582 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (retro_endianness.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __LIBRETRO_SDK_ENDIANNESS_H
+#define __LIBRETRO_SDK_ENDIANNESS_H
+
+#include <retro_inline.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#if defined(_MSC_VER) && _MSC_VER > 1200
+#define SWAP16 _byteswap_ushort
+#define SWAP32 _byteswap_ulong
+#else
+static INLINE uint16_t SWAP16(uint16_t x)
+{
+  return ((x & 0x00ff) << 8) |
+         ((x & 0xff00) >> 8);
+}
+
+static INLINE uint32_t SWAP32(uint32_t x)
+{
+  return ((x & 0x000000ff) << 24) |
+         ((x & 0x0000ff00) <<  8) |
+         ((x & 0x00ff0000) >>  8) |
+         ((x & 0xff000000) >> 24);
+}
+
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER <= 1200
+static INLINE uint64_t SWAP64(uint64_t val)
+{
+  return
+      ((val & 0x00000000000000ff) << 56)
+    | ((val & 0x000000000000ff00) << 40)
+    | ((val & 0x0000000000ff0000) << 24)
+    | ((val & 0x00000000ff000000) << 8)
+    | ((val & 0x000000ff00000000) >> 8)
+    | ((val & 0x0000ff0000000000) >> 24)
+    | ((val & 0x00ff000000000000) >> 40)
+    | ((val & 0xff00000000000000) >> 56);
+}
+#else
+static INLINE uint64_t SWAP64(uint64_t val)
+{
+  return   ((val & 0x00000000000000ffULL) << 56)
+	 | ((val & 0x000000000000ff00ULL) << 40)
+	 | ((val & 0x0000000000ff0000ULL) << 24)
+	 | ((val & 0x00000000ff000000ULL) << 8)
+	 | ((val & 0x000000ff00000000ULL) >> 8)
+	 | ((val & 0x0000ff0000000000ULL) >> 24)
+	 | ((val & 0x00ff000000000000ULL) >> 40)
+         | ((val & 0xff00000000000000ULL) >> 56);
+}
+#endif
+
+
+#if defined (LSB_FIRST) || defined (MSB_FIRST)
+#  warning Defining MSB_FIRST and LSB_FIRST in compile options is deprecated
+#  undef LSB_FIRST
+#  undef MSB_FIRST
+#endif
+
+#if defined(_MSC_VER) && !defined(_XBOX)
+#include <winsock2.h>
+#endif
+
+#ifdef _MSC_VER
+#if _M_IX86 || _M_AMD64 || _M_ARM || _M_ARM64
+#define LSB_FIRST 1
+#elif _M_PPC
+#define MSB_FIRST 1
+#else
+/* MSVC can run on _M_ALPHA and _M_IA64 too, but they're both bi-endian; need to find what mode MSVC runs them at */
+#error "unknown platform, can't determine endianness"
+#endif
+#else
+#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#define MSB_FIRST 1
+#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#define LSB_FIRST 1
+#else
+#error "Invalid endianness macros"
+#endif
+#endif
+
+#if defined(MSB_FIRST) && defined(LSB_FIRST)
+#  error "Bug in LSB_FIRST/MSB_FIRST definition"
+#endif
+
+#if !defined(MSB_FIRST) && !defined(LSB_FIRST)
+#  error "Bug in LSB_FIRST/MSB_FIRST definition"
+#endif
+
+#ifdef MSB_FIRST
+#  define RETRO_IS_BIG_ENDIAN 1
+#  define RETRO_IS_LITTLE_ENDIAN 0
+/* For compatibility */
+#  define WORDS_BIGENDIAN 1
+#else
+#  define RETRO_IS_BIG_ENDIAN 0
+#  define RETRO_IS_LITTLE_ENDIAN 1
+/* For compatibility */
+#  undef WORDS_BIGENDIAN
+#endif
+
+
+/**
+ * is_little_endian:
+ *
+ * Checks if the system is little endian or big-endian.
+ *
+ * Returns: greater than 0 if little-endian,
+ * otherwise big-endian.
+ **/
+#define is_little_endian() RETRO_IS_LITTLE_ENDIAN
+
+/**
+ * swap_if_big64:
+ * @val        : unsigned 64-bit value
+ *
+ * Byteswap unsigned 64-bit value if system is big-endian.
+ *
+ * Returns: Byteswapped value in case system is big-endian,
+ * otherwise returns same value.
+ **/
+
+#if RETRO_IS_BIG_ENDIAN
+#define swap_if_big64(val) (SWAP64(val))
+#elif RETRO_IS_LITTLE_ENDIAN
+#define swap_if_big64(val) (val)
+#endif
+
+/**
+ * swap_if_big32:
+ * @val        : unsigned 32-bit value
+ *
+ * Byteswap unsigned 32-bit value if system is big-endian.
+ *
+ * Returns: Byteswapped value in case system is big-endian,
+ * otherwise returns same value.
+ **/
+
+#if RETRO_IS_BIG_ENDIAN
+#define swap_if_big32(val) (SWAP32(val))
+#elif RETRO_IS_LITTLE_ENDIAN
+#define swap_if_big32(val) (val)
+#endif
+
+/**
+ * swap_if_little64:
+ * @val        : unsigned 64-bit value
+ *
+ * Byteswap unsigned 64-bit value if system is little-endian.
+ *
+ * Returns: Byteswapped value in case system is little-endian,
+ * otherwise returns same value.
+ **/
+
+#if RETRO_IS_BIG_ENDIAN
+#define swap_if_little64(val) (val)
+#elif RETRO_IS_LITTLE_ENDIAN
+#define swap_if_little64(val) (SWAP64(val))
+#endif
+
+/**
+ * swap_if_little32:
+ * @val        : unsigned 32-bit value
+ *
+ * Byteswap unsigned 32-bit value if system is little-endian.
+ *
+ * Returns: Byteswapped value in case system is little-endian,
+ * otherwise returns same value.
+ **/
+
+#if RETRO_IS_BIG_ENDIAN
+#define swap_if_little32(val) (val)
+#elif RETRO_IS_LITTLE_ENDIAN
+#define swap_if_little32(val) (SWAP32(val))
+#endif
+
+/**
+ * swap_if_big16:
+ * @val        : unsigned 16-bit value
+ *
+ * Byteswap unsigned 16-bit value if system is big-endian.
+ *
+ * Returns: Byteswapped value in case system is big-endian,
+ * otherwise returns same value.
+ **/
+
+#if RETRO_IS_BIG_ENDIAN
+#define swap_if_big16(val) (SWAP16(val))
+#elif RETRO_IS_LITTLE_ENDIAN
+#define swap_if_big16(val) (val)
+#endif
+
+/**
+ * swap_if_little16:
+ * @val        : unsigned 16-bit value
+ *
+ * Byteswap unsigned 16-bit value if system is little-endian.
+ *
+ * Returns: Byteswapped value in case system is little-endian,
+ * otherwise returns same value.
+ **/
+
+#if RETRO_IS_BIG_ENDIAN
+#define swap_if_little16(val) (val)
+#elif RETRO_IS_LITTLE_ENDIAN
+#define swap_if_little16(val) (SWAP16(val))
+#endif
+
+/**
+ * store32be:
+ * @addr        : pointer to unsigned 32-bit buffer
+ * @data        : unsigned 32-bit value to write
+ *
+ * Write data to address. Endian-safe. Byteswaps the data
+ * first if necessary before storing it.
+ **/
+static INLINE void store32be(uint32_t *addr, uint32_t data)
+{
+   *addr = swap_if_little32(data);
+}
+
+/**
+ * load32be:
+ * @addr        : pointer to unsigned 32-bit buffer
+ *
+ * Load value from address. Endian-safe.
+ *
+ * Returns: value from address, byte-swapped if necessary.
+ **/
+static INLINE uint32_t load32be(const uint32_t *addr)
+{
+   return swap_if_little32(*addr);
+}
+
+/**
+ * retro_cpu_to_le16:
+ * @val        : unsigned 16-bit value
+ *
+ * Convert unsigned 16-bit value from system to little-endian.
+ *
+ * Returns: Little-endian representation of val.
+ **/
+
+#define retro_cpu_to_le16(val) swap_if_big16(val)
+
+/**
+ * retro_cpu_to_le32:
+ * @val        : unsigned 32-bit value
+ *
+ * Convert unsigned 32-bit value from system to little-endian.
+ *
+ * Returns: Little-endian representation of val.
+ **/
+
+#define retro_cpu_to_le32(val) swap_if_big32(val)
+
+/**
+ * retro_cpu_to_le64:
+ * @val        : unsigned 64-bit value
+ *
+ * Convert unsigned 64-bit value from system to little-endian.
+ *
+ * Returns: Little-endian representation of val.
+ **/
+
+#define retro_cpu_to_le64(val) swap_if_big64(val)
+
+/**
+ * retro_le_to_cpu16:
+ * @val        : unsigned 16-bit value
+ *
+ * Convert unsigned 16-bit value from little-endian to native.
+ *
+ * Returns: Native representation of little-endian val.
+ **/
+
+#define retro_le_to_cpu16(val) swap_if_big16(val)
+
+/**
+ * retro_le_to_cpu32:
+ * @val        : unsigned 32-bit value
+ *
+ * Convert unsigned 32-bit value from little-endian to native.
+ *
+ * Returns: Native representation of little-endian val.
+ **/
+
+#define retro_le_to_cpu32(val) swap_if_big32(val)
+
+/**
+ * retro_le_to_cpu16:
+ * @val        : unsigned 64-bit value
+ *
+ * Convert unsigned 64-bit value from little-endian to native.
+ *
+ * Returns: Native representation of little-endian val.
+ **/
+
+#define retro_le_to_cpu64(val) swap_if_big64(val)
+
+/**
+ * retro_cpu_to_be16:
+ * @val        : unsigned 16-bit value
+ *
+ * Convert unsigned 16-bit value from system to big-endian.
+ *
+ * Returns: Big-endian representation of val.
+ **/
+
+#define retro_cpu_to_be16(val) swap_if_little16(val)
+
+/**
+ * retro_cpu_to_be32:
+ * @val        : unsigned 32-bit value
+ *
+ * Convert unsigned 32-bit value from system to big-endian.
+ *
+ * Returns: Big-endian representation of val.
+ **/
+
+#define retro_cpu_to_be32(val) swap_if_little32(val)
+
+/**
+ * retro_cpu_to_be64:
+ * @val        : unsigned 64-bit value
+ *
+ * Convert unsigned 64-bit value from system to big-endian.
+ *
+ * Returns: Big-endian representation of val.
+ **/
+
+#define retro_cpu_to_be64(val) swap_if_little64(val)
+
+/**
+ * retro_be_to_cpu16:
+ * @val        : unsigned 16-bit value
+ *
+ * Convert unsigned 16-bit value from big-endian to native.
+ *
+ * Returns: Native representation of big-endian val.
+ **/
+
+#define retro_be_to_cpu16(val) swap_if_little16(val)
+
+/**
+ * retro_be_to_cpu32:
+ * @val        : unsigned 32-bit value
+ *
+ * Convert unsigned 32-bit value from big-endian to native.
+ *
+ * Returns: Native representation of big-endian val.
+ **/
+
+#define retro_be_to_cpu32(val) swap_if_little32(val)
+
+/**
+ * retro_be_to_cpu64:
+ * @val        : unsigned 64-bit value
+ *
+ * Convert unsigned 64-bit value from big-endian to native.
+ *
+ * Returns: Native representation of big-endian val.
+ **/
+
+#define retro_be_to_cpu64(val) swap_if_little64(val)
+
+#ifdef  __GNUC__
+/* This attribute means that the same memory may be referred through
+   pointers to different size of the object (aliasing). E.g. that u8 *
+   and u32 * may actually be pointing to the same object.  */
+#define MAY_ALIAS  __attribute__((__may_alias__))
+#else
+#define MAY_ALIAS
+#endif
+
+#pragma pack(push, 1)
+struct retro_unaligned_uint16_s
+{
+  uint16_t val;
+} MAY_ALIAS;
+struct retro_unaligned_uint32_s
+{
+  uint32_t val;
+} MAY_ALIAS;
+struct retro_unaligned_uint64_s
+{
+  uint64_t val;
+} MAY_ALIAS;
+#pragma pack(pop)
+
+typedef struct retro_unaligned_uint16_s retro_unaligned_uint16_t;
+typedef struct retro_unaligned_uint32_s retro_unaligned_uint32_t;
+typedef struct retro_unaligned_uint64_s retro_unaligned_uint64_t;
+
+/* L-value references to unaligned pointers.  */
+#define retro_unaligned16(p) (((retro_unaligned_uint16_t *)p)->val)
+#define retro_unaligned32(p) (((retro_unaligned_uint32_t *)p)->val)
+#define retro_unaligned64(p) (((retro_unaligned_uint64_t *)p)->val)
+
+/**
+ * retro_get_unaligned_16be:
+ * @addr        : pointer to unsigned 16-bit value
+ *
+ * Convert unsigned unaligned 16-bit value from big-endian to native.
+ *
+ * Returns: Native representation of big-endian val.
+ **/
+
+static INLINE uint16_t retro_get_unaligned_16be(void *addr) {
+  return retro_be_to_cpu16(retro_unaligned16(addr));
+}
+
+/**
+ * retro_get_unaligned_32be:
+ * @addr        : pointer to unsigned 32-bit value
+ *
+ * Convert unsigned unaligned 32-bit value from big-endian to native.
+ *
+ * Returns: Native representation of big-endian val.
+ **/
+
+static INLINE uint32_t retro_get_unaligned_32be(void *addr) {
+  return retro_be_to_cpu32(retro_unaligned32(addr));
+}
+
+/**
+ * retro_get_unaligned_64be:
+ * @addr        : pointer to unsigned 64-bit value
+ *
+ * Convert unsigned unaligned 64-bit value from big-endian to native.
+ *
+ * Returns: Native representation of big-endian val.
+ **/
+
+static INLINE uint64_t retro_get_unaligned_64be(void *addr) {
+  return retro_be_to_cpu64(retro_unaligned64(addr));
+}
+
+/**
+ * retro_get_unaligned_16le:
+ * @addr        : pointer to unsigned 16-bit value
+ *
+ * Convert unsigned unaligned 16-bit value from little-endian to native.
+ *
+ * Returns: Native representation of little-endian val.
+ **/
+
+static INLINE uint16_t retro_get_unaligned_16le(void *addr) {
+  return retro_le_to_cpu16(retro_unaligned16(addr));
+}
+
+/**
+ * retro_get_unaligned_32le:
+ * @addr        : pointer to unsigned 32-bit value
+ *
+ * Convert unsigned unaligned 32-bit value from little-endian to native.
+ *
+ * Returns: Native representation of little-endian val.
+ **/
+
+static INLINE uint32_t retro_get_unaligned_32le(void *addr) {
+  return retro_le_to_cpu32(retro_unaligned32(addr));
+}
+
+/**
+ * retro_get_unaligned_64le:
+ * @addr        : pointer to unsigned 64-bit value
+ *
+ * Convert unsigned unaligned 64-bit value from little-endian to native.
+ *
+ * Returns: Native representation of little-endian val.
+ **/
+
+static INLINE uint64_t retro_get_unaligned_64le(void *addr) {
+  return retro_le_to_cpu64(retro_unaligned64(addr));
+}
+
+/**
+ * retro_set_unaligned_16le:
+ * @addr        : pointer to unsigned 16-bit value
+ * @val         : value to store
+ *
+ * Convert native value to unsigned unaligned 16-bit little-endian value
+ *
+ **/
+
+static INLINE void retro_set_unaligned_16le(void *addr, uint16_t v) {
+  retro_unaligned16(addr) = retro_cpu_to_le16(v);
+}
+
+/**
+ * retro_set_unaligned_32le:
+ * @addr        : pointer to unsigned 32-bit value
+ * @val         : value to store
+ *
+ * Convert native value to unsigned unaligned 32-bit little-endian value
+ *
+ **/
+
+static INLINE void retro_set_unaligned_32le(void *addr, uint32_t v) {
+  retro_unaligned32(addr) = retro_cpu_to_le32(v);
+}
+
+/**
+ * retro_set_unaligned_32le:
+ * @addr        : pointer to unsigned 32-bit value
+ * @val         : value to store
+ *
+ * Convert native value to unsigned unaligned 32-bit little-endian value
+ *
+ **/
+
+static INLINE void retro_set_unaligned_64le(void *addr, uint64_t v) {
+  retro_unaligned64(addr) = retro_cpu_to_le64(v);
+}
+
+/**
+ * retro_set_unaligned_16be:
+ * @addr        : pointer to unsigned 16-bit value
+ * @val         : value to store
+ *
+ * Convert native value to unsigned unaligned 16-bit big-endian value
+ *
+ **/
+
+static INLINE void retro_set_unaligned_16be(void *addr, uint16_t v) {
+  retro_unaligned16(addr) = retro_cpu_to_be16(v);
+}
+
+/**
+ * retro_set_unaligned_32be:
+ * @addr        : pointer to unsigned 32-bit value
+ * @val         : value to store
+ *
+ * Convert native value to unsigned unaligned 32-bit big-endian value
+ *
+ **/
+
+static INLINE void retro_set_unaligned_32be(void *addr, uint32_t v) {
+  retro_unaligned32(addr) = retro_cpu_to_be32(v);
+}
+
+/**
+ * retro_set_unaligned_32be:
+ * @addr        : pointer to unsigned 32-bit value
+ * @val         : value to store
+ *
+ * Convert native value to unsigned unaligned 32-bit big-endian value
+ *
+ **/
+
+static INLINE void retro_set_unaligned_64be(void *addr, uint64_t v) {
+  retro_unaligned64(addr) = retro_cpu_to_be64(v);
+}
+
+
+#endif

libretro/libretro-common/include/retro_environment.h

@@ -0,0 +1,114 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (retro_environment.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __LIBRETRO_SDK_ENVIRONMENT_H
+#define __LIBRETRO_SDK_ENVIRONMENT_H
+
+/*
+This file is designed to create a normalized environment for compiling
+libretro-common's private implementations, or any other sources which might
+enjoy use of it's environment (RetroArch for instance).
+This should be an elaborately crafted environment so that sources don't
+need to be full of platform-specific workarounds.
+*/
+
+#if defined (__cplusplus)
+#if 0
+printf("This is C++, version %d.\n", __cplusplus);
+#endif
+/* The expected values would be
+ *   199711L, for ISO/IEC 14882:1998 or 14882:2003
+ */
+
+#elif defined(__STDC__)
+/* This is standard C. */
+
+#if (__STDC__ == 1)
+/* The implementation is ISO-conforming. */
+#define __STDC_ISO__
+#else
+/* The implementation is not ISO-conforming. */
+#endif
+
+#if defined(__STDC_VERSION__)
+#if (__STDC_VERSION__ >= 201112L)
+/* This is C11. */
+#define __STDC_C11__
+#elif (__STDC_VERSION__ >= 199901L)
+/* This is C99. */
+#define __STDC_C99__
+#elif (__STDC_VERSION__ >= 199409L)
+/* This is C89 with amendment 1. */
+#define __STDC_C89__
+#define __STDC_C89_AMENDMENT_1__
+#else
+/* This is C89 without amendment 1. */
+#define __STDC_C89__
+#endif
+#else /* !defined(__STDC_VERSION__) */
+/* This is C89. __STDC_VERSION__ is not defined. */
+#define __STDC_C89__
+#endif
+
+#else   /* !defined(__STDC__) */
+/* This is not standard C. __STDC__ is not defined. */
+#endif
+
+#if defined(WIN32) || defined(_WIN32) || defined(__CYGWIN__) || defined(__MINGW32__)
+/* Try to find out if we're compiling for WinRT or non-WinRT */
+#if defined(_MSC_VER) && defined(__has_include)
+#if __has_include(<winapifamily.h>)
+#define HAVE_WINAPIFAMILY_H 1
+#else
+#define HAVE_WINAPIFAMILY_H 0
+#endif
+
+/* If _USING_V110_SDK71_ is defined it means we are using the Windows XP toolset. */
+#elif defined(_MSC_VER) && (_MSC_VER >= 1700 && !_USING_V110_SDK71_)    /* _MSC_VER == 1700 for Visual Studio 2012 */
+#define HAVE_WINAPIFAMILY_H 1
+#else
+#define HAVE_WINAPIFAMILY_H 0
+#endif
+
+#if HAVE_WINAPIFAMILY_H
+#include <winapifamily.h>
+#define WINAPI_FAMILY_WINRT (!WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) && WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP))
+#else
+#define WINAPI_FAMILY_WINRT 0
+#endif /* HAVE_WINAPIFAMILY_H */
+
+#if WINAPI_FAMILY_WINRT
+#undef __WINRT__
+#define __WINRT__ 1
+#endif
+
+/* MSVC obviously has to have some non-standard constants... */
+#if _M_IX86_FP == 1
+#define __SSE__ 1
+#elif _M_IX86_FP == 2 || (defined(_M_AMD64) || defined(_M_X64))
+#define __SSE__ 1
+#define __SSE2__ 1
+#endif
+
+#endif
+
+#endif

libretro/libretro-common/include/retro_inline.h

@@ -0,0 +1,39 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (retro_inline.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __LIBRETRO_SDK_INLINE_H
+#define __LIBRETRO_SDK_INLINE_H
+
+#ifndef INLINE
+
+#if defined(_WIN32) || defined(__INTEL_COMPILER)
+#define INLINE __inline
+#elif defined(__STDC_VERSION__) && __STDC_VERSION__>=199901L
+#define INLINE inline
+#elif defined(__GNUC__)
+#define INLINE __inline__
+#else
+#define INLINE
+#endif
+
+#endif
+#endif

libretro/libretro-common/include/retro_math.h

@@ -0,0 +1,94 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (retro_math.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef _LIBRETRO_COMMON_MATH_H
+#define _LIBRETRO_COMMON_MATH_H
+
+#include <stdint.h>
+
+#if defined(_WIN32) && !defined(_XBOX)
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#elif defined(_WIN32) && defined(_XBOX)
+#include <Xtl.h>
+#endif
+
+#include <limits.h>
+
+#ifdef _MSC_VER
+#include <compat/msvc.h>
+#endif
+#include <retro_inline.h>
+
+#ifndef M_PI
+#if !defined(USE_MATH_DEFINES)
+#define M_PI 3.14159265358979323846264338327
+#endif
+#endif
+
+#ifndef MAX
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+#endif
+
+#ifndef MIN
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+#endif
+
+/**
+ * next_pow2:
+ * @v         : initial value
+ *
+ * Get next power of 2 value based on  initial value.
+ *
+ * Returns: next power of 2 value (derived from @v).
+ **/
+static INLINE uint32_t next_pow2(uint32_t v)
+{
+   v--;
+   v |= v >> 1;
+   v |= v >> 2;
+   v |= v >> 4;
+   v |= v >> 8;
+   v |= v >> 16;
+   v++;
+   return v;
+}
+
+/**
+ * prev_pow2:
+ * @v         : initial value
+ *
+ * Get previous power of 2 value based on initial value.
+ *
+ * Returns: previous power of 2 value (derived from @v).
+ **/
+static INLINE uint32_t prev_pow2(uint32_t v)
+{
+   v |= v >> 1;
+   v |= v >> 2;
+   v |= v >> 4;
+   v |= v >> 8;
+   v |= v >> 16;
+   return v - (v >> 1);
+}
+
+#endif

libretro/libretro-common/include/retro_miscellaneous.h

@@ -0,0 +1,186 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (retro_miscellaneous.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __RARCH_MISCELLANEOUS_H
+#define __RARCH_MISCELLANEOUS_H
+
+#define RARCH_MAX_SUBSYSTEMS 10
+#define RARCH_MAX_SUBSYSTEM_ROMS 10
+
+#include <stdint.h>
+#include <boolean.h>
+#include <retro_inline.h>
+
+#if defined(_WIN32)
+
+#if defined(_XBOX)
+#include <Xtl.h>
+#else
+#ifndef WIN32_LEAN_AND_MEAN
+#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#endif
+
+#endif
+
+#if defined(__CELLOS_LV2__) && !defined(__PSL1GHT__)
+#include <sys/fs_external.h>
+#endif
+
+#include <limits.h>
+
+#ifdef _MSC_VER
+#include <compat/msvc.h>
+#endif
+
+static INLINE void bits_or_bits(uint32_t *a, uint32_t *b, uint32_t count)
+{
+   uint32_t i;
+   for (i = 0; i < count;i++)
+      a[i] |= b[i];
+}
+
+static INLINE void bits_clear_bits(uint32_t *a, uint32_t *b, uint32_t count)
+{
+   uint32_t i;
+   for (i = 0; i < count;i++)
+      a[i] &= ~b[i];
+}
+
+static INLINE bool bits_any_set(uint32_t* ptr, uint32_t count)
+{
+   uint32_t i;
+   for (i = 0; i < count; i++)
+   {
+      if (ptr[i] != 0)
+         return true;
+   }
+   return false;
+}
+
+#ifndef PATH_MAX_LENGTH
+#if defined(__CELLOS_LV2__) && !defined(__PSL1GHT__)
+#define PATH_MAX_LENGTH CELL_FS_MAX_FS_PATH_LENGTH
+#elif defined(_XBOX1) || defined(_3DS) || defined(PSP) || defined(PS2) || defined(GEKKO)|| defined(WIIU) || defined(ORBIS)
+#define PATH_MAX_LENGTH 512
+#else
+#define PATH_MAX_LENGTH 4096
+#endif
+#endif
+
+#ifndef MAX
+#define MAX(a, b) ((a) > (b) ? (a) : (b))
+#endif
+
+#ifndef MIN
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+#endif
+
+#define ARRAY_SIZE(a)              (sizeof(a) / sizeof((a)[0]))
+
+#define BITS_GET_ELEM(a, i)        ((a).data[i])
+#define BITS_GET_ELEM_PTR(a, i)    ((a)->data[i])
+
+#define BIT_SET(a, bit)   ((a)[(bit) >> 3] |=  (1 << ((bit) & 7)))
+#define BIT_CLEAR(a, bit) ((a)[(bit) >> 3] &= ~(1 << ((bit) & 7)))
+#define BIT_GET(a, bit)   (((a)[(bit) >> 3] >> ((bit) & 7)) & 1)
+
+#define BIT16_SET(a, bit)    ((a) |=  (1 << ((bit) & 15)))
+#define BIT16_CLEAR(a, bit)  ((a) &= ~(1 << ((bit) & 15)))
+#define BIT16_GET(a, bit)    (((a) >> ((bit) & 15)) & 1)
+#define BIT16_CLEAR_ALL(a)   ((a) = 0)
+
+#define BIT32_SET(a, bit)    ((a) |=  (UINT32_C(1) << ((bit) & 31)))
+#define BIT32_CLEAR(a, bit)  ((a) &= ~(UINT32_C(1) << ((bit) & 31)))
+#define BIT32_GET(a, bit)    (((a) >> ((bit) & 31)) & 1)
+#define BIT32_CLEAR_ALL(a)   ((a) = 0)
+
+#define BIT64_SET(a, bit)    ((a) |=  (UINT64_C(1) << ((bit) & 63)))
+#define BIT64_CLEAR(a, bit)  ((a) &= ~(UINT64_C(1) << ((bit) & 63)))
+#define BIT64_GET(a, bit)    (((a) >> ((bit) & 63)) & 1)
+#define BIT64_CLEAR_ALL(a)   ((a) = 0)
+
+#define BIT128_SET(a, bit)   ((a).data[(bit) >> 5] |=  (UINT32_C(1) << ((bit) & 31)))
+#define BIT128_CLEAR(a, bit) ((a).data[(bit) >> 5] &= ~(UINT32_C(1) << ((bit) & 31)))
+#define BIT128_GET(a, bit)   (((a).data[(bit) >> 5] >> ((bit) & 31)) & 1)
+#define BIT128_CLEAR_ALL(a)  memset(&(a), 0, sizeof(a))
+
+#define BIT128_SET_PTR(a, bit)   BIT128_SET(*a, bit)
+#define BIT128_CLEAR_PTR(a, bit) BIT128_CLEAR(*a, bit)
+#define BIT128_GET_PTR(a, bit)   BIT128_GET(*a, bit)
+#define BIT128_CLEAR_ALL_PTR(a)  BIT128_CLEAR_ALL(*a)
+
+#define BIT256_SET(a, bit)       BIT128_SET(a, bit)
+#define BIT256_CLEAR(a, bit)     BIT128_CLEAR(a, bit)
+#define BIT256_GET(a, bit)       BIT128_GET(a, bit)
+#define BIT256_CLEAR_ALL(a)      BIT128_CLEAR_ALL(a)
+
+#define BIT256_SET_PTR(a, bit)   BIT256_SET(*a, bit)
+#define BIT256_CLEAR_PTR(a, bit) BIT256_CLEAR(*a, bit)
+#define BIT256_GET_PTR(a, bit)   BIT256_GET(*a, bit)
+#define BIT256_CLEAR_ALL_PTR(a)  BIT256_CLEAR_ALL(*a)
+
+#define BITS_COPY16_PTR(a,bits) \
+{ \
+   BIT128_CLEAR_ALL_PTR(a); \
+   BITS_GET_ELEM_PTR(a, 0) = (bits) & 0xffff; \
+}
+
+#define BITS_COPY32_PTR(a,bits) \
+{ \
+   BIT128_CLEAR_ALL_PTR(a); \
+   BITS_GET_ELEM_PTR(a, 0) = (bits); \
+}
+
+/* Helper macros and struct to keep track of many booleans. */
+/* This struct has 256 bits. */
+typedef struct
+{
+   uint32_t data[8];
+} retro_bits_t;
+
+#ifdef _WIN32
+#  ifdef _WIN64
+#    define PRI_SIZET PRIu64
+#  else
+#    if _MSC_VER == 1800
+#      define PRI_SIZET PRIu32
+#    else
+#      define PRI_SIZET "u"
+#    endif
+#  endif
+#elif defined(PS2)
+#  define PRI_SIZET "u"
+#else
+#  if (SIZE_MAX == 0xFFFF)
+#    define PRI_SIZET "hu"
+#  elif (SIZE_MAX == 0xFFFFFFFF)
+#    define PRI_SIZET "u"
+#  elif (SIZE_MAX == 0xFFFFFFFFFFFFFFFF)
+#    define PRI_SIZET "lu"
+#  else
+#    error PRI_SIZET: unknown SIZE_MAX
+#  endif
+#endif
+
+#endif

libretro/libretro-common/include/retro_stat.h

@@ -0,0 +1,63 @@
+/* Copyright  (C) 2010-2016 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (retro_stat.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __RETRO_STAT_H
+#define __RETRO_STAT_H
+
+#include <stdint.h>
+#include <stddef.h>
+
+#include <retro_common_api.h>
+
+#include <boolean.h>
+
+RETRO_BEGIN_DECLS
+
+/**
+ * path_is_directory:
+ * @path               : path
+ *
+ * Checks if path is a directory.
+ *
+ * Returns: true (1) if path is a directory, otherwise false (0).
+ */
+bool path_is_directory(const char *path);
+
+bool path_is_character_special(const char *path);
+
+bool path_is_valid(const char *path);
+
+int32_t path_get_size(const char *path);
+
+/**
+ * path_mkdir_norecurse:
+ * @dir                : directory
+ *
+ * Create directory on filesystem.
+ *
+ * Returns: true (1) if directory could be created, otherwise false (0).
+ **/
+bool mkdir_norecurse(const char *dir);
+
+RETRO_END_DECLS
+
+#endif

libretro/libretro-common/include/retro_timers.h

@@ -0,0 +1,112 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (retro_timers.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __LIBRETRO_COMMON_TIMERS_H
+#define __LIBRETRO_COMMON_TIMERS_H
+
+#include <stdint.h>
+
+#if defined(__CELLOS_LV2__) && !defined(__PSL1GHT__)
+#include <sys/timer.h>
+#elif defined(XENON)
+#include <time/time.h>
+#elif defined(GEKKO) || defined(__PSL1GHT__) || defined(__QNX__)
+#include <unistd.h>
+#elif defined(WIIU)
+#include <wiiu/os/thread.h>
+#elif defined(PSP)
+#include <pspthreadman.h>
+#elif defined(VITA)
+#include <psp2/kernel/threadmgr.h>
+#elif defined(_3DS)
+#include <3ds.h>
+#else
+#include <time.h>
+#endif
+
+#if defined(_WIN32) && !defined(_XBOX)
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#elif defined(_WIN32) && defined(_XBOX)
+#include <Xtl.h>
+#endif
+
+#include <limits.h>
+
+#ifdef _MSC_VER
+#include <compat/msvc.h>
+#endif
+#include <retro_inline.h>
+
+#ifdef DJGPP
+#define timespec timeval
+#define tv_nsec tv_usec
+#include <unistd.h>
+
+extern int nanosleep(const struct timespec *rqtp, struct timespec *rmtp);
+
+static int nanosleepDOS(const struct timespec *rqtp, struct timespec *rmtp)
+{
+   usleep(1000000L * rqtp->tv_sec + rqtp->tv_nsec / 1000);
+
+   if (rmtp)
+      rmtp->tv_sec = rmtp->tv_nsec=0;
+
+   return 0;
+}
+
+#define nanosleep nanosleepDOS
+#endif
+
+/**
+ * retro_sleep:
+ * @msec         : amount in milliseconds to sleep
+ *
+ * Sleeps for a specified amount of milliseconds (@msec).
+ **/
+#if defined(__CELLOS_LV2__) && !defined(__PSL1GHT__)
+#define retro_sleep(msec) (sys_timer_usleep(1000 * (msec)))
+#elif defined(PSP) || defined(VITA)
+#define retro_sleep(msec) (sceKernelDelayThread(1000 * (msec)))
+#elif defined(_3DS)
+#define retro_sleep(msec) (svcSleepThread(1000000 * (s64)(msec)))
+#elif defined(__WINRT__) || defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
+#define retro_sleep(msec) (SleepEx((msec), FALSE))
+#elif defined(_WIN32)
+#define retro_sleep(msec) (Sleep((msec)))
+#elif defined(XENON)
+#define retro_sleep(msec) (udelay(1000 * (msec)))
+#elif defined(GEKKO) || defined(__PSL1GHT__) || defined(__QNX__)
+#define retro_sleep(msec) (usleep(1000 * (msec)))
+#elif defined(WIIU)
+#define retro_sleep(msec) (OSSleepTicks(ms_to_ticks((msec))))
+#else
+static INLINE void retro_sleep(unsigned msec)
+{
+   struct timespec tv = {0};
+   tv.tv_sec          = msec / 1000;
+   tv.tv_nsec         = (msec % 1000) * 1000000;
+   nanosleep(&tv, NULL);
+}
+#endif
+
+#endif

libretro/libretro-common/include/string/stdstring.h

@@ -0,0 +1,198 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (stdstring.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __LIBRETRO_SDK_STDSTRING_H
+#define __LIBRETRO_SDK_STDSTRING_H
+
+#include <stdlib.h>
+#include <stddef.h>
+#include <ctype.h>
+#include <string.h>
+#include <boolean.h>
+
+#include <retro_common_api.h>
+#include <retro_inline.h>
+#include <compat/strl.h>
+
+RETRO_BEGIN_DECLS
+
+#define STRLEN_CONST(x)                   ((sizeof((x))-1))
+
+#define strcpy_literal(a, b)              strcpy(a, b)
+
+#define string_is_not_equal(a, b)         !string_is_equal((a), (b))
+
+#define string_is_not_equal_fast(a, b, size) (memcmp(a, b, size) != 0)
+#define string_is_equal_fast(a, b, size)     (memcmp(a, b, size) == 0)
+
+#define TOLOWER(c)   (c |  (lr_char_props[c] & 0x20))
+#define TOUPPER(c)   (c & ~(lr_char_props[c] & 0x20))
+
+/* C standard says \f \v are space, but this one disagrees */
+#define ISSPACE(c)   (lr_char_props[c]  & 0x80) 
+
+#define ISDIGIT(c)   (lr_char_props[c]  & 0x40)
+#define ISALPHA(c)   (lr_char_props[c]  & 0x20)
+#define ISLOWER(c)   (lr_char_props[c]  & 0x04)
+#define ISUPPER(c)   (lr_char_props[c]  & 0x02)
+#define ISALNUM(c)   (lr_char_props[c]  & 0x60)
+#define ISUALPHA(c)  (lr_char_props[c]  & 0x28)
+#define ISUALNUM(c)  (lr_char_props[c]  & 0x68)
+#define IS_XDIGIT(c) (lr_char_props[c]  & 0x01)
+
+/* Deprecated alias, all callers should use string_is_equal_case_insensitive instead */
+#define string_is_equal_noncase string_is_equal_case_insensitive
+
+static INLINE bool string_is_empty(const char *data)
+{
+   return !data || (*data == '\0');
+}
+
+static INLINE bool string_is_equal(const char *a, const char *b)
+{
+   return (a && b) ? !strcmp(a, b) : false;
+}
+
+static INLINE bool string_starts_with_size(const char *str, const char *prefix,
+      size_t size)
+{
+   return (str && prefix) ? !strncmp(prefix, str, size) : false;
+}
+
+static INLINE bool string_starts_with(const char *str, const char *prefix)
+{
+   return (str && prefix) ? !strncmp(prefix, str, strlen(prefix)) : false;
+}
+
+static INLINE bool string_ends_with_size(const char *str, const char *suffix,
+      size_t str_len, size_t suffix_len)
+{
+   return (str_len < suffix_len) ? false :
+         !memcmp(suffix, str + (str_len - suffix_len), suffix_len);
+}
+
+static INLINE bool string_ends_with(const char *str, const char *suffix)
+{
+   if (!str || !suffix)
+      return false;
+   return string_ends_with_size(str, suffix, strlen(str), strlen(suffix));
+}
+
+/* Returns the length of 'str' (c.f. strlen()), but only
+ * checks the first 'size' characters
+ * - If 'str' is NULL, returns 0
+ * - If 'str' is not NULL and no '\0' character is found
+ *   in the first 'size' characters, returns 'size' */
+static INLINE size_t strlen_size(const char *str, size_t size)
+{
+   size_t i = 0;
+   if (str)
+      while (i < size && str[i]) i++;
+   return i;
+}
+
+
+static INLINE bool string_is_equal_case_insensitive(const char *a,
+      const char *b)
+{
+   int result              = 0;
+   const unsigned char *p1 = (const unsigned char*)a;
+   const unsigned char *p2 = (const unsigned char*)b;
+
+   if (!a || !b)
+      return false;
+   if (p1 == p2)
+      return true;
+
+   while ((result = tolower (*p1) - tolower (*p2++)) == 0)
+      if (*p1++ == '\0')
+         break;
+
+   return (result == 0);
+}
+
+char *string_to_upper(char *s);
+
+char *string_to_lower(char *s);
+
+char *string_ucwords(char *s);
+
+char *string_replace_substring(const char *in, const char *pattern,
+      const char *by);
+
+/* Remove leading whitespaces */
+char *string_trim_whitespace_left(char *const s);
+
+/* Remove trailing whitespaces */
+char *string_trim_whitespace_right(char *const s);
+
+/* Remove leading and trailing whitespaces */
+char *string_trim_whitespace(char *const s);
+
+/* max_lines == 0 means no limit */
+char *word_wrap(char *buffer, const char *string,
+      int line_width, bool unicode, unsigned max_lines);
+
+/* Splits string into tokens seperated by 'delim'
+ * > Returned token string must be free()'d
+ * > Returns NULL if token is not found
+ * > After each call, 'str' is set to the position after the
+ *   last found token
+ * > Tokens *include* empty strings
+ * Usage example:
+ *    char *str      = "1,2,3,4,5,6,7,,,10,";
+ *    char **str_ptr = &str;
+ *    char *token    = NULL;
+ *    while ((token = string_tokenize(str_ptr, ",")))
+ *    {
+ *        printf("%s\n", token);
+ *        free(token);
+ *        token = NULL;
+ *    }
+ */
+char* string_tokenize(char **str, const char *delim);
+
+/* Removes every instance of character 'c' from 'str' */
+void string_remove_all_chars(char *str, char c);
+
+/* Replaces every instance of character 'find' in 'str'
+ * with character 'replace' */
+void string_replace_all_chars(char *str, char find, char replace);
+
+/* Converts string to unsigned integer.
+ * Returns 0 if string is invalid  */
+unsigned string_to_unsigned(const char *str);
+
+/* Converts hexadecimal string to unsigned integer.
+ * Handles optional leading '0x'.
+ * Returns 0 if string is invalid  */
+unsigned string_hex_to_unsigned(const char *str);
+
+char *string_init(const char *src);
+
+void string_set(char **string, const char *src);
+
+extern const unsigned char lr_char_props[256];
+
+RETRO_END_DECLS
+
+#endif

libretro/libretro-common/include/time/rtime.h

@@ -0,0 +1,48 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (rtime.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __LIBRETRO_SDK_RTIME_H__
+#define __LIBRETRO_SDK_RTIME_H__
+
+#include <retro_common_api.h>
+
+#include <stdint.h>
+#include <stddef.h>
+#include <time.h>
+
+RETRO_BEGIN_DECLS
+
+/* TODO/FIXME: Move all generic time handling functions
+ * to this file */
+
+/* Must be called before using rtime_localtime() */
+void rtime_init(void);
+
+/* Must be called upon program termination */
+void rtime_deinit(void);
+
+/* Thread-safe wrapper for localtime() */
+struct tm *rtime_localtime(const time_t *timep, struct tm *result);
+
+RETRO_END_DECLS
+
+#endif

libretro/libretro-common/include/vfs/vfs.h

@@ -0,0 +1,111 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+*
+* ---------------------------------------------------------------------------------------
+* The following license statement only applies to this file (vfs_implementation.h).
+* ---------------------------------------------------------------------------------------
+*
+* Permission is hereby granted, free of charge,
+* to any person obtaining a copy of this software and associated documentation files (the "Software"),
+* to deal in the Software without restriction, including without limitation the rights to
+* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef __LIBRETRO_SDK_VFS_H
+#define __LIBRETRO_SDK_VFS_H
+
+#include <retro_common_api.h>
+#include <boolean.h>
+
+#ifdef RARCH_INTERNAL
+#ifndef VFS_FRONTEND
+#define VFS_FRONTEND
+#endif
+#endif
+
+RETRO_BEGIN_DECLS
+
+#ifdef _WIN32
+typedef void* HANDLE;
+#endif
+
+#ifdef HAVE_CDROM
+typedef struct
+{
+   int64_t byte_pos;
+   char *cue_buf;
+   size_t cue_len;
+   unsigned cur_lba;
+   unsigned last_frame_lba;
+   unsigned char cur_min;
+   unsigned char cur_sec;
+   unsigned char cur_frame;
+   unsigned char cur_track;
+   unsigned char last_frame[2352];
+   char drive;
+   bool last_frame_valid;
+} vfs_cdrom_t;
+#endif
+
+enum vfs_scheme
+{
+   VFS_SCHEME_NONE = 0,
+   VFS_SCHEME_CDROM
+};
+
+#ifndef __WINRT__
+#ifdef VFS_FRONTEND
+struct retro_vfs_file_handle
+#else
+struct libretro_vfs_implementation_file
+#endif
+{
+#ifdef HAVE_CDROM
+   vfs_cdrom_t cdrom; /* int64_t alignment */
+#endif
+   int64_t size;
+   uint64_t mappos;
+   uint64_t mapsize;
+   FILE *fp;
+#ifdef _WIN32
+   HANDLE fh;
+#endif
+   char *buf;
+   char* orig_path;
+   uint8_t *mapped;
+   int fd;
+   unsigned hints;
+   enum vfs_scheme scheme;
+};
+#endif
+
+/* Replace the following symbol with something appropriate
+ * to signify the file is being compiled for a front end instead of a core.
+ * This allows the same code to act as reference implementation
+ * for VFS and as fallbacks for when the front end does not provide VFS functionality.
+ */
+
+#ifdef VFS_FRONTEND
+typedef struct retro_vfs_file_handle libretro_vfs_implementation_file;
+#else
+typedef struct libretro_vfs_implementation_file libretro_vfs_implementation_file;
+#endif
+
+#ifdef VFS_FRONTEND
+typedef struct retro_vfs_dir_handle libretro_vfs_implementation_dir;
+#else
+typedef struct libretro_vfs_implementation_dir libretro_vfs_implementation_dir;
+#endif
+
+RETRO_END_DECLS
+
+#endif

libretro/libretro-common/include/vfs/vfs_implementation.h

@@ -0,0 +1,76 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+*
+* ---------------------------------------------------------------------------------------
+* The following license statement only applies to this file (vfs_implementation.h).
+* ---------------------------------------------------------------------------------------
+*
+* Permission is hereby granted, free of charge,
+* to any person obtaining a copy of this software and associated documentation files (the "Software"),
+* to deal in the Software without restriction, including without limitation the rights to
+* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#ifndef __LIBRETRO_SDK_VFS_IMPLEMENTATION_H
+#define __LIBRETRO_SDK_VFS_IMPLEMENTATION_H
+
+#include <stdio.h>
+#include <stdint.h>
+#include <libretro.h>
+#include <retro_environment.h>
+#include <vfs/vfs.h>
+
+RETRO_BEGIN_DECLS
+
+libretro_vfs_implementation_file *retro_vfs_file_open_impl(const char *path, unsigned mode, unsigned hints);
+
+int retro_vfs_file_close_impl(libretro_vfs_implementation_file *stream);
+
+int retro_vfs_file_error_impl(libretro_vfs_implementation_file *stream);
+
+int64_t retro_vfs_file_size_impl(libretro_vfs_implementation_file *stream);
+
+int64_t retro_vfs_file_truncate_impl(libretro_vfs_implementation_file *stream, int64_t length);
+
+int64_t retro_vfs_file_tell_impl(libretro_vfs_implementation_file *stream);
+
+int64_t retro_vfs_file_seek_impl(libretro_vfs_implementation_file *stream, int64_t offset, int seek_position);
+
+int64_t retro_vfs_file_read_impl(libretro_vfs_implementation_file *stream, void *s, uint64_t len);
+
+int64_t retro_vfs_file_write_impl(libretro_vfs_implementation_file *stream, const void *s, uint64_t len);
+
+int retro_vfs_file_flush_impl(libretro_vfs_implementation_file *stream);
+
+int retro_vfs_file_remove_impl(const char *path);
+
+int retro_vfs_file_rename_impl(const char *old_path, const char *new_path);
+
+const char *retro_vfs_file_get_path_impl(libretro_vfs_implementation_file *stream);
+
+int retro_vfs_stat_impl(const char *path, int32_t *size);
+
+int retro_vfs_mkdir_impl(const char *dir);
+
+libretro_vfs_implementation_dir *retro_vfs_opendir_impl(const char *dir, bool include_hidden);
+
+bool retro_vfs_readdir_impl(libretro_vfs_implementation_dir *dirstream);
+
+const char *retro_vfs_dirent_get_name_impl(libretro_vfs_implementation_dir *dirstream);
+
+bool retro_vfs_dirent_is_dir_impl(libretro_vfs_implementation_dir *dirstream);
+
+int retro_vfs_closedir_impl(libretro_vfs_implementation_dir *dirstream);
+
+RETRO_END_DECLS
+
+#endif

libretro/libretro-common/include/vfs/vfs_implementation_cdrom.h

@@ -0,0 +1,52 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (vfs_implementation_cdrom.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __LIBRETRO_SDK_VFS_IMPLEMENTATION_CDROM_H
+#define __LIBRETRO_SDK_VFS_IMPLEMENTATION_CDROM_H
+
+#include <vfs/vfs.h>
+#include <cdrom/cdrom.h>
+
+RETRO_BEGIN_DECLS
+
+int64_t retro_vfs_file_seek_cdrom(libretro_vfs_implementation_file *stream, int64_t offset, int whence);
+
+void retro_vfs_file_open_cdrom(
+      libretro_vfs_implementation_file *stream,
+      const char *path, unsigned mode, unsigned hints);
+
+int retro_vfs_file_close_cdrom(libretro_vfs_implementation_file *stream);
+
+int64_t retro_vfs_file_tell_cdrom(libretro_vfs_implementation_file *stream);
+
+int64_t retro_vfs_file_read_cdrom(libretro_vfs_implementation_file *stream,
+      void *s, uint64_t len);
+
+int retro_vfs_file_error_cdrom(libretro_vfs_implementation_file *stream);
+
+const cdrom_toc_t* retro_vfs_file_get_cdrom_toc(void);
+
+const vfs_cdrom_t* retro_vfs_file_get_cdrom_position(const libretro_vfs_implementation_file *stream);
+
+RETRO_END_DECLS
+
+#endif

libretro/libretro-common/libco/aarch64.c

@@ -0,0 +1,128 @@
+/*
+  libco.aarch64 (2017-06-26)
+  author: webgeek1234
+  license: public domain
+*/
+
+#define LIBCO_C
+#include "libco.h"
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#ifndef IOS
+#include <malloc.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static thread_local uint64_t co_active_buffer[64];
+static thread_local cothread_t co_active_handle;
+
+asm (
+      ".globl co_switch_aarch64\n"
+      ".globl _co_switch_aarch64\n"
+      "co_switch_aarch64:\n"
+      "_co_switch_aarch64:\n"
+      "  stp x8,  x9,  [x1]\n"
+      "  stp x10, x11, [x1, #16]\n"
+      "  stp x12, x13, [x1, #32]\n"
+      "  stp x14, x15, [x1, #48]\n"
+      "  str x19, [x1, #72]\n"
+      "  stp x20, x21, [x1, #80]\n"
+      "  stp x22, x23, [x1, #96]\n"
+      "  stp x24, x25, [x1, #112]\n"
+      "  stp x26, x27, [x1, #128]\n"
+      "  stp x28, x29, [x1, #144]\n"
+      "  mov x16, sp\n"
+      "  stp x16, x30, [x1, #160]\n"
+
+      "  ldp x8,  x9,  [x0]\n"
+      "  ldp x10, x11, [x0, #16]\n"
+      "  ldp x12, x13, [x0, #32]\n"
+      "  ldp x14, x15, [x0, #48]\n"
+      "  ldr x19, [x0, #72]\n"
+      "  ldp x20, x21, [x0, #80]\n"
+      "  ldp x22, x23, [x0, #96]\n"
+      "  ldp x24, x25, [x0, #112]\n"
+      "  ldp x26, x27, [x0, #128]\n"
+      "  ldp x28, x29, [x0, #144]\n"
+      "  ldp x16, x17, [x0, #160]\n"
+      "  mov sp, x16\n"
+      "  br x17\n"
+    );
+
+/* ASM */
+void co_switch_aarch64(cothread_t handle, cothread_t current);
+
+static void crash(void)
+{
+   /* Called only if cothread_t entrypoint returns. */
+   assert(0);
+}
+
+cothread_t co_create(unsigned int size, void (*entrypoint)(void))
+{
+   size = (size + 1023) & ~1023;
+   cothread_t handle = 0;
+#if HAVE_POSIX_MEMALIGN >= 1
+   if (posix_memalign(&handle, 1024, size + 512) < 0)
+      return 0;
+#else
+   handle = memalign(1024, size + 512);
+#endif
+
+   if (!handle)
+      return handle;
+
+   uint64_t *ptr = (uint64_t*)handle;
+   /* Non-volatiles.  */
+   ptr[0]  = 0; /* x8  */
+   ptr[1]  = 0; /* x9  */
+   ptr[2]  = 0; /* x10 */
+   ptr[3]  = 0; /* x11 */
+   ptr[4]  = 0; /* x12 */
+   ptr[5]  = 0; /* x13 */
+   ptr[6]  = 0; /* x14 */
+   ptr[7]  = 0; /* x15 */
+   ptr[8]  = 0; /* padding */
+   ptr[9]  = 0; /* x19 */
+   ptr[10] = 0; /* x20 */
+   ptr[11] = 0; /* x21 */
+   ptr[12] = 0; /* x22 */
+   ptr[13] = 0; /* x23 */
+   ptr[14] = 0; /* x24 */
+   ptr[15] = 0; /* x25 */
+   ptr[16] = 0; /* x26 */
+   ptr[17] = 0; /* x27 */
+   ptr[18] = 0; /* x28 */
+   ptr[20] = (uintptr_t)ptr + size + 512 - 16; /* x30, stack pointer */
+   ptr[19] = ptr[20]; /* x29, frame pointer */
+   ptr[21] = (uintptr_t)entrypoint; /* PC (link register x31 gets saved here). */
+   return handle;
+}
+
+cothread_t co_active(void)
+{
+   if (!co_active_handle)
+      co_active_handle = co_active_buffer;
+   return co_active_handle;
+}
+
+void co_delete(cothread_t handle)
+{
+   free(handle);
+}
+
+void co_switch(cothread_t handle)
+{
+   cothread_t co_previous_handle = co_active();
+   co_switch_aarch64(co_active_handle = handle, co_previous_handle);
+}
+
+#ifdef __cplusplus
+}
+#endif

libretro/libretro-common/libco/amd64.c

@@ -0,0 +1,223 @@
+/*
+  libco.amd64 (2009-10-12)
+  author: byuu
+  license: public domain
+*/
+
+#define LIBCO_C
+#include <libco.h>
+#include <assert.h>
+#include <stdlib.h>
+
+#if defined(__GNUC__) && !defined(_WIN32) && !defined(__cplusplus)
+#define CO_USE_INLINE_ASM
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static thread_local long long co_active_buffer[64];
+static thread_local cothread_t co_active_handle = 0;
+#ifndef CO_USE_INLINE_ASM
+static void (*co_swap)(cothread_t, cothread_t) = 0;
+#endif
+
+#ifdef _WIN32
+/* ABI: Win64 */
+  /* On windows handle is allocated by malloc and there it's guaranteed to
+     have at least 16-byte alignment. Hence we don't need to align
+     it in order to use movaps.  */
+static unsigned char co_swap_function[] = {
+    0x48, 0x89, 0x22,              /* mov [rdx],rsp          */
+    0x48, 0x8b, 0x21,              /* mov rsp,[rcx]          */
+    0x58,                          /* pop rax                */
+    0x48, 0x89, 0x6a, 0x08,        /* mov [rdx+ 8],rbp       */
+    0x48, 0x89, 0x72, 0x10,        /* mov [rdx+16],rsi       */
+    0x48, 0x89, 0x7a, 0x18,        /* mov [rdx+24],rdi       */
+    0x48, 0x89, 0x5a, 0x20,        /* mov [rdx+32],rbx       */
+    0x4c, 0x89, 0x62, 0x28,        /* mov [rdx+40],r12       */
+    0x4c, 0x89, 0x6a, 0x30,        /* mov [rdx+48],r13       */
+    0x4c, 0x89, 0x72, 0x38,        /* mov [rdx+56],r14       */
+    0x4c, 0x89, 0x7a, 0x40,        /* mov [rdx+64],r15       */
+  #if !defined(LIBCO_NO_SSE)
+    0x0f, 0x29, 0x72, 0x50,        /* movaps [rdx+ 80],xmm6  */
+    0x0f, 0x29, 0x7a, 0x60,        /* movaps [rdx+ 96],xmm7  */
+    0x44, 0x0f, 0x29, 0x42, 0x70,  /* movaps [rdx+112],xmm8  */
+    0x48, 0x83, 0xc2, 0x70,        /* add rdx,112            */
+    0x44, 0x0f, 0x29, 0x4a, 0x10,  /* movaps [rdx+ 16],xmm9  */
+    0x44, 0x0f, 0x29, 0x52, 0x20,  /* movaps [rdx+ 32],xmm10 */
+    0x44, 0x0f, 0x29, 0x5a, 0x30,  /* movaps [rdx+ 48],xmm11 */
+    0x44, 0x0f, 0x29, 0x62, 0x40,  /* movaps [rdx+ 64],xmm12 */
+    0x44, 0x0f, 0x29, 0x6a, 0x50,  /* movaps [rdx+ 80],xmm13 */
+    0x44, 0x0f, 0x29, 0x72, 0x60,  /* movaps [rdx+ 96],xmm14 */
+    0x44, 0x0f, 0x29, 0x7a, 0x70,  /* movaps [rdx+112],xmm15 */
+  #endif
+    0x48, 0x8b, 0x69, 0x08,        /* mov rbp,[rcx+ 8]       */
+    0x48, 0x8b, 0x71, 0x10,        /* mov rsi,[rcx+16]       */
+    0x48, 0x8b, 0x79, 0x18,        /* mov rdi,[rcx+24]       */
+    0x48, 0x8b, 0x59, 0x20,        /* mov rbx,[rcx+32]       */
+    0x4c, 0x8b, 0x61, 0x28,        /* mov r12,[rcx+40]       */
+    0x4c, 0x8b, 0x69, 0x30,        /* mov r13,[rcx+48]       */
+    0x4c, 0x8b, 0x71, 0x38,        /* mov r14,[rcx+56]       */
+    0x4c, 0x8b, 0x79, 0x40,        /* mov r15,[rcx+64]       */
+  #if !defined(LIBCO_NO_SSE)
+    0x0f, 0x28, 0x71, 0x50,        /* movaps xmm6, [rcx+ 80] */
+    0x0f, 0x28, 0x79, 0x60,        /* movaps xmm7, [rcx+ 96] */
+    0x44, 0x0f, 0x28, 0x41, 0x70,  /* movaps xmm8, [rcx+112] */
+    0x48, 0x83, 0xc1, 0x70,        /* add rcx,112            */
+    0x44, 0x0f, 0x28, 0x49, 0x10,  /* movaps xmm9, [rcx+ 16] */
+    0x44, 0x0f, 0x28, 0x51, 0x20,  /* movaps xmm10,[rcx+ 32] */
+    0x44, 0x0f, 0x28, 0x59, 0x30,  /* movaps xmm11,[rcx+ 48] */
+    0x44, 0x0f, 0x28, 0x61, 0x40,  /* movaps xmm12,[rcx+ 64] */
+    0x44, 0x0f, 0x28, 0x69, 0x50,  /* movaps xmm13,[rcx+ 80] */
+    0x44, 0x0f, 0x28, 0x71, 0x60,  /* movaps xmm14,[rcx+ 96] */
+    0x44, 0x0f, 0x28, 0x79, 0x70,  /* movaps xmm15,[rcx+112] */
+  #endif
+    0xff, 0xe0,                    /* jmp rax                */
+};
+
+#include <windows.h>
+
+static void co_init(void)
+{
+   DWORD old_privileges;
+   VirtualProtect(co_swap_function,
+         sizeof(co_swap_function), PAGE_EXECUTE_READWRITE, &old_privileges);
+}
+#else
+/* ABI: SystemV */
+#ifndef CO_USE_INLINE_ASM
+static unsigned char co_swap_function[] = {
+  0x48, 0x89, 0x26,                                 /* mov    [rsi],rsp      */
+  0x48, 0x8b, 0x27,                                 /* mov    rsp,[rdi]      */
+  0x58,                                             /* pop    rax            */
+  0x48, 0x89, 0x6e, 0x08,                           /* mov    [rsi+0x08],rbp */
+  0x48, 0x89, 0x5e, 0x10,                           /* mov    [rsi+0x10],rbx */
+  0x4c, 0x89, 0x66, 0x18,                           /* mov    [rsi+0x18],r12 */
+  0x4c, 0x89, 0x6e, 0x20,                           /* mov    [rsi+0x20],r13 */
+  0x4c, 0x89, 0x76, 0x28,                           /* mov    [rsi+0x28],r14 */
+  0x4c, 0x89, 0x7e, 0x30,                           /* mov    [rsi+0x30],r15 */
+  0x48, 0x8b, 0x6f, 0x08,                           /* mov    rbp,[rdi+0x08] */
+  0x48, 0x8b, 0x5f, 0x10,                           /* mov    rbx,[rdi+0x10] */
+  0x4c, 0x8b, 0x67, 0x18,                           /* mov    r12,[rdi+0x18] */
+  0x4c, 0x8b, 0x6f, 0x20,                           /* mov    r13,[rdi+0x20] */
+  0x4c, 0x8b, 0x77, 0x28,                           /* mov    r14,[rdi+0x28] */
+  0x4c, 0x8b, 0x7f, 0x30,                           /* mov    r15,[rdi+0x30] */
+  0xff, 0xe0,                                       /* jmp    rax            */
+};
+
+#include <unistd.h>
+#include <sys/mman.h>
+
+static void co_init(void)
+{
+   unsigned long long addr = (unsigned long long)co_swap_function;
+   unsigned long long base = addr - (addr % sysconf(_SC_PAGESIZE));
+   unsigned long long size = (addr - base) + sizeof(co_swap_function);
+   mprotect((void*)base, size, PROT_READ | PROT_WRITE | PROT_EXEC);
+}
+#else
+static void co_init(void) {}
+#endif
+#endif
+
+static void crash(void)
+{
+  assert(0); /* called only if cothread_t entrypoint returns */
+}
+
+cothread_t co_active(void)
+{
+  if (!co_active_handle)
+     co_active_handle = &co_active_buffer;
+  return co_active_handle;
+}
+
+cothread_t co_create(unsigned int size, void (*entrypoint)(void))
+{
+   cothread_t handle;
+
+#ifndef CO_USE_INLINE_ASM
+   if(!co_swap)
+   {
+      co_init();
+      co_swap = (void (*)(cothread_t, cothread_t))co_swap_function;
+   }
+#endif
+
+   if (!co_active_handle)
+      co_active_handle = &co_active_buffer;
+   size += 512; /* allocate additional space for storage */
+   size &= ~15; /* align stack to 16-byte boundary */
+
+#ifdef __GENODE__
+   if((handle = (cothread_t)genode_alloc_secondary_stack(size)))
+   {
+      long long *p = (long long*)((char*)handle); /* OS returns top of stack */
+      *--p = (long long)crash;                    /* crash if entrypoint returns */
+      *--p = (long long)entrypoint;               /* start of function */
+      *(long long*)handle = (long long)p;         /* stack pointer */
+   }
+#else
+   if((handle = (cothread_t)malloc(size)))
+   {
+      long long *p = (long long*)((char*)handle + size); /* seek to top of stack */
+      *--p = (long long)crash;                           /* crash if entrypoint returns */
+      *--p = (long long)entrypoint;                      /* start of function */
+      *(long long*)handle = (long long)p;                /* stack pointer */
+   }
+#endif
+
+   return handle;
+}
+
+void co_delete(cothread_t handle)
+{
+#ifdef __GENODE__
+   genode_free_secondary_stack(handle);
+#else
+   free(handle);
+#endif
+}
+
+#ifndef CO_USE_INLINE_ASM
+void co_switch(cothread_t handle)
+{
+  register cothread_t co_previous_handle = co_active_handle;
+  co_swap(co_active_handle = handle, co_previous_handle);
+}
+#else
+#ifdef __APPLE__
+#define ASM_PREFIX "_"
+#else
+#define ASM_PREFIX ""
+#endif
+__asm__(
+".intel_syntax noprefix         \n"
+".globl " ASM_PREFIX "co_switch              \n"
+ASM_PREFIX "co_switch:                     \n"
+"mov rsi, [rip+" ASM_PREFIX "co_active_handle]\n"
+"mov [rsi],rsp                  \n"
+"mov [rsi+0x08],rbp             \n"
+"mov [rsi+0x10],rbx             \n"
+"mov [rsi+0x18],r12             \n"
+"mov [rsi+0x20],r13             \n"
+"mov [rsi+0x28],r14             \n"
+"mov [rsi+0x30],r15             \n"
+"mov [rip+" ASM_PREFIX "co_active_handle], rdi\n"
+"mov rsp,[rdi]                  \n"
+"mov rbp,[rdi+0x08]             \n"
+"mov rbx,[rdi+0x10]             \n"
+"mov r12,[rdi+0x18]             \n"
+"mov r13,[rdi+0x20]             \n"
+"mov r14,[rdi+0x28]             \n"
+"mov r15,[rdi+0x30]             \n"
+"ret                            \n"
+".att_syntax                    \n"
+);
+#endif
+
+#ifdef __cplusplus
+}
+#endif

libretro/libretro-common/libco/armeabi.c

@@ -0,0 +1,109 @@
+/*
+  libco.armeabi (2013-04-05)
+  author: Themaister
+  license: public domain
+*/
+
+#define LIBCO_C
+#include <libco.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#ifndef __APPLE__
+#include <malloc.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static thread_local uint32_t co_active_buffer[64];
+static thread_local cothread_t co_active_handle;
+
+__asm__ (
+#if defined(__thumb2__)
+      ".align 2\n"
+      ".globl co_switch_arm\n"
+      ".globl _co_switch_arm\n"
+      ".thumb\n"
+      ".thumb_func\n"
+      ".type   co_switch_arm, %function\n"
+      ".type   _co_switch_arm, %function\n"
+      "co_switch_arm:\n"
+      "_co_switch_arm:\n"
+      " mov r3, sp\n"
+      " stmia r1!, {r4, r5, r6, r7, r8, r9, r10, r11}\n"
+      " stmia r1!, {r3, lr}\n"
+      " ldmia r0!, {r4, r5, r6, r7, r8, r9, r10, r11}\n"
+      " ldmfd r0!, { r3 }\n"
+      " mov sp, r3\n"
+      " ldmfd r0!, { r3 }\n"
+      " mov pc, r3\n"
+#else
+      ".arm\n"
+      ".align 4\n"
+      ".globl co_switch_arm\n"
+      ".globl _co_switch_arm\n"
+      "co_switch_arm:\n"
+      "_co_switch_arm:\n"
+      "  stmia r1!, {r4, r5, r6, r7, r8, r9, r10, r11, sp, lr}\n"
+      "  ldmia r0!, {r4, r5, r6, r7, r8, r9, r10, r11, sp, pc}\n"
+#endif
+    );
+
+/* ASM */
+void co_switch_arm(cothread_t handle, cothread_t current);
+
+cothread_t co_create(unsigned int size, void (*entrypoint)(void))
+{
+   size = (size + 1023) & ~1023;
+   cothread_t handle = 0;
+#if defined(__APPLE__) || HAVE_POSIX_MEMALIGN >= 1
+   if (posix_memalign(&handle, 1024, size + 256) < 0)
+      return 0;
+#else
+   handle = memalign(1024, size + 256);
+#endif
+
+   if (!handle)
+      return handle;
+
+   uint32_t *ptr = (uint32_t*)handle;
+   /* Non-volatiles.  */
+   ptr[0] = 0; /* r4  */
+   ptr[1] = 0; /* r5  */
+   ptr[2] = 0; /* r6  */
+   ptr[3] = 0; /* r7  */
+   ptr[4] = 0; /* r8  */
+   ptr[5] = 0; /* r9  */
+   ptr[6] = 0; /* r10 */
+   ptr[7] = 0; /* r11 */
+   /* Align stack to 64-bit */
+   ptr[8] = (uintptr_t)ptr + size + 256 - 8; /* r13, stack pointer */
+   ptr[9] = (uintptr_t)entrypoint; /* r15, PC (link register r14 gets saved here). */
+   return handle;
+}
+
+cothread_t co_active(void)
+{
+   if (!co_active_handle)
+      co_active_handle = co_active_buffer;
+   return co_active_handle;
+}
+
+void co_delete(cothread_t handle)
+{
+   free(handle);
+}
+
+void co_switch(cothread_t handle)
+{
+   cothread_t co_previous_handle = co_active();
+   co_switch_arm(co_active_handle = handle, co_previous_handle);
+}
+
+#ifdef __cplusplus
+}
+#endif

libretro/libretro-common/libco/fiber.c

@@ -0,0 +1,71 @@
+/*
+  libco.win (2008-01-28)
+  authors: Nach, byuu
+  license: public domain
+*/
+
+#define LIBCO_C
+#include <libco.h>
+#define WINVER 0x0400
+#define _WIN32_WINNT 0x0400
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static thread_local cothread_t co_active_ = 0;
+
+static void __stdcall co_thunk(void *coentry)
+{
+   ((void (*)(void))coentry)();
+}
+
+cothread_t co_active(void)
+{
+   if(!co_active_)
+   {
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
+      ConvertThreadToFiberEx(0, FIBER_FLAG_FLOAT_SWITCH);
+#else
+      ConvertThreadToFiber(0);
+#endif
+      co_active_ = GetCurrentFiber();
+   }
+   return co_active_;
+}
+
+cothread_t co_create(unsigned int heapsize, void (*coentry)(void))
+{
+   if(!co_active_)
+   {
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
+      ConvertThreadToFiberEx(0, FIBER_FLAG_FLOAT_SWITCH);
+#else
+      ConvertThreadToFiber(0);
+#endif
+      co_active_ = GetCurrentFiber();
+   }
+
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
+   return (cothread_t)CreateFiberEx(heapsize, heapsize, FIBER_FLAG_FLOAT_SWITCH, co_thunk, (void*)coentry);
+#else
+   return (cothread_t)CreateFiber(heapsize, co_thunk, (void*)coentry);
+#endif
+}
+
+void co_delete(cothread_t cothread)
+{
+   DeleteFiber(cothread);
+}
+
+void co_switch(cothread_t cothread)
+{
+   co_active_ = cothread;
+   SwitchToFiber(cothread);
+}
+
+#ifdef __cplusplus
+}
+#endif

libretro/libretro-common/libco/genode.cpp

@@ -0,0 +1,29 @@
+/*
+  libco.genode_secondary_stack (2018-09-15)
+  author: Emery Hemingway
+  license: public domain
+*/
+
+/* Genode include */
+#include <base/thread.h>
+
+/* Libco include */
+#include <libco.h>
+
+extern "C"
+void *genode_alloc_secondary_stack(unsigned long stack_size)
+{
+	try {
+		return Genode::Thread::myself()->alloc_secondary_stack("libco", stack_size); }
+	catch (...) {
+		Genode::error("libco: failed to allocate ", stack_size, " byte secondary stack");
+		return nullptr;
+	}
+
+}
+
+extern "C"
+void genode_free_secondary_stack(void *stack)
+{
+	Genode::Thread::myself()->free_secondary_stack(stack);
+}

libretro/libretro-common/libco/libco.c

@@ -0,0 +1,43 @@
+/*
+  libco
+  auto-selection module
+  license: public domain
+*/
+
+#ifdef __GENODE__
+void *genode_alloc_secondary_stack(unsigned long stack_size);
+void genode_free_secondary_stack(void *stack);
+#endif
+
+#if defined _MSC_VER
+  #include <Windows.h>
+  #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
+    #include "fiber.c"
+  #elif defined _M_IX86
+    #include "x86.c"
+  #elif defined _M_AMD64
+    #include "amd64.c"
+  #else
+    #include "fiber.c"
+  #endif
+#elif defined __GNUC__
+  #if defined __i386__
+    #include "x86.c"
+  #elif defined __amd64__
+    #include "amd64.c"
+  #elif defined _ARCH_PPC
+    #include "ppc.c"
+  #elif defined(__aarch64__)
+    #include "aarch64.c"
+  #elif defined(PSP)
+    #include "psp1.c"
+  #elif defined VITA
+    #include "scefiber.c"
+  #elif defined(__ARM_EABI__) || defined(__arm__)
+    #include "armeabi.c"
+  #else
+    #include "sjlj.c"
+  #endif
+#else
+  #error "libco: unsupported processor, compiler or operating system"
+#endif

libretro/libretro-common/libco/ppc.c

@@ -0,0 +1,407 @@
+/*
+  libco.ppc (2010-10-17)
+  author: blargg
+  license: public domain
+*/
+
+/* PowerPC 32/64 using embedded or external asm, with optional
+floating-point and AltiVec save/restore */
+
+#define LIBCO_C
+#include <libco.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+
+#define LIBCO_MPROTECT (__unix__ && !LIBCO_PPC_ASM)
+
+#if LIBCO_MPROTECT
+	#include <unistd.h>
+	#include <sys/mman.h>
+#endif
+
+/* State format (offsets in 32-bit words)
+
++0	Pointer to swap code
+	Rest of function descriptor for entry function
++8	PC
++10	SP
+	Special regs
+	GPRs
+	FPRs
+	VRs
+	stack
+*/
+
+enum { state_size  = 1024 };
+enum { above_stack = 2048 };
+enum { stack_align = 256  };
+
+static thread_local cothread_t co_active_handle = 0;
+
+/**** Determine environment ****/
+
+#define LIBCO_PPC64 (_ARCH_PPC64 || __PPC64__ || __ppc64__ || __powerpc64__)
+
+/* Whether function calls are indirect through a descriptor,
+or are directly to function */
+#ifndef LIBCO_PPCDESC
+	#if !_CALL_SYSV && (_CALL_AIX || _CALL_AIXDESC || LIBCO_PPC64)
+		#define LIBCO_PPCDESC 1
+	#endif
+#endif
+
+#ifdef LIBCO_PPC_ASM
+
+	#ifdef __cplusplus
+		extern "C"
+	#endif
+
+	/* Swap code is in ppc.S */
+	void co_swap_asm( cothread_t, cothread_t );
+	#define CO_SWAP_ASM( x, y ) co_swap_asm( x, y )
+
+#else
+
+/* Swap code is here in array. Please leave dieassembly comments,
+as they make it easy to see what it does, and reorder instructions
+if one wants to see whether that improves performance. */
+static const uint32_t libco_ppc_code [] = {
+#if LIBCO_PPC64
+    0x7d000026, /* mfcr    r8 */
+    0xf8240028, /* std     r1,40(r4) */
+    0x7d2802a6, /* mflr    r9 */
+    0xf9c40048, /* std     r14,72(r4) */
+    0xf9e40050, /* std     r15,80(r4) */
+    0xfa040058, /* std     r16,88(r4) */
+    0xfa240060, /* std     r17,96(r4) */
+    0xfa440068, /* std     r18,104(r4) */
+    0xfa640070, /* std     r19,112(r4) */
+    0xfa840078, /* std     r20,120(r4) */
+    0xfaa40080, /* std     r21,128(r4) */
+    0xfac40088, /* std     r22,136(r4) */
+    0xfae40090, /* std     r23,144(r4) */
+    0xfb040098, /* std     r24,152(r4) */
+    0xfb2400a0, /* std     r25,160(r4) */
+    0xfb4400a8, /* std     r26,168(r4) */
+    0xfb6400b0, /* std     r27,176(r4) */
+    0xfb8400b8, /* std     r28,184(r4) */
+    0xfba400c0, /* std     r29,192(r4) */
+    0xfbc400c8, /* std     r30,200(r4) */
+    0xfbe400d0, /* std     r31,208(r4) */
+    0xf9240020, /* std     r9,32(r4) */
+    0xe8e30020, /* ld      r7,32(r3) */
+    0xe8230028, /* ld      r1,40(r3) */
+    0x48000009, /* bl      1 */
+	0x7fe00008, /* trap */
+    0x91040030,/*1:stw     r8,48(r4) */
+    0x80c30030, /* lwz     r6,48(r3) */
+    0x7ce903a6, /* mtctr   r7 */
+    0xe9c30048, /* ld      r14,72(r3) */
+    0xe9e30050, /* ld      r15,80(r3) */
+    0xea030058, /* ld      r16,88(r3) */
+    0xea230060, /* ld      r17,96(r3) */
+    0xea430068, /* ld      r18,104(r3) */
+    0xea630070, /* ld      r19,112(r3) */
+    0xea830078, /* ld      r20,120(r3) */
+    0xeaa30080, /* ld      r21,128(r3) */
+    0xeac30088, /* ld      r22,136(r3) */
+    0xeae30090, /* ld      r23,144(r3) */
+    0xeb030098, /* ld      r24,152(r3) */
+    0xeb2300a0, /* ld      r25,160(r3) */
+    0xeb4300a8, /* ld      r26,168(r3) */
+    0xeb6300b0, /* ld      r27,176(r3) */
+    0xeb8300b8, /* ld      r28,184(r3) */
+    0xeba300c0, /* ld      r29,192(r3) */
+    0xebc300c8, /* ld      r30,200(r3) */
+    0xebe300d0, /* ld      r31,208(r3) */
+    0x7ccff120, /* mtcr    r6 */
+#else
+	0x7d000026, /* mfcr    r8 */
+	0x90240028, /* stw     r1,40(r4) */
+	0x7d2802a6, /* mflr    r9 */
+	0x91a4003c, /* stw     r13,60(r4) */
+	0x91c40040, /* stw     r14,64(r4) */
+	0x91e40044, /* stw     r15,68(r4) */
+	0x92040048, /* stw     r16,72(r4) */
+	0x9224004c, /* stw     r17,76(r4) */
+	0x92440050, /* stw     r18,80(r4) */
+	0x92640054, /* stw     r19,84(r4) */
+	0x92840058, /* stw     r20,88(r4) */
+	0x92a4005c, /* stw     r21,92(r4) */
+	0x92c40060, /* stw     r22,96(r4) */
+	0x92e40064, /* stw     r23,100(r4) */
+	0x93040068, /* stw     r24,104(r4) */
+	0x9324006c, /* stw     r25,108(r4) */
+	0x93440070, /* stw     r26,112(r4) */
+	0x93640074, /* stw     r27,116(r4) */
+	0x93840078, /* stw     r28,120(r4) */
+	0x93a4007c, /* stw     r29,124(r4) */
+	0x93c40080, /* stw     r30,128(r4) */
+	0x93e40084, /* stw     r31,132(r4) */
+	0x91240020, /* stw     r9,32(r4) */
+	0x80e30020, /* lwz     r7,32(r3) */
+	0x80230028, /* lwz     r1,40(r3) */
+	0x48000009, /* bl      1 */
+	0x7fe00008, /* trap */
+	0x91040030,/*1:stw     r8,48(r4) */
+	0x80c30030, /* lwz     r6,48(r3) */
+	0x7ce903a6, /* mtctr   r7 */
+	0x81a3003c, /* lwz     r13,60(r3) */
+	0x81c30040, /* lwz     r14,64(r3) */
+	0x81e30044, /* lwz     r15,68(r3) */
+	0x82030048, /* lwz     r16,72(r3) */
+	0x8223004c, /* lwz     r17,76(r3) */
+	0x82430050, /* lwz     r18,80(r3) */
+	0x82630054, /* lwz     r19,84(r3) */
+	0x82830058, /* lwz     r20,88(r3) */
+	0x82a3005c, /* lwz     r21,92(r3) */
+	0x82c30060, /* lwz     r22,96(r3) */
+	0x82e30064, /* lwz     r23,100(r3) */
+	0x83030068, /* lwz     r24,104(r3) */
+	0x8323006c, /* lwz     r25,108(r3) */
+	0x83430070, /* lwz     r26,112(r3) */
+	0x83630074, /* lwz     r27,116(r3) */
+	0x83830078, /* lwz     r28,120(r3) */
+	0x83a3007c, /* lwz     r29,124(r3) */
+	0x83c30080, /* lwz     r30,128(r3) */
+	0x83e30084, /* lwz     r31,132(r3) */
+	0x7ccff120, /* mtcr    r6 */
+#endif
+
+#ifndef LIBCO_PPC_NOFP
+	0xd9c400e0, /* stfd    f14,224(r4) */
+	0xd9e400e8, /* stfd    f15,232(r4) */
+	0xda0400f0, /* stfd    f16,240(r4) */
+	0xda2400f8, /* stfd    f17,248(r4) */
+	0xda440100, /* stfd    f18,256(r4) */
+	0xda640108, /* stfd    f19,264(r4) */
+	0xda840110, /* stfd    f20,272(r4) */
+	0xdaa40118, /* stfd    f21,280(r4) */
+	0xdac40120, /* stfd    f22,288(r4) */
+	0xdae40128, /* stfd    f23,296(r4) */
+	0xdb040130, /* stfd    f24,304(r4) */
+	0xdb240138, /* stfd    f25,312(r4) */
+	0xdb440140, /* stfd    f26,320(r4) */
+	0xdb640148, /* stfd    f27,328(r4) */
+	0xdb840150, /* stfd    f28,336(r4) */
+	0xdba40158, /* stfd    f29,344(r4) */
+	0xdbc40160, /* stfd    f30,352(r4) */
+	0xdbe40168, /* stfd    f31,360(r4) */
+	0xc9c300e0, /* lfd     f14,224(r3) */
+	0xc9e300e8, /* lfd     f15,232(r3) */
+	0xca0300f0, /* lfd     f16,240(r3) */
+	0xca2300f8, /* lfd     f17,248(r3) */
+	0xca430100, /* lfd     f18,256(r3) */
+	0xca630108, /* lfd     f19,264(r3) */
+	0xca830110, /* lfd     f20,272(r3) */
+	0xcaa30118, /* lfd     f21,280(r3) */
+	0xcac30120, /* lfd     f22,288(r3) */
+	0xcae30128, /* lfd     f23,296(r3) */
+	0xcb030130, /* lfd     f24,304(r3) */
+	0xcb230138, /* lfd     f25,312(r3) */
+	0xcb430140, /* lfd     f26,320(r3) */
+	0xcb630148, /* lfd     f27,328(r3) */
+	0xcb830150, /* lfd     f28,336(r3) */
+	0xcba30158, /* lfd     f29,344(r3) */
+	0xcbc30160, /* lfd     f30,352(r3) */
+	0xcbe30168, /* lfd     f31,360(r3) */
+#endif
+
+#ifdef __ALTIVEC__
+	0x7ca042a6, /* mfvrsave r5 */
+	0x39040180, /* addi    r8,r4,384 */
+	0x39240190, /* addi    r9,r4,400 */
+	0x70a00fff, /* andi.   r0,r5,4095 */
+	0x90a40034, /* stw     r5,52(r4) */
+	0x4182005c, /* beq-    2 */
+	0x7e8041ce, /* stvx    v20,r0,r8 */
+	0x39080020, /* addi    r8,r8,32 */
+	0x7ea049ce, /* stvx    v21,r0,r9 */
+	0x39290020, /* addi    r9,r9,32 */
+	0x7ec041ce, /* stvx    v22,r0,r8 */
+	0x39080020, /* addi    r8,r8,32 */
+	0x7ee049ce, /* stvx    v23,r0,r9 */
+	0x39290020, /* addi    r9,r9,32 */
+	0x7f0041ce, /* stvx    v24,r0,r8 */
+	0x39080020, /* addi    r8,r8,32 */
+	0x7f2049ce, /* stvx    v25,r0,r9 */
+	0x39290020, /* addi    r9,r9,32 */
+	0x7f4041ce, /* stvx    v26,r0,r8 */
+	0x39080020, /* addi    r8,r8,32 */
+	0x7f6049ce, /* stvx    v27,r0,r9 */
+	0x39290020, /* addi    r9,r9,32 */
+	0x7f8041ce, /* stvx    v28,r0,r8 */
+	0x39080020, /* addi    r8,r8,32 */
+	0x7fa049ce, /* stvx    v29,r0,r9 */
+	0x39290020, /* addi    r9,r9,32 */
+	0x7fc041ce, /* stvx    v30,r0,r8 */
+	0x7fe049ce, /* stvx    v31,r0,r9 */
+	0x80a30034,/*2:lwz     r5,52(r3) */
+	0x39030180, /* addi    r8,r3,384 */
+	0x39230190, /* addi    r9,r3,400 */
+	0x70a00fff, /* andi.   r0,r5,4095 */
+	0x7ca043a6, /* mtvrsave r5 */
+	0x4d820420, /* beqctr   */
+	0x7e8040ce, /* lvx     v20,r0,r8 */
+	0x39080020, /* addi    r8,r8,32 */
+	0x7ea048ce, /* lvx     v21,r0,r9 */
+	0x39290020, /* addi    r9,r9,32 */
+	0x7ec040ce, /* lvx     v22,r0,r8 */
+	0x39080020, /* addi    r8,r8,32 */
+	0x7ee048ce, /* lvx     v23,r0,r9 */
+	0x39290020, /* addi    r9,r9,32 */
+	0x7f0040ce, /* lvx     v24,r0,r8 */
+	0x39080020, /* addi    r8,r8,32 */
+	0x7f2048ce, /* lvx     v25,r0,r9 */
+	0x39290020, /* addi    r9,r9,32 */
+	0x7f4040ce, /* lvx     v26,r0,r8 */
+	0x39080020, /* addi    r8,r8,32 */
+	0x7f6048ce, /* lvx     v27,r0,r9 */
+	0x39290020, /* addi    r9,r9,32 */
+	0x7f8040ce, /* lvx     v28,r0,r8 */
+	0x39080020, /* addi    r8,r8,32 */
+	0x7fa048ce, /* lvx     v29,r0,r9 */
+	0x39290020, /* addi    r9,r9,32 */
+	0x7fc040ce, /* lvx     v30,r0,r8 */
+	0x7fe048ce, /* lvx     v31,r0,r9 */
+#endif
+
+	0x4e800420, /* bctr */
+};
+
+	#if LIBCO_PPCDESC
+		/* Function call goes through indirect descriptor */
+		#define CO_SWAP_ASM( x, y ) \
+			((void (*)( cothread_t, cothread_t )) (uintptr_t) x)( x, y )
+	#else
+		/* Function call goes directly to code */
+		#define CO_SWAP_ASM( x, y ) \
+			((void (*)( cothread_t, cothread_t )) (uintptr_t) libco_ppc_code)( x, y )
+	#endif
+
+#endif
+
+static uint32_t* co_create_( unsigned size, uintptr_t entry )
+{
+	uint32_t* t = (uint32_t*) malloc( size );
+
+	(void) entry;
+
+	#if LIBCO_PPCDESC
+		if ( t )
+		{
+			/* Copy entry's descriptor */
+			memcpy( t, (void*) entry, sizeof (void*) * 3 );
+
+			/* Set function pointer to swap routine */
+			#ifdef LIBCO_PPC_ASM
+				*(const void**) t = *(void**) &co_swap_asm;
+			#else
+				*(const void**) t = libco_ppc_code;
+			#endif
+		}
+	#endif
+
+	return t;
+}
+
+cothread_t co_create( unsigned int size, void (*entry_)( void ) )
+{
+	uintptr_t entry = (uintptr_t) entry_;
+	uint32_t* t = NULL;
+
+	/* Be sure main thread was successfully allocated */
+	if ( co_active() )
+	{
+		size += state_size + above_stack + stack_align;
+		t = co_create_( size, entry );
+	}
+
+	if ( t )
+	{
+		uintptr_t sp;
+		int shift;
+
+		/* Save current registers into new thread, so that any special ones will
+		have proper values when thread is begun */
+		CO_SWAP_ASM( t, t );
+
+		#if LIBCO_PPCDESC
+			/* Get real address */
+			entry = (uintptr_t) *(void**) entry;
+		#endif
+
+		/* Put stack near end of block, and align */
+		sp = (uintptr_t) t + size - above_stack;
+		sp -= sp % stack_align;
+
+		/* On PPC32, we save and restore GPRs as 32 bits. For PPC64, we
+		save and restore them as 64 bits, regardless of the size the ABI
+		uses. So, we manually write pointers at the proper size. We always
+		save and restore at the same address, and since PPC is big-endian,
+		we must put the low byte first on PPC32. */
+
+		/* If uintptr_t is 32 bits, >>32 is undefined behavior, so we do two shifts
+		and don't have to care how many bits uintptr_t is. */
+		#if LIBCO_PPC64
+			shift = 16;
+		#else
+			shift = 0;
+		#endif
+
+		/* Set up so entry will be called on next swap */
+		t [8] = (uint32_t) (entry >> shift >> shift);
+		t [9] = (uint32_t) entry;
+
+		t [10] = (uint32_t) (sp >> shift >> shift);
+		t [11] = (uint32_t) sp;
+	}
+
+	return t;
+}
+
+void co_delete( cothread_t t )
+{
+   free(t);
+}
+
+static void co_init_( void )
+{
+#if LIBCO_MPROTECT
+   /* TODO: pre- and post-pad PPC code so that this doesn't make other
+      data executable and writable */
+   long page_size = sysconf( _SC_PAGESIZE );
+   if ( page_size > 0 )
+   {
+      uintptr_t align = page_size;
+      uintptr_t begin = (uintptr_t) libco_ppc_code;
+      uintptr_t end   = begin + sizeof libco_ppc_code;
+
+      /* Align beginning and end */
+      end   += align - 1;
+      end   -= end   % align;
+      begin -= begin % align;
+
+      mprotect( (void*) begin, end - begin, PROT_READ | PROT_WRITE | PROT_EXEC );
+   }
+#endif
+
+   co_active_handle = co_create_( state_size, (uintptr_t) &co_switch );
+}
+
+cothread_t co_active(void)
+{
+   if (!co_active_handle)
+      co_init_();
+
+   return co_active_handle;
+}
+
+void co_switch(cothread_t t)
+{
+   cothread_t old = co_active_handle;
+   co_active_handle = t;
+
+   CO_SWAP_ASM( t, old );
+}

libretro/libretro-common/libco/psp1.c

@@ -0,0 +1,41 @@
+#define LIBCO_C
+#include "libco.h"
+
+#include <stdlib.h>
+#include <pspthreadman.h>
+
+typedef void (*entrypoint_t)(void);
+
+cothread_t co_active()
+{
+  return (void *) sceKernelGetThreadId();
+}
+
+static int thread_wrap(unsigned int argc, void *argp)
+{
+  entrypoint_t entrypoint = *(entrypoint_t *) argp;
+  sceKernelSleepThread();
+  entrypoint();
+  return 0;
+}
+
+cothread_t co_create(unsigned int size, void (*entrypoint)(void))
+{
+  SceUID new_thread_id = sceKernelCreateThread("cothread", thread_wrap, 0x12, size, 0, NULL);
+  sceKernelStartThread(new_thread_id, sizeof (entrypoint), &entrypoint);
+  return (void *) new_thread_id;
+}
+
+void co_delete(cothread_t handle)
+{
+  SceUID id = (SceUID) handle;
+  sceKernelTerminateDeleteThread(id);
+}
+
+void co_switch(cothread_t handle)
+{
+  SceUID id = (SceUID) handle;
+  sceKernelWakeupThread(id);
+  /* Sleep the currently active thread so the new thread can start */
+  sceKernelSleepThread();
+}

libretro/libretro-common/libco/psp2.c

@@ -0,0 +1,113 @@
+/*
+libco.arm (2015-06-18)
+license: public domain
+*/
+
+#define LIBCO_C
+#include "libco.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <psp2/kernel/sysmem.h>
+#include <stdio.h>
+#include <string.h>
+
+#define FOUR_KB_ALIGN(x) align(x, 12)
+#define MB_ALIGN(x)      align(x, 20)
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+   static inline int align(int x, int n)
+   {
+      return (((x >> n) + 1) << n);
+   }
+
+   static thread_local unsigned long co_active_buffer[64];
+   static thread_local cothread_t co_active_handle = 0;
+   static void(*co_swap)(cothread_t, cothread_t) = 0;
+   static int block;
+   static uint32_t co_swap_function[] = {
+      0xe8a16ff0,  /* stmia r1!, {r4-r11,sp,lr} */
+      0xe8b0aff0,  /* ldmia r0!, {r4-r11,sp,pc} */
+      0xe12fff1e,  /* bx lr                     */
+   };
+
+   static void co_init(void)
+   {
+      int ret;
+      void *base;
+
+      block = sceKernelAllocMemBlockForVM("libco",
+            MB_ALIGN(FOUR_KB_ALIGN(sizeof co_swap_function)));
+      if (block < 0)
+         return;
+
+      /* get base address */
+      ret = sceKernelGetMemBlockBase(block, &base);
+      if (ret < 0)
+         return;
+
+      /* set domain to be writable by user */
+      ret = sceKernelOpenVMDomain();
+      if (ret < 0)
+         return;
+
+      memcpy(base, co_swap_function, sizeof co_swap_function);
+
+      /* set domain back to read-only */
+      ret = sceKernelCloseVMDomain();
+      if (ret < 0)
+         return;
+
+      /* flush icache */
+      ret = sceKernelSyncVMDomain(block, base,
+            MB_ALIGN(FOUR_KB_ALIGN(sizeof co_swap_function)));
+      if (ret < 0)
+         return;
+
+      co_swap = (void(*)(cothread_t, cothread_t))base;
+   }
+
+   cothread_t co_active(void)
+   {
+      if (!co_active_handle) co_active_handle = &co_active_buffer;
+      return co_active_handle;
+   }
+
+   cothread_t co_create(unsigned int size, void(*entrypoint)(void))
+   {
+      unsigned long* handle = 0;
+      if (!co_swap)
+         co_init();
+      if (!co_active_handle) co_active_handle = &co_active_buffer;
+      size += 256;
+      size &= ~15;
+
+      if ((handle = (unsigned long*)malloc(size)))
+      {
+         unsigned long* p = (unsigned long*)((unsigned char*)handle + size);
+         handle[8] = (unsigned long)p;
+         handle[9] = (unsigned long)entrypoint;
+      }
+
+      return handle;
+   }
+
+   void co_delete(cothread_t handle)
+   {
+      free(handle);
+      sceKernelFreeMemBlock(block);
+   }
+
+   void co_switch(cothread_t handle)
+   {
+      cothread_t co_previous_handle = co_active_handle;
+      co_swap(co_active_handle = handle, co_previous_handle);
+   }
+
+#ifdef __cplusplus
+}
+#endif

libretro/libretro-common/libco/scefiber.c

@@ -0,0 +1,96 @@
+/*
+  libco.win (2016-09-06)
+  authors: frangarcj
+  license: public domain
+*/
+
+#define LIBCO_C
+#include <libco.h>
+#include <stdlib.h>
+#include <psp2/sysmodule.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static thread_local cothread_t co_active_ = 0;
+
+typedef struct SceFiber {
+	char reserved[128];
+} SceFiber __attribute__( ( aligned ( 8 ) ) ) ;
+
+int32_t _sceFiberInitializeImpl(SceFiber* fiber, char* name, void* entry, uint32_t argOnInitialize, void* addrContext, int32_t sizeContext, void* params);
+
+int32_t sceFiberFinalize(SceFiber* fiber);
+
+int32_t sceFiberRun(SceFiber* fiber, uint32_t argOnRunTo, uint32_t* argOnRun);
+
+int32_t sceFiberSwitch(SceFiber* fiber, uint32_t argOnRunTo, uint32_t* argOnRun);
+
+int32_t sceFiberReturnToThread(uint32_t argOnReturn, uint32_t* argOnRun);
+
+static void co_thunk(uint32_t argOnInitialize, uint32_t argOnRun)
+{
+   ((void (*)(void))argOnInitialize)();
+}
+
+cothread_t co_active(void)
+{
+   if(!co_active_)
+   {
+		  sceSysmoduleLoadModule(SCE_SYSMODULE_FIBER);
+      co_active_ = (cothread_t)1;
+   }
+   return co_active_;
+}
+
+cothread_t co_create(unsigned int heapsize, void (*coentry)(void))
+{
+   SceFiber* tailFiber = malloc(sizeof(SceFiber));
+	 char * m_contextBuffer = malloc(sizeof(char)*heapsize);
+	 if(!co_active_)
+   {
+      sceSysmoduleLoadModule(SCE_SYSMODULE_FIBER);
+      co_active_ = (cothread_t)1;
+   }
+
+   //_sceFiberInitializeImpl
+   int ret = _sceFiberInitializeImpl(tailFiber, "tailFiber", co_thunk, (uint32_t)coentry, (void*) m_contextBuffer, heapsize, NULL);
+   if(ret==0){
+     return (cothread_t)tailFiber;
+   }else{
+     return (cothread_t)ret;
+   }
+
+}
+
+void co_delete(cothread_t cothread)
+{
+	 if(cothread == (cothread_t)1){
+		 return;
+	 }
+   sceFiberFinalize((SceFiber*)cothread);
+}
+
+void co_switch(cothread_t cothread)
+{
+
+   uint32_t argOnReturn = 0;
+   if(cothread == (cothread_t)1){
+     co_active_ = cothread;
+     sceFiberReturnToThread(0, NULL);
+   }else{
+		 SceFiber* theFiber = (SceFiber*)cothread;
+		 if(co_active_ == (cothread_t)1){
+			 co_active_ = cothread;
+			 sceFiberRun(theFiber, 0, &argOnReturn);
+		 }else{
+			 co_active_ = cothread;
+			 sceFiberSwitch(theFiber, 0, &argOnReturn);
+		 }
+   }
+}
+
+#ifdef __cplusplus
+}
+#endif

libretro/libretro-common/libco/sjlj.c

@@ -0,0 +1,115 @@
+/*
+  libco.sjlj (2008-01-28)
+  author: Nach
+  license: public domain
+*/
+
+/*
+ * Note this was designed for UNIX systems. Based on ideas expressed in a paper
+ * by Ralf Engelschall.
+ * For SJLJ on other systems, one would want to rewrite springboard() and
+ * co_create() and hack the jmb_buf stack pointer.
+ */
+
+#define LIBCO_C
+#include <libco.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <setjmp.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct
+{
+   sigjmp_buf context;
+   void (*coentry)(void);
+   void *stack;
+} cothread_struct;
+
+static thread_local cothread_struct co_primary;
+static thread_local cothread_struct *creating, *co_running = 0;
+
+static void springboard(int ignored)
+{
+   if(sigsetjmp(creating->context, 0))
+      co_running->coentry();
+}
+
+cothread_t co_active(void)
+{
+  if (!co_running)
+     co_running = &co_primary;
+  return (cothread_t)co_running;
+}
+
+cothread_t co_create(unsigned int size, void (*coentry)(void))
+{
+   if(!co_running)
+      co_running = &co_primary;
+
+   cothread_struct *thread = (cothread_struct*)malloc(sizeof(cothread_struct));
+
+   if(thread)
+   {
+      stack_t stack;
+      stack_t old_stack;
+
+      struct sigaction handler     = {{0}};
+      struct sigaction old_handler = {{0}};
+
+      thread->coentry = thread->stack = 0;
+
+      stack.ss_flags = 0;
+      stack.ss_size = size;
+      thread->stack = stack.ss_sp = malloc(size);
+
+      if(stack.ss_sp && !sigaltstack(&stack, &old_stack))
+      {
+         handler.sa_handler = springboard;
+         handler.sa_flags   = SA_ONSTACK;
+         sigemptyset(&handler.sa_mask);
+         creating = thread;
+
+         if(!sigaction(SIGUSR1, &handler, &old_handler))
+         {
+            if(!raise(SIGUSR1))
+               thread->coentry = coentry;
+            sigaltstack(&old_stack, 0);
+            sigaction(SIGUSR1, &old_handler, 0);
+         }
+      }
+
+      if(thread->coentry != coentry)
+      {
+         co_delete(thread);
+         thread = 0;
+      }
+   }
+
+   return (cothread_t)thread;
+}
+
+void co_delete(cothread_t cothread)
+{
+   if (cothread)
+   {
+      if(((cothread_struct*)cothread)->stack)
+         free(((cothread_struct*)cothread)->stack);
+      free(cothread);
+   }
+}
+
+void co_switch(cothread_t cothread)
+{
+   if (!sigsetjmp(co_running->context, 0))
+   {
+      co_running = (cothread_struct*)cothread;
+      siglongjmp(co_running->context, 1);
+   }
+}
+
+#ifdef __cplusplus
+}
+#endif

libretro/libretro-common/libco/ucontext.c

@@ -0,0 +1,81 @@
+/*
+  libco.ucontext (2008-01-28)
+  author: Nach
+  license: public domain
+*/
+
+/*
+ * WARNING: the overhead of POSIX ucontext is very high,
+ * assembly versions of libco or libco_sjlj should be much faster
+ *
+ * This library only exists for two reasons:
+ * 1 - as an initial test for the viability of a ucontext implementation
+ * 2 - to demonstrate the power and speed of libco over existing implementations,
+ *     such as pth (which defaults to wrapping ucontext on unix targets)
+ *
+ * Use this library only as a *last resort*
+ */
+
+#define LIBCO_C
+#include <libco.h>
+#include <stdlib.h>
+#include <ucontext.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+static thread_local ucontext_t co_primary;
+static thread_local ucontext_t *co_running = 0;
+
+cothread_t co_active(void)
+{
+   if (!co_running)
+      co_running = &co_primary;
+   return (cothread_t)co_running;
+}
+
+cothread_t co_create(unsigned int heapsize, void (*coentry)(void))
+{
+   if (!co_running)
+      co_running = &co_primary;
+   ucontext_t *thread = (ucontext_t*)malloc(sizeof(ucontext_t));
+
+   if(thread)
+   {
+      if((!getcontext(thread) && !(thread->uc_stack.ss_sp = 0)) && (thread->uc_stack.ss_sp = malloc(heapsize)))
+      {
+         thread->uc_link = co_running;
+         thread->uc_stack.ss_size = heapsize;
+         makecontext(thread, coentry, 0);
+      }
+      else
+      {
+         co_delete((cothread_t)thread);
+         thread = 0;
+      }
+   }
+   return (cothread_t)thread;
+}
+
+void co_delete(cothread_t cothread)
+{
+   if (!cothread)
+      return;
+
+   if(((ucontext_t*)cothread)->uc_stack.ss_sp)
+      free(((ucontext_t*)cothread)->uc_stack.ss_sp);
+   free(cothread);
+}
+
+void co_switch(cothread_t cothread)
+{
+   ucontext_t *old_thread = co_running;
+
+   co_running = (ucontext_t*)cothread;
+   swapcontext(old_thread, co_running);
+}
+
+#ifdef __cplusplus
+}
+#endif

libretro/libretro-common/libco/x86.c

@@ -0,0 +1,117 @@
+/*
+  libco.x86 (2009-10-12)
+  author: byuu
+  license: public domain
+*/
+
+#define LIBCO_C
+#include <libco.h>
+#include <assert.h>
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(_MSC_VER)
+  #define fastcall __fastcall
+#elif defined(__GNUC__)
+  #define fastcall __attribute__((fastcall))
+#else
+  #error "libco: please define fastcall macro"
+#endif
+
+static thread_local long co_active_buffer[64];
+static thread_local cothread_t co_active_handle = 0;
+static void (fastcall *co_swap)(cothread_t, cothread_t) = 0;
+
+//ABI: fastcall
+static unsigned char co_swap_function[] = {
+  0x89, 0x22,         /* mov [edx],esp      */
+  0x8b, 0x21,         /* mov esp,[ecx]      */
+  0x58,               /* pop eax            */
+  0x89, 0x6a, 0x04,   /* mov [edx+0x04],ebp */
+  0x89, 0x72, 0x08,   /* mov [edx+0x08],esi */
+  0x89, 0x7a, 0x0c,   /* mov [edx+0x0c],edi */
+  0x89, 0x5a, 0x10,   /* mov [edx+0x10],ebx */
+  0x8b, 0x69, 0x04,   /* mov ebp,[ecx+0x04] */
+  0x8b, 0x71, 0x08,   /* mov esi,[ecx+0x08] */
+  0x8b, 0x79, 0x0c,   /* mov edi,[ecx+0x0c] */
+  0x8b, 0x59, 0x10,   /* mov ebx,[ecx+0x10] */
+  0xff, 0xe0,         /* jmp eax            */
+};
+
+#ifdef _WIN32
+#include <windows.h>
+
+static void co_init(void)
+{
+   DWORD old_privileges;
+   VirtualProtect(co_swap_function,
+         sizeof co_swap_function, PAGE_EXECUTE_READWRITE, &old_privileges);
+}
+#else
+#include <unistd.h>
+#include <sys/mman.h>
+
+static void co_init(void)
+{
+   unsigned long addr = (unsigned long)co_swap_function;
+   unsigned long base = addr - (addr % sysconf(_SC_PAGESIZE));
+   unsigned long size = (addr - base) + sizeof co_swap_function;
+   mprotect((void*)base, size, PROT_READ | PROT_WRITE | PROT_EXEC);
+}
+#endif
+
+static void crash(void)
+{
+   assert(0); /* called only if cothread_t entrypoint returns */
+}
+
+cothread_t co_active(void)
+{
+   if(!co_active_handle)
+      co_active_handle = &co_active_buffer;
+   return co_active_handle;
+}
+
+cothread_t co_create(unsigned int size, void (*entrypoint)(void))
+{
+   cothread_t handle;
+   if(!co_swap)
+   {
+      co_init();
+      co_swap = (void (fastcall*)(cothread_t, cothread_t))co_swap_function;
+   }
+
+   if(!co_active_handle)
+      co_active_handle = &co_active_buffer;
+
+   size += 256; /* allocate additional space for storage */
+   size &= ~15; /* align stack to 16-byte boundary */
+
+   if((handle = (cothread_t)malloc(size)))
+   {
+      long *p = (long*)((char*)handle + size); /* seek to top of stack */
+      *--p = (long)crash;                      /* crash if entrypoint returns */
+      *--p = (long)entrypoint;                 /* start of function */
+      *(long*)handle = (long)p;                /* stack pointer */
+   }
+
+   return handle;
+}
+
+void co_delete(cothread_t handle)
+{
+   free(handle);
+}
+
+void co_switch(cothread_t handle)
+{
+   register cothread_t co_previous_handle = co_active_handle;
+   co_swap(co_active_handle = handle, co_previous_handle);
+}
+
+#ifdef __cplusplus
+}
+#endif

libretro/libretro-common/string/stdstring.c

@@ -0,0 +1,416 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (stdstring.c).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stdint.h>
+#include <ctype.h>
+
+#include <string/stdstring.h>
+#include <encodings/utf.h>
+
+const uint8_t lr_char_props[256] = {
+	/*x0   x1   x2   x3   x4   x5   x6   x7   x8   x9   xA   xB   xC   xD   xE   xF */
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x80,0x00,0x00,0x80,0x00,0x00, /* 0x                  */
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 1x                  */
+	0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 2x  !"#$%&'()*+,-./ */
+	0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x00,0x00,0x00,0x00,0x00,0x00, /* 3x 0123456789:;<=>? */
+	0x00,0x23,0x23,0x23,0x23,0x23,0x23,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22, /* 4x @ABCDEFGHIJKLMNO */
+	0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x00,0x00,0x00,0x00,0x08, /* 5x PQRSTUVWXYZ[\]^_ */
+	0x00,0x25,0x25,0x25,0x25,0x25,0x25,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24, /* 6x `abcdefghijklmno */
+	0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x00,0x00,0x00,0x00,0x00, /* 7x pqrstuvwxyz{|}~  */
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 8x                  */
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 9x                  */
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Ax                  */
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Bx                  */
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Cx                  */
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Dx                  */
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Ex                  */
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Fx                  */
+};
+
+char *string_init(const char *src)
+{
+   return src ? strdup(src) : NULL;
+}
+
+void string_set(char **string, const char *src)
+{
+   free(*string);
+   *string = string_init(src);
+}
+
+
+char *string_to_upper(char *s)
+{
+   char *cs = (char *)s;
+   for ( ; *cs != '\0'; cs++)
+      *cs = toupper((unsigned char)*cs);
+   return s;
+}
+
+char *string_to_lower(char *s)
+{
+   char *cs = (char *)s;
+   for ( ; *cs != '\0'; cs++)
+      *cs = tolower((unsigned char)*cs);
+   return s;
+}
+
+char *string_ucwords(char *s)
+{
+   char *cs = (char *)s;
+   for ( ; *cs != '\0'; cs++)
+   {
+      if (*cs == ' ')
+         *(cs+1) = toupper((unsigned char)*(cs+1));
+   }
+
+   s[0] = toupper((unsigned char)s[0]);
+   return s;
+}
+
+char *string_replace_substring(const char *in,
+      const char *pattern, const char *replacement)
+{
+   size_t numhits, pattern_len, replacement_len, outlen;
+   const char *inat   = NULL;
+   const char *inprev = NULL;
+   char          *out = NULL;
+   char        *outat = NULL;
+
+   /* if either pattern or replacement is NULL,
+    * duplicate in and let caller handle it. */
+   if (!pattern || !replacement)
+      return strdup(in);
+
+   pattern_len     = strlen(pattern);
+   replacement_len = strlen(replacement);
+   numhits         = 0;
+   inat            = in;
+
+   while ((inat = strstr(inat, pattern)))
+   {
+      inat += pattern_len;
+      numhits++;
+   }
+
+   outlen          = strlen(in) - pattern_len*numhits + replacement_len*numhits;
+   out             = (char *)malloc(outlen+1);
+
+   if (!out)
+      return NULL;
+
+   outat           = out;
+   inat            = in;
+   inprev          = in;
+
+   while ((inat = strstr(inat, pattern)))
+   {
+      memcpy(outat, inprev, inat-inprev);
+      outat += inat-inprev;
+      memcpy(outat, replacement, replacement_len);
+      outat += replacement_len;
+      inat += pattern_len;
+      inprev = inat;
+   }
+   strcpy(outat, inprev);
+
+   return out;
+}
+
+/* Remove leading whitespaces */
+char *string_trim_whitespace_left(char *const s)
+{
+   if (s && *s)
+   {
+      size_t len     = strlen(s);
+      char *current  = s;
+
+      while (*current && ISSPACE((unsigned char)*current))
+      {
+         ++current;
+         --len;
+      }
+
+      if (s != current)
+         memmove(s, current, len + 1);
+   }
+
+   return s;
+}
+
+/* Remove trailing whitespaces */
+char *string_trim_whitespace_right(char *const s)
+{
+   if (s && *s)
+   {
+      size_t len     = strlen(s);
+      char  *current = s + len - 1;
+
+      while (current != s && ISSPACE((unsigned char)*current))
+      {
+         --current;
+         --len;
+      }
+
+      current[ISSPACE((unsigned char)*current) ? 0 : 1] = '\0';
+   }
+
+   return s;
+}
+
+/* Remove leading and trailing whitespaces */
+char *string_trim_whitespace(char *const s)
+{
+   string_trim_whitespace_right(s);  /* order matters */
+   string_trim_whitespace_left(s);
+
+   return s;
+}
+
+char *word_wrap(char* buffer, const char *string, int line_width, bool unicode, unsigned max_lines)
+{
+   unsigned i     = 0;
+   unsigned len   = (unsigned)strlen(string);
+   unsigned lines = 1;
+
+   while (i < len)
+   {
+      unsigned counter;
+      int pos = (int)(&buffer[i] - buffer);
+
+      /* copy string until the end of the line is reached */
+      for (counter = 1; counter <= (unsigned)line_width; counter++)
+      {
+         const char *character;
+         unsigned char_len;
+         unsigned j = i;
+
+         /* check if end of string reached */
+         if (i == len)
+         {
+            buffer[i] = 0;
+            return buffer;
+         }
+
+         character = utf8skip(&string[i], 1);
+         char_len  = (unsigned)(character - &string[i]);
+
+         if (!unicode)
+            counter += char_len - 1;
+
+         do
+         {
+            buffer[i] = string[i];
+            char_len--;
+            i++;
+         } while (char_len);
+
+         /* check for newlines embedded in the original input
+          * and reset the index */
+         if (buffer[j] == '\n')
+         {
+            lines++;
+            counter = 1;
+         }
+      }
+
+      /* check for whitespace */
+      if (string[i] == ' ')
+      {
+         if ((max_lines == 0 || lines < max_lines))
+         {
+            buffer[i] = '\n';
+            i++;
+            lines++;
+         }
+      }
+      else
+      {
+         int k;
+
+         /* check for nearest whitespace back in string */
+         for (k = i; k > 0; k--)
+         {
+            if (string[k] != ' ' || (max_lines != 0 && lines >= max_lines))
+               continue;
+
+            buffer[k] = '\n';
+            /* set string index back to character after this one */
+            i         = k + 1;
+            lines++;
+            break;
+         }
+
+         if (&buffer[i] - buffer == pos)
+            return buffer;
+      }
+   }
+
+   buffer[i] = 0;
+
+   return buffer;
+}
+
+/* Splits string into tokens seperated by 'delim'
+ * > Returned token string must be free()'d
+ * > Returns NULL if token is not found
+ * > After each call, 'str' is set to the position after the
+ *   last found token
+ * > Tokens *include* empty strings
+ * Usage example:
+ *    char *str      = "1,2,3,4,5,6,7,,,10,";
+ *    char **str_ptr = &str;
+ *    char *token    = NULL;
+ *    while ((token = string_tokenize(str_ptr, ",")))
+ *    {
+ *        printf("%s\n", token);
+ *        free(token);
+ *        token = NULL;
+ *    }
+ */
+char* string_tokenize(char **str, const char *delim)
+{
+   /* Taken from https://codereview.stackexchange.com/questions/216956/strtok-function-thread-safe-supports-empty-tokens-doesnt-change-string# */
+   char *str_ptr    = NULL;
+   char *delim_ptr  = NULL;
+   char *token      = NULL;
+   size_t token_len = 0;
+
+   /* Sanity checks */
+   if (!str || string_is_empty(delim))
+      return NULL;
+
+   str_ptr = *str;
+
+   /* Note: we don't check string_is_empty() here,
+    * empty strings are valid */
+   if (!str_ptr)
+      return NULL;
+
+   /* Search for delimiter */
+   delim_ptr = strstr(str_ptr, delim);
+
+   if (delim_ptr)
+      token_len = delim_ptr - str_ptr;
+   else
+      token_len = strlen(str_ptr);
+
+   /* Allocate token string */
+   token = (char *)malloc((token_len + 1) * sizeof(char));
+
+   if (!token)
+      return NULL;
+
+   /* Copy token */
+   strlcpy(token, str_ptr, (token_len + 1) * sizeof(char));
+   token[token_len] = '\0';
+
+   /* Update input string pointer */
+   *str = delim_ptr ? delim_ptr + strlen(delim) : NULL;
+
+   return token;
+}
+
+/* Removes every instance of character 'c' from 'str' */
+void string_remove_all_chars(char *str, char c)
+{
+   char *read_ptr  = NULL;
+   char *write_ptr = NULL;
+
+   if (string_is_empty(str))
+      return;
+
+   read_ptr  = str;
+   write_ptr = str;
+
+   while (*read_ptr != '\0')
+   {
+      *write_ptr = *read_ptr++;
+      write_ptr += (*write_ptr != c) ? 1 : 0;
+   }
+
+   *write_ptr = '\0';
+}
+
+/* Replaces every instance of character 'find' in 'str'
+ * with character 'replace' */
+void string_replace_all_chars(char *str, char find, char replace)
+{
+   char *str_ptr = str;
+
+   if (string_is_empty(str))
+      return;
+
+   while ((str_ptr = strchr(str_ptr, find)))
+      *str_ptr++ = replace;
+}
+
+/* Converts string to unsigned integer.
+ * Returns 0 if string is invalid  */
+unsigned string_to_unsigned(const char *str)
+{
+   const char *ptr = NULL;
+
+   if (string_is_empty(str))
+      return 0;
+
+   for (ptr = str; *ptr != '\0'; ptr++)
+   {
+      if (!ISDIGIT((unsigned char)*ptr))
+         return 0;
+   }
+
+   return (unsigned)strtoul(str, NULL, 10);
+}
+
+/* Converts hexadecimal string to unsigned integer.
+ * Handles optional leading '0x'.
+ * Returns 0 if string is invalid  */
+unsigned string_hex_to_unsigned(const char *str)
+{
+   const char *hex_str = str;
+   const char *ptr     = NULL;
+   size_t len;
+
+   if (string_is_empty(str))
+      return 0;
+
+   /* Remove leading '0x', if required */
+   len = strlen(str);
+
+   if (len >= 2)
+      if ((str[0] == '0') &&
+          ((str[1] == 'x') || (str[1] == 'X')))
+         hex_str = str + 2;
+
+   if (string_is_empty(hex_str))
+      return 0;
+
+   /* Check for valid characters */
+   for (ptr = hex_str; *ptr != '\0'; ptr++)
+   {
+      if (!isxdigit((unsigned char)*ptr))
+         return 0;
+   }
+
+   return (unsigned)strtoul(hex_str, NULL, 16);
+}

libretro/libretro-common/time/rtime.c

@@ -0,0 +1,81 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (rtime.c).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifdef HAVE_THREADS
+#include <rthreads/rthreads.h>
+#include <retro_assert.h>
+#include <stdlib.h>
+#endif
+
+#include <string.h>
+#include <time/rtime.h>
+
+#ifdef HAVE_THREADS
+/* TODO/FIXME - global */
+slock_t *rtime_localtime_lock = NULL;
+#endif
+
+/* Must be called before using rtime_localtime() */
+void rtime_init(void)
+{
+   rtime_deinit();
+#ifdef HAVE_THREADS
+   if (!rtime_localtime_lock)
+      rtime_localtime_lock = slock_new();
+
+   retro_assert(rtime_localtime_lock);
+#endif
+}
+
+/* Must be called upon program termination */
+void rtime_deinit(void)
+{
+#ifdef HAVE_THREADS
+   if (rtime_localtime_lock)
+   {
+      slock_free(rtime_localtime_lock);
+      rtime_localtime_lock = NULL;
+   }
+#endif
+}
+
+/* Thread-safe wrapper for localtime() */
+struct tm *rtime_localtime(const time_t *timep, struct tm *result)
+{
+   struct tm *time_info = NULL;
+
+   /* Lock mutex */
+#ifdef HAVE_THREADS
+   slock_lock(rtime_localtime_lock);
+#endif
+
+   time_info = localtime(timep);
+   if (time_info)
+      memcpy(result, time_info, sizeof(struct tm));
+
+   /* Unlock mutex */
+#ifdef HAVE_THREADS
+   slock_unlock(rtime_localtime_lock);
+#endif
+
+   return result;
+}

libretro/libretro-common/vfs/vfs_implementation_cdrom.c

@@ -0,0 +1,495 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+*
+* ---------------------------------------------------------------------------------------
+* The following license statement only applies to this file (vfs_implementation_cdrom.c).
+* ---------------------------------------------------------------------------------------
+*
+* Permission is hereby granted, free of charge,
+* to any person obtaining a copy of this software and associated documentation files (the "Software"),
+* to deal in the Software without restriction, including without limitation the rights to
+* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include <vfs/vfs_implementation.h>
+#include <file/file_path.h>
+#include <compat/fopen_utf8.h>
+#include <string/stdstring.h>
+#include <cdrom/cdrom.h>
+
+#if defined(_WIN32) && !defined(_XBOX)
+#include <windows.h>
+#endif
+
+/* TODO/FIXME - static global variable */
+static cdrom_toc_t vfs_cdrom_toc = {0};
+
+const cdrom_toc_t* retro_vfs_file_get_cdrom_toc(void)
+{
+   return &vfs_cdrom_toc;
+}
+
+int64_t retro_vfs_file_seek_cdrom(
+      libretro_vfs_implementation_file *stream,
+      int64_t offset, int whence)
+{
+   const char *ext = path_get_extension(stream->orig_path);
+
+   if (string_is_equal_noncase(ext, "cue"))
+   {
+      switch (whence)
+      {
+         case SEEK_SET:
+            stream->cdrom.byte_pos = offset;
+            break;
+         case SEEK_CUR:
+            stream->cdrom.byte_pos += offset;
+            break;
+         case SEEK_END:
+            stream->cdrom.byte_pos  = (stream->cdrom.cue_len - 1) + offset;
+            break;
+      }
+
+#ifdef CDROM_DEBUG
+      printf("[CDROM] Seek: Path %s Offset %" PRIu64 " is now at %" PRIu64 "\n",
+            stream->orig_path,
+            offset,
+            stream->cdrom.byte_pos);
+      fflush(stdout);
+#endif
+   }
+   else if (string_is_equal_noncase(ext, "bin"))
+   {
+      int lba               = (offset / 2352);
+      unsigned char min     = 0;
+      unsigned char sec     = 0;
+      unsigned char frame   = 0;
+#ifdef CDROM_DEBUG
+      const char *seek_type = "SEEK_SET";
+#endif
+
+      switch (whence)
+      {
+         case SEEK_CUR:
+            {
+               unsigned new_lba;
+#ifdef CDROM_DEBUG
+               seek_type               = "SEEK_CUR";
+#endif
+               stream->cdrom.byte_pos += offset;
+               new_lba                 = vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].lba + (stream->cdrom.byte_pos / 2352);
+
+               cdrom_lba_to_msf(new_lba, &min, &sec, &frame);
+            }
+            break;
+         case SEEK_END:
+            {
+               ssize_t pregap_lba_len = (vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].audio 
+                     ? 0 
+                     : (vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].lba - vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].lba_start));
+               ssize_t lba_len        = vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].track_size - pregap_lba_len;
+#ifdef CDROM_DEBUG
+               seek_type              = "SEEK_END";
+#endif
+
+               cdrom_lba_to_msf(lba_len + lba, &min, &sec, &frame);
+               stream->cdrom.byte_pos = lba_len * 2352;
+            }
+            break;
+         case SEEK_SET:
+         default:
+            {
+#ifdef CDROM_DEBUG
+               seek_type = "SEEK_SET";
+#endif
+               stream->cdrom.byte_pos = offset;
+               cdrom_lba_to_msf(vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].lba + (stream->cdrom.byte_pos / 2352), &min, &sec, &frame);
+            }
+            break;
+      }
+
+      stream->cdrom.cur_min   = min;
+      stream->cdrom.cur_sec   = sec;
+      stream->cdrom.cur_frame = frame;
+      stream->cdrom.cur_lba   = cdrom_msf_to_lba(min, sec, frame);
+
+#ifdef CDROM_DEBUG
+      printf(
+            "[CDROM] Seek %s: Path %s Offset %" PRIu64 " is now at %" PRIu64 " (MSF %02u:%02u:%02u) (LBA %u)...\n",
+            seek_type,
+            stream->orig_path,
+            offset,
+            stream->cdrom.byte_pos,
+            (unsigned)stream->cdrom.cur_min,
+            (unsigned)stream->cdrom.cur_sec,
+            (unsigned)stream->cdrom.cur_frame,
+            stream->cdrom.cur_lba);
+      fflush(stdout);
+#endif
+   }
+   else
+      return -1;
+
+   return 0;
+}
+
+void retro_vfs_file_open_cdrom(
+      libretro_vfs_implementation_file *stream,
+      const char *path, unsigned mode, unsigned hints)
+{
+#if defined(__linux__) && !defined(ANDROID)
+   char cdrom_path[]       = "/dev/sg1";
+   size_t path_len         = strlen(path);
+   const char *ext         = path_get_extension(path);
+
+   stream->cdrom.cur_track = 1;
+
+   if (     !string_is_equal_noncase(ext, "cue") 
+         && !string_is_equal_noncase(ext, "bin"))
+      return;
+
+   if (path_len >= STRLEN_CONST("drive1-track01.bin"))
+   {
+      if (!memcmp(path, "drive", STRLEN_CONST("drive")))
+      {
+         if (!memcmp(path + 6, "-track", STRLEN_CONST("-track")))
+         {
+            if (sscanf(path + 12, "%02u", (unsigned*)&stream->cdrom.cur_track))
+            {
+#ifdef CDROM_DEBUG
+               printf("[CDROM] Opening track %d\n", stream->cdrom.cur_track);
+               fflush(stdout);
+#endif
+            }
+         }
+      }
+   }
+
+   if (path_len >= STRLEN_CONST("drive1.cue"))
+   {
+      if (!memcmp(path, "drive", STRLEN_CONST("drive")))
+      {
+         if (path[5] >= '0' && path[5] <= '9')
+         {
+            cdrom_path[7]       = path[5];
+            stream->cdrom.drive = path[5];
+            vfs_cdrom_toc.drive = stream->cdrom.drive;
+         }
+      }
+   }
+
+#ifdef CDROM_DEBUG
+   printf("[CDROM] Open: Path %s URI %s\n", cdrom_path, path);
+   fflush(stdout);
+#endif
+   stream->fp = (FILE*)fopen_utf8(cdrom_path, "r+b");
+
+   if (!stream->fp)
+      return;
+
+   if (string_is_equal_noncase(ext, "cue"))
+   {
+      if (stream->cdrom.cue_buf)
+      {
+         free(stream->cdrom.cue_buf);
+         stream->cdrom.cue_buf = NULL;
+      }
+
+      cdrom_write_cue(stream,
+            &stream->cdrom.cue_buf,
+            &stream->cdrom.cue_len,
+            stream->cdrom.drive,
+            &vfs_cdrom_toc.num_tracks,
+            &vfs_cdrom_toc);
+      cdrom_get_timeouts(stream, &vfs_cdrom_toc.timeouts);
+
+#ifdef CDROM_DEBUG
+      if (string_is_empty(stream->cdrom.cue_buf))
+      {
+         printf("[CDROM] Error writing cue sheet.\n");
+         fflush(stdout);
+      }
+      else
+      {
+         printf("[CDROM] CUE Sheet:\n%s\n", stream->cdrom.cue_buf);
+         fflush(stdout);
+      }
+#endif
+   }
+#endif
+#if defined(_WIN32) && !defined(_XBOX)
+   char cdrom_path[] = "\\\\.\\D:";
+   size_t path_len   = strlen(path);
+   const char *ext   = path_get_extension(path);
+
+   if (     !string_is_equal_noncase(ext, "cue") 
+         && !string_is_equal_noncase(ext, "bin"))
+      return;
+
+   if (path_len >= STRLEN_CONST("d:/drive-track01.bin"))
+   {
+      if (!memcmp(path + 1, ":/drive-track", STRLEN_CONST(":/drive-track")))
+      {
+         if (sscanf(path + 14, "%02u", (unsigned*)&stream->cdrom.cur_track))
+         {
+#ifdef CDROM_DEBUG
+            printf("[CDROM] Opening track %d\n", stream->cdrom.cur_track);
+            fflush(stdout);
+#endif
+         }
+      }
+   }
+
+   if (path_len >= STRLEN_CONST("d:/drive.cue"))
+   {
+      if (!memcmp(path + 1, ":/drive", STRLEN_CONST(":/drive")))
+      {
+         if ((path[0] >= 'A' && path[0] <= 'Z') || (path[0] >= 'a' && path[0] <= 'z'))
+         {
+            cdrom_path[4]       = path[0];
+            stream->cdrom.drive = path[0];
+            vfs_cdrom_toc.drive = stream->cdrom.drive;
+         }
+      }
+   }
+
+#ifdef CDROM_DEBUG
+   printf("[CDROM] Open: Path %s URI %s\n", cdrom_path, path);
+   fflush(stdout);
+#endif
+   stream->fh = CreateFile(cdrom_path,
+         GENERIC_READ | GENERIC_WRITE,
+         FILE_SHARE_READ | FILE_SHARE_WRITE,
+         NULL,
+         OPEN_EXISTING,
+         FILE_ATTRIBUTE_NORMAL,
+         NULL);
+
+   if (stream->fh == INVALID_HANDLE_VALUE)
+      return;
+
+   if (string_is_equal_noncase(ext, "cue"))
+   {
+      if (stream->cdrom.cue_buf)
+      {
+         free(stream->cdrom.cue_buf);
+         stream->cdrom.cue_buf = NULL;
+      }
+
+      cdrom_write_cue(stream,
+            &stream->cdrom.cue_buf,
+            &stream->cdrom.cue_len,
+            stream->cdrom.drive,
+            &vfs_cdrom_toc.num_tracks,
+            &vfs_cdrom_toc);
+      cdrom_get_timeouts(stream,
+            &vfs_cdrom_toc.timeouts);
+
+#ifdef CDROM_DEBUG
+      if (string_is_empty(stream->cdrom.cue_buf))
+      {
+         printf("[CDROM] Error writing cue sheet.\n");
+         fflush(stdout);
+      }
+      else
+      {
+         printf("[CDROM] CUE Sheet:\n%s\n", stream->cdrom.cue_buf);
+         fflush(stdout);
+      }
+#endif
+   }
+#endif
+   if (vfs_cdrom_toc.num_tracks > 1 && stream->cdrom.cur_track)
+   {
+      stream->cdrom.cur_min   = vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].min;
+      stream->cdrom.cur_sec   = vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].sec;
+      stream->cdrom.cur_frame = vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].frame;
+      stream->cdrom.cur_lba   = cdrom_msf_to_lba(stream->cdrom.cur_min, stream->cdrom.cur_sec, stream->cdrom.cur_frame);
+   }
+   else
+   {
+      stream->cdrom.cur_min   = vfs_cdrom_toc.track[0].min;
+      stream->cdrom.cur_sec   = vfs_cdrom_toc.track[0].sec;
+      stream->cdrom.cur_frame = vfs_cdrom_toc.track[0].frame;
+      stream->cdrom.cur_lba   = cdrom_msf_to_lba(stream->cdrom.cur_min, stream->cdrom.cur_sec, stream->cdrom.cur_frame);
+   }
+}
+
+int retro_vfs_file_close_cdrom(libretro_vfs_implementation_file *stream)
+{
+#ifdef CDROM_DEBUG
+   printf("[CDROM] Close: Path %s\n", stream->orig_path);
+   fflush(stdout);
+#endif
+
+#if defined(_WIN32) && !defined(_XBOX)
+   if (!stream->fh || !CloseHandle(stream->fh))
+      return -1;
+#else
+   if (!stream->fp || fclose(stream->fp))
+      return -1;
+#endif
+
+   return 0;
+}
+
+int64_t retro_vfs_file_tell_cdrom(libretro_vfs_implementation_file *stream)
+{
+   const char *ext = NULL;
+   if (!stream)
+      return -1;
+
+   ext = path_get_extension(stream->orig_path);
+
+   if (string_is_equal_noncase(ext, "cue"))
+   {
+#ifdef CDROM_DEBUG
+      printf("[CDROM] (cue) Tell: Path %s Position %" PRIu64 "\n", stream->orig_path, stream->cdrom.byte_pos);
+      fflush(stdout);
+#endif
+      return stream->cdrom.byte_pos;
+   }
+   else if (string_is_equal_noncase(ext, "bin"))
+   {
+#ifdef CDROM_DEBUG
+      printf("[CDROM] (bin) Tell: Path %s Position %" PRId64 "\n", stream->orig_path, stream->cdrom.byte_pos);
+      fflush(stdout);
+#endif
+      return stream->cdrom.byte_pos;
+   }
+
+   return -1;
+}
+
+int64_t retro_vfs_file_read_cdrom(libretro_vfs_implementation_file *stream,
+      void *s, uint64_t len)
+{
+   int rv;
+   const char *ext = path_get_extension(stream->orig_path);
+
+   if (string_is_equal_noncase(ext, "cue"))
+   {
+      if ((int64_t)len >= (int64_t)stream->cdrom.cue_len 
+            - stream->cdrom.byte_pos)
+         len = stream->cdrom.cue_len - stream->cdrom.byte_pos - 1;
+#ifdef CDROM_DEBUG
+      printf(
+            "[CDROM] Read: Reading %" PRIu64 " bytes from cuesheet starting at %" PRIu64 "...\n",
+            len,
+            stream->cdrom.byte_pos);
+      fflush(stdout);
+#endif
+      memcpy(s, stream->cdrom.cue_buf + stream->cdrom.byte_pos, len);
+      stream->cdrom.byte_pos += len;
+
+      return len;
+   }
+   else if (string_is_equal_noncase(ext, "bin"))
+   {
+      unsigned char min    = 0;
+      unsigned char sec    = 0;
+      unsigned char frame  = 0;
+      unsigned char rmin   = 0;
+      unsigned char rsec   = 0;
+      unsigned char rframe = 0;
+      size_t skip          = stream->cdrom.byte_pos % 2352;
+
+      if (stream->cdrom.byte_pos >= 
+            vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].track_bytes)
+         return 0;
+
+      if (stream->cdrom.byte_pos + len > 
+            vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].track_bytes)
+         len -= (stream->cdrom.byte_pos + len) 
+            - vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].track_bytes;
+
+      cdrom_lba_to_msf(stream->cdrom.cur_lba, &min, &sec, &frame);
+      cdrom_lba_to_msf(stream->cdrom.cur_lba 
+            - vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].lba,
+            &rmin, &rsec, &rframe);
+
+#ifdef CDROM_DEBUG
+      printf(
+            "[CDROM] Read: Reading %" PRIu64 " bytes from %s starting at byte offset %" PRIu64 " (rMSF %02u:%02u:%02u aMSF %02u:%02u:%02u) (LBA %u) skip %" PRIu64 "...\n",
+            len,
+            stream->orig_path,
+            stream->cdrom.byte_pos,
+            (unsigned)rmin,
+            (unsigned)rsec,
+            (unsigned)rframe,
+            (unsigned)min,
+            (unsigned)sec,
+            (unsigned)frame,
+            stream->cdrom.cur_lba,
+            skip);
+      fflush(stdout);
+#endif
+
+#if 1
+      rv = cdrom_read(stream, &vfs_cdrom_toc.timeouts, min, sec,
+            frame, s, (size_t)len, skip);
+#else
+      rv = cdrom_read_lba(stream, stream->cdrom.cur_lba, s,
+            (size_t)len, skip);
+#endif
+
+      if (rv)
+      {
+#ifdef CDROM_DEBUG
+         printf("[CDROM] Failed to read %" PRIu64 " bytes from CD.\n", len);
+         fflush(stdout);
+#endif
+         return 0;
+      }
+
+      stream->cdrom.byte_pos += len;
+      stream->cdrom.cur_lba   = 
+         vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].lba 
+         + (stream->cdrom.byte_pos / 2352);
+
+      cdrom_lba_to_msf(stream->cdrom.cur_lba,
+            &stream->cdrom.cur_min,
+            &stream->cdrom.cur_sec,
+            &stream->cdrom.cur_frame);
+
+#ifdef CDROM_DEBUG
+      printf(
+            "[CDROM] read %" PRIu64 " bytes, position is now: %" PRIu64 " (MSF %02u:%02u:%02u) (LBA %u)\n",
+            len,
+            stream->cdrom.byte_pos,
+            (unsigned)stream->cdrom.cur_min,
+            (unsigned)stream->cdrom.cur_sec,
+            (unsigned)stream->cdrom.cur_frame,
+            cdrom_msf_to_lba(
+               stream->cdrom.cur_min,
+               stream->cdrom.cur_sec,
+               stream->cdrom.cur_frame)
+            );
+      fflush(stdout);
+#endif
+
+      return len;
+   }
+
+   return 0;
+}
+
+int retro_vfs_file_error_cdrom(libretro_vfs_implementation_file *stream)
+{
+   return 0;
+}
+
+const vfs_cdrom_t* retro_vfs_file_get_cdrom_position(
+      const libretro_vfs_implementation_file *stream)
+{
+   return &stream->cdrom;
+}

libretro/libretro-common/vfs/vfs_implementation_uwp.cpp

@@ -0,0 +1,826 @@
+/* Copyright  (C) 2018-2020 The RetroArch team
+*
+* ---------------------------------------------------------------------------------------
+* The following license statement only applies to this file (vfs_implementation_uwp.cpp).
+* ---------------------------------------------------------------------------------------
+*
+* Permission is hereby granted, free of charge,
+* to any person obtaining a copy of this software and associated documentation files (the "Software"),
+* to deal in the Software without restriction, including without limitation the rights to
+* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+* and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+*
+* The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+* INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+
+#include <retro_environment.h>
+
+#include <ppl.h>
+#include <ppltasks.h>
+#include <stdio.h>
+#include <wrl.h>
+#include <wrl/implements.h>
+#include <windows.storage.streams.h>
+#include <robuffer.h>
+#include <collection.h>
+#include <functional>
+
+using namespace Windows::Foundation;
+using namespace Windows::Foundation::Collections;
+using namespace Windows::Storage;
+using namespace Windows::Storage::Streams;
+using namespace Windows::Storage::FileProperties;
+
+#ifdef RARCH_INTERNAL
+#ifndef VFS_FRONTEND
+#define VFS_FRONTEND
+#endif
+#endif
+
+#include <vfs/vfs.h>
+#include <vfs/vfs_implementation.h>
+#include <libretro.h>
+#include <encodings/utf.h>
+#include <retro_miscellaneous.h>
+#include <file/file_path.h>
+#include <retro_assert.h>
+#include <string/stdstring.h>
+#include <retro_environment.h>
+#include <uwp/uwp_async.h>
+
+namespace
+{
+	void windowsize_path(wchar_t* path)
+	{
+		/* UWP deals with paths containing / instead of 
+       * \ way worse than normal Windows */
+		/* and RetroArch may sometimes mix them 
+       * (e.g. on archive extraction) */
+		if (!path)
+			return;
+
+		while (*path)
+		{
+			if (*path == '/')
+				*path = '\\';
+			++path;
+		}
+	}
+}
+
+namespace
+{
+	/* Damn you, UWP, why no functions for that either */
+	template<typename T>
+	concurrency::task<T^> GetItemFromPathAsync(Platform::String^ path)
+	{
+		static_assert(false, "StorageFile and StorageFolder only");
+	}
+	template<>
+	concurrency::task<StorageFile^> GetItemFromPathAsync(Platform::String^ path)
+	{
+		return concurrency::create_task(StorageFile::GetFileFromPathAsync(path));
+	}
+	template<>
+	concurrency::task<StorageFolder^> GetItemFromPathAsync(Platform::String^ path)
+	{
+		return concurrency::create_task(StorageFolder::GetFolderFromPathAsync(path));
+	}
+
+	template<typename T>
+	concurrency::task<T^> GetItemInFolderFromPathAsync(StorageFolder^ folder, Platform::String^ path)
+	{
+		static_assert(false, "StorageFile and StorageFolder only");
+	}
+	template<>
+	concurrency::task<StorageFile^> GetItemInFolderFromPathAsync(StorageFolder^ folder, Platform::String^ path)
+	{
+		if (path->IsEmpty())
+			retro_assert(false); /* Attempt to read a folder as a file - this really should have been caught earlier */
+		return concurrency::create_task(folder->GetFileAsync(path));
+	}
+	template<>
+	concurrency::task<StorageFolder^> GetItemInFolderFromPathAsync(StorageFolder^ folder, Platform::String^ path)
+	{
+		if (path->IsEmpty())
+			return concurrency::create_task(concurrency::create_async([folder]() { return folder; }));
+		return concurrency::create_task(folder->GetFolderAsync(path));
+	}
+}
+
+namespace
+{
+	/* A list of all StorageFolder objects returned using from the file picker */
+	Platform::Collections::Vector<StorageFolder^> accessible_directories;
+
+	concurrency::task<Platform::String^> TriggerPickerAddDialog()
+	{
+		auto folderPicker = ref new Windows::Storage::Pickers::FolderPicker();
+		folderPicker->SuggestedStartLocation = Windows::Storage::Pickers::PickerLocationId::Desktop;
+		folderPicker->FileTypeFilter->Append("*");
+
+		return concurrency::create_task(folderPicker->PickSingleFolderAsync()).then([](StorageFolder^ folder) {
+			if (folder == nullptr)
+				throw ref new Platform::Exception(E_ABORT, L"Operation cancelled by user");
+
+			/* TODO: check for duplicates */
+			accessible_directories.Append(folder);
+			return folder->Path;
+		});
+	}
+
+	template<typename T>
+	concurrency::task<T^> LocateStorageItem(Platform::String^ path)
+	{
+		/* Look for a matching directory we can use */
+		for each (StorageFolder^ folder in accessible_directories)
+		{
+         std::wstring file_path;
+			std::wstring folder_path = folder->Path->Data();
+         size_t folder_path_size  = folder_path.size();
+			/* Could be C:\ or C:\Users\somebody - remove the trailing slash to unify them */
+			if (folder_path[folder_path_size - 1] == '\\')
+				folder_path.erase(folder_path_size - 1);
+
+			file_path = path->Data();
+
+			if (file_path.find(folder_path) == 0)
+			{
+				/* Found a match */
+				file_path = file_path.length() > folder_path.length() 
+               ? file_path.substr(folder_path.length() + 1) 
+               : L"";
+				return concurrency::create_task(GetItemInFolderFromPathAsync<T>(folder, ref new Platform::String(file_path.data())));
+			}
+		}
+
+		/* No matches - try accessing directly, and fallback to user prompt */
+		return concurrency::create_task(GetItemFromPathAsync<T>(path)).then([&](concurrency::task<T^> item) {
+			try
+			{
+				T^ storageItem = item.get();
+				return concurrency::create_task(concurrency::create_async([storageItem]() { return storageItem; }));
+			}
+			catch (Platform::AccessDeniedException^ e)
+			{
+				Windows::UI::Popups::MessageDialog^ dialog =
+					ref new Windows::UI::Popups::MessageDialog("Path \"" + path + "\" is not currently accessible. Please open any containing directory to access it.");
+				dialog->Commands->Append(ref new Windows::UI::Popups::UICommand("Open file picker"));
+				dialog->Commands->Append(ref new Windows::UI::Popups::UICommand("Cancel"));
+				return concurrency::create_task(dialog->ShowAsync()).then([path](Windows::UI::Popups::IUICommand^ cmd) {
+					if (cmd->Label == "Open file picker")
+					{
+						return TriggerPickerAddDialog().then([path](Platform::String^ added_path) {
+							/* Retry */
+							return LocateStorageItem<T>(path);
+						});
+					}
+					else
+					{
+						throw ref new Platform::Exception(E_ABORT, L"Operation cancelled by user");
+					}
+				});
+			}
+		});
+	}
+
+	IStorageItem^ LocateStorageFileOrFolder(Platform::String^ path)
+	{
+		if (!path || path->IsEmpty())
+			return nullptr;
+
+		if (*(path->End() - 1) == '\\')
+		{
+			/* Ends with a slash, so it's definitely a directory */
+			return RunAsyncAndCatchErrors<StorageFolder^>([&]() {
+				return concurrency::create_task(LocateStorageItem<StorageFolder>(path));
+			}, nullptr);
+		}
+		else
+		{
+			/* No final slash - probably a file (since RetroArch usually slash-terminates dirs), but there is still a chance it's a directory */
+			IStorageItem^ item;
+			item = RunAsyncAndCatchErrors<StorageFile^>([&]() {
+				return concurrency::create_task(LocateStorageItem<StorageFile>(path));
+			}, nullptr);
+			if (!item)
+			{
+				item = RunAsyncAndCatchErrors<StorageFolder^>([&]() {
+					return concurrency::create_task(LocateStorageItem<StorageFolder>(path));
+				}, nullptr);
+			}
+			return item;
+		}
+	}
+}
+
+
+/* This is some pure magic and I have absolutely no idea how it works */
+/* Wraps a raw buffer into a WinRT object */
+/* https://stackoverflow.com/questions/10520335/how-to-wrap-a-char-buffer-in-a-winrt-ibuffer-in-c */
+class NativeBuffer :
+	public Microsoft::WRL::RuntimeClass<Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::RuntimeClassType::WinRtClassicComMix>,
+	ABI::Windows::Storage::Streams::IBuffer,
+	Windows::Storage::Streams::IBufferByteAccess>
+{
+public:
+	virtual ~NativeBuffer()
+	{
+	}
+
+	HRESULT __stdcall RuntimeClassInitialize(
+         byte *buffer, uint32_t capacity, uint32_t length)
+	{
+		m_buffer = buffer;
+		m_capacity = capacity;
+		m_length = length;
+		return S_OK;
+	}
+
+	HRESULT __stdcall Buffer(byte **value)
+	{
+		if (m_buffer == nullptr)
+			return E_INVALIDARG;
+		*value = m_buffer;
+		return S_OK;
+	}
+
+	HRESULT __stdcall get_Capacity(uint32_t *value)
+	{
+		*value = m_capacity;
+		return S_OK;
+	}
+
+	HRESULT __stdcall get_Length(uint32_t *value)
+	{
+		*value = m_length;
+		return S_OK;
+	}
+
+	HRESULT __stdcall put_Length(uint32_t value)
+	{
+		if (value > m_capacity)
+			return E_INVALIDARG;
+		m_length = value;
+		return S_OK;
+	}
+
+private:
+	byte *m_buffer;
+	uint32_t m_capacity;
+	uint32_t m_length;
+};
+
+IBuffer^ CreateNativeBuffer(void* buf, uint32_t capacity, uint32_t length)
+{
+	Microsoft::WRL::ComPtr<NativeBuffer> nativeBuffer;
+	Microsoft::WRL::Details::MakeAndInitialize<NativeBuffer>(&nativeBuffer, (byte *)buf, capacity, length);
+	auto iinspectable = (IInspectable *)reinterpret_cast<IInspectable *>(nativeBuffer.Get());
+	IBuffer ^buffer = reinterpret_cast<IBuffer ^>(iinspectable);
+	return buffer;
+}
+
+#ifdef VFS_FRONTEND
+struct retro_vfs_file_handle
+#else
+struct libretro_vfs_implementation_file
+#endif
+{
+	IRandomAccessStream^ fp;
+	IBuffer^ bufferp;
+	char* buffer;
+	char* orig_path;
+	size_t buffer_size;
+	int buffer_left;
+	size_t buffer_fill;
+};
+
+libretro_vfs_implementation_file *retro_vfs_file_open_impl(
+      const char *path, unsigned mode, unsigned hints)
+{
+   char dirpath[PATH_MAX_LENGTH];
+   char filename[PATH_MAX_LENGTH];
+   wchar_t *dirpath_wide;
+   wchar_t *filename_wide;
+   Platform::String^ filename_str;
+   Platform::String^ dirpath_str;
+	if (!path || !*path)
+		return NULL;
+
+   /* Something tried to access files from current directory. 
+    * This is not allowed on UWP. */
+	if (!path_is_absolute(path))
+		return NULL;
+
+   /* Trying to open a directory as file?! */
+	if (PATH_CHAR_IS_SLASH(path[strlen(path) - 1]))
+		return NULL;
+
+   dirpath[0] = filename[0] = '\0';
+
+	fill_pathname_basedir(dirpath, path, sizeof(dirpath));
+	dirpath_wide          = utf8_to_utf16_string_alloc(dirpath);
+	windowsize_path(dirpath_wide);
+	dirpath_str           = ref new Platform::String(dirpath_wide);
+	free(dirpath_wide);
+
+	fill_pathname_base(filename, path, sizeof(filename));
+	filename_wide         = utf8_to_utf16_string_alloc(filename);
+	filename_str          = ref new Platform::String(filename_wide);
+	free(filename_wide);
+
+	retro_assert(!dirpath_str->IsEmpty() && !filename_str->IsEmpty());
+
+	return RunAsyncAndCatchErrors<libretro_vfs_implementation_file*>([&]() {
+		return concurrency::create_task(LocateStorageItem<StorageFolder>(dirpath_str)).then([&](StorageFolder^ dir) {
+			if (mode == RETRO_VFS_FILE_ACCESS_READ)
+				return dir->GetFileAsync(filename_str);
+			else
+				return dir->CreateFileAsync(filename_str, (mode & RETRO_VFS_FILE_ACCESS_UPDATE_EXISTING) != 0 ?
+					CreationCollisionOption::OpenIfExists : CreationCollisionOption::ReplaceExisting);
+		}).then([&](StorageFile^ file) {
+			FileAccessMode accessMode = (mode == RETRO_VFS_FILE_ACCESS_READ) ?
+				FileAccessMode::Read : FileAccessMode::ReadWrite;
+			return file->OpenAsync(accessMode);
+		}).then([&](IRandomAccessStream^ fpstream) {
+			libretro_vfs_implementation_file *stream = (libretro_vfs_implementation_file*)calloc(1, sizeof(*stream));
+			if (!stream)
+				return (libretro_vfs_implementation_file*)NULL;
+
+			stream->orig_path   = strdup(path);
+			stream->fp          = fpstream;
+			stream->fp->Seek(0);
+			/* Preallocate a small buffer for manually buffered I/O,
+          * makes short read faster */
+			int buf_size        = 8 * 1024;
+			stream->buffer      = (char*)malloc(buf_size);
+			stream->bufferp     = CreateNativeBuffer(stream->buffer, buf_size, 0);
+			stream->buffer_left = 0;
+			stream->buffer_fill = 0;
+			stream->buffer_size = buf_size;
+			return stream;
+		});
+	}, NULL);
+}
+
+int retro_vfs_file_close_impl(libretro_vfs_implementation_file *stream)
+{
+	if (!stream || !stream->fp)
+		return -1;
+
+	/* Apparently, this is how you close a file in WinRT */
+	/* Yes, really */
+	stream->fp = nullptr;
+	free(stream->buffer);
+
+	return 0;
+}
+
+int retro_vfs_file_error_impl(libretro_vfs_implementation_file *stream)
+{
+	return false; /* TODO */
+}
+
+int64_t retro_vfs_file_size_impl(libretro_vfs_implementation_file *stream)
+{
+	if (!stream || !stream->fp)
+		return 0;
+	return stream->fp->Size;
+}
+
+int64_t retro_vfs_file_truncate_impl(libretro_vfs_implementation_file *stream, int64_t length)
+{
+	if (!stream || !stream->fp)
+		return -1;
+	stream->fp->Size = length;
+	return 0;
+}
+
+int64_t retro_vfs_file_tell_impl(libretro_vfs_implementation_file *stream)
+{
+	if (!stream || !stream->fp)
+		return -1;
+	return stream->fp->Position - stream->buffer_left;
+}
+
+int64_t retro_vfs_file_seek_impl(
+      libretro_vfs_implementation_file *stream,
+      int64_t offset, int seek_position)
+{
+   if (!stream || !stream->fp)
+      return -1;
+
+   switch (seek_position)
+   {
+      case RETRO_VFS_SEEK_POSITION_START:
+         stream->fp->Seek(offset);
+         break;
+
+      case RETRO_VFS_SEEK_POSITION_CURRENT:
+         stream->fp->Seek(retro_vfs_file_tell_impl(stream) + offset);
+         break;
+
+      case RETRO_VFS_SEEK_POSITION_END:
+         stream->fp->Seek(stream->fp->Size - offset);
+         break;
+   }
+
+   // For simplicity always flush the buffer on seek
+   stream->buffer_left = 0;
+
+   return 0;
+}
+
+int64_t retro_vfs_file_read_impl(
+      libretro_vfs_implementation_file *stream, void *s, uint64_t len)
+{
+   int64_t ret;
+	int64_t bytes_read = 0;
+   IBuffer^ buffer;
+
+	if (!stream || !stream->fp || !s)
+		return -1;
+
+	if (len <= stream->buffer_size)
+   {
+      /* Small read, use manually buffered I/O */
+      if (stream->buffer_left < len)
+      {
+         /* Exhaust the buffer */
+         memcpy(s,
+               &stream->buffer[stream->buffer_fill - stream->buffer_left],
+               stream->buffer_left);
+         len                 -= stream->buffer_left;
+         bytes_read          += stream->buffer_left;
+         stream->buffer_left  = 0;
+
+         /* Fill buffer */
+         stream->buffer_left = RunAsyncAndCatchErrors<int64_t>([&]() {
+               return concurrency::create_task(stream->fp->ReadAsync(stream->bufferp, stream->bufferp->Capacity, InputStreamOptions::None)).then([&](IBuffer^ buf) {
+                     retro_assert(stream->bufferp == buf);
+                     return (int64_t)stream->bufferp->Length;
+                     });
+               }, -1);
+         stream->buffer_fill = stream->buffer_left;
+
+         if (stream->buffer_left == -1)
+         {
+            stream->buffer_left = 0;
+            stream->buffer_fill = 0;
+            return -1;
+         }
+
+         if (stream->buffer_left < len)
+         {
+            /* EOF */
+            memcpy(&((char*)s)[bytes_read],
+                  stream->buffer, stream->buffer_left);
+            bytes_read += stream->buffer_left;
+            stream->buffer_left = 0;
+            return bytes_read;
+         }
+
+         memcpy(&((char*)s)[bytes_read], stream->buffer, len);
+         bytes_read += len;
+         stream->buffer_left -= len;
+         return bytes_read;
+      }
+
+      /* Internal buffer already contains requested amount */
+      memcpy(s,
+            &stream->buffer[stream->buffer_fill - stream->buffer_left],
+            len);
+      stream->buffer_left -= len;
+      return len;
+   }
+
+	/* Big read exceeding buffer size, 
+    * exhaust small buffer and read rest in one go */
+	memcpy(s, &stream->buffer[stream->buffer_fill - stream->buffer_left], stream->buffer_left);
+	len                 -= stream->buffer_left;
+	bytes_read          += stream->buffer_left;
+	stream->buffer_left  = 0;
+
+	buffer               = CreateNativeBuffer(&((char*)s)[bytes_read], len, 0);
+	ret                  = RunAsyncAndCatchErrors<int64_t>([&]() {
+		return concurrency::create_task(stream->fp->ReadAsync(buffer, buffer->Capacity - bytes_read, InputStreamOptions::None)).then([&](IBuffer^ buf) {
+			retro_assert(buf == buffer);
+			return (int64_t)buffer->Length;
+		});
+	}, -1);
+
+	if (ret == -1)
+		return -1;
+	return bytes_read + ret;
+}
+
+int64_t retro_vfs_file_write_impl(
+      libretro_vfs_implementation_file *stream, const void *s, uint64_t len)
+{
+   IBuffer^ buffer;
+   if (!stream || !stream->fp || !s)
+      return -1;
+
+   /* const_cast to remove const modifier is undefined behaviour, but the buffer is only read, should be safe */
+   buffer = CreateNativeBuffer(const_cast<void*>(s), len, len);
+   return RunAsyncAndCatchErrors<int64_t>([&]() {
+         return concurrency::create_task(stream->fp->WriteAsync(buffer)).then([&](unsigned int written) {
+               return (int64_t)written;
+               });
+         }, -1);
+}
+
+int retro_vfs_file_flush_impl(libretro_vfs_implementation_file *stream)
+{
+	if (!stream || !stream->fp)
+		return -1;
+
+	return RunAsyncAndCatchErrors<int>([&]() {
+		return concurrency::create_task(stream->fp->FlushAsync()).then([&](bool this_value_is_not_even_documented_wtf) {
+			/* The bool value may be reporting an error or something, but just leave it alone for now */
+			/* https://github.com/MicrosoftDocs/winrt-api/issues/841 */
+			return 0;
+		});
+	}, -1);
+}
+
+int retro_vfs_file_remove_impl(const char *path)
+{
+   wchar_t *path_wide;
+   Platform::String^ path_str;
+
+	if (!path || !*path)
+		return -1;
+
+	path_wide = utf8_to_utf16_string_alloc(path);
+	windowsize_path(path_wide);
+	path_str  = ref new Platform::String(path_wide);
+	free(path_wide);
+
+	return RunAsyncAndCatchErrors<int>([&]() {
+		return concurrency::create_task(LocateStorageItem<StorageFile>(path_str)).then([&](StorageFile^ file) {
+			return file->DeleteAsync(StorageDeleteOption::PermanentDelete);
+		}).then([&]() {
+			return 0;
+		});
+	}, -1);
+}
+
+/* TODO: this may not work if trying to move a directory */
+int retro_vfs_file_rename_impl(const char *old_path, const char *new_path)
+{
+   char new_file_name[PATH_MAX_LENGTH];
+   char new_dir_path[PATH_MAX_LENGTH];
+   wchar_t *new_file_name_wide;
+   wchar_t *old_path_wide, *new_dir_path_wide;
+   Platform::String^ old_path_str;
+   Platform::String^ new_dir_path_str;
+   Platform::String^ new_file_name_str;
+
+   if (!old_path || !*old_path || !new_path || !*new_path)
+		return -1;
+
+   new_file_name[0] = '\0';
+   new_dir_path [0] = '\0';
+
+	old_path_wide = utf8_to_utf16_string_alloc(old_path);
+	old_path_str  = ref new Platform::String(old_path_wide);
+	free(old_path_wide);
+
+	fill_pathname_basedir(new_dir_path, new_path, sizeof(new_dir_path));
+	new_dir_path_wide = utf8_to_utf16_string_alloc(new_dir_path);
+	windowsize_path(new_dir_path_wide);
+	new_dir_path_str  = ref new Platform::String(new_dir_path_wide);
+	free(new_dir_path_wide);
+
+	fill_pathname_base(new_file_name, new_path, sizeof(new_file_name));
+	new_file_name_wide = utf8_to_utf16_string_alloc(new_file_name);
+	new_file_name_str  = ref new Platform::String(new_file_name_wide);
+	free(new_file_name_wide);
+
+	retro_assert(!old_path_str->IsEmpty() && !new_dir_path_str->IsEmpty() && !new_file_name_str->IsEmpty());
+
+	return RunAsyncAndCatchErrors<int>([&]() {
+		concurrency::task<StorageFile^> old_file_task = concurrency::create_task(LocateStorageItem<StorageFile>(old_path_str));
+		concurrency::task<StorageFolder^> new_dir_task = concurrency::create_task(LocateStorageItem<StorageFolder>(new_dir_path_str));
+		return concurrency::create_task([&] {
+			/* Run these two tasks in parallel */
+			/* TODO: There may be some cleaner way to express this */
+			concurrency::task_group group;
+			group.run([&] { return old_file_task; });
+			group.run([&] { return new_dir_task; });
+			group.wait();
+		}).then([&]() {
+			return old_file_task.get()->MoveAsync(new_dir_task.get(), new_file_name_str, NameCollisionOption::ReplaceExisting);
+		}).then([&]() {
+			return 0;
+		});
+	}, -1);
+}
+
+const char *retro_vfs_file_get_path_impl(libretro_vfs_implementation_file *stream)
+{
+	/* should never happen, do something noisy so caller can be fixed */
+	if (!stream)
+		abort();
+	return stream->orig_path;
+}
+
+int retro_vfs_stat_impl(const char *path, int32_t *size)
+{
+   wchar_t *path_wide;
+   Platform::String^ path_str;
+   IStorageItem^ item;
+
+	if (!path || !*path)
+		return 0;
+
+	path_wide = utf8_to_utf16_string_alloc(path);
+	windowsize_path(path_wide);
+	path_str  = ref new Platform::String(path_wide);
+	free(path_wide);
+
+	item      = LocateStorageFileOrFolder(path_str);
+	if (!item)
+		return 0;
+
+	return RunAsyncAndCatchErrors<int>([&]() {
+		return concurrency::create_task(item->GetBasicPropertiesAsync()).then([&](BasicProperties^ properties) {
+			if (size)
+				*size = properties->Size;
+			return item->IsOfType(StorageItemTypes::Folder) ? RETRO_VFS_STAT_IS_VALID | RETRO_VFS_STAT_IS_DIRECTORY : RETRO_VFS_STAT_IS_VALID;
+		});
+	}, 0);
+}
+
+int retro_vfs_mkdir_impl(const char *dir)
+{
+   Platform::String^ parent_path_str;
+   Platform::String^ dir_name_str;
+   wchar_t *dir_name_wide, *parent_path_wide;
+   char *dir_local, *tmp, *dir_name;
+   char parent_path[PATH_MAX_LENGTH];
+   char dir_name[PATH_MAX_LENGTH];
+	if (!dir || !*dir)
+		return -1;
+
+   dir_name[0]      = '\0';
+
+   /* If the path ends with a slash, we have to remove 
+    * it for basename to work */
+	dir_local        = strdup(dir);
+	tmp              = dir_local + strlen(dir_local) - 1;
+
+	if (PATH_CHAR_IS_SLASH(*tmp))
+		*tmp          = 0;
+
+	fill_pathname_base(dir_name, dir_local, sizeof(dir_name));
+	dir_name_wide    = utf8_to_utf16_string_alloc(dir_name);
+	dir_name_str     = ref new Platform::String(dir_name_wide);
+	free(dir_name_wide);
+
+	fill_pathname_parent_dir(parent_path, dir_local, sizeof(parent_path));
+	parent_path_wide = utf8_to_utf16_string_alloc(parent_path);
+	windowsize_path(parent_path_wide);
+	parent_path_str  = ref new Platform::String(parent_path_wide);
+	free(parent_path_wide);
+
+	retro_assert(!dir_name_str->IsEmpty() 
+         && !parent_path_str->IsEmpty());
+
+	free(dir_local);
+
+	return RunAsyncAndCatchErrors<int>([&]() {
+		return concurrency::create_task(LocateStorageItem<StorageFolder>(
+               parent_path_str)).then([&](StorageFolder^ parent) {
+			return parent->CreateFolderAsync(dir_name_str);
+		}).then([&](concurrency::task<StorageFolder^> new_dir) {
+			try
+			{
+				new_dir.get();
+			}
+			catch (Platform::COMException^ e)
+			{
+				if (e->HResult == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS))
+					return -2;
+				throw;
+			}
+			return 0;
+		});
+	}, -1);
+}
+
+#ifdef VFS_FRONTEND
+struct retro_vfs_dir_handle
+#else
+struct libretro_vfs_implementation_dir
+#endif
+{
+	IVectorView<IStorageItem^>^ directory;
+	IIterator<IStorageItem^>^ entry;
+	char *entry_name;
+};
+
+libretro_vfs_implementation_dir *retro_vfs_opendir_impl(const char *name, bool include_hidden)
+{
+   wchar_t *name_wide;
+   Platform::String^ name_str;
+	libretro_vfs_implementation_dir *rdir;
+
+	if (!name || !*name)
+		return NULL;
+
+	rdir = (libretro_vfs_implementation_dir*)calloc(1, sizeof(*rdir));
+	if (!rdir)
+		return NULL;
+
+	name_wide = utf8_to_utf16_string_alloc(name);
+	windowsize_path(name_wide);
+	name_str  = ref new Platform::String(name_wide);
+	free(name_wide);
+
+	rdir->directory = RunAsyncAndCatchErrors<IVectorView<IStorageItem^>^>([&]() {
+		return concurrency::create_task(LocateStorageItem<StorageFolder>(name_str)).then([&](StorageFolder^ folder) {
+			return folder->GetItemsAsync();
+		});
+	}, nullptr);
+
+	if (rdir->directory)
+		return rdir;
+
+	free(rdir);
+	return NULL;
+}
+
+bool retro_vfs_readdir_impl(libretro_vfs_implementation_dir *rdir)
+{
+	if (!rdir->entry)
+	{
+		rdir->entry = rdir->directory->First();
+		return rdir->entry->HasCurrent;
+	}
+   return rdir->entry->MoveNext();
+}
+
+const char *retro_vfs_dirent_get_name_impl(
+      libretro_vfs_implementation_dir *rdir)
+{
+	if (rdir->entry_name)
+		free(rdir->entry_name);
+	rdir->entry_name = utf16_to_utf8_string_alloc(
+         rdir->entry->Current->Name->Data());
+	return rdir->entry_name;
+}
+
+bool retro_vfs_dirent_is_dir_impl(libretro_vfs_implementation_dir *rdir)
+{
+	return rdir->entry->Current->IsOfType(StorageItemTypes::Folder);
+}
+
+int retro_vfs_closedir_impl(libretro_vfs_implementation_dir *rdir)
+{
+	if (!rdir)
+		return -1;
+
+	if (rdir->entry_name)
+		free(rdir->entry_name);
+	rdir->entry     = nullptr;
+	rdir->directory = nullptr;
+
+	free(rdir);
+	return 0;
+}
+
+bool uwp_drive_exists(const char *path)
+{
+   wchar_t *path_wide;
+   Platform::String^ path_str;
+   if (!path || !*path)
+      return 0;
+
+   path_wide = utf8_to_utf16_string_alloc(path);
+   path_str  = ref new Platform::String(path_wide);
+   free(path_wide);
+
+   return RunAsyncAndCatchErrors<bool>([&]() {
+         return concurrency::create_task(StorageFolder::GetFolderFromPathAsync(path_str)).then([](StorageFolder^ properties) {
+               return true;
+               });
+         }, false);
+}
+
+char* uwp_trigger_picker(void)
+{
+	return RunAsyncAndCatchErrors<char*>([&]() {
+		return TriggerPickerAddDialog().then([](Platform::String^ path) {
+			return utf16_to_utf8_string_alloc(path->Data());
+		});
+	}, NULL);
+}