Fetch translations from Crowdin

CD-i discs have a unique quirk: they store data in tracks labeled as
AUDIO in both CUE and CHD formats. The scanner normally skips AUDIO
tracks when looking for data, causing CD-i games to never match the
database.

Makefile.libnx

@@ -57,6 +57,8 @@ HAVE_CHD = 1
 HAVE_STB_VORBIS = 1
 HAVE_IBXM = 1
 HAVE_CORE_INFO_CACHE = 1
+HAVE_CLOUD_SYNC = 1
+HAVE_SSL = 1
 
 # RetroArch libnx useful flags
 HAVE_THREADS = 1
@@ -148,7 +150,7 @@ LDFLAGS	=	-specs=$(DEVKITPRO)/libnx/switch.specs $(ARCH) -Wl,--allow-multiple-de
 # add things from Makefile.common
 CFLAGS += $(DEF_FLAGS)
 
-LIBS	:= -lswresample -lavformat -lavcodec -lavutil -lswscale -lstdc++ -lbz2 -lpng -lz -lnx -lvpx -lopus -llzma -lm
+LIBS := -lswresample -lavformat -lavcodec -lavutil -lswscale -lstdc++ -lbz2 -lpng -lz -lnx -lvpx -lopus -llzma -lmbedtls -lmbedx509 -lmbedcrypto -lnx -lm
 
 ifeq ($(HAVE_OPENGL), 1)
   LIBS := -lEGL -lglapi -ldrm_nouveau $(LIBS)

Makefile.webos

@@ -224,7 +224,10 @@ define APPINFO
     "main": "retroarch",
     "iconColor": "#333333",
     "type": "native",
-    "appDescription": "Emulation frontend"
+    "appDescription": "Emulation frontend",
+    "cloudgame_active": true,
+    "useAllMouseButtons": true,
+    "useAllKeyboardKeys": true
 }
 endef
 export APPINFO

command.h

@@ -149,6 +149,10 @@ enum event_command
    CMD_EVENT_VIDEO_SET_ASPECT_RATIO,
    /* Restarts RetroArch. */
    CMD_EVENT_RESTART_RETROARCH,
+#ifdef HAVE_CLOUDSYNC
+   /* Trigger cloud sync */
+   CMD_EVENT_CLOUD_SYNC,
+#endif
    /* Shutdown the OS */
    CMD_EVENT_SHUTDOWN,
    /* Reboot the OS */

configuration.c

@@ -2612,6 +2612,9 @@ static struct config_uint_setting *populate_settings_uint(
 #ifdef HAVE_NETWORKGAMEPAD
    SETTING_UINT("network_remote_base_port",      &settings->uints.network_remote_base_port, true, DEFAULT_NETWORK_REMOTE_BASE_PORT, false);
 #endif
+#ifdef HAVE_CLOUDSYNC
+   SETTING_UINT("cloud_sync_sync_mode",          &settings->uints.cloud_sync_sync_mode, true, CLOUD_SYNC_MODE_AUTOMATIC, false);
+#endif
 
 #ifdef HAVE_LANGEXTRA
    SETTING_UINT("user_language",                 msg_hash_get_uint(MSG_HASH_USER_LANGUAGE), true, frontend_driver_get_user_language(), false);

configuration.h

@@ -89,6 +89,13 @@ enum override_type
    OVERRIDE_GAME
 };
 
+enum cloud_sync_mode_type
+{
+   CLOUD_SYNC_MODE_AUTOMATIC = 0,
+   CLOUD_SYNC_MODE_MANUAL,
+   CLOUD_SYNC_MODE_LAST
+};
+
 enum settings_glob_flags
 {
    SETTINGS_FLG_MODIFIED              = (1 << 0),
@@ -238,6 +245,7 @@ typedef struct settings
       unsigned network_cmd_port;
       unsigned network_remote_base_port;
       unsigned keymapper_port;
+      unsigned cloud_sync_sync_mode;
       unsigned video_window_opacity;
       unsigned crt_switch_resolution;
       unsigned crt_switch_resolution_super;

cores/libretro-video-processor/video_processor_v4l2.c

@@ -33,6 +33,7 @@
 
 #include <libretro.h>
 #include <clamping.h>
+#include <compat/strl.h>
 #include <retro_miscellaneous.h>
 
 #include <sys/mman.h>
@@ -607,9 +608,9 @@ RETRO_API void VIDEOPROC_CORE_PREFIX(retro_get_system_av_info)(struct retro_syst
       info->geometry.base_height = video_format.fmt.pix.height;
 
       if(capture_resolution.value != NULL)
-         strncpy(video_capture_resolution, capture_resolution.value, ENVVAR_BUFLEN-1);
+         strlcpy(video_capture_resolution, capture_resolution.value, sizeof(video_capture_resolution));
       else
-         strncpy(video_capture_resolution, "auto", ENVVAR_BUFLEN-1);
+         strlcpy(video_capture_resolution, "auto", sizeof(video_capture_resolution));
 
       if (strcmp(video_capture_resolution, "auto") != 0)
       {
@@ -1047,7 +1048,7 @@ RETRO_API void VIDEOPROC_CORE_PREFIX(retro_run)(void)
       }
 
       if (frametimes.value != NULL)
-         strncpy(video_frame_times, frametimes.value, ENVVAR_BUFLEN-1);
+         strlcpy(video_frame_times, frametimes.value, sizeof(video_frame_times));
    }
 
    VIDEOPROC_CORE_PREFIX(input_poll_cb)();
@@ -1217,18 +1218,18 @@ RETRO_API bool VIDEOPROC_CORE_PREFIX(retro_load_game)(const struct retro_game_in
        close_devices();
        return false;
    }
-   strncpy(video_device, videodev.value, ENVVAR_BUFLEN-1);
+   strlcpy(video_device, videodev.value, sizeof(video_device));
 
    /* Audio device is optional... */
    VIDEOPROC_CORE_PREFIX(environment_cb)(RETRO_ENVIRONMENT_GET_VARIABLE, &audiodev);
    if (audiodev.value != NULL)
-      strncpy(audio_device, audiodev.value, ENVVAR_BUFLEN-1);
+      strlcpy(audio_device, audiodev.value, sizeof(audio_device));
 
    VIDEOPROC_CORE_PREFIX(environment_cb)(RETRO_ENVIRONMENT_GET_VARIABLE, &capture_resolution);
    if(capture_resolution.value != NULL)
-      strncpy(video_capture_resolution, capture_resolution.value, ENVVAR_BUFLEN-1);
+      strlcpy(video_capture_resolution, capture_resolution.value, sizeof(video_capture_resolution));
    else
-      strncpy(video_capture_resolution, "auto", ENVVAR_BUFLEN-1);
+      strlcpy(video_capture_resolution, "auto", sizeof(video_capture_resolution));
 
    VIDEOPROC_CORE_PREFIX(environment_cb)(RETRO_ENVIRONMENT_GET_VARIABLE, &capture_mode);
    VIDEOPROC_CORE_PREFIX(environment_cb)(RETRO_ENVIRONMENT_GET_VARIABLE, &output_mode);
@@ -1237,12 +1238,12 @@ RETRO_API bool VIDEOPROC_CORE_PREFIX(retro_load_game)(const struct retro_game_in
        close_devices();
        return false;
    }
-   strncpy(video_capture_mode, capture_mode.value, ENVVAR_BUFLEN-1);
-   strncpy(video_output_mode, output_mode.value, ENVVAR_BUFLEN-1);
+   strlcpy(video_capture_mode, capture_mode.value, sizeof(video_capture_mode));
+   strlcpy(video_output_mode,  output_mode.value,  sizeof(video_output_mode));
 
    VIDEOPROC_CORE_PREFIX(environment_cb)(RETRO_ENVIRONMENT_GET_VARIABLE, &frame_times);
    if (frame_times.value != NULL)
-      strncpy(video_frame_times, frame_times.value, ENVVAR_BUFLEN-1);
+      strlcpy(video_frame_times, frame_times.value, sizeof(video_frame_times));
 
    if (strcmp(video_device, "dummy") == 0)
    {
@@ -1499,8 +1500,8 @@ RETRO_API bool VIDEOPROC_CORE_PREFIX(retro_load_game)(const struct retro_game_in
 
 RETRO_API void VIDEOPROC_CORE_PREFIX(retro_unload_game)(void)
 {
-   struct v4l2_requestbuffers reqbufs;
    int i;
+   struct v4l2_requestbuffers reqbufs;
 
 #ifdef HAVE_ALSA
    if (audio_handle != NULL)

database_info.c

@@ -718,7 +718,7 @@ static int database_cursor_iterate(libretrodb_cursor_t *cur,
       else if (string_is_equal(str, "analog"))
          db_info->analog_supported        = (int)val->val.uint_;
       else if (string_is_equal(str, "size"))
-         db_info->size                    = (unsigned)val->val.uint_;
+         db_info->size                    = (uint64_t)val->val.uint_;
       else if (string_is_equal(str, "crc"))
       {
          switch (val->val.binary.len)

database_info.h

@@ -123,7 +123,7 @@ typedef struct
    int rumble_supported;
    int coop_supported;
    uint32_t crc32;
-   unsigned size;
+   uint64_t size;
    unsigned famitsu_magazine_rating;
    unsigned edge_magazine_rating;
    unsigned edge_magazine_issue;

deps/dr/dr_flac.h

@@ -61,50 +61,11 @@ typedef drflac_uint32           drflac_bool32;
 
 /* Decorations */
 #if !defined(DRFLAC_API)
-    #if defined(DRFLAC_DLL)
-        #if defined(_WIN32)
-            #define DRFLAC_DLL_IMPORT  __declspec(dllimport)
-            #define DRFLAC_DLL_EXPORT  __declspec(dllexport)
-            #define DRFLAC_DLL_PRIVATE static
-        #else
-            #if defined(__GNUC__) && __GNUC__ >= 4
-                #define DRFLAC_DLL_IMPORT  __attribute__((visibility("default")))
-                #define DRFLAC_DLL_EXPORT  __attribute__((visibility("default")))
-                #define DRFLAC_DLL_PRIVATE __attribute__((visibility("hidden")))
-            #else
-                #define DRFLAC_DLL_IMPORT
-                #define DRFLAC_DLL_EXPORT
-                #define DRFLAC_DLL_PRIVATE static
-            #endif
-        #endif
-
-        #if defined(DR_FLAC_IMPLEMENTATION) || defined(DRFLAC_IMPLEMENTATION)
-            #define DRFLAC_API  DRFLAC_DLL_EXPORT
-        #else
-            #define DRFLAC_API  DRFLAC_DLL_IMPORT
-        #endif
-        #define DRFLAC_PRIVATE DRFLAC_DLL_PRIVATE
-    #else
-        #define DRFLAC_API extern
-        #define DRFLAC_PRIVATE static
-    #endif
+#define DRFLAC_API extern
+#define DRFLAC_PRIVATE static
 #endif
 /* End Decorations */
 
-#if defined(_MSC_VER) && _MSC_VER >= 1700   /* Visual Studio 2012 */
-    #define DRFLAC_DEPRECATED       __declspec(deprecated)
-#elif (defined(__GNUC__) && __GNUC__ >= 4)  /* GCC 4 */
-    #define DRFLAC_DEPRECATED       __attribute__((deprecated))
-#elif defined(__has_feature)                /* Clang */
-    #if __has_feature(attribute_deprecated)
-        #define DRFLAC_DEPRECATED   __attribute__((deprecated))
-    #else
-        #define DRFLAC_DEPRECATED
-    #endif
-#else
-    #define DRFLAC_DEPRECATED
-#endif
-
 /* Allocation Callbacks */
 typedef struct
 {
@@ -1403,10 +1364,8 @@ static DRFLAC_INLINE drflac_uint16 drflac__be2host_16(drflac_uint16 n)
 
 static DRFLAC_INLINE drflac_uint32 drflac__be2host_32(drflac_uint32 n)
 {
-    if (drflac__is_little_endian()) {
+    if (drflac__is_little_endian())
         return drflac__swap_endian_uint32(n);
-    }
-
     return n;
 }
 
@@ -1418,20 +1377,16 @@ static DRFLAC_INLINE drflac_uint32 drflac__be2host_32_ptr_unaligned(const void*
 
 static DRFLAC_INLINE drflac_uint64 drflac__be2host_64(drflac_uint64 n)
 {
-    if (drflac__is_little_endian()) {
+    if (drflac__is_little_endian())
         return drflac__swap_endian_uint64(n);
-    }
-
     return n;
 }
 
 
 static DRFLAC_INLINE drflac_uint32 drflac__le2host_32(drflac_uint32 n)
 {
-    if (!drflac__is_little_endian()) {
+    if (!drflac__is_little_endian())
         return drflac__swap_endian_uint32(n);
-    }
-
     return n;
 }
 
@@ -1453,8 +1408,6 @@ static DRFLAC_INLINE drflac_uint32 drflac__unsynchsafe_32(drflac_uint32 n)
     return result;
 }
 
-
-
 /* The CRC code below is based on this document: http://zlib.net/crc_v3.txt */
 static drflac_uint8 drflac__crc8_table[] = {
     0x00, 0x07, 0x0E, 0x09, 0x1C, 0x1B, 0x12, 0x15, 0x38, 0x3F, 0x36, 0x31, 0x24, 0x23, 0x2A, 0x2D,
@@ -1669,14 +1622,14 @@ static DRFLAC_INLINE drflac_bool32 drflac__reload_l1_cache_from_l2(drflac_bs* bs
     If we get here it means we've run out of data in the L2 cache. We'll need to fetch more from the client, if there's
     any left.
     */
-    if (bs->unalignedByteCount > 0) {
+    if (bs->unalignedByteCount > 0)
         return DRFLAC_FALSE;   /* If we have any unaligned bytes it means there's no more aligned bytes left in the client. */
-    }
 
     bytesRead = bs->onRead(bs->pUserData, bs->cacheL2, DRFLAC_CACHE_L2_SIZE_BYTES(bs));
 
     bs->nextL2Line = 0;
-    if (bytesRead == DRFLAC_CACHE_L2_SIZE_BYTES(bs)) {
+    if (bytesRead == DRFLAC_CACHE_L2_SIZE_BYTES(bs))
+    {
         bs->cache = bs->cacheL2[bs->nextL2Line++];
         return DRFLAC_TRUE;
     }
@@ -1696,21 +1649,21 @@ static DRFLAC_INLINE drflac_bool32 drflac__reload_l1_cache_from_l2(drflac_bs* bs
         bs->unalignedCache = bs->cacheL2[alignedL1LineCount];
     }
 
-    if (alignedL1LineCount > 0) {
+    if (alignedL1LineCount > 0)
+    {
         size_t offset = DRFLAC_CACHE_L2_LINE_COUNT(bs) - alignedL1LineCount;
         size_t i;
-        for (i = alignedL1LineCount; i > 0; --i) {
+        for (i = alignedL1LineCount; i > 0; --i)
             bs->cacheL2[i-1 + offset] = bs->cacheL2[i-1];
-        }
 
         bs->nextL2Line = (drflac_uint32)offset;
         bs->cache = bs->cacheL2[bs->nextL2Line++];
         return DRFLAC_TRUE;
-    } else {
-        /* If we get into this branch it means we weren't able to load any L1-aligned data. */
-        bs->nextL2Line = DRFLAC_CACHE_L2_LINE_COUNT(bs);
-        return DRFLAC_FALSE;
     }
+
+    /* If we get into this branch it means we weren't able to load any L1-aligned data. */
+    bs->nextL2Line = DRFLAC_CACHE_L2_LINE_COUNT(bs);
+    return DRFLAC_FALSE;
 }
 
 static drflac_bool32 drflac__reload_cache(drflac_bs* bs)
@@ -1722,7 +1675,8 @@ static drflac_bool32 drflac__reload_cache(drflac_bs* bs)
 #endif
 
     /* Fast path. Try just moving the next value in the L2 cache to the L1 cache. */
-    if (drflac__reload_l1_cache_from_l2(bs)) {
+    if (drflac__reload_l1_cache_from_l2(bs))
+    {
         bs->cache = drflac__be2host__cache_line(bs->cache);
         bs->consumedBits = 0;
 #ifndef DR_FLAC_NO_CRC
@@ -1739,7 +1693,8 @@ static drflac_bool32 drflac__reload_cache(drflac_bs* bs)
     data from the unaligned cache.
     */
     bytesRead = bs->unalignedByteCount;
-    if (bytesRead == 0) {
+    if (bytesRead == 0)
+    {
         bs->consumedBits = DRFLAC_CACHE_L1_SIZE_BITS(bs);   /* <-- The stream has been exhausted, so marked the bits as consumed. */
         return DRFLAC_FALSE;
     }
@@ -1827,14 +1782,13 @@ static drflac_bool32 drflac__read_int32(drflac_bs* bs, unsigned int bitCount, dr
 {
     drflac_uint32 result;
 
-    if (!drflac__read_uint32(bs, bitCount, &result)) {
+    if (!drflac__read_uint32(bs, bitCount, &result))
         return DRFLAC_FALSE;
-    }
 
     /* Do not attempt to shift by 32 as it's undefined. */
-    if (bitCount < 32) {
-        drflac_uint32 signbit;
-        signbit = ((result >> (bitCount-1)) & 0x01);
+    if (bitCount < 32)
+    {
+        drflac_uint32 signbit = ((result >> (bitCount-1)) & 0x01);
         result |= (~signbit + 1) << bitCount;
     }
 
@@ -1895,55 +1849,55 @@ static drflac_bool32 drflac__read_int8(drflac_bs* bs, unsigned int bitCount, drf
 
 static drflac_bool32 drflac__seek_bits(drflac_bs* bs, size_t bitsToSeek)
 {
-    if (bitsToSeek <= DRFLAC_CACHE_L1_BITS_REMAINING(bs)) {
-        bs->consumedBits += (drflac_uint32)bitsToSeek;
-        bs->cache <<= bitsToSeek;
-        return DRFLAC_TRUE;
-    } else {
-        /* It straddles the cached data. This function isn't called too frequently so I'm favouring simplicity here. */
-        bitsToSeek       -= DRFLAC_CACHE_L1_BITS_REMAINING(bs);
-        bs->consumedBits += DRFLAC_CACHE_L1_BITS_REMAINING(bs);
-        bs->cache         = 0;
+   if (bitsToSeek <= DRFLAC_CACHE_L1_BITS_REMAINING(bs))
+   {
+      bs->consumedBits += (drflac_uint32)bitsToSeek;
+      bs->cache <<= bitsToSeek;
+      return DRFLAC_TRUE;
+   }
 
-        /* Simple case. Seek in groups of the same number as bits that fit within a cache line. */
+   /* It straddles the cached data. This function isn't called too frequently so I'm favouring simplicity here. */
+   bitsToSeek       -= DRFLAC_CACHE_L1_BITS_REMAINING(bs);
+   bs->consumedBits += DRFLAC_CACHE_L1_BITS_REMAINING(bs);
+   bs->cache         = 0;
+
+   /* Simple case. Seek in groups of the same number as bits that fit within a cache line. */
 #ifdef DRFLAC_64BIT
-        while (bitsToSeek >= DRFLAC_CACHE_L1_SIZE_BITS(bs)) {
-            drflac_uint64 bin;
-            if (!drflac__read_uint64(bs, DRFLAC_CACHE_L1_SIZE_BITS(bs), &bin)) {
-                return DRFLAC_FALSE;
-            }
-            bitsToSeek -= DRFLAC_CACHE_L1_SIZE_BITS(bs);
-        }
+   while (bitsToSeek >= DRFLAC_CACHE_L1_SIZE_BITS(bs)) {
+      drflac_uint64 bin;
+      if (!drflac__read_uint64(bs, DRFLAC_CACHE_L1_SIZE_BITS(bs), &bin)) {
+         return DRFLAC_FALSE;
+      }
+      bitsToSeek -= DRFLAC_CACHE_L1_SIZE_BITS(bs);
+   }
 #else
-        while (bitsToSeek >= DRFLAC_CACHE_L1_SIZE_BITS(bs)) {
-            drflac_uint32 bin;
-            if (!drflac__read_uint32(bs, DRFLAC_CACHE_L1_SIZE_BITS(bs), &bin)) {
-                return DRFLAC_FALSE;
-            }
-            bitsToSeek -= DRFLAC_CACHE_L1_SIZE_BITS(bs);
-        }
+   while (bitsToSeek >= DRFLAC_CACHE_L1_SIZE_BITS(bs)) {
+      drflac_uint32 bin;
+      if (!drflac__read_uint32(bs, DRFLAC_CACHE_L1_SIZE_BITS(bs), &bin)) {
+         return DRFLAC_FALSE;
+      }
+      bitsToSeek -= DRFLAC_CACHE_L1_SIZE_BITS(bs);
+   }
 #endif
 
-        /* Whole leftover bytes. */
-        while (bitsToSeek >= 8) {
-            drflac_uint8 bin;
-            if (!drflac__read_uint8(bs, 8, &bin)) {
-                return DRFLAC_FALSE;
-            }
-            bitsToSeek -= 8;
-        }
+   /* Whole leftover bytes. */
+   while (bitsToSeek >= 8) {
+      drflac_uint8 bin;
+      if (!drflac__read_uint8(bs, 8, &bin)) {
+         return DRFLAC_FALSE;
+      }
+      bitsToSeek -= 8;
+   }
 
-        /* Leftover bits. */
-        if (bitsToSeek > 0) {
-            drflac_uint8 bin;
-            if (!drflac__read_uint8(bs, (drflac_uint32)bitsToSeek, &bin)) {
-                return DRFLAC_FALSE;
-            }
-            bitsToSeek = 0; /* <-- Necessary for the assert below. */
-        }
+   /* Leftover bits. */
+   if (bitsToSeek > 0) {
+      drflac_uint8 bin;
+      if (!drflac__read_uint8(bs, (drflac_uint32)bitsToSeek, &bin))
+         return DRFLAC_FALSE;
+      bitsToSeek = 0; /* <-- Necessary for the assert below. */
+   }
 
-        return DRFLAC_TRUE;
-    }
+   return DRFLAC_TRUE;
 }
 
 
@@ -1954,42 +1908,37 @@ static drflac_bool32 drflac__find_and_seek_to_next_sync_code(drflac_bs* bs)
     The sync code is always aligned to 8 bits. This is convenient for us because it means we can do byte-aligned movements. The first
     thing to do is align to the next byte.
     */
-    if (!drflac__seek_bits(bs, DRFLAC_CACHE_L1_BITS_REMAINING(bs) & 7)) {
-        return DRFLAC_FALSE;
-    }
-
-    for (;;) {
-        drflac_uint8 hi;
+    if (drflac__seek_bits(bs, DRFLAC_CACHE_L1_BITS_REMAINING(bs) & 7))
+    {
+       for (;;)
+       {
+          drflac_uint8 hi;
 
 #ifndef DR_FLAC_NO_CRC
-        drflac__reset_crc16(bs);
+          drflac__reset_crc16(bs);
 #endif
 
-        if (!drflac__read_uint8(bs, 8, &hi)) {
-            return DRFLAC_FALSE;
-        }
+          if (!drflac__read_uint8(bs, 8, &hi))
+             return DRFLAC_FALSE;
 
-        if (hi == 0xFF) {
-            drflac_uint8 lo;
-            if (!drflac__read_uint8(bs, 6, &lo)) {
+          if (hi == 0xFF)
+          {
+             drflac_uint8 lo;
+             if (!drflac__read_uint8(bs, 6, &lo))
                 return DRFLAC_FALSE;
-            }
 
-            if (lo == 0x3E) {
+             if (lo == 0x3E)
                 return DRFLAC_TRUE;
-            } else {
-                if (!drflac__seek_bits(bs, DRFLAC_CACHE_L1_BITS_REMAINING(bs) & 7)) {
-                    return DRFLAC_FALSE;
-                }
-            }
-        }
+
+             if (!drflac__seek_bits(bs, DRFLAC_CACHE_L1_BITS_REMAINING(bs) & 7))
+                return DRFLAC_FALSE;
+          }
+       }
     }
 
-    /* Should never get here. */
-    /*return DRFLAC_FALSE;*/
+    return DRFLAC_FALSE;
 }
 
-
 #if defined(DRFLAC_HAS_LZCNT_INTRINSIC)
 #define DRFLAC_IMPLEMENT_CLZ_LZCNT
 #endif
@@ -2047,11 +1996,11 @@ static DRFLAC_INLINE drflac_bool32 drflac__is_lzcnt_supported(void)
     return DRFLAC_TRUE;
 #else
     /* If the compiler itself does not support the intrinsic then we'll need to return false. */
-    #ifdef DRFLAC_HAS_LZCNT_INTRINSIC
-        return drflac__gIsLZCNTSupported;
-    #else
-        return DRFLAC_FALSE;
-    #endif
+#ifdef DRFLAC_HAS_LZCNT_INTRINSIC
+    return drflac__gIsLZCNTSupported;
+#else
+    return DRFLAC_FALSE;
+#endif
 #endif
 }
 
@@ -2138,11 +2087,8 @@ static DRFLAC_INLINE drflac_uint32 drflac__clz_lzcnt(drflac_cache_t x)
 static DRFLAC_INLINE drflac_uint32 drflac__clz_msvc(drflac_cache_t x)
 {
     drflac_uint32 n;
-
-    if (x == 0) {
+    if (x == 0)
         return sizeof(x)*8;
-    }
-
 #ifdef DRFLAC_64BIT
     _BitScanReverse64((unsigned long*)&n, x);
 #else
@@ -2200,19 +2146,19 @@ static DRFLAC_INLINE drflac_bool32 drflac__seek_past_next_set_bit(drflac_bs* bs,
     drflac_uint32 zeroCounter = 0;
     drflac_uint32 setBitOffsetPlus1;
 
-    while (bs->cache == 0) {
+    while (bs->cache == 0)
+    {
         zeroCounter += (drflac_uint32)DRFLAC_CACHE_L1_BITS_REMAINING(bs);
-        if (!drflac__reload_cache(bs)) {
+        if (!drflac__reload_cache(bs))
             return DRFLAC_FALSE;
-        }
     }
 
-    if (bs->cache == 1) {
+    if (bs->cache == 1)
+    {
         /* Not catching this would lead to undefined behaviour: a shift of a 32-bit number by 32 or more is undefined */
         *pOffsetOut = zeroCounter + (drflac_uint32)DRFLAC_CACHE_L1_BITS_REMAINING(bs) - 1;
-        if (!drflac__reload_cache(bs)) {
+        if (!drflac__reload_cache(bs))
             return DRFLAC_FALSE;
-        }
 
         return DRFLAC_TRUE;
     }
@@ -2220,10 +2166,9 @@ static DRFLAC_INLINE drflac_bool32 drflac__seek_past_next_set_bit(drflac_bs* bs,
     setBitOffsetPlus1 = drflac__clz(bs->cache);
     setBitOffsetPlus1 += 1;
 
-    if (setBitOffsetPlus1 > DRFLAC_CACHE_L1_BITS_REMAINING(bs)) {
-        /* This happens when we get to end of stream */
+    /* This happens when we get to end of stream */
+    if (setBitOffsetPlus1 > DRFLAC_CACHE_L1_BITS_REMAINING(bs))
         return DRFLAC_FALSE;
-    }
 
     bs->consumedBits += setBitOffsetPlus1;
     bs->cache <<= setBitOffsetPlus1;
@@ -2232,8 +2177,6 @@ static DRFLAC_INLINE drflac_bool32 drflac__seek_past_next_set_bit(drflac_bs* bs,
     return DRFLAC_TRUE;
 }
 
-
-
 static drflac_bool32 drflac__seek_to_byte(drflac_bs* bs, drflac_uint64 offsetFromStart)
 {
     /*
@@ -2289,26 +2232,29 @@ static drflac_result drflac__read_utf8_coded_number(drflac_bs* bs, drflac_uint64
     }
 
     /*byteCount = 1;*/
-    if ((utf8[0] & 0xE0) == 0xC0) {
+    if ((utf8[0] & 0xE0) == 0xC0)
         byteCount = 2;
-    } else if ((utf8[0] & 0xF0) == 0xE0) {
+    else if ((utf8[0] & 0xF0) == 0xE0)
         byteCount = 3;
-    } else if ((utf8[0] & 0xF8) == 0xF0) {
+    else if ((utf8[0] & 0xF8) == 0xF0)
         byteCount = 4;
-    } else if ((utf8[0] & 0xFC) == 0xF8) {
+    else if ((utf8[0] & 0xFC) == 0xF8)
         byteCount = 5;
-    } else if ((utf8[0] & 0xFE) == 0xFC) {
+    else if ((utf8[0] & 0xFE) == 0xFC)
         byteCount = 6;
-    } else if ((utf8[0] & 0xFF) == 0xFE) {
+    else if ((utf8[0] & 0xFF) == 0xFE)
         byteCount = 7;
-    } else {
+    else
+    {
         *pNumberOut = 0;
         return DRFLAC_CRC_MISMATCH;     /* Bad UTF-8 encoding. */
     }
 
     result = (drflac_uint64)(utf8[0] & (0xFF >> (byteCount + 1)));
-    for (i = 1; i < byteCount; ++i) {
-        if (!drflac__read_uint8(bs, 8, utf8 + i)) {
+    for (i = 1; i < byteCount; ++i)
+    {
+        if (!drflac__read_uint8(bs, 8, utf8 + i))
+        {
             *pNumberOut = 0;
             return DRFLAC_AT_END;
         }
@@ -4022,18 +3968,15 @@ static drflac_bool32 drflac__decode_samples_with_residual(drflac_bs* bs, drflac_
         }
 
         if (riceParam != 0xFF) {
-            if (!drflac__decode_samples_with_residual__rice(bs, bitsPerSample, samplesInPartition, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pDecodedSamples)) {
+            if (!drflac__decode_samples_with_residual__rice(bs, bitsPerSample, samplesInPartition, riceParam, lpcOrder, lpcShift, lpcPrecision, coefficients, pDecodedSamples))
                 return DRFLAC_FALSE;
-            }
         } else {
             drflac_uint8 unencodedBitsPerSample = 0;
-            if (!drflac__read_uint8(bs, 5, &unencodedBitsPerSample)) {
+            if (!drflac__read_uint8(bs, 5, &unencodedBitsPerSample))
                 return DRFLAC_FALSE;
-            }
 
-            if (!drflac__decode_samples_with_residual__unencoded(bs, bitsPerSample, samplesInPartition, unencodedBitsPerSample, lpcOrder, lpcShift, lpcPrecision, coefficients, pDecodedSamples)) {
+            if (!drflac__decode_samples_with_residual__unencoded(bs, bitsPerSample, samplesInPartition, unencodedBitsPerSample, lpcOrder, lpcShift, lpcPrecision, coefficients, pDecodedSamples))
                 return DRFLAC_FALSE;
-            }
         }
 
         pDecodedSamples += samplesInPartition;

deps/stb/stb_vorbis.h

@@ -1,6 +1,8 @@
 #ifndef STB_VORBIS_INCLUDE_STB_VORBIS_H
 #define STB_VORBIS_INCLUDE_STB_VORBIS_H
 
+#include <assert.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -11,6 +13,7 @@ typedef struct
    int   alloc_buffer_length_in_bytes;
 } stb_vorbis_alloc;
 
+
 /*   FUNCTIONS USEABLE WITH ALL INPUT MODES */
 
 typedef struct stb_vorbis stb_vorbis;
@@ -30,9 +33,19 @@ typedef struct
 /* get general information about the file */
 extern stb_vorbis_info stb_vorbis_get_info(stb_vorbis *f);
 
+/* get the last error detected (clears it, too) */
+extern int stb_vorbis_get_error(stb_vorbis *f);
+
 /* close an ogg vorbis file and free all memory in use */
 extern void stb_vorbis_close(stb_vorbis *f);
 
+/* this function returns the offset (in samples) from the beginning of the
+ * file that will be returned by the next decode, if it is known, or -1
+ * otherwise. after a flush_pushdata() call, this may take a while before
+ * it becomes valid again.
+ * NOT WORKING YET after a seek with PULLDATA API */
+extern int stb_vorbis_get_sample_offset(stb_vorbis *f);
+
 /* returns the current seek point within the file, or offset from the beginning
  * of the memory buffer. In pushdata mode it returns 0. */
 extern unsigned int stb_vorbis_get_file_offset(stb_vorbis *f);
@@ -51,6 +64,7 @@ extern stb_vorbis * stb_vorbis_open_memory(const unsigned char *data, int len,
 /* create an ogg vorbis decoder from an ogg vorbis stream in memory (note
  * this must be the entire stream!). on failure, returns NULL and sets *error */
 
+extern int stb_vorbis_seek_frame(stb_vorbis *f, unsigned int sample_number);
 extern int stb_vorbis_seek(stb_vorbis *f, unsigned int sample_number);
 /* NOT WORKING YET
  * these functions seek in the Vorbis file to (approximately) 'sample_number'.
@@ -65,6 +79,7 @@ extern void stb_vorbis_seek_start(stb_vorbis *f);
  * actually works */
 
 extern unsigned int stb_vorbis_stream_length_in_samples(stb_vorbis *f);
+extern float        stb_vorbis_stream_length_in_seconds(stb_vorbis *f);
 /* these functions return the total length of the vorbis stream */
 
 extern int stb_vorbis_get_frame_float(stb_vorbis *f, int *channels, float ***output);
@@ -79,6 +94,12 @@ extern int stb_vorbis_get_frame_float(stb_vorbis *f, int *channels, float ***out
  */
 
 extern int stb_vorbis_get_samples_float_interleaved(stb_vorbis *f, int channels, float *buffer, int num_floats);
+extern int stb_vorbis_get_samples_float(stb_vorbis *f, int channels, float **buffer, int num_samples);
+/* gets num_samples samples, not necessarily on a frame boundary--this requires
+ * buffering so you have to supply the buffers. DOES NOT APPLY THE COERCION RULES.
+ * Returns the number of samples stored per channel; it may be less than requested
+ * at the end of the file. If there are no more samples in the file, returns 0.
+ */
 
 /*   ERROR CODES */
 
@@ -123,6 +144,8 @@ enum STBVorbisError
 
 #endif /* STB_VORBIS_INCLUDE_STB_VORBIS_H */
 
+#ifndef STB_VORBIS_HEADER_ONLY
+
 /* global configuration settings (e.g. set these in the project/makefile),
  * or just set them in this file at the top (although ideally the first few
  * should be visible when the header file is compiled too, although it's not
@@ -156,7 +179,27 @@ enum STBVorbisError
  *     sets the log size of the binary-search acceleration table. this
  *     is used in similar fashion to the fast-huffman size to set initial
  *     parameters for the binary search
+
+ * STB_VORBIS_FAST_HUFFMAN_INT
+ *     The fast huffman tables are much more efficient if they can be
+ *     stored as 16-bit results instead of 32-bit results. This restricts
+ *     the codebooks to having only 65535 possible outcomes, though.
+ *     (At least, accelerated by the huffman table.)
  */
+#ifndef STB_VORBIS_FAST_HUFFMAN_INT
+#define STB_VORBIS_FAST_HUFFMAN_SHORT
+#endif
+
+/* STB_VORBIS_CODEBOOK_SHORTS
+ *     The vorbis file format encodes VQ codebook floats as ax+b where a and
+ *     b are floating point per-codebook constants, and x is a 16-bit int.
+ *     Normally, stb_vorbis decodes them to floats rather than leaving them
+ *     as 16-bit ints and computing ax+b while decoding. This is a speed/space
+ *     tradeoff; you can save space by defining this flag.
+ */
+#ifndef STB_VORBIS_CODEBOOK_SHORTS
+#define STB_VORBIS_CODEBOOK_FLOATS
+#endif
 
 #include <retro_inline.h>
 
@@ -168,7 +211,11 @@ enum STBVorbisError
 #define FALSE 0
 #endif
 
+#ifdef STB_VORBIS_CODEBOOK_FLOATS
 typedef float stb_vorbis_codetype;
+#else
+typedef uint16_t stb_vorbis_codetype;
+#endif
 
 /* @NOTE
  *
@@ -198,9 +245,13 @@ typedef struct
    uint8_t  sequence_p;
    uint8_t  sparse;
    uint32_t lookup_values;
-   float *multiplicands;
+   stb_vorbis_codetype *multiplicands;
    uint32_t *codewords;
-   int16_t  fast_huffman[FAST_HUFFMAN_TABLE_SIZE];
+   #ifdef STB_VORBIS_FAST_HUFFMAN_SHORT
+    int16_t  fast_huffman[FAST_HUFFMAN_TABLE_SIZE];
+   #else
+    int32_t  fast_huffman[FAST_HUFFMAN_TABLE_SIZE];
+   #endif
    uint32_t *sorted_codewords;
    int    *sorted_values;
    int     sorted_entries;
@@ -273,6 +324,15 @@ typedef struct
    uint16_t transformtype;
 } Mode;
 
+typedef struct
+{
+   uint32_t  goal_crc;    /* expected crc if match */
+   int     bytes_left;  /* bytes left in packet */
+   uint32_t  crc_so_far;  /* running crc */
+   int     bytes_done;  /* bytes processed in _current_ chunk */
+   uint32_t  sample_loc;  /* granule pos encoded in page */
+} CRCscan;
+
 typedef struct
 {
    uint32_t page_start, page_end;
@@ -283,7 +343,7 @@ typedef struct
 
 struct stb_vorbis
 {
-   /* user-accessible info */
+  /* user-accessible info */
    unsigned int sample_rate;
    int channels;
 
@@ -303,18 +363,18 @@ struct stb_vorbis
 
    ProbedPage p_first, p_last;
 
-   /* memory management */
+  /* memory management */
    stb_vorbis_alloc alloc;
    int setup_offset;
    int temp_offset;
 
-   /* run-time results */
+  /* run-time results */
    int eof;
    enum STBVorbisError error;
 
-   /* user-useful data */
+  /* user-useful data */
 
-   /* header info */
+  /* header info */
    int blocksize[2];
    int blocksize_0, blocksize_1;
    int codebook_count;
@@ -332,7 +392,7 @@ struct stb_vorbis
 
    uint32_t total_samples;
 
-   /* decode buffer */
+  /* decode buffer */
    float *channel_buffers[STB_VORBIS_MAX_CHANNELS];
    float *outputs        [STB_VORBIS_MAX_CHANNELS];
 
@@ -344,14 +404,14 @@ struct stb_vorbis
    uint32_t current_loc; /* sample location of next frame to decode */
    int    current_loc_valid;
 
-   /* per-blocksize precomputed data */
+  /* per-blocksize precomputed data */
 
    /* twiddle factors */
    float *A[2],*B[2],*C[2];
    float *window[2];
    uint16_t *bit_reverse[2];
 
-   /* current page/packet/segment streaming info */
+  /* current page/packet/segment streaming info */
    uint32_t serial; /* stream serial number for verification */
    int last_page;
    int segment_count;
@@ -370,11 +430,16 @@ struct stb_vorbis
    int discard_samples_deferred;
    uint32_t samples_output;
 
+  /* push mode scanning */
+   int page_crc_tests; /* only in push_mode: number of tests active; -1 if not searching */
+
   /* sample-access */
    int channel_buffer_start;
    int channel_buffer_end;
 };
 
+#define IS_PUSH_MODE(f)   FALSE
+
 typedef struct stb_vorbis vorb;
 
 static int error(vorb *f, enum STBVorbisError e)
@@ -558,8 +623,7 @@ static int compute_codewords(Codebook *c, uint8_t *len, int n, uint32_t *values)
    memset(available, 0, sizeof(available));
    /* find the first entry */
    for (k=0; k < n; ++k) if (len[k] < NO_CODE) break;
-   if (k == n)
-      return TRUE;
+   if (k == n) { assert(c->sorted_entries == 0); return TRUE; }
    /* add to the list */
    add_entry(c, 0, k, m++, len[k], values);
    /* add all available leaves */
@@ -580,16 +644,16 @@ static int compute_codewords(Codebook *c, uint8_t *len, int n, uint32_t *values)
        * trivial to prove, but it seems true and the assert never
        * fires, so! */
       while (z > 0 && !available[z]) --z;
-      if (z == 0)
-         return FALSE;
+      if (z == 0) { assert(0); return FALSE; }
       res = available[z];
       available[z] = 0;
       add_entry(c, bit_reverse(res), i, m++, len[i], values);
       /* propogate availability up the tree */
-      if (z != len[i])
-      {
-         for (y=len[i]; y > z; --y)
+      if (z != len[i]) {
+         for (y=len[i]; y > z; --y) {
+            assert(available[y] == 0);
             available[y] = res + (1 << (32-y));
+         }
       }
    }
    return TRUE;
@@ -604,7 +668,9 @@ static void compute_accelerated_huffman(Codebook *c)
       c->fast_huffman[i] = -1;
 
    len = c->sparse ? c->sorted_entries : c->entries;
+   #ifdef STB_VORBIS_FAST_HUFFMAN_SHORT
    if (len > 32767) len = 32767; /* largest possible value we can encode! */
+   #endif
    for (i=0; i < len; ++i) {
       if (c->codeword_lengths[i] <= STB_VORBIS_FAST_HUFFMAN_LENGTH) {
          uint32_t z = c->sparse ? bit_reverse(c->sorted_codewords[i]) : c->codewords[i];
@@ -632,12 +698,9 @@ static int STBV_CDECL uint32_t_compare(const void *p, const void *q)
 
 static int include_in_sort(Codebook *c, uint8_t len)
 {
-   if (c->sparse)
-      return TRUE;
-   if (len == NO_CODE)
-      return FALSE;
-   if (len > STB_VORBIS_FAST_HUFFMAN_LENGTH)
-      return TRUE;
+   if (c->sparse) { assert(len != NO_CODE); return TRUE; }
+   if (len == NO_CODE) return FALSE;
+   if (len > STB_VORBIS_FAST_HUFFMAN_LENGTH) return TRUE;
    return FALSE;
 }
 
@@ -655,9 +718,8 @@ static void compute_sorted_huffman(Codebook *c, uint8_t *lengths, uint32_t *valu
       for (i=0; i < c->entries; ++i)
          if (include_in_sort(c, lengths[i]))
             c->sorted_codewords[k++] = bit_reverse(c->codewords[i]);
-   }
-   else
-   {
+      assert(k == c->sorted_entries);
+   } else {
       for (i=0; i < c->sorted_entries; ++i)
          c->sorted_codewords[i] = bit_reverse(c->codewords[i]);
    }
@@ -679,21 +741,20 @@ static void compute_sorted_huffman(Codebook *c, uint8_t *lengths, uint32_t *valu
          while (n > 1) {
             /* invariant: sc[x] <= code < sc[x+n] */
             int m = x + (n >> 1);
-            if (c->sorted_codewords[m] <= code)
-            {
+            if (c->sorted_codewords[m] <= code) {
                x = m;
                n -= (n>>1);
-            }
-            else
+            } else {
                n >>= 1;
+            }
          }
-         if (c->sparse)
-         {
+         assert(c->sorted_codewords[x] == code);
+         if (c->sparse) {
             c->sorted_values[x] = values[i];
             c->codeword_lengths[x] = huff_len;
-         }
-         else
+         } else {
             c->sorted_values[x] = i;
+         }
       }
    }
 }
@@ -712,6 +773,8 @@ static int lookup1_values(int entries, int dim)
    int r = (int) floor(exp((float) log((float) entries) / dim));
    if ((int) floor(pow((float) r+1, dim)) <= entries)   /* (int) cast for MinGW warning; */
       ++r;                                              /* floor() to avoid _ftol() when non-CRT */
+   assert(pow((float) r+1, dim) > entries);
+   assert((int) floor(pow((float) r, dim)) <= entries); /* (int),floor() as above */
    return r;
 }
 
@@ -964,6 +1027,7 @@ static int next_segment(vorb *f)
    }
    if (f->next_seg >= f->segment_count)
       f->next_seg = -1;
+   assert(f->bytes_in_seg == 0);
    f->bytes_in_seg = len;
    return len;
 }
@@ -977,6 +1041,7 @@ static int get8_packet_raw(vorb *f)
       if (f->last_seg) return EOP;
       else if (!next_segment(f)) return EOP;
    }
+   assert(f->bytes_in_seg > 0);
    --f->bytes_in_seg;
    ++f->packet_bytes;
    return get8(f);
@@ -1057,25 +1122,23 @@ static int codebook_decode_scalar_raw(vorb *f, Codebook *c)
    int i;
    prep_huffman(f);
 
+   assert(c->sorted_codewords || c->codewords);
    /* cases to use binary search: sorted_codewords && !c->codewords
     *                             sorted_codewords && c->entries > 8 */
-   if (c->entries > 8 ? c->sorted_codewords!=NULL : !c->codewords)
-   {
+   if (c->entries > 8 ? c->sorted_codewords!=NULL : !c->codewords) {
       /* binary search */
       uint32_t code = bit_reverse(f->acc);
       int x=0, n=c->sorted_entries, len;
 
-      while (n > 1)
-      {
+      while (n > 1) {
          /* invariant: sc[x] <= code < sc[x+n] */
          int m = x + (n >> 1);
-         if (c->sorted_codewords[m] <= code)
-         {
+         if (c->sorted_codewords[m] <= code) {
             x = m;
             n -= (n>>1);
-         }
-         else
+         } else {
             n >>= 1;
+         }
       }
       /* x is now the sorted index */
       if (!c->sparse) x = c->sorted_values[x];
@@ -1092,14 +1155,11 @@ static int codebook_decode_scalar_raw(vorb *f, Codebook *c)
    }
 
    /* if small, linear search */
-   for (i=0; i < c->entries; ++i)
-   {
-      if (c->codeword_lengths[i] == NO_CODE)
-         continue;
-      if (c->codewords[i] == (f->acc & ((1 << c->codeword_lengths[i])-1)))
-      {
-         if (f->valid_bits >= c->codeword_lengths[i])
-         {
+   assert(!c->sparse);
+   for (i=0; i < c->entries; ++i) {
+      if (c->codeword_lengths[i] == NO_CODE) continue;
+      if (c->codewords[i] == (f->acc & ((1 << c->codeword_lengths[i])-1))) {
+         if (f->valid_bits >= c->codeword_lengths[i]) {
             f->acc >>= c->codeword_lengths[i];
             f->valid_bits -= c->codeword_lengths[i];
             return i;
@@ -1142,9 +1202,15 @@ static int codebook_decode_scalar(vorb *f, Codebook *c)
 
 /* CODEBOOK_ELEMENT_FAST is an optimization for the CODEBOOK_FLOATS case
  * where we avoid one addition */
-#define CODEBOOK_ELEMENT(c,off)          (c->multiplicands[off] * c->delta_value + c->minimum_value)
-#define CODEBOOK_ELEMENT_FAST(c,off)     (c->multiplicands[off] * c->delta_value)
-#define CODEBOOK_ELEMENT_BASE(c)         (c->minimum_value)
+#ifndef STB_VORBIS_CODEBOOK_FLOATS
+   #define CODEBOOK_ELEMENT(c,off)          (c->multiplicands[off] * c->delta_value + c->minimum_value)
+   #define CODEBOOK_ELEMENT_FAST(c,off)     (c->multiplicands[off] * c->delta_value)
+   #define CODEBOOK_ELEMENT_BASE(c)         (c->minimum_value)
+#else
+   #define CODEBOOK_ELEMENT(c,off)          (c->multiplicands[off])
+   #define CODEBOOK_ELEMENT_FAST(c,off)     (c->multiplicands[off])
+   #define CODEBOOK_ELEMENT_BASE(c)         (0)
+#endif
 
 static int codebook_decode_start(vorb *f, Codebook *c)
 {
@@ -1155,8 +1221,8 @@ static int codebook_decode_start(vorb *f, Codebook *c)
       error(f, VORBIS_invalid_stream);
    else {
       DECODE_VQ(z,f,c);
-      if (z < 0)
-      {  /* check for EOP */
+      if (c->sparse) assert(z < c->sorted_entries);
+      if (z < 0) {  /* check for EOP */
          if (!f->bytes_in_seg)
             if (f->last_seg)
                return z;
@@ -1219,6 +1285,7 @@ static int codebook_decode_deinterleave_repeat(vorb *f, Codebook *c, float **out
    while (total_decode > 0) {
       float last = CODEBOOK_ELEMENT_BASE(c);
       DECODE_VQ(z,f,c);
+      assert(!c->sparse || z < c->sorted_entries);
       if (z < 0) {
          if (!f->bytes_in_seg)
             if (f->last_seg) return FALSE;
@@ -1674,6 +1741,7 @@ static void imdct_step3_iter0_loop(int n, float *e, int i_off, int k_off, float
    float *ee2 = ee0 + k_off;
    int i;
 
+   assert((n & 3) == 0);
    for (i=(n>>2); i > 0; --i) {
       float k00_20, k01_21;
       k00_20  = ee0[ 0] - ee2[ 0];
@@ -2076,6 +2144,10 @@ static void inverse_mdct(float *buffer, int n, vorb *f, int blocktype)
    }
    /* (paper output is u, now v) */
 
+
+   /* data must be in buf2 */
+   assert(v == buf2);
+
    /* step 7   (paper output is v, now v)
     * this is now in place */
    {
@@ -2194,6 +2266,7 @@ static float *get_window(vorb *f, int len)
    len <<= 1;
    if (len == f->blocksize_0) return f->window[0];
    if (len == f->blocksize_1) return f->window[1];
+   assert(0);
    return NULL;
 }
 
@@ -2241,10 +2314,15 @@ static int vorbis_decode_initial(vorb *f, int *p_left_start, int *p_left_end, in
       return FALSE;
    /* check packet type */
    if (get_bits(f,1) != 0) {
+      if (IS_PUSH_MODE(f))
+         return error(f,VORBIS_bad_packet_type);
       while (EOP != get8_packet(f));
       goto retry;
    }
 
+   if (f->alloc.alloc_buffer)
+      assert(f->alloc.alloc_buffer_length_in_bytes == f->temp_offset);
+
    i = get_bits(f, ilog(f->mode_count-1));
    if (i == EOP) return FALSE;
    if (i >= f->mode_count) return FALSE;
@@ -2385,6 +2463,9 @@ static int vorbis_decode_packet_rest(vorb *f, int *len, Mode *m, int left_start,
    }
    /* at this point we've decoded all floors */
 
+   if (f->alloc.alloc_buffer)
+      assert(f->alloc.alloc_buffer_length_in_bytes == f->temp_offset);
+
    /* re-enable coupled channels if necessary */
    memcpy(really_zero_channel, zero_channel, sizeof(really_zero_channel[0]) * f->channels);
    for (i=0; i < map->coupling_steps; ++i)
@@ -2414,7 +2495,10 @@ static int vorbis_decode_packet_rest(vorb *f, int *len, Mode *m, int left_start,
       decode_residue(f, residue_buffers, ch, n2, r, do_not_decode);
    }
 
-   /* INVERSE COUPLING */
+   if (f->alloc.alloc_buffer)
+      assert(f->alloc.alloc_buffer_length_in_bytes == f->temp_offset);
+
+/* INVERSE COUPLING */
    for (i = map->coupling_steps-1; i >= 0; --i) {
       int n2 = n >> 1;
       float *m = f->channel_buffers[map->chan[i].magnitude];
@@ -2517,6 +2601,8 @@ static int vorbis_decode_packet_rest(vorb *f, int *len, Mode *m, int left_start,
    if (f->current_loc_valid)
       f->current_loc += (right_start - left_start);
 
+   if (f->alloc.alloc_buffer)
+      assert(f->alloc.alloc_buffer_length_in_bytes == f->temp_offset);
    *len = right_end;  /* ignore samples after the window goes to 0 */
    return TRUE;
 }
@@ -2580,6 +2666,13 @@ static int vorbis_finish_frame(stb_vorbis *f, int len, int left, int right)
    return right - left;
 }
 
+static void vorbis_pump_first_frame(stb_vorbis *f)
+{
+   int len, right, left;
+   if (vorbis_decode_packet(f, &len, &left, &right))
+      vorbis_finish_frame(f, len, left, right);
+}
+
 static int start_decoder(vorb *f)
 {
    uint8_t header[6], x,y;
@@ -2610,59 +2703,46 @@ static int start_decoder(vorb *f)
    get32(f); /* bitrate_nominal */
    get32(f); /* bitrate_minimum */
    x = get8(f);
-   {
-      int log0,log1;
-      log0 = x & 15;
-      log1 = x >> 4;
-      f->blocksize_0 = 1 << log0;
-      f->blocksize_1 = 1 << log1;
-      if (log0 < 6 || log0 > 13)
-         return error(f, VORBIS_invalid_setup);
-      if (log1 < 6 || log1 > 13)
-         return error(f, VORBIS_invalid_setup);
-      if (log0 > log1)
-         return error(f, VORBIS_invalid_setup);
+   { int log0,log1;
+   log0 = x & 15;
+   log1 = x >> 4;
+   f->blocksize_0 = 1 << log0;
+   f->blocksize_1 = 1 << log1;
+   if (log0 < 6 || log0 > 13)                       return error(f, VORBIS_invalid_setup);
+   if (log1 < 6 || log1 > 13)                       return error(f, VORBIS_invalid_setup);
+   if (log0 > log1)                                 return error(f, VORBIS_invalid_setup);
    }
 
    /* framing_flag */
    x = get8(f);
-   if (!(x & 1))
-      return error(f, VORBIS_invalid_first_page);
+   if (!(x & 1))                                    return error(f, VORBIS_invalid_first_page);
 
    /* second packet! */
-   if (!start_page(f))
-      return FALSE;
+   if (!start_page(f))                              return FALSE;
 
-   if (!start_packet(f))
-      return FALSE;
-   do
-   {
+   if (!start_packet(f))                            return FALSE;
+   do {
       len = next_segment(f);
       skip(f, len);
       f->bytes_in_seg = 0;
    } while (len);
 
    /* third packet! */
-   if (!start_packet(f))
-      return FALSE;
+   if (!start_packet(f))                            return FALSE;
 
    crc32_init(); /* always init it, to avoid multithread race conditions */
 
-   if (get8_packet(f) != VORBIS_packet_setup)
-      return error(f, VORBIS_invalid_setup);
+   if (get8_packet(f) != VORBIS_packet_setup)       return error(f, VORBIS_invalid_setup);
    for (i=0; i < 6; ++i) header[i] = get8_packet(f);
-   if (!vorbis_validate(header))
-      return error(f, VORBIS_invalid_setup);
+   if (!vorbis_validate(header))                    return error(f, VORBIS_invalid_setup);
 
    /* codebooks */
 
    f->codebook_count = get_bits(f,8) + 1;
    f->codebooks = (Codebook *) setup_malloc(f, sizeof(*f->codebooks) * f->codebook_count);
-   if (f->codebooks == NULL)
-      return error(f, VORBIS_outofmem);
+   if (f->codebooks == NULL)                        return error(f, VORBIS_outofmem);
    memset(f->codebooks, 0, sizeof(*f->codebooks) * f->codebook_count);
-   for (i=0; i < f->codebook_count; ++i)
-   {
+   for (i=0; i < f->codebook_count; ++i) {
       uint32_t *values;
       int ordered, sorted_count;
       int total=0;
@@ -2802,9 +2882,9 @@ static int start_decoder(vorb *f)
             /* pre-expand the lookup1-style multiplicands, to avoid a divide in the inner loop */
             if (sparse) {
                if (c->sorted_entries == 0) goto skip;
-               c->multiplicands = (float *) setup_malloc(f, sizeof(c->multiplicands[0]) * c->sorted_entries * c->dimensions);
+               c->multiplicands = (stb_vorbis_codetype *) setup_malloc(f, sizeof(c->multiplicands[0]) * c->sorted_entries * c->dimensions);
             } else
-               c->multiplicands = (float *) setup_malloc(f, sizeof(c->multiplicands[0]) * c->entries        * c->dimensions);
+               c->multiplicands = (stb_vorbis_codetype *) setup_malloc(f, sizeof(c->multiplicands[0]) * c->entries        * c->dimensions);
             if (c->multiplicands == NULL) { setup_temp_free(f,mults,sizeof(mults[0])*c->lookup_values); return error(f, VORBIS_outofmem); }
             len = sparse ? c->sorted_entries : c->entries;
             for (j=0; j < len; ++j) {
@@ -2812,7 +2892,15 @@ static int start_decoder(vorb *f)
                for (k=0; k < c->dimensions; ++k) {
                   int off = (z / div) % c->lookup_values;
                   c->multiplicands[j*c->dimensions + k] =
+                         #ifndef STB_VORBIS_CODEBOOK_FLOATS
+                            mults[off];
+                         #else
                             mults[off]*c->delta_value + c->minimum_value;
+                            /* in this case (and this case only) we could pre-expand c->sequence_p,
+                             * and throw away the decode logic for it; have to ALSO do
+                             * it in the case below, but it can only be done if
+                             *    STB_VORBIS_CODEBOOK_FLOATS     */
+                         #endif
                   div *= c->lookup_values;
                }
             }
@@ -2821,37 +2909,39 @@ static int start_decoder(vorb *f)
          }
          else
          {
-            c->multiplicands = (float *) setup_malloc(f, sizeof(c->multiplicands[0]) * c->lookup_values);
+            c->multiplicands = (stb_vorbis_codetype *) setup_malloc(f, sizeof(c->multiplicands[0]) * c->lookup_values);
+            #ifndef STB_VORBIS_CODEBOOK_FLOATS
+            memcpy(c->multiplicands, mults, sizeof(c->multiplicands[0]) * c->lookup_values);
+            #else
             for (j=0; j < (int) c->lookup_values; ++j)
                c->multiplicands[j] = mults[j] * c->delta_value + c->minimum_value;
+            #endif
             setup_temp_free(f, mults,sizeof(mults[0])*c->lookup_values);
          }
         skip:;
 
-         if (c->lookup_type == 2 && c->sequence_p)
-         {
+         #ifdef STB_VORBIS_CODEBOOK_FLOATS
+         if (c->lookup_type == 2 && c->sequence_p) {
             for (j=1; j < (int) c->lookup_values; ++j)
                c->multiplicands[j] = c->multiplicands[j-1];
             c->sequence_p = 0;
          }
+         #endif
       }
    }
 
    /* time domain transfers (notused) */
 
    x = get_bits(f, 6) + 1;
-   for (i=0; i < x; ++i)
-   {
+   for (i=0; i < x; ++i) {
       uint32_t z = get_bits(f, 16);
-      if (z != 0)
-         return error(f, VORBIS_invalid_setup);
+      if (z != 0) return error(f, VORBIS_invalid_setup);
    }
 
    /* Floors */
    f->floor_count = get_bits(f, 6)+1;
    f->floor_config = (Floor *)  setup_malloc(f, f->floor_count * sizeof(*f->floor_config));
-   for (i=0; i < f->floor_count; ++i)
-   {
+   for (i=0; i < f->floor_count; ++i) {
       f->floor_types[i] = get_bits(f, 16);
       if (f->floor_types[i] > 1) return error(f, VORBIS_invalid_setup);
       if (f->floor_types[i] == 0) {
@@ -2925,8 +3015,7 @@ static int start_decoder(vorb *f)
    /* Residue */
    f->residue_count = get_bits(f, 6)+1;
    f->residue_config = (Residue *) setup_malloc(f, f->residue_count * sizeof(*f->residue_config));
-   for (i=0; i < f->residue_count; ++i)
-   {
+   for (i=0; i < f->residue_count; ++i) {
       uint8_t residue_cascade[64];
       Residue *r = f->residue_config+i;
       f->residue_types[i] = get_bits(f, 16);
@@ -2972,8 +3061,7 @@ static int start_decoder(vorb *f)
 
    f->mapping_count = get_bits(f,6)+1;
    f->mapping = (Mapping *) setup_malloc(f, f->mapping_count * sizeof(*f->mapping));
-   for (i=0; i < f->mapping_count; ++i)
-   {
+   for (i=0; i < f->mapping_count; ++i) {
       Mapping *m = f->mapping + i;
       int mapping_type = get_bits(f,16);
       if (mapping_type != 0) return error(f, VORBIS_invalid_setup);
@@ -3019,8 +3107,7 @@ static int start_decoder(vorb *f)
 
    /* Modes */
    f->mode_count = get_bits(f, 6)+1;
-   for (i=0; i < f->mode_count; ++i)
-   {
+   for (i=0; i < f->mode_count; ++i) {
       Mode *m = f->mode_config+i;
       m->blockflag = get_bits(f,1);
       m->windowtype = get_bits(f,16);
@@ -3035,8 +3122,7 @@ static int start_decoder(vorb *f)
 
    f->previous_length = 0;
 
-   for (i=0; i < f->channels; ++i)
-   {
+   for (i=0; i < f->channels; ++i) {
       f->channel_buffers[i] = (float *) setup_malloc(f, sizeof(float) * f->blocksize_1);
       f->previous_window[i] = (float *) setup_malloc(f, sizeof(float) * f->blocksize_1/2);
       f->finalY[i]          = (int16_t *) setup_malloc(f, sizeof(int16_t) * longest_floorlist);
@@ -3070,8 +3156,8 @@ static int start_decoder(vorb *f)
 
    f->first_decode = TRUE;
 
-   if (f->alloc.alloc_buffer)
-   {
+   if (f->alloc.alloc_buffer) {
+      assert(f->temp_offset == f->alloc.alloc_buffer_length_in_bytes);
       /* check if there's enough temp memory so we don't error later */
       if (f->setup_offset + sizeof(*f) + f->temp_memory_required > (unsigned) f->temp_offset)
          return error(f, VORBIS_outofmem);
@@ -3145,6 +3231,14 @@ static void vorbis_init(stb_vorbis *p, stb_vorbis_alloc *z)
    p->error = VORBIS__no_error;
    p->stream = NULL;
    p->codebooks = NULL;
+   p->page_crc_tests = -1;
+}
+
+int stb_vorbis_get_sample_offset(stb_vorbis *f)
+{
+   if (f->current_loc_valid)
+      return f->current_loc;
+   return -1;
 }
 
 stb_vorbis_info stb_vorbis_get_info(stb_vorbis *f)
@@ -3159,6 +3253,13 @@ stb_vorbis_info stb_vorbis_get_info(stb_vorbis *f)
    return d;
 }
 
+int stb_vorbis_get_error(stb_vorbis *f)
+{
+   int e = f->error;
+   f->error = VORBIS__no_error;
+   return e;
+}
+
 static stb_vorbis * vorbis_alloc(stb_vorbis *f)
 {
    stb_vorbis *p = (stb_vorbis *) setup_malloc(f, sizeof(*p));
@@ -3275,6 +3376,7 @@ static int vorbis_analyze_page(stb_vorbis *f, ProbedPage *z)
 
    /* parse the header */
    getn(f, header, 27);
+   assert(header[0] == 'O' && header[1] == 'g' && header[2] == 'g' && header[3] == 'S');
    getn(f, lacing, header[26]);
 
    /* determine the length of the payload */
@@ -3379,12 +3481,12 @@ static int vorbis_analyze_page(stb_vorbis *f, ProbedPage *z)
    return 1;
 
    /* restore file state to where we were */
-bail:
+  bail:
    set_file_offset(f, z->page_start);
    return 0;
 }
 
-static int vorbis_seek_frame_from_page(stb_vorbis *f, uint32_t page_start, uint32_t first_sample, uint32_t target_sample)
+static int vorbis_seek_frame_from_page(stb_vorbis *f, uint32_t page_start, uint32_t first_sample, uint32_t target_sample, int fine)
 {
    int left_start, left_end, right_start, right_end, mode,i;
    int frame=0;
@@ -3453,6 +3555,7 @@ static int vorbis_seek_frame_from_page(stb_vorbis *f, uint32_t page_start, uint3
        * (which means frame-2+1 total frames) then decode frame-1,
        * then leave frame pending */
       frames_to_skip = frame - 1;
+      assert(frames_to_skip >= 0);
       data_to_skip = -1;
    }
 
@@ -3464,8 +3567,7 @@ static int vorbis_seek_frame_from_page(stb_vorbis *f, uint32_t page_start, uint3
       flush_packet(f);
    }
 
-   if (data_to_skip >= 0)
-   {
+   if (data_to_skip >= 0) {
       int i,j,n = f->blocksize_0 >> 1;
       f->discard_samples_deferred = data_to_skip;
       for (i=0; i < f->channels; ++i)
@@ -3473,22 +3575,19 @@ static int vorbis_seek_frame_from_page(stb_vorbis *f, uint32_t page_start, uint3
             f->previous_window[i][j] = 0;
       f->previous_length = n;
       frame_start += data_to_skip;
-   }
-   else
-   {
-      int len, right, left;
+   } else {
       f->previous_length = 0;
-      if (vorbis_decode_packet(f, &len, &left, &right))
-         vorbis_finish_frame(f, len, left, right);
+      vorbis_pump_first_frame(f);
    }
 
    /* at this point, the NEXT decoded frame will generate the desired sample */
-   {
+   if (fine) {
       /* so if we're doing sample accurate streaming, we want to go ahead and decode it! */
-      if (target_sample != frame_start)
-      {
+      if (target_sample != frame_start) {
          int n;
          stb_vorbis_get_frame_float(f, &n, NULL);
+         assert(target_sample > frame_start);
+         assert(f->channel_buffer_start + (int) (target_sample-frame_start) < f->channel_buffer_end);
          f->channel_buffer_start += (target_sample - frame_start);
       }
    }
@@ -3496,9 +3595,10 @@ static int vorbis_seek_frame_from_page(stb_vorbis *f, uint32_t page_start, uint3
    return 0;
 }
 
-int stb_vorbis_seek(stb_vorbis *f, unsigned int sample_number)
+static int vorbis_seek_base(stb_vorbis *f, unsigned int sample_number, int fine)
 {
    ProbedPage p[2],q;
+   if (IS_PUSH_MODE(f)) return error(f, VORBIS_invalid_api_mixing);
 
    /* do we know the location of the last page? */
    if (f->p_last.page_start == 0) {
@@ -3513,7 +3613,7 @@ int stb_vorbis_seek(stb_vorbis *f, unsigned int sample_number)
       sample_number = f->p_last.last_decoded_sample-1;
 
    if (sample_number < f->p_first.last_decoded_sample) {
-      vorbis_seek_frame_from_page(f, p[0].page_start, 0, sample_number);
+      vorbis_seek_frame_from_page(f, p[0].page_start, 0, sample_number, fine);
       return 0;
    } else {
       int attempts=0;
@@ -3573,22 +3673,31 @@ int stb_vorbis_seek(stb_vorbis *f, unsigned int sample_number)
       }
 
       if (p[0].last_decoded_sample <= sample_number && sample_number < p[1].last_decoded_sample) {
-         vorbis_seek_frame_from_page(f, p[1].page_start, p[0].last_decoded_sample, sample_number);
+         vorbis_seek_frame_from_page(f, p[1].page_start, p[0].last_decoded_sample, sample_number, fine);
          return 0;
       }
       return error(f, VORBIS_seek_failed);
    }
 }
 
+int stb_vorbis_seek_frame(stb_vorbis *f, unsigned int sample_number)
+{
+   return vorbis_seek_base(f, sample_number, FALSE);
+}
+
+int stb_vorbis_seek(stb_vorbis *f, unsigned int sample_number)
+{
+   return vorbis_seek_base(f, sample_number, TRUE);
+}
+
 void stb_vorbis_seek_start(stb_vorbis *f)
 {
-   int len, right, left;
+   if (IS_PUSH_MODE(f)) { error(f, VORBIS_invalid_api_mixing); return; }
    set_file_offset(f, f->first_audio_page_offset);
    f->previous_length = 0;
    f->first_decode = TRUE;
    f->next_seg = -1;
-   if (vorbis_decode_packet(f, &len, &left, &right))
-      vorbis_finish_frame(f, len, left, right);
+   vorbis_pump_first_frame(f);
 }
 
 unsigned int stb_vorbis_stream_length_in_samples(stb_vorbis *f)
@@ -3596,8 +3705,8 @@ unsigned int stb_vorbis_stream_length_in_samples(stb_vorbis *f)
    unsigned int restore_offset, previous_safe;
    unsigned int end, last_page_loc;
 
-   if (!f->total_samples)
-   {
+   if (IS_PUSH_MODE(f)) return error(f, VORBIS_invalid_api_mixing);
+   if (!f->total_samples) {
       unsigned int last;
       uint32_t lo,hi;
       char header[6];
@@ -3668,12 +3777,19 @@ unsigned int stb_vorbis_stream_length_in_samples(stb_vorbis *f)
    return f->total_samples == SAMPLE_unknown ? 0 : f->total_samples;
 }
 
+float stb_vorbis_stream_length_in_seconds(stb_vorbis *f)
+{
+   return stb_vorbis_stream_length_in_samples(f) / (float) f->sample_rate;
+}
+
+
+
 int stb_vorbis_get_frame_float(stb_vorbis *f, int *channels, float ***output)
 {
    int len, right,left,i;
+   if (IS_PUSH_MODE(f)) return error(f, VORBIS_invalid_api_mixing);
 
-   if (!vorbis_decode_packet(f, &len, &left, &right))
-   {
+   if (!vorbis_decode_packet(f, &len, &left, &right)) {
       f->channel_buffer_start = f->channel_buffer_end = 0;
       return 0;
    }
@@ -3700,15 +3816,11 @@ stb_vorbis * stb_vorbis_open_memory(const unsigned char *data, int len, int *err
    p.stream_start = (uint8_t *) p.stream;
    p.stream_len = len;
    p.push_mode = FALSE;
-   if (start_decoder(&p))
-   {
+   if (start_decoder(&p)) {
       f = vorbis_alloc(&p);
-      if (f)
-      {
-         int len, right, left;
+      if (f) {
          *f = p;
-         if (vorbis_decode_packet(f, &len, &left, &right))
-            vorbis_finish_frame(f, len, left, right);
+         vorbis_pump_first_frame(f);
          return f;
       }
    }
@@ -3743,3 +3855,31 @@ int stb_vorbis_get_samples_float_interleaved(stb_vorbis *f, int channels, float
    }
    return n;
 }
+
+int stb_vorbis_get_samples_float(stb_vorbis *f, int channels, float **buffer, int num_samples)
+{
+   float **outputs;
+   int n=0;
+   int z = f->channels;
+   if (z > channels) z = channels;
+   while (n < num_samples) {
+      int i;
+      int k = f->channel_buffer_end - f->channel_buffer_start;
+      if (n+k >= num_samples) k = num_samples - n;
+      if (k) {
+         for (i=0; i < z; ++i)
+            memcpy(buffer[i]+n, f->channel_buffers[i]+f->channel_buffer_start, sizeof(float)*k);
+         for (   ; i < channels; ++i)
+            memset(buffer[i]+n, 0, sizeof(float) * k);
+      }
+      n += k;
+      f->channel_buffer_start += k;
+      if (n == num_samples)
+         break;
+      if (!stb_vorbis_get_frame_float(f, NULL, &outputs))
+         break;
+   }
+   return n;
+}
+
+#endif /* STB_VORBIS_HEADER_ONLY */

frontend/drivers/platform_darwin.m

@@ -373,7 +373,7 @@ static void frontend_darwin_get_env(int *argc, char *argv[],
    }
 #endif
    if (portable)
-      strncpy(documents_dir_buf, application_data, sizeof(documents_dir_buf));
+      strlcpy(documents_dir_buf, application_data, sizeof(documents_dir_buf));
    else
    {
       CFSearchPathForDirectoriesInDomains(documents_dir_buf, sizeof(documents_dir_buf));
@@ -385,7 +385,7 @@ static void frontend_darwin_get_env(int *argc, char *argv[],
    path_resolve_realpath(documents_dir_buf, sizeof(documents_dir_buf), true);
    strlcat(documents_dir_buf, "/RetroArch", sizeof(documents_dir_buf));
    /* iOS and tvOS are going to put everything in the documents dir */
-   strncpy(application_data, documents_dir_buf, sizeof(application_data));
+   strlcpy(application_data, documents_dir_buf, sizeof(application_data));
 #endif
 
    /* By the time we are here:

gfx/widgets/gfx_widget_leaderboard_display.c

@@ -458,7 +458,8 @@ void gfx_widgets_set_leaderboard_display(unsigned id, const char* value)
          if (i == state->tracker_count)
             state->tracker_info[state->tracker_count++].id = id;
 
-         strncpy(state->tracker_info[i].display, value, sizeof(state->tracker_info[i].display));
+         strlcpy(state->tracker_info[i].display, value,
+               sizeof(state->tracker_info[i].display));
 
          {
             unsigned width = CHEEVO_LBOARD_DISPLAY_PADDING * 2;

input/bsv/bsvmovie.c

@@ -17,6 +17,7 @@
 
 #include "bsvmovie.h"
 #include <retro_endianness.h>
+#include <stdint.h>
 #include "../input_driver.h"
 #include "../../retroarch.h"
 #include "../../state_manager.h"
@@ -144,7 +145,8 @@ static bool bsv_movie_peek_frame_info(bsv_movie_t *movie, uint8_t *token, uint64
          if (intfstream_read(movie->file, &(state_length), sizeof(uint64_t)) != sizeof(uint64_t))
             goto end;
          state_length = swap_if_big64(state_length);
-         ret = intfstream_seek(movie->file, state_length, SEEK_CUR) >= 0;
+         if (intfstream_seek(movie->file, state_length, SEEK_CUR) < 0)
+            goto end;
       }
       else if (tok == REPLAY_TOKEN_CHECKPOINT2_FRAME)
       {
@@ -156,7 +158,8 @@ static bool bsv_movie_peek_frame_info(bsv_movie_t *movie, uint8_t *token, uint64
          if (intfstream_read(movie->file, &(state_length), sizeof(uint32_t)) != sizeof(uint32_t))
             goto end;
          /* Seek past the state data */
-         ret = intfstream_seek(movie->file, state_length, SEEK_CUR) >= 0;
+         if (intfstream_seek(movie->file, state_length, SEEK_CUR) < 0)
+            goto end;
       }
       /* We are already at the end of the frame */
       else if (tok == REPLAY_TOKEN_REGULAR_FRAME) { }
@@ -668,7 +671,7 @@ int64_t bsv_movie_write_checkpoint(bsv_movie_t *handle, uint8_t compression, uin
    uint8_t *swap;
    size_t size_swap;
    int64_t ret = -1;
-   uint32_t encoded_size, compressed_encoded_size, size_;
+   uint32_t encoded_size = 0, compressed_encoded_size, size_ = 0;
    uint8_t *encoded_data = NULL, *compressed_encoded_data = NULL;
    bool owns_encoded = false, owns_compressed_encoded = false;
    retro_ctx_serialize_info_t serial_info;
@@ -689,15 +692,17 @@ int64_t bsv_movie_write_checkpoint(bsv_movie_t *handle, uint8_t compression, uin
    switch (encoding)
    {
       case REPLAY_CHECKPOINT2_ENCODING_RAW:
-         encoded_size = serial_info.size;
+         /* If serial_info.size > uint32 max, we have bigger problems on our hands */
+         encoded_size = (uint32_t)serial_info.size;
          encoded_data = (uint8_t*)serial_info.data;
          break;
 #ifdef HAVE_STATESTREAM
       case REPLAY_CHECKPOINT2_ENCODING_STATESTREAM:
-         encoded_size = serial_info.size + serial_info.size / 2;
+         /* encoded size estimate or actual encoded state size should not exceed uint32 max */
+         encoded_size = (uint32_t)(serial_info.size + serial_info.size / 2);
          encoded_data = (uint8_t*)malloc(encoded_size);
          owns_encoded = true;
-         encoded_size = bsv_movie_write_deduped_state(handle, (uint8_t*)serial_info.data,
+         encoded_size = (uint32_t)bsv_movie_write_deduped_state(handle, (uint8_t*)serial_info.data,
                serial_info.size, encoded_data, encoded_size);
          break;
 #endif
@@ -723,23 +728,24 @@ int64_t bsv_movie_write_checkpoint(bsv_movie_t *handle, uint8_t compression, uin
             ret = -1;
             goto exit;
          }
-         compressed_encoded_size = zlib_compressed_encoded_size;
+         compressed_encoded_size = (uint32_t)zlib_compressed_encoded_size;
          break;
       }
 #endif
 #ifdef HAVE_ZSTD
       case REPLAY_CHECKPOINT2_COMPRESSION_ZSTD:
       {
-         size_t compressed_encoded_size_big = ZSTD_compressBound(encoded_size);
-         compressed_encoded_data = (uint8_t*)calloc(compressed_encoded_size_big, sizeof(uint8_t));
+         size_t compressed_encoded_size_zstd = ZSTD_compressBound(encoded_size);
+         compressed_encoded_data = (uint8_t*)calloc(compressed_encoded_size_zstd, sizeof(uint8_t));
          owns_compressed_encoded = true;
-         compressed_encoded_size_big = ZSTD_compress(compressed_encoded_data, compressed_encoded_size_big, encoded_data, encoded_size, 3);
-         if (ZSTD_isError(compressed_encoded_size_big))
+         compressed_encoded_size_zstd = ZSTD_compress(compressed_encoded_data, compressed_encoded_size_zstd, encoded_data, encoded_size, 3);
+         if (ZSTD_isError(compressed_encoded_size_zstd))
          {
             ret = -1;
             goto exit;
          }
-         compressed_encoded_size = compressed_encoded_size_big;
+         /* Have to cast after checking the error flags, not before */
+         compressed_encoded_size = (uint32_t)compressed_encoded_size_zstd;
          break;
       }
 #endif
@@ -749,7 +755,7 @@ int64_t bsv_movie_write_checkpoint(bsv_movie_t *handle, uint8_t compression, uin
          goto exit;
    }
    /* uncompressed, unencoded size */
-   size_ = swap_if_big32(serial_info.size);
+   size_ = swap_if_big32((uint32_t)serial_info.size);
    if (intfstream_write(handle->file, &size_, sizeof(uint32_t)) < (int64_t)sizeof(uint32_t))
    {
       ret = -1;
@@ -1127,7 +1133,12 @@ bool replay_get_serialized_data(void* buffer)
       buf                     = ((uint8_t *)buffer) + sizeof(uint32_t);
       intfstream_rewind(handle->file);
       read_amt                = intfstream_read(handle->file, buf, file_end);
-      ((uint32_t *)buffer)[1+REPLAY_HEADER_FRAME_COUNT_INDEX] = swap_if_big32(handle->frame_counter);
+      if (handle->frame_counter > UINT32_MAX) {
+         RARCH_ERR("[Replay] Frame counter too big to fit in 32 bits\n");
+         return false;
+      }
+      /* Bounds checked above, this cast is safe */
+      ((uint32_t *)buffer)[1+REPLAY_HEADER_FRAME_COUNT_INDEX] = swap_if_big32((uint32_t)(handle->frame_counter));
       if (read_amt != file_end)
          RARCH_ERR("[Replay] Failed to write correct number of replay bytes into state file: %d / %d.\n",
                read_amt, file_end);
@@ -1199,11 +1210,13 @@ bool replay_check_same_timeline(bsv_movie_t *movie,
          intfstream_seek(movie->file, sizeof(uint32_t), SEEK_CUR);
          intfstream_seek(check_stream, sizeof(uint32_t), SEEK_CUR);
       }
+      keycount1 = UINT8_MAX;
+      keycount2 = UINT8_MAX;
       if (intfstream_read(movie->file, &keycount1, 1) < 1 ||
             intfstream_read(check_stream, &keycount2, 1) < 1 ||
             keycount1 != keycount2)
       {
-         RARCH_ERR("[Replay] Replay checkpoints disagree on key count, %d vs %d\n", keycount1, keycount2);
+         RARCH_ERR("[Replay] Replay checkpoints disagree on key count, %d vs %d (255 means read error)\n", keycount1, keycount2);
          ret = false;
          goto exit;
       }
@@ -1585,7 +1598,8 @@ int64_t bsv_movie_write_deduped_state(bsv_movie_t *movie, uint8_t *state,
             /* write "here is a new block" and new block to file */
             rmsgpack_write_int(out_stream, BSV_IFRAME_NEW_BLOCK_TOKEN);
             rmsgpack_write_int(out_stream, found_block.index);
-            rmsgpack_write_bin(out_stream, state+block_start, block_byte_size);
+            /* Cast is fine, a single block can't be super big */
+            rmsgpack_write_bin(out_stream, state+block_start, (uint32_t)block_byte_size);
          }
          else
             reused_blocks++;
@@ -1597,7 +1611,8 @@ int64_t bsv_movie_write_deduped_state(bsv_movie_t *movie, uint8_t *state,
          /* write "here is a new superblock" and new superblock to file */
          rmsgpack_write_int(out_stream, BSV_IFRAME_NEW_SUPERBLOCK_TOKEN);
          rmsgpack_write_int(out_stream, found_block.index);
-         rmsgpack_write_array_header(out_stream, superblock_size);
+         /* Cast is fine, a single superblock can't be billions of blocks long */
+         rmsgpack_write_array_header(out_stream, (uint32_t)superblock_size);
          for (i = 0; i < superblock_size; i++)
             rmsgpack_write_int(out_stream, superblock_buf[i]);
       }
@@ -1610,7 +1625,8 @@ int64_t bsv_movie_write_deduped_state(bsv_movie_t *movie, uint8_t *state,
    /* uint32s_index_commit(movie->superblocks); */
    /* write "here is the superblock seq" and superblock seq to file */
    rmsgpack_write_int(out_stream, BSV_IFRAME_SUPERBLOCK_SEQ_TOKEN);
-   rmsgpack_write_array_header(out_stream, superblock_count);
+   /* Cast is fine, we won't have billions of superblocks */
+   rmsgpack_write_array_header(out_stream, (uint32_t)superblock_count);
    for (i = 0; i < superblock_count; i++)
        rmsgpack_write_int(out_stream, movie->superblock_seq[i]);
    free(superblock_buf);
@@ -1647,6 +1663,10 @@ bool bsv_movie_read_deduped_state(bsv_movie_t *movie, uint8_t *encoded, size_t e
       free(movie->superblock_seq);
       movie->superblock_seq = NULL;
    }
+   if (!movie->cur_save) {
+      RARCH_ERR("[STATESTREAM] movie has no current serialized save\n");
+      goto exit;
+   }
    total_decode_count++;
    rmsgpack_dom_read_with(read_mem, &item, reader_state);
    if (item.type != RDT_INT && item.type != RDT_UINT)
@@ -1684,7 +1704,8 @@ bool bsv_movie_read_deduped_state(bsv_movie_t *movie, uint8_t *encoded, size_t e
                RARCH_ERR("[STATESTREAM] new block index type is wrong\n");
                goto exit;
             }
-            index = item.val.uint_;
+            /* Block indexes must be 32bit */
+            index = (uint32_t)item.val.uint_;
             rmsgpack_dom_read_with(read_mem, &item, reader_state);
             if (item.type != RDT_BINARY)
             {
@@ -1715,7 +1736,8 @@ bool bsv_movie_read_deduped_state(bsv_movie_t *movie, uint8_t *encoded, size_t e
                RARCH_ERR("[STATESTREAM] new superblock index type is wrong\n");
                goto exit;
             }
-            index = item.val.uint_;
+            /* Block indices are 32-bit */
+            index = (uint32_t)item.val.uint_;
             if (rmsgpack_dom_read_with(read_mem, &item, reader_state) < 0)
             {
                RARCH_ERR("[STATESTREAM] array read failed\n");
@@ -1738,7 +1760,8 @@ bool bsv_movie_read_deduped_state(bsv_movie_t *movie, uint8_t *encoded, size_t e
             {
                struct rmsgpack_dom_value inner_item = item.val.array.items[i];
                /* assert(inner_item.type == RDT_INT || inner_item.type == RDT_UINT); */
-               superblock[i] = inner_item.val.uint_;
+               /* Superblock indices are 32-bit */
+               superblock[i] = (uint32_t)inner_item.val.uint_;
             }
             if (!uint32s_index_insert_exact(movie->superblocks, index, superblock, movie->frame_counter))
             {
@@ -1766,7 +1789,8 @@ bool bsv_movie_read_deduped_state(bsv_movie_t *movie, uint8_t *encoded, size_t e
                uint32_t *superblock;
                struct rmsgpack_dom_value inner_item = item.val.array.items[i];
                /* assert(inner_item.type == RDT_INT || inner_item.type == RDT_UINT); */
-               uint32_t superblock_idx = inner_item.val.uint_;
+               /* Superblock indices are 32-bit */
+               uint32_t superblock_idx = (uint32_t)inner_item.val.uint_;
                /* if this superblock is the same as last time, no need to scan the blocks. */
                if (movie->cur_save_valid && movie->cur_save && superblock_idx == movie->superblock_seq[i])
                {

input/bsv/uint32s_index.c

@@ -25,7 +25,7 @@
 #define XXH_INLINE_ALL
 #include <xxHash/xxhash.h>
 
-#define HASHMAP_CAP (1 << 16)
+#define HASHMAP_CAP 65536
 #define uint32s_hash_bytes(bytes, len) XXH32(bytes,len,0)
 
 uint32s_index_t *uint32s_index_new(size_t object_size,
@@ -283,11 +283,16 @@ void uint32s_index_pop(uint32s_index_t *index)
    uint32_t idx  = RBUF_LEN(index->objects)-1;
    uint32_t hash = index->hashes[idx];
    struct uint32s_bucket *bucket = RHMAP_PTR(index->index, hash);
+   uint32_t old_len = bucket->len;
+   if (old_len == 0) {
+      RARCH_ERR("[STATESTREAM] trying to pop from empty bucket\n");
+      return;
+   }
    RBUF_RESIZE(index->objects, idx);
    RBUF_RESIZE(index->counts, idx);
    RBUF_RESIZE(index->hashes, idx);
    uint32s_bucket_remove(bucket, idx);
-   if (bucket->len == 0)
+   if (old_len - 1 == 0)
    {
       uint32s_bucket_free(bucket);
       if (!RHMAP_DEL(index->index, hash))

input/drivers/android_input.c

@@ -915,7 +915,17 @@ static INLINE void android_input_poll_event_type_key(
 {
    uint8_t *buf = android_key_state[port];
    int action   = AKeyEvent_getAction(event);
+   int keysym   = keycode;
 
+   /* Handle 'duplicate' inputs that correspond
+    * to the same RETROK_* key */
+   switch (keycode)
+   {
+      case AKEYCODE_DPAD_CENTER:
+         keysym = AKEYCODE_ENTER;
+      default:
+         break;
+   }
    /* some controllers send both the up and down events at once
     * when the button is released for "special" buttons, like menu buttons
     * work around that by only using down events for meta keys (which get
@@ -924,10 +934,10 @@ static INLINE void android_input_poll_event_type_key(
    switch (action)
    {
       case AKEY_EVENT_ACTION_UP:
-         BIT_CLEAR(buf, keycode);
+         BIT_CLEAR(buf, keysym);
          break;
       case AKEY_EVENT_ACTION_DOWN:
-         BIT_SET(buf, keycode);
+         BIT_SET(buf, keysym);
          break;
    }
 

input/input_keymaps.c

@@ -1395,7 +1395,7 @@ const struct rarch_key_map rarch_key_map_android[] = {
    { AKEYCODE_TAB, RETROK_TAB },
    { AKEYCODE_CLEAR, RETROK_CLEAR },
    { AKEYCODE_ENTER, RETROK_RETURN },
-   { AKEYCODE_DPAD_CENTER, RETROK_RETURN },
+/*   { AKEYCODE_DPAD_CENTER, RETROK_RETURN }, */ /* Duplicate - skip */
    { AKEYCODE_BREAK, RETROK_PAUSE },
    { AKEYCODE_ESCAPE, RETROK_ESCAPE },
    { AKEYCODE_SPACE, RETROK_SPACE },

intl/msg_hash_ar.h

@@ -1296,6 +1296,14 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "إذا تم التعطيل، سيتم نقل الملفات إلى مجلد النسخ الاحتياطي قبل الحذف أو الاستبدال."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_AUTOMATIC,
+   "تلقائي"
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "يدوي"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
    "خدمة المزامنة السحابية"

intl/msg_hash_be.h

@@ -1316,6 +1316,14 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "Калі адключана, файлы будуць перасунутыя ў тэчку рэзервовай копіі перад іх перазапісам ці выдаленнем."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_AUTOMATIC,
+   "Аўтаматычная"
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "Уручную"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
    "Бэкенд воблачнай сінхранізацыі"

intl/msg_hash_ca.h

@@ -217,6 +217,14 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_QUIT_RETROARCH,
    "Tanca el RetroArch. La configuració es desarà en sortir."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_NOW,
+   "Sincronitza ara"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_NOW,
+   "Activa manual la sincronització al núvol."
+   )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_QUIT_RETROARCH_NOSAVE,
    "Tanca el RetroArch. La configuració no es desarà en sortir."
@@ -1316,6 +1324,18 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "En desactivar-ho, els fitxers es mouen a una carpeta de còpia de seguretat abans de sobreescriure's o eliminar-se."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE,
+   "Mode de sincronització"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_MODE,
+   "Automàtic: Sincronitza RetroArch a l'inici, abans que es carreguin els nuclis. Manual: Només se sincronitza si es clica el botó 'Sincronitza ara'."
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_AUTOMATIC,
+   "Automàtic"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
    "Rerefons de la sincronització al núvol"
@@ -5051,7 +5071,7 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_CORE_SUGGEST_ALWAYS,
-   "Suggereix tots els nuclis disponibles quan es carrega un nucli."
+   "Suggereix tots els nuclis disponibles quen es carrega un nucli manualment."
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_USE_BUILTIN_PLAYER,

intl/msg_hash_chs.h

@@ -1332,6 +1332,14 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "禁用后，文件会在被覆盖或删除之前移至备份文件夹。"
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_AUTOMATIC,
+   "自动"
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "手动"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
    "云同步后端"
@@ -5081,10 +5089,6 @@ MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CORE_SUGGEST_ALWAYS,
    "始终建议核心"
    )
-MSG_HASH(
-   MENU_ENUM_SUBLABEL_CORE_SUGGEST_ALWAYS,
-   "即使已加载某个核心，仍显示所有可用的核心建议。"
-   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_USE_BUILTIN_PLAYER,
    "使用内建媒体播放器"

intl/msg_hash_cht.h

@@ -1228,6 +1228,14 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "關閉時檔案將會在覆寫或刪除前移動到備份資料夾。"
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_AUTOMATIC,
+   "白框線 (Automatic)"
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "手動"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
    "雲端同步後端"

intl/msg_hash_cs.h

@@ -1260,6 +1260,14 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "Pokud je tato funkce vypnuta, jsou soubory před přepsáním nebo odstraněním přesunuty do záložní složky."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_AUTOMATIC,
+   "Automatické"
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "Ruční"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
    "Backend cloudové synchronizace"

intl/msg_hash_de.h

@@ -1260,6 +1260,14 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "Wenn deaktiviert, werden die Dateien in einen Sicherungsordner verschoben, bevor sie überschrieben oder gelöscht werden."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_AUTOMATIC,
+   "Automatisch"
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "Manuell"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
    "Cloud-Sync-Backend"
@@ -4955,7 +4963,7 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_CORE_SUGGEST_ALWAYS,
-   "Verfügbare Cores vorschlagen, auch wenn bereits ein Core geladen ist."
+   "Verfügbare Cores auch dann vorschlagen, wenn ein Core manuell geladen wird."
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_USE_BUILTIN_PLAYER,

intl/msg_hash_el.h

@@ -1336,6 +1336,10 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "Όταν απενεργοποιηθεί, τα αρχεία μετακινούνται σε ένα φάκελο αντιγράφων ασφαλείας πριν αντικατασταθούν ή διαγραφούν."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "Χειροκίνητο"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
    "Σύστημα υποστήριξης συγχρονισμού cloud"

intl/msg_hash_es.h

@@ -217,6 +217,14 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_QUIT_RETROARCH,
    "Abandona la aplicación RetroArch. La opción «Guardar configuración al salir» está activada."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_NOW,
+   "Sincronizar ahora"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_NOW,
+   "Inicia manualmente la sincronización en la nube."
+   )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_QUIT_RETROARCH_NOSAVE,
    "Abandona la aplicación RetroArch. La opción «Guardar configuración al salir» está desactivada."
@@ -1320,6 +1328,18 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "Al desactivar esta opción, los archivos serán trasladados a una carpeta de copia de seguridad antes de ser sobrescritos o eliminados."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE,
+   "Modo de sincronización"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_MODE,
+   "Automático: inicia la sincronización al ejecutar RetroArch y al descargar un núcleo. Manual: inicia la sincronización solo al seleccionar la opción Sincronizar ahora."
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_AUTOMATIC,
+   "Automático"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
    "Servicio de sincronización en la nube"
@@ -5063,7 +5083,7 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_CORE_SUGGEST_ALWAYS,
-   "Sugiere los núcleos disponibles, aunque haya otro ya cargado."
+   "Sugiere los núcleos disponibles, aunque haya otro cargado manualmente."
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_USE_BUILTIN_PLAYER,

intl/msg_hash_fa.h

@@ -1176,6 +1176,10 @@ MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DESTRUCTIVE,
    "همگام‌سازی ابری تخریبی"
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "دستی"
+   )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DRIVER,
    "شیوه‌نامهٔ شبکهٔ فضای ابری که باید استفاده شود."

intl/msg_hash_fi.h

@@ -1288,6 +1288,14 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "Kun pois käytöstä, tiedostot siirretään varmuuskopio-kansioon, ennen kuin niitä korvataan tai poistetaan."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_AUTOMATIC,
+   "Automaattinen"
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "Manuaalinen"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
    "Pilvisynkronoinnin taustaosa"
@@ -4225,10 +4233,6 @@ MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CORE_SUGGEST_ALWAYS,
    "Ehdota aina ytimiä"
    )
-MSG_HASH(
-   MENU_ENUM_SUBLABEL_CORE_SUGGEST_ALWAYS,
-   "Ehdota saatavilla olevia ytimiä silloinkin, kun ydin on jo ladattu."
-   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_USE_BUILTIN_PLAYER,
    "Käytä sisäänrakennettua mediasoitinta"

intl/msg_hash_fr.h

@@ -213,6 +213,14 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_QUIT_RETROARCH,
    "Quitter l'application RetroArch. L'enregistrement de la configuration à la sortie est activé."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_NOW,
+   "Synchroniser maintenant"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_NOW,
+   "Déclencher manuellement la synchronisation avec le cloud."
+   )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_QUIT_RETROARCH_NOSAVE,
    "Quitter l'application RetroArch. L'enregistrement de la configuration à la sortie est désactivé."
@@ -1296,6 +1304,22 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "Lorsque cette option est désactivée, les fichiers sont déplacés vers un dossier de sauvegarde avant d'être remplacés ou supprimés."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE,
+   "Mode de synchronisation"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_MODE,
+   "Automatique : Synchronisation au démarrage de RetroArch et lorsque les cœurs sont déchargés. Manuel : Synchronisation uniquement lorsque le bouton 'Synchroniser maintenant' est déclenché manuellement."
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_AUTOMATIC,
+   "Automatique"
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "Manuel"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
    "Plateforme de synchronisation avec le Cloud"
@@ -5023,7 +5047,7 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_CORE_SUGGEST_ALWAYS,
-   "Suggérer des cœurs disponibles même lorsqu'un cœur est déjà chargé."
+   "Suggérer des cœurs disponibles même lorsqu'un cœur est chargé manuellement."
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_USE_BUILTIN_PLAYER,

intl/msg_hash_ga.h

@@ -209,6 +209,14 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_QUIT_RETROARCH,
    "Scoir feidhmchlár RetroArch. Tá sábháil chumraíochta ar scor cumasaithe."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_NOW,
+   "Sioncrónaigh Anois"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_NOW,
+   "Spreag sioncrónú scamall de láimh."
+   )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_QUIT_RETROARCH_NOSAVE,
    "Scoir feidhmchlár RetroArch. Tá sábháil chumraíochta ar scor díchumasaithe. Scoir feidhmchlár RetroArch. Tá sábháil chumraíochta ar scor díchumasaithe."
@@ -1320,6 +1328,22 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "Nuair a bhíonn sé díchumasaithe, bogtar comhaid chuig fillteán cúltaca sula ndéantar iad a athscríobh nó a scriosadh."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE,
+   "Mód Sioncrónaithe"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_MODE,
+   "Uathoibríoch: Sioncrónaigh ar thosú RetroArch agus nuair a dhíluchtaítear croíleacáin. Lámhleabhar: Sioncrónaigh ach amháin nuair a chuirtear an cnaipe 'Sioncrónaigh Anois' i ngníomh de láimh."
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_AUTOMATIC,
+   "Uathoibríoch"
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "Lámhleabhar"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
    "Cúltaca Sioncrónaithe Cloud"
@@ -5063,7 +5087,7 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_CORE_SUGGEST_ALWAYS,
-   "Mol croíthe atá ar fáil fiú nuair atá croí luchtaithe cheana féin."
+   "Mol croíleacáin atá ar fáil fiú nuair a luchtaítear croí de láimh."
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_USE_BUILTIN_PLAYER,

intl/msg_hash_gl.h

@@ -1320,6 +1320,10 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "Cando está desactivado, os ficheiros móvense a un cartafol de copia de seguranza antes de sobrescribilos ou eliminalos."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_AUTOMATIC,
+   "Automático"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
    "Infraestrutura (backend) de sincronización na nube"
@@ -5001,10 +5005,6 @@ MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CORE_SUGGEST_ALWAYS,
    "Suxerir sempre núcleos"
    )
-MSG_HASH(
-   MENU_ENUM_SUBLABEL_CORE_SUGGEST_ALWAYS,
-   "Suxerir núcleos dispoñibles incluso cando xa hai un núcleo cargado."
-   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_USE_BUILTIN_PLAYER,
    "Usa o reprodutor multimedia integrado"

intl/msg_hash_he.h

@@ -71,6 +71,14 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CORE_LIST,
    "בחרו באיזו ליבה להשתמש."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CORE_LIST_UNLOAD,
+   "פריקת ליבה"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_CORE_LIST_UNLOAD,
+   "שחרור הליבה הטעונה."
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_HELP_CORE_LIST,
    "עיון אחר ליבה עבור הטמעת ליבת libretro. היכן העיון מתחיל תלוי בנתיב הליבה שלך. אם ריק, העיון יתחיל בנתיב הראשי.\nאם נתיב הליבה הוא תיקייה, התפריט ישתמש בה כתיקיית על. אם נתיב ליבה הוא נתיב מלא, העיון יתחיל בתיקייה שבה הקובץ."

intl/msg_hash_hu.h

@@ -209,6 +209,14 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_QUIT_RETROARCH,
    "Kilépés a RetroArch alkalmazásból. Konfiguráció mentése kilépéskor: engedélyezve."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_NOW,
+   "Szinkronizálás most"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_NOW,
+   "A felhőbe szinkronizálás kézi indítása."
+   )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_QUIT_RETROARCH_NOSAVE,
    "Kilépés a RetroArch alkalmazásból. Konfiguráció mentése kilépéskor: letiltva."
@@ -1304,6 +1312,22 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "Kikapcsolt állapotban a fájlok egy tartalék könyvtárba kerülnek felülírás vagy törlés előtt."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE,
+   "Szinkronizálás módja"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_MODE,
+   "Automatikus: szinkronizálás a RetroArch indításakor és magok leállításakor. Kézi: csak a \"Szinkronizálás most\" gomb megnyomásakor."
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_AUTOMATIC,
+   "Automatikus"
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "Kézi"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
    "A felhőszinkronizálás háttértára"
@@ -14050,6 +14074,14 @@ MSG_HASH(
    MSG_LIBRETRO_FRONTEND,
    "Libretro frontend"
    )
+MSG_HASH(
+   MSG_LOADED_STATE_FROM_SLOT,
+   "Játékállás betöltve a %d. rekeszből."
+   )
+MSG_HASH(
+   MSG_LOADED_STATE_FROM_SLOT_AUTO,
+   "Játékállás betöltve az automata rekeszből."
+   )
 MSG_HASH(
    MSG_LOADING,
    "Betöltés"
@@ -14246,6 +14278,14 @@ MSG_HASH(
    MSG_SAVED_NEW_CONFIG_TO,
    "Konfiguráció mentve ide"
    )
+MSG_HASH(
+   MSG_SAVED_STATE_TO_SLOT,
+   "Játékállás elmentve a %d. rekeszbe."
+   )
+MSG_HASH(
+   MSG_SAVED_STATE_TO_SLOT_AUTO,
+   "Játékállás elmentve az automata rekeszbe."
+   )
 MSG_HASH(
    MSG_SAVED_SUCCESSFULLY_TO,
    "Sikeresen mentve ide"

intl/msg_hash_it.h

@@ -1288,6 +1288,14 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "Quando questa opzione è disabilitata, i file vengono spostati in una cartella di backup prima di essere sovrascritti o cancellati."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_AUTOMATIC,
+   "Automatico"
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "Manuale"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
    "Backend di sincronizzazione cloud"
@@ -4953,10 +4961,6 @@ MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CORE_SUGGEST_ALWAYS,
    "Suggerisci Sempre Nucleo"
    )
-MSG_HASH(
-   MENU_ENUM_SUBLABEL_CORE_SUGGEST_ALWAYS,
-   "Suggerisci i nuclei disponibili anche quando un nucleo è già caricato."
-   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_USE_BUILTIN_PLAYER,
    "Usa Lettore Multimediale Integrato"
@@ -14086,6 +14090,14 @@ MSG_HASH(
    MSG_LIBRETRO_FRONTEND,
    "Frontend per libretro"
    )
+MSG_HASH(
+   MSG_LOADED_STATE_FROM_SLOT,
+   "Caricamento del salvataggio dallo slot: #%d."
+   )
+MSG_HASH(
+   MSG_LOADED_STATE_FROM_SLOT_AUTO,
+   "Stato caricato dallo slot: Auto."
+   )
 MSG_HASH(
    MSG_LOADING,
    "Caricamento in corso"
@@ -14282,6 +14294,14 @@ MSG_HASH(
    MSG_SAVED_NEW_CONFIG_TO,
    "Configurazione salvata in"
    )
+MSG_HASH(
+   MSG_SAVED_STATE_TO_SLOT,
+   "Stato salvato nello slot: %d."
+   )
+MSG_HASH(
+   MSG_SAVED_STATE_TO_SLOT_AUTO,
+   "Stato salvato nello slot: Auto."
+   )
 MSG_HASH(
    MSG_SAVED_SUCCESSFULLY_TO,
    "Salvato con successo su"

intl/msg_hash_ja.h

@@ -1288,6 +1288,10 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "無効にすると、ファイルは上書きまたは削除される前にバックアップフォルダに移動されます。"
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "手動"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
    "クラウド同期のバックエンド"

intl/msg_hash_ko.h

@@ -217,6 +217,14 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_QUIT_RETROARCH,
    "RetroArch 응용 프로그램을 종료합니다. 종료 시 구성 저장이 활성화되어 있습니다."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_NOW,
+   "지금 동기화"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_NOW,
+   "수동으로 클라우드 동기화를 수행합니다."
+   )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_QUIT_RETROARCH_NOSAVE,
    "RetroArch 응용 프로그램을 종료합니다. 종료 시 구성 저장이 비활성화되어 있습니다."
@@ -1332,6 +1340,22 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "비활성화할 경우, 동기화 대상 파일들을 덮어씌우거나 삭제하지 않고 백업 폴더에 저장합니다."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE,
+   "동기화 모드"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_MODE,
+   "자동: RetroArch가 실행될 때와 코어가 종료될 때 동기화합니다. 수동: '지금 동기화' 버튼을 직접 누를 때에만 동기화합니다."
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_AUTOMATIC,
+   "자동"
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "수동"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
    "클라우드 동기화 백엔드"
@@ -5093,10 +5117,6 @@ MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CORE_SUGGEST_ALWAYS,
    "항상 코어 제안하기"
    )
-MSG_HASH(
-   MENU_ENUM_SUBLABEL_CORE_SUGGEST_ALWAYS,
-   "코어가 이미 불러와져 있더라도 항상 사용 가능한 코어 목록을 표시합니다."
-   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_USE_BUILTIN_PLAYER,
    "내장 미디어 플레이어 사용"
@@ -14402,6 +14422,14 @@ MSG_HASH(
    MSG_LIBRETRO_FRONTEND,
    "libretro 프론트엔드"
    )
+MSG_HASH(
+   MSG_LOADED_STATE_FROM_SLOT,
+   "%d번 슬롯에서 상태 불러옴."
+   )
+MSG_HASH(
+   MSG_LOADED_STATE_FROM_SLOT_AUTO,
+   "자동 슬롯에서 상태 불러옴."
+   )
 MSG_HASH(
    MSG_LOADING,
    "불러오는 중"
@@ -14598,6 +14626,14 @@ MSG_HASH(
    MSG_SAVED_NEW_CONFIG_TO,
    "구성을 다음 위치에 저장함:"
    )
+MSG_HASH(
+   MSG_SAVED_STATE_TO_SLOT,
+   "%d번 슬롯에 상태 저장함."
+   )
+MSG_HASH(
+   MSG_SAVED_STATE_TO_SLOT_AUTO,
+   "자동 슬롯에 상태 저장함."
+   )
 MSG_HASH(
    MSG_SAVED_SUCCESSFULLY_TO,
    "저장 성공:"

intl/msg_hash_lbl.h

@@ -3018,6 +3018,10 @@ MSG_HASH(
    MENU_ENUM_LABEL_QUIT_RETROARCH,
    "quit_retroarch"
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_CLOUD_SYNC_SYNC_NOW,
+   "cloud_sync_sync_now"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_RDB_ENTRY,
    "rdb_entry"
@@ -3686,6 +3690,18 @@ MSG_HASH(
    MENU_ENUM_LABEL_CLOUD_SYNC_ENABLE,
    "cloud_sync_enable"
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_CLOUD_SYNC_SYNC_MODE,
+   "cloud_sync_sync_mode"
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_CLOUD_SYNC_SYNC_MODE_AUTOMATIC,
+   "cloud_sync_sync_mode_automatic"
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "cloud_sync_sync_mode_manual"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_CLOUD_SYNC_DESTRUCTIVE,
    "cloud_sync_destructive"

intl/msg_hash_no.h

@@ -1156,6 +1156,10 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "Når deaktivert, flyttes filer til en sikkerhetskopimappe før de overskrives eller slettes."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "Manuell"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_URL,
    "URL for sky-lagring"

intl/msg_hash_pl.h

@@ -1304,6 +1304,14 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "Gdy wyłączone, pliki są przenoszone do folderu kopii zapasowej przed nadpisaniem lub usunięciem."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_AUTOMATIC,
+   "Automatyczne"
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "Ręczny"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
    "Back-end synchronizacji w chmurze"
@@ -4321,10 +4329,6 @@ MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CORE_SUGGEST_ALWAYS,
    "Zawsze proponuj rdzenie"
    )
-MSG_HASH(
-   MENU_ENUM_SUBLABEL_CORE_SUGGEST_ALWAYS,
-   "Zaproponuj dostępne rdzenie nawet wtedy, gdy rdzeń jest już załadowany."
-   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_USE_BUILTIN_PLAYER,
    "Użyj wbudowanego odtwarzacza multimedialnego"

intl/msg_hash_pt_br.h

@@ -209,6 +209,14 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_QUIT_RETROARCH,
    "Fecha o RetroArch.\n\"Salvar configuração ao sair\" está ativado."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_NOW,
+   "Sincronizar Agora"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_NOW,
+   "Acionar manualmente a sincronização com a nuvem."
+   )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_QUIT_RETROARCH_NOSAVE,
    "Fecha o RetroArch.\n\"Salvar configuração ao sair\" está desativado."
@@ -1308,6 +1316,18 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "Quando desativado, os arquivos são movidos para uma pasta de backup antes de serem substituídos ou excluídos."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE,
+   "Modo de Sincronização"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_MODE,
+   "Automático: Sincroniza na inicialização do RetroArch e quando os núcleos são descarregados. Manual: Só sincroniza quando o botão 'Sincronizar Agora' for acionado manualmente."
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_AUTOMATIC,
+   "Automático"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
    "Sincronização da nuvem Backend"
@@ -5025,10 +5045,6 @@ MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CORE_SUGGEST_ALWAYS,
    "Sempre Sugerir Núcleos"
    )
-MSG_HASH(
-   MENU_ENUM_SUBLABEL_CORE_SUGGEST_ALWAYS,
-   "Sugerir núcleos disponíveis mesmo quando um núcleo já estiver carregado."
-   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_USE_BUILTIN_PLAYER,
    "Utilizar o reprodutor de mídia integrado"

intl/msg_hash_ru.h

@@ -217,6 +217,14 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_QUIT_RETROARCH,
    "Закрыть RetroArch. Сохранение конфигурации при выходе включено."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_NOW,
+   "Синхронизировать сейчас"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_NOW,
+   "Ручной запуск облачной синхронизации."
+   )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_QUIT_RETROARCH_NOSAVE,
    "Закрыть RetroArch. Сохранение конфигурации при выходе отключено."
@@ -1328,6 +1336,18 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "При отключении опции файлы перед удалением или перезаписью будут помещены в папку резервного копирования."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE,
+   "Режим синхронизации"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_MODE,
+   "Автоматический: синхронизировать при запуске RetroArch и когда нет загруженных ядер. Ручной: синхронизировать только вручную нажатием кнопки 'Синхронизировать сейчас'."
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "Вручную"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
    "Бэкенд облачной синхронизации"
@@ -5083,7 +5103,7 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_CORE_SUGGEST_ALWAYS,
-   "Предлагать доступные ядра даже если ядро уже загружено."
+   "Предлагать доступные ядра даже при ручной загрузке ядра."
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_USE_BUILTIN_PLAYER,
@@ -14338,6 +14358,14 @@ MSG_HASH(
    MSG_LIBRETRO_FRONTEND,
    "Фронтенд для libretro"
    )
+MSG_HASH(
+   MSG_LOADED_STATE_FROM_SLOT,
+   "Загружено сохранение в слоте %d."
+   )
+MSG_HASH(
+   MSG_LOADED_STATE_FROM_SLOT_AUTO,
+   "Загружено сохранение в автослоте."
+   )
 MSG_HASH(
    MSG_LOADING,
    "Загружается"
@@ -14534,6 +14562,14 @@ MSG_HASH(
    MSG_SAVED_NEW_CONFIG_TO,
    "Конфигурация сохранена в"
    )
+MSG_HASH(
+   MSG_SAVED_STATE_TO_SLOT,
+   "Создано сохранение в слоте %d."
+   )
+MSG_HASH(
+   MSG_SAVED_STATE_TO_SLOT_AUTO,
+   "Создано сохранение в автослоте."
+   )
 MSG_HASH(
    MSG_SAVED_SUCCESSFULLY_TO,
    "Успешно сохранено в"

intl/msg_hash_sk.h

@@ -1140,6 +1140,14 @@ MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_ENABLE,
    "Povoliť cloud synchronizáciu"
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_AUTOMATIC,
+   "Automaticky"
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "Ručne"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_USERNAME,
    "Meno používateľa"

intl/msg_hash_sv.h

@@ -123,7 +123,7 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_PLAYLISTS_TAB,
-   "Visar spellistor med skannat innehåll som matchar databasen."
+   "Visar spellistor med genomsökt innehåll som matchar databasen."
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_ADD_CONTENT_LIST,
@@ -131,7 +131,7 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_ADD_CONTENT_LIST,
-   "Skapa eller uppdatera spellistor genom att skanna Innehåll."
+   "Skapa eller uppdatera spellistor genom att söka igenom innehåll."
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_SHOW_WIMP,
@@ -205,6 +205,14 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_QUIT_RETROARCH,
    "Avsluta RetroArch-programmet. Konfiguration sparas vid avslut är aktiverat."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_NOW,
+   "Synkronisera nu"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_NOW,
+   "Starta molnsynkronisering manuellt."
+   )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_QUIT_RETROARCH_NOSAVE,
    "Avsluta RetroArch-programmet. Konfiguration sparas vid avslut är inaktiverat."
@@ -1218,7 +1226,7 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_SAVING_SETTINGS,
-   "Sparar"
+   "Sparningar"
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_SAVING_SETTINGS,
@@ -1280,6 +1288,22 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "Inaktiverat flyttas filer till en säkerhetskopia innan de skrivs över eller raderas."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE,
+   "Synkroniseringsläge"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_MODE,
+   "Automatiskt: Synkronisering vid uppstart av RetroArch och när kärnor läses ur. Manuellt: Synkronisering endast när knappen ”Synkronisera nu” trycks in manuellt."
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_AUTOMATIC,
+   "Automatiskt"
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "Manuellt"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
    "Backend för molnsynk"
@@ -2637,7 +2661,7 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_VRR_RUNLOOP_ENABLE,
-   "Synkronisera exakt till innehålls bildhastighet (G-syn, FreeSync)"
+   "Synkronisera exakt till innehållets bildhastighet (G-Sync, FreeSync)"
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_VRR_RUNLOOP_ENABLE,
@@ -2770,7 +2794,7 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_AUDIO_DSP_PLUGIN,
-   "DSP-plugin"
+   "DSP-insticksmodul"
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_AUDIO_DSP_PLUGIN,
@@ -2782,7 +2806,7 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_AUDIO_DSP_PLUGIN_REMOVE,
-   "Inaktiverar DSP-plugins som är aktiva."
+   "Inaktiverar DSP-insticksmoduler som är aktiva."
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_AUDIO_WASAPI_EXCLUSIVE_MODE,
@@ -3203,11 +3227,11 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_INPUT_AUTO_GAME_FOCUS,
-   "Automatiskt 'Game Focus'-läge"
+   "Automatiskt 'Spelfokus'-läge"
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_INPUT_AUTO_GAME_FOCUS,
-   "Aktivera alltid 'Game Focus' -läget när innehåll startar eller återupptas. När inställt på \"Detektera\" kommer alternativet att aktiveras om kärnan implementerar frontens-tangentbordsåteruppringningsfunktioner."
+   "Aktivera alltid 'Spelfokus' -läget när innehåll startar eller återupptas. När inställt på \"Identifiera\" kommer alternativet att aktiveras om kärnan implementerar frontendens funktioner för tangentbordsåteranrop."
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_INPUT_AUTO_GAME_FOCUS_OFF,
@@ -3219,7 +3243,7 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_INPUT_AUTO_GAME_FOCUS_DETECT,
-   "Detektera"
+   "Identifiera"
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_PAUSE_ON_DISCONNECT,
@@ -3976,7 +4000,7 @@ MSG_HASH(
 
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_INPUT_META_VRR_RUNLOOP_TOGGLE,
-   "Synkronisera till exakt innehållsbildhastighet (På/Av)"
+   "Synkronisera till exakt bildhastighet för innehållet (På/Av)"
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_INPUT_META_VRR_RUNLOOP_TOGGLE,
@@ -4792,7 +4816,7 @@ MSG_HASH(
 
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_LOG_VERBOSITY,
-   "Verbositet för loggning"
+   "Utförlighetsnivå för loggning"
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_LOG_VERBOSITY,
@@ -4895,7 +4919,7 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_CORE_SUGGEST_ALWAYS,
-   "Föreslå tillgängliga kärnor även när en kärna redan har lästs in."
+   "Föreslå tillgängliga kärnor även när en kärna lästs in manuellt."
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_USE_BUILTIN_PLAYER,
@@ -4914,7 +4938,7 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_INPUT_META_REWIND,
-   "Ändra inställningar för Spola tillbaka."
+   "Ändra inställningar för Tillbakaspolning."
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_FRAME_TIME_COUNTER_SETTINGS,
@@ -4981,7 +5005,7 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_REWIND_BUFFER_SIZE,
-   "Spola tillbaka Buffertstorlek (MB)"
+   "Buffertstorlek för tillbakaspolning (MB)"
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_REWIND_BUFFER_SIZE,
@@ -6556,11 +6580,11 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CONTENT_SHOW_REWIND,
-   "Visa 'Spola tillbaka'"
+   "Visa 'Tillbakaspolning'"
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_CONTENT_SHOW_REWIND,
-   "Visa alternativet 'Spola tillbaka'."
+   "Visa alternativet 'Tillbakaspolning'."
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_QUICK_MENU_SHOW_SAVE_CORE_OVERRIDES,
@@ -6711,11 +6735,11 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_SETTINGS_SHOW_SAVING,
-   "Visa 'Sparar'"
+   "Visa 'Sparningar'"
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_SETTINGS_SHOW_SAVING,
-   "Visa inställningar för 'Sparar'."
+   "Visa inställningar för 'Sparningar'."
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_SETTINGS_SHOW_LOGGING,
@@ -8417,23 +8441,23 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_SCAN_FILE,
-   "Skanna fil"
+   "Sök igenom fil"
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_SCAN_FILE,
-   "Skannar en fil efter innehåll som matchar databasen."
+   "Söker igenom en fil efter innehåll som matchar databasen."
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_MANUAL_CONTENT_SCAN_LIST,
-   "Manuell skanning"
+   "Manuell genomsökning"
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_MANUAL_CONTENT_SCAN_LIST,
-   "Konfigurerbar skanning baserad på filnamnet på innehåll. Kräver inte att innehåll matchar databasen."
+   "Konfigurerbar genomsökning baserad på filnamnet på innehåll. Kräver inte att innehåll matchar databasen."
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_SCAN_ENTRY,
-   "Skanna"
+   "Sök igenom"
    )
 
 /* Import Content > Scan File */
@@ -8499,7 +8523,7 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_MANUAL_CONTENT_SCAN_SEARCH_ARCHIVES,
-   "Skanna inuti Arkiv"
+   "Sök igenom inuti arkiv"
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_MANUAL_CONTENT_SCAN_SEARCH_ARCHIVES,
@@ -8535,7 +8559,7 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_MANUAL_CONTENT_SCAN_START,
-   "Starta skanning"
+   "Starta genomsökning"
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_MANUAL_CONTENT_SCAN_START,
@@ -12456,6 +12480,10 @@ MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CONTENT_HISTORY_PATH,
    "Sökväg för innehållshistorik"
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CRT_SWITCH_RESOLUTION_OUTPUT_DISPLAY_ID,
+   "Skärm-id för utgång"
+   )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_CRT_SWITCH_RESOLUTION_OUTPUT_DISPLAY_ID,
    "Välj utgångsporten som är ansluten till CRT-skärmen."
@@ -13908,7 +13936,7 @@ MSG_HASH(
    )
 MSG_HASH(
    MSG_SCANNING,
-   "Skannar"
+   "Söker igenom"
    )
 MSG_HASH(
    MSG_SCANNING_OF_DIRECTORY_FINISHED,
@@ -14140,7 +14168,7 @@ MSG_HASH(
    )
 MSG_HASH(
    MSG_BLUETOOTH_SCAN_COMPLETE,
-   "Bluetooth-skanning slutförd."
+   "Bluetooth-genomsökning slutförd."
    )
 MSG_HASH(
    MSG_BLUETOOTH_PAIRING_REMOVED,
@@ -14148,15 +14176,15 @@ MSG_HASH(
    )
 MSG_HASH(
    MSG_WIFI_SCAN_COMPLETE,
-   "Wi-Fi-skanning slutförd."
+   "Wi-Fi-genomsökning slutförd."
    )
 MSG_HASH(
    MSG_SCANNING_BLUETOOTH_DEVICES,
-   "Skannar efter bluetooth-enheter..."
+   "Söker efter bluetooth-enheter..."
    )
 MSG_HASH(
    MSG_SCANNING_WIRELESS_NETWORKS,
-   "Skannar trådlösa nätverk..."
+   "Söker efter trådlösa nätverk..."
    )
 MSG_HASH(
    MSG_ENABLING_WIRELESS,
@@ -14576,7 +14604,7 @@ MSG_HASH(
    )
 MSG_HASH(
    MSG_MANUAL_CONTENT_SCAN_START,
-   "Skannar innehåll: "
+   "Söker igenom innehåll: "
    )
 MSG_HASH(
    MSG_MANUAL_CONTENT_SCAN_PLAYLIST_CLEANUP,
@@ -14584,7 +14612,7 @@ MSG_HASH(
    )
 MSG_HASH(
    MSG_MANUAL_CONTENT_SCAN_IN_PROGRESS,
-   "Skannar: "
+   "Söker igenom: "
    )
 MSG_HASH(
    MSG_MANUAL_CONTENT_SCAN_M3U_CLEANUP,
@@ -14830,11 +14858,11 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_BLUETOOTH_SETTINGS,
-   "Skanna efter bluetooth-enheter och anslut dem."
+   "Sök efter bluetooth-enheter och anslut dem."
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_WIFI_SETTINGS,
-   "Skanna efter trådlösa nätverk och etablera anslutning."
+   "Sök efter trådlösa nätverk och etablera anslutning."
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_WIFI_ENABLED,

intl/msg_hash_tr.h

@@ -1316,6 +1316,14 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "Devre dışı bırakıldığında, dosyalar üzerine yazılmadan veya silinmeden önce yedek klasörüne taşınır."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_AUTOMATIC,
+   "Otomatik"
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "El İle"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
    "Bulut Eşitleyici Arka Uç"
@@ -5053,10 +5061,6 @@ MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CORE_SUGGEST_ALWAYS,
    "Her Zaman Çekirdekleri Öner"
    )
-MSG_HASH(
-   MENU_ENUM_SUBLABEL_CORE_SUGGEST_ALWAYS,
-   "Bir çekirdek zaten yüklü olsa bile kullanılabilir çekirdekleri öner."
-   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_USE_BUILTIN_PLAYER,
    "Dahili Medya Oynatıcı Kullan"

intl/msg_hash_uk.h

@@ -217,6 +217,14 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_QUIT_RETROARCH,
    "Вихід з додатка RetroArch. Збереження конфігурації на виході увімкнено."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_NOW,
+   "Синхронізувати зараз"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_NOW,
+   "Синхронізація хмар вручну тригера."
+   )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_QUIT_RETROARCH_NOSAVE,
    "Вихід з додатка RetroArch. Збереження конфігурації на виході вимкнено."
@@ -1328,6 +1336,22 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "У вимкненому стані, файли переміщуються до резервного каталогу перед перезаписом чи видаленням."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE,
+   "Режим синхронізації"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_MODE,
+   "Автоматична: Синхронізація при запуску RetroArch та при відключенні ядра. Вручну: синхронізувати, коли кнопка 'Sync зараз' буде викликана вручну."
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_AUTOMATIC,
+   "Автоматично"
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "Ручний"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
    "Бекенд хмарної синхронізації"
@@ -5063,7 +5087,7 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_CORE_SUGGEST_ALWAYS,
-   "Пропозиція доступних ядер навіть тоді, коли ядро вже завантажено."
+   "Запропонувати доступні ядра навіть якщо ядро завантажується вручну."
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_USE_BUILTIN_PLAYER,

intl/msg_hash_us.h

@@ -217,6 +217,14 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_QUIT_RETROARCH,
    "Quit RetroArch application. Configuration save on exit is enabled."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_NOW,
+   "Sync Now"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_NOW,
+   "Manually trigger cloud synchronization."
+   )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_QUIT_RETROARCH_NOSAVE,
    "Quit RetroArch application. Configuration save on exit is disabled."
@@ -1344,6 +1352,22 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "When disabled, files are moved to a backup folder before being overwritten or deleted."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE,
+   "Sync Mode"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_MODE,
+   "Automatic: Sync on RetroArch startup and when cores are unloaded. Manual: Only sync when 'Sync Now' button is manually triggered."
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_AUTOMATIC,
+   "Automatic"
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "Manual"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
    "Cloud Sync Backend"
@@ -5127,7 +5151,7 @@ MSG_HASH(
    )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_CORE_SUGGEST_ALWAYS,
-   "Suggest available cores even when a core is already loaded."
+   "Suggest available cores even when a core is manually loaded."
    )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_USE_BUILTIN_PLAYER,

intl/msg_hash_val.h

@@ -1120,6 +1120,10 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_SAVING_SETTINGS,
    "Canvia els ajustos de guardat."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "Selecció manual"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_LOGGING_SETTINGS,
    "Registres"

intl/msg_hash_vn.h

@@ -217,6 +217,14 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_QUIT_RETROARCH,
    "Thoát RetroArch. Lưu thiết lập khi thoát được bật."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_NOW,
+   "Đồng bộ ngay"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_NOW,
+   "Kích hoạt đồng bộ hóa đám mây thủ công."
+   )
 MSG_HASH(
    MENU_ENUM_SUBLABEL_QUIT_RETROARCH_NOSAVE,
    "Thoát RetroArch. Lưu thiết lập khi thoát bị tắt."
@@ -1324,6 +1332,22 @@ MSG_HASH(
    MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE,
    "Khi tắt, các tệp sẽ được chuyển vào thư mục sao lưu trước khi bị ghi đè hoặc xoá."
    )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE,
+   "Chế độ đồng bộ"
+   )
+MSG_HASH(
+   MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_MODE,
+   "Tự động: Đồng bộ khi khởi động RetroArch và khi các core được tắt. Thủ công: Chỉ đồng bộ khi nút Đồng bộ ngay được nhấn."
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_AUTOMATIC,
+   "Tự động"
+   )
+MSG_HASH(
+   MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL,
+   "Thủ công"
+   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_DRIVER,
    "Nền tảng đồng bộ đám mây."
@@ -5077,10 +5101,6 @@ MSG_HASH(
    MENU_ENUM_LABEL_VALUE_CORE_SUGGEST_ALWAYS,
    "Luôn Gợi ý Core"
    )
-MSG_HASH(
-   MENU_ENUM_SUBLABEL_CORE_SUGGEST_ALWAYS,
-   "Gợi ý các core có sẵn ngay cả khi đã có một core được tải."
-   )
 MSG_HASH(
    MENU_ENUM_LABEL_VALUE_USE_BUILTIN_PLAYER,
    "Sử dụng Trình phát Media tích hợp sẵn"

intl/progress.h

@@ -31,7 +31,7 @@
 #define LANGUAGE_PROGRESS_DANISH_APPROVED   0
 
 /* German */
-#define LANGUAGE_PROGRESS_GERMAN_TRANSLATED 100
+#define LANGUAGE_PROGRESS_GERMAN_TRANSLATED 99
 #define LANGUAGE_PROGRESS_GERMAN_APPROVED   13
 
 /* Greek */
@@ -48,7 +48,7 @@
 
 /* Spanish */
 #define LANGUAGE_PROGRESS_SPANISH_TRANSLATED 100
-#define LANGUAGE_PROGRESS_SPANISH_APPROVED   95
+#define LANGUAGE_PROGRESS_SPANISH_APPROVED   94
 
 /* Persian */
 #define LANGUAGE_PROGRESS_PERSIAN_TRANSLATED 11
@@ -79,7 +79,7 @@
 #define LANGUAGE_PROGRESS_CROATIAN_APPROVED   0
 
 /* Hungarian */
-#define LANGUAGE_PROGRESS_HUNGARIAN_TRANSLATED 99
+#define LANGUAGE_PROGRESS_HUNGARIAN_TRANSLATED 100
 #define LANGUAGE_PROGRESS_HUNGARIAN_APPROVED   0
 
 /* Indonesian */
@@ -123,7 +123,7 @@
 #define LANGUAGE_PROGRESS_PORTUGUESE_APPROVED   0
 
 /* Russian */
-#define LANGUAGE_PROGRESS_RUSSIAN_TRANSLATED 99
+#define LANGUAGE_PROGRESS_RUSSIAN_TRANSLATED 100
 #define LANGUAGE_PROGRESS_RUSSIAN_APPROVED   12
 
 /* Slovak */
@@ -136,7 +136,7 @@
 
 /* Swedish */
 #define LANGUAGE_PROGRESS_SWEDISH_TRANSLATED 98
-#define LANGUAGE_PROGRESS_SWEDISH_APPROVED   64
+#define LANGUAGE_PROGRESS_SWEDISH_APPROVED   65
 
 /* Turkish */
 #define LANGUAGE_PROGRESS_TURKISH_TRANSLATED 99
@@ -155,7 +155,7 @@
 #define LANGUAGE_PROGRESS_VALENCIAN_APPROVED   0
 
 /* Vietnamese */
-#define LANGUAGE_PROGRESS_VIETNAMESE_TRANSLATED 100
+#define LANGUAGE_PROGRESS_VIETNAMESE_TRANSLATED 99
 #define LANGUAGE_PROGRESS_VIETNAMESE_APPROVED   0
 
 /* Chinese Simplified */

libretro-common/features/features_cpu.c

@@ -870,6 +870,7 @@ end:
          if (pipe)
          {
             char buf[256];
+
             while (fgets(buf, sizeof(buf), pipe))
             {
                if (strncmp(buf, "Model name:", 11) == 0)
@@ -881,34 +882,37 @@ end:
                      while (*p == ' ' || *p == '\t') p++;
                      size_t len2 = strcspn(p, "\r\n");
 
-                     char *tmp = (char *)malloc(len2 + 1);
-                     if (tmp)
+                     if (len2 > 0)
                      {
-                        memcpy(tmp, p, len2);
-                        tmp[len2] = '\0';
-
-                        if (model_name && *model_name)
+                        char *tmp = malloc(len2 + 1);
+                        if (tmp)
                         {
-                           size_t oldlen = strlen(model_name);
-                           char *combined = (char *)malloc(oldlen + len2 + 4);
-                           if (combined)
+                           memcpy(tmp, p, len2);
+                           tmp[len2] = '\0';
+
+                           if (s[0] != '\0')
                            {
-                              memcpy(combined, model_name, oldlen);
-                              combined[oldlen] = ' ';
-                              combined[oldlen + 1] = '(';
-                              memcpy(combined + oldlen + 2, tmp, len2);
-                              combined[oldlen + 2 + len2] = ')';
-                              combined[oldlen + 2 + len2 + 1] = '\0';
-                              free(model_name);
-                              model_name = combined;
+                              size_t oldlen = strlen(s);
+                              char *combined = malloc(oldlen + len2 + 4);
+                              if (combined)
+                              {
+                                 memcpy(combined, s, oldlen);
+                                 combined[oldlen] = ' ';
+                                 combined[oldlen + 1] = '(';
+                                 memcpy(combined + oldlen + 2, tmp, len2);
+                                 combined[oldlen + 2 + len2] = ')';
+                                 combined[oldlen + 2 + len2 + 1] = '\0';
+
+                                 strlcpy(s, combined, len);
+                                 free(combined);
+                              }
+                           }
+                           else
+                           {
+                              strlcpy(s, tmp, len);
                            }
                            free(tmp);
                         }
-                        else
-                        {
-                           free(model_name);
-                           model_name = tmp;
-                        }
                      }
                   }
                   break;
@@ -916,12 +920,6 @@ end:
             }
             pclose(pipe);
          }
-
-         if (model_name)
-         {
-            strncpy(s, model_name, len);
-            s[len - 1] = '\0';
-         }
       }
 #endif
    }

menu/cbs/menu_cbs_ok.c

@@ -1948,8 +1948,8 @@ static bool menu_content_find_first_core(
             &supported);
 
 #ifdef HAVE_DYNAMIC
-   /* Don't suggest cores if a core is already loaded. */
-   if (     !path_is_empty(RARCH_PATH_CORE)
+   /* Don't suggest cores if a core is manually loaded. */
+   if (     !path_is_empty(RARCH_PATH_CORE_LAST)
          && !config_get_ptr()->bools.core_suggest_always)
       load_content_with_current_core = true;
 #endif

menu/cbs/menu_cbs_sublabel.c

@@ -261,6 +261,7 @@ DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_retro_achievements_settings_list, ME
 DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_saving_settings_list,          MENU_ENUM_SUBLABEL_SAVING_SETTINGS)
 DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_cloud_sync_settings_list,      MENU_ENUM_SUBLABEL_CLOUD_SYNC_SETTINGS)
 DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_cloud_sync_enable,             MENU_ENUM_SUBLABEL_CLOUD_SYNC_ENABLE)
+DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_cloud_sync_sync_mode,          MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_MODE)
 DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_cloud_sync_destructive,        MENU_ENUM_SUBLABEL_CLOUD_SYNC_DESTRUCTIVE)
 DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_cloud_sync_sync_saves,         MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_SAVES)
 DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_cloud_sync_sync_configs,       MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_CONFIGS)
@@ -635,6 +636,7 @@ DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_core_list,                     MENU_
 DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_core_list_unload,              MENU_ENUM_SUBLABEL_CORE_LIST_UNLOAD)
 DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_download_core,                 MENU_ENUM_SUBLABEL_DOWNLOAD_CORE)
 DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_update_installed_cores,        MENU_ENUM_SUBLABEL_UPDATE_INSTALLED_CORES)
+DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_sync_now,                      MENU_ENUM_SUBLABEL_CLOUD_SYNC_SYNC_NOW)
 #if defined(ANDROID)
 DEFAULT_SUBLABEL_MACRO(action_bind_sublabel_switch_installed_cores_pfd,    MENU_ENUM_SUBLABEL_SWITCH_INSTALLED_CORES_PFD)
 #endif
@@ -4611,6 +4613,9 @@ int menu_cbs_init_bind_sublabel(menu_file_list_cbs_t *cbs,
          case MENU_ENUM_LABEL_UPDATE_INSTALLED_CORES:
             BIND_ACTION_SUBLABEL(cbs, action_bind_sublabel_update_installed_cores);
             break;
+         case MENU_ENUM_LABEL_CLOUD_SYNC_SYNC_NOW:
+            BIND_ACTION_SUBLABEL(cbs, action_bind_sublabel_sync_now);
+            break;
 #if defined(ANDROID)
          case MENU_ENUM_LABEL_SWITCH_INSTALLED_CORES_PFD:
             BIND_ACTION_SUBLABEL(cbs, action_bind_sublabel_switch_installed_cores_pfd);
@@ -5247,6 +5252,9 @@ int menu_cbs_init_bind_sublabel(menu_file_list_cbs_t *cbs,
          case MENU_ENUM_LABEL_CLOUD_SYNC_ENABLE:
             BIND_ACTION_SUBLABEL(cbs, action_bind_sublabel_cloud_sync_enable);
             break;
+         case MENU_ENUM_LABEL_CLOUD_SYNC_SYNC_MODE:
+            BIND_ACTION_SUBLABEL(cbs, action_bind_sublabel_cloud_sync_sync_mode);
+            break;
          case MENU_ENUM_LABEL_CLOUD_SYNC_DESTRUCTIVE:
             BIND_ACTION_SUBLABEL(cbs, action_bind_sublabel_cloud_sync_destructive);
             break;

menu/drivers/materialui.c

@@ -10750,6 +10750,17 @@ static int materialui_list_push(void *data, void *userdata,
             }
 #endif
 
+#if defined(HAVE_CLOUDSYNC)
+            if (settings->bools.cloud_sync_enable)
+            {
+               MENU_DISPLAYLIST_PARSE_SETTINGS_ENUM(
+                     info->list,
+                     MENU_ENUM_LABEL_CLOUD_SYNC_SYNC_NOW,
+                     PARSE_ACTION,
+                     false);
+            }
+#endif
+
 #if defined(HAVE_NETWORKING)
 #ifdef HAVE_LAKKA
             MENU_DISPLAYLIST_PARSE_SETTINGS_ENUM(
@@ -12032,6 +12043,7 @@ static void materialui_list_insert(void *userdata,
             }
             else if (   string_is_equal(label, msg_hash_to_str(MENU_ENUM_LABEL_QUIT_RETROARCH))
                      || string_is_equal(label, msg_hash_to_str(MENU_ENUM_LABEL_RESTART_RETROARCH))
+                     || string_is_equal(label, msg_hash_to_str(MENU_ENUM_LABEL_CLOUD_SYNC_SYNC_NOW))
                   )
             {
                node->icon_texture_index = MUI_TEXTURE_QUIT;

menu/drivers/ozone.c

@@ -2239,6 +2239,7 @@ static uintptr_t ozone_entries_icon_get_texture(
       case MENU_ENUM_LABEL_CHEAT_COPY_BEFORE:
       case MENU_ENUM_LABEL_CHEAT_RELOAD_CHEATS:
       case MENU_ENUM_LABEL_RESTART_RETROARCH:
+      case MENU_ENUM_LABEL_CLOUD_SYNC_SYNC_NOW:
       case MENU_ENUM_LABEL_FRAME_TIME_COUNTER_SETTINGS:
       case MENU_ENUM_LABEL_PLAYLIST_MANAGER_CLEAN_PLAYLIST:
       case MENU_ENUM_LABEL_PLAYLIST_MANAGER_REFRESH_PLAYLIST:

menu/drivers/xmb.c

@@ -3423,6 +3423,7 @@ static uintptr_t xmb_icon_get_id(xmb_handle_t *xmb,
       case MENU_ENUM_LABEL_CHEAT_COPY_BEFORE:
       case MENU_ENUM_LABEL_CHEAT_RELOAD_CHEATS:
       case MENU_ENUM_LABEL_RESTART_RETROARCH:
+      case MENU_ENUM_LABEL_CLOUD_SYNC_SYNC_NOW:
       case MENU_ENUM_LABEL_FRAME_TIME_COUNTER_SETTINGS:
       case MENU_ENUM_LABEL_PLAYLIST_MANAGER_CLEAN_PLAYLIST:
       case MENU_ENUM_LABEL_PLAYLIST_MANAGER_REFRESH_PLAYLIST:
@@ -4664,6 +4665,9 @@ static bool xmb_animation_line_ticker_smooth(gfx_animation_t *p_anim, gfx_animat
          break;
    }
 
+   if (!num_display_lines)
+      goto end;
+
    /* Build output string from required lines */
    xmb_animation_build_line_ticker_string(
          num_display_lines, line_offset, &lines, lines.size,
@@ -4765,7 +4769,7 @@ static int xmb_draw_item(
    bool show_switch_icons              = settings->bools.menu_xmb_switch_icons;
    unsigned show_history_icons         = settings->uints.playlist_show_history_icons;
    unsigned vertical_fade_factor       = settings->uints.menu_xmb_vertical_fade_factor;
-   bool show_icon_thumbnail;
+   bool show_icon_thumbnail            = false;
 
    /* Initial ticker configuration */
    if (use_smooth_ticker)
@@ -5360,17 +5364,20 @@ static int xmb_draw_item(
 
       if (show_icon_thumbnail)
       {
-         float gfx_icon_width_draw, gfx_icon_height_draw;
+         float gfx_icon_width_draw, gfx_icon_height_draw, gfx_icon_aspect;
          float gfx_icon_x_end = icon_x + xmb->icon_size;
+         float zoom_mp        = (xmb->use_ps3_layout) ? 2.0f : 1.0f;
+         bool zoom            = (i == current);
 
          texture = node->thumbnail_icon.icon.texture;
 
          /* More active zoom */
-         if (i == current)
-            gfx_icon_height = (xmb->icon_size * 2.0f);
+         if (zoom)
+            gfx_icon_height = (xmb->icon_size * zoom_mp);
 
          /* More width room for non-squares */
-         gfx_icon_width = (gfx_icon_height * 1.5f);
+         gfx_icon_width  = (gfx_icon_height * 1.5f);
+         gfx_icon_aspect = (gfx_icon_width / gfx_icon_height);
 
          gfx_thumbnail_get_draw_dimensions(
                &node->thumbnail_icon.icon,
@@ -5383,19 +5390,45 @@ static int xmb_draw_item(
          /* Match center with normal icons */
          icon_x -= (gfx_icon_width / 6.0f);
 
-         /* Align current to right instead of center */
-         if (i == current)
-            icon_x -= (gfx_icon_width_draw / 2.0f) + (gfx_icon_width / 24.0f);
+         if (xmb->use_ps3_layout)
+         {
+            /* Align current to right instead of center */
+            if (zoom)
+               icon_x -= (gfx_icon_width_draw / 2.0f) + (gfx_icon_width / 24.0f);
 
-         /* Center alignments */
-         gfx_icon_x = icon_x + (gfx_icon_width - gfx_icon_width_draw) / 2.0f;
+            /* Center alignments */
+            gfx_icon_x = icon_x + (gfx_icon_width - gfx_icon_width_draw) / 2.0f;
 
-         /* Limit current maximum right aligment */
-         if (i == current && gfx_icon_x + gfx_icon_width_draw > gfx_icon_x_end)
-            gfx_icon_x -= (gfx_icon_x_end - gfx_icon_width_draw - gfx_icon_x);
+            /* Limit current maximum right aligment */
+            if (zoom && gfx_icon_x + gfx_icon_width_draw > gfx_icon_x_end)
+               gfx_icon_x -= (gfx_icon_x_end - gfx_icon_width_draw - gfx_icon_x);
+
+         }
+         else
+         {
+            float icon_x_orig = gfx_icon_x;
+
+            /* Align current to right instead of center */
+            if (zoom)
+               icon_x -= (gfx_icon_width_draw / 2.0f) + (gfx_icon_width / 24.0f);
+
+            /* Center alignments */
+            gfx_icon_x = icon_x + (gfx_icon_width - gfx_icon_width_draw) / 2.0f;
+
+            /* Limit current maximum left alignment */
+            if (zoom && gfx_icon_x < icon_x_orig)
+               gfx_icon_x -= gfx_icon_x - icon_x_orig;
+
+            /* Limit current maximum right aligment */
+            if (zoom && gfx_icon_x + gfx_icon_width_draw > gfx_icon_x_end)
+            {
+               gfx_icon_width_draw  = gfx_icon_x_end - gfx_icon_x;
+               gfx_icon_height_draw = gfx_icon_width_draw / gfx_icon_aspect;
+            }
+         }
 
          gfx_icon_y = icon_y - (gfx_icon_height - gfx_icon_height_draw) / 2.0f;
-         if (i == current)
+         if (zoom && xmb->use_ps3_layout)
             gfx_icon_y += (xmb->icon_size / 1.5f);
 
          gfx_icon_width  = gfx_icon_width_draw;
@@ -5442,9 +5475,11 @@ static int xmb_draw_item(
             xmb->icon_size,
             xmb->icon_size,
             texture_switch,
-            node->x + xmb->margins_screen_left
-            + xmb->icon_spacing_horizontal
-            + xmb->icon_size / 2.0 + xmb->margins_setting_left,
+            node->x
+               + xmb->margins_screen_left
+               + xmb->icon_spacing_horizontal
+               + xmb->icon_size / 2.0
+               + xmb->margins_setting_left,
             xmb->margins_screen_top + node->y + xmb->icon_size / 2.0,
             width, height,
             node->alpha,
@@ -7357,8 +7392,14 @@ static void xmb_draw_no_thumbnail_available(
    gfx_display_ctx_driver_t *dispctx = p_disp->dispctx;
    unsigned icon_size                = (unsigned)xmb->icon_size;
 
+   if (icon_size < 64)
+      icon_size = 64;
+
+   if (icon_size > view_width || icon_size > view_height)
+      icon_size = MIN(view_width, view_height);
+
    if (draw_text)
-      y_position += (icon_size / 5.0f);
+      y_position -= (icon_size / 5.0f);
 
    if (dispctx)
    {
@@ -7378,7 +7419,7 @@ static void xmb_draw_no_thumbnail_available(
                icon_size,
                xmb->textures.list[XMB_TEXTURE_IMAGE],
                x_position + ((view_width - icon_size) / 2),
-               video_height - y_position - ((view_height - icon_size) / 2),
+               y_position + ((view_height - icon_size) / 2) + icon_size,
                video_width,
                video_height,
                xmb->alpha,
@@ -7397,7 +7438,7 @@ static void xmb_draw_no_thumbnail_available(
    xmb_draw_text(shadows_enable, xmb, config_get_ptr(),
          msg_hash_to_str(MSG_NO_THUMBNAIL_AVAILABLE),
          x_position + (view_width / 2),
-         video_height - y_position - ((view_height - icon_size * 1.50f) / 2),
+         video_height - y_position - ((view_height - icon_size) / 2),
          1, 1, TEXT_ALIGN_CENTER,
          video_width, video_height,
          xmb->font2);
@@ -7442,9 +7483,7 @@ static void xmb_draw_fullscreen_thumbnails(
       float right_thumbnail_draw_height = 0.0f;
       float left_thumbnail_draw_width   = 0.0f;
       float left_thumbnail_draw_height  = 0.0f;
-      /* XMB doesn't have a proper theme interface, so
-       * hard-code this alpha value for now... */
-      float background_alpha            = 0.75f;
+      float background_alpha            = 0.95f;
       float background_color[16]        = {
             0.0f, 0.0f, 0.0f, 1.0f,
             0.0f, 0.0f, 0.0f, 1.0f,
@@ -7800,39 +7839,19 @@ static void xmb_draw_fullscreen_thumbnails(
       /* Show "No thumbnail available" */
       if (     !show_right_thumbnail
             && !show_left_thumbnail)
-      {
-         unsigned bg_w = video_width  / 3.0f;
-         unsigned bg_h = video_height / 3.0f;
-
-         /* Darken background */
-         gfx_display_draw_quad(
-               p_disp,
-               userdata,
-               video_width,
-               video_height,
-               (video_width - bg_w) / 2.0f,
-               video_height - bg_h - (video_height - bg_h) / 2.0f,
-               bg_w,
-               bg_h,
-               video_width,
-               video_height,
-               background_color,
-               NULL);
-
          xmb_draw_no_thumbnail_available(
                xmb,
                p_disp,
                userdata,
                video_width,
                video_height,
-               (video_width - bg_w) / 2.0f,
-               video_height - bg_h - (video_height - bg_h) / 2.0f,
-               bg_w,
-               bg_h,
+               0,
+               0,
+               video_width,
+               video_height,
                shadows_enable,
                true,
                NULL);
-      }
    }
    return;
 
@@ -7856,7 +7875,6 @@ static void xmb_frame(void *data, video_frame_info_t *video_info)
    size_t title_header_max_width       = 0;
    bool render_background              = false;
    file_list_t *selection_buf          = NULL;
-   const float under_thumb_margin      = 0.96f;
    float left_thumbnail_margin_width   = 0.0f;
    float right_thumbnail_margin_width  = 0.0f;
    float thumbnail_margin_height_under = 0.0f;
@@ -7913,17 +7931,17 @@ static void xmb_frame(void *data, video_frame_info_t *video_info)
             video_st->data, video_width, video_height, true, false);
 
    pseudo_font_length                      = xmb->icon_spacing_horizontal * 4 - xmb->icon_size / 4.0f;
-   left_thumbnail_margin_width             = xmb->icon_size * 3.4f;
+   left_thumbnail_margin_width             = xmb->icon_size * (xmb->use_ps3_layout ? 3.4f : 2.4f);
    right_thumbnail_margin_width            =
          (float)video_width - (xmb->icon_size / 2.0f) -
          (xmb->margins_screen_left * xmb_scale_mod[5]) -
          xmb->icon_spacing_horizontal - pseudo_font_length;
-   thumbnail_margin_height_under           = ((float)video_height * under_thumb_margin)
-                                           - xmb->margins_screen_top - xmb->icon_size;
+   thumbnail_margin_height_under           = (float)video_height
+                                           - xmb->margins_screen_top - (xmb->icon_size * 1.025f);
    thumbnail_margin_height_full            = (float)video_height - xmb->margins_title_top
                                            - ((xmb->icon_size / 4.0f) * 2.0f);
-   left_thumbnail_margin_x                 = xmb->icon_size / 4.0f;
-   right_thumbnail_margin_x                = (float)video_width - (xmb->icon_size / 8.0f)
+   left_thumbnail_margin_x                 = xmb->icon_size / 8.0f;
+   right_thumbnail_margin_x                = (float)video_width - left_thumbnail_margin_x
                                            - right_thumbnail_margin_width;
    xmb->margins_title                      = (float)settings->ints.menu_xmb_title_margin * 10.0f;
    xmb->margins_title_horizontal_offset    = (float)settings->ints.menu_xmb_title_margin_horizontal_offset * 10.0f;
@@ -8021,12 +8039,14 @@ static void xmb_frame(void *data, video_frame_info_t *video_info)
             xmb->icon_size,
             xmb->icon_size,
             xmb->textures.list[XMB_TEXTURE_ARROW],
-              xmb->x + xmb->margins_screen_left
-            + xmb->icon_spacing_horizontal
-            - xmb->icon_size / 2.0 + xmb->icon_size,
-              xmb->margins_screen_top
-            + xmb->icon_size / 2.0 + xmb->icon_spacing_vertical
-            * xmb->active_item_factor,
+            xmb->x
+               + xmb->margins_screen_left
+               + xmb->icon_spacing_horizontal
+               - (xmb->icon_size / 2.0)
+               + xmb->icon_size,
+            xmb->margins_screen_top
+               + (xmb->icon_size / 2.0)
+               + (xmb->icon_spacing_vertical * xmb->active_item_factor),
             video_width,
             video_height,
             xmb->textures_arrow_alpha,
@@ -8192,6 +8212,12 @@ static void xmb_frame(void *data, video_frame_info_t *video_info)
          && (!xmb->show_fullscreen_thumbnails)
       )
    {
+      float background_color[16] = {
+            0.0f, 0.0f, 0.0f, 1.0f,
+            0.0f, 0.0f, 0.0f, 1.0f,
+            0.0f, 0.0f, 0.0f, 1.0f,
+            0.0f, 0.0f, 0.0f, 1.0f,
+      };
       float thumb_width         = right_thumbnail_margin_width;
       float thumb_height        = thumb_width - (thumb_width / 4);
       float scaled_thumb_width  = thumb_width * thumbnail_scale_factor;
@@ -8205,17 +8231,34 @@ static void xmb_frame(void *data, video_frame_info_t *video_info)
 
       if (!xmb->use_ps3_layout)
       {
-         thumb_width         = xmb->icon_size * 2.4f;
+         float height_offset = xmb->icon_size * 0.35f;
+
+         thumb_width         = left_thumbnail_margin_width;
          thumb_height        = thumb_width - (thumb_width / 4);
          scaled_thumb_width  = thumb_width * thumbnail_scale_factor;
          scaled_thumb_height = thumb_height * thumbnail_scale_factor;
          thumb_x             = (thumb_width - scaled_thumb_width) / 2.0f;
-         thumb_y             = video_height - thumbnail_margin_height_under - (xmb->icon_size * 0.55f);
+         thumb_y             = video_height - thumbnail_margin_height_under - height_offset;
       }
 
       if (     (xmb->thumbnails.savestate.status == GFX_THUMBNAIL_STATUS_AVAILABLE)
             || (xmb->thumbnails.savestate.status == GFX_THUMBNAIL_STATUS_PENDING))
       {
+         if (settings->bools.menu_thumbnail_background_enable)
+            gfx_display_draw_quad(
+                  p_disp,
+                  userdata,
+                  video_width,
+                  video_height,
+                  thumb_x,
+                  thumb_y,
+                  scaled_thumb_width,
+                  scaled_thumb_height,
+                  video_width,
+                  video_height,
+                  background_color,
+                  NULL);
+
          gfx_thumbnail_draw(
                userdata,
                video_width,
@@ -8230,13 +8273,6 @@ static void xmb_frame(void *data, video_frame_info_t *video_info)
       }
       else
       {
-         float background_color[16]        = {
-               0.0f, 0.0f, 0.0f, 1.0f,
-               0.0f, 0.0f, 0.0f, 1.0f,
-               0.0f, 0.0f, 0.0f, 1.0f,
-               0.0f, 0.0f, 0.0f, 1.0f,
-         };
-
          /* Darken background */
          gfx_display_draw_quad(
                p_disp,
@@ -8285,7 +8321,6 @@ static void xmb_frame(void *data, video_frame_info_t *video_info)
                   && xmb->thumbnails_right_status_prev != GFX_THUMBNAIL_STATUS_UNKNOWN));
       bool show_left_thumbnail  =
                (gfx_thumbnail_is_enabled(menu_st->thumbnail_path_data, GFX_THUMBNAIL_LEFT))
-            && xmb->show_thumbnails
             && (  (xmb->thumbnails.left.status == GFX_THUMBNAIL_STATUS_AVAILABLE)
                || (  xmb->thumbnails.left.status       < GFX_THUMBNAIL_STATUS_AVAILABLE
                   && xmb->thumbnails_left_status_prev <= GFX_THUMBNAIL_STATUS_AVAILABLE
@@ -8299,6 +8334,9 @@ static void xmb_frame(void *data, video_frame_info_t *video_info)
           * stacked thumbnails */
          if (vertical_thumbnails)
          {
+            if (!xmb->show_thumbnails)
+               show_right_thumbnail = show_left_thumbnail = false;
+
             /* Right + left thumbnails, right side */
             if (show_right_thumbnail && show_left_thumbnail)
             {
@@ -8415,13 +8453,14 @@ static void xmb_frame(void *data, video_frame_info_t *video_info)
             /* Right thumbnail, right side */
             if (show_right_thumbnail)
             {
+               float y_offset            = xmb->icon_size / 1.5f;
                float thumb_width         = right_thumbnail_margin_width;
                float thumb_height        = thumbnail_margin_height_under;
                float scaled_thumb_width  = thumb_width * thumbnail_scale_factor;
                float scaled_thumb_height = thumb_height * thumbnail_scale_factor;
                float thumb_x             = right_thumbnail_margin_x
                                          + ((thumb_width - scaled_thumb_width) / 2.0f);
-               float thumb_y             = xmb->margins_screen_top + (xmb->icon_size / 1.5f);
+               float thumb_y             = xmb->margins_screen_top + y_offset;
 
                if (thumbnail_background)
                   gfx_display_draw_quad(
@@ -8454,42 +8493,50 @@ static void xmb_frame(void *data, video_frame_info_t *video_info)
             /* Left thumbnail, left side */
             if (show_left_thumbnail)
             {
-               float y_offset            = xmb->icon_size * 1.75f;
+               bool icon_thumbnails      = settings->uints.menu_icon_thumbnails;
+               float margins_title_min   = -(xmb->icon_size / 8.0f);
+               float margins_title       = (xmb->margins_title_bottom < margins_title_min)
+                     ? margins_title_min : xmb->margins_title_bottom;
+               float height_offset       = xmb->icon_size * 0.5f;
+               float y_offset            = xmb->icon_size * (icon_thumbnails ? 1.75f : 1.15f);
                float thumb_width         = left_thumbnail_margin_width;
                float thumb_height        = thumbnail_margin_height_under
-                                         - xmb->margins_title_bottom - y_offset;
+                                         - (height_offset / 2.0f) - y_offset - margins_title;
                float scaled_thumb_width  = thumb_width * thumbnail_scale_factor;
                float scaled_thumb_height = thumb_height * thumbnail_scale_factor;
                float thumb_x             = left_thumbnail_margin_x
                                          + ((thumb_width - scaled_thumb_width) / 2.0f);
-               float thumb_y             = xmb->margins_screen_top + xmb->icon_size + y_offset;
+               float thumb_y             = xmb->margins_screen_top + (height_offset * 2.0f) + y_offset;
 
-               if (thumbnail_background)
-                  gfx_display_draw_quad(
-                        p_disp,
+               if (thumb_height > xmb->icon_size)
+               {
+                  if (thumbnail_background)
+                     gfx_display_draw_quad(
+                           p_disp,
+                           userdata,
+                           video_width,
+                           video_height,
+                           thumb_x,
+                           thumb_y,
+                           scaled_thumb_width,
+                           scaled_thumb_height,
+                           video_width,
+                           video_height,
+                           background_color,
+                           NULL);
+
+                  gfx_thumbnail_draw(
                         userdata,
                         video_width,
                         video_height,
+                        &xmb->thumbnails.left,
                         thumb_x,
                         thumb_y,
-                        scaled_thumb_width,
-                        scaled_thumb_height,
-                        video_width,
-                        video_height,
-                        background_color,
-                        NULL);
-
-               gfx_thumbnail_draw(
-                     userdata,
-                     video_width,
-                     video_height,
-                     &xmb->thumbnails.left,
-                     thumb_x,
-                     thumb_y,
-                     (scaled_thumb_width  > 0.0f) ? (unsigned)scaled_thumb_width  : 0,
-                     (scaled_thumb_height > 0.0f) ? (unsigned)scaled_thumb_height : 0,
-                     (thumbnail_background) ? GFX_THUMBNAIL_ALIGN_CENTRE : GFX_THUMBNAIL_ALIGN_TOP,
-                     1.0f, 1.0f, &thumbnail_shadow);
+                        (scaled_thumb_width  > 0.0f) ? (unsigned)scaled_thumb_width  : 0,
+                        (scaled_thumb_height > 0.0f) ? (unsigned)scaled_thumb_height : 0,
+                        (thumbnail_background) ? GFX_THUMBNAIL_ALIGN_CENTRE : GFX_THUMBNAIL_ALIGN_TOP,
+                        1.0f, 1.0f, &thumbnail_shadow);
+               }
             }
          }
       }
@@ -8500,14 +8547,18 @@ static void xmb_frame(void *data, video_frame_info_t *video_info)
        *   (if available) */
       else if (show_right_thumbnail || show_left_thumbnail)
       {
-         float thumb_width         = xmb->icon_size * 2.4f;
-         float thumb_height        = thumbnail_margin_height_under
-                                   - xmb->margins_title_bottom;
+         float margins_title_min   = -(xmb->icon_size / 4.0f);
+         float margins_title       = (xmb->margins_title_bottom < margins_title_min)
+               ? margins_title_min : xmb->margins_title_bottom;
+         float height_offset       = xmb->icon_size * 0.5f;
+         float thumb_width         = left_thumbnail_margin_width;
+         float thumb_height        = thumbnail_margin_height_under + (height_offset / 2.0f)
+                                   - margins_title;
          float scaled_thumb_width  = thumb_width * thumbnail_scale_factor;
          float scaled_thumb_height = thumb_height * thumbnail_scale_factor;
          float thumb_x             = (thumb_width - scaled_thumb_width) / 2.0f;
          float thumb_y             = video_height
-                                   - thumbnail_margin_height_under - (xmb->icon_size * 0.55f);
+                                   - thumbnail_margin_height_under - height_offset;
 
          /* Very small thumbnails look ridiculous
           * > Impose a minimum size limit */

menu/menu_displaylist.c

@@ -11061,6 +11061,7 @@ unsigned menu_displaylist_build_list(
          {
             menu_displaylist_build_info_selective_t build_list[] = {
                {MENU_ENUM_LABEL_CLOUD_SYNC_ENABLE,       PARSE_ONLY_BOOL,           true},
+               {MENU_ENUM_LABEL_CLOUD_SYNC_SYNC_MODE,    PARSE_ONLY_UINT,           true},
                {MENU_ENUM_LABEL_CLOUD_SYNC_DESTRUCTIVE,  PARSE_ONLY_BOOL,           true},
                {MENU_ENUM_LABEL_CLOUD_SYNC_SYNC_SAVES,   PARSE_ONLY_BOOL,           true},
                {MENU_ENUM_LABEL_CLOUD_SYNC_SYNC_CONFIGS, PARSE_ONLY_BOOL,           true},
@@ -15242,6 +15243,15 @@ bool menu_displaylist_ctl(enum menu_displaylist_ctl_state type,
 #endif /* HAVE_LAKKA */
 #endif /* HAVE_CDROM */
 
+#if defined(HAVE_CLOUDSYNC)
+               if (settings->bools.cloud_sync_enable)
+                  if (MENU_DISPLAYLIST_PARSE_SETTINGS_ENUM(
+                        info->list,
+                        MENU_ENUM_LABEL_CLOUD_SYNC_SYNC_NOW,
+                        PARSE_ACTION, false) == 0)
+                     count++;
+#endif
+
                if (show_playlists)
                   if (menu_entries_append(info->list,
                            msg_hash_to_str(MENU_ENUM_LABEL_VALUE_PLAYLISTS_TAB),

menu/menu_driver.c

@@ -8114,6 +8114,14 @@ int generic_menu_entry_action(
       menu_st->flags &= ~(MENU_ST_FLAG_PENDING_CLOSE_CONTENT
                         | MENU_ST_FLAG_PENDING_ENV_SHUTDOWN_FLUSH);
       menu_st->pending_env_shutdown_content_path[0] = '\0';
+
+      /* Reload core on launch failure if manually loaded */
+      if (     !path_is_empty(RARCH_PATH_CORE_LAST)
+            && !(menu_st->flags & MENU_ST_FLAG_PENDING_RELOAD_CORE))
+      {
+         menu_st->flags |= MENU_ST_FLAG_PENDING_RELOAD_CORE;
+         menu_st->flags |= MENU_ST_FLAG_PENDING_ENV_SHUTDOWN_FLUSH;
+      }
    }
    else if (menu_st->flags & MENU_ST_FLAG_PENDING_RELOAD_CORE)
    {

menu/menu_setting.c

@@ -5343,6 +5343,30 @@ static size_t setting_get_string_representation_uint_input_auto_game_focus(
    return 0;
 }
 
+#ifdef HAVE_CLOUDSYNC
+static size_t setting_get_string_representation_uint_cloud_sync_sync_mode(
+      rarch_setting_t *setting, char *s, size_t len)
+{
+   if (setting)
+   {
+      switch (*setting->value.target.unsigned_integer)
+      {
+         case CLOUD_SYNC_MODE_AUTOMATIC:
+            return strlcpy(s,
+                  msg_hash_to_str(
+                     MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_AUTOMATIC),
+                  len);
+         case CLOUD_SYNC_MODE_MANUAL:
+            return strlcpy(s,
+                  msg_hash_to_str(
+                     MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE_MANUAL),
+                  len);
+      }
+   }
+   return 0;
+}
+#endif
+
 #if defined(HAVE_OVERLAY)
 static size_t setting_get_string_representation_uint_input_overlay_show_inputs(
       rarch_setting_t *setting, char *s, size_t len)
@@ -10138,6 +10162,17 @@ static bool setting_append_list(
          }
 #endif
 
+#ifdef HAVE_CLOUDSYNC
+         CONFIG_ACTION(
+               list, list_info,
+               MENU_ENUM_LABEL_CLOUD_SYNC_SYNC_NOW,
+               MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_NOW,
+               &group_info,
+               &subgroup_info,
+               parent_group);
+         MENU_SETTINGS_LIST_CURRENT_ADD_CMD(list, list_info, CMD_EVENT_CLOUD_SYNC);
+#endif
+
          CONFIG_ACTION(
                list, list_info,
                MENU_ENUM_LABEL_CONFIGURATIONS_LIST,
@@ -11793,6 +11828,23 @@ static bool setting_append_list(
                general_read_handler,
                SD_FLAG_NONE);
 
+         CONFIG_UINT(
+               list, list_info,
+               &settings->uints.cloud_sync_sync_mode,
+               MENU_ENUM_LABEL_CLOUD_SYNC_SYNC_MODE,
+               MENU_ENUM_LABEL_VALUE_CLOUD_SYNC_SYNC_MODE,
+               CLOUD_SYNC_MODE_AUTOMATIC,
+               &group_info,
+               &subgroup_info,
+               parent_group,
+               general_write_handler,
+               general_read_handler);
+         (*list)[list_info->index - 1].ui_type   = ST_UI_TYPE_UINT_COMBOBOX;
+         (*list)[list_info->index - 1].action_ok = &setting_action_ok_uint;
+         (*list)[list_info->index - 1].get_string_representation =
+            &setting_get_string_representation_uint_cloud_sync_sync_mode;
+         menu_settings_list_current_add_range(list, list_info, 0, CLOUD_SYNC_MODE_LAST-1, 1, true, true);
+
          CONFIG_STRING_OPTIONS(
                list, list_info,
                settings->arrays.cloud_sync_driver,

msg_hash.h

@@ -3279,6 +3279,9 @@ enum msg_hash_enums
    MENU_LABEL(SAVING_SETTINGS),
    MENU_LABEL(CLOUD_SYNC_SETTINGS),
    MENU_LABEL(CLOUD_SYNC_ENABLE),
+   MENU_LABEL(CLOUD_SYNC_SYNC_MODE),
+   MENU_LABEL(CLOUD_SYNC_SYNC_MODE_AUTOMATIC),
+   MENU_LABEL(CLOUD_SYNC_SYNC_MODE_MANUAL),
    MENU_LABEL(CLOUD_SYNC_DESTRUCTIVE),
    MENU_LABEL(CLOUD_SYNC_SYNC_SAVES),
    MENU_LABEL(CLOUD_SYNC_SYNC_CONFIGS),
@@ -3288,6 +3291,7 @@ enum msg_hash_enums
    MENU_LABEL(CLOUD_SYNC_URL),
    MENU_LABEL(CLOUD_SYNC_USERNAME),
    MENU_LABEL(CLOUD_SYNC_PASSWORD),
+   MENU_LABEL(CLOUD_SYNC_SYNC_NOW),
    MENU_LABEL(RECORDING_SETTINGS),
    MENU_LABEL(OVERLAY_SETTINGS),
    MENU_LABEL(REWIND_SETTINGS),

pkg/android/phoenix-common/jni/Android.mk

@@ -95,6 +95,9 @@ DEFINES += -DRARCH_MOBILE \
 	   -DHAVE_BSV_MOVIE \
 	   -DHAVE_ZLIB \
 	   -DHAVE_NO_BUILTINZLIB \
+	   -DHAVE_ZSTD \
+	   -DZSTD_DISABLE_ASM \
+	   -DHAVE_CHEEVOS_RVZ \
 	   -DHAVE_RPNG \
 	   -DHAVE_RJPEG \
 	   -DHAVE_RBMP \
@@ -183,11 +186,13 @@ LOCAL_C_INCLUDES := \
 		    $(LOCAL_PATH)/$(RARCH_DIR)/libretro-common/include \
 		    $(LOCAL_PATH)/$(RARCH_DIR)/deps \
 		    $(LOCAL_PATH)/$(RARCH_DIR)/deps/stb \
-		    $(LOCAL_PATH)/$(RARCH_DIR)/deps/7zip
+		    $(LOCAL_PATH)/$(RARCH_DIR)/deps/7zip \
+		    $(LOCAL_PATH)/$(RARCH_DIR)/deps/zstd/lib
 
 INCLUDE_DIRS     := \
 		    -I$(LOCAL_PATH)/$(DEPS_DIR)/stb/ \
 		    -I$(LOCAL_PATH)/$(DEPS_DIR)/7zip/ \
+		    -I$(LOCAL_PATH)/$(DEPS_DIR)/zstd/lib/ \
 		    -I$(LOCAL_PATH)/$(DEPS_DIR)/libFLAC/include
 
 ifeq ($(HAVE_CHEEVOS),1)

pkg/android/phoenix-legacy/AndroidManifest.xml

@@ -1,8 +1,8 @@
 <!-- <!DOCTYPE manifest [ <!ENTITY % versionDTD SYSTEM "../../../version.dtd"> %versionDTD; ]> !-->
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="com.retroarch.legacy"
-    android:versionCode="1556806385"
-    android:versionName="1.22.1"
+    android:versionCode="1556806386"
+    android:versionName="1.22.2"
     android:installLocation="internalOnly">
     <uses-feature android:glEsVersion="0x00020000" />
     <uses-feature android:name="android.hardware.touchscreen" android:required="false"/>

pkg/android/phoenix/AndroidManifest.xml

@@ -2,8 +2,8 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
           xmlns:tools="http://schemas.android.com/tools"
     package="com.retroarch"
-    android:versionCode="1597175266"
-    android:versionName="1.22.1"
+    android:versionCode="1597175267"
+    android:versionName="1.22.2"
     android:installLocation="internalOnly">
     <uses-feature android:glEsVersion="0x00020000" />
     <uses-feature android:name="android.hardware.type.pc" android:required="false"/>

pkg/apple/OSX/Info.plist

@@ -30,11 +30,11 @@
 	<key>CFBundlePackageType</key>
 	<string>APPL</string>
 	<key>CFBundleShortVersionString</key>
-	<string>1.22.1</string>
+	<string>1.22.2</string>
 	<key>CFBundleSignature</key>
 	<string>????</string>
 	<key>CFBundleVersion</key>
-	<string>1.22.1</string>
+	<string>1.22.2</string>
 	<key>LSApplicationCategoryType</key>
 	<string>public.app-category.games</string>
 	<key>LSMinimumSystemVersion</key>

pkg/apple/RetroArch_Metal.xcodeproj/project.pbxproj

@@ -1985,7 +1985,7 @@
 				);
 				LLVM_LTO = YES_THIN;
 				MACOSX_DEPLOYMENT_TARGET = 10.13;
-				MARKETING_VERSION = 1.22.1;
+				MARKETING_VERSION = 1.22.2;
 				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
 				MTL_FAST_MATH = YES;
 				ONLY_ACTIVE_ARCH = YES;
@@ -2069,7 +2069,7 @@
 				);
 				LLVM_LTO = YES_THIN;
 				MACOSX_DEPLOYMENT_TARGET = 10.13;
-				MARKETING_VERSION = 1.22.1;
+				MARKETING_VERSION = 1.22.2;
 				MTL_ENABLE_DEBUG_INFO = NO;
 				MTL_FAST_MATH = YES;
 				MTL_IGNORE_WARNINGS = YES;

pkg/apple/RetroArch_iOS10.xcodeproj/project.pbxproj

@@ -460,7 +460,7 @@
 				CODE_SIGN_IDENTITY = "iPhone Developer";
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
 				CODE_SIGN_RESOURCE_RULES_PATH = "$(SDKROOT)/ResourceRules.plist";
-				CURRENT_PROJECT_VERSION = 1.22.1;
+				CURRENT_PROJECT_VERSION = 1.22.2;
 				DEVELOPMENT_TEAM = UK699V5ZS8;
 				ENABLE_BITCODE = NO;
 				GCC_PRECOMPILE_PREFIX_HEADER = NO;
@@ -478,7 +478,7 @@
 				IPHONEOS_DEPLOYMENT_TARGET = 10.0;
 				LD_NO_PIE = YES;
 				LIBRARY_SEARCH_PATHS = "";
-				MARKETING_VERSION = 1.22.1;
+				MARKETING_VERSION = 1.22.2;
 				ONLY_ACTIVE_ARCH = NO;
 				OTHER_CFLAGS = (
 					"-DHAVE_NETWORKGAMEPAD",
@@ -564,7 +564,7 @@
 				CODE_SIGN_IDENTITY = "iPhone Developer";
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
 				CODE_SIGN_RESOURCE_RULES_PATH = "$(SDKROOT)/ResourceRules.plist";
-				CURRENT_PROJECT_VERSION = 1.22.1;
+				CURRENT_PROJECT_VERSION = 1.22.2;
 				DEVELOPMENT_TEAM = UK699V5ZS8;
 				ENABLE_BITCODE = NO;
 				GCC_PRECOMPILE_PREFIX_HEADER = NO;
@@ -582,7 +582,7 @@
 				IPHONEOS_DEPLOYMENT_TARGET = 10.0;
 				LD_NO_PIE = YES;
 				LIBRARY_SEARCH_PATHS = "";
-				MARKETING_VERSION = 1.22.1;
+				MARKETING_VERSION = 1.22.2;
 				OTHER_CFLAGS = (
 					"-DNS_BLOCK_ASSERTIONS=1",
 					"-DNDEBUG",

pkg/apple/RetroArch_iOS10_static.xcodeproj/project.pbxproj

@@ -464,7 +464,7 @@
 				CODE_SIGN_IDENTITY = "iPhone Developer";
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
 				CODE_SIGN_RESOURCE_RULES_PATH = "$(SDKROOT)/ResourceRules.plist";
-				CURRENT_PROJECT_VERSION = 1.22.1;
+				CURRENT_PROJECT_VERSION = 1.22.2;
 				DEVELOPMENT_TEAM = UK699V5ZS8;
 				ENABLE_BITCODE = NO;
 				GCC_PRECOMPILE_PREFIX_HEADER = NO;
@@ -481,7 +481,7 @@
 				IPHONEOS_DEPLOYMENT_TARGET = 10.0;
 				LD_NO_PIE = YES;
 				LIBRARY_SEARCH_PATHS = "$(PROJECT_DIR)";
-				MARKETING_VERSION = 1.22.1;
+				MARKETING_VERSION = 1.22.2;
 				ONLY_ACTIVE_ARCH = NO;
 				OTHER_CFLAGS = (
 					"-DHAVE_APPLE_STORE",
@@ -567,7 +567,7 @@
 				CODE_SIGN_IDENTITY = "iPhone Developer";
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
 				CODE_SIGN_RESOURCE_RULES_PATH = "$(SDKROOT)/ResourceRules.plist";
-				CURRENT_PROJECT_VERSION = 1.22.1;
+				CURRENT_PROJECT_VERSION = 1.22.2;
 				DEVELOPMENT_TEAM = UK699V5ZS8;
 				ENABLE_BITCODE = NO;
 				GCC_PRECOMPILE_PREFIX_HEADER = NO;
@@ -584,7 +584,7 @@
 				IPHONEOS_DEPLOYMENT_TARGET = 10.0;
 				LD_NO_PIE = YES;
 				LIBRARY_SEARCH_PATHS = "$(PROJECT_DIR)";
-				MARKETING_VERSION = 1.22.1;
+				MARKETING_VERSION = 1.22.2;
 				OTHER_CFLAGS = (
 					"-DNS_BLOCK_ASSERTIONS=1",
 					"-DNDEBUG",

pkg/apple/RetroArch_iOS11.xcodeproj/project.pbxproj

@@ -611,7 +611,7 @@
 				CODE_SIGN_IDENTITY = "iPhone Developer";
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
 				CODE_SIGN_RESOURCE_RULES_PATH = "$(SDKROOT)/ResourceRules.plist";
-				CURRENT_PROJECT_VERSION = 1.22.1;
+				CURRENT_PROJECT_VERSION = 1.22.2;
 				DEVELOPMENT_TEAM = R72X3BF4KE;
 				ENABLE_BITCODE = NO;
 				GCC_PRECOMPILE_PREFIX_HEADER = NO;
@@ -628,7 +628,7 @@
 				IPHONEOS_DEPLOYMENT_TARGET = 11.0;
 				LD_NO_PIE = YES;
 				LIBRARY_SEARCH_PATHS = "";
-				MARKETING_VERSION = 1.22.1;
+				MARKETING_VERSION = 1.22.2;
 				ONLY_ACTIVE_ARCH = NO;
 				OTHER_CFLAGS = (
 					"-DHAVE_NETWORKGAMEPAD",
@@ -711,7 +711,7 @@
 				CODE_SIGN_IDENTITY = "iPhone Developer";
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
 				CODE_SIGN_RESOURCE_RULES_PATH = "$(SDKROOT)/ResourceRules.plist";
-				CURRENT_PROJECT_VERSION = 1.22.1;
+				CURRENT_PROJECT_VERSION = 1.22.2;
 				DEVELOPMENT_TEAM = R72X3BF4KE;
 				ENABLE_BITCODE = NO;
 				GCC_PRECOMPILE_PREFIX_HEADER = NO;
@@ -728,7 +728,7 @@
 				IPHONEOS_DEPLOYMENT_TARGET = 11.0;
 				LD_NO_PIE = YES;
 				LIBRARY_SEARCH_PATHS = "";
-				MARKETING_VERSION = 1.22.1;
+				MARKETING_VERSION = 1.22.2;
 				"OTHER_CFLAGS[arch=*]" = (
 					"-DNS_BLOCK_ASSERTIONS=1",
 					"-DNDEBUG",
@@ -835,7 +835,7 @@
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CODE_SIGN_IDENTITY = "iPhone Developer";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 1.22.1;
+				CURRENT_PROJECT_VERSION = 1.22.2;
 				DEBUG_INFORMATION_FORMAT = dwarf;
 				DEVELOPMENT_TEAM = R72X3BF4KE;
 				ENABLE_STRICT_OBJC_MSGSEND = YES;
@@ -857,7 +857,7 @@
 				);
 				INFOPLIST_FILE = "$(SRCROOT)/tvOS/Info.plist";
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
-				MARKETING_VERSION = 1.22.1;
+				MARKETING_VERSION = 1.22.2;
 				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
 				MTL_FAST_MATH = YES;
 				ONLY_ACTIVE_ARCH = YES;
@@ -962,7 +962,7 @@
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CODE_SIGN_IDENTITY = "iPhone Developer";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 1.22.1;
+				CURRENT_PROJECT_VERSION = 1.22.2;
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
 				DEVELOPMENT_TEAM = R72X3BF4KE;
 				ENABLE_NS_ASSERTIONS = NO;
@@ -984,7 +984,7 @@
 				);
 				INFOPLIST_FILE = "$(SRCROOT)/tvOS/Info.plist";
 				LD_RUNPATH_SEARCH_PATHS = "$(inherited) @executable_path/Frameworks";
-				MARKETING_VERSION = 1.22.1;
+				MARKETING_VERSION = 1.22.2;
 				MTL_ENABLE_DEBUG_INFO = NO;
 				MTL_FAST_MATH = YES;
 				OTHER_CFLAGS = (

pkg/apple/RetroArch_iOS11_Metal.xcodeproj/project.pbxproj

@@ -1323,7 +1323,7 @@
 				CODE_SIGN_IDENTITY = "iPhone Developer";
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
 				CODE_SIGN_RESOURCE_RULES_PATH = "$(SDKROOT)/ResourceRules.plist";
-				CURRENT_PROJECT_VERSION = 1.22.1;
+				CURRENT_PROJECT_VERSION = 1.22.2;
 				DEPS_DIR = "$(SRCBASE)/deps";
 				DEVELOPMENT_TEAM = UK699V5ZS8;
 				ENABLE_BITCODE = NO;
@@ -1352,7 +1352,7 @@
 					"@executable_path/Frameworks",
 					"$(PROJECT_DIR)/iOS/modules",
 				);
-				MARKETING_VERSION = 1.22.1;
+				MARKETING_VERSION = 1.22.2;
 				MTL_FAST_MATH = YES;
 				ONLY_ACTIVE_ARCH = NO;
 				OTHER_CFLAGS = (
@@ -1448,7 +1448,7 @@
 				CODE_SIGN_IDENTITY = "iPhone Developer";
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
 				CODE_SIGN_RESOURCE_RULES_PATH = "$(SDKROOT)/ResourceRules.plist";
-				CURRENT_PROJECT_VERSION = 1.22.1;
+				CURRENT_PROJECT_VERSION = 1.22.2;
 				DEPS_DIR = "$(SRCBASE)/deps";
 				DEVELOPMENT_TEAM = UK699V5ZS8;
 				ENABLE_BITCODE = NO;
@@ -1477,7 +1477,7 @@
 					"@executable_path/Frameworks",
 					"$(PROJECT_DIR)/iOS/modules",
 				);
-				MARKETING_VERSION = 1.22.1;
+				MARKETING_VERSION = 1.22.2;
 				MTL_FAST_MATH = YES;
 				OTHER_CFLAGS = (
 					"-DNS_BLOCK_ASSERTIONS=1",
@@ -1654,7 +1654,7 @@
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 1.22.1;
+				CURRENT_PROJECT_VERSION = 1.22.2;
 				DEBUG_INFORMATION_FORMAT = dwarf;
 				DEPS_DIR = "$(SRCBASE)/deps";
 				DEVELOPMENT_TEAM = UK699V5ZS8;
@@ -1688,7 +1688,7 @@
 					"$(inherited)",
 					"$(PROJECT_DIR)/tvOS/modules",
 				);
-				MARKETING_VERSION = 1.22.1;
+				MARKETING_VERSION = 1.22.2;
 				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
 				MTL_FAST_MATH = YES;
 				ONLY_ACTIVE_ARCH = YES;
@@ -1795,7 +1795,7 @@
 				CLANG_WARN_UNREACHABLE_CODE = YES;
 				CODE_SIGN_IDENTITY = "Apple Development";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 1.22.1;
+				CURRENT_PROJECT_VERSION = 1.22.2;
 				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
 				DEPS_DIR = "$(SRCBASE)/deps";
 				DEVELOPMENT_TEAM = UK699V5ZS8;
@@ -1829,7 +1829,7 @@
 					"$(inherited)",
 					"$(PROJECT_DIR)/tvOS/modules",
 				);
-				MARKETING_VERSION = 1.22.1;
+				MARKETING_VERSION = 1.22.2;
 				MTL_ENABLE_DEBUG_INFO = NO;
 				MTL_FAST_MATH = YES;
 				OTHER_CFLAGS = (

pkg/apple/RetroArch_iOS11_static.xcodeproj/project.pbxproj

@@ -464,7 +464,7 @@
 				CODE_SIGN_IDENTITY = "iPhone Developer";
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
 				CODE_SIGN_RESOURCE_RULES_PATH = "$(SDKROOT)/ResourceRules.plist";
-				CURRENT_PROJECT_VERSION = 1.22.1;
+				CURRENT_PROJECT_VERSION = 1.22.2;
 				DEVELOPMENT_TEAM = UK699V5ZS8;
 				ENABLE_BITCODE = NO;
 				GCC_PRECOMPILE_PREFIX_HEADER = NO;
@@ -481,7 +481,7 @@
 				IPHONEOS_DEPLOYMENT_TARGET = 11.0;
 				LD_NO_PIE = YES;
 				LIBRARY_SEARCH_PATHS = "$(PROJECT_DIR)";
-				MARKETING_VERSION = 1.22.1;
+				MARKETING_VERSION = 1.22.2;
 				ONLY_ACTIVE_ARCH = NO;
 				OTHER_CFLAGS = (
 					"-DHAVE_APPLE_STORE",
@@ -567,7 +567,7 @@
 				CODE_SIGN_IDENTITY = "iPhone Developer";
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
 				CODE_SIGN_RESOURCE_RULES_PATH = "$(SDKROOT)/ResourceRules.plist";
-				CURRENT_PROJECT_VERSION = 1.22.1;
+				CURRENT_PROJECT_VERSION = 1.22.2;
 				DEVELOPMENT_TEAM = UK699V5ZS8;
 				ENABLE_BITCODE = NO;
 				GCC_PRECOMPILE_PREFIX_HEADER = NO;
@@ -584,7 +584,7 @@
 				IPHONEOS_DEPLOYMENT_TARGET = 11.0;
 				LD_NO_PIE = YES;
 				LIBRARY_SEARCH_PATHS = "$(PROJECT_DIR)";
-				MARKETING_VERSION = 1.22.1;
+				MARKETING_VERSION = 1.22.2;
 				OTHER_CFLAGS = (
 					"-DNS_BLOCK_ASSERTIONS=1",
 					"-DNDEBUG",

pkg/apple/RetroArch_iOS13.xcodeproj/project.pbxproj

@@ -1876,7 +1876,7 @@
 				IPHONEOS_DEPLOYMENT_TARGET = 12.0;
 				LIBRARY_SEARCH_PATHS = "";
 				LLVM_LTO = YES_THIN;
-				MARKETING_VERSION = 1.22.1;
+				MARKETING_VERSION = 1.22.2;
 				MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE;
 				MTL_FAST_MATH = YES;
 				OTHER_CFLAGS = "$(inherited)";
@@ -1935,7 +1935,7 @@
 				IPHONEOS_DEPLOYMENT_TARGET = 12.0;
 				LIBRARY_SEARCH_PATHS = "";
 				LLVM_LTO = YES_THIN;
-				MARKETING_VERSION = 1.22.1;
+				MARKETING_VERSION = 1.22.2;
 				MTL_ENABLE_DEBUG_INFO = NO;
 				MTL_FAST_MATH = YES;
 				MTL_IGNORE_WARNINGS = YES;

pkg/apple/RetroArch_iOS6.xcodeproj/project.pbxproj

@@ -455,7 +455,7 @@
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
 				CODE_SIGN_RESOURCE_RULES_PATH = "$(SDKROOT)/ResourceRules.plist";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 1.22.1;
+				CURRENT_PROJECT_VERSION = 1.22.2;
 				DEVELOPMENT_TEAM = UK699V5ZS8;
 				ENABLE_BITCODE = NO;
 				GCC_PRECOMPILE_PREFIX_HEADER = NO;
@@ -473,7 +473,7 @@
 				IPHONEOS_DEPLOYMENT_TARGET = 6.0;
 				LD_NO_PIE = YES;
 				LIBRARY_SEARCH_PATHS = "";
-				MARKETING_VERSION = 1.22.1;
+				MARKETING_VERSION = 1.22.2;
 				ONLY_ACTIVE_ARCH = NO;
 				OTHER_CFLAGS = (
 					"-DHAVE_NETWORKGAMEPAD",
@@ -556,7 +556,7 @@
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
 				CODE_SIGN_RESOURCE_RULES_PATH = "$(SDKROOT)/ResourceRules.plist";
 				CODE_SIGN_STYLE = Automatic;
-				CURRENT_PROJECT_VERSION = 1.22.1;
+				CURRENT_PROJECT_VERSION = 1.22.2;
 				DEVELOPMENT_TEAM = UK699V5ZS8;
 				ENABLE_BITCODE = NO;
 				GCC_PRECOMPILE_PREFIX_HEADER = NO;
@@ -574,7 +574,7 @@
 				IPHONEOS_DEPLOYMENT_TARGET = 6.0;
 				LD_NO_PIE = YES;
 				LIBRARY_SEARCH_PATHS = "";
-				MARKETING_VERSION = 1.22.1;
+				MARKETING_VERSION = 1.22.2;
 				OTHER_CFLAGS = (
 					"-DNS_BLOCK_ASSERTIONS=1",
 					"-DNDEBUG",

pkg/apple/RetroArch_iOS8.xcodeproj/project.pbxproj

@@ -614,7 +614,7 @@
 				CODE_SIGN_IDENTITY = "iPhone Developer";
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
 				CODE_SIGN_RESOURCE_RULES_PATH = "$(SDKROOT)/ResourceRules.plist";
-				CURRENT_PROJECT_VERSION = 1.22.1;
+				CURRENT_PROJECT_VERSION = 1.22.2;
 				DEVELOPMENT_TEAM = UK699V5ZS8;
 				ENABLE_BITCODE = NO;
 				GCC_PRECOMPILE_PREFIX_HEADER = NO;
@@ -632,7 +632,7 @@
 				IPHONEOS_DEPLOYMENT_TARGET = 8.4;
 				LD_NO_PIE = YES;
 				LIBRARY_SEARCH_PATHS = "";
-				MARKETING_VERSION = 1.22.1;
+				MARKETING_VERSION = 1.22.2;
 				ONLY_ACTIVE_ARCH = NO;
 				OTHER_CFLAGS = (
 					"-DHAVE_NETWORKGAMEPAD",
@@ -718,7 +718,7 @@
 				CODE_SIGN_IDENTITY = "iPhone Developer";
 				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer";
 				CODE_SIGN_RESOURCE_RULES_PATH = "$(SDKROOT)/ResourceRules.plist";
-				CURRENT_PROJECT_VERSION = 1.22.1;
+				CURRENT_PROJECT_VERSION = 1.22.2;
 				DEVELOPMENT_TEAM = UK699V5ZS8;
 				ENABLE_BITCODE = NO;
 				GCC_PRECOMPILE_PREFIX_HEADER = NO;
@@ -736,7 +736,7 @@
 				IPHONEOS_DEPLOYMENT_TARGET = 8.4;
 				LD_NO_PIE = YES;
 				LIBRARY_SEARCH_PATHS = "";
-				MARKETING_VERSION = 1.22.1;
+				MARKETING_VERSION = 1.22.2;
 				OTHER_CFLAGS = (
 					"-DNS_BLOCK_ASSERTIONS=1",
 					"-DNDEBUG",

pkg/qnx/bar-descriptor.xml

@@ -2,7 +2,7 @@
 <qnx xmlns="http://www.qnx.com/schemas/application/1.0">
 
     <id>com.RetroArch</id>
-    <versionNumber>1.22.1</versionNumber>
+    <versionNumber>1.22.2</versionNumber>
     <buildId>3</buildId>
     <description>Cross-platform entertainment system</description>
     <author>Team Libretro</author>

pkg/sailfishos/retroarch-sailfishos.spec

@@ -1,6 +1,6 @@
 Name:           retroarch
-Version:        1.22.1
-Release:        v1.22.1
+Version:        1.22.2
+Release:        v1.22.2
 Summary:        Official reference frontend for libretro
 
 Group:          Applications/Emulators

pkg/wii/meta.xml

@@ -2,7 +2,7 @@
 <app version="1">
   <name>RetroArch</name>
   <coder>Libretro</coder>
-  <version>1.22.1</version>
+  <version>1.22.2</version>
   <release_date>2012-2025</release_date>
   <short_description>The cross-platform entertainment system</short_description>
   <long_description>A port of RetroArch to the GameCube/Wii.</long_description>

qb/config.params.sh

@@ -158,6 +158,7 @@ HAVE_QT=auto               # Qt companion support
 C89_QT=no
 HAVE_XSHM=no               # XShm video driver support
 HAVE_CHEEVOS=yes           # Retro Achievements
+HAVE_CHEEVOS_RVZ=yes       # Retro Achievements hashing for Wii/GC RVZ files, depends on Zstd
 HAVE_LUA=no                # Lua support (for Retro Achievements)
 HAVE_DISCORD=yes           # Discord Integration
 C89_DISCORD=no

retroarch.c

@@ -3667,9 +3667,7 @@ bool command_event(enum event_command cmd, void *data)
                }
             }
 #endif
-#ifdef HAVE_CLOUDSYNC
-            task_push_cloud_sync();
-#endif
+
 #if defined(HAVE_CG) || defined(HAVE_GLSL) || defined(HAVE_SLANG) || defined(HAVE_HLSL)
             runloop_st->runtime_shader_preset_path[0] = '\0';
 #endif
@@ -3719,6 +3717,11 @@ bool command_event(enum event_command cmd, void *data)
                runloop_st->subsystem_current_count = 0;
                content_clear_subsystem();
             }
+#ifdef HAVE_CLOUDSYNC
+            /* Sync on core unload if in automatic mode */
+            if (settings->uints.cloud_sync_sync_mode == CLOUD_SYNC_MODE_AUTOMATIC)
+               task_push_cloud_sync();
+#endif
          }
 
 #ifdef HAVE_MENU
@@ -4631,6 +4634,11 @@ bool command_event(enum event_command cmd, void *data)
          command_event(CMD_EVENT_QUIT, NULL);
 #endif
          break;
+#ifdef HAVE_CLOUDSYNC
+      case CMD_EVENT_CLOUD_SYNC:
+         task_push_cloud_sync();
+         break;
+#endif
       case CMD_EVENT_MENU_RESET_TO_DEFAULT_CONFIG:
          config_set_defaults(global_get_ptr());
          break;
@@ -6040,8 +6048,9 @@ int rarch_main(int argc, char *argv[], void *data)
 #endif
          settings->bools.ui_companion_start_on_boot
          );
-#if HAVE_CLOUDSYNC
-   task_push_cloud_sync();
+#ifdef HAVE_CLOUDSYNC
+   if (settings->uints.cloud_sync_sync_mode == CLOUD_SYNC_MODE_AUTOMATIC)
+      task_push_cloud_sync();
 #endif
 #if !defined(HAVE_MAIN) || defined(HAVE_QT)
    for (;;)

runloop.c

@@ -4291,6 +4291,10 @@ static bool event_init_content(
       /* Single-click playlist return */
       if (settings->bools.input_menu_singleclick_playlists)
          menu_state_get_ptr()->flags |= MENU_ST_FLAG_PENDING_CLOSE_CONTENT;
+
+      /* Return from empty Quick Menu if core is manually loaded and needs reloading */
+      if (!path_is_empty(RARCH_PATH_CORE_LAST))
+         menu_state_get_ptr()->flags |= MENU_ST_FLAG_PENDING_CLOSE_CONTENT;
 #endif
       return false;
    }

tasks/task_database.c

@@ -384,18 +384,54 @@ static int task_database_gdi_get_serial(const char *name, char *s, size_t len, u
    return intfstream_file_get_serial(track_path, 0, INT64_MAX, s, len, filesize);
 }
 
+/* Helper function to detect if a CHD file is a CD-i disc
+ * CD-i discs store data in AUDIO-labeled tracks, so we need
+ * to explicitly open track 1 for scanning */
+static bool is_chd_file_cdi(const char *path)
+{
+   intfstream_t *fd;
+   uint8_t magic[12];
+   bool is_cdi = false;
+   const uint8_t cdi_magic[] = {0x00, 0xff, 0xff, 0xff, 0xff, 0xff,
+                                 0xff, 0xff, 0xff, 0xff, 0xff, 0x00};
+
+   /* Try to open track 1 explicitly */
+   fd = intfstream_open_chd_track(path,
+         RETRO_VFS_FILE_ACCESS_READ,
+         RETRO_VFS_FILE_ACCESS_HINT_NONE,
+         1);  /* Explicit track number, not CHDSTREAM_TRACK_FIRST_DATA */
+
+   if (!fd)
+      return false;
+
+   /* Read and check CD-i magic bytes at offset 0 */
+   if (intfstream_read(fd, magic, sizeof(magic)) == sizeof(magic))
+      is_cdi = (memcmp(magic, cdi_magic, sizeof(cdi_magic)) == 0);
+
+   intfstream_close(fd);
+   free(fd);
+   return is_cdi;
+}
+
 static int task_database_chd_get_serial(const char *name, char *serial, size_t len, uint64_t *filesize)
 {
    int result;
-   intfstream_t *fd = intfstream_open_chd_track(
+   int32_t track;
+   intfstream_t *fd;
+
+   /* CD-i discs store data in AUDIO-labeled tracks, so we must
+    * explicitly open track 1 instead of using CHDSTREAM_TRACK_FIRST_DATA */
+   track = is_chd_file_cdi(name) ? 1 : CHDSTREAM_TRACK_FIRST_DATA;
+
+   fd = intfstream_open_chd_track(
          name,
          RETRO_VFS_FILE_ACCESS_READ,
          RETRO_VFS_FILE_ACCESS_HINT_NONE,
-         CHDSTREAM_TRACK_FIRST_DATA);
+         track);
    if (!fd)
       return 0;
 
-   *filesize = intfstream_get_size(fd);
+   *filesize = intfstream_get_size(fd); /* TODO: get the full CHD size instead */
    result = intfstream_get_serial(fd, serial, len, name);
    intfstream_close(fd);
    free(fd);
@@ -503,11 +539,18 @@ static int task_database_gdi_get_crc_and_size(const char *name, uint32_t *crc, u
 static bool task_database_chd_get_crc_and_size(const char *name, uint32_t *crc, uint64_t *size)
 {
    bool found_crc   = false;
-   intfstream_t *fd = intfstream_open_chd_track(
+   int32_t track;
+   intfstream_t *fd;
+
+   /* CD-i discs store data in AUDIO-labeled tracks, so we must
+    * explicitly open track 1 instead of using CHDSTREAM_TRACK_PRIMARY */
+   track = is_chd_file_cdi(name) ? 1 : CHDSTREAM_TRACK_PRIMARY;
+
+   fd = intfstream_open_chd_track(
          name,
          RETRO_VFS_FILE_ACCESS_READ,
          RETRO_VFS_FILE_ACCESS_HINT_NONE,
-         CHDSTREAM_TRACK_PRIMARY);
+         track);
    if (!fd)
       return 0;
 
@@ -682,7 +725,7 @@ static int task_database_iterate_playlist(
       case FILE_TYPE_CHD:
          db_state->serial[0] = '\0';
          if (task_database_chd_get_serial(name, db_state->serial, sizeof(db_state->serial),&db_state->size))
-            db->type         = DATABASE_TYPE_SERIAL_LOOKUP_SIZEHINT;
+            db->type         = DATABASE_TYPE_SERIAL_LOOKUP;
          else
          {
             db->type         = DATABASE_TYPE_CRC_LOOKUP;

tasks/task_database_cue.c

@@ -62,6 +62,7 @@ static struct magic_entry MAGIC_NUMBERS[] = {
    { "Sony - PlayStation 2",        "PLAYSTATION",      0x008008}, /* PS2 DVD */
    { "Sony - PlayStation 2",        "           ",      0x008008}, /* PS2 DVD */
    { "Sony - PlayStation Portable", "PSP GAME",         0x008008},
+   { "Philips - CD-i",              "\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00", 0x000000},
    { NULL,                          NULL,               0}
 };
 
@@ -742,11 +743,21 @@ int detect_sat_game(intfstream_t *fd, char *s, size_t len, const char *filename)
    /** redump serials are built differently for each region **/
    switch (region_id)
    {
-      case 'U':
+      case 'B':  /* Brazil/multi-region (BKUT) */
+      case 'T':  /* Taiwan/Asia */
+      case 'K':  /* Korea */
+      case 'A':  /* Americas */
+      case 'U':  /* USA */
          if (     raw_game_id[0] == 'M'
                && raw_game_id[1] == 'K'
                && raw_game_id[2] == '-')
-            strlcpy(s, &raw_game_id[3], len);
+         {
+            const char *serial_start = &raw_game_id[3];
+            /* Strip leading zeros from serial number */
+            while (*serial_start == '0' && *(serial_start + 1) != '\0')
+               serial_start++;
+            strlcpy(s, serial_start, len);
+         }
          else
             strlcpy(s, raw_game_id, len);
          cue_append_multi_disc_suffix(s, filename);
@@ -1155,6 +1166,37 @@ int cue_find_track(const char *cue_path, bool first,
          task_database_cue_get_token(fd, tmp_token, sizeof(tmp_token));
          is_data = !string_is_equal_noncase(tmp_token, "AUDIO");
          ++track;
+
+         /* Special case: CD-i stores data in AUDIO-labeled tracks */
+         /* Check if track 1 is AUDIO but contains CD-i magic bytes */
+         if (!is_data && track == 1 && last_file[0] != '\0')
+         {
+            intfstream_t *track_fd = NULL;
+            intfstream_info_t track_info;
+            uint8_t magic_buf[12];
+            const uint8_t cdi_magic[] = {0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00};
+
+            track_info.type = INTFSTREAM_FILE;
+            if ((track_fd = (intfstream_t*)intfstream_init(&track_info)))
+            {
+               if (intfstream_open(track_fd, last_file,
+                     RETRO_VFS_FILE_ACCESS_READ, RETRO_VFS_FILE_ACCESS_HINT_NONE))
+               {
+                  if (intfstream_read(track_fd, magic_buf, sizeof(magic_buf)) == sizeof(magic_buf))
+                  {
+                     if (memcmp(magic_buf, cdi_magic, sizeof(cdi_magic)) == 0)
+                     {
+                        is_data = true;  /* CD-i AUDIO track contains data */
+#ifdef DEBUG
+                        RARCH_LOG("[Scanner] Detected CD-i data in AUDIO track 1\n");
+#endif
+                     }
+                  }
+                  intfstream_close(track_fd);
+               }
+               free(track_fd);
+            }
+         }
       }
       else if (string_is_equal_noncase(tmp_token, "INDEX"))
       {

version.all

@@ -6,5 +6,5 @@
 # /* - pkg/snap/snapcraft.yaml (including the github url) */
 
 #ifndef PACKAGE_VERSION
-#define PACKAGE_VERSION "1.22.1"
+#define PACKAGE_VERSION "1.22.2"
 #endif

version.dtd

@@ -1 +1 @@
-<!ENTITY version "1.22.1">
+<!ENTITY version "1.22.2">