diff --git a/Makefile.common b/Makefile.common
index 3150817b75..2a6450021a 100644
--- a/Makefile.common
+++ b/Makefile.common
@@ -26,6 +26,7 @@ SOURCES_C  += $(CORE_DIR)/libretro-common/compat/compat_strl.c \
               $(CORE_DIR)/libretro-common/streams/file_stream_transforms.c \
               $(CORE_DIR)/libretro-common/streams/memory_stream.c \
               $(CORE_DIR)/libretro-common/string/stdstring.c \
+              $(CORE_DIR)/libretro-common/time/rtime.c \
               $(CORE_DIR)/libretro-common/vfs/vfs_implementation.c
 endif
 
diff --git a/src/DSi_NWifi.cpp b/src/DSi_NWifi.cpp
index 57bd93c343..06e83c8f79 100644
--- a/src/DSi_NWifi.cpp
+++ b/src/DSi_NWifi.cpp
@@ -1002,7 +1002,7 @@ void DSi_NWifi::WMI_Command()
 
         case 0x000E: // get channel list
             {
-                int nchan = 11; // TODO: customize??
+                const int nchan = 11; // TODO: customize??
                 u8 reply[2 + (nchan*2) + 2];
 
                 reply[0] = 0;
diff --git a/src/GPU.cpp b/src/GPU.cpp
index de229b3ca8..f94eb2acb7 100644
--- a/src/GPU.cpp
+++ b/src/GPU.cpp
@@ -23,6 +23,10 @@
 
 #include "GPU2D_Soft.h"
 
+#ifdef _MSC_VER
+#include <bit>
+#endif
+
 namespace GPU
 {
 
@@ -515,7 +519,11 @@ void SetRenderSettings(int renderer, RenderSettings& settings)
 u8* GetUniqueBankPtr(u32 mask, u32 offset)
 {
     if (!mask || (mask & (mask - 1)) != 0) return NULL;
+#ifdef _MSC_VER
+    int num = std::countr_zero(mask);
+#else
     int num = __builtin_ctz(mask);
+#endif
     return &VRAM[num][offset & VRAMMask[num]];
 }
 
@@ -1211,7 +1219,11 @@ NonStupidBitField<Size/VRAMDirtyGranularity> VRAMTrackingSet<Size, MappingGranul
 
             while (mapping != 0)
             {
+#ifdef _MSC_VER
+                u32 num = std::countr_zero(mapping);
+#else
                 u32 num = __builtin_ctz(mapping);
+#endif
                 mapping &= ~(1 << num);
 
                 // hack for **speed**
@@ -1246,7 +1258,11 @@ NonStupidBitField<Size/VRAMDirtyGranularity> VRAMTrackingSet<Size, MappingGranul
 
     while (banksToBeZeroed != 0)
     {
+#ifdef _MSC_VER
+        u32 num = std::countr_zero(banksToBeZeroed);
+#else
         u32 num = __builtin_ctz(banksToBeZeroed);
+#endif
         banksToBeZeroed &= ~(1 << num);
         VRAMDirty[num].Clear();
     }
diff --git a/src/GPU3D.cpp b/src/GPU3D.cpp
index 9c02b2f3f5..fdaa929ff5 100644
--- a/src/GPU3D.cpp
+++ b/src/GPU3D.cpp
@@ -2420,7 +2420,11 @@ void ExecuteCommand()
                     break;
 
                 default:
+#ifdef _MSC_VER
+                    __assume(0);
+#else
                     __builtin_unreachable();
+#endif
                 }
             }
         }
diff --git a/src/NDSCart_SRAMManager.cpp b/src/NDSCart_SRAMManager.cpp
index ba31e8cb44..0ef7ea8be5 100644
--- a/src/NDSCart_SRAMManager.cpp
+++ b/src/NDSCart_SRAMManager.cpp
@@ -18,7 +18,9 @@
 
 #include <stdio.h>
 #include <string.h>
+#ifndef _MSC_VER
 #include <unistd.h>
+#endif
 #include <time.h>
 #include "NDSCart_SRAMManager.h"
 #include "Platform.h"
diff --git a/src/NonStupidBitfield.h b/src/NonStupidBitfield.h
index 45b160e7fa..2998276ce6 100644
--- a/src/NonStupidBitfield.h
+++ b/src/NonStupidBitfield.h
@@ -26,6 +26,10 @@
 #include <initializer_list>
 #include <algorithm>
 
+#ifdef _MSC_VER
+#include <bit>
+#endif
+
 // like std::bitset but less stupid and optimised for 
 // our use case (keeping track of memory invalidations)
 
@@ -88,8 +92,11 @@ struct NonStupidBitField
                 return;
             done:;
             }
-
+#ifdef _MSC_VER
+            BitIdx = std::countr_zero(RemainingBits);
+#else
             BitIdx = __builtin_ctzll(RemainingBits);
+#endif
             RemainingBits &= ~(1ULL << BitIdx);
 
             if ((Size & 0x3F) && BitIdx >= Size)
@@ -144,7 +151,11 @@ struct NonStupidBitField
     {
         for (u32 i = 0; i < DataLength; i++)
         {
+#ifdef _MSC_VER
+            u32 idx = std::countr_zero(Data[i]);
+#else
             u32 idx = __builtin_ctzll(Data[i]);
+#endif
             if (Data[i] && idx + i * 64 < Size)
             {
                 return {*this, i, idx, Data[i] & ~(1ULL << idx)};
diff --git a/src/Platform.h b/src/Platform.h
index 2240e458c9..2254b948e9 100644
--- a/src/Platform.h
+++ b/src/Platform.h
@@ -31,6 +31,10 @@
 #define fread rfread
 #define fseek rfseek
 
+#ifdef _MSC_VER
+#include <compat/msvc.h>
+#endif
+
 #endif
 
 namespace Platform
diff --git a/src/RTC.cpp b/src/RTC.cpp
index 905a8d86b5..0e9f852833 100644
--- a/src/RTC.cpp
+++ b/src/RTC.cpp
@@ -130,8 +130,11 @@ void ByteIn(u8 val)
                 {
                     time_t timestamp = time(NULL);
                     struct tm timedata;
+#ifdef _MSC_VER
+                    localtime_s(&timedata, &timestamp);
+#else
                     localtime_r(&timestamp, &timedata);
-
+#endif
                     Output[0] = BCD(timedata.tm_year - 100);
                     Output[1] = BCD(timedata.tm_mon + 1);
                     Output[2] = BCD(timedata.tm_mday);
@@ -146,8 +149,11 @@ void ByteIn(u8 val)
                 {
                     time_t timestamp = time(NULL);
                     struct tm timedata;
+#ifdef _MSC_VER
+                    localtime_s(&timedata, &timestamp);
+#else
                     localtime_r(&timestamp, &timedata);
-
+#endif
                     Output[0] = BCD(timedata.tm_hour);
                     Output[1] = BCD(timedata.tm_min);
                     Output[2] = BCD(timedata.tm_sec);
diff --git a/src/fatfs/ff.h b/src/fatfs/ff.h
index 6df78a8e40..cf48d510f7 100644
--- a/src/fatfs/ff.h
+++ b/src/fatfs/ff.h
@@ -35,15 +35,7 @@ extern "C" {
 
 /* Integer types used for FatFs API */
 
-#if defined(_WIN32)		/* Windows VC++ (for development only) */
-#define FF_INTDEF 2
-#include <windows.h>
-typedef unsigned __int64 QWORD;
-#include <float.h>
-#define isnan(v) _isnan(v)
-#define isinf(v) (!_finite(v))
-
-#elif (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__cplusplus)	/* C99 or later */
+#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__cplusplus)	/* C99 or later */
 #define FF_INTDEF 2
 #include <stdint.h>
 typedef unsigned int	UINT;	/* int must be 16-bit or 32-bit */
@@ -53,6 +45,12 @@ typedef uint32_t		DWORD;	/* 32-bit unsigned integer */
 typedef uint64_t		QWORD;	/* 64-bit unsigned integer */
 typedef WORD			WCHAR;	/* UTF-16 character type */
 
+#if defined(_WIN32)
+#include <float.h>
+#define isnan(v) _isnan(v)
+#define isinf(v) (!_finite(v))
+#endif
+
 #else  	/* Earlier than C99 */
 #define FF_INTDEF 1
 typedef unsigned int	UINT;	/* int must be 16-bit or 32-bit */
diff --git a/src/fatfs/ffsystem.c b/src/fatfs/ffsystem.c
index b0409efa69..3983978460 100644
--- a/src/fatfs/ffsystem.c
+++ b/src/fatfs/ffsystem.c
@@ -109,7 +109,11 @@ DWORD get_fattime()
 
     time_t timestamp = time(NULL);
     struct tm timedata;
+#ifdef _MSC_VER
+    localtime_s(&timedata, &timestamp);
+#else
     localtime_r(&timestamp, &timedata);
+#endif
 
     DWORD ret;
     ret  = (timedata.tm_sec >> 1);
diff --git a/src/libretro/libretro-common/.gitignore b/src/libretro/libretro-common/.gitignore
index 5761abcfdf..4e88cc3908 100644
--- a/src/libretro/libretro-common/.gitignore
+++ b/src/libretro/libretro-common/.gitignore
@@ -1 +1,6 @@
-*.o
+glsm/
+*.[od]
+*.dll
+*.so
+*.dylib
+*.exe
diff --git a/src/libretro/libretro-common/audio/audio_mix.c b/src/libretro/libretro-common/audio/audio_mix.c
index 15879ab248..eb138edd44 100644
--- a/src/libretro/libretro-common/audio/audio_mix.c
+++ b/src/libretro/libretro-common/audio/audio_mix.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (audio_mix.c).
@@ -20,7 +20,11 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#include <audio/audio_mix.h>
+#include <stdlib.h>
+#include <string.h>
+#include <memalign.h>
+
+#include <retro_environment.h>
 
 #if defined(__SSE2__)
 #include <emmintrin.h>
@@ -28,10 +32,6 @@
 #include <altivec.h>
 #endif
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <memalign.h>
 #include <retro_miscellaneous.h>
 #include <audio/audio_mix.h>
 #include <streams/file_stream.h>
@@ -48,7 +48,7 @@ void audio_mix_volume_C(float *out, const float *in, float vol, size_t samples)
 #ifdef __SSE2__
 void audio_mix_volume_SSE2(float *out, const float *in, float vol, size_t samples)
 {
-   size_t i;
+   size_t i, remaining_samples;
    __m128 volume = _mm_set1_ps(vol);
 
    for (i = 0; i + 16 <= samples; i += 16, out += 16, in += 16)
@@ -71,7 +71,10 @@ void audio_mix_volume_SSE2(float *out, const float *in, float vol, size_t sample
          _mm_storeu_ps(out + 4 * j, _mm_add_ps(input[j], additive[j]));
    }
 
-   audio_mix_volume_C(out, in, vol, samples - i);
+   remaining_samples = samples - i;
+
+   for (i = 0; i < remaining_samples; i++)
+      out[i] += in[i] * vol;
 }
 #endif
 
@@ -80,12 +83,14 @@ void audio_mix_free_chunk(audio_chunk_t *chunk)
    if (!chunk)
       return;
 
+#ifdef HAVE_RWAV
    if (chunk->rwav && chunk->rwav->samples)
    {
       /* rwav_free only frees the samples */
       rwav_free(chunk->rwav);
       free(chunk->rwav);
    }
+#endif
 
    if (chunk->buf)
       free(chunk->buf);
@@ -108,57 +113,89 @@ void audio_mix_free_chunk(audio_chunk_t *chunk)
    free(chunk);
 }
 
-audio_chunk_t* audio_mix_load_wav_file(const char *path, int sample_rate)
+audio_chunk_t* audio_mix_load_wav_file(const char *path, int sample_rate,
+      const char *resampler_ident, enum resampler_quality quality)
 {
+#ifdef HAVE_RWAV
    int sample_size;
-   int64_t len          = 0;
-   void *buf            = NULL;
-   audio_chunk_t *chunk = (audio_chunk_t*)calloc(1, sizeof(*chunk));
+   int64_t len                = 0;
+   void *buf                  = NULL;
+   audio_chunk_t *chunk       = (audio_chunk_t*)malloc(sizeof(*chunk));
 
    if (!chunk)
       return NULL;
 
+   chunk->buf                 = NULL;
+   chunk->upsample_buf        = NULL;
+   chunk->float_buf           = NULL;
+   chunk->float_resample_buf  = NULL;
+   chunk->resample_buf        = NULL;
+   chunk->len                 = 0;
+   chunk->resample_len        = 0;
+   chunk->sample_rate         = sample_rate;
+   chunk->resample            = false;
+   chunk->resampler           = NULL;
+   chunk->resampler_data      = NULL;
+   chunk->ratio               = 0.00f;
+   chunk->rwav                = (rwav_t*)malloc(sizeof(rwav_t));
+
+   if (!chunk->rwav)
+      goto error;
+
+   chunk->rwav->bitspersample = 0;
+   chunk->rwav->numchannels   = 0;
+   chunk->rwav->samplerate    = 0;
+   chunk->rwav->numsamples    = 0;
+   chunk->rwav->subchunk2size = 0;
+   chunk->rwav->samples       = NULL;
+
    if (!filestream_read_file(path, &buf, &len))
-   {
-      printf("Could not open WAV file for reading.\n");
       goto error;
-   }
 
-   chunk->sample_rate = sample_rate;
-   chunk->buf         = buf;
-   chunk->len         = len;
-   chunk->rwav        = (rwav_t*)malloc(sizeof(rwav_t));
+   chunk->buf                 = buf;
+   chunk->len                 = len;
 
    if (rwav_load(chunk->rwav, chunk->buf, chunk->len) == RWAV_ITERATE_ERROR)
-   {
-      printf("error: could not load WAV file\n");
       goto error;
-   }
 
    /* numsamples does not know or care about
     * multiple channels, but we need space for 2 */
-   chunk->upsample_buf = (int16_t*)memalign_alloc(128,
+   chunk->upsample_buf        = (int16_t*)memalign_alloc(128,
          chunk->rwav->numsamples * 2 * sizeof(int16_t));
 
-   sample_size = chunk->rwav->bitspersample / 8;
+   sample_size                = chunk->rwav->bitspersample / 8;
 
    if (sample_size == 1)
    {
       unsigned i;
 
-     for (i = 0; i < chunk->rwav->numsamples; i++)
-     {
-        uint8_t *sample                     = (
-              (uint8_t*)chunk->rwav->samples) +
-           (i * chunk->rwav->numchannels);
-
-        chunk->upsample_buf[i * 2]          = (int16_t)((sample[0] - 128) << 8);
+      if (chunk->rwav->numchannels == 1)
+      {
+         for (i = 0; i < chunk->rwav->numsamples; i++)
+         {
+            uint8_t *sample                  = (
+                  (uint8_t*)chunk->rwav->samples) + i;
 
-        if (chunk->rwav->numchannels == 1)
-           chunk->upsample_buf[(i * 2) + 1] = (int16_t)((sample[0] - 128) << 8);
-        else if (chunk->rwav->numchannels == 2)
-           chunk->upsample_buf[(i * 2) + 1] = (int16_t)((sample[1] - 128) << 8);
-     }
+            chunk->upsample_buf[i * 2]       = 
+               (int16_t)((sample[0] - 128) << 8);
+            chunk->upsample_buf[(i * 2) + 1] = 
+               (int16_t)((sample[0] - 128) << 8);
+         }
+      }
+      else if (chunk->rwav->numchannels == 2)
+      {
+         for (i = 0; i < chunk->rwav->numsamples; i++)
+         {
+            uint8_t *sample                  = (
+                  (uint8_t*)chunk->rwav->samples) +
+               (i * 2);
+
+            chunk->upsample_buf[i * 2]       = 
+               (int16_t)((sample[0] - 128) << 8);
+            chunk->upsample_buf[(i * 2) + 1] = 
+               (int16_t)((sample[1] - 128) << 8);
+         }
+      }
    }
    else if (sample_size == 2)
    {
@@ -168,43 +205,50 @@ audio_chunk_t* audio_mix_load_wav_file(const char *path, int sample_rate)
 
          for (i = 0; i < chunk->rwav->numsamples; i++)
          {
-            int16_t sample                   = ((int16_t*)chunk->rwav->samples)[i];
+            int16_t sample                   = ((int16_t*)
+                  chunk->rwav->samples)[i];
 
             chunk->upsample_buf[i * 2]       = sample;
             chunk->upsample_buf[(i * 2) + 1] = sample;
          }
       }
       else if (chunk->rwav->numchannels == 2)
-         memcpy(chunk->upsample_buf, chunk->rwav->samples, chunk->rwav->subchunk2size);
+         memcpy(chunk->upsample_buf, chunk->rwav->samples,
+               chunk->rwav->subchunk2size);
    }
    else if (sample_size != 2)
    {
       /* we don't support any other sample size besides 8 and 16-bit yet */
-      printf("error: we don't support a sample size of %d\n", sample_size);
       goto error;
    }
 
    if (sample_rate != (int)chunk->rwav->samplerate)
    {
       chunk->resample = true;
-      chunk->ratio = (double)sample_rate / chunk->rwav->samplerate;
+      chunk->ratio    = (double)sample_rate / chunk->rwav->samplerate;
 
       retro_resampler_realloc(&chunk->resampler_data,
             &chunk->resampler,
-            NULL,
-            RESAMPLER_QUALITY_DONTCARE,
+            resampler_ident,
+            quality,
             chunk->ratio);
 
       if (chunk->resampler && chunk->resampler_data)
       {
          struct resampler_data info;
 
-         chunk->float_buf = (float*)memalign_alloc(128, chunk->rwav->numsamples * 2 * chunk->ratio * sizeof(float));
+         chunk->float_buf          = (float*)memalign_alloc(128,
+               chunk->rwav->numsamples * 2 * 
+               chunk->ratio * sizeof(float));
 
-         /* why is *3 needed instead of just *2? does the sinc driver require more space than we know about? */
-         chunk->float_resample_buf = (float*)memalign_alloc(128, chunk->rwav->numsamples * 3 * chunk->ratio * sizeof(float));
+         /* why is *3 needed instead of just *2? Does the 
+          * sinc driver require more space than we know about? */
+         chunk->float_resample_buf = (float*)memalign_alloc(128,
+               chunk->rwav->numsamples * 3 * 
+               chunk->ratio * sizeof(float));
 
-         convert_s16_to_float(chunk->float_buf, chunk->upsample_buf, chunk->rwav->numsamples * 2, 1.0);
+         convert_s16_to_float(chunk->float_buf,
+               chunk->upsample_buf, chunk->rwav->numsamples * 2, 1.0);
 
          info.data_in       = (const float*)chunk->float_buf;
          info.data_out      = chunk->float_resample_buf;
@@ -216,10 +260,13 @@ audio_chunk_t* audio_mix_load_wav_file(const char *path, int sample_rate)
 
          chunk->resampler->process(chunk->resampler_data, &info);
 
-         /* number of output_frames does not increase with multiple channels, but assume we need space for 2 */
-         chunk->resample_buf = (int16_t*)memalign_alloc(128, info.output_frames * 2 * sizeof(int16_t));
+         /* number of output_frames does not increase with 
+          * multiple channels, but assume we need space for 2 */
+         chunk->resample_buf = (int16_t*)memalign_alloc(128,
+               info.output_frames * 2 * sizeof(int16_t));
          chunk->resample_len = info.output_frames;
-         convert_float_to_s16(chunk->resample_buf, chunk->float_resample_buf, info.output_frames * 2);
+         convert_float_to_s16(chunk->resample_buf,
+               chunk->float_resample_buf, info.output_frames * 2);
       }
    }
 
@@ -227,6 +274,7 @@ audio_chunk_t* audio_mix_load_wav_file(const char *path, int sample_rate)
 
 error:
    audio_mix_free_chunk(chunk);
+#endif
    return NULL;
 }
 
@@ -235,12 +283,14 @@ size_t audio_mix_get_chunk_num_samples(audio_chunk_t *chunk)
    if (!chunk)
       return 0;
 
+#ifdef HAVE_RWAV
    if (chunk->rwav)
    {
       if (chunk->resample)
          return chunk->resample_len;
       return chunk->rwav->numsamples;
    }
+#endif
 
    /* no other filetypes supported yet */
    return 0;
@@ -256,11 +306,13 @@ size_t audio_mix_get_chunk_num_samples(audio_chunk_t *chunk)
  *
  * Returns: A signed 16-bit audio sample.
  **/
-int16_t audio_mix_get_chunk_sample(audio_chunk_t *chunk, unsigned channel, size_t index)
+int16_t audio_mix_get_chunk_sample(audio_chunk_t *chunk,
+      unsigned channel, size_t index)
 {
    if (!chunk)
       return 0;
 
+#ifdef HAVE_RWAV
    if (chunk->rwav)
    {
       int sample_size    = chunk->rwav->bitspersample / 8;
@@ -271,15 +323,18 @@ int16_t audio_mix_get_chunk_sample(audio_chunk_t *chunk, unsigned channel, size_
 
       if (chunk->resample)
          sample = (uint8_t*)chunk->resample_buf +
-            (sample_size * index * chunk->rwav->numchannels) + (channel * sample_size);
+            (sample_size * index * chunk->rwav->numchannels) 
+            + (channel * sample_size);
       else
          sample = (uint8_t*)chunk->upsample_buf +
-            (sample_size * index * chunk->rwav->numchannels) + (channel * sample_size);
+            (sample_size * index * chunk->rwav->numchannels) 
+            + (channel * sample_size);
 
       sample_out = (int16_t)*sample;
 
       return sample_out;
    }
+#endif
 
    /* no other filetypes supported yet */
    return 0;
@@ -290,6 +345,7 @@ int16_t* audio_mix_get_chunk_samples(audio_chunk_t *chunk)
    if (!chunk)
       return 0;
 
+#ifdef HAVE_RWAV
    if (chunk->rwav)
    {
       int16_t *sample;
@@ -301,6 +357,7 @@ int16_t* audio_mix_get_chunk_samples(audio_chunk_t *chunk)
 
       return sample;
    }
+#endif
 
    return NULL;
 }
@@ -310,8 +367,10 @@ int audio_mix_get_chunk_num_channels(audio_chunk_t *chunk)
    if (!chunk)
       return 0;
 
+#ifdef HAVE_RWAV
    if (chunk->rwav)
       return chunk->rwav->numchannels;
+#endif
 
    /* don't support other formats yet */
    return 0;
diff --git a/src/libretro/libretro-common/audio/audio_mixer.c b/src/libretro/libretro-common/audio/audio_mixer.c
index f717761796..a274989be4 100644
--- a/src/libretro/libretro-common/audio/audio_mixer.c
+++ b/src/libretro/libretro-common/audio/audio_mixer.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (audio_mixer.c).
@@ -20,10 +20,16 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
+#ifdef HAVE_CONFIG_H
+#include "../../config.h"
+#endif
+
 #include <audio/audio_mixer.h>
 #include <audio/audio_resampler.h>
 
+#ifdef HAVE_RWAV
 #include <formats/rwav.h>
+#endif
 #include <memalign.h>
 
 #include <stdio.h>
@@ -31,10 +37,6 @@
 #include <string.h>
 #include <math.h>
 
-#ifdef HAVE_CONFIG_H
-#include "../../config.h"
-#endif
-
 #ifdef HAVE_STB_VORBIS
 #define STB_VORBIS_NO_PUSHDATA_API
 #define STB_VORBIS_NO_STDIO
@@ -59,6 +61,15 @@
 #include <ibxm/ibxm.h>
 #endif
 
+#ifdef HAVE_THREADS
+#include <rthreads/rthreads.h>
+#define AUDIO_MIXER_LOCK(voice)   slock_lock(voice->lock)
+#define AUDIO_MIXER_UNLOCK(voice) slock_unlock(voice->lock)
+#else
+#define AUDIO_MIXER_LOCK(voice)   do {} while(0)
+#define AUDIO_MIXER_UNLOCK(voice) do {} while(0)
+#endif
+
 #define AUDIO_MIXER_MAX_VOICES      8
 #define AUDIO_MIXER_TEMP_BUFFER 8192
 
@@ -71,16 +82,16 @@ struct audio_mixer_sound
       struct
       {
          /* wav */
-         unsigned frames;
          const float* pcm;
+         unsigned frames;
       } wav;
 
 #ifdef HAVE_STB_VORBIS
       struct
       {
          /* ogg */
-         unsigned size;
          const void* data;
+         unsigned size;
       } ogg;
 #endif
 
@@ -88,8 +99,8 @@ struct audio_mixer_sound
       struct
       {
           /* flac */
-         unsigned size;
          const void* data;
+         unsigned size;
       } flac;
 #endif
 
@@ -97,8 +108,8 @@ struct audio_mixer_sound
       struct
       {
           /* mp */
-         unsigned size;
          const void* data;
+         unsigned size;
       } mp3;
 #endif
 
@@ -106,8 +117,8 @@ struct audio_mixer_sound
       struct
       {
          /* mod/s3m/xm */
-         unsigned size;
          const void* data;
+         unsigned size;
       } mod;
 #endif
    } types;
@@ -115,13 +126,7 @@ struct audio_mixer_sound
 
 struct audio_mixer_voice
 {
-   bool     repeat;
-   unsigned type;
-   float    volume;
-   audio_mixer_sound_t *sound;
-   audio_mixer_stop_cb_t stop_cb;
-
-   union
+   struct
    {
       struct
       {
@@ -131,63 +136,75 @@ struct audio_mixer_voice
 #ifdef HAVE_STB_VORBIS
       struct
       {
+         stb_vorbis *stream;
+         void       *resampler_data;
+         const retro_resampler_t *resampler;
+         float      *buffer;
          unsigned    position;
          unsigned    samples;
          unsigned    buf_samples;
-         float*      buffer;
          float       ratio;
-         stb_vorbis *stream;
-         void       *resampler_data;
-         const retro_resampler_t *resampler;
       } ogg;
 #endif
 
 #ifdef HAVE_DR_FLAC
       struct
       {
-         unsigned    position;
-         unsigned    samples;
-         unsigned    buf_samples;
          float*      buffer;
-         float       ratio;
          drflac      *stream;
          void        *resampler_data;
          const retro_resampler_t *resampler;
+         unsigned    position;
+         unsigned    samples;
+         unsigned    buf_samples;
+         float       ratio;
       } flac;
 #endif
 
 #ifdef HAVE_DR_MP3
       struct
       {
+         drmp3       stream;
+         void        *resampler_data;
+         const retro_resampler_t *resampler;
+         float*      buffer;
          unsigned    position;
          unsigned    samples;
          unsigned    buf_samples;
-         float*      buffer;
          float       ratio;
-         drmp3       stream;
-         void        *resampler_data;
-         const retro_resampler_t *resampler;
       } mp3;
 #endif
 
 #ifdef HAVE_IBXM
       struct
       {
-         unsigned          position;
-         unsigned          samples;
-         unsigned          buf_samples;
          int*              buffer;
          struct replay*    stream;
          struct module*    module;
+         unsigned          position;
+         unsigned          samples;
+         unsigned          buf_samples;
       } mod;
 #endif
    } types;
+   audio_mixer_sound_t *sound;
+   audio_mixer_stop_cb_t stop_cb;
+   unsigned type;
+   float    volume;
+   bool     repeat;
+#ifdef HAVE_THREADS
+   slock_t *lock;
+#endif
 };
 
-static struct audio_mixer_voice s_voices[AUDIO_MIXER_MAX_VOICES] = {{0}};
+/* TODO/FIXME - static globals */
+static struct audio_mixer_voice s_voices[AUDIO_MIXER_MAX_VOICES] = {0};
 static unsigned s_rate = 0;
 
-static bool wav2float(const rwav_t* wav, float** pcm, size_t samples_out)
+static void audio_mixer_release(audio_mixer_voice_t* voice);
+
+#ifdef HAVE_RWAV
+static bool wav_to_float(const rwav_t* wav, float** pcm, size_t samples_out)
 {
    size_t i;
    /* Allocate on a 16-byte boundary, and pad to a multiple of 16 bytes */
@@ -263,28 +280,27 @@ static bool wav2float(const rwav_t* wav, float** pcm, size_t samples_out)
 }
 
 static bool one_shot_resample(const float* in, size_t samples_in,
-      unsigned rate, float** out, size_t* samples_out)
+      unsigned rate, const char *resampler_ident, enum resampler_quality quality,
+      float** out, size_t* samples_out)
 {
    struct resampler_data info;
    void* data                         = NULL;
    const retro_resampler_t* resampler = NULL;
    float ratio                        = (double)s_rate / (double)rate;
 
-   if (!retro_resampler_realloc(&data, &resampler, NULL,
-            RESAMPLER_QUALITY_DONTCARE, ratio))
+   if (!retro_resampler_realloc(&data, &resampler,
+         resampler_ident, quality, ratio))
       return false;
 
-   /*
-    * Allocate on a 16-byte boundary, and pad to a multiple of 16 bytes. We
-    * add four more samples in the formula below just as safeguard, because
+   /* Allocate on a 16-byte boundary, and pad to a multiple of 16 bytes. We
+    * add 16 more samples in the formula below just as safeguard, because
     * resampler->process sometimes reports more output samples than the
     * formula below calculates. Ideally, audio resamplers should have a
     * function to return the number of samples they will output given a
-    * count of input samples.
-    */
-   *samples_out                       = samples_in * ratio + 4;
+    * count of input samples. */
+   *samples_out                       = (size_t)(samples_in * ratio);
    *out                               = (float*)memalign_alloc(16,
-         ((*samples_out + 15) & ~15) * sizeof(float));
+         (((*samples_out + 16) + 15) & ~15) * sizeof(float));
 
    if (*out == NULL)
       return false;
@@ -299,6 +315,7 @@ static bool one_shot_resample(const float* in, size_t samples_in,
    resampler->free(data);
    return true;
 }
+#endif
 
 void audio_mixer_init(unsigned rate)
 {
@@ -307,7 +324,15 @@ void audio_mixer_init(unsigned rate)
    s_rate = rate;
 
    for (i = 0; i < AUDIO_MIXER_MAX_VOICES; i++)
-      s_voices[i].type = AUDIO_MIXER_TYPE_NONE;
+   {
+      audio_mixer_voice_t *voice = &s_voices[i];
+
+      voice->type = AUDIO_MIXER_TYPE_NONE;
+#ifdef HAVE_THREADS
+      if (!voice->lock)
+         voice->lock = slock_new();
+#endif
+   }
 }
 
 void audio_mixer_done(void)
@@ -315,11 +340,23 @@ void audio_mixer_done(void)
    unsigned i;
 
    for (i = 0; i < AUDIO_MIXER_MAX_VOICES; i++)
-      s_voices[i].type = AUDIO_MIXER_TYPE_NONE;
+   {
+      audio_mixer_voice_t *voice = &s_voices[i];
+
+      AUDIO_MIXER_LOCK(voice);
+      audio_mixer_release(voice);
+      AUDIO_MIXER_UNLOCK(voice);
+#ifdef HAVE_THREADS
+      slock_free(voice->lock);
+      voice->lock = NULL;
+#endif
+   }
 }
 
-audio_mixer_sound_t* audio_mixer_load_wav(void *buffer, int32_t size)
+audio_mixer_sound_t* audio_mixer_load_wav(void *buffer, int32_t size,
+      const char *resampler_ident, enum resampler_quality quality)
 {
+#ifdef HAVE_RWAV
    /* WAV data */
    rwav_t wav;
    /* WAV samples converted to float */
@@ -327,22 +364,29 @@ audio_mixer_sound_t* audio_mixer_load_wav(void *buffer, int32_t size)
    size_t samples             = 0;
    /* Result */
    audio_mixer_sound_t* sound = NULL;
-   enum rwav_state rwav_ret   = rwav_load(&wav, buffer, size);
 
-   if (rwav_ret != RWAV_ITERATE_DONE)
+   wav.bitspersample          = 0;
+   wav.numchannels            = 0;
+   wav.samplerate             = 0;
+   wav.numsamples             = 0;
+   wav.subchunk2size          = 0;
+   wav.samples                = NULL;
+
+   if ((rwav_load(&wav, buffer, size)) != RWAV_ITERATE_DONE)
       return NULL;
 
    samples       = wav.numsamples * 2;
 
-   if (!wav2float(&wav, &pcm, samples))
+   if (!wav_to_float(&wav, &pcm, samples))
       return NULL;
 
    if (wav.samplerate != s_rate)
    {
       float* resampled           = NULL;
 
-      if (!one_shot_resample(pcm, samples,
-               wav.samplerate, &resampled, &samples))
+      if (!one_shot_resample(pcm, samples, wav.samplerate,
+            resampler_ident, quality,
+            &resampled, &samples))
          return NULL;
 
       memalign_free((void*)pcm);
@@ -364,6 +408,9 @@ audio_mixer_sound_t* audio_mixer_load_wav(void *buffer, int32_t size)
    rwav_free(&wav);
 
    return sound;
+#else
+   return NULL;
+#endif
 }
 
 audio_mixer_sound_t* audio_mixer_load_ogg(void *buffer, int32_t size)
@@ -499,6 +546,8 @@ static bool audio_mixer_play_ogg(
       audio_mixer_sound_t* sound,
       audio_mixer_voice_t* voice,
       bool repeat, float volume,
+      const char *resampler_ident,
+      enum resampler_quality quality,
       audio_mixer_stop_cb_t stop_cb)
 {
    stb_vorbis_info info;
@@ -522,14 +571,20 @@ static bool audio_mixer_play_ogg(
       ratio = (double)s_rate / (double)info.sample_rate;
 
       if (!retro_resampler_realloc(&resampler_data,
-               &resamp, NULL, RESAMPLER_QUALITY_DONTCARE,
+               &resamp, resampler_ident, quality,
                ratio))
          goto error;
    }
 
+   /* Allocate on a 16-byte boundary, and pad to a multiple of 16 bytes. We
+    * add 16 more samples in the formula below just as safeguard, because
+    * resampler->process sometimes reports more output samples than the
+    * formula below calculates. Ideally, audio resamplers should have a
+    * function to return the number of samples they will output given a
+    * count of input samples. */
    samples                         = (unsigned)(AUDIO_MIXER_TEMP_BUFFER * ratio);
    ogg_buffer                      = (float*)memalign_alloc(16,
-         ((samples + 15) & ~15) * sizeof(float));
+         (((samples + 16) + 15) & ~15) * sizeof(float));
 
    if (!ogg_buffer)
    {
@@ -538,14 +593,6 @@ static bool audio_mixer_play_ogg(
       goto error;
    }
 
-   /* "system" menu sounds may reuse the same voice without freeing anything first, so do that here if needed */
-   if (voice->types.ogg.stream)
-      stb_vorbis_close(voice->types.ogg.stream);
-   if (voice->types.ogg.resampler && voice->types.ogg.resampler_data)
-      voice->types.ogg.resampler->free(voice->types.ogg.resampler_data);
-   if (voice->types.ogg.buffer)
-      memalign_free(voice->types.ogg.buffer);
-
    voice->types.ogg.resampler      = resamp;
    voice->types.ogg.resampler_data = resampler_data;
    voice->types.ogg.buffer         = (float*)ogg_buffer;
@@ -561,6 +608,17 @@ static bool audio_mixer_play_ogg(
    stb_vorbis_close(stb_vorbis);
    return false;
 }
+
+static void audio_mixer_release_ogg(audio_mixer_voice_t* voice)
+{
+   if (voice->types.ogg.stream)
+      stb_vorbis_close(voice->types.ogg.stream);
+   if (voice->types.ogg.resampler && voice->types.ogg.resampler_data)
+      voice->types.ogg.resampler->free(voice->types.ogg.resampler_data);
+   if (voice->types.ogg.buffer)
+      memalign_free(voice->types.ogg.buffer);
+}
+
 #endif
 
 #ifdef HAVE_IBXM
@@ -618,12 +676,6 @@ static bool audio_mixer_play_mod(
       goto error;
    }
 
-   /* FIXME: stopping and then starting a mod stream will crash here in dispose_replay (ASAN says struct replay is misaligned?) */
-   if (voice->types.mod.stream)
-      dispose_replay(voice->types.mod.stream);
-   if (voice->types.mod.buffer)
-      memalign_free(voice->types.mod.buffer);
-
    voice->types.mod.buffer         = (int*)mod_buffer;
    voice->types.mod.buf_samples    = buf_samples;
    voice->types.mod.stream         = replay;
@@ -640,6 +692,14 @@ static bool audio_mixer_play_mod(
    return false;
 
 }
+
+static void audio_mixer_release_mod(audio_mixer_voice_t* voice)
+{
+   if (voice->types.mod.stream)
+      dispose_replay(voice->types.mod.stream);
+   if (voice->types.mod.buffer)
+      memalign_free(voice->types.mod.buffer);
+}
 #endif
 
 #ifdef HAVE_DR_FLAC
@@ -647,6 +707,8 @@ static bool audio_mixer_play_flac(
       audio_mixer_sound_t* sound,
       audio_mixer_voice_t* voice,
       bool repeat, float volume,
+      const char *resampler_ident,
+      enum resampler_quality quality,
       audio_mixer_stop_cb_t stop_cb)
 {
    float ratio                     = 1.0f;
@@ -663,14 +725,20 @@ static bool audio_mixer_play_flac(
       ratio = (double)s_rate / (double)(dr_flac->sampleRate);
 
       if (!retro_resampler_realloc(&resampler_data,
-               &resamp, NULL, RESAMPLER_QUALITY_DONTCARE,
+               &resamp, resampler_ident, quality,
                ratio))
          goto error;
    }
 
+   /* Allocate on a 16-byte boundary, and pad to a multiple of 16 bytes. We
+    * add 16 more samples in the formula below just as safeguard, because
+    * resampler->process sometimes reports more output samples than the
+    * formula below calculates. Ideally, audio resamplers should have a
+    * function to return the number of samples they will output given a
+    * count of input samples. */
    samples                         = (unsigned)(AUDIO_MIXER_TEMP_BUFFER * ratio);
-   flac_buffer                      = (float*)memalign_alloc(16,
-         ((samples + 15) & ~15) * sizeof(float));
+   flac_buffer                     = (float*)memalign_alloc(16,
+         (((samples + 16) + 15) & ~15) * sizeof(float));
 
    if (!flac_buffer)
    {
@@ -679,13 +747,6 @@ static bool audio_mixer_play_flac(
       goto error;
    }
 
-   if (voice->types.flac.stream)
-      drflac_close(voice->types.flac.stream);
-   if (voice->types.flac.resampler && voice->types.flac.resampler_data)
-      voice->types.flac.resampler->free(voice->types.flac.resampler_data);
-   if (voice->types.flac.buffer)
-      memalign_free(voice->types.flac.buffer);
-
    voice->types.flac.resampler      = resamp;
    voice->types.flac.resampler_data = resampler_data;
    voice->types.flac.buffer         = (float*)flac_buffer;
@@ -701,6 +762,16 @@ static bool audio_mixer_play_flac(
    drflac_close(dr_flac);
    return false;
 }
+
+static void audio_mixer_release_flac(audio_mixer_voice_t* voice)
+{
+   if (voice->types.flac.stream)
+      drflac_close(voice->types.flac.stream);
+   if (voice->types.flac.resampler && voice->types.flac.resampler_data)
+      voice->types.flac.resampler->free(voice->types.flac.resampler_data);
+   if (voice->types.flac.buffer)
+      memalign_free(voice->types.flac.buffer);
+}
 #endif
 
 #ifdef HAVE_DR_MP3
@@ -708,6 +779,8 @@ static bool audio_mixer_play_mp3(
       audio_mixer_sound_t* sound,
       audio_mixer_voice_t* voice,
       bool repeat, float volume,
+      const char *resampler_ident,
+      enum resampler_quality quality,
       audio_mixer_stop_cb_t stop_cb)
 {
    float ratio                     = 1.0f;
@@ -717,12 +790,6 @@ static bool audio_mixer_play_mp3(
    const retro_resampler_t* resamp = NULL;
    bool res;
 
-   if (voice->types.mp3.stream.pData)
-   {
-      drmp3_uninit(&voice->types.mp3.stream);
-      memset(&voice->types.mp3.stream, 0, sizeof(voice->types.mp3.stream));
-   }
-
    res = drmp3_init_memory(&voice->types.mp3.stream, (const unsigned char*)sound->types.mp3.data, sound->types.mp3.size, NULL);
 
    if (!res)
@@ -733,14 +800,20 @@ static bool audio_mixer_play_mp3(
       ratio = (double)s_rate / (double)(voice->types.mp3.stream.sampleRate);
 
       if (!retro_resampler_realloc(&resampler_data,
-               &resamp, NULL, RESAMPLER_QUALITY_DONTCARE,
+               &resamp, resampler_ident, quality,
                ratio))
          goto error;
    }
 
+   /* Allocate on a 16-byte boundary, and pad to a multiple of 16 bytes. We
+    * add 16 more samples in the formula below just as safeguard, because
+    * resampler->process sometimes reports more output samples than the
+    * formula below calculates. Ideally, audio resamplers should have a
+    * function to return the number of samples they will output given a
+    * count of input samples. */
    samples                         = (unsigned)(AUDIO_MIXER_TEMP_BUFFER * ratio);
    mp3_buffer                      = (float*)memalign_alloc(16,
-         ((samples + 15) & ~15) * sizeof(float));
+         (((samples + 16) + 15) & ~15) * sizeof(float));
 
    if (!mp3_buffer)
    {
@@ -749,12 +822,6 @@ static bool audio_mixer_play_mp3(
       goto error;
    }
 
-   /* "system" menu sounds may reuse the same voice without freeing anything first, so do that here if needed */
-   if (voice->types.mp3.resampler && voice->types.mp3.resampler_data)
-      voice->types.mp3.resampler->free(voice->types.mp3.resampler_data);
-   if (voice->types.mp3.buffer)
-      memalign_free(voice->types.mp3.buffer);
-
    voice->types.mp3.resampler      = resamp;
    voice->types.mp3.resampler_data = resampler_data;
    voice->types.mp3.buffer         = (float*)mp3_buffer;
@@ -769,10 +836,24 @@ static bool audio_mixer_play_mp3(
    drmp3_uninit(&voice->types.mp3.stream);
    return false;
 }
+
+static void audio_mixer_release_mp3(audio_mixer_voice_t* voice)
+{
+   if (voice->types.mp3.resampler && voice->types.mp3.resampler_data)
+      voice->types.mp3.resampler->free(voice->types.mp3.resampler_data);
+   if (voice->types.mp3.buffer)
+      memalign_free(voice->types.mp3.buffer);
+   if (voice->types.mp3.stream.pData)
+      drmp3_uninit(&voice->types.mp3.stream);
+}
+
 #endif
 
-audio_mixer_voice_t* audio_mixer_play(audio_mixer_sound_t* sound, bool repeat,
-      float volume, audio_mixer_stop_cb_t stop_cb)
+audio_mixer_voice_t* audio_mixer_play(audio_mixer_sound_t* sound,
+      bool repeat, float volume,
+      const char *resampler_ident,
+      enum resampler_quality quality,
+      audio_mixer_stop_cb_t stop_cb)
 {
    unsigned i;
    bool res                   = false;
@@ -786,6 +867,17 @@ audio_mixer_voice_t* audio_mixer_play(audio_mixer_sound_t* sound, bool repeat,
       if (voice->type != AUDIO_MIXER_TYPE_NONE)
          continue;
 
+      AUDIO_MIXER_LOCK(voice);
+
+      if (voice->type != AUDIO_MIXER_TYPE_NONE)
+      {
+         AUDIO_MIXER_UNLOCK(voice);
+         continue;
+      }
+
+      /* claim the voice, also helps with cleanup on error */
+      voice->type = sound->type;
+
       switch (sound->type)
       {
          case AUDIO_MIXER_TYPE_WAV:
@@ -793,7 +885,8 @@ audio_mixer_voice_t* audio_mixer_play(audio_mixer_sound_t* sound, bool repeat,
             break;
          case AUDIO_MIXER_TYPE_OGG:
 #ifdef HAVE_STB_VORBIS
-            res = audio_mixer_play_ogg(sound, voice, repeat, volume, stop_cb);
+            res = audio_mixer_play_ogg(sound, voice, repeat, volume,
+                  resampler_ident, quality, stop_cb);
 #endif
             break;
          case AUDIO_MIXER_TYPE_MOD:
@@ -803,12 +896,14 @@ audio_mixer_voice_t* audio_mixer_play(audio_mixer_sound_t* sound, bool repeat,
             break;
          case AUDIO_MIXER_TYPE_FLAC:
 #ifdef HAVE_DR_FLAC
-            res = audio_mixer_play_flac(sound, voice, repeat, volume, stop_cb);
+            res = audio_mixer_play_flac(sound, voice, repeat, volume,
+                  resampler_ident, quality, stop_cb);
 #endif
             break;
          case AUDIO_MIXER_TYPE_MP3:
 #ifdef HAVE_DR_MP3
-            res = audio_mixer_play_mp3(sound, voice, repeat, volume, stop_cb);
+            res = audio_mixer_play_mp3(sound, voice, repeat, volume,
+                  resampler_ident, quality, stop_cb);
 #endif
             break;
          case AUDIO_MIXER_TYPE_NONE:
@@ -820,18 +915,61 @@ audio_mixer_voice_t* audio_mixer_play(audio_mixer_sound_t* sound, bool repeat,
 
    if (res)
    {
-      voice->type     = sound->type;
       voice->repeat   = repeat;
       voice->volume   = volume;
       voice->sound    = sound;
       voice->stop_cb  = stop_cb;
+      AUDIO_MIXER_UNLOCK(voice);
    }
    else
+   {
+      if (i < AUDIO_MIXER_MAX_VOICES)
+      {
+         audio_mixer_release(voice);
+         AUDIO_MIXER_UNLOCK(voice);
+      }
       voice = NULL;
+   }
 
    return voice;
 }
 
+/* Need to hold lock for voice.  */
+static void audio_mixer_release(audio_mixer_voice_t* voice)
+{
+   if (!voice)
+      return;
+
+   switch (voice->type)
+   {
+#ifdef HAVE_STB_VORBIS
+      case AUDIO_MIXER_TYPE_OGG:
+         audio_mixer_release_ogg(voice);
+         break;
+#endif
+#ifdef HAVE_IBXM
+      case AUDIO_MIXER_TYPE_MOD:
+         audio_mixer_release_mod(voice);
+         break;
+#endif
+#ifdef HAVE_DR_FLAC
+      case AUDIO_MIXER_TYPE_FLAC:
+         audio_mixer_release_flac(voice);
+         break;
+#endif
+#ifdef HAVE_DR_MP3
+      case AUDIO_MIXER_TYPE_MP3:
+         audio_mixer_release_mp3(voice);
+         break;
+#endif
+      default:
+         break;
+   }
+
+   memset(&voice->types, 0, sizeof(voice->types));
+   voice->type = AUDIO_MIXER_TYPE_NONE;
+}
+
 void audio_mixer_stop(audio_mixer_voice_t* voice)
 {
    audio_mixer_stop_cb_t stop_cb = NULL;
@@ -839,10 +977,13 @@ void audio_mixer_stop(audio_mixer_voice_t* voice)
 
    if (voice)
    {
-      stop_cb = voice->stop_cb;
-      sound   = voice->sound;
+      AUDIO_MIXER_LOCK(voice);
+      stop_cb     = voice->stop_cb;
+      sound       = voice->sound;
 
-      voice->type = AUDIO_MIXER_TYPE_NONE;
+      audio_mixer_release(voice);
+
+      AUDIO_MIXER_UNLOCK(voice);
 
       if (stop_cb)
          stop_cb(sound, AUDIO_MIXER_SOUND_STOPPED);
@@ -882,7 +1023,7 @@ static void audio_mixer_mix_wav(float* buffer, size_t num_frames,
       if (voice->stop_cb)
          voice->stop_cb(voice->sound, AUDIO_MIXER_SOUND_FINISHED);
 
-      voice->type = AUDIO_MIXER_TYPE_NONE;
+      audio_mixer_release(voice);
    }
    else
    {
@@ -899,15 +1040,20 @@ static void audio_mixer_mix_ogg(float* buffer, size_t num_frames,
       float volume)
 {
    int i;
-   struct resampler_data info = { 0 };
-   float temp_buffer[AUDIO_MIXER_TEMP_BUFFER] = { 0 };
+   float* temp_buffer = NULL;
    unsigned buf_free                = (unsigned)(num_frames * 2);
    unsigned temp_samples            = 0;
    float* pcm                       = NULL;
 
+   if (!voice->types.ogg.stream)
+      return;
+
    if (voice->types.ogg.position == voice->types.ogg.samples)
    {
 again:
+      if (temp_buffer == NULL)
+         temp_buffer = (float*)malloc(AUDIO_MIXER_TEMP_BUFFER * sizeof(float));
+
       temp_samples = stb_vorbis_get_samples_float_interleaved(
             voice->types.ogg.stream, 2, temp_buffer,
             AUDIO_MIXER_TEMP_BUFFER) * 2;
@@ -922,28 +1068,30 @@ static void audio_mixer_mix_ogg(float* buffer, size_t num_frames,
             stb_vorbis_seek_start(voice->types.ogg.stream);
             goto again;
          }
-         else
-         {
-            if (voice->stop_cb)
-               voice->stop_cb(voice->sound, AUDIO_MIXER_SOUND_FINISHED);
 
-            voice->type = AUDIO_MIXER_TYPE_NONE;
-            return;
-         }
-      }
+         if (voice->stop_cb)
+            voice->stop_cb(voice->sound, AUDIO_MIXER_SOUND_FINISHED);
 
-      info.data_in              = temp_buffer;
-      info.data_out             = voice->types.ogg.buffer;
-      info.input_frames         = temp_samples / 2;
-      info.output_frames        = 0;
-      info.ratio                = voice->types.ogg.ratio;
+         audio_mixer_release(voice);
+         goto cleanup;
+      }
 
       if (voice->types.ogg.resampler)
       {
-        voice->types.ogg.resampler->process(voice->types.ogg.resampler_data, &info);
+         struct resampler_data info;
+         info.data_in = temp_buffer;
+         info.data_out = voice->types.ogg.buffer;
+         info.input_frames = temp_samples / 2;
+         info.output_frames = 0;
+         info.ratio = voice->types.ogg.ratio;
+
+         voice->types.ogg.resampler->process(
+               voice->types.ogg.resampler_data, &info);
       }
       else
-        memcpy(voice->types.ogg.buffer, temp_buffer, temp_samples * sizeof(float));
+         memcpy(voice->types.ogg.buffer, temp_buffer,
+               temp_samples * sizeof(float));
+
       voice->types.ogg.position = 0;
       voice->types.ogg.samples  = voice->types.ogg.buf_samples;
    }
@@ -958,15 +1106,16 @@ static void audio_mixer_mix_ogg(float* buffer, size_t num_frames,
       buf_free -= voice->types.ogg.samples;
       goto again;
    }
-   else
-   {
-      int i;
-      for (i = buf_free; i != 0; --i )
-         *buffer++ += *pcm++ * volume;
 
-      voice->types.ogg.position += buf_free;
-      voice->types.ogg.samples  -= buf_free;
-   }
+   for (i = buf_free; i != 0; --i )
+      *buffer++ += *pcm++ * volume;
+
+   voice->types.ogg.position += buf_free;
+   voice->types.ogg.samples  -= buf_free;
+
+cleanup:
+   if (temp_buffer != NULL)
+      free(temp_buffer);
 }
 #endif
 
@@ -977,18 +1126,15 @@ static void audio_mixer_mix_mod(float* buffer, size_t num_frames,
 {
    int i;
    float samplef                    = 0.0f;
-   int samplei                      = 0;
    unsigned temp_samples            = 0;
    unsigned buf_free                = (unsigned)(num_frames * 2);
    int* pcm                         = NULL;
 
-   if (voice->types.mod.position == voice->types.mod.samples)
+   if (voice->types.mod.samples == 0)
    {
 again:
       temp_samples = replay_get_audio(
-            voice->types.mod.stream, voice->types.mod.buffer );
-
-      temp_samples *= 2; /* stereo */
+            voice->types.mod.stream, voice->types.mod.buffer, 0 ) * 2;
 
       if (temp_samples == 0)
       {
@@ -1000,14 +1146,12 @@ static void audio_mixer_mix_mod(float* buffer, size_t num_frames,
             replay_seek( voice->types.mod.stream, 0);
             goto again;
          }
-         else
-         {
-            if (voice->stop_cb)
-               voice->stop_cb(voice->sound, AUDIO_MIXER_SOUND_FINISHED);
 
-            voice->type = AUDIO_MIXER_TYPE_NONE;
-            return;
-         }
+         if (voice->stop_cb)
+            voice->stop_cb(voice->sound, AUDIO_MIXER_SOUND_FINISHED);
+
+         audio_mixer_release(voice);
+         return;
       }
 
       voice->types.mod.position = 0;
@@ -1019,29 +1163,24 @@ static void audio_mixer_mix_mod(float* buffer, size_t num_frames,
    {
       for (i = voice->types.mod.samples; i != 0; i--)
       {
-         samplei     = *pcm++ * volume;
-         samplef     = (float)((int)samplei + 32768) / 65535.0f;
+         samplef     = ((float)(*pcm++) + 32768.0f) / 65535.0f;
          samplef     = samplef * 2.0f - 1.0f;
-         *buffer++  += samplef;
+         *buffer++  += samplef * volume;
       }
 
       buf_free -= voice->types.mod.samples;
       goto again;
    }
-   else
-   {
-      int i;
-      for (i = buf_free; i != 0; --i )
-      {
-         samplei     = *pcm++ * volume;
-         samplef     = (float)((int)samplei + 32768) / 65535.0f;
-         samplef     = samplef * 2.0f - 1.0f;
-         *buffer++  += samplef;
-      }
 
-      voice->types.mod.position += buf_free;
-      voice->types.mod.samples  -= buf_free;
+   for (i = buf_free; i != 0; --i )
+   {
+      samplef     = ((float)(*pcm++) + 32768.0f) / 65535.0f;
+      samplef     = samplef * 2.0f - 1.0f;
+      *buffer++  += samplef * volume;
    }
+
+   voice->types.mod.position += buf_free;
+   voice->types.mod.samples  -= buf_free;
 }
 #endif
 
@@ -1051,11 +1190,11 @@ static void audio_mixer_mix_flac(float* buffer, size_t num_frames,
       float volume)
 {
    int i;
-   struct resampler_data info = { 0 };
+   struct resampler_data info;
    float temp_buffer[AUDIO_MIXER_TEMP_BUFFER] = { 0 };
    unsigned buf_free                = (unsigned)(num_frames * 2);
    unsigned temp_samples            = 0;
-   float* pcm                       = NULL;
+   float *pcm                       = NULL;
 
    if (voice->types.flac.position == voice->types.flac.samples)
    {
@@ -1071,14 +1210,12 @@ static void audio_mixer_mix_flac(float* buffer, size_t num_frames,
             drflac_seek_to_sample(voice->types.flac.stream,0);
             goto again;
          }
-         else
-         {
-            if (voice->stop_cb)
-               voice->stop_cb(voice->sound, AUDIO_MIXER_SOUND_FINISHED);
 
-            voice->type = AUDIO_MIXER_TYPE_NONE;
-            return;
-         }
+         if (voice->stop_cb)
+            voice->stop_cb(voice->sound, AUDIO_MIXER_SOUND_FINISHED);
+
+         audio_mixer_release(voice);
+         return;
       }
 
       info.data_in              = temp_buffer;
@@ -1088,11 +1225,10 @@ static void audio_mixer_mix_flac(float* buffer, size_t num_frames,
       info.ratio                = voice->types.flac.ratio;
 
       if (voice->types.flac.resampler)
-      {
-        voice->types.flac.resampler->process(voice->types.flac.resampler_data, &info);
-      }
+         voice->types.flac.resampler->process(
+               voice->types.flac.resampler_data, &info);
       else
-        memcpy(voice->types.flac.buffer, temp_buffer, temp_samples * sizeof(float));
+         memcpy(voice->types.flac.buffer, temp_buffer, temp_samples * sizeof(float));
       voice->types.flac.position = 0;
       voice->types.flac.samples  = voice->types.flac.buf_samples;
    }
@@ -1107,15 +1243,12 @@ static void audio_mixer_mix_flac(float* buffer, size_t num_frames,
       buf_free -= voice->types.flac.samples;
       goto again;
    }
-   else
-   {
-      int i;
-      for (i = buf_free; i != 0; --i )
-         *buffer++ += *pcm++ * volume;
 
-      voice->types.flac.position += buf_free;
-      voice->types.flac.samples  -= buf_free;
-   }
+   for (i = buf_free; i != 0; --i )
+      *buffer++ += *pcm++ * volume;
+
+   voice->types.flac.position += buf_free;
+   voice->types.flac.samples  -= buf_free;
 }
 #endif
 
@@ -1125,7 +1258,7 @@ static void audio_mixer_mix_mp3(float* buffer, size_t num_frames,
       float volume)
 {
    int i;
-   struct resampler_data info = { 0 };
+   struct resampler_data info;
    float temp_buffer[AUDIO_MIXER_TEMP_BUFFER] = { 0 };
    unsigned buf_free                = (unsigned)(num_frames * 2);
    unsigned temp_samples            = 0;
@@ -1134,7 +1267,9 @@ static void audio_mixer_mix_mp3(float* buffer, size_t num_frames,
    if (voice->types.mp3.position == voice->types.mp3.samples)
    {
 again:
-      temp_samples = (unsigned)drmp3_read_f32(&voice->types.mp3.stream, AUDIO_MIXER_TEMP_BUFFER/2, temp_buffer) * 2;
+      temp_samples = (unsigned)drmp3_read_f32(
+            &voice->types.mp3.stream,
+            AUDIO_MIXER_TEMP_BUFFER / 2, temp_buffer) * 2;
 
       if (temp_samples == 0)
       {
@@ -1146,14 +1281,12 @@ static void audio_mixer_mix_mp3(float* buffer, size_t num_frames,
             drmp3_seek_to_frame(&voice->types.mp3.stream,0);
             goto again;
          }
-         else
-         {
-            if (voice->stop_cb)
-               voice->stop_cb(voice->sound, AUDIO_MIXER_SOUND_FINISHED);
 
-            voice->type = AUDIO_MIXER_TYPE_NONE;
-            return;
-         }
+         if (voice->stop_cb)
+            voice->stop_cb(voice->sound, AUDIO_MIXER_SOUND_FINISHED);
+
+         audio_mixer_release(voice);
+         return;
       }
 
       info.data_in              = temp_buffer;
@@ -1163,9 +1296,11 @@ static void audio_mixer_mix_mp3(float* buffer, size_t num_frames,
       info.ratio                = voice->types.mp3.ratio;
 
       if (voice->types.mp3.resampler)
-        voice->types.mp3.resampler->process(voice->types.mp3.resampler_data, &info);
+         voice->types.mp3.resampler->process(
+               voice->types.mp3.resampler_data, &info);
       else
-        memcpy(voice->types.mp3.buffer, temp_buffer, temp_samples * sizeof(float));
+         memcpy(voice->types.mp3.buffer, temp_buffer,
+               temp_samples * sizeof(float));
       voice->types.mp3.position = 0;
       voice->types.mp3.samples  = voice->types.mp3.buf_samples;
    }
@@ -1180,19 +1315,17 @@ static void audio_mixer_mix_mp3(float* buffer, size_t num_frames,
       buf_free -= voice->types.mp3.samples;
       goto again;
    }
-   else
-   {
-      int i;
-      for (i = buf_free; i != 0; --i )
-         *buffer++ += *pcm++ * volume;
 
-      voice->types.mp3.position += buf_free;
-      voice->types.mp3.samples  -= buf_free;
-   }
+   for (i = buf_free; i != 0; --i )
+      *buffer++ += *pcm++ * volume;
+
+   voice->types.mp3.position += buf_free;
+   voice->types.mp3.samples  -= buf_free;
 }
 #endif
 
-void audio_mixer_mix(float* buffer, size_t num_frames, float volume_override, bool override)
+void audio_mixer_mix(float* buffer, size_t num_frames,
+      float volume_override, bool override)
 {
    unsigned i;
    size_t j                   = 0;
@@ -1201,7 +1334,11 @@ void audio_mixer_mix(float* buffer, size_t num_frames, float volume_override, bo
 
    for (i = 0; i < AUDIO_MIXER_MAX_VOICES; i++, voice++)
    {
-      float volume = (override) ? volume_override : voice->volume;
+      float volume;
+
+      AUDIO_MIXER_LOCK(voice);
+
+      volume = (override) ? volume_override : voice->volume;
 
       switch (voice->type)
       {
@@ -1231,9 +1368,11 @@ void audio_mixer_mix(float* buffer, size_t num_frames, float volume_override, bo
          case AUDIO_MIXER_TYPE_NONE:
             break;
       }
+
+      AUDIO_MIXER_UNLOCK(voice);
    }
 
-   for (j = 0, sample = buffer; j < num_frames; j++, sample++)
+   for (j = 0, sample = buffer; j < num_frames * 2; j++, sample++)
    {
       if (*sample < -1.0f)
          *sample = -1.0f;
@@ -1255,5 +1394,7 @@ void audio_mixer_voice_set_volume(audio_mixer_voice_t *voice, float val)
    if (!voice)
       return;
 
+   AUDIO_MIXER_LOCK(voice);
    voice->volume = val;
+   AUDIO_MIXER_UNLOCK(voice);
 }
diff --git a/src/libretro/libretro-common/audio/conversion/float_to_s16.c b/src/libretro/libretro-common/audio/conversion/float_to_s16.c
index baf8b4fd01..6f65fe1588 100644
--- a/src/libretro/libretro-common/audio/conversion/float_to_s16.c
+++ b/src/libretro/libretro-common/audio/conversion/float_to_s16.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2021 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (float_to_s16.c).
@@ -31,46 +31,93 @@
 #include <features/features_cpu.h>
 #include <audio/conversion/float_to_s16.h>
 
-#if defined(__ARM_NEON__) && !defined(DONT_WANT_ARM_OPTIMIZATIONS)
+#if (defined(__ARM_NEON__) || defined(HAVE_NEON))
 static bool float_to_s16_neon_enabled = false;
-void convert_float_s16_asm(int16_t *out, const float *in, size_t samples);
+#ifdef HAVE_ARM_NEON_ASM_OPTIMIZATIONS
+void convert_float_s16_asm(int16_t *out,
+      const float *in, size_t samples);
+#else
+#include <arm_neon.h>
 #endif
 
-/**
- * convert_float_to_s16:
- * @out               : output buffer
- * @in                : input buffer
- * @samples           : size of samples to be converted
- *
- * Converts floating point
- * to signed integer 16-bit.
- *
- * C implementation callback function.
- **/
 void convert_float_to_s16(int16_t *out,
       const float *in, size_t samples)
 {
-   size_t i      = 0;
+   size_t i           = 0;
+   if (float_to_s16_neon_enabled)
+   {
+      float        gf = (1<<15);
+      float32x4_t vgf = {gf, gf, gf, gf};
+      while (samples >= 8)
+      {
+#ifdef HAVE_ARM_NEON_ASM_OPTIMIZATIONS
+         size_t aligned_samples = samples & ~7;
+         if (aligned_samples)
+            convert_float_s16_asm(out, in, aligned_samples);
+
+         out                += aligned_samples;
+         in                 += aligned_samples;
+         samples            -= aligned_samples;
+         i                   = 0;
+#else
+         int16x4x2_t oreg;
+         int32x4x2_t creg;
+         float32x4x2_t inreg = vld2q_f32(in);
+         creg.val[0]         = vcvtq_s32_f32(vmulq_f32(inreg.val[0], vgf));
+         creg.val[1]         = vcvtq_s32_f32(vmulq_f32(inreg.val[1], vgf));
+         oreg.val[0]         = vqmovn_s32(creg.val[0]);
+         oreg.val[1]         = vqmovn_s32(creg.val[1]);
+         vst2_s16(out, oreg);
+         in                 += 8;
+         out                += 8;
+         samples            -= 8;
+#endif
+      }
+   }
+
+   for (; i < samples; i++)
+   {
+      int32_t val = (int32_t)(in[i] * 0x8000);
+      out[i]      = (val > 0x7FFF) ? 0x7FFF :
+         (val < -0x8000 ? -0x8000 : (int16_t)val);
+   }
+}
+
+void convert_float_to_s16_init_simd(void)
+{
+   uint64_t cpu = cpu_features_get();
+
+   if (cpu & RETRO_SIMD_NEON)
+      float_to_s16_neon_enabled = true;
+}
+#else
+void convert_float_to_s16(int16_t *out,
+      const float *in, size_t samples)
+{
+   size_t i          = 0;
 #if defined(__SSE2__)
-   __m128 factor = _mm_set1_ps((float)0x8000);
+   __m128 factor     = _mm_set1_ps((float)0x8000);
+   /* Initialize a 4D vector with 32768.0 for its elements */
 
    for (i = 0; i + 8 <= samples; i += 8, in += 8, out += 8)
-   {
-      __m128 input_l = _mm_loadu_ps(in + 0);
-      __m128 input_r = _mm_loadu_ps(in + 4);
-      __m128 res_l   = _mm_mul_ps(input_l, factor);
-      __m128 res_r   = _mm_mul_ps(input_r, factor);
-      __m128i ints_l = _mm_cvtps_epi32(res_l);
-      __m128i ints_r = _mm_cvtps_epi32(res_r);
-      __m128i packed = _mm_packs_epi32(ints_l, ints_r);
-
-      _mm_storeu_si128((__m128i *)out, packed);
+   { /* Skip forward 8 samples at a time... */
+      __m128 input_a = _mm_loadu_ps(in + 0); /* Create a 4-float vector from the next four samples... */
+      __m128 input_b = _mm_loadu_ps(in + 4); /* ...and another from the *next* next four. */
+      __m128 res_a   = _mm_mul_ps(input_a, factor);
+      __m128 res_b   = _mm_mul_ps(input_b, factor); /* Multiply these samples by 32768 */
+      __m128i ints_a = _mm_cvtps_epi32(res_a);
+      __m128i ints_b = _mm_cvtps_epi32(res_b); /* Convert the samples to 32-bit integers */
+      __m128i packed = _mm_packs_epi32(ints_a, ints_b); /* Then convert them to 16-bit ints, clamping to [-32768, 32767] */
+
+      _mm_storeu_si128((__m128i *)out, packed); /* Then put the result in the output array */
    }
 
-   samples = samples - i;
-   i       = 0;
+   samples           = samples - i;
+   i                 = 0;
+   /* If there are any stray samples at the end, we need to convert them
+    * (maybe the original array didn't contain a multiple of 8 samples) */
 #elif defined(__ALTIVEC__)
-   int samples_in = samples;
+   int samples_in    = samples;
 
    /* Unaligned loads/store is a bit expensive,
     * so we optimize for the good path (very likely). */
@@ -86,25 +133,12 @@ void convert_float_to_s16(int16_t *out,
          vec_st(vec_packs(result0, result1), 0, out);
       }
 
-      samples_in -= i;
+      samples_in    -= i;
    }
 
-   samples = samples_in;
-   i       = 0;
-#elif defined(__ARM_NEON__) && !defined(DONT_WANT_ARM_OPTIMIZATIONS)
-   if (float_to_s16_neon_enabled)
-   {
-      size_t aligned_samples = samples & ~7;
-      if (aligned_samples)
-         convert_float_s16_asm(out, in, aligned_samples);
-
-      out     = out     + aligned_samples;
-      in      = in      + aligned_samples;
-      samples = samples - aligned_samples;
-      i       = 0;
-   }
+   samples           = samples_in;
+   i                 = 0;
 #elif defined(_MIPS_ARCH_ALLEGREX)
-
 #ifdef DEBUG
    /* Make sure the buffers are 16 byte aligned, this should be
     * the default behaviour of malloc in the PSPSDK.
@@ -132,29 +166,18 @@ void convert_float_to_s16(int16_t *out,
             ".set    pop                  \n"
             :: "r"(in + i), "r"(out + i));
    }
-
 #endif
 
+   /* This loop converts stray samples to the right format,
+    * but it's also a fallback in case no SIMD instructions are available. */
    for (; i < samples; i++)
    {
-      int32_t val = (int32_t)(in[i] * 0x8000);
-      out[i]      = (val > 0x7FFF) ? 0x7FFF :
-         (val < -0x8000 ? -0x8000 : (int16_t)val);
+      int32_t val    = (int32_t)(in[i] * 0x8000);
+      out[i]         = (val > 0x7FFF) 
+         ? 0x7FFF 
+         : (val < -0x8000 ? -0x8000 : (int16_t)val);
    }
 }
 
-/**
- * convert_float_to_s16_init_simd:
- *
- * Sets up function pointers for conversion
- * functions based on CPU features.
- **/
-void convert_float_to_s16_init_simd(void)
-{
-#if defined(__ARM_NEON__) && !defined(DONT_WANT_ARM_OPTIMIZATIONS)
-   unsigned cpu = cpu_features_get();
-
-   if (cpu & RETRO_SIMD_NEON)
-      float_to_s16_neon_enabled = true;
+void convert_float_to_s16_init_simd(void) { }
 #endif
-}
diff --git a/src/libretro/libretro-common/audio/conversion/float_to_s16_neon.S b/src/libretro/libretro-common/audio/conversion/float_to_s16_neon.S
index 9df58ce024..951084ff16 100644
--- a/src/libretro/libretro-common/audio/conversion/float_to_s16_neon.S
+++ b/src/libretro/libretro-common/audio/conversion/float_to_s16_neon.S
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (float_to_s16_neon.S).
@@ -19,7 +19,7 @@
  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-#if defined(__ARM_NEON__) && !defined(DONT_WANT_ARM_OPTIMIZATIONS)
+#if defined(__ARM_NEON__) && defined(HAVE_ARM_NEON_ASM_OPTIMIZATIONS)
 
 #ifndef __MACH__
 .arm
diff --git a/src/libretro/libretro-common/audio/conversion/float_to_s16_neon.c b/src/libretro/libretro-common/audio/conversion/float_to_s16_neon.c
index ab3f14e414..85f4a96529 100644
--- a/src/libretro/libretro-common/audio/conversion/float_to_s16_neon.c
+++ b/src/libretro/libretro-common/audio/conversion/float_to_s16_neon.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (float_to_s16_neon.S).
@@ -19,7 +19,7 @@
  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-#if defined(__ARM_NEON__) && !defined(DONT_WANT_ARM_OPTIMIZATIONS)
+#if defined(__ARM_NEON__) && defined(HAVE_ARM_NEON_ASM_OPTIMIZATIONS)
 
 #if defined(__thumb__)
 #define DECL_ARMMODE(x) "  .align 2\n" "  .global " x "\n" "  .thumb\n" "  .thumb_func\n" "  .type " x ", %function\n" x ":\n"
diff --git a/src/libretro/libretro-common/audio/conversion/s16_to_float.c b/src/libretro/libretro-common/audio/conversion/s16_to_float.c
index d65afa48be..03a836dea6 100644
--- a/src/libretro/libretro-common/audio/conversion/s16_to_float.c
+++ b/src/libretro/libretro-common/audio/conversion/s16_to_float.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2021 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (s16_to_float.c).
@@ -29,28 +29,71 @@
 #include <features/features_cpu.h>
 #include <audio/conversion/s16_to_float.h>
 
-#if defined(__ARM_NEON__) && !defined(DONT_WANT_ARM_OPTIMIZATIONS)
+#if (defined(__ARM_NEON__) || defined(HAVE_NEON))
 static bool s16_to_float_neon_enabled = false;
 
+#ifdef HAVE_ARM_NEON_ASM_OPTIMIZATIONS
 /* Avoid potential hard-float/soft-float ABI issues. */
 void convert_s16_float_asm(float *out, const int16_t *in,
       size_t samples, const float *gain);
+#else
+#include <arm_neon.h>
 #endif
 
-/**
- * convert_s16_to_float:
- * @out               : output buffer
- * @in                : input buffer
- * @samples           : size of samples to be converted
- * @gain              : gain applied (.e.g. audio volume)
- *
- * Converts from signed integer 16-bit
- * to floating point.
- **/
 void convert_s16_to_float(float *out,
       const int16_t *in, size_t samples, float gain)
 {
-   size_t i      = 0;
+   unsigned i      = 0;
+
+   if (s16_to_float_neon_enabled)
+   {
+#ifdef HAVE_ARM_NEON_ASM_OPTIMIZATIONS
+      size_t aligned_samples = samples & ~7;
+      if (aligned_samples)
+         convert_s16_float_asm(out, in, aligned_samples, &gain);
+
+      /* Could do all conversion in ASM, but keep it simple for now. */
+      out                   += aligned_samples;
+      in                    += aligned_samples;
+      samples               -= aligned_samples;
+      i                      = 0;
+#else
+      float        gf        = gain / (1 << 15);
+      float32x4_t vgf        = {gf, gf, gf, gf};
+      while (samples >= 8)
+      {
+         float32x4x2_t oreg;
+         int16x4x2_t inreg   = vld2_s16(in);
+         int32x4_t      p1   = vmovl_s16(inreg.val[0]);
+         int32x4_t      p2   = vmovl_s16(inreg.val[1]);
+         oreg.val[0]         = vmulq_f32(vcvtq_f32_s32(p1), vgf);
+         oreg.val[1]         = vmulq_f32(vcvtq_f32_s32(p2), vgf);
+         vst2q_f32(out, oreg);
+         in                 += 8;
+         out                += 8;
+         samples            -= 8;
+      }
+#endif
+   }
+
+   gain /= 0x8000;
+
+   for (; i < samples; i++)
+      out[i] = (float)in[i] * gain;
+}
+
+void convert_s16_to_float_init_simd(void)
+{
+   uint64_t cpu = cpu_features_get();
+
+   if (cpu & RETRO_SIMD_NEON)
+      s16_to_float_neon_enabled = true;
+}
+#else
+void convert_s16_to_float(float *out,
+      const int16_t *in, size_t samples, float gain)
+{
+   unsigned i      = 0;
 
 #if defined(__SSE2__)
    float fgain   = gain / UINT32_C(0x80000000);
@@ -77,7 +120,6 @@ void convert_s16_to_float(float *out,
     * optimize for the good path (very likely). */
    if (((uintptr_t)out & 15) + ((uintptr_t)in & 15) == 0)
    {
-      size_t i;
       const vector float gain_vec = { gain, gain , gain, gain };
       const vector float zero_vec = { 0.0f, 0.0f, 0.0f, 0.0f};
 
@@ -98,24 +140,9 @@ void convert_s16_to_float(float *out,
 
    samples = samples_in;
    i       = 0;
-
-#elif defined(__ARM_NEON__) && !defined(DONT_WANT_ARM_OPTIMIZATIONS)
-   if (s16_to_float_neon_enabled)
-   {
-      size_t aligned_samples = samples & ~7;
-      if (aligned_samples)
-         convert_s16_float_asm(out, in, aligned_samples, &gain);
-
-      /* Could do all conversion in ASM, but keep it simple for now. */
-      out     = out + aligned_samples;
-      in      = in  + aligned_samples;
-      samples = samples - aligned_samples;
-      i       = 0;
-   }
-
 #endif
 
-   gain = gain / 0x8000;
+   gain   /= 0x8000;
 
 #if defined(_MIPS_ARCH_ALLEGREX)
 #ifdef DEBUG
@@ -167,25 +194,12 @@ void convert_s16_to_float(float *out,
             ".set    pop                  \n"
             :: "r"(in + i), "r"(out + i));
    }
-
 #endif
 
    for (; i < samples; i++)
       out[i] = (float)in[i] * gain;
 }
 
-/**
- * convert_s16_to_float_init_simd:
- *
- * Sets up function pointers for conversion
- * functions based on CPU features.
- **/
-void convert_s16_to_float_init_simd(void)
-{
-#if defined(__ARM_NEON__) && !defined(DONT_WANT_ARM_OPTIMIZATIONS)
-   unsigned cpu = cpu_features_get();
-
-   if (cpu & RETRO_SIMD_NEON)
-      s16_to_float_neon_enabled = true;
+void convert_s16_to_float_init_simd(void) { }
 #endif
-}
+
diff --git a/src/libretro/libretro-common/audio/conversion/s16_to_float_neon.S b/src/libretro/libretro-common/audio/conversion/s16_to_float_neon.S
index bb3e7d8d4e..60602140c2 100644
--- a/src/libretro/libretro-common/audio/conversion/s16_to_float_neon.S
+++ b/src/libretro/libretro-common/audio/conversion/s16_to_float_neon.S
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (s16_to_float_neon.S).
@@ -19,7 +19,7 @@
  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-#if defined(__ARM_NEON__) && !defined(DONT_WANT_ARM_OPTIMIZATIONS)
+#if defined(__ARM_NEON__) && defined(HAVE_ARM_NEON_ASM_OPTIMIZATIONS)
 
 #ifndef __MACH__
 .arm
diff --git a/src/libretro/libretro-common/audio/conversion/s16_to_float_neon.c b/src/libretro/libretro-common/audio/conversion/s16_to_float_neon.c
index 2282bb792c..0972de951a 100644
--- a/src/libretro/libretro-common/audio/conversion/s16_to_float_neon.c
+++ b/src/libretro/libretro-common/audio/conversion/s16_to_float_neon.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (s16_to_float_neon.S).
@@ -19,7 +19,7 @@
  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
-#if defined(__ARM_NEON__) && !defined(DONT_WANT_ARM_OPTIMIZATIONS)
+#if defined(__ARM_NEON__) && defined(HAVE_ARM_NEON_ASM_OPTIMIZATIONS)
 
 #if defined(__thumb__)
 #define DECL_ARMMODE(x) "  .align 2\n" "  .global " x "\n" "  .thumb\n" "  .thumb_func\n" "  .type " x ", %function\n" x ":\n"
diff --git a/src/libretro/libretro-common/audio/dsp_filter.c b/src/libretro/libretro-common/audio/dsp_filter.c
index 14f15f4f05..544a9fbe2a 100644
--- a/src/libretro/libretro-common/audio/dsp_filter.c
+++ b/src/libretro/libretro-common/audio/dsp_filter.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (dsp_filter.c).
diff --git a/src/libretro/libretro-common/audio/dsp_filters/Makefile b/src/libretro/libretro-common/audio/dsp_filters/Makefile
index d3c228cd94..34392e173c 100644
--- a/src/libretro/libretro-common/audio/dsp_filters/Makefile
+++ b/src/libretro/libretro-common/audio/dsp_filters/Makefile
@@ -8,17 +8,15 @@ INSTALLDIR  := $(PREFIX)/lib/retroarch/filters/audio
 
 ifeq ($(platform),)
    platform = unix
-   ifeq ($(shell uname -a),)
+   ifeq ($(shell uname -s),)
       platform = win
-   else ifneq ($(findstring MINGW,$(shell uname -a)),)
-      platform = win
-   else ifneq ($(findstring Darwin,$(shell uname -a)),)
+   else ifneq ($(findstring Darwin,$(shell uname -s)),)
       platform = osx
-      arch = intel
+      arch     = intel
       ifeq ($(shell uname -p),powerpc)
          arch = ppc
       endif
-   else ifneq ($(findstring win,$(shell uname -a)),)
+   else ifneq ($(findstring MINGW,$(shell uname -s)),)
       platform = win
    endif
 endif
@@ -52,6 +50,43 @@ else ifeq ($(platform), osx)
    compiler := $(CC)
    DYLIB = dylib
    ldflags := -dynamiclib
+   ARCHFLAGS=
+   MINVERFLAGS=
+   ifeq ($(shell uname -p),arm)
+      MINVERFLAGS = -mmacosx-version-min=10.15 -stdlib=libc++ # macOS  (Metal, ARM 64bit)
+   else ifeq ($(HAVE_METAL),1)
+      MINVERFLAGS = -mmacosx-version-min=10.13 -stdlib=libc++  # macOS  (Metal, x86 64bit)
+   else ifeq ($(shell uname -p),powerpc)
+      MINVERFLAGS = -mmacosx-version-min=10.5  # macOSX (PowerPC 32-bit)
+   else ifeq ($(shell uname -m),i386)
+      MINVERFLAGS = -mmacosx-version-min=10.6  # macOSX (OpenGL, x86 32bit)
+   else
+      MINVERFLAGS = -mmacosx-version-min=10.7 -stdlib=libc++ # macOSX (OpenGL, x86 64bit)
+   endif
+
+	# Build for a specific architecture when ARCH is defined as a switch
+   ifeq ($(ARCH),arm64)
+      MINVERFLAGS  = -mmacosx-version-min=10.15 -stdlib=libc++ # macOS  (Metal, ARM 64bit)
+      ARCHFLAGS    = -arch arm64
+   else ifeq ($(ARCH),x86_64)
+      ifeq ($(HAVE_METAL),1)
+         MINVERFLAGS  = -mmacosx-version-min=10.13 -stdlib=libc++
+      else
+         MINVERFLAGS  = -mmacosx-version-min=10.7  -stdlib=libc++
+      endif
+      ARCHFLAGS       = -arch x86_64
+   else ifeq ($(ARCH),x86)
+      MINVERFLAGS     = -mmacosx-version-min=10.6
+      ARCHFLAGS       = -arch x86
+   else ifeq ($(ARCH),ppc)
+      MINVERFLAGS     = -mmacosx-version-min=10.5
+      ARCHFLAGS       = -arch ppc
+   endif
+   ifeq ($(BUILDBOT),1)
+      ARCHFLAGS       = -target $(LIBRETRO_APPLE_PLATFORM) -isysroot $(LIBRETRO_APPLE_ISYSROOT)
+   endif
+	extraflags += $(MINVERFLAGS) $(ARCHFLAGS)
+	ldflags += $(MINVERFLAGS) $(ARCHFLAGS)
 else
    extra_flags += -static-libgcc -static-libstdc++
    DYLIB = dll
diff --git a/src/libretro/libretro-common/audio/dsp_filters/chorus.c b/src/libretro/libretro-common/audio/dsp_filters/chorus.c
index 60ae02bcb5..c6dae1192b 100644
--- a/src/libretro/libretro-common/audio/dsp_filters/chorus.c
+++ b/src/libretro/libretro-common/audio/dsp_filters/chorus.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2017 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (chorus.c).
@@ -33,13 +33,12 @@
 struct chorus_data
 {
    float old[2][CHORUS_MAX_DELAY];
-   unsigned old_ptr;
-
    float delay;
    float depth;
    float input_rate;
    float mix_dry;
    float mix_wet;
+   unsigned old_ptr;
    unsigned lfo_ptr;
    unsigned lfo_period;
 };
@@ -66,37 +65,37 @@ static void chorus_process(void *data, struct dspfilter_output *output,
       unsigned delay_int;
       float delay_frac, l_a, l_b, r_a, r_b;
       float chorus_l, chorus_r;
-      float in[2] = { out[0], out[1] };
-      float delay = ch->delay + ch->depth * sin((2.0 * M_PI * ch->lfo_ptr++) / ch->lfo_period);
+      float in[2]             = { out[0], out[1] };
+      float delay             = ch->delay + ch->depth * sin((2.0 * M_PI * ch->lfo_ptr++) / ch->lfo_period);
 
-      delay *= ch->input_rate;
+      delay                  *= ch->input_rate;
       if (ch->lfo_ptr >= ch->lfo_period)
-         ch->lfo_ptr = 0;
+         ch->lfo_ptr          = 0;
 
-      delay_int = (unsigned)delay;
+      delay_int               = (unsigned)delay;
 
       if (delay_int >= CHORUS_MAX_DELAY - 1)
-         delay_int = CHORUS_MAX_DELAY - 2;
+         delay_int            = CHORUS_MAX_DELAY - 2;
 
-      delay_frac = delay - delay_int;
+      delay_frac              = delay - delay_int;
 
       ch->old[0][ch->old_ptr] = in[0];
       ch->old[1][ch->old_ptr] = in[1];
 
-      l_a         = ch->old[0][(ch->old_ptr - delay_int - 0) & CHORUS_DELAY_MASK];
-      l_b         = ch->old[0][(ch->old_ptr - delay_int - 1) & CHORUS_DELAY_MASK];
-      r_a         = ch->old[1][(ch->old_ptr - delay_int - 0) & CHORUS_DELAY_MASK];
-      r_b         = ch->old[1][(ch->old_ptr - delay_int - 1) & CHORUS_DELAY_MASK];
+      l_a                     = ch->old[0][(ch->old_ptr - delay_int - 0) & CHORUS_DELAY_MASK];
+      l_b                     = ch->old[0][(ch->old_ptr - delay_int - 1) & CHORUS_DELAY_MASK];
+      r_a                     = ch->old[1][(ch->old_ptr - delay_int - 0) & CHORUS_DELAY_MASK];
+      r_b                     = ch->old[1][(ch->old_ptr - delay_int - 1) & CHORUS_DELAY_MASK];
 
       /* Lerp introduces aliasing of the chorus component,
        * but doing full polyphase here is probably overkill. */
-      chorus_l    = l_a * (1.0f - delay_frac) + l_b * delay_frac;
-      chorus_r    = r_a * (1.0f - delay_frac) + r_b * delay_frac;
+      chorus_l                = l_a * (1.0f - delay_frac) + l_b * delay_frac;
+      chorus_r                = r_a * (1.0f - delay_frac) + r_b * delay_frac;
 
-      out[0]      = ch->mix_dry * in[0] + ch->mix_wet * chorus_l;
-      out[1]      = ch->mix_dry * in[1] + ch->mix_wet * chorus_r;
+      out[0]                  = ch->mix_dry * in[0] + ch->mix_wet * chorus_l;
+      out[1]                  = ch->mix_dry * in[1] + ch->mix_wet * chorus_r;
 
-      ch->old_ptr = (ch->old_ptr + 1) & CHORUS_DELAY_MASK;
+      ch->old_ptr             = (ch->old_ptr + 1) & CHORUS_DELAY_MASK;
    }
 }
 
@@ -113,24 +112,24 @@ static void *chorus_init(const struct dspfilter_info *info,
    config->get_float(userdata, "lfo_freq", &lfo_freq, 0.5f);
    config->get_float(userdata, "drywet", &drywet, 0.8f);
 
-   delay /= 1000.0f;
-   depth /= 1000.0f;
+   delay            /= 1000.0f;
+   depth            /= 1000.0f;
 
    if (depth > delay)
-      depth = delay;
+      depth          = delay;
 
    if (drywet < 0.0f)
-      drywet = 0.0f;
+      drywet         = 0.0f;
    else if (drywet > 1.0f)
-      drywet = 1.0f;
+      drywet         = 1.0f;
 
-   ch->mix_dry = 1.0f - 0.5f * drywet;
-   ch->mix_wet = 0.5f * drywet;
+   ch->mix_dry       = 1.0f - 0.5f * drywet;
+   ch->mix_wet       = 0.5f * drywet;
 
-   ch->delay = delay;
-   ch->depth = depth;
-   ch->lfo_period = (1.0f / lfo_freq) * info->input_rate;
-   ch->input_rate = info->input_rate;
+   ch->delay         = delay;
+   ch->depth         = depth;
+   ch->lfo_period    = (1.0f / lfo_freq) * info->input_rate;
+   ch->input_rate    = info->input_rate;
    if (!ch->lfo_period)
       ch->lfo_period = 1;
    return ch;
@@ -151,10 +150,6 @@ static const struct dspfilter_implementation chorus_plug = {
 #endif
 
 const struct dspfilter_implementation *
-dspfilter_get_implementation(dspfilter_simd_mask_t mask)
-{
-   (void)mask;
-   return &chorus_plug;
-}
+dspfilter_get_implementation(dspfilter_simd_mask_t mask) { return &chorus_plug; }
 
 #undef dspfilter_get_implementation
diff --git a/src/libretro/libretro-common/audio/dsp_filters/crystalizer.c b/src/libretro/libretro-common/audio/dsp_filters/crystalizer.c
index b83842c027..8ccecd8377 100644
--- a/src/libretro/libretro-common/audio/dsp_filters/crystalizer.c
+++ b/src/libretro/libretro-common/audio/dsp_filters/crystalizer.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2017 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (echo.c).
@@ -42,7 +42,7 @@ static void delta_process(void *data, struct dspfilter_output *output,
       const struct dspfilter_input *input)
 {
    unsigned i, c;
-   struct delta_data *d = (struct delta_data*)data;
+   struct delta_data *d   = (struct delta_data*)data;
    float *out             = output->samples;
    output->samples        = input->samples;
    output->frames         = input->frames;
@@ -51,9 +51,9 @@ static void delta_process(void *data, struct dspfilter_output *output,
    {
       for (c = 0; c < 2; c++)
       {
-           float current = *out;
-           *out++ = current + (current - d->old[c]) * d->intensity;
-           d->old[c] = current;
+           float current  = *out;
+           *out++         = current + (current - d->old[c]) * d->intensity;
+           d->old[c]      = current;
       }
    }
 }
@@ -83,7 +83,6 @@ static const struct dspfilter_implementation delta_plug = {
 
 const struct dspfilter_implementation *dspfilter_get_implementation(dspfilter_simd_mask_t mask)
 {
-   (void)mask;
    return &delta_plug;
 }
 
diff --git a/src/libretro/libretro-common/audio/dsp_filters/echo.c b/src/libretro/libretro-common/audio/dsp_filters/echo.c
index 491c2e6de9..27df905231 100644
--- a/src/libretro/libretro-common/audio/dsp_filters/echo.c
+++ b/src/libretro/libretro-common/audio/dsp_filters/echo.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2017 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (echo.c).
@@ -75,11 +75,11 @@ static void echo_process(void *data, struct dspfilter_output *output,
          echo_right += echo->channels[c].buffer[(echo->channels[c].ptr << 1) + 1];
       }
 
-      echo_left  *= echo->amp;
-      echo_right *= echo->amp;
+      echo_left     *= echo->amp;
+      echo_right    *= echo->amp;
 
-      left        = out[0] + echo_left;
-      right       = out[1] + echo_right;
+      left           = out[0] + echo_left;
+      right          = out[1] + echo_right;
 
       for (c = 0; c < echo->num_channels; c++)
       {
@@ -121,28 +121,25 @@ static void *echo_init(const struct dspfilter_info *info,
          &num_feedback, default_feedback, 1);
    config->get_float(userdata, "amp", &echo->amp, 0.2f);
 
-   channels       = num_feedback = num_delay = MIN(num_delay, num_feedback);
+   channels            = num_feedback = num_delay = MIN(num_delay, num_feedback);
 
-   echo_channels = (struct echo_channel*)calloc(channels,
-         sizeof(*echo_channels));
-
-   if (!echo_channels)
+   if (!(echo_channels = (struct echo_channel*)calloc(channels,
+         sizeof(*echo_channels))))
       goto error;
 
-   echo->channels     = echo_channels;
-   echo->num_channels = channels;
+   echo->channels      = echo_channels;
+   echo->num_channels  = channels;
 
    for (i = 0; i < channels; i++)
    {
-      unsigned frames = (unsigned)(delay[i] * info->input_rate / 1000.0f + 0.5f);
+      unsigned frames  = (unsigned)(delay[i] * info->input_rate / 1000.0f + 0.5f);
       if (!frames)
          goto error;
 
-      echo->channels[i].buffer = (float*)calloc(frames, 2 * sizeof(float));
-      if (!echo->channels[i].buffer)
+      if (!(echo->channels[i].buffer = (float*)calloc(frames, 2 * sizeof(float))))
          goto error;
 
-      echo->channels[i].frames = frames;
+      echo->channels[i].frames   = frames;
       echo->channels[i].feedback = feedback[i];
    }
 
@@ -173,7 +170,6 @@ static const struct dspfilter_implementation echo_plug = {
 
 const struct dspfilter_implementation *dspfilter_get_implementation(dspfilter_simd_mask_t mask)
 {
-   (void)mask;
    return &echo_plug;
 }
 
diff --git a/src/libretro/libretro-common/audio/dsp_filters/eq.c b/src/libretro/libretro-common/audio/dsp_filters/eq.c
index ac911231e4..a7578d9281 100644
--- a/src/libretro/libretro-common/audio/dsp_filters/eq.c
+++ b/src/libretro/libretro-common/audio/dsp_filters/eq.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2017 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (eq.c).
@@ -34,12 +34,11 @@
 struct eq_data
 {
    fft_t *fft;
-   float buffer[8 * 1024];
-
    float *save;
    float *block;
    fft_complex_t *filter;
    fft_complex_t *fftblock;
+   float buffer[8 * 1024];
    unsigned block_size;
    unsigned block_ptr;
 };
@@ -88,11 +87,11 @@ static void eq_process(void *data, struct dspfilter_output *output,
 
       memcpy(eq->block + eq->block_ptr * 2, in, write_avail * 2 * sizeof(float));
 
-      in += write_avail * 2;
-      input_frames -= write_avail;
+      in            += write_avail * 2;
+      input_frames  -= write_avail;
       eq->block_ptr += write_avail;
 
-      // Convolve a new block.
+      /* Convolve a new block. */
       if (eq->block_ptr == eq->block_size)
       {
          unsigned i, c;
@@ -105,16 +104,16 @@ static void eq_process(void *data, struct dspfilter_output *output,
             fft_process_inverse(eq->fft, out + c, eq->fftblock, 2);
          }
 
-         // Overlap add method, so add in saved block now.
+         /* Overlap add method, so add in saved block now. */
          for (i = 0; i < 2 * eq->block_size; i++)
-            out[i] += eq->save[i];
+            out[i]      += eq->save[i];
 
-         // Save block for later.
+         /* Save block for later. */
          memcpy(eq->save, out + 2 * eq->block_size, 2 * eq->block_size * sizeof(float));
 
-         out += eq->block_size * 2;
+         out            += eq->block_size * 2;
          output->frames += eq->block_size;
-         eq->block_ptr = 0;
+         eq->block_ptr   = 0;
       }
    }
 }
@@ -184,8 +183,8 @@ static void generate_response(fft_complex_t *response,
          lerp = (freq - start_freq) / (end_freq - start_freq);
       gain = (1.0f - lerp) * start_gain + lerp * end_gain;
 
-      response[i].real = gain;
-      response[i].imag = 0.0f;
+      response[i].real               = gain;
+      response[i].imag               = 0.0f;
       response[2 * samples - i].real = gain;
       response[2 * samples - i].imag = 0.0f;
    }
@@ -196,10 +195,9 @@ static void create_filter(struct eq_data *eq, unsigned size_log2,
 {
    int i;
    int half_block_size = eq->block_size >> 1;
-   double window_mod = 1.0 / kaiser_window_function(0.0, beta);
-
-   fft_t *fft = fft_new(size_log2);
-   float *time_filter = (float*)calloc(eq->block_size * 2 + 1, sizeof(*time_filter));
+   double window_mod   = 1.0 / kaiser_window_function(0.0, beta);
+   fft_t *fft          = fft_new(size_log2);
+   float *time_filter  = (float*)calloc(eq->block_size * 2 + 1, sizeof(*time_filter));
    if (!fft || !time_filter)
       goto end;
 
@@ -228,11 +226,12 @@ static void create_filter(struct eq_data *eq, unsigned size_log2,
    for (i = 0; i < (int)eq->block_size; i++)
    {
       /* Kaiser window. */
-      double phase = (double)i / eq->block_size;
-      phase = 2.0 * (phase - 0.5);
+      double phase    = (double)i / eq->block_size;
+      phase           = 2.0 * (phase - 0.5);
       time_filter[i] *= window_mod * kaiser_window_function(phase, beta);
    }
 
+#ifdef DEBUG
    /* Debugging. */
    if (filter_path)
    {
@@ -244,6 +243,7 @@ static void create_filter(struct eq_data *eq, unsigned size_log2,
          fclose(file);
       }
    }
+#endif
 
    /* Padded FFT to create our FFT filter.
     * Make our even-length filter odd by discarding the first coefficient.
@@ -259,15 +259,15 @@ static void create_filter(struct eq_data *eq, unsigned size_log2,
 static void *eq_init(const struct dspfilter_info *info,
       const struct dspfilter_config *config, void *userdata)
 {
-   float *frequencies, *gain;
-   unsigned num_freq, num_gain, i, size;
    int size_log2;
    float beta;
-   struct eq_gain *gains = NULL;
-   char *filter_path = NULL;
+   float *frequencies, *gain;
+   unsigned num_freq, num_gain, i, size;
+   struct eq_gain *gains      = NULL;
+   char *filter_path          = NULL;
    const float default_freq[] = { 0.0f, info->input_rate };
    const float default_gain[] = { 0.0f, 0.0f };
-   struct eq_data *eq = (struct eq_data*)calloc(1, sizeof(*eq));
+   struct eq_data *eq         = (struct eq_data*)calloc(1, sizeof(*eq));
    if (!eq)
       return NULL;
 
@@ -287,8 +287,7 @@ static void *eq_init(const struct dspfilter_info *info,
 
    num_gain = num_freq = MIN(num_gain, num_freq);
 
-   gains = (struct eq_gain*)calloc(num_gain, sizeof(*gains));
-   if (!gains)
+   if (!(gains = (struct eq_gain*)calloc(num_gain, sizeof(*gains))))
       goto error;
 
    for (i = 0; i < num_gain; i++)
@@ -301,15 +300,15 @@ static void *eq_init(const struct dspfilter_info *info,
 
    eq->block_size = size;
 
-   eq->save     = (float*)calloc(    size, 2 * sizeof(*eq->save));
-   eq->block    = (float*)calloc(2 * size, 2 * sizeof(*eq->block));
-   eq->fftblock = (fft_complex_t*)calloc(2 * size, sizeof(*eq->fftblock));
-   eq->filter   = (fft_complex_t*)calloc(2 * size, sizeof(*eq->filter));
+   eq->save       = (float*)calloc(    size, 2 * sizeof(*eq->save));
+   eq->block      = (float*)calloc(2 * size, 2 * sizeof(*eq->block));
+   eq->fftblock   = (fft_complex_t*)calloc(2 * size, sizeof(*eq->fftblock));
+   eq->filter     = (fft_complex_t*)calloc(2 * size, sizeof(*eq->filter));
 
    /* Use an FFT which is twice the block size with zero-padding
     * to make circular convolution => proper convolution.
     */
-   eq->fft = fft_new(size_log2 + 1);
+   eq->fft        = fft_new(size_log2 + 1);
 
    if (!eq->fft || !eq->fftblock || !eq->save || !eq->block || !eq->filter)
       goto error;
@@ -343,7 +342,6 @@ static const struct dspfilter_implementation eq_plug = {
 
 const struct dspfilter_implementation *dspfilter_get_implementation(dspfilter_simd_mask_t mask)
 {
-   (void)mask;
    return &eq_plug;
 }
 
diff --git a/src/libretro/libretro-common/audio/dsp_filters/fft/fft.c b/src/libretro/libretro-common/audio/dsp_filters/fft/fft.c
index 1457069cdd..3d63d3272c 100644
--- a/src/libretro/libretro-common/audio/dsp_filters/fft/fft.c
+++ b/src/libretro/libretro-common/audio/dsp_filters/fft/fft.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (fft.c).
diff --git a/src/libretro/libretro-common/audio/dsp_filters/fft/fft.h b/src/libretro/libretro-common/audio/dsp_filters/fft/fft.h
index 75b1c258ca..50c191da6f 100644
--- a/src/libretro/libretro-common/audio/dsp_filters/fft/fft.h
+++ b/src/libretro/libretro-common/audio/dsp_filters/fft/fft.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (fft.h).
diff --git a/src/libretro/libretro-common/audio/dsp_filters/iir.c b/src/libretro/libretro-common/audio/dsp_filters/iir.c
index cb4d078d48..4eb79997e5 100644
--- a/src/libretro/libretro-common/audio/dsp_filters/iir.c
+++ b/src/libretro/libretro-common/audio/dsp_filters/iir.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2017 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (iir.c).
@@ -142,6 +142,7 @@ static enum IIRFilter str_to_type(const char *str)
 
    return LPF; /* Fallback. */
 }
+#undef CHECK
 
 static void make_poly_from_roots(
       const double *roots, unsigned num_roots, float *poly)
@@ -223,7 +224,8 @@ static void iir_filter_init(struct iir_data *iir,
       case RIAA_phono: /* http://www.dsprelated.com/showmessage/73300/3.php */
       {
          double y, b_re, a_re, b_im, a_im, g;
-         float b[3], a[3];
+         float b[3] = {0.0f};
+         float a[3] = {0.0f};
 
          if ((int)sample_rate == 44100)
          {
@@ -363,7 +365,6 @@ static const struct dspfilter_implementation iir_plug = {
 
 const struct dspfilter_implementation *dspfilter_get_implementation(dspfilter_simd_mask_t mask)
 {
-   (void)mask;
    return &iir_plug;
 }
 
diff --git a/src/libretro/libretro-common/audio/dsp_filters/panning.c b/src/libretro/libretro-common/audio/dsp_filters/panning.c
index c1259be83e..87216edf0b 100644
--- a/src/libretro/libretro-common/audio/dsp_filters/panning.c
+++ b/src/libretro/libretro-common/audio/dsp_filters/panning.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2017 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (panning.c).
@@ -104,7 +104,6 @@ static const struct dspfilter_implementation panning = {
 const struct dspfilter_implementation *
 dspfilter_get_implementation(dspfilter_simd_mask_t mask)
 {
-   (void)mask;
    return &panning;
 }
 
diff --git a/src/libretro/libretro-common/audio/dsp_filters/phaser.c b/src/libretro/libretro-common/audio/dsp_filters/phaser.c
index edc48a990e..4c5d206df8 100644
--- a/src/libretro/libretro-common/audio/dsp_filters/phaser.c
+++ b/src/libretro/libretro-common/audio/dsp_filters/phaser.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2017 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (phaser.c).
@@ -27,8 +27,8 @@
 #include <retro_miscellaneous.h>
 #include <libretro_dspfilter.h>
 
-#define phaserlfoshape 4.0
-#define phaserlfoskipsamples 20
+#define PHASER_LFO_SHAPE 4.0
+#define PHASER_LFO_SKIP_SAMPLES 20
 
 struct phaser_data
 {
@@ -71,10 +71,10 @@ static void phaser_process(void *data, struct dspfilter_output *output,
       for (c = 0; c < 2; c++)
          m[c] = in[c] + ph->fbout[c] * ph->fb * 0.01f;
 
-      if ((ph->skipcount++ % phaserlfoskipsamples) == 0)
+      if ((ph->skipcount++ % PHASER_LFO_SKIP_SAMPLES) == 0)
       {
          ph->gain = 0.5 * (1.0 + cos(ph->skipcount * ph->lfoskip + ph->phase));
-         ph->gain = (exp(ph->gain * phaserlfoshape) - 1.0) / (exp(phaserlfoshape) - 1);
+         ph->gain = (exp(ph->gain * PHASER_LFO_SHAPE) - 1.0) / (exp(PHASER_LFO_SHAPE) - 1);
          ph->gain = 1.0 - ph->gain * ph->depth;
       }
 
@@ -138,7 +138,6 @@ static const struct dspfilter_implementation phaser_plug = {
 
 const struct dspfilter_implementation *dspfilter_get_implementation(dspfilter_simd_mask_t mask)
 {
-   (void)mask;
    return &phaser_plug;
 }
 
diff --git a/src/libretro/libretro-common/audio/dsp_filters/reverb.c b/src/libretro/libretro-common/audio/dsp_filters/reverb.c
index c91e2be3c5..10559b3a3c 100644
--- a/src/libretro/libretro-common/audio/dsp_filters/reverb.c
+++ b/src/libretro/libretro-common/audio/dsp_filters/reverb.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2017 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (reverb.c).
@@ -309,7 +309,6 @@ static const struct dspfilter_implementation reverb_plug = {
 
 const struct dspfilter_implementation *dspfilter_get_implementation(dspfilter_simd_mask_t mask)
 {
-   (void)mask;
    return &reverb_plug;
 }
 
diff --git a/src/libretro/libretro-common/audio/dsp_filters/tremolo.c b/src/libretro/libretro-common/audio/dsp_filters/tremolo.c
index 8c5bb40a5a..5bdf52ed32 100644
--- a/src/libretro/libretro-common/audio/dsp_filters/tremolo.c
+++ b/src/libretro/libretro-common/audio/dsp_filters/tremolo.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2017 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (tremolo.c).
@@ -32,11 +32,11 @@
 
 struct tremolo_core
 {
-      float freq;
-      float depth;
-	float* wavetable;
-      int index;
-	int maxindex;
+   float *wavetable;
+   float freq;
+   float depth;
+   int index;
+   int maxindex;
 };
 
 struct tremolo
@@ -54,24 +54,25 @@ static void tremolo_free(void *data)
 
 static void tremolocore_init(struct tremolo_core *core,float depth,int samplerate,float freq)
 {
-      const double offset = 1. - depth / 2.;
-      unsigned i;
-      double env;
-      core->index = 0;
-	core->maxindex = samplerate/freq;
-	core->wavetable = malloc(core->maxindex*sizeof(float));
-	memset(core->wavetable, 0, core->maxindex * sizeof(float));
-	for (i = 0; i < core->maxindex; i++) {
-	env = freq * i / samplerate;
-	env = sin((M_PI*2) * fmod(env + 0.25, 1.0));
-	core->wavetable[i] = env * (1 - fabs(offset)) + offset;
-      }
+   double env;
+   unsigned i;
+   const double offset = 1. - depth / 2.;
+   core->index     = 0;
+   core->maxindex  = samplerate / freq;
+   core->wavetable = malloc(core->maxindex   * sizeof(float));
+   memset(core->wavetable, 0, core->maxindex * sizeof(float));
+   for (i = 0; i < core->maxindex; i++)
+   {
+      env                = freq * i / samplerate;
+      env                = sin((M_PI*2) * fmod(env + 0.25, 1.0));
+      core->wavetable[i] = env * (1 - fabs(offset)) + offset;
+   }
 }
 
 float tremolocore_core(struct tremolo_core *core,float in)
 {
-      core->index = core->index % core->maxindex;
-      return in * core->wavetable[core->index++];
+   core->index = core->index % core->maxindex;
+   return in * core->wavetable[core->index++];
 }
 
 static void tremolo_process(void *data, struct dspfilter_output *output,
@@ -81,16 +82,15 @@ static void tremolo_process(void *data, struct dspfilter_output *output,
    float *out;
    struct tremolo *tre = (struct tremolo*)data;
 
-   output->samples         = input->samples;
-   output->frames          = input->frames;
-   out                     = output->samples;
+   output->samples     = input->samples;
+   output->frames      = input->frames;
+   out                 = output->samples;
 
    for (i = 0; i < input->frames; i++, out += 2)
    {
-      float in[2] = { out[0], out[1] };
-
-      out[0] = tremolocore_core(&tre->left, in[0]);
-      out[1] = tremolocore_core(&tre->right, in[1]);
+      float in[2]      = { out[0], out[1] };
+      out[0]           = tremolocore_core(&tre->left, in[0]);
+      out[1]           = tremolocore_core(&tre->right, in[1]);
    }
 }
 
@@ -98,7 +98,7 @@ static void *tremolo_init(const struct dspfilter_info *info,
       const struct dspfilter_config *config, void *userdata)
 {
    float freq, depth;
-   struct tremolo *tre   = (struct tremolo*)calloc(1, sizeof(*tre));
+   struct tremolo *tre = (struct tremolo*)calloc(1, sizeof(*tre));
    if (!tre)
       return NULL;
 
@@ -125,7 +125,6 @@ static const struct dspfilter_implementation tremolo_plug = {
 
 const struct dspfilter_implementation *dspfilter_get_implementation(dspfilter_simd_mask_t mask)
 {
-   (void)mask;
    return &tremolo_plug;
 }
 
diff --git a/src/libretro/libretro-common/audio/dsp_filters/vibrato.c b/src/libretro/libretro-common/audio/dsp_filters/vibrato.c
index 7752489f7c..2db906bb03 100644
--- a/src/libretro/libretro-common/audio/dsp_filters/vibrato.c
+++ b/src/libretro/libretro-common/audio/dsp_filters/vibrato.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2017 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (vibrato.c).
@@ -30,31 +30,30 @@
 
 #define sqr(a) ((a) * (a))
 
-const float BASE_DELAY_SEC = 0.002; // 2 ms
-const float VIBRATO_FREQUENCY_DEFAULT_HZ = 2;
-const float VIBRATO_FREQUENCY_MAX_HZ = 14;
-const float VIBRATO_DEPTH_DEFAULT_PERCENT = 50;
-const int add_delay = 3;
+#define VIBRATO_BASE_DELAY_SEC 0.002f /* 2 ms */
+#define VIBRATO_FREQUENCY_DEFAULT_HZ 2.0f
+#define VIBRATO_FREQUENCY_MAX_HZ 14.0f
+#define VIBRATO_DEPTH_DEFAULT_PERCENT 50.0f
+#define VIBRATO_ADD_DELAY 3
 
-float hermite_interp(float x, float *y)
+static float hermite_interp(float x, float *y)
 {
-	float c0, c1, c2, c3;
-	c0 = y[1];
-	c1 = (1.0 / 2.0)*(y[2] - y[0]);
-	c2 = (y[0] - (5.0 / 2.0)*y[1]) + (2.0*y[2] - (1.0 / 2.0)*y[3]);
-	c3 = (1.0 / 2.0)*(y[3] - y[0]) + (3.0 / 2.0)*(y[1] - y[2]);
-	return ((c3*x + c2)*x + c1)*x + c0;
+   float c0 = y[1];
+   float c1 = (1.0f / 2.0f) * (y[2] - y[0]);
+   float c2 = (y[0] - (5.0f / 2.0f) * y[1]) + (2.0f * y[2] - (1.0f / 2.0f) * y[3]);
+   float c3 = (1.0f / 2.0f) * (y[3] - y[0]) + (3.0f / 2.0f) * (y[1] - y[2]);
+   return ((c3 * x + c2) * x + c1) * x + c0;
 }
 
 struct vibrato_core
 {
-      float freq;
-      float samplerate;
-      int phase;
-      float depth;
-	float* buffer;
-	int writeindex;
-      int size;
+   float* buffer;
+   float freq;
+   float samplerate;
+   float depth;
+   int phase;
+   int writeindex;
+   int size;
 };
 
 struct vibrato
@@ -72,60 +71,62 @@ static void vibrato_free(void *data)
 
 static void vibratocore_init(struct vibrato_core *core,float depth,int samplerate,float freq)
 {
-	core->size = BASE_DELAY_SEC * samplerate * 2;
-	core->buffer = malloc((core->size + add_delay)*sizeof(float));
-	memset(core->buffer, 0, (core->size + add_delay) * sizeof(float));
+	core->size       = VIBRATO_BASE_DELAY_SEC * samplerate * 2;
+	core->buffer     = malloc((core->size + VIBRATO_ADD_DELAY) * sizeof(float));
+	memset(core->buffer, 0, (core->size   + VIBRATO_ADD_DELAY) * sizeof(float));
 	core->samplerate = samplerate;
-	core->freq = freq;
-	core->depth = depth;
-	core->phase = 0;
+	core->freq       = freq;
+	core->depth      = depth;
+	core->phase      = 0;
 	core->writeindex = 0;
 }
 
 float vibratocore_core(struct vibrato_core *core,float in)
 {
-            float M = core->freq / core->samplerate;
-		int maxphase = core->samplerate / core->freq;
-		float lfo = sin(M * 2. * M_PI * core->phase++);
-		core->phase = core->phase % maxphase;
-	      lfo = (lfo + 1) * 1.; // transform from [-1; 1] to [0; 1]
-		int maxdelay = BASE_DELAY_SEC * core->samplerate;
-		float delay =  lfo * core->depth * maxdelay;
-		delay += add_delay;
-		float readindex = core->writeindex - 1 - delay;
-		while (readindex < 0)readindex += core->size;
-		while (readindex >= core->size)readindex -= core->size;
-		int ipart = (int)readindex; // integer part of the delay
-		float fpart = readindex - ipart; // fractional part of the delay
-		float value = hermite_interp(fpart, &(core->buffer[ipart]));
-		core->buffer[core->writeindex] = in;
-		if (core->writeindex < add_delay){
-			core->buffer[core->size + core->writeindex] = in;
-		}
-		core->writeindex++;
-		if (core->writeindex == core->size) {
-			core->writeindex = 0;
-		}
-            return value;
+   int ipart;
+   float delay, readindex, fpart, value;
+   float M                        = core->freq / core->samplerate;
+   int maxphase                   = core->samplerate / core->freq;
+   float lfo                      = sin(M * 2. * M_PI * core->phase++);
+   int maxdelay                   = VIBRATO_BASE_DELAY_SEC * core->samplerate;
+   core->phase                    = core->phase % maxphase;
+   lfo                            = (lfo + 1) * 1.; // transform from [-1; 1] to [0; 1]
+   delay                          =  lfo * core->depth * maxdelay;
+   delay                         += VIBRATO_ADD_DELAY;
+   readindex                      = core->writeindex - 1 - delay;
+   while (readindex < 0)
+      readindex                  += core->size;
+   while (readindex >= core->size)
+      readindex                  -= core->size;
+   ipart                          = (int)readindex;    /* Integer part of the delay */
+   fpart                          = readindex - ipart; /* fractional part of the delay */
+   value                          = hermite_interp(fpart, &(core->buffer[ipart]));
+   core->buffer[core->writeindex] = in;
+   if (core->writeindex < VIBRATO_ADD_DELAY)
+      core->buffer[core->size + core->writeindex] = in;
+   core->writeindex++;
+   if (core->writeindex == core->size)
+      core->writeindex = 0;
+   return value;
 }
 
-static void vibrato_process(void *data, struct dspfilter_output *output,
+static void vibrato_process(void *data,
+      struct dspfilter_output *output,
       const struct dspfilter_input *input)
 {
    unsigned i;
    float *out;
    struct vibrato *vib = (struct vibrato*)data;
 
-   output->samples         = input->samples;
-   output->frames          = input->frames;
-   out                     = output->samples;
+   output->samples     = input->samples;
+   output->frames      = input->frames;
+   out                 = output->samples;
 
    for (i = 0; i < input->frames; i++, out += 2)
    {
       float in[2] = { out[0], out[1] };
-
-      out[0] = vibratocore_core(&vib->left, in[0]);
-      out[1] = vibratocore_core(&vib->right, in[1]);
+      out[0]      = vibratocore_core(&vib->left, in[0]);
+      out[1]      = vibratocore_core(&vib->right, in[1]);
    }
 }
 
@@ -133,7 +134,7 @@ static void *vibrato_init(const struct dspfilter_info *info,
       const struct dspfilter_config *config, void *userdata)
 {
    float freq, depth;
-   struct vibrato *vib   = (struct vibrato*)calloc(1, sizeof(*vib));
+   struct vibrato *vib = (struct vibrato*)calloc(1, sizeof(*vib));
    if (!vib)
       return NULL;
 
@@ -160,7 +161,6 @@ static const struct dspfilter_implementation vibrato_plug = {
 
 const struct dspfilter_implementation *dspfilter_get_implementation(dspfilter_simd_mask_t mask)
 {
-   (void)mask;
    return &vibrato_plug;
 }
 
diff --git a/src/libretro/libretro-common/audio/dsp_filters/wahwah.c b/src/libretro/libretro-common/audio/dsp_filters/wahwah.c
index eca269f47c..fff8be7e2e 100644
--- a/src/libretro/libretro-common/audio/dsp_filters/wahwah.c
+++ b/src/libretro/libretro-common/audio/dsp_filters/wahwah.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2017 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (wahwah.c).
@@ -68,39 +68,39 @@ static void wahwah_process(void *data, struct dspfilter_output *output,
       if ((wah->skipcount++ % WAHWAH_LFO_SKIP_SAMPLES) == 0)
       {
          float omega, sn, cs, alpha;
-         float frequency = (1.0 + cos(wah->skipcount * wah->lfoskip + wah->phase)) / 2.0;
-
-         frequency = frequency * wah->depth * (1.0 - wah->freqofs) + wah->freqofs;
-         frequency = exp((frequency - 1.0) * 6.0);
-
-         omega     = M_PI * frequency;
-         sn        = sin(omega);
-         cs        = cos(omega);
-         alpha     = sn / (2.0 * wah->res);
-
-         wah->b0   = (1.0 - cs) / 2.0;
-         wah->b1   = 1.0 - cs;
-         wah->b2   = (1.0 - cs) / 2.0;
-         wah->a0   = 1.0 + alpha;
-         wah->a1   = -2.0 * cs;
-         wah->a2   = 1.0 - alpha;
+         float frequency = (1.0f + cos(wah->skipcount * wah->lfoskip + wah->phase)) / 2.0f;
+
+         frequency       = frequency * wah->depth * (1.0f - wah->freqofs) + wah->freqofs;
+         frequency       = exp((frequency - 1.0f) * 6.0f);
+
+         omega           = M_PI * frequency;
+         sn              = sin(omega);
+         cs              = cos(omega);
+         alpha           = sn / (2.0f * wah->res);
+
+         wah->b0         = (1.0f - cs) / 2.0f;
+         wah->b1         = 1.0f  - cs;
+         wah->b2         = (1.0f - cs) / 2.0f;
+         wah->a0         = 1.0f + alpha;
+         wah->a1         = -2.0f * cs;
+         wah->a2         = 1.0f - alpha;
       }
 
-      out_l      = (wah->b0 * in[0] + wah->b1 * wah->l.xn1 + wah->b2 * wah->l.xn2 - wah->a1 * wah->l.yn1 - wah->a2 * wah->l.yn2) / wah->a0;
-      out_r      = (wah->b0 * in[1] + wah->b1 * wah->r.xn1 + wah->b2 * wah->r.xn2 - wah->a1 * wah->r.yn1 - wah->a2 * wah->r.yn2) / wah->a0;
+      out_l              = (wah->b0 * in[0] + wah->b1 * wah->l.xn1 + wah->b2 * wah->l.xn2 - wah->a1 * wah->l.yn1 - wah->a2 * wah->l.yn2) / wah->a0;
+      out_r              = (wah->b0 * in[1] + wah->b1 * wah->r.xn1 + wah->b2 * wah->r.xn2 - wah->a1 * wah->r.yn1 - wah->a2 * wah->r.yn2) / wah->a0;
 
-      wah->l.xn2 = wah->l.xn1;
-      wah->l.xn1 = in[0];
-      wah->l.yn2 = wah->l.yn1;
-      wah->l.yn1 = out_l;
+      wah->l.xn2         = wah->l.xn1;
+      wah->l.xn1         = in[0];
+      wah->l.yn2         = wah->l.yn1;
+      wah->l.yn1         = out_l;
 
-      wah->r.xn2 = wah->r.xn1;
-      wah->r.xn1 = in[1];
-      wah->r.yn2 = wah->r.yn1;
-      wah->r.yn1 = out_r;
+      wah->r.xn2         = wah->r.xn1;
+      wah->r.xn1         = in[1];
+      wah->r.yn2         = wah->r.yn1;
+      wah->r.yn1         = out_r;
 
-      out[0]     = out_l;
-      out[1]     = out_r;
+      out[0]             = out_l;
+      out[1]             = out_r;
    }
 }
 
@@ -117,8 +117,8 @@ static void *wahwah_init(const struct dspfilter_info *info,
    config->get_float(userdata, "depth", &wah->depth, 0.7f);
    config->get_float(userdata, "resonance", &wah->res, 2.5f);
 
-   wah->lfoskip = wah->freq * 2.0 * M_PI / info->input_rate;
-   wah->phase   = wah->startphase * M_PI / 180.0;
+   wah->lfoskip = wah->freq * 2.0f * M_PI / info->input_rate;
+   wah->phase   = wah->startphase * M_PI / 180.0f;
 
    return wah;
 }
diff --git a/src/libretro/libretro-common/audio/resampler/audio_resampler.c b/src/libretro/libretro-common/audio/resampler/audio_resampler.c
index 8d27f06932..884d961fb7 100644
--- a/src/libretro/libretro-common/audio/resampler/audio_resampler.c
+++ b/src/libretro/libretro-common/audio/resampler/audio_resampler.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (audio_resampler.c).
@@ -28,12 +28,28 @@
 
 #include <audio/audio_resampler.h>
 
+static void resampler_null_process(void *a, struct resampler_data *b) { }
+static void resampler_null_free(void *a) { }
+static void *resampler_null_init(const struct resampler_config *a, double b,
+      enum resampler_quality c, resampler_simd_mask_t d) { return (void*)0; }
+
+retro_resampler_t null_resampler = {
+   resampler_null_init,
+   resampler_null_process,
+   resampler_null_free,
+   RESAMPLER_API_VERSION,
+   "null",
+   "null"
+};
+
 static const retro_resampler_t *resampler_drivers[] = {
    &sinc_resampler,
 #ifdef HAVE_CC_RESAMPLER
    &CC_resampler,
 #endif
+#ifdef HAVE_NEAREST_RESAMPLER
    &nearest_resampler,
+#endif
    &null_resampler,
    NULL,
 };
@@ -66,36 +82,6 @@ static int find_resampler_driver_index(const char *ident)
    return -1;
 }
 
-/**
- * audio_resampler_driver_find_handle:
- * @idx                : index of driver to get handle to.
- *
- * Returns: handle to audio resampler driver at index. Can be NULL
- * if nothing found.
- **/
-const void *audio_resampler_driver_find_handle(int idx)
-{
-   const void *drv = resampler_drivers[idx];
-   if (!drv)
-      return NULL;
-   return drv;
-}
-
-/**
- * audio_resampler_driver_find_ident:
- * @idx                : index of driver to get handle to.
- *
- * Returns: Human-readable identifier of audio resampler driver at index.
- * Can be NULL if nothing found.
- **/
-const char *audio_resampler_driver_find_ident(int idx)
-{
-   const retro_resampler_t *drv = resampler_drivers[idx];
-   if (!drv)
-      return NULL;
-   return drv->ident;
-}
-
 /**
  * find_resampler_driver:
  * @ident                      : Identifier of resampler driver to find.
@@ -140,6 +126,37 @@ static bool resampler_append_plugs(void **re,
    return true;
 }
 
+
+/**
+ * audio_resampler_driver_find_handle:
+ * @idx                : index of driver to get handle to.
+ *
+ * Returns: handle to audio resampler driver at index. Can be NULL
+ * if nothing found.
+ **/
+const void *audio_resampler_driver_find_handle(int idx)
+{
+   const void *drv = resampler_drivers[idx];
+   if (!drv)
+      return NULL;
+   return drv;
+}
+
+/**
+ * audio_resampler_driver_find_ident:
+ * @idx                : index of driver to get handle to.
+ *
+ * Returns: Human-readable identifier of audio resampler driver at index.
+ * Can be NULL if nothing found.
+ **/
+const char *audio_resampler_driver_find_ident(int idx)
+{
+   const retro_resampler_t *drv = resampler_drivers[idx];
+   if (!drv)
+      return NULL;
+   return drv->ident;
+}
+
 /**
  * retro_resampler_realloc:
  * @re                         : Resampler handle
diff --git a/src/libretro/libretro-common/audio/resampler/drivers/nearest_resampler.c b/src/libretro/libretro-common/audio/resampler/drivers/nearest_resampler.c
index 5ef44c00a6..578f589f2e 100644
--- a/src/libretro/libretro-common/audio/resampler/drivers/nearest_resampler.c
+++ b/src/libretro/libretro-common/audio/resampler/drivers/nearest_resampler.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (nearest_resampler.c).
@@ -40,11 +40,11 @@ static void resampler_nearest_process(
    audio_frame_float_t  *outp    = (audio_frame_float_t*)data->data_out;
    float                   ratio = 1.0 / data->ratio;
 
-   while(inp != inp_max)
+   while (inp != inp_max)
    {
-      while(re->fraction > 1)
+      while (re->fraction > 1)
       {
-         *outp++ = *inp;
+         *outp++       = *inp;
          re->fraction -= ratio;
       }
       re->fraction++;
@@ -68,15 +68,9 @@ static void *resampler_nearest_init(const struct resampler_config *config,
 {
    rarch_nearest_resampler_t *re = (rarch_nearest_resampler_t*)
       calloc(1, sizeof(rarch_nearest_resampler_t));
-
-   (void)config;
-   (void)mask;
-
    if (!re)
       return NULL;
-
    re->fraction = 0;
-
    return re;
 }
 
diff --git a/src/libretro/libretro-common/audio/resampler/drivers/sinc_resampler.c b/src/libretro/libretro-common/audio/resampler/drivers/sinc_resampler.c
index 2b43cb0d59..fa3a78a04a 100644
--- a/src/libretro/libretro-common/audio/resampler/drivers/sinc_resampler.c
+++ b/src/libretro/libretro-common/audio/resampler/drivers/sinc_resampler.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (sinc_resampler.c).
@@ -27,6 +27,7 @@
 #include <math.h>
 #include <string.h>
 
+#include <retro_environment.h>
 #include <retro_inline.h>
 #include <filters.h>
 #include <memalign.h>
@@ -67,7 +68,13 @@ enum sinc_window
 
 typedef struct rarch_sinc_resampler
 {
-   unsigned enable_avx;
+   /* A buffer for phase_table, buffer_l and buffer_r
+    * are created in a single calloc().
+    * Ensure that we get as good cache locality as we can hope for. */
+   float *main_buffer;
+   float *phase_table;
+   float *buffer_l;
+   float *buffer_r;
    unsigned phase_bits;
    unsigned subphase_bits;
    unsigned subphase_mask;
@@ -76,72 +83,84 @@ typedef struct rarch_sinc_resampler
    uint32_t time;
    float subphase_mod;
    float kaiser_beta;
-   enum sinc_window window_type;
-
-   /* A buffer for phase_table, buffer_l and buffer_r
-    * are created in a single calloc().
-    * Ensure that we get as good cache locality as we can hope for. */
-   float *main_buffer;
-   float *phase_table;
-   float *buffer_l;
-   float *buffer_r;
 } rarch_sinc_resampler_t;
 
-#if defined(__ARM_NEON__) && !defined(DONT_WANT_ARM_OPTIMIZATIONS)
-#if TARGET_OS_IPHONE
-#else
-#define WANT_NEON
-#endif
-#endif
+#if (defined(__ARM_NEON__) || defined(HAVE_NEON))
 
-#ifdef WANT_NEON
-/* Assumes that taps >= 8, and that taps is a multiple of 8. */
+#ifdef HAVE_ARM_NEON_ASM_OPTIMIZATIONS
 void process_sinc_neon_asm(float *out, const float *left,
       const float *right, const float *coeff, unsigned taps);
+#else
+#include <arm_neon.h>
 
-static void resampler_sinc_process_neon(void *re_, struct resampler_data *data)
+/* Assumes that taps >= 8, and that taps is a multiple of 8.
+ * Not bothering to reimplement this one for the external .S
+ */
+static void resampler_sinc_process_neon_kaiser(void *re_, struct resampler_data *data)
 {
    rarch_sinc_resampler_t *resamp = (rarch_sinc_resampler_t*)re_;
    unsigned phases                = 1 << (resamp->phase_bits + resamp->subphase_bits);
-
    uint32_t ratio                 = phases / data->ratio;
    const float *input             = data->data_in;
    float *output                  = data->data_out;
    size_t frames                  = data->input_frames;
    size_t out_frames              = 0;
-
+   unsigned taps                  = resamp->taps;
    while (frames)
    {
       while (frames && resamp->time >= phases)
       {
          /* Push in reverse to make filter more obvious. */
          if (!resamp->ptr)
-            resamp->ptr = resamp->taps;
+            resamp->ptr = taps;
          resamp->ptr--;
 
-         resamp->buffer_l[resamp->ptr + resamp->taps] =
-         resamp->buffer_l[resamp->ptr]                = *input++;
+         resamp->buffer_l[resamp->ptr + taps] =
+            resamp->buffer_l[resamp->ptr]     = *input++;
 
-         resamp->buffer_r[resamp->ptr + resamp->taps] =
-         resamp->buffer_r[resamp->ptr]                = *input++;
+         resamp->buffer_r[resamp->ptr + taps] =
+            resamp->buffer_r[resamp->ptr]     = *input++;
 
-         resamp->time                                -= phases;
+         resamp->time                        -= phases;
          frames--;
       }
 
-      while (resamp->time < phases)
       {
          const float *buffer_l    = resamp->buffer_l + resamp->ptr;
          const float *buffer_r    = resamp->buffer_r + resamp->ptr;
-         unsigned taps            = resamp->taps;
-         unsigned phase           = resamp->time >> resamp->subphase_bits;
-         const float *phase_table = resamp->phase_table + phase * taps;
-
-         process_sinc_neon_asm(output, buffer_l, buffer_r, phase_table, taps);
+         while (resamp->time < phases)
+         {
+            unsigned phase           = resamp->time >> resamp->subphase_bits;
+            const float *phase_table = resamp->phase_table + phase * taps * 2;
+            const float *delta_table = phase_table + taps;
+            float32x4_t delta        = vdupq_n_f32((resamp->time & resamp->subphase_mask) * resamp->subphase_mod);
+            int i;
+            float32x4_t p1 = {0, 0, 0, 0}, p2 = {0, 0, 0, 0};
+            float32x2_t p3, p4;
+
+            for (i = 0; i < (int)taps; i += 8)
+            {
+               float32x4x2_t coeff8  = vld2q_f32(&phase_table[i]);
+               float32x4x2_t delta8  = vld2q_f32(&delta_table[i]);
+               float32x4x2_t left8   = vld2q_f32(&buffer_l[i]);
+               float32x4x2_t right8  = vld2q_f32(&buffer_r[i]);
+
+               coeff8.val[0] = vmlaq_f32(coeff8.val[0], delta8.val[0], delta);
+               coeff8.val[1] = vmlaq_f32(coeff8.val[1], delta8.val[1], delta);
+
+               p1 = vmlaq_f32(p1,  left8.val[0], coeff8.val[0]);
+               p2 = vmlaq_f32(p2, right8.val[0], coeff8.val[0]);
+               p1 = vmlaq_f32(p1,  left8.val[1], coeff8.val[1]);
+               p2 = vmlaq_f32(p2, right8.val[1], coeff8.val[1]);
+            }
 
-         output += 2;
-         out_frames++;
-         resamp->time += ratio;
+            p3 = vadd_f32(vget_low_f32(p1), vget_high_f32(p1));
+            p4 = vadd_f32(vget_low_f32(p2), vget_high_f32(p2));
+            vst1_f32(output, vpadd_f32(p3, p4));
+            output                 += 2;
+            out_frames++;
+            resamp->time           += ratio;
+         }
       }
    }
 
@@ -149,17 +168,17 @@ static void resampler_sinc_process_neon(void *re_, struct resampler_data *data)
 }
 #endif
 
-#if defined(__AVX__)
-static void resampler_sinc_process_avx(void *re_, struct resampler_data *data)
+/* Assumes that taps >= 8, and that taps is a multiple of 8. */
+static void resampler_sinc_process_neon(void *re_, struct resampler_data *data)
 {
    rarch_sinc_resampler_t *resamp = (rarch_sinc_resampler_t*)re_;
    unsigned phases                = 1 << (resamp->phase_bits + resamp->subphase_bits);
-
    uint32_t ratio                 = phases / data->ratio;
    const float *input             = data->data_in;
    float *output                  = data->data_out;
    size_t frames                  = data->input_frames;
    size_t out_frames              = 0;
+   unsigned taps                  = resamp->taps;
 
    while (frames)
    {
@@ -167,81 +186,53 @@ static void resampler_sinc_process_avx(void *re_, struct resampler_data *data)
       {
          /* Push in reverse to make filter more obvious. */
          if (!resamp->ptr)
-            resamp->ptr = resamp->taps;
+            resamp->ptr = taps;
          resamp->ptr--;
 
-         resamp->buffer_l[resamp->ptr + resamp->taps] =
-         resamp->buffer_l[resamp->ptr]                = *input++;
+         resamp->buffer_l[resamp->ptr + taps] =
+            resamp->buffer_l[resamp->ptr]     = *input++;
 
-         resamp->buffer_r[resamp->ptr + resamp->taps] =
-         resamp->buffer_r[resamp->ptr]                = *input++;
+         resamp->buffer_r[resamp->ptr + taps] =
+            resamp->buffer_r[resamp->ptr]     = *input++;
 
-         resamp->time                                -= phases;
+         resamp->time                        -= phases;
          frames--;
       }
 
-      while (resamp->time < phases)
       {
-         unsigned i;
-         __m256 delta, sum_l, sum_r;
-         float *delta_table       = NULL;
-         float *phase_table       = NULL;
          const float *buffer_l    = resamp->buffer_l + resamp->ptr;
          const float *buffer_r    = resamp->buffer_r + resamp->ptr;
-         unsigned taps            = resamp->taps;
-         unsigned phase           = resamp->time >> resamp->subphase_bits;
-
-         phase_table              = resamp->phase_table + phase * taps;
-
-         if (resamp->window_type == SINC_WINDOW_KAISER)
-         {
-            phase_table              = resamp->phase_table + phase * taps * 2;
-            delta_table              = phase_table + taps;
-            delta                    = _mm256_set1_ps((float)
-                  (resamp->time & resamp->subphase_mask) * resamp->subphase_mod);
-         }
-
-         sum_l                    = _mm256_setzero_ps();
-         sum_r                    = _mm256_setzero_ps();
-
-         for (i = 0; i < taps; i += 8)
+         while (resamp->time < phases)
          {
-            __m256 sinc;
-            __m256 buf_l  = _mm256_loadu_ps(buffer_l + i);
-            __m256 buf_r  = _mm256_loadu_ps(buffer_r + i);
+            unsigned phase           = resamp->time >> resamp->subphase_bits;
+            const float *phase_table = resamp->phase_table + phase * taps;
+#ifdef HAVE_ARM_NEON_ASM_OPTIMIZATIONS
+            process_sinc_neon_asm(output, buffer_l, buffer_r, phase_table, taps);
+#else
+            int i;
+            float32x4_t p1 = {0, 0, 0, 0}, p2 = {0, 0, 0, 0};
+            float32x2_t p3, p4;
 
-            if (resamp->window_type == SINC_WINDOW_KAISER)
+            for (i = 0; i < (int)taps; i += 8)
             {
-               __m256 deltas = _mm256_load_ps(delta_table + i);
-               sinc          = _mm256_add_ps(_mm256_load_ps((const float*)phase_table + i),
-                     _mm256_mul_ps(deltas, delta));
-            }
-            else
-            {
-               sinc          = _mm256_load_ps((const float*)phase_table + i);
+               float32x4x2_t coeff8  = vld2q_f32(&phase_table[i]);
+               float32x4x2_t left8   = vld2q_f32(&buffer_l[i]);
+               float32x4x2_t right8  = vld2q_f32(&buffer_r[i]);
+
+               p1 = vmlaq_f32(p1,  left8.val[0], coeff8.val[0]);
+               p2 = vmlaq_f32(p2, right8.val[0], coeff8.val[0]);
+               p1 = vmlaq_f32(p1,  left8.val[1], coeff8.val[1]);
+               p2 = vmlaq_f32(p2, right8.val[1], coeff8.val[1]);
             }
 
-            sum_l         = _mm256_add_ps(sum_l, _mm256_mul_ps(buf_l, sinc));
-            sum_r         = _mm256_add_ps(sum_r, _mm256_mul_ps(buf_r, sinc));
+            p3 = vadd_f32(vget_low_f32(p1), vget_high_f32(p1));
+            p4 = vadd_f32(vget_low_f32(p2), vget_high_f32(p2));
+            vst1_f32(output, vpadd_f32(p3, p4));
+#endif
+            output                 += 2;
+            out_frames++;
+            resamp->time           += ratio;
          }
-
-         /* hadd on AVX is weird, and acts on low-lanes
-          * and high-lanes separately. */
-         __m256 res_l = _mm256_hadd_ps(sum_l, sum_l);
-         __m256 res_r = _mm256_hadd_ps(sum_r, sum_r);
-         res_l        = _mm256_hadd_ps(res_l, res_l);
-         res_r        = _mm256_hadd_ps(res_r, res_r);
-         res_l        = _mm256_add_ps(_mm256_permute2f128_ps(res_l, res_l, 1), res_l);
-         res_r        = _mm256_add_ps(_mm256_permute2f128_ps(res_r, res_r, 1), res_r);
-
-         /* This is optimized to mov %xmmN, [mem].
-          * There doesn't seem to be any _mm256_store_ss intrinsic. */
-         _mm_store_ss(output + 0, _mm256_extractf128_ps(res_l, 0));
-         _mm_store_ss(output + 1, _mm256_extractf128_ps(res_r, 0));
-
-         output += 2;
-         out_frames++;
-         resamp->time += ratio;
       }
    }
 
@@ -249,8 +240,8 @@ static void resampler_sinc_process_avx(void *re_, struct resampler_data *data)
 }
 #endif
 
-#if defined(__SSE__)
-static void resampler_sinc_process_sse(void *re_, struct resampler_data *data)
+#if defined(__AVX__)
+static void resampler_sinc_process_avx_kaiser(void *re_, struct resampler_data *data)
 {
    rarch_sinc_resampler_t *resamp = (rarch_sinc_resampler_t*)re_;
    unsigned phases                = 1 << (resamp->phase_bits + resamp->subphase_bits);
@@ -260,100 +251,342 @@ static void resampler_sinc_process_sse(void *re_, struct resampler_data *data)
    float *output                  = data->data_out;
    size_t frames                  = data->input_frames;
    size_t out_frames              = 0;
+   unsigned taps                  = resamp->taps;
 
-   while (frames)
    {
-      while (frames && resamp->time >= phases)
+      while (frames)
       {
-         /* Push in reverse to make filter more obvious. */
-         if (!resamp->ptr)
-            resamp->ptr = resamp->taps;
-         resamp->ptr--;
+         while (frames && resamp->time >= phases)
+         {
+            /* Push in reverse to make filter more obvious. */
+            if (!resamp->ptr)
+               resamp->ptr = taps;
+            resamp->ptr--;
 
-         resamp->buffer_l[resamp->ptr + resamp->taps] =
-         resamp->buffer_l[resamp->ptr]                = *input++;
+            resamp->buffer_l[resamp->ptr + taps] =
+               resamp->buffer_l[resamp->ptr]     = *input++;
 
-         resamp->buffer_r[resamp->ptr + resamp->taps] =
-         resamp->buffer_r[resamp->ptr]                = *input++;
+            resamp->buffer_r[resamp->ptr + taps] =
+               resamp->buffer_r[resamp->ptr]     = *input++;
 
-         resamp->time                                -= phases;
-         frames--;
+            resamp->time                                -= phases;
+            frames--;
+         }
+
+         {
+            const float *buffer_l    = resamp->buffer_l + resamp->ptr;
+            const float *buffer_r    = resamp->buffer_r + resamp->ptr;
+            while (resamp->time < phases)
+            {
+               int i;
+               unsigned phase           = resamp->time >> resamp->subphase_bits;
+
+               float *phase_table       = resamp->phase_table + phase * taps * 2;
+               float *delta_table       = phase_table + taps;
+               __m256 delta             = _mm256_set1_ps((float)
+                     (resamp->time & resamp->subphase_mask) * resamp->subphase_mod);
+
+               __m256 sum_l             = _mm256_setzero_ps();
+               __m256 sum_r             = _mm256_setzero_ps();
+
+               for (i = 0; i < (int)taps; i += 8)
+               {
+                  __m256 buf_l  = _mm256_loadu_ps(buffer_l + i);
+                  __m256 buf_r  = _mm256_loadu_ps(buffer_r + i);
+                  __m256 deltas = _mm256_load_ps(delta_table + i);
+                  __m256 sinc   = _mm256_add_ps(_mm256_load_ps((const float*)phase_table + i),
+                        _mm256_mul_ps(deltas, delta));
+
+                  sum_l         = _mm256_add_ps(sum_l, _mm256_mul_ps(buf_l, sinc));
+                  sum_r         = _mm256_add_ps(sum_r, _mm256_mul_ps(buf_r, sinc));
+               }
+
+               /* hadd on AVX is weird, and acts on low-lanes
+                * and high-lanes separately. */
+               __m256 res_l = _mm256_hadd_ps(sum_l, sum_l);
+               __m256 res_r = _mm256_hadd_ps(sum_r, sum_r);
+               res_l        = _mm256_hadd_ps(res_l, res_l);
+               res_r        = _mm256_hadd_ps(res_r, res_r);
+               res_l        = _mm256_add_ps(_mm256_permute2f128_ps(res_l, res_l, 1), res_l);
+               res_r        = _mm256_add_ps(_mm256_permute2f128_ps(res_r, res_r, 1), res_r);
+
+               /* This is optimized to mov %xmmN, [mem].
+                * There doesn't seem to be any _mm256_store_ss intrinsic. */
+               _mm_store_ss(output + 0, _mm256_extractf128_ps(res_l, 0));
+               _mm_store_ss(output + 1, _mm256_extractf128_ps(res_r, 0));
+
+               output += 2;
+               out_frames++;
+               resamp->time += ratio;
+            }
+         }
       }
+   }
 
-      while (resamp->time < phases)
-      {
-         unsigned i;
-         __m128 sum, sum_l, sum_r, delta;
-         float *phase_table       = NULL;
-         float *delta_table       = NULL;
-         const float *buffer_l    = resamp->buffer_l + resamp->ptr;
-         const float *buffer_r    = resamp->buffer_r + resamp->ptr;
-         unsigned taps            = resamp->taps;
-         unsigned phase           = resamp->time >> resamp->subphase_bits;
+   data->output_frames = out_frames;
+}
 
-         if (resamp->window_type == SINC_WINDOW_KAISER)
+static void resampler_sinc_process_avx(void *re_, struct resampler_data *data)
+{
+   rarch_sinc_resampler_t *resamp = (rarch_sinc_resampler_t*)re_;
+   unsigned phases                = 1 << (resamp->phase_bits + resamp->subphase_bits);
+
+   uint32_t ratio                 = phases / data->ratio;
+   const float *input             = data->data_in;
+   float *output                  = data->data_out;
+   size_t frames                  = data->input_frames;
+   size_t out_frames              = 0;
+   unsigned taps                  = resamp->taps;
+
+   {
+      while (frames)
+      {
+         while (frames && resamp->time >= phases)
          {
-            phase_table              = resamp->phase_table + phase * taps * 2;
-            delta_table              = phase_table + taps;
-            delta                    = _mm_set1_ps((float)
-                  (resamp->time & resamp->subphase_mask) * resamp->subphase_mod);
+            /* Push in reverse to make filter more obvious. */
+            if (!resamp->ptr)
+               resamp->ptr = taps;
+            resamp->ptr--;
+
+            resamp->buffer_l[resamp->ptr + taps] =
+               resamp->buffer_l[resamp->ptr]     = *input++;
+
+            resamp->buffer_r[resamp->ptr + taps] =
+               resamp->buffer_r[resamp->ptr]     = *input++;
+
+            resamp->time                        -= phases;
+            frames--;
          }
-         else
+
          {
-            phase_table              = resamp->phase_table + phase * taps;
+            const float *buffer_l    = resamp->buffer_l + resamp->ptr;
+            const float *buffer_r    = resamp->buffer_r + resamp->ptr;
+            while (resamp->time < phases)
+            {
+               int i;
+               __m256 delta;
+               unsigned phase           = resamp->time >> resamp->subphase_bits;
+               float *phase_table       = resamp->phase_table + phase * taps;
+
+               __m256 sum_l             = _mm256_setzero_ps();
+               __m256 sum_r             = _mm256_setzero_ps();
+
+               for (i = 0; i < (int)taps; i += 8)
+               {
+                  __m256 buf_l  = _mm256_loadu_ps(buffer_l + i);
+                  __m256 buf_r  = _mm256_loadu_ps(buffer_r + i);
+                  __m256 sinc   = _mm256_load_ps((const float*)phase_table + i);
+
+                  sum_l         = _mm256_add_ps(sum_l, _mm256_mul_ps(buf_l, sinc));
+                  sum_r         = _mm256_add_ps(sum_r, _mm256_mul_ps(buf_r, sinc));
+               }
+
+               /* hadd on AVX is weird, and acts on low-lanes
+                * and high-lanes separately. */
+               __m256 res_l = _mm256_hadd_ps(sum_l, sum_l);
+               __m256 res_r = _mm256_hadd_ps(sum_r, sum_r);
+               res_l        = _mm256_hadd_ps(res_l, res_l);
+               res_r        = _mm256_hadd_ps(res_r, res_r);
+               res_l        = _mm256_add_ps(_mm256_permute2f128_ps(res_l, res_l, 1), res_l);
+               res_r        = _mm256_add_ps(_mm256_permute2f128_ps(res_r, res_r, 1), res_r);
+
+               /* This is optimized to mov %xmmN, [mem].
+                * There doesn't seem to be any _mm256_store_ss intrinsic. */
+               _mm_store_ss(output + 0, _mm256_extractf128_ps(res_l, 0));
+               _mm_store_ss(output + 1, _mm256_extractf128_ps(res_r, 0));
+
+               output += 2;
+               out_frames++;
+               resamp->time += ratio;
+            }
          }
+      }
+   }
 
-         sum_l                    = _mm_setzero_ps();
-         sum_r                    = _mm_setzero_ps();
+   data->output_frames = out_frames;
+}
+#endif
 
-         for (i = 0; i < taps; i += 4)
+#if defined(__SSE__)
+static void resampler_sinc_process_sse_kaiser(void *re_, struct resampler_data *data)
+{
+   rarch_sinc_resampler_t *resamp = (rarch_sinc_resampler_t*)re_;
+   unsigned phases                = 1 << (resamp->phase_bits + resamp->subphase_bits);
+
+   uint32_t ratio                 = phases / data->ratio;
+   const float *input             = data->data_in;
+   float *output                  = data->data_out;
+   size_t frames                  = data->input_frames;
+   size_t out_frames              = 0;
+   unsigned taps                  = resamp->taps;
+
+   {
+      while (frames)
+      {
+         while (frames && resamp->time >= phases)
          {
-            __m128 deltas, _sinc;
-            __m128 buf_l = _mm_loadu_ps(buffer_l + i);
-            __m128 buf_r = _mm_loadu_ps(buffer_r + i);
+            /* Push in reverse to make filter more obvious. */
+            if (!resamp->ptr)
+               resamp->ptr = taps;
+            resamp->ptr--;
 
-            if (resamp->window_type == SINC_WINDOW_KAISER)
-            {
-               deltas = _mm_load_ps(delta_table + i);
-               _sinc  = _mm_add_ps(_mm_load_ps((const float*)phase_table + i),
-                     _mm_mul_ps(deltas, delta));
-            }
-            else
+            resamp->buffer_l[resamp->ptr + taps] =
+               resamp->buffer_l[resamp->ptr]     = *input++;
+
+            resamp->buffer_r[resamp->ptr + taps] =
+               resamp->buffer_r[resamp->ptr]     = *input++;
+
+            resamp->time                        -= phases;
+            frames--;
+         }
+
+         {
+            const float *buffer_l    = resamp->buffer_l + resamp->ptr;
+            const float *buffer_r    = resamp->buffer_r + resamp->ptr;
+            while (resamp->time < phases)
             {
-               _sinc  = _mm_load_ps((const float*)phase_table + i);
+               int i;
+               __m128 sum;
+               unsigned phase           = resamp->time >> resamp->subphase_bits;
+               float *phase_table       = resamp->phase_table + phase * taps * 2;
+               float *delta_table       = phase_table + taps;
+               __m128 delta             = _mm_set1_ps((float)
+                     (resamp->time & resamp->subphase_mask) * resamp->subphase_mod);
+
+               __m128 sum_l             = _mm_setzero_ps();
+               __m128 sum_r             = _mm_setzero_ps();
+
+               for (i = 0; i < (int)taps; i += 4)
+               {
+                  __m128 buf_l = _mm_loadu_ps(buffer_l + i);
+                  __m128 buf_r = _mm_loadu_ps(buffer_r + i);
+                  __m128 deltas = _mm_load_ps(delta_table + i);
+                  __m128 _sinc  = _mm_add_ps(_mm_load_ps((const float*)phase_table + i),
+                        _mm_mul_ps(deltas, delta));
+                  sum_l        = _mm_add_ps(sum_l, _mm_mul_ps(buf_l, _sinc));
+                  sum_r        = _mm_add_ps(sum_r, _mm_mul_ps(buf_r, _sinc));
+               }
+
+               /* Them annoying shuffles.
+                * sum_l = { l3, l2, l1, l0 }
+                * sum_r = { r3, r2, r1, r0 }
+                */
+
+               sum = _mm_add_ps(_mm_shuffle_ps(sum_l, sum_r,
+                        _MM_SHUFFLE(1, 0, 1, 0)),
+                     _mm_shuffle_ps(sum_l, sum_r, _MM_SHUFFLE(3, 2, 3, 2)));
+
+               /* sum   = { r1, r0, l1, l0 } + { r3, r2, l3, l2 }
+                * sum   = { R1, R0, L1, L0 }
+                */
+
+               sum = _mm_add_ps(_mm_shuffle_ps(sum, sum, _MM_SHUFFLE(3, 3, 1, 1)), sum);
+
+               /* sum   = {R1, R1, L1, L1 } + { R1, R0, L1, L0 }
+                * sum   = { X,  R,  X,  L }
+                */
+
+               /* Store L */
+               _mm_store_ss(output + 0, sum);
+
+               /* movehl { X, R, X, L } == { X, R, X, R } */
+               _mm_store_ss(output + 1, _mm_movehl_ps(sum, sum));
+
+               output += 2;
+               out_frames++;
+               resamp->time += ratio;
             }
-            sum_l        = _mm_add_ps(sum_l, _mm_mul_ps(buf_l, _sinc));
-            sum_r        = _mm_add_ps(sum_r, _mm_mul_ps(buf_r, _sinc));
          }
+      }
+   }
 
-         /* Them annoying shuffles.
-          * sum_l = { l3, l2, l1, l0 }
-          * sum_r = { r3, r2, r1, r0 }
-          */
+   data->output_frames = out_frames;
+}
 
-         sum = _mm_add_ps(_mm_shuffle_ps(sum_l, sum_r,
-                  _MM_SHUFFLE(1, 0, 1, 0)),
-               _mm_shuffle_ps(sum_l, sum_r, _MM_SHUFFLE(3, 2, 3, 2)));
+static void resampler_sinc_process_sse(void *re_, struct resampler_data *data)
+{
+   rarch_sinc_resampler_t *resamp = (rarch_sinc_resampler_t*)re_;
+   unsigned phases                = 1 << (resamp->phase_bits + resamp->subphase_bits);
 
-         /* sum   = { r1, r0, l1, l0 } + { r3, r2, l3, l2 }
-          * sum   = { R1, R0, L1, L0 }
-          */
+   uint32_t ratio                 = phases / data->ratio;
+   const float *input             = data->data_in;
+   float *output                  = data->data_out;
+   size_t frames                  = data->input_frames;
+   size_t out_frames              = 0;
+   unsigned taps                  = resamp->taps;
 
-         sum = _mm_add_ps(_mm_shuffle_ps(sum, sum, _MM_SHUFFLE(3, 3, 1, 1)), sum);
+   {
+      while (frames)
+      {
+         while (frames && resamp->time >= phases)
+         {
+            /* Push in reverse to make filter more obvious. */
+            if (!resamp->ptr)
+               resamp->ptr = taps;
+            resamp->ptr--;
 
-         /* sum   = {R1, R1, L1, L1 } + { R1, R0, L1, L0 }
-          * sum   = { X,  R,  X,  L }
-          */
+            resamp->buffer_l[resamp->ptr + taps] =
+               resamp->buffer_l[resamp->ptr]     = *input++;
 
-         /* Store L */
-         _mm_store_ss(output + 0, sum);
+            resamp->buffer_r[resamp->ptr + taps] =
+               resamp->buffer_r[resamp->ptr]     = *input++;
 
-         /* movehl { X, R, X, L } == { X, R, X, R } */
-         _mm_store_ss(output + 1, _mm_movehl_ps(sum, sum));
+            resamp->time                        -= phases;
+            frames--;
+         }
 
-         output += 2;
-         out_frames++;
-         resamp->time += ratio;
+         {
+            const float *buffer_l    = resamp->buffer_l + resamp->ptr;
+            const float *buffer_r    = resamp->buffer_r + resamp->ptr;
+            while (resamp->time < phases)
+            {
+               int i;
+               __m128 sum;
+               unsigned phase           = resamp->time >> resamp->subphase_bits;
+               float *phase_table       = resamp->phase_table + phase * taps;
+
+               __m128 sum_l             = _mm_setzero_ps();
+               __m128 sum_r             = _mm_setzero_ps();
+
+               for (i = 0; i < (int)taps; i += 4)
+               {
+                  __m128 buf_l = _mm_loadu_ps(buffer_l + i);
+                  __m128 buf_r = _mm_loadu_ps(buffer_r + i);
+                  __m128 _sinc = _mm_load_ps((const float*)phase_table + i);
+                  sum_l        = _mm_add_ps(sum_l, _mm_mul_ps(buf_l, _sinc));
+                  sum_r        = _mm_add_ps(sum_r, _mm_mul_ps(buf_r, _sinc));
+               }
+
+               /* Them annoying shuffles.
+                * sum_l = { l3, l2, l1, l0 }
+                * sum_r = { r3, r2, r1, r0 }
+                */
+
+               sum = _mm_add_ps(_mm_shuffle_ps(sum_l, sum_r,
+                        _MM_SHUFFLE(1, 0, 1, 0)),
+                     _mm_shuffle_ps(sum_l, sum_r, _MM_SHUFFLE(3, 2, 3, 2)));
+
+               /* sum   = { r1, r0, l1, l0 } + { r3, r2, l3, l2 }
+                * sum   = { R1, R0, L1, L0 }
+                */
+
+               sum = _mm_add_ps(_mm_shuffle_ps(sum, sum, _MM_SHUFFLE(3, 3, 1, 1)), sum);
+
+               /* sum   = {R1, R1, L1, L1 } + { R1, R0, L1, L0 }
+                * sum   = { X,  R,  X,  L }
+                */
+
+               /* Store L */
+               _mm_store_ss(output + 0, sum);
+
+               /* movehl { X, R, X, L } == { X, R, X, R } */
+               _mm_store_ss(output + 1, _mm_movehl_ps(sum, sum));
+
+               output += 2;
+               out_frames++;
+               resamp->time += ratio;
+            }
+         }
       }
    }
 
@@ -361,7 +594,7 @@ static void resampler_sinc_process_sse(void *re_, struct resampler_data *data)
 }
 #endif
 
-static void resampler_sinc_process_c(void *re_, struct resampler_data *data)
+static void resampler_sinc_process_c_kaiser(void *re_, struct resampler_data *data)
 {
    rarch_sinc_resampler_t *resamp = (rarch_sinc_resampler_t*)re_;
    unsigned phases                = 1 << (resamp->phase_bits + resamp->subphase_bits);
@@ -371,70 +604,126 @@ static void resampler_sinc_process_c(void *re_, struct resampler_data *data)
    float *output                  = data->data_out;
    size_t frames                  = data->input_frames;
    size_t out_frames              = 0;
+   unsigned taps                  = resamp->taps;
 
-   while (frames)
    {
-      while (frames && resamp->time >= phases)
+      while (frames)
       {
-         /* Push in reverse to make filter more obvious. */
-         if (!resamp->ptr)
-            resamp->ptr = resamp->taps;
-         resamp->ptr--;
-
-         resamp->buffer_l[resamp->ptr + resamp->taps]    =
-            resamp->buffer_l[resamp->ptr]                = *input++;
-
-         resamp->buffer_r[resamp->ptr + resamp->taps]    =
-            resamp->buffer_r[resamp->ptr]                = *input++;
+         while (frames && resamp->time >= phases)
+         {
+            /* Push in reverse to make filter more obvious. */
+            if (!resamp->ptr)
+               resamp->ptr = taps;
+            resamp->ptr--;
 
-         resamp->time                                   -= phases;
-         frames--;
-      }
+            resamp->buffer_l[resamp->ptr + taps]    =
+               resamp->buffer_l[resamp->ptr]        = *input++;
 
-      while (resamp->time < phases)
-      {
-         unsigned i;
-         float delta              = 0.0f;
-         float sum_l              = 0.0f;
-         float sum_r              = 0.0f;
-         float *phase_table       = NULL;
-         float *delta_table       = NULL;
-         const float *buffer_l    = resamp->buffer_l + resamp->ptr;
-         const float *buffer_r    = resamp->buffer_r + resamp->ptr;
-         unsigned taps            = resamp->taps;
-         unsigned phase           = resamp->time >> resamp->subphase_bits;
+            resamp->buffer_r[resamp->ptr + taps]    =
+               resamp->buffer_r[resamp->ptr]        = *input++;
 
-         if (resamp->window_type == SINC_WINDOW_KAISER)
-         {
-            phase_table           = resamp->phase_table + phase * taps * 2;
-            delta_table           = phase_table + taps;
-            delta                 = (float)
-               (resamp->time & resamp->subphase_mask) * resamp->subphase_mod;
+            resamp->time                           -= phases;
+            frames--;
          }
-         else
+
          {
-            phase_table           = resamp->phase_table + phase * taps;
+            const float *buffer_l    = resamp->buffer_l + resamp->ptr;
+            const float *buffer_r    = resamp->buffer_r + resamp->ptr;
+            while (resamp->time < phases)
+            {
+               int i;
+               float sum_l              = 0.0f;
+               float sum_r              = 0.0f;
+               unsigned phase           = resamp->time >> resamp->subphase_bits;
+               float *phase_table       = resamp->phase_table + phase * taps * 2;
+               float *delta_table       = phase_table + taps;
+               float delta              = (float)
+                  (resamp->time & resamp->subphase_mask) * resamp->subphase_mod;
+
+               for (i = 0; i < (int)taps; i++)
+               {
+                  float sinc_val        = phase_table[i] + delta_table[i] * delta;
+
+                  sum_l                += buffer_l[i] * sinc_val;
+                  sum_r                += buffer_r[i] * sinc_val;
+               }
+
+               output[0]                = sum_l;
+               output[1]                = sum_r;
+
+               output                  += 2;
+               out_frames++;
+               resamp->time            += ratio;
+            }
          }
 
-         for (i = 0; i < taps; i++)
+      }
+   }
+
+   data->output_frames = out_frames;
+}
+
+static void resampler_sinc_process_c(void *re_, struct resampler_data *data)
+{
+   rarch_sinc_resampler_t *resamp = (rarch_sinc_resampler_t*)re_;
+   unsigned phases                = 1 << (resamp->phase_bits + resamp->subphase_bits);
+
+   uint32_t ratio                 = phases / data->ratio;
+   const float *input             = data->data_in;
+   float *output                  = data->data_out;
+   size_t frames                  = data->input_frames;
+   size_t out_frames              = 0;
+   unsigned taps                  = resamp->taps;
+
+   {
+      while (frames)
+      {
+         while (frames && resamp->time >= phases)
          {
-            float sinc_val        = phase_table[i];
+            /* Push in reverse to make filter more obvious. */
+            if (!resamp->ptr)
+               resamp->ptr = taps;
+            resamp->ptr--;
+
+            resamp->buffer_l[resamp->ptr + taps]    =
+               resamp->buffer_l[resamp->ptr]        = *input++;
 
-            if (resamp->window_type == SINC_WINDOW_KAISER)
-               sinc_val           = sinc_val + delta_table[i] * delta;
+            resamp->buffer_r[resamp->ptr + taps]    =
+               resamp->buffer_r[resamp->ptr]        = *input++;
 
-            sum_l                += buffer_l[i] * sinc_val;
-            sum_r                += buffer_r[i] * sinc_val;
+            resamp->time                           -= phases;
+            frames--;
          }
 
-         output[0]                = sum_l;
-         output[1]                = sum_r;
+         {
+            const float *buffer_l    = resamp->buffer_l + resamp->ptr;
+            const float *buffer_r    = resamp->buffer_r + resamp->ptr;
+            while (resamp->time < phases)
+            {
+               int i;
+               float sum_l              = 0.0f;
+               float sum_r              = 0.0f;
+               unsigned phase           = resamp->time >> resamp->subphase_bits;
+               float *phase_table       = resamp->phase_table + phase * taps;
+
+               for (i = 0; i < (int)taps; i++)
+               {
+                  float sinc_val        = phase_table[i];
+
+                  sum_l                += buffer_l[i] * sinc_val;
+                  sum_r                += buffer_r[i] * sinc_val;
+               }
+
+               output[0]                = sum_l;
+               output[1]                = sum_r;
+
+               output                  += 2;
+               out_frames++;
+               resamp->time            += ratio;
+            }
+         }
 
-         output                  += 2;
-         out_frames++;
-         resamp->time            += ratio;
       }
-
    }
 
    data->output_frames = out_frames;
@@ -453,7 +742,9 @@ static void sinc_init_table_kaiser(rarch_sinc_resampler_t *resamp,
       float *phase_table, int phases, int taps, bool calculate_delta)
 {
    int i, j;
-   double    window_mod = kaiser_window_function(0.0, resamp->kaiser_beta); /* Need to normalize w(0) to 1.0. */
+   /* Kaiser window function - need to normalize w(0) to 1.0f */
+   float kaiser_beta    = resamp->kaiser_beta;
+   double    window_mod = besseli0(kaiser_beta);
    int           stride = calculate_delta ? 2 : 1;
    double     sidelobes = taps / 2.0;
 
@@ -461,14 +752,15 @@ static void sinc_init_table_kaiser(rarch_sinc_resampler_t *resamp,
    {
       for (j = 0; j < taps; j++)
       {
-         double sinc_phase;
          float val;
+         double sinc_phase;
          int               n = j * phases + i;
          double window_phase = (double)n / (phases * taps); /* [0, 1). */
          window_phase        = 2.0 * window_phase - 1.0; /* [-1, 1) */
          sinc_phase          = sidelobes * window_phase;
          val                 = cutoff * sinc(M_PI * sinc_phase * cutoff) *
-            kaiser_window_function(window_phase, resamp->kaiser_beta) / window_mod;
+              besseli0(kaiser_beta * sqrtf(1 - window_phase * window_phase))
+            / window_mod;
          phase_table[i * stride * taps + j] = val;
       }
    }
@@ -499,18 +791,21 @@ static void sinc_init_table_kaiser(rarch_sinc_resampler_t *resamp,
          sinc_phase          = sidelobes * window_phase;
 
          val                 = cutoff * sinc(M_PI * sinc_phase * cutoff) *
-            kaiser_window_function(window_phase, resamp->kaiser_beta) / window_mod;
+              besseli0(resamp->kaiser_beta * sqrtf(1 - window_phase *
+window_phase)) / window_mod;
          delta = (val - phase_table[phase * stride * taps + j]);
          phase_table[(phase * stride + 1) * taps + j] = delta;
       }
    }
 }
 
-static void sinc_init_table_lanczos(rarch_sinc_resampler_t *resamp, double cutoff,
+static void sinc_init_table_lanczos(
+      rarch_sinc_resampler_t *resamp, double cutoff,
       float *phase_table, int phases, int taps, bool calculate_delta)
 {
    int i, j;
-   double    window_mod = lanzcos_window_function(0.0); /* Need to normalize w(0) to 1.0. */
+   /* Lanczos window function - need to normalize w(0) to 1.0f */
+   double    window_mod = 1.0;
    int           stride = calculate_delta ? 2 : 1;
    double     sidelobes = taps / 2.0;
 
@@ -525,7 +820,7 @@ static void sinc_init_table_lanczos(rarch_sinc_resampler_t *resamp, double cutof
          window_phase        = 2.0 * window_phase - 1.0; /* [-1, 1) */
          sinc_phase          = sidelobes * window_phase;
          val                 = cutoff * sinc(M_PI * sinc_phase * cutoff) *
-            lanzcos_window_function(window_phase) / window_mod;
+            sinc(M_PI * window_phase) / window_mod;
          phase_table[i * stride * taps + j] = val;
       }
    }
@@ -556,7 +851,7 @@ static void sinc_init_table_lanczos(rarch_sinc_resampler_t *resamp, double cutof
          sinc_phase          = sidelobes * window_phase;
 
          val                 = cutoff * sinc(M_PI * sinc_phase * cutoff) *
-            lanzcos_window_function(window_phase) / window_mod;
+            sinc(M_PI * window_phase) / window_mod;
          delta = (val - phase_table[phase * stride * taps + j]);
          phase_table[(phase * stride + 1) * taps + j] = delta;
       }
@@ -570,15 +865,15 @@ static void *resampler_sinc_new(const struct resampler_config *config,
    double cutoff                  = 0.0;
    size_t phase_elems             = 0;
    size_t elems                   = 0;
+   unsigned enable_avx            = 0;
    unsigned sidelobes             = 0;
+   enum sinc_window window_type   = SINC_WINDOW_NONE;
    rarch_sinc_resampler_t *re     = (rarch_sinc_resampler_t*)
       calloc(1, sizeof(*re));
 
    if (!re)
       return NULL;
 
-   re->window_type                = SINC_WINDOW_NONE;
-
    switch (quality)
    {
       case RESAMPLER_QUALITY_LOWEST:
@@ -586,34 +881,32 @@ static void *resampler_sinc_new(const struct resampler_config *config,
          sidelobes         = 2;
          re->phase_bits    = 12;
          re->subphase_bits = 10;
-         re->window_type   = SINC_WINDOW_LANCZOS;
-         re->enable_avx    = 0;
+         window_type       = SINC_WINDOW_LANCZOS;
          break;
       case RESAMPLER_QUALITY_LOWER:
          cutoff            = 0.98;
          sidelobes         = 4;
          re->phase_bits    = 12;
          re->subphase_bits = 10;
-         re->window_type   = SINC_WINDOW_LANCZOS;
-         re->enable_avx    = 0;
+         window_type       = SINC_WINDOW_LANCZOS;
          break;
       case RESAMPLER_QUALITY_HIGHER:
          cutoff            = 0.90;
          sidelobes         = 32;
          re->phase_bits    = 10;
          re->subphase_bits = 14;
-         re->window_type   = SINC_WINDOW_KAISER;
+         window_type       = SINC_WINDOW_KAISER;
          re->kaiser_beta   = 10.5;
-         re->enable_avx    = 1;
+         enable_avx        = 1;
          break;
       case RESAMPLER_QUALITY_HIGHEST:
          cutoff            = 0.962;
          sidelobes         = 128;
          re->phase_bits    = 10;
          re->subphase_bits = 14;
-         re->window_type   = SINC_WINDOW_KAISER;
+         window_type       = SINC_WINDOW_KAISER;
          re->kaiser_beta   = 14.5;
-         re->enable_avx    = 1;
+         enable_avx        = 1;
          break;
       case RESAMPLER_QUALITY_NORMAL:
       case RESAMPLER_QUALITY_DONTCARE:
@@ -621,9 +914,8 @@ static void *resampler_sinc_new(const struct resampler_config *config,
          sidelobes         = 8;
          re->phase_bits    = 8;
          re->subphase_bits = 16;
-         re->window_type   = SINC_WINDOW_KAISER;
+         window_type       = SINC_WINDOW_KAISER;
          re->kaiser_beta   = 5.5;
-         re->enable_avx    = 0;
          break;
    }
 
@@ -635,18 +927,18 @@ static void *resampler_sinc_new(const struct resampler_config *config,
     * taps accordingly to keep same stopband attenuation. */
    if (bandwidth_mod < 1.0)
    {
-      cutoff *= bandwidth_mod;
+      cutoff  *= bandwidth_mod;
       re->taps = (unsigned)ceil(re->taps / bandwidth_mod);
    }
 
    /* Be SIMD-friendly. */
 #if defined(__AVX__)
-   if (re->enable_avx)
+   if (enable_avx)
       re->taps  = (re->taps + 7) & ~7;
    else
 #endif
    {
-#if defined(WANT_NEON)
+#if (defined(__ARM_NEON__) || defined(HAVE_NEON))
       re->taps     = (re->taps + 7) & ~7;
 #else
       re->taps     = (re->taps + 3) & ~3;
@@ -654,7 +946,7 @@ static void *resampler_sinc_new(const struct resampler_config *config,
    }
 
    phase_elems     = ((1 << re->phase_bits) * re->taps);
-   if (re->window_type == SINC_WINDOW_KAISER)
+   if (window_type == SINC_WINDOW_KAISER)
       phase_elems  = phase_elems * 2;
    elems           = phase_elems + 4 * re->taps;
 
@@ -668,7 +960,7 @@ static void *resampler_sinc_new(const struct resampler_config *config,
    re->buffer_l    = re->main_buffer + phase_elems;
    re->buffer_r    = re->buffer_l + 2 * re->taps;
 
-   switch (re->window_type)
+   switch (window_type)
    {
       case SINC_WINDOW_LANCZOS:
          sinc_init_table_lanczos(re, cutoff, re->phase_table,
@@ -683,23 +975,36 @@ static void *resampler_sinc_new(const struct resampler_config *config,
    }
 
    sinc_resampler.process = resampler_sinc_process_c;
+   if (window_type == SINC_WINDOW_KAISER)
+      sinc_resampler.process    = resampler_sinc_process_c_kaiser;
 
-   if (mask & RESAMPLER_SIMD_AVX && re->enable_avx)
+   if (mask & RESAMPLER_SIMD_AVX && enable_avx)
    {
 #if defined(__AVX__)
-      sinc_resampler.process = resampler_sinc_process_avx;
+      sinc_resampler.process    = resampler_sinc_process_avx;
+      if (window_type == SINC_WINDOW_KAISER)
+         sinc_resampler.process = resampler_sinc_process_avx_kaiser;
 #endif
    }
    else if (mask & RESAMPLER_SIMD_SSE)
    {
 #if defined(__SSE__)
       sinc_resampler.process = resampler_sinc_process_sse;
+      if (window_type == SINC_WINDOW_KAISER)
+         sinc_resampler.process = resampler_sinc_process_sse_kaiser;
 #endif
    }
-   else if (mask & RESAMPLER_SIMD_NEON && re->window_type != SINC_WINDOW_KAISER)
+   else if (mask & RESAMPLER_SIMD_NEON)
    {
-#if defined(WANT_NEON)
+#if (defined(__ARM_NEON__) || defined(HAVE_NEON))
+#ifdef HAVE_ARM_NEON_ASM_OPTIMIZATIONS
+      if (window_type != SINC_WINDOW_KAISER)
+         sinc_resampler.process = resampler_sinc_process_neon;
+#else
       sinc_resampler.process = resampler_sinc_process_neon;
+      if (window_type == SINC_WINDOW_KAISER)
+         sinc_resampler.process = resampler_sinc_process_neon_kaiser;
+#endif
 #endif
    }
 
@@ -718,5 +1023,3 @@ retro_resampler_t sinc_resampler = {
    "sinc",
    "sinc"
 };
-
-#undef WANT_NEON
diff --git a/src/libretro/libretro-common/audio/resampler/drivers/sinc_resampler_neon.S b/src/libretro/libretro-common/audio/resampler/drivers/sinc_resampler_neon.S
index ca157b8cd7..c9587fd3ae 100644
--- a/src/libretro/libretro-common/audio/resampler/drivers/sinc_resampler_neon.S
+++ b/src/libretro/libretro-common/audio/resampler/drivers/sinc_resampler_neon.S
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (sinc_resampler_neon.S).
@@ -20,7 +20,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#if defined(__ARM_NEON__) && !defined(DONT_WANT_ARM_OPTIMIZATIONS)
+#if defined(__ARM_NEON__) && defined(HAVE_ARM_NEON_ASM_OPTIMIZATIONS)
 
 #ifndef __MACH__
 .arm
diff --git a/src/libretro/libretro-common/cdrom/cdrom.c b/src/libretro/libretro-common/cdrom/cdrom.c
index cb5ff8c110..58cb5cf188 100644
--- a/src/libretro/libretro-common/cdrom/cdrom.c
+++ b/src/libretro/libretro-common/cdrom/cdrom.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2019 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
 *
 * ---------------------------------------------------------------------------------------
 * The following license statement only applies to this file (cdrom.c).
@@ -29,6 +29,7 @@
 #include <stdio.h>
 #include <string.h>
 #include <compat/strl.h>
+#include <compat/strcasestr.h>
 #include <retro_math.h>
 #include <retro_timers.h>
 #include <streams/file_stream.h>
@@ -96,6 +97,7 @@ void increment_msf(unsigned char *min, unsigned char *sec, unsigned char *frame)
    *frame = (*frame < 74) ? (*frame + 1) : 0;
 }
 
+#ifdef CDROM_DEBUG
 static void cdrom_print_sense_data(const unsigned char *sense, size_t len)
 {
    unsigned i;
@@ -252,6 +254,7 @@ static void cdrom_print_sense_data(const unsigned char *sense, size_t len)
 
    fflush(stdout);
 }
+#endif
 
 #if defined(_WIN32) && !defined(_XBOX)
 static int cdrom_send_command_win32(const libretro_vfs_implementation_file *stream, CDROM_CMD_Direction dir, void *buf, size_t len, unsigned char *cmd, size_t cmd_len, unsigned char *sense, size_t sense_len)
@@ -519,7 +522,9 @@ static int cdrom_send_command(libretro_vfs_implementation_file *stream, CDROM_CM
       }
       else
       {
+#ifdef CDROM_DEBUG
          cdrom_print_sense_data(sense, sizeof(sense));
+#endif
 
          /* INQUIRY/TEST/SENSE should never fail, don't retry. */
          /* READ ATIP seems to fail outright on some drives with pressed discs, skip retries. */
@@ -672,7 +677,9 @@ int cdrom_get_sense(libretro_vfs_implementation_file *stream, unsigned char *sen
    if (rv)
       return 1;
 
+#ifdef CDROM_DEBUG
    cdrom_print_sense_data(buf, sizeof(buf));
+#endif
 
    return 0;
 }
@@ -1336,22 +1343,26 @@ struct string_list* cdrom_get_available_drives(void)
 
    for (i = 0; i < (int)dir_list->size; i++)
    {
-      if (strstr(dir_list->elems[i].data, "/dev/sg"))
+      if (string_starts_with_size(dir_list->elems[i].data, "/dev/sg",
+               STRLEN_CONST("/dev/sg")))
       {
-         char drive_model[32] = {0};
-         char drive_string[33] = {0};
-         union string_list_elem_attr attr = {0};
-         int dev_index = 0;
-         RFILE *file = filestream_open(dir_list->elems[i].data, RETRO_VFS_FILE_ACCESS_READ, 0);
+         char drive_string[33];
          libretro_vfs_implementation_file *stream;
-         bool is_cdrom = false;
+         char drive_model[32]             = {0};
+         union string_list_elem_attr attr = {0};
+         int dev_index                    = 0;
+         RFILE *file                      = filestream_open(
+               dir_list->elems[i].data, RETRO_VFS_FILE_ACCESS_READ, 0);
+         bool is_cdrom                    = false;
 
          found = true;
 
          if (!file)
          {
+#ifdef CDROM_DEBUG
             printf("[CDROM] Could not open %s, please check permissions.\n", dir_list->elems[i].data);
             fflush(stdout);
+#endif
             continue;
          }
 
@@ -1362,15 +1373,16 @@ struct string_list* cdrom_get_available_drives(void)
          if (!is_cdrom)
             continue;
 
-         sscanf(dir_list->elems[i].data + strlen("/dev/sg"), "%d", &dev_index);
+         sscanf(dir_list->elems[i].data + STRLEN_CONST("/dev/sg"),
+               "%d", &dev_index);
 
          dev_index = '0' + dev_index;
-         attr.i = dev_index;
+         attr.i    = dev_index;
 
          if (!string_is_empty(drive_model))
-            strlcat(drive_string, drive_model, sizeof(drive_string));
+            strlcpy(drive_string, drive_model, sizeof(drive_string));
          else
-            strlcat(drive_string, "Unknown Drive", sizeof(drive_string));
+            strlcpy(drive_string, "Unknown Drive", sizeof(drive_string));
 
          string_list_append(list, drive_string, attr);
       }
@@ -1378,29 +1390,35 @@ struct string_list* cdrom_get_available_drives(void)
 
    if (!found)
    {
-      char *buf = NULL;
+      char *buf   = NULL;
       int64_t len = 0;
 
       if (filestream_read_file("/proc/modules", (void**)&buf, &len))
       {
-         struct string_list *mods = string_split(buf, "\n");
-         bool found = false;
+#ifdef CDROM_DEBUG
+         bool found              = false;
+#endif
+         struct string_list mods = {0};
 
-         if (mods)
+         string_list_initialize(&mods);
+         
+         if (string_split_noalloc(&mods, buf, "\n"))
          {
-
-            for (i = 0; i < mods->size; i++)
+            for (i = 0; i < (int)mods.size; i++)
             {
-               if (strcasestr(mods->elems[i].data, "sg "))
+               if (strcasestr(mods.elems[i].data, "sg "))
                {
+#ifdef CDROM_DEBUG
                   found = true;
+#endif
                   break;
                }
             }
-
-            string_list_free(mods);
          }
+         string_list_deinitialize(&mods);
+         free(buf);
 
+#ifdef CDROM_DEBUG
          if (found)
          {
             printf("[CDROM] No sg devices found but kernel module is loaded.\n");
@@ -1411,12 +1429,15 @@ struct string_list* cdrom_get_available_drives(void)
             printf("[CDROM] No sg devices found and sg kernel module is not loaded.\n");
             fflush(stdout);
          }
+#endif
       }
+#ifdef CDROM_DEBUG
       else
       {
          printf("[CDROM] No sg devices found, could not check if sg kernel module is loaded.\n");
          fflush(stdout);
       }
+#endif
    }
 
    string_list_free(dir_list);
@@ -1425,13 +1446,13 @@ struct string_list* cdrom_get_available_drives(void)
    DWORD drive_mask = GetLogicalDrives();
    int i;
 
-   for (i = 0; i < sizeof(DWORD) * 8; i++)
+   for (i = 0; i < (int)(sizeof(DWORD) * 8); i++)
    {
-      char path[] = {"a:\\"};
+      char path[]       = {"a:\\"};
       char cdrom_path[] = {"cdrom://a:/drive-track01.bin"};
 
-      path[0] += i;
-      cdrom_path[8] += i;
+      path[0]          += i;
+      cdrom_path[8]    += i;
 
       /* this drive letter doesn't exist */
       if (!(drive_mask & (1 << i)))
@@ -1439,15 +1460,14 @@ struct string_list* cdrom_get_available_drives(void)
 
       if (GetDriveType(path) != DRIVE_CDROM)
          continue;
-      else
+
       {
-         char drive_model[32] = {0};
-         char drive_string[33] = {0};
+         char drive_string[33];
+         libretro_vfs_implementation_file *stream;
+         bool is_cdrom                    = false;
+         char drive_model[32]             = {0};
          union string_list_elem_attr attr = {0};
          RFILE *file = filestream_open(cdrom_path, RETRO_VFS_FILE_ACCESS_READ, 0);
-         libretro_vfs_implementation_file *stream;
-         bool is_cdrom = false;
-
          if (!file)
             continue;
 
@@ -1461,9 +1481,9 @@ struct string_list* cdrom_get_available_drives(void)
          attr.i = path[0];
 
          if (!string_is_empty(drive_model))
-            strlcat(drive_string, drive_model, sizeof(drive_string));
+            strlcpy(drive_string, drive_model, sizeof(drive_string));
          else
-            strlcat(drive_string, "Unknown Drive", sizeof(drive_string));
+            strlcpy(drive_string, "Unknown Drive", sizeof(drive_string));
 
          string_list_append(list, drive_string, attr);
       }
@@ -1503,9 +1523,7 @@ bool cdrom_drive_has_media(const char drive)
    if (file)
    {
       libretro_vfs_implementation_file *stream = filestream_get_vfs_handle(file);
-      bool has_media = false;
-
-      has_media = cdrom_is_media_inserted(stream);
+      bool has_media = cdrom_is_media_inserted(stream);
 
       filestream_close(file);
 
@@ -1517,14 +1535,14 @@ bool cdrom_drive_has_media(const char drive)
 
 bool cdrom_set_read_cache(libretro_vfs_implementation_file *stream, bool enabled)
 {
+   int i;
    /* MMC Command: MODE SENSE (10) and MODE SELECT (10) */
    unsigned char cdb_sense_changeable[] = {0x5A, 0, 0x48, 0, 0, 0, 0, 0, 0x14, 0};
-   unsigned char cdb_sense[] = {0x5A, 0, 0x8, 0, 0, 0, 0, 0, 0x14, 0};
-   unsigned char cdb_select[] = {0x55, 0x10, 0, 0, 0, 0, 0, 0, 0x14, 0};
-   unsigned char buf[20] = {0};
-   int rv, i;
-
-   rv = cdrom_send_command(stream, DIRECTION_IN, buf, sizeof(buf), cdb_sense_changeable, sizeof(cdb_sense_changeable), 0);
+   unsigned char cdb_sense[]            = {0x5A, 0, 0x8, 0, 0, 0, 0, 0, 0x14, 0};
+   unsigned char cdb_select[]           = {0x55, 0x10, 0, 0, 0, 0, 0, 0, 0x14, 0};
+   unsigned char buf[20]                = {0};
+   int rv = cdrom_send_command(stream, DIRECTION_IN, buf, sizeof(buf),
+         cdb_sense_changeable, sizeof(cdb_sense_changeable), 0);
 
 #ifdef CDROM_DEBUG
    printf("[CDROM] mode sense changeable status code %d\n", rv);
@@ -1560,9 +1578,7 @@ bool cdrom_set_read_cache(libretro_vfs_implementation_file *stream, bool enabled
    printf("Mode sense data for caching mode page: ");
 
    for (i = 0; i < (int)sizeof(buf); i++)
-   {
       printf("%02X ", buf[i]);
-   }
 
    printf("\n");
    fflush(stdout);
@@ -1575,7 +1591,7 @@ bool cdrom_set_read_cache(libretro_vfs_implementation_file *stream, bool enabled
    if (enabled)
       buf[10] &= ~1;
    else
-      buf[10] |= 1;
+      buf[10] |=  1;
 
    rv = cdrom_send_command(stream, DIRECTION_OUT, buf, sizeof(buf), cdb_select, sizeof(cdb_select), 0);
 
@@ -1624,9 +1640,7 @@ bool cdrom_get_timeouts(libretro_vfs_implementation_file *stream, cdrom_group_ti
       printf("Mode sense data for timeout groups: ");
 
       for (i = 0; i < (int)sizeof(buf); i++)
-      {
          printf("%02X ", buf[i]);
-      }
 
       printf("\n");
 
@@ -1648,8 +1662,8 @@ bool cdrom_get_timeouts(libretro_vfs_implementation_file *stream, cdrom_group_ti
 bool cdrom_has_atip(libretro_vfs_implementation_file *stream)
 {
    /* MMC Command: READ TOC/PMA/ATIP */
-   unsigned char cdb[] = {0x43, 0x2, 0x4, 0, 0, 0, 0, 0x9, 0x30, 0};
-   unsigned char buf[32] = {0};
+   unsigned char cdb[]     = {0x43, 0x2, 0x4, 0, 0, 0, 0, 0x9, 0x30, 0};
+   unsigned char buf[32]   = {0};
    unsigned short atip_len = 0;
    int rv = cdrom_send_command(stream, DIRECTION_IN, buf, sizeof(buf), cdb, sizeof(cdb), 0);
 
@@ -1659,7 +1673,10 @@ bool cdrom_has_atip(libretro_vfs_implementation_file *stream)
    atip_len = buf[0] << 8 | buf[1];
 
 #ifdef CDROM_DEBUG
-   printf("ATIP Length %d, Disc Type %d, Disc Sub-Type %d\n", atip_len, (buf[6] >> 6) & 0x1, ((buf[6] >> 5) & 0x1) << 2 | ((buf[6] >> 4) & 0x1) << 1 | ((buf[6] >> 3) & 0x1) << 0);
+   printf("ATIP Length %d, Disc Type %d, Disc Sub-Type %d\n",
+         atip_len,
+         (buf[6]  >> 6) & 0x1,
+         ((buf[6] >> 5) & 0x1) << 2 | ((buf[6] >> 4) & 0x1) << 1 | ((buf[6] >> 3) & 0x1) << 0);
 #endif
 
    if (atip_len < 5)
@@ -1670,30 +1687,23 @@ bool cdrom_has_atip(libretro_vfs_implementation_file *stream)
 
 void cdrom_device_fillpath(char *path, size_t len, char drive, unsigned char track, bool is_cue)
 {
-   size_t pos = 0;
-
    if (!path || len == 0)
       return;
-
    if (is_cue)
    {
 #ifdef _WIN32
-      pos = strlcpy(path, "cdrom://", len);
-
+      size_t pos = strlcpy(path, "cdrom://", len);
       if (len > pos)
          path[pos++] = drive;
-
       pos = strlcat(path, ":/drive.cue", len);
 #else
 #ifdef __linux__
-      pos = strlcpy(path, "cdrom://drive", len);
-
+      size_t pos = strlcpy(path, "cdrom://drive", len);
       if (len > pos + 1)
       {
          path[pos++] = drive;
-         path[pos] = '\0';
+         path[pos]   = '\0';
       }
-
       pos = strlcat(path, ".cue", len);
 #endif
 #endif
@@ -1701,22 +1711,18 @@ void cdrom_device_fillpath(char *path, size_t len, char drive, unsigned char tra
    else
    {
 #ifdef _WIN32
-      pos = strlcpy(path, "cdrom://", len);
-
+      size_t pos = strlcpy(path, "cdrom://", len);
       if (len > pos + 1)
       {
          path[pos++] = drive;
-         path[pos] = '\0';
+         path[pos]   = '\0';
       }
-
       pos += snprintf(path + pos, len - pos, ":/drive-track%02d.bin", track);
 #else
 #ifdef __linux__
-      pos = strlcpy(path, "cdrom://drive", len);
-
+      size_t pos = strlcpy(path, "cdrom://drive", len);
       if (len > pos)
          path[pos++] = drive;
-
       pos += snprintf(path + pos, len - pos, "-track%02d.bin", track);
 #endif
 #endif
diff --git a/src/libretro/libretro-common/compat/compat_fnmatch.c b/src/libretro/libretro-common/compat/compat_fnmatch.c
index 19f87cc76a..8e46ce8a3c 100644
--- a/src/libretro/libretro-common/compat/compat_fnmatch.c
+++ b/src/libretro/libretro-common/compat/compat_fnmatch.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (compat_fnmatch.c).
@@ -20,9 +20,6 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#if __TEST_FNMATCH__
-#include <assert.h>
-#endif
 #include <stddef.h>
 
 #include <compat/fnmatch.h>
@@ -123,37 +120,3 @@ int rl_fnmatch(const char *pattern, const char *string, int flags)
       return 0;
    return FNM_NOMATCH;
 }
-
-#if __TEST_FNMATCH__
-int main(void)
-{
-   assert(rl_fnmatch("TEST", "TEST", 0) == 0);
-   assert(rl_fnmatch("TE?T", "TEST", 0) == 0);
-   assert(rl_fnmatch("TE[Ssa]T", "TEST", 0) == 0);
-   assert(rl_fnmatch("TE[Ssda]T", "TEsT", 0) == 0);
-   assert(rl_fnmatch("TE[Ssda]T", "TEdT", 0) == 0);
-   assert(rl_fnmatch("TE[Ssda]T", "TEaT", 0) == 0);
-   assert(rl_fnmatch("TEST*", "TEST", 0) == 0);
-   assert(rl_fnmatch("TEST**", "TEST", 0) == 0);
-   assert(rl_fnmatch("TE*ST*", "TEST", 0) == 0);
-   assert(rl_fnmatch("TE**ST*", "TEST", 0) == 0);
-   assert(rl_fnmatch("TE**ST*", "TExST", 0) == 0);
-   assert(rl_fnmatch("TE**ST", "TEST", 0) == 0);
-   assert(rl_fnmatch("TE**ST", "TExST", 0) == 0);
-   assert(rl_fnmatch("TE\\**ST", "TE*xST", 0) == 0);
-   assert(rl_fnmatch("*.*", "test.jpg", 0) == 0);
-   assert(rl_fnmatch("*.jpg", "test.jpg", 0) == 0);
-   assert(rl_fnmatch("*.[Jj][Pp][Gg]", "test.jPg", 0) == 0);
-   assert(rl_fnmatch("*.[Jj]*[Gg]", "test.jPg", 0) == 0);
-   assert(rl_fnmatch("TEST?", "TEST", 0) == FNM_NOMATCH);
-   assert(rl_fnmatch("TES[asd", "TEST", 0) == FNM_NOMATCH);
-   assert(rl_fnmatch("TEST\\", "TEST", 0) == FNM_NOMATCH);
-   assert(rl_fnmatch("TEST*S", "TEST", 0) == FNM_NOMATCH);
-   assert(rl_fnmatch("TE**ST", "TExT", 0) == FNM_NOMATCH);
-   assert(rl_fnmatch("TE\\*T", "TExT", 0) == FNM_NOMATCH);
-   assert(rl_fnmatch("TES?", "TES", 0) == FNM_NOMATCH);
-   assert(rl_fnmatch("TE", "TEST", 0) == FNM_NOMATCH);
-   assert(rl_fnmatch("TEST!", "TEST", 0) == FNM_NOMATCH);
-   assert(rl_fnmatch("DSAD", "TEST", 0) == FNM_NOMATCH);
-}
-#endif
diff --git a/src/libretro/libretro-common/compat/compat_getopt.c b/src/libretro/libretro-common/compat/compat_getopt.c
index 81978b86c2..2d1652236a 100644
--- a/src/libretro/libretro-common/compat/compat_getopt.c
+++ b/src/libretro/libretro-common/compat/compat_getopt.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (compat_getopt.c).
@@ -35,8 +35,6 @@
 #include <compat/strcasestr.h>
 #include <compat/posix_string.h>
 
-#include <retro_assert.h>
-
 char *optarg;
 int optind, opterr, optopt;
 
@@ -126,19 +124,38 @@ static int parse_short(const char *optstring, char * const *argv)
 static int parse_long(const struct option *longopts, char * const *argv)
 {
    size_t indice;
+   char *save  = NULL;
+   char *argv0 = strdup(&argv[0][2]);
+   char *token = strtok_r(argv0, "=", &save);
    const struct option *opt = NULL;
+
    for (indice = 0; longopts[indice].name; indice++)
    {
-      if (!strcmp(longopts[indice].name, &argv[0][2]))
+      if (token && !strcmp(longopts[indice].name, token))
       {
          opt = &longopts[indice];
          break;
       }
    }
 
+   free(argv0);
+   argv0 = NULL;
+
    if (!opt)
       return '?';
 
+   /* Handle args with '=' instead of space */
+   if (opt->has_arg)
+   {
+      char *special_arg = strchr(argv[0], '=');
+      if (special_arg)
+      {
+         optarg = ++special_arg;
+         optind++;
+         return opt->val;
+      }
+   }
+
    /* getopt_long has an "optional" arg, but we don't bother with that. */
    if (opt->has_arg && !argv[1])
       return '?';
@@ -165,8 +182,6 @@ static void shuffle_block(char **begin, char **last, char **end)
    ptrdiff_t    len = last - begin;
    const char **tmp = (const char**)calloc(len, sizeof(const char*));
 
-   retro_assert(tmp);
-
    memcpy((void*)tmp, begin, len * sizeof(const char*));
    memmove(begin, last, (end - last) * sizeof(const char*));
    memcpy(end - len, tmp, len * sizeof(const char*));
@@ -179,8 +194,6 @@ int getopt_long(int argc, char *argv[],
 {
    int short_index, long_index;
 
-   (void)longindex;
-
    if (optind == 0)
       optind = 1;
 
@@ -208,8 +221,6 @@ int getopt_long(int argc, char *argv[],
       long_index = 0;
    }
 
-   retro_assert(short_index == 0 || long_index == 0);
-
    if (short_index == 0)
       return parse_short(optstring, &argv[optind]);
    if (long_index == 0)
diff --git a/src/libretro/libretro-common/compat/compat_ifaddrs.c b/src/libretro/libretro-common/compat/compat_ifaddrs.c
index 3e54e899e1..4a270b69df 100644
--- a/src/libretro/libretro-common/compat/compat_ifaddrs.c
+++ b/src/libretro/libretro-common/compat/compat_ifaddrs.c
@@ -48,12 +48,13 @@ static int netlink_socket(void)
    struct sockaddr_nl l_addr;
    int l_socket = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
 
-   if(l_socket < 0)
+   if (l_socket < 0)
       return -1;
 
    memset(&l_addr, 0, sizeof(l_addr));
    l_addr.nl_family = AF_NETLINK;
-   if(bind(l_socket, (struct sockaddr *)&l_addr, sizeof(l_addr)) < 0)
+
+   if (bind(l_socket, (struct sockaddr *)&l_addr, sizeof(l_addr)) < 0)
    {
       close(l_socket);
       return -1;
@@ -91,67 +92,77 @@ static int netlink_recv(int p_socket, void *p_buffer, size_t p_len)
    struct iovec l_iov = { p_buffer, p_len };
    struct sockaddr_nl l_addr;
 
-   for(;;)
+   for (;;)
    {
-      l_msg.msg_name = (void *)&l_addr;
-      l_msg.msg_namelen = sizeof(l_addr);
-      l_msg.msg_iov = &l_iov;
-      l_msg.msg_iovlen = 1;
-      l_msg.msg_control = NULL;
+      int l_result;
+
+      l_msg.msg_name       = (void *)&l_addr;
+      l_msg.msg_namelen    = sizeof(l_addr);
+      l_msg.msg_iov        = &l_iov;
+      l_msg.msg_iovlen     = 1;
+      l_msg.msg_control    = NULL;
       l_msg.msg_controllen = 0;
-      l_msg.msg_flags = 0;
-      int l_result = recvmsg(p_socket, &l_msg, 0);
+      l_msg.msg_flags      = 0;
+
+      l_result             = recvmsg(p_socket, &l_msg, 0);
 
-      if(l_result < 0)
+      if (l_result < 0)
       {
-         if(errno == EINTR)
+         if (errno == EINTR)
             continue;
          return -2;
       }
 
-      if(l_msg.msg_flags & MSG_TRUNC) /* buffer too small */
+      if (l_msg.msg_flags & MSG_TRUNC) /* buffer too small */
          return -1;
       return l_result;
    }
 }
 
-static struct nlmsghdr *getNetlinkResponse(int p_socket, int *p_size, int *p_done)
+static struct nlmsghdr *getNetlinkResponse(int p_socket,
+      int *p_size, int *p_done)
 {
-   size_t l_size = 4096;
+   size_t l_size  = 4096;
    void *l_buffer = NULL;
 
-   for(;;)
+   for (;;)
    {
+      int l_read;
+
       free(l_buffer);
       l_buffer = malloc(l_size);
-      if (l_buffer == NULL)
+      if (!l_buffer)
          return NULL;
 
-      int l_read = netlink_recv(p_socket, l_buffer, l_size);
+      l_read  = netlink_recv(p_socket, l_buffer, l_size);
       *p_size = l_read;
 
-      if(l_read == -2)
+      if (l_read == -2)
       {
          free(l_buffer);
          return NULL;
       }
 
-      if(l_read >= 0)
+      if (l_read >= 0)
       {
          pid_t l_pid = getpid();
          struct nlmsghdr *l_hdr;
-         for(l_hdr = (struct nlmsghdr *)l_buffer; NLMSG_OK(l_hdr, (unsigned int)l_read); l_hdr = (struct nlmsghdr *)NLMSG_NEXT(l_hdr, l_read))
+
+         for (l_hdr = (struct nlmsghdr *)l_buffer;
+               NLMSG_OK(l_hdr, (unsigned int)l_read);
+               l_hdr = (struct nlmsghdr *)NLMSG_NEXT(l_hdr, l_read))
          {
-            if((pid_t)l_hdr->nlmsg_pid != l_pid || (int)l_hdr->nlmsg_seq != p_socket)
+            if (  (pid_t)l_hdr->nlmsg_pid != l_pid || 
+                  (int)l_hdr->nlmsg_seq   != p_socket)
                continue;
 
-            if(l_hdr->nlmsg_type == NLMSG_DONE)
+            if (l_hdr->nlmsg_type == NLMSG_DONE)
             {
                *p_done = 1;
                break;
             }
 
-            if(l_hdr->nlmsg_type == NLMSG_ERROR)
+            if (l_hdr->nlmsg_type == NLMSG_ERROR)
             {
                free(l_buffer);
                return NULL;
@@ -166,8 +177,8 @@ static struct nlmsghdr *getNetlinkResponse(int p_socket, int *p_size, int *p_don
 
 static NetlinkList *newListItem(struct nlmsghdr *p_data, unsigned int p_size)
 {
-   NetlinkList *l_item = malloc(sizeof(NetlinkList));
-   if (l_item == NULL)
+   NetlinkList *l_item = (NetlinkList*)malloc(sizeof(NetlinkList));
+   if (!l_item)
       return NULL;
 
    l_item->m_next = NULL;
@@ -179,7 +190,8 @@ static NetlinkList *newListItem(struct nlmsghdr *p_data, unsigned int p_size)
 static void freeResultList(NetlinkList *p_list)
 {
    NetlinkList *l_cur;
-   while(p_list)
+
+   while (p_list)
    {
       l_cur = p_list;
       p_list = p_list->m_next;
@@ -190,29 +202,30 @@ static void freeResultList(NetlinkList *p_list)
 
 static NetlinkList *getResultList(int p_socket, int p_request)
 {
-   if(netlink_send(p_socket, p_request) < 0)
+   int l_size;
+   NetlinkList *l_list = NULL;
+   NetlinkList *l_end  = NULL;
+   int l_done          = 0;
+
+   if (netlink_send(p_socket, p_request) < 0)
       return NULL;
 
-   NetlinkList *l_list = NULL;
-   NetlinkList *l_end = NULL;
-   int l_size;
-   int l_done = 0;
-   while(!l_done)
+   while (!l_done)
    {
       NetlinkList *l_item    = NULL;
       struct nlmsghdr *l_hdr = getNetlinkResponse(p_socket, &l_size, &l_done);
-      if(!l_hdr)
+      if (!l_hdr)
          goto error;
 
       l_item = newListItem(l_hdr, l_size);
       if (!l_item)
          goto error;
 
-      if(!l_list)
-         l_list = l_item;
+      if (!l_list)
+         l_list        = l_item;
       else
          l_end->m_next = l_item;
-      l_end = l_item;
+      l_end            = l_item;
    }
 
    return l_list;
@@ -267,12 +280,12 @@ static void makeSockaddr(sa_family_t p_family, struct sockaddr *p_dest, void *p_
 
 static void addToEnd(struct ifaddrs **p_resultList, struct ifaddrs *p_entry)
 {
-   if(!*p_resultList)
+   if (!*p_resultList)
       *p_resultList = p_entry;
    else
    {
       struct ifaddrs *l_cur = *p_resultList;
-      while(l_cur->ifa_next)
+      while (l_cur->ifa_next)
          l_cur = l_cur->ifa_next;
       l_cur->ifa_next = p_entry;
    }
@@ -288,7 +301,8 @@ static int interpretLink(struct nlmsghdr *p_hdr, struct ifaddrs **p_resultList)
    size_t l_dataSize        = 0;
    size_t l_rtaSize         = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifinfomsg));
 
-   for(l_rta = IFLA_RTA(l_info); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize))
+   for (l_rta = IFLA_RTA(l_info); RTA_OK(l_rta, l_rtaSize);
+         l_rta = RTA_NEXT(l_rta, l_rtaSize))
    {
       size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
       switch(l_rta->rta_type)
@@ -308,8 +322,8 @@ static int interpretLink(struct nlmsghdr *p_hdr, struct ifaddrs **p_resultList)
       }
    }
 
-   l_entry = malloc(sizeof(struct ifaddrs) + sizeof(int) + l_nameSize + l_addrSize + l_dataSize);
-   if (l_entry == NULL)
+   l_entry = (struct ifaddrs*)malloc(sizeof(struct ifaddrs) + sizeof(int) + l_nameSize + l_addrSize + l_dataSize);
+   if (!l_entry)
       return -1;
 
    memset(l_entry, 0, sizeof(struct ifaddrs));
@@ -320,16 +334,20 @@ static int interpretLink(struct nlmsghdr *p_hdr, struct ifaddrs **p_resultList)
    char *l_addr = l_name + l_nameSize;
    char *l_data = l_addr + l_addrSize;
 
-   // save the interface index so we can look it up when handling the addresses.
+   /* save the interface index so we can look 
+    * it up when handling the addresses. */
    memcpy(l_index, &l_info->ifi_index, sizeof(int));
 
    l_entry->ifa_flags = l_info->ifi_flags;
 
-   l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifinfomsg));
-   for(l_rta = IFLA_RTA(l_info); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize))
+   l_rtaSize          = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifinfomsg));
+
+   for (l_rta = IFLA_RTA(l_info); RTA_OK(l_rta, l_rtaSize);
+         l_rta = RTA_NEXT(l_rta, l_rtaSize))
    {
-      void *l_rtaData = RTA_DATA(l_rta);
+      void      *l_rtaData = RTA_DATA(l_rta);
       size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
+
       switch(l_rta->rta_type)
       {
          case IFLA_ADDRESS:
@@ -339,8 +357,8 @@ static int interpretLink(struct nlmsghdr *p_hdr, struct ifaddrs **p_resultList)
                makeSockaddr(AF_PACKET, (struct sockaddr *)l_addr, l_rtaData, l_rtaDataSize);
                ((struct sockaddr_ll *)l_addr)->sll_ifindex = l_info->ifi_index;
                ((struct sockaddr_ll *)l_addr)->sll_hatype = l_info->ifi_type;
-               if(l_rta->rta_type == IFLA_ADDRESS)
-                  l_entry->ifa_addr = (struct sockaddr *)l_addr;
+               if (l_rta->rta_type == IFLA_ADDRESS)
+                  l_entry->ifa_addr      = (struct sockaddr *)l_addr;
                else
                   l_entry->ifa_broadaddr = (struct sockaddr *)l_addr;
                l_addr += NLMSG_ALIGN(l_addrLen);
@@ -364,17 +382,19 @@ static int interpretLink(struct nlmsghdr *p_hdr, struct ifaddrs **p_resultList)
    return 0;
 }
 
-static struct ifaddrs *findInterface(int p_index, struct ifaddrs **p_links, int p_numLinks)
+static struct ifaddrs *findInterface(int p_index,
+      struct ifaddrs **p_links, int p_numLinks)
 {
-   int l_num = 0;
+   int l_num             = 0;
    struct ifaddrs *l_cur = *p_links;
-   while(l_cur && l_num < p_numLinks)
+
+   while (l_cur && l_num < p_numLinks)
    {
       int l_index;
       char *l_indexPtr = ((char *)l_cur) + sizeof(struct ifaddrs);
 
       memcpy(&l_index, l_indexPtr, sizeof(int));
-      if(l_index == p_index)
+      if (l_index == p_index)
          return l_cur;
 
       l_cur = l_cur->ifa_next;
@@ -383,21 +403,24 @@ static struct ifaddrs *findInterface(int p_index, struct ifaddrs **p_links, int
    return NULL;
 }
 
-static int interpretAddr(struct nlmsghdr *p_hdr, struct ifaddrs **p_resultList, int p_numLinks)
+static int interpretAddr(struct nlmsghdr *p_hdr,
+      struct ifaddrs **p_resultList, int p_numLinks)
 {
-   size_t l_nameSize = 0;
-   size_t l_addrSize = 0;
-   int l_addedNetmask = 0;
-   struct ifaddrmsg *l_info = (struct ifaddrmsg *)NLMSG_DATA(p_hdr);
+   struct rtattr *l_rta;
+   size_t l_rtaSize;
+   size_t l_nameSize           = 0;
+   size_t l_addrSize           = 0;
+   int l_addedNetmask          = 0;
+   struct ifaddrmsg *l_info    = (struct ifaddrmsg *)NLMSG_DATA(p_hdr);
    struct ifaddrs *l_interface = findInterface(l_info->ifa_index, p_resultList, p_numLinks);
 
-   if(l_info->ifa_family == AF_PACKET)
+   if (l_info->ifa_family == AF_PACKET)
       return 0;
 
-   size_t l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifaddrmsg));
-   struct rtattr *l_rta;
+   l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifaddrmsg));
 
-   for(l_rta = IFA_RTA(l_info); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize))
+   for (l_rta = IFA_RTA(l_info); RTA_OK(l_rta, l_rtaSize);
+         l_rta = RTA_NEXT(l_rta, l_rtaSize))
    {
       size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
 
@@ -405,7 +428,7 @@ static int interpretAddr(struct nlmsghdr *p_hdr, struct ifaddrs **p_resultList,
       {
          case IFA_ADDRESS:
          case IFA_LOCAL:
-            if((l_info->ifa_family == AF_INET || l_info->ifa_family == AF_INET6) && !l_addedNetmask)
+            if ((l_info->ifa_family == AF_INET || l_info->ifa_family == AF_INET6) && !l_addedNetmask)
             {
                /* make room for netmask */
                l_addrSize += NLMSG_ALIGN(calcAddrLen(l_info->ifa_family, l_rtaDataSize));
@@ -422,8 +445,8 @@ static int interpretAddr(struct nlmsghdr *p_hdr, struct ifaddrs **p_resultList,
       }
    }
 
-   struct ifaddrs *l_entry = malloc(sizeof(struct ifaddrs) + l_nameSize + l_addrSize);
-   if (l_entry == NULL)
+   struct ifaddrs *l_entry = (struct ifaddrs*)malloc(sizeof(struct ifaddrs) + l_nameSize + l_addrSize);
+   if (!l_entry)
       return -1;
 
    memset(l_entry, 0, sizeof(struct ifaddrs));
@@ -433,11 +456,12 @@ static int interpretAddr(struct nlmsghdr *p_hdr, struct ifaddrs **p_resultList,
    char *l_addr = l_name + l_nameSize;
 
    l_entry->ifa_flags = l_info->ifa_flags;
-   if(l_interface)
+   if (l_interface)
       l_entry->ifa_flags |= l_interface->ifa_flags;
 
    l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifaddrmsg));
-   for(l_rta = IFA_RTA(l_info); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize))
+   for (l_rta = IFA_RTA(l_info); RTA_OK(l_rta, l_rtaSize);
+         l_rta = RTA_NEXT(l_rta, l_rtaSize))
    {
       void *l_rtaData = RTA_DATA(l_rta);
       size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
@@ -449,24 +473,24 @@ static int interpretAddr(struct nlmsghdr *p_hdr, struct ifaddrs **p_resultList,
             {
                size_t l_addrLen = calcAddrLen(l_info->ifa_family, l_rtaDataSize);
                makeSockaddr(l_info->ifa_family, (struct sockaddr *)l_addr, l_rtaData, l_rtaDataSize);
-               if(l_info->ifa_family == AF_INET6)
+               if (l_info->ifa_family == AF_INET6)
                {
-                  if(IN6_IS_ADDR_LINKLOCAL((struct in6_addr *)l_rtaData) || IN6_IS_ADDR_MC_LINKLOCAL((struct in6_addr *)l_rtaData))
+                  if (IN6_IS_ADDR_LINKLOCAL((struct in6_addr *)l_rtaData) || IN6_IS_ADDR_MC_LINKLOCAL((struct in6_addr *)l_rtaData))
                      ((struct sockaddr_in6 *)l_addr)->sin6_scope_id = l_info->ifa_index;
                }
 
-               if(l_rta->rta_type == IFA_ADDRESS)
+               if (l_rta->rta_type == IFA_ADDRESS)
                {
                   /* apparently in a point-to-point network IFA_ADDRESS
                    * contains the dest address and IFA_LOCAL contains the local address */
-                  if(l_entry->ifa_addr)
+                  if (l_entry->ifa_addr)
                      l_entry->ifa_dstaddr = (struct sockaddr *)l_addr;
                   else
                      l_entry->ifa_addr = (struct sockaddr *)l_addr;
                }
-               else if(l_rta->rta_type == IFA_LOCAL)
+               else if (l_rta->rta_type == IFA_LOCAL)
                {
-                  if(l_entry->ifa_addr)
+                  if (l_entry->ifa_addr)
                      l_entry->ifa_dstaddr = l_entry->ifa_addr;
                   l_entry->ifa_addr = (struct sockaddr *)l_addr;
                }
@@ -485,7 +509,7 @@ static int interpretAddr(struct nlmsghdr *p_hdr, struct ifaddrs **p_resultList,
       }
    }
 
-   if(l_entry->ifa_addr &&
+   if (l_entry->ifa_addr &&
          (   l_entry->ifa_addr->sa_family == AF_INET
           || l_entry->ifa_addr->sa_family == AF_INET6))
    {
@@ -498,9 +522,9 @@ static int interpretAddr(struct nlmsghdr *p_hdr, struct ifaddrs **p_resultList,
 
       l_mask[0] = '\0';
 
-      for(i=0; i<(l_prefix/8); ++i)
+      for (i=0; i<(l_prefix/8); ++i)
          l_mask[i] = 0xff;
-      if(l_prefix % 8)
+      if (l_prefix % 8)
          l_mask[i] = 0xff << (8 - (l_prefix % 8));
 
       makeSockaddr(l_entry->ifa_addr->sa_family,
@@ -516,23 +540,26 @@ static int interpretLinks(int p_socket, NetlinkList *p_netlinkList,
       struct ifaddrs **p_resultList)
 {
    int l_numLinks = 0;
-   pid_t l_pid = getpid();
-   for(; p_netlinkList; p_netlinkList = p_netlinkList->m_next)
+   pid_t l_pid    = getpid();
+
+   for (; p_netlinkList; p_netlinkList = p_netlinkList->m_next)
    {
       struct nlmsghdr *l_hdr = NULL;
       unsigned int l_nlsize  = p_netlinkList->m_size;
 
-      for(l_hdr = p_netlinkList->m_data; NLMSG_OK(l_hdr, l_nlsize); l_hdr = NLMSG_NEXT(l_hdr, l_nlsize))
+      for (l_hdr = p_netlinkList->m_data; NLMSG_OK(l_hdr, l_nlsize);
+            l_hdr = NLMSG_NEXT(l_hdr, l_nlsize))
       {
-         if((pid_t)l_hdr->nlmsg_pid != l_pid || (int)l_hdr->nlmsg_seq != p_socket)
+         if (  (pid_t)l_hdr->nlmsg_pid != l_pid || 
+               (int)l_hdr->nlmsg_seq   != p_socket)
             continue;
 
-         if(l_hdr->nlmsg_type == NLMSG_DONE)
+         if (l_hdr->nlmsg_type == NLMSG_DONE)
             break;
 
-         if(l_hdr->nlmsg_type == RTM_NEWLINK)
+         if (l_hdr->nlmsg_type == RTM_NEWLINK)
          {
-            if(interpretLink(l_hdr, p_resultList) == -1)
+            if (interpretLink(l_hdr, p_resultList) == -1)
                return -1;
             ++l_numLinks;
          }
@@ -545,20 +572,22 @@ static int interpretAddrs(int p_socket, NetlinkList *p_netlinkList,
       struct ifaddrs **p_resultList, int p_numLinks)
 {
    pid_t l_pid = getpid();
-   for(; p_netlinkList; p_netlinkList = p_netlinkList->m_next)
+   for (; p_netlinkList; p_netlinkList = p_netlinkList->m_next)
    {
       struct nlmsghdr *l_hdr = NULL;
       unsigned int l_nlsize  = p_netlinkList->m_size;
 
-      for(l_hdr = p_netlinkList->m_data; NLMSG_OK(l_hdr, l_nlsize); l_hdr = NLMSG_NEXT(l_hdr, l_nlsize))
+      for (l_hdr = p_netlinkList->m_data; NLMSG_OK(l_hdr, l_nlsize);
+            l_hdr = NLMSG_NEXT(l_hdr, l_nlsize))
       {
-         if((pid_t)l_hdr->nlmsg_pid != l_pid || (int)l_hdr->nlmsg_seq != p_socket)
+         if (     (pid_t)l_hdr->nlmsg_pid != l_pid 
+               || (int)l_hdr->nlmsg_seq   != p_socket)
             continue;
 
-         if(l_hdr->nlmsg_type == NLMSG_DONE)
+         if (l_hdr->nlmsg_type == NLMSG_DONE)
             break;
 
-         if(l_hdr->nlmsg_type == RTM_NEWADDR)
+         if (l_hdr->nlmsg_type == RTM_NEWADDR)
          {
             if (interpretAddr(l_hdr, p_resultList, p_numLinks) == -1)
                return -1;
@@ -570,34 +599,40 @@ static int interpretAddrs(int p_socket, NetlinkList *p_netlinkList,
 
 int getifaddrs(struct ifaddrs **ifap)
 {
-   int l_socket = 0;
-   int l_result = 0;
-   if(!ifap)
+   NetlinkList *l_linkResults;
+   NetlinkList *l_addrResults;
+   int l_numLinks;
+   int l_socket   = 0;
+   int l_result   = 0;
+   if (!ifap)
       return -1;
-   *ifap = NULL;
+
+   *ifap    = NULL;
 
    l_socket = netlink_socket();
-   if(l_socket < 0)
+
+   if (l_socket < 0)
       return -1;
 
-   NetlinkList *l_linkResults = getResultList(l_socket, RTM_GETLINK);
-   if(!l_linkResults)
+   l_linkResults = getResultList(l_socket, RTM_GETLINK);
+   if (!l_linkResults)
    {
       close(l_socket);
       return -1;
    }
 
-   NetlinkList *l_addrResults = getResultList(l_socket, RTM_GETADDR);
-   if(!l_addrResults)
+   l_addrResults = getResultList(l_socket, RTM_GETADDR);
+   if (!l_addrResults)
    {
       close(l_socket);
       freeResultList(l_linkResults);
       return -1;
    }
 
-   int l_numLinks = interpretLinks(l_socket, l_linkResults, ifap);
+   l_numLinks = interpretLinks(l_socket, l_linkResults, ifap);
 
-   if(l_numLinks == -1 || interpretAddrs(l_socket, l_addrResults, ifap, l_numLinks) == -1)
+   if (  l_numLinks == -1 || 
+         interpretAddrs(l_socket, l_addrResults, ifap, l_numLinks) == -1)
       l_result = -1;
 
    freeResultList(l_linkResults);
@@ -610,10 +645,10 @@ void freeifaddrs(struct ifaddrs *ifa)
 {
    struct ifaddrs *l_cur = NULL;
 
-   while(ifa)
+   while (ifa)
    {
       l_cur = ifa;
-      ifa = ifa->ifa_next;
+      ifa   = ifa->ifa_next;
       free(l_cur);
    }
 }
diff --git a/src/libretro/libretro-common/compat/compat_posix_string.c b/src/libretro/libretro-common/compat/compat_posix_string.c
index 33a30e5772..6a2f07ee4b 100644
--- a/src/libretro/libretro-common/compat/compat_posix_string.c
+++ b/src/libretro/libretro-common/compat/compat_posix_string.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (compat_posix_string.c).
diff --git a/src/libretro/libretro-common/compat/compat_snprintf.c b/src/libretro/libretro-common/compat/compat_snprintf.c
index b69ad047a2..d7320cc949 100644
--- a/src/libretro/libretro-common/compat/compat_snprintf.c
+++ b/src/libretro/libretro-common/compat/compat_snprintf.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (compat_snprintf.c).
@@ -33,12 +33,12 @@
 #if _MSC_VER < 1300
 #define _vscprintf c89_vscprintf_retro__
 
-static int c89_vscprintf_retro__(const char *format, va_list pargs)
+static int c89_vscprintf_retro__(const char *fmt, va_list pargs)
 {
    int retval;
    va_list argcopy;
    va_copy(argcopy, pargs);
-   retval = vsnprintf(NULL, 0, format, argcopy);
+   retval = vsnprintf(NULL, 0, fmt, argcopy);
    va_end(argcopy);
    return retval;
 }
@@ -46,38 +46,36 @@ static int c89_vscprintf_retro__(const char *format, va_list pargs)
 
 /* http://stackoverflow.com/questions/2915672/snprintf-and-visual-studio-2010 */
 
-int c99_vsnprintf_retro__(char *outBuf, size_t size, const char *format, va_list ap)
+int c99_vsnprintf_retro__(char *s, size_t len, const char *fmt, va_list ap)
 {
    int count = -1;
 
-   if (size != 0)
+   if (len != 0)
    {
 #if (_MSC_VER <= 1310)
-      count = _vsnprintf(outBuf, size - 1, format, ap);
+      count = _vsnprintf(s, len - 1, fmt, ap);
 #else
-      count = _vsnprintf_s(outBuf, size, size - 1, format, ap);
+      count = _vsnprintf_s(s, len, len - 1, fmt, ap);
 #endif
    }
 
    if (count == -1)
-       count = _vscprintf(format, ap);
+       count = _vscprintf(fmt, ap);
 
-   if (count == size)
-   {
-      /* there was no room for a NULL, so truncate the last character */
-      outBuf[size - 1] = '\0';
-   }
+   /* there was no room for a NULL, so truncate the last character */
+   if (count == len && len)
+      s[len - 1] = '\0';
 
    return count;
 }
 
-int c99_snprintf_retro__(char *outBuf, size_t size, const char *format, ...)
+int c99_snprintf_retro__(char *s, size_t len, const char *fmt, ...)
 {
    int count;
    va_list ap;
 
-   va_start(ap, format);
-   count = c99_vsnprintf_retro__(outBuf, size, format, ap);
+   va_start(ap, fmt);
+   count = c99_vsnprintf_retro__(s, len, fmt, ap);
    va_end(ap);
 
    return count;
diff --git a/src/libretro/libretro-common/compat/compat_strcasestr.c b/src/libretro/libretro-common/compat/compat_strcasestr.c
index 54c93a48d0..4129dab29a 100644
--- a/src/libretro/libretro-common/compat/compat_strcasestr.c
+++ b/src/libretro/libretro-common/compat/compat_strcasestr.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (compat_strcasestr.c).
diff --git a/src/libretro/libretro-common/compat/compat_strl.c b/src/libretro/libretro-common/compat/compat_strl.c
index 94cb39b62b..3a6392cb12 100644
--- a/src/libretro/libretro-common/compat/compat_strl.c
+++ b/src/libretro/libretro-common/compat/compat_strl.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (compat_strl.c).
@@ -60,10 +60,3 @@ size_t strlcat(char *dest, const char *source, size_t size)
    return len + strlcpy(dest, source, size);
 }
 #endif
-
-char *strldup(const char *s, size_t n)
-{
-   char *dst = (char*)malloc(sizeof(char) * (n + 1));
-   strlcpy(dst, s, n);
-   return dst;
-}
diff --git a/src/libretro/libretro-common/compat/compat_vscprintf.c b/src/libretro/libretro-common/compat/compat_vscprintf.c
index ddffeb7e77..50e9e8d7ed 100644
--- a/src/libretro/libretro-common/compat/compat_vscprintf.c
+++ b/src/libretro/libretro-common/compat/compat_vscprintf.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2017 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (compat_snprintf.c).
diff --git a/src/libretro/libretro-common/compat/fopen_utf8.c b/src/libretro/libretro-common/compat/fopen_utf8.c
index 893afb83ea..384657b5df 100644
--- a/src/libretro/libretro-common/compat/fopen_utf8.c
+++ b/src/libretro/libretro-common/compat/fopen_utf8.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (fopen_utf8.c).
@@ -37,22 +37,28 @@
 void *fopen_utf8(const char * filename, const char * mode)
 {
 #if defined(LEGACY_WIN32)
-   FILE             *ret = NULL;
    char * filename_local = utf8_to_local_string_alloc(filename);
-
-   if (!filename_local)
-      return NULL;
-   ret = fopen(filename_local, mode);
    if (filename_local)
+   {
+      FILE *ret          = fopen(filename_local, mode);
       free(filename_local);
-   return ret;
+      return ret;
+   }
 #else
-   wchar_t * filename_w = utf8_to_utf16_string_alloc(filename);
-   wchar_t * mode_w = utf8_to_utf16_string_alloc(mode);
-   FILE* ret = _wfopen(filename_w, mode_w);
-   free(filename_w);
-   free(mode_w);
-   return ret;
+   wchar_t * filename_w  = utf8_to_utf16_string_alloc(filename);
+   if (filename_w)
+   {
+      FILE    *ret       = NULL;
+      wchar_t *mode_w    = utf8_to_utf16_string_alloc(mode);
+      if (mode_w)
+      {
+         ret             = _wfopen(filename_w, mode_w);
+         free(mode_w);
+      }
+      free(filename_w);
+      return ret;
+   }
 #endif
+   return NULL;
 }
 #endif
diff --git a/src/libretro/libretro-common/dynamic/dylib.c b/src/libretro/libretro-common/dynamic/dylib.c
index 74c1c879e3..248c61283a 100644
--- a/src/libretro/libretro-common/dynamic/dylib.c
+++ b/src/libretro/libretro-common/dynamic/dylib.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (dylib.c).
@@ -25,14 +25,20 @@
 #include <dynamic/dylib.h>
 #include <encodings/utf.h>
 
+#if defined(ORBIS)
+#include <orbis/libkernel.h>
+#endif
+
 #ifdef NEED_DYNAMIC
 
 #ifdef _WIN32
 #include <compat/posix_string.h>
 #include <windows.h>
 #else
+#if !defined(ORBIS)
 #include <dlfcn.h>
 #endif
+#endif
 
 /* Assume W-functions do not work below Win2K and Xbox platforms */
 #if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0500 || defined(_XBOX)
@@ -69,7 +75,7 @@ static void set_dl_error(void)
  *
  * Platform independent dylib loading.
  *
- * Returns: library handle on success, otherwise NULL.
+ * @return Library handle on success, otherwise NULL.
  **/
 dylib_t dylib_load(const char *path)
 {
@@ -78,35 +84,34 @@ dylib_t dylib_load(const char *path)
    int prevmode = SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX);
 #endif
 #ifdef __WINRT__
+   dylib_t lib;
    /* On UWP, you can only load DLLs inside your install directory, using a special function that takes a relative path */
+   char relative_path_abbrev[PATH_MAX_LENGTH];
+   char *relative_path = relative_path_abbrev;
+   wchar_t *path_wide  = NULL;
+
+   relative_path_abbrev[0] = '\0';
 
    if (!path_is_absolute(path))
       RARCH_WARN("Relative path in dylib_load! This is likely an attempt to load a system library that will fail\n");
 
-   char *relative_path_abbrev = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
-   fill_pathname_abbreviate_special(relative_path_abbrev, path, PATH_MAX_LENGTH * sizeof(char));
+   fill_pathname_abbreviate_special(relative_path_abbrev, path, sizeof(relative_path_abbrev));
 
-   char *relative_path = relative_path_abbrev;
-   if (relative_path[0] != ':' || !path_char_is_slash(relative_path[1]))
-   {
-      /* Path to dylib_load is not inside app install directory.
-       * Loading will probably fail. */
-   }
+   /* Path to dylib_load is not inside app install directory.
+    * Loading will probably fail. */
+   if (relative_path[0] != ':' || !PATH_CHAR_IS_SLASH(relative_path[1])) { }
    else
       relative_path += 2;
 
-
-   wchar_t *pathW = utf8_to_utf16_string_alloc(relative_path);
-   dylib_t lib = LoadPackagedLibrary(pathW, 0);
-   free(pathW);
-
-   free(relative_path_abbrev);
+   path_wide = utf8_to_utf16_string_alloc(relative_path);
+   lib       = LoadPackagedLibrary(path_wide, 0);
+   free(path_wide);
 #elif defined(LEGACY_WIN32)
-   dylib_t lib  = LoadLibrary(path);
+   dylib_t lib        = LoadLibrary(path);
 #else
-   wchar_t *pathW = utf8_to_utf16_string_alloc(path);
-   dylib_t lib  = LoadLibraryW(pathW);
-   free(pathW);
+   wchar_t *path_wide = utf8_to_utf16_string_alloc(path);
+   dylib_t lib        = LoadLibraryW(path_wide);
+   free(path_wide);
 #endif
 
 #ifndef __WINRT__
@@ -119,6 +124,9 @@ dylib_t dylib_load(const char *path)
       return NULL;
    }
    last_dyn_error[0] = 0;
+#elif defined(ORBIS)
+   int res;
+   dylib_t lib = (dylib_t)sceKernelLoadStartModule(path, 0, NULL, 0, NULL, &res);
 #else
    dylib_t lib = dlopen(path, RTLD_LAZY | RTLD_LOCAL);
 #endif
@@ -142,26 +150,33 @@ function_t dylib_proc(dylib_t lib, const char *proc)
 
 #ifdef _WIN32
    HMODULE mod = (HMODULE)lib;
-#ifndef __WINRT__
-   if (!mod)
-      mod = GetModuleHandle(NULL);
-#else
-   /* GetModuleHandle is not available on UWP */
    if (!mod)
    {
+#ifdef __WINRT__
+      /* GetModuleHandle is not available on UWP */
       /* It's not possible to lookup symbols in current executable
        * on UWP. */
       DebugBreak();
       return NULL;
-   }
+#else
+      mod = GetModuleHandle(NULL);
 #endif
-   sym = (function_t)GetProcAddress(mod, proc);
-   if (!sym)
+   }
+   if (!(sym = (function_t)GetProcAddress(mod, proc)))
    {
       set_dl_error();
       return NULL;
    }
    last_dyn_error[0] = 0;
+#elif defined(ORBIS)
+   void *ptr_sym = NULL;
+   sym = NULL;
+
+   if (lib)
+   {
+     sceKernelDlsym((SceKernelModule)lib, proc, &ptr_sym);
+     memcpy(&sym, &ptr_sym, sizeof(void*));
+   }
 #else
    void *ptr_sym = NULL;
 
@@ -197,6 +212,9 @@ void dylib_close(dylib_t lib)
    if (!FreeLibrary((HMODULE)lib))
       set_dl_error();
    last_dyn_error[0] = 0;
+#elif defined(ORBIS)
+   int res;
+   sceKernelStopUnloadModule((SceKernelModule)lib, 0, NULL, 0, NULL, &res);
 #else
 #ifndef NO_DLCLOSE
    dlclose(lib);
diff --git a/src/libretro/libretro-common/encodings/encoding_base64.c b/src/libretro/libretro-common/encodings/encoding_base64.c
index 7f30cf9e98..eb4224367a 100644
--- a/src/libretro/libretro-common/encodings/encoding_base64.c
+++ b/src/libretro/libretro-common/encodings/encoding_base64.c
@@ -29,6 +29,38 @@
 #include <stdlib.h>
 #include <encodings/base64.h>
 
+const static char* b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+/* maps A=>0,B=>1.. */
+const static unsigned char unb64[]={
+  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+  0,   0,   0,  62,   0,   0,   0,  63,  52,  53,
+ 54,  55,  56,  57,  58,  59,  60,  61,   0,   0,
+  0,   0,   0,   0,   0,   0,   1,   2,   3,   4,
+  5,   6,   7,   8,   9,  10,  11,  12,  13,  14,
+ 15,  16,  17,  18,  19,  20,  21,  22,  23,  24,
+ 25,   0,   0,   0,   0,   0,   0,  26,  27,  28,
+ 29,  30,  31,  32,  33,  34,  35,  36,  37,  38,
+ 39,  40,  41,  42,  43,  44,  45,  46,  47,  48,
+ 49,  50,  51,   0,   0,   0,   0,   0,   0,   0,
+  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
+  0,   0,   0,   0,   0,   0,
+}; /* This array has 256 elements */
+
 /*
    Converts binary data of length=len to base64 characters.
    Length of the resultant string is stored in flen
@@ -36,24 +68,17 @@
 */
 char* base64(const void* binaryData, int len, int *flen)
 {
-   const unsigned char* bin          = (const unsigned char*) binaryData;
    char* res;
-  
-   int rc = 0; /* result counter */
    int byteNo; /* I need this after the loop */
-  
-   int modulusLen = len % 3 ;
-
+   const unsigned char* bin = (const unsigned char*) binaryData;
+   int rc                   = 0; /* result counter */
+   int modulusLen           = len % 3 ;
    /* 2 gives 1 and 1 gives 2, but 0 gives 0. */
-   int pad = ((modulusLen&1)<<1) + ((modulusLen&2)>>1);
+   int pad                  = ((modulusLen&1)<<1) + ((modulusLen&2)>>1);
 
-   *flen = 4*(len + pad)/3;
-   res = (char*) malloc(*flen + 1); /* and one for the null */
-   if (!res)
-   {
-      /* ERROR: base64 could not allocate enough memory. */
+   *flen                    = 4*(len + pad)/3;
+   if (!(res = (char*) malloc(*flen + 1))) /* and one for the NULL */
       return 0;
-   }
   
    for (byteNo=0; byteNo <= len-3; byteNo+=3)
    {
@@ -88,34 +113,29 @@ char* base64(const void* binaryData, int len, int *flen)
 
 unsigned char* unbase64(const char* ascii, int len, int *flen)
 {
-   const unsigned char *safeAsciiPtr = (const unsigned char*) ascii;
+   int charNo;
    unsigned char *bin;
+   const unsigned char *safeAsciiPtr = (const unsigned char*) ascii;
    int cb                            = 0;
-   int charNo;
    int pad                           = 0;
 
-   if (len < 2) { /* 2 accesses below would be OOB. */
+   if (len < 2) /* 2 accesses below would be OOB (Out Of Bounds). */
+   {
       /* catch empty string, return NULL as result. */
-
       /* ERROR: You passed an invalid base64 string (too short). 
        * You get NULL back. */
       *flen = 0;
       return 0;
    }
 
-   if(safeAsciiPtr[len-1]=='=')
+   if (safeAsciiPtr[len-1]=='=')
       ++pad;
-   if(safeAsciiPtr[len-2]=='=')
+   if (safeAsciiPtr[len-2]=='=')
       ++pad;
   
    *flen = 3*len/4 - pad;
-   bin = (unsigned char*)malloc(*flen);
-
-   if (!bin)
-   {
-      /* ERROR: unbase64 could not allocate enough memory. */
+   if (!(bin = (unsigned char*)malloc(*flen)))
       return 0;
-   }
   
    for (charNo=0; charNo <= len-4-pad; charNo+=4)
    {
diff --git a/src/libretro/libretro-common/encodings/encoding_crc32.c b/src/libretro/libretro-common/encodings/encoding_crc32.c
index a0d1e580ab..ab8ce8267e 100644
--- a/src/libretro/libretro-common/encodings/encoding_crc32.c
+++ b/src/libretro/libretro-common/encodings/encoding_crc32.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (encoding_crc32.c).
@@ -23,7 +23,6 @@
 #include <stdint.h>
 #include <stddef.h>
 #include <encodings/crc32.h>
-#include <streams/file_stream.h>
 #include <stdlib.h>
 
 static const uint32_t crc32_table[256] = {
@@ -90,51 +89,3 @@ uint32_t encoding_crc32(uint32_t crc, const uint8_t *buf, size_t len)
 
    return crc ^ 0xffffffff;
 }
-
-#define CRC32_BUFFER_SIZE 1048576
-#define CRC32_MAX_MB 64
-
-/**
- * Calculate a CRC32 from the first part of the given file.
- * "first part" being the first (CRC32_BUFFER_SIZE * CRC32_MAX_MB)
- * bytes.
- *
- * Returns: the crc32, or 0 if there was an error.
- */
-uint32_t file_crc32(uint32_t crc, const char *path)
-{
-   unsigned i;
-   RFILE *file        = NULL;
-   unsigned char *buf = NULL;
-   if (!path)
-      return 0;
-
-   file = filestream_open(path, RETRO_VFS_FILE_ACCESS_READ, 0);
-   if (!file)
-      goto error;
-
-   buf = (unsigned char*)malloc(CRC32_BUFFER_SIZE);
-   if (!buf)
-      goto error;
-
-   for(i = 0; i < CRC32_MAX_MB; i++)
-   {
-      int64_t nread = filestream_read(file, buf, CRC32_BUFFER_SIZE);
-      if (nread < 0)		
-         goto error;
-
-      crc = encoding_crc32(crc, buf, (size_t)nread);
-      if (filestream_eof(file))
-         break;
-   }
-   free(buf);
-   filestream_close(file);
-   return crc;
-
-error:
-   if (buf)
-      free(buf);
-   if (file)
-      filestream_close(file);
-   return 0;
-}
diff --git a/src/libretro/libretro-common/encodings/encoding_utf.c b/src/libretro/libretro-common/encodings/encoding_utf.c
index b6ad2f9669..f9c594de60 100644
--- a/src/libretro/libretro-common/encodings/encoding_utf.c
+++ b/src/libretro/libretro-common/encodings/encoding_utf.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (encoding_utf.c).
@@ -37,6 +37,8 @@
 #include <xtl.h>
 #endif
 
+#define UTF8_WALKBYTE(string) (*((*(string))++))
+
 static unsigned leading_ones(uint8_t c)
 {
    unsigned ones = 0;
@@ -49,9 +51,12 @@ static unsigned leading_ones(uint8_t c)
    return ones;
 }
 
-/* Simple implementation. Assumes the sequence is
- * properly synchronized and terminated. */
-
+/**
+ * utf8_conv_utf32:
+ *
+ * Simple implementation. Assumes the sequence is
+ * properly synchronized and terminated.
+ **/
 size_t utf8_conv_utf32(uint32_t *out, size_t out_chars,
       const char *in, size_t in_size)
 {
@@ -77,7 +82,7 @@ size_t utf8_conv_utf32(uint32_t *out, size_t out_chars,
       for (i = 0; i < extra; i++, in++, shift -= 6)
          c |= (*in & 0x3f) << shift;
 
-      *out++ = c;
+      *out++   = c;
       in_size -= 1 + extra;
       out_chars--;
       ret++;
@@ -86,16 +91,22 @@ size_t utf8_conv_utf32(uint32_t *out, size_t out_chars,
    return ret;
 }
 
+/**
+ * utf16_conv_utf8:
+ *
+ * Leaf function.
+ **/
 bool utf16_conv_utf8(uint8_t *out, size_t *out_chars,
      const uint16_t *in, size_t in_size)
 {
-   static uint8_t kUtf8Limits[5] = { 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
-   size_t out_pos = 0;
-   size_t in_pos  = 0;
+   size_t out_pos            = 0;
+   size_t in_pos             = 0;
+   static const 
+      uint8_t utf8_limits[5] = { 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
 
    for (;;)
    {
-      unsigned numAdds;
+      unsigned num_adds;
       uint32_t value;
 
       if (in_pos == in_size)
@@ -124,37 +135,41 @@ bool utf16_conv_utf8(uint8_t *out, size_t *out_chars,
          value = (((value - 0xD800) << 10) | (c2 - 0xDC00)) + 0x10000;
       }
 
-      for (numAdds = 1; numAdds < 5; numAdds++)
-         if (value < (((uint32_t)1) << (numAdds * 5 + 6)))
+      for (num_adds = 1; num_adds < 5; num_adds++)
+         if (value < (((uint32_t)1) << (num_adds * 5 + 6)))
             break;
       if (out)
-         out[out_pos] = (char)(kUtf8Limits[numAdds - 1]
-               + (value >> (6 * numAdds)));
+         out[out_pos] = (char)(utf8_limits[num_adds - 1]
+               + (value >> (6 * num_adds)));
       out_pos++;
       do
       {
-         numAdds--;
+         num_adds--;
          if (out)
             out[out_pos] = (char)(0x80
-                  + ((value >> (6 * numAdds)) & 0x3F));
+                  + ((value >> (6 * num_adds)) & 0x3F));
          out_pos++;
-      }while (numAdds != 0);
+      }while (num_adds != 0);
    }
 
    *out_chars = out_pos;
    return false;
 }
 
-/* Acts mostly like strlcpy.
+/**
+ * utf8cpy:
+ *
+ * Acts mostly like strlcpy.
  *
  * Copies the given number of UTF-8 characters,
- * but at most d_len bytes.
+ * but at most @d_len bytes.
  *
- * Always NULL terminates.
- * Does not copy half a character.
+ * Always NULL terminates. Does not copy half a character.
+ * @s is assumed valid UTF-8.
+ * Use only if @chars is considerably less than @d_len. 
  *
- * Returns number of bytes. 's' is assumed valid UTF-8.
- * Use only if 'chars' is considerably less than 'd_len'. */
+ * @return Number of bytes. 
+ **/
 size_t utf8cpy(char *d, size_t d_len, const char *s, size_t chars)
 {
    const uint8_t *sb     = (const uint8_t*)s;
@@ -166,13 +181,15 @@ size_t utf8cpy(char *d, size_t d_len, const char *s, size_t chars)
    while (*sb && chars-- > 0)
    {
       sb++;
-      while ((*sb & 0xC0) == 0x80) sb++;
+      while ((*sb & 0xC0) == 0x80)
+         sb++;
    }
 
    if ((size_t)(sb - sb_org) > d_len-1 /* NUL */)
    {
       sb = sb_org + d_len-1;
-      while ((*sb & 0xC0) == 0x80) sb--;
+      while ((*sb & 0xC0) == 0x80)
+         sb--;
    }
 
    memcpy(d, sb_org, sb-sb_org);
@@ -181,20 +198,34 @@ size_t utf8cpy(char *d, size_t d_len, const char *s, size_t chars)
    return sb-sb_org;
 }
 
+/**
+ * utf8skip:
+ *
+ * Leaf function
+ **/
 const char *utf8skip(const char *str, size_t chars)
 {
    const uint8_t *strb = (const uint8_t*)str;
+
    if (!chars)
       return str;
+
    do
    {
       strb++;
-      while ((*strb & 0xC0)==0x80) strb++;
+      while ((*strb & 0xC0)==0x80)
+         strb++;
       chars--;
-   } while(chars);
+   }while (chars);
+
    return (const char*)strb;
 }
 
+/**
+ * utf8len:
+ *
+ * Leaf function.
+ **/
 size_t utf8len(const char *string)
 {
    size_t ret = 0;
@@ -211,24 +242,30 @@ size_t utf8len(const char *string)
    return ret;
 }
 
-#define utf8_walkbyte(string) (*((*(string))++))
-
-/* Does not validate the input, returns garbage if it's not UTF-8. */
+/** 
+ * utf8_walk:
+ *
+ * Does not validate the input.
+ *
+ * Leaf function.
+ *
+ * @return Returns garbage if it's not UTF-8.
+ **/
 uint32_t utf8_walk(const char **string)
 {
-   uint8_t first = utf8_walkbyte(string);
+   uint8_t first = UTF8_WALKBYTE(string);
    uint32_t ret  = 0;
 
    if (first < 128)
       return first;
 
-   ret    = (ret << 6) | (utf8_walkbyte(string) & 0x3F);
+   ret    = (ret << 6) | (UTF8_WALKBYTE(string) & 0x3F);
    if (first >= 0xE0)
    {
-      ret = (ret << 6) | (utf8_walkbyte(string) & 0x3F);
+      ret = (ret << 6) | (UTF8_WALKBYTE(string) & 0x3F);
       if (first >= 0xF0)
       {
-         ret = (ret << 6) | (utf8_walkbyte(string) & 0x3F);
+         ret = (ret << 6) | (UTF8_WALKBYTE(string) & 0x3F);
          return ret | (first & 7) << 18;
       }
       return ret | (first & 15) << 12;
@@ -241,24 +278,23 @@ static bool utf16_to_char(uint8_t **utf_data,
       size_t *dest_len, const uint16_t *in)
 {
    unsigned len    = 0;
-
    while (in[len] != '\0')
       len++;
-
    utf16_conv_utf8(NULL, dest_len, in, len);
    *dest_len  += 1;
-   *utf_data   = (uint8_t*)malloc(*dest_len);
-   if (*utf_data == 0)
-      return false;
-
-   return utf16_conv_utf8(*utf_data, dest_len, in, len);
+   if ((*utf_data = (uint8_t*)malloc(*dest_len)) != 0)
+      return utf16_conv_utf8(*utf_data, dest_len, in, len);
+   return false;
 }
 
+/**
+ * utf16_to_char_string:
+ **/
 bool utf16_to_char_string(const uint16_t *in, char *s, size_t len)
 {
-   size_t     dest_len  = 0;
-   uint8_t *utf16_data  = NULL;
-   bool            ret  = utf16_to_char(&utf16_data, &dest_len, in);
+   size_t     dest_len     = 0;
+   uint8_t *utf16_data     = NULL;
+   bool            ret     = utf16_to_char(&utf16_data, &dest_len, in);
 
    if (ret)
    {
@@ -267,19 +303,21 @@ bool utf16_to_char_string(const uint16_t *in, char *s, size_t len)
    }
 
    free(utf16_data);
-   utf16_data = NULL;
+   utf16_data              = NULL;
 
    return ret;
 }
 
 #if defined(_WIN32) && !defined(_XBOX) && !defined(UNICODE)
-/* Returned pointer MUST be freed by the caller if non-NULL. */
+/**
+ * mb_to_mb_string_alloc:
+ *
+ * @return Returned pointer MUST be freed by the caller if non-NULL.
+ **/
 static char *mb_to_mb_string_alloc(const char *str,
       enum CodePage cp_in, enum CodePage cp_out)
 {
-   char *path_buf         = NULL;
    wchar_t *path_buf_wide = NULL;
-   int path_buf_len       = 0;
    int path_buf_wide_len  = MultiByteToWideChar(cp_in, 0, str, -1, NULL, 0);
 
    /* Windows 95 will return 0 from these functions with 
@@ -292,162 +330,153 @@ static char *mb_to_mb_string_alloc(const char *str,
     *   MultiByteToWideChar also supports CP_UTF7 and CP_UTF8.
     */
 
-   if (path_buf_wide_len)
+   if (!path_buf_wide_len)
+      return strdup(str);
+
+   if ((path_buf_wide = (wchar_t*)
+      calloc(path_buf_wide_len + sizeof(wchar_t), sizeof(wchar_t))))
    {
-      path_buf_wide = (wchar_t*)
-         calloc(path_buf_wide_len + sizeof(wchar_t), sizeof(wchar_t));
+      MultiByteToWideChar(cp_in, 0,
+            str, -1, path_buf_wide, path_buf_wide_len);
 
-      if (path_buf_wide)
+      if (*path_buf_wide)
       {
-         MultiByteToWideChar(cp_in, 0,
-               str, -1, path_buf_wide, path_buf_wide_len);
+         int path_buf_len = WideCharToMultiByte(cp_out, 0,
+               path_buf_wide, -1, NULL, 0, NULL, NULL);
 
-         if (*path_buf_wide)
+         if (path_buf_len)
          {
-            path_buf_len = WideCharToMultiByte(cp_out, 0,
-                  path_buf_wide, -1, NULL, 0, NULL, NULL);
+            char *path_buf = (char*)
+               calloc(path_buf_len + sizeof(char), sizeof(char));
 
-            if (path_buf_len)
+            if (path_buf)
             {
-               path_buf = (char*)
-                  calloc(path_buf_len + sizeof(char), sizeof(char));
-
-               if (path_buf)
-               {
-                  WideCharToMultiByte(cp_out, 0,
-                        path_buf_wide, -1, path_buf,
-                        path_buf_len, NULL, NULL);
+               WideCharToMultiByte(cp_out, 0,
+                     path_buf_wide, -1, path_buf,
+                     path_buf_len, NULL, NULL);
 
-                  free(path_buf_wide);
+               free(path_buf_wide);
 
-                  if (*path_buf)
-                     return path_buf;
+               if (*path_buf)
+                  return path_buf;
 
-                  free(path_buf);
-                  return NULL;
-               }
-            }
-            else
-            {
-               free(path_buf_wide);
-               return strdup(str);
+               free(path_buf);
+               return NULL;
             }
          }
+         else
+         {
+            free(path_buf_wide);
+            return strdup(str);
+         }
       }
-   }
-   else
-      return strdup(str);
 
-   if (path_buf_wide)
       free(path_buf_wide);
+   }
 
    return NULL;
 }
 #endif
 
-/* Returned pointer MUST be freed by the caller if non-NULL. */
+/**
+ * utf8_to_local_string_alloc:
+ *
+ * @return Returned pointer MUST be freed by the caller if non-NULL.
+ **/
 char* utf8_to_local_string_alloc(const char *str)
 {
    if (str && *str)
-   {
 #if defined(_WIN32) && !defined(_XBOX) && !defined(UNICODE)
       return mb_to_mb_string_alloc(str, CODEPAGE_UTF8, CODEPAGE_LOCAL);
 #else
-      /* assume string needs no modification if not on Windows */
-      return strdup(str);
+      return strdup(str); /* Assume string needs no modification if not on Windows */
 #endif
-   }
    return NULL;
 }
 
-/* Returned pointer MUST be freed by the caller if non-NULL. */
-char* local_to_utf8_string_alloc(const char *str)
+/**
+ * local_to_utf8_string_alloc:
+ *
+ * @return Returned pointer MUST be freed by the caller if non-NULL.
+ **/
+char *local_to_utf8_string_alloc(const char *str)
 {
-   if (str && *str)
-   {
+	if (str && *str)
 #if defined(_WIN32) && !defined(_XBOX) && !defined(UNICODE)
-      return mb_to_mb_string_alloc(str, CODEPAGE_LOCAL, CODEPAGE_UTF8);
+		return mb_to_mb_string_alloc(str, CODEPAGE_LOCAL, CODEPAGE_UTF8);
 #else
-      /* assume string needs no modification if not on Windows */
-      return strdup(str);
+      return strdup(str); /* Assume string needs no modification if not on Windows */
 #endif
-   }
-   return NULL;
+	return NULL;
 }
 
-/* Returned pointer MUST be freed by the caller if non-NULL. */
+/**
+ * utf8_to_utf16_string_alloc:
+ * 
+ * @return Returned pointer MUST be freed by the caller if non-NULL.
+ **/
 wchar_t* utf8_to_utf16_string_alloc(const char *str)
 {
 #ifdef _WIN32
-   int len = 0;
-   int out_len = 0;
+   int len        = 0;
 #else
-   size_t len = 0;
-   size_t out_len = 0;
+   size_t len     = 0;
 #endif
-   wchar_t *buf = NULL;
+   wchar_t *buf   = NULL;
 
    if (!str || !*str)
       return NULL;
 
 #ifdef _WIN32
-   len = MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0);
-
-   if (len)
+   if ((len = MultiByteToWideChar(CP_UTF8, 0, str, -1, NULL, 0)))
    {
-      buf = (wchar_t*)calloc(len, sizeof(wchar_t));
-
-      if (!buf)
+      if (!(buf = (wchar_t*)calloc(len, sizeof(wchar_t))))
          return NULL;
 
-      out_len = MultiByteToWideChar(CP_UTF8, 0, str, -1, buf, len);
+      if ((MultiByteToWideChar(CP_UTF8, 0, str, -1, buf, len)) < 0)
+      {
+         free(buf);
+         return NULL;
+      }
    }
    else
    {
-      /* fallback to ANSI codepage instead */
-      len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0);
-
-      if (len)
+      /* Fallback to ANSI codepage instead */
+      if ((len = MultiByteToWideChar(CP_ACP, 0, str, -1, NULL, 0)))
       {
-         buf = (wchar_t*)calloc(len, sizeof(wchar_t));
-
-         if (!buf)
+         if (!(buf = (wchar_t*)calloc(len, sizeof(wchar_t))))
             return NULL;
 
-         out_len = MultiByteToWideChar(CP_ACP, 0, str, -1, buf, len);
+         if ((MultiByteToWideChar(CP_ACP, 0, str, -1, buf, len)) < 0)
+         {
+            free(buf);
+            return NULL;
+         }
       }
    }
-
-   if (out_len < 0)
-   {
-      free(buf);
-      return NULL;
-   }
 #else
    /* NOTE: For now, assume non-Windows platforms' locale is already UTF-8. */
-   len = mbstowcs(NULL, str, 0) + 1;
-
-   if (len)
+   if ((len = mbstowcs(NULL, str, 0) + 1))
    {
-      buf = (wchar_t*)calloc(len, sizeof(wchar_t));
-
-      if (!buf)
+      if (!(buf = (wchar_t*)calloc(len, sizeof(wchar_t))))
          return NULL;
 
-      out_len = mbstowcs(buf, str, len);
-   }
-
-   if (out_len == (size_t)-1)
-   {
-      free(buf);
-      return NULL;
+      if ((mbstowcs(buf, str, len)) == (size_t)-1)
+      {
+         free(buf);
+         return NULL;
+      }
    }
 #endif
 
    return buf;
 }
 
-/* Returned pointer MUST be freed by the caller if non-NULL. */
+/**
+ * utf16_to_utf8_string_alloc:
+ *
+ * @return Returned pointer MUST be freed by the caller if non-NULL.
+ **/
 char* utf16_to_utf8_string_alloc(const wchar_t *str)
 {
 #ifdef _WIN32
@@ -463,20 +492,17 @@ char* utf16_to_utf8_string_alloc(const wchar_t *str)
 #ifdef _WIN32
    {
       UINT code_page = CP_UTF8;
-      len            = WideCharToMultiByte(code_page,
-            0, str, -1, NULL, 0, NULL, NULL);
 
       /* fallback to ANSI codepage instead */
-      if (!len)
+      if (!(len = WideCharToMultiByte(code_page,
+            0, str, -1, NULL, 0, NULL, NULL)))
       {
          code_page   = CP_ACP;
          len         = WideCharToMultiByte(code_page,
                0, str, -1, NULL, 0, NULL, NULL);
       }
 
-      buf = (char*)calloc(len, sizeof(char));
-
-      if (!buf)
+      if (!(buf = (char*)calloc(len, sizeof(char))))
          return NULL;
 
       if (WideCharToMultiByte(code_page,
@@ -489,13 +515,9 @@ char* utf16_to_utf8_string_alloc(const wchar_t *str)
 #else
    /* NOTE: For now, assume non-Windows platforms' 
     * locale is already UTF-8. */
-   len = wcstombs(NULL, str, 0) + 1;
-
-   if (len)
+   if ((len = wcstombs(NULL, str, 0) + 1))
    {
-      buf = (char*)calloc(len, sizeof(char));
-
-      if (!buf)
+      if (!(buf = (char*)calloc(len, sizeof(char))))
          return NULL;
 
       if (wcstombs(buf, str, len) == (size_t)-1)
diff --git a/src/libretro/libretro-common/features/features_cpu.c b/src/libretro/libretro-common/features/features_cpu.c
index 78e6f82d50..80fe2c1bee 100644
--- a/src/libretro/libretro-common/features/features_cpu.c
+++ b/src/libretro/libretro-common/features/features_cpu.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (features_cpu.c).
@@ -39,12 +39,16 @@
 #include <windows.h>
 #endif
 
-#if defined(__CELLOS_LV2__) || ( defined(__OpenBSD__) && defined(__powerpc__) )
+#ifdef __PSL1GHT__
+#include <lv2/systime.h>
+#endif
+
+#if defined(_XBOX360)
+#include <PPCIntrinsics.h>
+#elif !defined(__MACH__) && (defined(__POWERPC__) || defined(__powerpc__) || defined(__ppc__) || defined(__PPC64__) || defined(__powerpc64__))
 #ifndef _PPU_INTRINSICS_H
 #include <ppu_intrinsics.h>
 #endif
-#elif defined(_XBOX360)
-#include <PPCIntrinsics.h>
 #elif defined(_POSIX_MONOTONIC_CLOCK) || defined(ANDROID) || defined(__QNX__) || defined(DJGPP)
 /* POSIX_MONOTONIC_CLOCK is not being defined in Android headers despite support being present. */
 #include <time.h>
@@ -56,7 +60,13 @@
 
 #if defined(PSP)
 #include <pspkernel.h>
+#endif
+
+#if defined(PSP) || defined(__PSL1GHT__)
 #include <sys/time.h>
+#endif
+
+#if defined(PSP)
 #include <psprtc.h>
 #endif
 
@@ -65,15 +75,15 @@
 #include <psp2/rtc.h>
 #endif
 
+#if defined(ORBIS)
+#include <orbis/libkernel.h>
+#endif
+
 #if defined(PS2)
-#include <kernel.h>
-#include <timer.h>
-#include <time.h>
+#include <ps2sdkapi.h>
 #endif
 
-#if defined(__PSL1GHT__)
-#include <sys/time.h>
-#elif defined(__CELLOS_LV2__)
+#if !defined(__PSL1GHT__) && defined(__PS3__)
 #include <sys/sys_time.h>
 #endif
 
@@ -110,11 +120,13 @@
 #define CLOCK_REALTIME 0
 #endif
 
-/* this function is part of iOS 10 now */
+/**
+ * TODO/FIXME: clock_gettime function is part of iOS 10 now
+ **/
 static int ra_clock_gettime(int clk_ik, struct timespec *t)
 {
    struct timeval now;
-   int rv = gettimeofday(&now, NULL);
+   int rv     = gettimeofday(&now, NULL);
    if (rv)
       return rv;
    t->tv_sec  = now.tv_sec;
@@ -143,7 +155,7 @@ static int ra_clock_gettime(int clk_ik, struct timespec *t)
  *
  * Gets performance counter.
  *
- * Returns: performance counter.
+ * @return Performance counter.
  **/
 retro_perf_tick_t cpu_features_get_perf_counter(void)
 {
@@ -167,8 +179,12 @@ retro_perf_tick_t cpu_features_get_perf_counter(void)
    tv_sec     = (long)((ularge.QuadPart - epoch) / 10000000L);
    tv_usec    = (long)(system_time.wMilliseconds * 1000);
    time_ticks = (1000000 * tv_sec + tv_usec);
-#elif defined(__linux__) || defined(__QNX__) || defined(__MACH__)
-   struct timespec tv = {0};
+#elif defined(GEKKO)
+   time_ticks = gettime();
+#elif !defined(__MACH__) && (defined(_XBOX360) || defined(__powerpc__) || defined(__ppc__) || defined(__POWERPC__) || defined(__PSL1GHT__) || defined(__PPC64__) || defined(__powerpc64__))
+   time_ticks = __mftb();
+#elif (defined(_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK > 0) || defined(__QNX__) || defined(ANDROID)
+   struct timespec tv;
    if (ra_clock_gettime(CLOCK_MONOTONIC, &tv) == 0)
       time_ticks = (retro_perf_tick_t)tv.tv_sec * 1000000000 +
          (retro_perf_tick_t)tv.tv_nsec;
@@ -181,26 +197,22 @@ retro_perf_tick_t cpu_features_get_perf_counter(void)
    time_ticks = (retro_perf_tick_t)a | ((retro_perf_tick_t)d << 32);
 #elif defined(__ARM_ARCH_6__)
    __asm__ volatile( "mrc p15, 0, %0, c9, c13, 0" : "=r"(time_ticks) );
-#elif defined(__CELLOS_LV2__) || defined(_XBOX360) || defined(__powerpc__) || defined(__ppc__) || defined(__POWERPC__)
-   time_ticks = __mftb();
-#elif defined(GEKKO)
-   time_ticks = gettime();
-#elif defined(PSP)
-   sceRtcGetCurrentTick((uint64_t*)&time_ticks);
-#elif defined(VITA)
+#elif defined(__aarch64__)
+   __asm__ volatile( "mrs %0, cntvct_el0" : "=r"(time_ticks) );
+#elif defined(PSP) || defined(VITA)
+   time_ticks = sceKernelGetSystemTimeWide();
+#elif defined(ORBIS)
    sceRtcGetCurrentTick((SceRtcTick*)&time_ticks);
 #elif defined(PS2)
-   time_ticks = clock()*294912; // 294,912MHZ / 1000 msecs
+   time_ticks = ps2_clock();
 #elif defined(_3DS)
    time_ticks = svcGetSystemTick();
 #elif defined(WIIU)
    time_ticks = OSGetSystemTime();
-#elif defined(__mips__)
-   struct timeval tv;
-   gettimeofday(&tv,NULL);
-   time_ticks = (1000000 * tv.tv_sec + tv.tv_usec);
 #elif defined(HAVE_LIBNX)
    time_ticks = armGetSystemTick();
+#elif defined(EMSCRIPTEN)
+   time_ticks = emscripten_get_now() * 1000;
 #endif
 
    return time_ticks;
@@ -211,7 +223,7 @@ retro_perf_tick_t cpu_features_get_perf_counter(void)
  *
  * Gets time in microseconds.
  *
- * Returns: time in microseconds.
+ * @return Time in microseconds.
  **/
 retro_time_t cpu_features_get_time_usec(void)
 {
@@ -225,8 +237,10 @@ retro_time_t cpu_features_get_time_usec(void)
 
    if (!QueryPerformanceCounter(&count))
       return 0;
-   return count.QuadPart * 1000000 / freq.QuadPart;
-#elif defined(__CELLOS_LV2__)
+   return (count.QuadPart / freq.QuadPart * 1000000) + (count.QuadPart % freq.QuadPart * 1000000 / freq.QuadPart);
+#elif defined(__PSL1GHT__)
+   return sysGetSystemTime();
+#elif !defined(__PSL1GHT__) && defined(__PS3__)
    return sys_time_get_system_time();
 #elif defined(GEKKO)
    return ticks_to_microsecs(gettime());
@@ -234,23 +248,23 @@ retro_time_t cpu_features_get_time_usec(void)
    return ticks_to_us(OSGetSystemTime());
 #elif defined(SWITCH) || defined(HAVE_LIBNX)
    return (svcGetSystemTick() * 10) / 192;
+#elif defined(_3DS)
+   return osGetTime() * 1000;
 #elif defined(_POSIX_MONOTONIC_CLOCK) || defined(__QNX__) || defined(ANDROID) || defined(__MACH__)
-   struct timespec tv = {0};
+   struct timespec tv;
    if (ra_clock_gettime(CLOCK_MONOTONIC, &tv) < 0)
       return 0;
    return tv.tv_sec * INT64_C(1000000) + (tv.tv_nsec + 500) / 1000;
 #elif defined(EMSCRIPTEN)
    return emscripten_get_now() * 1000;
 #elif defined(PS2)
-      return clock()*1000;
-#elif defined(__mips__) || defined(DJGPP)
-   struct timeval tv;
-   gettimeofday(&tv,NULL);
-   return (1000000 * tv.tv_sec + tv.tv_usec);
-#elif defined(_3DS)
-   return osGetTime() * 1000;
-#elif defined(VITA)
-   return sceKernelGetProcessTimeWide();
+   return ps2_clock() / PS2_CLOCKS_PER_MSEC * 1000;
+#elif defined(VITA) || defined(PSP)
+   return sceKernelGetSystemTimeWide();
+#elif defined(DJGPP)
+   return uclock() * 1000000LL / UCLOCKS_PER_SEC;
+#elif defined(ORBIS)
+   return sceKernelGetProcessTime();
 #else
 #error "Your platform does not have a timer function implemented in cpu_features_get_time_usec(). Cannot continue."
 #endif
@@ -289,7 +303,9 @@ void x86_cpuid(int func, int flags[4])
 #elif defined(_MSC_VER)
    __cpuid(flags, func);
 #else
+#ifndef NDEBUG
    printf("Unknown compiler. Cannot check CPUID with inline assembly.\n");
+#endif
    memset(flags, 0, 4 * sizeof(int));
 #endif
 }
@@ -311,13 +327,16 @@ static uint64_t xgetbv_x86(uint32_t idx)
    /* Intrinsic only works on 2010 SP1 and above. */
    return _xgetbv(idx);
 #else
+#ifndef NDEBUG
    printf("Unknown compiler. Cannot check xgetbv bits.\n");
+#endif
    return 0;
 #endif
 }
 #endif
 
 #if defined(__ARM_NEON__)
+#if defined(__arm__)
 static void arm_enable_runfast_mode(void)
 {
    /* RunFast mode. Enables flush-to-zero and some
@@ -335,6 +354,7 @@ static void arm_enable_runfast_mode(void)
         );
 }
 #endif
+#endif
 
 #if defined(__linux__) && !defined(CPU_X86)
 static unsigned char check_arm_cpu_feature(const char* feature)
@@ -348,12 +368,12 @@ static unsigned char check_arm_cpu_feature(const char* feature)
    if (!fp)
       return 0;
 
-   while (filestream_gets(fp, line, sizeof(line)) != NULL)
+   while (filestream_gets(fp, line, sizeof(line)))
    {
       if (strncmp(line, "Features\t: ", 11))
          continue;
 
-      if (strstr(line + 11, feature) != NULL)
+      if (strstr(line + 11, feature))
          status = 1;
 
       break;
@@ -365,7 +385,10 @@ static unsigned char check_arm_cpu_feature(const char* feature)
 }
 
 #if !defined(_SC_NPROCESSORS_ONLN)
-/* Parse an decimal integer starting from 'input', but not going further
+/**
+ * parse_decimal:
+ *
+ * Parse an decimal integer starting from 'input', but not going further
  * than 'limit'. Return the value into '*result'.
  *
  * NOTE: Does not skip over leading spaces, or deal with sign characters.
@@ -374,7 +397,9 @@ static unsigned char check_arm_cpu_feature(const char* feature)
  * The function returns NULL in case of error (bad format), or the new
  * position after the decimal number in case of success (which will always
  * be <= 'limit').
- */
+ *
+ * Leaf function.
+ **/
 static const char *parse_decimal(const char* input,
       const char* limit, int* result)
 {
@@ -396,7 +421,9 @@ static const char *parse_decimal(const char* input,
     return p;
 }
 
-/* Parse a textual list of cpus and store the result inside a CpuList object.
+/**
+ * cpulist_parse:
+ * Parse a textual list of cpus and store the result inside a CpuList object.
  * Input format is the following:
  * - comma-separated list of items (no spaces)
  * - each item is either a single decimal number (cpu index), or a range made
@@ -405,7 +432,7 @@ static const char *parse_decimal(const char* input,
  * Examples:   0
  *             2,4-127,128-143
  *             0-1
- */
+ **/
 static void cpulist_parse(CpuList* list, char **buf, ssize_t length)
 {
    const char* p   = (const char*)buf;
@@ -424,8 +451,7 @@ static void cpulist_parse(CpuList* list, char **buf, ssize_t length)
          q = end;
 
       /* Get first value */
-      p = parse_decimal(p, q, &start_value);
-      if (p == NULL)
+      if (!(p = parse_decimal(p, q, &start_value)))
          return;
 
       end_value = start_value;
@@ -435,8 +461,7 @@ static void cpulist_parse(CpuList* list, char **buf, ssize_t length)
        */
       if (p < q && *p == '-')
       {
-         p = parse_decimal(p+1, q, &end_value);
-         if (p == NULL)
+         if (!(p = parse_decimal(p+1, q, &end_value)))
             return;
       }
 
@@ -444,7 +469,7 @@ static void cpulist_parse(CpuList* list, char **buf, ssize_t length)
       for (val = start_value; val <= end_value; val++)
       {
          if ((unsigned)val < 32)
-            list->mask |= (uint32_t)(1U << val);
+            list->mask |= (uint32_t)(UINT32_C(1) << val);
       }
 
       /* Jump to next item */
@@ -454,7 +479,11 @@ static void cpulist_parse(CpuList* list, char **buf, ssize_t length)
    }
 }
 
-/* Read a CPU list from one sysfs file */
+/**
+ * cpulist_read_from:
+ *
+ * Read a CPU list from one sysfs file
+ **/
 static void cpulist_read_from(CpuList* list, const char* filename)
 {
    ssize_t length;
@@ -479,7 +508,7 @@ static void cpulist_read_from(CpuList* list, const char* filename)
  *
  * Gets the amount of available CPU cores.
  *
- * Returns: amount of CPU cores available.
+ * @return Amount of CPU cores available.
  **/
 unsigned cpu_features_get_core_amount(void)
 {
@@ -496,6 +525,8 @@ unsigned cpu_features_get_core_amount(void)
    return 1;
 #elif defined(PSP) || defined(PS2)
    return 1;
+#elif defined(__PSL1GHT__) || !defined(__PSL1GHT__) && defined(__PS3__)
+   return 1; /* Only one PPU, SPUs don't really count */
 #elif defined(VITA)
    return 4;
 #elif defined(HAVE_LIBNX) || defined(SWITCH)
@@ -583,7 +614,7 @@ unsigned cpu_features_get_core_amount(void)
  *
  * Gets CPU features..
  *
- * Returns: bitmask of all CPU features available.
+ * @return Bitmask of all CPU features available.
  **/
 uint64_t cpu_features_get(void)
 {
@@ -594,17 +625,14 @@ uint64_t cpu_features_get(void)
 #endif
 #if defined(__MACH__)
    size_t len          = sizeof(size_t);
-   if (sysctlbyname("hw.optional.mmx", NULL, &len, NULL, 0) == 0)
-   {
-      cpu |= RETRO_SIMD_MMX;
-      cpu |= RETRO_SIMD_MMXEXT;
-   }
 
-   len            = sizeof(size_t);
    if (sysctlbyname("hw.optional.floatingpoint", NULL, &len, NULL, 0) == 0)
-   {
       cpu |= RETRO_SIMD_CMOV;
-   }
+
+#if defined(CPU_X86)
+   len            = sizeof(size_t);
+   if (sysctlbyname("hw.optional.mmx", NULL, &len, NULL, 0) == 0)
+      cpu |= RETRO_SIMD_MMX | RETRO_SIMD_MMXEXT;
 
    len            = sizeof(size_t);
    if (sysctlbyname("hw.optional.sse", NULL, &len, NULL, 0) == 0)
@@ -646,20 +674,26 @@ uint64_t cpu_features_get(void)
    if (sysctlbyname("hw.optional.altivec", NULL, &len, NULL, 0) == 0)
       cpu |= RETRO_SIMD_VMX;
 
+#else
    len            = sizeof(size_t);
    if (sysctlbyname("hw.optional.neon", NULL, &len, NULL, 0) == 0)
       cpu |= RETRO_SIMD_NEON;
 
+   len            = sizeof(size_t);
+   if (sysctlbyname("hw.optional.neon_fp16", NULL, &len, NULL, 0) == 0)
+      cpu |= RETRO_SIMD_VFPV3;
+
+   len            = sizeof(size_t);
+   if (sysctlbyname("hw.optional.neon_hpfp", NULL, &len, NULL, 0) == 0)
+      cpu |= RETRO_SIMD_VFPV4;
+#endif
 #elif defined(_XBOX1)
-   cpu |= RETRO_SIMD_MMX;
-   cpu |= RETRO_SIMD_SSE;
-   cpu |= RETRO_SIMD_MMXEXT;
+   cpu |= RETRO_SIMD_MMX | RETRO_SIMD_SSE | RETRO_SIMD_MMXEXT;
 #elif defined(CPU_X86)
    unsigned max_flag   = 0;
    int flags[4];
    int vendor_shuffle[3];
    char vendor[13];
-   uint64_t cpu_flags  = 0;
    x86_cpuid(0, flags);
    vendor_shuffle[0] = flags[1];
    vendor_shuffle[1] = flags[3];
@@ -687,12 +721,9 @@ uint64_t cpu_features_get(void)
    if (flags[3] & (1 << 23))
       cpu |= RETRO_SIMD_MMX;
 
+   /* SSE also implies MMXEXT (according to FFmpeg source). */
    if (flags[3] & (1 << 25))
-   {
-      /* SSE also implies MMXEXT (according to FFmpeg source). */
-      cpu |= RETRO_SIMD_SSE;
-      cpu |= RETRO_SIMD_MMXEXT;
-   }
+      cpu |= RETRO_SIMD_SSE | RETRO_SIMD_MMXEXT;
 
    if (flags[3] & (1 << 26))
       cpu |= RETRO_SIMD_SSE2;
@@ -745,7 +776,7 @@ uint64_t cpu_features_get(void)
    if (check_arm_cpu_feature("neon"))
    {
       cpu |= RETRO_SIMD_NEON;
-#ifdef __ARM_NEON__
+#if defined(__ARM_NEON__) && defined(__arm__)
       arm_enable_runfast_mode();
 #endif
    }
@@ -761,7 +792,9 @@ uint64_t cpu_features_get(void)
       cpu |= RETRO_SIMD_ASIMD;
 #ifdef __ARM_NEON__
       cpu |= RETRO_SIMD_NEON;
+#if defined(__arm__)
       arm_enable_runfast_mode();
+#endif
 #endif
    }
 
@@ -780,7 +813,9 @@ uint64_t cpu_features_get(void)
 
 #elif defined(__ARM_NEON__)
    cpu |= RETRO_SIMD_NEON;
+#if defined(__arm__)
    arm_enable_runfast_mode();
+#endif
 #elif defined(__ALTIVEC__)
    cpu |= RETRO_SIMD_VMX;
 #elif defined(XBOX360)
@@ -798,11 +833,12 @@ void cpu_features_get_model_name(char *name, int len)
 {
 #if defined(CPU_X86) && !defined(__MACH__)
    union {
-      int i[4];
-      unsigned char s[16];
+      int32_t i[4];
+      uint32_t u[4];
+      uint8_t s[16];
    } flags;
    int i, j;
-   size_t pos = 0;
+   int pos = 0;
    bool start = false;
 
    if (!name)
@@ -810,7 +846,8 @@ void cpu_features_get_model_name(char *name, int len)
 
    x86_cpuid(0x80000000, flags.i);
 
-   if (flags.i[0] < 0x80000004)
+   /* Check for additional cpuid attributes availability */
+   if (flags.u[0] < 0x80000004)
       return;
 
    for (i = 0; i < 3; i++)
@@ -818,7 +855,7 @@ void cpu_features_get_model_name(char *name, int len)
       memset(flags.i, 0, sizeof(flags.i));
       x86_cpuid(0x80000002 + i, flags.i);
 
-      for (j = 0; j < sizeof(flags.s); j++)
+      for (j = 0; j < (int)sizeof(flags.s); j++)
       {
          if (!start && flags.s[j] == ' ')
             continue;
@@ -837,7 +874,7 @@ void cpu_features_get_model_name(char *name, int len)
    }
 end:
    /* terminate our string */
-   if (pos < (size_t)len)
+   if (pos < len)
       name[pos] = '\0';
 #elif defined(__MACH__)
    if (!name)
@@ -846,6 +883,35 @@ void cpu_features_get_model_name(char *name, int len)
       size_t len_size = len;
       sysctlbyname("machdep.cpu.brand_string", name, &len_size, NULL, 0);
    }
+#elif defined(__linux__)
+   if (!name)
+      return;
+   {
+      char *model_name, line[128];
+      RFILE *fp = filestream_open("/proc/cpuinfo",
+            RETRO_VFS_FILE_ACCESS_READ,
+            RETRO_VFS_FILE_ACCESS_HINT_NONE);
+
+      if (!fp)
+         return;
+
+      while (filestream_gets(fp, line, sizeof(line)))
+      {
+         if (strncmp(line, "model name", 10))
+            continue;
+
+         if ((model_name = strstr(line + 10, ": ")))
+         {
+            model_name += 2;
+            strncpy(name, model_name, len);
+            name[len - 1] = '\0';
+         }
+
+         break;
+      }
+
+      filestream_close(fp);
+   }
 #else
    if (!name)
       return;
diff --git a/src/libretro/libretro-common/file/archive_file.c b/src/libretro/libretro-common/file/archive_file.c
index 2450508a99..40ece85ab5 100644
--- a/src/libretro/libretro-common/file/archive_file.c
+++ b/src/libretro/libretro-common/file/archive_file.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (archive_file.c).
@@ -24,19 +24,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#ifdef HAVE_MMAP
-#include <fcntl.h>
-#include <errno.h>
-#include <unistd.h>
-
-#include <sys/mman.h>
-#include <sys/stat.h>
-#endif
-
 #include <compat/strl.h>
 #include <file/archive_file.h>
 #include <file/file_path.h>
@@ -45,110 +32,12 @@
 #include <lists/string_list.h>
 #include <string/stdstring.h>
 
-struct file_archive_file_data
-{
-#ifdef HAVE_MMAP
-   int fd;
-#endif
-   void *data;
-   size_t size;
-};
-
-static size_t file_archive_size(file_archive_file_data_t *data)
-{
-   if (!data)
-      return 0;
-   return data->size;
-}
-
-static const uint8_t *file_archive_data(file_archive_file_data_t *data)
-{
-   if (!data)
-      return NULL;
-   return (const uint8_t*)data->data;
-}
-
 #ifdef HAVE_MMAP
-/* Closes, unmaps and frees. */
-static void file_archive_free(file_archive_file_data_t *data)
-{
-   if (!data)
-      return;
-
-   if (data->data)
-      munmap(data->data, data->size);
-   if (data->fd >= 0)
-      close(data->fd);
-   free(data);
-}
-
-static file_archive_file_data_t* file_archive_open(const char *path)
-{
-   file_archive_file_data_t *data = (file_archive_file_data_t*)calloc(1, sizeof(*data));
-
-   if (!data)
-      return NULL;
-
-   data->fd = open(path, O_RDONLY);
-
-   /* Failed to open archive. */
-   if (data->fd < 0)
-      goto error;
-
-   data->size = path_get_size(path);
-   if (!data->size)
-      return data;
-
-   data->data = mmap(NULL, data->size, PROT_READ, MAP_SHARED, data->fd, 0);
-   if (data->data == MAP_FAILED)
-   {
-      data->data = NULL;
-
-      /* Failed to mmap() file */
-      goto error;
-   }
-
-   return data;
-
-error:
-   file_archive_free(data);
-   return NULL;
-}
-#else
-
-/* Closes, unmaps and frees. */
-static void file_archive_free(file_archive_file_data_t *data)
-{
-   if (!data)
-      return;
-   if(data->data)
-      free(data->data);
-   free(data);
-}
-
-static file_archive_file_data_t* file_archive_open(const char *path)
-{
-   int64_t ret            = -1;
-   bool read_from_file    = false;
-   file_archive_file_data_t *data = (file_archive_file_data_t*)
-      calloc(1, sizeof(*data));
-
-   if (!data)
-      return NULL;
-
-   read_from_file = filestream_read_file(path, &data->data, &ret);
-
-   /* Failed to open archive? */
-   if (!read_from_file || ret < 0)
-      goto error;
-
-   data->size = ret;
-   return data;
-
-error:
-   file_archive_free(data);
-   return NULL;
-}
+#include <fcntl.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
 #endif
 
 static int file_archive_get_file_list_cb(
@@ -169,37 +58,34 @@ static int file_archive_get_file_list_cb(
       size_t path_len              = strlen(path);
       /* Checks if this entry is a directory or a file. */
       char last_char               = path[path_len - 1];
-      struct string_list *ext_list = NULL;
+      struct string_list ext_list  = {0};
 
       /* Skip if directory. */
       if (last_char == '/' || last_char == '\\' )
-      {
-         string_list_free(ext_list);
-         return 0;
-      }
+         return 1;
       
-      ext_list                = string_split(valid_exts, "|");
-
-      if (ext_list)
+      string_list_initialize(&ext_list);
+      if (string_split_noalloc(&ext_list, valid_exts, "|"))
       {
          const char *file_ext = path_get_extension(path);
 
          if (!file_ext)
          {
-            string_list_free(ext_list);
-            return 0;
+            string_list_deinitialize(&ext_list);
+            return 1;
          }
 
-         if (!string_list_find_elem_prefix(ext_list, ".", file_ext))
+         if (!string_list_find_elem_prefix(&ext_list, ".", file_ext))
          {
             /* keep iterating */
-            string_list_free(ext_list);
+            string_list_deinitialize(&ext_list);
             return -1;
          }
 
          attr.i = RARCH_COMPRESSED_FILE_IN_ARCHIVE;
-         string_list_free(ext_list);
       }
+
+      string_list_deinitialize(&ext_list);
    }
 
    return string_list_append(userdata->list, path, attr);
@@ -216,37 +102,29 @@ static int file_archive_extract_cb(const char *name, const char *valid_exts,
    if (ext && string_list_find_elem(userdata->ext, ext))
    {
       char new_path[PATH_MAX_LENGTH];
-      char wanted_file[PATH_MAX_LENGTH];
-      const char *delim                 = NULL;
+      const char *delim;
 
-      new_path[0] = wanted_file[0]      = '\0';
+      if ((delim = path_get_archive_delim(userdata->archive_path)))
+      {
+         if (!string_is_equal_noncase(
+                  userdata->current_file_path, delim + 1))
+           return 1; /* keep searching for the right file */
+      }
 
       if (userdata->extraction_directory)
-         fill_pathname_join(new_path, userdata->extraction_directory,
+         fill_pathname_join_special(new_path, userdata->extraction_directory,
                path_basename(name), sizeof(new_path));
       else
          fill_pathname_resolve_relative(new_path, userdata->archive_path,
                path_basename(name), sizeof(new_path));
 
-      userdata->first_extracted_file_path = strdup(new_path);
-
-      delim = path_get_archive_delim(userdata->archive_path);
-
-      if (delim)
-      {
-         strlcpy(wanted_file, delim + 1, sizeof(wanted_file));
-
-         if (!string_is_equal_noncase(userdata->extracted_file_path,
-                   wanted_file))
-           return 1; /* keep searching for the right file */
-      }
-      else
-         strlcpy(wanted_file, userdata->archive_path, sizeof(wanted_file));
-
       if (file_archive_perform_mode(new_path,
                 valid_exts, cdata, cmode, csize, size,
-                0, userdata))
+                checksum, userdata))
+      {
          userdata->found_file = true;
+         userdata->first_extracted_file_path = strdup(new_path);
+      }
 
       return 0;
    }
@@ -260,107 +138,50 @@ static int file_archive_parse_file_init(file_archive_transfer_t *state,
    char path[PATH_MAX_LENGTH];
    char *last                 = NULL;
 
-   path[0] = '\0';
-
    strlcpy(path, file, sizeof(path));
 
-   last = (char*)path_get_archive_delim(path);
-
-   if (last)
-      *last = '\0';
+   if ((last = (char*)path_get_archive_delim(path)))
+      *last  = '\0';
 
-   state->backend = file_archive_get_file_backend(path);
-   if (!state->backend)
+   if (!(state->backend = file_archive_get_file_backend(path)))
       return -1;
 
-   state->handle = file_archive_open(path);
-   if (!state->handle)
+   /* Failed to open archive. */
+   if (!(state->archive_file = filestream_open(path,
+         RETRO_VFS_FILE_ACCESS_READ,
+         RETRO_VFS_FILE_ACCESS_HINT_NONE)))
       return -1;
 
-   state->archive_size = (int32_t)file_archive_size(state->handle);
-   state->data         = file_archive_data(state->handle);
-   state->footer       = 0;
-   state->directory    = 0;
-
-   return state->backend->archive_parse_file_init(state, path);
-}
-
-/**
- * file_archive_decompress_data_to_file:
- * @path                        : filename path of archive.
- * @valid_exts                  : Valid extensions of archive to be parsed.
- *                                If NULL, allow all.
- * @cdata                       : input data.
- * @csize                       : size of input data.
- * @size                        : output file size
- * @checksum                    : CRC32 checksum from input data.
- *
- * Decompress data to file.
- *
- * Returns: true (1) on success, otherwise false (0).
- **/
-static int file_archive_decompress_data_to_file(
-      file_archive_file_handle_t *handle,
-      int ret,
-      const char *path,
-      const char *valid_exts,
-      const uint8_t *cdata,
-      uint32_t csize,
-      uint32_t size,
-      uint32_t checksum)
-{
-   if (!handle || ret == -1)
-   {
-      ret = 0;
-      goto end;
-   }
-
-#if 0
-   handle->real_checksum = handle->backend->stream_crc_calculate(
-         0, handle->data, size);
-   if (handle->real_checksum != checksum)
-   {
-      /* File CRC difers from archive CRC. */
-      printf("File CRC differs from archive CRC. File: 0x%x, Archive: 0x%x.\n",
-            (unsigned)handle->real_checksum, (unsigned)checksum);
-   }
-#endif
-
-   if (!filestream_write_file(path, handle->data, size))
-   {
-      ret = false;
-      goto end;
-   }
-
-end:
+   state->archive_size = filestream_get_size(state->archive_file);
 
-   if (handle)
+#ifdef HAVE_MMAP
+   if (state->archive_size <= (256*1024*1024))
    {
-      if (handle->backend)
+      state->archive_mmap_fd = open(path, O_RDONLY);
+      if (state->archive_mmap_fd)
       {
-         if (handle->backend->stream_free)
-         {
-#ifdef HAVE_7ZIP
-            if (handle->backend != &sevenzip_backend)
-            {
-               handle->backend->stream_free(handle->stream);
+         state->archive_mmap_data = (uint8_t*)mmap(NULL, (size_t)state->archive_size,
+               PROT_READ, MAP_SHARED, state->archive_mmap_fd, 0);
 
-               if (handle->data)
-                  free(handle->data);
-            }
-#else
-            handle->backend->stream_free(handle->stream);
-#endif
+         if (state->archive_mmap_data == (uint8_t*)MAP_FAILED)
+         {
+            close(state->archive_mmap_fd);
+            state->archive_mmap_fd = 0;
+            state->archive_mmap_data = NULL;
          }
       }
    }
+#endif
 
-   return ret;
+   state->step_current = 0;
+   state->step_total   = 0;
+
+   return state->backend->archive_parse_file_init(state, path);
 }
 
 void file_archive_parse_file_iterate_stop(file_archive_transfer_t *state)
 {
-   if (!state || !state->handle)
+   if (!state || !state->archive_file)
       return;
 
    state->type = ARCHIVE_TRANSFER_DEINIT;
@@ -387,7 +208,7 @@ int file_archive_parse_file_iterate(
          {
             if (userdata)
             {
-               userdata->context = state->stream;
+               userdata->transfer = state;
                strlcpy(userdata->archive_path, file,
                      sizeof(userdata->archive_path));
             }
@@ -397,14 +218,13 @@ int file_archive_parse_file_iterate(
             state->type = ARCHIVE_TRANSFER_DEINIT_ERROR;
          break;
       case ARCHIVE_TRANSFER_ITERATE:
-         if (file_archive_get_file_backend(file))
+         if (state->backend)
          {
-            const struct file_archive_file_backend *backend =
-               file_archive_get_file_backend(file);
-            int ret                                         =
-               backend->archive_parse_file_iterate_step(state,
-                  valid_exts, userdata, file_cb);
+            int ret = state->backend->archive_parse_file_iterate_step(
+                  state->context, valid_exts, userdata, file_cb);
 
+            if (ret == 1)
+               state->step_current++; /* found another file */
             if (ret != 1)
                state->type = ARCHIVE_TRANSFER_DEINIT;
             if (ret == -1)
@@ -417,25 +237,31 @@ int file_archive_parse_file_iterate(
       case ARCHIVE_TRANSFER_DEINIT_ERROR:
          *returnerr = false;
       case ARCHIVE_TRANSFER_DEINIT:
-         if (state->handle)
+         if (state->context)
          {
-            file_archive_free(state->handle);
-            state->handle = NULL;
+            if (state->backend->archive_parse_file_free)
+               state->backend->archive_parse_file_free(state->context);
+            state->context = NULL;
          }
 
-         if (state->stream && state->backend)
+         if (state->archive_file)
          {
-            if (state->backend->stream_free)
-               state->backend->stream_free(state->stream);
-
-            if (state->stream)
-               free(state->stream);
-
-            state->stream = NULL;
+            filestream_close(state->archive_file);
+            state->archive_file = NULL;
+         }
 
-            if (userdata)
-               userdata->context = NULL;
+#ifdef HAVE_MMAP
+         if (state->archive_mmap_data)
+         {
+            munmap(state->archive_mmap_data, (size_t)state->archive_size);
+            close(state->archive_mmap_fd);
+            state->archive_mmap_fd = 0;
+            state->archive_mmap_data = NULL;
          }
+#endif
+
+         if (userdata)
+            userdata->transfer = NULL;
          break;
    }
 
@@ -463,16 +289,19 @@ static bool file_archive_walk(const char *file, const char *valid_exts,
       file_archive_file_cb file_cb, struct archive_extract_userdata *userdata)
 {
    file_archive_transfer_t state;
-   bool returnerr                = true;
+   bool returnerr          = true;
 
-   state.type                    = ARCHIVE_TRANSFER_INIT;
-   state.archive_size            = 0;
-   state.handle                  = NULL;
-   state.stream                  = NULL;
-   state.footer                  = NULL;
-   state.directory               = NULL;
-   state.data                    = NULL;
-   state.backend                 = NULL;
+   state.type              = ARCHIVE_TRANSFER_INIT;
+   state.archive_file      = NULL;
+#ifdef HAVE_MMAP
+   state.archive_mmap_fd   = 0;
+   state.archive_mmap_data = NULL;
+#endif
+   state.archive_size      = 0;
+   state.context           = NULL;
+   state.step_total        = 0;
+   state.step_current      = 0;
+   state.backend           = NULL;
 
    for (;;)
    {
@@ -486,23 +315,15 @@ static bool file_archive_walk(const char *file, const char *valid_exts,
 
 int file_archive_parse_file_progress(file_archive_transfer_t *state)
 {
-   ptrdiff_t delta = 0;
-
-   if (!state || state->archive_size == 0)
+   if (!state || state->step_total == 0)
       return 0;
 
-   delta = state->directory - state->data;
-
-   if (!state->start_delta)
-      state->start_delta = delta;
-
-   return (int)(((delta - state->start_delta) * 100) / (state->archive_size - state->start_delta));
+   return (int)((state->step_current * 100) / (state->step_total));
 }
 
 /**
  * file_archive_extract_file:
- * @archive_path                    : filename path to archive.
- * @archive_path_size               : size of archive.
+ * @archive_path                : filename path to archive.
  * @valid_exts                  : valid extensions for the file.
  * @extraction_directory        : the directory to extract temporary
  *                                file to.
@@ -513,8 +334,7 @@ int file_archive_parse_file_progress(file_archive_transfer_t *state)
  * Returns : true (1) on success, otherwise false (0).
  **/
 bool file_archive_extract_file(
-      char *archive_path,
-      size_t archive_path_size,
+      const char *archive_path,
       const char *valid_exts,
       const char *extraction_directory,
       char *out_path, size_t len)
@@ -524,24 +344,17 @@ bool file_archive_extract_file(
    struct string_list *list                 = string_split(valid_exts, "|");
 
    userdata.archive_path[0]                 = '\0';
+   userdata.current_file_path[0]            = '\0';
    userdata.first_extracted_file_path       = NULL;
-   userdata.extracted_file_path             = NULL;
    userdata.extraction_directory            = extraction_directory;
-   userdata.archive_path_size               = archive_path_size;
    userdata.ext                             = list;
    userdata.list                            = NULL;
    userdata.found_file                      = false;
    userdata.list_only                       = false;
-   userdata.context                         = NULL;
-   userdata.archive_name[0]                 = '\0';
    userdata.crc                             = 0;
+   userdata.transfer                        = NULL;
    userdata.dec                             = NULL;
 
-   userdata.decomp_state.opt_file           = NULL;
-   userdata.decomp_state.needle             = NULL;
-   userdata.decomp_state.size               = 0;
-   userdata.decomp_state.found              = false;
-
    if (!list)
    {
       ret = false;
@@ -575,6 +388,36 @@ bool file_archive_extract_file(
    return ret;
 }
 
+/* Warning: 'list' must zero initialised before
+ * calling this function, otherwise memory leaks/
+ * undefined behaviour will occur */
+bool file_archive_get_file_list_noalloc(struct string_list *list,
+      const char *path,
+      const char *valid_exts)
+{
+   struct archive_extract_userdata userdata;
+
+   if (!list || !string_list_initialize(list))
+      return false;
+
+   strlcpy(userdata.archive_path, path, sizeof(userdata.archive_path));
+   userdata.current_file_path[0]            = '\0';
+   userdata.first_extracted_file_path       = NULL;
+   userdata.extraction_directory            = NULL;
+   userdata.ext                             = NULL;
+   userdata.list                            = list;
+   userdata.found_file                      = false;
+   userdata.list_only                       = true;
+   userdata.crc                             = 0;
+   userdata.transfer                        = NULL;
+   userdata.dec                             = NULL;
+
+   if (!file_archive_walk(path, valid_exts,
+            file_archive_get_file_list_cb, &userdata))
+      return false;
+   return true;
+}
+
 /**
  * file_archive_get_file_list:
  * @path                        : filename path of archive
@@ -587,82 +430,53 @@ struct string_list *file_archive_get_file_list(const char *path,
    struct archive_extract_userdata userdata;
 
    strlcpy(userdata.archive_path, path, sizeof(userdata.archive_path));
+   userdata.current_file_path[0]            = '\0';
    userdata.first_extracted_file_path       = NULL;
-   userdata.extracted_file_path             = NULL;
    userdata.extraction_directory            = NULL;
-   userdata.archive_path_size               = 0;
    userdata.ext                             = NULL;
    userdata.list                            = string_list_new();
    userdata.found_file                      = false;
    userdata.list_only                       = true;
-   userdata.context                         = NULL;
-   userdata.archive_name[0]                 = '\0';
    userdata.crc                             = 0;
+   userdata.transfer                        = NULL;
    userdata.dec                             = NULL;
 
-   userdata.decomp_state.opt_file           = NULL;
-   userdata.decomp_state.needle             = NULL;
-   userdata.decomp_state.size               = 0;
-   userdata.decomp_state.found              = false;
-
    if (!userdata.list)
-      goto error;
-
+      return NULL;
    if (!file_archive_walk(path, valid_exts,
          file_archive_get_file_list_cb, &userdata))
-      goto error;
-
-   return userdata.list;
-
-error:
-   if (userdata.list)
+   {
       string_list_free(userdata.list);
-   return NULL;
+      return NULL;
+   }
+   return userdata.list;
 }
 
 bool file_archive_perform_mode(const char *path, const char *valid_exts,
       const uint8_t *cdata, unsigned cmode, uint32_t csize, uint32_t size,
       uint32_t crc32, struct archive_extract_userdata *userdata)
 {
-   switch (cmode)
-   {
-      case ARCHIVE_MODE_UNCOMPRESSED:
-         if (!filestream_write_file(path, cdata, size))
-            return false;
-         break;
+   file_archive_file_handle_t handle;
+   int ret;
 
-      case ARCHIVE_MODE_COMPRESSED:
-         {
-            int ret = 0;
-            file_archive_file_handle_t handle;
+   if (!userdata->transfer || !userdata->transfer->backend)
+      return false;
 
-            handle.stream        = userdata->context;
-            handle.data          = NULL;
-            handle.real_checksum = 0;
-            handle.backend       = file_archive_get_file_backend(userdata->archive_path);
+   handle.data          = NULL;
+   handle.real_checksum = 0;
 
-            if (!handle.backend)
-               return false;
+   if (!userdata->transfer->backend->stream_decompress_data_to_file_init(
+            userdata->transfer->context, &handle, cdata, cmode, csize, size))
+      return false;
 
-            if (!handle.backend->stream_decompress_data_to_file_init(&handle,
-                     cdata, csize, size))
-               return false;
+   do
+   {
+      ret = userdata->transfer->backend->stream_decompress_data_to_file_iterate(
+               userdata->transfer->context, &handle);
+   }while (ret == 0);
 
-            do
-            {
-               ret = handle.backend->stream_decompress_data_to_file_iterate(
-                     handle.stream);
-            }while(ret == 0);
-
-            if (!file_archive_decompress_data_to_file(&handle,
-                     ret, path, valid_exts,
-                     cdata, csize, size, crc32))
-               return false;
-         }
-         break;
-      default:
-         return false;
-   }
+   if (ret == -1 || !filestream_write_file(path, handle.data, size))
+      return false;
 
    return true;
 }
@@ -785,16 +599,12 @@ const struct file_archive_file_backend* file_archive_get_file_backend(const char
    const char *file_ext          = NULL;
    char *last                    = NULL;
 
-   newpath[0] = '\0';
-
    strlcpy(newpath, path, sizeof(newpath));
 
-   last = (char*)path_get_archive_delim(newpath);
+   if ((last = (char*)path_get_archive_delim(newpath)))
+      *last  = '\0';
 
-   if (last)
-      *last = '\0';
-
-   file_ext = path_get_extension(newpath);
+   file_ext  = path_get_extension(newpath);
 
 #ifdef HAVE_7ZIP
    if (string_is_equal_noncase(file_ext, "7z"))
@@ -823,7 +633,7 @@ const struct file_archive_file_backend* file_archive_get_file_backend(const char
 uint32_t file_archive_get_file_crc32(const char *path)
 {
    file_archive_transfer_t state;
-   struct archive_extract_userdata userdata        = {{0}};
+   struct archive_extract_userdata userdata        = {0};
    bool returnerr                                  = false;
    const char *archive_path                        = NULL;
    bool contains_compressed = path_contains_compressed_file(path);
@@ -837,14 +647,17 @@ uint32_t file_archive_get_file_crc32(const char *path)
          archive_path += 1;
    }
 
-   state.type          = ARCHIVE_TRANSFER_INIT;
-   state.archive_size  = 0;
-   state.handle        = NULL;
-   state.stream        = NULL;
-   state.footer        = NULL;
-   state.directory     = NULL;
-   state.data          = NULL;
-   state.backend       = NULL;
+   state.type              = ARCHIVE_TRANSFER_INIT;
+   state.archive_file      = NULL;
+#ifdef HAVE_MMAP
+   state.archive_mmap_fd   = 0;
+   state.archive_mmap_data = NULL;
+#endif
+   state.archive_size      = 0;
+   state.context           = NULL;
+   state.step_total        = 0;
+   state.step_current      = 0;
+   state.backend           = NULL;
 
    /* Initialize and open archive first.
       Sets next state type to ITERATE. */
@@ -869,7 +682,7 @@ uint32_t file_archive_get_file_crc32(const char *path)
       /* Stop when the right file in the archive is found. */
       if (archive_path)
       {
-         if (string_is_equal(userdata.extracted_file_path, archive_path))
+         if (string_is_equal(userdata.current_file_path, archive_path))
             break;
       }
       else
@@ -878,8 +691,5 @@ uint32_t file_archive_get_file_crc32(const char *path)
 
    file_archive_parse_file_iterate_stop(&state);
 
-   if (userdata.crc)
-      return userdata.crc;
-
-   return 0;
+   return userdata.crc;
 }
diff --git a/src/libretro/libretro-common/file/archive_file_7z.c b/src/libretro/libretro-common/file/archive_file_7z.c
index 86e03b7d11..c0aa7ad0ff 100644
--- a/src/libretro/libretro-common/file/archive_file_7z.c
+++ b/src/libretro/libretro-common/file/archive_file_7z.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (archive_file_sevenzip.c).
@@ -38,6 +38,7 @@
 
 #define SEVENZIP_MAGIC "7z\xBC\xAF\x27\x1C"
 #define SEVENZIP_MAGIC_LEN 6
+#define SEVENZIP_LOOKTOREAD_BUF_SIZE (1 << 14)
 
 /* Assume W-functions do not work below Win2K and Xbox platforms */
 #if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0500 || defined(_XBOX)
@@ -46,28 +47,29 @@
 #endif
 #endif
 
-struct sevenzip_context_t {
+struct sevenzip_context_t
+{
+   uint8_t *output;
    CFileInStream archiveStream;
-   CLookToRead lookStream;
+   CLookToRead2 lookStream;
    ISzAlloc allocImp;
    ISzAlloc allocTempImp;
    CSzArEx db;
    size_t temp_size;
-   uint32_t block_index;
-   uint32_t index;
+   uint32_t parse_index;
+   uint32_t decompress_index;
    uint32_t packIndex;
-   uint8_t *output;
-   file_archive_file_handle_t *handle;
+   uint32_t   block_index;
 };
 
-static void *sevenzip_stream_alloc_impl(void *p, size_t size)
+static void *sevenzip_stream_alloc_impl(ISzAllocPtr p, size_t size)
 {
    if (size == 0)
       return 0;
    return malloc(size);
 }
 
-static void sevenzip_stream_free_impl(void *p, void *address)
+static void sevenzip_stream_free_impl(ISzAllocPtr p, void *address)
 {
    (void)p;
 
@@ -75,7 +77,7 @@ static void sevenzip_stream_free_impl(void *p, void *address)
       free(address);
 }
 
-static void *sevenzip_stream_alloc_tmp_impl(void *p, size_t size)
+static void *sevenzip_stream_alloc_tmp_impl(ISzAllocPtr p, size_t size)
 {
    (void)p;
    if (size == 0)
@@ -96,14 +98,19 @@ static void* sevenzip_stream_new(void)
    sevenzip_context->allocTempImp.Free  = sevenzip_stream_free_impl;
    sevenzip_context->block_index        = 0xFFFFFFFF;
    sevenzip_context->output             = NULL;
-   sevenzip_context->handle             = NULL;
+
+   sevenzip_context->lookStream.bufSize = SEVENZIP_LOOKTOREAD_BUF_SIZE * sizeof(Byte);
+   sevenzip_context->lookStream.buf     = (Byte*)malloc(sevenzip_context->lookStream.bufSize);
+
+   if (!sevenzip_context->lookStream.buf)
+      sevenzip_context->lookStream.bufSize = 0;
 
    return sevenzip_context;
 }
 
-static void sevenzip_stream_free(void *data)
+static void sevenzip_parse_file_free(void *context)
 {
-   struct sevenzip_context_t *sevenzip_context = (struct sevenzip_context_t*)data;
+   struct sevenzip_context_t *sevenzip_context = (struct sevenzip_context_t*)context;
 
    if (!sevenzip_context)
       return;
@@ -112,11 +119,15 @@ static void sevenzip_stream_free(void *data)
    {
       IAlloc_Free(&sevenzip_context->allocImp, sevenzip_context->output);
       sevenzip_context->output       = NULL;
-      sevenzip_context->handle->data = NULL;
    }
 
    SzArEx_Free(&sevenzip_context->db, &sevenzip_context->allocImp);
    File_Close(&sevenzip_context->archiveStream.file);
+
+   if (sevenzip_context->lookStream.buf)
+      free(sevenzip_context->lookStream.buf);
+
+   free(sevenzip_context);
 }
 
 /* Extract the relative path (needle) from a 7z archive
@@ -124,18 +135,18 @@ static void sevenzip_stream_free(void *data)
  * If optional_outfile is set, extract to that instead
  * and don't allocate buffer.
  */
-static int sevenzip_file_read(
+static int64_t sevenzip_file_read(
       const char *path,
       const char *needle, void **buf,
       const char *optional_outfile)
 {
    CFileInStream archiveStream;
-   CLookToRead lookStream;
+   CLookToRead2 lookStream;
    ISzAlloc allocImp;
    ISzAlloc allocTempImp;
    CSzArEx db;
    uint8_t *output      = 0;
-   long outsize         = -1;
+   int64_t outsize      = -1;
 
    /*These are the allocation routines.
     * Currently using the non-standard 7zip choices. */
@@ -144,6 +155,12 @@ static int sevenzip_file_read(
    allocTempImp.Alloc   = sevenzip_stream_alloc_tmp_impl;
    allocTempImp.Free    = sevenzip_stream_free_impl;
 
+   lookStream.bufSize   = SEVENZIP_LOOKTOREAD_BUF_SIZE * sizeof(Byte);
+   lookStream.buf       = (Byte*)malloc(lookStream.bufSize);
+
+   if (!lookStream.buf)
+      lookStream.bufSize = 0;
+
 #if defined(_WIN32) && defined(USE_WINDOWS_FILE) && !defined(LEGACY_WIN32)
    if (!string_is_empty(path))
    {
@@ -168,51 +185,34 @@ static int sevenzip_file_read(
 #endif
 
    FileInStream_CreateVTable(&archiveStream);
-   LookToRead_CreateVTable(&lookStream, false);
-   lookStream.realStream = &archiveStream.s;
-   LookToRead_Init(&lookStream);
+   LookToRead2_CreateVTable(&lookStream, false);
+   lookStream.realStream = &archiveStream.vt;
+   LookToRead2_Init(&lookStream);
    CrcGenerateTable();
 
-   db.db.PackSizes               = NULL;
-   db.db.PackCRCsDefined         = NULL;
-   db.db.PackCRCs                = NULL;
-   db.db.Folders                 = NULL;
-   db.db.Files                   = NULL;
-   db.db.NumPackStreams          = 0;
-   db.db.NumFolders              = 0;
-   db.db.NumFiles                = 0;
-   db.startPosAfterHeader        = 0;
-   db.dataPos                    = 0;
-   db.FolderStartPackStreamIndex = NULL;
-   db.PackStreamStartPositions   = NULL;
-   db.FolderStartFileIndex       = NULL;
-   db.FileIndexToFolderIndexMap  = NULL;
-   db.FileNameOffsets            = NULL;
-   db.FileNames.data             = NULL;
-   db.FileNames.size             = 0;
+   memset(&db, 0, sizeof(db));
 
    SzArEx_Init(&db);
 
-   if (SzArEx_Open(&db, &lookStream.s, &allocImp, &allocTempImp) == SZ_OK)
+   if (SzArEx_Open(&db, &lookStream.vt, &allocImp, &allocTempImp) == SZ_OK)
    {
       uint32_t i;
       bool file_found      = false;
       uint16_t *temp       = NULL;
       size_t temp_size     = 0;
-      uint32_t block_index = 0xFFFFFFFF;
+      uint32_t block_index   = 0xFFFFFFFF;
       SRes res             = SZ_OK;
 
-      for (i = 0; i < db.db.NumFiles; i++)
+      for (i = 0; i < db.NumFiles; i++)
       {
          size_t len;
          char infile[PATH_MAX_LENGTH];
          size_t offset                = 0;
          size_t outSizeProcessed      = 0;
-         const CSzFileItem    *f      = db.db.Files + i;
 
          /* We skip over everything which is not a directory.
-          * FIXME: Why continue then if f->IsDir is true?*/
-         if (f->IsDir)
+          * FIXME: Why continue then if IsDir is true?*/
+         if (SzArEx_IsDir(&db, i))
             continue;
 
          len = SzArEx_GetFileNameUtf16(&db, i, NULL);
@@ -247,16 +247,16 @@ static int sevenzip_file_read(
              * sourceforge.net/p/sevenzip/discussion/45798/thread/6fb59aaf/
              * */
             file_found = true;
-            res = SzArEx_Extract(&db, &lookStream.s, i, &block_index,
+            res = SzArEx_Extract(&db, &lookStream.vt, i, &block_index,
                   &output, &output_size, &offset, &outSizeProcessed,
                   &allocImp, &allocTempImp);
 
             if (res != SZ_OK)
                break; /* This goes to the error section. */
 
-            outsize = outSizeProcessed;
+            outsize = (int64_t)outSizeProcessed;
 
-            if (optional_outfile != NULL)
+            if (optional_outfile)
             {
                const void *ptr = (const void*)(output + offset);
 
@@ -274,7 +274,7 @@ static int sevenzip_file_read(
                 * We would however need to realloc anyways, because RetroArch
                 * expects a \0 at the end, therefore we allocate new,
                 * copy and free the old one. */
-               *buf = malloc(outsize + 1);
+               *buf = malloc((size_t)(outsize + 1));
                ((char*)(*buf))[outsize] = '\0';
                memcpy(*buf,output + offset,outsize);
             }
@@ -300,28 +300,32 @@ static int sevenzip_file_read(
    SzArEx_Free(&db, &allocImp);
    File_Close(&archiveStream.file);
 
-   return (int)outsize;
+   if (lookStream.buf)
+      free(lookStream.buf);
+
+   return outsize;
 }
 
 static bool sevenzip_stream_decompress_data_to_file_init(
-      file_archive_file_handle_t *handle,
-      const uint8_t *cdata,  uint32_t csize, uint32_t size)
+      void *context, file_archive_file_handle_t *handle,
+      const uint8_t *cdata, unsigned cmode, uint32_t csize, uint32_t size)
 {
    struct sevenzip_context_t *sevenzip_context =
-         (struct sevenzip_context_t*)handle->stream;
+         (struct sevenzip_context_t*)context;
 
    if (!sevenzip_context)
       return false;
 
-   sevenzip_context->handle = handle;
+   sevenzip_context->decompress_index = (uint32_t)(size_t)cdata;
 
    return true;
 }
 
-static int sevenzip_stream_decompress_data_to_file_iterate(void *data)
+static int sevenzip_stream_decompress_data_to_file_iterate(
+      void *context, file_archive_file_handle_t *handle)
 {
    struct sevenzip_context_t *sevenzip_context =
-         (struct sevenzip_context_t*)data;
+         (struct sevenzip_context_t*)context;
 
    SRes res                = SZ_ERROR_FAIL;
    size_t output_size      = 0;
@@ -329,7 +333,7 @@ static int sevenzip_stream_decompress_data_to_file_iterate(void *data)
    size_t outSizeProcessed = 0;
 
    res = SzArEx_Extract(&sevenzip_context->db,
-         &sevenzip_context->lookStream.s, sevenzip_context->index,
+         &sevenzip_context->lookStream.vt, sevenzip_context->decompress_index,
          &sevenzip_context->block_index, &sevenzip_context->output,
          &output_size, &offset, &outSizeProcessed,
          &sevenzip_context->allocImp, &sevenzip_context->allocTempImp);
@@ -337,8 +341,8 @@ static int sevenzip_stream_decompress_data_to_file_iterate(void *data)
    if (res != SZ_OK)
       return 0;
 
-   if (sevenzip_context->handle)
-      sevenzip_context->handle->data = sevenzip_context->output + offset;
+   if (handle)
+      handle->data = sevenzip_context->output + offset;
 
    return 1;
 }
@@ -346,16 +350,21 @@ static int sevenzip_stream_decompress_data_to_file_iterate(void *data)
 static int sevenzip_parse_file_init(file_archive_transfer_t *state,
       const char *file)
 {
-   struct sevenzip_context_t *sevenzip_context =
-         (struct sevenzip_context_t*)sevenzip_stream_new();
+   uint8_t magic_buf[SEVENZIP_MAGIC_LEN];
+   struct sevenzip_context_t *sevenzip_context = NULL;
 
    if (state->archive_size < SEVENZIP_MAGIC_LEN)
       goto error;
 
-   if (string_is_not_equal_fast(state->data, SEVENZIP_MAGIC, SEVENZIP_MAGIC_LEN))
+   filestream_seek(state->archive_file, 0, SEEK_SET);
+   if (filestream_read(state->archive_file, magic_buf, SEVENZIP_MAGIC_LEN) != SEVENZIP_MAGIC_LEN)
       goto error;
 
-   state->stream = sevenzip_context;
+   if (string_is_not_equal_fast(magic_buf, SEVENZIP_MAGIC, SEVENZIP_MAGIC_LEN))
+      goto error;
+
+   sevenzip_context = (struct sevenzip_context_t*)sevenzip_stream_new();
+   state->context = sevenzip_context;
 
 #if defined(_WIN32) && defined(USE_WINDOWS_FILE) && !defined(LEGACY_WIN32)
    if (!string_is_empty(file))
@@ -381,46 +390,48 @@ static int sevenzip_parse_file_init(file_archive_transfer_t *state,
 #endif
 
    FileInStream_CreateVTable(&sevenzip_context->archiveStream);
-   LookToRead_CreateVTable(&sevenzip_context->lookStream, false);
-   sevenzip_context->lookStream.realStream = &sevenzip_context->archiveStream.s;
-   LookToRead_Init(&sevenzip_context->lookStream);
+   LookToRead2_CreateVTable(&sevenzip_context->lookStream, false);
+   sevenzip_context->lookStream.realStream = &sevenzip_context->archiveStream.vt;
+   LookToRead2_Init(&sevenzip_context->lookStream);
    CrcGenerateTable();
    SzArEx_Init(&sevenzip_context->db);
 
-   if (SzArEx_Open(&sevenzip_context->db, &sevenzip_context->lookStream.s,
+   if (SzArEx_Open(&sevenzip_context->db, &sevenzip_context->lookStream.vt,
          &sevenzip_context->allocImp, &sevenzip_context->allocTempImp) != SZ_OK)
       goto error;
 
+   state->step_total = sevenzip_context->db.NumFiles;
+
    return 0;
 
 error:
    if (sevenzip_context)
-      sevenzip_stream_free(sevenzip_context);
+      sevenzip_parse_file_free(sevenzip_context);
    return -1;
 }
 
 static int sevenzip_parse_file_iterate_step_internal(
-      file_archive_transfer_t *state, char *filename,
+      struct sevenzip_context_t *sevenzip_context, char *filename,
       const uint8_t **cdata, unsigned *cmode,
       uint32_t *size, uint32_t *csize, uint32_t *checksum,
       unsigned *payback, struct archive_extract_userdata *userdata)
 {
-   struct sevenzip_context_t *sevenzip_context = (struct sevenzip_context_t*)state->stream;
-   const CSzFileItem *file = sevenzip_context->db.db.Files + sevenzip_context->index;
-
-   if (sevenzip_context->index < sevenzip_context->db.db.NumFiles)
+   if (sevenzip_context->parse_index < sevenzip_context->db.NumFiles)
    {
       size_t len = SzArEx_GetFileNameUtf16(&sevenzip_context->db,
-            sevenzip_context->index, NULL);
+            sevenzip_context->parse_index, NULL);
       uint64_t compressed_size = 0;
 
       if (sevenzip_context->packIndex < sevenzip_context->db.db.NumPackStreams)
       {
-         compressed_size = sevenzip_context->db.db.PackSizes[sevenzip_context->packIndex];
+         compressed_size = sevenzip_context->db.db.PackPositions[sevenzip_context->packIndex + 1] -
+               sevenzip_context->db.db.PackPositions[sevenzip_context->packIndex];
+
          sevenzip_context->packIndex++;
       }
 
-      if (len < PATH_MAX_LENGTH && !file->IsDir)
+      if (len < PATH_MAX_LENGTH &&
+          !SzArEx_IsDir(&sevenzip_context->db, sevenzip_context->parse_index))
       {
          char infile[PATH_MAX_LENGTH];
          SRes res                     = SZ_ERROR_FAIL;
@@ -431,7 +442,7 @@ static int sevenzip_parse_file_iterate_step_internal(
 
          infile[0] = '\0';
 
-         SzArEx_GetFileNameUtf16(&sevenzip_context->db, sevenzip_context->index,
+         SzArEx_GetFileNameUtf16(&sevenzip_context->db, sevenzip_context->parse_index,
                temp);
 
          if (temp)
@@ -446,10 +457,12 @@ static int sevenzip_parse_file_iterate_step_internal(
 
          strlcpy(filename, infile, PATH_MAX_LENGTH);
 
-         *cmode    = ARCHIVE_MODE_COMPRESSED;
-         *checksum = file->Crc;
-         *size     = (uint32_t)file->Size;
+         *cmode    = 0; /* unused for 7zip */
+         *checksum = sevenzip_context->db.CRCs.Vals[sevenzip_context->parse_index];
+         *size     = (uint32_t)SzArEx_GetFileSize(&sevenzip_context->db, sevenzip_context->parse_index);
          *csize    = (uint32_t)compressed_size;
+
+         *cdata    = (uint8_t *)(size_t)sevenzip_context->parse_index;
       }
    }
    else
@@ -460,39 +473,37 @@ static int sevenzip_parse_file_iterate_step_internal(
    return 1;
 }
 
-static int sevenzip_parse_file_iterate_step(file_archive_transfer_t *state,
+static int sevenzip_parse_file_iterate_step(void *context,
       const char *valid_exts,
       struct archive_extract_userdata *userdata, file_archive_file_cb file_cb)
 {
-   char filename[PATH_MAX_LENGTH];
    const uint8_t *cdata = NULL;
    uint32_t checksum    = 0;
    uint32_t size        = 0;
    uint32_t csize       = 0;
    unsigned cmode       = 0;
    unsigned payload     = 0;
-   struct sevenzip_context_t *sevenzip_context = NULL;
+   struct sevenzip_context_t *sevenzip_context = (struct sevenzip_context_t*)context;
    int ret;
 
-   filename[0]                   = '\0';
+   userdata->current_file_path[0] = '\0';
 
-   ret = sevenzip_parse_file_iterate_step_internal(state, filename,
+   ret = sevenzip_parse_file_iterate_step_internal(sevenzip_context,
+         userdata->current_file_path,
          &cdata, &cmode, &size, &csize,
          &checksum, &payload, userdata);
 
    if (ret != 1)
       return ret;
 
-   userdata->extracted_file_path = filename;
    userdata->crc                 = checksum;
 
-   if (file_cb && !file_cb(filename, valid_exts, cdata, cmode,
+   if (file_cb && !file_cb(userdata->current_file_path, valid_exts,
+            cdata, cmode,
             csize, size, checksum, userdata))
       return 0;
 
-   sevenzip_context = (struct sevenzip_context_t*)state->stream;
-
-   sevenzip_context->index += payload;
+   sevenzip_context->parse_index += payload;
 
    return 1;
 }
@@ -504,13 +515,12 @@ static uint32_t sevenzip_stream_crc32_calculate(uint32_t crc,
 }
 
 const struct file_archive_file_backend sevenzip_backend = {
-   sevenzip_stream_new,
-   sevenzip_stream_free,
+   sevenzip_parse_file_init,
+   sevenzip_parse_file_iterate_step,
+   sevenzip_parse_file_free,
    sevenzip_stream_decompress_data_to_file_init,
    sevenzip_stream_decompress_data_to_file_iterate,
    sevenzip_stream_crc32_calculate,
    sevenzip_file_read,
-   sevenzip_parse_file_init,
-   sevenzip_parse_file_iterate_step,
    "7z"
 };
diff --git a/src/libretro/libretro-common/file/archive_file_zlib.c b/src/libretro/libretro-common/file/archive_file_zlib.c
index a9bcddc22b..f9cd64be5c 100644
--- a/src/libretro/libretro-common/file/archive_file_zlib.c
+++ b/src/libretro/libretro-common/file/archive_file_zlib.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (archive_file_zlib.c).
@@ -25,12 +25,10 @@
 
 #include <file/archive_file.h>
 #include <streams/file_stream.h>
-#include <streams/trans_stream.h>
 #include <retro_inline.h>
 #include <retro_miscellaneous.h>
 #include <encodings/crc32.h>
 
-/* Only for MAX_WBITS */
 #include <zlib.h>
 
 #ifndef CENTRAL_FILE_HEADER_SIGNATURE
@@ -41,6 +39,28 @@
 #define END_OF_CENTRAL_DIR_SIGNATURE 0x06054b50
 #endif
 
+#define _READ_CHUNK_SIZE   (128*1024)   /* Read 128KiB compressed chunks */
+
+enum file_archive_compression_mode
+{
+   ZIP_MODE_STORED   = 0,
+   ZIP_MODE_DEFLATED = 8
+};
+
+typedef struct
+{
+   struct file_archive_transfer *state;
+   uint8_t *directory;
+   uint8_t *directory_entry;
+   uint8_t *directory_end;
+   uint64_t fdoffset;
+   uint32_t boffset, csize, usize;
+   unsigned cmode;
+   z_stream *zstream;
+   uint8_t *tmpbuf;
+   uint8_t *decompressed_data;
+} zip_context_t;
+
 static INLINE uint32_t read_le(const uint8_t *data, unsigned size)
 {
    unsigned i;
@@ -53,70 +73,185 @@ static INLINE uint32_t read_le(const uint8_t *data, unsigned size)
    return val;
 }
 
-static void *zlib_stream_new(void)
+static void zip_context_free_stream(
+      zip_context_t *zip_context, bool keep_decompressed)
 {
-   return zlib_inflate_backend.stream_new();
-}
-
-static void zlib_stream_free(void *stream)
-{
-   zlib_inflate_backend.stream_free(stream);
+   if (zip_context->zstream)
+   {
+      inflateEnd(zip_context->zstream);
+      free(zip_context->zstream);
+      zip_context->fdoffset = 0;
+      zip_context->csize = 0;
+      zip_context->usize = 0;
+      zip_context->zstream = NULL;
+   }
+   if (zip_context->tmpbuf)
+   {
+      free(zip_context->tmpbuf);
+      zip_context->tmpbuf = NULL;
+   }
+   if (zip_context->decompressed_data && !keep_decompressed)
+   {
+      free(zip_context->decompressed_data);
+      zip_context->decompressed_data = NULL;
+   }
 }
 
 static bool zlib_stream_decompress_data_to_file_init(
-      file_archive_file_handle_t *handle,
-      const uint8_t *cdata,  uint32_t csize, uint32_t size)
+      void *context, file_archive_file_handle_t *handle,
+      const uint8_t *cdata, unsigned cmode, uint32_t csize, uint32_t size)
 {
-   if (!handle)
-      return false;
-
-   handle->stream = zlib_inflate_backend.stream_new();
-
-   if (!handle->stream)
-      goto error;
-
-   if (zlib_inflate_backend.define)
-      zlib_inflate_backend.define(handle->stream, "window_bits", (uint32_t)-MAX_WBITS);
+   zip_context_t *zip_context = (zip_context_t *)context;
+   struct file_archive_transfer *state = zip_context->state;
+   uint8_t local_header_buf[4];
+   uint8_t *local_header;
+   uint32_t offsetNL, offsetEL;
+   int64_t offsetData;
+
+   /* free previous data and stream if left unfinished */
+   zip_context_free_stream(zip_context, false);
+
+   /* seek past most of the local directory header */
+#ifdef HAVE_MMAP
+   if (state->archive_mmap_data)
+   {
+      local_header = state->archive_mmap_data + (size_t)cdata + 26;
+   }
+   else
+#endif
+   {
+      filestream_seek(state->archive_file, (int64_t)(size_t)cdata + 26, RETRO_VFS_SEEK_POSITION_START);
+      if (filestream_read(state->archive_file, local_header_buf, 4) != 4)
+         goto error;
+      local_header = local_header_buf;
+   }
 
-   handle->data = (uint8_t*)malloc(size);
+   offsetNL = read_le(local_header,     2); /* file name length */
+   offsetEL = read_le(local_header + 2, 2); /* extra field length */
+   offsetData = (int64_t)(size_t)cdata + 26 + 4 + offsetNL + offsetEL;
 
-   if (!handle->data)
-      goto error;
+   zip_context->fdoffset = offsetData;
+   zip_context->usize = size;
+   zip_context->csize = csize;
+   zip_context->boffset = 0;
+   zip_context->cmode = cmode;
+   zip_context->decompressed_data = (uint8_t*)malloc(size);
+   zip_context->zstream = NULL;
+   zip_context->tmpbuf = NULL;
 
-   zlib_inflate_backend.set_in(handle->stream,
-         (const uint8_t*)cdata, csize);
-   zlib_inflate_backend.set_out(handle->stream,
-         handle->data, size);
+   if (cmode == ZIP_MODE_DEFLATED)
+   {
+      /* Initialize the zlib inflate machinery */
+      zip_context->zstream = (z_stream*)malloc(sizeof(z_stream));
+      zip_context->tmpbuf = malloc(_READ_CHUNK_SIZE);
+
+      zip_context->zstream->next_in   = NULL;
+      zip_context->zstream->avail_in  = 0;
+      zip_context->zstream->total_in  = 0;
+      zip_context->zstream->next_out  = zip_context->decompressed_data;
+      zip_context->zstream->avail_out = size;
+      zip_context->zstream->total_out = 0;
+
+      zip_context->zstream->zalloc    = NULL;
+      zip_context->zstream->zfree     = NULL;
+      zip_context->zstream->opaque    = NULL;
+
+      if (inflateInit2(zip_context->zstream, -MAX_WBITS) != Z_OK) {
+         free(zip_context->zstream);
+         zip_context->zstream = NULL;
+         goto error;
+      }
+   }
 
    return true;
 
 error:
-   if (handle->stream)
-      zlib_inflate_backend.stream_free(handle->stream);
-   if (handle->data)
-      free(handle->data);
-
+   zip_context_free_stream(zip_context, false);
    return false;
 }
 
-static int zlib_stream_decompress_data_to_file_iterate(void *stream)
+static int zlib_stream_decompress_data_to_file_iterate(
+      void *context, file_archive_file_handle_t *handle)
 {
-   bool zstatus;
-   uint32_t rd, wn;
-   enum trans_stream_error terror;
+   zip_context_t *zip_context = (zip_context_t *)context;
+   struct file_archive_transfer *state = zip_context->state;
+   int64_t rd;
 
-   if (!stream)
-      return -1;
+   if (zip_context->cmode == ZIP_MODE_STORED)
+   {
+      #ifdef HAVE_MMAP
+      if (zip_context->state->archive_mmap_data)
+      {
+         /* Simply copy the data to the output buffer */
+         memcpy(zip_context->decompressed_data,
+                zip_context->state->archive_mmap_data + (size_t)zip_context->fdoffset,
+                zip_context->usize);
+      }
+      else
+      #endif
+      {
+         /* Read the entire file to memory */
+         filestream_seek(state->archive_file, zip_context->fdoffset, RETRO_VFS_SEEK_POSITION_START);
+         if (filestream_read(state->archive_file,
+                             zip_context->decompressed_data,
+                             zip_context->usize) < 0)
+            return -1;
+      }
 
-   zstatus = zlib_inflate_backend.trans(stream, false, &rd, &wn, &terror);
+      handle->data = zip_context->decompressed_data;
+      return 1;
+   }
+   else if (zip_context->cmode == ZIP_MODE_DEFLATED)
+   {
+      int to_read = MIN(zip_context->csize - zip_context->boffset, _READ_CHUNK_SIZE);
+      uint8_t *dptr;
+      if (!zip_context->zstream)
+      {
+         /* file was uncompressed or decompression finished before */
+         return 1;
+      }
 
-   if (!zstatus && terror != TRANS_STREAM_ERROR_BUFFER_FULL)
-      return -1;
+      #ifdef HAVE_MMAP
+      if (state->archive_mmap_data)
+      {
+         /* Decompress from the mapped file */
+         dptr = state->archive_mmap_data + (size_t)zip_context->fdoffset + zip_context->boffset;
+         rd = to_read;
+      }
+      else
+      #endif
+      {
+         /* Read some compressed data from file to the temp buffer */
+         filestream_seek(state->archive_file, zip_context->fdoffset + zip_context->boffset,
+                         RETRO_VFS_SEEK_POSITION_START);
+         rd = filestream_read(state->archive_file, zip_context->tmpbuf, to_read);
+         if (rd < 0)
+            return -1;
+         dptr = zip_context->tmpbuf;
+      }
 
-   if (zstatus && !terror)
-      return 1;
+      zip_context->boffset           += rd;
+      zip_context->zstream->next_in   = dptr;
+      zip_context->zstream->avail_in  = (uInt)rd;
 
-   return 0;
+      if (inflate(zip_context->zstream, 0) < 0)
+         return -1;
+
+      if (zip_context->boffset >= zip_context->csize)
+      {
+         inflateEnd(zip_context->zstream);
+         free(zip_context->zstream);
+         zip_context->zstream = NULL;
+
+         handle->data = zip_context->decompressed_data;
+         return 1;
+      }
+
+      return 0;   /* still more data to process */
+   }
+
+   /* No idea what kind of compression this is */
+   return -1;
 }
 
 static uint32_t zlib_stream_crc32_calculate(uint32_t crc,
@@ -126,49 +261,39 @@ static uint32_t zlib_stream_crc32_calculate(uint32_t crc,
 }
 
 static bool zip_file_decompressed_handle(
-      file_archive_file_handle_t *handle,
-      const uint8_t *cdata, uint32_t csize,
+      file_archive_transfer_t *transfer,
+      file_archive_file_handle_t* handle,
+      const uint8_t *cdata, unsigned cmode, uint32_t csize,
       uint32_t size, uint32_t crc32)
 {
    int ret   = 0;
 
-   handle->backend = &zlib_backend;
+   transfer->backend = &zlib_backend;
 
-   if (!handle->backend->stream_decompress_data_to_file_init(
-            handle, cdata, csize, size))
+   if (!transfer->backend->stream_decompress_data_to_file_init(
+            transfer->context, handle, cdata, cmode, csize, size))
       return false;
 
    do
    {
-      ret = handle->backend->stream_decompress_data_to_file_iterate(
-            handle->stream);
-   }while(ret == 0);
-
-#if 0
-   handle->real_checksum = handle->backend->stream_crc_calculate(0,
-         handle->data, size);
-
-   if (handle->real_checksum != crc32)
-      goto error;
-#endif
-
-   if (handle->stream)
-      free(handle->stream);
+      ret = transfer->backend->stream_decompress_data_to_file_iterate(
+            transfer->context, handle);
+      if (ret < 0)
+         return false;
+   }while (ret == 0);
 
    return true;
-#if 0
-error:
-   if (handle->stream)
-      free(handle->stream);
-   if (handle->data)
-      free(handle->data);
-
-   handle->stream = NULL;
-   handle->data   = NULL;
-   return false;
-#endif
 }
 
+typedef struct
+{
+   char *opt_file;
+   char *needle;
+   void **buf;
+   size_t size;
+   bool found;
+} decomp_state_t;
+
 /* Extract the relative path (needle) from a
  * ZIP archive (path) and allocate a buffer for it to write it in.
  *
@@ -182,212 +307,257 @@ static int zip_file_decompressed(
       uint32_t csize, uint32_t size,
       uint32_t crc32, struct archive_extract_userdata *userdata)
 {
+   decomp_state_t* decomp_state = (decomp_state_t*)userdata->cb_data;
    char last_char = name[strlen(name) - 1];
    /* Ignore directories. */
    if (last_char == '/' || last_char == '\\')
       return 1;
 
-   if (strstr(name, userdata->decomp_state.needle))
+   if (strstr(name, decomp_state->needle))
    {
-      bool goto_error = false;
       file_archive_file_handle_t handle = {0};
 
-      userdata->decomp_state.found = true;
-
-      if (zip_file_decompressed_handle(&handle,
-               cdata, csize, size, crc32))
+      if (zip_file_decompressed_handle(userdata->transfer,
+               &handle, cdata, cmode, csize, size, crc32))
       {
-         if (userdata->decomp_state.opt_file != 0)
+         if (decomp_state->opt_file != 0)
          {
             /* Called in case core has need_fullpath enabled. */
-            char *buf       = (char*)malloc(size);
+            bool success = filestream_write_file(decomp_state->opt_file, handle.data, size);
 
-            if (buf)
-            {
-               memcpy(buf, handle.data, size);
+            /* Note: Do not free handle.data here - this
+             * will be done when stream is deinitialised */
+            handle.data = NULL;
 
-               if (!filestream_write_file(userdata->decomp_state.opt_file, buf, size))
-                  goto_error = true;
-            }
+            decomp_state->size = 0;
 
-            free(buf);
-
-            userdata->decomp_state.size = 0;
+            if (!success)
+               return -1;
          }
          else
          {
             /* Called in case core has need_fullpath disabled.
-             * Will copy decompressed content directly into
+             * Will move decompressed content directly into
              * RetroArch's ROM buffer. */
-            *userdata->decomp_state.buf = malloc(size);
-            memcpy(*userdata->decomp_state.buf, handle.data, size);
-
-            userdata->decomp_state.size = size;
+            zip_context_t *zip_context = (zip_context_t *)userdata->transfer->context;
+
+            decomp_state->size = 0;
+            *decomp_state->buf             = handle.data;
+            decomp_state->size             = size;
+            /* We keep the data, prevent its deallocation during free */
+            zip_context->decompressed_data = NULL;
+            handle.data = NULL;
          }
       }
 
-      if (handle.data)
-         free(handle.data);
-
-      if (goto_error)
-         return 0;
+      decomp_state->found = true;
    }
 
    return 1;
 }
 
-static int zip_file_read(
+static int64_t zip_file_read(
       const char *path,
       const char *needle, void **buf,
       const char *optional_outfile)
 {
-   file_archive_transfer_t zlib;
-   struct archive_extract_userdata userdata = {{0}};
+   file_archive_transfer_t state            = {0};
+   decomp_state_t decomp                    = {0};
+   struct archive_extract_userdata userdata = {0};
    bool returnerr                           = true;
    int ret                                  = 0;
 
-   zlib.type                                = ARCHIVE_TRANSFER_INIT;
-   zlib.archive_size                        = 0;
-   zlib.start_delta                         = 0;
-   zlib.handle                              = NULL;
-   zlib.stream                              = NULL;
-   zlib.footer                              = NULL;
-   zlib.directory                           = NULL;
-   zlib.data                                = NULL;
-   zlib.backend                             = NULL;
-
-   userdata.decomp_state.needle             = NULL;
-   userdata.decomp_state.opt_file           = NULL;
-   userdata.decomp_state.found              = false;
-   userdata.decomp_state.buf                = buf;
-
    if (needle)
-      userdata.decomp_state.needle          = strdup(needle);
+      decomp.needle          = strdup(needle);
    if (optional_outfile)
-      userdata.decomp_state.opt_file        = strdup(optional_outfile);
+      decomp.opt_file        = strdup(optional_outfile);
+
+   state.type                = ARCHIVE_TRANSFER_INIT;
+   userdata.transfer         = &state;
+   userdata.cb_data          = &decomp;
+   decomp.buf                = buf;
 
    do
    {
-      ret = file_archive_parse_file_iterate(&zlib, &returnerr, path,
+      ret = file_archive_parse_file_iterate(&state, &returnerr, path,
             "", zip_file_decompressed, &userdata);
       if (!returnerr)
          break;
-   }while(ret == 0 && !userdata.decomp_state.found);
+   }while (ret == 0 && !decomp.found);
 
-   file_archive_parse_file_iterate_stop(&zlib);
+   file_archive_parse_file_iterate_stop(&state);
 
-   if (userdata.decomp_state.opt_file)
-      free(userdata.decomp_state.opt_file);
-   if (userdata.decomp_state.needle)
-      free(userdata.decomp_state.needle);
+   if (decomp.opt_file)
+      free(decomp.opt_file);
+   if (decomp.needle)
+      free(decomp.needle);
 
-   if (!userdata.decomp_state.found)
+   if (!decomp.found)
       return -1;
 
-   return (int)userdata.decomp_state.size;
+   return (int64_t)decomp.size;
 }
 
 static int zip_parse_file_init(file_archive_transfer_t *state,
       const char *file)
 {
-   if (state->archive_size < 22)
+   uint8_t footer_buf[1024];
+   uint8_t *footer = footer_buf;
+   int64_t read_pos = state->archive_size;
+   int64_t read_block = MIN(read_pos, (ssize_t)sizeof(footer_buf));
+   int64_t directory_size, directory_offset;
+   zip_context_t *zip_context = NULL;
+
+   /* Minimal ZIP file size is 22 bytes */
+   if (read_block < 22)
       return -1;
 
-   state->footer = state->data + state->archive_size - 22;
-
-   for (;; state->footer--)
+   /* Find the end of central directory record by scanning
+    * the file from the end towards the beginning.
+    */
+   for (;;)
    {
-      if (state->footer <= state->data + 22)
-         return -1;
-      if (read_le(state->footer, 4) == END_OF_CENTRAL_DIR_SIGNATURE)
+      if (--footer < footer_buf)
+      {
+         if (read_pos <= 0)
+            return -1; /* reached beginning of file */
+
+         /* Read 21 bytes of overlaps except on the first block. */
+         if (read_pos == state->archive_size)
+            read_pos = read_pos - read_block;
+         else
+            read_pos = MAX(read_pos - read_block + 21, 0);
+
+         /* Seek to read_pos and read read_block bytes. */
+         filestream_seek(state->archive_file, read_pos, RETRO_VFS_SEEK_POSITION_START);
+         if (filestream_read(state->archive_file, footer_buf, read_block) != read_block)
+            return -1;
+
+         footer = footer_buf + read_block - 22;
+      }
+      if (read_le(footer, 4) == END_OF_CENTRAL_DIR_SIGNATURE)
       {
-         unsigned comment_len = read_le(state->footer + 20, 2);
-         if (state->footer + 22 + comment_len == state->data + state->archive_size)
-            break;
+         unsigned comment_len = read_le(footer + 20, 2);
+         if (read_pos + (footer - footer_buf) + 22 + comment_len == state->archive_size)
+            break; /* found it! */
       }
    }
 
-   state->directory = state->data + read_le(state->footer + 16, 4);
+   /* Read directory info and do basic sanity checks. */
+   directory_size   = read_le(footer + 12, 4);
+   directory_offset = read_le(footer + 16, 4);
+   if (directory_size > state->archive_size
+         || directory_offset > state->archive_size)
+      return -1;
+
+   /* This is a ZIP file, allocate one block of memory for both the
+    * context and the entire directory, then read the directory.
+    */
+   zip_context = (zip_context_t*)malloc(sizeof(zip_context_t) + (size_t)directory_size);
+   zip_context->state             = state;
+   zip_context->directory         = (uint8_t*)(zip_context + 1);
+   zip_context->directory_entry   = zip_context->directory;
+   zip_context->directory_end     = zip_context->directory + (size_t)directory_size;
+   zip_context->zstream           = NULL;
+   zip_context->tmpbuf            = NULL;
+   zip_context->decompressed_data = NULL;
+
+   filestream_seek(state->archive_file, directory_offset, RETRO_VFS_SEEK_POSITION_START);
+   if (filestream_read(state->archive_file, zip_context->directory, directory_size) != directory_size)
+   {
+      free(zip_context);
+      return -1;
+   }
+
+   state->context = zip_context;
+   state->step_total = read_le(footer + 10, 2); /* total entries */;
 
    return 0;
 }
 
 static int zip_parse_file_iterate_step_internal(
-      file_archive_transfer_t *state, char *filename,
+      zip_context_t * zip_context, char *filename,
       const uint8_t **cdata,
       unsigned *cmode, uint32_t *size, uint32_t *csize,
       uint32_t *checksum, unsigned *payback)
 {
-   uint32_t offset;
-   uint32_t namelength, extralength, commentlength,
-            offsetNL, offsetEL;
-   uint32_t signature = read_le(state->directory + 0, 4);
+   uint8_t *entry = zip_context->directory_entry;
+   uint32_t signature, namelength, extralength, commentlength, offset;
+
+   if (entry < zip_context->directory || entry >= zip_context->directory_end)
+      return 0;
+
+   signature = read_le(zip_context->directory_entry + 0, 4);
 
    if (signature != CENTRAL_FILE_HEADER_SIGNATURE)
       return 0;
 
-   *cmode         = read_le(state->directory + 10, 2); /* compression mode, 0 = store, 8 = deflate */
-   *checksum      = read_le(state->directory + 16, 4); /* CRC32 */
-   *csize         = read_le(state->directory + 20, 4); /* compressed size */
-   *size          = read_le(state->directory + 24, 4); /* uncompressed size */
+   *cmode         = read_le(zip_context->directory_entry + 10, 2); /* compression mode, 0 = store, 8 = deflate */
+   *checksum      = read_le(zip_context->directory_entry + 16, 4); /* CRC32 */
+   *csize         = read_le(zip_context->directory_entry + 20, 4); /* compressed size */
+   *size          = read_le(zip_context->directory_entry + 24, 4); /* uncompressed size */
 
-   namelength     = read_le(state->directory + 28, 2); /* file name length */
-   extralength    = read_le(state->directory + 30, 2); /* extra field length */
-   commentlength  = read_le(state->directory + 32, 2); /* file comment length */
+   namelength     = read_le(zip_context->directory_entry + 28, 2); /* file name length */
+   extralength    = read_le(zip_context->directory_entry + 30, 2); /* extra field length */
+   commentlength  = read_le(zip_context->directory_entry + 32, 2); /* file comment length */
 
    if (namelength >= PATH_MAX_LENGTH)
       return -1;
 
-   memcpy(filename, state->directory + 46, namelength); /* file name */
+   memcpy(filename, zip_context->directory_entry + 46, namelength); /* file name */
+   filename[namelength] = '\0';
 
-   offset         = read_le(state->directory + 42, 4); /* relative offset of local file header */
-   offsetNL       = read_le(state->data + offset + 26, 2); /* file name length */
-   offsetEL       = read_le(state->data + offset + 28, 2); /* extra field length */
+   offset   = read_le(zip_context->directory_entry + 42, 4); /* relative offset of local file header */
 
-   *cdata         = state->data + offset + 30 + offsetNL + offsetEL;
+   *cdata   = (uint8_t*)(size_t)offset; /* store file offset in data pointer */
 
-   *payback       = 46 + namelength + extralength + commentlength;
+   *payback = 46 + namelength + extralength + commentlength;
 
    return 1;
 }
 
-static int zip_parse_file_iterate_step(file_archive_transfer_t *state,
+static int zip_parse_file_iterate_step(void *context,
       const char *valid_exts, struct archive_extract_userdata *userdata,
       file_archive_file_cb file_cb)
 {
-   char filename[PATH_MAX_LENGTH] = {0};
+   zip_context_t *zip_context = (zip_context_t *)context;
    const uint8_t *cdata           = NULL;
    uint32_t checksum              = 0;
    uint32_t size                  = 0;
    uint32_t csize                 = 0;
    unsigned cmode                 = 0;
    unsigned payload               = 0;
-   int ret                        = zip_parse_file_iterate_step_internal(
-         state, filename, &cdata, &cmode, &size, &csize, &checksum, &payload);
+   int ret                        = zip_parse_file_iterate_step_internal(zip_context,
+         userdata->current_file_path, &cdata, &cmode, &size, &csize, &checksum, &payload);
 
    if (ret != 1)
       return ret;
 
-   userdata->extracted_file_path = filename;
    userdata->crc = checksum;
 
-   if (file_cb && !file_cb(filename, valid_exts, cdata, cmode,
+   if (file_cb && !file_cb(userdata->current_file_path, valid_exts, cdata, cmode,
             csize, size, checksum, userdata))
       return 0;
 
-   state->directory += payload;
+   zip_context->directory_entry += payload;
 
    return 1;
 }
 
+static void zip_parse_file_free(void *context)
+{
+   zip_context_t *zip_context = (zip_context_t *)context;
+   zip_context_free_stream(zip_context, false);
+   free(zip_context);
+}
+
 const struct file_archive_file_backend zlib_backend = {
-   zlib_stream_new,
-   zlib_stream_free,
+   zip_parse_file_init,
+   zip_parse_file_iterate_step,
+   zip_parse_file_free,
    zlib_stream_decompress_data_to_file_init,
    zlib_stream_decompress_data_to_file_iterate,
    zlib_stream_crc32_calculate,
    zip_file_read,
-   zip_parse_file_init,
-   zip_parse_file_iterate_step,
    "zlib"
 };
diff --git a/src/libretro/libretro-common/file/config_file.c b/src/libretro/libretro-common/file/config_file.c
index a16e2148b1..5ad3b6d54b 100644
--- a/src/libretro/libretro-common/file/config_file.c
+++ b/src/libretro/libretro-common/file/config_file.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (config_file.c).
@@ -26,18 +26,6 @@
 #include <ctype.h>
 #include <errno.h>
 
-#if !defined(_WIN32) && !defined(__CELLOS_LV2__) && !defined(_XBOX)
-#include <sys/param.h> /* PATH_MAX */
-#elif defined(_WIN32) && !defined(_XBOX)
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#elif defined(_XBOX)
-#include <xtl.h>
-#endif
-#ifdef ORBIS
-#include <sys/fcntl.h>
-#include <orbisFile.h>
-#endif
 #include <retro_miscellaneous.h>
 #include <compat/strl.h>
 #include <compat/posix_string.h>
@@ -45,40 +33,42 @@
 #include <compat/msvc.h>
 #include <file/config_file.h>
 #include <file/file_path.h>
-#include <lists/string_list.h>
 #include <string/stdstring.h>
 #include <streams/file_stream.h>
+#include <array/rhmap.h>
 
 #define MAX_INCLUDE_DEPTH 16
 
-struct config_entry_list
-{
-   /* If we got this from an #include,
-    * do not allow overwrite. */
-   bool readonly;
-
-   char *key;
-   char *value;
-   struct config_entry_list *next;
-};
-
 struct config_include_list
 {
    char *path;
    struct config_include_list *next;
 };
 
-static config_file_t *config_file_new_internal(
-      const char *path, unsigned depth, config_file_cb_t *cb);
+/* Forward declaration */
+static bool config_file_parse_line(config_file_t *conf,
+      struct config_entry_list *list, char *line, config_file_cb_t *cb);
 
-static int config_sort_compare_func(struct config_entry_list *a,
+static int config_file_sort_compare_func(struct config_entry_list *a,
       struct config_entry_list *b)
 {
-   return (a && b) ? strcasecmp(a->key, b->key) : 0;
+   if (a && b)
+   {
+      if (a->key)
+      {
+         if (b->key)
+            return strcasecmp(a->key, b->key);
+         return 1;
+      }
+      else if (b->key)
+         return -1;
+   }
+
+   return 0;
 }
 
 /* https://stackoverflow.com/questions/7685/merge-sort-a-linked-list */
-static struct config_entry_list* merge_sort_linked_list(
+static struct config_entry_list* config_file_merge_sort_linked_list(
          struct config_entry_list *list, int (*compare)(
          struct config_entry_list *one,struct config_entry_list *two))
 {
@@ -98,18 +88,18 @@ static struct config_entry_list* merge_sort_linked_list(
     * one at twice the speed of the other). */
    while (temp && temp->next)
    {
-      last  = right;
-      right = right->next;
-      temp  = temp->next->next;
+      last     = right;
+      right    = right->next;
+      temp     = temp->next->next;
    }
 
    /* Break the list in two. (prev pointers are broken here,
     * but we fix later) */
-   last->next = 0;
+   last->next  = 0;
 
    /* Recurse on the two smaller lists: */
-   list = merge_sort_linked_list(list, compare);
-   right = merge_sort_linked_list(right, compare);
+   list        = config_file_merge_sort_linked_list(list, compare);
+   right       = config_file_merge_sort_linked_list(right, compare);
 
    /* Merge: */
    while (list || right)
@@ -117,116 +107,170 @@ static struct config_entry_list* merge_sort_linked_list(
       /* Take from empty lists, or compare: */
       if (!right)
       {
-         next = list;
-         list = list->next;
+         next  = list;
+         list  = list->next;
       }
       else if (!list)
       {
-         next = right;
+         next  = right;
          right = right->next;
       }
       else if (compare(list, right) < 0)
       {
-         next = list;
-         list = list->next;
+         next  = list;
+         list  = list->next;
       }
       else
       {
-         next = right;
+         next  = right;
          right = right->next;
       }
 
       if (!result)
-         result = next;
+         result     = next;
       else
          tail->next = next;
 
-      tail = next;
+      tail          = next;
    }
 
    return result;
 }
 
-static char *strip_comment(char *str)
+/**
+ * config_file_strip_comment:
+ *
+ * Searches input string for a comment ('#') entry
+ * > If first character is '#', then entire line is
+ *   a comment and may correspond to a directive
+ *   (command action - e.g. include sub-config file).
+ *   In this case, 'str' is set to NUL and the comment
+ *   itself (everything after the '#' character) is
+ *   returned
+ * > If a '#' character is found inside a string literal
+ *   value, then it does not correspond to a comment and
+ *   is ignored. In this case, 'str' is left untouched
+ *   and NULL is returned
+ * > If a '#' character is found anywhere else, then the
+ *   comment text is a suffix of the input string and
+ *   has no programmatic value. In this case, the comment
+ *   is removed from the end of 'str' and NULL is returned
+ **/
+static char *config_file_strip_comment(char *str)
 {
-   /* Remove everything after comment.
-    * Keep #s inside string literals. */
-   char *string_end  = str + strlen(str);
-   bool cut_comment  = true;
+   /* Search for a comment (#) character */
+   char *comment = strchr(str, '#');
 
-   while (!string_is_empty(str))
+   if (comment)
    {
-      char *comment  = NULL;
-      char *literal  = strchr(str, '\"');
-      if (!literal)
-         literal     = string_end;
-      comment        = (char*)strchr(str, '#');
+      char *literal_start = NULL;
 
-      if (!comment)
-         comment     = string_end;
-
-      if (cut_comment && literal < comment)
-      {
-         cut_comment = false;
-         str         = literal + 1;
-      }
-      else if (!cut_comment && literal)
+      /* Check whether entire line is a comment
+       * > First character == '#' */
+      if (str == comment)
       {
-         cut_comment = true;
-         str         = (literal < string_end) ? literal + 1 : string_end;
+         /* Set 'str' to NUL and return comment
+          * for processing at a higher level */
+         *str = '\0';
+         return ++comment;
       }
-      else
+
+      /* Comment character occurs at an offset:
+       * Search for the start of a string literal value */
+      literal_start = strchr(str, '\"');
+
+      /* Check whether string literal start occurs
+       * *before* the comment character */
+      if (literal_start && (literal_start < comment))
       {
-         *comment    = '\0';
-         str         = comment;
+         /* Search for the end of the string literal
+          * value */
+         char *literal_end = strchr(literal_start + 1, '\"');
+
+         /* Check whether string literal end occurs
+          * *after* the comment character
+          * > If this is the case, ignore the comment
+          * > Leave 'str' untouched and return NULL */
+         if (literal_end && (literal_end > comment))
+            return NULL;
       }
+
+      /* If we reach this point, then a comment
+       * exists outside of a string literal
+       * > Trim the entire comment from the end
+       *   of 'str' */
+      *comment = '\0';
    }
 
-   return str;
+   return NULL;
 }
 
-static char *extract_value(char *line, bool is_value)
+static char *config_file_extract_value(char *line)
 {
-   char *save = NULL;
-   char *tok  = NULL;
-
-   if (is_value)
-   {
-      while (isspace((int)*line))
-         line++;
-
-      /* If we don't have an equal sign here,
-       * we've got an invalid string. */
-      if (*line != '=')
-         return NULL;
-
+   char *dst = NULL;
+   while (ISSPACE((int)*line))
       line++;
-   }
 
-   while (isspace((int)*line))
-      line++;
+   /* Note: From this point on, an empty value
+    * string is valid - and in this case, strldup("", sizeof(""))
+    * will be returned (see Note 2)
+    * > If we instead return NULL, the the entry
+    *   is ignored completely - which means we cannot
+    *   track *changes* in entry value */
 
-   /* We have a full string. Read until next ". */
+   /* If first character is ("), we have a full string
+    * literal */
    if (*line == '"')
    {
+      size_t idx  = 0;
+      char *value = NULL;
+      /* Skip to next character */
       line++;
-      if (*line == '"')
-         return NULL;
-      tok = strtok_r(line, "\"", &save);
+
+      /* If this a ("), then value string is empty */
+      if (*line != '"')
+      {
+         /* Find the next (") character */
+         while (line[idx] && (line[idx] != '\"'))
+            idx++;
+
+         line[idx] = '\0';
+         if ((value = line) && *value)
+            return strdup(value);
+      }
+   }
+   /* This is not a string literal - just read
+    * until the next space is found
+    * > Note: Skip this if line is empty */
+   else if (*line != '\0')
+   {
+      size_t idx  = 0;
+      char *value = NULL;
+      /* Find next space character */
+      while (line[idx] && isgraph((int)line[idx]))
+         idx++;
+
+      line[idx] = '\0';
+      if ((value = line) && *value)
+         return strdup(value);
    }
-   /* We don't have that. Read until next space. */
-   else if (*line != '\0') /* Nothing */
-      tok = strtok_r(line, " \n\t\f\r\v", &save);
 
-   if (tok && *tok)
-      return strdup(tok);
-   return NULL;
+   /* Note 2: This is an unrolled strldup call 
+    * to avoid an unnecessary dependency -
+    * call is strldup("", sizeof(""))
+    **/
+   dst = (char*)malloc(sizeof(char) * 2);
+   strlcpy(dst, "", 1);
+   return dst;
 }
 
 /* Move semantics? */
-static void add_child_list(config_file_t *parent, config_file_t *child)
+static void config_file_add_child_list(config_file_t *parent,
+      config_file_t *child)
 {
    struct config_entry_list *list = child->entries;
+   bool merge_hash_map            = false;
+
    if (parent->entries)
    {
       struct config_entry_list *head = parent->entries;
@@ -240,6 +284,8 @@ static void add_child_list(config_file_t *parent, config_file_t *child)
          list           = list->next;
       }
       head->next        = child->entries;
+
+      merge_hash_map    = true;
    }
    else
    {
@@ -252,8 +298,6 @@ static void add_child_list(config_file_t *parent, config_file_t *child)
       parent->entries   = child->entries;
    }
 
-   child->entries = NULL;
-
    /* Rebase tail. */
    if (parent->entries)
    {
@@ -266,216 +310,416 @@ static void add_child_list(config_file_t *parent, config_file_t *child)
    }
    else
       parent->tail = NULL;
+
+   /* Update hash map */
+   if (merge_hash_map)
+   {
+      size_t i;
+      size_t cap;
+
+      /* We are merging two lists - if any child entry
+       * (key) is not present in the parent list, add it
+       * to the parent hash map */
+      for (i = 0, cap = RHMAP_CAP(child->entries_map); i != cap; i++)
+      {
+         uint32_t child_hash   = RHMAP_KEY(child->entries_map, i);
+         const char *child_key = RHMAP_KEY_STR(child->entries_map, i);
+
+         if (child_hash &&
+             child_key &&
+             !RHMAP_HAS_FULL(parent->entries_map, child_hash, child_key))
+         {
+            struct config_entry_list *entry = child->entries_map[i];
+
+            if (entry)
+               RHMAP_SET_FULL(parent->entries_map, child_hash, child_key, entry);
+         }
+      }
+
+      /* Child entries map is no longer required,
+       * so free it now */
+      RHMAP_FREE(child->entries_map);
+   }
+   else
+   {
+      /* If parent list was originally empty,
+       * take map from child list */
+      RHMAP_FREE(parent->entries_map);
+      parent->entries_map = child->entries_map;
+      child->entries_map  = NULL;
+   }
+
+   child->entries = NULL;
 }
 
-static void add_sub_conf(config_file_t *conf, char *path, config_file_cb_t *cb)
+static void config_file_get_realpath(char *s, size_t len,
+      char *path, const char *config_path)
+{
+#ifdef _WIN32
+   if (!string_is_empty(config_path))
+      fill_pathname_resolve_relative(s, config_path,
+            path, len);
+#else
+#if !defined(__PSL1GHT__) && !defined(__PS3__)
+   if (*path == '~')
+   {
+      const char *home = getenv("HOME");
+      if (home)
+      {
+         size_t _len = strlcpy(s, home,     len);
+         strlcpy(s + _len, path + 1, len - _len);
+      }
+      else
+         strlcpy(s, path + 1, len);
+   }
+   else
+#endif
+      if (!string_is_empty(config_path))
+         fill_pathname_resolve_relative(s, config_path, path, len);
+#endif
+}
+
+static void config_file_add_sub_conf(config_file_t *conf, char *path,
+      char *real_path, size_t len, config_file_cb_t *cb)
 {
-   char real_path[PATH_MAX_LENGTH];
-   config_file_t         *sub_conf  = NULL;
    struct config_include_list *head = conf->includes;
    struct config_include_list *node = (struct config_include_list*)
       malloc(sizeof(*node));
 
    if (node)
    {
-      node->next = NULL;
+      node->next        = NULL;
       /* Add include list */
-      node->path = strdup(path);
+      node->path        = strdup(path);
 
       if (head)
       {
          while (head->next)
-            head = head->next;
+            head        = head->next;
 
-         head->next = node;
+         head->next     = node;
       }
       else
          conf->includes = node;
    }
 
-   real_path[0] = '\0';
+   config_file_get_realpath(real_path, len, path,
+         conf->path);
+}
 
-#ifdef _WIN32
-   if (!string_is_empty(conf->path))
-      fill_pathname_resolve_relative(real_path, conf->path,
-            path, sizeof(real_path));
-#else
-#ifndef __CELLOS_LV2__
-   if (*path == '~')
+size_t config_file_add_reference(config_file_t *conf, char *path)
+{
+   size_t len;
+   /* It is expected that the conf has it's path already set */
+   char short_path[PATH_MAX_LENGTH];
+   if (!conf->references)
+      conf->references = path_linked_list_new();
+   len = fill_pathname_abbreviated_or_relative(short_path, conf->path, path, sizeof(short_path));
+   path_linked_list_add_path(conf->references, short_path);
+   return len;
+}
+
+static int config_file_load_internal(
+      struct config_file *conf,
+      const char *path, unsigned depth, config_file_cb_t *cb)
+{
+   RFILE         *file = NULL;
+   char      *new_path = strdup(path);
+   if (!new_path)
+      return 1;
+
+   conf->path          = new_path;
+   conf->include_depth = depth;
+
+   if (!(file = filestream_open(path,
+         RETRO_VFS_FILE_ACCESS_READ,
+         RETRO_VFS_FILE_ACCESS_HINT_NONE)))
    {
-      const char *home = getenv("HOME");
-      strlcpy(real_path, home ? home : "", sizeof(real_path));
-      strlcat(real_path, path + 1, sizeof(real_path));
+      free(conf->path);
+      return 1;
    }
-   else
-#endif
-      if (!string_is_empty(conf->path))
-         fill_pathname_resolve_relative(real_path, conf->path,
-               path, sizeof(real_path));
-#endif
 
-   sub_conf = (config_file_t*)
-      config_file_new_internal(real_path, conf->include_depth + 1, cb);
-   if (!sub_conf)
-      return;
+   while (!filestream_eof(file))
+   {
+      char *line                     = NULL;
+      struct config_entry_list *list = (struct config_entry_list*)
+         malloc(sizeof(*list));
 
-   /* Pilfer internal list. */
-   add_child_list(conf, sub_conf);
-   config_file_free(sub_conf);
+      if (!list)
+      {
+         filestream_close(file);
+         return -1;
+      }
+
+      list->readonly  = false;
+      list->key       = NULL;
+      list->value     = NULL;
+      list->next      = NULL;
+
+      line            = filestream_getline(file);
+
+      if (!line)
+      {
+         free(list);
+         continue;
+      }
+
+      if ( 
+              !string_is_empty(line) 
+            && config_file_parse_line(conf, list, line, cb))
+      {
+         if (conf->entries)
+            conf->tail->next = list;
+         else
+            conf->entries    = list;
+
+         conf->tail = list;
+
+         if (list->key)
+         {
+            /* Only add entry to the map if an entry
+             * with the specified value does not
+             * already exist */
+            uint32_t hash = rhmap_hash_string(list->key);
+
+            if (!RHMAP_HAS_FULL(conf->entries_map, hash, list->key))
+            {
+               RHMAP_SET_FULL(conf->entries_map, hash, list->key, list);
+
+               if (cb && list->value)
+                  cb->config_file_new_entry_cb(list->key, list->value);
+            }
+         }
+      }
+
+      free(line);
+
+      if (list != conf->tail)
+         free(list);
+   }
+
+   filestream_close(file);
+
+   return 0;
 }
 
-static bool parse_line(config_file_t *conf,
+static bool config_file_parse_line(config_file_t *conf,
       struct config_entry_list *list, char *line, config_file_cb_t *cb)
 {
-   char *key       = NULL;
-   char *key_tmp   = NULL;
-   size_t cur_size = 8;
-   size_t idx      = 0;
-   char *comment   = strip_comment(line);
-
-   /* Starting line with #include includes config files. */
-   if (comment == line)
+   size_t cur_size       = 32;
+   size_t idx            = 0;
+   char *key             = NULL;
+   char *key_tmp         = NULL;
+   /* Remove any comment text */
+   char *comment         = config_file_strip_comment(line);
+
+   /* Check whether entire line is a comment */
+   if (comment)
    {
-      comment++;
-      if (strstr(comment, "include ") == comment)
+      char *path               = NULL;
+      bool include_found       = string_starts_with_size(comment,
+            "include ",   STRLEN_CONST("include "));
+      bool reference_found     = string_starts_with_size(comment,
+            "reference ", STRLEN_CONST("reference "));
+
+      /* All comments except those starting with the include or 
+       * reference directive are ignored */
+      if (!include_found && !reference_found)
+         return false;
+
+      /* Starting a line with an 'include' directive
+       * appends a sub-config file */
+      if (include_found)
       {
+         config_file_t sub_conf;
+         char real_path[PATH_MAX_LENGTH];
          char *include_line = comment + STRLEN_CONST("include ");
-         char *path         = extract_value(include_line, false);
 
-         if (!path)
+         if (string_is_empty(include_line))
             return false;
 
-         if (conf->include_depth >= MAX_INCLUDE_DEPTH)
-            fprintf(stderr, "!!! #include depth exceeded for config. Might be a cycle.\n");
-         else
-            add_sub_conf(conf, path, cb);
-         free(path);
+         if (!(path = config_file_extract_value(include_line)))
+            return false;
+
+         if (     string_is_empty(path)
+               || conf->include_depth >= MAX_INCLUDE_DEPTH)
+         {
+            free(path);
+            return false;
+         }
+
+         config_file_add_sub_conf(conf, path,
+            real_path, sizeof(real_path), cb);
+
+         config_file_initialize(&sub_conf);
+
+         switch (config_file_load_internal(&sub_conf, real_path,
+            conf->include_depth + 1, cb))
+         {
+            case 0:
+               /* Pilfer internal list. */
+               config_file_add_child_list(conf, &sub_conf);
+               /* fall-through to deinitialize */
+            case -1:
+               config_file_deinitialize(&sub_conf);
+               break;
+            case 1:
+            default:
+               break;
+         }
+      }
+
+      /* Starting a line with an 'reference' directive
+       * sets the reference path */
+      if (reference_found)
+      {
+         char *reference_line = comment + STRLEN_CONST("reference ");
+
+         if (string_is_empty(reference_line))
+            return false;
+
+         if (!(path = config_file_extract_value(reference_line)))
+            return false;
+
+         config_file_add_reference(conf, path);
+
+         if (!path)
+            return false;
       }
+
+      free(path);
+      return true;
    }
 
-   /* Skips to first character. */
-   while (isspace((int)*line))
+   /* Skip to first non-space character */
+   while (ISSPACE((int)*line))
       line++;
 
-   key             = (char*)malloc(9);
+   /* Allocate storage for key */
+   if (!(key = (char*)malloc(cur_size + 1)))
+      return false;
 
+   /* Copy line contents into key until we
+    * reach the next space character */
    while (isgraph((int)*line))
    {
+      /* If current key storage is too small,
+       * double its size */
       if (idx == cur_size)
       {
          cur_size *= 2;
-         key_tmp   = (char*)realloc(key, cur_size + 1);
-
-         if (!key_tmp)
+         if (!(key_tmp   = (char*)realloc(key, cur_size + 1)))
          {
             free(key);
             return false;
          }
 
-         key = key_tmp;
+         key     = key_tmp;
       }
 
       key[idx++] = *line++;
    }
    key[idx]      = '\0';
+
+   /* Add key and value entries to list */
    list->key     = key;
 
-   list->value   = extract_value(line, true);
+   /* An entry without a value is invalid */
+   while (ISSPACE((int)*line))
+      line++;
 
-   if (!list->value)
+   /* If we don't have an equal sign here,
+    * we've got an invalid string. */
+   if (*line != '=')
    {
-      list->key = NULL;
-      free(key);
-      return false;
+      list->value = NULL;
+      goto error;
    }
 
+   line++;
+
+   if (!(list->value   = config_file_extract_value(line)))
+      goto error;
+
    return true;
+
+error:
+   list->key   = NULL;
+   free(key);
+   return false;
 }
 
-static config_file_t *config_file_new_internal(
-      const char *path, unsigned depth, config_file_cb_t *cb)
+static int config_file_from_string_internal(
+      struct config_file *conf,
+      char *from_string,
+      const char *path)
 {
-   RFILE              *file = NULL;
-   struct config_file *conf = config_file_new_alloc();
-
-   if (!path || !*path)
-      return conf;
-   conf->path          = strdup(path);
-   if (!conf->path)
-      goto error;
+   char *lines                    = from_string;
+   char *save_ptr                 = NULL;
+   char *line                     = NULL;
 
-   conf->include_depth = depth;
-   file                = filestream_open(path,
-         RETRO_VFS_FILE_ACCESS_READ,
-         RETRO_VFS_FILE_ACCESS_HINT_NONE);
+   if (!string_is_empty(path))
+      conf->path                  = strdup(path);
+   if (string_is_empty(lines))
+      return 0;
 
-   if (!file)
-   {
-      free(conf->path);
-      goto error;
-   }
+   /* Get first line of config file */
+   line = strtok_r(lines, "\n", &save_ptr);
 
-   while (!filestream_eof(file))
+   while (line)
    {
-      char *line                     = NULL;
       struct config_entry_list *list = (struct config_entry_list*)
-         malloc(sizeof(*list));
+            malloc(sizeof(*list));
 
       if (!list)
-      {
-         config_file_free(conf);
-         filestream_close(file);
-         return NULL;
-      }
+         return -1;
 
       list->readonly  = false;
       list->key       = NULL;
       list->value     = NULL;
       list->next      = NULL;
 
-      line            = filestream_getline(file);
-
-      if (!line)
-      {
-         free(list);
-         continue;
-      }
-
-      if (*line && parse_line(conf, list, line, cb))
+      /* Parse current line */
+      if (
+              !string_is_empty(line)
+            && config_file_parse_line(conf, list, line, NULL))
       {
          if (conf->entries)
             conf->tail->next = list;
          else
             conf->entries    = list;
 
-         conf->tail = list;
+         conf->tail          = list;
 
-         if (cb != NULL && list->key != NULL && list->value != NULL)
-            cb->config_file_new_entry_cb(list->key, list->value) ;
+         if (list->key)
+         {
+            /* Only add entry to the map if an entry
+             * with the specified value does not
+             * already exist */
+            uint32_t hash = rhmap_hash_string(list->key);
+            if (!RHMAP_HAS_FULL(conf->entries_map, hash, list->key))
+               RHMAP_SET_FULL(conf->entries_map, hash, list->key, list);
+         }
       }
 
-      free(line);
-
       if (list != conf->tail)
          free(list);
-   }
 
-   filestream_close(file);
-
-   return conf;
-
-error:
-   free(conf);
-
-   return NULL;
+      /* Get next line of config file */
+      line = strtok_r(NULL, "\n", &save_ptr);
+   }
+   
+   return 0;
 }
 
-void config_file_free(config_file_t *conf)
+
+bool config_file_deinitialize(config_file_t *conf)
 {
    struct config_include_list *inc_tmp = NULL;
    struct config_entry_list *tmp       = NULL;
+
    if (!conf)
-      return;
+      return false;
 
    tmp = conf->entries;
    while (tmp)
@@ -508,17 +752,56 @@ void config_file_free(config_file_t *conf)
          free(hold);
    }
 
+   path_linked_list_free(conf->references);
+
    if (conf->path)
       free(conf->path);
-   free(conf);
+
+   RHMAP_FREE(conf->entries_map);
+
+   return true;
+}
+
+/**
+ * config_file_free:
+ *
+ * Frees config file.
+ **/
+void config_file_free(config_file_t *conf)
+{
+   if (config_file_deinitialize(conf))
+      free(conf);
 }
 
+/**
+ * config_append_file:
+ *
+ * Loads a new config, and appends its data to @conf.
+ * The key-value pairs of the new config file takes priority over the old.
+ **/
 bool config_append_file(config_file_t *conf, const char *path)
 {
+   size_t i, cap;
    config_file_t *new_conf = config_file_new_from_path_to_string(path);
+
    if (!new_conf)
       return false;
 
+   /* Update hash map */
+   for (i = 0, cap = RHMAP_CAP(new_conf->entries_map); i != cap; i++)
+   {
+      uint32_t new_hash   = RHMAP_KEY(new_conf->entries_map, i);
+      const char *new_key = RHMAP_KEY_STR(new_conf->entries_map, i);
+
+      if (new_hash && new_key)
+      {
+         struct config_entry_list *entry = new_conf->entries_map[i];
+
+         if (entry)
+            RHMAP_SET_FULL(conf->entries_map, new_hash, new_key, entry);
+      }
+   }
+
    if (new_conf->tail)
    {
       new_conf->tail->next = conf->entries;
@@ -530,145 +813,182 @@ bool config_append_file(config_file_t *conf, const char *path)
    return true;
 }
 
-config_file_t *config_file_new_from_string(const char *from_string,
+/**
+ * config_file_new_from_string:
+ *
+ * Load a config file from a string.
+ *
+ * NOTE: This will modify @from_string.
+ * Pass a copy of source string if original
+ * contents must be preserved
+ **/
+config_file_t *config_file_new_from_string(char *from_string,
       const char *path)
 {
-   size_t i;
-   struct string_list *lines = NULL;
-   struct config_file *conf  = (struct config_file*)malloc(sizeof(*conf));
-   if (!conf)
-      return NULL;
-
-   if (!from_string)
+   struct config_file *conf      = config_file_new_alloc();
+   if (     conf 
+         && config_file_from_string_internal(
+            conf, from_string, path) != -1)
       return conf;
-
-   conf->path                     = NULL;
-   conf->entries                  = NULL;
-   conf->tail                     = NULL;
-   conf->last                     = NULL;
-   conf->includes                 = NULL;
-   conf->include_depth            = 0;
-   conf->guaranteed_no_duplicates = false ;
-
-   if (!string_is_empty(path))
-      conf->path                  = strdup(path);
-
-   lines                          = string_split(from_string, "\n");
-   if (!lines)
-      return conf;
-
-   for (i = 0; i < lines->size; i++)
-   {
-      struct config_entry_list *list = (struct config_entry_list*)
-         malloc(sizeof(*list));
-      char                    *line  = lines->elems[i].data;
-
-      if (!list)
-      {
-         string_list_free(lines);
-         config_file_free(conf);
-         return NULL;
-      }
-
-      list->readonly  = false;
-      list->key       = NULL;
-      list->value     = NULL;
-      list->next      = NULL;
-
-      if (line && conf)
-      {
-         if (*line && parse_line(conf, list, line, NULL))
-         {
-            if (conf->entries)
-               conf->tail->next = list;
-            else
-               conf->entries    = list;
-
-            conf->tail          = list;
-         }
-      }
-
-      if (list != conf->tail)
-         free(list);
-   }
-
-   string_list_free(lines);
-
-   return conf;
+   if (conf)
+      config_file_free(conf);
+   return NULL;
 }
 
 config_file_t *config_file_new_from_path_to_string(const char *path)
 {
-   int64_t length                = 0;
-   uint8_t *ret_buf              = NULL;
-   config_file_t *conf           = NULL;
-
    if (path_is_valid(path))
    {
+	   uint8_t *ret_buf                 = NULL;
+      int64_t length                   = 0;
       if (filestream_read_file(path, (void**)&ret_buf, &length))
       {
+         config_file_t *conf           = NULL;
+         /* Note: 'ret_buf' is not used outside this
+          * function - we do not care that it will be
+          * modified by config_file_new_from_string() */
          if (length >= 0)
-            conf = config_file_new_from_string((const char*)ret_buf, path);
+            conf = config_file_new_from_string((char*)ret_buf, path);
+
          if ((void*)ret_buf)
             free((void*)ret_buf);
+
+         return conf;
       }
    }
 
-   return conf;
+   return NULL;
 }
 
+/**
+ * config_file_new_with_callback:
+ *
+ * Loads a config file.
+ * If @path is NULL, will create an empty config file.
+ * Includes cb callbacks  to run custom code during config file processing.
+ *
+ * @return Returns NULL if file doesn't exist.
+ **/
 config_file_t *config_file_new_with_callback(
       const char *path, config_file_cb_t *cb)
 {
-   return config_file_new_internal(path, 0, cb);
+   int ret                  = 0;
+   struct config_file *conf = config_file_new_alloc();
+   if (!path || !*path)
+      return conf;
+   if ((ret = config_file_load_internal(conf, path, 0, cb)) == -1)
+   {
+      config_file_free(conf);
+      return NULL;
+   }
+   else if (ret == 1)
+   {
+      free(conf);
+      return NULL;
+   }
+   return conf;
 }
 
+/**
+ * config_file_new:
+ *
+ * Loads a config file.
+ * If @path is NULL, will create an empty config file.
+ *
+ * @return Returns NULL if file doesn't exist.
+ **/
 config_file_t *config_file_new(const char *path)
 {
-   return config_file_new_internal(path, 0, NULL);
+   int ret                  = 0;
+   struct config_file *conf = config_file_new_alloc();
+   if (!path || !*path)
+      return conf;
+   if ((ret = config_file_load_internal(conf, path, 0, NULL)) == -1)
+   {
+      config_file_free(conf);
+      return NULL;
+   }
+   else if (ret == 1)
+   {
+      free(conf);
+      return NULL;
+   }
+   return conf;
 }
 
-config_file_t *config_file_new_alloc(void)
+/**
+ * config_file_initialize:
+ *
+ * Leaf function.
+ **/
+void config_file_initialize(struct config_file *conf)
 {
-   struct config_file *conf = (struct config_file*)malloc(sizeof(*conf));
    if (!conf)
-      return NULL;
+      return;
 
    conf->path                     = NULL;
+   conf->entries_map              = NULL;
    conf->entries                  = NULL;
    conf->tail                     = NULL;
    conf->last                     = NULL;
+   conf->references               = NULL;
    conf->includes                 = NULL;
    conf->include_depth            = 0;
-   conf->guaranteed_no_duplicates = false ;
+   conf->guaranteed_no_duplicates = false;
+   conf->modified                 = false;
+}
 
+config_file_t *config_file_new_alloc(void)
+{
+   struct config_file *conf = (struct config_file*)malloc(sizeof(*conf));
+   if (!conf)
+      return NULL;
+   config_file_initialize(conf);
    return conf;
 }
 
-static struct config_entry_list *config_get_entry(
+/**
+ * config_get_entry_internal:
+ *
+ * Leaf function.
+ **/
+static struct config_entry_list *config_get_entry_internal(
       const config_file_t *conf,
       const char *key, struct config_entry_list **prev)
 {
-   struct config_entry_list *entry    = NULL;
-   struct config_entry_list *previous = prev ? *prev : NULL;
+   struct config_entry_list *entry = RHMAP_GET_STR(conf->entries_map, key);
 
-   for (entry = conf->entries; entry; entry = entry->next)
-   {
-      if (string_is_equal(key, entry->key))
-         return entry;
-
-      previous = entry;
-   }
+   if (entry)
+      return entry;
 
    if (prev)
+   {
+      struct config_entry_list *previous = *prev;
+      for (entry = conf->entries; entry; entry = entry->next)
+         previous = entry;
+
       *prev = previous;
+   }
 
    return NULL;
 }
 
+struct config_entry_list *config_get_entry(
+      const config_file_t *conf, const char *key)
+{
+   return RHMAP_GET_STR(conf->entries_map, key);
+}
+
+/**
+ * config_get_double:
+ *
+ * Extracts a double from config file.
+ *
+ * @return true if found, otherwise false.
+ **/
 bool config_get_double(config_file_t *conf, const char *key, double *in)
 {
-   const struct config_entry_list *entry = config_get_entry(conf, key, NULL);
+   const struct config_entry_list *entry = config_get_entry(conf, key);
 
    if (!entry)
       return false;
@@ -677,9 +997,16 @@ bool config_get_double(config_file_t *conf, const char *key, double *in)
    return true;
 }
 
+/**
+ * config_get_float:
+ *
+ * Extracts a float from config file.
+ *
+ * @return true if found, otherwise false.
+ **/
 bool config_get_float(config_file_t *conf, const char *key, float *in)
 {
-   const struct config_entry_list *entry = config_get_entry(conf, key, NULL);
+   const struct config_entry_list *entry = config_get_entry(conf, key);
 
    if (!entry)
       return false;
@@ -691,7 +1018,7 @@ bool config_get_float(config_file_t *conf, const char *key, float *in)
 
 bool config_get_int(config_file_t *conf, const char *key, int *in)
 {
-   const struct config_entry_list *entry = config_get_entry(conf, key, NULL);
+   const struct config_entry_list *entry = config_get_entry(conf, key);
    errno = 0;
 
    if (entry)
@@ -710,7 +1037,7 @@ bool config_get_int(config_file_t *conf, const char *key, int *in)
 
 bool config_get_size_t(config_file_t *conf, const char *key, size_t *in)
 {
-   const struct config_entry_list *entry = config_get_entry(conf, key, NULL);
+   const struct config_entry_list *entry = config_get_entry(conf, key);
    errno = 0;
 
    if (entry)
@@ -729,7 +1056,7 @@ bool config_get_size_t(config_file_t *conf, const char *key, size_t *in)
 #if defined(__STDC_VERSION__) && __STDC_VERSION__>=199901L
 bool config_get_uint64(config_file_t *conf, const char *key, uint64_t *in)
 {
-   const struct config_entry_list *entry = config_get_entry(conf, key, NULL);
+   const struct config_entry_list *entry = config_get_entry(conf, key);
    errno = 0;
 
    if (entry)
@@ -748,7 +1075,7 @@ bool config_get_uint64(config_file_t *conf, const char *key, uint64_t *in)
 
 bool config_get_uint(config_file_t *conf, const char *key, unsigned *in)
 {
-   const struct config_entry_list *entry = config_get_entry(conf, key, NULL);
+   const struct config_entry_list *entry = config_get_entry(conf, key);
    errno = 0;
 
    if (entry)
@@ -767,7 +1094,7 @@ bool config_get_uint(config_file_t *conf, const char *key, unsigned *in)
 
 bool config_get_hex(config_file_t *conf, const char *key, unsigned *in)
 {
-   const struct config_entry_list *entry = config_get_entry(conf, key, NULL);
+   const struct config_entry_list *entry = config_get_entry(conf, key);
    errno = 0;
 
    if (entry)
@@ -784,9 +1111,17 @@ bool config_get_hex(config_file_t *conf, const char *key, unsigned *in)
    return false;
 }
 
+/**
+ * config_get_char:
+ *
+ * Extracts a single char from config file.
+ * If value consists of several chars, this is an error.
+ *
+ * @return true if found, otherwise false.
+ **/
 bool config_get_char(config_file_t *conf, const char *key, char *in)
 {
-   const struct config_entry_list *entry = config_get_entry(conf, key, NULL);
+   const struct config_entry_list *entry = config_get_entry(conf, key);
 
    if (entry)
    {
@@ -800,29 +1135,42 @@ bool config_get_char(config_file_t *conf, const char *key, char *in)
    return false;
 }
 
+/**
+ * config_get_string:
+ *
+ * Extracts an allocated string in *in. This must be free()-d if
+ * this function succeeds.
+ *
+ * @return true if found, otherwise false.
+ **/
 bool config_get_string(config_file_t *conf, const char *key, char **str)
 {
-   const struct config_entry_list *entry = config_get_entry(conf, key, NULL);
+   const struct config_entry_list *entry = config_get_entry(conf, key);
 
-   if (!entry)
+   if (!entry || !entry->value)
       return false;
 
    *str = strdup(entry->value);
    return true;
 }
 
+/**
+  * config_get_config_path:
+  *
+  * Extracts a string to a preallocated buffer.
+  * Avoid memory allocation.
+  **/
 bool config_get_config_path(config_file_t *conf, char *s, size_t len)
 {
-   if (!conf)
-      return false;
-   return strlcpy(s, conf->path, len);
+   if (conf)
+      return strlcpy(s, conf->path, len);
+   return false;
 }
 
 bool config_get_array(config_file_t *conf, const char *key,
       char *buf, size_t size)
 {
-   const struct config_entry_list *entry = config_get_entry(conf, key, NULL);
-
+   const struct config_entry_list *entry = config_get_entry(conf, key);
    if (entry)
       return strlcpy(buf, entry->value, size) < size;
    return false;
@@ -835,8 +1183,7 @@ bool config_get_path(config_file_t *conf, const char *key,
    if (config_get_array(conf, key, buf, size))
       return true;
 #else
-   const struct config_entry_list *entry = config_get_entry(conf, key, NULL);
-
+   const struct config_entry_list *entry = config_get_entry(conf, key);
    if (entry)
    {
       fill_pathname_expand_special(buf, entry->value, size);
@@ -846,51 +1193,96 @@ bool config_get_path(config_file_t *conf, const char *key,
    return false;
 }
 
+/**
+ * config_get_bool:
+ * 
+ * Extracts a boolean from config.
+ * Valid boolean true are "true" and "1". Valid false are "false" and "0".
+ * Other values will be treated as an error.
+ *
+ * @return true if preconditions are true, otherwise false.
+ **/
 bool config_get_bool(config_file_t *conf, const char *key, bool *in)
 {
-   const struct config_entry_list *entry = config_get_entry(conf, key, NULL);
+   const struct config_entry_list *entry = config_get_entry(conf, key);
 
-   if (entry)
-   {
-      if (string_is_equal(entry->value, "true"))
-         *in = true;
-      else if (string_is_equal(entry->value, "1"))
-         *in = true;
-      else if (string_is_equal(entry->value, "false"))
-         *in = false;
-      else if (string_is_equal(entry->value, "0"))
-         *in = false;
-      else
-         return false;
-   }
+   if (!entry)
+      return false;
+
+   if      (
+         (
+            entry->value[0] == '1'
+         && entry->value[1] == '\0'
+         )
+         || string_is_equal(entry->value, "true")
+         )
+      *in = true;
+   else if (
+         (
+            entry->value[0] == '0'
+         && entry->value[1] == '\0'
+         )
+         || string_is_equal(entry->value, "false")
+         )
+      *in = false;
+   else
+      return false;
 
-   return entry != NULL;
+   return true;
 }
 
 void config_set_string(config_file_t *conf, const char *key, const char *val)
 {
-   struct config_entry_list *last  = (conf->guaranteed_no_duplicates && conf->last) ? conf->last : conf->entries;
-   struct config_entry_list *entry = conf->guaranteed_no_duplicates?NULL:config_get_entry(conf, key, &last);
+   struct config_entry_list *last  = NULL;
+   struct config_entry_list *entry = NULL;
 
-   if (entry && !entry->readonly)
-   {
-      if (entry->value)
-         free(entry->value);
-      entry->value = strdup(val);
+   if (!conf || !key || !val)
       return;
+
+   last                            = conf->entries;
+
+   if (conf->guaranteed_no_duplicates)
+   {
+      if (conf->last)
+         last                      = conf->last;
    }
+   else
+   {
+      if ((entry = config_get_entry_internal(conf, key, &last)))
+      {
+         /* An entry corresponding to 'key' already exists
+          * > Check whether value is currently set */
+         if (entry->value)
+         {
+            /* Do nothing if value is unchanged */
+            if (string_is_equal(entry->value, val))
+               return;
 
-   if (!val)
-      return;
+            /* Value is to be updated
+             * > Free existing */
+            free(entry->value);
+         }
 
-   entry = (struct config_entry_list*)malloc(sizeof(*entry));
-   if (!entry)
+         /* Update value
+          * > Note that once a value is set, it
+          *   is no longer considered 'read only' */
+         entry->value    = strdup(val);
+         entry->readonly = false;
+         conf->modified  = true;
+         return;
+      }
+   }
+
+   /* Entry corresponding to 'key' does not exist
+    * > Create new entry */
+   if (!(entry = (struct config_entry_list*)malloc(sizeof(*entry))))
       return;
 
    entry->readonly  = false;
    entry->key       = strdup(key);
    entry->value     = strdup(val);
    entry->next      = NULL;
+   conf->modified   = true;
 
    if (last)
       last->next    = entry;
@@ -898,20 +1290,34 @@ void config_set_string(config_file_t *conf, const char *key, const char *val)
       conf->entries = entry;
 
    conf->last       = entry;
+
+   RHMAP_SET_STR(conf->entries_map, entry->key, entry);
 }
 
 void config_unset(config_file_t *conf, const char *key)
 {
-   struct config_entry_list *last  = conf->entries;
-   struct config_entry_list *entry = config_get_entry(conf, key, &last);
+   struct config_entry_list *last  = NULL;
+   struct config_entry_list *entry = NULL;
 
-   if (!entry)
+   if (!conf || !key)
+      return;
+
+   last  = conf->entries;
+
+   if (!(entry = config_get_entry_internal(conf, key, &last)))
       return;
 
-   entry->key   = NULL;
-   entry->value = NULL;
-   free(entry->key);
-   free(entry->value);
+   (void)RHMAP_DEL_STR(conf->entries_map, entry->key);
+
+   if (entry->key)
+      free(entry->key);
+
+   if (entry->value)
+      free(entry->value);
+
+   entry->key     = NULL;
+   entry->value   = NULL;
+   conf->modified = true;
 }
 
 void config_set_path(config_file_t *conf, const char *entry, const char *val)
@@ -920,166 +1326,136 @@ void config_set_path(config_file_t *conf, const char *entry, const char *val)
    config_set_string(conf, entry, val);
 #else
    char buf[PATH_MAX_LENGTH];
-
-   buf[0] = '\0';
    fill_pathname_abbreviate_special(buf, val, sizeof(buf));
    config_set_string(conf, entry, buf);
 #endif
 }
 
-void config_set_double(config_file_t *conf, const char *key, double val)
+size_t config_set_double(config_file_t *conf, const char *key, double val)
 {
-   char buf[128];
-
-   buf[0] = '\0';
+   char buf[320];
 #ifdef __cplusplus
-   snprintf(buf, sizeof(buf), "%f", (float)val);
+   size_t len = snprintf(buf, sizeof(buf), "%f", (float)val);
 #elif defined(__STDC_VERSION__) && __STDC_VERSION__>=199901L
-   snprintf(buf, sizeof(buf), "%lf", val);
+   size_t len = snprintf(buf, sizeof(buf), "%lf", val);
 #else
-   snprintf(buf, sizeof(buf), "%f", (float)val);
+   size_t len = snprintf(buf, sizeof(buf), "%f", (float)val);
 #endif
    config_set_string(conf, key, buf);
+   return len;
 }
 
-void config_set_float(config_file_t *conf, const char *key, float val)
+size_t config_set_float(config_file_t *conf, const char *key, float val)
 {
-   char buf[128];
-
-   buf[0] = '\0';
-   snprintf(buf, sizeof(buf), "%f", val);
+   char buf[64];
+   size_t len = snprintf(buf, sizeof(buf), "%f", val);
    config_set_string(conf, key, buf);
+   return len;
 }
 
-void config_set_int(config_file_t *conf, const char *key, int val)
+size_t config_set_int(config_file_t *conf, const char *key, int val)
 {
-   char buf[128];
-
-   buf[0] = '\0';
-   snprintf(buf, sizeof(buf), "%d", val);
+   char buf[16];
+   size_t len = snprintf(buf, sizeof(buf), "%d", val);
    config_set_string(conf, key, buf);
+   return len;
 }
 
-void config_set_uint(config_file_t *conf, const char *key, unsigned int val)
+size_t config_set_uint(config_file_t *conf, const char *key, unsigned int val)
 {
-   char buf[128];
-
-   buf[0] = '\0';
-   snprintf(buf, sizeof(buf), "%u", val);
+   char buf[16];
+   size_t len = snprintf(buf, sizeof(buf), "%u", val);
    config_set_string(conf, key, buf);
+   return len;
 }
 
-void config_set_hex(config_file_t *conf, const char *key, unsigned val)
+size_t config_set_hex(config_file_t *conf, const char *key, unsigned val)
 {
-   char buf[128];
-
-   buf[0] = '\0';
-   snprintf(buf, sizeof(buf), "%x", val);
+   char buf[16];
+   size_t len = snprintf(buf, sizeof(buf), "%x", val);
    config_set_string(conf, key, buf);
+   return len;
 }
 
-void config_set_uint64(config_file_t *conf, const char *key, uint64_t val)
+size_t config_set_uint64(config_file_t *conf, const char *key, uint64_t val)
 {
-   char buf[128];
-
-   buf[0] = '\0';
-   snprintf(buf, sizeof(buf), "%" PRIu64, val);
+   char buf[32];
+   size_t len = snprintf(buf, sizeof(buf), "%" PRIu64, val);
    config_set_string(conf, key, buf);
+   return len;
 }
 
-void config_set_char(config_file_t *conf, const char *key, char val)
+size_t config_set_char(config_file_t *conf, const char *key, char val)
 {
    char buf[2];
-
-   buf[0] = '\0';
-   snprintf(buf, sizeof(buf), "%c", val);
+   size_t len = snprintf(buf, sizeof(buf), "%c", val);
    config_set_string(conf, key, buf);
+   return len;
 }
 
-void config_set_bool(config_file_t *conf, const char *key, bool val)
-{
-   config_set_string(conf, key, val ? "true" : "false");
-}
-
+/**
+ * config_file_write:
+ *
+ * Write the current config to a file.
+ **/
 bool config_file_write(config_file_t *conf, const char *path, bool sort)
 {
-   if (!string_is_empty(path))
-   {
-#ifdef ORBIS
-      int fd     = orbisOpen(path,O_RDWR|O_CREAT,0644);
-      if (fd < 0)
-         return false;
-      config_file_dump_orbis(conf,fd);
-      orbisClose(fd);
-#else
-      void* buf  = NULL;
-      FILE *file = (FILE*)fopen_utf8(path, "wb");
-      if (!file)
-         return false;
-
-      /* TODO: this is only useful for a few platforms, find which and add ifdef */
-#if !defined(PS2) && !defined(PSP)
-      buf = calloc(1, 0x4000);
-      setvbuf(file, (char*)buf, _IOFBF, 0x4000);
-#endif
-
-      config_file_dump(conf, file, sort);
+   if (!conf)
+      return false;
 
-      if (file != stdout)
-         fclose(file);
-      if (buf)
-         free(buf);
-#endif
-   }
-   else
-      config_file_dump(conf, stdout, sort);
+   if (conf->modified)
+   {
+      if (string_is_empty(path))
+         config_file_dump(conf, stdout, sort);
+      else
+      {
+         void* buf  = NULL;
+         FILE *file = (FILE*)fopen_utf8(path, "wb");
+         if (!file)
+            return false;
 
-   return true;
-}
+         buf        = calloc(1, 0x4000);
+         setvbuf(file, (char*)buf, _IOFBF, 0x4000);
 
-#ifdef ORBIS
-void config_file_dump_orbis(config_file_t *conf, int fd)
-{
-   struct config_entry_list       *list = NULL;
-   struct config_include_list *includes = conf->includes;
-   while (includes)
-   {
-      char cad[256];
-      sprintf(cad,"#include %s\n", includes->path);
-      orbisWrite(fd, cad, strlen(cad));
-      includes = includes->next;
-   }
+         config_file_dump(conf, file, sort);
 
-   list = merge_sort_linked_list((struct config_entry_list*)conf->entries, config_sort_compare_func);
-   conf->entries = list;
+         if (file != stdout)
+            fclose(file);
+         if (buf)
+            free(buf);
 
-   while (list)
-   {
-      if (!list->readonly && list->key)
-      {
-         char newlist[256];
-         sprintf(newlist,"%s = %s\n", list->key, list->value);
-         orbisWrite(fd, newlist, strlen(newlist));
+         /* Only update modified flag if config file
+          * is actually written to disk */
+         conf->modified = false;
       }
-      list = list->next;
    }
+
+   return true;
 }
-#endif
 
+/**
+ * config_file_dump:
+ *
+ * Dump the current config to an already opened file.
+ * Does not close the file.
+ **/
 void config_file_dump(config_file_t *conf, FILE *file, bool sort)
 {
    struct config_entry_list       *list = NULL;
    struct config_include_list *includes = conf->includes;
+   struct path_linked_list *ref_tmp = conf->references;
 
-   while (includes)
+   while (ref_tmp)
    {
-      fprintf(file, "#include \"%s\"\n", includes->path);
-      includes = includes->next;
+      pathname_make_slashes_portable(ref_tmp->path);
+      fprintf(file, "#reference \"%s\"\n", ref_tmp->path);
+      ref_tmp = ref_tmp->next;
    }
 
    if (sort)
-      list = merge_sort_linked_list((struct config_entry_list*)
-            conf->entries, config_sort_compare_func);
+      list = config_file_merge_sort_linked_list(
+            (struct config_entry_list*)conf->entries,
+            config_file_sort_compare_func);
    else
       list = (struct config_entry_list*)conf->entries;
 
@@ -1091,22 +1467,25 @@ void config_file_dump(config_file_t *conf, FILE *file, bool sort)
          fprintf(file, "%s = \"%s\"\n", list->key, list->value);
       list = list->next;
    }
-}
-
-bool config_entry_exists(config_file_t *conf, const char *entry)
-{
-   struct config_entry_list *list = conf->entries;
 
-   while (list)
+   /* Config files are read from the top down - if
+    * duplicate entries are found then the topmost
+    * one in the list takes precedence. This means
+    * '#include' directives must go *after* individual
+    * config entries, otherwise they will override
+    * any custom-set values */
+   while (includes)
    {
-      if (string_is_equal(entry, list->key))
-         return true;
-      list = list->next;
+      fprintf(file, "#include \"%s\"\n", includes->path);
+      includes = includes->next;
    }
-
-   return false;
 }
 
+/**
+ * config_get_entry_list_head:
+ *
+ * Leaf function.
+ **/
 bool config_get_entry_list_head(config_file_t *conf,
       struct config_file_entry *entry)
 {
@@ -1121,6 +1500,11 @@ bool config_get_entry_list_head(config_file_t *conf,
    return true;
 }
 
+/**
+ * config_get_entry_list_next:
+ *
+ * Leaf function.
+ **/
 bool config_get_entry_list_next(struct config_file_entry *entry)
 {
    const struct config_entry_list *next = entry->next;
@@ -1133,73 +1517,3 @@ bool config_get_entry_list_next(struct config_file_entry *entry)
    entry->next  = next->next;
    return true;
 }
-
-bool config_file_exists(const char *path)
-{
-   config_file_t *config = config_file_new(path);
-   if (!config)
-      return false;
-
-   config_file_free(config);
-   return true;
-}
-
-#if 0
-static void test_config_file_parse_contains(
-      const char * cfgtext,
-      const char *key, const char *val)
-{
-   config_file_t *cfg = config_file_new_from_string(cfgtext, NULL);
-   char          *out = NULL;
-   bool            ok = false;
-
-   if (!cfg)
-      abort();
-
-   ok = config_get_string(cfg, key, &out);
-   if (ok != (bool)val)
-      abort();
-   if (!val)
-      return;
-
-   if (out == NULL)
-      out = strdup("");
-   if (strcmp(out, val) != 0)
-      abort();
-   free(out);
-}
-
-static void test_config_file(void)
-{
-   test_config_file_parse_contains("foo = \"bar\"\n",   "foo", "bar");
-   test_config_file_parse_contains("foo = \"bar\"",     "foo", "bar");
-   test_config_file_parse_contains("foo = \"bar\"\r\n", "foo", "bar");
-   test_config_file_parse_contains("foo = \"bar\"",     "foo", "bar");
-
-#if 0
-   /* turns out it treats empty as nonexistent -
-    * should probably be fixed */
-   test_config_file_parse_contains("foo = \"\"\n",   "foo", "");
-   test_config_file_parse_contains("foo = \"\"",     "foo", "");
-   test_config_file_parse_contains("foo = \"\"\r\n", "foo", "");
-   test_config_file_parse_contains("foo = \"\"",     "foo", "");
-#endif
-
-   test_config_file_parse_contains("foo = \"\"\n",   "bar", NULL);
-   test_config_file_parse_contains("foo = \"\"",     "bar", NULL);
-   test_config_file_parse_contains("foo = \"\"\r\n", "bar", NULL);
-   test_config_file_parse_contains("foo = \"\"",     "bar", NULL);
-}
-
-/* compile with:
- gcc config_file.c -g -I ../include/ \
- ../streams/file_stream.c ../vfs/vfs_implementation.c ../lists/string_list.c \
- ../compat/compat_strl.c file_path.c ../compat/compat_strcasestr.c \
- && ./a.out
-*/
-
-int main(void)
-{
-	test_config_file();
-}
-#endif
diff --git a/src/libretro/libretro-common/file/config_file_userdata.c b/src/libretro/libretro-common/file/config_file_userdata.c
index e91fb8b04e..799ce5f2a4 100644
--- a/src/libretro/libretro-common/file/config_file_userdata.c
+++ b/src/libretro/libretro-common/file/config_file_userdata.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (config_file_userdata.c).
@@ -61,6 +61,24 @@ int config_userdata_get_int(void *userdata, const char *key_str,
    return got;
 }
 
+int config_userdata_get_hex(void *userdata, const char *key_str,
+      unsigned *value, unsigned default_value)
+{
+   bool got;
+   char key[2][256];
+   struct config_file_userdata *usr = (struct config_file_userdata*)userdata;
+
+   fill_pathname_join_delim(key[0], usr->prefix[0], key_str, '_', sizeof(key[0]));
+   fill_pathname_join_delim(key[1], usr->prefix[1], key_str, '_', sizeof(key[1]));
+
+   got = config_get_hex(usr->conf, key[0], value);
+   got = got || config_get_hex(usr->conf, key[1], value);
+
+   if (!got)
+      *value = default_value;
+   return got;
+}
+
 int config_userdata_get_float_array(void *userdata, const char *key_str,
       float **values, unsigned *out_num_values,
       const float *default_values, unsigned num_default_values)
@@ -76,12 +94,14 @@ int config_userdata_get_float_array(void *userdata, const char *key_str,
          config_get_string(usr->conf, key[1], &str))
    {
       unsigned i;
-      struct string_list *list = string_split(str, " ");
-      *values = (float*)calloc(list->size, sizeof(float));
-      for (i = 0; i < list->size; i++)
-         (*values)[i] = (float)strtod(list->elems[i].data, NULL);
-      *out_num_values = (unsigned)list->size;
-      string_list_free(list);
+      struct string_list list = {0};
+      string_list_initialize(&list);
+      string_split_noalloc(&list, str, " ");
+      *values = (float*)calloc(list.size, sizeof(float));
+      for (i = 0; i < list.size; i++)
+         (*values)[i] = (float)strtod(list.elems[i].data, NULL);
+      *out_num_values = (unsigned)list.size;
+      string_list_deinitialize(&list);
       free(str);
       return true;
    }
@@ -106,12 +126,14 @@ int config_userdata_get_int_array(void *userdata, const char *key_str,
          config_get_string(usr->conf, key[1], &str))
    {
       unsigned i;
-      struct string_list *list = string_split(str, " ");
-      *values = (int*)calloc(list->size, sizeof(int));
-      for (i = 0; i < list->size; i++)
-         (*values)[i] = (int)strtod(list->elems[i].data, NULL);
-      *out_num_values = (unsigned)list->size;
-      string_list_free(list);
+      struct string_list list = {0};
+      string_list_initialize(&list);
+      string_split_noalloc(&list, str, " ");
+      *values = (int*)calloc(list.size, sizeof(int));
+      for (i = 0; i < list.size; i++)
+         (*values)[i] = (int)strtod(list.elems[i].data, NULL);
+      *out_num_values = (unsigned)list.size;
+      string_list_deinitialize(&list);
       free(str);
       return true;
    }
diff --git a/src/libretro/libretro-common/file/file_path.c b/src/libretro/libretro-common/file/file_path.c
index 65b8f5b944..c696ff0456 100644
--- a/src/libretro/libretro-common/file/file_path.c
+++ b/src/libretro/libretro-common/file/file_path.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2019 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (file_path.c).
@@ -24,16 +24,15 @@
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
-#include <errno.h>
+#include <locale.h>
 
 #include <sys/stat.h>
 
 #include <boolean.h>
 #include <file/file_path.h>
-#include <retro_assert.h>
+#include <retro_miscellaneous.h>
 #include <string/stdstring.h>
-#define VFS_FRONTEND
-#include <vfs/vfs_implementation.h>
+#include <time/rtime.h>
 
 /* TODO: There are probably some unnecessary things on this huge include list now but I'm too afraid to touch it */
 #ifdef __APPLE__
@@ -46,56 +45,12 @@
 #include <compat/strl.h>
 #include <compat/posix_string.h>
 #endif
-#include <compat/strcasestr.h>
 #include <retro_miscellaneous.h>
 #include <encodings/utf.h>
 
-#if defined(_WIN32)
-#ifdef _MSC_VER
-#define setmode _setmode
-#endif
-#include <sys/stat.h>
-#ifdef _XBOX
-#include <xtl.h>
-#define INVALID_FILE_ATTRIBUTES -1
-#else
-#include <io.h>
-#include <fcntl.h>
+#ifdef _WIN32
 #include <direct.h>
-#include <windows.h>
-#if defined(_MSC_VER) && _MSC_VER <= 1200
-#define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
-#endif
-#endif
-#elif defined(VITA)
-#define SCE_ERROR_ERRNO_EEXIST 0x80010011
-#include <psp2/io/fcntl.h>
-#include <psp2/io/dirent.h>
-#include <psp2/io/stat.h>
 #else
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <unistd.h>
-#endif
-
-#if defined(PSP)
-#include <pspkernel.h>
-#endif
-
-#if defined(PS2)
-#include <fileXio_rpc.h>
-#include <fileXio.h>
-#endif
-
-#if defined(__CELLOS_LV2__)
-#include <cell/cell_fs.h>
-#endif
-
-#if defined(VITA)
-#define FIO_S_ISDIR SCE_S_ISDIR
-#endif
-
-#if (defined(__CELLOS_LV2__) && !defined(__PSL1GHT__)) || defined(__QNX__) || defined(PSP) || defined(PS2)
 #include <unistd.h> /* stat() is defined here */
 #endif
 
@@ -114,131 +69,101 @@
 
 #endif
 
-static retro_vfs_stat_t path_stat_cb   = retro_vfs_stat_impl;
-static retro_vfs_mkdir_t path_mkdir_cb = retro_vfs_mkdir_impl;
-
-void path_vfs_init(const struct retro_vfs_interface_info* vfs_info)
+/* Time format strings with AM-PM designation require special
+ * handling due to platform dependence */
+void strftime_am_pm(char *s, size_t len, const char* format,
+      const void *ptr)
 {
-   const struct retro_vfs_interface* 
-      vfs_iface           = vfs_info->iface;
+   char *local = NULL;
+   const struct tm *timeptr = (const struct tm*)ptr;
 
-   path_stat_cb           = retro_vfs_stat_impl;
-   path_mkdir_cb          = retro_vfs_mkdir_impl;
-
-   if (vfs_info->required_interface_version < PATH_REQUIRED_VFS_VERSION || !vfs_iface)
-      return;
+   /* Ensure correct locale is set
+    * > Required for localised AM/PM strings */
+   setlocale(LC_TIME, "");
 
-   path_stat_cb           = vfs_iface->stat;
-   path_mkdir_cb          = vfs_iface->mkdir;
-}
+   strftime(s, len, format, timeptr);
+#if !(defined(__linux__) && !defined(ANDROID))
+   if ((local = local_to_utf8_string_alloc(s)))
+   {
+      if (!string_is_empty(local))
+         strlcpy(s, local, len);
 
-int path_stat(const char *path)
-{
-   return path_stat_cb(path, NULL);
+      free(local);
+      local = NULL;
+   }
+#endif
 }
 
 /**
- * path_is_directory:
- * @path               : path
- *
- * Checks if path is a directory.
- *
- * Returns: true (1) if path is a directory, otherwise false (0).
- */
-bool path_is_directory(const char *path)
+ * Create a new linked list with one node in it
+ * The path on this node will be set to NULL
+**/
+struct path_linked_list* path_linked_list_new(void)
 {
-   return (path_stat_cb(path, NULL) & RETRO_VFS_STAT_IS_DIRECTORY) != 0;
-}
-
-bool path_is_character_special(const char *path)
-{
-   return (path_stat_cb(path, NULL) & RETRO_VFS_STAT_IS_CHARACTER_SPECIAL) != 0;
-}
-
-bool path_is_valid(const char *path)
-{
-   return (path_stat_cb(path, NULL) & RETRO_VFS_STAT_IS_VALID) != 0;
-}
-
-int32_t path_get_size(const char *path)
-{
-   int32_t filesize = 0;
-   if (path_stat_cb(path, &filesize) != 0)
-      return filesize;
-
-   return -1;
+   struct path_linked_list* paths_list = (struct path_linked_list*)malloc(sizeof(*paths_list));
+   paths_list->next = NULL;
+   paths_list->path = NULL;
+   return paths_list;
 }
 
 /**
- * path_mkdir:
- * @dir                : directory
- *
- * Create directory on filesystem.
+ * path_linked_list_free:
  *
- * Returns: true (1) if directory could be created, otherwise false (0).
+ * Free the entire linked list
  **/
-bool path_mkdir(const char *dir)
+void path_linked_list_free(struct path_linked_list *in_path_linked_list)
 {
-   bool         sret  = false;
-   bool norecurse     = false;
-   char     *basedir  = NULL;
-
-   if (!(dir && *dir))
-      return false;
-
-   /* Use heap. Real chance of stack 
-    * overflow if we recurse too hard. */
-   basedir            = strdup(dir);
-
-   if (!basedir)
-	   return false;
-
-   path_parent_dir(basedir);
-
-   if (!*basedir || !strcmp(basedir, dir))
+   struct path_linked_list *node_tmp = (struct path_linked_list*)in_path_linked_list;
+   while (node_tmp)
    {
-      free(basedir);
-      return false;
+      struct path_linked_list *hold = NULL;
+      if (node_tmp->path)
+         free(node_tmp->path);
+      hold     = (struct path_linked_list*)node_tmp;
+      node_tmp = node_tmp->next;
+      if (hold)
+         free(hold);
    }
+}
 
-#if defined(GEKKO)
-   {
-      size_t len = strlen(basedir);
-
-      /* path_parent_dir() keeps the trailing slash.
-       * On Wii, mkdir() fails if the path has a
-       * trailing slash...
-       * We must therefore remove it. */
-      if (len > 0)
-         if (basedir[len - 1] == '/')
-            basedir[len - 1] = '\0';
-   }
-#endif
-
-   if (path_is_directory(basedir))
-      norecurse = true;
+/**
+ * path_linked_list_add_path:
+ *
+ * Add a node to the linked list with this path
+ * If the first node's path if it's not yet set the path
+ * on this node instead
+**/
+void path_linked_list_add_path(struct path_linked_list *in_path_linked_list,
+      char *path)
+{
+    /* If the first item does not have a path this is
+      a list which has just been created, so we just fill 
+      the path for the first item
+   */
+   if (!in_path_linked_list->path)
+      in_path_linked_list->path = strdup(path);
    else
-   {
-      sret      = path_mkdir(basedir);
-
-      if (sret)
-         norecurse = true;
-   }
+   {  
+      struct path_linked_list *node = (struct path_linked_list*) malloc(sizeof(*node));
 
-   free(basedir);
+      if (node)
+      {
+         struct path_linked_list *head = in_path_linked_list;
 
-   if (norecurse)
-   {
-      int ret = path_mkdir_cb(dir);
+         node->next                    = NULL;
+         node->path                    = strdup(path);
 
-      /* Don't treat this as an error. */
-      if (ret == -2 && path_is_directory(dir))
-         return true;
+         if (head)
+         {
+            while (head->next)
+               head        = head->next;
 
-      return (ret == 0);
+            head->next     = node;
+         }
+         else
+            in_path_linked_list = node;
+      }
    }
-
-   return sret;
 }
 
 /**
@@ -248,31 +173,51 @@ bool path_mkdir(const char *dir)
  * Find delimiter of an archive file. Only the first '#'
  * after a compression extension is considered.
  *
- * Returns: pointer to the delimiter in the path if it contains
+ * @return pointer to the delimiter in the path if it contains
  * a path inside a compressed file, otherwise NULL.
- */
+ **/
 const char *path_get_archive_delim(const char *path)
 {
-   const char *last  = find_last_slash(path);
-   const char *delim = NULL;
-
-   if (!last)
-      return NULL;
+   char buf[5];
+   /* Find delimiter position
+    * > Since filenames may contain '#' characters,
+    *   must loop until we find the first '#' that
+    *   is directly *after* a compression extension */
+   const char *delim      = strchr(path, '#');
+
+   while (delim)
+   {
+      /* Check whether this is a known archive type
+       * > Note: The code duplication here is
+       *   deliberate, to maximise performance */
+      if (delim - path > 4)
+      {
+         strlcpy(buf, delim - 4, sizeof(buf));
+         buf[4] = '\0';
 
-   /* Test if it's .zip */
-   delim = strcasestr(last, ".zip#");
+         string_to_lower(buf);
 
-   if (!delim) /* If it's not a .zip, test if it's .apk */
-      delim = strcasestr(last, ".apk#");
+         /* Check if this is a '.zip', '.apk' or '.7z' file */
+         if (   string_is_equal(buf,     ".zip")
+             || string_is_equal(buf,     ".apk")
+             || string_is_equal(buf + 1, ".7z"))
+            return delim;
+      }
+      else if (delim - path > 3)
+      {
+         strlcpy(buf, delim - 3, sizeof(buf));
+         buf[3] = '\0';
 
-   if (delim)
-      return delim + 4;
+         string_to_lower(buf);
 
-   /* If it's not a .zip or .apk file, test if it's .7z */
-   delim = strcasestr(last, ".7z#");
+         /* Check if this is a '.7z' file */
+         if (string_is_equal(buf, ".7z"))
+            return delim;
+      }
 
-   if (delim)
-      return delim + 3;
+      delim++;
+      delim = strchr(delim, '#');
+   }
 
    return NULL;
 }
@@ -284,16 +229,36 @@ const char *path_get_archive_delim(const char *path)
  * Gets extension of file. Only '.'s
  * after the last slash are considered.
  *
- * Returns: extension part from the path.
- */
+ * @return extension part from the path.
+ **/
 const char *path_get_extension(const char *path)
 {
    const char *ext;
-   if (!string_is_empty(path) && ((ext = strrchr(path_basename(path), '.'))))
+   if (!string_is_empty(path) && ((ext = (char*)strrchr(path_basename(path), '.'))))
       return ext + 1;
    return "";
 }
 
+/**
+ * path_get_extension_mutable:
+ * @path               : path
+ *
+ * Specialized version of path_get_extension(). Return
+ * value is mutable.
+ *
+ * Gets extension of file. Only '.'s
+ * after the last slash are considered.
+ *
+ * @return extension part from the path.
+ **/
+char *path_get_extension_mutable(const char *path)
+{
+   char *ext = NULL;
+   if (!string_is_empty(path) && ((ext = (char*)strrchr(path_basename(path), '.'))))
+      return ext;
+   return NULL;
+}
+
 /**
  * path_remove_extension:
  * @path               : path
@@ -302,12 +267,12 @@ const char *path_get_extension(const char *path)
  * text after and including the last '.'.
  * Only '.'s after the last slash are considered.
  *
- * Returns:
+ * @return
  * 1) If path has an extension, returns path with the
  *    extension removed.
  * 2) If there is no extension, returns NULL.
  * 3) If path is empty or NULL, returns NULL
- */
+ **/
 char *path_remove_extension(char *path)
 {
    char *last = !string_is_empty(path)
@@ -325,17 +290,15 @@ char *path_remove_extension(char *path)
  *
  * Checks if path is a compressed file.
  *
- * Returns: true (1) if path is a compressed file, otherwise false (0).
+ * @return true if path is a compressed file, otherwise false.
  **/
 bool path_is_compressed_file(const char* path)
 {
    const char *ext = path_get_extension(path);
-
-   if (     strcasestr(ext, "zip")
-         || strcasestr(ext, "apk")
-         || strcasestr(ext, "7z"))
-      return true;
-
+   if (!string_is_empty(ext))
+      return (   string_is_equal_noncase(ext, "zip")
+              || string_is_equal_noncase(ext, "apk")
+              || string_is_equal_noncase(ext, "7z"));
    return false;
 }
 
@@ -359,53 +322,45 @@ bool path_is_compressed_file(const char* path)
  * out_path = "/foo/bar/baz/boo.asm"
  * E.g.: in_path = "/foo/bar/baz/boo.c", replace = ""     =>
  * out_path = "/foo/bar/baz/boo"
+ *
+ * @return Length of the string copied into @out
  */
-void fill_pathname(char *out_path, const char *in_path,
+size_t fill_pathname(char *out_path, const char *in_path,
       const char *replace, size_t size)
 {
+   size_t _len;
    char tmp_path[PATH_MAX_LENGTH];
-   char *tok                      = NULL;
-
-   tmp_path[0] = '\0';
-
+   char *tok   = NULL;
    strlcpy(tmp_path, in_path, sizeof(tmp_path));
    if ((tok = (char*)strrchr(path_basename(tmp_path), '.')))
       *tok = '\0';
 
-   fill_pathname_noext(out_path, tmp_path, replace, size);
+   _len  = strlcpy(out_path, tmp_path, size);
+   _len += strlcpy(out_path + _len, replace, size - _len);
+   return _len;
 }
 
+
 /**
- * fill_pathname_noext:
- * @out_path           : output path
- * @in_path            : input  path
- * @replace            : what to replace
- * @size               : buffer size of output path
- *
- * Appends a filename extension 'replace' to 'in_path', and outputs
- * result in 'out_path'.
- *
- * Assumes in_path has no extension. If an extension is still
- * present in 'in_path', it will be ignored.
+ * find_last_slash:
+ * @str                : path
+ * @size               : size of path
  *
- */
-size_t fill_pathname_noext(char *out_path, const char *in_path,
-      const char *replace, size_t size)
-{
-   strlcpy(out_path, in_path, size);
-   return strlcat(out_path, replace, size);
-}
+ * Find last slash in path. Tries to find
+ * a backslash as used for Windows paths,
+ * otherwise checks for a regular slash.
 
+ * @return pointer to last slash/backslash found in @str.
+ **/
 char *find_last_slash(const char *str)
 {
    const char *slash     = strrchr(str, '/');
-#ifdef _WIN32
    const char *backslash = strrchr(str, '\\');
 
    if (!slash || (backslash > slash))
       return (char*)backslash;
-#endif
-   return (char*)slash;
+   else
+      return (char*)slash;
 }
 
 /**
@@ -416,24 +371,20 @@ char *find_last_slash(const char *str)
  * Assumes path is a directory. Appends a slash
  * if not already there.
  **/
-void fill_pathname_slash(char *path, size_t size)
+size_t fill_pathname_slash(char *path, size_t size)
 {
    size_t path_len;
    const char *last_slash = find_last_slash(path);
-
    if (!last_slash)
-   {
-      strlcat(path, path_default_slash(), size);
-      return;
-   }
-
-   path_len               = strlen(path);
+      return strlcat(path, PATH_DEFAULT_SLASH(), size);
+   path_len            = strlen(path);
    /* Try to preserve slash type. */
    if (last_slash != (path + path_len - 1))
    {
-      path[path_len]   = last_slash[0];
-      path[path_len+1] = '\0';
+      path[  path_len] = last_slash[0];
+      path[++path_len] = '\0';
    }
+   return path_len;
 }
 
 /**
@@ -456,12 +407,11 @@ void fill_pathname_slash(char *path, size_t size)
 size_t fill_pathname_dir(char *in_dir, const char *in_basename,
       const char *replace, size_t size)
 {
-   const char *base = NULL;
-
-   fill_pathname_slash(in_dir, size);
-   base = path_basename(in_basename);
-   strlcat(in_dir, base, size);
-   return strlcat(in_dir, replace, size);
+   size_t _len      = fill_pathname_slash(in_dir, size);
+   const char *base = path_basename(in_basename);
+   _len            += strlcpy(in_dir + _len, base,    size - _len);
+   _len            += strlcpy(in_dir + _len, replace, size - _len);
+   return _len;
 }
 
 /**
@@ -471,30 +421,15 @@ size_t fill_pathname_dir(char *in_dir, const char *in_basename,
  * @size               : size of output path
  *
  * Copies basename of @in_path into @out_path.
+ *
+ * @return Length of the string copied into @out
  **/
 size_t fill_pathname_base(char *out, const char *in_path, size_t size)
 {
    const char     *ptr = path_basename(in_path);
-
-   if (!ptr)
-      ptr = in_path;
-
-   return strlcpy(out, ptr, size);
-}
-
-void fill_pathname_base_noext(char *out,
-      const char *in_path, size_t size)
-{
-   fill_pathname_base(out, in_path, size);
-   path_remove_extension(out);
-}
-
-size_t fill_pathname_base_ext(char *out,
-      const char *in_path, const char *ext,
-      size_t size)
-{
-   fill_pathname_base_noext(out, in_path, size);
-   return strlcat(out, ext, size);
+   if (ptr)
+      return strlcpy(out, ptr, size);
+   return strlcpy(out, in_path, size);
 }
 
 /**
@@ -515,13 +450,6 @@ void fill_pathname_basedir(char *out_dir,
    path_basedir(out_dir);
 }
 
-void fill_pathname_basedir_noext(char *out_dir,
-      const char *in_path, size_t size)
-{
-   fill_pathname_basedir(out_dir, in_path, size);
-   path_remove_extension(out_dir);
-}
-
 /**
  * fill_pathname_parent_dir_name:
  * @out_dir            : output directory
@@ -530,12 +458,12 @@ void fill_pathname_basedir_noext(char *out_dir,
  *
  * Copies only the parent directory name of @in_dir into @out_dir.
  * The two buffers must not overlap. Removes trailing '/'.
- * Returns true on success, false if a slash was not found in the path.
+ *
+ * @return true on success, false if a slash was not found in the path.
  **/
 bool fill_pathname_parent_dir_name(char *out_dir,
       const char *in_dir, size_t size)
 {
-   bool success = false;
    char *temp   = strdup(in_dir);
    char *last   = find_last_slash(temp);
 
@@ -545,18 +473,30 @@ bool fill_pathname_parent_dir_name(char *out_dir,
       last      = find_last_slash(temp);
    }
 
+   /* Cut the last part of the string (the filename) after the slash,
+      leaving the directory name (or nested directory names) only. */
    if (last)
       *last     = '\0';
 
-   in_dir       = find_last_slash(temp);
-
-   success      = in_dir && in_dir[1];
+   /* Point in_dir to the address of the last slash. */
+   /* If find_last_slash returns NULL, it means there was no slash in temp,
+      so use temp as-is. */
+   if (!(in_dir = find_last_slash(temp)))
+       in_dir   = temp;
 
-   if (success)
-      strlcpy(out_dir, in_dir + 1, size);
+   if (in_dir && in_dir[1])
+   {
+       /* If path starts with an slash, eliminate it. */
+       if (path_is_absolute(in_dir))
+           strlcpy(out_dir, in_dir + 1, size);
+       else
+           strlcpy(out_dir, in_dir, size);
+       free(temp);
+       return true;
+   }
 
    free(temp);
-   return success;
+   return false;
 }
 
 /**
@@ -567,14 +507,18 @@ bool fill_pathname_parent_dir_name(char *out_dir,
  *
  * Copies parent directory of @in_dir into @out_dir.
  * Assumes @in_dir is a directory. Keeps trailing '/'.
- * If the path was already at the root directory, @out_dir will be an empty string.
+ * If the path was already at the root directory,
+ * @out_dir will be an empty string.
  **/
 void fill_pathname_parent_dir(char *out_dir,
       const char *in_dir, size_t size)
 {
+   size_t len = 0;
    if (out_dir != in_dir)
-      strlcpy(out_dir, in_dir, size);
-   path_parent_dir(out_dir);
+      len = strlcpy(out_dir, in_dir, size);
+   else
+      len = strlen(out_dir);
+   path_parent_dir(out_dir, len);
 }
 
 /**
@@ -592,12 +536,14 @@ void fill_pathname_parent_dir(char *out_dir,
 size_t fill_dated_filename(char *out_filename,
       const char *ext, size_t size)
 {
-   time_t       cur_time = time(NULL);
-   const struct tm* tm_  = localtime(&cur_time);
-
-   strftime(out_filename, size,
-         "RetroArch-%m%d-%H%M%S", tm_);
-   return strlcat(out_filename, ext, size);
+   size_t _len;
+   struct tm tm_;
+   time_t cur_time = time(NULL);
+   rtime_localtime(&cur_time, &tm_);
+   _len  = strftime(out_filename, size,
+         "RetroArch-%m%d-%H%M%S", &tm_);
+   _len += strlcpy(out_filename + _len, ext, size - _len);
+   return _len;
 }
 
 /**
@@ -612,29 +558,30 @@ size_t fill_dated_filename(char *out_filename,
  *
  * E.g.:
  * out_filename = "RetroArch-{year}{month}{day}-{Hour}{Minute}{Second}.{@ext}"
+ *
+ * @return Length of the string copied into @out_path
  **/
-void fill_str_dated_filename(char *out_filename,
+size_t fill_str_dated_filename(char *out_filename,
       const char *in_str, const char *ext, size_t size)
 {
-   char format[256];
-   time_t cur_time      = time(NULL);
-   const struct tm* tm_ = localtime(&cur_time);
-
-   format[0]            = '\0';
-
+   struct tm tm_;
+   char format[NAME_MAX_LENGTH];
+   size_t _len     = 0;
+   time_t cur_time = time(NULL);
+   rtime_localtime(&cur_time, &tm_);
+   _len      = strlcpy(out_filename, in_str, size);
    if (string_is_empty(ext))
    {
-      strftime(format, sizeof(format), "-%y%m%d-%H%M%S", tm_);
-      fill_pathname_noext(out_filename, in_str, format, size);
+      strftime(format, sizeof(format), "-%y%m%d-%H%M%S", &tm_);
+      _len  += strlcpy(out_filename + _len, format, size - _len);
    }
    else
    {
-      strftime(format, sizeof(format), "-%y%m%d-%H%M%S.", tm_);
-
-      fill_pathname_join_concat_noext(out_filename,
-            in_str, format, ext,
-            size);
+      strftime(format, sizeof(format), "-%y%m%d-%H%M%S.", &tm_);
+      _len  += strlcpy(out_filename + _len, format, size - _len);
+      _len  += strlcpy(out_filename + _len, ext,    size - _len);
    }
+   return _len;
 }
 
 /**
@@ -647,36 +594,34 @@ void fill_str_dated_filename(char *out_filename,
 void path_basedir(char *path)
 {
    char *last = NULL;
-
-   if (strlen(path) < 2)
+   if (!path || path[0] == '\0' || path[1] == '\0')
       return;
 
-   last = find_last_slash(path);
-
-   if (last)
+   if ((last = find_last_slash(path)))
       last[1] = '\0';
    else
-      snprintf(path, 3, ".%s", path_default_slash());
+   {
+      path[0] = '.';
+      path[1] = PATH_DEFAULT_SLASH_C();
+      path[2] = '\0';
+   }
 }
 
 /**
  * path_parent_dir:
  * @path               : path
+ * @len                : length of @path
  *
  * Extracts parent directory by mutating path.
  * Assumes that path is a directory. Keeps trailing '/'.
  * If the path was already at the root directory, returns empty string
  **/
-void path_parent_dir(char *path)
+void path_parent_dir(char *path, size_t len)
 {
-   size_t len = 0;
-
    if (!path)
       return;
    
-   len = strlen(path);
-
-   if (len && path_char_is_slash(path[len - 1]))
+   if (len && PATH_CHAR_IS_SLASH(path[len - 1]))
    {
       bool path_was_absolute = path_is_absolute(path);
 
@@ -702,22 +647,35 @@ void path_parent_dir(char *path)
  *
  * Get basename from @path.
  *
- * Returns: basename from path.
+ * @return basename from path.
  **/
 const char *path_basename(const char *path)
 {
-   /* We cut at the first compression-related hash */
-   const char *delim = path_get_archive_delim(path);
-   if (delim)
-      return delim + 1;
-
-   {
-      /* We cut at the last slash */
-      const char *last  = find_last_slash(path);
-      if (last)
-         return last + 1;
-   }
+   /* We cut either at the first compression-related hash,
+    * or we cut at the last slash */
+   const char *ptr = NULL;
+   if (     (ptr = path_get_archive_delim(path))
+         || (ptr = find_last_slash(path)))
+      return ptr + 1;
+   return path;
+}
 
+/* Specialized version */
+/**
+ * path_basename_nocompression:
+ * @path               : path
+ *
+ * Specialized version of path_basename().
+ * Get basename from @path.
+ *
+ * @return basename from path.
+ **/
+const char *path_basename_nocompression(const char *path)
+{
+   /* We cut at the last slash */
+   const char *last  = find_last_slash(path);
+   if (last)
+      return last + 1;
    return path;
 }
 
@@ -727,23 +685,28 @@ const char *path_basename(const char *path)
  *
  * Checks if @path is an absolute path or a relative path.
  *
- * Returns: true if path is absolute, false if path is relative.
+ * @return true if path is absolute, false if path is relative.
  **/
 bool path_is_absolute(const char *path)
 {
-   if (path[0] == '/')
-      return true;
-#ifdef _WIN32
-   /* Many roads lead to Rome ... */
-   if ((    strstr(path, "\\\\") == path)
-         || strstr(path, ":/")
-         || strstr(path, ":\\")
-         || strstr(path, ":\\\\"))
-      return true;
-#elif defined(__wiiu__)
-   if (strstr(path, ":/"))
-      return true;
+   if (!string_is_empty(path))
+   {
+      if (path[0] == '/')
+         return true;
+#if defined(_WIN32)
+      /* Many roads lead to Rome...
+       * Note: Drive letter can only be 1 character long */
+      return ( string_starts_with_size(path,     "\\\\", STRLEN_CONST("\\\\"))
+            || string_starts_with_size(path + 1, ":/",   STRLEN_CONST(":/")) 
+            || string_starts_with_size(path + 1, ":\\",  STRLEN_CONST(":\\")));
+#elif defined(__wiiu__) || defined(VITA)
+      {
+         const char *seperator = strchr(path, ':');
+         return (seperator && (seperator[1] == '/'));
+      }
 #endif
+   }
+
    return false;
 }
 
@@ -757,7 +720,7 @@ bool path_is_absolute(const char *path)
  *
  * Relative paths are rebased on the current working dir.
  *
- * Returns: @buf if successful, NULL otherwise.
+ * @return @buf if successful, NULL otherwise.
  * Note: Not implemented on consoles
  * Note: Symlinks are only resolved on Unix-likes
  * Note: The current working dir might not be what you expect,
@@ -767,16 +730,32 @@ bool path_is_absolute(const char *path)
 char *path_resolve_realpath(char *buf, size_t size, bool resolve_symlinks)
 {
 #if !defined(RARCH_CONSOLE) && defined(RARCH_INTERNAL)
-   char tmp[PATH_MAX_LENGTH];
 #ifdef _WIN32
-   strlcpy(tmp, buf, sizeof(tmp));
-   if (!_fullpath(buf, tmp, size))
+   char *ret         = NULL;
+   wchar_t *rel_path = utf8_to_utf16_string_alloc(buf);
+
+   if (rel_path)
    {
-      strlcpy(buf, tmp, size);
-      return NULL;
+      wchar_t abs_path[PATH_MAX_LENGTH];
+
+      if (_wfullpath(abs_path, rel_path, PATH_MAX_LENGTH))
+      {
+         char *tmp = utf16_to_utf8_string_alloc(abs_path);
+
+         if (tmp)
+         {
+            strlcpy(buf, tmp, size);
+            free(tmp);
+            ret = buf;
+         }
+      }
+
+      free(rel_path);
    }
-   return buf;
+
+   return ret;
 #else
+   char tmp[PATH_MAX_LENGTH];
    size_t t;
    char *p;
    const char *next;
@@ -799,20 +778,20 @@ char *path_resolve_realpath(char *buf, size_t size, bool resolve_symlinks)
       return buf;
    }
 
-   t = 0; /* length of output */
+   t       = 0; /* length of output */
    buf_end = buf + strlen(buf);
 
    if (!path_is_absolute(buf))
    {
       size_t len;
       /* rebase on working directory */
-      if (!getcwd(tmp, PATH_MAX_LENGTH-1))
+      if (!getcwd(tmp, PATH_MAX_LENGTH - 1))
          return NULL;
 
       len = strlen(tmp);
-      t += len;
+      t  += len;
 
-      if (tmp[len-1] != '/')
+      if (tmp[len - 1] != '/')
          tmp[t++] = '/';
 
       if (string_is_empty(buf))
@@ -831,8 +810,7 @@ char *path_resolve_realpath(char *buf, size_t size, bool resolve_symlinks)
     * if there are no slashes, they point relative to where one would be */
    do
    {
-      next = strchr(p, '/');
-      if (!next)
+      if (!(next = strchr(p, '/')))
          next = buf_end;
 
       if ((next - p == 2 && p[0] == '.' && p[1] == '.'))
@@ -844,8 +822,8 @@ char *path_resolve_realpath(char *buf, size_t size, bool resolve_symlinks)
             return NULL;
 
          /* delete previous segment in tmp by adjusting size t
-          * tmp[t-1] == '/', find '/' before that */
-         t = t-2;
+          * tmp[t - 1] == '/', find '/' before that */
+         t -= 2;
          while (tmp[t] != '/')
             t--;
          t++;
@@ -857,15 +835,14 @@ char *path_resolve_realpath(char *buf, size_t size, bool resolve_symlinks)
       else
       {
          /* fail when truncating */
-         if (t + next-p+1 > PATH_MAX_LENGTH-1)
+         if (t + next - p + 1 > PATH_MAX_LENGTH - 1)
             return NULL;
 
          while (p <= next)
             tmp[t++] = *p++;
       }
-
-   }
-   while (next < buf_end);
+   }while(next < buf_end);
+   
 
 end:
    tmp[t] = '\0';
@@ -889,32 +866,43 @@ char *path_resolve_realpath(char *buf, size_t size, bool resolve_symlinks)
  * Both @path and @base are assumed to be absolute paths without "." or "..".
  *
  * E.g. path /a/b/e/f.cg with base /a/b/c/d/ turns into ../../e/f.cg
+ *
+ * @return Length of the string copied into @out
  **/
 size_t path_relative_to(char *out,
       const char *path, const char *base, size_t size)
 {
-   size_t i;
+   size_t i, j;
    const char *trimmed_path, *trimmed_base;
 
 #ifdef _WIN32
    /* For different drives, return absolute path */
-   if (strlen(path) >= 2 && strlen(base) >= 2
-         && path[1] == ':' && base[1] == ':'
+   if (
+            path
+         && base
+         && path[0] != '\0' 
+         && path[1] != '\0'
+         && base[0] != '\0'
+         && base[1] != '\0'
+         && path[1] == ':' 
+         && base[1] == ':'
          && path[0] != base[0])
       return strlcpy(out, path, size);
 #endif
 
    /* Trim common beginning */
-   for (i = 0; path[i] && base[i] && path[i] == base[i]; )
-      i++;
-   trimmed_path = path+i;
+   for (i = 0, j = 0; path[i] && base[i] && path[i] == base[i]; i++)
+      if (path[i] == PATH_DEFAULT_SLASH_C())
+         j = i + 1;
+
+   trimmed_path = path+j;
    trimmed_base = base+i;
 
    /* Each segment of base turns into ".." */
    out[0] = '\0';
    for (i = 0; trimmed_base[i]; i++)
-      if (trimmed_base[i] == path_default_slash_c())
-         strlcat(out, ".." path_default_slash(), size);
+      if (trimmed_base[i] == PATH_DEFAULT_SLASH_C())
+         strlcat(out, ".." PATH_DEFAULT_SLASH(), size);
 
    return strlcat(out, trimmed_path, size);
 }
@@ -940,7 +928,9 @@ void fill_pathname_resolve_relative(char *out_path,
       return;
    }
 
-   fill_pathname_basedir(out_path, in_refpath, size);
+   if (out_path != in_refpath)
+      strlcpy(out_path, in_refpath, size);
+   path_basedir(out_path);
    strlcat(out_path, in_path, size);
    path_resolve_realpath(out_path, size, false);
 }
@@ -955,17 +945,68 @@ void fill_pathname_resolve_relative(char *out_path,
  * Joins a directory (@dir) and path (@path) together.
  * Makes sure not to get  two consecutive slashes
  * between directory and path.
+ *
+ * Deprecated. Use fill_pathname_join_special() instead
+ * if you can ensure @dir and @out_path won't overlap.
+ *
+ * @return Length of the string copied into @out_path
  **/
 size_t fill_pathname_join(char *out_path,
       const char *dir, const char *path, size_t size)
 {
+   size_t _len = 0;
    if (out_path != dir)
-      strlcpy(out_path, dir, size);
+      _len = strlcpy(out_path, dir, size);
+   if (*out_path)
+      _len = fill_pathname_slash(out_path, size);
+   _len   += strlcpy(out_path + _len, path, size - _len);
+   return _len;
+}
+
+/**
+ * fill_pathname_join_special:
+ * @out_path           : output path
+ * @dir                : directory. Cannot be identical to @out_path
+ * @path               : path
+ * @size               : size of output path
+ *
+ *
+ * Specialized version of fill_pathname_join.
+ * Unlike fill_pathname_join(),
+ * @dir and @out_path CANNOT be identical.
+ *
+ * Joins a directory (@dir) and path (@path) together.
+ * Makes sure not to get  two consecutive slashes
+ * between directory and path.
+ *
+ * @return Length of the string copied into @out_path
+ **/
+size_t fill_pathname_join_special(char *out_path,
+      const char *dir, const char *path, size_t size)
+{
+   size_t len = strlcpy(out_path, dir, size);
 
    if (*out_path)
-      fill_pathname_slash(out_path, size);
+   {
+      const char *last_slash = find_last_slash(out_path);
+      if (last_slash)
+      {
+         /* Try to preserve slash type. */
+         if (last_slash != (out_path + len - 1))
+         {
+            out_path[  len] = last_slash[0];
+            out_path[++len] = '\0';
+         }
+      }
+      else
+      {
+         out_path[  len]    = PATH_DEFAULT_SLASH_C();
+         out_path[++len]    = '\0';
+      }
+   }
 
-   return strlcat(out_path, path, size);
+   len += strlcpy(out_path + len, path, size - len);
+   return len;
 }
 
 size_t fill_pathname_join_special_ext(char *out_path,
@@ -973,37 +1014,12 @@ size_t fill_pathname_join_special_ext(char *out_path,
       const char *last, const char *ext,
       size_t size)
 {
-   fill_pathname_join(out_path, dir, path, size);
+   size_t _len = fill_pathname_join(out_path, dir, path, size);
    if (*out_path)
-      fill_pathname_slash(out_path, size);
-
-   strlcat(out_path, last, size);
-   return strlcat(out_path, ext, size);
-}
-
-size_t fill_pathname_join_concat_noext(char *out_path,
-      const char *dir, const char *path,
-      const char *concat,
-      size_t size)
-{
-   fill_pathname_noext(out_path, dir, path, size);
-   return strlcat(out_path, concat, size);
-}
-
-size_t fill_pathname_join_concat(char *out_path,
-      const char *dir, const char *path,
-      const char *concat,
-      size_t size)
-{
-   fill_pathname_join(out_path, dir, path, size);
-   return strlcat(out_path, concat, size);
-}
-
-void fill_pathname_join_noext(char *out_path,
-      const char *dir, const char *path, size_t size)
-{
-   fill_pathname_join(out_path, dir, path, size);
-   path_remove_extension(out_path);
+      _len     = fill_pathname_slash(out_path, size);
+   _len       += strlcpy(out_path + _len, last, size - _len);
+   _len       += strlcpy(out_path + _len, ext,  size - _len);
+   return _len;
 }
 
 /**
@@ -1020,120 +1036,50 @@ void fill_pathname_join_noext(char *out_path,
 size_t fill_pathname_join_delim(char *out_path, const char *dir,
       const char *path, const char delim, size_t size)
 {
-   size_t copied;
-   /* behavior of strlcpy is undefined if dst and src overlap */
+   size_t _len;
+   /* Behavior of strlcpy is undefined if dst and src overlap */
    if (out_path == dir)
-      copied = strlen(dir);
+      _len          = strlen(dir);
    else
-      copied = strlcpy(out_path, dir, size);
+      _len          = strlcpy(out_path, dir, size);
 
-   out_path[copied]   = delim;
-   out_path[copied+1] = '\0';
+   out_path[_len]   = delim;
+   out_path[_len+1] = '\0';
 
    if (path)
-      copied = strlcat(out_path, path, size);
-   return copied;
-}
-
-size_t fill_pathname_join_delim_concat(char *out_path, const char *dir,
-      const char *path, const char delim, const char *concat,
-      size_t size)
-{
-   fill_pathname_join_delim(out_path, dir, path, delim, size);
-   return strlcat(out_path, concat, size);
-}
-
-/**
- * fill_short_pathname_representation:
- * @out_rep            : output representation
- * @in_path            : input path
- * @size               : size of output representation
- *
- * Generates a short representation of path. It should only
- * be used for displaying the result; the output representation is not
- * binding in any meaningful way (for a normal path, this is the same as basename)
- * In case of more complex URLs, this should cut everything except for
- * the main image file.
- *
- * E.g.: "/path/to/game.img" -> game.img
- *       "/path/to/myarchive.7z#folder/to/game.img" -> game.img
- */
-size_t fill_short_pathname_representation(char* out_rep,
-      const char *in_path, size_t size)
-{
-   char path_short[PATH_MAX_LENGTH];
-
-   path_short[0] = '\0';
-
-   fill_pathname(path_short, path_basename(in_path), "",
-            sizeof(path_short));
-
-   return strlcpy(out_rep, path_short, size);
-}
-
-void fill_short_pathname_representation_noext(char* out_rep,
-      const char *in_path, size_t size)
-{
-   fill_short_pathname_representation(out_rep, in_path, size);
-   path_remove_extension(out_rep);
+      return strlcat(out_path, path, size);
+   return _len;
 }
 
-void fill_pathname_expand_special(char *out_path,
+size_t fill_pathname_expand_special(char *out_path,
       const char *in_path, size_t size)
 {
 #if !defined(RARCH_CONSOLE) && defined(RARCH_INTERNAL)
+   char *app_dir = NULL;
    if (in_path[0] == '~')
    {
-      char *home_dir = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
-
-      home_dir[0] = '\0';
-
-      fill_pathname_home_dir(home_dir,
-         PATH_MAX_LENGTH * sizeof(char));
-
-      if (*home_dir)
-      {
-         size_t src_size = strlcpy(out_path, home_dir, size);
-         retro_assert(src_size < size);
-
-         out_path  += src_size;
-         size      -= src_size;
-
-         if (!path_char_is_slash(out_path[-1]))
-         {
-            src_size = strlcpy(out_path, path_default_slash(), size);
-            retro_assert(src_size < size);
-
-            out_path += src_size;
-            size -= src_size;
-         }
-
-         in_path += 2;
-      }
-
-      free(home_dir);
+      app_dir    = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
+      fill_pathname_home_dir(app_dir, PATH_MAX_LENGTH * sizeof(char));
    }
    else if (in_path[0] == ':')
    {
-      char *application_dir = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
-
-      application_dir[0]    = '\0';
-
-      fill_pathname_application_dir(application_dir,
-            PATH_MAX_LENGTH * sizeof(char));
+      app_dir    = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
+      app_dir[0] = '\0';
+      fill_pathname_application_dir(app_dir, PATH_MAX_LENGTH * sizeof(char));
+   }
 
-      if (*application_dir)
+   if (app_dir)
+   {
+      if (*app_dir)
       {
-         size_t src_size   = strlcpy(out_path, application_dir, size);
-         retro_assert(src_size < size);
+         size_t src_size = strlcpy(out_path, app_dir, size);
 
-         out_path  += src_size;
-         size      -= src_size;
+         out_path       += src_size;
+         size           -= src_size;
 
-         if (!path_char_is_slash(out_path[-1]))
+         if (!PATH_CHAR_IS_SLASH(out_path[-1]))
          {
-            src_size = strlcpy(out_path, path_default_slash(), size);
-            retro_assert(src_size < size);
+            src_size  = strlcpy(out_path, PATH_DEFAULT_SLASH(), size);
 
             out_path += src_size;
             size     -= src_size;
@@ -1142,22 +1088,21 @@ void fill_pathname_expand_special(char *out_path,
          in_path += 2;
       }
 
-      free(application_dir);
+      free(app_dir);
    }
 #endif
-
-   retro_assert(strlcpy(out_path, in_path, size) < size);
+   return strlcpy(out_path, in_path, size);
 }
 
-void fill_pathname_abbreviate_special(char *out_path,
+size_t fill_pathname_abbreviate_special(char *out_path,
       const char *in_path, size_t size)
 {
 #if !defined(RARCH_CONSOLE) && defined(RARCH_INTERNAL)
    unsigned i;
    const char *candidates[3];
    const char *notations[3];
-   char *application_dir     = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
-   char *home_dir            = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
+   char application_dir[PATH_MAX_LENGTH];
+   char home_dir[PATH_MAX_LENGTH];
 
    application_dir[0] = '\0';
 
@@ -1176,28 +1121,23 @@ void fill_pathname_abbreviate_special(char *out_path,
    notations [1] = "~";
    notations [2] = NULL;
 
-   fill_pathname_application_dir(application_dir,
-         PATH_MAX_LENGTH * sizeof(char));
-   fill_pathname_home_dir(home_dir,
-         PATH_MAX_LENGTH * sizeof(char));
+   fill_pathname_application_dir(application_dir, sizeof(application_dir));
+   fill_pathname_home_dir(home_dir, sizeof(home_dir));
 
    for (i = 0; candidates[i]; i++)
    {
       if (!string_is_empty(candidates[i]) &&
-            strstr(in_path, candidates[i]) == in_path)
+          string_starts_with(in_path, candidates[i]))
       {
          size_t src_size  = strlcpy(out_path, notations[i], size);
 
-         retro_assert(src_size < size);
-
          out_path        += src_size;
          size            -= src_size;
          in_path         += strlen(candidates[i]);
 
-         if (!path_char_is_slash(*in_path))
+         if (!PATH_CHAR_IS_SLASH(*in_path))
          {
-            retro_assert(strlcpy(out_path,
-                     path_default_slash(), size) < size);
+            strcpy_literal(out_path, PATH_DEFAULT_SLASH());
             out_path++;
             size--;
          }
@@ -1205,12 +1145,132 @@ void fill_pathname_abbreviate_special(char *out_path,
          break; /* Don't allow more abbrevs to take place. */
       }
    }
-
-   free(application_dir);
-   free(home_dir);
 #endif
+   return strlcpy(out_path, in_path, size);
+}
+
+/**
+ * pathname_conform_slashes_to_os:
+ *
+ * @path               : path
+ *
+ * Leaf function.
+ *
+ * Changes the slashes to the correct kind for the OS 
+ * So forward slash on linux and backslash on Windows
+ **/
+void pathname_conform_slashes_to_os(char *path)
+{
+   /* Conform slashes to OS standard so we get proper matching */
+   char *p;
+   for (p = path; *p; p++)
+      if (*p == '/' || *p == '\\')
+         *p = PATH_DEFAULT_SLASH_C();
+}
+
+/**
+ * pathname_make_slashes_portable:
+ * @path               : path
+ *
+ * Leaf function.
+ *
+ * Change all slashes to forward so they are more 
+ * portable between Windows and Linux
+ **/
+void pathname_make_slashes_portable(char *path)
+{
+   /* Conform slashes to OS standard so we get proper matching */
+   char *p;
+   for (p = path; *p; p++)
+      if (*p == '/' || *p == '\\')
+         *p = '/';
+}
+
+/**
+ * get_pathname_num_slashes:
+ * @in_path            : input path
+ *
+ * Leaf function.
+ *
+ * Get the number of slashes in a path.
+ *
+ * @return number of slashes found in @in_path.
+ **/
+static int get_pathname_num_slashes(const char *in_path)
+{
+   int num_slashes = 0;
+   int i = 0;
+
+   for (i = 0; i < PATH_MAX_LENGTH; i++)
+   {
+      if (PATH_CHAR_IS_SLASH(in_path[i]))
+         num_slashes++;
+      if (in_path[i] == '\0')
+         break;
+   }
+
+   return num_slashes;
+}
+
+/**
+ * fill_pathname_abbreviated_or_relative:
+ *
+ * Fills the supplied path with either the abbreviated path or 
+ * the relative path, which ever one has less depth / number of slashes
+ * 
+ * If lengths of abbreviated and relative paths are the same,
+ * the relative path will be used
+ * @in_path can be an absolute, relative or abbreviated path
+ *
+ * @return Length of the string copied into @out_path
+ **/
+size_t fill_pathname_abbreviated_or_relative(char *out_path,
+      const char *in_refpath, const char *in_path, size_t size)
+{
+   char in_path_conformed[PATH_MAX_LENGTH];
+   char in_refpath_conformed[PATH_MAX_LENGTH];
+   char expanded_path[PATH_MAX_LENGTH];
+   char absolute_path[PATH_MAX_LENGTH];
+   char relative_path[PATH_MAX_LENGTH];
+   char abbreviated_path[PATH_MAX_LENGTH];
+   
+   expanded_path[0]        = '\0';
+   absolute_path[0]        = '\0';
+   relative_path[0]        = '\0';
+   abbreviated_path[0]     = '\0';
+
+   strlcpy(in_path_conformed, in_path, sizeof(in_path_conformed));
+   strlcpy(in_refpath_conformed, in_refpath, sizeof(in_refpath_conformed));
+
+   pathname_conform_slashes_to_os(in_path_conformed);
+   pathname_conform_slashes_to_os(in_refpath_conformed);
+
+   /* Expand paths which start with :\ to an absolute path */
+   fill_pathname_expand_special(expanded_path,
+         in_path_conformed, sizeof(expanded_path));
+
+   /* Get the absolute path if it is not already */
+   if (path_is_absolute(expanded_path))
+      strlcpy(absolute_path, expanded_path, PATH_MAX_LENGTH);
+   else
+      fill_pathname_resolve_relative(absolute_path,
+            in_refpath_conformed, in_path_conformed, PATH_MAX_LENGTH);
+
+   pathname_conform_slashes_to_os(absolute_path);
+
+   /* Get the relative path and see how many directories long it is */
+   path_relative_to(relative_path, absolute_path,
+         in_refpath_conformed, sizeof(relative_path));
 
-   retro_assert(strlcpy(out_path, in_path, size) < size);
+   /* Get the abbreviated path and see how many directories long it is */
+   fill_pathname_abbreviate_special(abbreviated_path,
+         absolute_path, sizeof(abbreviated_path));
+
+   /* Use the shortest path, preferring the relative path*/
+   if (  get_pathname_num_slashes(relative_path) <= 
+         get_pathname_num_slashes(abbreviated_path))
+      return strlcpy(out_path, relative_path, size);
+   return strlcpy(out_path, abbreviated_path, size);
 }
 
 /**
@@ -1223,22 +1283,23 @@ void fill_pathname_abbreviate_special(char *out_path,
 void path_basedir_wrapper(char *path)
 {
    char *last = NULL;
-   if (strlen(path) < 2)
+   if (!path || path[0] == '\0' || path[1] == '\0')
       return;
 
 #ifdef HAVE_COMPRESSION
    /* We want to find the directory with the archive in basedir. */
-   last = (char*)path_get_archive_delim(path);
-   if (last)
+   if ((last = (char*)path_get_archive_delim(path)))
       *last = '\0';
 #endif
 
-   last = find_last_slash(path);
-
-   if (last)
+   if ((last = find_last_slash(path)))
       last[1] = '\0';
    else
-      snprintf(path, 3, ".%s", path_default_slash());
+   {
+      path[0] = '.';
+      path[1] = PATH_DEFAULT_SLASH_C();
+      path[2] = '\0';
+   }
 }
 
 #if !defined(RARCH_CONSOLE) && defined(RARCH_INTERNAL)
@@ -1293,8 +1354,9 @@ void fill_pathname_application_path(char *s, size_t len)
          char resolved_bundle_dir_buf[PATH_MAX_LENGTH] = {0};
          if (realpath(s, resolved_bundle_dir_buf))
          {
-            strlcpy(s, resolved_bundle_dir_buf, len - 1);
-            strlcat(s, "/", len);
+            size_t _len = strlcpy(s, resolved_bundle_dir_buf, len - 1);
+            s[  _len]   = '/';
+            s[++_len]   = '\0';
          }
       }
 #endif
@@ -1304,7 +1366,7 @@ void fill_pathname_application_path(char *s, size_t len)
 #ifndef HAVE_COCOATOUCH
       /* Not sure what this does but it breaks 
        * stuff for iOS, so skipping */
-      retro_assert(strlcat(s, "nobin", len) < len);
+      strlcat(s, "nobin", len);
 #endif
       return;
    }
@@ -1340,9 +1402,8 @@ void fill_pathname_application_path(char *s, size_t len)
 
          snprintf(link_path, sizeof(link_path), "/proc/%u/%s",
                (unsigned)pid, exts[i]);
-         ret = readlink(link_path, s, len - 1);
 
-         if (ret >= 0)
+         if ((ret = readlink(link_path, s, len - 1)) >= 0)
          {
             s[ret] = '\0';
             return;
@@ -1365,29 +1426,21 @@ void fill_pathname_application_dir(char *s, size_t len)
 void fill_pathname_home_dir(char *s, size_t len)
 {
 #ifdef __WINRT__
-   strlcpy(s, uwp_dir_data, len);
+   const char *home = uwp_dir_data;
 #else
    const char *home = getenv("HOME");
+#endif
    if (home)
       strlcpy(s, home, len);
    else
       *s = 0;
-#endif
 }
 #endif
 
 bool is_path_accessible_using_standard_io(const char *path)
 {
 #ifdef __WINRT__
-   bool result;
-   size_t         path_sizeof = PATH_MAX_LENGTH * sizeof(char);
-   char *relative_path_abbrev = (char*)malloc(path_sizeof);
-   fill_pathname_abbreviate_special(relative_path_abbrev, path, path_sizeof);
-
-   result = strlen(relative_path_abbrev) >= 2 && (relative_path_abbrev[0] == ':' || relative_path_abbrev[0] == '~') && path_char_is_slash(relative_path_abbrev[1]);
-
-   free(relative_path_abbrev);
-   return result;
+   return GetFileAttributesA(path) != INVALID_FILE_ATTRIBUTES;
 #else
    return true;
 #endif
diff --git a/src/libretro/libretro-common/file/nbio/nbio_intf.c b/src/libretro/libretro-common/file/nbio/nbio_intf.c
index 59be8e2a5d..e945a34082 100644
--- a/src/libretro/libretro-common/file/nbio/nbio_intf.c
+++ b/src/libretro/libretro-common/file/nbio/nbio_intf.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (nbio_intf.c).
@@ -32,19 +32,32 @@
 extern nbio_intf_t nbio_linux;
 extern nbio_intf_t nbio_mmap_unix;
 extern nbio_intf_t nbio_mmap_win32;
-#if defined(ORBIS)
-extern nbio_intf_t nbio_orbis;
-#endif
 extern nbio_intf_t nbio_stdio;
 
+#ifndef _XBOX
+#if defined(_WIN32)
+#if defined(_MSC_VER) && _MSC_VER >= 1500
+
+#ifndef HAVE_MMAP_WIN32
+#define HAVE_MMAP_WIN32
+#endif
+
+#elif !defined(_MSC_VER)
+
+#ifndef HAVE_MMAP_WIN32
+#define HAVE_MMAP_WIN32
+#endif
+#endif
+#endif
+
+#endif
+
 #if defined(_linux__)
 static nbio_intf_t *internal_nbio = &nbio_linux;
 #elif defined(HAVE_MMAP) && defined(BSD)
 static nbio_intf_t *internal_nbio = &nbio_mmap_unix;
-#elif defined(_WIN32) && !defined(_XBOX)
+#elif defined(HAVE_MMAP_WIN32)
 static nbio_intf_t *internal_nbio = &nbio_mmap_win32;
-#elif defined(ORBIS)
-static nbio_intf_t *internal_nbio = &nbio_orbis;
 #else
 static nbio_intf_t *internal_nbio = &nbio_stdio;
 #endif
diff --git a/src/libretro/libretro-common/file/nbio/nbio_linux.c b/src/libretro/libretro-common/file/nbio/nbio_linux.c
index 70e3a98c80..b0ae46d32b 100644
--- a/src/libretro/libretro-common/file/nbio/nbio_linux.c
+++ b/src/libretro/libretro-common/file/nbio/nbio_linux.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (nbio_linux.c).
@@ -31,6 +31,7 @@
 #include <stdlib.h>
 #include <stdint.h>
 #include <string.h>
+#include <time.h>
 
 #include <unistd.h>
 #include <fcntl.h>
@@ -39,14 +40,12 @@
 
 struct nbio_linux_t
 {
-   int fd;
-   bool busy;
-
+   void* ptr;
    aio_context_t ctx;
    struct iocb cb;
-
-   void* ptr;
    size_t len;
+   int fd;
+   bool busy;
 };
 
 /* there's also a Unix AIO thingy, but it's not in glibc
diff --git a/src/libretro/libretro-common/file/nbio/nbio_orbis.c b/src/libretro/libretro-common/file/nbio/nbio_orbis.c
index c6c8f3cbc2..7f0676310e 100644
--- a/src/libretro/libretro-common/file/nbio/nbio_orbis.c
+++ b/src/libretro/libretro-common/file/nbio/nbio_orbis.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (nbio_orbis.c).
@@ -31,10 +31,11 @@
 
 struct nbio_orbis_t
 {
-   int fd;
    void* data;
    size_t progress;
    size_t len;
+   int fd;
+   unsigned int mode;
    /*
     * possible values:
     * NBIO_READ, NBIO_WRITE - obvious
@@ -42,7 +43,6 @@ struct nbio_orbis_t
     * -2 - the pointer was reallocated since the last operation
     */
    signed char op;
-   unsigned int mode;
 };
 
 static void *nbio_orbis_open(const char * filename, unsigned int mode)
diff --git a/src/libretro/libretro-common/file/nbio/nbio_stdio.c b/src/libretro/libretro-common/file/nbio/nbio_stdio.c
index 9bacacb5a0..e05968b6fa 100644
--- a/src/libretro/libretro-common/file/nbio/nbio_stdio.c
+++ b/src/libretro/libretro-common/file/nbio/nbio_stdio.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (nbio_stdio.c).
@@ -22,6 +22,9 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#if defined(WIIU)
+#include <malloc.h>
+#endif
 
 #include <file/nbio.h>
 #include <encodings/utf.h>
@@ -35,6 +38,18 @@
 
 #endif
 
+#if defined(_WIN32)
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+#define ATLEAST_VC2005
+#endif
+#endif
+
+#if (defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE - 0) >= 200112) || (defined(__POSIX_VISIBLE) && __POSIX_VISIBLE >= 200112) || (defined(_POSIX_VERSION) && _POSIX_VERSION >= 200112) || __USE_LARGEFILE || (defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS == 64)
+#ifndef HAVE_64BIT_OFFSETS
+#define HAVE_64BIT_OFFSETS
+#endif
+#endif
+
 struct nbio_stdio_t
 {
    FILE* f;
@@ -57,11 +72,35 @@ static const char    *stdio_modes[] = { "rb", "wb", "r+b", "rb", "wb", "r+b" };
 static const wchar_t *stdio_modes[] = { L"rb", L"wb", L"r+b", L"rb", L"wb", L"r+b" };
 #endif
 
+static int64_t fseek_wrap(FILE *f, int64_t offset, int origin)
+{
+#ifdef ATLEAST_VC2005
+   /* VC2005 and up have a special 64-bit fseek */
+   return _fseeki64(f, offset, origin);
+#elif defined(HAVE_64BIT_OFFSETS)
+   return fseeko(f, (off_t)offset, origin);
+#else
+   return fseek(f, (long)offset, origin);
+#endif
+}
+
+static int64_t ftell_wrap(FILE *f)
+{
+#ifdef ATLEAST_VC2005
+   /* VC2005 and up have a special 64-bit ftell */
+   return _ftelli64(f);
+#elif defined(HAVE_64BIT_OFFSETS)
+   return ftello(f);
+#else
+   return ftell(f);
+#endif
+}
+
 static void *nbio_stdio_open(const char * filename, unsigned mode)
 {
    void *buf                   = NULL;
    struct nbio_stdio_t* handle = NULL;
-   size_t len                  = 0;
+   int64_t len                 = 0;
 #if !defined(_WIN32) || defined(LEGACY_WIN32)
    FILE* f                     = fopen(filename, stdio_modes[mode]);
 #else
@@ -87,15 +126,21 @@ static void *nbio_stdio_open(const char * filename, unsigned mode)
       case BIO_WRITE:
          break;
       default:
-         fseek(handle->f, 0, SEEK_END);
-         len = ftell(handle->f);
+         fseek_wrap(handle->f, 0, SEEK_END);
+         len = ftell_wrap(handle->f);
          break;
    }
 
    handle->mode          = mode;
 
+#if defined(WIIU)
+   /* hit the aligned-buffer fast path on Wii U */
    if (len)
-      buf                = malloc(len);
+      buf                = memalign(0x40, (size_t)len);
+#else
+   if (len)
+      buf                = malloc((size_t)len);
+#endif
 
    if (len && !buf)
       goto error;
@@ -123,7 +168,7 @@ static void nbio_stdio_begin_read(void *data)
    if (handle->op >= 0)
       abort();
 
-   fseek(handle->f, 0, SEEK_SET);
+   fseek_wrap(handle->f, 0, SEEK_SET);
 
    handle->op       = NBIO_READ;
    handle->progress = 0;
@@ -138,7 +183,7 @@ static void nbio_stdio_begin_write(void *data)
    if (handle->op >= 0)
       abort();
 
-   fseek(handle->f, 0, SEEK_SET);
+   fseek_wrap(handle->f, 0, SEEK_SET);
    handle->op = NBIO_WRITE;
    handle->progress = 0;
 }
diff --git a/src/libretro/libretro-common/file/nbio/nbio_unixmmap.c b/src/libretro/libretro-common/file/nbio/nbio_unixmmap.c
index 8be3a0ea4e..1a94238beb 100644
--- a/src/libretro/libretro-common/file/nbio/nbio_unixmmap.c
+++ b/src/libretro/libretro-common/file/nbio/nbio_unixmmap.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (nbio_unixmmap.c).
@@ -55,10 +55,10 @@
 
 struct nbio_mmap_unix_t
 {
+   void* ptr;
+   size_t len;
    int fd;
    int map_flags;
-   size_t len;
-   void* ptr;
 };
 
 static void *nbio_mmap_unix_open(const char * filename, unsigned mode)
diff --git a/src/libretro/libretro-common/file/nbio/nbio_windowsmmap.c b/src/libretro/libretro-common/file/nbio/nbio_windowsmmap.c
index 067aca745e..82b1c342df 100644
--- a/src/libretro/libretro-common/file/nbio/nbio_windowsmmap.c
+++ b/src/libretro/libretro-common/file/nbio/nbio_windowsmmap.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (nbio_windowsmmap.c).
@@ -22,7 +22,23 @@
 
 #include <file/nbio.h>
 
-#if defined(_WIN32) && !defined(_XBOX)
+#if defined(_WIN32)
+#if defined(_MSC_VER) && _MSC_VER >= 1500
+
+#ifndef HAVE_MMAP_WIN32
+#define HAVE_MMAP_WIN32
+#endif
+
+#elif !defined(_MSC_VER)
+
+#ifndef HAVE_MMAP_WIN32
+#define HAVE_MMAP_WIN32
+#endif
+#endif
+
+#endif
+
+#if defined(HAVE_MMAP_WIN32)
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -47,9 +63,9 @@
 struct nbio_mmap_win32_t
 {
    HANDLE file;
-   bool is_write;
-   size_t len;
    void* ptr;
+   size_t len;
+   bool is_write;
 };
 
 static void *nbio_mmap_win32_open(const char * filename, unsigned mode)
diff --git a/src/libretro/libretro-common/file/retro_dirent.c b/src/libretro/libretro-common/file/retro_dirent.c
index 752cbdad01..51f89c2e66 100644
--- a/src/libretro/libretro-common/file/retro_dirent.c
+++ b/src/libretro/libretro-common/file/retro_dirent.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2019 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (retro_dirent.c).
@@ -31,37 +31,41 @@
 #define VFS_FRONTEND
 #include <vfs/vfs_implementation.h>
 
-static retro_vfs_opendir_t dirent_opendir_cb = NULL;
-static retro_vfs_readdir_t dirent_readdir_cb = NULL;
+/* TODO/FIXME - static globals */
+static retro_vfs_opendir_t dirent_opendir_cb                 = NULL;
+static retro_vfs_readdir_t dirent_readdir_cb                 = NULL;
 static retro_vfs_dirent_get_name_t dirent_dirent_get_name_cb = NULL;
-static retro_vfs_dirent_is_dir_t dirent_dirent_is_dir_cb = NULL;
-static retro_vfs_closedir_t dirent_closedir_cb = NULL;
+static retro_vfs_dirent_is_dir_t dirent_dirent_is_dir_cb     = NULL;
+static retro_vfs_closedir_t dirent_closedir_cb               = NULL;
 
 void dirent_vfs_init(const struct retro_vfs_interface_info* vfs_info)
 {
    const struct retro_vfs_interface* vfs_iface;
 
-   dirent_opendir_cb = NULL;
-   dirent_readdir_cb = NULL;
+   dirent_opendir_cb         = NULL;
+   dirent_readdir_cb         = NULL;
    dirent_dirent_get_name_cb = NULL;
-   dirent_dirent_is_dir_cb = NULL;
-   dirent_closedir_cb = NULL;
+   dirent_dirent_is_dir_cb   = NULL;
+   dirent_closedir_cb        = NULL;
 
-   vfs_iface = vfs_info->iface;
+   vfs_iface                 = vfs_info->iface;
 
-   if (vfs_info->required_interface_version < DIRENT_REQUIRED_VFS_VERSION || !vfs_iface)
+   if (
+         vfs_info->required_interface_version < DIRENT_REQUIRED_VFS_VERSION || 
+         !vfs_iface)
       return;
 
-   dirent_opendir_cb = vfs_iface->opendir;
-   dirent_readdir_cb = vfs_iface->readdir;
+   dirent_opendir_cb         = vfs_iface->opendir;
+   dirent_readdir_cb         = vfs_iface->readdir;
    dirent_dirent_get_name_cb = vfs_iface->dirent_get_name;
-   dirent_dirent_is_dir_cb = vfs_iface->dirent_is_dir;
-   dirent_closedir_cb = vfs_iface->closedir;
+   dirent_dirent_is_dir_cb   = vfs_iface->dirent_is_dir;
+   dirent_closedir_cb        = vfs_iface->closedir;
 }
 
-struct RDIR *retro_opendir_include_hidden(const char *name, bool include_hidden)
+struct RDIR *retro_opendir_include_hidden(
+      const char *name, bool include_hidden)
 {
-   if (dirent_opendir_cb != NULL)
+   if (dirent_opendir_cb)
       return (struct RDIR *)dirent_opendir_cb(name, include_hidden);
    return (struct RDIR *)retro_vfs_opendir_impl(name, include_hidden);
 }
@@ -79,14 +83,14 @@ bool retro_dirent_error(struct RDIR *rdir)
 
 int retro_readdir(struct RDIR *rdir)
 {
-   if (dirent_readdir_cb != NULL)
+   if (dirent_readdir_cb)
       return dirent_readdir_cb((struct retro_vfs_dir_handle *)rdir);
    return retro_vfs_readdir_impl((struct retro_vfs_dir_handle *)rdir);
 }
 
 const char *retro_dirent_get_name(struct RDIR *rdir)
 {
-   if (dirent_dirent_get_name_cb != NULL)
+   if (dirent_dirent_get_name_cb)
       return dirent_dirent_get_name_cb((struct retro_vfs_dir_handle *)rdir);
    return retro_vfs_dirent_get_name_impl((struct retro_vfs_dir_handle *)rdir);
 }
@@ -104,14 +108,14 @@ const char *retro_dirent_get_name(struct RDIR *rdir)
  */
 bool retro_dirent_is_dir(struct RDIR *rdir, const char *unused)
 {
-   if (dirent_dirent_is_dir_cb != NULL)
+   if (dirent_dirent_is_dir_cb)
       return dirent_dirent_is_dir_cb((struct retro_vfs_dir_handle *)rdir);
    return retro_vfs_dirent_is_dir_impl((struct retro_vfs_dir_handle *)rdir);
 }
 
 void retro_closedir(struct RDIR *rdir)
 {
-   if (dirent_closedir_cb != NULL)
+   if (dirent_closedir_cb)
       dirent_closedir_cb((struct retro_vfs_dir_handle *)rdir);
    else
       retro_vfs_closedir_impl((struct retro_vfs_dir_handle *)rdir);
diff --git a/src/libretro/libretro-common/formats/bmp/rbmp.c b/src/libretro/libretro-common/formats/bmp/rbmp.c
index d373d3caba..1d3f489a1e 100644
--- a/src/libretro/libretro-common/formats/bmp/rbmp.c
+++ b/src/libretro/libretro-common/formats/bmp/rbmp.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (rbmp.c).
@@ -41,17 +41,15 @@
 
 typedef struct
 {
-   uint32_t img_x;
-   uint32_t img_y;
+   unsigned char *img_buffer;
+   unsigned char *img_buffer_end;
+   unsigned char *img_buffer_original;
    int img_n;
    int img_out_n;
-
    int buflen;
+   uint32_t img_x;
+   uint32_t img_y;
    unsigned char buffer_start[128];
-
-   unsigned char *img_buffer;
-   unsigned char *img_buffer_end;
-   unsigned char *img_buffer_original;
 } rbmp_context;
 
 struct rbmp
@@ -107,40 +105,40 @@ static unsigned char *rbmp_convert_format(
       switch (((img_n)*8+(req_comp)))
       {
          case 10:
-            for(i = x-1; i >= 0; --i, src += 1, dest += 2)
+            for (i = x-1; i >= 0; --i, src += 1, dest += 2)
             {
                dest[0]=src[0];
                dest[1]=255;
             }
             break;
          case 11:
-            for(i = x-1; i >= 0; --i, src += 1, dest += 3)
+            for (i = x-1; i >= 0; --i, src += 1, dest += 3)
                dest[0]=dest[1]=dest[2]=src[0];
             break;
          case 12:
-            for(i = x-1; i >= 0; --i, src += 1, dest += 4)
+            for (i = x-1; i >= 0; --i, src += 1, dest += 4)
             {
                dest[0]=dest[1]=dest[2]=src[0];
                dest[3]=255;
             }
             break;
          case 17:
-            for(i = x-1; i >= 0; --i, src += 2, dest += 1)
+            for (i = x-1; i >= 0; --i, src += 2, dest += 1)
                dest[0]=src[0];
             break;
          case 19:
-            for(i = x-1; i >= 0; --i, src += 2, dest += 3)
+            for (i = x-1; i >= 0; --i, src += 2, dest += 3)
                dest[0]=dest[1]=dest[2]=src[0];
             break;
          case 20:
-            for(i = x-1; i >= 0; --i, src += 2, dest += 4)
+            for (i = x-1; i >= 0; --i, src += 2, dest += 4)
             {
                dest[0]=dest[1]=dest[2]=src[0];
                dest[3]=src[1];
             }
             break;
          case 28:
-            for(i = x-1; i >= 0; --i, src += 3, dest += 4)
+            for (i = x-1; i >= 0; --i, src += 3, dest += 4)
             {
                dest[0]=src[0];
                dest[1]=src[1];
@@ -149,29 +147,29 @@ static unsigned char *rbmp_convert_format(
             }
             break;
          case 25:
-            for(i = x-1; i >= 0; --i, src += 3, dest += 1)
+            for (i = x-1; i >= 0; --i, src += 3, dest += 1)
                dest[0] = RBMP_COMPUTE_Y(src[0],src[1],src[2]);
             break;
          case 26:
-            for(i = x-1; i >= 0; --i, src += 3, dest += 2)
+            for (i = x-1; i >= 0; --i, src += 3, dest += 2)
             {
                dest[0] = RBMP_COMPUTE_Y(src[0],src[1],src[2]);
                dest[1] = 255;
             }
             break;
          case 33:
-            for(i = x-1; i >= 0; --i, src += 4, dest += 1)
+            for (i = x-1; i >= 0; --i, src += 4, dest += 1)
                dest[0] = RBMP_COMPUTE_Y(src[0],src[1],src[2]);
             break;
          case 34:
-            for(i = x-1; i >= 0; --i, src += 4, dest += 2)
+            for (i = x-1; i >= 0; --i, src += 4, dest += 2)
             {
                dest[0] = RBMP_COMPUTE_Y(src[0],src[1],src[2]);
                dest[1] = src[3];
             }
             break;
          case 35:
-            for(i = x-1; i >= 0; --i, src += 4, dest += 3)
+            for (i = x-1; i >= 0; --i, src += 4, dest += 3)
             {
                dest[0]=src[0];
                dest[1]=src[1];
@@ -735,7 +733,7 @@ static void rbmp_convert_frame(uint32_t *frame, unsigned width, unsigned height)
 {
    uint32_t *end = frame + (width * height * sizeof(uint32_t))/4;
 
-   while(frame < end)
+   while (frame < end)
    {
       uint32_t pixel = *frame;
       *frame = (pixel & 0xff00ff00) | ((pixel << 16) & 0x00ff0000) | ((pixel >> 16) & 0xff);
diff --git a/src/libretro/libretro-common/formats/bmp/rbmp_encode.c b/src/libretro/libretro-common/formats/bmp/rbmp_encode.c
index 26aabf6871..0cf619d311 100644
--- a/src/libretro/libretro-common/formats/bmp/rbmp_encode.c
+++ b/src/libretro/libretro-common/formats/bmp/rbmp_encode.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (rbmp_encode.c).
@@ -165,12 +165,12 @@ static void dump_content(RFILE *file, const void *frame,
          {
             /* BGR24 byte order input matches output. Can directly copy, but... need to make sure we pad it. */
             uint32_t zeros = 0;
-            int pad        = (int)(line_size-pitch);
+            int padding    = (int)(line_size-pitch);
             for (j = 0; j < height; j++, u.u8 += pitch)
             {
                filestream_write(file, u.u8, pitch);
-               if(pad != 0)
-                  filestream_write(file, &zeros, pad);
+               if (padding != 0)
+                  filestream_write(file, &zeros, padding);
             }
          }
          break;
@@ -184,8 +184,7 @@ static void dump_content(RFILE *file, const void *frame,
    }
 
    /* allocate line buffer, and initialize the final four bytes to zero, for deterministic padding */
-   line = (uint8_t*)malloc(line_size);
-   if (!line)
+   if (!(line = (uint8_t*)malloc(line_size)))
       return;
    *(uint32_t*)(line + line_size - 4) = 0;
 
diff --git a/src/libretro/libretro-common/formats/cdfs/cdfs.c b/src/libretro/libretro-common/formats/cdfs/cdfs.c
index 2f5ce15001..20cbf147e2 100644
--- a/src/libretro/libretro-common/formats/cdfs/cdfs.c
+++ b/src/libretro/libretro-common/formats/cdfs/cdfs.c
@@ -12,8 +12,7 @@
 static void cdfs_determine_sector_size(cdfs_track_t* track)
 {
    uint8_t buffer[32];
-   int64_t stream_size;
-   const int toc_sector = track->pregap_sectors + 16;
+   const int toc_sector = 16;
 
    /* MODE information is normally found in the CUE sheet, but we can try to determine it from the raw data.
     *
@@ -28,20 +27,26 @@ static void cdfs_determine_sector_size(cdfs_track_t* track)
     */
 
    /* The boot record or primary volume descriptor is always at sector 16 and will contain a "CD001" marker */
-   intfstream_seek(track->stream, toc_sector * 2352, SEEK_SET);
-   if (intfstream_read(track->stream, buffer, sizeof(buffer)) < sizeof(buffer))
+   intfstream_seek(track->stream, toc_sector * 2352 + track->first_sector_offset, SEEK_SET);
+   if (intfstream_read(track->stream, &buffer, sizeof(buffer)) != (int64_t)sizeof(buffer))
       return;
 
    /* if this is a CDROM-XA data source, the "CD001" tag will be 25 bytes into the sector */
-   if (buffer[25] == 0x43 && buffer[26] == 0x44 &&
-      buffer[27] == 0x30 && buffer[28] == 0x30 && buffer[29] == 0x31)
+   if (  buffer[25] == 0x43 
+      && buffer[26] == 0x44
+      && buffer[27] == 0x30 
+      && buffer[28] == 0x30 
+      && buffer[29] == 0x31)
    {
-      track->stream_sector_size = 2352;
+      track->stream_sector_size        = 2352;
       track->stream_sector_header_size = 24;
    }
    /* otherwise it should be 17 bytes into the sector */
-   else if (buffer[17] == 0x43 && buffer[18] == 0x44 &&
-      buffer[19] == 0x30 && buffer[20] == 0x30 && buffer[21] == 0x31)
+   else if (buffer[17] == 0x43
+      &&    buffer[18] == 0x44
+      &&    buffer[19] == 0x30 
+      &&    buffer[20] == 0x30 
+      &&    buffer[21] == 0x31)
    {
       track->stream_sector_size = 2352;
       track->stream_sector_header_size = 16;
@@ -49,44 +54,60 @@ static void cdfs_determine_sector_size(cdfs_track_t* track)
    else
    {
       /* ISO-9660 says the first twelve bytes of a sector should be the sync pattern 00 FF FF FF FF FF FF FF FF FF FF 00 */
-      if (buffer[0] == 0 && buffer[1] == 0xFF && buffer[2] == 0xFF && buffer[3] == 0xFF &&
-         buffer[4] == 0xFF && buffer[5] == 0xFF && buffer[6] == 0xFF && buffer[7] == 0xFF &&
-         buffer[8] == 0xFF && buffer[9] == 0xFF && buffer[10] == 0xFF && buffer[11] == 0)
+      if (
+            buffer[ 0] == 0
+         && buffer[ 1] == 0xFF
+         && buffer[ 2] == 0xFF
+         && buffer[ 3] == 0xFF
+         && buffer[ 4] == 0xFF
+         && buffer[ 5] == 0xFF
+         && buffer[ 6] == 0xFF
+         && buffer[ 7] == 0xFF
+         && buffer[ 8] == 0xFF
+         && buffer[ 9] == 0xFF
+         && buffer[10] == 0xFF 
+         && buffer[11] == 0)
       {
          /* if we didn't find a CD001 tag, this format may predate ISO-9660 */
 
          /* after the 12 byte sync pattern is three bytes identifying the sector and then one byte for the mode (total 16 bytes) */
-         track->stream_sector_size = 2352;
+         track->stream_sector_size        = 2352;
          track->stream_sector_header_size = 16;
       }
-      else
-      {
-         /* no recognizable header - attempt to determine sector size from stream size */
-         stream_size = intfstream_get_size(track->stream);
+   }
+}
 
-         if ((stream_size % 2352) == 0)
-         {
-            /* audio tracks use all 2352 bytes without a header */
-            track->stream_sector_size = 2352;
-         }
-         else if ((stream_size % 2048) == 0)
-         {
-            /* cooked tracks eliminate all header/footer data */
-            track->stream_sector_size = 2048;
-         }
-         else if ((stream_size % 2336) == 0)
-         {
-            /* MODE 2 format without 16-byte sync data */
-            track->stream_sector_size = 2336;
-            track->stream_sector_header_size = 8;
-         }
-      }
+static void cdfs_determine_sector_size_from_file_size(cdfs_track_t* track)
+{
+   /* attempt to determine stream_sector_size from file size */
+   size_t size = intfstream_get_size(track->stream);
+
+   if ((size % 2352) == 0)
+   {
+      /* raw tracks use all 2352 bytes and have a 24 byte header */
+      track->stream_sector_size        = 2352;
+      track->stream_sector_header_size = 24;
+   }
+   else if ((size % 2048) == 0)
+   {
+      /* cooked tracks eliminate all header/footer data */
+      track->stream_sector_size        = 2048;
+      track->stream_sector_header_size = 0;
+   }
+   else if ((size % 2336) == 0)
+   {
+      /* MODE 2 format without 16-byte sync data */
+      track->stream_sector_size        = 2336;
+      track->stream_sector_header_size = 8;
    }
 }
 
 static void cdfs_seek_track_sector(cdfs_track_t* track, unsigned int sector)
 {
-   intfstream_seek(track->stream, (sector + track->pregap_sectors) * track->stream_sector_size + track->stream_sector_header_size, SEEK_SET);
+   intfstream_seek(track->stream,
+           sector * track->stream_sector_size
+         + track->stream_sector_header_size
+         + track->first_sector_offset, SEEK_SET);
 }
 
 void cdfs_seek_sector(cdfs_file_t* file, unsigned int sector)
@@ -94,23 +115,41 @@ void cdfs_seek_sector(cdfs_file_t* file, unsigned int sector)
    /* only allowed if open_file was called with a NULL path */
    if (file->first_sector == 0)
    {
-      if (sector != file->current_sector)
+      if (file->current_sector != (int)sector)
       {
-         file->current_sector = sector;
+         file->current_sector      = (int)sector;
          file->sector_buffer_valid = 0;
       }
 
-      file->pos = file->current_sector * 2048;
-      file->current_sector_offset = 0;
+      file->pos                    = sector * 2048;
+      file->current_sector_offset  = 0;
+   }
+}
+
+uint32_t cdfs_get_num_sectors(cdfs_file_t* file)
+{
+   uint32_t frame_size = intfstream_get_frame_size(file->track->stream);
+   if (frame_size == 0)
+   {
+      frame_size = file->track->stream_sector_size;
+      if (frame_size == 0)
+         frame_size = 1; /* prevent divide by 0 error if sector size is unknown */
    }
+   return (uint32_t)(intfstream_get_size(file->track->stream) / frame_size);
+}
+
+uint32_t cdfs_get_first_sector(cdfs_file_t* file)
+{
+   return file->track->first_sector_index;
 }
 
 static int cdfs_find_file(cdfs_file_t* file, const char* path)
 {
+   size_t path_length;
+   int sector;
    uint8_t buffer[2048], *tmp;
-   int sector, path_length;
-
    const char* slash = strrchr(path, '\\');
+
    if (slash)
    {
       /* navigate the path to the directory record for the file */
@@ -128,12 +167,13 @@ static int cdfs_find_file(cdfs_file_t* file, const char* path)
    {
       int offset;
 
-      /* find the cd information (always 16 frames in) */
+      /* find the CD information (always 16 frames in) */
       cdfs_seek_track_sector(file->track, 16);
       intfstream_read(file->track->stream, buffer, sizeof(buffer));
 
       /* the directory_record starts at 156 bytes into the sector.
-       * the sector containing the root directory contents is a 3 byte value that is 2 bytes into the directory_record. */
+       * the sector containing the root directory contents is a 
+       * 3 byte value that is 2 bytes into the directory_record. */
       offset = 156 + 2;
       sector = buffer[offset] | (buffer[offset + 1] << 8) | (buffer[offset + 2] << 16);
    }
@@ -143,22 +183,30 @@ static int cdfs_find_file(cdfs_file_t* file, const char* path)
    intfstream_read(file->track->stream, buffer, sizeof(buffer));
 
    path_length = strlen(path);
-   tmp = buffer;
+   tmp         = buffer;
+
    while (tmp < buffer + sizeof(buffer))
    {
-      /* the first byte of the record is the length of the record - if 0, we reached the end of the data */
+      /* The first byte of the record is the length of 
+       * the record - if 0, we reached the end of the data */
       if (!*tmp)
          break;
 
-      /* filename is 33 bytes into the record and the format is "FILENAME;version" or "DIRECTORY" */
-      if ((tmp[33 + path_length] == ';' || tmp[33 + path_length] == '\0') &&
-         strncasecmp((const char*)(tmp + 33), path, path_length) == 0)
+      /* filename is 33 bytes into the record and 
+       * the format is "FILENAME;version" or "DIRECTORY" */
+      if (        (tmp[33 + path_length] == ';' 
+               || (tmp[33 + path_length] == '\0'))
+               &&  strncasecmp((const char*)(tmp + 33), path, path_length) == 0)
       {
          /* the file size is in bytes 10-13 of the record */
-         if (!slash)
-            file->size = tmp[10] | (tmp[11] << 8) | (tmp[12] << 16) | (tmp[13] << 24);
-
-         /* the file contents are in the sector identified in bytes 2-4 of the record */
+         file->size = 
+              (tmp[10])
+            | (tmp[11] << 8) 
+            | (tmp[12] << 16) 
+            | (tmp[13] << 24);
+
+         /* the file contents are in the sector identified 
+          * in bytes 2-4 of the record */
          sector = tmp[2] | (tmp[3] << 8) | (tmp[4] << 16);
          return sector;
       }
@@ -177,21 +225,19 @@ int cdfs_open_file(cdfs_file_t* file, cdfs_track_t* track, const char* path)
 
    memset(file, 0, sizeof(*file));
 
-   file->track = track;
-
+   file->track          = track;
    file->current_sector = -1;
-   if (path != NULL)
-   {
+   file->first_sector   = -1;
+
+   if (path)
       file->first_sector = cdfs_find_file(file, path);
-   }
    else if (file->track->stream_sector_size)
    {
       file->first_sector = 0;
-      file->size = (intfstream_get_size(file->track->stream) / file->track->stream_sector_size) * 2048;
-   }
-   else
-   {
-      file->first_sector = -1;
+      file->size         = (unsigned int)((intfstream_get_size(
+               file->track->stream) / file->track->stream_sector_size) 
+         * 2048);
+      return 1;
    }
 
    return (file->first_sector >= 0);
@@ -217,26 +263,29 @@ int64_t cdfs_read_file(cdfs_file_t* file, void* buffer, uint64_t len)
       {
          if (remaining >= len)
          {
-            memcpy(buffer, &file->sector_buffer[file->current_sector_offset], len);
+            memcpy(buffer,
+                  &file->sector_buffer[file->current_sector_offset],
+                  (size_t)len);
             file->current_sector_offset += len;
             return len;
          }
 
-         memcpy(buffer, &file->sector_buffer[file->current_sector_offset], remaining);
-         buffer = (char*)buffer + remaining;
+         memcpy(buffer,
+               &file->sector_buffer[file->current_sector_offset], remaining);
+         buffer      = (char*)buffer + remaining;
          bytes_read += remaining;
-         len -= remaining;
+         len        -= remaining;
 
          file->current_sector_offset += remaining;
       }
 
       ++file->current_sector;
       file->current_sector_offset = 0;
-      file->sector_buffer_valid = 0;
+      file->sector_buffer_valid   = 0;
    }
    else if (file->current_sector < file->first_sector)
    {
-      file->current_sector = file->first_sector;
+      file->current_sector        = file->first_sector;
       file->current_sector_offset = 0;
    }
 
@@ -245,19 +294,20 @@ int64_t cdfs_read_file(cdfs_file_t* file, void* buffer, uint64_t len)
       cdfs_seek_track_sector(file->track, file->current_sector);
       intfstream_read(file->track->stream, buffer, 2048);
 
-      buffer = (char*)buffer + 2048;
+      buffer      = (char*)buffer + 2048;
       bytes_read += 2048;
+
       ++file->current_sector;
 
-      len -= 2048;
+      len        -= 2048;
    }
 
    if (len > 0)
    {
       cdfs_seek_track_sector(file->track, file->current_sector);
       intfstream_read(file->track->stream, file->sector_buffer, 2048);
-      memcpy(buffer, file->sector_buffer, len);
-      file->current_sector_offset = len;
+      memcpy(buffer, file->sector_buffer, (size_t)len);
+      file->current_sector_offset = (unsigned int)len;
       file->sector_buffer_valid   = 1;
 
       bytes_read += len;
@@ -269,18 +319,17 @@ int64_t cdfs_read_file(cdfs_file_t* file, void* buffer, uint64_t len)
 
 void cdfs_close_file(cdfs_file_t* file)
 {
+   /* Not really anything to do here, just 
+    * clear out the first_sector so 
+    * read() won't do anything */
    if (file)
-   {
-      /* not really anything to do here, just clear out the first_sector so read() won't do anything */
       file->first_sector = -1;
-   }
 }
 
 int64_t cdfs_get_size(cdfs_file_t* file)
 {
    if (!file || file->first_sector < 0)
       return 0;
-
    return file->size;
 }
 
@@ -288,7 +337,6 @@ int64_t cdfs_tell(cdfs_file_t* file)
 {
    if (!file || file->first_sector < 0)
       return -1;
-
    return file->pos;
 }
 
@@ -329,7 +377,7 @@ int64_t cdfs_seek(cdfs_file_t* file, int64_t offset, int whence)
    new_sector = file->pos / 2048;
    if (new_sector != file->current_sector)
    {
-      file->current_sector = new_sector;
+      file->current_sector      = new_sector;
       file->sector_buffer_valid = false;
    }
 
@@ -342,32 +390,44 @@ static void cdfs_skip_spaces(const char** ptr)
       ++(*ptr);
 }
 
-static cdfs_track_t* cdfs_wrap_stream(intfstream_t* stream, unsigned pregap_sectors)
+static cdfs_track_t* cdfs_wrap_stream(
+      intfstream_t* stream,
+      unsigned first_sector_offset,
+      unsigned first_sector_index)
 {
-   cdfs_track_t* track;
+   cdfs_track_t* track = NULL;
 
-   if (stream == NULL)
+   if (!stream)
       return NULL;
 
-   track = (cdfs_track_t*)calloc(1, sizeof(*track));
-   track->stream = stream;
-   track->pregap_sectors = pregap_sectors;
+   track                      = (cdfs_track_t*)
+      calloc(1, sizeof(*track));
+   track->stream              = stream;
+   track->first_sector_offset = first_sector_offset;
+   track->first_sector_index  = first_sector_index;
+
    cdfs_determine_sector_size(track);
+
    return track;
 }
 
-static cdfs_track_t* cdfs_open_cue_track(const char* path, unsigned int track_index)
+static cdfs_track_t* cdfs_open_cue_track(
+      const char* path, unsigned int track_index)
 {
    char* cue                                = NULL;
    const char* line                         = NULL;
    int found_track                          = 0;
    char current_track_path[PATH_MAX_LENGTH] = {0};
    char track_path[PATH_MAX_LENGTH]         = {0};
-   unsigned int pregap_sectors              = 0;
+   unsigned int sector_size                 = 0;
+   unsigned int previous_sector_size        = 0;
+   unsigned int previous_index_sector_offset= 0;
+   unsigned int track_offset                = 0;
    intfstream_t *cue_stream                 = intfstream_open_file(path, RETRO_VFS_FILE_ACCESS_READ, RETRO_VFS_FILE_ACCESS_HINT_NONE);
    int64_t stream_size                      = intfstream_get_size(cue_stream);
-   char *cue_contents                       = (char*)malloc(stream_size + 1);
-    
+   char *cue_contents                       = (char*)malloc((size_t)(stream_size + 1));
+   cdfs_track_t* track                      = NULL;
+
    if (!cue_contents)
    {
       intfstream_close(cue_stream);
@@ -401,7 +461,8 @@ static cdfs_track_t* cdfs_open_cue_track(const char* path, unsigned int track_in
             while (file_end > file && *file_end != ' ' && *file_end != '\t')
                --file_end;
 
-            if (file[0] == '"' && file_end[-1] == '"')
+            if (     file[0]      == '"' 
+                  && file_end[-1] == '"')
             {
                ++file;
                --file_end;
@@ -410,67 +471,69 @@ static cdfs_track_t* cdfs_open_cue_track(const char* path, unsigned int track_in
             memcpy(current_track_path, file, file_end - file);
             current_track_path[file_end - file] = '\0';
          }
+
+         previous_sector_size = 0;
+         previous_index_sector_offset = 0;
+         track_offset = 0;
       }
       else if (!strncasecmp(line, "TRACK", 5))
       {
+         char *ptr             = NULL;
          unsigned track_number = 0;
-
-         const char *track = line + 5;
+         const char *track     = line + 5;
          cdfs_skip_spaces(&track);
 
-         sscanf(track, "%d", &track_number);
+         track_number = (unsigned)strtol(track, &ptr, 10);
+         while (*track && *track != ' ' && *track != '\n')
+            ++track;
+
+         previous_sector_size = sector_size;
+
+         cdfs_skip_spaces(&track);
 
-         if (track_index)
+         if (!strncasecmp(track, "MODE", 4))
          {
-            if (track_index == track_number)
+            /* track_index = 0 means find the first data track */
+            if (!track_index || track_index == track_number)
                found_track = track_number;
-         }
-         else /* track_index = 0 means find the first data track */
-         {
-            while (track[0] && track[0] != ' ' && track[0] != '\t')
-               track++;
 
-            if (track[0])
-            {
-               cdfs_skip_spaces(&track);
-
-               if (!strncasecmp(track, "MODE", 4))
-                  found_track = track_number;
-            }
+            sector_size = atoi(track + 6);
          }
+         else /* assume AUDIO */
+            sector_size = 2352;
       }
-      else if (found_track && !strncasecmp(line, "INDEX", 5))
+      else if (!strncasecmp(line, "INDEX", 5))
       {
-         const char *index = line + 5;
+         unsigned sector_offset;
+         unsigned min = 0, sec = 0, frame = 0;
+         unsigned index_number = 0;
+         const char *index     = line + 5;
+
+         cdfs_skip_spaces(&index);
+         sscanf(index, "%u", &index_number);
+         while (*index && *index != ' ' && *index != '\n')
+            ++index;
          cdfs_skip_spaces(&index);
 
-         if (index[0])
-         {
-            unsigned index_number = 0;
-            sscanf(index, "%u", &index_number);
+         sscanf(index, "%u:%u:%u", &min, &sec, &frame);
+         sector_offset                 = ((min * 60) + sec) * 75 + frame;
+         sector_offset                -= previous_index_sector_offset;
+         track_offset                 += sector_offset * previous_sector_size;
+         previous_sector_size          = sector_size;
+         previous_index_sector_offset += sector_offset;
 
-            if (index_number == 1)
+         if (found_track && index_number == 1)
+         {
+            if (     strstr(current_track_path, "/")
+                  || strstr(current_track_path, "\\"))
+               strncpy(track_path, current_track_path, sizeof(track_path));
+            else
             {
-               unsigned min = 0, sec = 0, frame = 0;
-               const char* ptr = index;
-               while (*ptr && *ptr != ' ' && *ptr != '\n')
-                  ++ptr;
-               cdfs_skip_spaces(&ptr);
-               sscanf(ptr, "%u:%u:%u", &min, &sec, &frame);
-               pregap_sectors = ((min * 60) + sec) * 75 + frame;
-
-               if (strstr(current_track_path, "/") || strstr(current_track_path, "\\"))
-               {
-                  strncpy(track_path, current_track_path, sizeof(track_path));
-               }
-               else
-               {
-                  fill_pathname_basedir(track_path, path, sizeof(track_path));
-                  strlcat(track_path, current_track_path, sizeof(track_path));
-               }
-
-               break;
+               fill_pathname_basedir(track_path, path, sizeof(track_path));
+               strlcat(track_path, current_track_path, sizeof(track_path));
             }
+
+            break;
          }
       }
    }
@@ -480,32 +543,56 @@ static cdfs_track_t* cdfs_open_cue_track(const char* path, unsigned int track_in
    if (string_is_empty(track_path))
       return NULL;
 
-   return cdfs_wrap_stream(intfstream_open_file(track_path, RETRO_VFS_FILE_ACCESS_READ, RETRO_VFS_FILE_ACCESS_HINT_NONE), pregap_sectors);
+   /* NOTE: previous_index_sector_offset will only be valid if all tracks are in the same BIN file.
+    * Otherwise, we need to determine how many tracks are in each previous BIN file, which is not
+    * stored in the CUE file. This will affect cdfs_get_first_sector, which luckily isn't used much. */
+   track = cdfs_wrap_stream(intfstream_open_file(
+            track_path, RETRO_VFS_FILE_ACCESS_READ,
+            RETRO_VFS_FILE_ACCESS_HINT_NONE), track_offset, previous_index_sector_offset);
+
+   if (track && track->stream_sector_size == 0)
+   {
+      track->stream_sector_size = sector_size;
+
+      if (sector_size == 2352)
+         track->stream_sector_header_size = 16;
+      else if (sector_size == 2336)
+         track->stream_sector_header_size = 8;
+   }
+
+   return track;
 }
 
 #ifdef HAVE_CHD
 static cdfs_track_t* cdfs_open_chd_track(const char* path, int32_t track_index)
 {
-   intfstream_t* intf_stream;
-   cdfs_track_t* track;
-   unsigned int pregap_sectors;
-
-   intf_stream = intfstream_open_chd_track(path, RETRO_VFS_FILE_ACCESS_READ, RETRO_VFS_FILE_ACCESS_HINT_NONE, track_index);
+   cdfs_track_t *track;
+   intfstream_t *intf_stream = intfstream_open_chd_track(path,
+         RETRO_VFS_FILE_ACCESS_READ, RETRO_VFS_FILE_ACCESS_HINT_NONE,
+         track_index);
    if (!intf_stream)
       return NULL;
 
-   pregap_sectors = intfstream_get_chd_pregap(intf_stream);
+   track = cdfs_wrap_stream(intf_stream,
+         intfstream_get_offset_to_start(intf_stream),
+         intfstream_get_first_sector(intf_stream));
 
-   track = cdfs_wrap_stream(intf_stream, pregap_sectors);
+   if (track && track->stream_sector_header_size == 0)
+   {
+      track->stream_sector_size = intfstream_get_frame_size(intf_stream);
+
+      if (track->stream_sector_size == 2352)
+         track->stream_sector_header_size = 16;
+      else if (track->stream_sector_size == 2336)
+         track->stream_sector_header_size = 8;
+   }
 
-   /* CHD removes the markers from the header, so we can't detect the header size, just assume its 16 bytes */
-   if (track->stream_sector_header_size == 0)
-      track->stream_sector_header_size = 16;
    return track;
 }
 #endif
 
-struct cdfs_track_t* cdfs_open_track(const char* path, unsigned int track_index)
+struct cdfs_track_t* cdfs_open_track(const char* path,
+      unsigned int track_index)
 {
    const char* ext = path_get_extension(path);
 
@@ -517,6 +604,10 @@ struct cdfs_track_t* cdfs_open_track(const char* path, unsigned int track_index)
       return cdfs_open_chd_track(path, track_index);
 #endif
 
+   /* if opening track 1, try opening as a raw track */
+   if (track_index == 1)
+      return cdfs_open_raw_track(path);
+
    /* unsupported file type */
    return NULL;
 }
@@ -539,20 +630,40 @@ struct cdfs_track_t* cdfs_open_data_track(const char* path)
 
 cdfs_track_t* cdfs_open_raw_track(const char* path)
 {
-   const char* ext = path_get_extension(path);
+   const char *ext     = path_get_extension(path);
+   cdfs_track_t *track = NULL;
 
-   if (string_is_equal_noncase(ext, "bin") || string_is_equal_noncase(ext, "iso"))
-      return cdfs_wrap_stream(intfstream_open_file(path, RETRO_VFS_FILE_ACCESS_READ, RETRO_VFS_FILE_ACCESS_HINT_NONE), 0);
+   if (     string_is_equal_noncase(ext, "bin")
+         || string_is_equal_noncase(ext, "iso"))
+   {
+      intfstream_t* file = intfstream_open_file(path,
+         RETRO_VFS_FILE_ACCESS_READ, RETRO_VFS_FILE_ACCESS_HINT_NONE);
 
-   /* unsupported file type */
-   return NULL;
+      track = cdfs_wrap_stream(file, 0, 0);
+      if (track && track->stream_sector_size == 0)
+      {
+         cdfs_determine_sector_size_from_file_size(track);
+         if (track->stream_sector_size == 0)
+         {
+            cdfs_close_track(track);
+            track = NULL;
+         }
+      }
+   }
+
+   return track;
 }
 
 void cdfs_close_track(cdfs_track_t* track)
 {
    if (track)
    {
-      intfstream_close(track->stream);
+      if (track->stream)
+      {
+         intfstream_close(track->stream);
+         free(track->stream);
+      }
+
       free(track);
    }
 }
diff --git a/src/libretro/libretro-common/formats/image_texture.c b/src/libretro/libretro-common/formats/image_texture.c
index 2e16fcbf7b..bfd7e78dd5 100644
--- a/src/libretro/libretro-common/formats/image_texture.c
+++ b/src/libretro/libretro-common/formats/image_texture.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (image_texture.c).
@@ -28,26 +28,51 @@
 #include <boolean.h>
 #include <formats/image.h>
 #include <file/nbio.h>
-
+#include <string/stdstring.h>
 
 enum image_type_enum image_texture_get_type(const char *path)
 {
-#ifdef HAVE_RTGA
-   if (strstr(path, ".tga"))
-      return IMAGE_TYPE_TGA;
-#endif
+   /* We are comparing against a fixed list of file
+    * extensions, the longest (jpeg) being 4 characters
+    * in length. We therefore only need to extract the first
+    * 5 characters from the extension of the input path
+    * to correctly validate a match */
+   const char *ext = NULL;
+   char ext_lower[6];
+
+   ext_lower[0] = '\0';
+
+   if (string_is_empty(path))
+      return IMAGE_TYPE_NONE;
+
+   /* Get file extension */
+   ext = strrchr(path, '.');
+
+   if (!ext || (*(++ext) == '\0'))
+      return IMAGE_TYPE_NONE;
+
+   /* Copy and convert to lower case */
+   strlcpy(ext_lower, ext, sizeof(ext_lower));
+   string_to_lower(ext_lower);
+
 #ifdef HAVE_RPNG
-   if (strstr(path, ".png"))
+   if (string_is_equal(ext_lower, "png"))
       return IMAGE_TYPE_PNG;
 #endif
 #ifdef HAVE_RJPEG
-   if (strstr(path, ".jpg") || strstr(path, ".jpeg"))
+   if (string_is_equal(ext_lower, "jpg") ||
+       string_is_equal(ext_lower, "jpeg"))
       return IMAGE_TYPE_JPEG;
 #endif
 #ifdef HAVE_RBMP
-   if (strstr(path, ".bmp"))
+   if (string_is_equal(ext_lower, "bmp"))
       return IMAGE_TYPE_BMP;
 #endif
+#ifdef HAVE_RTGA
+   if (string_is_equal(ext_lower, "tga"))
+      return IMAGE_TYPE_TGA;
+#endif
+
    return IMAGE_TYPE_NONE;
 }
 
@@ -90,8 +115,13 @@ bool image_texture_color_convert(unsigned r_shift,
          uint8_t r    = (uint8_t)(col >> 16);
          uint8_t g    = (uint8_t)(col >>  8);
          uint8_t b    = (uint8_t)(col >>  0);
-         pixels[i]    = (a << a_shift) |
-            (r << r_shift) | (g << g_shift) | (b << b_shift);
+         /* Explicitly cast these to uint32_t to prevent
+          * ASAN runtime error: left shift of 255 by 24 places
+          * cannot be represented in type 'int' */
+         pixels[i]    = ((uint32_t)a << a_shift) |
+                        ((uint32_t)r << r_shift) |
+                        ((uint32_t)g << g_shift) |
+                        ((uint32_t)b << b_shift);
       }
 
       return true;
@@ -190,7 +220,7 @@ static bool image_texture_load_internal(
       ret = image_transfer_process(img, type,
             (uint32_t**)&out_img->pixels, len, &out_img->width,
             &out_img->height);
-   }while(ret == IMAGE_PROCESS_NEXT);
+   } while (ret == IMAGE_PROCESS_NEXT);
 
    if (ret == IMAGE_PROCESS_ERROR || ret == IMAGE_PROCESS_ERROR_END)
       goto end;
diff --git a/src/libretro/libretro-common/formats/image_transfer.c b/src/libretro/libretro-common/formats/image_transfer.c
index c47a308818..76759ef468 100644
--- a/src/libretro/libretro-common/formats/image_transfer.c
+++ b/src/libretro/libretro-common/formats/image_transfer.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (image_transfer.c).
@@ -22,7 +22,8 @@
 
 #include <stdint.h>
 #include <string.h>
-#include <errno.h>
+
+#include <boolean.h>
 
 #ifdef HAVE_RPNG
 #include <formats/rpng.h>
diff --git a/src/libretro/libretro-common/formats/jpeg/rjpeg.c b/src/libretro/libretro-common/formats/jpeg/rjpeg.c
index 38b2f8aaed..166731c0ac 100644
--- a/src/libretro/libretro-common/formats/jpeg/rjpeg.c
+++ b/src/libretro/libretro-common/formats/jpeg/rjpeg.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (rjpeg.c).
@@ -28,7 +28,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include <retro_assert.h>
 #include <retro_inline.h>
 #include <boolean.h>
 #include <formats/image.h>
@@ -141,17 +140,15 @@ struct rjpeg
 
 typedef struct
 {
-   uint32_t img_x;
-   uint32_t img_y;
+   uint8_t *img_buffer;
+   uint8_t *img_buffer_end;
+   uint8_t *img_buffer_original;
    int      img_n;
    int      img_out_n;
-
    int      buflen;
+   uint32_t img_x;
+   uint32_t img_y;
    uint8_t  buffer_start[128];
-
-   uint8_t *img_buffer;
-   uint8_t *img_buffer_end;
-   uint8_t *img_buffer_original;
 } rjpeg_context;
 
 static INLINE uint8_t rjpeg_get8(rjpeg_context *s)
@@ -171,31 +168,32 @@ static INLINE uint8_t rjpeg_get8(rjpeg_context *s)
 
 typedef struct
 {
-   uint8_t  fast[1 << FAST_BITS];
+   unsigned int maxcode[18];
+   int    delta[17];   /* old 'firstsymbol' - old 'firstcode' */
    /* weirdly, repacking this into AoS is a 10% speed loss, instead of a win */
    uint16_t code[256];
+   uint8_t  fast[1 << FAST_BITS];
    uint8_t  values[256];
    uint8_t  size[257];
-   unsigned int maxcode[18];
-   int    delta[17];   /* old 'firstsymbol' - old 'firstcode' */
 } rjpeg_huffman;
 
 typedef struct
 {
    rjpeg_context *s;
-   rjpeg_huffman huff_dc[4];
-   rjpeg_huffman huff_ac[4];
-   uint8_t dequant[4][64];
-   int16_t fast_ac[4][1 << FAST_BITS];
-
-   /* sizes for components, interleaved MCUs */
-   int img_h_max, img_v_max;
-   int img_mcu_x, img_mcu_y;
-   int img_mcu_w, img_mcu_h;
+   /* kernels */
+   void (*idct_block_kernel)(uint8_t *out, int out_stride, short data[64]);
+   void (*YCbCr_to_RGB_kernel)(uint8_t *out, const uint8_t *y, const uint8_t *pcb,
+         const uint8_t *pcr, int count, int step);
+   uint8_t *(*resample_row_hv_2_kernel)(uint8_t *out, uint8_t *in_near,
+         uint8_t *in_far, int w, int hs);
 
    /* definition of jpeg image component */
    struct
    {
+      uint8_t *data;
+      void *raw_data, *raw_coeff;
+      uint8_t *linebuf;
+      short   *coeff;            /* progressive only */
       int id;
       int h,v;
       int tq;
@@ -203,35 +201,31 @@ typedef struct
       int dc_pred;
 
       int x,y,w2,h2;
-      uint8_t *data;
-      void *raw_data, *raw_coeff;
-      uint8_t *linebuf;
-      short   *coeff;            /* progressive only */
       int      coeff_w;          /* number of 8x8 coefficient blocks */
       int      coeff_h;          /* number of 8x8 coefficient blocks */
    } img_comp[4];
 
-   uint32_t       code_buffer;   /* jpeg entropy-coded buffer */
+   /* sizes for components, interleaved MCUs */
+   int img_h_max, img_v_max;
+   int img_mcu_x, img_mcu_y;
+   int img_mcu_w, img_mcu_h;
+
    int            code_bits;     /* number of valid bits */
-   unsigned char  marker;        /* marker seen while filling entropy buffer */
    int            nomore;        /* flag if we saw a marker so must stop */
-
    int            progressive;
    int            spec_start;
    int            spec_end;
    int            succ_high;
    int            succ_low;
    int            eob_run;
-
    int scan_n, order[4];
    int restart_interval, todo;
-
-   /* kernels */
-   void (*idct_block_kernel)(uint8_t *out, int out_stride, short data[64]);
-   void (*YCbCr_to_RGB_kernel)(uint8_t *out, const uint8_t *y, const uint8_t *pcb,
-         const uint8_t *pcr, int count, int step);
-   uint8_t *(*resample_row_hv_2_kernel)(uint8_t *out, uint8_t *in_near,
-         uint8_t *in_far, int w, int hs);
+   uint32_t       code_buffer;   /* jpeg entropy-coded buffer */
+   rjpeg_huffman huff_dc[4];     /* unsigned int alignment */
+   rjpeg_huffman huff_ac[4];     /* unsigned int alignment */
+   int16_t fast_ac[4][1 << FAST_BITS];
+   unsigned char  marker;        /* marker seen while filling entropy buffer */
+   uint8_t dequant[4][64];
 } rjpeg_jpeg;
 
 #define RJPEG_F2F(x)  ((int) (((x) * 4096 + 0.5)))
@@ -417,7 +411,6 @@ static INLINE int rjpeg_jpeg_huff_decode(rjpeg_jpeg *j, rjpeg_huffman *h)
 
    /* convert the huffman code to the symbol id */
    c = ((j->code_buffer >> (32 - k)) & rjpeg_bmask[k]) + h->delta[k];
-   retro_assert((((j->code_buffer) >> (32 - h->size[c])) & rjpeg_bmask[h->size[c]]) == h->code[c]);
 
    /* convert the id to a symbol */
    j->code_bits -= k;
@@ -437,9 +430,8 @@ static INLINE int rjpeg_extend_receive(rjpeg_jpeg *j, int n)
    if (j->code_bits < n)
       rjpeg_grow_buffer_unsafe(j);
 
-   sgn = (int32_t)j->code_buffer >> 31; /* sign bit is always in MSB */
-   k = RJPEG_LROT(j->code_buffer, n);
-   retro_assert(n >= 0 && n < (int) (sizeof(rjpeg_bmask)/sizeof(*rjpeg_bmask)));
+   sgn             = (int32_t)j->code_buffer >> 31; /* sign bit is always in MSB */
+   k               = RJPEG_LROT(j->code_buffer, n);
    j->code_buffer  = k & ~rjpeg_bmask[n];
    k              &= rjpeg_bmask[n];
    j->code_bits   -= n;
diff --git a/src/libretro/libretro-common/formats/libchdr/libchdr_chd.c b/src/libretro/libretro-common/formats/libchdr/libchdr_chd.c
index d076ee1291..9a157cce8f 100644
--- a/src/libretro/libretro-common/formats/libchdr/libchdr_chd.c
+++ b/src/libretro/libretro-common/formats/libchdr/libchdr_chd.c
@@ -65,8 +65,6 @@
 #define TRUE 1
 #define FALSE 0
 
-#define CHD_MAKE_TAG(a,b,c,d)       (((a) << 24) | ((b) << 16) | ((c) << 8) | (d))
-
 /***************************************************************************
     DEBUGGING
 ***************************************************************************/
@@ -95,18 +93,22 @@
 
 #define NO_MATCH					(~0)
 
-#define MAP_ENTRY_TYPE_INVALID		0x0000		/* invalid type */
-#define MAP_ENTRY_TYPE_COMPRESSED	0x0001		/* standard compression */
-#define MAP_ENTRY_TYPE_UNCOMPRESSED	0x0002		/* uncompressed data */
-#define MAP_ENTRY_TYPE_MINI			0x0003		/* mini: use offset as raw data */
-#define MAP_ENTRY_TYPE_SELF_HUNK	   0x0004		/* same as another hunk in this file */
-#define MAP_ENTRY_TYPE_PARENT_HUNK	0x0005		/* same as a hunk in the parent file */
-#define MAP_ENTRY_TYPE_2ND_COMPRESSED 0x0006    /* compressed with secondary algorithm (usually FLAC CDDA) */
-
 #ifdef WANT_RAW_DATA_SECTOR
 const uint8_t s_cd_sync_header[12] = { 0x00,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00 };
 #endif
 
+/* V3-V4 entry types */
+enum
+{
+	V34_MAP_ENTRY_TYPE_INVALID = 0,             /* invalid type */
+	V34_MAP_ENTRY_TYPE_COMPRESSED = 1,          /* standard compression */
+	V34_MAP_ENTRY_TYPE_UNCOMPRESSED = 2,        /* uncompressed data */
+	V34_MAP_ENTRY_TYPE_MINI = 3,                /* mini: use offset as raw data */
+	V34_MAP_ENTRY_TYPE_SELF_HUNK = 4,           /* same as another hunk in this file */
+	V34_MAP_ENTRY_TYPE_PARENT_HUNK = 5,         /* same as a hunk in the parent file */
+	V34_MAP_ENTRY_TYPE_2ND_COMPRESSED = 6       /* compressed with secondary algorithm (usually FLAC CDDA) */
+};
+
 /* V5 compression types */
 enum
 {
@@ -147,8 +149,6 @@ enum
     MACROS
 ***************************************************************************/
 
-#define SET_ERROR_AND_CLEANUP(err) do { last_error = (err); goto cleanup; } while (0)
-
 #define EARLY_EXIT(x)				do { (void)(x); goto cleanup; } while (0)
 
 /***************************************************************************
@@ -262,13 +262,6 @@ static chd_error metadata_find_entry(chd_file *chd, UINT32 metatag, UINT32 metai
     CODEC INTERFACES
 ***************************************************************************/
 
-#define CHD_MAKE_TAG(a,b,c,d)       (((a) << 24) | ((b) << 16) | ((c) << 8) | (d))
-
-/* general codecs with CD frontend */
-#define CHD_CODEC_CD_ZLIB CHD_MAKE_TAG('c','d','z','l')
-#define CHD_CODEC_CD_LZMA CHD_MAKE_TAG('c','d','l','z')
-#define CHD_CODEC_CD_FLAC CHD_MAKE_TAG('c','d','f','l')
-
 static const codec_interface codec_interfaces[] =
 {
 	/* "none" or no compression */
@@ -305,6 +298,17 @@ static const codec_interface codec_interfaces[] =
 		NULL
 	},
 
+   /* V5 zlib compression */
+	{
+		CHD_CODEC_ZLIB,
+		"zlib (Deflate)",
+		FALSE,
+		zlib_codec_init,
+		zlib_codec_free,
+		zlib_codec_decompress,
+		NULL
+	},
+
 	/* V5 CD zlib compression */
 	{
 		CHD_CODEC_CD_ZLIB,
@@ -417,20 +421,22 @@ static INLINE UINT32 get_bigendian_uint32(const UINT8 *base)
     the data stream in bigendian order
 -------------------------------------------------*/
 
-static INLINE void put_bigendian_uint24(UINT8 *base, UINT32 value)
+#if 0
+static INLINE void put_bigendian_uint32(UINT8 *base, UINT32 value)
 {
-	value &= 0xffffff;
-	base[0] = value >> 16;
-	base[1] = value >> 8;
-	base[2] = value;
+   base[0] = value >> 24;
+	base[1] = value >> 16;
+	base[2] = value >> 8;
+	base[3] = value;
 }
+#endif
 
 /*-------------------------------------------------
     put_bigendian_uint24 - write a UINT24 to
     the data stream in bigendian order
 -------------------------------------------------*/
 
-static INLINE void put_bigendian_uint32(UINT8 *base, UINT32 value)
+static INLINE void put_bigendian_uint24(UINT8 *base, UINT32 value)
 {
 	value &= 0xffffff;
 	base[0] = value >> 16;
@@ -487,6 +493,7 @@ static INLINE void map_extract(const UINT8 *base, map_entry *entry)
     entry to the datastream
 -------------------------------------------------*/
 
+#if 0
 static INLINE void map_assemble(UINT8 *base, map_entry *entry)
 {
 	put_bigendian_uint64(&base[0], entry->offset);
@@ -495,6 +502,7 @@ static INLINE void map_assemble(UINT8 *base, map_entry *entry)
 	base[14] = entry->length >> 16;
 	base[15] = entry->flags;
 }
+#endif
 
 /*-------------------------------------------------
     map_size_v5 - calculate CHDv5 map size
@@ -633,7 +641,7 @@ static chd_error decompress_v5_map(chd_file* chd, chd_header* header)
 		return CHDERR_DECOMPRESSION_ERROR;
 	}
 
-	for (hunknum = 0; hunknum < header->hunkcount; hunknum++)
+	for (hunknum = 0; hunknum < (int)header->hunkcount; hunknum++)
 	{
 		uint8_t *rawmap = header->rawmap + (hunknum * 12);
 		if (repcount > 0)
@@ -662,7 +670,7 @@ static chd_error decompress_v5_map(chd_file* chd, chd_header* header)
 
 	/* then iterate through the hunks and extract the needed data */
 	curoffset = firstoffs;
-	for (hunknum = 0; hunknum < header->hunkcount; hunknum++)
+	for (hunknum = 0; hunknum < (int)header->hunkcount; hunknum++)
 	{
 		uint8_t *rawmap = header->rawmap + (hunknum * 12);
 		uint64_t offset = curoffset;
@@ -745,7 +753,7 @@ static INLINE void map_extract_old(const UINT8 *base, map_entry *entry, UINT32 h
 	entry->offset = get_bigendian_uint64(&base[0]);
 	entry->crc = 0;
 	entry->length = entry->offset >> 44;
-	entry->flags = MAP_ENTRY_FLAG_NO_CRC | ((entry->length == hunkbytes) ? MAP_ENTRY_TYPE_UNCOMPRESSED : MAP_ENTRY_TYPE_COMPRESSED);
+	entry->flags = MAP_ENTRY_FLAG_NO_CRC | ((entry->length == hunkbytes) ? V34_MAP_ENTRY_TYPE_UNCOMPRESSED : V34_MAP_ENTRY_TYPE_COMPRESSED);
 #ifdef __MWERKS__
 	entry->offset = entry->offset & 0x00000FFFFFFFFFFFLL;
 #else
@@ -826,14 +834,13 @@ chd_error chd_open_file(RFILE *file, int mode, chd_file *parent, chd_file **chd)
 	if (newchd->header.version < 5)
 	{
 		err = map_read(newchd);
-		if (err != CHDERR_NONE)
-			EARLY_EXIT(err);
 	}
 	else
 	{
 		err = decompress_v5_map(newchd, &(newchd->header));
-        (void)err;
 	}
+	if (err != CHDERR_NONE)
+		EARLY_EXIT(err);
 
 #ifdef NEED_CACHE_HUNK
 	/* allocate and init the hunk cache */
@@ -853,7 +860,7 @@ chd_error chd_open_file(RFILE *file, int mode, chd_file *parent, chd_file **chd)
 	/* find the codec interface */
 	if (newchd->header.version < 5)
 	{
-		for (intfnum = 0; intfnum < ARRAY_SIZE(codec_interfaces); intfnum++)
+		for (intfnum = 0; intfnum < (int)ARRAY_SIZE(codec_interfaces); intfnum++)
 			if (codec_interfaces[intfnum].compression == newchd->header.compression[0])
 			{
 				newchd->codecintf[0] = &codec_interfaces[intfnum];
@@ -875,9 +882,9 @@ chd_error chd_open_file(RFILE *file, int mode, chd_file *parent, chd_file **chd)
 	{
 		int i, decompnum;
 		/* verify the compression types and initialize the codecs */
-		for (decompnum = 0; decompnum < ARRAY_SIZE(newchd->header.compression); decompnum++)
+		for (decompnum = 0; decompnum < (int)ARRAY_SIZE(newchd->header.compression); decompnum++)
 		{
-			for (i = 0 ; i < ARRAY_SIZE(codec_interfaces) ; i++)
+			for (i = 0 ; i < (int)ARRAY_SIZE(codec_interfaces); i++)
 			{
 				if (codec_interfaces[i].compression == newchd->header.compression[decompnum])
 				{
@@ -894,6 +901,12 @@ chd_error chd_open_file(RFILE *file, int mode, chd_file *parent, chd_file **chd)
 						void* codec = NULL;
 						switch (newchd->header.compression[decompnum])
 						{
+                     case CHD_CODEC_ZLIB:
+#ifdef HAVE_ZLIB
+								codec = &newchd->zlib_codec_data;
+#endif
+								break;
+
 							case CHD_CODEC_CD_ZLIB:
 #ifdef HAVE_ZLIB
 								codec = &newchd->cdzl_codec_data;
@@ -940,6 +953,38 @@ chd_error chd_open_file(RFILE *file, int mode, chd_file *parent, chd_file **chd)
 	return err;
 }
 
+/*-------------------------------------------------
+    chd_precache - precache underlying file in
+    memory
+-------------------------------------------------*/
+
+chd_error chd_precache(chd_file *chd)
+{
+	int64_t size, count;
+
+	if (!chd->file_cache)
+	{
+		filestream_seek(chd->file, 0, SEEK_END);
+		size = filestream_tell(chd->file);
+		if (size <= 0)
+			return CHDERR_INVALID_DATA;
+		chd->file_cache = (UINT8*)malloc(size);
+		if (chd->file_cache == NULL)
+			return CHDERR_OUT_OF_MEMORY;
+		filestream_seek(chd->file, 0, SEEK_SET);
+		count = filestream_read(chd->file, chd->file_cache, size);
+		if (count != size)
+		{
+			free(chd->file_cache);
+			chd->file_cache = NULL;
+			return CHDERR_READ_ERROR;
+		}
+	}
+
+	return CHDERR_NONE;
+}
+
+
 /*-------------------------------------------------
     chd_open - open a CHD file by
     filename
@@ -986,32 +1031,6 @@ chd_error chd_open(const char *filename, int mode, chd_file *parent, chd_file **
 	return err;
 }
 
-chd_error chd_precache(chd_file *chd)
-{
-	int64_t size, count;
-
-	if (!chd->file_cache)
-	{
-		filestream_seek(chd->file, 0, SEEK_END);
-		size = filestream_tell(chd->file);
-		if (size <= 0)
-			return CHDERR_INVALID_DATA;
-		chd->file_cache = (UINT8*)malloc(size);
-		if (chd->file_cache == NULL)
-			return CHDERR_OUT_OF_MEMORY;
-		filestream_seek(chd->file, 0, SEEK_SET);
-		count = filestream_read(chd->file, chd->file_cache, size);
-		if (count != size)
-		{
-			free(chd->file_cache);
-			chd->file_cache = NULL;
-			return CHDERR_READ_ERROR;
-		}
-	}
-
-	return CHDERR_NONE;
-}
-
 /*-------------------------------------------------
     chd_close - close a CHD file for access
 -------------------------------------------------*/
@@ -1048,6 +1067,12 @@ void chd_close(chd_file *chd)
 #endif
                break;
 
+            case CHD_CODEC_ZLIB:
+#ifdef HAVE_ZLIB
+               codec = &chd->zlib_codec_data;
+#endif
+               break;
+
             case CHD_CODEC_CD_ZLIB:
 #ifdef HAVE_ZLIB
                codec = &chd->cdzl_codec_data;
@@ -1214,7 +1239,13 @@ chd_error chd_get_metadata(chd_file *chd, UINT32 searchtag, UINT32 searchindex,
 			UINT32 faux_length;
 
 			/* fill in the faux metadata */
-			sprintf(faux_metadata, HARD_DISK_METADATA_FORMAT, chd->header.obsolete_cylinders, chd->header.obsolete_heads, chd->header.obsolete_sectors, chd->header.hunkbytes / chd->header.obsolete_hunksize);
+			snprintf(faux_metadata,
+               sizeof(faux_metadata),
+               HARD_DISK_METADATA_FORMAT,
+               chd->header.obsolete_cylinders,
+               chd->header.obsolete_heads,
+               chd->header.obsolete_sectors,
+               chd->header.hunkbytes / chd->header.obsolete_hunksize);
 			faux_length = (UINT32)strlen(faux_metadata) + 1;
 
 			/* copy the metadata itself */
@@ -1304,7 +1335,7 @@ static chd_error header_validate(const chd_header *header)
 			return CHDERR_INVALID_PARAMETER;
 
 		/* require a supported compression mechanism */
-		for (intfnum = 0; intfnum < ARRAY_SIZE(codec_interfaces); intfnum++)
+		for (intfnum = 0; intfnum < (int)ARRAY_SIZE(codec_interfaces); intfnum++)
 			if (codec_interfaces[intfnum].compression == header->compression[0])
 				break;
 
@@ -1357,6 +1388,7 @@ static UINT32 header_guess_unitbytes(chd_file *chd)
 	if (chd_get_metadata(chd, CDROM_OLD_METADATA_TAG, 0, metadata, sizeof(metadata), NULL, NULL, NULL) == CHDERR_NONE ||
 		chd_get_metadata(chd, CDROM_TRACK_METADATA_TAG, 0, metadata, sizeof(metadata), NULL, NULL, NULL) == CHDERR_NONE ||
 		chd_get_metadata(chd, CDROM_TRACK_METADATA2_TAG, 0, metadata, sizeof(metadata), NULL, NULL, NULL) == CHDERR_NONE ||
+      chd_get_metadata(chd, GDROM_OLD_METADATA_TAG, 0, metadata, sizeof(metadata), NULL, NULL, NULL) == CHDERR_NONE ||
 		chd_get_metadata(chd, GDROM_TRACK_METADATA_TAG, 0, metadata, sizeof(metadata), NULL, NULL, NULL) == CHDERR_NONE)
 		return CD_FRAME_SIZE;
 
@@ -1531,19 +1563,29 @@ static chd_error hunk_read_into_cache(chd_file *chd, UINT32 hunknum)
 }
 #endif
 
-static UINT8* read_compressed(chd_file *chd, UINT64 offset, size_t size)
+/*-------------------------------------------------
+    hunk_read_compressed - read a compressed
+    hunk
+-------------------------------------------------*/
+
+static UINT8* hunk_read_compressed(chd_file *chd, UINT64 offset, size_t size)
 {
    int64_t bytes;
    if (chd->file_cache)
       return chd->file_cache + offset;
    filestream_seek(chd->file, offset, SEEK_SET);
    bytes = filestream_read(chd->file, chd->compressed, size);
-   if (bytes != size)
+   if (bytes != (int64_t)size)
       return NULL;
    return chd->compressed;
 }
 
-static chd_error read_uncompressed(chd_file *chd, UINT64 offset, size_t size, UINT8 *dest)
+/*-------------------------------------------------
+    hunk_read_uncompressed - read an uncompressed
+    hunk
+-------------------------------------------------*/
+
+static chd_error hunk_read_uncompressed(chd_file *chd, UINT64 offset, size_t size, UINT8 *dest)
 {
    int64_t bytes;
    if (chd->file_cache)
@@ -1553,7 +1595,7 @@ static chd_error read_uncompressed(chd_file *chd, UINT64 offset, size_t size, UI
    }
    filestream_seek(chd->file, offset, SEEK_SET);
    bytes = filestream_read(chd->file, dest, size);
-   if (bytes != size)
+   if (bytes != (int64_t)size)
       return CHDERR_READ_ERROR;
    return CHDERR_NONE;
 }
@@ -1582,17 +1624,20 @@ static chd_error hunk_read_into_memory(chd_file *chd, UINT32 hunknum, UINT8 *des
 	{
 		map_entry *entry = &chd->map[hunknum];
 		UINT32 bytes;
+      UINT8* compressed_bytes;
 
 		/* switch off the entry type */
 		switch (entry->flags & MAP_ENTRY_FLAG_TYPE_MASK)
 		{
 			/* compressed data */
-			case MAP_ENTRY_TYPE_COMPRESSED:
+			case V34_MAP_ENTRY_TYPE_COMPRESSED:
             {
+               /* read it into the decompression buffer */
+
                void *codec;
-               UINT8 *bytes = read_compressed(chd, entry->offset,
+               compressed_bytes = hunk_read_compressed(chd, entry->offset,
                      entry->length);
-               if (bytes == NULL)
+               if (compressed_bytes == NULL)
                   return CHDERR_READ_ERROR;
 
 #ifdef HAVE_ZLIB
@@ -1600,7 +1645,7 @@ static chd_error hunk_read_into_memory(chd_file *chd, UINT32 hunknum, UINT8 *des
                err   = CHDERR_NONE;
                codec = &chd->zlib_codec_data;
                if (chd->codecintf[0]->decompress != NULL)
-                  err = (*chd->codecintf[0]->decompress)(codec, chd->compressed, entry->length, dest, chd->header.hunkbytes);
+                  err = (*chd->codecintf[0]->decompress)(codec, compressed_bytes, entry->length, dest, chd->header.hunkbytes);
                if (err != CHDERR_NONE)
                   return err;
 #endif
@@ -1608,21 +1653,21 @@ static chd_error hunk_read_into_memory(chd_file *chd, UINT32 hunknum, UINT8 *des
 				break;
 
 			/* uncompressed data */
-			case MAP_ENTRY_TYPE_UNCOMPRESSED:
-            err = read_uncompressed(chd, entry->offset, chd->header.hunkbytes, dest);
+			case V34_MAP_ENTRY_TYPE_UNCOMPRESSED:
+            err = hunk_read_uncompressed(chd, entry->offset, chd->header.hunkbytes, dest);
             if (err != CHDERR_NONE)
                return err;
 				break;
 
 			/* mini-compressed data */
-			case MAP_ENTRY_TYPE_MINI:
+			case V34_MAP_ENTRY_TYPE_MINI:
 				put_bigendian_uint64(&dest[0], entry->offset);
 				for (bytes = 8; bytes < chd->header.hunkbytes; bytes++)
 					dest[bytes] = dest[bytes - 8];
 				break;
 
 			/* self-referenced data */
-			case MAP_ENTRY_TYPE_SELF_HUNK:
+			case V34_MAP_ENTRY_TYPE_SELF_HUNK:
 #ifdef NEED_CACHE_HUNK
 				if (chd->cachehunk == entry->offset && dest == chd->cache)
 					break;
@@ -1630,7 +1675,7 @@ static chd_error hunk_read_into_memory(chd_file *chd, UINT32 hunknum, UINT8 *des
 				return hunk_read_into_memory(chd, (UINT32)entry->offset, dest);
 
 			/* parent-referenced data */
-			case MAP_ENTRY_TYPE_PARENT_HUNK:
+			case V34_MAP_ENTRY_TYPE_PARENT_HUNK:
 				err = hunk_read_into_memory(chd->parent, (UINT32)entry->offset, dest);
 				if (err != CHDERR_NONE)
 					return err;
@@ -1648,7 +1693,7 @@ static chd_error hunk_read_into_memory(chd_file *chd, UINT32 hunknum, UINT8 *des
 		uint16_t blockcrc;
 #endif
 		uint8_t *rawmap = &chd->header.rawmap[chd->header.mapentrybytes * hunknum];
-      UINT8 *bytes;
+      UINT8 *compressed_bytes;
 
 #if 0
 		/* uncompressed case - TODO */
@@ -1679,8 +1724,8 @@ static chd_error hunk_read_into_memory(chd_file *chd, UINT32 hunknum, UINT8 *des
 			case COMPRESSION_TYPE_1:
 			case COMPRESSION_TYPE_2:
 			case COMPRESSION_TYPE_3:
-            bytes = read_compressed(chd, blockoffs, blocklen);
-            if (bytes == NULL)
+            compressed_bytes = hunk_read_compressed(chd, blockoffs, blocklen);
+            if (compressed_bytes == NULL)
                return CHDERR_READ_ERROR;
             if (!chd->codecintf[rawmap[0]])
                return CHDERR_UNSUPPORTED_FORMAT;
@@ -1692,6 +1737,12 @@ static chd_error hunk_read_into_memory(chd_file *chd, UINT32 hunknum, UINT8 *des
 #endif
 						break;
 
+               case CHD_CODEC_ZLIB:
+#ifdef HAVE_ZLIB
+                  codec = &chd->zlib_codec_data;
+#endif
+                  break;
+
 					case CHD_CODEC_CD_ZLIB:
 #ifdef HAVE_ZLIB
 						codec = &chd->cdzl_codec_data;
@@ -1706,7 +1757,7 @@ static chd_error hunk_read_into_memory(chd_file *chd, UINT32 hunknum, UINT8 *des
 				}
 				if (codec==NULL)
 					return CHDERR_CODEC_ERROR;
-				err = (*chd->codecintf[rawmap[0]]->decompress)(codec, chd->compressed, blocklen, dest, chd->header.hunkbytes);
+				err = (*chd->codecintf[rawmap[0]]->decompress)(codec, compressed_bytes, blocklen, dest, chd->header.hunkbytes);
 				if (err != CHDERR_NONE)
 					return err;
 #ifdef VERIFY_BLOCK_CRC
@@ -1716,7 +1767,7 @@ static chd_error hunk_read_into_memory(chd_file *chd, UINT32 hunknum, UINT8 *des
 				return CHDERR_NONE;
 
 			case COMPRESSION_NONE:
-            err = read_uncompressed(chd, blockoffs, blocklen, dest);
+            err = hunk_read_uncompressed(chd, blockoffs, blocklen, dest);
             if (err != CHDERR_NONE)
                return err;
 #ifdef VERIFY_BLOCK_CRC
@@ -1778,7 +1829,7 @@ static chd_error map_read(chd_file *chd)
 
 	/* read the map entries in in chunks and extract to the map list */
 	fileoffset = chd->header.length;
-	for (i = 0; i < chd->header.totalhunks; i += MAP_STACK_ENTRIES)
+	for (i = 0; i < (int)chd->header.totalhunks; i += MAP_STACK_ENTRIES)
 	{
 		/* compute how many entries this time */
 		int entries = chd->header.totalhunks - i, j;
@@ -1809,8 +1860,8 @@ static chd_error map_read(chd_file *chd)
 
 		/* track the maximum offset */
 		for (j = 0; j < entries; j++)
-			if ((chd->map[i + j].flags & MAP_ENTRY_FLAG_TYPE_MASK) == MAP_ENTRY_TYPE_COMPRESSED ||
-				(chd->map[i + j].flags & MAP_ENTRY_FLAG_TYPE_MASK) == MAP_ENTRY_TYPE_UNCOMPRESSED)
+			if ((chd->map[i + j].flags & MAP_ENTRY_FLAG_TYPE_MASK) == V34_MAP_ENTRY_TYPE_COMPRESSED ||
+				(chd->map[i + j].flags & MAP_ENTRY_FLAG_TYPE_MASK) == V34_MAP_ENTRY_TYPE_UNCOMPRESSED)
 				maxoffset = MAX(maxoffset, chd->map[i + j].offset + chd->map[i + j].length);
 	}
 
diff --git a/src/libretro/libretro-common/formats/libchdr/libchdr_flac.c b/src/libretro/libretro-common/formats/libchdr/libchdr_flac.c
index dd09dc013f..e441c15a49 100644
--- a/src/libretro/libretro-common/formats/libchdr/libchdr_flac.c
+++ b/src/libretro/libretro-common/formats/libchdr/libchdr_flac.c
@@ -292,7 +292,7 @@ FLAC__StreamDecoderWriteStatus flac_decoder_write_callback(void *client_data, co
 	{
 		int16_t *dest = decoder->uncompressed_start[0] + decoder->uncompressed_offset * frame->header.channels;
 		for (sampnum = 0; sampnum < blocksize && decoder->uncompressed_offset < decoder->uncompressed_length; sampnum++, decoder->uncompressed_offset++)
-			for (chan = 0; chan < frame->header.channels; chan++)
+			for (chan = 0; chan < (int)frame->header.channels; chan++)
 				*dest++ = (int16_t)((((uint16_t)buffer[chan][sampnum]) << shift) | (((uint16_t)buffer[chan][sampnum]) >> shift));
 	}
 
@@ -300,7 +300,7 @@ FLAC__StreamDecoderWriteStatus flac_decoder_write_callback(void *client_data, co
 	else
 	{
 		for (sampnum = 0; sampnum < blocksize && decoder->uncompressed_offset < decoder->uncompressed_length; sampnum++, decoder->uncompressed_offset++)
-			for (chan = 0; chan < frame->header.channels; chan++)
+			for (chan = 0; chan < (int)frame->header.channels; chan++)
 				if (decoder->uncompressed_start[chan] != NULL)
 					decoder->uncompressed_start[chan][decoder->uncompressed_offset] = (int16_t) ( (((uint16_t)(buffer[chan][sampnum])) << shift) | ( ((uint16_t)(buffer[chan][sampnum])) >> shift) );
 	}
diff --git a/src/libretro/libretro-common/formats/libchdr/libchdr_huffman.c b/src/libretro/libretro-common/formats/libchdr/libchdr_huffman.c
index bf54b59aeb..1fe38388a3 100644
--- a/src/libretro/libretro-common/formats/libchdr/libchdr_huffman.c
+++ b/src/libretro/libretro-common/formats/libchdr/libchdr_huffman.c
@@ -191,7 +191,7 @@ enum huffman_error huffman_import_tree_rle(struct huffman_decoder* decoder, stru
 		numbits = 3;
 
 	/* loop until we read all the nodes */
-	for (curnode = 0; curnode < decoder->numcodes; )
+	for (curnode = 0; curnode < (int)decoder->numcodes; /* blank */)
 	{
 		/* a non-one value is just raw */
 		int nodebits = bitstream_read(bitbuf, numbits);
@@ -217,7 +217,7 @@ enum huffman_error huffman_import_tree_rle(struct huffman_decoder* decoder, stru
 	}
 
 	/* make sure we ended up with the right number */
-	if (curnode != decoder->numcodes)
+	if (curnode != (int)decoder->numcodes)
 		return HUFFERR_INVALID_DATA;
 
 	/* assign canonical codes for all nodes based on their code lengths */
@@ -279,7 +279,7 @@ enum huffman_error huffman_import_tree_huffman(struct huffman_decoder* decoder,
     }
 
 	/* now process the rest of the data */
-	for (curcode = 0; curcode < decoder->numcodes; )
+	for (curcode = 0; curcode < (int)decoder->numcodes; /* blank */)
 	{
 		int value = huffman_decode_one(smallhuff, bitbuf);
 		if (value != 0)
@@ -289,13 +289,13 @@ enum huffman_error huffman_import_tree_huffman(struct huffman_decoder* decoder,
 			int count = bitstream_read(bitbuf, 3) + 2;
 			if (count == 7+2)
 				count += bitstream_read(bitbuf, rlefullbits);
-			for ( ; count != 0 && curcode < decoder->numcodes; count--)
+			for (/* blank */; count != 0 && curcode < (int)decoder->numcodes; count--)
 				decoder->huffnode[curcode++].numbits = last;
 		}
 	}
 
 	/* make sure we ended up with the right number */
-	if (curcode != decoder->numcodes)
+	if (curcode != (int)decoder->numcodes)
    {
       delete_huffman_decoder(smallhuff);
 		return HUFFERR_INVALID_DATA;
@@ -330,12 +330,13 @@ enum huffman_error huffman_compute_tree_from_histo(struct huffman_decoder* decod
    uint32_t upperweight;
 	uint32_t lowerweight = 0;
 	uint32_t sdatacount = 0;
-	for (i = 0; i < decoder->numcodes; i++)
+	for (i = 0; i < (int)decoder->numcodes; i++)
 		sdatacount += decoder->datahisto[i];
 
 	/* binary search to achieve the optimum encoding */
 	upperweight = sdatacount * 2;
-	while (1)
+
+   for (;;)
 	{
 		/* build a tree using the current weight */
 		uint32_t curweight = (upperweight + lowerweight) / 2;
@@ -398,7 +399,7 @@ int huffman_build_tree(struct huffman_decoder* decoder, uint32_t totaldata, uint
 	memset(decoder->huffnode, 0,
          decoder->numcodes * sizeof(decoder->huffnode[0]));
 
-	for (curcode = 0; curcode < decoder->numcodes; curcode++)
+	for (curcode = 0; curcode < (int)decoder->numcodes; curcode++)
 		if (decoder->datahisto[curcode] != 0)
 		{
 			list[listitems++] = &decoder->huffnode[curcode];
@@ -406,7 +407,7 @@ int huffman_build_tree(struct huffman_decoder* decoder, uint32_t totaldata, uint
 			decoder->huffnode[curcode].bits = curcode;
 
 			/* scale the weight by the current effective length, ensuring we don't go to 0 */
-			decoder->huffnode[curcode].weight = ((uint64_t)decoder->datahisto[curcode]) * ((uint64_t)totalweight) / ((uint64_t)totaldata);
+			decoder->huffnode[curcode].weight = (uint32_t)(((uint64_t)decoder->datahisto[curcode]) * ((uint64_t)totalweight) / ((uint64_t)totaldata));
 			if (decoder->huffnode[curcode].weight == 0)
 				decoder->huffnode[curcode].weight = 1;
 		}
@@ -465,7 +466,7 @@ int huffman_build_tree(struct huffman_decoder* decoder, uint32_t totaldata, uint
 
 	/* compute the number of bits in each code,
     * and fill in another histogram */
-	for (curcode = 0; curcode < decoder->numcodes; curcode++)
+	for (curcode = 0; curcode < (int)decoder->numcodes; curcode++)
 	{
 		struct node_t *curnode;
 		struct node_t* node = &decoder->huffnode[curcode];
@@ -503,7 +504,7 @@ enum huffman_error huffman_assign_canonical_codes(struct huffman_decoder* decode
 	/* build up a histogram of bit lengths */
 	int curcode, codelen;
 	uint32_t bithisto[33] = { 0 };
-	for (curcode = 0; curcode < decoder->numcodes; curcode++)
+	for (curcode = 0; curcode < (int)decoder->numcodes; curcode++)
 	{
 		struct node_t* node = &decoder->huffnode[curcode];
 		if (node->numbits > decoder->maxbits)
@@ -523,7 +524,7 @@ enum huffman_error huffman_assign_canonical_codes(struct huffman_decoder* decode
 	}
 
 	/* now assign canonical codes */
-	for (curcode = 0; curcode < decoder->numcodes; curcode++)
+	for (curcode = 0; curcode < (int)decoder->numcodes; curcode++)
 	{
 		struct node_t* node = &decoder->huffnode[curcode];
 		if (node->numbits > 0)
@@ -542,22 +543,19 @@ void huffman_build_lookup_table(struct huffman_decoder* decoder)
 {
 	/* iterate over all codes */
 	int curcode;
-	for (curcode = 0; curcode < decoder->numcodes; curcode++)
+	for (curcode = 0; curcode < (int)decoder->numcodes; curcode++)
 	{
 		/* process all nodes which have non-zero bits */
 		struct node_t* node = &decoder->huffnode[curcode];
 		if (node->numbits > 0)
 		{
-         int shift;
-         lookup_value *dest;
-         lookup_value *destend;
 			/* set up the entry */
 			lookup_value value = MAKE_LOOKUP(curcode, node->numbits);
 
 			/* fill all matching entries */
-			shift = decoder->maxbits - node->numbits;
-			dest = &decoder->lookup[node->bits << shift];
-			destend = &decoder->lookup[((node->bits + 1) << shift) - 1];
+			int shift          = decoder->maxbits - node->numbits;
+			lookup_value *dest = &decoder->lookup[node->bits << shift];
+			lookup_value *destend = &decoder->lookup[((node->bits + 1) << shift) - 1];
 			while (dest <= destend)
 				*dest++ = value;
 		}
diff --git a/src/libretro/libretro-common/formats/libchdr/libchdr_lzma.c b/src/libretro/libretro-common/formats/libchdr/libchdr_lzma.c
index 846ef8cd20..f4a009d18d 100644
--- a/src/libretro/libretro-common/formats/libchdr/libchdr_lzma.c
+++ b/src/libretro/libretro-common/formats/libchdr/libchdr_lzma.c
@@ -42,12 +42,12 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <zlib.h>
 #include <libchdr/chd.h>
 #include <libchdr/minmax.h>
 #include <libchdr/cdrom.h>
 #include <libchdr/lzma.h>
 #include <libchdr/huffman.h>
-#include <zlib.h>
 
 #include <retro_inline.h>
 #include <streams/file_stream.h>
@@ -66,11 +66,16 @@
  *-------------------------------------------------
  */
 
+/* Huge alignment values for possible SIMD optimization by compiler (NEON, SSE, AVX) */
+#define LZMA_MIN_ALIGNMENT_BITS 512
+#define LZMA_MIN_ALIGNMENT_BYTES (LZMA_MIN_ALIGNMENT_BITS / 8)
+
 static void *lzma_fast_alloc(void *p, size_t size)
 {
 	int scan;
-    uint32_t *addr        = NULL;
+	uint32_t *addr        = NULL;
 	lzma_allocator *codec = (lzma_allocator *)(p);
+	uintptr_t vaddr = 0;
 
 	/* compute the size, rounding to the nearest 1k */
 	size = (size + 0x3ff) & ~0x3ff;
@@ -83,27 +88,36 @@ static void *lzma_fast_alloc(void *p, size_t size)
 		{
 			/* set the low bit of the size so we don't match next time */
 			*ptr |= 1;
-			return ptr + 1;
+
+			/* return aligned address of the block */
+			return codec->allocptr2[scan];
 		}
 	}
 
 	/* alloc a new one and put it into the list */
-	addr = (uint32_t *)malloc(sizeof(uint32_t) * (size + sizeof(uint32_t)));
-	if (!addr)
+	addr = (uint32_t *)malloc(size + sizeof(uint32_t) + LZMA_MIN_ALIGNMENT_BYTES);
+	if (addr==NULL)
 		return NULL;
-
 	for (scan = 0; scan < MAX_LZMA_ALLOCS; scan++)
 	{
 		if (codec->allocptr[scan] == NULL)
 		{
+			/* store block address */
 			codec->allocptr[scan] = addr;
+
+			/* compute aligned address, store it */
+			vaddr = (uintptr_t)addr;
+			vaddr = (vaddr + sizeof(uint32_t) + (LZMA_MIN_ALIGNMENT_BYTES-1)) & (~(LZMA_MIN_ALIGNMENT_BYTES-1));
+			codec->allocptr2[scan] = (uint32_t*)vaddr;
 			break;
 		}
 	}
 
 	/* set the low bit of the size so we don't match next time */
-	*addr = (uint32_t)(size | 1);
-	return addr + 1;
+	*addr = (uint32_t)size | 1;
+
+	/* return aligned address */
+	return (void*)vaddr;
 }
 
 /*-------------------------------------------------
@@ -114,21 +128,22 @@ static void *lzma_fast_alloc(void *p, size_t size)
 static void lzma_fast_free(void *p, void *address)
 {
 	int scan;
-   uint32_t *ptr;
-   lzma_allocator *codec;
+	uint32_t *ptr = NULL;
+	lzma_allocator *codec = NULL;
+
 	if (address == NULL)
 		return;
 
 	codec = (lzma_allocator *)(p);
 
 	/* find the hunk */
-	ptr = (uint32_t *)(address) - 1;
+	ptr = (uint32_t *)address;
 	for (scan = 0; scan < MAX_LZMA_ALLOCS; scan++)
 	{
-		if (ptr == codec->allocptr[scan])
+		if (ptr == codec->allocptr2[scan])
 		{
 			/* clear the low bit of the size to allow matches */
-			*ptr &= ~1;
+			*codec->allocptr[scan] &= ~1;
 			return;
 		}
 	}
@@ -238,8 +253,8 @@ void lzma_codec_free(void* codec)
 	lzma_allocator* alloc = &lzma_codec->allocator;
 
 	/* free memory */
-	lzma_allocator_free(alloc);
 	LzmaDec_Free(&lzma_codec->decoder, (ISzAlloc*)&lzma_codec->allocator);
+	lzma_allocator_free(alloc);
 }
 
 /*-------------------------------------------------
diff --git a/src/libretro/libretro-common/formats/libchdr/libchdr_zlib.c b/src/libretro/libretro-common/formats/libchdr/libchdr_zlib.c
index 6aaae8d009..e02ab31722 100644
--- a/src/libretro/libretro-common/formats/libchdr/libchdr_zlib.c
+++ b/src/libretro/libretro-common/formats/libchdr/libchdr_zlib.c
@@ -174,6 +174,10 @@ chd_error zlib_codec_init(void *codec, uint32_t hunkbytes)
 	else
 		err = CHDERR_NONE;
 
+	/* handle an error */
+	if (err != CHDERR_NONE)
+		zlib_codec_free(data);
+
 	return err;
 }
 
@@ -190,7 +194,7 @@ void zlib_codec_free(void *codec)
 	if (data != NULL)
 	{
 		int i;
-      zlib_allocator alloc;
+		zlib_allocator alloc;
 
 		inflateEnd(&data->inflater);
 
@@ -225,7 +229,7 @@ chd_error zlib_codec_decompress(void *codec, const uint8_t *src, uint32_t comple
 
 	/* do it */
 	zerr = inflate(&data->inflater, Z_FINISH);
-    (void)zerr;
+	(void)zerr;
 	if (data->inflater.total_out != destlen)
 		return CHDERR_DECOMPRESSION_ERROR;
 
@@ -237,9 +241,14 @@ chd_error zlib_codec_decompress(void *codec, const uint8_t *src, uint32_t comple
     allocates and frees memory frequently
 -------------------------------------------------*/
 
+/* Huge alignment values for possible SIMD optimization by compiler (NEON, SSE, AVX) */
+#define ZLIB_MIN_ALIGNMENT_BITS 512
+#define ZLIB_MIN_ALIGNMENT_BYTES (ZLIB_MIN_ALIGNMENT_BITS / 8)
+
 voidpf zlib_fast_alloc(voidpf opaque, uInt items, uInt size)
 {
 	zlib_allocator *alloc = (zlib_allocator *)opaque;
+	uintptr_t paddr = 0;
 	UINT32 *ptr;
 	int i;
 
@@ -254,12 +263,14 @@ voidpf zlib_fast_alloc(voidpf opaque, uInt items, uInt size)
 		{
 			/* set the low bit of the size so we don't match next time */
 			*ptr |= 1;
-			return ptr + 1;
+
+			/* return aligned block address */
+			return (voidpf)(alloc->allocptr2[i]);
 		}
 	}
 
 	/* alloc a new one */
-	ptr = (UINT32 *)malloc(size + sizeof(UINT32));
+	ptr = (UINT32 *)malloc(size + sizeof(UINT32) + ZLIB_MIN_ALIGNMENT_BYTES);
 	if (!ptr)
 		return NULL;
 
@@ -268,12 +279,16 @@ voidpf zlib_fast_alloc(voidpf opaque, uInt items, uInt size)
 		if (!alloc->allocptr[i])
 		{
 			alloc->allocptr[i] = ptr;
+			paddr = (((uintptr_t)ptr) + sizeof(UINT32) + (ZLIB_MIN_ALIGNMENT_BYTES-1)) & (~(ZLIB_MIN_ALIGNMENT_BYTES-1));
+			alloc->allocptr2[i] = (uint32_t*)paddr;
 			break;
 		}
 
 	/* set the low bit of the size so we don't match next time */
 	*ptr = size | 1;
-	return ptr + 1;
+
+	/* return aligned block address */
+	return (voidpf)paddr;
 }
 
 /*-------------------------------------------------
@@ -284,15 +299,15 @@ voidpf zlib_fast_alloc(voidpf opaque, uInt items, uInt size)
 void zlib_fast_free(voidpf opaque, voidpf address)
 {
 	zlib_allocator *alloc = (zlib_allocator *)opaque;
-	UINT32 *ptr = (UINT32 *)address - 1;
+	UINT32 *ptr = (UINT32 *)address;
 	int i;
 
 	/* find the hunk */
 	for (i = 0; i < MAX_ZLIB_ALLOCS; i++)
-		if (ptr == alloc->allocptr[i])
+		if (ptr == alloc->allocptr2[i])
 		{
 			/* clear the low bit of the size to allow matches */
-			*ptr &= ~1;
+			*(alloc->allocptr[i]) &= ~1;
 			return;
 		}
 }
diff --git a/src/libretro/libretro-common/formats/png/rpng.c b/src/libretro/libretro-common/formats/png/rpng.c
index 9484dc470b..9cd19f6d43 100644
--- a/src/libretro/libretro-common/formats/png/rpng.c
+++ b/src/libretro/libretro-common/formats/png/rpng.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (rpng.c).
@@ -20,7 +20,9 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
+#ifdef DEBUG
 #include <stdio.h>
+#endif
 #include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
@@ -80,22 +82,22 @@ struct idat_buffer
    size_t size;
 };
 
-struct png_chunk
+enum rpng_process_flags
 {
-   uint32_t size;
-   char type[4];
-   uint8_t *data;
+   RPNG_PROCESS_FLAG_INFLATE_INITIALIZED    = (1 << 0),
+   RPNG_PROCESS_FLAG_ADAM7_PASS_INITIALIZED = (1 << 1),
+   RPNG_PROCESS_FLAG_PASS_INITIALIZED       = (1 << 2)
 };
 
 struct rpng_process
 {
-   bool inflate_initialized;
-   bool adam7_pass_initialized;
-   bool pass_initialized;
+   uint32_t *data;
+   uint32_t *palette;
+   void *stream;
+   const struct trans_stream_backend *stream_backend;
    uint8_t *prev_scanline;
    uint8_t *decoded_scanline;
    uint8_t *inflate_buf;
-   struct png_ihdr ihdr;
    size_t restore_buf_size;
    size_t adam7_restore_buf_size;
    size_t data_restore_buf_size;
@@ -104,139 +106,138 @@ struct rpng_process
    size_t avail_out;
    size_t total_out;
    size_t pass_size;
+   struct png_ihdr ihdr; /* uint32_t alignment */
    unsigned bpp;
    unsigned pitch;
    unsigned h;
    unsigned pass_width;
    unsigned pass_height;
    unsigned pass_pos;
-   uint32_t *data;
-   uint32_t *palette;
-   void *stream;
-   const struct trans_stream_backend *stream_backend;
+   uint8_t flags;
+};
+
+enum rpng_flags
+{
+   RPNG_FLAG_HAS_IHDR = (1 << 0),
+   RPNG_FLAG_HAS_IDAT = (1 << 1),
+   RPNG_FLAG_HAS_IEND = (1 << 2),
+   RPNG_FLAG_HAS_PLTE = (1 << 3),
+   RPNG_FLAG_HAS_TRNS = (1 << 4)
 };
 
 struct rpng
 {
    struct rpng_process *process;
-   bool has_ihdr;
-   bool has_idat;
-   bool has_iend;
-   bool has_plte;
-   bool has_trns;
-   struct idat_buffer idat_buf;
-   struct png_ihdr ihdr;
    uint8_t *buff_data;
    uint8_t *buff_end;
+   struct idat_buffer idat_buf; /* ptr alignment */
+   struct png_ihdr ihdr; /* uint32 alignment */
    uint32_t palette[256];
+   uint8_t flags;
 };
 
-static INLINE uint32_t dword_be(const uint8_t *buf)
-{
-   return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | (buf[3] << 0);
-}
+static const struct adam7_pass rpng_passes[] = {
+   { 0, 0, 8, 8 },
+   { 4, 0, 8, 8 },
+   { 0, 4, 4, 8 },
+   { 2, 0, 4, 4 },
+   { 0, 2, 2, 4 },
+   { 1, 0, 2, 2 },
+   { 0, 1, 1, 2 },
+};
 
-static enum png_chunk_type png_chunk_type(const struct png_chunk *chunk)
+static INLINE uint32_t rpng_dword_be(const uint8_t *buf)
 {
-   unsigned i;
-   struct
-   {
-      const char *id;
-      enum png_chunk_type type;
-   } static const chunk_map[] = {
-      { "IHDR", PNG_CHUNK_IHDR },
-      { "IDAT", PNG_CHUNK_IDAT },
-      { "IEND", PNG_CHUNK_IEND },
-      { "PLTE", PNG_CHUNK_PLTE },
-      { "tRNS", PNG_CHUNK_tRNS },
-   };
-
-   for (i = 0; i < ARRAY_SIZE(chunk_map); i++)
-   {
-      if (string_is_equal(chunk->type, chunk_map[i].id))
-         return chunk_map[i].type;
-   }
-
-   return PNG_CHUNK_NOOP;
+   return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | (buf[3] << 0);
 }
 
-static bool png_process_ihdr(struct png_ihdr *ihdr)
+#if defined(DEBUG) || defined(RPNG_TEST)
+static bool rpng_process_ihdr(struct png_ihdr *ihdr)
 {
-   unsigned i;
-   bool ret = true;
+   uint8_t ihdr_depth = ihdr->depth;
 
    switch (ihdr->color_type)
    {
       case PNG_IHDR_COLOR_RGB:
       case PNG_IHDR_COLOR_GRAY_ALPHA:
       case PNG_IHDR_COLOR_RGBA:
-         if (ihdr->depth != 8 && ihdr->depth != 16)
-            GOTO_END_ERROR();
+         if (ihdr_depth != 8 && ihdr_depth != 16)
+         {
+            fprintf(stderr, "[RPNG]: Error in line %d.\n", __LINE__);
+            return false;
+         }
          break;
       case PNG_IHDR_COLOR_GRAY:
+         /* Valid bitdepths are: 1, 2, 4, 8, 16 */
+         if (ihdr_depth > 16 || (0x977F7FFF << ihdr_depth) & 0x80000000)
          {
-            static const unsigned valid_bpp[] = { 1, 2, 4, 8, 16 };
-            bool correct_bpp = false;
-
-            for (i = 0; i < ARRAY_SIZE(valid_bpp); i++)
-            {
-               if (valid_bpp[i] == ihdr->depth)
-               {
-                  correct_bpp = true;
-                  break;
-               }
-            }
-
-            if (!correct_bpp)
-               GOTO_END_ERROR();
+            fprintf(stderr, "[RPNG]: Error in line %d.\n", __LINE__);
+            return false;
          }
          break;
       case PNG_IHDR_COLOR_PLT:
+         /* Valid bitdepths are: 1, 2, 4, 8 */
+         if (ihdr_depth > 8 || (0x977F7FFF << ihdr_depth)  & 0x80000000)
          {
-            static const unsigned valid_bpp[] = { 1, 2, 4, 8 };
-            bool correct_bpp = false;
-
-            for (i = 0; i < ARRAY_SIZE(valid_bpp); i++)
-            {
-               if (valid_bpp[i] == ihdr->depth)
-               {
-                  correct_bpp = true;
-                  break;
-               }
-            }
-
-            if (!correct_bpp)
-               GOTO_END_ERROR();
+            fprintf(stderr, "[RPNG]: Error in line %d.\n", __LINE__);
+            return false;
          }
          break;
       default:
-         GOTO_END_ERROR();
+         fprintf(stderr, "[RPNG]: Error in line %d.\n", __LINE__);
+         return false;
    }
 
 #ifdef RPNG_TEST
    fprintf(stderr, "IHDR: (%u x %u), bpc = %u, palette = %s, color = %s, alpha = %s, adam7 = %s.\n",
          ihdr->width, ihdr->height,
-         ihdr->depth, (ihdr->color_type == PNG_IHDR_COLOR_PLT) ? "yes" : "no",
-         (ihdr->color_type & PNG_IHDR_COLOR_RGB) ? "yes" : "no",
-         (ihdr->color_type & PNG_IHDR_COLOR_GRAY_ALPHA) ? "yes" : "no",
+         ihdr_depth, (ihdr->color_type == PNG_IHDR_COLOR_PLT) ? "yes" : "no",
+         (ihdr->color_type & PNG_IHDR_COLOR_RGB)              ? "yes" : "no",
+         (ihdr->color_type & PNG_IHDR_COLOR_GRAY_ALPHA)       ? "yes" : "no",
          ihdr->interlace == 1 ? "yes" : "no");
 #endif
 
-   if (ihdr->compression != 0)
-      GOTO_END_ERROR();
+   return true;
+}
+#else
+static bool rpng_process_ihdr(struct png_ihdr *ihdr)
+{
+   uint8_t ihdr_depth = ihdr->depth;
 
-end:
-   return ret;
+   switch (ihdr->color_type)
+   {
+      case PNG_IHDR_COLOR_RGB:
+      case PNG_IHDR_COLOR_GRAY_ALPHA:
+      case PNG_IHDR_COLOR_RGBA:
+         if (ihdr_depth != 8 && ihdr_depth != 16)
+            return false;
+         break;
+      case PNG_IHDR_COLOR_GRAY:
+         /* Valid bitdepths are: 1, 2, 4, 8, 16 */
+         if (ihdr_depth > 16 || (0x977F7FFF << ihdr_depth) & 0x80000000)
+            return false;
+         break;
+      case PNG_IHDR_COLOR_PLT:
+         /* Valid bitdepths are: 1, 2, 4, 8 */
+         if (ihdr_depth > 8 || (0x977F7FFF << ihdr_depth)  & 0x80000000)
+            return false;
+         break;
+      default:
+         return false;
+   }
+
+   return true;
 }
+#endif
 
-static void png_reverse_filter_copy_line_rgb(uint32_t *data,
+static void rpng_reverse_filter_copy_line_rgb(uint32_t *data,
       const uint8_t *decoded, unsigned width, unsigned bpp)
 {
-   unsigned i;
+   int i;
 
    bpp /= 8;
 
-   for (i = 0; i < width; i++)
+   for (i = 0; i < (int)width; i++)
    {
       uint32_t r, g, b;
 
@@ -250,14 +251,14 @@ static void png_reverse_filter_copy_line_rgb(uint32_t *data,
    }
 }
 
-static void png_reverse_filter_copy_line_rgba(uint32_t *data,
+static void rpng_reverse_filter_copy_line_rgba(uint32_t *data,
       const uint8_t *decoded, unsigned width, unsigned bpp)
 {
-   unsigned i;
+   int i;
 
    bpp /= 8;
 
-   for (i = 0; i < width; i++)
+   for (i = 0; i < (int)width; i++)
    {
       uint32_t r, g, b, a;
       r        = *decoded;
@@ -272,16 +273,17 @@ static void png_reverse_filter_copy_line_rgba(uint32_t *data,
    }
 }
 
-static void png_reverse_filter_copy_line_bw(uint32_t *data,
+static void rpng_reverse_filter_copy_line_bw(uint32_t *data,
       const uint8_t *decoded, unsigned width, unsigned depth)
 {
-   unsigned i, bit;
+   int i;
+   unsigned bit;
    static const unsigned mul_table[] = { 0, 0xff, 0x55, 0, 0x11, 0, 0, 0, 0x01 };
    unsigned mul, mask;
 
    if (depth == 16)
    {
-      for (i = 0; i < width; i++)
+      for (i = 0; i < (int)width; i++)
       {
          uint32_t val = decoded[i << 1];
          data[i]      = (val * 0x010101) | (0xffu << 24);
@@ -293,7 +295,7 @@ static void png_reverse_filter_copy_line_bw(uint32_t *data,
    mask = (1 << depth) - 1;
    bit  = 0;
 
-   for (i = 0; i < width; i++, bit += depth)
+   for (i = 0; i < (int)width; i++, bit += depth)
    {
       unsigned byte = bit >> 3;
       unsigned val  = decoded[byte] >> (8 - depth - (bit & 7));
@@ -304,15 +306,15 @@ static void png_reverse_filter_copy_line_bw(uint32_t *data,
    }
 }
 
-static void png_reverse_filter_copy_line_gray_alpha(uint32_t *data,
+static void rpng_reverse_filter_copy_line_gray_alpha(uint32_t *data,
       const uint8_t *decoded, unsigned width,
       unsigned bpp)
 {
-   unsigned i;
+   int i;
 
    bpp /= 8;
 
-   for (i = 0; i < width; i++)
+   for (i = 0; i < (int)width; i++)
    {
       uint32_t gray, alpha;
 
@@ -325,7 +327,7 @@ static void png_reverse_filter_copy_line_gray_alpha(uint32_t *data,
    }
 }
 
-static void png_reverse_filter_copy_line_plt(uint32_t *data,
+static void rpng_reverse_filter_copy_line_plt(uint32_t *data,
       const uint8_t *decoded, unsigned width,
       unsigned depth, const uint32_t *palette)
 {
@@ -333,10 +335,9 @@ static void png_reverse_filter_copy_line_plt(uint32_t *data,
    {
       case 1:
          {
+            int i;
             unsigned w = width / 8;
-            unsigned i;
-
-            for (i = 0; i < w; i++, decoded++)
+            for (i = 0; i < (int)w; i++, decoded++)
             {
                *data++ = palette[(*decoded >> 7) & 1];
                *data++ = palette[(*decoded >> 6) & 1];
@@ -371,10 +372,9 @@ static void png_reverse_filter_copy_line_plt(uint32_t *data,
 
       case 2:
          {
+            int i;
             unsigned w = width / 4;
-            unsigned i;
-
-            for (i = 0; i < w; i++, decoded++)
+            for (i = 0; i < (int)w; i++, decoded++)
             {
                *data++ = palette[(*decoded >> 6) & 3];
                *data++ = palette[(*decoded >> 4) & 3];
@@ -397,41 +397,35 @@ static void png_reverse_filter_copy_line_plt(uint32_t *data,
 
       case 4:
          {
+            int i;
             unsigned w = width / 2;
-            unsigned i;
-
-            for (i = 0; i < w; i++, decoded++)
+            for (i = 0; i < (int)w; i++, decoded++)
             {
                *data++ = palette[*decoded >> 4];
                *data++ = palette[*decoded & 0x0f];
             }
 
             if (width & 1)
-            {
                *data = palette[*decoded >> 4];
-            }
          }
          break;
 
       case 8:
          {
-            unsigned i;
-
-            for (i = 0; i < width; i++, decoded++, data++)
-            {
+            int i;
+            for (i = 0; i < (int)width; i++, decoded++, data++)
                *data = palette[*decoded];
-            }
          }
          break;
    }
 }
 
-static void png_pass_geom(const struct png_ihdr *ihdr,
+static void rpng_pass_geom(const struct png_ihdr *ihdr,
       unsigned width, unsigned height,
       unsigned *bpp_out, unsigned *pitch_out, size_t *pass_size)
 {
-   unsigned bpp;
-   unsigned pitch;
+   unsigned bpp   = 0;
+   unsigned pitch = 0;
 
    switch (ihdr->color_type)
    {
@@ -456,20 +450,18 @@ static void png_pass_geom(const struct png_ihdr *ihdr,
          pitch = (ihdr->width * ihdr->depth * 4 + 7) / 8;
          break;
       default:
-         bpp = 0;
-         pitch = 0;
          break;
    }
 
    if (pass_size)
       *pass_size = (pitch + 1) * ihdr->height;
    if (bpp_out)
-      *bpp_out = bpp;
+      *bpp_out   = bpp;
    if (pitch_out)
       *pitch_out = pitch;
 }
 
-static void png_reverse_filter_adam7_deinterlace_pass(uint32_t *data,
+static void rpng_reverse_filter_adam7_deinterlace_pass(uint32_t *data,
       const struct png_ihdr *ihdr,
       const uint32_t *input, unsigned pass_width, unsigned pass_height,
       const struct adam7_pass *pass)
@@ -488,7 +480,7 @@ static void png_reverse_filter_adam7_deinterlace_pass(uint32_t *data,
    }
 }
 
-static void png_reverse_filter_deinit(struct rpng_process *pngp)
+static void rpng_reverse_filter_deinit(struct rpng_process *pngp)
 {
    if (!pngp)
       return;
@@ -499,47 +491,37 @@ static void png_reverse_filter_deinit(struct rpng_process *pngp)
       free(pngp->prev_scanline);
    pngp->prev_scanline    = NULL;
 
-   pngp->pass_initialized = false;
+   pngp->flags           &= ~RPNG_PROCESS_FLAG_PASS_INITIALIZED;
    pngp->h                = 0;
 }
 
-static const struct adam7_pass passes[] = {
-   { 0, 0, 8, 8 },
-   { 4, 0, 8, 8 },
-   { 0, 4, 4, 8 },
-   { 2, 0, 4, 4 },
-   { 0, 2, 2, 4 },
-   { 1, 0, 2, 2 },
-   { 0, 1, 1, 2 },
-};
-
-static int png_reverse_filter_init(const struct png_ihdr *ihdr,
+static int rpng_reverse_filter_init(const struct png_ihdr *ihdr,
       struct rpng_process *pngp)
 {
    size_t pass_size;
 
-   if (!pngp->adam7_pass_initialized && ihdr->interlace)
+   if (   !(pngp->flags & RPNG_PROCESS_FLAG_ADAM7_PASS_INITIALIZED) 
+         && ihdr->interlace)
    {
-      if (ihdr->width <= passes[pngp->pass_pos].x ||
-            ihdr->height <= passes[pngp->pass_pos].y) /* Empty pass */
+      if (     ihdr->width  <= rpng_passes[pngp->pass_pos].x
+            || ihdr->height <= rpng_passes[pngp->pass_pos].y) /* Empty pass */
          return 1;
 
       pngp->pass_width  = (ihdr->width -
-            passes[pngp->pass_pos].x + passes[pngp->pass_pos].stride_x - 1) / passes[pngp->pass_pos].stride_x;
-      pngp->pass_height = (ihdr->height - passes[pngp->pass_pos].y +
-            passes[pngp->pass_pos].stride_y - 1) / passes[pngp->pass_pos].stride_y;
-
-      pngp->data = (uint32_t*)malloc(
-            pngp->pass_width * pngp->pass_height * sizeof(uint32_t));
+            rpng_passes[pngp->pass_pos].x + rpng_passes[pngp->pass_pos].stride_x
+- 1) / rpng_passes[pngp->pass_pos].stride_x;
+      pngp->pass_height = (ihdr->height - rpng_passes[pngp->pass_pos].y +
+            rpng_passes[pngp->pass_pos].stride_y - 1) / rpng_passes[pngp->pass_pos].stride_y;
 
-      if (!pngp->data)
+      if (!(pngp->data = (uint32_t*)malloc(
+            pngp->pass_width * pngp->pass_height * sizeof(uint32_t))))
          return -1;
 
       pngp->ihdr        = *ihdr;
       pngp->ihdr.width  = pngp->pass_width;
       pngp->ihdr.height = pngp->pass_height;
 
-      png_pass_geom(&pngp->ihdr, pngp->pass_width,
+      rpng_pass_geom(&pngp->ihdr, pngp->pass_width,
             pngp->pass_height, NULL, NULL, &pngp->pass_size);
 
       if (pngp->pass_size > pngp->total_out)
@@ -549,15 +531,15 @@ static int png_reverse_filter_init(const struct png_ihdr *ihdr,
          return -1;
       }
 
-      pngp->adam7_pass_initialized = true;
+      pngp->flags |= RPNG_PROCESS_FLAG_ADAM7_PASS_INITIALIZED;
 
       return 0;
    }
 
-   if (pngp->pass_initialized)
+   if (pngp->flags & RPNG_PROCESS_FLAG_PASS_INITIALIZED)
       return 0;
 
-   png_pass_geom(ihdr, ihdr->width, ihdr->height, &pngp->bpp, &pngp->pitch, &pass_size);
+   rpng_pass_geom(ihdr, ihdr->width, ihdr->height, &pngp->bpp, &pngp->pitch, &pass_size);
 
    if (pngp->total_out < pass_size)
       return -1;
@@ -570,17 +552,18 @@ static int png_reverse_filter_init(const struct png_ihdr *ihdr,
    if (!pngp->prev_scanline || !pngp->decoded_scanline)
       goto error;
 
-   pngp->h = 0;
-   pngp->pass_initialized = true;
+   pngp->h                    = 0;
+   pngp->flags               |= RPNG_PROCESS_FLAG_PASS_INITIALIZED;
 
    return 0;
 
 error:
-   png_reverse_filter_deinit(pngp);
+   rpng_reverse_filter_deinit(pngp);
    return -1;
 }
 
-static int png_reverse_filter_copy_line(uint32_t *data, const struct png_ihdr *ihdr,
+static int rpng_reverse_filter_copy_line(uint32_t *data,
+      const struct png_ihdr *ihdr,
       struct rpng_process *pngp, unsigned filter)
 {
    unsigned i;
@@ -591,35 +574,36 @@ static int png_reverse_filter_copy_line(uint32_t *data, const struct png_ihdr *i
          memcpy(pngp->decoded_scanline, pngp->inflate_buf, pngp->pitch);
          break;
       case PNG_FILTER_SUB:
-         for (i = 0; i < pngp->bpp; i++)
-            pngp->decoded_scanline[i] = pngp->inflate_buf[i];
+         memcpy(pngp->decoded_scanline, pngp->inflate_buf, pngp->pitch);
          for (i = pngp->bpp; i < pngp->pitch; i++)
-            pngp->decoded_scanline[i] = pngp->decoded_scanline[i - pngp->bpp] + pngp->inflate_buf[i];
+            pngp->decoded_scanline[i] += pngp->decoded_scanline[i - pngp->bpp];
          break;
       case PNG_FILTER_UP:
+         memcpy(pngp->decoded_scanline, pngp->inflate_buf, pngp->pitch);
          for (i = 0; i < pngp->pitch; i++)
-            pngp->decoded_scanline[i] = pngp->prev_scanline[i] + pngp->inflate_buf[i];
+            pngp->decoded_scanline[i] += pngp->prev_scanline[i];
          break;
       case PNG_FILTER_AVERAGE:
+         memcpy(pngp->decoded_scanline, pngp->inflate_buf, pngp->pitch);
          for (i = 0; i < pngp->bpp; i++)
          {
             uint8_t avg = pngp->prev_scanline[i] >> 1;
-            pngp->decoded_scanline[i] = avg + pngp->inflate_buf[i];
+            pngp->decoded_scanline[i] += avg;
          }
          for (i = pngp->bpp; i < pngp->pitch; i++)
          {
             uint8_t avg = (pngp->decoded_scanline[i - pngp->bpp] + pngp->prev_scanline[i]) >> 1;
-            pngp->decoded_scanline[i] = avg + pngp->inflate_buf[i];
+            pngp->decoded_scanline[i] += avg;
          }
          break;
       case PNG_FILTER_PAETH:
+         memcpy(pngp->decoded_scanline, pngp->inflate_buf, pngp->pitch);
          for (i = 0; i < pngp->bpp; i++)
-            pngp->decoded_scanline[i] = paeth(0, pngp->prev_scanline[i], 0) + pngp->inflate_buf[i];
+            pngp->decoded_scanline[i] += pngp->prev_scanline[i];
          for (i = pngp->bpp; i < pngp->pitch; i++)
-            pngp->decoded_scanline[i] = paeth(pngp->decoded_scanline[i - pngp->bpp],
-                  pngp->prev_scanline[i], pngp->prev_scanline[i - pngp->bpp]) + pngp->inflate_buf[i];
+            pngp->decoded_scanline[i] += paeth(pngp->decoded_scanline[i - pngp->bpp],
+                  pngp->prev_scanline[i], pngp->prev_scanline[i - pngp->bpp]);
          break;
-
       default:
          return IMAGE_PROCESS_ERROR_END;
    }
@@ -627,21 +611,22 @@ static int png_reverse_filter_copy_line(uint32_t *data, const struct png_ihdr *i
    switch (ihdr->color_type)
    {
       case PNG_IHDR_COLOR_GRAY:
-         png_reverse_filter_copy_line_bw(data, pngp->decoded_scanline, ihdr->width, ihdr->depth);
+         rpng_reverse_filter_copy_line_bw(data, pngp->decoded_scanline, ihdr->width, ihdr->depth);
          break;
       case PNG_IHDR_COLOR_RGB:
-         png_reverse_filter_copy_line_rgb(data, pngp->decoded_scanline, ihdr->width, ihdr->depth);
+         rpng_reverse_filter_copy_line_rgb(data, pngp->decoded_scanline, ihdr->width, ihdr->depth);
          break;
       case PNG_IHDR_COLOR_PLT:
-         png_reverse_filter_copy_line_plt(data, pngp->decoded_scanline, ihdr->width,
+         rpng_reverse_filter_copy_line_plt(
+               data, pngp->decoded_scanline, ihdr->width,
                ihdr->depth, pngp->palette);
          break;
       case PNG_IHDR_COLOR_GRAY_ALPHA:
-         png_reverse_filter_copy_line_gray_alpha(data, pngp->decoded_scanline, ihdr->width,
+         rpng_reverse_filter_copy_line_gray_alpha(data, pngp->decoded_scanline, ihdr->width,
                ihdr->depth);
          break;
       case PNG_IHDR_COLOR_RGBA:
-         png_reverse_filter_copy_line_rgba(data, pngp->decoded_scanline, ihdr->width, ihdr->depth);
+         rpng_reverse_filter_copy_line_rgba(data, pngp->decoded_scanline, ihdr->width, ihdr->depth);
          break;
    }
 
@@ -650,20 +635,21 @@ static int png_reverse_filter_copy_line(uint32_t *data, const struct png_ihdr *i
    return IMAGE_PROCESS_NEXT;
 }
 
-static int png_reverse_filter_regular_iterate(uint32_t **data, const struct png_ihdr *ihdr,
+static int rpng_reverse_filter_regular_iterate(
+      uint32_t **data, const struct png_ihdr *ihdr,
       struct rpng_process *pngp)
 {
    int ret = IMAGE_PROCESS_END;
-
    if (pngp->h < ihdr->height)
    {
-      unsigned filter = *pngp->inflate_buf++;
+      unsigned filter         = *pngp->inflate_buf++;
       pngp->restore_buf_size += 1;
-      ret = png_reverse_filter_copy_line(*data,
+      ret                     = rpng_reverse_filter_copy_line(*data,
             ihdr, pngp, filter);
+      if (ret == IMAGE_PROCESS_END || ret == IMAGE_PROCESS_ERROR_END)
+         goto end;
    }
-
-   if (ret == IMAGE_PROCESS_END || ret == IMAGE_PROCESS_ERROR_END)
+   else
       goto end;
 
    pngp->h++;
@@ -676,7 +662,7 @@ static int png_reverse_filter_regular_iterate(uint32_t **data, const struct png_
    return IMAGE_PROCESS_NEXT;
 
 end:
-   png_reverse_filter_deinit(pngp);
+   rpng_reverse_filter_deinit(pngp);
 
    pngp->inflate_buf -= pngp->restore_buf_size;
    *data             -= pngp->data_restore_buf_size;
@@ -684,31 +670,30 @@ static int png_reverse_filter_regular_iterate(uint32_t **data, const struct png_
    return ret;
 }
 
-static int png_reverse_filter_adam7_iterate(uint32_t **data_,
+static int rpng_reverse_filter_adam7_iterate(uint32_t **data_,
       const struct png_ihdr *ihdr,
       struct rpng_process *pngp)
 {
    int        ret = 0;
-   bool   to_next = pngp->pass_pos < ARRAY_SIZE(passes);
+   bool   to_next = pngp->pass_pos < ARRAY_SIZE(rpng_passes);
    uint32_t *data = *data_;
 
    if (!to_next)
       return IMAGE_PROCESS_END;
 
-   ret = png_reverse_filter_init(ihdr, pngp);
-
-   if (ret == 1)
+   if ((ret = rpng_reverse_filter_init(ihdr, pngp)) == 1)
       return IMAGE_PROCESS_NEXT;
-   if (ret == -1)
+   else if (ret == -1)
       return IMAGE_PROCESS_ERROR_END;
 
-   if (png_reverse_filter_init(&pngp->ihdr, pngp) == -1)
+   if (rpng_reverse_filter_init(&pngp->ihdr, pngp) == -1)
       return IMAGE_PROCESS_ERROR;
 
-   do{
-      ret = png_reverse_filter_regular_iterate(&pngp->data,
+   do
+   {
+      ret = rpng_reverse_filter_regular_iterate(&pngp->data,
             &pngp->ihdr, pngp);
-   }while(ret == IMAGE_PROCESS_NEXT);
+   } while (ret == IMAGE_PROCESS_NEXT);
 
    if (ret == IMAGE_PROCESS_ERROR || ret == IMAGE_PROCESS_ERROR_END)
       return IMAGE_PROCESS_ERROR;
@@ -718,25 +703,26 @@ static int png_reverse_filter_adam7_iterate(uint32_t **data_,
 
    pngp->total_out              -= pngp->pass_size;
 
-   png_reverse_filter_adam7_deinterlace_pass(data,
-         ihdr, pngp->data, pngp->pass_width, pngp->pass_height, &passes[pngp->pass_pos]);
+   rpng_reverse_filter_adam7_deinterlace_pass(data,
+         ihdr, pngp->data, pngp->pass_width, pngp->pass_height,
+         &rpng_passes[pngp->pass_pos]);
 
    free(pngp->data);
 
-   pngp->data = NULL;
-   pngp->pass_width  = 0;
-   pngp->pass_height = 0;
-   pngp->pass_size   = 0;
-   pngp->adam7_pass_initialized = false;
+   pngp->data                   = NULL;
+   pngp->pass_width             = 0;
+   pngp->pass_height            = 0;
+   pngp->pass_size              = 0;
+   pngp->flags                 &= ~RPNG_PROCESS_FLAG_ADAM7_PASS_INITIALIZED;
 
    return IMAGE_PROCESS_NEXT;
 }
 
-static int png_reverse_filter_adam7(uint32_t **data_,
+static int rpng_reverse_filter_adam7(uint32_t **data_,
       const struct png_ihdr *ihdr,
       struct rpng_process *pngp)
 {
-   int ret = png_reverse_filter_adam7_iterate(data_,
+   int ret = rpng_reverse_filter_adam7_iterate(data_,
          ihdr, pngp);
 
    switch (ret)
@@ -763,18 +749,8 @@ static int png_reverse_filter_adam7(uint32_t **data_,
    return ret;
 }
 
-static int png_reverse_filter_iterate(rpng_t *rpng, uint32_t **data)
-{
-   if (!rpng)
-      return false;
-
-   if (rpng->ihdr.interlace && rpng->process)
-      return png_reverse_filter_adam7(data, &rpng->ihdr, rpng->process);
-
-   return png_reverse_filter_regular_iterate(data, &rpng->ihdr, rpng->process);
-}
-
-static int rpng_load_image_argb_process_inflate_init(rpng_t *rpng, uint32_t **data)
+static int rpng_load_image_argb_process_inflate_init(
+      rpng_t *rpng, uint32_t **data)
 {
    bool zstatus;
    enum trans_stream_error terror;
@@ -818,47 +794,21 @@ static int rpng_load_image_argb_process_inflate_init(rpng_t *rpng, uint32_t **da
    process->palette                = rpng->palette;
 
    if (rpng->ihdr.interlace != 1)
-      if (png_reverse_filter_init(&rpng->ihdr, process) == -1)
+      if (rpng_reverse_filter_init(&rpng->ihdr, process) == -1)
          goto false_end;
 
-   process->inflate_initialized = true;
+   process->flags              |=  RPNG_PROCESS_FLAG_INFLATE_INITIALIZED;
    return 1;
 
 error:
 false_end:
-   process->inflate_initialized = false;
+   process->flags              &= ~RPNG_PROCESS_FLAG_INFLATE_INITIALIZED;
    return -1;
 }
 
-static bool png_read_plte(uint8_t *buf,
-      uint32_t *buffer, unsigned entries)
-{
-   unsigned i;
-
-   for (i = 0; i < entries; i++)
-   {
-      uint32_t r = buf[3 * i + 0];
-      uint32_t g = buf[3 * i + 1];
-      uint32_t b = buf[3 * i + 2];
-      buffer[i] = (r << 16) | (g << 8) | (b << 0) | (0xffu << 24);
-   }
-
-   return true;
-}
-
-static bool png_read_trns(uint8_t *buf, uint32_t *palette, unsigned entries)
-{
-   unsigned i;
-
-   for (i = 0; i < entries; i++, buf++, palette++)
-      *palette = (*palette & 0x00ffffff) | (unsigned)*buf << 24;
-
-   return true;
-}
-
-bool png_realloc_idat(const struct png_chunk *chunk, struct idat_buffer *buf)
+static bool rpng_realloc_idat(struct idat_buffer *buf, uint32_t chunk_size)
 {
-   uint8_t *new_buffer = (uint8_t*)realloc(buf->data, buf->size + chunk->size);
+   uint8_t *new_buffer = (uint8_t*)realloc(buf->data, buf->size + chunk_size);
 
    if (!new_buffer)
       return false;
@@ -869,15 +819,45 @@ bool png_realloc_idat(const struct png_chunk *chunk, struct idat_buffer *buf)
 
 static struct rpng_process *rpng_process_init(rpng_t *rpng)
 {
-   uint8_t *inflate_buf         = NULL;
-   struct rpng_process *process = (struct rpng_process*)calloc(1, sizeof(*process));
+   uint8_t *inflate_buf            = NULL;
+   struct rpng_process *process    = (struct rpng_process*)malloc(sizeof(*process));
 
    if (!process)
       return NULL;
 
-   process->stream_backend = trans_stream_get_zlib_inflate_backend();
+   process->flags                  = 0;
+   process->prev_scanline          = NULL;
+   process->decoded_scanline       = NULL;
+   process->inflate_buf            = NULL;
 
-   png_pass_geom(&rpng->ihdr, rpng->ihdr.width,
+   process->ihdr.width             = 0;
+   process->ihdr.height            = 0;
+   process->ihdr.depth             = 0;
+   process->ihdr.color_type        = 0;
+   process->ihdr.compression       = 0;
+   process->ihdr.filter            = 0;
+   process->ihdr.interlace         = 0;
+
+   process->restore_buf_size       = 0;
+   process->adam7_restore_buf_size = 0;
+   process->data_restore_buf_size  = 0;
+   process->inflate_buf_size       = 0;
+   process->avail_in               = 0;
+   process->avail_out              = 0;
+   process->total_out              = 0;
+   process->pass_size              = 0;
+   process->bpp                    = 0;
+   process->pitch                  = 0;
+   process->h                      = 0;
+   process->pass_width             = 0;
+   process->pass_height            = 0;
+   process->pass_pos               = 0;
+   process->data                   = 0;
+   process->palette                = 0;
+   process->stream                 = NULL;
+   process->stream_backend         = trans_stream_get_zlib_inflate_backend();
+
+   rpng_pass_geom(&rpng->ihdr, rpng->ihdr.width,
          rpng->ihdr.height, NULL, NULL, &process->inflate_buf_size);
    if (rpng->ihdr.interlace == 1) /* To be sure. */
       process->inflate_buf_size *= 2;
@@ -895,9 +875,9 @@ static struct rpng_process *rpng_process_init(rpng_t *rpng)
       goto error;
 
    process->inflate_buf = inflate_buf;
-   process->avail_in = rpng->idat_buf.size;
-   process->avail_out = process->inflate_buf_size;
-   process->total_out = 0;
+   process->avail_in    = rpng->idat_buf.size;
+   process->avail_out   = process->inflate_buf_size;
+
    process->stream_backend->set_in(
          process->stream,
          rpng->idat_buf.data,
@@ -919,26 +899,19 @@ static struct rpng_process *rpng_process_init(rpng_t *rpng)
    return NULL;
 }
 
-static bool read_chunk_header(uint8_t *buf, uint8_t *buf_end, struct png_chunk *chunk)
+/**
+ * rpng_read_chunk_header:
+ *
+ * Leaf function.
+ *
+ * @return The PNG type of the memory chunk (i.e. IHDR, IDAT, IEND,
+   PLTE, and/or tRNS)
+ **/
+static enum png_chunk_type rpng_read_chunk_header(
+      uint8_t *buf, uint32_t chunk_size)
 {
-   unsigned i;
-   uint8_t dword[4];
-
-   dword[0] = '\0';
-
-   /* Check whether reading the header will overflow
-    * the data buffer */
-   if (buf_end - buf < 8)
-      return false;
-
-   for (i = 0; i < 4; i++)
-      dword[i] = buf[i];
-
-   chunk->size = dword_be(dword);
-
-   /* Check whether chunk will overflow the data buffer */
-   if (buf + 8 + chunk->size > buf_end)
-      return false;
+   int i;
+   char type[4];
 
    for (i = 0; i < 4; i++)
    {
@@ -947,159 +920,212 @@ static bool read_chunk_header(uint8_t *buf, uint8_t *buf_end, struct png_chunk *
       /* All four bytes of the chunk type must be
        * ASCII letters (codes 65-90 and 97-122) */
       if ((byte < 65) || ((byte > 90) && (byte < 97)) || (byte > 122))
-         return false;
-
-      chunk->type[i] = byte;
+         return PNG_CHUNK_ERROR;
+      type[i]      = byte;
    }
 
-   return true;
-}
-
-static bool png_parse_ihdr(uint8_t *buf,
-      struct png_ihdr *ihdr)
-{
-   buf += 4 + 4;
-
-   ihdr->width       = dword_be(buf + 0);
-   ihdr->height      = dword_be(buf + 4);
-   ihdr->depth       = buf[8];
-   ihdr->color_type  = buf[9];
-   ihdr->compression = buf[10];
-   ihdr->filter      = buf[11];
-   ihdr->interlace   = buf[12];
-
-   if (ihdr->width == 0 || ihdr->height == 0)
-      return false;
+   if (     
+            type[0] == 'I'
+         && type[1] == 'H'
+         && type[2] == 'D'
+         && type[3] == 'R'
+      )
+      return PNG_CHUNK_IHDR;
+   else if
+      (
+          type[0] == 'I'
+       && type[1] == 'D'
+       && type[2] == 'A'
+       && type[3] == 'T'
+      )
+         return PNG_CHUNK_IDAT;
+   else if
+      (
+          type[0] == 'I'
+       && type[1] == 'E'
+       && type[2] == 'N'
+       && type[3] == 'D'
+      )
+         return PNG_CHUNK_IEND;
+   else if
+      (
+          type[0] == 'P'
+       && type[1] == 'L'
+       && type[2] == 'T'
+       && type[3] == 'E'
+      )
+         return PNG_CHUNK_PLTE;
+   else if
+      (
+          type[0] == 't'
+       && type[1] == 'R'
+       && type[2] == 'N'
+       && type[3] == 'S'
+      )
+         return PNG_CHUNK_tRNS;
 
-   return true;
+   return PNG_CHUNK_NOOP;
 }
 
 bool rpng_iterate_image(rpng_t *rpng)
 {
    unsigned i;
-   struct png_chunk chunk;
-   uint8_t *buf           = (uint8_t*)rpng->buff_data;
-
-   chunk.size             = 0;
-   chunk.type[0]          = 0;
-   chunk.data             = NULL;
+   uint8_t *buf             = (uint8_t*)rpng->buff_data;
+   uint32_t chunk_size      = 0;
 
    /* Check whether data buffer pointer is valid */
    if (buf > rpng->buff_end)
-      goto error;
+      return false;
 
-   if (!read_chunk_header(buf, rpng->buff_end, &chunk))
-      goto error;
+   /* Check whether reading the header will overflow
+    * the data buffer */
+   if (rpng->buff_end - buf < 8)
+      return false;
 
-#if 0
-   for (i = 0; i < 4; i++)
-   {
-      fprintf(stderr, "chunktype: %c\n", chunk.type[i]);
-   }
-#endif
+   chunk_size = rpng_dword_be(buf);
+
+   /* Check whether chunk will overflow the data buffer */
+   if (buf + 8 + chunk_size > rpng->buff_end)
+      return false;
 
-   switch (png_chunk_type(&chunk))
+   switch (rpng_read_chunk_header(buf, chunk_size))
    {
       case PNG_CHUNK_NOOP:
       default:
          break;
 
       case PNG_CHUNK_ERROR:
-         goto error;
+         return false;
 
       case PNG_CHUNK_IHDR:
-         if (rpng->has_ihdr || rpng->has_idat || rpng->has_iend)
-            goto error;
-
-         if (chunk.size != 13)
-            goto error;
-
-         if (!png_parse_ihdr(buf, &rpng->ihdr))
-            goto error;
-
-         if (!png_process_ihdr(&rpng->ihdr))
-            goto error;
+         if (     (rpng->flags & RPNG_FLAG_HAS_IHDR) 
+               || (rpng->flags & RPNG_FLAG_HAS_IDAT)
+               || (rpng->flags & RPNG_FLAG_HAS_IEND))
+            return false;
+
+         if (chunk_size != 13)
+            return false;
+
+         buf                    += 4 + 4;
+
+         rpng->ihdr.width        = rpng_dword_be(buf + 0);
+         rpng->ihdr.height       = rpng_dword_be(buf + 4);
+         rpng->ihdr.depth        = buf[8];
+         rpng->ihdr.color_type   = buf[9];
+         rpng->ihdr.compression  = buf[10];
+         rpng->ihdr.filter       = buf[11];
+         rpng->ihdr.interlace    = buf[12];
+
+         if (     rpng->ihdr.width  == 0 
+               || rpng->ihdr.height == 0 
+               /* ensure multiplications don't overflow and wrap around, that'd give buffer overflow crashes */
+               || (uint64_t)rpng->ihdr.width*rpng->ihdr.height*sizeof(uint32_t) >= 0x80000000)
+            return false;
+
+         if (!rpng_process_ihdr(&rpng->ihdr))
+            return false;
+
+         if (rpng->ihdr.compression != 0)
+         {
+#if defined(DEBUG) || defined(RPNG_TEST)
+            fprintf(stderr, "[RPNG]: Error in line %d.\n", __LINE__);
+#endif
+            return false;
+         }
 
-         rpng->has_ihdr = true;
+         rpng->flags   |= RPNG_FLAG_HAS_IHDR;
          break;
 
       case PNG_CHUNK_PLTE:
          {
-            unsigned entries = chunk.size / 3;
-
-            if (!rpng->has_ihdr || rpng->has_plte || rpng->has_iend || rpng->has_idat || rpng->has_trns)
-               goto error;
-
-            if (chunk.size % 3)
-               goto error;
+            int i;
+            unsigned entries = chunk_size / 3;
 
             if (entries > 256)
-               goto error;
+               return false;
+            if (chunk_size % 3)
+               return false;
+
+            if (     !(rpng->flags & RPNG_FLAG_HAS_IHDR)
+                  ||  (rpng->flags & RPNG_FLAG_HAS_PLTE)
+                  ||  (rpng->flags & RPNG_FLAG_HAS_IEND)
+                  ||  (rpng->flags & RPNG_FLAG_HAS_IDAT)
+                  ||  (rpng->flags & RPNG_FLAG_HAS_TRNS))
+               return false;
 
             buf += 8;
 
-            if (!png_read_plte(buf, rpng->palette, entries))
-               goto error;
+            for (i = 0; i < (int)entries; i++)
+            {
+               uint32_t r       = buf[3 * i + 0];
+               uint32_t g       = buf[3 * i + 1];
+               uint32_t b       = buf[3 * i + 2];
+               rpng->palette[i] = (r << 16) | (g << 8) | (b << 0) | (0xffu << 24);
+            }
 
-            rpng->has_plte = true;
+            rpng->flags        |= RPNG_FLAG_HAS_PLTE;
          }
          break;
 
       case PNG_CHUNK_tRNS:
-         if (rpng->has_idat)
-            goto error;
+         if (rpng->flags & RPNG_FLAG_HAS_IDAT)
+            return false;
 
          if (rpng->ihdr.color_type == PNG_IHDR_COLOR_PLT)
          {
+            int i;
+            uint32_t *palette;
             /* we should compare with the number of palette entries */
-            if (chunk.size > 256)
-               goto error;
+            if (chunk_size > 256)
+               return false;
 
-            buf += 8;
+            buf    += 8;
+            palette = rpng->palette;
 
-            if (!png_read_trns(buf, rpng->palette, chunk.size))
-               goto error;
+            for (i = 0; i < (int)chunk_size; i++, buf++, palette++)
+               *palette = (*palette & 0x00ffffff) | (unsigned)*buf << 24;
          }
          /* TODO: support colorkey in grayscale and truecolor images */
 
-         rpng->has_trns = true;
+         rpng->flags         |= RPNG_FLAG_HAS_TRNS;
          break;
 
       case PNG_CHUNK_IDAT:
-         if (!(rpng->has_ihdr) || rpng->has_iend || (rpng->ihdr.color_type == PNG_IHDR_COLOR_PLT && !(rpng->has_plte)))
-            goto error;
+         if (     !(rpng->flags & RPNG_FLAG_HAS_IHDR) 
+               ||  (rpng->flags & RPNG_FLAG_HAS_IEND)
+               ||  (rpng->ihdr.color_type == PNG_IHDR_COLOR_PLT 
+                  && 
+                  !(rpng->flags & RPNG_FLAG_HAS_PLTE)))
+            return false;
 
-         if (!png_realloc_idat(&chunk, &rpng->idat_buf))
-            goto error;
+         if (!rpng_realloc_idat(&rpng->idat_buf, chunk_size))
+            return false;
 
          buf += 8;
 
-         for (i = 0; i < chunk.size; i++)
+         for (i = 0; i < chunk_size; i++)
             rpng->idat_buf.data[i + rpng->idat_buf.size] = buf[i];
 
-         rpng->idat_buf.size += chunk.size;
+         rpng->idat_buf.size += chunk_size;
 
-         rpng->has_idat = true;
+         rpng->flags         |= RPNG_FLAG_HAS_IDAT;
          break;
 
       case PNG_CHUNK_IEND:
-         if (!(rpng->has_ihdr) || !(rpng->has_idat))
-            goto error;
+         if (     !(rpng->flags & RPNG_FLAG_HAS_IHDR) 
+               || !(rpng->flags & RPNG_FLAG_HAS_IDAT))
+            return false;
 
-         rpng->has_iend = true;
-         goto error;
+         rpng->flags         |= RPNG_FLAG_HAS_IEND;
+         return false;
    }
 
-   rpng->buff_data += chunk.size + 12;
+   rpng->buff_data += chunk_size + 12;
 
    /* Check whether data buffer pointer is valid */
    if (rpng->buff_data > rpng->buff_end)
-      goto error;
-
+      return false;
    return true;
-
-error:
-   return false;
 }
 
 int rpng_process_image(rpng_t *rpng,
@@ -1107,8 +1133,6 @@ int rpng_process_image(rpng_t *rpng,
 {
    uint32_t **data = (uint32_t**)_data;
 
-   (void)size;
-
    if (!rpng->process)
    {
       struct rpng_process *process = rpng_process_init(rpng);
@@ -1120,7 +1144,7 @@ int rpng_process_image(rpng_t *rpng,
       return IMAGE_PROCESS_NEXT;
    }
 
-   if (!rpng->process->inflate_initialized)
+   if (!(rpng->process->flags & RPNG_PROCESS_FLAG_INFLATE_INITIALIZED))
    {
       if (rpng_load_image_argb_process_inflate_init(rpng, data) == -1)
          goto error;
@@ -1130,7 +1154,9 @@ int rpng_process_image(rpng_t *rpng,
    *width  = rpng->ihdr.width;
    *height = rpng->ihdr.height;
 
-   return png_reverse_filter_iterate(rpng, data);
+   if (rpng->ihdr.interlace && rpng->process)
+      return rpng_reverse_filter_adam7(data, &rpng->ihdr, rpng->process);
+   return rpng_reverse_filter_regular_iterate(data, &rpng->ihdr, rpng->process);
 
 error:
    if (rpng->process)
@@ -1140,6 +1166,7 @@ int rpng_process_image(rpng_t *rpng,
       if (rpng->process->stream)
          rpng->process->stream_backend->stream_free(rpng->process->stream);
       free(rpng->process);
+      rpng->process = NULL;
    }
    return IMAGE_PROCESS_ERROR;
 }
@@ -1170,9 +1197,6 @@ void rpng_free(rpng_t *rpng)
 
 bool rpng_start(rpng_t *rpng)
 {
-   unsigned i;
-   char header[8];
-
    if (!rpng)
       return false;
 
@@ -1181,12 +1205,8 @@ bool rpng_start(rpng_t *rpng)
    if (rpng->buff_end - rpng->buff_data < 8)
       return false;
 
-   header[0] = '\0';
-
-   for (i = 0; i < 8; i++)
-      header[i] = rpng->buff_data[i];
-
-   if (string_is_not_equal_fast(header, png_magic, sizeof(png_magic)))
+   if (string_is_not_equal_fast(
+            rpng->buff_data, png_magic, sizeof(png_magic)))
       return false;
 
    rpng->buff_data += 8;
@@ -1194,14 +1214,21 @@ bool rpng_start(rpng_t *rpng)
    return true;
 }
 
+/**
+ * rpng_is_valid:
+ *
+ * Check if @rpng is a valid PNG image.
+ * Must contain an IHDR chunk, one or more IDAT
+ * chunks, and an IEND chunk.
+ *
+ * Leaf function.
+ *
+ * @return true if it's a valid PNG image, otherwise false.
+ **/
 bool rpng_is_valid(rpng_t *rpng)
 {
-   /* A valid PNG image must contain an IHDR chunk,
-    * one or more IDAT chunks, and an IEND chunk */
-   if (rpng && rpng->has_ihdr && rpng->has_idat && rpng->has_iend)
-      return true;
-
-   return false;
+   return (rpng && ((rpng->flags & (RPNG_FLAG_HAS_IHDR | RPNG_FLAG_HAS_IDAT |
+RPNG_FLAG_HAS_IEND)) > 0));
 }
 
 bool rpng_set_buf_ptr(rpng_t *rpng, void *data, size_t len)
diff --git a/src/libretro/libretro-common/formats/png/rpng_encode.c b/src/libretro/libretro-common/formats/png/rpng_encode.c
index 2794b171d4..ced535cd23 100644
--- a/src/libretro/libretro-common/formats/png/rpng_encode.c
+++ b/src/libretro/libretro-common/formats/png/rpng_encode.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (rpng_encode.c).
@@ -36,7 +36,7 @@
    fprintf(stderr, "[RPNG]: Error in line %d.\n", __LINE__); \
    ret = false; \
    goto end; \
-} while(0)
+} while (0)
 
 double DEFLATE_PADDING = 1.1;
 int PNG_ROUGH_HEADER = 100;
@@ -413,7 +413,7 @@ uint8_t* rpng_save_image_bgr24_string(const uint8_t *data,
    buf        = (uint8_t*)malloc(buf_length*sizeof(uint8_t));
    if (!buf)
       GOTO_END_ERROR(); 
-   
+
    intf_s = intfstream_open_writable_memory(buf, 
          RETRO_VFS_FILE_ACCESS_WRITE,
          RETRO_VFS_FILE_ACCESS_HINT_NONE,
@@ -424,7 +424,7 @@ uint8_t* rpng_save_image_bgr24_string(const uint8_t *data,
 
    *bytes = intfstream_get_ptr(intf_s);
    intfstream_rewind(intf_s);
-   output = (uint8_t*)malloc((*bytes)*sizeof(uint8_t));
+   output = (uint8_t*)malloc((size_t)((*bytes)*sizeof(uint8_t)));
    if (!output)
       GOTO_END_ERROR();
    intfstream_read(intf_s, output, *bytes);
@@ -433,7 +433,10 @@ uint8_t* rpng_save_image_bgr24_string(const uint8_t *data,
    if (buf)
       free(buf);
    if (intf_s)
+   {
+      intfstream_close(intf_s);
       free(intf_s);
+   }
    if (ret == false)
    {
       if (output)
diff --git a/src/libretro/libretro-common/formats/png/rpng_internal.h b/src/libretro/libretro-common/formats/png/rpng_internal.h
index 62dcfbc9e0..9e5d78f801 100644
--- a/src/libretro/libretro-common/formats/png/rpng_internal.h
+++ b/src/libretro/libretro-common/formats/png/rpng_internal.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (rpng_internal.h).
@@ -27,13 +27,6 @@
 #include <filters.h>
 #include <formats/rpng.h>
 
-#undef GOTO_END_ERROR
-#define GOTO_END_ERROR() do { \
-   fprintf(stderr, "[RPNG]: Error in line %d.\n", __LINE__); \
-   ret = false; \
-   goto end; \
-} while(0)
-
 #ifndef ARRAY_SIZE
 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
 #endif
diff --git a/src/libretro/libretro-common/formats/tga/rtga.c b/src/libretro/libretro-common/formats/tga/rtga.c
index e5a413a5b9..01b96e35a5 100644
--- a/src/libretro/libretro-common/formats/tga/rtga.c
+++ b/src/libretro/libretro-common/formats/tga/rtga.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (rtga.c).
@@ -29,7 +29,6 @@
 #include <stdlib.h>
 #include <string.h>
 
-#include <retro_assert.h>
 #include <retro_inline.h>
 
 #include <formats/image.h>
@@ -45,15 +44,13 @@ struct rtga
 
 typedef struct
 {
-   uint32_t img_x, img_y;
-   int img_n, img_out_n;
-
-   int buflen;
-   uint8_t buffer_start[128];
-
    uint8_t *img_buffer;
    uint8_t *img_buffer_end;
    uint8_t *img_buffer_original;
+   int buflen;
+   int img_n, img_out_n;
+   uint32_t img_x, img_y;
+   uint8_t buffer_start[128];
 } rtga_context;
 
 static INLINE uint8_t rtga_get8(rtga_context *s)
@@ -102,40 +99,40 @@ static unsigned char *rtga_convert_format(
       switch (((img_n)*8+(req_comp)))
       {
          case ((1)*8+(2)):
-            for(i=x-1; i >= 0; --i, src += 1, dest += 2)
+            for (i=x-1; i >= 0; --i, src += 1, dest += 2)
             {
                dest[0]=src[0];
                dest[1]=255;
             }
             break;
          case ((1)*8+(3)):
-            for(i=x-1; i >= 0; --i, src += 1, dest += 3)
+            for (i=x-1; i >= 0; --i, src += 1, dest += 3)
                dest[0]=dest[1]=dest[2]=src[0];
             break;
          case ((1)*8+(4)):
-            for(i=x-1; i >= 0; --i, src += 1, dest += 4)
+            for (i=x-1; i >= 0; --i, src += 1, dest += 4)
             {
                dest[0]=dest[1]=dest[2]=src[0];
                dest[3]=255;
             }
             break;
          case ((2)*8+(1)):
-            for(i=x-1; i >= 0; --i, src += 2, dest += 1)
+            for (i=x-1; i >= 0; --i, src += 2, dest += 1)
                dest[0]=src[0];
             break;
          case ((2)*8+(3)):
-            for(i=x-1; i >= 0; --i, src += 2, dest += 3)
+            for (i=x-1; i >= 0; --i, src += 2, dest += 3)
                dest[0]=dest[1]=dest[2]=src[0];
             break;
          case ((2)*8+(4)):
-            for(i=x-1; i >= 0; --i, src += 2, dest += 4)
+            for (i=x-1; i >= 0; --i, src += 2, dest += 4)
             {
                dest[0]=dest[1]=dest[2]=src[0];
                dest[3]=src[1];
             }
             break;
          case ((3)*8+(4)):
-            for(i=x-1; i >= 0; --i, src += 3, dest += 4)
+            for (i=x-1; i >= 0; --i, src += 3, dest += 4)
             {
                dest[0]=src[0];
                dest[1]=src[1];
@@ -144,29 +141,29 @@ static unsigned char *rtga_convert_format(
             }
             break;
          case ((3)*8+(1)):
-            for(i=x-1; i >= 0; --i, src += 3, dest += 1)
+            for (i=x-1; i >= 0; --i, src += 3, dest += 1)
                dest[0] = RTGA_COMPUTE_Y(src[0],src[1],src[2]);
             break;
          case ((3)*8+(2)):
-            for(i=x-1; i >= 0; --i, src += 3, dest += 2)
+            for (i=x-1; i >= 0; --i, src += 3, dest += 2)
             {
                dest[0] = RTGA_COMPUTE_Y(src[0],src[1],src[2]);
                dest[1] = 255;
             }
             break;
          case ((4)*8+(1)):
-            for(i=x-1; i >= 0; --i, src += 4, dest += 1)
+            for (i=x-1; i >= 0; --i, src += 4, dest += 1)
                dest[0] = RTGA_COMPUTE_Y(src[0],src[1],src[2]);
             break;
          case ((4)*8+(2)):
-            for(i=x-1; i >= 0; --i, src += 4, dest += 2)
+            for (i=x-1; i >= 0; --i, src += 4, dest += 2)
             {
                dest[0] = RTGA_COMPUTE_Y(src[0],src[1],src[2]);
                dest[1] = src[3];
             }
             break;
          case ((4)*8+(3)):
-            for(i=x-1; i >= 0; --i, src += 4, dest += 3)
+            for (i=x-1; i >= 0; --i, src += 4, dest += 3)
             {
                dest[0]=src[0];
                dest[1]=src[1];
@@ -268,7 +265,9 @@ static uint8_t *rtga_tga_load(rtga_context *s,
       int RLE_repeating          = 0;
       int RLE_count              = 0;
       int read_next_pixel        = 1;
-      unsigned char raw_data[4]  = {0};
+      /* Needs to be at least 33 bytes to silence a GCC warning,
+       * only 4 are actually used */
+      unsigned char raw_data[33] = {0};
       unsigned char *tga_palette = NULL;
 
       /*   Do I need to load a palette? */
@@ -357,18 +356,21 @@ static uint8_t *rtga_tga_load(rtga_context *s,
       /*   do I need to invert the image? */
       if (tga_inverted)
       {
-         for (j = 0; j*2 < tga_height; ++j)
+         if (tga_data)
          {
-            int index1 = j * tga_width * tga_comp;
-            int index2 = (tga_height - 1 - j) * tga_width * tga_comp;
-
-            for (i = tga_width * tga_comp; i > 0; --i)
+            for (j = 0; j*2 < tga_height; ++j)
             {
-               unsigned char temp = tga_data[index1];
-               tga_data[index1] = tga_data[index2];
-               tga_data[index2] = temp;
-               ++index1;
-               ++index2;
+               int index1 = j * tga_width * tga_comp;
+               int index2 = (tga_height - 1 - j) * tga_width * tga_comp;
+
+               for (i = tga_width * tga_comp; i > 0; --i)
+               {
+                  unsigned char temp = tga_data[index1];
+                  tga_data[index1]   = tga_data[index2];
+                  tga_data[index2]   = temp;
+                  ++index1;
+                  ++index2;
+               }
             }
          }
       }
@@ -431,7 +433,7 @@ int rtga_process_image(rtga_t *rtga, void **buf_data,
    size_tex              = (*width) * (*height);
 
    /* Convert RGBA to ARGB */
-   while(size_tex--)
+   while (size_tex--)
    {
       unsigned int texel = rtga->output_image[size_tex];
       unsigned int A     = texel & 0xFF000000;
diff --git a/src/libretro/libretro-common/formats/wav/rwav.c b/src/libretro/libretro-common/formats/wav/rwav.c
index e012005ae8..b9ed71befd 100644
--- a/src/libretro/libretro-common/formats/wav/rwav.c
+++ b/src/libretro/libretro-common/formats/wav/rwav.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (rwav.c).
@@ -95,12 +95,13 @@ enum rwav_state rwav_iterate(rwav_iterator_t *iter)
 
          rwav->subchunk2size = data[40] | data[41] << 8 | data[42] << 16 | data[43] << 24;
 
-         if (rwav->subchunk2size > iter->size - 44)
+         if ((rwav->subchunk2size < 1) ||
+             (rwav->subchunk2size > iter->size - 44))
             return RWAV_ITERATE_ERROR; /* too few bytes in buffer */
 
          samples = malloc(rwav->subchunk2size);
 
-         if (samples == NULL)
+         if (!samples)
             return RWAV_ITERATE_ERROR;
 
          rwav->numchannels = data[22] | data[23] << 8;
diff --git a/src/libretro/libretro-common/formats/xml/rxml.c b/src/libretro/libretro-common/formats/xml/rxml.c
index 4513e45312..cce10401b6 100644
--- a/src/libretro/libretro-common/formats/xml/rxml.c
+++ b/src/libretro/libretro-common/formats/xml/rxml.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (rxml.c).
@@ -31,10 +31,11 @@
 
 #define BUFSIZE 4096
 
-struct rxml_parse_buffer {
+struct rxml_parse_buffer
+{
+   rxml_node_t *stack[32];
    char xml[BUFSIZE];
    char val[BUFSIZE];
-   rxml_node_t* stack[32];
 };
 
 struct rxml_document
@@ -66,19 +67,15 @@ static void rxml_free_node(struct rxml_node *node)
 
    for (attrib_node_head = node->attrib; attrib_node_head; )
    {
-      struct rxml_attrib_node *next_attrib = NULL;
-
-      next_attrib = (struct rxml_attrib_node*)attrib_node_head->next;
+      struct rxml_attrib_node *next_attrib =
+            (struct rxml_attrib_node*)attrib_node_head->next;
 
-      if (next_attrib)
-      {
-         if (attrib_node_head->attrib)
-            free(attrib_node_head->attrib);
-         if (attrib_node_head->value)
-            free(attrib_node_head->value);
-         if (attrib_node_head)
-            free(attrib_node_head);
-      }
+      if (attrib_node_head->attrib)
+         free(attrib_node_head->attrib);
+      if (attrib_node_head->value)
+         free(attrib_node_head->value);
+      if (attrib_node_head)
+         free(attrib_node_head);
 
       attrib_node_head = next_attrib;
    }
@@ -93,145 +90,201 @@ static void rxml_free_node(struct rxml_node *node)
 
 rxml_document_t *rxml_load_document(const char *path)
 {
-   rxml_document_t *doc;
+   rxml_document_t *doc    = NULL;
    char *memory_buffer     = NULL;
-   long len                = 0;
+   int64_t len             = 0;
    RFILE *file             = filestream_open(path,
          RETRO_VFS_FILE_ACCESS_READ,
          RETRO_VFS_FILE_ACCESS_HINT_NONE);
    if (!file)
       return NULL;
 
-   len           = filestream_get_size(file);
-   memory_buffer = (char*)malloc(len + 1);
+   len                     = filestream_get_size(file);
+   memory_buffer           = (char*)malloc((size_t)(len + 1));
    if (!memory_buffer)
       goto error;
 
-   memory_buffer[len] = '\0';
-   if (filestream_read(file, memory_buffer, len) != (size_t)len)
+   memory_buffer[len]      = '\0';
+   if (filestream_read(file, memory_buffer, len) != len)
       goto error;
 
    filestream_close(file);
-   file = NULL;
+   file                    = NULL;
 
-   doc = rxml_load_document_string(memory_buffer);
+   doc                     = rxml_load_document_string(memory_buffer);
 
    free(memory_buffer);
    return doc;
 
 error:
    free(memory_buffer);
-   if(file)
+   if (file)
       filestream_close(file);
    return NULL;
 }
 
 rxml_document_t *rxml_load_document_string(const char *str)
 {
+   yxml_t x;
    rxml_document_t *doc          = NULL;
-   struct rxml_parse_buffer *buf = NULL;
    size_t stack_i                = 0;
    size_t level                  = 0;
-   int c                         = 0;
+   int i                         = 0;
    char *valptr                  = NULL;
-   yxml_t x;
-
    rxml_node_t *node             = NULL;
    struct rxml_attrib_node *attr = NULL;
-
-   buf = (struct rxml_parse_buffer*)malloc(sizeof(*buf));
+   struct rxml_parse_buffer *buf = (struct rxml_parse_buffer*)
+      malloc(sizeof(*buf));
    if (!buf)
-      goto error;
-
-   valptr = buf->val;
+      return NULL;
 
-   doc = (rxml_document_t*)calloc(1, sizeof(*doc));
+   valptr                        = buf->val;
+   doc                           = (rxml_document_t*)malloc(sizeof(*doc));
    if (!doc)
       goto error;
 
    yxml_init(&x, buf->xml, BUFSIZE);
 
-   for (; *str; ++str) {
+   for (; *str; ++str)
+   {
       yxml_ret_t r = yxml_parse(&x, *str);
 
       if (r < 0)
          goto error;
 
-      switch (r) {
+      switch (r)
+      {
+
+         case YXML_ELEMSTART:
+            if (node)
+            {
+               if (level > stack_i)
+               {
+                  buf->stack[stack_i]      = node;
+                  ++stack_i;
+
+                  node->children           = (rxml_node_t*)
+                     malloc(sizeof(*node));
+
+                  node->children->name     = NULL;
+                  node->children->data     = NULL;
+                  node->children->attrib   = NULL;
+                  node->children->children = NULL;
+                  node->children->next     = NULL;
+
+                  node                     = node->children;
+               }
+               else
+               {
+                  node->next               = (rxml_node_t*)
+                     malloc(sizeof(*node));
+
+                  node->next->name         = NULL;
+                  node->next->data         = NULL;
+                  node->next->attrib       = NULL;
+                  node->next->children     = NULL;
+                  node->next->next         = NULL;
+
+                  node                     = node->next;
+               }
+            }
+            else
+               node = doc->root_node       = (rxml_node_t*)
+                  calloc(1, sizeof(*node));
+
+            if (node->name)
+               free(node->name);
+            node->name                     = strdup(x.elem);
+
+            attr                           = NULL;
+            valptr                         = buf->val;
+
+            ++level;
+            break;
+
+         case YXML_ELEMEND:
+            --level;
+
+            if (valptr > buf->val)
+            {
+               *valptr = '\0';
+
+               /* Original code was broken here:
+                * > If an element ended on two successive
+                *   iterations, on the second iteration
+                *   the 'data' for the *previous* node would
+                *   get overwritten
+                * > This effectively erased the data for the
+                *   previous node, *and* caused a memory leak
+                *   (due to the double strdup())
+                * It seems the correct thing to do here is
+                * only copy the data if the current 'level'
+                * and 'stack index' are the same... */
+               if (level == stack_i)
+               {
+                  if (node->data)
+                     free(node->data);
+                  node->data = strdup(buf->val);
+               }
+
+               valptr = buf->val;
+            }
 
-      case YXML_ELEMSTART:
-         if (node) {
-            if (level > stack_i) {
-               buf->stack[stack_i] = node;
-               ++stack_i;
+            if (level < stack_i)
+            {
+               --stack_i;
+               node = buf->stack[stack_i];
+            }
+            break;
 
-               node->children = (rxml_node_t*)calloc(1, sizeof(*node));
-               node = node->children;
+         case YXML_CONTENT:
+            for (i = 0; i < (int)sizeof(x.data) && x.data[i]; i++)
+            {
+               *valptr = x.data[i];
+               ++valptr;
             }
-            else {
-               node->next = (rxml_node_t*)calloc(1, sizeof(*node));
-               node = node->next;
+            break;
+
+         case YXML_ATTRSTART:
+            if (attr)
+               attr = attr->next   = (struct rxml_attrib_node*)
+                     calloc(1, sizeof(*attr));
+            else
+               attr = node->attrib = (struct rxml_attrib_node*)calloc(1, sizeof(*attr));
+
+            if (attr->attrib)
+               free(attr->attrib);
+            attr->attrib = strdup(x.attr);
+
+            valptr       = buf->val;
+            break;
+
+         case YXML_ATTRVAL:
+            for (i = 0; i < (int)sizeof(x.data) && x.data[i]; i++)
+            {
+               *valptr = x.data[i];
+               ++valptr;
             }
-         }
-         else {
-            node = doc->root_node = (rxml_node_t*)calloc(1, sizeof(*node));
-         }
-
-         node->name = strdup(x.elem);
-         attr = NULL;
-
-         ++level;
-         break;
-
-      case YXML_ELEMEND:
-         --level;
-
-         if (valptr > buf->val) {
-            *valptr = '\0';
-            node->data = strdup(buf->val);
-            valptr = buf->val;
-         }
-
-         if (level < stack_i) {
-            --stack_i;
-            node = buf->stack[stack_i];
-         }
-         break;
-
-      case YXML_CONTENT:
-         for (c = 0; c < sizeof(x.data) && x.data[c]; ++c) {
-            *valptr = x.data[c];
-            ++valptr;
-         }
-         break;
-
-      case YXML_ATTRSTART:
-         if (attr)
-            attr = attr->next = (struct rxml_attrib_node*)calloc(1, sizeof(*attr));
-         else
-            attr = node->attrib = (struct rxml_attrib_node*)calloc(1, sizeof(*attr));
-
-         attr->attrib = strdup(x.attr);
-         valptr = buf->val;
-         break;
-
-      case YXML_ATTRVAL:
-         for(c = 0; c < sizeof(x.data) && x.data[c]; ++c) {
-            *valptr = x.data[c];
-            ++valptr;
-         }
-         break;
-
-      case YXML_ATTREND:
-         if (valptr > buf->val) {
-            *valptr = '\0';
-            attr->value = strdup(buf->val);
-            valptr = buf->val;
-         }
-         break;
-
-      default:
-         break;
+            break;
+
+         case YXML_ATTREND:
+            if (valptr > buf->val)
+            {
+               *valptr = '\0';
+
+               if (attr)
+               {
+                  if (attr->value)
+                     free(attr->value);
+                  attr->value = strdup(buf->val);
+               }
+
+               valptr      = buf->val;
+            }
+            break;
+
+         default:
+            break;
       }
    }
 
diff --git a/src/libretro/libretro-common/gfx/gl_capabilities.c b/src/libretro/libretro-common/gfx/gl_capabilities.c
index 8eea056584..f7e4838000 100644
--- a/src/libretro/libretro-common/gfx/gl_capabilities.c
+++ b/src/libretro/libretro-common/gfx/gl_capabilities.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (gl_capabilities.c).
@@ -300,7 +300,7 @@ bool gl_check_capability(enum gl_capability_enum enum_idx)
       case GL_CAPS_BGRA8888:
 #ifdef HAVE_OPENGLES
          /* There are both APPLE and EXT variants. */
-         if (gl_query_extension("BGRA8888") && !strstr(renderer, "VideoCore"))
+         if (gl_query_extension("BGRA8888"))
             return true;
 #else
          return true;
diff --git a/src/libretro/libretro-common/gfx/scaler/pixconv.c b/src/libretro/libretro-common/gfx/scaler/pixconv.c
index cca79b5260..276ab345f0 100644
--- a/src/libretro/libretro-common/gfx/scaler/pixconv.c
+++ b/src/libretro/libretro-common/gfx/scaler/pixconv.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (pixconv.c).
@@ -41,6 +41,8 @@
 #include <emmintrin.h>
 #elif defined(__MMX__)
 #include <mmintrin.h>
+#elif (defined(__ARM_NEON__) || defined(__ARM_NEON))
+#include <arm_neon.h>
 #endif
 
 void conv_rgb565_0rgb1555(void *output_, const void *input_,
@@ -220,6 +222,8 @@ void conv_rgb565_argb8888(void *output_, const void *input_,
    const __m64 a          = _mm_set1_pi16(0x00ff);
 
    int max_width            = width - 3;
+#elif (defined(__ARM_NEON__) || defined(__ARM_NEON))
+   int max_width            = width - 7;
 #endif
 
    for (h = 0; h < height;
@@ -282,6 +286,23 @@ void conv_rgb565_argb8888(void *output_, const void *input_,
       }
 
       _mm_empty();
+#elif (defined(__ARM_NEON__) || defined(__ARM_NEON))
+      for (; w < max_width; w += 8)
+      {
+         uint16x8_t in = vld1q_u16(input + w);
+
+         uint16x8_t r = vsriq_n_u16(in, in, 5);
+         uint16x8_t b = vsliq_n_u16(in, in, 5);
+         uint16x8_t g = vsriq_n_u16(b,  b,  6);
+
+         uint8x8x4_t res;
+         res.val[3] = vdup_n_u8(0xffu);
+         res.val[2] = vshrn_n_u16(r, 8);
+         res.val[1] = vshrn_n_u16(g, 8);
+         res.val[0] = vshrn_n_u16(b, 2);
+
+         vst4_u8((uint8_t*)(output + w), res);
+      }
 #endif
 
       for (; w < width; w++)
@@ -315,6 +336,8 @@ void conv_rgb565_abgr8888(void *output_, const void *input_,
    const __m128i mul16_b    = _mm_set1_epi16(0x4200);
    const __m128i a          = _mm_set1_epi16(0x00ff);
     int max_width            = width - 7;
+#elif (defined(__ARM_NEON__) || defined(__ARM_NEON))
+   int max_width            = width - 7;
 #endif
     for (h = 0; h < height;
          h++, output += out_stride >> 2, input += in_stride >> 1)
@@ -343,6 +366,23 @@ void conv_rgb565_abgr8888(void *output_, const void *input_,
          _mm_storeu_si128((__m128i*)(output + w + 0), res_lo);
          _mm_storeu_si128((__m128i*)(output + w + 4), res_hi);
       }
+#elif (defined(__ARM_NEON__) || defined(__ARM_NEON))
+      for (; w < max_width; w += 8)
+      {
+         uint16x8_t in = vld1q_u16(input + w);
+
+         uint16x8_t r = vsriq_n_u16(in, in, 5);
+         uint16x8_t b = vsliq_n_u16(in, in, 5);
+         uint16x8_t g = vsriq_n_u16(b,  b,  6);
+
+         uint8x8x4_t res;
+         res.val[3] = vdup_n_u8(0xffu);
+         res.val[2] = vshrn_n_u16(b, 2);
+         res.val[1] = vshrn_n_u16(g, 8);
+         res.val[0] = vshrn_n_u16(r, 8);
+
+         vst4_u8((uint8_t*)(output + w), res);
+      }
 #endif
        for (; w < width; w++)
       {
diff --git a/src/libretro/libretro-common/gfx/scaler/scaler.c b/src/libretro/libretro-common/gfx/scaler/scaler.c
index 99805fa496..7c3c54e0e8 100644
--- a/src/libretro/libretro-common/gfx/scaler/scaler.c
+++ b/src/libretro/libretro-common/gfx/scaler/scaler.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (scaler.c).
diff --git a/src/libretro/libretro-common/gfx/scaler/scaler_filter.c b/src/libretro/libretro-common/gfx/scaler/scaler_filter.c
index adca7eb033..a614290d22 100644
--- a/src/libretro/libretro-common/gfx/scaler/scaler_filter.c
+++ b/src/libretro/libretro-common/gfx/scaler/scaler_filter.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (scaler_filter.c).
@@ -85,7 +85,9 @@ static bool validate_filter(struct scaler_ctx *ctx)
    {
       if (ctx->horiz.filter_pos[i] > max_w_pos || ctx->horiz.filter_pos[i] < 0)
       {
+#ifndef NDEBUG
          fprintf(stderr, "Out X = %d => In X = %d\n", i, ctx->horiz.filter_pos[i]);
+#endif
          return false;
       }
    }
@@ -96,7 +98,9 @@ static bool validate_filter(struct scaler_ctx *ctx)
    {
       if (ctx->vert.filter_pos[i] > max_h_pos || ctx->vert.filter_pos[i] < 0)
       {
+#ifndef NDEBUG
          fprintf(stderr, "Out Y = %d => In Y = %d\n", i, ctx->vert.filter_pos[i]);
+#endif
          return false;
       }
    }
diff --git a/src/libretro/libretro-common/gfx/scaler/scaler_int.c b/src/libretro/libretro-common/gfx/scaler/scaler_int.c
index 0affef7ca2..3c659e16b0 100644
--- a/src/libretro/libretro-common/gfx/scaler/scaler_int.c
+++ b/src/libretro/libretro-common/gfx/scaler/scaler_int.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (scaler_int.c).
diff --git a/src/libretro/libretro-common/glsm/glsm.c b/src/libretro/libretro-common/glsm/glsm.c
index a70aaf417f..8b08c575a6 100644
--- a/src/libretro/libretro-common/glsm/glsm.c
+++ b/src/libretro/libretro-common/glsm/glsm.c
@@ -507,24 +507,6 @@ void rglColorMask(GLboolean red, GLboolean green,
    gl_state.colormask.used  = true;
 }
 
-/*
- *
- * Core in:
- * OpenGLES  : 3.2
- */
-void rglColorMaski(GLint buf, GLboolean red, GLboolean green,
-      GLboolean blue, GLboolean alpha)
-{
-#ifdef GLSM_DEBUG
-   log_cb(RETRO_LOG_INFO, "glColorMaski.\n");
-#endif
-#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES) && defined(HAVE_OPENGLES_3_2)
-   glsm_ctl(GLSM_CTL_IMM_VBO_DRAW, NULL);
-   glColorMaski(buf, red, green, blue, alpha);
-   // TODO: Does the state of this need to be tracked?
-#endif
-}
-
 /*
  *
  * Core in:
@@ -2577,80 +2559,6 @@ void rglDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type,
 #endif
 }
 
-void rglFlush(void)
-{
-#ifdef GLSM_DEBUG
-   log_cb(RETRO_LOG_INFO, "glFlush.\n");
-#endif
-   glFlush();
-}
-
-/*
- *
- * Core in:
- * OpenGL    : 2.0
- * OpenGLES  : 2.0
- */
-void rglTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-#ifdef GLSM_DEBUG
-   log_cb(RETRO_LOG_INFO, "glDrawElementsBaseVertex.\n");
-#endif
-#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES)
-   glTexParameteri(target, pname, param);
-#endif
-}
-
-/*
- *
- * Core in:
- * OpenGL    : 2.0
- * OpenGLES  : 2.0
- */
-void rglTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width,
-	GLsizei height,GLint border, GLenum format,	GLenum type, const GLvoid * data)
-{
-#ifdef GLSM_DEBUG
-   log_cb(RETRO_LOG_INFO, "glTexImage2D.\n");
-#endif
-#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES)
-   glTexImage2D(target, level, internalformat, width, height, border, format, type, data);
-#endif
-}
-
-/*
- *
- * Core in:
- * OpenGL    : 2.0
- * OpenGLES  : 3.0
- */
-void rglDrawBuffer(GLenum buf)
-{
-#ifdef GLSM_DEBUG
-   log_cb(RETRO_LOG_INFO, "glDrawBuffer.\n");
-#endif
-#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES3)
-   glDrawBuffer(buf);
-#endif
-}
-
-/*
- *
- * Core in:
- * OpenGL    : 2.0
- * OpenGLES  : 2.0
- */
-void rglReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
-   GLenum format, GLenum type, GLvoid * data)
-{
-#ifdef GLSM_DEBUG
-   log_cb(RETRO_LOG_INFO, "glFinish.\n");
-#endif
-#if defined(HAVE_OPENGL) || defined(HAVE_OPENGLES)
-   glReadPixels(x, y, width, height, format, type, data);
-#endif
-}
-
 /* GLSM-side */
 
 static void glsm_state_setup(void)
diff --git a/src/libretro/libretro-common/glsym/glgen.py b/src/libretro/libretro-common/glsym/glgen.py
index 3fe2cf5276..8d82357fca 100755
--- a/src/libretro/libretro-common/glsym/glgen.py
+++ b/src/libretro/libretro-common/glsym/glgen.py
@@ -2,9 +2,7 @@
 
 """
    License statement applies to this file (glgen.py) only.
-"""
 
-"""
    Permission is hereby granted, free of charge,
    to any person obtaining a copy of this software and associated documentation files (the "Software"),
    to deal in the Software without restriction, including without limitation the rights to
diff --git a/src/libretro/libretro-common/glsym/glsym_gl.c b/src/libretro/libretro-common/glsym/glsym_gl.c
index 51d3bf0f31..a5ce04e8e0 100644
--- a/src/libretro/libretro-common/glsym/glsym_gl.c
+++ b/src/libretro/libretro-common/glsym/glsym_gl.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010-2018 The RetroArch team
+/* Copyright (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this libretro SDK code part (glsym).
diff --git a/src/libretro/libretro-common/glsym/rglgen.c b/src/libretro/libretro-common/glsym/rglgen.c
index a05d5445d9..d1c4119db6 100644
--- a/src/libretro/libretro-common/glsym/rglgen.c
+++ b/src/libretro/libretro-common/glsym/rglgen.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010-2018 The RetroArch team
+/* Copyright (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this libretro SDK code part (glsym).
diff --git a/src/libretro/libretro-common/glsym/rglgen.py b/src/libretro/libretro-common/glsym/rglgen.py
index c1255ad8c8..ee43be2c88 100755
--- a/src/libretro/libretro-common/glsym/rglgen.py
+++ b/src/libretro/libretro-common/glsym/rglgen.py
@@ -2,9 +2,7 @@
 
 """
    License statement applies to this file (glgen.py) only.
-"""
 
-"""
    Permission is hereby granted, free of charge,
    to any person obtaining a copy of this software and associated documentation files (the "Software"),
    to deal in the Software without restriction, including without limitation the rights to
diff --git a/src/libretro/libretro-common/glsym/xglgen.py b/src/libretro/libretro-common/glsym/xglgen.py
index 92b428baf2..215ffff3bc 100644
--- a/src/libretro/libretro-common/glsym/xglgen.py
+++ b/src/libretro/libretro-common/glsym/xglgen.py
@@ -2,9 +2,7 @@
 
 """
    License statement applies to this file (xglgen.py) only.
-"""
 
-"""
    Permission is hereby granted, free of charge,
    to any person obtaining a copy of this software and associated documentation files (the "Software"),
    to deal in the Software without restriction, including without limitation the rights to
diff --git a/src/libretro/libretro-common/include/audio/audio_mix.h b/src/libretro/libretro-common/include/audio/audio_mix.h
index 937c4b28e8..6a2adac171 100644
--- a/src/libretro/libretro-common/include/audio/audio_mix.h
+++ b/src/libretro/libretro-common/include/audio/audio_mix.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (audio_mix.h).
@@ -40,19 +40,19 @@ RETRO_BEGIN_DECLS
 
 typedef struct
 {
+   double ratio;
    void *buf;
    int16_t *upsample_buf;
    float *float_buf;
    float *float_resample_buf;
    int16_t *resample_buf;
+   const retro_resampler_t *resampler;
+   void *resampler_data;
+   rwav_t *rwav;
    ssize_t len;
    size_t resample_len;
-   rwav_t *rwav;
    int sample_rate;
    bool resample;
-   const retro_resampler_t *resampler;
-   void *resampler_data;
-   double ratio;
 } audio_chunk_t;
 
 #if defined(__SSE2__)
@@ -68,7 +68,8 @@ void audio_mix_volume_C(float *dst, const float *src, float vol, size_t samples)
 
 void audio_mix_free_chunk(audio_chunk_t *chunk);
 
-audio_chunk_t* audio_mix_load_wav_file(const char *path, int sample_rate);
+audio_chunk_t* audio_mix_load_wav_file(const char *path, int sample_rate,
+      const char *resampler_ident, enum resampler_quality quality);
 
 size_t audio_mix_get_chunk_num_samples(audio_chunk_t *chunk);
 
diff --git a/src/libretro/libretro-common/include/audio/audio_mixer.h b/src/libretro/libretro-common/include/audio/audio_mixer.h
index bb8d35d0c7..6b07bbe1e5 100644
--- a/src/libretro/libretro-common/include/audio/audio_mixer.h
+++ b/src/libretro/libretro-common/include/audio/audio_mixer.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (audio_mixer.h).
@@ -34,6 +34,8 @@
 #include <boolean.h>
 #include <retro_common_api.h>
 
+#include <audio/audio_resampler.h>
+
 RETRO_BEGIN_DECLS
 
 enum audio_mixer_type
@@ -60,7 +62,8 @@ void audio_mixer_init(unsigned rate);
 
 void audio_mixer_done(void);
 
-audio_mixer_sound_t* audio_mixer_load_wav(void *buffer, int32_t size);
+audio_mixer_sound_t* audio_mixer_load_wav(void *buffer, int32_t size,
+      const char *resampler_ident, enum resampler_quality quality);
 audio_mixer_sound_t* audio_mixer_load_ogg(void *buffer, int32_t size);
 audio_mixer_sound_t* audio_mixer_load_mod(void *buffer, int32_t size);
 audio_mixer_sound_t* audio_mixer_load_flac(void *buffer, int32_t size);
@@ -69,7 +72,10 @@ audio_mixer_sound_t* audio_mixer_load_mp3(void *buffer, int32_t size);
 void audio_mixer_destroy(audio_mixer_sound_t* sound);
 
 audio_mixer_voice_t* audio_mixer_play(audio_mixer_sound_t* sound,
-      bool repeat, float volume, audio_mixer_stop_cb_t stop_cb);
+      bool repeat, float volume,
+      const char *resampler_ident,
+      enum resampler_quality quality,
+      audio_mixer_stop_cb_t stop_cb);
 
 void audio_mixer_stop(audio_mixer_voice_t* voice);
 
diff --git a/src/libretro/libretro-common/include/audio/audio_resampler.h b/src/libretro/libretro-common/include/audio/audio_resampler.h
index 46eb426a20..cdb09c232d 100644
--- a/src/libretro/libretro-common/include/audio/audio_resampler.h
+++ b/src/libretro/libretro-common/include/audio/audio_resampler.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (audio_resampler.h).
@@ -65,14 +65,43 @@ typedef unsigned resampler_simd_mask_t;
 
 #define RESAMPLER_API_VERSION 1
 
+/**
+ * A struct that groups the input and output of a resampler.
+ */
 struct resampler_data
 {
+   /**
+    * The buffer containing the data to be resampled.
+    */
    const float *data_in;
+
+   /**
+    * The buffer that will be used to store resampled output.
+    * Must be allocated in advance, and must not be the same as data_in.
+    */
    float *data_out;
 
+   /**
+    * The size of ::data_in, in frames (\em not bytes or samples).
+    * For example, 32-bit stereo frames would consist of 8 bytes
+    * (two 4-byte floats per frame).
+    */
    size_t input_frames;
+
+   /**
+    * The number of frames (\em not bytes or samples) that the resampler produced.
+    * This value is set by the resampler.
+    * The resampler may not provide the same number of frames with each use,
+    * so be sure to check this value.
+    */
    size_t output_frames;
 
+   /**
+    * The desired ratio of output_frames to input_frames.
+    * This value is used to determine the number of frames written to \c data_out.
+    * If this value is (almost) equal to 1,
+    * then resampling may be skipped.
+    */
    double ratio;
 };
 
@@ -155,7 +184,6 @@ extern retro_resampler_t sinc_resampler;
 extern retro_resampler_t CC_resampler;
 #endif
 extern retro_resampler_t nearest_resampler;
-extern retro_resampler_t null_resampler;
 
 /**
  * audio_resampler_driver_find_handle:
diff --git a/src/libretro/libretro-common/include/audio/conversion/float_to_s16.h b/src/libretro/libretro-common/include/audio/conversion/float_to_s16.h
index 2ddf65e75d..42b9571e4f 100644
--- a/src/libretro/libretro-common/include/audio/conversion/float_to_s16.h
+++ b/src/libretro/libretro-common/include/audio/conversion/float_to_s16.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2021 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (float_to_s16.h).
diff --git a/src/libretro/libretro-common/include/audio/conversion/s16_to_float.h b/src/libretro/libretro-common/include/audio/conversion/s16_to_float.h
index 4f705b8b80..188296e076 100644
--- a/src/libretro/libretro-common/include/audio/conversion/s16_to_float.h
+++ b/src/libretro/libretro-common/include/audio/conversion/s16_to_float.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2021 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (s16_to_float.h).
diff --git a/src/libretro/libretro-common/include/audio/dsp_filter.h b/src/libretro/libretro-common/include/audio/dsp_filter.h
index 2bbe74af29..fc5be2094c 100644
--- a/src/libretro/libretro-common/include/audio/dsp_filter.h
+++ b/src/libretro/libretro-common/include/audio/dsp_filter.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (dsp_filter.h).
@@ -34,6 +34,9 @@ retro_dsp_filter_t *retro_dsp_filter_new(const char *filter_config,
 
 void retro_dsp_filter_free(retro_dsp_filter_t *dsp);
 
+/**
+ * A struct that groups the input and output of a DSP filter.
+ */
 struct retro_dsp_data
 {
    float *input;
diff --git a/src/libretro/libretro-common/include/boolean.h b/src/libretro/libretro-common/include/boolean.h
index f06ac5a742..9d0d7c129e 100644
--- a/src/libretro/libretro-common/include/boolean.h
+++ b/src/libretro/libretro-common/include/boolean.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (boolean.h).
diff --git a/src/libretro/libretro-common/include/cdrom/cdrom.h b/src/libretro/libretro-common/include/cdrom/cdrom.h
index d455602fa7..063d9aca49 100644
--- a/src/libretro/libretro-common/include/cdrom/cdrom.h
+++ b/src/libretro/libretro-common/include/cdrom/cdrom.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2019 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (cdrom.h).
@@ -62,10 +62,10 @@ typedef struct
 
 typedef struct
 {
-   char drive;
+   cdrom_track_t track[99];         /* unsigned alignment */
+   cdrom_group_timeouts_t timeouts; /* unsigned short alignment */
    unsigned char num_tracks;
-   cdrom_group_timeouts_t timeouts;
-   cdrom_track_t track[99];
+   char drive;
 } cdrom_toc_t;
 
 void cdrom_lba_to_msf(unsigned lba, unsigned char *min, unsigned char *sec, unsigned char *frame);
diff --git a/src/libretro/libretro-common/include/clamping.h b/src/libretro/libretro-common/include/clamping.h
index ec29bf9a38..d836d98990 100644
--- a/src/libretro/libretro-common/include/clamping.h
+++ b/src/libretro/libretro-common/include/clamping.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (clamping.h).
diff --git a/src/libretro/libretro-common/include/compat/apple_compat.h b/src/libretro/libretro-common/include/compat/apple_compat.h
index 819b39ecf6..bf98a59138 100644
--- a/src/libretro/libretro-common/include/compat/apple_compat.h
+++ b/src/libretro/libretro-common/include/compat/apple_compat.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (apple_compat.h).
diff --git a/src/libretro/libretro-common/include/compat/fnmatch.h b/src/libretro/libretro-common/include/compat/fnmatch.h
index cede1ca6c7..9787878448 100644
--- a/src/libretro/libretro-common/include/compat/fnmatch.h
+++ b/src/libretro/libretro-common/include/compat/fnmatch.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (fnmatch.h).
diff --git a/src/libretro/libretro-common/include/compat/fopen_utf8.h b/src/libretro/libretro-common/include/compat/fopen_utf8.h
index f59822a5ca..97d4404e27 100644
--- a/src/libretro/libretro-common/include/compat/fopen_utf8.h
+++ b/src/libretro/libretro-common/include/compat/fopen_utf8.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (fopen_utf8.h).
diff --git a/src/libretro/libretro-common/include/compat/getopt.h b/src/libretro/libretro-common/include/compat/getopt.h
index 2e606a68c7..48603f0d22 100644
--- a/src/libretro/libretro-common/include/compat/getopt.h
+++ b/src/libretro/libretro-common/include/compat/getopt.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (getopt.h).
diff --git a/src/libretro/libretro-common/include/compat/intrinsics.h b/src/libretro/libretro-common/include/compat/intrinsics.h
index cb1f540daa..ac490274e8 100644
--- a/src/libretro/libretro-common/include/compat/intrinsics.h
+++ b/src/libretro/libretro-common/include/compat/intrinsics.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (intrinsics.h).
@@ -41,7 +41,7 @@ RETRO_BEGIN_DECLS
 /* Count Leading Zero, unsigned 16bit input value */
 static INLINE unsigned compat_clz_u16(uint16_t val)
 {
-#if defined(__GNUC__) && !defined(PS2)
+#if defined(__GNUC__)
    return __builtin_clz(val << 16 | 0x8000);
 #else
    unsigned ret = 0;
@@ -63,20 +63,34 @@ static INLINE int compat_ctz(unsigned x)
    return __builtin_ctz(x);
 #elif _MSC_VER >= 1400 && !defined(_XBOX) && !defined(__WINRT__)
    unsigned long r = 0;
-   _BitScanReverse((unsigned long*)&r, x);
+   _BitScanForward((unsigned long*)&r, x);
    return (int)r;
 #else
-/* Only checks at nibble granularity,
- * because that's what we need. */
-   if (x & 0x000f)
-      return 0;
-   if (x & 0x00f0)
-      return 4;
-   if (x & 0x0f00)
-      return 8;
-   if (x & 0xf000)
-      return 12;
-   return 16;
+   int count = 0;
+   if (!(x & 0xffff))
+   {
+      x >>= 16;
+      count |= 16;
+   }
+   if (!(x & 0xff))
+   {
+      x >>= 8;
+      count |= 8;
+   }
+   if (!(x & 0xf))
+   {
+      x >>= 4;
+      count |= 4;
+   }
+   if (!(x & 0x3))
+   {
+      x >>= 2;
+      count |= 2;
+   }
+   if (!(x & 0x1))
+      count |= 1;
+
+   return count;
 #endif
 }
 
diff --git a/src/libretro/libretro-common/include/compat/msvc.h b/src/libretro/libretro-common/include/compat/msvc.h
index 4681b12cf2..a4c93a59ab 100644
--- a/src/libretro/libretro-common/include/compat/msvc.h
+++ b/src/libretro/libretro-common/include/compat/msvc.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (msvc.h).
@@ -29,20 +29,17 @@
 extern "C"  {
 #endif
 
-/* Pre-MSVC 2015 compilers don't implement snprintf in a cross-platform manner. */
+/* Pre-MSVC 2015 compilers don't implement snprintf, vsnprintf in a cross-platform manner. */
 #if _MSC_VER < 1900
+   #include <stdio.h>
+   #include <stdarg.h>
    #include <stdlib.h>
+
    #ifndef snprintf
       #define snprintf c99_snprintf_retro__
    #endif
-
    int c99_snprintf_retro__(char *outBuf, size_t size, const char *format, ...);
-#endif
 
-/* Pre-MSVC 2008 compilers don't implement vsnprintf in a cross-platform manner? Not sure about this one. */
-#if _MSC_VER < 1500
-   #include <stdarg.h>
-   #include <stdlib.h>
    #ifndef vsnprintf
       #define vsnprintf c99_vsnprintf_retro__
    #endif
diff --git a/src/libretro/libretro-common/include/compat/posix_string.h b/src/libretro/libretro-common/include/compat/posix_string.h
index f4380c3a65..47964b2a0f 100644
--- a/src/libretro/libretro-common/include/compat/posix_string.h
+++ b/src/libretro/libretro-common/include/compat/posix_string.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (posix_string.h).
@@ -29,10 +29,6 @@
 #include <compat/msvc.h>
 #endif
 
-#if defined(PS2)
-#include <compat_ctype.h>
-#endif
-
 RETRO_BEGIN_DECLS
 
 #ifdef _WIN32
diff --git a/src/libretro/libretro-common/include/compat/strcasestr.h b/src/libretro/libretro-common/include/compat/strcasestr.h
index c26de9e008..227e253e7b 100644
--- a/src/libretro/libretro-common/include/compat/strcasestr.h
+++ b/src/libretro/libretro-common/include/compat/strcasestr.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (strcasestr.h).
@@ -25,10 +25,6 @@
 
 #include <string.h>
 
-#if defined(PS2)
-#include <compat_ctype.h>
-#endif
-
 #if defined(RARCH_INTERNAL) && defined(HAVE_CONFIG_H)
 #include "../../../config.h"
 #endif
diff --git a/src/libretro/libretro-common/include/compat/strl.h b/src/libretro/libretro-common/include/compat/strl.h
index c70f119557..5e7a892fcb 100644
--- a/src/libretro/libretro-common/include/compat/strl.h
+++ b/src/libretro/libretro-common/include/compat/strl.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (strl.h).
diff --git a/src/libretro/libretro-common/include/compat/zlib.h b/src/libretro/libretro-common/include/compat/zlib.h
index 94110afd3d..efd0a897d3 100644
--- a/src/libretro/libretro-common/include/compat/zlib.h
+++ b/src/libretro/libretro-common/include/compat/zlib.h
@@ -1196,8 +1196,8 @@ typedef int (*out_func) (void FAR *, unsigned char FAR *, unsigned);
    compress() or compress2() call to allocate the destination buffer.
 */
 
- int  uncompress (unsigned char *dest,   uint32_t *destLen,
-       const unsigned char *source, uint32_t sourceLen);
+ int  uncompress (Bytef *dest,   uLongf *destLen,
+       const Bytef *source, uLongf sourceLen);
 /*
      Decompresses the source buffer into the destination buffer.  sourceLen is
    the byte length of the source buffer.  Upon entry, destLen is the total size
@@ -1742,8 +1742,9 @@ uint32_t adler32 (uint32_t adler, const uint8_t *buf, size_t len);
  const char   *  zError           (int);
  int             inflateSyncPoint (z_streamp);
 
-const uint32_t * get_crc_table(void);
+ const uint32_t * get_crc_table(void);
  int             inflateUndermine (z_streamp, int);
+ int             inflateValidate  (z_streamp, int);
  int             inflateResetKeep (z_streamp);
  int             deflateResetKeep (z_streamp);
 #if defined(_WIN32) && !defined(Z_SOLO)
diff --git a/src/libretro/libretro-common/include/dynamic/dylib.h b/src/libretro/libretro-common/include/dynamic/dylib.h
index f6951273bd..6a52b95cd8 100644
--- a/src/libretro/libretro-common/include/dynamic/dylib.h
+++ b/src/libretro/libretro-common/include/dynamic/dylib.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (dylib.h).
@@ -49,7 +49,7 @@ typedef void (*function_t)(void);
  *
  * Platform independent dylib loading.
  *
- * Returns: library handle on success, otherwise NULL.
+ * @return Library handle on success, otherwise NULL.
  **/
 dylib_t dylib_load(const char *path);
 
diff --git a/src/libretro/libretro-common/include/encodings/base64.h b/src/libretro/libretro-common/include/encodings/base64.h
index 11658d763f..13808511e1 100644
--- a/src/libretro/libretro-common/include/encodings/base64.h
+++ b/src/libretro/libretro-common/include/encodings/base64.h
@@ -8,38 +8,6 @@
 
 RETRO_BEGIN_DECLS
 
-const static char* b64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-/* maps A=>0,B=>1.. */
-const static unsigned char unb64[]={
-  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-  0,   0,   0,  62,   0,   0,   0,  63,  52,  53,
- 54,  55,  56,  57,  58,  59,  60,  61,   0,   0,
-  0,   0,   0,   0,   0,   0,   1,   2,   3,   4,
-  5,   6,   7,   8,   9,  10,  11,  12,  13,  14,
- 15,  16,  17,  18,  19,  20,  21,  22,  23,  24,
- 25,   0,   0,   0,   0,   0,   0,  26,  27,  28,
- 29,  30,  31,  32,  33,  34,  35,  36,  37,  38,
- 39,  40,  41,  42,  43,  44,  45,  46,  47,  48,
- 49,  50,  51,   0,   0,   0,   0,   0,   0,   0,
-  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-  0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
-  0,   0,   0,   0,   0,   0,
-}; /* This array has 256 elements */
-
 char* base64(const void* binaryData, int len, int *flen);
 unsigned char* unbase64(const char* ascii, int len, int *flen);
 
diff --git a/src/libretro/libretro-common/include/encodings/crc32.h b/src/libretro/libretro-common/include/encodings/crc32.h
index 25e926276f..5f26cc72f2 100644
--- a/src/libretro/libretro-common/include/encodings/crc32.h
+++ b/src/libretro/libretro-common/include/encodings/crc32.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (crc32.h).
@@ -31,7 +31,6 @@
 RETRO_BEGIN_DECLS
 
 uint32_t encoding_crc32(uint32_t crc, const uint8_t *buf, size_t len);
-uint32_t file_crc32(uint32_t crc, const char *path);
 
 RETRO_END_DECLS
 
diff --git a/src/libretro/libretro-common/include/encodings/utf.h b/src/libretro/libretro-common/include/encodings/utf.h
index b513f28a18..ccd08fa6e7 100644
--- a/src/libretro/libretro-common/include/encodings/utf.h
+++ b/src/libretro/libretro-common/include/encodings/utf.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (utf.h).
@@ -35,32 +35,102 @@ RETRO_BEGIN_DECLS
 enum CodePage
 {
    CODEPAGE_LOCAL = 0, /* CP_ACP */
-   CODEPAGE_UTF8 = 65001 /* CP_UTF8 */
+   CODEPAGE_UTF8  = 65001 /* CP_UTF8 */
 };
 
+/**
+ * utf8_conv_utf32:
+ *
+ * Simple implementation. Assumes the sequence is
+ * properly synchronized and terminated.
+ **/
 size_t utf8_conv_utf32(uint32_t *out, size_t out_chars,
       const char *in, size_t in_size);
 
+/**
+ * utf16_conv_utf8:
+ *
+ * Leaf function.
+ **/
 bool utf16_conv_utf8(uint8_t *out, size_t *out_chars,
       const uint16_t *in, size_t in_size);
 
+/**
+ * utf8len:
+ *
+ * Leaf function.
+ **/
 size_t utf8len(const char *string);
 
+/**
+ * utf8cpy:
+ *
+ * Acts mostly like strlcpy.
+ *
+ * Copies the given number of UTF-8 characters,
+ * but at most @d_len bytes.
+ *
+ * Always NULL terminates. Does not copy half a character.
+ * @s is assumed valid UTF-8.
+ * Use only if @chars is considerably less than @d_len. 
+ *
+ * Hidden non-leaf function cost:
+ * - Calls memcpy
+ *
+ * @return Number of bytes. 
+ **/
 size_t utf8cpy(char *d, size_t d_len, const char *s, size_t chars);
 
+/**
+ * utf8skip:
+ *
+ * Leaf function
+ **/
 const char *utf8skip(const char *str, size_t chars);
 
+/** 
+ * utf8_walk:
+ *
+ * Does not validate the input.
+ *
+ * Leaf function.
+ *
+ * @return Returns garbage if it's not UTF-8.
+ **/
 uint32_t utf8_walk(const char **string);
 
+/**
+ * utf16_to_char_string:
+ **/
 bool utf16_to_char_string(const uint16_t *in, char *s, size_t len);
 
-char* utf8_to_local_string_alloc(const char *str);
-
-char* local_to_utf8_string_alloc(const char *str);
-
-wchar_t* utf8_to_utf16_string_alloc(const char *str);
+/**
+ * utf8_to_local_string_alloc:
+ *
+ * @return Returned pointer MUST be freed by the caller if non-NULL.
+ **/
+char *utf8_to_local_string_alloc(const char *str);
 
-char* utf16_to_utf8_string_alloc(const wchar_t *str);
+/**
+ * local_to_utf8_string_alloc:
+ *
+ * @return Returned pointer MUST be freed by the caller if non-NULL.
+ **/
+char *local_to_utf8_string_alloc(const char *str);
+
+/**
+ * utf8_to_utf16_string_alloc:
+ * 
+ * @return Returned pointer MUST be freed by the caller if non-NULL.
+ **/
+wchar_t *utf8_to_utf16_string_alloc(const char *str);
+
+/**
+ * utf16_to_utf8_string_alloc:
+ *
+ * @return Returned pointer MUST be freed by the caller if non-NULL.
+ **/
+char *utf16_to_utf8_string_alloc(const wchar_t *str);
 
 RETRO_END_DECLS
 
diff --git a/src/libretro/libretro-common/include/encodings/win32.h b/src/libretro/libretro-common/include/encodings/win32.h
index d4221bd9b7..8104af0c67 100644
--- a/src/libretro/libretro-common/include/encodings/win32.h
+++ b/src/libretro/libretro-common/include/encodings/win32.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (utf.h).
diff --git a/src/libretro/libretro-common/include/fastcpy.h b/src/libretro/libretro-common/include/fastcpy.h
index 9d40702bf3..7ecd460f7c 100644
--- a/src/libretro/libretro-common/include/fastcpy.h
+++ b/src/libretro/libretro-common/include/fastcpy.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (fastcpy.h).
@@ -45,49 +45,48 @@ static INLINE void* memcpy64(void* dst,void* src,size_t size)
 
 static INLINE void* memset16(void* dst,uint16_t val,size_t size)
 {
-   uint16_t* typedptr = (uint16_t*)dst;
+   uint16_t *typedptr = (uint16_t*)dst;
    std::fill(typedptr, typedptr + size, val);
    return dst;
 }
 
 static INLINE void* memset32(void* dst,uint32_t val,size_t size)
 {
-   uint32_t* typedptr = (uint32_t*)dst;
+   uint32_t *typedptr = (uint32_t*)dst;
    std::fill(typedptr, typedptr + size, val);
    return dst;
 }
 
 static INLINE void* memset64(void* dst,uint64_t val,size_t size)
 {
-   uint64_t* typedptr = (uint64_t*)dst;
+   uint64_t *typedptr = (uint64_t*)dst;
    std::fill(typedptr, typedptr + size, val);
    return dst;
 }
 #else
-
-static INLINE void* memset16(void* dst,uint16_t val,size_t size)
+static INLINE void *memset16(void* dst,uint16_t val,size_t size)
 {
    size_t i;
-   uint16_t* typedptr = (uint16_t*)dst;
-   for(i = 0;i < size;i++)
+   uint16_t *typedptr = (uint16_t*)dst;
+   for (i = 0;i < size;i++)
       typedptr[i] = val;
    return dst;
 }
 
-static INLINE void* memset32(void* dst,uint32_t val,size_t size)
+static INLINE void *memset32(void* dst,uint32_t val,size_t size)
 {
    size_t i;
-   uint32_t* typedptr = (uint32_t*)dst;
-   for(i = 0;i < size;i++)
+   uint32_t *typedptr = (uint32_t*)dst;
+   for (i = 0; i < size; i++)
       typedptr[i] = val;
    return dst;
 }
 
-static INLINE void* memset64(void* dst,uint64_t val,size_t size)
+static INLINE void *memset64(void* dst,uint64_t val,size_t size)
 {
    size_t i;
-   uint64_t* typedptr = (uint64_t*)dst;
-   for(i = 0;i < size;i++)
+   uint64_t *typedptr = (uint64_t*)dst;
+   for (i = 0; i < size;i++)
       typedptr[i] = val;
    return dst;
 }
diff --git a/src/libretro/libretro-common/include/features/features_cpu.h b/src/libretro/libretro-common/include/features/features_cpu.h
index 139d9b2d0a..130d748125 100644
--- a/src/libretro/libretro-common/include/features/features_cpu.h
+++ b/src/libretro/libretro-common/include/features/features_cpu.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (features_cpu.h).
@@ -36,7 +36,7 @@ RETRO_BEGIN_DECLS
  *
  * Gets performance counter.
  *
- * Returns: performance counter.
+ * @return Performance counter.
  **/
 retro_perf_tick_t cpu_features_get_perf_counter(void);
 
@@ -46,7 +46,7 @@ retro_perf_tick_t cpu_features_get_perf_counter(void);
  * Gets time in microseconds, from an undefined epoch.
  * The epoch may change between computers or across reboots.
  *
- * Returns: time in microseconds
+ * @return Time in microseconds
  **/
 retro_time_t cpu_features_get_time_usec(void);
 
@@ -55,7 +55,7 @@ retro_time_t cpu_features_get_time_usec(void);
  *
  * Gets CPU features.
  *
- * Returns: bitmask of all CPU features available.
+ * @return Bitmask of all CPU features available.
  **/
 uint64_t cpu_features_get(void);
 
@@ -64,7 +64,7 @@ uint64_t cpu_features_get(void);
  *
  * Gets the amount of available CPU cores.
  *
- * Returns: amount of CPU cores available.
+ * @return Amount of CPU cores available.
  **/
 unsigned cpu_features_get_core_amount(void);
 
diff --git a/src/libretro/libretro-common/include/file/archive_file.h b/src/libretro/libretro-common/include/file/archive_file.h
index 9c46da0286..7a0a9f7065 100644
--- a/src/libretro/libretro-common/include/file/archive_file.h
+++ b/src/libretro/libretro-common/include/file/archive_file.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (archive_file.h).
@@ -37,9 +37,11 @@
 
 #include <retro_common_api.h>
 
-RETRO_BEGIN_DECLS
+#if defined(RARCH_INTERNAL) && defined(HAVE_CONFIG_H)
+#include "../../../config.h" /* for HAVE_MMAP */
+#endif
 
-struct archive_extract_userdata;
+RETRO_BEGIN_DECLS
 
 enum file_archive_transfer_type
 {
@@ -52,72 +54,53 @@ enum file_archive_transfer_type
 
 typedef struct file_archive_handle
 {
-   void     *stream;
    uint8_t  *data;
    uint32_t real_checksum;
-   const struct file_archive_file_backend *backend;
 } file_archive_file_handle_t;
 
-typedef struct file_archive_file_data file_archive_file_data_t;
-
 typedef struct file_archive_transfer
 {
-   enum file_archive_transfer_type type;
-   int32_t archive_size;
-   ptrdiff_t start_delta;
-   file_archive_file_data_t *handle;
-   void *stream;
-   const uint8_t *footer;
-   const uint8_t *directory;
-   const uint8_t *data;
+   int64_t archive_size;
+   void *context;
+   struct RFILE *archive_file;
    const struct file_archive_file_backend *backend;
+#ifdef HAVE_MMAP
+   uint8_t *archive_mmap_data;
+   int archive_mmap_fd;
+#endif
+   unsigned step_total;
+   unsigned step_current;
+   enum file_archive_transfer_type type;
 } file_archive_transfer_t;
 
-enum file_archive_compression_mode
-{
-   ARCHIVE_MODE_UNCOMPRESSED = 0,
-   ARCHIVE_MODE_COMPRESSED   = 8
-};
-
-struct decomp_state_t
-{
-   char *opt_file;
-   char *needle;
-   void **buf;
-   size_t size;
-   bool found;
-};
-
 typedef struct
 {
+   file_archive_transfer_t archive;             /* int64_t alignment */
    char *source_file;
    char *subdir;
    char *target_dir;
    char *target_file;
    char *valid_ext;
-
    char *callback_error;
-
-   file_archive_transfer_t archive;
    struct archive_extract_userdata *userdata;
 } decompress_state_t;
 
 struct archive_extract_userdata
 {
-   char archive_path[PATH_MAX_LENGTH];
+   /* These are set or read by the archive processing */
    char *first_extracted_file_path;
-   char *extracted_file_path;
    const char *extraction_directory;
-   size_t archive_path_size;
    struct string_list *ext;
    struct string_list *list;
+   file_archive_transfer_t *transfer;
+   /* Not used by the processing, free to use outside or in iterate callback */
+   decompress_state_t *dec;
+   void* cb_data;
+   uint32_t crc;
+   char archive_path[PATH_MAX_LENGTH];
+   char current_file_path[PATH_MAX_LENGTH];
    bool found_file;
    bool list_only;
-   void *context;
-   char archive_name[PATH_MAX_LENGTH];
-   uint32_t crc;
-   struct decomp_state_t decomp_state;
-   decompress_state_t *dec;
 };
 
 /* Returns true when parsing should continue. False to stop. */
@@ -127,22 +110,27 @@ typedef int (*file_archive_file_cb)(const char *name, const char *valid_exts,
 
 struct file_archive_file_backend
 {
-   void *(*stream_new)(void);
-   void  (*stream_free)(void *);
-   bool     (*stream_decompress_data_to_file_init)(
-         file_archive_file_handle_t *, const uint8_t *,  uint32_t, uint32_t);
-   int      (*stream_decompress_data_to_file_iterate)(void *);
-   uint32_t (*stream_crc_calculate)(uint32_t, const uint8_t *, size_t);
-   int (*compressed_file_read)(const char *path, const char *needle, void **buf,
-         const char *optional_outfile);
    int (*archive_parse_file_init)(
       file_archive_transfer_t *state,
       const char *file);
    int (*archive_parse_file_iterate_step)(
-      file_archive_transfer_t *state,
+      void *context,
       const char *valid_exts,
       struct archive_extract_userdata *userdata,
       file_archive_file_cb file_cb);
+   void (*archive_parse_file_free)(
+      void *context);
+
+   bool     (*stream_decompress_data_to_file_init)(
+      void *context, file_archive_file_handle_t *handle,
+      const uint8_t *cdata, unsigned cmode, uint32_t csize, uint32_t size);
+   int      (*stream_decompress_data_to_file_iterate)(
+      void *context,
+      file_archive_file_handle_t *handle);
+
+   uint32_t (*stream_crc_calculate)(uint32_t, const uint8_t *, size_t);
+   int64_t (*compressed_file_read)(const char *path, const char *needle, void **buf,
+         const char *optional_outfile);
    const char *ident;
 };
 
@@ -160,8 +148,7 @@ int file_archive_parse_file_progress(file_archive_transfer_t *state);
 
 /**
  * file_archive_extract_file:
- * @archive_path                    : filename path to ZIP archive.
- * @archive_path_size               : size of ZIP archive.
+ * @archive_path                : filename path to ZIP archive.
  * @valid_exts                  : valid extensions for a file.
  * @extraction_directory        : the directory to extract the temporary
  *                                file to.
@@ -171,10 +158,17 @@ int file_archive_parse_file_progress(file_archive_transfer_t *state);
  *
  * Returns : true (1) on success, otherwise false (0).
  **/
-bool file_archive_extract_file(char *archive_path, size_t archive_path_size,
+bool file_archive_extract_file(const char *archive_path,
       const char *valid_exts, const char *extraction_dir,
       char *out_path, size_t len);
 
+/* Warning: 'list' must zero initialised before
+ * calling this function, otherwise memory leaks/
+ * undefined behaviour will occur */
+bool file_archive_get_file_list_noalloc(struct string_list *list,
+      const char *path,
+      const char *valid_exts);
+
 /**
  * file_archive_get_file_list:
  * @path                        : filename path of archive
diff --git a/src/libretro/libretro-common/include/file/config_file.h b/src/libretro/libretro-common/include/file/config_file.h
index e13e655a90..5f40845914 100644
--- a/src/libretro/libretro-common/include/file/config_file.h
+++ b/src/libretro/libretro-common/include/file/config_file.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (config_file.h).
@@ -54,13 +54,15 @@ RETRO_BEGIN_DECLS
 struct config_file
 {
    char *path;
+   struct config_entry_list **entries_map;
    struct config_entry_list *entries;
    struct config_entry_list *tail;
    struct config_entry_list *last;
+   struct config_include_list *includes;
+   struct path_linked_list *references;
    unsigned include_depth;
    bool guaranteed_no_duplicates;
-
-   struct config_include_list *includes;
+   bool modified;
 };
 
 typedef struct config_file config_file_t;
@@ -82,36 +84,83 @@ typedef struct config_file_cb config_file_cb_t ;
  * Key/value pairs from an #include are read-only, and cannot be modified.
  */
 
-/* Loads a config file. Returns NULL if file doesn't exist.
- * NULL path will create an empty config file. */
+/**
+ * config_file_new:
+ *
+ * Loads a config file.
+ * If @path is NULL, will create an empty config file.
+ *
+ * @return Returns NULL if file doesn't exist.
+ **/
 config_file_t *config_file_new(const char *path);
 
 config_file_t *config_file_new_alloc(void);
 
-/* Loads a config file. Returns NULL if file doesn't exist.
- * NULL path will create an empty config file.
- * Includes cb callbacks to run custom code during config file processing.*/
-config_file_t *config_file_new_with_callback(const char *path, config_file_cb_t *cb);
+/**
+ * config_file_initialize:
+ *
+ * Leaf function.
+ **/
+void config_file_initialize(struct config_file *conf);
+
+/**
+ * config_file_new_with_callback:
+ *
+ * Loads a config file.
+ * If @path is NULL, will create an empty config file.
+ * Includes cb callbacks  to run custom code during config file processing.
+ *
+ * @return Returns NULL if file doesn't exist.
+ **/
+config_file_t *config_file_new_with_callback(
+      const char *path, config_file_cb_t *cb);
 
-/* Load a config file from a string. */
-config_file_t *config_file_new_from_string(const char *from_string,
+/**
+ * config_file_new_from_string:
+ *
+ * Load a config file from a string.
+ *
+ * NOTE: This will modify @from_string.
+ * Pass a copy of source string if original
+ * contents must be preserved
+ **/
+config_file_t *config_file_new_from_string(char *from_string,
       const char *path);
 
 config_file_t *config_file_new_from_path_to_string(const char *path);
 
-/* Frees config file. */
+/**
+ * config_file_free:
+ *
+ * Frees config file.
+ **/
 void config_file_free(config_file_t *conf);
 
-/* Loads a new config, and appends its data to conf.
- * The key-value pairs of the new config file takes priority over the old. */
+size_t config_file_add_reference(config_file_t *conf, char *path);
+
+bool config_file_deinitialize(config_file_t *conf);
+
+/**
+ * config_append_file:
+ *
+ * Loads a new config, and appends its data to @conf.
+ * The key-value pairs of the new config file takes priority over the old.
+ **/
 bool config_append_file(config_file_t *conf, const char *path);
 
 /* All extract functions return true when value is valid and exists.
  * Returns false otherwise. */
 
-bool config_entry_exists(config_file_t *conf, const char *entry);
+struct config_entry_list
+{
+   char *key;
+   char *value;
+   struct config_entry_list *next;
+   /* If we got this from an #include,
+    * do not allow overwrite. */
+   bool readonly;
+};
 
-struct config_entry_list;
 struct config_file_entry
 {
    const char *key;
@@ -120,13 +169,48 @@ struct config_file_entry
    const struct config_entry_list *next;
 };
 
-bool config_get_entry_list_head(config_file_t *conf, struct config_file_entry *entry);
+struct config_entry_list *config_get_entry(
+      const config_file_t *conf, const char *key);
+
+/**
+ * config_get_entry_list_head:
+ *
+ * Leaf function.
+ **/
+bool config_get_entry_list_head(config_file_t *conf,
+      struct config_file_entry *entry);
+
+/**
+ * config_get_entry_list_next:
+ *
+ * Leaf function.
+ **/
 bool config_get_entry_list_next(struct config_file_entry *entry);
 
-/* Extracts a double from config file. */
+/**
+ * config_get_double:
+ *
+ * Extracts a double from config file.
+ *
+ * Hidden non-leaf function cost:
+ * - Calls config_get_entry()
+ * - Calls strtod
+ *
+ * @return True if double found, otherwise false.
+ **/
 bool config_get_double(config_file_t *conf, const char *entry, double *in);
 
-/* Extracts a float from config file. */
+/**
+ * config_get_float:
+ *
+ * Extracts a float from config file.
+ *
+ * Hidden non-leaf function cost:
+ * - Calls config_get_entry()
+ * - Calls strtod
+ *
+ * @return true if found, otherwise false.
+ **/
 bool config_get_float(config_file_t *conf, const char *entry, float *in);
 
 /* Extracts an int from config file. */
@@ -146,56 +230,94 @@ bool config_get_uint64(config_file_t *conf, const char *entry, uint64_t *in);
 /* Extracts an unsigned int from config file treating input as hex. */
 bool config_get_hex(config_file_t *conf, const char *entry, unsigned *in);
 
-/* Extracts a single char. If value consists of several chars,
- * this is an error. */
+/**
+ * config_get_char:
+ *
+ * Extracts a single char from config file.
+ * If value consists of several chars, this is an error.
+ *
+ * Hidden non-leaf function cost:
+ * - Calls config_get_entry()
+ *
+ * @return true if found, otherwise false.
+ **/
 bool config_get_char(config_file_t *conf, const char *entry, char *in);
 
-/* Extracts an allocated string in *in. This must be free()-d if
- * this function succeeds. */
+/**
+ * config_get_string:
+ *
+ * Extracts an allocated string in *in. This must be free()-d if
+ * this function succeeds.
+ *
+ * Hidden non-leaf function cost:
+ * - Calls config_get_entry()
+ * - Calls strdup
+ *
+ * @return true if found, otherwise false.
+ **/
 bool config_get_string(config_file_t *conf, const char *entry, char **in);
 
 /* Extracts a string to a preallocated buffer. Avoid memory allocation. */
 bool config_get_array(config_file_t *conf, const char *entry, char *s, size_t len);
 
+/**
+  * config_get_config_path:
+  *
+  * Extracts a string to a preallocated buffer.
+  * Avoid memory allocation.
+  *
+  * Hidden non-leaf function cost:
+  * - Calls strlcpy
+  **/
+bool config_get_config_path(config_file_t *conf, char *s, size_t len);
+
 /* Extracts a string to a preallocated buffer. Avoid memory allocation.
  * Recognized magic like ~/. Similar to config_get_array() otherwise. */
 bool config_get_path(config_file_t *conf, const char *entry, char *s, size_t len);
 
-/* Extracts a string to a preallocated buffer. Avoid memory allocation. */
-bool config_get_config_path(config_file_t *conf, char *s, size_t len);
-
-/* Extracts a boolean from config.
+/**
+ * config_get_bool:
+ * 
+ * Extracts a boolean from config.
  * Valid boolean true are "true" and "1". Valid false are "false" and "0".
- * Other values will be treated as an error. */
+ * Other values will be treated as an error.
+ *
+ * Hidden non-leaf function cost:
+ * - Calls string_is_equal() x times
+ *
+ * @return true if preconditions are true, otherwise false.
+ **/
 bool config_get_bool(config_file_t *conf, const char *entry, bool *in);
 
 /* Setters. Similar to the getters.
  * Will not write to entry if the entry was obtained from an #include. */
-void config_set_double(config_file_t *conf, const char *entry, double value);
-void config_set_float(config_file_t *conf, const char *entry, float value);
-void config_set_int(config_file_t *conf, const char *entry, int val);
-void config_set_hex(config_file_t *conf, const char *entry, unsigned val);
-void config_set_uint64(config_file_t *conf, const char *entry, uint64_t val);
-void config_set_char(config_file_t *conf, const char *entry, char val);
+size_t config_set_double(config_file_t *conf, const char *entry, double value);
+size_t config_set_float(config_file_t *conf, const char *entry, float value);
+size_t config_set_int(config_file_t *conf, const char *entry, int val);
+size_t config_set_hex(config_file_t *conf, const char *entry, unsigned val);
+size_t config_set_uint64(config_file_t *conf, const char *entry, uint64_t val);
+size_t config_set_char(config_file_t *conf, const char *entry, char val);
+size_t config_set_uint(config_file_t *conf, const char *key, unsigned int val);
+
+void config_set_path(config_file_t *conf, const char *entry, const char *val);
 void config_set_string(config_file_t *conf, const char *entry, const char *val);
 void config_unset(config_file_t *conf, const char *key);
-void config_set_path(config_file_t *conf, const char *entry, const char *val);
-void config_set_bool(config_file_t *conf, const char *entry, bool val);
-void config_set_uint(config_file_t *conf, const char *key, unsigned int val);
 
-/* Write the current config to a file. */
+/**
+ * config_file_write:
+ *
+ * Write the current config to a file.
+ **/
 bool config_file_write(config_file_t *conf, const char *path, bool val);
 
-/* Dump the current config to an already opened file.
- * Does not close the file. */
+/**
+ * config_file_dump:
+ *
+ * Dump the current config to an already opened file.
+ * Does not close the file.
+ **/
 void config_file_dump(config_file_t *conf, FILE *file, bool val);
 
-#ifdef ORBIS
-void config_file_dump_orbis(config_file_t *conf, int fd);
-#endif
-
-bool config_file_exists(const char *path);
-
 RETRO_END_DECLS
 
 #endif
diff --git a/src/libretro/libretro-common/include/file/config_file_userdata.h b/src/libretro/libretro-common/include/file/config_file_userdata.h
index ca6f691785..0490da2481 100644
--- a/src/libretro/libretro-common/include/file/config_file_userdata.h
+++ b/src/libretro/libretro-common/include/file/config_file_userdata.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (config_file_userdata.h).
@@ -43,6 +43,9 @@ int config_userdata_get_float(void *userdata, const char *key_str,
 int config_userdata_get_int(void *userdata, const char *key_str,
       int *value, int default_value);
 
+int config_userdata_get_hex(void *userdata, const char *key_str,
+      unsigned *value, unsigned default_value);
+
 int config_userdata_get_float_array(void *userdata, const char *key_str,
       float **values, unsigned *out_num_values,
       const float *default_values, unsigned num_default_values);
diff --git a/src/libretro/libretro-common/include/file/file_path.h b/src/libretro/libretro-common/include/file/file_path.h
index 0a50416dbe..d410cc43b0 100644
--- a/src/libretro/libretro-common/include/file/file_path.h
+++ b/src/libretro/libretro-common/include/file/file_path.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2019 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (file_path.h).
@@ -51,6 +51,28 @@ enum
    RARCH_FILE_UNSUPPORTED
 };
 
+struct path_linked_list
+{
+   char *path;
+   struct path_linked_list *next;
+};
+
+/**
+ * Create a new linked list with one item in it
+ * The path on this item will be set to NULL
+**/
+struct path_linked_list* path_linked_list_new(void);
+
+/* Free the entire linked list */
+void path_linked_list_free(struct path_linked_list *in_path_linked_list);
+
+/**
+ * Add a node to the linked list with this path
+ * If the first node's path if it's not yet set, 
+ * set this instead
+**/
+void path_linked_list_add_path(struct path_linked_list *in_path_linked_list, char *path);
+
 /**
  * path_is_compressed_file:
  * @path               : path
@@ -81,12 +103,12 @@ bool path_is_compressed_file(const char *path);
  * path_get_archive_delim:
  * @path               : path
  *
- * Gets delimiter of an archive file. Only the first '#'
+ * Find delimiter of an archive file. Only the first '#'
  * after a compression extension is considered.
  *
- * Returns: pointer to the delimiter in the path if it contains
- * a compressed file, otherwise NULL.
- */
+ * @return pointer to the delimiter in the path if it contains
+ * a path inside a compressed file, otherwise NULL.
+ **/
 const char *path_get_archive_delim(const char *path);
 
 /**
@@ -96,10 +118,28 @@ const char *path_get_archive_delim(const char *path);
  * Gets extension of file. Only '.'s
  * after the last slash are considered.
  *
- * Returns: extension part from the path.
- */
+ * Hidden non-leaf function cost:
+ * - calls string_is_empty()
+ * - calls strrchr
+ *
+ * @return extension part from the path.
+ **/
 const char *path_get_extension(const char *path);
 
+/**
+ * path_get_extension_mutable:
+ * @path               : path
+ *
+ * Specialized version of path_get_extension(). Return
+ * value is mutable.
+ *
+ * Gets extension of file. Only '.'s
+ * after the last slash are considered.
+ *
+ * @return extension part from the path.
+ **/
+char *path_get_extension_mutable(const char *path);
+
 /**
  * path_remove_extension:
  * @path               : path
@@ -108,7 +148,10 @@ const char *path_get_extension(const char *path);
  * text after and including the last '.'.
  * Only '.'s after the last slash are considered.
  *
- * Returns:
+ * Hidden non-leaf function cost:
+ * - calls strrchr
+ *
+ * @return
  * 1) If path has an extension, returns path with the
  *    extension removed.
  * 2) If there is no extension, returns NULL.
@@ -122,10 +165,28 @@ char *path_remove_extension(char *path);
  *
  * Get basename from @path.
  *
- * Returns: basename from path.
+ * Hidden non-leaf function cost:
+ * - Calls path_get_archive_delim()
+ *   - can call find_last_slash() once if it returns NULL
+ *
+ * @return basename from path.
  **/
 const char *path_basename(const char *path);
 
+/**
+ * path_basename_nocompression:
+ * @path               : path
+ *
+ * Specialized version of path_basename().
+ * Get basename from @path.
+ *
+ * Hidden non-leaf function cost:
+ * - Calls find_last_slash()
+ *
+ * @return basename from path.
+ **/
+const char *path_basename_nocompression(const char *path);
+
 /**
  * path_basedir:
  * @path               : path
@@ -138,12 +199,13 @@ void path_basedir(char *path);
 /**
  * path_parent_dir:
  * @path               : path
+ * @len                : length of @path
  *
  * Extracts parent directory by mutating path.
  * Assumes that path is a directory. Keeps trailing '/'.
  * If the path was already at the root directory, returns empty string
  **/
-void path_parent_dir(char *path);
+void path_parent_dir(char *path, size_t len);
 
 /**
  * path_resolve_realpath:
@@ -155,7 +217,7 @@ void path_parent_dir(char *path);
  *
  * Relative paths are rebased on the current working dir.
  *
- * Returns: @buf if successful, NULL otherwise.
+ * @return @buf if successful, NULL otherwise.
  * Note: Not implemented on consoles
  * Note: Symlinks are only resolved on Unix-likes
  * Note: The current working dir might not be what you expect,
@@ -177,8 +239,11 @@ char *path_resolve_realpath(char *buf, size_t size, bool resolve_symlinks);
  * Both @path and @base are assumed to be absolute paths without "." or "..".
  *
  * E.g. path /a/b/e/f.cgp with base /a/b/c/d/ turns into ../../e/f.cgp
+ *
+ * @return Length of the string copied into @out
  **/
-size_t path_relative_to(char *out, const char *path, const char *base, size_t size);
+size_t path_relative_to(char *out, const char *path, const char *base,
+      size_t size);
 
 /**
  * path_is_absolute:
@@ -186,7 +251,7 @@ size_t path_relative_to(char *out, const char *path, const char *base, size_t si
  *
  * Checks if @path is an absolute path or a relative path.
  *
- * Returns: true if path is absolute, false if path is relative.
+ * @return true if path is absolute, false if path is relative.
  **/
 bool path_is_absolute(const char *path);
 
@@ -210,8 +275,15 @@ bool path_is_absolute(const char *path);
  * out_path = "/foo/bar/baz/boo.asm"
  * E.g.: in_path = "/foo/bar/baz/boo.c", replace = ""     =>
  * out_path = "/foo/bar/baz/boo"
+ *
+ * Hidden non-leaf function cost:
+ * - calls strlcpy 2x
+ * - calls strrchr
+ * - calls strlcat
+ *
+ * @return Length of the string copied into @out
  */
-void fill_pathname(char *out_path, const char *in_path,
+size_t fill_pathname(char *out_path, const char *in_path,
       const char *replace, size_t size);
 
 /**
@@ -225,6 +297,12 @@ void fill_pathname(char *out_path, const char *in_path,
  *
  * E.g.:
  * out_filename = "RetroArch-{month}{day}-{Hours}{Minutes}.{@ext}"
+ *
+ * Hidden non-leaf function cost:
+ * - Calls rtime_localtime()
+ * - Calls strftime
+ * - Calls strlcat
+ *
  **/
 size_t fill_dated_filename(char *out_filename,
       const char *ext, size_t size);
@@ -241,34 +319,33 @@ size_t fill_dated_filename(char *out_filename,
  *
  * E.g.:
  * out_filename = "RetroArch-{year}{month}{day}-{Hour}{Minute}{Second}.{@ext}"
- **/
-void fill_str_dated_filename(char *out_filename,
-      const char *in_str, const char *ext, size_t size);
-
-/**
- * fill_pathname_noext:
- * @out_path           : output path
- * @in_path            : input  path
- * @replace            : what to replace
- * @size               : buffer size of output path
- *
- * Appends a filename extension 'replace' to 'in_path', and outputs
- * result in 'out_path'.
  *
- * Assumes in_path has no extension. If an extension is still
- * present in 'in_path', it will be ignored.
+ * Hidden non-leaf function cost:
+ * - Calls time
+ * - Calls rtime_localtime()
+ * - Calls strlcpy 2x
+ * - Calls string_is_empty()
+ * - Calls strftime
+ * - Calls strlcat
  *
- */
-size_t fill_pathname_noext(char *out_path, const char *in_path,
-      const char *replace, size_t size);
+ * @return Length of the string copied into @out_path
+ **/
+size_t fill_str_dated_filename(char *out_filename,
+      const char *in_str, const char *ext, size_t size);
 
 /**
  * find_last_slash:
- * @str : input path
+ * @str                : path
+ * @size               : size of path
  *
- * Gets a pointer to the last slash in the input path.
+ * Find last slash in path. Tries to find
+ * a backslash on Windows too which takes precedence
+ * over regular slash.
+
+ * Hidden non-leaf function cost: 
+ * - calls strrchr
  *
- * Returns: a pointer to the last slash in the input path.
+ * @return pointer to last slash/backslash found in @str.
  **/
 char *find_last_slash(const char *str);
 
@@ -288,6 +365,11 @@ char *find_last_slash(const char *str);
  *
  * E.g..: in_dir = "/tmp/some_dir", in_basename = "/some_content/foo.c",
  * replace = ".asm" => in_dir = "/tmp/some_dir/foo.c.asm"
+ *
+ * Hidden non-leaf function cost:
+ * - Calls fill_pathname_slash()
+ * - Calls path_basename()
+ * - Calls strlcpy 2x
  **/
 size_t fill_pathname_dir(char *in_dir, const char *in_basename,
       const char *replace, size_t size);
@@ -299,16 +381,15 @@ size_t fill_pathname_dir(char *in_dir, const char *in_basename,
  * @size               : size of output path
  *
  * Copies basename of @in_path into @out_path.
+ *
+ * Hidden non-leaf function cost:
+ * - Calls path_basename()
+ * - Calls strlcpy
+ *
+ * @return length of the string copied into @out
  **/
 size_t fill_pathname_base(char *out_path, const char *in_path, size_t size);
 
-void fill_pathname_base_noext(char *out_dir,
-      const char *in_path, size_t size);
-
-size_t fill_pathname_base_ext(char *out,
-      const char *in_path, const char *ext,
-      size_t size);
-
 /**
  * fill_pathname_basedir:
  * @out_dir            : output directory
@@ -318,12 +399,13 @@ size_t fill_pathname_base_ext(char *out,
  * Copies base directory of @in_path into @out_path.
  * If in_path is a path without any slashes (relative current directory),
  * @out_path will get path "./".
+ *
+ * Hidden non-leaf function cost:
+ * - Calls strlcpy
+ * - Calls path_basedir()
  **/
 void fill_pathname_basedir(char *out_path, const char *in_path, size_t size);
 
-void fill_pathname_basedir_noext(char *out_dir,
-      const char *in_path, size_t size);
-
 /**
  * fill_pathname_parent_dir_name:
  * @out_dir            : output directory
@@ -332,7 +414,13 @@ void fill_pathname_basedir_noext(char *out_dir,
  *
  * Copies only the parent directory name of @in_dir into @out_dir.
  * The two buffers must not overlap. Removes trailing '/'.
- * Returns true on success, false if a slash was not found in the path.
+ *
+ * Hidden non-leaf function cost:
+ * - Calls strdup
+ * - Calls find_last_slash() x times
+ * - Can call strlcpy
+ *
+ * @return true on success, false if a slash was not found in the path.
  **/
 bool fill_pathname_parent_dir_name(char *out_dir,
       const char *in_dir, size_t size);
@@ -346,6 +434,11 @@ bool fill_pathname_parent_dir_name(char *out_dir,
  * Copies parent directory of @in_dir into @out_dir.
  * Assumes @in_dir is a directory. Keeps trailing '/'.
  * If the path was already at the root directory, @out_dir will be an empty string.
+ *
+ * Hidden non-leaf function cost:
+ * - Can call strlcpy if (@out_dir != @in_dir)
+ * - Calls strlen if (@out_dir == @in_dir)
+ * - Calls path_parent_dir()
  **/
 void fill_pathname_parent_dir(char *out_dir,
       const char *in_dir, size_t size);
@@ -373,30 +466,51 @@ void fill_pathname_resolve_relative(char *out_path, const char *in_refpath,
  * @size               : size of output path
  *
  * Joins a directory (@dir) and path (@path) together.
- * Makes sure not to get  two consecutive slashes
+ * Makes sure not to get two consecutive slashes
  * between directory and path.
+ * 
+ * Hidden non-leaf function cost: 
+ * - calls strlcpy at least once
+ * - calls fill_pathname_slash()
+ *
+ * Deprecated. Use fill_pathname_join_special() instead
+ * if you can ensure @dir != @out_path
+ *
+ * @return Length of the string copied into @out_path
  **/
 size_t fill_pathname_join(char *out_path, const char *dir,
       const char *path, size_t size);
 
+/**
+ * fill_pathname_join_special:
+ * @out_path           : output path
+ * @dir                : directory. Cannot be identical to @out_path
+ * @path               : path
+ * @size               : size of output path
+ *
+ *
+ * Specialized version of fill_pathname_join.
+ * Unlike fill_pathname_join(),
+ * @dir and @out_path CANNOT be identical.
+ *
+ * Joins a directory (@dir) and path (@path) together.
+ * Makes sure not to get two consecutive slashes
+ * between directory and path.
+ *
+ * Hidden non-leaf function cost: 
+ * - calls strlcpy 2x
+ * - calls find_last_slash()
+ *
+ * @return Length of the string copied into @out_path
+ **/
+size_t fill_pathname_join_special(char *out_path,
+      const char *dir, const char *path, size_t size);
+
 size_t fill_pathname_join_special_ext(char *out_path,
       const char *dir,  const char *path,
       const char *last, const char *ext,
       size_t size);
 
-size_t fill_pathname_join_concat_noext(char *out_path,
-      const char *dir, const char *path,
-      const char *concat,
-      size_t size);
-
-size_t fill_pathname_join_concat(char *out_path,
-      const char *dir, const char *path,
-      const char *concat,
-      size_t size);
-
-void fill_pathname_join_noext(char *out_path,
-      const char *dir, const char *path, size_t size);
-
 /**
  * fill_pathname_join_delim:
  * @out_path           : output path
@@ -407,40 +521,58 @@ void fill_pathname_join_noext(char *out_path,
  *
  * Joins a directory (@dir) and path (@path) together
  * using the given delimiter (@delim).
+ *
+ * Hidden non-leaf function cost: 
+ * - can call strlen
+ * - can call strlcpy
+ * - can call strlcat
  **/
 size_t fill_pathname_join_delim(char *out_path, const char *dir,
       const char *path, const char delim, size_t size);
 
-size_t fill_pathname_join_delim_concat(char *out_path, const char *dir,
-      const char *path, const char delim, const char *concat,
-      size_t size);
+size_t fill_pathname_expand_special(char *out_path,
+      const char *in_path, size_t size);
+
+size_t fill_pathname_abbreviate_special(char *out_path,
+      const char *in_path, size_t size);
 
 /**
- * fill_short_pathname_representation:
- * @out_rep            : output representation
- * @in_path            : input path
- * @size               : size of output representation
+ * fill_pathname_abbreviated_or_relative:
  *
- * Generates a short representation of path. It should only
- * be used for displaying the result; the output representation is not
- * binding in any meaningful way (for a normal path, this is the same as basename)
- * In case of more complex URLs, this should cut everything except for
- * the main image file.
+ * Fills the supplied path with either the abbreviated path or 
+ * the relative path, which ever one has less depth / number of slashes
+ * 
+ * If lengths of abbreviated and relative paths are the same,
+ * the relative path will be used
+ * @in_path can be an absolute, relative or abbreviated path
  *
- * E.g.: "/path/to/game.img" -> game.img
- *       "/path/to/myarchive.7z#folder/to/game.img" -> game.img
- */
-size_t fill_short_pathname_representation(char* out_rep,
-      const char *in_path, size_t size);
-
-void fill_short_pathname_representation_noext(char* out_rep,
-      const char *in_path, size_t size);
+ * @return Length of the string copied into @out_path
+ **/
+size_t fill_pathname_abbreviated_or_relative(char *out_path,
+		const char *in_refpath, const char *in_path, size_t size);
 
-void fill_pathname_expand_special(char *out_path,
-      const char *in_path, size_t size);
+/**
+ * pathname_conform_slashes_to_os:
+ *
+ * @path               : path
+ * 
+ * Leaf function.
+ *
+ * Changes the slashes to the correct kind for the os 
+ * So forward slash on linux and backslash on Windows
+ **/
+void pathname_conform_slashes_to_os(char *path);
 
-void fill_pathname_abbreviate_special(char *out_path,
-      const char *in_path, size_t size);
+/**
+ * pathname_make_slashes_portable:
+ * @path               : path
+ *
+ * Leaf function.
+ *
+ * Change all slashes to forward so they are more 
+ * portable between Windows and Linux
+ **/
+void pathname_make_slashes_portable(char *path);
 
 /**
  * path_basedir:
@@ -457,12 +589,12 @@ void path_basedir_wrapper(char *path);
  *
  * Checks if character (@c) is a slash.
  *
- * Returns: true (1) if character is a slash, otherwise false (0).
- */
+ * @return true if character is a slash, otherwise false.
+ **/
 #ifdef _WIN32
-#define path_char_is_slash(c) (((c) == '/') || ((c) == '\\'))
+#define PATH_CHAR_IS_SLASH(c) (((c) == '/') || ((c) == '\\'))
 #else
-#define path_char_is_slash(c) ((c) == '/')
+#define PATH_CHAR_IS_SLASH(c) ((c) == '/')
 #endif
 
 /**
@@ -470,14 +602,14 @@ void path_basedir_wrapper(char *path);
  *
  * Gets the default slash separator.
  *
- * Returns: default slash separator.
- */
+ * @return default slash separator.
+ **/
 #ifdef _WIN32
-#define path_default_slash() "\\"
-#define path_default_slash_c() '\\'
+#define PATH_DEFAULT_SLASH() "\\"
+#define PATH_DEFAULT_SLASH_C() '\\'
 #else
-#define path_default_slash() "/"
-#define path_default_slash_c() '/'
+#define PATH_DEFAULT_SLASH() "/"
+#define PATH_DEFAULT_SLASH_C() '/'
 #endif
 
 /**
@@ -487,8 +619,13 @@ void path_basedir_wrapper(char *path);
  *
  * Assumes path is a directory. Appends a slash
  * if not already there.
+
+ * Hidden non-leaf function cost: 
+ * - calls find_last_slash()
+ *   - can call strlcat once if it returns false
+ * - calls strlen
  **/
-void fill_pathname_slash(char *path, size_t size);
+size_t fill_pathname_slash(char *path, size_t size);
 
 #if !defined(RARCH_CONSOLE) && defined(RARCH_INTERNAL)
 void fill_pathname_application_path(char *buf, size_t size);
@@ -502,7 +639,16 @@ void fill_pathname_home_dir(char *buf, size_t size);
  *
  * Create directory on filesystem.
  *
- * Returns: true (1) if directory could be created, otherwise false (0).
+ * Recursive function.
+ *
+ * Hidden non-leaf function cost:
+ * - Calls strdup
+ * - Calls path_parent_dir()
+ * - Calls strcmp
+ * - Calls path_is_directory()
+ * - Calls path_mkdir()
+ *
+ * @return true if directory could be created, otherwise false.
  **/
 bool path_mkdir(const char *dir);
 
@@ -512,10 +658,15 @@ bool path_mkdir(const char *dir);
  *
  * Checks if path is a directory.
  *
- * Returns: true (1) if path is a directory, otherwise false (0).
+ * @return true if path is a directory, otherwise false.
  */
 bool path_is_directory(const char *path);
 
+/* Time format strings with AM-PM designation require special
+ * handling due to platform dependence */
+void strftime_am_pm(char *s, size_t len, const char* format,
+      const void* timeptr);
+
 bool path_is_character_special(const char *path);
 
 int path_stat(const char *path);
diff --git a/src/libretro/libretro-common/include/file/nbio.h b/src/libretro/libretro-common/include/file/nbio.h
index 4b5e5a41bc..cd9f13b968 100644
--- a/src/libretro/libretro-common/include/file/nbio.h
+++ b/src/libretro/libretro-common/include/file/nbio.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (nbio.h).
diff --git a/src/libretro/libretro-common/include/filters.h b/src/libretro/libretro-common/include/filters.h
index 69048efd90..6ef9aced7d 100644
--- a/src/libretro/libretro-common/include/filters.h
+++ b/src/libretro/libretro-common/include/filters.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (filters.h).
@@ -31,6 +31,11 @@
 #include <retro_inline.h>
 #include <retro_math.h>
 
+/**
+ * sinc:
+ *
+ * Pure function.
+ **/
 static INLINE double sinc(double val)
 {
    if (fabs(val) < 0.00001)
@@ -38,7 +43,12 @@ static INLINE double sinc(double val)
    return sin(val) / val;
 }
 
-/* Paeth prediction filter. */
+/**
+ * paeth:
+ *
+ * Pure function.
+ * Paeth prediction filter.
+ **/
 static INLINE int paeth(int a, int b, int c)
 {
    int p  = a + b - c;
@@ -53,11 +63,17 @@ static INLINE int paeth(int a, int b, int c)
    return c;
 }
 
-/* Modified Bessel function of first order.
- * Check Wiki for mathematical definition ... */
+/**
+ * besseli0:
+ *
+ * Pure function.
+ *
+ * Modified Bessel function of first order.
+ * Check Wiki for mathematical definition ...
+ **/
 static INLINE double besseli0(double x)
 {
-   unsigned i;
+   int i;
    double sum            = 0.0;
    double factorial      = 1.0;
    double factorial_mult = 0.0;
@@ -69,12 +85,11 @@ static INLINE double besseli0(double x)
     * Luckily, it converges rather fast. */
    for (i = 0; i < 18; i++)
    {
-      sum += x_pow * two_div_pow / (factorial * factorial);
-
+      sum            += x_pow * two_div_pow / (factorial * factorial);
       factorial_mult += 1.0;
-      x_pow *= x_sqr;
-      two_div_pow *= 0.25;
-      factorial *= factorial_mult;
+      x_pow          *= x_sqr;
+      two_div_pow    *= 0.25;
+      factorial      *= factorial_mult;
    }
 
    return sum;
@@ -85,9 +100,4 @@ static INLINE double kaiser_window_function(double index, double beta)
    return besseli0(beta * sqrtf(1 - index * index));
 }
 
-static INLINE double lanzcos_window_function(double index)
-{
-   return sinc(M_PI * index);
-}
-
 #endif
diff --git a/src/libretro/libretro-common/include/formats/cdfs.h b/src/libretro/libretro-common/include/formats/cdfs.h
index b5d7a90f04..ab4241e4ca 100644
--- a/src/libretro/libretro-common/include/formats/cdfs.h
+++ b/src/libretro/libretro-common/include/formats/cdfs.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2019 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (cdfs.h).
@@ -36,23 +36,25 @@ typedef struct cdfs_track_t
    intfstream_t* stream;
    unsigned int stream_sector_size;
    unsigned int stream_sector_header_size;
-   unsigned int pregap_sectors;
+   unsigned int first_sector_offset;
+   unsigned int first_sector_index;
 } cdfs_track_t;
 
 typedef struct cdfs_file_t
 {
+   struct cdfs_track_t* track;
    int first_sector;
    int current_sector;
-   unsigned int current_sector_offset;
    int sector_buffer_valid;
+   unsigned int current_sector_offset;
    unsigned int size;
    unsigned int pos;
    uint8_t sector_buffer[2048];
-   struct cdfs_track_t* track;
 } cdfs_file_t;
 
 /* opens the specified file within the CD or virtual CD.
- * if path is NULL, will open the raw CD (useful for reading CD without having to worry about sector sizes,
+ * if path is NULL, will open the raw CD (useful for 
+ * reading CD without having to worry about sector sizes,
  * headers, or checksum data)
  */
 int cdfs_open_file(cdfs_file_t* file, cdfs_track_t* stream, const char* path);
@@ -69,6 +71,10 @@ int64_t cdfs_seek(cdfs_file_t* file, int64_t offset, int whence);
 
 void cdfs_seek_sector(cdfs_file_t* file, unsigned int sector);
 
+uint32_t cdfs_get_num_sectors(cdfs_file_t* file);
+
+uint32_t cdfs_get_first_sector(cdfs_file_t* file);
+
 /* opens the specified track in a CD or virtual CD file - the resulting stream should be passed to
  * cdfs_open_file to get access to a file within the CD.
  *
diff --git a/src/libretro/libretro-common/include/formats/image.h b/src/libretro/libretro-common/include/formats/image.h
index 6d86db4116..70e5842204 100644
--- a/src/libretro/libretro-common/include/formats/image.h
+++ b/src/libretro/libretro-common/include/formats/image.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (image.h).
@@ -42,9 +42,9 @@ enum image_process_code
 
 struct texture_image
 {
+   uint32_t *pixels;
    unsigned width;
    unsigned height;
-   uint32_t *pixels;
    bool supports_rgba;
 };
 
diff --git a/src/libretro/libretro-common/include/formats/rbmp.h b/src/libretro/libretro-common/include/formats/rbmp.h
index 28403c9481..6e20df005d 100644
--- a/src/libretro/libretro-common/include/formats/rbmp.h
+++ b/src/libretro/libretro-common/include/formats/rbmp.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (rbmp.h).
diff --git a/src/libretro/libretro-common/include/formats/rjpeg.h b/src/libretro/libretro-common/include/formats/rjpeg.h
index 6a60391004..18d3568bd6 100644
--- a/src/libretro/libretro-common/include/formats/rjpeg.h
+++ b/src/libretro/libretro-common/include/formats/rjpeg.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (rjpeg.h).
diff --git a/src/libretro/libretro-common/include/formats/rpng.h b/src/libretro/libretro-common/include/formats/rpng.h
index a2da60b2b6..d855658b3a 100644
--- a/src/libretro/libretro-common/include/formats/rpng.h
+++ b/src/libretro/libretro-common/include/formats/rpng.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (rpng.h).
diff --git a/src/libretro/libretro-common/include/formats/rtga.h b/src/libretro/libretro-common/include/formats/rtga.h
index 1b9409c365..330e47133f 100644
--- a/src/libretro/libretro-common/include/formats/rtga.h
+++ b/src/libretro/libretro-common/include/formats/rtga.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (rtga.h).
diff --git a/src/libretro/libretro-common/include/formats/rwav.h b/src/libretro/libretro-common/include/formats/rwav.h
index 198d24b5b5..e5379da0af 100644
--- a/src/libretro/libretro-common/include/formats/rwav.h
+++ b/src/libretro/libretro-common/include/formats/rwav.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (rwav.h).
diff --git a/src/libretro/libretro-common/include/formats/rxml.h b/src/libretro/libretro-common/include/formats/rxml.h
index 06255524b7..e3f1c9a5f9 100644
--- a/src/libretro/libretro-common/include/formats/rxml.h
+++ b/src/libretro/libretro-common/include/formats/rxml.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (rxml.h).
@@ -64,4 +64,6 @@ struct rxml_node *rxml_root_node(rxml_document_t *doc);
 
 const char *rxml_node_attrib(struct rxml_node *node, const char *attrib);
 
+RETRO_END_DECLS
+
 #endif
diff --git a/src/libretro/libretro-common/include/gfx/gl_capabilities.h b/src/libretro/libretro-common/include/gfx/gl_capabilities.h
index 0d015941ce..fc6c17ce46 100644
--- a/src/libretro/libretro-common/include/gfx/gl_capabilities.h
+++ b/src/libretro/libretro-common/include/gfx/gl_capabilities.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (gl_capabilities.h).
diff --git a/src/libretro/libretro-common/include/gfx/math/matrix_3x3.h b/src/libretro/libretro-common/include/gfx/math/matrix_3x3.h
index 8dbf66c090..2e0bcf5465 100644
--- a/src/libretro/libretro-common/include/gfx/math/matrix_3x3.h
+++ b/src/libretro/libretro-common/include/gfx/math/matrix_3x3.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (matrix_3x3.h).
diff --git a/src/libretro/libretro-common/include/gfx/math/matrix_4x4.h b/src/libretro/libretro-common/include/gfx/math/matrix_4x4.h
index 6d7f130413..5b9a4cdb79 100644
--- a/src/libretro/libretro-common/include/gfx/math/matrix_4x4.h
+++ b/src/libretro/libretro-common/include/gfx/math/matrix_4x4.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (matrix_4x4.h).
diff --git a/src/libretro/libretro-common/include/gfx/math/vector_2.h b/src/libretro/libretro-common/include/gfx/math/vector_2.h
index 3e2c9324ab..7a989fc004 100644
--- a/src/libretro/libretro-common/include/gfx/math/vector_2.h
+++ b/src/libretro/libretro-common/include/gfx/math/vector_2.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (vector_2.h).
@@ -54,7 +54,7 @@ static INLINE float overflow(void)
    unsigned i;
    volatile float f = 1e10;
 
-   for(i = 0; i < 10; ++i)
+   for (i = 0; i < 10; ++i)
       f *= f;
    return f;
 }
@@ -75,22 +75,22 @@ static INLINE int16_t tofloat16(float f)
    e       = ((i >> 23) & 0x000000ff) - (127 - 15);
    m       =   i        & 0x007fffff;
 
-   if(e <= 0)
+   if (e <= 0)
    {
-      if(e < -10)
+      if (e < -10)
          return (int16_t)(s);
 
       m = (m | 0x00800000) >> (1 - e);
 
-      if(m & 0x00001000)
+      if (m & 0x00001000)
          m += 0x00002000;
 
       return (int16_t)(s | (m >> 13));
    }
 
-   if(e == 0xff - (127 - 15))
+   if (e == 0xff - (127 - 15))
    {
-      if(m == 0)
+      if (m == 0)
          return (int16_t)(s | 0x7c00);
 
       m >>= 13;
@@ -98,11 +98,11 @@ static INLINE int16_t tofloat16(float f)
       return (int16_t)(s | 0x7c00 | m | (m == 0));
    }
 
-   if(m &  0x00001000)
+   if (m &  0x00001000)
    {
       m += 0x00002000;
 
-      if(m & 0x00800000)
+      if (m & 0x00800000)
       {
          m =  0;
          e += 1;
diff --git a/src/libretro/libretro-common/include/gfx/math/vector_3.h b/src/libretro/libretro-common/include/gfx/math/vector_3.h
index 4ab48e3f6f..c4c9bd2acf 100644
--- a/src/libretro/libretro-common/include/gfx/math/vector_3.h
+++ b/src/libretro/libretro-common/include/gfx/math/vector_3.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (vector_3.h).
diff --git a/src/libretro/libretro-common/include/gfx/math/vector_4.h b/src/libretro/libretro-common/include/gfx/math/vector_4.h
index c2001437ff..000f279b6e 100644
--- a/src/libretro/libretro-common/include/gfx/math/vector_4.h
+++ b/src/libretro/libretro-common/include/gfx/math/vector_4.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (vector_4.h).
diff --git a/src/libretro/libretro-common/include/gfx/scaler/filter.h b/src/libretro/libretro-common/include/gfx/scaler/filter.h
index 29ff56bcf8..99fd210769 100644
--- a/src/libretro/libretro-common/include/gfx/scaler/filter.h
+++ b/src/libretro/libretro-common/include/gfx/scaler/filter.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (filter.h).
diff --git a/src/libretro/libretro-common/include/gfx/scaler/pixconv.h b/src/libretro/libretro-common/include/gfx/scaler/pixconv.h
index 788f5ee8c5..60d6e4692c 100644
--- a/src/libretro/libretro-common/include/gfx/scaler/pixconv.h
+++ b/src/libretro/libretro-common/include/gfx/scaler/pixconv.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (pixconv.h).
diff --git a/src/libretro/libretro-common/include/gfx/scaler/scaler.h b/src/libretro/libretro-common/include/gfx/scaler/scaler.h
index b13b89a1bd..287d84d40c 100644
--- a/src/libretro/libretro-common/include/gfx/scaler/scaler.h
+++ b/src/libretro/libretro-common/include/gfx/scaler/scaler.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (scaler.h).
@@ -54,25 +54,13 @@ enum scaler_type
 struct scaler_filter
 {
    int16_t *filter;
-   int filter_len;
-   int filter_stride;
-   int *filter_pos;
+   int     *filter_pos;
+   int      filter_len;
+   int      filter_stride;
 };
 
 struct scaler_ctx
 {
-   int in_width;
-   int in_height;
-   int in_stride;
-
-   int out_width;
-   int out_height;
-   int out_stride;
-
-   enum scaler_pix_fmt in_fmt;
-   enum scaler_pix_fmt out_fmt;
-   enum scaler_type scaler_type;
-
    void (*scaler_horiz)(const struct scaler_ctx*,
          const void*, int);
    void (*scaler_vert)(const struct scaler_ctx*,
@@ -83,9 +71,7 @@ struct scaler_ctx
    void (*in_pixconv)(void*, const void*, int, int, int, int);
    void (*out_pixconv)(void*, const void*, int, int, int, int);
    void (*direct_pixconv)(void*, const void*, int, int, int, int);
-
-   bool unscaled;
-   struct scaler_filter horiz, vert;
+   struct scaler_filter horiz, vert;   /* ptr alignment */
 
    struct
    {
@@ -106,6 +92,20 @@ struct scaler_ctx
       uint32_t *frame;
       int stride;
    } output;
+
+   int in_width;
+   int in_height;
+   int in_stride;
+
+   int out_width;
+   int out_height;
+   int out_stride;
+
+   enum scaler_pix_fmt in_fmt;
+   enum scaler_pix_fmt out_fmt;
+   enum scaler_type scaler_type;
+
+   bool unscaled;
 };
 
 bool scaler_ctx_gen_filter(struct scaler_ctx *ctx);
diff --git a/src/libretro/libretro-common/include/gfx/scaler/scaler_int.h b/src/libretro/libretro-common/include/gfx/scaler/scaler_int.h
index 6ce68475ef..ad9e2fb761 100644
--- a/src/libretro/libretro-common/include/gfx/scaler/scaler_int.h
+++ b/src/libretro/libretro-common/include/gfx/scaler/scaler_int.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (scaler_int.h).
diff --git a/src/libretro/libretro-common/include/gfx/video_frame.h b/src/libretro/libretro-common/include/gfx/video_frame.h
index c00dc81d57..05ba3f7b49 100644
--- a/src/libretro/libretro-common/include/gfx/video_frame.h
+++ b/src/libretro/libretro-common/include/gfx/video_frame.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (video_frame.h).
diff --git a/src/libretro/libretro-common/include/glsm/glsmsym.h b/src/libretro/libretro-common/include/glsm/glsmsym.h
index aedf68ec34..3c9d3bd9a6 100644
--- a/src/libretro/libretro-common/include/glsm/glsmsym.h
+++ b/src/libretro/libretro-common/include/glsm/glsmsym.h
@@ -126,7 +126,6 @@ RETRO_BEGIN_DECLS
 #define glBlendFuncSeparate         rglBlendFuncSeparate
 #define glDepthFunc                 rglDepthFunc
 #define glColorMask                 rglColorMask
-#define glColorMaski                rglColorMaski
 #define glClearColor                rglClearColor
 #define glViewport                  rglViewport
 #define glScissor                   rglScissor
@@ -187,11 +186,6 @@ RETRO_BEGIN_DECLS
 #define glFlushMappedBufferRange    rglFlushMappedBufferRange
 #define glClientWaitSync            rglClientWaitSync
 #define glDrawElementsBaseVertex    rglDrawElementsBaseVertex
-#define glFlush                     rglFlush
-#define glTexParameteri             rglTexParameteri
-#define glTexImage2D                rglTexImage2D
-#define glDrawBuffer                rglDrawBuffer
-#define glReadPixels                rglReadPixels
 
 const GLubyte* rglGetStringi(GLenum name, GLuint index);
 void rglTexBuffer(GLenum target, GLenum internalFormat, GLuint buffer);
@@ -338,7 +332,6 @@ void rglBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha,
       GLenum dstAlpha);
 void rglDepthFunc(GLenum func);
 void rglColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-void rglColorMaski(GLint buf, GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
 void rglClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
 void rglViewport(GLint x, GLint y, GLsizei width, GLsizei height);
 void rglScissor(GLint x, GLint y, GLsizei width, GLsizei height);
@@ -484,11 +477,6 @@ void rglUniform2iv(	GLint location,
  	const GLint *value);
 void rglProvokingVertex(	GLenum provokeMode);
 void rglDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, GLvoid *indices, GLint basevertex);
-void rglFlush(void);
-void rglTexParameteri(GLenum target, GLenum pname, GLint param);
-void rglTexImage2D(GLenum target,GLint level, GLint internalformat, GLsizei width, GLsizei height,GLint border, GLenum format,	GLenum type, const GLvoid * data);
-void rglDrawBuffer(GLenum buf);
-void rglReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid * data);
 
 RETRO_END_DECLS
 
diff --git a/src/libretro/libretro-common/include/glsym/glsym.h b/src/libretro/libretro-common/include/glsym/glsym.h
index 4e06a4a07a..b004036c36 100644
--- a/src/libretro/libretro-common/include/glsym/glsym.h
+++ b/src/libretro/libretro-common/include/glsym/glsym.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010-2018 The RetroArch team
+/* Copyright (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this libretro SDK code part (glsym).
diff --git a/src/libretro/libretro-common/include/glsym/glsym_es3.h b/src/libretro/libretro-common/include/glsym/glsym_es3.h
index 9ffd150644..89ffc72d2e 100644
--- a/src/libretro/libretro-common/include/glsym/glsym_es3.h
+++ b/src/libretro/libretro-common/include/glsym/glsym_es3.h
@@ -28,6 +28,9 @@ typedef unsigned long long int GLuint64;
 typedef unsigned long long int GLuint64EXT;
 typedef struct __GLsync *GLsync;
 #endif
+#ifndef GL_APIENTRYP
+#define GL_APIENTRYP GL_APIENTRY*
+#endif
 typedef void (GL_APIENTRYP RGLSYMGLBLENDBARRIERKHRPROC) (void);
 typedef void (GL_APIENTRYP RGLSYMGLDEBUGMESSAGECONTROLKHRPROC) (GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled);
 typedef void (GL_APIENTRYP RGLSYMGLDEBUGMESSAGEINSERTKHRPROC) (GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf);
diff --git a/src/libretro/libretro-common/include/glsym/glsym_gl.h b/src/libretro/libretro-common/include/glsym/glsym_gl.h
index 1934287f2a..a4e76a2761 100644
--- a/src/libretro/libretro-common/include/glsym/glsym_gl.h
+++ b/src/libretro/libretro-common/include/glsym/glsym_gl.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010-2018 The RetroArch team
+/* Copyright (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this libretro SDK code part (glsym).
diff --git a/src/libretro/libretro-common/include/glsym/rglgen.h b/src/libretro/libretro-common/include/glsym/rglgen.h
index c9918df778..503223f135 100644
--- a/src/libretro/libretro-common/include/glsym/rglgen.h
+++ b/src/libretro/libretro-common/include/glsym/rglgen.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010-2018 The RetroArch team
+/* Copyright (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this libretro SDK code part (glsym).
diff --git a/src/libretro/libretro-common/include/glsym/rglgen_headers.h b/src/libretro/libretro-common/include/glsym/rglgen_headers.h
index 7d44b6d0fc..7b44bef8fb 100644
--- a/src/libretro/libretro-common/include/glsym/rglgen_headers.h
+++ b/src/libretro/libretro-common/include/glsym/rglgen_headers.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010-2018 The RetroArch team
+/* Copyright (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this libretro SDK code part (glsym).
@@ -28,55 +28,7 @@
 #include <EGL/eglext.h>
 #endif
 
-#if defined(IOS)
-
-#if defined(HAVE_OPENGLES3)
-#include <OpenGLES/ES3/gl.h>
-#include <OpenGLES/ES3/glext.h>
-#else
-#include <OpenGLES/ES2/gl.h>
-#include <OpenGLES/ES2/glext.h>
-#endif
-
-#elif defined(__APPLE__)
-#include <compat/apple_compat.h>
-#if MAC_OS_X_VERSION_10_7
-#include <OpenGL/gl3.h>
-#include <OpenGL/gl3ext.h>
-#else
-#include <OpenGL/gl.h>
-#include <OpenGL/glext.h>
-#endif
-#elif defined(HAVE_PSGL)
-#include <PSGL/psgl.h>
-#include <GLES/glext.h>
-#elif defined(HAVE_OPENGL_MODERN)
-#include <GL3/gl3.h>
-#include <GL3/gl3ext.h>
-#elif defined(HAVE_OPENGLES3)
-#include <GLES3/gl3.h>
-#define __gl2_h_
-#include <GLES2/gl2ext.h>
-#elif defined(HAVE_OPENGLES2)
-#include <GLES2/gl2.h>
-#include <GLES2/gl2ext.h>
-#elif defined(HAVE_OPENGLES1)
-#include <GLES/gl.h>
-#include <GLES/glext.h>
-#else
-#if defined(_WIN32) && !defined(_XBOX)
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#endif
-#ifndef HAVE_LIBNX
-#include <GL/gl.h>
-#include <GL/glext.h>
-#else
-/* We need to avoid including <GL/gl.h> on this platform */
-#include "switch/nx_gl.h"
-#include <GL/glext.h>
-#endif /* SWITCH */
-#endif
+#include "rglgen_private_headers.h"
 
 #ifndef GL_MAP_WRITE_BIT
 #define GL_MAP_WRITE_BIT 0x0002
diff --git a/src/libretro/libretro-common/include/glsym/rglgen_private_headers.h b/src/libretro/libretro-common/include/glsym/rglgen_private_headers.h
index 85de101483..2b5e520cf7 100644
--- a/src/libretro/libretro-common/include/glsym/rglgen_private_headers.h
+++ b/src/libretro/libretro-common/include/glsym/rglgen_private_headers.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010-2019 The RetroArch team
+/* Copyright (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this libretro SDK code part (glsym).
diff --git a/src/libretro/libretro-common/include/glsym/switch/nx_gl.h b/src/libretro/libretro-common/include/glsym/switch/nx_gl.h
index 2c4b3e13d1..f4f37c07d9 100644
--- a/src/libretro/libretro-common/include/glsym/switch/nx_gl.h
+++ b/src/libretro/libretro-common/include/glsym/switch/nx_gl.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2018 The RetroArch team
+/* Copyright (C) 2018-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this libretro SDK code part (nx_gl.h).
diff --git a/src/libretro/libretro-common/include/libchdr/chd.h b/src/libretro/libretro-common/include/libchdr/chd.h
index a21ee9dd52..b22b6e4835 100644
--- a/src/libretro/libretro-common/include/libchdr/chd.h
+++ b/src/libretro/libretro-common/include/libchdr/chd.h
@@ -193,12 +193,21 @@ extern "C" {
 #define CHDFLAGS_IS_WRITEABLE		0x00000002
 #define CHDFLAGS_UNDEFINED			0xfffffffc
 
+#define CHD_MAKE_TAG(a,b,c,d)       (((a) << 24) | ((b) << 16) | ((c) << 8) | (d))
+
 /* compression types */
 #define CHDCOMPRESSION_NONE			0
 #define CHDCOMPRESSION_ZLIB			1
 #define CHDCOMPRESSION_ZLIB_PLUS	2
 #define CHDCOMPRESSION_AV			3
 
+#define CHD_CODEC_ZLIB				CHD_MAKE_TAG('z','l','i','b')
+
+/* general codecs with CD frontend */
+#define CHD_CODEC_CD_ZLIB CHD_MAKE_TAG('c','d','z','l')
+#define CHD_CODEC_CD_LZMA CHD_MAKE_TAG('c','d','l','z')
+#define CHD_CODEC_CD_FLAC CHD_MAKE_TAG('c','d','f','l')
+
 /* A/V codec configuration parameters */
 #define AV_CODEC_COMPRESS_CONFIG	1
 #define AV_CODEC_DECOMPRESS_CONFIG	2
@@ -211,33 +220,34 @@ extern "C" {
 #define CHD_MDFLAGS_CHECKSUM		0x01		/* indicates data is checksummed */
 
 /* standard hard disk metadata */
-#define HARD_DISK_METADATA_TAG		0x47444444	/* 'GDDD' */
+#define HARD_DISK_METADATA_TAG		CHD_MAKE_TAG('G','D','D','D')
 #define HARD_DISK_METADATA_FORMAT	"CYLS:%u,HEADS:%u,SECS:%u,BPS:%u"
 
 /* hard disk identify information */
-#define HARD_DISK_IDENT_METADATA_TAG 0x49444e54 /* 'IDNT' */
+#define HARD_DISK_IDENT_METADATA_TAG CHD_MAKE_TAG('I','D','N','T')
 
 /* hard disk key information */
-#define HARD_DISK_KEY_METADATA_TAG	0x4b455920  /* 'KEY '  */
+#define HARD_DISK_KEY_METADATA_TAG	CHD_MAKE_TAG('K','E','Y',' ')
 
 /* pcmcia CIS information */
-#define PCMCIA_CIS_METADATA_TAG		0x43495320  /* 'CIS '  */
+#define PCMCIA_CIS_METADATA_TAG		CHD_MAKE_TAG('C','I','S',' ')
 
 /* standard CD-ROM metadata */
-#define CDROM_OLD_METADATA_TAG		0x43484344	/* 'CHCD' */
-#define CDROM_TRACK_METADATA_TAG	0x43485452	/* 'CHTR' */
+#define CDROM_OLD_METADATA_TAG		CHD_MAKE_TAG('C','H','C','D')
+#define CDROM_TRACK_METADATA_TAG	   CHD_MAKE_TAG('C','H','T','R')
 #define CDROM_TRACK_METADATA_FORMAT	"TRACK:%u TYPE:%s SUBTYPE:%s FRAMES:%u"
-#define CDROM_TRACK_METADATA2_TAG	0x43485432	/* 'CHT2' */
+#define CDROM_TRACK_METADATA2_TAG	CHD_MAKE_TAG('C','H','T','2')
 #define CDROM_TRACK_METADATA2_FORMAT	"TRACK:%u TYPE:%s SUBTYPE:%s FRAMES:%u PREGAP:%u PGTYPE:%s PGSUB:%s POSTGAP:%u"
-#define GDROM_TRACK_METADATA_TAG	0x43484744	/* 'CHTD' */
+#define GDROM_OLD_METADATA_TAG		CHD_MAKE_TAG('C','H','G','T')
+#define GDROM_TRACK_METADATA_TAG	CHD_MAKE_TAG('C', 'H', 'G', 'D')
 #define GDROM_TRACK_METADATA_FORMAT	"TRACK:%u TYPE:%s SUBTYPE:%s FRAMES:%u PAD:%u PREGAP:%u PGTYPE:%s PGSUB:%s POSTGAP:%u"
 
 /* standard A/V metadata */
-#define AV_METADATA_TAG				0x41564156	/* 'AVAV' */
+#define AV_METADATA_TAG				CHD_MAKE_TAG('A','V','A','V')
 #define AV_METADATA_FORMAT			"FPS:%d.%06d WIDTH:%d HEIGHT:%d INTERLACED:%d CHANNELS:%d SAMPLERATE:%d"
 
 /* A/V laserdisc frame metadata */
-#define AV_LD_METADATA_TAG			0x41564C44	/* 'AVLD' */
+#define AV_LD_METADATA_TAG			CHD_MAKE_TAG('A','V','L','D')
 
 /* CHD open values */
 #define CHD_OPEN_READ				1
diff --git a/src/libretro/libretro-common/include/libchdr/libchdr_zlib.h b/src/libretro/libretro-common/include/libchdr/libchdr_zlib.h
index 324faeeaa2..86544d6d00 100644
--- a/src/libretro/libretro-common/include/libchdr/libchdr_zlib.h
+++ b/src/libretro/libretro-common/include/libchdr/libchdr_zlib.h
@@ -27,6 +27,7 @@ typedef struct _zlib_allocator zlib_allocator;
 struct _zlib_allocator
 {
 	UINT32 *				allocptr[MAX_ZLIB_ALLOCS];
+	UINT32 *				allocptr2[MAX_ZLIB_ALLOCS];
 };
 
 typedef struct _zlib_codec_data zlib_codec_data;
diff --git a/src/libretro/libretro-common/include/libchdr/lzma.h b/src/libretro/libretro-common/include/libchdr/lzma.h
index e3cccbc196..15deb62759 100644
--- a/src/libretro/libretro-common/include/libchdr/lzma.h
+++ b/src/libretro/libretro-common/include/libchdr/lzma.h
@@ -30,6 +30,7 @@ struct _lzma_allocator
  	void (*Free)(void *p, void *address); /* address can be 0 */
 	void (*FreeSz)(void *p, void *address, size_t size); /* address can be 0 */
 	uint32_t*	allocptr[MAX_LZMA_ALLOCS];
+	uint32_t*	allocptr2[MAX_LZMA_ALLOCS];
 };
 
 typedef struct _lzma_codec_data lzma_codec_data;
diff --git a/src/libretro/libretro-common/include/libco.h b/src/libretro/libretro-common/include/libco.h
index 851b29cc43..177721a3a8 100644
--- a/src/libretro/libretro-common/include/libco.h
+++ b/src/libretro/libretro-common/include/libco.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (libco.h).
diff --git a/src/libretro/libretro-common/include/libretro.h b/src/libretro/libretro-common/include/libretro.h
index bb114aed35..cb1c2d25ef 100644
--- a/src/libretro/libretro-common/include/libretro.h
+++ b/src/libretro/libretro-common/include/libretro.h
@@ -289,6 +289,9 @@ enum retro_language
    RETRO_LANGUAGE_CZECH               = 27,
    RETRO_LANGUAGE_CATALAN_VALENCIA    = 28,
    RETRO_LANGUAGE_CATALAN             = 29,
+   RETRO_LANGUAGE_BRITISH_ENGLISH     = 30,
+   RETRO_LANGUAGE_HUNGARIAN           = 31,
+   RETRO_LANGUAGE_BELARUSIAN          = 32,
    RETRO_LANGUAGE_LAST,
 
    /* Ensure sizeof(enum) == sizeof(int) */
@@ -926,8 +929,6 @@ enum retro_mod
                                             * anything else.
                                             * It is recommended to expose all relevant pointers through
                                             * retro_get_memory_* as well.
-                                            *
-                                            * Can be called from retro_init and retro_load_game.
                                             */
 #define RETRO_ENVIRONMENT_SET_GEOMETRY 37
                                            /* const struct retro_game_geometry * --
@@ -1765,6 +1766,90 @@ enum retro_mod
                                             * (see enum retro_savestate_context)
                                             */
 
+#define RETRO_ENVIRONMENT_GET_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE_SUPPORT (73 | RETRO_ENVIRONMENT_EXPERIMENTAL)
+                                            /* struct retro_hw_render_context_negotiation_interface * --
+                                             * Before calling SET_HW_RNEDER_CONTEXT_NEGOTIATION_INTERFACE, a core can query
+                                             * which version of the interface is supported.
+                                             *
+                                             * Frontend looks at interface_type and returns the maximum supported
+                                             * context negotiation interface version.
+                                             * If the interface_type is not supported or recognized by the frontend, a version of 0
+                                             * must be returned in interface_version and true is returned by frontend.
+                                             *
+                                             * If this environment call returns true with interface_version greater than 0,
+                                             * a core can always use a negotiation interface version larger than what the frontend returns, but only
+                                             * earlier versions of the interface will be used by the frontend.
+                                             * A frontend must not reject a negotiation interface version that is larger than
+                                             * what the frontend supports. Instead, the frontend will use the older entry points that it recognizes.
+                                             * If this is incompatible with a particular core's requirements, it can error out early.
+                                             *
+                                             * Backwards compatibility note:
+                                             * This environment call was introduced after Vulkan v1 context negotiation.
+                                             * If this environment call is not supported by frontend - i.e. the environment call returns false -
+                                             * only Vulkan v1 context negotiation is supported (if Vulkan HW rendering is supported at all).
+                                             * If a core uses Vulkan negotiation interface with version > 1, negotiation may fail unexpectedly.
+                                             * All future updates to the context negotiation interface implies that frontend must support
+                                             * this environment call to query support.
+                                             */
+
+#define RETRO_ENVIRONMENT_GET_JIT_CAPABLE 74
+                                           /* bool * --
+                                            * Result is set to true if the frontend has already verified JIT can be
+                                            * used, mainly for use iOS/tvOS. On other platforms the result is true.
+                                            */
+
+#define RETRO_ENVIRONMENT_GET_MICROPHONE_INTERFACE (75 | RETRO_ENVIRONMENT_EXPERIMENTAL)
+                                           /* struct retro_microphone_interface * --
+                                            * Returns an interface that can be used to receive input from the microphone driver.
+                                            *
+                                            * Returns true if microphone support is available,
+                                            * even if no microphones are plugged in.
+                                            * Returns false if mic support is disabled or unavailable.
+                                            *
+                                            * This callback can be invoked at any time,
+                                            * even before the microphone driver is ready.
+                                            */
+
+#define RETRO_ENVIRONMENT_SET_NETPACKET_INTERFACE 76
+                                           /* const struct retro_netpacket_callback * --
+                                            * When set, a core gains control over network packets sent and
+                                            * received during a multiplayer session. This can be used to
+                                            * emulate multiplayer games that were originally played on two
+                                            * or more separate consoles or computers connected together.
+                                            *
+                                            * The frontend will take care of connecting players together,
+                                            * and the core only needs to send the actual data as needed for
+                                            * the emulation, while handshake and connection management happen
+                                            * in the background.
+                                            *
+                                            * When two or more players are connected and this interface has
+                                            * been set, time manipulation features (such as pausing, slow motion,
+                                            * fast forward, rewinding, save state loading, etc.) are disabled to
+                                            * avoid interrupting communication.
+                                            *
+                                            * Should be set in either retro_init or retro_load_game, but not both.
+                                            *
+                                            * When not set, a frontend may use state serialization-based
+                                            * multiplayer, where a deterministic core supporting multiple
+                                            * input devices does not need to take any action on its own.
+                                            */
+
+#define RETRO_ENVIRONMENT_GET_DEVICE_POWER (77 | RETRO_ENVIRONMENT_EXPERIMENTAL)
+                                           /* struct retro_device_power * --
+                                            * Returns the device's current power state as reported by the frontend.
+                                            * This is useful for emulating the battery level in handheld consoles,
+                                            * or for reducing power consumption when on battery power.
+                                            *
+                                            * The return value indicates whether the frontend can provide this information,
+                                            * even if the parameter is NULL.
+                                            *
+                                            * If the frontend does not support this functionality,
+                                            * then the provided argument will remain unchanged.
+                                            *
+                                            * Note that this environment call describes the power state for the entire device,
+                                            * not for individual peripherals like controllers.
+                                            */
+
 /* VFS functionality */
 
 /* File paths:
@@ -1939,13 +2024,13 @@ struct retro_vfs_interface_info
 
 enum retro_hw_render_interface_type
 {
-	RETRO_HW_RENDER_INTERFACE_VULKAN = 0,
-	RETRO_HW_RENDER_INTERFACE_D3D9   = 1,
-	RETRO_HW_RENDER_INTERFACE_D3D10  = 2,
-	RETRO_HW_RENDER_INTERFACE_D3D11  = 3,
-	RETRO_HW_RENDER_INTERFACE_D3D12  = 4,
+   RETRO_HW_RENDER_INTERFACE_VULKAN     = 0,
+   RETRO_HW_RENDER_INTERFACE_D3D9       = 1,
+   RETRO_HW_RENDER_INTERFACE_D3D10      = 2,
+   RETRO_HW_RENDER_INTERFACE_D3D11      = 3,
+   RETRO_HW_RENDER_INTERFACE_D3D12      = 4,
    RETRO_HW_RENDER_INTERFACE_GSKIT_PS2  = 5,
-   RETRO_HW_RENDER_INTERFACE_DUMMY  = INT_MAX
+   RETRO_HW_RENDER_INTERFACE_DUMMY      = INT_MAX
 };
 
 /* Base struct. All retro_hw_render_interface_* types
@@ -2721,9 +2806,17 @@ enum retro_hw_context_type
    /* Vulkan, see RETRO_ENVIRONMENT_GET_HW_RENDER_INTERFACE. */
    RETRO_HW_CONTEXT_VULKAN           = 6,
 
-   /* Direct3D, set version_major to select the type of interface
-    * returned by RETRO_ENVIRONMENT_GET_HW_RENDER_INTERFACE */
-   RETRO_HW_CONTEXT_DIRECT3D         = 7,
+   /* Direct3D11, see RETRO_ENVIRONMENT_GET_HW_RENDER_INTERFACE */
+   RETRO_HW_CONTEXT_D3D11            = 7,
+
+   /* Direct3D10, see RETRO_ENVIRONMENT_GET_HW_RENDER_INTERFACE */
+   RETRO_HW_CONTEXT_D3D10            = 8,
+
+   /* Direct3D12, see RETRO_ENVIRONMENT_GET_HW_RENDER_INTERFACE */
+   RETRO_HW_CONTEXT_D3D12            = 9,
+
+   /* Direct3D9, see RETRO_ENVIRONMENT_GET_HW_RENDER_INTERFACE */
+   RETRO_HW_CONTEXT_D3D9             = 10,
 
    RETRO_HW_CONTEXT_DUMMY = INT_MAX
 };
@@ -2978,6 +3071,100 @@ struct retro_disk_control_ext_callback
    retro_get_image_label_t get_image_label;     /* Optional - may be NULL */
 };
 
+/* Definitions for RETRO_ENVIRONMENT_SET_NETPACKET_INTERFACE.
+ * A core can set it if sending and receiving custom network packets
+ * during a multiplayer session is desired.
+ */
+
+/* Netpacket flags for retro_netpacket_send_t */
+#define RETRO_NETPACKET_UNRELIABLE  0        /* Packet to be sent unreliable, depending on network quality it might not arrive. */
+#define RETRO_NETPACKET_RELIABLE    (1 << 0) /* Reliable packets are guaranteed to arrive at the target in the order they were send. */
+#define RETRO_NETPACKET_UNSEQUENCED (1 << 1) /* Packet will not be sequenced with other packets and may arrive out of order. Cannot be set on reliable packets. */
+
+/* Used by the core to send a packet to one or more connected players.
+ * A single packet sent via this interface can contain up to 64 KB of data.
+ *
+ * The broadcast flag can be set to true to send to multiple connected clients.
+ * In a broadcast, the client_id argument indicates 1 client NOT to send the
+ * packet to (pass 0xFFFF to send to everyone). Otherwise, the client_id
+ * argument indicates a single client to send the packet to.
+ *
+ * A frontend must support sending reliable packets (RETRO_NETPACKET_RELIABLE).
+ * Unreliable packets might not be supported by the frontend, but the flags can
+ * still be specified. Reliable transmission will be used instead.
+ *
+ * If this function is called passing NULL for buf, it will instead flush all
+ * previously buffered outgoing packets and instantly read any incoming packets.
+ * During such a call, retro_netpacket_receive_t and retro_netpacket_stop_t can
+ * be called. The core can perform this in a loop to do a blocking read, i.e.,
+ * wait for incoming data, but needs to handle stop getting called and also
+ * give up after a short while to avoid freezing on a connection problem.
+ *
+ * This function is not guaranteed to be thread-safe and must be called during
+ * retro_run or any of the netpacket callbacks passed with this interface.
+ */
+typedef void (RETRO_CALLCONV *retro_netpacket_send_t)(int flags, const void* buf, size_t len, uint16_t client_id, bool broadcast);
+
+/* Called by the frontend to signify that a multiplayer session has started.
+ * If client_id is 0 the local player is the host of the session and at this
+ * point no other player has connected yet.
+ *
+ * If client_id is > 0 the local player is a client connected to a host and
+ * at this point is already fully connected to the host.
+ *
+ * The core must store the retro_netpacket_send_t function pointer provided
+ * here and use it whenever it wants to send a packet. This function pointer
+ * remains valid until the frontend calls retro_netpacket_stop_t.
+ */
+typedef void (RETRO_CALLCONV *retro_netpacket_start_t)(uint16_t client_id, retro_netpacket_send_t send_fn);
+
+/* Called by the frontend when a new packet arrives which has been sent from
+ * another player with retro_netpacket_send_t. The client_id argument indicates
+ * who has sent the packet.
+ */
+typedef void (RETRO_CALLCONV *retro_netpacket_receive_t)(const void* buf, size_t len, uint16_t client_id);
+
+/* Called by the frontend when the multiplayer session has ended.
+ * Once this gets called the retro_netpacket_send_t function pointer passed
+ * to retro_netpacket_start_t will not be valid anymore.
+ */
+typedef void (RETRO_CALLCONV *retro_netpacket_stop_t)(void);
+
+/* Called by the frontend every frame (between calls to retro_run while
+ * updating the state of the multiplayer session.
+ * This is a good place for the core to call retro_netpacket_send_t from.
+ */
+typedef void (RETRO_CALLCONV *retro_netpacket_poll_t)(void);
+
+/* Called by the frontend when a new player connects to the hosted session.
+ * This is only called on the host side, not for clients connected to the host.
+ * If this function returns false, the newly connected player gets dropped.
+ * This can be used for example to limit the number of players.
+ */
+typedef bool (RETRO_CALLCONV *retro_netpacket_connected_t)(uint16_t client_id);
+
+/* Called by the frontend when a player leaves or disconnects from the hosted session.
+ * This is only called on the host side, not for clients connected to the host.
+ */
+typedef void (RETRO_CALLCONV *retro_netpacket_disconnected_t)(uint16_t client_id);
+
+/**
+ * A callback interface for giving a core the ability to send and receive custom
+ * network packets during a multiplayer session between two or more instances
+ * of a libretro frontend.
+ *
+ * @see RETRO_ENVIRONMENT_SET_NETPACKET_INTERFACE
+ */
+struct retro_netpacket_callback
+{
+   retro_netpacket_start_t        start;
+   retro_netpacket_receive_t      receive;
+   retro_netpacket_stop_t         stop;         /* Optional - may be NULL */
+   retro_netpacket_poll_t         poll;         /* Optional - may be NULL */
+   retro_netpacket_connected_t    connected;    /* Optional - may be NULL */
+   retro_netpacket_disconnected_t disconnected; /* Optional - may be NULL */
+};
+
 enum retro_pixel_format
 {
    /* 0RGB1555, native endian.
@@ -3780,6 +3967,289 @@ struct retro_throttle_state
    float rate;
 };
 
+/**
+ * Opaque handle to a microphone that's been opened for use.
+ * The underlying object is accessed or created with \c retro_microphone_interface_t.
+ */
+typedef struct retro_microphone retro_microphone_t;
+
+/**
+ * Parameters for configuring a microphone.
+ * Some of these might not be honored,
+ * depending on the available hardware and driver configuration.
+ */
+typedef struct retro_microphone_params
+{
+   /**
+    * The desired sample rate of the microphone's input, in Hz.
+    * The microphone's input will be resampled,
+    * so cores can ask for whichever frequency they need.
+    *
+    * If zero, some reasonable default will be provided by the frontend
+    * (usually from its config file).
+    *
+    * @see retro_get_mic_rate_t
+    */
+   unsigned rate;
+} retro_microphone_params_t;
+
+/**
+ * @copydoc retro_microphone_interface::open_mic
+ */
+typedef retro_microphone_t *(RETRO_CALLCONV *retro_open_mic_t)(const retro_microphone_params_t *params);
+
+/**
+ * @copydoc retro_microphone_interface::close_mic
+ */
+typedef void (RETRO_CALLCONV *retro_close_mic_t)(retro_microphone_t *microphone);
+
+/**
+ * @copydoc retro_microphone_interface::get_params
+ */
+typedef bool (RETRO_CALLCONV *retro_get_mic_params_t)(const retro_microphone_t *microphone, retro_microphone_params_t *params);
+
+/**
+ * @copydoc retro_microphone_interface::set_mic_state
+ */
+typedef bool (RETRO_CALLCONV *retro_set_mic_state_t)(retro_microphone_t *microphone, bool state);
+
+/**
+ * @copydoc retro_microphone_interface::get_mic_state
+ */
+typedef bool (RETRO_CALLCONV *retro_get_mic_state_t)(const retro_microphone_t *microphone);
+
+/**
+ * @copydoc retro_microphone_interface::read_mic
+ */
+typedef int (RETRO_CALLCONV *retro_read_mic_t)(retro_microphone_t *microphone, int16_t* samples, size_t num_samples);
+
+/**
+ * The current version of the microphone interface.
+ * Will be incremented whenever \c retro_microphone_interface or \c retro_microphone_params_t
+ * receive new fields.
+ *
+ * Frontends using cores built against older mic interface versions
+ * should not access fields introduced in newer versions.
+ */
+#define RETRO_MICROPHONE_INTERFACE_VERSION 1
+
+/**
+ * An interface for querying the microphone and accessing data read from it.
+ *
+ * @see RETRO_ENVIRONMENT_GET_MICROPHONE_INTERFACE
+ */
+struct retro_microphone_interface
+{
+   /**
+    * The version of this microphone interface.
+    * Set by the core to request a particular version,
+    * and set by the frontend to indicate the returned version.
+    * 0 indicates that the interface is invalid or uninitialized.
+    */
+   unsigned interface_version;
+
+   /**
+    * Initializes a new microphone.
+    * Assuming that microphone support is enabled and provided by the frontend,
+    * cores may call this function whenever necessary.
+    * A microphone could be opened throughout a core's lifetime,
+    * or it could wait until a microphone is plugged in to the emulated device.
+    *
+    * The returned handle will be valid until it's freed,
+    * even if the audio driver is reinitialized.
+    *
+    * This function is not guaranteed to be thread-safe.
+    *
+    * @param args[in] Parameters used to create the microphone.
+    * May be \c NULL, in which case the default value of each parameter will be used.
+    *
+    * @returns Pointer to the newly-opened microphone,
+    * or \c NULL if one couldn't be opened.
+    * This likely means that no microphone is plugged in and recognized,
+    * or the maximum number of supported microphones has been reached.
+    *
+    * @note Microphones are \em inactive by default;
+    * to begin capturing audio, call \c set_mic_state.
+    * @see retro_microphone_params_t
+    */
+   retro_open_mic_t open_mic;
+
+   /**
+    * Closes a microphone that was initialized with \c open_mic.
+    * Calling this function will stop all microphone activity
+    * and free up the resources that it allocated.
+    * Afterwards, the handle is invalid and must not be used.
+    *
+    * A frontend may close opened microphones when unloading content,
+    * but this behavior is not guaranteed.
+    * Cores should close their microphones when exiting, just to be safe.
+    *
+    * @param microphone Pointer to the microphone that was allocated by \c open_mic.
+    * If \c NULL, this function does nothing.
+    *
+    * @note The handle might be reused if another microphone is opened later.
+    */
+   retro_close_mic_t close_mic;
+
+   /**
+    * Returns the configured parameters of this microphone.
+    * These may differ from what was requested depending on
+    * the driver and device configuration.
+    *
+    * Cores should check these values before they start fetching samples.
+    *
+    * Will not change after the mic was opened.
+    *
+    * @param microphone[in] Opaque handle to the microphone
+    * whose parameters will be retrieved.
+    * @param params[out] The parameters object that the
+    * microphone's parameters will be copied to.
+    *
+    * @return \c true if the parameters were retrieved,
+    * \c false if there was an error.
+    */
+   retro_get_mic_params_t get_params;
+
+   /**
+    * Enables or disables the given microphone.
+    * Microphones are disabled by default
+    * and must be explicitly enabled before they can be used.
+    * Disabled microphones will not process incoming audio samples,
+    * and will therefore have minimal impact on overall performance.
+    * Cores may enable microphones throughout their lifetime,
+    * or only for periods where they're needed.
+    *
+    * Cores that accept microphone input should be able to operate without it;
+    * we suggest substituting silence in this case.
+    *
+    * @param microphone Opaque handle to the microphone
+    * whose state will be adjusted.
+    * This will have been provided by \c open_mic.
+    * @param state \c true if the microphone should receive audio input,
+    * \c false if it should be idle.
+    * @returns \c true if the microphone's state was successfully set,
+    * \c false if \c microphone is invalid
+    * or if there was an error.
+    */
+   retro_set_mic_state_t set_mic_state;
+
+   /**
+    * Queries the active state of a microphone at the given index.
+    * Will return whether the microphone is enabled,
+    * even if the driver is paused.
+    *
+    * @param microphone Opaque handle to the microphone
+    * whose state will be queried.
+    * @return \c true if the provided \c microphone is valid and active,
+    * \c false if not or if there was an error.
+    */
+   retro_get_mic_state_t get_mic_state;
+
+   /**
+    * Retrieves the input processed by the microphone since the last call.
+    * \em Must be called every frame unless \c microphone is disabled,
+    * similar to how \c retro_audio_sample_batch_t works.
+    *
+    * @param[in] microphone Opaque handle to the microphone
+    * whose recent input will be retrieved.
+    * @param[out] samples The buffer that will be used to store the microphone's data.
+    * Microphone input is in mono (i.e. one number per sample).
+    * Should be large enough to accommodate the expected number of samples per frame;
+    * for example, a 44.1kHz sample rate at 60 FPS would require space for 735 samples.
+    * @param[in] num_samples The size of the data buffer in samples (\em not bytes).
+    * Microphone input is in mono, so a "frame" and a "sample" are equivalent in length here.
+    *
+    * @return The number of samples that were copied into \c samples.
+    * If \c microphone is pending driver initialization,
+    * this function will copy silence of the requested length into \c samples.
+    *
+    * Will return -1 if the microphone is disabled,
+    * the audio driver is paused,
+    * or there was an error.
+    */
+   retro_read_mic_t read_mic;
+};
+
+/**
+ * Describes how a device is being powered.
+ * @see RETRO_ENVIRONMENT_GET_DEVICE_POWER
+ */
+enum retro_power_state
+{
+   /**
+    * Indicates that the frontend cannot report its power state at this time,
+    * most likely due to a lack of support.
+    *
+    * \c RETRO_ENVIRONMENT_GET_DEVICE_POWER will not return this value;
+    * instead, the environment callback will return \c false.
+    */
+   RETRO_POWERSTATE_UNKNOWN = 0,
+
+   /**
+    * Indicates that the device is running on its battery.
+    * Usually applies to portable devices such as handhelds, laptops, and smartphones.
+    */
+   RETRO_POWERSTATE_DISCHARGING,
+
+   /**
+    * Indicates that the device's battery is currently charging.
+    */
+   RETRO_POWERSTATE_CHARGING,
+
+   /**
+    * Indicates that the device is connected to a power source
+    * and that its battery has finished charging.
+    */
+   RETRO_POWERSTATE_CHARGED,
+
+   /**
+    * Indicates that the device is connected to a power source
+    * and that it does not have a battery.
+    * This usually suggests a desktop computer or a non-portable game console.
+    */
+   RETRO_POWERSTATE_PLUGGED_IN
+};
+
+/**
+ * Indicates that an estimate is not available for the battery level or time remaining,
+ * even if the actual power state is known.
+ */
+#define RETRO_POWERSTATE_NO_ESTIMATE (-1)
+
+/**
+ * Describes the power state of the device running the frontend.
+ * @see RETRO_ENVIRONMENT_GET_DEVICE_POWER
+ */
+struct retro_device_power
+{
+   /**
+    * The current state of the frontend's power usage.
+    */
+   enum retro_power_state state;
+
+   /**
+    * A rough estimate of the amount of time remaining (in seconds)
+    * before the device powers off.
+    * This value depends on a variety of factors,
+    * so it is not guaranteed to be accurate.
+    *
+    * Will be set to \c RETRO_POWERSTATE_NO_ESTIMATE if \c state does not equal \c RETRO_POWERSTATE_DISCHARGING.
+    * May still be set to \c RETRO_POWERSTATE_NO_ESTIMATE if the frontend is unable to provide an estimate.
+    */
+   int seconds;
+
+   /**
+    * The approximate percentage of battery charge,
+    * ranging from 0 to 100 (inclusive).
+    * The device may power off before this reaches 0.
+    *
+    * The user might have configured their device
+    * to stop charging before the battery is full,
+    * so do not assume that this will be 100 in the \c RETRO_POWERSTATE_CHARGED state.
+    */
+   int8_t percent;
+};
+
 /* Callbacks */
 
 /* Environment callback. Gives implementations a way of performing
diff --git a/src/libretro/libretro-common/include/libretro_d3d.h b/src/libretro/libretro-common/include/libretro_d3d.h
index 51165a3717..8e1824323b 100644
--- a/src/libretro/libretro-common/include/libretro_d3d.h
+++ b/src/libretro/libretro-common/include/libretro_d3d.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010-2018 The RetroArch team
+/* Copyright (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------------
  * The following license statement only applies to this libretro API header (libretro_d3d.h)
@@ -56,4 +56,32 @@ struct retro_hw_render_interface_d3d11
 
 #endif
 
+#ifdef HAVE_D3D12
+
+#include <d3d12.h>
+#include <d3dcompiler.h>
+
+#define RETRO_HW_RENDER_INTERFACE_D3D12_VERSION 1
+
+struct retro_hw_render_interface_d3d12
+{
+  /* Must be set to RETRO_HW_RENDER_INTERFACE_D3D12. */
+  enum retro_hw_render_interface_type interface_type;
+  /* Must be set to RETRO_HW_RENDER_INTERFACE_D3D12_VERSION. */
+  unsigned interface_version;
+
+  /* Opaque handle to the d3d12 backend in the frontend
+   * which must be passed along to all function pointers
+   * in this interface.
+   */
+  void* handle;
+  ID3D12Device *device;
+  ID3D12CommandQueue *queue;
+  pD3DCompile D3DCompile;
+  D3D12_RESOURCE_STATES required_state;
+  void (*set_texture)(void* handle, ID3D12Resource* texture, DXGI_FORMAT format);
+};
+
+#endif
+
 #endif /* LIBRETRO_DIRECT3D_H__ */
diff --git a/src/libretro/libretro-common/include/libretro_dspfilter.h b/src/libretro/libretro-common/include/libretro_dspfilter.h
index 36bfd88d5f..27dd3c7de7 100644
--- a/src/libretro/libretro-common/include/libretro_dspfilter.h
+++ b/src/libretro/libretro-common/include/libretro_dspfilter.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010-2018 The RetroArch team
+/* Copyright (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this libretro API header (libretro_dspfilter.h).
diff --git a/src/libretro/libretro-common/include/libretro_gskit_ps2.h b/src/libretro/libretro-common/include/libretro_gskit_ps2.h
index f7b61dc2e8..033bb1f681 100644
--- a/src/libretro/libretro-common/include/libretro_gskit_ps2.h
+++ b/src/libretro/libretro-common/include/libretro_gskit_ps2.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010-2018 The RetroArch team
+/* Copyright (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------------
  * The following license statement only applies to this libretro API header (libretro_d3d.h)
@@ -33,7 +33,7 @@
 
 #include <gsKit.h>
 
-#define RETRO_HW_RENDER_INTERFACE_GSKIT_PS2_VERSION 1
+#define RETRO_HW_RENDER_INTERFACE_GSKIT_PS2_VERSION 2
 
 struct retro_hw_ps2_insets
 {
@@ -57,8 +57,6 @@ struct retro_hw_render_interface_gskit_ps2
    * in this interface.
    */
    GSTEXTURE *coreTexture;
-   bool clearTexture;
-   bool updatedPalette;
    struct retro_hw_ps2_insets padding;
 };
 typedef struct retro_hw_render_interface_gskit_ps2 RETRO_HW_RENDER_INTEFACE_GSKIT_PS2;
diff --git a/src/libretro/libretro-common/include/libretro_vulkan.h b/src/libretro/libretro-common/include/libretro_vulkan.h
index a6f9fb3c75..bfc93af596 100644
--- a/src/libretro/libretro-common/include/libretro_vulkan.h
+++ b/src/libretro/libretro-common/include/libretro_vulkan.h
@@ -1,4 +1,4 @@
-/* Copyright (C) 2010-2018 The RetroArch team
+/* Copyright (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------------
  * The following license statement only applies to this libretro API header (libretro_vulkan.h)
@@ -27,7 +27,7 @@
 #include <vulkan/vulkan.h>
 
 #define RETRO_HW_RENDER_INTERFACE_VULKAN_VERSION 5
-#define RETRO_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE_VULKAN_VERSION 1
+#define RETRO_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE_VULKAN_VERSION 2
 
 struct retro_vulkan_image
 {
@@ -64,6 +64,8 @@ struct retro_vulkan_context
    uint32_t presentation_queue_family_index;
 };
 
+/* This is only used in v1 of the negotiation interface.
+ * It is deprecated since it cannot express PDF2 features or optional extensions. */
 typedef bool (*retro_vulkan_create_device_t)(
       struct retro_vulkan_context *context,
       VkInstance instance,
@@ -78,6 +80,32 @@ typedef bool (*retro_vulkan_create_device_t)(
 
 typedef void (*retro_vulkan_destroy_device_t)(void);
 
+/* v2 CONTEXT_NEGOTIATION_INTERFACE only. */
+typedef VkInstance (*retro_vulkan_create_instance_wrapper_t)(
+      void *opaque, const VkInstanceCreateInfo *create_info);
+
+/* v2 CONTEXT_NEGOTIATION_INTERFACE only. */
+typedef VkInstance (*retro_vulkan_create_instance_t)(
+      PFN_vkGetInstanceProcAddr get_instance_proc_addr,
+      const VkApplicationInfo *app,
+      retro_vulkan_create_instance_wrapper_t create_instance_wrapper,
+      void *opaque);
+
+/* v2 CONTEXT_NEGOTIATION_INTERFACE only. */
+typedef VkDevice (*retro_vulkan_create_device_wrapper_t)(
+      VkPhysicalDevice gpu, void *opaque,
+      const VkDeviceCreateInfo *create_info);
+
+/* v2 CONTEXT_NEGOTIATION_INTERFACE only. */
+typedef bool (*retro_vulkan_create_device2_t)(
+      struct retro_vulkan_context *context,
+      VkInstance instance,
+      VkPhysicalDevice gpu,
+      VkSurfaceKHR surface,
+      PFN_vkGetInstanceProcAddr get_instance_proc_addr,
+      retro_vulkan_create_device_wrapper_t create_device_wrapper,
+      void *opaque);
+
 /* Note on thread safety:
  * The Vulkan API is heavily designed around multi-threading, and
  * the libretro interface for it should also be threading friendly.
@@ -89,11 +117,24 @@ struct retro_hw_render_context_negotiation_interface_vulkan
 {
    /* Must be set to RETRO_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE_VULKAN. */
    enum retro_hw_render_context_negotiation_interface_type interface_type;
-   /* Must be set to RETRO_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE_VULKAN_VERSION. */
+   /* Usually set to RETRO_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE_VULKAN_VERSION,
+    * but can be lower depending on GET_HW_RENDER_CONTEXT_NEGOTIATION_INTERFACE_SUPPORT. */
    unsigned interface_version;
 
    /* If non-NULL, returns a VkApplicationInfo struct that the frontend can use instead of
     * its "default" application info.
+    * VkApplicationInfo::apiVersion also controls the target core Vulkan version for instance level functionality.
+    * Lifetime of the returned pointer must remain until the retro_vulkan_context is initialized.
+    *
+    * NOTE: For optimal compatibility with e.g. Android which is very slow to update its loader,
+    * a core version of 1.1 should be requested. Features beyond that can be requested with extensions.
+    * Vulkan 1.0 is only appropriate for legacy cores, but is still supported.
+    * A frontend is free to bump the instance creation apiVersion as necessary if the frontend requires more advanced core features.
+    *
+    * v2: This function must not be NULL, and must not return NULL.
+    * v1: It was not clearly defined if this function could return NULL.
+    *     Frontends should be defensive and provide a default VkApplicationInfo
+    *     if this function returns NULL or if this function is NULL.
     */
    retro_vulkan_get_application_info_t get_application_info;
 
@@ -102,8 +143,8 @@ struct retro_hw_render_context_negotiation_interface_vulkan
     * The core must prepare a designated PhysicalDevice, Device, Queue and queue family index
     * which the frontend will use for its internal operation.
     *
-    * If gpu is not VK_NULL_HANDLE, the physical device provided to the frontend must be this PhysicalDevice.
-    * The core is still free to use other physical devices.
+    * If gpu is not VK_NULL_HANDLE, the physical device provided to the frontend must be this PhysicalDevice if the call succeeds.
+    * The core is still free to use other physical devices for other purposes that are private to the core.
     *
     * The frontend will request certain extensions and layers for a device which is created.
     * The core must ensure that the queue and queue_family_index support GRAPHICS and COMPUTE.
@@ -132,8 +173,64 @@ struct retro_hw_render_context_negotiation_interface_vulkan
     * tearing down its own device resources.
     *
     * Only auxillary resources should be freed here, i.e. resources which are not part of retro_vulkan_context.
+    * v2: Auxillary instance resources created during create_instance can also be freed here.
     */
    retro_vulkan_destroy_device_t destroy_device;
+
+   /* v2 API: If interface_version is < 2, fields below must be ignored.
+    * If the frontend does not support interface version 2, the v1 entry points will be used instead. */
+
+   /* If non-NULL, this is called to create an instance, otherwise a VkInstance is created by the frontend.
+    * v1 interface bug: The only way to enable instance features is through core versions signalled in VkApplicationInfo.
+    * The frontend may request that certain extensions and layers
+    * are enabled on the VkInstance. Application may add additional features.
+    * If app is non-NULL, apiVersion controls the minimum core version required by the application.
+    * Return a VkInstance or VK_NULL_HANDLE. The VkInstance is owned by the frontend.
+    *
+    * Rather than call vkCreateInstance directly, a core must call the CreateInstance wrapper provided with:
+    * VkInstance instance = create_instance_wrapper(opaque, &create_info);
+    * If the core wishes to create a private instance for whatever reason (relying on shared memory for example),
+    * it may call vkCreateInstance directly. */
+   retro_vulkan_create_instance_t create_instance;
+
+   /* If non-NULL and frontend recognizes negotiation interface >= 2, create_device2 takes precedence over create_device.
+    * Similar to create_device, but is extended to better understand new core versions and PDF2 feature enablement.
+    * Requirements for create_device2 are the same as create_device unless a difference is mentioned.
+    *
+    * v2 consideration:
+    * If the chosen gpu by frontend cannot be supported, a core must return false.
+    *
+    * NOTE: "Cannot be supported" is intentionally vaguely defined.
+    * Refusing to run on an iGPU for a very intensive core with desktop GPU as a minimum spec may be in the gray area.
+    * Not supporting optional features is not a good reason to reject a physical device, however.
+    *
+    * On device creation feature with explicit gpu, a frontend should fall back create_device2 with gpu == VK_NULL_HANDLE and let core
+    * decide on a supported device if possible.
+    *
+    * A core must assume that the explicitly provided GPU is the only guaranteed attempt it has to create a device.
+    * A fallback may not be attempted if there are particular reasons why only a specific physical device can work,
+    * but these situations should be esoteric and rare in nature, e.g. a libretro frontend is implemented with external memory
+    * and only LUID matching would work.
+    * Cores and frontends should ensure "best effort" when negotiating like this and appropriate logging is encouraged.
+    *
+    * v1 note: In the v1 version of create_device, it was never expected that create_device would fail like this,
+    * and frontends are not expected to attempt fall backs.
+    *
+    * Rather than call vkCreateDevice directly, a core must call the CreateDevice wrapper provided with:
+    * VkDevice device = create_device_wrapper(gpu, opaque, &create_info);
+    * If the core wishes to create a private device for whatever reason (relying on shared memory for example),
+    * it may call vkCreateDevice directly.
+    *
+    * This allows the frontend to add additional extensions that it requires as well as adjust the PDF2 pNext as required.
+    * It is also possible adjust the queue create infos in case the frontend desires to allocate some private queues.
+    *
+    * The get_instance_proc_addr provided in create_device2 must be the same as create_instance.
+    *
+    * NOTE: The frontend must not disable features requested by application.
+    * NOTE: The frontend must not add any robustness features as some API behavior may change (VK_EXT_descriptor_buffer comes to mind).
+    * I.e. robustBufferAccess and the like. (nullDescriptor from robustness2 is allowed to be enabled).
+    */
+   retro_vulkan_create_device2_t create_device2;
 };
 
 struct retro_hw_render_interface_vulkan
diff --git a/src/libretro/libretro-common/include/lists/dir_list.h b/src/libretro/libretro-common/include/lists/dir_list.h
index d1d61d9be5..39a0f75217 100644
--- a/src/libretro/libretro-common/include/lists/dir_list.h
+++ b/src/libretro/libretro-common/include/lists/dir_list.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (dir_list.h).
@@ -24,6 +24,7 @@
 #define __LIBRETRO_SDK_DIR_LIST_H
 
 #include <retro_common_api.h>
+#include <boolean.h>
 
 #include <lists/string_list.h>
 
@@ -41,7 +42,7 @@ RETRO_BEGIN_DECLS
  *
  * Create a directory listing, appending to an existing list
  *
- * Returns: true success, false in case of error.
+ * @return Returns true on success, otherwise false.
  **/
 bool dir_list_append(struct string_list *list, const char *dir, const char *ext,
       bool include_dirs, bool include_hidden, bool include_compressed, bool recursive);
@@ -57,31 +58,52 @@ bool dir_list_append(struct string_list *list, const char *dir, const char *ext,
  *
  * Create a directory listing.
  *
- * Returns: pointer to a directory listing of type 'struct string_list *' on success,
+ * @return pointer to a directory listing of type 'struct string_list *' on success,
  * NULL in case of error. Has to be freed manually.
  **/
 struct string_list *dir_list_new(const char *dir, const char *ext,
       bool include_dirs, bool include_hidden, bool include_compressed, bool recursive);
 
+/**
+ * dir_list_initialize:
+ *
+ * NOTE: @list must zero initialised before
+ * calling this function, otherwise UB.
+ **/
+bool dir_list_initialize(struct string_list *list,
+      const char *dir,
+      const char *ext, bool include_dirs,
+      bool include_hidden, bool include_compressed,
+      bool recursive);
+
 /**
  * dir_list_sort:
  * @list      : pointer to the directory listing.
  * @dir_first : move the directories in the listing to the top?
  *
  * Sorts a directory listing.
- *
  **/
 void dir_list_sort(struct string_list *list, bool dir_first);
 
+/**
+ * dir_list_sort_ignore_ext:
+ * @list      : pointer to the directory listing.
+ * @dir_first : move the directories in the listing to the top?
+ *
+ * Sorts a directory listing. File extensions are ignored.
+ **/
+void dir_list_sort_ignore_ext(struct string_list *list, bool dir_first);
+
 /**
  * dir_list_free:
  * @list : pointer to the directory listing
  *
  * Frees a directory listing.
- *
  **/
 void dir_list_free(struct string_list *list);
 
+bool dir_list_deinitialize(struct string_list *list);
+
 RETRO_END_DECLS
 
 #endif
diff --git a/src/libretro/libretro-common/include/lists/file_list.h b/src/libretro/libretro-common/include/lists/file_list.h
index c41b5e7968..3f7ebadc2a 100644
--- a/src/libretro/libretro-common/include/lists/file_list.h
+++ b/src/libretro/libretro-common/include/lists/file_list.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (file_list.h).
@@ -34,14 +34,14 @@ RETRO_BEGIN_DECLS
 
 struct item_file
 {
+   void *userdata;
+   void *actiondata;
    char *path;
    char *label;
    char *alt;
-   unsigned type;
    size_t directory_ptr;
    size_t entry_idx;
-   void *userdata;
-   void *actiondata;
+   unsigned type;
 };
 
 typedef struct file_list
@@ -66,18 +66,20 @@ void *file_list_get_actiondata_at_offset(const file_list_t *list,
  * or non-contiguous data there, make sure you free it's fields
  * before calling this function or you might get a memory leak.
  *
- * @param list
+ * @param list List to be freed
  */
 void file_list_free(file_list_t *list);
 
+bool file_list_deinitialize(file_list_t *list);
+
 /**
  * @brief makes the list big enough to contain at least nitems
  *
  * This function will not change the capacity if nitems is smaller
  * than the current capacity.
  *
- * @param list
- * @param nitems
+ * @param list The list to open for input
+ * @param nitems Number of items to reserve space for
  * @return whether or not the operation succeeded
  */
 bool file_list_reserve(file_list_t *list, size_t nitems);
@@ -86,11 +88,6 @@ bool file_list_append(file_list_t *userdata, const char *path,
       const char *label, unsigned type, size_t current_directory_ptr,
       size_t entry_index);
 
-bool file_list_prepend(file_list_t *list,
-      const char *path, const char *label,
-      unsigned type, size_t directory_ptr,
-      size_t entry_idx);
-
 bool file_list_insert(file_list_t *list,
       const char *path, const char *label,
       unsigned type, size_t directory_ptr,
@@ -101,37 +98,13 @@ void file_list_pop(file_list_t *list, size_t *directory_ptr);
 
 void file_list_clear(file_list_t *list);
 
-void file_list_get_last(const file_list_t *list,
-      const char **path, const char **label,
-      unsigned *type, size_t *entry_idx);
-
-void *file_list_get_last_actiondata(const file_list_t *list);
-
-size_t file_list_get_size(const file_list_t *list);
-
-size_t file_list_get_directory_ptr(const file_list_t *list);
-
-void file_list_get_at_offset(const file_list_t *list, size_t index,
-      const char **path, const char **label,
-      unsigned *type, size_t *entry_idx);
-
 void file_list_free_userdata(const file_list_t *list, size_t index);
 
 void file_list_free_actiondata(const file_list_t *list, size_t idx);
 
-void file_list_set_label_at_offset(file_list_t *list, size_t index,
-      const char *label);
-
-void file_list_get_label_at_offset(const file_list_t *list, size_t index,
-      const char **label);
-
 void file_list_set_alt_at_offset(file_list_t *list, size_t index,
       const char *alt);
 
-void file_list_set_userdata(const file_list_t *list, size_t idx, void *ptr);
-
-void file_list_set_actiondata(const file_list_t *list, size_t idx, void *ptr);
-
 void file_list_sort_on_alt(file_list_t *list);
 
 void file_list_sort_on_type(file_list_t *list);
diff --git a/src/libretro/libretro-common/include/lists/string_list.h b/src/libretro/libretro-common/include/lists/string_list.h
index de26282d76..f772193e22 100644
--- a/src/libretro/libretro-common/include/lists/string_list.h
+++ b/src/libretro/libretro-common/include/lists/string_list.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (string_list.h).
@@ -59,7 +59,7 @@ struct string_list
  *
  * Searches for an element (@elem) inside the string list.
  *
- * Returns: true (1) if element could be found, otherwise false (0).
+ * @return Number of elements found, otherwise 0.
  */
 int string_list_find_elem(const struct string_list *list, const char *elem);
 
@@ -88,6 +88,9 @@ bool string_list_find_elem_prefix(const struct string_list *list,
  */
 struct string_list *string_split(const char *str, const char *delim);
 
+bool string_split_noalloc(struct string_list *list,
+      const char *str, const char *delim);
+
 /**
  * string_separate:
  * @str              : string to turn into a string list
@@ -97,17 +100,24 @@ struct string_list *string_split(const char *str, const char *delim);
  * Includes empty strings - i.e. two adjacent delimiters will resolve
  * to a string list element of "".
  *
- * Returns: new string list if successful, otherwise NULL.
- */
+ * @return New string list if successful, otherwise NULL.
+ **/
 struct string_list *string_separate(char *str, const char *delim);
 
+bool string_separate_noalloc(struct string_list *list, 
+      char *str, const char *delim);
+
+bool string_list_deinitialize(struct string_list *list);
+
+bool string_list_initialize(struct string_list *list);
+
 /**
  * string_list_new:
  *
  * Creates a new string list. Has to be freed manually.
  *
- * Returns: new string list if successful, otherwise NULL.
- */
+ * @return New string list if successful, otherwise NULL.
+ **/
 struct string_list *string_list_new(void);
 
 /**
@@ -117,8 +127,12 @@ struct string_list *string_list_new(void);
  * @attr             : attributes of new element.
  *
  * Appends a new element to the string list.
+
+ * Hidden non-leaf function cost:
+ * - Calls string_list_capacity()
+ * - Calls strdup
  *
- * Returns: true (1) if successful, otherwise false (0).
+ * @return true if successful, otherwise false.
  **/
 bool string_list_append(struct string_list *list, const char *elem,
       union string_list_elem_attr attr);
@@ -132,7 +146,12 @@ bool string_list_append(struct string_list *list, const char *elem,
  *
  * Appends a new element to the string list.
  *
- * Returns: true (1) if successful, otherwise false (0).
+ * Hidden non-leaf function cost:
+ * - Calls string_list_capacity()
+ * - Calls malloc
+ * - Calls strlcpy
+ *
+ * @return true if successful, otherwise false.
  **/
 bool string_list_append_n(struct string_list *list, const char *elem,
       unsigned length, union string_list_elem_attr attr);
@@ -142,7 +161,7 @@ bool string_list_append_n(struct string_list *list, const char *elem,
  * @list             : pointer to string list object
  *
  * Frees a string list.
- */
+ **/
 void string_list_free(struct string_list *list);
 
 /**
@@ -154,7 +173,13 @@ void string_list_free(struct string_list *list);
  *
  * A string list will be joined/concatenated as a
  * string to @buffer, delimited by @delim.
- */
+ *
+ * NOTE: @buffer must be NULL-terminated.
+ *
+ * Hidden non-leaf function cost:
+ * - Calls strlen_size()
+ * - Calls strlcat x times in a loop
+ **/
 void string_list_join_concat(char *buffer, size_t size,
       const struct string_list *list, const char *sep);
 
@@ -165,6 +190,10 @@ void string_list_join_concat(char *buffer, size_t size,
  * @str              : value for the element.
  *
  * Set value of element inside string list.
+ *
+ * Hidden non-leaf function cost:
+ * - Calls free
+ * - Calls strdup
  **/
 void string_list_set(struct string_list *list, unsigned idx,
       const char *str);
diff --git a/src/libretro/libretro-common/include/math/complex.h b/src/libretro/libretro-common/include/math/complex.h
index abfbfa60f5..c7f34d468a 100644
--- a/src/libretro/libretro-common/include/math/complex.h
+++ b/src/libretro/libretro-common/include/math/complex.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (complex.h).
diff --git a/src/libretro/libretro-common/include/math/float_minmax.h b/src/libretro/libretro-common/include/math/float_minmax.h
index 9d446d6196..bfd2daec3a 100644
--- a/src/libretro/libretro-common/include/math/float_minmax.h
+++ b/src/libretro/libretro-common/include/math/float_minmax.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (float_minmax.h).
diff --git a/src/libretro/libretro-common/include/math/fxp.h b/src/libretro/libretro-common/include/math/fxp.h
index b4f199ac45..895f1dcb18 100644
--- a/src/libretro/libretro-common/include/math/fxp.h
+++ b/src/libretro/libretro-common/include/math/fxp.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (fxp.h).
diff --git a/src/libretro/libretro-common/include/media/media_detect_cd.h b/src/libretro/libretro-common/include/media/media_detect_cd.h
index 9b2a9c6968..6d8194fc2e 100644
--- a/src/libretro/libretro-common/include/media/media_detect_cd.h
+++ b/src/libretro/libretro-common/include/media/media_detect_cd.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2019 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (media_detect_cd.h).
diff --git a/src/libretro/libretro-common/include/memalign.h b/src/libretro/libretro-common/include/memalign.h
index 2c07a7c053..59ffbd7439 100644
--- a/src/libretro/libretro-common/include/memalign.h
+++ b/src/libretro/libretro-common/include/memalign.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (memalign.h).
diff --git a/src/libretro/libretro-common/include/memmap.h b/src/libretro/libretro-common/include/memmap.h
index 277f9cb309..88978777c6 100644
--- a/src/libretro/libretro-common/include/memmap.h
+++ b/src/libretro/libretro-common/include/memmap.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (memmap.h).
@@ -26,7 +26,7 @@
 #include <stdio.h>
 #include <stdint.h>
 
-#if defined(__CELLOS_LV2__) || defined(PSP) || defined(PS2) || defined(GEKKO) || defined(VITA) || defined(_XBOX) || defined(_3DS) || defined(WIIU) || defined(SWITCH) || defined(HAVE_LIBNX)
+#if defined(PSP) || defined(PS2) || defined(GEKKO) || defined(VITA) || defined(_XBOX) || defined(_3DS) || defined(WIIU) || defined(SWITCH) || defined(HAVE_LIBNX) || defined(__PS3__) || defined(__PSL1GHT__)
 /* No mman available */
 #elif defined(_WIN32) && !defined(_XBOX)
 #include <windows.h>
diff --git a/src/libretro/libretro-common/include/net/net_compat.h b/src/libretro/libretro-common/include/net/net_compat.h
index 516120ab9d..3408b47672 100644
--- a/src/libretro/libretro-common/include/net/net_compat.h
+++ b/src/libretro/libretro-common/include/net/net_compat.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2022 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (net_compat.h).
@@ -20,94 +20,147 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef LIBRETRO_SDK_NETPLAY_COMPAT_H__
-#define LIBRETRO_SDK_NETPLAY_COMPAT_H__
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
+#ifndef _LIBRETRO_SDK_NET_COMPAT_H
+#define _LIBRETRO_SDK_NET_COMPAT_H
 
+#include <stdint.h>
 #include <boolean.h>
 #include <retro_inline.h>
-#include <stdint.h>
 
-#if defined(_WIN32) && !defined(_XBOX)
-#ifndef _WIN32_WINNT
-#define _WIN32_WINNT 0x0501
+#include <errno.h>
+
+#ifndef _WIN32
+#include <sys/time.h>
+#include <unistd.h>
 #endif
 
+#include <retro_common_api.h>
+
+#if defined(_WIN32) && !defined(_XBOX)
 #define WIN32_LEAN_AND_MEAN
 
 #include <winsock2.h>
 #include <windows.h>
 #include <ws2tcpip.h>
 
-#ifndef MSG_NOSIGNAL
-#define MSG_NOSIGNAL 0
+#if _MSC_VER && _MSC_VER <= 1600
+/* If we are using MSVC2010 or lower, disable WSAPoll support 
+ * to ensure Windows XP and earlier backwards compatibility */
+#else
+#ifndef WIN32_SUPPORTS_POLL
+#define WIN32_SUPPORTS_POLL 1
+#endif
 #endif
 
-#elif defined(_XBOX)
+#if defined(WIN32_SUPPORTS_POLL) && defined(_WIN32_WINNT) && _WIN32_WINNT >= 0x0600
+#define NETWORK_HAVE_POLL 1
+#endif
 
+#elif defined(_XBOX)
 #define NOD3D
+
 #include <xtl.h>
 #include <io.h>
 
-#elif defined(GEKKO)
+#ifndef SO_KEEPALIVE
+#define SO_KEEPALIVE 0 /* verify if correct */
+#endif
 
-#include <network.h>
+#define socklen_t unsigned int
 
 #elif defined(VITA)
-
 #include <psp2/net/net.h>
 #include <psp2/net/netctl.h>
 
-#define sockaddr_in SceNetSockaddrIn
-#define sockaddr SceNetSockaddr
-#define sendto sceNetSendto
-#define recvfrom sceNetRecvfrom
-#define socket(a,b,c) sceNetSocket("unknown",a,b,c)
-#define bind sceNetBind
-#define accept sceNetAccept
-#define setsockopt sceNetSetsockopt
-#define connect sceNetConnect
-#define listen sceNetListen
-#define send sceNetSend
-#define recv sceNetRecv
-#define MSG_DONTWAIT SCE_NET_MSG_DONTWAIT
-#define AF_INET SCE_NET_AF_INET
+#define NETWORK_HAVE_POLL 1
+
 #define AF_UNSPEC 0
-#define INADDR_ANY SCE_NET_INADDR_ANY
-#define INADDR_NONE 0xffffffff
+#define AF_INET SCE_NET_AF_INET
+
 #define SOCK_STREAM SCE_NET_SOCK_STREAM
 #define SOCK_DGRAM SCE_NET_SOCK_DGRAM
+
+#define INADDR_ANY SCE_NET_INADDR_ANY
+#define INADDR_NONE 0xFFFFFFFF
+
 #define SOL_SOCKET SCE_NET_SOL_SOCKET
 #define SO_REUSEADDR SCE_NET_SO_REUSEADDR
+#define SO_KEEPALIVE SCE_NET_SO_KEEPALIVE
+#define SO_BROADCAST SCE_NET_SO_BROADCAST
 #define SO_SNDBUF SCE_NET_SO_SNDBUF
+#define SO_RCVBUF SCE_NET_SO_RCVBUF
 #define SO_SNDTIMEO SCE_NET_SO_SNDTIMEO
+#define SO_RCVTIMEO SCE_NET_SO_RCVTIMEO
+#define SO_ERROR SCE_NET_SO_ERROR
 #define SO_NBIO SCE_NET_SO_NBIO
+
+#define IPPROTO_IP SCE_NET_IPPROTO_IP
+#define IP_MULTICAST_TTL SCE_NET_IP_MULTICAST_TTL
+
+#define IPPROTO_TCP SCE_NET_IPPROTO_TCP
+#define TCP_NODELAY SCE_NET_TCP_NODELAY
+
+#define IPPROTO_UDP SCE_NET_IPPROTO_UDP
+
+#define MSG_DONTWAIT SCE_NET_MSG_DONTWAIT
+
+#define POLLIN   SCE_NET_EPOLLIN
+#define POLLOUT  SCE_NET_EPOLLOUT
+#define POLLERR  SCE_NET_EPOLLERR
+#define POLLHUP  SCE_NET_EPOLLHUP
+#define POLLNVAL 0
+
+#define sockaddr SceNetSockaddr
+#define sockaddr_in SceNetSockaddrIn
+#define in_addr SceNetInAddr
+#define socklen_t unsigned int
+
+#define socket(a,b,c) sceNetSocket("unknown",a,b,c)
+#define getsockname sceNetGetsockname
+#define getsockopt sceNetGetsockopt
+#define setsockopt sceNetSetsockopt
+#define bind sceNetBind
+#define listen sceNetListen
+#define accept sceNetAccept
+#define connect sceNetConnect
+#define send sceNetSend
+#define sendto sceNetSendto
+#define recv sceNetRecv
+#define recvfrom sceNetRecvfrom
 #define htonl sceNetHtonl
 #define ntohl sceNetNtohl
 #define htons sceNetHtons
-#define socklen_t unsigned int
+#define ntohs sceNetNtohs
+#define inet_ntop sceNetInetNtop
+#define inet_pton sceNetInetPton
 
-struct hostent
-{
-	char *h_name;
-	char **h_aliases;
-	int  h_addrtype;
-	int  h_length;
-	char **h_addr_list;
-	char *h_addr;
-};
+#elif defined(GEKKO)
+#include <network.h>
 
-struct SceNetInAddr inet_aton(const char *ip_addr);
+#define NETWORK_HAVE_POLL 1
+
+#define pollfd pollsd
+
+#define socket(a,b,c) net_socket(a,b,c)
+#define getsockopt(a,b,c,d,e) net_getsockopt(a,b,c,d,e)
+#define setsockopt(a,b,c,d,e) net_setsockopt(a,b,c,d,e)
+#define bind(a,b,c) net_bind(a,b,c)
+#define listen(a,b) net_listen(a,b)
+#define accept(a,b,c) net_accept(a,b,c)
+#define connect(a,b,c) net_connect(a,b,c)
+#define send(a,b,c,d) net_send(a,b,c,d)
+#define sendto(a,b,c,d,e,f) net_sendto(a,b,c,d,e,f)
+#define recv(a,b,c,d) net_recv(a,b,c,d)
+#define recvfrom(a,b,c,d,e,f) net_recvfrom(a,b,c,d,e,f)
+#define select(a,b,c,d,e) net_select(a,b,c,d,e)
+#define gethostbyname(a) net_gethostbyname(a)
 
 #else
-#include <sys/select.h>
 #include <sys/types.h>
 #include <sys/socket.h>
-#include <netinet/in.h>
+#include <sys/select.h>
 
+#include <netinet/in.h>
 #ifndef __PSL1GHT__
 #include <netinet/tcp.h>
 #endif
@@ -116,65 +169,27 @@ struct SceNetInAddr inet_aton(const char *ip_addr);
 #include <netdb.h>
 #include <fcntl.h>
 
-#if defined(__CELLOS_LV2__) && !defined(__PSL1GHT__)
-#include <cell/sysmodule.h>
-#include <netex/net.h>
+#if !defined(__PSL1GHT__) && defined(__PS3__)
 #include <netex/libnetctl.h>
-#include <sys/timer.h>
-
-#ifndef EWOULDBLOCK
-#define EWOULDBLOCK SYS_NET_EWOULDBLOCK
-#endif
-
+#include <netex/errno.h>
 #else
 #include <signal.h>
 #endif
 
-#endif
+#if defined(__PSL1GHT__)
+#include <net/poll.h>
 
-#include <errno.h>
+#define NETWORK_HAVE_POLL 1
 
-#ifdef GEKKO
-#define sendto(s, msg, len, flags, addr, tolen) net_sendto(s, msg, len, 0, addr, 8)
-#define socket(domain, type, protocol) net_socket(domain, type, protocol)
-#define bind(s, name, namelen) net_bind(s, name, namelen)
-#define listen(s, backlog) net_listen(s, backlog)
-#define accept(s, addr, addrlen) net_accept(s, addr, addrlen)
-#define connect(s, addr, addrlen) net_connect(s, addr, addrlen)
-#define send(s, data, size, flags) net_send(s, data, size, flags)
-#define recv(s, mem, len, flags) net_recv(s, mem, len, flags)
-#define recvfrom(s, mem, len, flags, from, fromlen) net_recvfrom(s, mem, len, flags, from, fromlen)
-#define select(maxfdp1, readset, writeset, exceptset, timeout) net_select(maxfdp1, readset, writeset, exceptset, timeout)
-#endif
-
-static INLINE bool isagain(int bytes)
-{
-#if defined(_WIN32)
-   if (bytes != SOCKET_ERROR)
-      return false;
-   if (WSAGetLastError() != WSAEWOULDBLOCK)
-      return false;
-   return true;
-#elif defined(__CELLOS_LV2__) && !defined(__PSL1GHT__)
-   return (sys_net_errno == SYS_NET_EWOULDBLOCK) || (sys_net_errno == SYS_NET_EAGAIN);//35
-#elif defined(VITA)
-   return (bytes<0 && (bytes == SCE_NET_ERROR_EAGAIN || bytes == SCE_NET_ERROR_EWOULDBLOCK));
 #elif defined(WIIU)
-   return (bytes == -1) && ((socketlasterr() == SO_SUCCESS) || (socketlasterr() == SO_EWOULDBLOCK));
-#else
-   return (bytes < 0 && (errno == EAGAIN || errno == EWOULDBLOCK));
-#endif
-}
+#define WIIU_RCVBUF 0x40000
+#define WIIU_SNDBUF 0x40000
 
-#ifdef _XBOX
-#define socklen_t int
+#elif !defined(__PS3__)
+#include <poll.h>
 
-#ifndef h_addr
-#define h_addr h_addr_list[0] /* for backward compatibility */
-#endif
+#define NETWORK_HAVE_POLL 1
 
-#ifndef SO_KEEPALIVE
-#define SO_KEEPALIVE 0 /* verify if correct */
 #endif
 #endif
 
@@ -182,67 +197,225 @@ static INLINE bool isagain(int bytes)
 #define MSG_NOSIGNAL 0
 #endif
 
-#ifndef _WIN32
-#include <sys/time.h>
-#include <unistd.h>
+#if defined(AF_INET6) && !defined(HAVE_SOCKET_LEGACY) && !defined(_3DS)
+#define HAVE_INET6 1
 #endif
 
+#ifdef NETWORK_HAVE_POLL
+#ifdef GEKKO
+#define NET_POLL_FD(sockfd, sockfds)    (sockfds)->socket  = (sockfd)
+#else
+#define NET_POLL_FD(sockfd, sockfds)    (sockfds)->fd      = (sockfd)
+#endif
+#define NET_POLL_EVENT(sockev, sockfds) (sockfds)->events |= (sockev)
+#define NET_POLL_HAS_EVENT(sockev, sockfds) ((sockfds)->revents & (sockev))
+#endif
+
+RETRO_BEGIN_DECLS
+
 /* Compatibility layer for legacy or incomplete BSD socket implementations.
  * Only for IPv4. Mostly useful for the consoles which do not support
  * anything reasonably modern on the socket API side of things. */
-
 #ifdef HAVE_SOCKET_LEGACY
-
 #define sockaddr_storage sockaddr_in
-#define addrinfo addrinfo_retro__
 
+#ifdef AI_PASSIVE
+#undef AI_PASSIVE
+#endif
+#ifdef AI_CANONNAME
+#undef AI_CANONNAME
+#endif
+#ifdef AI_NUMERICHOST
+#undef AI_NUMERICHOST
+#endif
+#ifdef AI_NUMERICSERV
+#undef AI_NUMERICSERV
+#endif
+
+#ifdef NI_NUMERICHOST
+#undef NI_NUMERICHOST
+#endif
+#ifdef NI_NUMERICSERV
+#undef NI_NUMERICSERV
+#endif
+#ifdef NI_NOFQDN
+#undef NI_NOFQDN
+#endif
+#ifdef NI_NAMEREQD
+#undef NI_NAMEREQD
+#endif
+#ifdef NI_DGRAM
+#undef NI_DGRAM
+#endif
+
+#define AI_PASSIVE     1
+#define AI_CANONNAME   2
+#define AI_NUMERICHOST 4
+#define AI_NUMERICSERV 8
+
+#define NI_NUMERICHOST 1
+#define NI_NUMERICSERV 2
+#define NI_NOFQDN      4
+#define NI_NAMEREQD    8
+#define NI_DGRAM       16
+
+#ifndef __PS3__
 struct addrinfo
 {
    int ai_flags;
    int ai_family;
    int ai_socktype;
    int ai_protocol;
-   size_t ai_addrlen;
+   socklen_t ai_addrlen;
    struct sockaddr *ai_addr;
    char *ai_canonname;
    struct addrinfo *ai_next;
 };
+#endif
+
+/* gai_strerror() not used, so we skip that. */
 
+#else
+/* Ensure that getaddrinfo and getnameinfo flags are always defined. */
 #ifndef AI_PASSIVE
-#define AI_PASSIVE 1
+#define AI_PASSIVE 0
+#endif
+#ifndef AI_CANONNAME
+#define AI_CANONNAME 0
+#endif
+#ifndef AI_NUMERICHOST
+#define AI_NUMERICHOST 0
+#endif
+#ifndef AI_NUMERICSERV
+#define AI_NUMERICSERV 0
 #endif
 
-/* gai_strerror() not used, so we skip that. */
+#ifndef NI_NUMERICHOST
+#define NI_NUMERICHOST 0
+#endif
+#ifndef NI_NUMERICSERV
+#define NI_NUMERICSERV 0
+#endif
+#ifndef NI_NOFQDN
+#define NI_NOFQDN 0
+#endif
+#ifndef NI_NAMEREQD
+#define NI_NAMEREQD 0
+#endif
+#ifndef NI_DGRAM
+#define NI_DGRAM 0
+#endif
+
+#endif
+
+#if defined(_XBOX)
+struct hostent
+{
+   char *h_name;
+   char **h_aliases;
+   int  h_addrtype;
+   int  h_length;
+   char **h_addr_list;
+   char *h_addr;
+   char *h_end;
+};
+
+#elif defined(VITA)
+struct pollfd
+{
+   int fd;
+   unsigned events;
+   unsigned revents;
+   unsigned __pad; /* Align to 64-bits boundary */
+};
+
+struct hostent
+{
+   char *h_name;
+   char **h_aliases;
+   int  h_addrtype;
+   int  h_length;
+   char **h_addr_list;
+   char *h_addr;
+   char *h_end;
+};
 
 #endif
 
-uint16_t inet_htons(uint16_t hostshort);
+static INLINE bool isagain(int val)
+{
+#if defined(_WIN32)
+   return (val == SOCKET_ERROR) && (WSAGetLastError() == WSAEWOULDBLOCK);
+#elif !defined(__PSL1GHT__) && defined(__PS3__)
+   return (sys_net_errno == SYS_NET_EAGAIN) || (sys_net_errno == SYS_NET_EWOULDBLOCK);
+#elif defined(VITA)
+   return (val == SCE_NET_ERROR_EAGAIN) || (val == SCE_NET_ERROR_EWOULDBLOCK);
+#elif defined(WIIU)
+   return (val == -1) && (socketlasterr() == SO_SUCCESS || socketlasterr() == SO_EWOULDBLOCK);
+#else
+   return (val < 0) && (errno == EAGAIN || errno == EWOULDBLOCK);
+#endif
+}
 
-int inet_ptrton(int af, const char *src, void *dst);
+static INLINE bool isinprogress(int val)
+{
+#if defined(_WIN32)
+   return (val == SOCKET_ERROR) && (WSAGetLastError() == WSAEWOULDBLOCK);
+#elif !defined(__PSL1GHT__) && defined(__PS3__)
+   return (sys_net_errno == SYS_NET_EINPROGRESS);
+#elif defined(VITA)
+   return (val == SCE_NET_ERROR_EINPROGRESS);
+#elif defined(WIIU)
+   return (val == -1) && (socketlasterr() == SO_EINPROGRESS);
+#else
+   return (val < 0) && (errno == EINPROGRESS);
+#endif
+}
+
+#if defined(_WIN32) && !defined(_XBOX)
+#if !defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600
+const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
+int inet_pton(int af, const char *src, void *dst);
+#endif
+
+#elif defined(_XBOX)
+struct hostent *gethostbyname(const char *name);
+
+#elif defined(VITA)
+char *inet_ntoa(struct in_addr in);
+int inet_aton(const char *cp, struct in_addr *inp);
+uint32_t inet_addr(const char *cp);
+
+struct hostent *gethostbyname(const char *name);
+
+#elif defined(GEKKO)
+const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
+int inet_pton(int af, const char *src, void *dst);
+
+#endif
 
 int getaddrinfo_retro(const char *node, const char *service,
       struct addrinfo *hints, struct addrinfo **res);
 
 void freeaddrinfo_retro(struct addrinfo *res);
 
+int getnameinfo_retro(const struct sockaddr *addr, socklen_t addrlen,
+      char *host, socklen_t hostlen, char *serv, socklen_t servlen, int flags);
+
+bool addr_6to4(struct sockaddr_storage *addr);
+
+bool ipv4_is_lan_address(const struct sockaddr_in *addr);
+bool ipv4_is_cgnat_address(const struct sockaddr_in *addr);
+
 /**
  * network_init:
  *
  * Platform specific socket library initialization.
  *
- * Returns: true (1) if successful, otherwise false (0).
+ * @return true if successful, otherwise false.
  **/
 bool network_init(void);
 
-/**
- * network_deinit:
- *
- * Deinitialize platform specific socket libraries.
- **/
-void network_deinit(void);
-
-const char *inet_ntop_compat(int af, const void *src, char *dst, socklen_t cnt);
-
-bool udp_send_packet(const char *host, uint16_t port, const char *msg);
+RETRO_END_DECLS
 
 #endif
diff --git a/src/libretro/libretro-common/include/net/net_http.h b/src/libretro/libretro-common/include/net/net_http.h
index b19abec106..c328d4265f 100644
--- a/src/libretro/libretro-common/include/net/net_http.h
+++ b/src/libretro/libretro-common/include/net/net_http.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (net_http.h).
@@ -36,44 +36,108 @@ struct http_connection_t;
 
 struct http_connection_t *net_http_connection_new(const char *url, const char *method, const char *data);
 
+/**
+ * net_http_connection_iterate:
+ *
+ * Leaf function.
+ **/
 bool net_http_connection_iterate(struct http_connection_t *conn);
 
 bool net_http_connection_done(struct http_connection_t *conn);
 
 void net_http_connection_free(struct http_connection_t *conn);
 
-void net_http_connection_set_user_agent(struct http_connection_t* conn, const char* user_agent);
+void net_http_connection_set_user_agent(struct http_connection_t *conn, const char *user_agent);
+
+void net_http_connection_set_headers(struct http_connection_t *conn, const char *headers);
+
+void net_http_connection_set_content(struct http_connection_t *conn, const char *content_type,
+      size_t content_length, const void *content);
 
 const char *net_http_connection_url(struct http_connection_t *conn);
 
+const char* net_http_connection_method(struct http_connection_t* conn);
+
 struct http_t *net_http_new(struct http_connection_t *conn);
 
-/* You can use this to call net_http_update
- * only when something will happen; select() it for reading. */
+/**
+ * net_http_fd:
+ *
+ * Leaf function.
+ *
+ * You can use this to call net_http_update
+ * only when something will happen; select() it for reading.
+ **/
 int net_http_fd(struct http_t *state);
 
-/* Returns true if it's done, or if something broke.
- * 'total' will be 0 if it's not known. */
+/**
+ * net_http_update:
+ *
+ * @return true if it's done, or if something broke.
+ * @total will be 0 if it's not known.
+ **/
 bool net_http_update(struct http_t *state, size_t* progress, size_t* total);
 
-/* 200, 404, or whatever.  */
+/**
+ * net_http_status:
+ *
+ * Report HTTP status. 200, 404, or whatever.
+ *
+ * Leaf function.
+ * 
+ * @return HTTP status code.
+ **/
 int net_http_status(struct http_t *state);
 
+/**
+ * net_http_error:
+ *
+ * Leaf function
+ **/
 bool net_http_error(struct http_t *state);
 
-/* Returns the downloaded data. The returned buffer is owned by the
- * HTTP handler; it's freed by net_http_delete.
+/**
+ * net_http_headers:
+ *
+ * Leaf function.
+ *
+ * @return the response headers. The returned buffer is owned by the
+ * caller of net_http_new; it is not freed by net_http_delete.
+ * If the status is not 20x and accept_error is false, it returns NULL.
+ **/
+struct string_list *net_http_headers(struct http_t *state);
+
+/**
+ * net_http_data:
+ *
+ * Leaf function.
  *
- * If the status is not 20x and accept_error is false, it returns NULL. */
+ * @return the downloaded data. The returned buffer is owned by the
+ * HTTP handler; it's freed by net_http_delete.
+ * If the status is not 20x and accept_error is false, it returns NULL.
+ **/
 uint8_t* net_http_data(struct http_t *state, size_t* len, bool accept_error);
 
-/* Cleans up all memory. */
+/**
+ * net_http_delete:
+ *
+ * Cleans up all memory.
+ **/
 void net_http_delete(struct http_t *state);
 
-/* URL Encode a string */
+/**
+ * net_http_urlencode:
+ *
+ * URL Encode a string
+ * caller is responsible for deleting the destination buffer
+ **/
 void net_http_urlencode(char **dest, const char *source);
 
-/* Re-encode a full URL */
+/**
+ * net_http_urlencode_full:
+ *
+ * Re-encode a full URL
+ **/
 void net_http_urlencode_full(char *dest, const char *source, size_t size);
 
 RETRO_END_DECLS
diff --git a/src/libretro/libretro-common/include/net/net_http_parse.h b/src/libretro/libretro-common/include/net/net_http_parse.h
index 6e957d3975..279e506b1d 100644
--- a/src/libretro/libretro-common/include/net/net_http_parse.h
+++ b/src/libretro/libretro-common/include/net/net_http_parse.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (net_http.h).
@@ -43,7 +43,7 @@ RETRO_BEGIN_DECLS
  * The buffer pointed to by @link is filled with the URL path the link points to,
  * and @name is filled with the title portion of the link.
  *
- * Returns: 0 if URL was parsed completely, otherwise 1.
+ * @return 0 if URL was parsed completely, otherwise 1.
  **/
 int string_parse_html_anchor(const char *line, char *link, char *name,
       size_t link_size, size_t name_size);
diff --git a/src/libretro/libretro-common/include/net/net_ifinfo.h b/src/libretro/libretro-common/include/net/net_ifinfo.h
index 14fbf68823..0511b3fbdc 100644
--- a/src/libretro/libretro-common/include/net/net_ifinfo.h
+++ b/src/libretro/libretro-common/include/net/net_ifinfo.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2022 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (net_ifinfo.h).
@@ -20,10 +20,9 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#ifndef _LIBRETRO_NET_IFINFO_H
-#define _LIBRETRO_NET_IFINFO_H
+#ifndef _LIBRETRO_SDK_NET_IFINFO_H
+#define _LIBRETRO_SDK_NET_IFINFO_H
 
-#include <stdint.h>
 #include <stddef.h>
 
 #include <boolean.h>
@@ -34,21 +33,21 @@ RETRO_BEGIN_DECLS
 
 struct net_ifinfo_entry
 {
-   char *name;
-   char *host;
+   char name[256];
+   char host[256];
 };
 
-struct net_ifinfo
+typedef struct net_ifinfo
 {
    struct net_ifinfo_entry *entries;
    size_t size;
-};
+} net_ifinfo_t;
 
-typedef struct net_ifinfo net_ifinfo_t;
+bool net_ifinfo_new(net_ifinfo_t *list);
 
 void net_ifinfo_free(net_ifinfo_t *list);
 
-bool net_ifinfo_new(net_ifinfo_t *list);
+bool net_ifinfo_best(const char *dst, void *src, bool ipv6);
 
 RETRO_END_DECLS
 
diff --git a/src/libretro/libretro-common/include/net/net_socket.h b/src/libretro/libretro-common/include/net/net_socket.h
index 098854e658..4fa5c13fff 100644
--- a/src/libretro/libretro-common/include/net/net_socket.h
+++ b/src/libretro/libretro-common/include/net/net_socket.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2022 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (net_socket.h).
@@ -23,9 +23,11 @@
 #ifndef _LIBRETRO_SDK_NET_SOCKET_H
 #define _LIBRETRO_SDK_NET_SOCKET_H
 
+#include <stddef.h>
 #include <stdint.h>
 #include <boolean.h>
-#include <string.h>
+
+#include <net/net_compat.h>
 
 #include <retro_common_api.h>
 
@@ -58,30 +60,50 @@ typedef struct socket_target
    enum socket_protocol prot;
 } socket_target_t;
 
-int socket_init(void **address, uint16_t port, const char *server, enum socket_type type);
+int socket_init(void **address, uint16_t port, const char *server,
+      enum socket_type type, int family);
 
 int socket_next(void **address);
 
 int socket_close(int fd);
 
+bool socket_set_block(int fd, bool block);
+
+/* TODO: all callers should be converted to socket_set_block() */
 bool socket_nonblock(int fd);
 
-int socket_select(int nfds, fd_set *readfs, fd_set *writefds,
+int socket_select(int nfds, fd_set *readfds, fd_set *writefds,
       fd_set *errorfds, struct timeval *timeout);
 
-int socket_send_all_blocking(int fd, const void *data_, size_t size, bool no_signal);
+#ifdef NETWORK_HAVE_POLL
+int socket_poll(struct pollfd *fds, unsigned nfds, int timeout);
+#endif
+
+bool socket_wait(int fd, bool *rd, bool *wr, int timeout);
+
+bool socket_send_all_blocking(int fd, const void *data_, size_t size, bool no_signal);
+
+bool socket_send_all_blocking_with_timeout(int fd,
+      const void *data_, size_t size,
+      int timeout, bool no_signal);
 
 ssize_t socket_send_all_nonblocking(int fd, const void *data_, size_t size,
       bool no_signal);
 
-int socket_receive_all_blocking(int fd, void *data_, size_t size);
+bool socket_receive_all_blocking(int fd, void *data_, size_t size);
+
+bool socket_receive_all_blocking_with_timeout(int fd,
+      void *data_, size_t size,
+      int timeout);
 
 ssize_t socket_receive_all_nonblocking(int fd, bool *error,
       void *data_, size_t size);
 
 bool socket_bind(int fd, void *data);
 
-int socket_connect(int fd, void *data, bool timeout_enable);
+int socket_connect(int fd, void *data);
+
+bool socket_connect_with_timeout(int fd, void *data, int timeout);
 
 int socket_create(
       const char *name,
diff --git a/src/libretro/libretro-common/include/net/net_socket_ssl.h b/src/libretro/libretro-common/include/net/net_socket_ssl.h
index 2691a2d12d..57e2627ed6 100644
--- a/src/libretro/libretro-common/include/net/net_socket_ssl.h
+++ b/src/libretro/libretro-common/include/net/net_socket_ssl.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (net_socket.h).
diff --git a/src/libretro/libretro-common/include/playlists/label_sanitization.h b/src/libretro/libretro-common/include/playlists/label_sanitization.h
index 1e2852d7a0..63ded8c995 100644
--- a/src/libretro/libretro-common/include/playlists/label_sanitization.h
+++ b/src/libretro/libretro-common/include/playlists/label_sanitization.h
@@ -1,7 +1,7 @@
-/* Copyright  (C) 2010-2019 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
- * The following license statement only applies to this file (file_path.h).
+ * The following license statement only applies to this file (label_sanitization.h).
  * ---------------------------------------------------------------------------------------
  *
  * Permission is hereby granted, free of charge,
@@ -22,6 +22,11 @@
 #include <stddef.h>
 #include <boolean.h>
 
+/**
+ * label_sanitize:
+ *
+ * NOTE: Does not work with nested blocks.
+ **/
 void label_sanitize(char *label, bool (*left)(char*), bool (*right)(char*));
 
 void label_remove_parens(char *label);
diff --git a/src/libretro/libretro-common/include/queues/fifo_queue.h b/src/libretro/libretro-common/include/queues/fifo_queue.h
index 4e87699da8..7a27b0434e 100644
--- a/src/libretro/libretro-common/include/queues/fifo_queue.h
+++ b/src/libretro/libretro-common/include/queues/fifo_queue.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (fifo_queue.h).
@@ -29,9 +29,18 @@
 
 #include <retro_common_api.h>
 #include <retro_inline.h>
+#include <boolean.h>
 
 RETRO_BEGIN_DECLS
 
+#define FIFO_READ_AVAIL(buffer) (((buffer)->end + (((buffer)->end < (buffer)->first) ? (buffer)->size : 0)) - (buffer)->first)
+
+#define FIFO_WRITE_AVAIL(buffer) (((buffer)->size - 1) - (((buffer)->end + (((buffer)->end < (buffer)->first) ? (buffer)->size : 0)) - (buffer)->first))
+
+#define FIFO_READ_AVAIL_NONPTR(buffer) (((buffer).end + (((buffer).end < (buffer).first) ? (buffer).size : 0)) - (buffer).first)
+
+#define FIFO_WRITE_AVAIL_NONPTR(buffer) (((buffer).size - 1) - (((buffer).end + (((buffer).end < (buffer).first) ? (buffer).size : 0)) - (buffer).first))
+
 struct fifo_buffer
 {
    uint8_t *buffer;
@@ -44,6 +53,8 @@ typedef struct fifo_buffer fifo_buffer_t;
 
 fifo_buffer_t *fifo_new(size_t size);
 
+bool fifo_initialize(fifo_buffer_t *buf, size_t size);
+
 static INLINE void fifo_clear(fifo_buffer_t *buffer)
 {
    buffer->first = 0;
@@ -54,24 +65,10 @@ void fifo_write(fifo_buffer_t *buffer, const void *in_buf, size_t size);
 
 void fifo_read(fifo_buffer_t *buffer, void *in_buf, size_t size);
 
-static INLINE void fifo_free(fifo_buffer_t *buffer)
-{
-   if (!buffer)
-      return;
-
-   free(buffer->buffer);
-   free(buffer);
-}
+void fifo_free(fifo_buffer_t *buffer);
 
-static INLINE size_t fifo_read_avail(fifo_buffer_t *buffer)
-{
-   return (buffer->end + ((buffer->end < buffer->first) ? buffer->size : 0)) - buffer->first;
-}
+bool fifo_deinitialize(fifo_buffer_t *buffer);
 
-static INLINE size_t fifo_write_avail(fifo_buffer_t *buffer)
-{
-   return (buffer->size - 1) - ((buffer->end + ((buffer->end < buffer->first) ? buffer->size : 0)) - buffer->first);
-}
 
 RETRO_END_DECLS
 
diff --git a/src/libretro/libretro-common/include/queues/message_queue.h b/src/libretro/libretro-common/include/queues/message_queue.h
index 43688369d0..d79c064604 100644
--- a/src/libretro/libretro-common/include/queues/message_queue.h
+++ b/src/libretro/libretro-common/include/queues/message_queue.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (message_queue.h).
@@ -26,6 +26,7 @@
 #include <stddef.h>
 
 #include <retro_common_api.h>
+#include <boolean.h>
 
 RETRO_BEGIN_DECLS
 
@@ -42,7 +43,33 @@ enum message_queue_category
    MESSAGE_QUEUE_CATEGORY_SUCCESS
 };
 
-typedef struct msg_queue msg_queue_t;
+typedef struct queue_elem
+{
+   char *msg;
+   char *title;
+   unsigned duration;
+   unsigned prio;
+   enum message_queue_icon icon;
+   enum message_queue_category category;
+} queue_elem_t;
+
+typedef struct msg_queue
+{
+   char *tmp_msg;
+   queue_elem_t **elems;
+   size_t ptr;
+   size_t size;
+} msg_queue_t;
+
+typedef struct
+{
+   unsigned duration;
+   unsigned prio;
+   enum message_queue_icon icon;
+   enum message_queue_category category;
+   char msg[1024];
+   char title[1024];
+} msg_queue_entry_t;
 
 /**
  * msg_queue_new:
@@ -55,6 +82,8 @@ typedef struct msg_queue msg_queue_t;
  **/
 msg_queue_t *msg_queue_new(size_t size);
 
+bool msg_queue_initialize(msg_queue_t *queue, size_t size);
+
 /**
  * msg_queue_push:
  * @queue             : pointer to queue object
@@ -82,6 +111,28 @@ void msg_queue_push(msg_queue_t *queue, const char *msg,
  **/
 const char *msg_queue_pull(msg_queue_t *queue);
 
+/**
+ * msg_queue_extract:
+ * @queue             : pointer to queue object
+ * @queue_entry       : pointer to external queue entry struct
+ *
+ * Removes highest priority message from queue, copying
+ * contents into queue_entry struct.
+ *
+ * Returns: false if no messages in queue, otherwise true
+ **/
+bool msg_queue_extract(msg_queue_t *queue, msg_queue_entry_t *queue_entry);
+
+/**
+ * msg_queue_size:
+ * @queue             : pointer to queue object
+ *
+ * Fetches number of messages in queue.
+ *
+ * Returns: Number of messages in queue.
+ **/
+size_t msg_queue_size(msg_queue_t *queue);
+
 /**
  * msg_queue_clear:
  * @queue             : pointer to queue object
@@ -98,6 +149,8 @@ void msg_queue_clear(msg_queue_t *queue);
  **/
 void msg_queue_free(msg_queue_t *queue);
 
+bool msg_queue_deinitialize(msg_queue_t *queue);
+
 RETRO_END_DECLS
 
 #endif
diff --git a/src/libretro/libretro-common/include/queues/task_queue.h b/src/libretro/libretro-common/include/queues/task_queue.h
index 3e182c755e..c91d4a73ca 100644
--- a/src/libretro/libretro-common/include/queues/task_queue.h
+++ b/src/libretro/libretro-common/include/queues/task_queue.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (task_queue.h).
@@ -30,6 +30,8 @@
 #include <retro_common.h>
 #include <retro_common_api.h>
 
+#include <libretro.h>
+
 RETRO_BEGIN_DECLS
 
 enum task_type
@@ -67,6 +69,9 @@ typedef struct
 
 struct retro_task
 {
+   /* when the task should run (0 for as soon as possible) */
+   retro_time_t when;
+
    retro_task_handler_t  handler;
 
    /* always called from the main loop */
@@ -76,17 +81,6 @@ struct retro_task
     * be called immediately after running the main callback */
    retro_task_handler_t cleanup;
 
-   /* set to true by the handler to signal
-    * the task has finished executing. */
-   bool finished;
-
-   /* set to true by the task system
-    * to signal the task *must* end. */
-   bool cancelled;
-
-   /* if true no OSD messages will be displayed. */
-   bool mute;
-
    /* created by the handler, destroyed by the user */
    void *task_data;
 
@@ -100,31 +94,42 @@ struct retro_task
     * (after calling the callback) */
    char *error;
 
-   /* -1 = unmetered/indeterminate, 0-100 = current progress percentage */
-   int8_t progress;
-
    void (*progress_cb)(retro_task_t*);
 
    /* handler can modify but will be
     * free()d automatically if non-NULL. */
    char *title;
 
-   enum task_type type;
+   /* frontend userdata
+    * (e.g. associate a sticky notification to a task) */
+   void *frontend_userdata;
+
+   /* don't touch this. */
+   retro_task_t *next;
+
+   /* -1 = unmetered/indeterminate, 0-100 = current progress percentage */
+   int8_t progress;
 
    /* task identifier */
    uint32_t ident;
 
-   /* frontend userdata
-    * (e.g. associate a sticky notification to a task) */
-   void *frontend_userdata;
+   enum task_type type;
 
    /* if set to true, frontend will
    use an alternative look for the
    task progress display */
    bool alternative_look;
 
-   /* don't touch this. */
-   retro_task_t *next;
+   /* set to true by the handler to signal
+    * the task has finished executing. */
+   bool finished;
+
+   /* set to true by the task system
+    * to signal the task *must* end. */
+   bool cancelled;
+
+   /* if true no OSD messages will be displayed. */
+   bool mute;
 };
 
 typedef struct task_finder_data
@@ -141,10 +146,10 @@ typedef struct task_retriever_info
 
 typedef struct task_retriever_data
 {
+   task_retriever_info_t *list;
    retro_task_handler_t handler;
-   size_t element_size;
    retro_task_retriever_t func;
-   task_retriever_info_t *list;
+   size_t element_size;
 } task_retriever_data_t;
 
 void *task_queue_retriever_info_next(task_retriever_info_t **link);
@@ -186,6 +191,8 @@ char* task_get_title(retro_task_t *task);
 
 void* task_get_data(retro_task_t *task);
 
+bool task_is_on_main_thread(void);
+
 void task_queue_set_threaded(void);
 
 void task_queue_unset_threaded(void);
@@ -219,8 +226,8 @@ void task_queue_check(void);
  * and the task will be ignored. */
 bool task_queue_push(retro_task_t *task);
 
-/* Blocks until all tasks have finished
- * will return early if cond is not NULL
+/* Blocks until all non-scheduled tasks have finished.
+ * Will return early if cond is not NULL
  * and cond(data) returns false.
  * This must only be called from the main thread. */
 void task_queue_wait(retro_task_condition_fn_t cond, void* data);
diff --git a/src/libretro/libretro-common/include/retro_assert.h b/src/libretro/libretro-common/include/retro_assert.h
index 13db8cf8a5..79dbb32e06 100644
--- a/src/libretro/libretro-common/include/retro_assert.h
+++ b/src/libretro/libretro-common/include/retro_assert.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (retro_assert.h).
@@ -27,9 +27,7 @@
 
 #ifdef RARCH_INTERNAL
 #include <stdio.h>
-#define retro_assert(cond) do { \
-   if (!(cond)) { printf("Assertion failed at %s:%d.\n", __FILE__, __LINE__); abort(); } \
-} while(0)
+#define retro_assert(cond) ((void)( (cond) || (printf("Assertion failed at %s:%d.\n", __FILE__, __LINE__), abort(), 0) ))
 #else
 #define retro_assert(cond) assert(cond)
 #endif
diff --git a/src/libretro/libretro-common/include/retro_common.h b/src/libretro/libretro-common/include/retro_common.h
index 9a1fd5fd61..a715a28c40 100644
--- a/src/libretro/libretro-common/include/retro_common.h
+++ b/src/libretro/libretro-common/include/retro_common.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (retro_common.h).
diff --git a/src/libretro/libretro-common/include/retro_common_api.h b/src/libretro/libretro-common/include/retro_common_api.h
index fc4f745414..ebb645d8d3 100644
--- a/src/libretro/libretro-common/include/retro_common_api.h
+++ b/src/libretro/libretro-common/include/retro_common_api.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (retro_common_api.h).
@@ -89,7 +89,9 @@ typedef int ssize_t;
 /* C++11 says this one isn't needed, but apparently (some versions of) mingw require it anyways */
 /* https://stackoverflow.com/questions/8132399/how-to-printf-uint64-t-fails-with-spurious-trailing-in-format */
 /* https://github.com/libretro/RetroArch/issues/6009 */
-#define __STDC_FORMAT_MACROS
+#ifndef __STDC_FORMAT_MACROS
+#define __STDC_FORMAT_MACROS 1
+#endif
 #include <inttypes.h>
 #endif
 #ifndef PRId64
@@ -99,6 +101,26 @@ typedef int ssize_t;
 #define STRING_REP_UINT64 "%" PRIu64
 #define STRING_REP_USIZE "%" PRIuPTR
 
+/* Wrap a declaration in RETRO_DEPRECATED() to produce a compiler warning when
+it's used. This is intended for developer machines, so it won't work on ancient
+or obscure compilers */
+#if defined(_MSC_VER)
+#if _MSC_VER >= 1400 /* Visual C 2005 or later */
+#define RETRO_DEPRECATED(decl) __declspec(deprecated) decl
+#endif
+#elif defined(__GNUC__)
+#if __GNUC__ >= 3 /* GCC 3 or later */
+#define RETRO_DEPRECATED(decl) decl __attribute__((deprecated))
+#endif
+#elif defined(__clang__)
+#if __clang_major__ >= 3 /* clang 3 or later */
+#define RETRO_DEPRECATED(decl) decl __attribute__((deprecated))
+#endif
+#endif
+#ifndef RETRO_DEPRECATED /* Unsupported compilers */
+#define RETRO_DEPRECATED(decl) decl
+#endif
+
 /*
 I would like to see retro_inline.h moved in here; possibly boolean too.
 
diff --git a/src/libretro/libretro-common/include/retro_dirent.h b/src/libretro/libretro-common/include/retro_dirent.h
index 8a2591bd3a..3b041679b8 100644
--- a/src/libretro/libretro-common/include/retro_dirent.h
+++ b/src/libretro/libretro-common/include/retro_dirent.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2019 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (retro_dirent.h).
@@ -25,7 +25,6 @@
 
 #include <libretro.h>
 #include <retro_common_api.h>
-#include <retro_miscellaneous.h>
 
 #include <boolean.h>
 
diff --git a/src/libretro/libretro-common/include/retro_endianness.h b/src/libretro/libretro-common/include/retro_endianness.h
index e721ec9d4d..46984638c8 100644
--- a/src/libretro/libretro-common/include/retro_endianness.h
+++ b/src/libretro/libretro-common/include/retro_endianness.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (retro_endianness.h).
@@ -31,39 +31,97 @@
 #define SWAP16 _byteswap_ushort
 #define SWAP32 _byteswap_ulong
 #else
-#define SWAP16(x) ((uint16_t)(                  \
-         (((uint16_t)(x) & 0x00ff) << 8)      | \
-         (((uint16_t)(x) & 0xff00) >> 8)        \
-          ))
-#define SWAP32(x) ((uint32_t)(           \
-         (((uint32_t)(x) & 0x000000ff) << 24) | \
-         (((uint32_t)(x) & 0x0000ff00) <<  8) | \
-         (((uint32_t)(x) & 0x00ff0000) >>  8) | \
-         (((uint32_t)(x) & 0xff000000) >> 24)   \
-         ))
+static INLINE uint16_t SWAP16(uint16_t x)
+{
+  return ((x & 0x00ff) << 8) |
+         ((x & 0xff00) >> 8);
+}
+
+static INLINE uint32_t SWAP32(uint32_t x)
+{
+  return ((x & 0x000000ff) << 24) |
+         ((x & 0x0000ff00) <<  8) |
+         ((x & 0x00ff0000) >>  8) |
+         ((x & 0xff000000) >> 24);
+}
+
 #endif
 
 #if defined(_MSC_VER) && _MSC_VER <= 1200
-#define SWAP64(val)                                             \
-	((((uint64_t)(val) & 0x00000000000000ff) << 56)      \
-	 | (((uint64_t)(val) & 0x000000000000ff00) << 40)    \
-	 | (((uint64_t)(val) & 0x0000000000ff0000) << 24)    \
-	 | (((uint64_t)(val) & 0x00000000ff000000) << 8)     \
-	 | (((uint64_t)(val) & 0x000000ff00000000) >> 8)     \
-	 | (((uint64_t)(val) & 0x0000ff0000000000) >> 24)    \
-	 | (((uint64_t)(val) & 0x00ff000000000000) >> 40)    \
-	 | (((uint64_t)(val) & 0xff00000000000000) >> 56))
+static INLINE uint64_t SWAP64(uint64_t val)
+{
+  return
+      ((val & 0x00000000000000ff) << 56)
+    | ((val & 0x000000000000ff00) << 40)
+    | ((val & 0x0000000000ff0000) << 24)
+    | ((val & 0x00000000ff000000) << 8)
+    | ((val & 0x000000ff00000000) >> 8)
+    | ((val & 0x0000ff0000000000) >> 24)
+    | ((val & 0x00ff000000000000) >> 40)
+    | ((val & 0xff00000000000000) >> 56);
+}
+#else
+static INLINE uint64_t SWAP64(uint64_t val)
+{
+  return   ((val & 0x00000000000000ffULL) << 56)
+	 | ((val & 0x000000000000ff00ULL) << 40)
+	 | ((val & 0x0000000000ff0000ULL) << 24)
+	 | ((val & 0x00000000ff000000ULL) << 8)
+	 | ((val & 0x000000ff00000000ULL) >> 8)
+	 | ((val & 0x0000ff0000000000ULL) >> 24)
+	 | ((val & 0x00ff000000000000ULL) >> 40)
+         | ((val & 0xff00000000000000ULL) >> 56);
+}
+#endif
+
+#ifdef _MSC_VER
+/* MSVC pre-defines macros depending on target arch */
+#if defined (_M_IX86) || defined (_M_AMD64) || defined (_M_ARM) || defined (_M_ARM64)
+#ifndef LSB_FIRST
+#define LSB_FIRST 1
+#endif
+#elif _M_PPC
+#ifndef MSB_FIRST
+#define MSB_FIRST 1
+#endif
 #else
-#define SWAP64(val)                                             \
-	((((uint64_t)(val) & 0x00000000000000ffULL) << 56)      \
-	 | (((uint64_t)(val) & 0x000000000000ff00ULL) << 40)    \
-	 | (((uint64_t)(val) & 0x0000000000ff0000ULL) << 24)    \
-	 | (((uint64_t)(val) & 0x00000000ff000000ULL) << 8)     \
-	 | (((uint64_t)(val) & 0x000000ff00000000ULL) >> 8)     \
-	 | (((uint64_t)(val) & 0x0000ff0000000000ULL) >> 24)    \
-	 | (((uint64_t)(val) & 0x00ff000000000000ULL) >> 40)    \
-	 | (((uint64_t)(val) & 0xff00000000000000ULL) >> 56))
+/* MSVC can run on _M_ALPHA and _M_IA64 too, but they're both bi-endian; need to find what mode MSVC runs them at */
+#error "unknown platform, can't determine endianness"
 #endif
+#else
+#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#ifndef MSB_FIRST
+#define MSB_FIRST 1
+#endif
+#elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+#ifndef LSB_FIRST
+#define LSB_FIRST 1
+#endif
+#else
+#error "Invalid endianness macros"
+#endif
+#endif
+
+#if defined(MSB_FIRST) && defined(LSB_FIRST)
+#  error "Bug in LSB_FIRST/MSB_FIRST definition"
+#endif
+
+#if !defined(MSB_FIRST) && !defined(LSB_FIRST)
+#  error "Bug in LSB_FIRST/MSB_FIRST definition"
+#endif
+
+#ifdef MSB_FIRST
+#  define RETRO_IS_BIG_ENDIAN 1
+#  define RETRO_IS_LITTLE_ENDIAN 0
+/* For compatibility */
+#  define WORDS_BIGENDIAN 1
+#else
+#  define RETRO_IS_BIG_ENDIAN 0
+#  define RETRO_IS_LITTLE_ENDIAN 1
+/* For compatibility */
+#  undef WORDS_BIGENDIAN
+#endif
+
 
 /**
  * is_little_endian:
@@ -73,23 +131,7 @@
  * Returns: greater than 0 if little-endian,
  * otherwise big-endian.
  **/
-#if defined(MSB_FIRST)
-#define is_little_endian() (0)
-#elif defined(__x86_64) || defined(__i386) || defined(_M_IX86) || defined(_M_X64)
-#define is_little_endian() (1)
-#else
-static INLINE uint8_t is_little_endian(void)
-{
-   union
-   {
-      uint16_t x;
-      uint8_t y[2];
-   } u;
-
-   u.x = 1;
-   return u.y[0];
-}
-#endif
+#define is_little_endian() RETRO_IS_LITTLE_ENDIAN
 
 /**
  * swap_if_big64:
@@ -101,17 +143,10 @@ static INLINE uint8_t is_little_endian(void)
  * otherwise returns same value.
  **/
 
-#if defined(MSB_FIRST)
+#if RETRO_IS_BIG_ENDIAN
 #define swap_if_big64(val) (SWAP64(val))
-#elif defined(__x86_64) || defined(__i386) || defined(_M_IX86) || defined(_M_X64)
+#elif RETRO_IS_LITTLE_ENDIAN
 #define swap_if_big64(val) (val)
-#else
-static INLINE uint64_t swap_if_big64(uint64_t val)
-{
-   if (is_little_endian())
-      return val;
-   return SWAP64(val);
-}
 #endif
 
 /**
@@ -124,17 +159,10 @@ static INLINE uint64_t swap_if_big64(uint64_t val)
  * otherwise returns same value.
  **/
 
-#if defined(MSB_FIRST)
+#if RETRO_IS_BIG_ENDIAN
 #define swap_if_big32(val) (SWAP32(val))
-#elif defined(__x86_64) || defined(__i386) || defined(_M_IX86) || defined(_M_X64)
+#elif RETRO_IS_LITTLE_ENDIAN
 #define swap_if_big32(val) (val)
-#else
-static INLINE uint32_t swap_if_big32(uint32_t val)
-{
-   if (is_little_endian())
-      return val;
-   return SWAP32(val);
-}
 #endif
 
 /**
@@ -147,17 +175,10 @@ static INLINE uint32_t swap_if_big32(uint32_t val)
  * otherwise returns same value.
  **/
 
-#if defined(MSB_FIRST)
+#if RETRO_IS_BIG_ENDIAN
 #define swap_if_little64(val) (val)
-#elif defined(__x86_64) || defined(__i386) || defined(_M_IX86) || defined(_M_X64)
+#elif RETRO_IS_LITTLE_ENDIAN
 #define swap_if_little64(val) (SWAP64(val))
-#else
-static INLINE uint64_t swap_if_little64(uint64_t val)
-{
-   if (is_little_endian())
-      return SWAP64(val);
-   return val;
-}
 #endif
 
 /**
@@ -170,17 +191,10 @@ static INLINE uint64_t swap_if_little64(uint64_t val)
  * otherwise returns same value.
  **/
 
-#if defined(MSB_FIRST)
+#if RETRO_IS_BIG_ENDIAN
 #define swap_if_little32(val) (val)
-#elif defined(__x86_64) || defined(__i386) || defined(_M_IX86) || defined(_M_X64)
+#elif RETRO_IS_LITTLE_ENDIAN
 #define swap_if_little32(val) (SWAP32(val))
-#else
-static INLINE uint32_t swap_if_little32(uint32_t val)
-{
-   if (is_little_endian())
-      return SWAP32(val);
-   return val;
-}
 #endif
 
 /**
@@ -193,17 +207,10 @@ static INLINE uint32_t swap_if_little32(uint32_t val)
  * otherwise returns same value.
  **/
 
-#if defined(MSB_FIRST)
+#if RETRO_IS_BIG_ENDIAN
 #define swap_if_big16(val) (SWAP16(val))
-#elif defined(__x86_64) || defined(__i386) || defined(_M_IX86) || defined(_M_X64)
+#elif RETRO_IS_LITTLE_ENDIAN
 #define swap_if_big16(val) (val)
-#else
-static INLINE uint16_t swap_if_big16(uint16_t val)
-{
-   if (is_little_endian())
-      return val;
-   return SWAP16(val);
-}
 #endif
 
 /**
@@ -216,17 +223,10 @@ static INLINE uint16_t swap_if_big16(uint16_t val)
  * otherwise returns same value.
  **/
 
-#if defined(MSB_FIRST)
+#if RETRO_IS_BIG_ENDIAN
 #define swap_if_little16(val) (val)
-#elif defined(__x86_64) || defined(__i386) || defined(_M_IX86) || defined(_M_X64)
+#elif RETRO_IS_LITTLE_ENDIAN
 #define swap_if_little16(val) (SWAP16(val))
-#else
-static INLINE uint16_t swap_if_little16(uint16_t val)
-{
-   if (is_little_endian())
-      return SWAP16(val);
-   return val;
-}
 #endif
 
 /**
@@ -255,4 +255,326 @@ static INLINE uint32_t load32be(const uint32_t *addr)
    return swap_if_little32(*addr);
 }
 
+/**
+ * retro_cpu_to_le16:
+ * @val        : unsigned 16-bit value
+ *
+ * Convert unsigned 16-bit value from system to little-endian.
+ *
+ * Returns: Little-endian representation of val.
+ **/
+
+#define retro_cpu_to_le16(val) swap_if_big16(val)
+
+/**
+ * retro_cpu_to_le32:
+ * @val        : unsigned 32-bit value
+ *
+ * Convert unsigned 32-bit value from system to little-endian.
+ *
+ * Returns: Little-endian representation of val.
+ **/
+
+#define retro_cpu_to_le32(val) swap_if_big32(val)
+
+/**
+ * retro_cpu_to_le64:
+ * @val        : unsigned 64-bit value
+ *
+ * Convert unsigned 64-bit value from system to little-endian.
+ *
+ * Returns: Little-endian representation of val.
+ **/
+
+#define retro_cpu_to_le64(val) swap_if_big64(val)
+
+/**
+ * retro_le_to_cpu16:
+ * @val        : unsigned 16-bit value
+ *
+ * Convert unsigned 16-bit value from little-endian to native.
+ *
+ * Returns: Native representation of little-endian val.
+ **/
+
+#define retro_le_to_cpu16(val) swap_if_big16(val)
+
+/**
+ * retro_le_to_cpu32:
+ * @val        : unsigned 32-bit value
+ *
+ * Convert unsigned 32-bit value from little-endian to native.
+ *
+ * Returns: Native representation of little-endian val.
+ **/
+
+#define retro_le_to_cpu32(val) swap_if_big32(val)
+
+/**
+ * retro_le_to_cpu16:
+ * @val        : unsigned 64-bit value
+ *
+ * Convert unsigned 64-bit value from little-endian to native.
+ *
+ * Returns: Native representation of little-endian val.
+ **/
+
+#define retro_le_to_cpu64(val) swap_if_big64(val)
+
+/**
+ * retro_cpu_to_be16:
+ * @val        : unsigned 16-bit value
+ *
+ * Convert unsigned 16-bit value from system to big-endian.
+ *
+ * Returns: Big-endian representation of val.
+ **/
+
+#define retro_cpu_to_be16(val) swap_if_little16(val)
+
+/**
+ * retro_cpu_to_be32:
+ * @val        : unsigned 32-bit value
+ *
+ * Convert unsigned 32-bit value from system to big-endian.
+ *
+ * Returns: Big-endian representation of val.
+ **/
+
+#define retro_cpu_to_be32(val) swap_if_little32(val)
+
+/**
+ * retro_cpu_to_be64:
+ * @val        : unsigned 64-bit value
+ *
+ * Convert unsigned 64-bit value from system to big-endian.
+ *
+ * Returns: Big-endian representation of val.
+ **/
+
+#define retro_cpu_to_be64(val) swap_if_little64(val)
+
+/**
+ * retro_be_to_cpu16:
+ * @val        : unsigned 16-bit value
+ *
+ * Convert unsigned 16-bit value from big-endian to native.
+ *
+ * Returns: Native representation of big-endian val.
+ **/
+
+#define retro_be_to_cpu16(val) swap_if_little16(val)
+
+/**
+ * retro_be_to_cpu32:
+ * @val        : unsigned 32-bit value
+ *
+ * Convert unsigned 32-bit value from big-endian to native.
+ *
+ * Returns: Native representation of big-endian val.
+ **/
+
+#define retro_be_to_cpu32(val) swap_if_little32(val)
+
+/**
+ * retro_be_to_cpu64:
+ * @val        : unsigned 64-bit value
+ *
+ * Convert unsigned 64-bit value from big-endian to native.
+ *
+ * Returns: Native representation of big-endian val.
+ **/
+
+#define retro_be_to_cpu64(val) swap_if_little64(val)
+
+#ifdef  __GNUC__
+/* This attribute means that the same memory may be referred through
+   pointers to different size of the object (aliasing). E.g. that u8 *
+   and u32 * may actually be pointing to the same object.  */
+#define MAY_ALIAS  __attribute__((__may_alias__))
+#else
+#define MAY_ALIAS
+#endif
+
+#pragma pack(push, 1)
+struct retro_unaligned_uint16_s
+{
+  uint16_t val;
+} MAY_ALIAS;
+struct retro_unaligned_uint32_s
+{
+  uint32_t val;
+} MAY_ALIAS;
+struct retro_unaligned_uint64_s
+{
+  uint64_t val;
+} MAY_ALIAS;
+#pragma pack(pop)
+
+typedef struct retro_unaligned_uint16_s retro_unaligned_uint16_t;
+typedef struct retro_unaligned_uint32_s retro_unaligned_uint32_t;
+typedef struct retro_unaligned_uint64_s retro_unaligned_uint64_t;
+
+/* L-value references to unaligned pointers.  */
+#define retro_unaligned16(p) (((retro_unaligned_uint16_t *)p)->val)
+#define retro_unaligned32(p) (((retro_unaligned_uint32_t *)p)->val)
+#define retro_unaligned64(p) (((retro_unaligned_uint64_t *)p)->val)
+
+/**
+ * retro_get_unaligned_16be:
+ * @addr        : pointer to unsigned 16-bit value
+ *
+ * Convert unsigned unaligned 16-bit value from big-endian to native.
+ *
+ * Returns: Native representation of big-endian val.
+ **/
+
+static INLINE uint16_t retro_get_unaligned_16be(void *addr) {
+  return retro_be_to_cpu16(retro_unaligned16(addr));
+}
+
+/**
+ * retro_get_unaligned_32be:
+ * @addr        : pointer to unsigned 32-bit value
+ *
+ * Convert unsigned unaligned 32-bit value from big-endian to native.
+ *
+ * Returns: Native representation of big-endian val.
+ **/
+
+static INLINE uint32_t retro_get_unaligned_32be(void *addr) {
+  return retro_be_to_cpu32(retro_unaligned32(addr));
+}
+
+/**
+ * retro_get_unaligned_64be:
+ * @addr        : pointer to unsigned 64-bit value
+ *
+ * Convert unsigned unaligned 64-bit value from big-endian to native.
+ *
+ * Returns: Native representation of big-endian val.
+ **/
+
+static INLINE uint64_t retro_get_unaligned_64be(void *addr) {
+  return retro_be_to_cpu64(retro_unaligned64(addr));
+}
+
+/**
+ * retro_get_unaligned_16le:
+ * @addr        : pointer to unsigned 16-bit value
+ *
+ * Convert unsigned unaligned 16-bit value from little-endian to native.
+ *
+ * Returns: Native representation of little-endian val.
+ **/
+
+static INLINE uint16_t retro_get_unaligned_16le(void *addr) {
+  return retro_le_to_cpu16(retro_unaligned16(addr));
+}
+
+/**
+ * retro_get_unaligned_32le:
+ * @addr        : pointer to unsigned 32-bit value
+ *
+ * Convert unsigned unaligned 32-bit value from little-endian to native.
+ *
+ * Returns: Native representation of little-endian val.
+ **/
+
+static INLINE uint32_t retro_get_unaligned_32le(void *addr) {
+  return retro_le_to_cpu32(retro_unaligned32(addr));
+}
+
+/**
+ * retro_get_unaligned_64le:
+ * @addr        : pointer to unsigned 64-bit value
+ *
+ * Convert unsigned unaligned 64-bit value from little-endian to native.
+ *
+ * Returns: Native representation of little-endian val.
+ **/
+
+static INLINE uint64_t retro_get_unaligned_64le(void *addr) {
+  return retro_le_to_cpu64(retro_unaligned64(addr));
+}
+
+/**
+ * retro_set_unaligned_16le:
+ * @addr        : pointer to unsigned 16-bit value
+ * @val         : value to store
+ *
+ * Convert native value to unsigned unaligned 16-bit little-endian value
+ *
+ **/
+
+static INLINE void retro_set_unaligned_16le(void *addr, uint16_t v) {
+  retro_unaligned16(addr) = retro_cpu_to_le16(v);
+}
+
+/**
+ * retro_set_unaligned_32le:
+ * @addr        : pointer to unsigned 32-bit value
+ * @val         : value to store
+ *
+ * Convert native value to unsigned unaligned 32-bit little-endian value
+ *
+ **/
+
+static INLINE void retro_set_unaligned_32le(void *addr, uint32_t v) {
+  retro_unaligned32(addr) = retro_cpu_to_le32(v);
+}
+
+/**
+ * retro_set_unaligned_32le:
+ * @addr        : pointer to unsigned 32-bit value
+ * @val         : value to store
+ *
+ * Convert native value to unsigned unaligned 32-bit little-endian value
+ *
+ **/
+
+static INLINE void retro_set_unaligned_64le(void *addr, uint64_t v) {
+  retro_unaligned64(addr) = retro_cpu_to_le64(v);
+}
+
+/**
+ * retro_set_unaligned_16be:
+ * @addr        : pointer to unsigned 16-bit value
+ * @val         : value to store
+ *
+ * Convert native value to unsigned unaligned 16-bit big-endian value
+ *
+ **/
+
+static INLINE void retro_set_unaligned_16be(void *addr, uint16_t v) {
+  retro_unaligned16(addr) = retro_cpu_to_be16(v);
+}
+
+/**
+ * retro_set_unaligned_32be:
+ * @addr        : pointer to unsigned 32-bit value
+ * @val         : value to store
+ *
+ * Convert native value to unsigned unaligned 32-bit big-endian value
+ *
+ **/
+
+static INLINE void retro_set_unaligned_32be(void *addr, uint32_t v) {
+  retro_unaligned32(addr) = retro_cpu_to_be32(v);
+}
+
+/**
+ * retro_set_unaligned_32be:
+ * @addr        : pointer to unsigned 32-bit value
+ * @val         : value to store
+ *
+ * Convert native value to unsigned unaligned 32-bit big-endian value
+ *
+ **/
+
+static INLINE void retro_set_unaligned_64be(void *addr, uint64_t v) {
+  retro_unaligned64(addr) = retro_cpu_to_be64(v);
+}
+
+
 #endif
diff --git a/src/libretro/libretro-common/include/retro_environment.h b/src/libretro/libretro-common/include/retro_environment.h
index 4a68046b51..1389eb5c03 100644
--- a/src/libretro/libretro-common/include/retro_environment.h
+++ b/src/libretro/libretro-common/include/retro_environment.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (retro_environment.h).
diff --git a/src/libretro/libretro-common/include/retro_inline.h b/src/libretro/libretro-common/include/retro_inline.h
index e4a21f6c41..b27d6dd6d4 100644
--- a/src/libretro/libretro-common/include/retro_inline.h
+++ b/src/libretro/libretro-common/include/retro_inline.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (retro_inline.h).
diff --git a/src/libretro/libretro-common/include/retro_math.h b/src/libretro/libretro-common/include/retro_math.h
index 03d31dd546..d1cb86294d 100644
--- a/src/libretro/libretro-common/include/retro_math.h
+++ b/src/libretro/libretro-common/include/retro_math.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (retro_math.h).
@@ -91,4 +91,100 @@ static INLINE uint32_t prev_pow2(uint32_t v)
    return v - (v >> 1);
 }
 
+/**
+ * clamp:
+ * @v         : initial value
+ *
+ * Get the clamped value based on initial value.
+ *
+ * Returns: clamped value (derived from @v).
+ **/
+static INLINE float clamp_value(float v, float min, float max)
+{
+   return v <= min ? min : v >= max ? max : v;
+}
+
+/**
+ * saturate_value:
+ * @v         : initial value
+ *
+ * Get the clamped 0.0-1.0 value based on initial value.
+ *
+ * Returns: clamped 0.0-1.0 value (derived from @v).
+ **/
+static INLINE float saturate_value(float v)
+{
+   return clamp_value(v, 0.0f, 1.0f);
+}
+
+/**
+ * dot_product:
+ * @a         : left hand vector value
+ * @b         : right hand vector value
+ *
+ * Get the dot product of the two passed in vectors.
+ *
+ * Returns: dot product value (derived from @a and @b).
+ **/
+static INLINE float dot_product(const float* a, const float* b) 
+{
+   return (a[0] * b[0]) + (a[1] * b[1]) + (a[2] * b[2]);
+}
+
+/**
+ * convert_rgb_to_yxy:
+ * @rgb         : in RGB colour space value
+ * @Yxy         : out Yxy colour space value
+ *
+ * Convert from RGB colour space to Yxy colour space.
+ *
+ * Returns: Yxy colour space value (derived from @rgb).
+ **/
+static INLINE void convert_rgb_to_yxy(const float* rgb, float* Yxy) 
+{
+   float inv;
+   float xyz[3];
+   float one[3]        = {1.0, 1.0, 1.0};
+   float rgb_xyz[3][3] = {
+      {0.4124564, 0.3575761, 0.1804375},
+      {0.2126729, 0.7151522, 0.0721750},
+      {0.0193339, 0.1191920, 0.9503041}
+   };
+
+   xyz[0]              = dot_product(rgb_xyz[0], rgb);
+   xyz[1]              = dot_product(rgb_xyz[1], rgb);
+   xyz[2]              = dot_product(rgb_xyz[2], rgb);
+
+   inv                 = 1.0f / dot_product(xyz, one);
+   Yxy[0]              = xyz[1]; 
+   Yxy[1]              = xyz[0] * inv;
+   Yxy[2]              = xyz[1] * inv;
+}
+ 
+/**
+ * convert_yxy_to_rgb:
+ * @rgb         : in Yxy colour space value
+ * @Yxy         : out rgb colour space value
+ *
+ * Convert from Yxy colour space to rgb colour space.
+ *
+ * Returns: rgb colour space value (derived from @Yxy).
+ **/
+static INLINE void convert_yxy_to_rgb(const float* Yxy, float* rgb)
+{
+   float xyz[3];
+   float xyz_rgb[3][3] = {
+      {3.2404542, -1.5371385, -0.4985314},
+      {-0.9692660, 1.8760108,  0.0415560},
+      {0.0556434, -0.2040259, 1.0572252}
+   };
+   xyz[0]              = Yxy[0] * Yxy[1] / Yxy[2];
+   xyz[1]              = Yxy[0];
+   xyz[2]              = Yxy[0] * (1.0 - Yxy[1] - Yxy[2]) / Yxy[2];
+
+   rgb[0]              = dot_product(xyz_rgb[0], xyz);
+   rgb[1]              = dot_product(xyz_rgb[1], xyz);
+   rgb[2]              = dot_product(xyz_rgb[2], xyz);
+}
+
 #endif
diff --git a/src/libretro/libretro-common/include/retro_miscellaneous.h b/src/libretro/libretro-common/include/retro_miscellaneous.h
index 3893416ee4..953ab18600 100644
--- a/src/libretro/libretro-common/include/retro_miscellaneous.h
+++ b/src/libretro/libretro-common/include/retro_miscellaneous.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (retro_miscellaneous.h).
@@ -30,17 +30,17 @@
 #include <boolean.h>
 #include <retro_inline.h>
 
-#if defined(_WIN32) && !defined(_XBOX)
+#if defined(_WIN32)
+
+#if defined(_XBOX)
+#include <Xtl.h>
+#else
 #ifndef WIN32_LEAN_AND_MEAN
 #define WIN32_LEAN_AND_MEAN
 #endif
 #include <windows.h>
-#elif defined(_WIN32) && defined(_XBOX)
-#include <Xtl.h>
 #endif
 
-#if defined(__CELLOS_LV2__)
-#include <sys/fs_external.h>
 #endif
 
 #include <limits.h>
@@ -49,6 +49,10 @@
 #include <compat/msvc.h>
 #endif
 
+#ifdef IOS
+#include <sys/param.h>
+#endif
+
 static INLINE void bits_or_bits(uint32_t *a, uint32_t *b, uint32_t count)
 {
    uint32_t i;
@@ -74,16 +78,29 @@ static INLINE bool bits_any_set(uint32_t* ptr, uint32_t count)
    return false;
 }
 
+static INLINE bool bits_any_different(uint32_t *a, uint32_t *b, uint32_t count)
+{
+   uint32_t i;
+   for (i = 0; i < count; i++)
+   {
+      if (a[i] != b[i])
+         return true;
+   }
+   return false;
+}
+
 #ifndef PATH_MAX_LENGTH
-#if defined(__CELLOS_LV2__)
-#define PATH_MAX_LENGTH CELL_FS_MAX_FS_PATH_LENGTH
-#elif defined(_XBOX1) || defined(_3DS) || defined(PSP) || defined(PS2) || defined(GEKKO)|| defined(WIIU) || defined(ORBIS)
+#if defined(_XBOX1) || defined(_3DS) || defined(PSP) || defined(PS2) || defined(GEKKO)|| defined(WIIU) || defined(__PSL1GHT__) || defined(__PS3__)
 #define PATH_MAX_LENGTH 512
 #else
 #define PATH_MAX_LENGTH 4096
 #endif
 #endif
 
+#ifndef NAME_MAX_LENGTH
+#define NAME_MAX_LENGTH 256
+#endif
+
 #ifndef MAX
 #define MAX(a, b) ((a) > (b) ? (a) : (b))
 #endif
@@ -106,8 +123,8 @@ static INLINE bool bits_any_set(uint32_t* ptr, uint32_t count)
 #define BIT16_GET(a, bit)    (((a) >> ((bit) & 15)) & 1)
 #define BIT16_CLEAR_ALL(a)   ((a) = 0)
 
-#define BIT32_SET(a, bit)    ((a) |=  (1 << ((bit) & 31)))
-#define BIT32_CLEAR(a, bit)  ((a) &= ~(1 << ((bit) & 31)))
+#define BIT32_SET(a, bit)    ((a) |=  (UINT32_C(1) << ((bit) & 31)))
+#define BIT32_CLEAR(a, bit)  ((a) &= ~(UINT32_C(1) << ((bit) & 31)))
 #define BIT32_GET(a, bit)    (((a) >> ((bit) & 31)) & 1)
 #define BIT32_CLEAR_ALL(a)   ((a) = 0)
 
@@ -116,8 +133,8 @@ static INLINE bool bits_any_set(uint32_t* ptr, uint32_t count)
 #define BIT64_GET(a, bit)    (((a) >> ((bit) & 63)) & 1)
 #define BIT64_CLEAR_ALL(a)   ((a) = 0)
 
-#define BIT128_SET(a, bit)   ((a).data[(bit) >> 5] |=  (1 << ((bit) & 31)))
-#define BIT128_CLEAR(a, bit) ((a).data[(bit) >> 5] &= ~(1 << ((bit) & 31)))
+#define BIT128_SET(a, bit)   ((a).data[(bit) >> 5] |=  (UINT32_C(1) << ((bit) & 31)))
+#define BIT128_CLEAR(a, bit) ((a).data[(bit) >> 5] &= ~(UINT32_C(1) << ((bit) & 31)))
 #define BIT128_GET(a, bit)   (((a).data[(bit) >> 5] >> ((bit) & 31)) & 1)
 #define BIT128_CLEAR_ALL(a)  memset(&(a), 0, sizeof(a))
 
@@ -136,6 +153,16 @@ static INLINE bool bits_any_set(uint32_t* ptr, uint32_t count)
 #define BIT256_GET_PTR(a, bit)   BIT256_GET(*a, bit)
 #define BIT256_CLEAR_ALL_PTR(a)  BIT256_CLEAR_ALL(*a)
 
+#define BIT512_SET(a, bit)       BIT256_SET(a, bit)
+#define BIT512_CLEAR(a, bit)     BIT256_CLEAR(a, bit)
+#define BIT512_GET(a, bit)       BIT256_GET(a, bit)
+#define BIT512_CLEAR_ALL(a)      BIT256_CLEAR_ALL(a)
+
+#define BIT512_SET_PTR(a, bit)   BIT512_SET(*a, bit)
+#define BIT512_CLEAR_PTR(a, bit) BIT512_CLEAR(*a, bit)
+#define BIT512_GET_PTR(a, bit)   BIT512_GET(*a, bit)
+#define BIT512_CLEAR_ALL_PTR(a)  BIT512_CLEAR_ALL(*a)
+
 #define BITS_COPY16_PTR(a,bits) \
 { \
    BIT128_CLEAR_ALL_PTR(a); \
@@ -148,6 +175,13 @@ static INLINE bool bits_any_set(uint32_t* ptr, uint32_t count)
    BITS_GET_ELEM_PTR(a, 0) = (bits); \
 }
 
+#define BITS_COPY64_PTR(a,bits) \
+{ \
+   BIT128_CLEAR_ALL_PTR(a); \
+   BITS_GET_ELEM_PTR(a, 0) = (bits); \
+   BITS_GET_ELEM_PTR(a, 1) = (bits >> 32); \
+}
+
 /* Helper macros and struct to keep track of many booleans. */
 /* This struct has 256 bits. */
 typedef struct
@@ -155,6 +189,12 @@ typedef struct
    uint32_t data[8];
 } retro_bits_t;
 
+/* This struct has 512 bits. */
+typedef struct
+{
+   uint32_t data[16];
+} retro_bits_512_t;
+
 #ifdef _WIN32
 #  ifdef _WIN64
 #    define PRI_SIZET PRIu64
@@ -165,7 +205,7 @@ typedef struct
 #      define PRI_SIZET "u"
 #    endif
 #  endif
-#elif PS2
+#elif defined(PS2)
 #  define PRI_SIZET "u"
 #else
 #  if (SIZE_MAX == 0xFFFF)
diff --git a/src/libretro/libretro-common/include/retro_timers.h b/src/libretro/libretro-common/include/retro_timers.h
index 884c078942..00e059e290 100644
--- a/src/libretro/libretro-common/include/retro_timers.h
+++ b/src/libretro/libretro-common/include/retro_timers.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (retro_timers.h).
@@ -25,10 +25,10 @@
 
 #include <stdint.h>
 
-#if defined(__CELLOS_LV2__) && !defined(__PSL1GHT__)
-#include <sys/timer.h>
-#elif defined(XENON)
+#if defined(XENON)
 #include <time/time.h>
+#elif !defined(__PSL1GHT__) && defined(__PS3__)
+#include <sys/timer.h>
 #elif defined(GEKKO) || defined(__PSL1GHT__) || defined(__QNX__)
 #include <unistd.h>
 #elif defined(WIIU)
@@ -37,10 +37,10 @@
 #include <pspthreadman.h>
 #elif defined(VITA)
 #include <psp2/kernel/threadmgr.h>
-#elif defined(PS2)
-#include <SDL/SDL_timer.h>
 #elif defined(_3DS)
 #include <3ds.h>
+#elif defined(EMSCRIPTEN)
+#include <emscripten/emscripten.h>
 #else
 #include <time.h>
 #endif
@@ -68,7 +68,7 @@ extern int nanosleep(const struct timespec *rqtp, struct timespec *rmtp);
 
 static int nanosleepDOS(const struct timespec *rqtp, struct timespec *rmtp)
 {
-   usleep(1000000 * rqtp->tv_sec + rqtp->tv_nsec / 1000);
+   usleep(1000000L * rqtp->tv_sec + rqtp->tv_nsec / 1000);
 
    if (rmtp)
       rmtp->tv_sec = rmtp->tv_nsec=0;
@@ -85,32 +85,32 @@ static int nanosleepDOS(const struct timespec *rqtp, struct timespec *rmtp)
  *
  * Sleeps for a specified amount of milliseconds (@msec).
  **/
-static INLINE void retro_sleep(unsigned msec)
-{
-#if defined(__CELLOS_LV2__) && !defined(__PSL1GHT__)
-   sys_timer_usleep(1000 * msec);
-#elif defined(PSP) || defined(VITA)
-   sceKernelDelayThread(1000 * msec);
-#elif defined(PS2)
-   SDL_Delay(msec);
+#if defined(VITA)
+#define retro_sleep(msec) (sceKernelDelayThread(1000 * (msec)))
 #elif defined(_3DS)
-   svcSleepThread(1000000 * (s64)msec);
+#define retro_sleep(msec) (svcSleepThread(1000000 * (s64)(msec)))
 #elif defined(__WINRT__) || defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
-   SleepEx(msec, FALSE);
+#define retro_sleep(msec) (SleepEx((msec), FALSE))
 #elif defined(_WIN32)
-   Sleep(msec);
+#define retro_sleep(msec) (Sleep((msec)))
 #elif defined(XENON)
-   udelay(1000 * msec);
+#define retro_sleep(msec) (udelay(1000 * (msec)))
+#elif !defined(__PSL1GHT__) && defined(__PS3__)
+#define retro_sleep(msec) (sys_timer_usleep(1000 * (msec)))
 #elif defined(GEKKO) || defined(__PSL1GHT__) || defined(__QNX__)
-   usleep(1000 * msec);
+#define retro_sleep(msec) (usleep(1000 * (msec)))
 #elif defined(WIIU)
-   OSSleepTicks(ms_to_ticks(msec));
+#define retro_sleep(msec) (OSSleepTicks(ms_to_ticks((msec))))
+#elif defined(EMSCRIPTEN)
+#define retro_sleep(msec) (emscripten_sleep(msec))
 #else
-   struct timespec tv = {0};
-   tv.tv_sec = msec / 1000;
-   tv.tv_nsec = (msec % 1000) * 1000000;
+static INLINE void retro_sleep(unsigned msec)
+{
+   struct timespec tv;
+   tv.tv_sec          = msec / 1000;
+   tv.tv_nsec         = (msec % 1000) * 1000000;
    nanosleep(&tv, NULL);
-#endif
 }
+#endif
 
 #endif
diff --git a/src/libretro/libretro-common/include/rthreads/async_job.h b/src/libretro/libretro-common/include/rthreads/async_job.h
index d98742b479..aa081d76b8 100644
--- a/src/libretro/libretro-common/include/rthreads/async_job.h
+++ b/src/libretro/libretro-common/include/rthreads/async_job.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2015 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (async_job.h).
diff --git a/src/libretro/libretro-common/include/rthreads/rthreads.h b/src/libretro/libretro-common/include/rthreads/rthreads.h
index e4eb208c4e..e4460a1742 100644
--- a/src/libretro/libretro-common/include/rthreads/rthreads.h
+++ b/src/libretro/libretro-common/include/rthreads/rthreads.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (rthreads.h).
diff --git a/src/libretro/libretro-common/include/streams/chd_stream.h b/src/libretro/libretro-common/include/streams/chd_stream.h
index 3b0ac4e131..51fd4d3ee9 100644
--- a/src/libretro/libretro-common/include/streams/chd_stream.h
+++ b/src/libretro/libretro-common/include/streams/chd_stream.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (chd_stream.h).
@@ -57,7 +57,11 @@ int64_t chdstream_seek(chdstream_t *stream, int64_t offset, int whence);
 
 ssize_t chdstream_get_size(chdstream_t *stream);
 
-uint32_t chdstream_get_pregap(chdstream_t* stream);
+uint32_t chdstream_get_track_start(chdstream_t* stream);
+
+uint32_t chdstream_get_frame_size(chdstream_t* stream);
+
+uint32_t chdstream_get_first_track_sector(chdstream_t* stream);
 
 RETRO_END_DECLS
 
diff --git a/src/libretro/libretro-common/include/streams/file_stream.h b/src/libretro/libretro-common/include/streams/file_stream.h
index 0cfadad83c..079221e1e0 100644
--- a/src/libretro/libretro-common/include/streams/file_stream.h
+++ b/src/libretro/libretro-common/include/streams/file_stream.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (file_stream.h).
@@ -59,7 +59,7 @@ int64_t filestream_truncate(RFILE *stream, int64_t length);
  * @bufsize            : optional buffer size (-1 or 0 to use default)
  *
  * Opens a file for reading or writing, depending on the requested mode.
- * Returns a pointer to an RFILE if opened successfully, otherwise NULL.
+ * @return A pointer to an RFILE if opened successfully, otherwise NULL.
  **/
 RFILE* filestream_open(const char *path, unsigned mode, unsigned hints);
 
@@ -75,16 +75,39 @@ void filestream_rewind(RFILE *stream);
 
 int filestream_close(RFILE *stream);
 
+/**
+ * filestream_read_file:
+ * @path             : path to file.
+ * @buf              : buffer to allocate and read the contents of the
+ *                     file into. Needs to be freed manually.
+ * @len              : optional output integer containing bytes read.
+ *
+ * Read the contents of a file into @buf.
+ *
+ * @return Non-zero on success.
+ */
 int64_t filestream_read_file(const char *path, void **buf, int64_t *len);
 
 char* filestream_gets(RFILE *stream, char *s, size_t len);
 
 int filestream_getc(RFILE *stream);
 
+int filestream_vscanf(RFILE *stream, const char* format, va_list *args);
+
 int filestream_scanf(RFILE *stream, const char* format, ...);
 
 int filestream_eof(RFILE *stream);
 
+/**
+ * filestream_write_file:
+ * @path             : path to file.
+ * @data             : contents to write to the file.
+ * @size             : size of the contents.
+ *
+ * Writes data to a file.
+ *
+ * @return true on success, otherwise false.
+ **/
 bool filestream_write_file(const char *path, const void *data, int64_t size);
 
 int filestream_putc(RFILE *stream, int c);
@@ -105,7 +128,11 @@ const char* filestream_get_path(RFILE *stream);
 
 bool filestream_exists(const char *path);
 
-/* Returned pointer must be freed by the caller. */
+/**
+ * filestream_getline:
+ *
+ * Returned pointer must be freed by the caller.
+ **/
 char* filestream_getline(RFILE *stream);
 
 libretro_vfs_implementation_file* filestream_get_vfs_handle(RFILE *stream);
diff --git a/src/libretro/libretro-common/include/streams/file_stream_transforms.h b/src/libretro/libretro-common/include/streams/file_stream_transforms.h
index 9cf15c599d..327e2184cb 100644
--- a/src/libretro/libretro-common/include/streams/file_stream_transforms.h
+++ b/src/libretro/libretro-common/include/streams/file_stream_transforms.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
 *
 * ---------------------------------------------------------------------------------------
 * The following license statement only applies to this file (file_stream_transforms.h).
diff --git a/src/libretro/libretro-common/include/streams/interface_stream.h b/src/libretro/libretro-common/include/streams/interface_stream.h
index 58371e2ca0..b62552f219 100644
--- a/src/libretro/libretro-common/include/streams/interface_stream.h
+++ b/src/libretro/libretro-common/include/streams/interface_stream.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (interface_stream.h).
@@ -36,7 +36,8 @@ enum intfstream_type
 {
    INTFSTREAM_FILE = 0,
    INTFSTREAM_MEMORY,
-   INTFSTREAM_CHD
+   INTFSTREAM_CHD,
+   INTFSTREAM_RZIP
 };
 
 typedef struct intfstream_internal intfstream_internal_t, intfstream_t;
@@ -74,6 +75,9 @@ int64_t intfstream_read(intfstream_internal_t *intf,
 int64_t intfstream_write(intfstream_internal_t *intf,
       const void *s, uint64_t len);
 
+int intfstream_printf(intfstream_internal_t *intf,
+      const char* format, ...);
+
 int64_t intfstream_get_ptr(intfstream_internal_t *intf);
 
 char *intfstream_gets(intfstream_internal_t *intf,
@@ -88,6 +92,8 @@ void intfstream_rewind(intfstream_internal_t *intf);
 
 int64_t intfstream_tell(intfstream_internal_t *intf);
 
+int intfstream_eof(intfstream_internal_t *intf);
+
 void intfstream_putc(intfstream_internal_t *intf, int c);
 
 int intfstream_close(intfstream_internal_t *intf);
@@ -96,9 +102,17 @@ int64_t intfstream_get_size(intfstream_internal_t *intf);
 
 int intfstream_flush(intfstream_internal_t *intf);
 
-uint32_t intfstream_get_chd_pregap(intfstream_internal_t *intf);
+uint32_t intfstream_get_offset_to_start(intfstream_internal_t *intf);
+
+uint32_t intfstream_get_frame_size(intfstream_internal_t *intf);
+
+uint32_t intfstream_get_first_sector(intfstream_internal_t* intf);
 
-intfstream_t* intfstream_open_file(const char *path,
+bool intfstream_is_compressed(intfstream_internal_t *intf);
+
+bool intfstream_get_crc(intfstream_internal_t *intf, uint32_t *crc);
+
+intfstream_t *intfstream_open_file(const char *path,
       unsigned mode, unsigned hints);
 
 intfstream_t *intfstream_open_memory(void *data,
@@ -110,6 +124,9 @@ intfstream_t *intfstream_open_writable_memory(void *data,
 intfstream_t *intfstream_open_chd_track(const char *path,
       unsigned mode, unsigned hints, int32_t track);
 
+intfstream_t *intfstream_open_rzip_file(const char *path,
+      unsigned mode);
+
 RETRO_END_DECLS
 
 #endif
diff --git a/src/libretro/libretro-common/include/streams/memory_stream.h b/src/libretro/libretro-common/include/streams/memory_stream.h
index f9e641b028..2c6f3fcd68 100644
--- a/src/libretro/libretro-common/include/streams/memory_stream.h
+++ b/src/libretro/libretro-common/include/streams/memory_stream.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (memory_stream.h).
diff --git a/src/libretro/libretro-common/include/streams/stdin_stream.h b/src/libretro/libretro-common/include/streams/stdin_stream.h
index 3ed9bfdc9e..4dd35460e7 100644
--- a/src/libretro/libretro-common/include/streams/stdin_stream.h
+++ b/src/libretro/libretro-common/include/streams/stdin_stream.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (stdin_stream.h).
diff --git a/src/libretro/libretro-common/include/streams/trans_stream.h b/src/libretro/libretro-common/include/streams/trans_stream.h
index d183c6333e..79c0570734 100644
--- a/src/libretro/libretro-common/include/streams/trans_stream.h
+++ b/src/libretro/libretro-common/include/streams/trans_stream.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (trans_stream.h).
diff --git a/src/libretro/libretro-common/include/string/stdstring.h b/src/libretro/libretro-common/include/string/stdstring.h
index 1e5e0a3bd3..4e38e8d4cd 100644
--- a/src/libretro/libretro-common/include/string/stdstring.h
+++ b/src/libretro/libretro-common/include/string/stdstring.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2019 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (stdstring.h).
@@ -35,6 +35,33 @@
 
 RETRO_BEGIN_DECLS
 
+#define STRLEN_CONST(x)                   ((sizeof((x))-1))
+
+#define strcpy_literal(a, b)              strcpy(a, b)
+
+#define string_is_not_equal(a, b)         !string_is_equal((a), (b))
+
+#define string_is_not_equal_fast(a, b, size) (memcmp(a, b, size) != 0)
+#define string_is_equal_fast(a, b, size)     (memcmp(a, b, size) == 0)
+
+#define TOLOWER(c)   ((c) |  (lr_char_props[(unsigned char)(c)] & 0x20))
+#define TOUPPER(c)   ((c) & ~(lr_char_props[(unsigned char)(c)] & 0x20))
+
+/* C standard says \f \v are space, but this one disagrees */
+#define ISSPACE(c)   (lr_char_props[(unsigned char)(c)] & 0x80)
+
+#define ISDIGIT(c)   (lr_char_props[(unsigned char)(c)] & 0x40)
+#define ISALPHA(c)   (lr_char_props[(unsigned char)(c)] & 0x20)
+#define ISLOWER(c)   (lr_char_props[(unsigned char)(c)] & 0x04)
+#define ISUPPER(c)   (lr_char_props[(unsigned char)(c)] & 0x02)
+#define ISALNUM(c)   (lr_char_props[(unsigned char)(c)] & 0x60)
+#define ISUALPHA(c)  (lr_char_props[(unsigned char)(c)] & 0x28)
+#define ISUALNUM(c)  (lr_char_props[(unsigned char)(c)] & 0x68)
+#define IS_XDIGIT(c) (lr_char_props[(unsigned char)(c)] & 0x01)
+
+/* Deprecated alias, all callers should use string_is_equal_case_insensitive instead */
+#define string_is_equal_noncase string_is_equal_case_insensitive
+
 static INLINE bool string_is_empty(const char *data)
 {
    return !data || (*data == '\0');
@@ -45,12 +72,48 @@ static INLINE bool string_is_equal(const char *a, const char *b)
    return (a && b) ? !strcmp(a, b) : false;
 }
 
-#define STRLEN_CONST(x)                   ((sizeof((x))-1))
+static INLINE bool string_starts_with_size(const char *str, const char *prefix,
+      size_t size)
+{
+   return (str && prefix) ? !strncmp(prefix, str, size) : false;
+}
 
-#define string_is_not_equal(a, b)         !string_is_equal((a), (b))
+static INLINE bool string_starts_with(const char *str, const char *prefix)
+{
+   return (str && prefix) ? !strncmp(prefix, str, strlen(prefix)) : false;
+}
+
+static INLINE bool string_ends_with_size(const char *str, const char *suffix,
+      size_t str_len, size_t suffix_len)
+{
+   return (str_len < suffix_len) ? false :
+         !memcmp(suffix, str + (str_len - suffix_len), suffix_len);
+}
+
+static INLINE bool string_ends_with(const char *str, const char *suffix)
+{
+   return str && suffix && string_ends_with_size(str, suffix, strlen(str), strlen(suffix));
+}
+
+/**
+ * strlen_size:
+ *
+ * Leaf function.
+ *
+ * @return the length of 'str' (c.f. strlen()), but only
+ * checks the first 'size' characters
+ * - If 'str' is NULL, returns 0
+ * - If 'str' is not NULL and no '\0' character is found
+ *   in the first 'size' characters, returns 'size'
+ **/
+static INLINE size_t strlen_size(const char *str, size_t size)
+{
+   size_t i = 0;
+   if (str)
+      while (i < size && str[i]) i++;
+   return i;
+}
 
-#define string_is_not_equal_fast(a, b, size) (memcmp(a, b, size) != 0)
-#define string_is_equal_fast(a, b, size)     (memcmp(a, b, size) == 0)
 
 static INLINE bool string_is_equal_case_insensitive(const char *a,
       const char *b)
@@ -71,22 +134,23 @@ static INLINE bool string_is_equal_case_insensitive(const char *a,
    return (result == 0);
 }
 
-static INLINE bool string_is_equal_noncase(const char *a, const char *b)
+static INLINE bool string_starts_with_case_insensitive(const char *str,
+      const char *prefix)
 {
    int result              = 0;
-   const unsigned char *p1 = (const unsigned char*)a;
-   const unsigned char *p2 = (const unsigned char*)b;
+   const unsigned char *p1 = (const unsigned char*)str;
+   const unsigned char *p2 = (const unsigned char*)prefix;
 
-   if (!a || !b)
+   if (!str || !prefix)
       return false;
    if (p1 == p2)
-      return false;
+      return true;
 
-   while ((result = tolower (*p1) - tolower (*p2++)) == 0)
-      if (*p1++ == '\0')
+   while ((result = tolower (*p1++) - tolower (*p2)) == 0)
+      if (*p2++ == '\0')
          break;
 
-   return (result == 0);
+   return (result == 0 || *p2 == '\0');
 }
 
 char *string_to_upper(char *s);
@@ -95,48 +159,229 @@ char *string_to_lower(char *s);
 
 char *string_ucwords(char *s);
 
-char *string_replace_substring(const char *in, const char *pattern,
-      const char *by);
+char *string_replace_substring(const char *in,
+      const char *pattern, size_t pattern_len,
+      const char *replacement, size_t replacement_len);
 
-/* Remove leading whitespaces */
+/**
+ * string_trim_whitespace_left:
+ *
+ * Remove leading whitespaces
+ **/
 char *string_trim_whitespace_left(char *const s);
 
-/* Remove trailing whitespaces */
+/**
+ * string_trim_whitespace_right:
+ *
+ * Remove trailing whitespaces
+ **/
 char *string_trim_whitespace_right(char *const s);
 
-/* Remove leading and trailing whitespaces */
+/**
+ * string_trim_whitespace:
+ *
+ * Remove leading and trailing whitespaces
+ **/
 char *string_trim_whitespace(char *const s);
 
-/* max_lines == 0 means no limit */
-char *word_wrap(char *buffer, const char *string,
-      int line_width, bool unicode, unsigned max_lines);
+/**
+ * word_wrap:
+ * @dst                : pointer to destination buffer.
+ * @dst_size           : size of destination buffer.
+ * @src                : pointer to input string.
+ * @src_len            : length of @src
+ * @line_width         : max number of characters per line.
+ * @wideglyph_width    : not used, but is necessary to keep
+ *                       compatibility with word_wrap_wideglyph().
+ * @max_lines          : max lines of destination string.
+ *                       0 means no limit.
+ *
+ * Wraps string specified by 'src' to destination buffer
+ * specified by 'dst' and 'dst_size'.
+ * This function assumes that all glyphs in the string
+ * have an on-screen pixel width similar to that of
+ * regular Latin characters - i.e. it will not wrap
+ * correctly any text containing so-called 'wide' Unicode
+ * characters (e.g. CJK languages, emojis, etc.).
+ **/
+size_t word_wrap(char *dst, size_t dst_size, const char *src, size_t src_len,
+      int line_width, int wideglyph_width, unsigned max_lines);
 
-/* Splits string into tokens seperated by 'delim'
+/**
+ * word_wrap_wideglyph:
+ * @dst                : pointer to destination buffer.
+ * @dst_size           : size of destination buffer.
+ * @src                : pointer to input string.
+ * @src_len            : length of @src
+ * @line_width         : max number of characters per line.
+ * @wideglyph_width    : effective width of 'wide' Unicode glyphs.
+ *                       the value here is normalised relative to the
+ *                       typical on-screen pixel width of a regular
+ *                       Latin character:
+ *                       - a regular Latin character is defined to
+ *                         have an effective width of 100
+ *                       - wideglyph_width = 100 * (wide_character_pixel_width / latin_character_pixel_width)
+ *                       - e.g. if 'wide' Unicode characters in 'src'
+ *                         have an on-screen pixel width twice that of
+ *                         regular Latin characters, wideglyph_width
+ *                         would be 200
+ * @max_lines          : max lines of destination string.
+ *                       0 means no limit.
+ *
+ * Wraps string specified by @src to destination buffer
+ * specified by @dst and @dst_size.
+ * This function assumes that all glyphs in the string
+ * are:
+ * - EITHER 'non-wide' Unicode glyphs, with an on-screen
+ *   pixel width similar to that of regular Latin characters
+ * - OR 'wide' Unicode glyphs (e.g. CJK languages, emojis, etc.)
+ *   with an on-screen pixel width defined by @wideglyph_width
+ * Note that wrapping may occur in inappropriate locations
+ * if @src string contains 'wide' Unicode characters whose
+ * on-screen pixel width deviates greatly from the set
+ * @wideglyph_width value.
+ **/
+size_t word_wrap_wideglyph(
+      char *dst, size_t dst_size,
+      const char *src, size_t src_len,
+      int line_width, int wideglyph_width,
+      unsigned max_lines);
+
+/**
+ * string_tokenize:
+ *
+ * Splits string into tokens seperated by @delim
  * > Returned token string must be free()'d
  * > Returns NULL if token is not found
- * > After each call, 'str' is set to the position after the
+ * > After each call, @str is set to the position after the
  *   last found token
  * > Tokens *include* empty strings
  * Usage example:
  *    char *str      = "1,2,3,4,5,6,7,,,10,";
  *    char **str_ptr = &str;
  *    char *token    = NULL;
- *    while((token = string_tokenize(str_ptr, ",")))
+ *    while ((token = string_tokenize(str_ptr, ",")))
  *    {
  *        printf("%s\n", token);
  *        free(token);
  *        token = NULL;
  *    }
- */
+ **/
 char* string_tokenize(char **str, const char *delim);
 
-/* Removes every instance of character 'c' from 'str' */
+/**
+ * string_remove_all_chars:
+ * @str                : input string (must be non-NULL, otherwise UB)
+ *
+ * Leaf function.
+ *
+ * Removes every instance of character @c from @str
+ **/
 void string_remove_all_chars(char *str, char c);
 
-/* Converts string to unsigned integer.
- * Returns 0 if string is invalid  */
+/**
+ * string_replace_all_chars:
+ * @str                : input string (must be non-NULL, otherwise UB)
+ * @find               : character to find
+ * @replace            : character to replace @find with
+ *
+ * Hidden non-leaf function cost:
+ * - Calls strchr (in a loop)
+ *
+ * Replaces every instance of character @find in @str
+ * with character @replace
+ **/
+void string_replace_all_chars(char *str, char find, char replace);
+
+/**
+ * string_to_unsigned:
+ * @str                : input string
+ *
+ * Converts string to unsigned integer.
+ *
+ * @return 0 if string is invalid, otherwise > 0
+ **/
 unsigned string_to_unsigned(const char *str);
 
+/**
+ * string_hex_to_unsigned:
+ * @str                : input string (must be non-NULL, otherwise UB)
+ *
+ * Converts hexadecimal string to unsigned integer.
+ * Handles optional leading '0x'.
+ *
+ * @return 0 if string is invalid, otherwise > 0
+ **/
+unsigned string_hex_to_unsigned(const char *str);
+
+char *string_init(const char *src);
+
+void string_set(char **string, const char *src);
+
+/**
+ * string_count_occurrences_single_character:
+ *
+ * Leaf function.
+ *
+ * Get the total number of occurrences of character @c in @str.
+ *
+ * @return Total number of occurrences of character @c
+ */
+int string_count_occurrences_single_character(const char *str, char c);
+
+/**
+ * string_replace_whitespace_with_single_character:
+ *
+ * Leaf function.
+ *
+ * Replaces all spaces with given character @c.
+ **/
+void string_replace_whitespace_with_single_character(char *str, char c);
+
+/**
+ * string_replace_multi_space_with_single_space:
+ *
+ * Leaf function.
+ *
+ * Replaces multiple spaces with a single space in a string.
+ **/
+void string_replace_multi_space_with_single_space(char *str);
+
+/**
+ * string_remove_all_whitespace:
+ *
+ * Leaf function.
+ *
+ * Remove all spaces from the given string.
+ **/
+void string_remove_all_whitespace(char *str_trimmed, const char *str);
+
+/* Retrieve the last occurance of the given character in a string. */
+int string_index_last_occurance(const char *str, char c);
+
+/**
+ * string_find_index_substring_string:
+ * @str                : input string (must be non-NULL, otherwise UB)
+ * @substr             : substring to find in @str
+ *
+ * Hidden non-leaf function cost:
+ * - Calls strstr
+ *
+ * Find the position of substring @substr in string @str.
+ **/
+int string_find_index_substring_string(const char *str, const char *substr);
+
+/**
+ * string_copy_only_ascii:
+ *
+ * Leaf function.
+ *
+ * Strips non-ASCII characters from a string.
+ **/
+void string_copy_only_ascii(char *str_stripped, const char *str);
+
+extern const unsigned char lr_char_props[256];
+
 RETRO_END_DECLS
 
 #endif
diff --git a/src/libretro/libretro-common/include/time/rtime.h b/src/libretro/libretro-common/include/time/rtime.h
new file mode 100644
index 0000000000..7629c1eab3
--- /dev/null
+++ b/src/libretro/libretro-common/include/time/rtime.h
@@ -0,0 +1,48 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (rtime.h).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef __LIBRETRO_SDK_RTIME_H__
+#define __LIBRETRO_SDK_RTIME_H__
+
+#include <retro_common_api.h>
+
+#include <stdint.h>
+#include <stddef.h>
+#include <time.h>
+
+RETRO_BEGIN_DECLS
+
+/* TODO/FIXME: Move all generic time handling functions
+ * to this file */
+
+/* Must be called before using rtime_localtime() */
+void rtime_init(void);
+
+/* Must be called upon program termination */
+void rtime_deinit(void);
+
+/* Thread-safe wrapper for localtime() */
+struct tm *rtime_localtime(const time_t *timep, struct tm *result);
+
+RETRO_END_DECLS
+
+#endif
diff --git a/src/libretro/libretro-common/include/vfs/vfs.h b/src/libretro/libretro-common/include/vfs/vfs.h
index b876f438b6..bd61c69aa9 100644
--- a/src/libretro/libretro-common/include/vfs/vfs.h
+++ b/src/libretro/libretro-common/include/vfs/vfs.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2019 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
 *
 * ---------------------------------------------------------------------------------------
 * The following license statement only applies to this file (vfs_implementation.h).
@@ -41,17 +41,17 @@ typedef void* HANDLE;
 #ifdef HAVE_CDROM
 typedef struct
 {
+   int64_t byte_pos;
    char *cue_buf;
    size_t cue_len;
-   int64_t byte_pos;
-   char drive;
+   unsigned cur_lba;
+   unsigned last_frame_lba;
    unsigned char cur_min;
    unsigned char cur_sec;
    unsigned char cur_frame;
    unsigned char cur_track;
-   unsigned cur_lba;
-   unsigned last_frame_lba;
    unsigned char last_frame[2352];
+   char drive;
    bool last_frame_valid;
 } vfs_cdrom_t;
 #endif
@@ -62,29 +62,29 @@ enum vfs_scheme
    VFS_SCHEME_CDROM
 };
 
-#ifndef __WINRT__
+#if !(defined(__WINRT__) && defined(__cplusplus_winrt))
 #ifdef VFS_FRONTEND
 struct retro_vfs_file_handle
 #else
 struct libretro_vfs_implementation_file
 #endif
 {
-   int fd;
-   unsigned hints;
+#ifdef HAVE_CDROM
+   vfs_cdrom_t cdrom; /* int64_t alignment */
+#endif
    int64_t size;
-   char *buf;
+   uint64_t mappos;
+   uint64_t mapsize;
    FILE *fp;
 #ifdef _WIN32
    HANDLE fh;
 #endif
+   char *buf;
    char* orig_path;
-   uint64_t mappos;
-   uint64_t mapsize;
    uint8_t *mapped;
+   int fd;
+   unsigned hints;
    enum vfs_scheme scheme;
-#ifdef HAVE_CDROM
-   vfs_cdrom_t cdrom;
-#endif
 };
 #endif
 
diff --git a/src/libretro/libretro-common/include/vfs/vfs_implementation.h b/src/libretro/libretro-common/include/vfs/vfs_implementation.h
index c981cf72f7..b88d2f3d2b 100644
--- a/src/libretro/libretro-common/include/vfs/vfs_implementation.h
+++ b/src/libretro/libretro-common/include/vfs/vfs_implementation.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2019 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
 *
 * ---------------------------------------------------------------------------------------
 * The following license statement only applies to this file (vfs_implementation.h).
@@ -71,6 +71,12 @@ bool retro_vfs_dirent_is_dir_impl(libretro_vfs_implementation_dir *dirstream);
 
 int retro_vfs_closedir_impl(libretro_vfs_implementation_dir *dirstream);
 
+#ifdef __WINRT__
+
+void uwp_set_acl(const wchar_t* path, const wchar_t* AccessString);
+
+#endif
+
 RETRO_END_DECLS
 
 #endif
diff --git a/src/libretro/libretro-common/include/vfs/vfs_implementation_cdrom.h b/src/libretro/libretro-common/include/vfs/vfs_implementation_cdrom.h
index 3996fbe877..f809963f4f 100644
--- a/src/libretro/libretro-common/include/vfs/vfs_implementation_cdrom.h
+++ b/src/libretro/libretro-common/include/vfs/vfs_implementation_cdrom.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2019 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (vfs_implementation_cdrom.h).
diff --git a/src/libretro/libretro-common/include/vulkan/vulkan_symbol_wrapper.h b/src/libretro/libretro-common/include/vulkan/vulkan_symbol_wrapper.h
index 4b1ded0d4e..4df6e88863 100644
--- a/src/libretro/libretro-common/include/vulkan/vulkan_symbol_wrapper.h
+++ b/src/libretro/libretro-common/include/vulkan/vulkan_symbol_wrapper.h
@@ -11,6 +11,8 @@ extern "C" {
 
 extern PFN_vkCreateInstance vulkan_symbol_wrapper_vkCreateInstance;
 #define vkCreateInstance vulkan_symbol_wrapper_vkCreateInstance
+extern PFN_vkEnumerateInstanceVersion vulkan_symbol_wrapper_vkEnumerateInstanceVersion;
+#define vkEnumerateInstanceVersion vulkan_symbol_wrapper_vkEnumerateInstanceVersion
 extern PFN_vkEnumerateInstanceExtensionProperties vulkan_symbol_wrapper_vkEnumerateInstanceExtensionProperties;
 #define vkEnumerateInstanceExtensionProperties vulkan_symbol_wrapper_vkEnumerateInstanceExtensionProperties
 extern PFN_vkEnumerateInstanceLayerProperties vulkan_symbol_wrapper_vkEnumerateInstanceLayerProperties;
@@ -317,22 +319,13 @@ extern PFN_vkCreateDisplayPlaneSurfaceKHR vulkan_symbol_wrapper_vkCreateDisplayP
 #define vkCreateDisplayPlaneSurfaceKHR vulkan_symbol_wrapper_vkCreateDisplayPlaneSurfaceKHR
 extern PFN_vkCreateSharedSwapchainsKHR vulkan_symbol_wrapper_vkCreateSharedSwapchainsKHR;
 #define vkCreateSharedSwapchainsKHR vulkan_symbol_wrapper_vkCreateSharedSwapchainsKHR
-extern PFN_vkCreateDebugReportCallbackEXT vulkan_symbol_wrapper_vkCreateDebugReportCallbackEXT;
-#define vkCreateDebugReportCallbackEXT vulkan_symbol_wrapper_vkCreateDebugReportCallbackEXT
-extern PFN_vkDestroyDebugReportCallbackEXT vulkan_symbol_wrapper_vkDestroyDebugReportCallbackEXT;
-#define vkDestroyDebugReportCallbackEXT vulkan_symbol_wrapper_vkDestroyDebugReportCallbackEXT
-extern PFN_vkDebugReportMessageEXT vulkan_symbol_wrapper_vkDebugReportMessageEXT;
-#define vkDebugReportMessageEXT vulkan_symbol_wrapper_vkDebugReportMessageEXT
-extern PFN_vkDebugMarkerSetObjectTagEXT vulkan_symbol_wrapper_vkDebugMarkerSetObjectTagEXT;
-#define vkDebugMarkerSetObjectTagEXT vulkan_symbol_wrapper_vkDebugMarkerSetObjectTagEXT
-extern PFN_vkDebugMarkerSetObjectNameEXT vulkan_symbol_wrapper_vkDebugMarkerSetObjectNameEXT;
-#define vkDebugMarkerSetObjectNameEXT vulkan_symbol_wrapper_vkDebugMarkerSetObjectNameEXT
-extern PFN_vkCmdDebugMarkerBeginEXT vulkan_symbol_wrapper_vkCmdDebugMarkerBeginEXT;
-#define vkCmdDebugMarkerBeginEXT vulkan_symbol_wrapper_vkCmdDebugMarkerBeginEXT
-extern PFN_vkCmdDebugMarkerEndEXT vulkan_symbol_wrapper_vkCmdDebugMarkerEndEXT;
-#define vkCmdDebugMarkerEndEXT vulkan_symbol_wrapper_vkCmdDebugMarkerEndEXT
-extern PFN_vkCmdDebugMarkerInsertEXT vulkan_symbol_wrapper_vkCmdDebugMarkerInsertEXT;
-#define vkCmdDebugMarkerInsertEXT vulkan_symbol_wrapper_vkCmdDebugMarkerInsertEXT
+
+extern PFN_vkCreateDebugUtilsMessengerEXT vulkan_symbol_wrapper_vkCreateDebugUtilsMessengerEXT;
+#define vkCreateDebugUtilsMessengerEXT vulkan_symbol_wrapper_vkCreateDebugUtilsMessengerEXT
+extern PFN_vkDestroyDebugUtilsMessengerEXT vulkan_symbol_wrapper_vkDestroyDebugUtilsMessengerEXT;
+#define vkDestroyDebugUtilsMessengerEXT vulkan_symbol_wrapper_vkDestroyDebugUtilsMessengerEXT
+extern PFN_vkSetDebugUtilsObjectNameEXT vulkan_symbol_wrapper_vkSetDebugUtilsObjectNameEXT;
+#define vkSetDebugUtilsObjectNameEXT vulkan_symbol_wrapper_vkSetDebugUtilsObjectNameEXT
 
 void vulkan_symbol_wrapper_init(PFN_vkGetInstanceProcAddr get_instance_proc_addr);
 PFN_vkGetInstanceProcAddr vulkan_symbol_wrapper_instance_proc_addr(void);
diff --git a/src/libretro/libretro-common/libco/aarch64.c b/src/libretro/libretro-common/libco/aarch64.c
index b9781e3390..516443fd03 100644
--- a/src/libretro/libretro-common/libco/aarch64.c
+++ b/src/libretro/libretro-common/libco/aarch64.c
@@ -11,7 +11,7 @@
 #include <string.h>
 #include <stdint.h>
 
-#ifndef IOS
+#ifndef __APPLE__
 #include <malloc.h>
 #endif
 
@@ -66,19 +66,20 @@ static void crash(void)
 
 cothread_t co_create(unsigned int size, void (*entrypoint)(void))
 {
-   size = (size + 1023) & ~1023;
+	uint64_t *ptr     = NULL;
    cothread_t handle = 0;
+   size              = (size + 1023) & ~1023;
 #if HAVE_POSIX_MEMALIGN >= 1
    if (posix_memalign(&handle, 1024, size + 512) < 0)
       return 0;
 #else
-   handle = memalign(1024, size + 512);
+   handle            = memalign(1024, size + 512);
 #endif
 
    if (!handle)
       return handle;
 
-   uint64_t *ptr = (uint64_t*)handle;
+   ptr     = (uint64_t*)handle;
    /* Non-volatiles.  */
    ptr[0]  = 0; /* x8  */
    ptr[1]  = 0; /* x9  */
diff --git a/src/libretro/libretro-common/libco/amd64.c b/src/libretro/libretro-common/libco/amd64.c
index c2d6ee0c88..54b1abf6d8 100644
--- a/src/libretro/libretro-common/libco/amd64.c
+++ b/src/libretro/libretro-common/libco/amd64.c
@@ -20,56 +20,61 @@ extern "C" {
 static thread_local long long co_active_buffer[64];
 static thread_local cothread_t co_active_handle = 0;
 #ifndef CO_USE_INLINE_ASM
-static void (*co_swap)(cothread_t, cothread_t) = 0;
+static void (*co_swap)(cothread_t, cothread_t)  = 0;
 #endif
 
 #ifdef _WIN32
 /* ABI: Win64 */
+  /* On windows handle is allocated by malloc and there it's guaranteed to
+     have at least 16-byte alignment. Hence we don't need to align
+     it in order to use movaps.  */
 static unsigned char co_swap_function[] = {
-  0x48, 0x89, 0x22,                                 /* mov    [rdx],rsp        */
-  0x48, 0x8b, 0x21,                                 /* mov    rsp,[rcx]        */
-  0x58,                                             /* pop    rax              */
-  0x48, 0x89, 0x6a, 0x08,                           /* mov    [rdx+0x8],rbp    */
-  0x48, 0x89, 0x72, 0x10,                           /* mov    [rdx+0x10],rsi   */
-  0x48, 0x89, 0x7a, 0x18,                           /* mov    [rdx+0x18],rdi   */
-  0x48, 0x89, 0x5a, 0x20,                           /* mov    [rdx+0x20],rbx   */
-  0x4c, 0x89, 0x62, 0x28,                           /* mov    [rdx+0x28],r12   */
-  0x4c, 0x89, 0x6a, 0x30,                           /* mov    [rdx+0x30],r13   */
-  0x4c, 0x89, 0x72, 0x38,                           /* mov    [rdx+0x38],r14   */
-  0x4c, 0x89, 0x7a, 0x40,                           /* mov    [rdx+0x40],r15   */
-  0x48, 0x81, 0xc2, 0x80, 0x00, 0x00, 0x00,         /* add    rdx,0x80         */
-  0x48, 0x83, 0xe2, 0xf0,                           /* and    rdx,-0x10        */
-  0x0f, 0x29, 0x32,                                 /* movaps [rdx],xmm6       */
-  0x0f, 0x29, 0x7a, 0x10,                           /* movaps [rdx+0x10],xmm7  */
-  0x44, 0x0f, 0x29, 0x42, 0x20,                     /* movaps [rdx+0x20],xmm8  */
-  0x44, 0x0f, 0x29, 0x4a, 0x30,                     /* movaps [rdx+0x30],xmm9  */
-  0x44, 0x0f, 0x29, 0x52, 0x40,                     /* movaps [rdx+0x40],xmm10 */
-  0x44, 0x0f, 0x29, 0x5a, 0x50,                     /* movaps [rdx+0x50],xmm11 */
-  0x44, 0x0f, 0x29, 0x62, 0x60,                     /* movaps [rdx+0x60],xmm12 */
-  0x44, 0x0f, 0x29, 0x6a, 0x70,                     /* movaps [rdx+0x70],xmm13 */
-  0x44, 0x0f, 0x29, 0xb2, 0x80, 0x00, 0x00, 0x00,   /* movaps [rdx+0x80],xmm14 */
-  0x44, 0x0f, 0x29, 0xba, 0x90, 0x00, 0x00, 0x00,   /* movaps [rdx+0x90],xmm15 */
-  0x48, 0x8b, 0x69, 0x08,                           /* mov    rbp,[rcx+0x8]    */
-  0x48, 0x8b, 0x71, 0x10,                           /* mov    rsi,[rcx+0x10]   */
-  0x48, 0x8b, 0x79, 0x18,                           /* mov    rdi,[rcx+0x18]   */
-  0x48, 0x8b, 0x59, 0x20,                           /* mov    rbx,[rcx+0x20]   */
-  0x4c, 0x8b, 0x61, 0x28,                           /* mov    r12,[rcx+0x28]   */
-  0x4c, 0x8b, 0x69, 0x30,                           /* mov    r13,[rcx+0x30]   */
-  0x4c, 0x8b, 0x71, 0x38,                           /* mov    r14,[rcx+0x38]   */
-  0x4c, 0x8b, 0x79, 0x40,                           /* mov    r15,[rcx+0x40]   */
-  0x48, 0x81, 0xc1, 0x80, 0x00, 0x00, 0x00,         /* add    rcx,0x80         */
-  0x48, 0x83, 0xe1, 0xf0,                           /* and    rcx,-0x10        */
-  0x0f, 0x29, 0x31,                                 /* movaps [rcx],xmm6       */
-  0x0f, 0x29, 0x79, 0x10,                           /* movaps [rcx+0x10],xmm7  */
-  0x44, 0x0f, 0x29, 0x41, 0x20,                     /* movaps [rcx+0x20],xmm8  */
-  0x44, 0x0f, 0x29, 0x49, 0x30,                     /* movaps [rcx+0x30],xmm9  */
-  0x44, 0x0f, 0x29, 0x51, 0x40,                     /* movaps [rcx+0x40],xmm10 */
-  0x44, 0x0f, 0x29, 0x59, 0x50,                     /* movaps [rcx+0x50],xmm11 */
-  0x44, 0x0f, 0x29, 0x61, 0x60,                     /* movaps [rcx+0x60],xmm12 */
-  0x44, 0x0f, 0x29, 0x69, 0x70,                     /* movaps [rcx+0x70],xmm13 */
-  0x44, 0x0f, 0x29, 0xb1, 0x80, 0x00, 0x00, 0x00,   /* movaps [rcx+0x80],xmm14 */
-  0x44, 0x0f, 0x29, 0xb9, 0x90, 0x00, 0x00, 0x00,   /* movaps [rcx+0x90],xmm15 */
-  0xff, 0xe0,                                       /* jmp    rax              */
+    0x48, 0x89, 0x22,              /* mov [rdx],rsp          */
+    0x48, 0x8b, 0x21,              /* mov rsp,[rcx]          */
+    0x58,                          /* pop rax                */
+    0x48, 0x89, 0x6a, 0x08,        /* mov [rdx+ 8],rbp       */
+    0x48, 0x89, 0x72, 0x10,        /* mov [rdx+16],rsi       */
+    0x48, 0x89, 0x7a, 0x18,        /* mov [rdx+24],rdi       */
+    0x48, 0x89, 0x5a, 0x20,        /* mov [rdx+32],rbx       */
+    0x4c, 0x89, 0x62, 0x28,        /* mov [rdx+40],r12       */
+    0x4c, 0x89, 0x6a, 0x30,        /* mov [rdx+48],r13       */
+    0x4c, 0x89, 0x72, 0x38,        /* mov [rdx+56],r14       */
+    0x4c, 0x89, 0x7a, 0x40,        /* mov [rdx+64],r15       */
+  #if !defined(LIBCO_NO_SSE)
+    0x0f, 0x29, 0x72, 0x50,        /* movaps [rdx+ 80],xmm6  */
+    0x0f, 0x29, 0x7a, 0x60,        /* movaps [rdx+ 96],xmm7  */
+    0x44, 0x0f, 0x29, 0x42, 0x70,  /* movaps [rdx+112],xmm8  */
+    0x48, 0x83, 0xc2, 0x70,        /* add rdx,112            */
+    0x44, 0x0f, 0x29, 0x4a, 0x10,  /* movaps [rdx+ 16],xmm9  */
+    0x44, 0x0f, 0x29, 0x52, 0x20,  /* movaps [rdx+ 32],xmm10 */
+    0x44, 0x0f, 0x29, 0x5a, 0x30,  /* movaps [rdx+ 48],xmm11 */
+    0x44, 0x0f, 0x29, 0x62, 0x40,  /* movaps [rdx+ 64],xmm12 */
+    0x44, 0x0f, 0x29, 0x6a, 0x50,  /* movaps [rdx+ 80],xmm13 */
+    0x44, 0x0f, 0x29, 0x72, 0x60,  /* movaps [rdx+ 96],xmm14 */
+    0x44, 0x0f, 0x29, 0x7a, 0x70,  /* movaps [rdx+112],xmm15 */
+  #endif
+    0x48, 0x8b, 0x69, 0x08,        /* mov rbp,[rcx+ 8]       */
+    0x48, 0x8b, 0x71, 0x10,        /* mov rsi,[rcx+16]       */
+    0x48, 0x8b, 0x79, 0x18,        /* mov rdi,[rcx+24]       */
+    0x48, 0x8b, 0x59, 0x20,        /* mov rbx,[rcx+32]       */
+    0x4c, 0x8b, 0x61, 0x28,        /* mov r12,[rcx+40]       */
+    0x4c, 0x8b, 0x69, 0x30,        /* mov r13,[rcx+48]       */
+    0x4c, 0x8b, 0x71, 0x38,        /* mov r14,[rcx+56]       */
+    0x4c, 0x8b, 0x79, 0x40,        /* mov r15,[rcx+64]       */
+  #if !defined(LIBCO_NO_SSE)
+    0x0f, 0x28, 0x71, 0x50,        /* movaps xmm6, [rcx+ 80] */
+    0x0f, 0x28, 0x79, 0x60,        /* movaps xmm7, [rcx+ 96] */
+    0x44, 0x0f, 0x28, 0x41, 0x70,  /* movaps xmm8, [rcx+112] */
+    0x48, 0x83, 0xc1, 0x70,        /* add rcx,112            */
+    0x44, 0x0f, 0x28, 0x49, 0x10,  /* movaps xmm9, [rcx+ 16] */
+    0x44, 0x0f, 0x28, 0x51, 0x20,  /* movaps xmm10,[rcx+ 32] */
+    0x44, 0x0f, 0x28, 0x59, 0x30,  /* movaps xmm11,[rcx+ 48] */
+    0x44, 0x0f, 0x28, 0x61, 0x40,  /* movaps xmm12,[rcx+ 64] */
+    0x44, 0x0f, 0x28, 0x69, 0x50,  /* movaps xmm13,[rcx+ 80] */
+    0x44, 0x0f, 0x28, 0x71, 0x60,  /* movaps xmm14,[rcx+ 96] */
+    0x44, 0x0f, 0x28, 0x79, 0x70,  /* movaps xmm15,[rcx+112] */
+  #endif
+    0xff, 0xe0,                    /* jmp rax                */
 };
 
 #include <windows.h>
@@ -132,9 +137,8 @@ cothread_t co_active(void)
 cothread_t co_create(unsigned int size, void (*entrypoint)(void))
 {
    cothread_t handle;
-
 #ifndef CO_USE_INLINE_ASM
-   if(!co_swap)
+   if (!co_swap)
    {
       co_init();
       co_swap = (void (*)(cothread_t, cothread_t))co_swap_function;
@@ -147,15 +151,15 @@ cothread_t co_create(unsigned int size, void (*entrypoint)(void))
    size &= ~15; /* align stack to 16-byte boundary */
 
 #ifdef __GENODE__
-   if((handle = (cothread_t)genode_alloc_secondary_stack(size)))
+   if ((handle = (cothread_t)genode_alloc_secondary_stack(size)))
    {
-      long long *p = (long long*)((char*)handle); /* OS returns top of stack */
-      *--p = (long long)crash;                    /* crash if entrypoint returns */
-      *--p = (long long)entrypoint;               /* start of function */
-      *(long long*)handle = (long long)p;         /* stack pointer */
+      long long *p        = (long long*)((char*)handle); /* OS returns top of stack */
+      *--p                = (long long)crash;            /* crash if entrypoint returns */
+      *--p                = (long long)entrypoint;       /* start of function */
+      *(long long*)handle = (long long)p;                /* stack pointer */
    }
 #else
-   if((handle = (cothread_t)malloc(size)))
+   if ((handle = (cothread_t)malloc(size)))
    {
       long long *p = (long long*)((char*)handle + size); /* seek to top of stack */
       *--p = (long long)crash;                           /* crash if entrypoint returns */
diff --git a/src/libretro/libretro-common/libco/armeabi.c b/src/libretro/libretro-common/libco/armeabi.c
index f03a356794..d3efd40f08 100644
--- a/src/libretro/libretro-common/libco/armeabi.c
+++ b/src/libretro/libretro-common/libco/armeabi.c
@@ -24,10 +24,13 @@ static thread_local cothread_t co_active_handle;
 
 __asm__ (
 #if defined(__thumb2__)
-      ".thumb\n"
       ".align 2\n"
       ".globl co_switch_arm\n"
       ".globl _co_switch_arm\n"
+      ".thumb\n"
+      ".thumb_func\n"
+      ".type   co_switch_arm, %function\n"
+      ".type   _co_switch_arm, %function\n"
       "co_switch_arm:\n"
       "_co_switch_arm:\n"
       " mov r3, sp\n"
@@ -55,8 +58,9 @@ void co_switch_arm(cothread_t handle, cothread_t current);
 
 cothread_t co_create(unsigned int size, void (*entrypoint)(void))
 {
-   size = (size + 1023) & ~1023;
+   uint32_t *ptr     = NULL;
    cothread_t handle = 0;
+   size              = (size + 1023) & ~1023;
 #if defined(__APPLE__) || HAVE_POSIX_MEMALIGN >= 1
    if (posix_memalign(&handle, 1024, size + 256) < 0)
       return 0;
@@ -67,7 +71,7 @@ cothread_t co_create(unsigned int size, void (*entrypoint)(void))
    if (!handle)
       return handle;
 
-   uint32_t *ptr = (uint32_t*)handle;
+   ptr    = (uint32_t*)handle;
    /* Non-volatiles.  */
    ptr[0] = 0; /* r4  */
    ptr[1] = 0; /* r5  */
diff --git a/src/libretro/libretro-common/libco/fiber.c b/src/libretro/libretro-common/libco/fiber.c
index 9e630894fa..d745926066 100644
--- a/src/libretro/libretro-common/libco/fiber.c
+++ b/src/libretro/libretro-common/libco/fiber.c
@@ -24,7 +24,7 @@ static void __stdcall co_thunk(void *coentry)
 
 cothread_t co_active(void)
 {
-   if(!co_active_)
+   if (!co_active_)
    {
 #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
       ConvertThreadToFiberEx(0, FIBER_FLAG_FLOAT_SWITCH);
@@ -38,7 +38,7 @@ cothread_t co_active(void)
 
 cothread_t co_create(unsigned int heapsize, void (*coentry)(void))
 {
-   if(!co_active_)
+   if (!co_active_)
    {
 #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP)
       ConvertThreadToFiberEx(0, FIBER_FLAG_FLOAT_SWITCH);
diff --git a/src/libretro/libretro-common/libco/genode.cpp b/src/libretro/libretro-common/libco/genode.cpp
index 2f2bdac52a..f1d671ad41 100644
--- a/src/libretro/libretro-common/libco/genode.cpp
+++ b/src/libretro/libretro-common/libco/genode.cpp
@@ -13,13 +13,15 @@
 extern "C"
 void *genode_alloc_secondary_stack(unsigned long stack_size)
 {
-	try {
-		return Genode::Thread::myself()->alloc_secondary_stack("libco", stack_size); }
-	catch (...) {
+	try
+   {
+		return Genode::Thread::myself()->alloc_secondary_stack("libco", stack_size);
+   }
+	catch (...)
+   {
 		Genode::error("libco: failed to allocate ", stack_size, " byte secondary stack");
 		return nullptr;
 	}
-
 }
 
 extern "C"
diff --git a/src/libretro/libretro-common/libco/libco.c b/src/libretro/libretro-common/libco/libco.c
index 50b6442c4b..44a65d528f 100644
--- a/src/libretro/libretro-common/libco/libco.c
+++ b/src/libretro/libretro-common/libco/libco.c
@@ -29,6 +29,10 @@ void genode_free_secondary_stack(void *stack);
     #include "ppc.c"
   #elif defined(__aarch64__)
     #include "aarch64.c"
+  #elif defined(PS2)
+    #include "ps2.c"
+  #elif defined(PSP)
+    #include "psp1.c"
   #elif defined VITA
     #include "scefiber.c"
   #elif defined(__ARM_EABI__) || defined(__arm__)
diff --git a/src/libretro/libretro-common/libco/ppc.c b/src/libretro/libretro-common/libco/ppc.c
index 391f7218e8..88faed611b 100644
--- a/src/libretro/libretro-common/libco/ppc.c
+++ b/src/libretro/libretro-common/libco/ppc.c
@@ -16,8 +16,8 @@ floating-point and AltiVec save/restore */
 #define LIBCO_MPROTECT (__unix__ && !LIBCO_PPC_ASM)
 
 #if LIBCO_MPROTECT
-	#include <unistd.h>
-	#include <sys/mman.h>
+#include <unistd.h>
+#include <sys/mman.h>
 #endif
 
 /* State format (offsets in 32-bit words)
@@ -58,8 +58,8 @@ or are directly to function */
 	#endif
 
 	/* Swap code is in ppc.S */
-	void co_swap_asm( cothread_t, cothread_t );
-	#define CO_SWAP_ASM( x, y ) co_swap_asm( x, y )
+	void co_swap_asm(cothread_t, cothread_t);
+	#define CO_SWAP_ASM(x, y) co_swap_asm(x, y)
 
 #else
 
@@ -272,122 +272,118 @@ static const uint32_t libco_ppc_code [] = {
 
 	#if LIBCO_PPCDESC
 		/* Function call goes through indirect descriptor */
-		#define CO_SWAP_ASM( x, y ) \
-			((void (*)( cothread_t, cothread_t )) (uintptr_t) x)( x, y )
+		#define CO_SWAP_ASM(x, y) \
+			((void (*)(cothread_t, cothread_t)) (uintptr_t) x)(x, y)
 	#else
 		/* Function call goes directly to code */
-		#define CO_SWAP_ASM( x, y ) \
-			((void (*)( cothread_t, cothread_t )) (uintptr_t) libco_ppc_code)( x, y )
+		#define CO_SWAP_ASM(x, y) \
+			((void (*)(cothread_t, cothread_t)) (uintptr_t) libco_ppc_code)(x, y)
 	#endif
 
 #endif
 
-static uint32_t* co_create_( unsigned size, uintptr_t entry )
+static uint32_t* co_create_( unsigned size, uintptr_t entry)
 {
-	uint32_t* t = (uint32_t*) malloc( size );
+	uint32_t *t = (uint32_t*)malloc(size);
 
-	(void) entry;
+#if LIBCO_PPCDESC
+   if (t)
+   {
+      /* Copy entry's descriptor */
+      memcpy(t, (void*)entry, sizeof(void*) * 3);
 
-	#if LIBCO_PPCDESC
-		if ( t )
-		{
-			/* Copy entry's descriptor */
-			memcpy( t, (void*) entry, sizeof (void*) * 3 );
-
-			/* Set function pointer to swap routine */
-			#ifdef LIBCO_PPC_ASM
-				*(const void**) t = *(void**) &co_swap_asm;
-			#else
-				*(const void**) t = libco_ppc_code;
-			#endif
-		}
+      /* Set function pointer to swap routine */
+#ifdef LIBCO_PPC_ASM
+      *(const void**) t = *(void**) &co_swap_asm;
+#else
+      *(const void**) t = libco_ppc_code;
+#endif
+   }
 	#endif
 
 	return t;
 }
 
-cothread_t co_create( unsigned int size, void (*entry_)( void ) )
+cothread_t co_create(unsigned int size, void (*entry_)(void))
 {
 	uintptr_t entry = (uintptr_t) entry_;
-	uint32_t* t = NULL;
+	uint32_t *t     = NULL;
 
 	/* Be sure main thread was successfully allocated */
-	if ( co_active() )
+	if (co_active())
 	{
 		size += state_size + above_stack + stack_align;
-		t = co_create_( size, entry );
+		t     = co_create_(size, entry);
 	}
 
-	if ( t )
-	{
-		uintptr_t sp;
-		int shift;
-
-		/* Save current registers into new thread, so that any special ones will
-		have proper values when thread is begun */
-		CO_SWAP_ASM( t, t );
-
-		#if LIBCO_PPCDESC
-			/* Get real address */
-			entry = (uintptr_t) *(void**) entry;
-		#endif
-
-		/* Put stack near end of block, and align */
-		sp = (uintptr_t) t + size - above_stack;
-		sp -= sp % stack_align;
-
-		/* On PPC32, we save and restore GPRs as 32 bits. For PPC64, we
-		save and restore them as 64 bits, regardless of the size the ABI
-		uses. So, we manually write pointers at the proper size. We always
-		save and restore at the same address, and since PPC is big-endian,
-		we must put the low byte first on PPC32. */
-
-		/* If uintptr_t is 32 bits, >>32 is undefined behavior, so we do two shifts
-		and don't have to care how many bits uintptr_t is. */
-		#if LIBCO_PPC64
-			shift = 16;
-		#else
-			shift = 0;
-		#endif
-
-		/* Set up so entry will be called on next swap */
-		t [8] = (uint32_t) (entry >> shift >> shift);
-		t [9] = (uint32_t) entry;
-
-		t [10] = (uint32_t) (sp >> shift >> shift);
-		t [11] = (uint32_t) sp;
-	}
+	if (t)
+   {
+      uintptr_t sp;
+#if LIBCO_PPC64
+      int shift = 16;
+#else
+      int shift = 0;
+#endif
+      /* Save current registers into new thread, so that any special ones will
+         have proper values when thread is begun */
+      CO_SWAP_ASM(t, t);
+
+#if LIBCO_PPCDESC
+      /* Get real address */
+      entry     = (uintptr_t) *(void**)entry;
+#endif
+
+      /* Put stack near end of block, and align */
+      sp        = (uintptr_t) t + size - above_stack;
+      sp       -= sp % stack_align;
+
+      /* On PPC32, we save and restore GPRs as 32 bits. For PPC64, we
+         save and restore them as 64 bits, regardless of the size the ABI
+         uses. So, we manually write pointers at the proper size. We always
+         save and restore at the same address, and since PPC is big-endian,
+         we must put the low byte first on PPC32. */
+
+      /* If uintptr_t is 32 bits, >>32 is undefined behavior, so we do two shifts
+         and don't have to care how many bits uintptr_t is. */
+
+      /* Set up so entry will be called on next swap */
+      t [8]  = (uint32_t) (entry >> shift >> shift);
+      t [9]  = (uint32_t) entry;
+
+      t [10] = (uint32_t) (sp    >> shift >> shift);
+      t [11] = (uint32_t) sp;
+   }
 
 	return t;
 }
 
-void co_delete( cothread_t t )
+void co_delete(cothread_t t)
 {
    free(t);
 }
 
-static void co_init_( void )
+static void co_init_(void)
 {
 #if LIBCO_MPROTECT
    /* TODO: pre- and post-pad PPC code so that this doesn't make other
       data executable and writable */
-   long page_size = sysconf( _SC_PAGESIZE );
-   if ( page_size > 0 )
+   long page_size = sysconf(_SC_PAGESIZE);
+   if (page_size > 0)
    {
       uintptr_t align = page_size;
       uintptr_t begin = (uintptr_t) libco_ppc_code;
       uintptr_t end   = begin + sizeof libco_ppc_code;
 
       /* Align beginning and end */
-      end   += align - 1;
-      end   -= end   % align;
-      begin -= begin % align;
+      end            += align - 1;
+      end            -= end   % align;
+      begin          -= begin % align;
 
-      mprotect( (void*) begin, end - begin, PROT_READ | PROT_WRITE | PROT_EXEC );
+      mprotect((void*)begin, end - begin, PROT_READ | PROT_WRITE | PROT_EXEC);
    }
 #endif
 
-   co_active_handle = co_create_( state_size, (uintptr_t) &co_switch );
+   co_active_handle = co_create_(state_size, (uintptr_t) &co_switch);
 }
 
 cothread_t co_active(void)
@@ -400,8 +396,7 @@ cothread_t co_active(void)
 
 void co_switch(cothread_t t)
 {
-   cothread_t old = co_active_handle;
+   cothread_t old   = co_active_handle;
    co_active_handle = t;
-
-   CO_SWAP_ASM( t, old );
+   CO_SWAP_ASM(t, old);
 }
diff --git a/src/libretro/libretro-common/libco/psp2.c b/src/libretro/libretro-common/libco/psp2.c
index d45568992d..82271bdf43 100644
--- a/src/libretro/libretro-common/libco/psp2.c
+++ b/src/libretro/libretro-common/libco/psp2.c
@@ -45,24 +45,21 @@ extern "C" {
       if (block < 0)
          return;
 
-      /* get base address */
-      ret = sceKernelGetMemBlockBase(block, &base);
-      if (ret < 0)
+      /* Get base address */
+      if ((ret = sceKernelGetMemBlockBase(block, &base)) < 0)
          return;
 
-      /* set domain to be writable by user */
-      ret = sceKernelOpenVMDomain();
-      if (ret < 0)
+      /* Set domain to be writable by user */
+      if ((ret = sceKernelOpenVMDomain()) < 0)
          return;
 
       memcpy(base, co_swap_function, sizeof co_swap_function);
 
-      /* set domain back to read-only */
-      ret = sceKernelCloseVMDomain();
-      if (ret < 0)
+      /* Set domain back to read-only */
+      if ((ret = sceKernelCloseVMDomain()) < 0)
          return;
 
-      /* flush icache */
+      /* Flush icache */
       ret = sceKernelSyncVMDomain(block, base,
             MB_ALIGN(FOUR_KB_ALIGN(sizeof co_swap_function)));
       if (ret < 0)
@@ -73,7 +70,8 @@ extern "C" {
 
    cothread_t co_active(void)
    {
-      if (!co_active_handle) co_active_handle = &co_active_buffer;
+      if (!co_active_handle)
+         co_active_handle = &co_active_buffer;
       return co_active_handle;
    }
 
@@ -82,15 +80,16 @@ extern "C" {
       unsigned long* handle = 0;
       if (!co_swap)
          co_init();
-      if (!co_active_handle) co_active_handle = &co_active_buffer;
-      size += 256;
-      size &= ~15;
+      if (!co_active_handle)
+         co_active_handle   = &co_active_buffer;
+      size                 += 256;
+      size                 &= ~15;
 
       if ((handle = (unsigned long*)malloc(size)))
       {
-         unsigned long* p = (unsigned long*)((unsigned char*)handle + size);
-         handle[8] = (unsigned long)p;
-         handle[9] = (unsigned long)entrypoint;
+         unsigned long *p   = (unsigned long*)((unsigned char*)handle + size);
+         handle[8]          = (unsigned long)p;
+         handle[9]          = (unsigned long)entrypoint;
       }
 
       return handle;
diff --git a/src/libretro/libretro-common/libco/scefiber.c b/src/libretro/libretro-common/libco/scefiber.c
index 11f521d607..0a2407301b 100644
--- a/src/libretro/libretro-common/libco/scefiber.c
+++ b/src/libretro/libretro-common/libco/scefiber.c
@@ -15,18 +15,17 @@ extern "C" {
 
 static thread_local cothread_t co_active_ = 0;
 
-typedef struct SceFiber {
+typedef struct SceFiber
+{
 	char reserved[128];
 } SceFiber __attribute__( ( aligned ( 8 ) ) ) ;
 
-int32_t _sceFiberInitializeImpl(SceFiber* fiber, char* name, void* entry, uint32_t argOnInitialize, void* addrContext, int32_t sizeContext, void* params);
-
+/* Forward declarations */
+int32_t _sceFiberInitializeImpl(SceFiber *fiber, char *name, void *entry, uint32_t argOnInitialize,
+      void* addrContext, int32_t sizeContext, void* params);
 int32_t sceFiberFinalize(SceFiber* fiber);
-
 int32_t sceFiberRun(SceFiber* fiber, uint32_t argOnRunTo, uint32_t* argOnRun);
-
 int32_t sceFiberSwitch(SceFiber* fiber, uint32_t argOnRunTo, uint32_t* argOnRun);
-
 int32_t sceFiberReturnToThread(uint32_t argOnReturn, uint32_t* argOnRun);
 
 static void co_thunk(uint32_t argOnInitialize, uint32_t argOnRun)
@@ -36,9 +35,9 @@ static void co_thunk(uint32_t argOnInitialize, uint32_t argOnRun)
 
 cothread_t co_active(void)
 {
-   if(!co_active_)
+   if (!co_active_)
    {
-		  sceSysmoduleLoadModule(SCE_SYSMODULE_FIBER);
+      sceSysmoduleLoadModule(SCE_SYSMODULE_FIBER);
       co_active_ = (cothread_t)1;
    }
    return co_active_;
@@ -46,48 +45,45 @@ cothread_t co_active(void)
 
 cothread_t co_create(unsigned int heapsize, void (*coentry)(void))
 {
-   SceFiber* tailFiber = malloc(sizeof(SceFiber));
-	 char * m_contextBuffer = malloc(sizeof(char)*heapsize);
-	 if(!co_active_)
+   int ret;
+   SceFiber* tail_fiber   = malloc(sizeof(SceFiber));
+   char * m_ctxbuf        = malloc(sizeof(char)*heapsize);
+   if (!co_active_)
    {
       sceSysmoduleLoadModule(SCE_SYSMODULE_FIBER);
-      co_active_ = (cothread_t)1;
-   }
-
-   //_sceFiberInitializeImpl
-   int ret = _sceFiberInitializeImpl(tailFiber, "tailFiber", co_thunk, (uint32_t)coentry, (void*) m_contextBuffer, heapsize, NULL);
-   if(ret==0){
-     return (cothread_t)tailFiber;
-   }else{
-     return (cothread_t)ret;
+      co_active_          = (cothread_t)1;
    }
 
+   /* _sceFiberInitializeImpl */
+   if ((ret = _sceFiberInitializeImpl(
+               tail_fiber, "tailFiber", co_thunk,
+               (uint32_t)coentry, (void*)m_ctxbuf, heapsize, NULL)) == 0)
+      return (cothread_t)tail_fiber;
+   return (cothread_t)ret;
 }
 
 void co_delete(cothread_t cothread)
 {
-	 if(cothread == (cothread_t)1){
-		 return;
-	 }
-   sceFiberFinalize((SceFiber*)cothread);
+   if (cothread != (cothread_t)1)
+      sceFiberFinalize((SceFiber*)cothread);
 }
 
 void co_switch(cothread_t cothread)
 {
-
-   uint32_t argOnReturn = 0;
-   if(cothread == (cothread_t)1){
-     co_active_ = cothread;
-     sceFiberReturnToThread(0, NULL);
-   }else{
-		 SceFiber* theFiber = (SceFiber*)cothread;
-		 if(co_active_ == (cothread_t)1){
-			 co_active_ = cothread;
-			 sceFiberRun(theFiber, 0, &argOnReturn);
-		 }else{
-			 co_active_ = cothread;
-			 sceFiberSwitch(theFiber, 0, &argOnReturn);
-		 }
+   uint32_t argOnReturn  = 0;
+   if (cothread == (cothread_t)1)
+   {
+      co_active_         = cothread;
+      sceFiberReturnToThread(0, NULL);
+   }
+   else
+   {
+      SceFiber* theFiber = (SceFiber*)cothread;
+      co_active_         = cothread;
+      if (co_active_ == (cothread_t)1)
+         sceFiberRun(theFiber, 0, &argOnReturn);
+      else
+         sceFiberSwitch(theFiber, 0, &argOnReturn);
    }
 }
 
diff --git a/src/libretro/libretro-common/libco/sjlj.c b/src/libretro/libretro-common/libco/sjlj.c
index bb6513675b..c661d15016 100644
--- a/src/libretro/libretro-common/libco/sjlj.c
+++ b/src/libretro/libretro-common/libco/sjlj.c
@@ -33,7 +33,7 @@ static thread_local cothread_struct *creating, *co_running = 0;
 
 static void springboard(int ignored)
 {
-   if(sigsetjmp(creating->context, 0))
+   if (sigsetjmp(creating->context, 0))
       co_running->coentry();
 }
 
@@ -46,42 +46,40 @@ cothread_t co_active(void)
 
 cothread_t co_create(unsigned int size, void (*coentry)(void))
 {
-   if(!co_running)
+   cothread_struct *thread;
+   if (!co_running)
       co_running = &co_primary;
 
-   cothread_struct *thread = (cothread_struct*)malloc(sizeof(cothread_struct));
-
-   if(thread)
+   if ((thread = (cothread_struct*)malloc(sizeof(cothread_struct))))
    {
       stack_t stack;
       stack_t old_stack;
 
-      struct sigaction handler     = {{0}};
-      struct sigaction old_handler = {{0}};
-
       thread->coentry = thread->stack = 0;
 
-      stack.ss_flags = 0;
-      stack.ss_size = size;
-      thread->stack = stack.ss_sp = malloc(size);
+      stack.ss_flags  = 0;
+      stack.ss_size   = size;
+      thread->stack   = stack.ss_sp = malloc(size);
 
-      if(stack.ss_sp && !sigaltstack(&stack, &old_stack))
+      if (stack.ss_sp && !sigaltstack(&stack, &old_stack))
       {
-         handler.sa_handler = springboard;
-         handler.sa_flags   = SA_ONSTACK;
+         struct sigaction old_handler = {{0}};
+         struct sigaction handler     = {{0}};
+         handler.sa_handler           = springboard;
+         handler.sa_flags             = SA_ONSTACK;
          sigemptyset(&handler.sa_mask);
-         creating = thread;
+         creating                     = thread;
 
-         if(!sigaction(SIGUSR1, &handler, &old_handler))
+         if (!sigaction(SIGUSR1, &handler, &old_handler))
          {
-            if(!raise(SIGUSR1))
-               thread->coentry = coentry;
+            if (!raise(SIGUSR1))
+               thread->coentry        = coentry;
             sigaltstack(&old_stack, 0);
             sigaction(SIGUSR1, &old_handler, 0);
          }
       }
 
-      if(thread->coentry != coentry)
+      if (thread->coentry != coentry)
       {
          co_delete(thread);
          thread = 0;
@@ -95,7 +93,7 @@ void co_delete(cothread_t cothread)
 {
    if (cothread)
    {
-      if(((cothread_struct*)cothread)->stack)
+      if (((cothread_struct*)cothread)->stack)
          free(((cothread_struct*)cothread)->stack);
       free(cothread);
    }
diff --git a/src/libretro/libretro-common/libco/ucontext.c b/src/libretro/libretro-common/libco/ucontext.c
index 3e21816023..949273d506 100644
--- a/src/libretro/libretro-common/libco/ucontext.c
+++ b/src/libretro/libretro-common/libco/ucontext.c
@@ -37,13 +37,13 @@ cothread_t co_active(void)
 
 cothread_t co_create(unsigned int heapsize, void (*coentry)(void))
 {
+   ucontext_t *thread;
    if (!co_running)
       co_running = &co_primary;
-   ucontext_t *thread = (ucontext_t*)malloc(sizeof(ucontext_t));
 
-   if(thread)
+   if ((thread = (ucontext_t*)malloc(sizeof(ucontext_t))))
    {
-      if((!getcontext(thread) && !(thread->uc_stack.ss_sp = 0)) && (thread->uc_stack.ss_sp = malloc(heapsize)))
+      if ((!getcontext(thread) && !(thread->uc_stack.ss_sp = 0)) && (thread->uc_stack.ss_sp = malloc(heapsize)))
       {
          thread->uc_link = co_running;
          thread->uc_stack.ss_size = heapsize;
@@ -63,7 +63,7 @@ void co_delete(cothread_t cothread)
    if (!cothread)
       return;
 
-   if(((ucontext_t*)cothread)->uc_stack.ss_sp)
+   if (((ucontext_t*)cothread)->uc_stack.ss_sp)
       free(((ucontext_t*)cothread)->uc_stack.ss_sp);
    free(cothread);
 }
@@ -71,8 +71,7 @@ void co_delete(cothread_t cothread)
 void co_switch(cothread_t cothread)
 {
    ucontext_t *old_thread = co_running;
-
-   co_running = (ucontext_t*)cothread;
+   co_running             = (ucontext_t*)cothread;
    swapcontext(old_thread, co_running);
 }
 
diff --git a/src/libretro/libretro-common/libco/x86.c b/src/libretro/libretro-common/libco/x86.c
index 1a1d01d0d8..24e5aa6ce2 100644
--- a/src/libretro/libretro-common/libco/x86.c
+++ b/src/libretro/libretro-common/libco/x86.c
@@ -70,7 +70,7 @@ static void crash(void)
 
 cothread_t co_active(void)
 {
-   if(!co_active_handle)
+   if (!co_active_handle)
       co_active_handle = &co_active_buffer;
    return co_active_handle;
 }
@@ -78,24 +78,24 @@ cothread_t co_active(void)
 cothread_t co_create(unsigned int size, void (*entrypoint)(void))
 {
    cothread_t handle;
-   if(!co_swap)
+   if (!co_swap)
    {
       co_init();
       co_swap = (void (fastcall*)(cothread_t, cothread_t))co_swap_function;
    }
 
-   if(!co_active_handle)
+   if (!co_active_handle)
       co_active_handle = &co_active_buffer;
 
    size += 256; /* allocate additional space for storage */
    size &= ~15; /* align stack to 16-byte boundary */
 
-   if((handle = (cothread_t)malloc(size)))
+   if ((handle = (cothread_t)malloc(size)))
    {
-      long *p = (long*)((char*)handle + size); /* seek to top of stack */
-      *--p = (long)crash;                      /* crash if entrypoint returns */
-      *--p = (long)entrypoint;                 /* start of function */
-      *(long*)handle = (long)p;                /* stack pointer */
+      long *p        = (long*)((char*)handle + size); /* seek to top of stack */
+      *--p           = (long)crash;                   /* crash if entrypoint returns */
+      *--p           = (long)entrypoint;              /* start of function */
+      *(long*)handle = (long)p;                       /* stack pointer */
    }
 
    return handle;
diff --git a/src/libretro/libretro-common/lists/dir_list.c b/src/libretro/libretro-common/lists/dir_list.c
index 417b0faa30..13a2b2267c 100644
--- a/src/libretro/libretro-common/lists/dir_list.c
+++ b/src/libretro/libretro-common/lists/dir_list.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (dir_list.c).
@@ -46,6 +46,22 @@ static int qstrcmp_plain(const void *a_, const void *b_)
    return strcasecmp(a->data, b->data);
 }
 
+static int qstrcmp_plain_noext(const void *a_, const void *b_)
+{
+   const struct string_list_elem *a = (const struct string_list_elem*)a_;
+   const struct string_list_elem *b = (const struct string_list_elem*)b_;
+
+   const char *ext_a = path_get_extension(a->data);
+   size_t l_a = string_is_empty(ext_a) ? strlen(a->data) : (ext_a - a->data - 1);
+   const char *ext_b = path_get_extension(b->data);
+   size_t l_b = string_is_empty(ext_b) ? strlen(b->data) : (ext_b - b->data - 1);
+
+   int rv = strncasecmp(a->data, b->data, MIN(l_a, l_b));
+   if (rv == 0 && l_a != l_b)
+       return (int)(l_a - l_b);
+   return rv;
+}
+
 static int qstrcmp_dir(const void *a_, const void *b_)
 {
    const struct string_list_elem *a = (const struct string_list_elem*)a_;
@@ -59,13 +75,25 @@ static int qstrcmp_dir(const void *a_, const void *b_)
    return strcasecmp(a->data, b->data);
 }
 
+static int qstrcmp_dir_noext(const void *a_, const void *b_)
+{
+   const struct string_list_elem *a = (const struct string_list_elem*)a_;
+   const struct string_list_elem *b = (const struct string_list_elem*)b_;
+   int a_type = a->attr.i;
+   int b_type = b->attr.i;
+
+   /* Sort directories before files. */
+   if (a_type != b_type)
+      return b_type - a_type;
+   return qstrcmp_plain_noext(a, b);
+}
+
 /**
  * dir_list_sort:
  * @list      : pointer to the directory listing.
  * @dir_first : move the directories in the listing to the top?
  *
  * Sorts a directory listing.
- *
  **/
 void dir_list_sort(struct string_list *list, bool dir_first)
 {
@@ -74,18 +102,38 @@ void dir_list_sort(struct string_list *list, bool dir_first)
             dir_first ? qstrcmp_dir : qstrcmp_plain);
 }
 
+/**
+ * dir_list_sort_ignore_ext:
+ * @list      : pointer to the directory listing.
+ * @dir_first : move the directories in the listing to the top?
+ *
+ * Sorts a directory listing. File extensions are ignored.
+ **/
+void dir_list_sort_ignore_ext(struct string_list *list, bool dir_first)
+{
+   if (list)
+      qsort(list->elems, list->size, sizeof(struct string_list_elem),
+            dir_first ? qstrcmp_dir_noext : qstrcmp_plain_noext);
+}
+
 /**
  * dir_list_free:
  * @list : pointer to the directory listing
  *
  * Frees a directory listing.
- *
  **/
 void dir_list_free(struct string_list *list)
 {
    string_list_free(list);
 }
 
+bool dir_list_deinitialize(struct string_list *list)
+{
+   if (!list)
+      return false;
+   return string_list_deinitialize(list);
+}
+
 /**
  * dir_list_read:
  * @dir                : directory path.
@@ -98,7 +146,7 @@ void dir_list_free(struct string_list *list)
  *
  * Add files within a directory to an existing string list
  *
- * Returns: -1 on error, 0 on success.
+ * @return -1 on error, 0 on success.
  **/
 static int dir_list_read(const char *dir,
       struct string_list *list, struct string_list *ext_list,
@@ -116,16 +164,31 @@ static int dir_list_read(const char *dir,
       char file_path[PATH_MAX_LENGTH];
       const char *name                = retro_dirent_get_name(entry);
 
-      if (!include_hidden && *name == '.')
-         continue;
-      if (!strcmp(name, ".") || !strcmp(name, ".."))
-         continue;
+      if (name[0] == '.')
+      {
+         /* Do not include hidden files and directories */
+         if (!include_hidden)
+            continue;
+
+         /* char-wise comparisons to avoid string comparison */
 
-      file_path[0] = '\0';
-      fill_pathname_join(file_path, dir, name, sizeof(file_path));
+         /* Do not include current dir */
+         if (name[1] == '\0')
+            continue;
+         /* Do not include parent dir */
+         if (name[1] == '.' && name[2] == '\0')
+            continue;
+      }
+
+      fill_pathname_join_special(file_path, dir, name, sizeof(file_path));
 
       if (retro_dirent_is_dir(entry, NULL))
       {
+         /* Exclude this frequent hidden dir on platforms which can not handle hidden attribute */
+#ifndef _WIN32
+         if (!include_hidden && strcmp(name, "System Volume Information") == 0)
+            continue;
+#endif
          if (recursive)
             dir_list_read(file_path, list, ext_list, include_dirs,
                   include_hidden, include_compressed, recursive);
@@ -188,7 +251,7 @@ static int dir_list_read(const char *dir,
  *
  * Create a directory listing, appending to an existing list
  *
- * Returns: true success, false in case of error.
+ * @return Returns true on success, otherwise false.
  **/
 bool dir_list_append(struct string_list *list,
       const char *dir,
@@ -196,12 +259,19 @@ bool dir_list_append(struct string_list *list,
       bool include_hidden, bool include_compressed,
       bool recursive)
 {
-   struct string_list *ext_list   = ext ? string_split(ext, "|") : NULL;
-   bool ret                       = dir_list_read(dir, list, ext_list,
-         include_dirs, include_hidden, include_compressed, recursive) != -1;
-
-   string_list_free(ext_list);
+   bool ret                         = false;
+   struct string_list ext_list      = {0};
+   struct string_list *ext_list_ptr = NULL;
 
+   if (ext)
+   {
+      string_list_initialize(&ext_list);
+      string_split_noalloc(&ext_list, ext, "|");
+      ext_list_ptr                  = &ext_list;
+   }
+   ret                            = dir_list_read(dir, list, ext_list_ptr,
+         include_dirs, include_hidden, include_compressed, recursive) != -1;
+   string_list_deinitialize(&ext_list);
    return ret;
 }
 
@@ -216,7 +286,7 @@ bool dir_list_append(struct string_list *list,
  *
  * Create a directory listing.
  *
- * Returns: pointer to a directory listing of type 'struct string_list *' on success,
+ * @return pointer to a directory listing of type 'struct string_list *' on success,
  * NULL in case of error. Has to be freed manually.
  **/
 struct string_list *dir_list_new(const char *dir,
@@ -224,9 +294,9 @@ struct string_list *dir_list_new(const char *dir,
       bool include_hidden, bool include_compressed,
       bool recursive)
 {
-   struct string_list *list       = NULL;
+   struct string_list *list       = string_list_new();
 
-   if (!(list = string_list_new()))
+   if (!list)
       return NULL;
 
    if (!dir_list_append(list, dir, ext, include_dirs,
@@ -238,3 +308,21 @@ struct string_list *dir_list_new(const char *dir,
 
    return list;
 }
+
+/**
+ * dir_list_initialize:
+ *
+ * NOTE: @list must zero initialised before
+ * calling this function, otherwise UB.
+ **/
+bool dir_list_initialize(struct string_list *list,
+      const char *dir,
+      const char *ext, bool include_dirs,
+      bool include_hidden, bool include_compressed,
+      bool recursive)
+{
+   if (list && string_list_initialize(list))
+      return dir_list_append(list, dir, ext, include_dirs,
+            include_hidden, include_compressed, recursive);
+   return false;
+}
diff --git a/src/libretro/libretro-common/lists/file_list.c b/src/libretro/libretro-common/lists/file_list.c
index d44bbcbd6e..ba1bba7707 100644
--- a/src/libretro/libretro-common/lists/file_list.c
+++ b/src/libretro/libretro-common/lists/file_list.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (file_list.c).
@@ -29,6 +29,32 @@
 #include <string/stdstring.h>
 #include <compat/strcasestr.h>
 
+static bool file_list_deinitialize_internal(file_list_t *list)
+{
+   size_t i;
+   for (i = 0; i < list->size; i++)
+   {
+      file_list_free_userdata(list, i);
+      file_list_free_actiondata(list, i);
+
+      if (list->list[i].path)
+         free(list->list[i].path);
+      list->list[i].path = NULL;
+
+      if (list->list[i].label)
+         free(list->list[i].label);
+      list->list[i].label = NULL;
+
+      if (list->list[i].alt)
+         free(list->list[i].alt);
+      list->list[i].alt = NULL;
+   }
+   if (list->list)
+      free(list->list);
+   list->list = NULL;
+   return true;
+}
+
 bool file_list_reserve(file_list_t *list, size_t nitems)
 {
    const size_t item_size = sizeof(struct item_file);
@@ -37,9 +63,7 @@ bool file_list_reserve(file_list_t *list, size_t nitems)
    if (nitems < list->capacity || nitems > (size_t)-1/item_size)
       return false;
 
-   new_data = (struct item_file*)realloc(list->list, nitems * item_size);
-
-   if (!new_data)
+   if (!(new_data = (struct item_file*)realloc(list->list, nitems * item_size)))
       return false;
 
    memset(&new_data[list->capacity], 0, item_size * (nitems - list->capacity));
@@ -50,18 +74,6 @@ bool file_list_reserve(file_list_t *list, size_t nitems)
    return true;
 }
 
-bool file_list_prepend(file_list_t *list,
-      const char *path, const char *label,
-      unsigned type, size_t directory_ptr,
-      size_t entry_idx)
-{
-   return file_list_insert(list, path,
-      label, type,
-      directory_ptr, entry_idx,
-      0
-   );
-}
-
 bool file_list_insert(file_list_t *list,
       const char *path, const char *label,
       unsigned type, size_t directory_ptr,
@@ -78,7 +90,16 @@ bool file_list_insert(file_list_t *list,
    for (i = (unsigned)list->size; i > (int)idx; i--)
    {
       struct item_file *copy = (struct item_file*)
-         calloc(1, sizeof(struct item_file));
+         malloc(sizeof(struct item_file));
+
+      copy->path             = NULL;
+      copy->label            = NULL;
+      copy->alt              = NULL;
+      copy->type             = 0;
+      copy->directory_ptr    = 0;
+      copy->entry_idx        = 0;
+      copy->userdata         = NULL;
+      copy->actiondata       = NULL;
 
       memcpy(copy, &list->list[i-1], sizeof(struct item_file));
 
@@ -137,19 +158,6 @@ bool file_list_append(file_list_t *list,
    return true;
 }
 
-size_t file_list_get_size(const file_list_t *list)
-{
-   if (!list)
-      return 0;
-   return list->size;
-}
-
-size_t file_list_get_directory_ptr(const file_list_t *list)
-{
-   size_t size = file_list_get_size(list);
-   return list->list[size].directory_ptr;
-}
-
 void file_list_pop(file_list_t *list, size_t *directory_ptr)
 {
    if (!list)
@@ -173,34 +181,23 @@ void file_list_pop(file_list_t *list, size_t *directory_ptr)
 
 void file_list_free(file_list_t *list)
 {
-   size_t i;
-
    if (!list)
       return;
-
-   for (i = 0; i < list->size; i++)
-   {
-      file_list_free_userdata(list, i);
-      file_list_free_actiondata(list, i);
-
-      if (list->list[i].path)
-         free(list->list[i].path);
-      list->list[i].path = NULL;
-
-      if (list->list[i].label)
-         free(list->list[i].label);
-      list->list[i].label = NULL;
-
-      if (list->list[i].alt)
-         free(list->list[i].alt);
-      list->list[i].alt = NULL;
-   }
-   if (list->list)
-      free(list->list);
-   list->list = NULL;
+   file_list_deinitialize_internal(list);
    free(list);
 }
 
+bool file_list_deinitialize(file_list_t *list)
+{
+   if (!list)
+      return false;
+   if (!file_list_deinitialize_internal(list))
+      return false;
+   list->capacity = 0;
+   list->size     = 0;
+   return true;
+}
+
 void file_list_clear(file_list_t *list)
 {
    size_t i;
@@ -226,21 +223,7 @@ void file_list_clear(file_list_t *list)
    list->size = 0;
 }
 
-void file_list_set_label_at_offset(file_list_t *list, size_t idx,
-      const char *label)
-{
-   if (!list)
-      return;
-
-   if (list->list[idx].label)
-      free(list->list[idx].label);
-   list->list[idx].alt      = NULL;
-
-   if (label)
-      list->list[idx].label = strdup(label);
-}
-
-void file_list_get_label_at_offset(const file_list_t *list, size_t idx,
+static void file_list_get_label_at_offset(const file_list_t *list, size_t idx,
       const char **label)
 {
    if (!label || !list)
@@ -256,13 +239,9 @@ void file_list_set_alt_at_offset(file_list_t *list, size_t idx,
 {
    if (!list || !alt)
       return;
-
    if (list->list[idx].alt)
       free(list->list[idx].alt);
-   list->list[idx].alt      = NULL;
-
-   if (alt)
-      list->list[idx].alt   = strdup(alt);
+   list->list[idx].alt   = strdup(alt);
 }
 
 static int file_list_alt_cmp(const void *a_, const void *b_)
@@ -303,18 +282,6 @@ void *file_list_get_userdata_at_offset(const file_list_t *list, size_t idx)
    return list->list[idx].userdata;
 }
 
-void file_list_set_userdata(const file_list_t *list, size_t idx, void *ptr)
-{
-   if (list && ptr)
-      list->list[idx].userdata = ptr;
-}
-
-void file_list_set_actiondata(const file_list_t *list, size_t idx, void *ptr)
-{
-   if (list && ptr)
-      list->list[idx].actiondata = ptr;
-}
-
 void *file_list_get_actiondata_at_offset(const file_list_t *list, size_t idx)
 {
    if (!list)
@@ -340,38 +307,6 @@ void file_list_free_userdata(const file_list_t *list, size_t idx)
    list->list[idx].userdata = NULL;
 }
 
-void *file_list_get_last_actiondata(const file_list_t *list)
-{
-   if (!list)
-      return NULL;
-   return list->list[list->size - 1].actiondata;
-}
-
-void file_list_get_at_offset(const file_list_t *list, size_t idx,
-      const char **path, const char **label, unsigned *file_type,
-      size_t *entry_idx)
-{
-   if (!list)
-      return;
-
-   if (path)
-      *path      = list->list[idx].path;
-   if (label)
-      *label     = list->list[idx].label;
-   if (file_type)
-      *file_type = list->list[idx].type;
-   if (entry_idx)
-      *entry_idx = list->list[idx].entry_idx;
-}
-
-void file_list_get_last(const file_list_t *list,
-      const char **path, const char **label,
-      unsigned *file_type, size_t *entry_idx)
-{
-   if (list && list->size)
-      file_list_get_at_offset(list, list->size - 1, path, label, file_type, entry_idx);
-}
-
 bool file_list_search(const file_list_t *list, const char *needle, size_t *idx)
 {
    size_t i;
@@ -394,8 +329,7 @@ bool file_list_search(const file_list_t *list, const char *needle, size_t *idx)
             continue;
       }
 
-      str = (const char *)strcasestr(alt, needle);
-      if (str == alt)
+      if ((str = (const char *)strcasestr(alt, needle)) == alt)
       {
          /* Found match with first chars, best possible match. */
          *idx = i;
diff --git a/src/libretro/libretro-common/lists/string_list.c b/src/libretro/libretro-common/lists/string_list.c
index 26d1d58a9b..1d485ac321 100644
--- a/src/libretro/libretro-common/lists/string_list.c
+++ b/src/libretro/libretro-common/lists/string_list.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (string_list.c).
@@ -29,20 +29,14 @@
 #include <compat/posix_string.h>
 #include <string/stdstring.h>
 
-/**
- * string_list_free
- * @list             : pointer to string list object
- *
- * Frees a string list.
- */
-void string_list_free(struct string_list *list)
+static bool string_list_deinitialize_internal(struct string_list *list)
 {
-   size_t i;
    if (!list)
-      return;
+      return false;
 
    if (list->elems)
    {
+      unsigned i;
       for (i = 0; i < list->size; i++)
       {
          if (list->elems[i].data)
@@ -57,7 +51,8 @@ void string_list_free(struct string_list *list)
    }
 
    list->elems = NULL;
-   free(list);
+
+   return true;
 }
 
 /**
@@ -67,7 +62,7 @@ void string_list_free(struct string_list *list)
  *
  * Change maximum capacity of string list's size.
  *
- * Returns: true (1) if successful, otherwise false (0).
+ * @return true if successful, otherwise false.
  **/
 static bool string_list_capacity(struct string_list *list, size_t cap)
 {
@@ -85,30 +80,82 @@ static bool string_list_capacity(struct string_list *list, size_t cap)
    return true;
 }
 
+/**
+ * string_list_free
+ * @list             : pointer to string list object
+ *
+ * Frees a string list.
+ **/
+void string_list_free(struct string_list *list)
+{
+   if (!list)
+      return;
+
+   string_list_deinitialize_internal(list);
+
+   free(list);
+}
+
+bool string_list_deinitialize(struct string_list *list)
+{
+   if (!list)
+      return false;
+   if (!string_list_deinitialize_internal(list))
+      return false;
+   list->elems              = NULL;
+   list->size               = 0;
+   list->cap                = 0;
+   return true;
+}
+
 /**
  * string_list_new:
  *
  * Creates a new string list. Has to be freed manually.
  *
- * Returns: new string list if successful, otherwise NULL.
- */
+ * @return New string list if successful, otherwise NULL.
+ **/
 struct string_list *string_list_new(void)
 {
+   struct string_list_elem *
+      elems                 = NULL;
    struct string_list *list = (struct string_list*)
-      calloc(1, sizeof(*list));
-
+      malloc(sizeof(*list));
    if (!list)
       return NULL;
 
-   if (!string_list_capacity(list, 32))
+   if (!(elems = (struct string_list_elem*)
+      calloc(32, sizeof(*elems))))
    {
       string_list_free(list);
       return NULL;
    }
 
+   list->elems              = elems;
+   list->size               = 0;
+   list->cap                = 32;
+
    return list;
 }
 
+bool string_list_initialize(struct string_list *list)
+{
+   struct string_list_elem *
+      elems                 = NULL;
+   if (!list)
+      return false;
+   if (!(elems = (struct string_list_elem*)
+      calloc(32, sizeof(*elems))))
+   {
+      string_list_deinitialize(list);
+      return false;
+   }
+   list->elems              = elems;
+   list->size               = 0;
+   list->cap                = 32;
+   return true;
+}
+
 /**
  * string_list_append:
  * @list             : pointer to string list
@@ -117,19 +164,25 @@ struct string_list *string_list_new(void)
  *
  * Appends a new element to the string list.
  *
- * Returns: true (1) if successful, otherwise false (0).
+ * @return true if successful, otherwise false.
  **/
 bool string_list_append(struct string_list *list, const char *elem,
       union string_list_elem_attr attr)
 {
    char *data_dup = NULL;
 
+   /* Note: If 'list' is incorrectly initialised
+    * (i.e. if struct is zero initialised and
+    * string_list_initialize() is not called on
+    * it) capacity will be zero. This will cause
+    * a segfault. Handle this case by forcing the new
+    * capacity to a fixed size of 32 */
    if (list->size >= list->cap &&
-         !string_list_capacity(list, list->cap * 2))
+         !string_list_capacity(list,
+               (list->cap > 0) ? (list->cap * 2) : 32))
       return false;
 
-   data_dup = strdup(elem);
-   if (!data_dup)
+   if (!(data_dup = strdup(elem)))
       return false;
 
    list->elems[list->size].data = data_dup;
@@ -148,7 +201,7 @@ bool string_list_append(struct string_list *list, const char *elem,
  *
  * Appends a new element to the string list.
  *
- * Returns: true (1) if successful, otherwise false (0).
+ * @return true if successful, otherwise false.
  **/
 bool string_list_append_n(struct string_list *list, const char *elem,
       unsigned length, union string_list_elem_attr attr)
@@ -159,9 +212,7 @@ bool string_list_append_n(struct string_list *list, const char *elem,
          !string_list_capacity(list, list->cap * 2))
       return false;
 
-   data_dup = (char*)malloc(length + 1);
-
-   if (!data_dup)
+   if (!(data_dup = (char*)malloc(length + 1)))
       return false;
 
    strlcpy(data_dup, elem, length + 1);
@@ -197,11 +248,22 @@ void string_list_set(struct string_list *list,
  *
  * A string list will be joined/concatenated as a
  * string to @buffer, delimited by @delim.
- */
+ **/
 void string_list_join_concat(char *buffer, size_t size,
       const struct string_list *list, const char *delim)
 {
-   size_t i, len = strlen(buffer);
+   size_t i;
+   size_t len = strlen_size(buffer, size);
+
+   /* If buffer is already 'full', nothing
+    * further can be added
+    * > This condition will also be triggered
+    *   if buffer is not NULL-terminated,
+    *   in which case any attempt to increment
+    *   buffer or decrement size would lead to
+    *   undefined behaviour */
+   if (len >= size)
+      return;
 
    buffer += len;
    size   -= len;
@@ -231,10 +293,9 @@ struct string_list *string_split(const char *str, const char *delim)
    struct string_list *list = string_list_new();
 
    if (!list)
-      goto error;
+      return NULL;
 
-   copy = strdup(str);
-   if (!copy)
+   if (!(copy = strdup(str)))
       goto error;
 
    tmp = strtok_r(copy, delim, &save);
@@ -259,6 +320,39 @@ struct string_list *string_split(const char *str, const char *delim)
    return NULL;
 }
 
+bool string_split_noalloc(struct string_list *list,
+      const char *str, const char *delim)
+{
+   char *save      = NULL;
+   char *copy      = NULL;
+   const char *tmp = NULL;
+
+   if (!list)
+      return false;
+
+   if (!(copy = strdup(str)))
+      return false;
+
+   tmp             = strtok_r(copy, delim, &save);
+   while (tmp)
+   {
+      union string_list_elem_attr attr;
+
+      attr.i = 0;
+
+      if (!string_list_append(list, tmp, attr))
+      {
+         free(copy);
+         return false;
+      }
+
+      tmp = strtok_r(NULL, delim, &save);
+   }
+
+   free(copy);
+   return true;
+}
+
 /**
  * string_separate:
  * @str              : string to turn into a string list
@@ -268,8 +362,8 @@ struct string_list *string_split(const char *str, const char *delim)
  * Includes empty strings - i.e. two adjacent delimiters will resolve
  * to a string list element of "".
  *
- * Returns: new string list if successful, otherwise NULL.
- */
+ * @return New string list if successful, otherwise NULL.
+ **/
 struct string_list *string_separate(char *str, const char *delim)
 {
    char *token              = NULL;
@@ -278,15 +372,13 @@ struct string_list *string_separate(char *str, const char *delim)
 
    /* Sanity check */
    if (!str || string_is_empty(delim))
-      goto error;
+      return NULL;
+   if (!(list = string_list_new()))
+	   return NULL;
 
    str_ptr = &str;
-   list    = string_list_new();
+   token   = string_tokenize(str_ptr, delim);
 
-   if (!list)
-      goto error;
-
-   token = string_tokenize(str_ptr, delim);
    while (token)
    {
       union string_list_elem_attr attr;
@@ -294,118 +386,145 @@ struct string_list *string_separate(char *str, const char *delim)
       attr.i = 0;
 
       if (!string_list_append(list, token, attr))
-         goto error;
+      {
+         free(token);
+         string_list_free(list);
+         return NULL;
+      }
 
       free(token);
-      token = NULL;
-
       token = string_tokenize(str_ptr, delim);
    }
 
    return list;
+}
+
+bool string_separate_noalloc(
+      struct string_list *list,
+      char *str, const char *delim)
+{
+   char *token              = NULL;
+   char **str_ptr           = NULL;
+
+   /* Sanity check */
+   if (!str || string_is_empty(delim) || !list)
+      return false;
+
+   str_ptr = &str;
+   token   = string_tokenize(str_ptr, delim);
+
+   while (token)
+   {
+      union string_list_elem_attr attr;
+
+      attr.i = 0;
+
+      if (!string_list_append(list, token, attr))
+      {
+         free(token);
+         return false;
+      }
 
-error:
-   if (token)
       free(token);
-   if (list)
-      string_list_free(list);
-   return NULL;
+      token = string_tokenize(str_ptr, delim);
+   }
+
+   return true;
 }
 
 /**
  * string_list_find_elem:
- * @list             : pointer to string list
- * @elem             : element to find inside the string list.
+ *
+ * @param list
+ * Pointer to string list
+ * @param elem
+ * Element to find inside the string list.
  *
  * Searches for an element (@elem) inside the string list.
  *
- * Returns: true (1) if element could be found, otherwise false (0).
+ * @return Number of elements found, otherwise 0.
  */
 int string_list_find_elem(const struct string_list *list, const char *elem)
 {
-   size_t i;
-
-   if (!list)
-      return false;
-
-   for (i = 0; i < list->size; i++)
+   if (list)
    {
-      if (string_is_equal_noncase(list->elems[i].data, elem))
-         return (int)(i + 1);
+      size_t i;
+      for (i = 0; i < list->size; i++)
+      {
+         if (string_is_equal_noncase(list->elems[i].data, elem))
+            return (int)(i + 1);
+      }
    }
-
-   return false;
+   return 0;
 }
 
 /**
  * string_list_find_elem_prefix:
- * @list             : pointer to string list
- * @prefix           : prefix to append to @elem
- * @elem             : element to find inside the string list.
+ *
+ * @param list
+ * Pointer to string list
+ * @param prefix
+ * Prefix to append to @elem
+ * @param elem
+ * Element to find inside the string list.
  *
  * Searches for an element (@elem) inside the string list. Will
  * also search for the same element prefixed by @prefix.
  *
- * Returns: true (1) if element could be found, otherwise false (0).
+ * @return true if element could be found, otherwise false.
  */
 bool string_list_find_elem_prefix(const struct string_list *list,
       const char *prefix, const char *elem)
 {
-   size_t i;
-   char prefixed[255];
-
-   if (!list)
-      return false;
-
-   prefixed[0] = '\0';
-
-   strlcpy(prefixed, prefix, sizeof(prefixed));
-   strlcat(prefixed, elem,   sizeof(prefixed));
-
-   for (i = 0; i < list->size; i++)
+   if (list)
    {
-      if (string_is_equal_noncase(list->elems[i].data, elem) ||
-            string_is_equal_noncase(list->elems[i].data, prefixed))
-         return true;
+      size_t i;
+      char prefixed[255];
+      size_t _len  = strlcpy(prefixed, prefix, sizeof(prefixed));
+      strlcpy(prefixed + _len, elem, sizeof(prefixed) - _len);
+      for (i = 0; i < list->size; i++)
+      {
+         if (     string_is_equal_noncase(list->elems[i].data, elem)
+               || string_is_equal_noncase(list->elems[i].data, prefixed))
+            return true;
+      }
    }
-
    return false;
 }
 
-struct string_list *string_list_clone(
-      const struct string_list *src)
+struct string_list *string_list_clone(const struct string_list *src)
 {
-   unsigned i;
+   size_t i;
    struct string_list_elem *elems = NULL;
    struct string_list *dest       = (struct string_list*)
-      calloc(1, sizeof(struct string_list));
+      malloc(sizeof(struct string_list));
 
    if (!dest)
       return NULL;
 
-   dest->size      = src->size;
-   dest->cap       = src->cap;
-   if (dest->cap < dest->size)
-      dest->cap    = dest->size;
-
-   elems           = (struct string_list_elem*)
-      calloc(dest->cap, sizeof(struct string_list_elem));
+   dest->elems                    = NULL;
+   dest->size                     = src->size;
+   if (src->cap < dest->size)
+      dest->cap                   = dest->size;
+   else 
+      dest->cap                   = src->cap;
 
-   if (!elems)
+   if (!(elems = (struct string_list_elem*)
+      calloc(dest->cap, sizeof(struct string_list_elem))))
    {
       free(dest);
       return NULL;
    }
 
-   dest->elems            = elems;
+   dest->elems                    = elems;
 
    for (i = 0; i < src->size; i++)
    {
-      const char *_src    = src->elems[i].data;
-      size_t      len     = _src ? strlen(_src) : 0;
+      const char *_src       = src->elems[i].data;
+      size_t      len        = _src ? strlen(_src) : 0;
 
-      dest->elems[i].data = NULL;
-      dest->elems[i].attr = src->elems[i].attr;
+      dest->elems[i].data    = NULL;
+      dest->elems[i].attr    = src->elems[i].attr;
 
       if (len != 0)
       {
diff --git a/src/libretro/libretro-common/lists/vector_list.c b/src/libretro/libretro-common/lists/vector_list.c
index b8493c5675..063c57126f 100644
--- a/src/libretro/libretro-common/lists/vector_list.c
+++ b/src/libretro/libretro-common/lists/vector_list.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (vector_list.c).
diff --git a/src/libretro/libretro-common/media/media_detect_cd.c b/src/libretro/libretro-common/media/media_detect_cd.c
index 9faa747a5a..ef872aa634 100644
--- a/src/libretro/libretro-common/media/media_detect_cd.c
+++ b/src/libretro/libretro-common/media/media_detect_cd.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2019 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
 *
 * ---------------------------------------------------------------------------------------
 * The following license statement only applies to this file (media_detect_cd.c).
@@ -43,50 +43,44 @@ static void media_zero_trailing_spaces(char *buf, size_t len)
 
 static bool media_skip_spaces(const char **buf, size_t len)
 {
-   bool found = false;
-   unsigned i;
-
-   if (!buf || !*buf || !**buf)
-      return false;
-
-   for (i = 0; i < len; i++)
+   if (buf && *buf && **buf)
    {
-      if ((*buf)[i] == ' ' || (*buf)[i] == '\t')
-         continue;
+      size_t i;
+      for (i = 0; i < len; i++)
+      {
+         if ((*buf)[i] == ' ' || (*buf)[i] == '\t')
+            continue;
 
-      *buf += i;
-      found = true;
-      break;
+         *buf += i;
+         return true;
+      }
    }
 
-   if (found)
-      return true;
-
    return false;
 }
 
 /* Fill in "info" with detected CD info. Use this when you have a cue file and want it parsed to find the first data track and any pregap info. */
 bool media_detect_cd_info_cue(const char *path, media_detect_cd_info_t *info)
 {
-   RFILE *file = NULL;
-   char *line = NULL;
-   char track_path[PATH_MAX_LENGTH] = {0};
+   RFILE *file                          = NULL;
+   char *line                           = NULL;
+   char track_path[PATH_MAX_LENGTH]     = {0};
    char track_abs_path[PATH_MAX_LENGTH] = {0};
-   char track_mode[11] = {0};
-   bool found_file = false;
-   bool found_track = false;
-   unsigned first_data_track = 0;
-   uint64_t data_track_pregap_bytes = 0;
+   char track_mode[11]                  = {0};
+   bool found_file                      = false;
+   bool found_track                     = false;
+   unsigned first_data_track            = 0;
+   uint64_t data_track_pregap_bytes     = 0;
 
    if (string_is_empty(path) || !info)
       return false;
 
-   file = filestream_open(path, RETRO_VFS_FILE_ACCESS_READ, 0);
-
-   if (!file)
+   if (!(file = filestream_open(path, RETRO_VFS_FILE_ACCESS_READ, 0)))
    {
+#ifdef MEDIA_CUE_PARSE_DEBUG
       printf("[MEDIA] Could not open cue path for reading: %s\n", path);
       fflush(stdout);
+#endif
       return false;
    }
 
@@ -101,8 +95,7 @@ bool media_detect_cd_info_cue(const char *path, media_detect_cd_info_t *info)
          continue;
       }
 
-      len = strlen(line);
-
+      len     = strlen(line);
       command = line;
 
       media_skip_spaces(&command, len);
@@ -115,8 +108,8 @@ bool media_detect_cd_info_cue(const char *path, media_detect_cd_info_t *info)
          if (!string_is_empty(file))
          {
             const char *file_end = NULL;
-            size_t file_len = 0;
-            bool quoted = false;
+            size_t file_len      = 0;
+            bool quoted          = false;
 
             if (file[0] == '"')
             {
@@ -148,8 +141,8 @@ bool media_detect_cd_info_cue(const char *path, media_detect_cd_info_t *info)
 
          if (!string_is_empty(track))
          {
-            unsigned track_number = 0;
-            sscanf(track, "%d", &track_number);
+            char *ptr             = NULL;
+            unsigned track_number = (unsigned)strtol(track, &ptr, 10);
 #ifdef MEDIA_CUE_PARSE_DEBUG
             printf("Found track: %d\n", track_number);
             fflush(stdout);
@@ -184,8 +177,8 @@ bool media_detect_cd_info_cue(const char *path, media_detect_cd_info_t *info)
 
          if (!string_is_empty(index))
          {
-            unsigned index_number = 0;
-            sscanf(index, "%d", &index_number);
+            char *ptr             = NULL;
+            unsigned index_number = (unsigned)strtol(index, &ptr, 10);
 
             if (index_number == 1)
             {
@@ -197,7 +190,7 @@ bool media_detect_cd_info_cue(const char *path, media_detect_cd_info_t *info)
                if (!string_is_empty(pregap))
                {
                   media_skip_spaces(&pregap, strlen(pregap));
-                  found_file = false;
+                  found_file  = false;
                   found_track = false;
 
                   if (first_data_track && !string_is_empty(track_mode))
@@ -207,7 +200,7 @@ bool media_detect_cd_info_cue(const char *path, media_detect_cd_info_t *info)
 
                      if (strlen(track_mode) == 10)
                      {
-                        sscanf(track_mode, "MODE%d/%d", &track_mode_number, &track_sector_size);
+                        sscanf(track_mode, "MODE%d/%d", (int*)&track_mode_number, (int*)&track_sector_size);
 #ifdef MEDIA_CUE_PARSE_DEBUG
                         printf("Found track mode %d with sector size %d\n", track_mode_number, track_sector_size);
                         fflush(stdout);
@@ -217,7 +210,7 @@ bool media_detect_cd_info_cue(const char *path, media_detect_cd_info_t *info)
                            unsigned min = 0;
                            unsigned sec = 0;
                            unsigned frame = 0;
-                           sscanf(pregap, "%02d:%02d:%02d", &min, &sec, &frame);
+                           sscanf(pregap, "%02d:%02d:%02d", (int*)&min, (int*)&sec, (int*)&frame);
 
                            if (min || sec || frame || strstr(pregap, "00:00:00"))
                            {
@@ -245,18 +238,20 @@ bool media_detect_cd_info_cue(const char *path, media_detect_cd_info_t *info)
    {
       if (strstr(track_path, "/") || strstr(track_path, "\\"))
       {
+#ifdef MEDIA_CUE_PARSE_DEBUG
          printf("using path %s\n", track_path);
          fflush(stdout);
+#endif
          return media_detect_cd_info(track_path, data_track_pregap_bytes, info);
       }
-      else
-      {
-         fill_pathname_basedir(track_abs_path, path, sizeof(track_abs_path));
-         strlcat(track_abs_path, track_path, sizeof(track_abs_path));
-         printf("using abs path %s\n", track_abs_path);
-         fflush(stdout);
-         return media_detect_cd_info(track_abs_path, data_track_pregap_bytes, info);
-      }
+
+      fill_pathname_basedir(track_abs_path, path, sizeof(track_abs_path));
+      strlcat(track_abs_path, track_path, sizeof(track_abs_path));
+#ifdef MEDIA_CUE_PARSE_DEBUG
+      printf("using abs path %s\n", track_abs_path);
+      fflush(stdout);
+#endif
+      return media_detect_cd_info(track_abs_path, data_track_pregap_bytes, info);
    }
 
    return true;
@@ -270,21 +265,21 @@ bool media_detect_cd_info(const char *path, uint64_t pregap_bytes, media_detect_
    if (string_is_empty(path) || !info)
       return false;
 
-   file = filestream_open(path, RETRO_VFS_FILE_ACCESS_READ, 0);
-
-   if (!file)
+   if (!(file = filestream_open(path, RETRO_VFS_FILE_ACCESS_READ, 0)))
    {
+#ifdef MEDIA_CUE_PARSE_DEBUG
       printf("[MEDIA] Could not open path for reading: %s\n", path);
       fflush(stdout);
+#endif
       return false;
    }
 
    {
-      unsigned offset = 0;
+      unsigned offset      = 0;
       unsigned sector_size = 0;
-      unsigned buf_size = 17 * 2352;
-      char *buf = (char*)calloc(1, buf_size);
-      int64_t read_bytes = 0;
+      unsigned buf_size    = 17 * 2352;
+      char *buf            = (char*)calloc(1, buf_size);
+      int64_t read_bytes   = 0;
 
       if (!buf)
          return false;
@@ -296,8 +291,10 @@ bool media_detect_cd_info(const char *path, uint64_t pregap_bytes, media_detect_
 
       if (read_bytes != buf_size)
       {
+#ifdef MEDIA_CUE_PARSE_DEBUG
          printf("[MEDIA] Could not read from media: got %" PRId64 " bytes instead of %d.\n", read_bytes, buf_size);
          fflush(stdout);
+#endif
          filestream_close(file);
          free(buf);
          return false;
@@ -314,35 +311,26 @@ bool media_detect_cd_info(const char *path, uint64_t pregap_bytes, media_detect_
          /* Assume track data contains all fields. */
          sector_size = 2352;
 
+         /* Assume Mode 2 formed (formless is rarely used) */
          if (buf[15] == 2)
-         {
-            /* assume Mode 2 formed (formless is rarely used) */
-            offset = 24;
-         }
-         else
-         {
-            /* assume Mode 1 */
-            offset = 16;
-         }
+            offset   = 24;
+         else /* Assume Mode 1 */
+            offset   = 16;
       }
-      else
-      {
-         /* Assume sectors only contain user data instead. */
-         offset = 0;
+      else /* Assume sectors only contain user data instead. */
          sector_size = 2048;
-      }
 
-      if (!memcmp(buf + offset, "SEGADISCSYSTEM", strlen("SEGADISCSYSTEM")))
+      if (!memcmp(buf + offset, "SEGADISCSYSTEM",
+               STRLEN_CONST("SEGADISCSYSTEM")))
       {
-         const char *title_pos;
-         const char *serial_pos;
-         bool title_found = false;
+         const char *title_pos  = NULL;
+         const char *serial_pos = NULL;
 
          /* All discs currently in Redump for MCD start with SEGADISCSYSTEM. There are other strings mentioned elsewhere online,
           * but I have not seen any real examples of them. */
          info->system_id = MEDIA_CD_SYSTEM_MEGA_CD;
 
-         strlcpy(info->system, "Sega CD / Mega CD", sizeof(info->system));
+         strcpy_literal(info->system, "Sega CD / Mega CD");
 
          title_pos = buf + offset + 0x150;
 
@@ -352,7 +340,12 @@ bool media_detect_cd_info(const char *path, uint64_t pregap_bytes, media_detect_
             media_zero_trailing_spaces(info->title, sizeof(info->title));
          }
          else
-            strlcpy(info->title, "N/A", sizeof(info->title));
+         {
+            info->title[0] = 'N';
+            info->title[1] = '/';
+            info->title[2] = 'A';
+            info->title[3] = '\0';
+         }
 
          serial_pos = buf + offset + 0x183;
 
@@ -362,19 +355,24 @@ bool media_detect_cd_info(const char *path, uint64_t pregap_bytes, media_detect_
             media_zero_trailing_spaces(info->serial, sizeof(info->serial));
          }
          else
-            strlcpy(info->serial, "N/A", sizeof(info->serial));
+         {
+            info->serial[0] = 'N';
+            info->serial[1] = '/';
+            info->serial[2] = 'A';
+            info->serial[3] = '\0';
+         }
       }
-      else if (!memcmp(buf + offset, "SEGA SEGASATURN", strlen("SEGA SEGASATURN")))
+      else if (!memcmp(buf + offset, "SEGA SEGASATURN",
+               STRLEN_CONST("SEGA SEGASATURN")))
       {
-         const char *title_pos;
-         const char *serial_pos;
-         const char *version_pos;
-         const char *release_date_pos;
-         bool title_found = false;
+         const char *title_pos        = NULL;
+         const char *serial_pos       = NULL;
+         const char *version_pos      = NULL;
+         const char *release_date_pos = NULL;
 
          info->system_id = MEDIA_CD_SYSTEM_SATURN;
 
-         strlcpy(info->system, "Sega Saturn", sizeof(info->system));
+         strcpy_literal(info->system, "Sega Saturn");
 
          title_pos = buf + offset + 0x60;
 
@@ -384,7 +382,12 @@ bool media_detect_cd_info(const char *path, uint64_t pregap_bytes, media_detect_
             media_zero_trailing_spaces(info->title, sizeof(info->title));
          }
          else
-            strlcpy(info->title, "N/A", sizeof(info->title));
+         {
+            info->title [0] = 'N';
+            info->title [1] = '/';
+            info->title [2] = 'A';
+            info->title [3] = '\0';
+         }
 
          serial_pos = buf + offset + 0x20;
 
@@ -394,7 +397,12 @@ bool media_detect_cd_info(const char *path, uint64_t pregap_bytes, media_detect_
             media_zero_trailing_spaces(info->serial, sizeof(info->serial));
          }
          else
-            strlcpy(info->serial, "N/A", sizeof(info->serial));
+         {
+            info->serial[0] = 'N';
+            info->serial[1] = '/';
+            info->serial[2] = 'A';
+            info->serial[3] = '\0';
+         }
 
          version_pos = buf + offset + 0x2a;
 
@@ -404,7 +412,12 @@ bool media_detect_cd_info(const char *path, uint64_t pregap_bytes, media_detect_
             media_zero_trailing_spaces(info->version, sizeof(info->version));
          }
          else
-            strlcpy(info->version, "N/A", sizeof(info->version));
+         {
+            info->version[0] = 'N';
+            info->version[1] = '/';
+            info->version[2] = 'A';
+            info->version[3] = '\0';
+         }
 
          release_date_pos = buf + offset + 0x30;
 
@@ -414,19 +427,23 @@ bool media_detect_cd_info(const char *path, uint64_t pregap_bytes, media_detect_
             media_zero_trailing_spaces(info->release_date, sizeof(info->release_date));
          }
          else
-            strlcpy(info->release_date, "N/A", sizeof(info->release_date));
+         {
+            info->release_date[0] = 'N';
+            info->release_date[1] = '/';
+            info->release_date[2] = 'A';
+            info->release_date[3] = '\0';
+         }
       }
-      else if (!memcmp(buf + offset, "SEGA SEGAKATANA", strlen("SEGA SEGAKATANA")))
+      else if (!memcmp(buf + offset, "SEGA SEGAKATANA", STRLEN_CONST("SEGA SEGAKATANA")))
       {
-         const char *title_pos;
-         const char *serial_pos;
-         const char *version_pos;
-         const char *release_date_pos;
-         bool title_found = false;
+         const char *title_pos        = NULL;
+         const char *serial_pos       = NULL;
+         const char *version_pos      = NULL;
+         const char *release_date_pos = NULL;
 
          info->system_id = MEDIA_CD_SYSTEM_DREAMCAST;
 
-         strlcpy(info->system, "Sega Dreamcast", sizeof(info->system));
+         strcpy_literal(info->system, "Sega Dreamcast");
 
          title_pos = buf + offset + 0x80;
 
@@ -436,7 +453,12 @@ bool media_detect_cd_info(const char *path, uint64_t pregap_bytes, media_detect_
             media_zero_trailing_spaces(info->title, sizeof(info->title));
          }
          else
-            strlcpy(info->title, "N/A", sizeof(info->title));
+         {
+            info->title       [0] = 'N';
+            info->title       [1] = '/';
+            info->title       [2] = 'A';
+            info->title       [3] = '\0';
+         }
 
          serial_pos = buf + offset + 0x40;
 
@@ -446,7 +468,12 @@ bool media_detect_cd_info(const char *path, uint64_t pregap_bytes, media_detect_
             media_zero_trailing_spaces(info->serial, sizeof(info->serial));
          }
          else
-            strlcpy(info->serial, "N/A", sizeof(info->serial));
+         {
+            info->serial      [0] = 'N';
+            info->serial      [1] = '/';
+            info->serial      [2] = 'A';
+            info->serial      [3] = '\0';
+         }
 
          version_pos = buf + offset + 0x4a;
 
@@ -456,7 +483,12 @@ bool media_detect_cd_info(const char *path, uint64_t pregap_bytes, media_detect_
             media_zero_trailing_spaces(info->version, sizeof(info->version));
          }
          else
-            strlcpy(info->version, "N/A", sizeof(info->version));
+         {
+            info->version     [0] = 'N';
+            info->version     [1] = '/';
+            info->version     [2] = 'A';
+            info->version     [3] = '\0';
+         }
 
          release_date_pos = buf + offset + 0x50;
 
@@ -466,17 +498,21 @@ bool media_detect_cd_info(const char *path, uint64_t pregap_bytes, media_detect_
             media_zero_trailing_spaces(info->release_date, sizeof(info->release_date));
          }
          else
-            strlcpy(info->release_date, "N/A", sizeof(info->release_date));
+         {
+            info->release_date[0] = 'N';
+            info->release_date[1] = '/';
+            info->release_date[2] = 'A';
+            info->release_date[3] = '\0';
+         }
       }
       /* Primary Volume Descriptor fields of ISO9660 */
       else if (!memcmp(buf + offset + (16 * sector_size), "\1CD001\1\0PLAYSTATION", 19))
       {
          const char *title_pos = NULL;
-         bool title_found      = false;
 
          info->system_id = MEDIA_CD_SYSTEM_PSX;
 
-         strlcpy(info->system, "Sony PlayStation", sizeof(info->system));
+         strcpy_literal(info->system, "Sony PlayStation");
 
          title_pos = buf + offset + (16 * sector_size) + 40;
 
@@ -486,19 +522,22 @@ bool media_detect_cd_info(const char *path, uint64_t pregap_bytes, media_detect_
             media_zero_trailing_spaces(info->title, sizeof(info->title));
          }
          else
-            strlcpy(info->title, "N/A", sizeof(info->title));
+         {
+            info->title       [0] = 'N';
+            info->title       [1] = '/';
+            info->title       [2] = 'A';
+            info->title       [3] = '\0';
+         }
       }
       else if (!memcmp(buf + offset, "\x01\x5a\x5a\x5a\x5a\x5a\x01\x00\x00\x00\x00\x00", 12))
       {
          info->system_id = MEDIA_CD_SYSTEM_3DO;
-
-         strlcpy(info->system, "3DO", sizeof(info->system));
+         strcpy_literal(info->system, "3DO");
       }
       else if (!memcmp(buf + offset + 0x950, "PC Engine CD-ROM SYSTEM", 23))
       {
          info->system_id = MEDIA_CD_SYSTEM_PC_ENGINE_CD;
-
-         strlcpy(info->system, "TurboGrafx-CD / PC-Engine CD", sizeof(info->system));
+         strcpy_literal(info->system, "TurboGrafx-CD / PC-Engine CD");
       }
 
       free(buf);
diff --git a/src/libretro/libretro-common/memmap/memalign.c b/src/libretro/libretro-common/memmap/memalign.c
index c2332962b7..14eaeffdbd 100644
--- a/src/libretro/libretro-common/memmap/memalign.c
+++ b/src/libretro/libretro-common/memmap/memalign.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (memalign.c).
diff --git a/src/libretro/libretro-common/memmap/memmap.c b/src/libretro/libretro-common/memmap/memmap.c
index 26d9ce031f..5272406168 100644
--- a/src/libretro/libretro-common/memmap/memmap.c
+++ b/src/libretro/libretro-common/memmap/memmap.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (memmap.c).
@@ -21,6 +21,7 @@
  */
 
 #include <stdint.h>
+#include <stdlib.h>
 #include <memmap.h>
 
 #ifndef PROT_READ
@@ -130,14 +131,14 @@ int mprotect(void *addr, size_t len, int prot)
 
 #endif
 
-#if defined(__MACH__) && defined(__arm__)
+#if defined(__MACH__) && (defined(__arm__) || defined(__arm64__))
 #include <libkern/OSCacheControl.h>
 #endif
 
 int memsync(void *start, void *end)
 {
    size_t len = (char*)end - (char*)start;
-#if defined(__MACH__) && defined(__arm__)
+#if defined(__MACH__) && (defined(__arm__) || defined(__arm64__))
    sys_dcache_flush(start ,len);
    sys_icache_invalidate(start, len);
    return 0;
diff --git a/src/libretro/libretro-common/net/net_compat.c b/src/libretro/libretro-common/net/net_compat.c
index 067655d8ae..e291bbee90 100644
--- a/src/libretro/libretro-common/net/net_compat.c
+++ b/src/libretro/libretro-common/net/net_compat.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2022 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (net_compat.c).
@@ -20,235 +20,319 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#include <stdio.h>
-#include <stdint.h>
-#include <stdlib.h>
-#include <sys/types.h>
 #include <stdlib.h>
-#include <ctype.h>
-#include <string.h>
+#include <stdio.h>
 
-#include <net/net_compat.h>
-#include <net/net_socket.h>
-#include <retro_timers.h>
 #include <compat/strl.h>
+#include <retro_miscellaneous.h>
+#include <retro_timers.h>
+
+#include <net/net_compat.h>
+
+#if defined(_WIN32) && !defined(_XBOX)
+#if !defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600
+const char *inet_ntop(int af, const void *src, char *dst, socklen_t size)
+{
+   struct sockaddr_storage addr;
+
+   switch (af)
+   {
+      case AF_INET:
+         memcpy(&((struct sockaddr_in*)&addr)->sin_addr, src,
+            sizeof(struct in_addr));
+         break;
+#ifdef HAVE_INET6
+      case AF_INET6:
+         memcpy(&((struct sockaddr_in6*)&addr)->sin6_addr, src,
+            sizeof(struct in6_addr));
+         break;
+#endif
+      default:
+         return NULL;
+   }
+
+   addr.ss_family = af;
+   if (getnameinfo((struct sockaddr*)&addr, sizeof(addr), dst, size, NULL, 0,
+         NI_NUMERICHOST))
+      return NULL;
+
+   return dst;
+}
 
-#if defined(_XBOX)
-/* TODO - implement h_length and h_addrtype */
-struct hostent
+int inet_pton(int af, const char *src, void *dst)
 {
-   int h_addrtype;     /* host address type   */
-   int h_length;       /* length of addresses */
-   char **h_addr_list; /* list of addresses   */
-};
+   struct addrinfo *addr = NULL;
+   struct addrinfo hints = {0};
+
+   switch (af)
+   {
+      case AF_INET:
+#ifdef HAVE_INET6
+      case AF_INET6:
+#endif
+         break;
+      default:
+         return -1;
+   }
 
+   hints.ai_family = af;
+   hints.ai_flags  = AI_NUMERICHOST;
+   switch (getaddrinfo(src, NULL, &hints, &addr))
+   {
+      case 0:
+         break;
+      case EAI_NONAME:
+         return 0;
+      default:
+         return -1;
+   }
+
+   if (!addr)
+      return -1;
+
+   switch (af)
+   {
+      case AF_INET:
+         memcpy(dst, &((struct sockaddr_in*)addr->ai_addr)->sin_addr,
+            sizeof(struct in_addr));
+         break;
+#ifdef HAVE_INET6
+      case AF_INET6:
+         memcpy(dst, &((struct sockaddr_in6*)addr->ai_addr)->sin6_addr,
+            sizeof(struct in6_addr));
+         break;
+#endif
+      default:
+         break;
+   }
+
+   freeaddrinfo(addr);
+
+   return 1;
+}
+#endif
+
+#elif defined(_XBOX)
 struct hostent *gethostbyname(const char *name)
 {
+   static struct in_addr addr = {0};
+   static struct hostent he   = {0};
    WSAEVENT event;
-   static struct hostent he;
-   static struct in_addr addr;
-   static char *addr_ptr      = NULL;
-   XNDNS *dns                 = NULL;
-
-   he.h_addr_list             = &addr_ptr;
-   addr_ptr                   = (char*)&addr;
+   XNDNS          *dns = NULL;
+   struct hostent *ret = NULL;
 
    if (!name)
       return NULL;
 
    event = WSACreateEvent();
+
    XNetDnsLookup(name, event, &dns);
    if (!dns)
-      goto error;
+      goto done;
 
    WaitForSingleObject((HANDLE)event, INFINITE);
+
    if (dns->iStatus)
-      goto error;
+      goto done;
 
    memcpy(&addr, dns->aina, sizeof(addr));
 
-   WSACloseEvent(event);
-   XNetDnsRelease(dns);
+   he.h_name      = NULL;
+   he.h_aliases   = NULL;
+   he.h_addrtype  = AF_INET;
+   he.h_length    = sizeof(addr);
+   he.h_addr_list = &he.h_addr;
+   he.h_addr      = (char*)&addr;
 
-   return &he;
+   ret = &he;
 
-error:
-   if (event)
-      WSACloseEvent(event);
-   return NULL;
-}
-#elif defined(VITA)
-static void *_net_compat_net_memory = NULL;
-#define COMPAT_NET_INIT_SIZE 512*1024
-#define INET_ADDRSTRLEN sizeof(struct sockaddr_in)
-#define MAX_NAME 512
+done:
+   WSACloseEvent(event);
+   if (dns)
+      XNetDnsRelease(dns);
 
-typedef uint32_t in_addr_t;
+   return ret;
+}
 
-struct in_addr
-{
-   in_addr_t s_addr;
-};
+#elif defined(VITA)
+#define COMPAT_NET_INIT_SIZE 0x80000
 
-char *inet_ntoa(struct SceNetInAddr in)
+char *inet_ntoa(struct in_addr in)
 {
-	static char ip_addr[INET_ADDRSTRLEN + 1];
+   static char ip_addr[16];
 
-   if (!inet_ntop_compat(AF_INET, &in, ip_addr, INET_ADDRSTRLEN))
-		strlcpy(ip_addr, "Invalid", sizeof(ip_addr));
+   sceNetInetNtop(AF_INET, &in, ip_addr, sizeof(ip_addr));
 
-	return ip_addr;
+   return ip_addr;
 }
 
-struct SceNetInAddr inet_aton(const char *ip_addr)
+int inet_aton(const char *cp, struct in_addr *inp)
 {
-   SceNetInAddr inaddr;
-
-   inet_ptrton(AF_INET, ip_addr, &inaddr);
-   return inaddr;
+   return sceNetInetPton(AF_INET, cp, inp);
 }
 
-unsigned int inet_addr(const char *cp)
+uint32_t inet_addr(const char *cp)
 {
-   return inet_aton(cp).s_addr;
+   struct in_addr in;
+
+   return (sceNetInetPton(AF_INET, cp, &in) == 1) ? in.s_addr : INADDR_NONE;
 }
 
 struct hostent *gethostbyname(const char *name)
 {
-   int err;
-   static struct hostent ent;
-   static char sname[MAX_NAME]      = {0};
-   static struct SceNetInAddr saddr = {0};
-   static char *addrlist[2]         = {(char *) &saddr, NULL };
-   int rid = sceNetResolverCreate("resolver", NULL, 0);
-
-   if(rid < 0)
+   static struct SceNetInAddr addr = {0};
+   static struct hostent      he   = {0};
+   int rid;
+   struct hostent *ret = NULL;
+
+   if (!name)
       return NULL;
 
-   err = sceNetResolverStartNtoa(rid, name, &saddr, 0,0,0);
-   sceNetResolverDestroy(rid);
-   if(err < 0)
+   rid = sceNetResolverCreate("resolver", NULL, 0);
+   if (rid < 0)
       return NULL;
 
-   addrlist[0]     = inet_ntoa(saddr);
-   ent.h_name      = sname;
-   ent.h_aliases   = 0;
-   ent.h_addrtype  = AF_INET;
-   ent.h_length    = sizeof(struct in_addr);
-   ent.h_addr_list = addrlist;
-   ent.h_addr      = addrlist[0];
+   if (sceNetResolverStartNtoa(rid, name, &addr, 0, 0, 0) < 0)
+      goto done;
+
+   he.h_name      = NULL;
+   he.h_aliases   = NULL;
+   he.h_addrtype  = AF_INET;
+   he.h_length    = sizeof(addr);
+   he.h_addr_list = &he.h_addr;
+   he.h_addr      = (char*)&addr;
+
+   ret = &he;
 
-   return &ent;
+done:
+   sceNetResolverDestroy(rid);
+
+   return ret;
 }
 
-int retro_epoll_fd;
-#elif defined(_3DS)
+#elif defined(GEKKO)
+const char *inet_ntop(int af, const void *src, char *dst, socklen_t size)
+{
+   const char *addr_str = inet_ntoa(*(struct in_addr*)src);
+
+   if (addr_str)
+   {
+      strlcpy(dst, addr_str, size);
+
+      return dst;
+   }
+
+   return NULL;
+}
+
+int inet_pton(int af, const char *src, void *dst)
+{
+   if (inet_aton(src, (struct in_addr*)dst))
+      return 1;
+
+   return 0;
+}
+
+#elif defined(WIIU)
 #include <malloc.h>
-#include <3ds/types.h>
-#include <3ds/services/soc.h>
-#define SOC_ALIGN       0x1000
-#define SOC_BUFFERSIZE  0x100000
-static u32* _net_compat_net_memory;
-#endif
 
-#if defined(_WIN32)
-int inet_aton(const char *cp, struct in_addr *inp)
+static int _net_compat_thread_entry(int argc, const char **argv)
 {
-	uint32_t addr = 0;
-#ifndef _XBOX
-	if (cp == 0 || inp == 0)
-		return -1;
-#endif
+   void *buf = memalign(128, WIIU_RCVBUF + WIIU_SNDBUF);
 
-	addr = inet_addr(cp);
-	if (addr == INADDR_NONE || addr == INADDR_ANY)
-		return -1;
+   if (!buf)
+      return -1;
 
-	inp->s_addr = addr;
-   return 1;
+   somemopt(1, buf, WIIU_RCVBUF + WIIU_SNDBUF, 0);
+
+   free(buf);
+
+   return 0;
 }
+
+static void _net_compat_thread_cleanup(OSThread *thread, void *stack)
+{
+   free(stack);
+}
+
+#elif defined(_3DS)
+#include <malloc.h>
+#include <3ds/types.h>
+#include <3ds/services/soc.h>
+
+#define SOC_ALIGN      0x1000
+#define SOC_BUFFERSIZE 0x100000
 #endif
 
 int getaddrinfo_retro(const char *node, const char *service,
       struct addrinfo *hints, struct addrinfo **res)
 {
-   struct sockaddr_in *in_addr = NULL;
-   struct addrinfo *info       = NULL;
-
-   (void)in_addr;
-   (void)info;
+#if defined(HAVE_SOCKET_LEGACY) || defined(WIIU)
+   struct addrinfo default_hints = {0};
 
+   if (!hints)
+      hints            = &default_hints;
    if (!hints->ai_family)
-   {
-#if defined(_WIN32) || defined(HAVE_SOCKET_LEGACY) || defined(WIIU)
-      hints->ai_family    = AF_INET;
-#else
-      hints->ai_family    = AF_UNSPEC;
-#endif
-   }
+      hints->ai_family = AF_INET;
 
-#if defined(WIIU)
    if (!node)
-   {
-      /* Wii U's socket library chokes on NULL node */
-      if (hints->ai_flags & AI_PASSIVE)
-         node = "0.0.0.0";
-      else
-         node = "127.0.0.1";
-   }
+      node = (hints->ai_flags & AI_PASSIVE) ? "0.0.0.0" : "127.0.0.1";
 #endif
 
 #ifdef HAVE_SOCKET_LEGACY
-   info = (struct addrinfo*)calloc(1, sizeof(*info));
-   if (!info)
-      goto error;
-
-   info->ai_family     = AF_INET;
-   info->ai_socktype   = hints->ai_socktype;
-   in_addr             = (struct sockaddr_in*)
-      calloc(1, sizeof(*in_addr));
-
-   if (!in_addr)
-      goto error;
-
-   info->ai_addrlen    = sizeof(*in_addr);
-   in_addr->sin_family = AF_INET;
-   in_addr->sin_port   = inet_htons(strtoul(service, NULL, 0));
-
-   if (!node && (hints->ai_flags & AI_PASSIVE))
-      in_addr->sin_addr.s_addr = INADDR_ANY;
-   else if (node && isdigit(*node))
-      in_addr->sin_addr.s_addr = inet_addr(node);
-   else if (node && !isdigit(*node))
    {
-      struct hostent *host = (struct hostent*)gethostbyname(node);
+      struct addrinfo    *info = (struct addrinfo*)calloc(1, sizeof(*info));
+      struct sockaddr_in *addr = (struct sockaddr_in*)malloc(sizeof(*addr));
 
-      if (!host || !host->h_addr_list[0])
-         goto error;
+      if (!info || !addr)
+         goto failure;
 
-      in_addr->sin_family = host->h_addrtype;
+      info->ai_family   = AF_INET;
+      info->ai_socktype = hints->ai_socktype;
+      info->ai_protocol = hints->ai_protocol;
+      info->ai_addrlen  = sizeof(*addr);
+      info->ai_addr     = (struct sockaddr*)addr;
+      /* We ignore AI_CANONNAME; ai_canonname is always NULL. */
 
-#if defined(AF_INET6) && !defined(__CELLOS_LV2__) || defined(VITA)
-      /* TODO/FIXME - In case we ever want to support IPv6 */
-      in_addr->sin_addr.s_addr = inet_addr(host->h_addr_list[0]);
-#else
-      memcpy(&in_addr->sin_addr, host->h_addr, host->h_length);
-#endif
-   }
-   else
-      goto error;
+      addr->sin_family = AF_INET;
 
-   info->ai_addr = (struct sockaddr*)in_addr;
-   *res          = info;
+      if (service)
+      {
+         /* We can only handle numeric ports; ignore AI_NUMERICSERV. */
+         char *service_end = NULL;
+         uint16_t port     = (uint16_t)strtoul(service, &service_end, 10);
 
-   return 0;
+         if (service_end == service || *service_end)
+            goto failure;
+
+         addr->sin_port = htons(port);
+      }
 
-error:
-   if (in_addr)
-      free(in_addr);
-   if (info)
+      if (hints->ai_flags & AI_NUMERICHOST)
+      {
+         if (!inet_aton(node, &addr->sin_addr))
+            goto failure;
+      }
+      else
+      {
+         struct hostent *host = gethostbyname(node);
+
+         if (!host || !host->h_addr)
+            goto failure;
+
+         memcpy(&addr->sin_addr, host->h_addr, sizeof(addr->sin_addr));
+      }
+
+      *res = info;
+
+      return 0;
+
+failure:
+      free(addr);
       free(info);
-   return -1;
+
+      return -1;
+   }
 #else
    return getaddrinfo(node, service, hints, res);
 #endif
@@ -257,392 +341,299 @@ int getaddrinfo_retro(const char *node, const char *service,
 void freeaddrinfo_retro(struct addrinfo *res)
 {
 #ifdef HAVE_SOCKET_LEGACY
-   free(res->ai_addr);
-   free(res);
+   if (res)
+   {
+      free(res->ai_addr);
+      free(res);
+   }
 #else
    freeaddrinfo(res);
 #endif
 }
 
-/**
- * network_init:
- *
- * Platform specific socket library initialization.
- *
- * Returns: true (1) if successful, otherwise false (0).
- **/
-bool network_init(void)
+int getnameinfo_retro(const struct sockaddr *addr, socklen_t addrlen,
+      char *host, socklen_t hostlen, char *serv, socklen_t servlen, int flags)
 {
-#ifdef _WIN32
-   WSADATA wsaData;
-#endif
-   static bool inited = false;
-   if (inited)
-      return true;
-
-#if defined(_WIN32)
-   if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
+#ifdef HAVE_SOCKET_LEGACY
+   const struct sockaddr_in *addr4 = (const struct sockaddr_in*)addr;
+
+   /* We cannot perform reverse DNS lookups here; ignore the following flags:
+      NI_NAMEREQD
+      NI_NOFQDN
+      NI_NUMERICHOST (always enforced)
+    */
+   if (host && hostlen)
    {
-      network_deinit();
-      return false;
+      const char *_host = inet_ntoa(addr4->sin_addr);
+
+      if (!_host)
+         return -1;
+
+      strlcpy(host, _host, hostlen);
    }
-#elif defined(__CELLOS_LV2__) && !defined(__PSL1GHT__)
-   int timeout_count = 10;
 
-   cellSysmoduleLoadModule(CELL_SYSMODULE_NET);
-   sys_net_initialize_network();
+   /* We cannot get service names here; ignore the following flags:
+      NI_DGRAM
+      NI_NUMERICSERV (always enforced)
+    */
+   if (serv && servlen)
+      snprintf(serv, servlen, "%hu", (unsigned short)ntohs(addr4->sin_port));
 
-   if (cellNetCtlInit() < 0)
-      return false;
+   return 0;
+#else
+   return getnameinfo(addr, addrlen, host, hostlen, serv, servlen, flags);
+#endif
+}
 
-   for (;;)
+bool addr_6to4(struct sockaddr_storage *addr)
+{
+#ifdef HAVE_INET6
+   /* ::ffff:a.b.c.d */
+   static const uint16_t preffix[] = {0,0,0,0,0,0xffff};
+   uint32_t address;
+   uint16_t port;
+   struct sockaddr_in6 *addr6 = (struct sockaddr_in6*)addr;
+   struct sockaddr_in  *addr4 = (struct sockaddr_in*)addr;
+
+   switch (addr->ss_family)
    {
-      int state;
-      if (cellNetCtlGetState(&state) < 0)
+      case AF_INET:
+         /* No need to convert. */
+         return true;
+      case AF_INET6:
+         /* Is the address provided an IPv4? */
+         if (!memcmp(&addr6->sin6_addr, preffix, sizeof(preffix)))
+            break;
+      default:
+         /* We don't know how to handle this. */
          return false;
+   }
 
-      if (state == CELL_NET_CTL_STATE_IPObtained)
-         break;
+   memcpy(&address, ((uint8_t*)&addr6->sin6_addr) + sizeof(preffix),
+      sizeof(address));
+   port = addr6->sin6_port;
 
-      retro_sleep(500);
-      timeout_count--;
-      if (timeout_count < 0)
-         return 0;
-   }
-#elif defined(VITA)
-   SceNetInitParam initparam;
+   memset(addr, 0, sizeof(*addr));
 
-   if (sceNetShowNetstat() == SCE_NET_ERROR_ENOTINIT)
-   {
-      _net_compat_net_memory = malloc(COMPAT_NET_INIT_SIZE);
+   addr4->sin_family = AF_INET;
+   addr4->sin_port   = port;
+   memcpy(&addr4->sin_addr, &address, sizeof(addr4->sin_addr));
+#endif
 
-      initparam.memory       = _net_compat_net_memory;
-      initparam.size         = COMPAT_NET_INIT_SIZE;
-      initparam.flags        = 0;
+   return true;
+}
 
-      sceNetInit(&initparam);
+bool ipv4_is_lan_address(const struct sockaddr_in *addr)
+{
+   static const uint32_t subnets[] = {0x0A000000, 0xAC100000, 0xC0A80000};
+   static const uint32_t masks[]   = {0xFF000000, 0xFFF00000, 0xFFFF0000};
+   size_t i;
+   uint32_t uaddr;
 
-      sceNetCtlInit();
-   }
+   memcpy(&uaddr, &addr->sin_addr, sizeof(uaddr));
+   uaddr = ntohl(uaddr);
 
-   retro_epoll_fd = sceNetEpollCreate("epoll", 0);
-#elif defined(GEKKO)
-   char t[16];
-   if (if_config(t, NULL, NULL, TRUE, 10) < 0)
-      return false;
-#elif defined(WIIU)
-   socket_lib_init();
-#elif defined(_3DS)
-    _net_compat_net_memory = (u32*)memalign(SOC_ALIGN, SOC_BUFFERSIZE);
-	if (!_net_compat_net_memory)
-		return false;
-	Result ret = socInit(_net_compat_net_memory, SOC_BUFFERSIZE);//WIFI init
-	if (ret != 0)
-		return false;
-#else
-   signal(SIGPIPE, SIG_IGN); /* Do not like SIGPIPE killing our app. */
-#endif
+   for (i = 0; i < ARRAY_SIZE(subnets); i++)
+      if ((uaddr & masks[i]) == subnets[i])
+         return true;
 
-   inited = true;
-   return true;
+   return false;
+}
+
+bool ipv4_is_cgnat_address(const struct sockaddr_in *addr)
+{
+   static const uint32_t subnet = 0x64400000;
+   static const uint32_t mask   = 0xFFC00000;
+   uint32_t uaddr;
+
+   memcpy(&uaddr, &addr->sin_addr, sizeof(uaddr));
+   uaddr = ntohl(uaddr);
+
+   return (uaddr & mask) == subnet;
 }
 
 /**
- * network_deinit:
+ * network_init:
  *
- * Deinitialize platform specific socket libraries.
+ * Platform specific socket library initialization.
+ *
+ * @return true if successful, otherwise false.
  **/
-void network_deinit(void)
+bool network_init(void)
 {
 #if defined(_WIN32)
-   WSACleanup();
-#elif defined(__CELLOS_LV2__) && !defined(__PSL1GHT__)
-   cellNetCtlTerm();
-   sys_net_finalize_network();
-   cellSysmoduleUnloadModule(CELL_SYSMODULE_NET);
-#elif defined(VITA)
-   sceNetCtlTerm();
-   sceNetTerm();
+   static bool initialized = false;
 
-   if (_net_compat_net_memory)
+   if (!initialized)
    {
-      free(_net_compat_net_memory);
-      _net_compat_net_memory = NULL;
+      WSADATA wsaData;
+
+      if (WSAStartup(MAKEWORD(2, 2), &wsaData))
+      {
+         WSACleanup();
+
+         return false;
+      }
+
+      initialized = true;
    }
-#elif defined(GEKKO) && !defined(HW_DOL)
-   net_deinit();
-#elif defined(_3DS)
-   socExit();
 
-   if(_net_compat_net_memory)
+   return true;
+#elif defined(__PSL1GHT__) || defined(__PS3__)
+   static bool initialized = false;
+
+   if (!initialized)
    {
-	  free(_net_compat_net_memory);
-	  _net_compat_net_memory = NULL;
-   }
-#endif
-}
+      int tries;
 
-uint16_t inet_htons(uint16_t hostshort)
-{
-#if defined(VITA) || defined(__ORBIS__)
-   return sceNetHtons(hostshort);
-#else
-   return htons(hostshort);
-#endif
-}
+      sysModuleLoad(SYSMODULE_NET);
 
+      netInitialize();
+      if (netCtlInit() < 0)
+         goto failure;
 
-int inet_ptrton(int af, const char *src, void *dst)
-{
-#if defined(VITA) || defined(__ORBIS__)
-   return sceNetInetPton(af, src, dst);
-#elif defined(GEKKO) || defined(_WIN32)
-   /* TODO/FIXME - should use InetPton on Vista and later */
-   return inet_aton(src, (struct in_addr*)dst);
-#else
-   return inet_pton(af, src, dst);
-#endif
-}
+      for (tries = 10;;)
+      {
+         int state;
 
-struct in_addr6_compat
-{
-   unsigned char ip_addr[16];
-};
+         if (netCtlGetState(&state) < 0)
+            goto failure;
+         if (state == NET_CTL_STATE_IPObtained)
+            break;
 
-#ifdef _XBOX
+         if (!(--tries))
+            goto failure;
 
-#ifndef IM_IN6ADDRSZ
-#define	IM_IN6ADDRSZ	16
-#endif
+         retro_sleep(500);
+      }
 
-#ifndef IM_INT16SZ
-#define	IM_INT16SZ		2
-#endif
+      initialized = true;
+   }
 
-#ifndef IM_INADDRSZ
-#define	IM_INADDRSZ		4
-#endif
-/* Taken from https://github.com/skywind3000/easenet/blob/master/inetbase.c
- */
+   return true;
 
-/* convert presentation format to network format */
-static const char *
-inet_ntop4x(const unsigned char *src, char *dst, size_t size)
-{
-   char tmp[64];
-   size_t len = snprintf(tmp,
-         sizeof(tmp),
-         "%u.%u.%u.%u", src[0], src[1], src[2], src[3]);
+failure:
+   netCtlTerm();
+   netFinalizeNetwork();
 
-   if (len >= size)
-      goto error;
+   sysModuleUnload(SYSMODULE_NET);
 
-   memcpy(dst, tmp, len + 1);
-   return dst;
+   return false;
+#elif defined(VITA)
+   if (sceNetShowNetstat() == SCE_NET_ERROR_ENOTINIT)
+   {
+      SceNetInitParam param;
+      void *net_compat_memory = malloc(COMPAT_NET_INIT_SIZE);
 
-error:
-   errno = ENOSPC;
-   return NULL;
-}
+      if (!net_compat_memory)
+         return false;
 
-/* convert presentation format to network format */
-static const char *
-inet_ntop6x(const unsigned char *src, char *dst, size_t size)
-{
-   char tmp[64], *tp;
-   int i, inc;
-   struct { int base, len; } best, cur;
-   unsigned int words[IM_IN6ADDRSZ / IM_INT16SZ];
+      param.memory = net_compat_memory;
+      param.size   = COMPAT_NET_INIT_SIZE;
+      param.flags  = 0;
 
-   memset(words, '\0', sizeof(words));
-   best.base = best.len = 0;
-   cur.base  = cur.len  = 0;
+      if (sceNetInit(&param) < 0)
+         goto failure;
+      if (sceNetCtlInit() < 0)
+         goto failure;
 
-   for (i = 0; i < IM_IN6ADDRSZ; i++)
-      words[i / 2] |= (src[i] << ((1 - (i % 2)) << 3));
+      return true;
 
-   best.base = -1;
-   cur.base  = -1;
+failure:
+      sceNetCtlTerm();
+      sceNetTerm();
 
-   for (i = 0; i < (IM_IN6ADDRSZ / IM_INT16SZ); i++)
-   {
-      if (words[i] == 0)
-      {
-         if (cur.base == -1)
-         {
-            cur.base = i;
-            cur.len  = 1;
-         }
-         else cur.len++;
-      }
-      else
-      {
-         if (cur.base != -1)
-         {
-            if (best.base == -1 || cur.len > best.len)
-               best = cur;
-            cur.base = -1;
-         }
-      }
-   }
-   if (cur.base != -1)
-   {
-      if (best.base == -1 || cur.len > best.len)
-         best = cur;
+      free(net_compat_memory);
+
+      return false;
    }
-   if (best.base != -1 && best.len < 2)
-      best.base = -1;
 
-   tp = tmp;
-   for (i = 0; i < (IM_IN6ADDRSZ / IM_INT16SZ); i++)
+   return true;
+#elif defined(GEKKO)
+   static bool initialized = false;
+
+   if (!initialized)
    {
-      if (best.base != -1 && i >= best.base &&
-            i < (best.base + best.len))
-      {
-         if (i == best.base)
-            *tp++ = ':';
-         continue;
-      }
+      char localip[16] = {0};
+      char netmask[16] = {0};
+      char gateway[16] = {0};
 
-      if (i != 0)
-         *tp++ = ':';
-      if (i == 6 && best.base == 0 &&
-            (best.len == 6 || (best.len == 5 && words[5] == 0xffff)))
+      if (if_config(localip, netmask, gateway, true, 10) < 0)
       {
-         if (!inet_ntop4x(src+12, tp, sizeof(tmp) - (tp - tmp)))
-            return NULL;
-         tp += strlen(tp);
-         break;
+         net_deinit();
+
+         return false;
       }
-      inc = sprintf(tp, "%x", words[i]);
-      tp += inc;
+
+      initialized = true;
    }
 
-   if (best.base != -1 && (best.base + best.len) ==
-         (IM_IN6ADDRSZ / IM_INT16SZ))
-      *tp++ = ':';
+   return true;
+#elif defined(WIIU)
+   static OSThread net_compat_thread;
+   static bool initialized = false;
 
-   *tp++ = '\0';
+   if (!initialized)
+   {
+      void *stack = malloc(0x1000);
 
-   if ((size_t)(tp - tmp) > size)
-      goto error;
+      if (!stack)
+         return false;
 
-   memcpy(dst, tmp, tp - tmp);
-   return dst;
+      socket_lib_init();
 
-error:
-   errno = ENOSPC;
-   return NULL;
-}
+      if (!OSCreateThread(&net_compat_thread, _net_compat_thread_entry,
+            0, NULL, (void*)((size_t)stack + 0x1000), 0x1000, 3,
+            OS_THREAD_ATTRIB_AFFINITY_ANY))
+      {
+         free(stack);
 
-/* convert network format to presentation format */
-/* another inet_ntop, supports AF_INET/AF_INET6 */
-static const char *isockaddr_ntop(int af,
-      const void *src, char *dst, size_t size)
-{
-   switch (af)
-   {
-      case AF_INET:
-         return inet_ntop4x((const unsigned char*)src, dst, size);
-#ifdef AF_INET6
-      case AF_INET6:
-         return inet_ntop6x((const unsigned char*)src, dst, size);
-#endif
-      default:
-         if (af == -6)
-            return inet_ntop6x((const unsigned char*)src, dst, size);
-         errno = EAFNOSUPPORT;
-         return NULL;
-   }
-}
-#endif
+         return false;
+      }
 
-const char *inet_ntop_compat(int af, const void *src, char *dst, socklen_t cnt)
-{
-#if defined(VITA) || defined(__ORBIS__)
-   return sceNetInetNtop(af,src,dst,cnt);
-#elif defined(WIIU)
-   return inet_ntop(af, src, dst, cnt);
-#elif defined(_XBOX)
-   return isockaddr_ntop(af, src, dst, cnt);
-#elif defined(_WIN32)
-   if (af == AF_INET)
-   {
-      struct sockaddr_in in;
-      memset(&in, 0, sizeof(in));
-      in.sin_family = AF_INET;
-      memcpy(&in.sin_addr, src, sizeof(struct in_addr));
-      getnameinfo((struct sockaddr *)&in, sizeof(struct
-               sockaddr_in), dst, cnt, NULL, 0, NI_NUMERICHOST);
-      return dst;
-   }
-#if defined(AF_INET6) && !defined(HAVE_SOCKET_LEGACY)
-   else if (af == AF_INET6)
-   {
-      struct sockaddr_in6 in;
-      memset(&in, 0, sizeof(in));
-      in.sin6_family = AF_INET6;
-      memcpy(&in.sin6_addr, src, sizeof(struct in_addr6_compat));
-      getnameinfo((struct sockaddr *)&in, sizeof(struct
-               sockaddr_in6), dst, cnt, NULL, 0, NI_NUMERICHOST);
-      return dst;
+      OSSetThreadName(&net_compat_thread, "Network compat thread");
+      OSSetThreadDeallocator(&net_compat_thread, _net_compat_thread_cleanup);
+      OSResumeThread(&net_compat_thread);
+
+      initialized = true;
    }
-#endif
-   else
-      return NULL;
-#else
-   return inet_ntop(af, src, dst, cnt);
-#endif
-}
 
-bool udp_send_packet(const char *host,
-      uint16_t port, const char *msg)
-{
-   char port_buf[16]           = {0};
-   struct addrinfo hints       = {0};
-   struct addrinfo *res        = NULL;
-   const struct addrinfo *tmp  = NULL;
-   int fd                      = -1;
-   bool ret                    = true;
+   return true;
+#elif defined(_3DS)
+   static bool initialized = false;
 
-   hints.ai_socktype           = SOCK_DGRAM;
+   if (!initialized)
+   {
+      u32 *net_compat_memory = (u32*)memalign(SOC_ALIGN, SOC_BUFFERSIZE);
 
-   snprintf(port_buf, sizeof(port_buf), "%hu", (unsigned short)port);
+      if (!net_compat_memory)
+         return false;
 
-   if (getaddrinfo_retro(host, port_buf, &hints, &res) != 0)
-      return false;
+      /* WIFI init */
+      if (socInit(net_compat_memory, SOC_BUFFERSIZE))
+      {
+         socExit();
 
-   /* Send to all possible targets.
-    * "localhost" might resolve to several different IPs. */
-   tmp = (const struct addrinfo*)res;
-   while (tmp)
-   {
-      ssize_t len, ret_len;
+         free(net_compat_memory);
 
-      fd = socket(tmp->ai_family, tmp->ai_socktype, tmp->ai_protocol);
-      if (fd < 0)
-      {
-         ret = false;
-         goto end;
+         return false;
       }
 
-      len     = strlen(msg);
-      ret_len = sendto(fd, msg, len, 0, tmp->ai_addr, tmp->ai_addrlen);
+      initialized = true;
+   }
 
-      if (ret_len < len)
-      {
-         ret = false;
-         goto end;
-      }
+   return true;
+#else
+   static bool initialized = false;
 
-      socket_close(fd);
-      fd = -1;
-      tmp = tmp->ai_next;
+   if (!initialized)
+   {
+      /* Do not like SIGPIPE killing our app. */
+      signal(SIGPIPE, SIG_IGN);
+
+      initialized = true;
    }
 
-end:
-   freeaddrinfo_retro(res);
-   if (fd >= 0)
-      socket_close(fd);
-   return ret;
+   return true;
+#endif
 }
diff --git a/src/libretro/libretro-common/net/net_http.c b/src/libretro/libretro-common/net/net_http.c
index 1ccd617a25..7205ee543e 100644
--- a/src/libretro/libretro-common/net/net_http.c
+++ b/src/libretro/libretro-common/net/net_http.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (net_http.c).
@@ -33,6 +33,7 @@
 #include <compat/strl.h>
 #include <string/stdstring.h>
 #include <string.h>
+#include <lists/string_list.h>
 #include <retro_common_api.h>
 #include <retro_miscellaneous.h>
 
@@ -55,24 +56,23 @@ enum
 
 struct http_socket_state_t
 {
+   void *ssl_ctx;
    int fd;
    bool ssl;
-   void *ssl_ctx;
 };
 
 struct http_t
 {
+   char *data;
+   struct string_list *headers;
+   struct http_socket_state_t sock_state; /* ptr alignment */
+   size_t pos;
+   size_t len;
+   size_t buflen;
    int status;
-
    char part;
    char bodytype;
    bool error;
-
-   size_t pos;
-   size_t len;
-   size_t buflen;
-   char *data;
-   struct http_socket_state_t sock_state;
 };
 
 struct http_connection_t
@@ -83,48 +83,293 @@ struct http_connection_t
    char *scan;
    char *methodcopy;
    char *contenttypecopy;
-   char *postdatacopy;
-   char* useragentcopy;
+   void *postdatacopy;
+   char *useragentcopy;
+   char *headerscopy;
+   struct http_socket_state_t sock_state; /* ptr alignment */
+   size_t contentlength;
    int port;
-   struct http_socket_state_t sock_state;
 };
 
-static char urlencode_lut[256];
-static bool urlencode_lut_inited = false;
-
-void urlencode_lut_init(void)
+/**
+ * net_http_urlencode:
+ *
+ * URL Encode a string
+ * caller is responsible for deleting the destination buffer
+ **/
+void net_http_urlencode(char **dest, const char *source)
 {
-   unsigned i;
-
-   urlencode_lut_inited = true;
-
-   for (i = 0; i < 256; i++)
+   static const char urlencode_lut[256] = 
    {
-      urlencode_lut[i] = isalnum(i) || i == '*' || i == '-' || i == '.' || i == '_' || i == '/' ? i : 0;
-   }
-}
+      0,       /* 0   */
+      0,       /* 1   */
+      0,       /* 2   */
+      0,       /* 3   */
+      0,       /* 4   */
+      0,       /* 5   */
+      0,       /* 6   */
+      0,       /* 7   */
+      0,       /* 8   */
+      0,       /* 9   */
+      0,       /* 10  */
+      0,       /* 11  */
+      0,       /* 12  */
+      0,       /* 13  */
+      0,       /* 14  */
+      0,       /* 15  */
+      0,       /* 16  */
+      0,       /* 17  */
+      0,       /* 18  */
+      0,       /* 19  */
+      0,       /* 20  */
+      0,       /* 21  */
+      0,       /* 22  */
+      0,       /* 23  */
+      0,       /* 24  */
+      0,       /* 25  */
+      0,       /* 26  */
+      0,       /* 27  */
+      0,       /* 28  */
+      0,       /* 29  */
+      0,       /* 30  */
+      0,       /* 31  */
+      0,       /* 32  */
+      0,       /* 33  */
+      0,       /* 34  */
+      0,       /* 35  */
+      0,       /* 36  */
+      0,       /* 37  */
+      0,       /* 38  */
+      0,       /* 39  */
+      0,       /* 40  */
+      0,       /* 41  */
+      '*',     /* 42  */
+      0,       /* 43  */
+      0,       /* 44  */
+      '-',     /* 45  */
+      '.',     /* 46  */
+      '/',     /* 47  */
+      '0',     /* 48  */
+      '1',     /* 49  */
+      '2',     /* 50  */
+      '3',     /* 51  */
+      '4',     /* 52  */
+      '5',     /* 53  */
+      '6',     /* 54  */
+      '7',     /* 55  */
+      '8',     /* 56  */
+      '9',     /* 57  */
+      0,       /* 58  */
+      0,       /* 59  */
+      0,       /* 60  */
+      0,       /* 61  */
+      0,       /* 62  */
+      0,       /* 63  */
+      0,       /* 64  */
+      'A',     /* 65  */
+      'B',     /* 66  */
+      'C',     /* 67  */
+      'D',     /* 68  */
+      'E',     /* 69  */
+      'F',     /* 70  */
+      'G',     /* 71  */
+      'H',     /* 72  */
+      'I',     /* 73  */
+      'J',     /* 74  */
+      'K',     /* 75  */
+      'L',     /* 76  */
+      'M',     /* 77  */
+      'N',     /* 78  */
+      'O',     /* 79  */
+      'P',     /* 80  */
+      'Q',     /* 81  */
+      'R',     /* 82  */
+      'S',     /* 83  */
+      'T',     /* 84  */
+      'U',     /* 85  */
+      'V',     /* 86  */
+      'W',     /* 87  */
+      'X',     /* 88  */
+      'Y',     /* 89  */
+      'Z',     /* 90  */
+      0,       /* 91  */
+      0,       /* 92  */
+      0,       /* 93  */
+      0,       /* 94  */
+      '_',     /* 95  */
+      0,       /* 96  */
+      'a',     /* 97  */
+      'b',     /* 98  */
+      'c',     /* 99  */
+      'd',     /* 100 */
+      'e',     /* 101 */
+      'f',     /* 102 */
+      'g',     /* 103 */
+      'h',     /* 104 */
+      'i',     /* 105 */
+      'j',     /* 106 */
+      'k',     /* 107 */
+      'l',     /* 108 */
+      'm',     /* 109 */
+      'n',     /* 110 */
+      'o',     /* 111 */
+      'p',     /* 112 */
+      'q',     /* 113 */
+      'r',     /* 114 */
+      's',     /* 115 */
+      't',     /* 116 */
+      'u',     /* 117 */
+      'v',     /* 118 */
+      'w',     /* 119 */
+      'x',     /* 120 */
+      'y',     /* 121 */
+      'z',     /* 122 */
+      0,       /* 123 */
+      0,       /* 124 */
+      0,       /* 125 */
+      0,       /* 126 */
+      0,       /* 127 */
+      0,       /* 128 */
+      0,       /* 129 */
+      0,       /* 130 */
+      0,       /* 131 */
+      0,       /* 132 */
+      0,       /* 133 */
+      0,       /* 134 */
+      0,       /* 135 */
+      0,       /* 136 */
+      0,       /* 137 */
+      0,       /* 138 */
+      0,       /* 139 */
+      0,       /* 140 */
+      0,       /* 141 */
+      0,       /* 142 */
+      0,       /* 143 */
+      0,       /* 144 */
+      0,       /* 145 */
+      0,       /* 146 */
+      0,       /* 147 */
+      0,       /* 148 */
+      0,       /* 149 */
+      0,       /* 150 */
+      0,       /* 151 */
+      0,       /* 152 */
+      0,       /* 153 */
+      0,       /* 154 */
+      0,       /* 155 */
+      0,       /* 156 */
+      0,       /* 157 */
+      0,       /* 158 */
+      0,       /* 159 */
+      0,       /* 160 */
+      0,       /* 161 */
+      0,       /* 162 */
+      0,       /* 163 */
+      0,       /* 164 */
+      0,       /* 165 */
+      0,       /* 166 */
+      0,       /* 167 */
+      0,       /* 168 */
+      0,       /* 169 */
+      0,       /* 170 */
+      0,       /* 171 */
+      0,       /* 172 */
+      0,       /* 173 */
+      0,       /* 174 */
+      0,       /* 175 */
+      0,       /* 176 */
+      0,       /* 177 */
+      0,       /* 178 */
+      0,       /* 179 */
+      0,       /* 180 */
+      0,       /* 181 */
+      0,       /* 182 */
+      0,       /* 183 */
+      0,       /* 184 */
+      0,       /* 185 */
+      0,       /* 186 */
+      0,       /* 187 */
+      0,       /* 188 */
+      0,       /* 189 */
+      0,       /* 190 */
+      0,       /* 191 */
+      0,       /* 192 */
+      0,       /* 193 */
+      0,       /* 194 */
+      0,       /* 195 */
+      0,       /* 196 */
+      0,       /* 197 */
+      0,       /* 198 */
+      0,       /* 199 */
+      0,       /* 200 */
+      0,       /* 201 */
+      0,       /* 202 */
+      0,       /* 203 */
+      0,       /* 204 */
+      0,       /* 205 */
+      0,       /* 206 */
+      0,       /* 207 */
+      0,       /* 208 */
+      0,       /* 209 */
+      0,       /* 210 */
+      0,       /* 211 */
+      0,       /* 212 */
+      0,       /* 213 */
+      0,       /* 214 */
+      0,       /* 215 */
+      0,       /* 216 */
+      0,       /* 217 */
+      0,       /* 218 */
+      0,       /* 219 */
+      0,       /* 220 */
+      0,       /* 221 */
+      0,       /* 222 */
+      0,       /* 223 */
+      0,       /* 224 */
+      0,       /* 225 */
+      0,       /* 226 */
+      0,       /* 227 */
+      0,       /* 228 */
+      0,       /* 229 */
+      0,       /* 230 */
+      0,       /* 231 */
+      0,       /* 232 */
+      0,       /* 233 */
+      0,       /* 234 */
+      0,       /* 235 */
+      0,       /* 236 */
+      0,       /* 237 */
+      0,       /* 238 */
+      0,       /* 239 */
+      0,       /* 240 */
+      0,       /* 241 */
+      0,       /* 242 */
+      0,       /* 243 */
+      0,       /* 244 */
+      0,       /* 245 */
+      0,       /* 246 */
+      0,       /* 247 */
+      0,       /* 248 */
+      0,       /* 249 */
+      0,       /* 250 */
+      0,       /* 251 */
+      0,       /* 252 */
+      0,       /* 253 */
+      0,       /* 254 */
+      0        /* 255 */
+   };
 
-/* URL Encode a string
-   caller is responsible for deleting the destination buffer */
-void net_http_urlencode(char **dest, const char *source)
-{
-   char *enc    = NULL;
    /* Assume every character will be encoded, so we need 3 times the space. */
-   size_t len   = strlen(source) * 3 + 1;
-   size_t count = len;
-
-   if (!urlencode_lut_inited)
-      urlencode_lut_init();
-
-   enc   = (char*)calloc(1, len);
-
-   *dest = enc;
+   size_t len                       = strlen(source) * 3 + 1;
+   size_t count                     = len;
+   char *enc                        = (char*)calloc(1, len);
+   *dest                            = enc;
 
    for (; *source; source++)
    {
       int written = 0;
 
-      /* any non-ascii character will just be encoded without question */
+      /* any non-ASCII character will just be encoded without question */
       if ((unsigned)*source < sizeof(urlencode_lut) && urlencode_lut[(unsigned)*source])
          written = snprintf(enc, count, "%c", urlencode_lut[(unsigned)*source]);
       else
@@ -139,18 +384,23 @@ void net_http_urlencode(char **dest, const char *source)
    (*dest)[len - 1] = '\0';
 }
 
-/* Re-encode a full URL */
+/**
+ * net_http_urlencode_full:
+ *
+ * Re-encode a full URL
+ **/
 void net_http_urlencode_full(char *dest,
       const char *source, size_t size)
 {
-   size_t buf_pos                    = 0;
+   size_t buf_pos;
+   size_t tmp_len;
+   char url_domain[256];
+   char url_path[PATH_MAX_LENGTH];
    char *tmp                         = NULL;
-   char url_domain[PATH_MAX_LENGTH]  = {0};
-   char url_path[PATH_MAX_LENGTH]    = {0};
    int count                         = 0;
 
    strlcpy(url_path, source, sizeof(url_path));
-   tmp = url_path;
+   tmp            = url_path;
 
    while (count < 3 && tmp[0] != '\0')
    {
@@ -159,65 +409,71 @@ void net_http_urlencode_full(char *dest,
       tmp++;
    }
 
-   strlcpy(url_domain, source, tmp - url_path);
-
+   tmp_len        = strlen(tmp);
+   buf_pos        = ((strlcpy(url_domain, source, tmp - url_path)) - tmp_len) - 1;
    strlcpy(url_path,
-         source + strlen(url_domain) + 1,
-         strlen(tmp) + 1
+         source  + buf_pos + 1,
+         tmp_len           + 1
          );
 
-   tmp            = NULL;
+   tmp             = NULL;
    net_http_urlencode(&tmp, url_path);
    buf_pos         = strlcpy(dest, url_domain, size);
-   dest[buf_pos]   = '/';
-   dest[buf_pos+1] = '\0';
-   strlcat(dest, tmp, size);
-   free (tmp);
+   dest[  buf_pos] = '/';
+   dest[++buf_pos] = '\0';
+   strlcpy(dest + buf_pos, tmp, size - buf_pos);
+   free(tmp);
 }
 
 static int net_http_new_socket(struct http_connection_t *conn)
 {
-   int ret;
    struct addrinfo *addr = NULL, *next_addr = NULL;
    int fd                = socket_init(
-         (void**)&addr, conn->port, conn->domain, SOCKET_TYPE_STREAM);
+         (void**)&addr, conn->port, conn->domain, SOCKET_TYPE_STREAM, 0);
 #ifdef HAVE_SSL
    if (conn->sock_state.ssl)
    {
-      if (!(conn->sock_state.ssl_ctx = ssl_socket_init(fd, conn->domain)))
-         return -1;
-   }
-#endif
-
-   next_addr = addr;
+      if (fd < 0)
+         goto done;
 
-   while (fd >= 0)
-   {
-#ifdef HAVE_SSL
-      if (conn->sock_state.ssl)
+      if (!(conn->sock_state.ssl_ctx = ssl_socket_init(fd, conn->domain)))
       {
-         ret = ssl_socket_connect(conn->sock_state.ssl_ctx,
-               (void*)next_addr, true, true);
+         socket_close(fd);
+         fd = -1;
+         goto done;
+      }
 
-         if (ret >= 0)
-            break;
+      /* TODO: Properly figure out what's going wrong when the newer 
+         timeout/poll code interacts with mbed and winsock
+         https://github.com/libretro/RetroArch/issues/14742 */
 
-         ssl_socket_close(conn->sock_state.ssl_ctx);
-      }
-      else
+      /* Temp fix, don't use new timeout/poll code for cheevos http requests */
+         bool timeout = true;
+#ifdef __WIN32
+      if (!strcmp(conn->domain, "retroachievements.org"))
+         timeout = false;
 #endif
-      {
-         ret = socket_connect(fd, (void*)next_addr, true);
-
-         if (ret >= 0 && socket_nonblock(fd))
-            break;
 
-         socket_close(fd);
+      if (ssl_socket_connect(conn->sock_state.ssl_ctx, addr, timeout, true)
+            < 0)
+      {
+         fd = -1;
+         goto done;
       }
+   }
+   else
+#endif
+   for (next_addr = addr; fd >= 0; fd = socket_next((void**)&next_addr))
+   {
+      if (socket_connect_with_timeout(fd, next_addr, 5000))
+         break;
 
-      fd = socket_next((void**)&next_addr);
+      socket_close(fd);
    }
 
+#ifdef HAVE_SSL
+done:
+#endif
    if (addr)
       freeaddrinfo_retro(addr);
 
@@ -227,12 +483,11 @@ static int net_http_new_socket(struct http_connection_t *conn)
 }
 
 static void net_http_send_str(
-      struct http_socket_state_t *sock_state, bool *error, const char *text)
+      struct http_socket_state_t *sock_state, bool *error,
+      const char *text, size_t text_size)
 {
-   size_t text_size;
    if (*error)
       return;
-   text_size = strlen(text);
 #ifdef HAVE_SSL
    if (sock_state->ssl)
    {
@@ -252,36 +507,38 @@ static void net_http_send_str(
 struct http_connection_t *net_http_connection_new(const char *url,
       const char *method, const char *data)
 {
-   char new_domain[2048];
-   bool error                     = false;
-   char **domain                  = NULL;
-   char *uri                      = NULL;
-   char *url_dup                  = NULL;
-   char *domain_port              = NULL;
-   char *domain_port2             = NULL;
-   char *url_port                 = NULL;
-
-   struct http_connection_t *conn = (struct http_connection_t*)calloc(1,
-         sizeof(*conn));
-
-   if (!conn)
-      return NULL;
+   struct http_connection_t *conn = NULL;
 
    if (!url)
-   {
-      free(conn);
       return NULL;
-   }
+   if (!(conn = (struct http_connection_t*)malloc(
+         sizeof(*conn))))
+      return NULL;
 
-   conn->urlcopy           = strdup(url);
+   conn->domain            = NULL;
+   conn->location          = NULL;
+   conn->urlcopy           = NULL;
+   conn->scan              = NULL;
+   conn->methodcopy        = NULL;
+   conn->contenttypecopy   = NULL;
+   conn->postdatacopy      = NULL;
+   conn->useragentcopy     = NULL;
+   conn->headerscopy       = NULL;
+   conn->port              = 0;
+   conn->sock_state.fd     = 0;
+   conn->sock_state.ssl    = false;
+   conn->sock_state.ssl_ctx= NULL;
 
    if (method)
       conn->methodcopy     = strdup(method);
 
    if (data)
+   {
       conn->postdatacopy   = strdup(data);
+      conn->contentlength  = strlen(data);
+   }
 
-   if (!conn->urlcopy)
+   if (!(conn->urlcopy = strdup(url)))
       goto error;
 
    if (!strncmp(url, "http://", STRLEN_CONST("http://")))
@@ -292,57 +549,12 @@ struct http_connection_t *net_http_connection_new(const char *url,
       conn->sock_state.ssl = true;
    }
    else
-      error = true;
-
-   if (string_is_empty(conn->scan))
       goto error;
 
-   /* Get the port here from the url if it's specified.
-      does not work on username password urls: user:pass@domain.com
-
-      This code is not supposed to be needed, since the port 
-      should be gotten elsewhere when the url is being scanned
-      for ":", but for whatever reason, it's not working correctly.
-   */
-     
-   uri = strchr(conn->scan, (char) '/');
-   
-   if (strchr(conn->scan, (char) ':'))
-   {
-      size_t buf_pos;
-      url_dup       = strdup(conn->scan);
-      domain_port   = strtok(url_dup, ":");
-      domain_port2  = strtok(NULL, ":");
-      url_port      = domain_port2;
-      if (strchr(domain_port2, (char) '/'))
-         url_port   = strtok(domain_port2, "/");
-
-      if (url_port)
-         conn->port = atoi(url_port);
-
-      buf_pos = strlcpy(new_domain, domain_port, sizeof(new_domain));
-      free(url_dup);
-
-      if (uri)
-      {
-         if (!strchr(uri, (char) '/'))
-            strlcat(new_domain, uri, sizeof(new_domain));
-         else
-         {
-            new_domain[buf_pos]   = '/';
-            new_domain[buf_pos+1] = '\0';
-            strlcat(new_domain, strchr(uri, (char)'/') + sizeof(char),
-                  sizeof(new_domain));
-         }
-         strlcpy(conn->scan, new_domain, strlen(conn->scan) + 1);
-      }
-   }
-   /* end of port-fetching from url  */
-   if (error)
+   if (string_is_empty(conn->scan))
       goto error;
 
-   domain        = &conn->domain;
-   *domain       = conn->scan;
+   conn->domain = conn->scan;
 
    return conn;
 
@@ -360,6 +572,11 @@ struct http_connection_t *net_http_connection_new(const char *url,
    return NULL;
 }
 
+/**
+ * net_http_connection_iterate:
+ *
+ * Leaf function.
+ **/
 bool net_http_connection_iterate(struct http_connection_t *conn)
 {
    if (!conn)
@@ -373,39 +590,72 @@ bool net_http_connection_iterate(struct http_connection_t *conn)
 
 bool net_http_connection_done(struct http_connection_t *conn)
 {
-   char **location = NULL;
+   int has_port = 0;
 
-   if (!conn)
+   if (!conn || !conn->domain || !*conn->domain)
       return false;
 
-   location     = &conn->location;
+   if (*conn->scan == ':')
+   {
+      /* domain followed by port, split off the port */
+      *conn->scan++ = '\0';
 
-   if (*conn->scan == '\0')
-      return false;
-   *conn->scan  = '\0';
+      if (!isdigit((int)(*conn->scan)))
+         return false;
 
-   if (conn->port == 0)
+      conn->port = (int)strtoul(conn->scan, &conn->scan, 10);
+      has_port   = 1;
+   }
+   else if (conn->port == 0)
    {
+      /* port not specified, default to standard HTTP or HTTPS port */
       if (conn->sock_state.ssl)
-         conn->port   = 443;
+         conn->port = 443;
       else
-         conn->port   = 80;
+         conn->port = 80;
    }
 
-   if (*conn->scan == ':')
+   if (*conn->scan == '/')
    {
-      if (!isdigit((int)conn->scan[1]))
-         return false;
-
-      conn->port = (int)strtoul(conn->scan + 1, &conn->scan, 10);
-
-      if (*conn->scan != '/')
-         return false;
+      /* domain followed by location - split off the location */
+      /*   site.com/path.html   or   site.com:80/path.html   */
+      *conn->scan    = '\0';
+      conn->location = conn->scan + 1;
+      return true;
+   }
+   else if (!*conn->scan)
+   {
+      /* domain with no location - point location at empty string */
+      /*   site.com   or   site.com:80   */
+      conn->location = conn->scan;
+      return true;
    }
+   else if (*conn->scan == '?')
+   {
+      /* domain with no location, but still has query parms - point location at the query parms */
+      /*   site.com?param=3   or  site.com:80?param=3   */
+      if (!has_port)
+      {
+         /* if there wasn't a port, we have to expand the urlcopy so we can separate the two parts */
+         size_t domain_len   = strlen(conn->domain);
+         size_t location_len = strlen(conn->scan);
+         char* urlcopy       = (char*)malloc(domain_len + location_len + 2);
+         memcpy(urlcopy, conn->domain, domain_len);
+         urlcopy[domain_len] = '\0';
+         memcpy(urlcopy + domain_len + 1, conn->scan, location_len + 1);
+
+         free(conn->urlcopy);
+         conn->domain        = conn->urlcopy = urlcopy;
+         conn->location      = conn->scan    = urlcopy + domain_len + 1;
+      }
+      else /* There was a port, so overwriting the : will terminate the domain and we can just point at the ? */
+         conn->location      = conn->scan;
 
-   *location = conn->scan + 1;
+      return true;
+   }
 
-   return true;
+   /* invalid character after domain/port */
+   return false;
 }
 
 void net_http_connection_free(struct http_connection_t *conn)
@@ -428,16 +678,21 @@ void net_http_connection_free(struct http_connection_t *conn)
    if (conn->useragentcopy)
       free(conn->useragentcopy);
 
+   if (conn->headerscopy)
+      free(conn->headerscopy);
+
    conn->urlcopy         = NULL;
    conn->methodcopy      = NULL;
    conn->contenttypecopy = NULL;
    conn->postdatacopy    = NULL;
    conn->useragentcopy   = NULL;
+   conn->headerscopy     = NULL;
 
    free(conn);
 }
 
-void net_http_connection_set_user_agent(struct http_connection_t* conn, const char* user_agent)
+void net_http_connection_set_user_agent(
+      struct http_connection_t *conn, const char *user_agent)
 {
    if (conn->useragentcopy)
       free(conn->useragentcopy);
@@ -445,79 +700,130 @@ void net_http_connection_set_user_agent(struct http_connection_t* conn, const ch
    conn->useragentcopy = user_agent ? strdup(user_agent) : NULL;
 }
 
+void net_http_connection_set_headers(
+      struct http_connection_t *conn, const char *headers)
+{
+   if (conn->headerscopy)
+      free(conn->headerscopy);
+
+   conn->headerscopy = headers ? strdup(headers) : NULL;
+}
+
+void net_http_connection_set_content(
+      struct http_connection_t *conn, const char *content_type,
+      size_t content_length, const void *content)
+
+{
+   if (conn->contenttypecopy)
+      free(conn->contenttypecopy);
+   if (conn->postdatacopy)
+      free(conn->postdatacopy);
+
+   conn->contenttypecopy = content_type ? strdup(content_type) : NULL;
+   conn->contentlength = content_length;
+   if (content_length)
+   {
+      conn->postdatacopy = malloc(content_length);
+      memcpy(conn->postdatacopy, content, content_length);
+   }
+}
+
 const char *net_http_connection_url(struct http_connection_t *conn)
 {
    return conn->urlcopy;
 }
 
+const char* net_http_connection_method(struct http_connection_t* conn)
+{
+   return conn->methodcopy;
+}
+
 struct http_t *net_http_new(struct http_connection_t *conn)
 {
    bool error            = false;
+#ifdef HAVE_SSL
+   if (!conn || (net_http_new_socket(conn)) < 0)
+      return NULL;
+#else
    int fd                = -1;
-   struct http_t *state  = NULL;
-
-   if (!conn)
-      goto error;
-
-   fd = net_http_new_socket(conn);
-
-   if (fd < 0)
-      goto error;
-
-   error = false;
+   if (!conn || (fd = net_http_new_socket(conn)) < 0)
+      return NULL;
+#endif
 
    /* This is a bit lazy, but it works. */
    if (conn->methodcopy)
    {
-      net_http_send_str(&conn->sock_state, &error, conn->methodcopy);
-      net_http_send_str(&conn->sock_state, &error, " /");
+      net_http_send_str(&conn->sock_state, &error, conn->methodcopy,
+            strlen(conn->methodcopy));
+      net_http_send_str(&conn->sock_state, &error, " /",
+            STRLEN_CONST(" /"));
    }
    else
    {
-      net_http_send_str(&conn->sock_state, &error, "GET /");
+      net_http_send_str(&conn->sock_state, &error, "GET /",
+            STRLEN_CONST("GET /"));
    }
 
-   net_http_send_str(&conn->sock_state, &error, conn->location);
-   net_http_send_str(&conn->sock_state, &error, " HTTP/1.1\r\n");
+   net_http_send_str(&conn->sock_state, &error, conn->location,
+         strlen(conn->location));
+   net_http_send_str(&conn->sock_state, &error, " HTTP/1.1\r\n",
+         STRLEN_CONST(" HTTP/1.1\r\n"));
 
-   net_http_send_str(&conn->sock_state, &error, "Host: ");
-   net_http_send_str(&conn->sock_state, &error, conn->domain);
+   net_http_send_str(&conn->sock_state, &error, "Host: ",
+         STRLEN_CONST("Host: "));
+   net_http_send_str(&conn->sock_state, &error, conn->domain,
+         strlen(conn->domain));
 
-   if (!conn->port)
+   if (conn->port)
    {
       char portstr[16];
-
-      portstr[0] = '\0';
-
-      snprintf(portstr, sizeof(portstr), ":%i", conn->port);
-      net_http_send_str(&conn->sock_state, &error, portstr);
+      size_t _len     = 0;
+      portstr[  _len] = ':';
+      portstr[++_len] = '\0';
+      _len           += snprintf(portstr + _len, sizeof(portstr) - _len,
+            "%i", conn->port);
+      net_http_send_str(&conn->sock_state, &error, portstr, _len);
    }
 
-   net_http_send_str(&conn->sock_state, &error, "\r\n");
+   net_http_send_str(&conn->sock_state, &error, "\r\n",
+         STRLEN_CONST("\r\n"));
 
-   /* This is not being set anywhere yet */
+   /* Pre-formatted headers */
+   if (conn->headerscopy)
+      net_http_send_str(&conn->sock_state, &error, conn->headerscopy,
+            strlen(conn->headerscopy));
    if (conn->contenttypecopy)
    {
-      net_http_send_str(&conn->sock_state, &error, "Content-Type: ");
-      net_http_send_str(&conn->sock_state, &error, conn->contenttypecopy);
-      net_http_send_str(&conn->sock_state, &error, "\r\n");
+      net_http_send_str(&conn->sock_state, &error, "Content-Type: ",
+            STRLEN_CONST("Content-Type: "));
+      net_http_send_str(&conn->sock_state, &error,
+            conn->contenttypecopy, strlen(conn->contenttypecopy));
+      net_http_send_str(&conn->sock_state, &error, "\r\n",
+            STRLEN_CONST("\r\n"));
    }
 
-   if (conn->methodcopy && (string_is_equal(conn->methodcopy, "POST")))
+   if (conn->methodcopy && (string_is_equal(conn->methodcopy, "POST") || string_is_equal(conn->methodcopy, "PUT")))
    {
       size_t post_len, len;
       char *len_str        = NULL;
 
-      if (!conn->postdatacopy)
-         goto error;
+      if (!conn->postdatacopy && !string_is_equal(conn->methodcopy, "PUT"))
+         goto err;
 
-      if (!conn->contenttypecopy)
-         net_http_send_str(&conn->sock_state, &error,
-               "Content-Type: application/x-www-form-urlencoded\r\n");
+      if (!conn->headerscopy)
+      {
+         if (!conn->contenttypecopy)
+            net_http_send_str(&conn->sock_state, &error,
+                  "Content-Type: application/x-www-form-urlencoded\r\n",
+                  STRLEN_CONST(
+                     "Content-Type: application/x-www-form-urlencoded\r\n"
+                     ));
+      }
 
-      net_http_send_str(&conn->sock_state, &error, "Content-Length: ");
+      net_http_send_str(&conn->sock_state, &error, "Content-Length: ",
+            STRLEN_CONST("Content-Length: "));
 
-      post_len = strlen(conn->postdatacopy);
+      post_len = conn->contentlength;
 #ifdef _WIN32
       len     = snprintf(NULL, 0, "%" PRIuPTR, post_len);
       len_str = (char*)malloc(len + 1);
@@ -530,72 +836,94 @@ struct http_t *net_http_new(struct http_connection_t *conn)
 
       len_str[len] = '\0';
 
-      net_http_send_str(&conn->sock_state, &error, len_str);
-      net_http_send_str(&conn->sock_state, &error, "\r\n");
+      net_http_send_str(&conn->sock_state, &error, len_str,
+            strlen(len_str));
+      net_http_send_str(&conn->sock_state, &error, "\r\n",
+            STRLEN_CONST("\r\n"));
 
       free(len_str);
    }
 
-   net_http_send_str(&conn->sock_state, &error, "User-Agent: ");
+   net_http_send_str(&conn->sock_state, &error, "User-Agent: ",
+         STRLEN_CONST("User-Agent: "));
    if (conn->useragentcopy)
-      net_http_send_str(&conn->sock_state, &error, conn->useragentcopy);
+      net_http_send_str(&conn->sock_state, &error,
+            conn->useragentcopy, strlen(conn->useragentcopy));
    else
-      net_http_send_str(&conn->sock_state, &error, "libretro");
-   net_http_send_str(&conn->sock_state, &error, "\r\n");
-
-   net_http_send_str(&conn->sock_state, &error, "Connection: close\r\n");
-   net_http_send_str(&conn->sock_state, &error, "\r\n");
+      net_http_send_str(&conn->sock_state, &error, "libretro",
+            STRLEN_CONST("libretro"));
+   net_http_send_str(&conn->sock_state, &error, "\r\n",
+         STRLEN_CONST("\r\n"));
 
-   if (conn->methodcopy && (string_is_equal(conn->methodcopy, "POST")))
-      net_http_send_str(&conn->sock_state, &error, conn->postdatacopy);
+   net_http_send_str(&conn->sock_state, &error,
+         "Connection: close\r\n", STRLEN_CONST("Connection: close\r\n"));
+   net_http_send_str(&conn->sock_state, &error, "\r\n",
+         STRLEN_CONST("\r\n"));
 
-   if (error)
-      goto error;
-
-   state             = (struct http_t*)malloc(sizeof(struct http_t));
-   state->sock_state = conn->sock_state;
-   state->status     = -1;
-   state->data       = NULL;
-   state->part       = P_HEADER_TOP;
-   state->bodytype   = T_FULL;
-   state->error      = false;
-   state->pos        = 0;
-   state->len        = 0;
-   state->buflen     = 512;
-   state->data       = (char*)malloc(state->buflen);
-
-   if (!state->data)
-      goto error;
+   if (conn->postdatacopy && conn->contentlength)
+      net_http_send_str(&conn->sock_state, &error, conn->postdatacopy,
+            conn->contentlength);
 
-   return state;
+   if (!error)
+   {
+      struct http_t *state = (struct http_t*)malloc(sizeof(struct http_t));
+      state->sock_state    = conn->sock_state;
+      state->status        = -1;
+      state->data          = NULL;
+      state->part          = P_HEADER_TOP;
+      state->bodytype      = T_FULL;
+      state->error         = false;
+      state->pos           = 0;
+      state->len           = 0;
+      state->buflen        = 512;
+
+      if ((state->data = (char*)malloc(state->buflen)))
+      {
+         if ((state->headers = string_list_new()) &&
+             string_list_initialize(state->headers))
+            return state;
+         string_list_free(state->headers);
+      }
+      free(state);
+   }
 
-error:
+err:
    if (conn)
    {
       if (conn->methodcopy)
          free(conn->methodcopy);
       if (conn->contenttypecopy)
          free(conn->contenttypecopy);
-      conn->methodcopy = NULL;
-      conn->contenttypecopy = NULL;
-      conn->postdatacopy = NULL;
-   }
+      if (conn->postdatacopy)
+         free(conn->postdatacopy);
+      conn->methodcopy           = NULL;
+      conn->contenttypecopy      = NULL;
+      conn->postdatacopy         = NULL;
+
 #ifdef HAVE_SSL
-   if (conn && conn->sock_state.ssl && conn->sock_state.ssl_ctx && fd >= 0)
-   {
-      ssl_socket_close(conn->sock_state.ssl_ctx);
-      ssl_socket_free(conn->sock_state.ssl_ctx);
-      conn->sock_state.ssl_ctx = NULL;
+      if (conn->sock_state.ssl_ctx)
+      {
+         ssl_socket_close(conn->sock_state.ssl_ctx);
+         ssl_socket_free(conn->sock_state.ssl_ctx);
+         conn->sock_state.ssl_ctx = NULL;
+      }
+#endif
    }
-#else
-   if (fd >= 0)
-      socket_close(fd);
+
+#ifndef HAVE_SSL
+   socket_close(fd);
 #endif
-   if (state)
-      free(state);
    return NULL;
 }
 
+/**
+ * net_http_fd:
+ *
+ * Leaf function.
+ *
+ * You can use this to call net_http_update
+ * only when something will happen; select() it for reading.
+ **/
 int net_http_fd(struct http_t *state)
 {
    if (!state)
@@ -603,236 +931,269 @@ int net_http_fd(struct http_t *state)
    return state->sock_state.fd;
 }
 
+/**
+ * net_http_update:
+ *
+ * @return true if it's done, or if something broke.
+ * @total will be 0 if it's not known.
+ **/
 bool net_http_update(struct http_t *state, size_t* progress, size_t* total)
 {
-   ssize_t newlen = 0;
-
-   if (!state || state->error)
-      goto fail;
-
-   if (state->part < P_BODY)
+   if (state)
    {
+      ssize_t newlen   = 0;
       if (state->error)
-         newlen = -1;
-      else
+         goto error;
+
+      if (state->part < P_BODY)
       {
+         if (state->error)
+            goto error;
+
 #ifdef HAVE_SSL
          if (state->sock_state.ssl && state->sock_state.ssl_ctx)
             newlen = ssl_socket_receive_all_nonblocking(state->sock_state.ssl_ctx, &state->error,
-               (uint8_t*)state->data + state->pos,
-               state->buflen - state->pos);
+                  (uint8_t*)state->data + state->pos,
+                  state->buflen - state->pos);
          else
 #endif
             newlen = socket_receive_all_nonblocking(state->sock_state.fd, &state->error,
-               (uint8_t*)state->data + state->pos,
-               state->buflen - state->pos);
-      }
+                  (uint8_t*)state->data + state->pos,
+                  state->buflen - state->pos);
 
-      if (newlen < 0)
-         goto fail;
+         if (newlen < 0)
+         {
+            state->error  = true;
+            goto error;
+         }
 
-      if (state->pos + newlen >= state->buflen - 64)
-      {
-         state->buflen *= 2;
-         state->data    = (char*)realloc(state->data, state->buflen);
-      }
-      state->pos += newlen;
+         if (state->pos + newlen >= state->buflen - 64)
+         {
+            state->buflen *= 2;
+            state->data    = (char*)realloc(state->data, state->buflen);
+         }
+         state->pos       += newlen;
 
-      while (state->part < P_BODY)
-      {
-         char *dataend = state->data + state->pos;
-         char *lineend = (char*)memchr(state->data, '\n', state->pos);
+         while (state->part < P_BODY)
+         {
+            char *dataend  = state->data + state->pos;
+            char *lineend  = (char*)memchr(state->data, '\n', state->pos);
 
-         if (!lineend)
-            break;
+            if (!lineend)
+               break;
 
-         *lineend='\0';
+            *lineend       = '\0';
 
-         if (lineend != state->data && lineend[-1]=='\r')
-            lineend[-1]='\0';
+            if (lineend != state->data && lineend[-1]=='\r')
+               lineend[-1] = '\0';
 
-         if (state->part == P_HEADER_TOP)
-         {
-            if (strncmp(state->data, "HTTP/1.", STRLEN_CONST("HTTP/1."))!=0)
-               goto fail;
-            state->status = (int)strtoul(state->data 
-                  + STRLEN_CONST("HTTP/1.1 "), NULL, 10);
-            state->part   = P_HEADER;
-         }
-         else
-         {
-            if (!strncmp(state->data, "Content-Length: ",
-                     STRLEN_CONST("Content-Length: ")))
+            if (state->part == P_HEADER_TOP)
             {
-               state->bodytype = T_LEN;
-               state->len = strtol(state->data +
-                     STRLEN_CONST("Content-Length: "), NULL, 10);
+               if (strncmp(state->data, "HTTP/1.", STRLEN_CONST("HTTP/1."))!=0)
+               {
+                  state->error  = true;
+                  goto error;
+               }
+               state->status    = (int)strtoul(state->data 
+                     + STRLEN_CONST("HTTP/1.1 "), NULL, 10);
+               state->part      = P_HEADER;
             }
-            if (string_is_equal(state->data, "Transfer-Encoding: chunked"))
-               state->bodytype = T_CHUNK;
-
-            /* TODO: save headers somewhere */
-            if (state->data[0]=='\0')
+            else
             {
-               state->part = P_BODY;
-               if (state->bodytype == T_CHUNK)
-                  state->part = P_BODY_CHUNKLEN;
+               if (string_starts_with_case_insensitive(state->data, "Content-Length:"))
+               {
+                  char* ptr = state->data + STRLEN_CONST("Content-Length:");
+                  while (ISSPACE(*ptr))
+                     ++ptr;
+
+                  state->bodytype = T_LEN;
+                  state->len = strtol(ptr, NULL, 10);
+               }
+               if (string_is_equal_case_insensitive(state->data, "Transfer-Encoding: chunked"))
+                  state->bodytype = T_CHUNK;
+
+               if (state->data[0]=='\0')
+               {
+                  if (state->status == 100)
+                  {
+                     state->part = P_HEADER_TOP;
+                  }
+                  else
+                  {
+                     state->part = P_BODY;
+                     if (state->bodytype == T_CHUNK)
+                        state->part = P_BODY_CHUNKLEN;
+                  }
+               }
+               else
+               {
+                  union string_list_elem_attr attr;
+                  attr.i = 0;
+                  string_list_append(state->headers, state->data, attr);
+               }
             }
+
+            memmove(state->data, lineend + 1, dataend-(lineend+1));
+            state->pos = (dataend-(lineend + 1));
          }
 
-         memmove(state->data, lineend + 1, dataend-(lineend+1));
-         state->pos = (dataend-(lineend + 1));
-      }
-      if (state->part >= P_BODY)
-      {
-         newlen = state->pos;
-         state->pos = 0;
+         if (state->part >= P_BODY)
+         {
+            newlen     = state->pos;
+            state->pos = 0;
+         }
       }
-   }
 
-   if (state->part >= P_BODY && state->part < P_DONE)
-   {
-      if (!newlen)
+      if (state->part >= P_BODY && state->part < P_DONE)
       {
-         if (state->error)
-            newlen = -1;
-         else
+         if (!newlen)
          {
+            if (state->error)
+               newlen = -1;
+            else if (state->len)
+            {
 #ifdef HAVE_SSL
-            if (state->sock_state.ssl && state->sock_state.ssl_ctx)
-               newlen = ssl_socket_receive_all_nonblocking(
-                  state->sock_state.ssl_ctx,
-                  &state->error,
-                  (uint8_t*)state->data + state->pos,
-                  state->buflen - state->pos);
-            else
+               if (state->sock_state.ssl && state->sock_state.ssl_ctx)
+                  newlen = ssl_socket_receive_all_nonblocking(
+                        state->sock_state.ssl_ctx,
+                        &state->error,
+                        (uint8_t*)state->data + state->pos,
+                        state->buflen - state->pos);
+               else
 #endif
-               newlen = socket_receive_all_nonblocking(
-                  state->sock_state.fd,
-                  &state->error,
-                  (uint8_t*)state->data + state->pos,
-                  state->buflen - state->pos);
-         }
+                  newlen = socket_receive_all_nonblocking(
+                        state->sock_state.fd,
+                        &state->error,
+                        (uint8_t*)state->data + state->pos,
+                        state->buflen - state->pos);
+            }
 
-         if (newlen < 0)
-         {
-            if (state->bodytype == T_FULL)
+            if (newlen < 0)
             {
-               state->part = P_DONE;
-               state->data = (char*)realloc(state->data, state->len);
+               if (state->bodytype != T_FULL)
+               {
+                  state->error  = true;
+                  goto error;
+               }
+               state->part      = P_DONE;
+               state->data      = (char*)realloc(state->data, state->len);
+               newlen           = 0;
             }
-            else
-               goto fail;
-            newlen=0;
-         }
 
-         if (state->pos + newlen >= state->buflen - 64)
-         {
-            state->buflen *= 2;
-            state->data = (char*)realloc(state->data, state->buflen);
+            if (state->pos + newlen >= state->buflen - 64)
+            {
+               state->buflen   *= 2;
+               state->data      = (char*)realloc(state->data, state->buflen);
+            }
          }
-      }
 
 parse_again:
-      if (state->bodytype == T_CHUNK)
-      {
-         if (state->part == P_BODY_CHUNKLEN)
+         if (state->bodytype == T_CHUNK)
          {
-            state->pos += newlen;
-            if (state->pos - state->len >= 2)
+            if (state->part == P_BODY_CHUNKLEN)
             {
-               /*
-                * len=start of chunk including \r\n
-                * pos=end of data
-                */
+               state->pos      += newlen;
 
-               char *fullend = state->data + state->pos;
-               char *end     = (char*)memchr(state->data + state->len + 2, '\n',
-                                             state->pos - state->len - 2);
-
-               if (end)
+               if (state->pos - state->len >= 2)
                {
-                  size_t chunklen = strtoul(state->data+state->len, NULL, 16);
-                  state->pos      = state->len;
-                  end++;
-
-                  memmove(state->data+state->len, end, fullend-end);
-
-                  state->len      = chunklen;
-                  newlen          = (fullend - end);
-
                   /*
-                     len=num bytes
-                     newlen=unparsed bytes after \n
-                     pos=start of chunk including \r\n
-                     */
+                   * len=start of chunk including \r\n
+                   * pos=end of data
+                   */
 
-                  state->part = P_BODY;
-                  if (state->len == 0)
+                  char *fullend = state->data + state->pos;
+                  char *end     = (char*)memchr(state->data + state->len + 2, '\n',
+                        state->pos - state->len - 2);
+
+                  if (end)
                   {
-                     state->part = P_DONE;
-                     state->len  = state->pos;
-                     state->data = (char*)realloc(state->data, state->len);
+                     size_t chunklen = strtoul(state->data+state->len, NULL, 16);
+                     state->pos      = state->len;
+                     end++;
+
+                     memmove(state->data+state->len, end, fullend-end);
+
+                     state->len      = chunklen;
+                     newlen          = (fullend - end);
+
+                     /*
+                        len=num bytes
+                        newlen=unparsed bytes after \n
+                        pos=start of chunk including \r\n
+                        */
+
+                     state->part = P_BODY;
+                     if (state->len == 0)
+                     {
+                        state->part = P_DONE;
+                        state->len  = state->pos;
+                        state->data = (char*)realloc(state->data, state->len);
+                     }
+                     goto parse_again;
                   }
+               }
+            }
+            else if (state->part == P_BODY)
+            {
+               if ((size_t)newlen >= state->len)
+               {
+                  state->pos += state->len;
+                  newlen     -= state->len;
+                  state->len  = state->pos;
+                  state->part = P_BODY_CHUNKLEN;
                   goto parse_again;
                }
+               state->pos += newlen;
+               state->len -= newlen;
             }
          }
-         else if (state->part == P_BODY)
+         else
          {
-            if ((size_t)newlen >= state->len)
+            state->pos += newlen;
+
+            if (state->pos > state->len)
             {
-               state->pos += state->len;
-               newlen     -= state->len;
-               state->len  = state->pos;
-               state->part = P_BODY_CHUNKLEN;
-               goto parse_again;
+               state->error  = true;
+               goto error;
             }
-            else
+            else if (state->pos == state->len)
             {
-               state->pos += newlen;
-               state->len -= newlen;
+               state->part   = P_DONE;
+               state->data   = (char*)realloc(state->data, state->len);
             }
          }
       }
-      else
-      {
-         state->pos += newlen;
 
-         if (state->pos == state->len)
-         {
-            state->part = P_DONE;
-            state->data = (char*)realloc(state->data, state->len);
-         }
-         if (state->pos > state->len)
-            goto fail;
-      }
-   }
-
-   if (progress)
-      *progress = state->pos;
+      if (progress)
+         *progress = state->pos;
 
-   if (total)
-   {
-      if (state->bodytype == T_LEN)
-         *total=state->len;
-      else
-         *total=0;
-   }
-
-   return (state->part == P_DONE);
+      if (total)
+      {
+         if (state->bodytype == T_LEN)
+            *total = state->len;
+         else
+            *total = 0;
+      }
 
-fail:
-   if (state)
-   {
-      state->error  = true;
-      state->part   = P_ERROR;
-      state->status = -1;
+      if (state->part != P_DONE)
+         return false;
    }
-
+   return true;
+error:
+   state->part   = P_ERROR;
+   state->status = -1;
    return true;
 }
 
+/**
+ * net_http_status:
+ *
+ * Report HTTP status. 200, 404, or whatever.
+ *
+ * Leaf function.
+ * 
+ * @return HTTP status code.
+ **/
 int net_http_status(struct http_t *state)
 {
    if (!state)
@@ -840,24 +1201,58 @@ int net_http_status(struct http_t *state)
    return state->status;
 }
 
+/**
+ * net_http_headers:
+ *
+ * Leaf function.
+ *
+ * @return the response headers. The returned buffer is owned by the
+ * caller of net_http_new; it is not freed by net_http_delete().
+ * If the status is not 20x and accept_error is false, it returns NULL.
+ **/
+struct string_list *net_http_headers(struct http_t *state)
+{
+   if (!state)
+      return NULL;
+
+   if (state->error)
+      return NULL;
+
+   return state->headers;
+}
+
+/**
+ * net_http_data:
+ *
+ * Leaf function.
+ *
+ * @return the downloaded data. The returned buffer is owned by the
+ * HTTP handler; it's freed by net_http_delete().
+ * If the status is not 20x and accept_error is false, it returns NULL.
+ **/
 uint8_t* net_http_data(struct http_t *state, size_t* len, bool accept_error)
 {
    if (!state)
       return NULL;
 
-   if (!accept_error && net_http_error(state))
+   if (!accept_error && (state->error || state->status < 200 || state->status > 299))
    {
       if (len)
-         *len=0;
+         *len = 0;
       return NULL;
    }
 
    if (len)
-      *len=state->len;
+      *len    = state->len;
 
    return (uint8_t*)state->data;
 }
 
+/**
+ * net_http_delete:
+ *
+ * Cleans up all memory.
+ **/
 void net_http_delete(struct http_t *state)
 {
    if (!state)
@@ -865,19 +1260,26 @@ void net_http_delete(struct http_t *state)
 
    if (state->sock_state.fd >= 0)
    {
-      socket_close(state->sock_state.fd);
 #ifdef HAVE_SSL
       if (state->sock_state.ssl && state->sock_state.ssl_ctx)
       {
+         ssl_socket_close(state->sock_state.ssl_ctx);
          ssl_socket_free(state->sock_state.ssl_ctx);
          state->sock_state.ssl_ctx = NULL;
       }
+      else
 #endif
+      socket_close(state->sock_state.fd);
    }
    free(state);
 }
 
+/**
+ * net_http_error:
+ *
+ * Leaf function
+ **/
 bool net_http_error(struct http_t *state)
 {
-   return (state->error || state->status<200 || state->status>299);
+   return (state->error || state->status < 200 || state->status > 299);
 }
diff --git a/src/libretro/libretro-common/net/net_http_parse.c b/src/libretro/libretro-common/net/net_http_parse.c
index 113eeaa00a..7f2914c979 100644
--- a/src/libretro/libretro-common/net/net_http_parse.c
+++ b/src/libretro/libretro-common/net/net_http_parse.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (net_http_parse.c).
@@ -35,7 +35,7 @@
  * The buffer pointed to by @link is filled with the URL path the link points to,
  * and @name is filled with the title portion of the link.
  *
- * Returns: 0 if URL was parsed completely, otherwise 1.
+ * @return 0 if URL was parsed completely, otherwise 1.
  **/
 int string_parse_html_anchor(const char *line, char *link, char *name,
       size_t link_size, size_t name_size)
@@ -84,20 +84,3 @@ int string_parse_html_anchor(const char *line, char *link, char *name,
 
    return 0;
 }
-
-#ifndef RARCH_INTERNAL
-int main(int argc, char *argv[])
-{
-   char link[1024];
-   char name[1024];
-   const char *line  = "<a href=\"http://www.test.com/somefile.zip\">Test</a>\n";
-
-   link[0] = name[0] = '\0';
-
-   string_parse_html_anchor(line, link, name, sizeof(link), sizeof(name));
-
-   printf("link: %s\nname: %s\n", link, name);
-
-   return 1;
-}
-#endif
diff --git a/src/libretro/libretro-common/net/net_ifinfo.c b/src/libretro/libretro-common/net/net_ifinfo.c
index 9fe7e09692..6e4d7d77be 100644
--- a/src/libretro/libretro-common/net/net_ifinfo.c
+++ b/src/libretro/libretro-common/net/net_ifinfo.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2022 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (net_ifinfo.c).
@@ -20,232 +20,401 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-#include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
+#include <stdio.h>
 
-#include <retro_miscellaneous.h>
+#include <string/stdstring.h>
+#include <net/net_compat.h>
 
 #if defined(_WIN32) && !defined(_XBOX)
-#include <winsock2.h>
+#ifdef _MSC_VER
+#pragma comment(lib, "Iphlpapi")
+#endif
+
 #include <iphlpapi.h>
-#include <ws2tcpip.h>
-#else
-#include <arpa/inet.h>
-#include <sys/socket.h>
-#include <netdb.h>
 
-#ifdef WANT_IFADDRS
+#elif !defined(VITA) && !defined(GEKKO)
+#if defined(WANT_IFADDRS)
 #include <compat/ifaddrs.h>
-#else
-#ifndef HAVE_LIBNX
+#elif !defined(HAVE_LIBNX) && !defined(_3DS)
 #include <ifaddrs.h>
+#ifndef WIIU
+#include <net/if.h>
 #endif
 #endif
 #endif
 
 #include <net/net_ifinfo.h>
 
-#if defined(BSD)
-#include <netinet/in.h>
-#endif
-
-void net_ifinfo_free(net_ifinfo_t *list)
+bool net_ifinfo_new(net_ifinfo_t *list)
 {
-   unsigned k;
-
-   if (!list)
-      return;
-
-   for (k = 0; k < list->size; k++)
+#if defined(_WIN32) && !defined(_XBOX)
+   /* Microsoft docs recommend doing it this way. */
+   char buf[512];
+   ULONG result;
+   PIP_ADAPTER_ADDRESSES addr;
+   struct net_ifinfo_entry *entry;
+   size_t                interfaces = 0;
+   ULONG                 flags      = GAA_FLAG_SKIP_ANYCAST
+                                    | GAA_FLAG_SKIP_MULTICAST 
+                                    | GAA_FLAG_SKIP_DNS_SERVER;
+   ULONG                 len        = 15 * 1024;
+   PIP_ADAPTER_ADDRESSES addresses  = (PIP_ADAPTER_ADDRESSES)calloc(1, len);
+
+   list->entries                    = NULL;
+
+   if (!addresses)
+      goto failure;
+
+   result = GetAdaptersAddresses(AF_UNSPEC, flags, NULL, addresses, &len);
+   if (result == ERROR_BUFFER_OVERFLOW)
    {
-      struct net_ifinfo_entry *ptr =
-         (struct net_ifinfo_entry*)&list->entries[k];
+      PIP_ADAPTER_ADDRESSES new_addresses =
+         (PIP_ADAPTER_ADDRESSES)realloc(addresses, len);
 
-      if (*ptr->name)
-         free(ptr->name);
-      if (*ptr->host)
-         free(ptr->host);
+      if (new_addresses)
+      {
+         memset(new_addresses, 0, len);
 
-      ptr->name = NULL;
-      ptr->host = NULL;
+         addresses = new_addresses;
+         result    = GetAdaptersAddresses(AF_UNSPEC, flags, NULL,
+            addresses, &len);
+      }
    }
-   free(list->entries);
-}
-
-#ifdef HAVE_LIBNX
-static void convert_ip(char *dst, size_t size, uint32_t ip, bool inverted)
-{
-   unsigned char bytes[4];
-   bytes[0] = ip & 0xFF;
-   bytes[1] = (ip >> 8) & 0xFF;
-   bytes[2] = (ip >> 16) & 0xFF;
-   bytes[3] = (ip >> 24) & 0xFF;
-
-   if (inverted)
-      snprintf(dst, size, "%d.%d.%d.%d", bytes[0], bytes[1], bytes[2], bytes[3]);
-   else
-      snprintf(dst, size, "%d.%d.%d.%d", bytes[3], bytes[2], bytes[1], bytes[0]);
-}
-#endif
+   if (result != ERROR_SUCCESS)
+      goto failure;
 
-bool net_ifinfo_new(net_ifinfo_t *list)
-{
-   unsigned k              = 0;
-#ifdef HAVE_LIBNX
-   uint32_t id;
-   Result rc;
+   /* Count the number of valid interfaces first. */
+   addr = addresses;
 
-   char hostname[128];
-   struct net_ifinfo_entry *ptr = NULL;
+   do
+   {
+      PIP_ADAPTER_UNICAST_ADDRESS unicast_addr = addr->FirstUnicastAddress;
 
-   memset(list, 0, sizeof(net_ifinfo_t));
+      if (!unicast_addr)
+         continue;
+      if (addr->OperStatus != IfOperStatusUp)
+         continue;
 
-   /* loopback */
-   convert_ip(hostname, sizeof(hostname), INADDR_LOOPBACK, false);
+      do
+      {
+         interfaces++;
+      } while ((unicast_addr = unicast_addr->Next));
+   } while ((addr = addr->Next));
 
-   ptr = (struct net_ifinfo_entry*)
-         realloc(list->entries, (k+1) * sizeof(struct net_ifinfo_entry));
+   if (!interfaces)
+      goto failure;
 
-   if (!ptr)
-      goto error;
+   if (!(list->entries =
+      (struct net_ifinfo_entry*)calloc(interfaces, sizeof(*list->entries))))
+      goto failure;
 
-   list->entries          = ptr;
+   list->size    = 0;
+   /* Now create the entries. */
+   addr          = addresses;
+   entry         = list->entries;
 
-   list->entries[k].name  = strdup("lo");
-   list->entries[k].host  = strdup(hostname);
-   list->size             = k + 1;
+   do
+   {
+      PIP_ADAPTER_UNICAST_ADDRESS unicast_addr = addr->FirstUnicastAddress;
 
-   k++;
+      if (!unicast_addr)
+         continue;
+      if (addr->OperStatus != IfOperStatusUp)
+         continue;
 
-   /*
-      actual interface
-      can be wlan or eth (with a wiiu adapter)
-      so we just use "switch" as a name
-   */
-   rc = nifmGetCurrentIpAddress(&id);
+      buf[0] = '\0';
+      if (addr->FriendlyName)
+      {
+         if (!WideCharToMultiByte(CP_UTF8, 0, addr->FriendlyName, -1,
+               buf, sizeof(buf), NULL, NULL))
+            buf[0] = '\0'; /* Empty name on conversion failure. */
+      }
 
-   if (!R_SUCCEEDED(rc)) /* not connected to any network */
-      return true;
+      do
+      {
+         if (getnameinfo_retro(unicast_addr->Address.lpSockaddr,
+               unicast_addr->Address.iSockaddrLength,
+               entry->host, sizeof(entry->host), NULL, 0, NI_NUMERICHOST))
+            continue;
 
-   convert_ip(hostname, sizeof(hostname), id, true);
+         strlcpy(entry->name, buf, sizeof(entry->name));
 
-   ptr = (struct net_ifinfo_entry*)
-         realloc(list->entries, (k+1) * sizeof(struct net_ifinfo_entry));
+         if (++list->size >= interfaces)
+            break;
 
-   if (!ptr)
-      goto error;
+         entry++;
+      } while ((unicast_addr = unicast_addr->Next));
 
-   list->entries          = ptr;
+      if (list->size >= interfaces)
+         break;
+   } while ((addr = addr->Next));
 
-   list->entries[k].name  = strdup("switch");
-   list->entries[k].host  = strdup(hostname);
-   list->size             = k + 1;
+   free(addresses);
 
    return true;
-#elif defined(_WIN32) && !defined(_XBOX)
-   PIP_ADAPTER_ADDRESSES adapter_addresses = NULL, aa = NULL;
-   PIP_ADAPTER_UNICAST_ADDRESS ua = NULL;
-#ifdef _WIN32_WINNT_WINXP
-   DWORD size;
-   DWORD rv = GetAdaptersAddresses(AF_UNSPEC, GAA_FLAG_INCLUDE_PREFIX, NULL, NULL, &size);
 
-   adapter_addresses = (PIP_ADAPTER_ADDRESSES)malloc(size);
+failure:
+   free(addresses);
+   net_ifinfo_free(list);
+
+   return false;
+#elif defined(VITA)
+   SceNetCtlInfo info;
+   if (!(list->entries = (struct net_ifinfo_entry*)calloc(2, sizeof(*list->entries))))
+   {
+      list->size = 0;
+      return false;
+   }
 
-   rv = GetAdaptersAddresses(AF_UNSPEC, GAA_FLAG_INCLUDE_PREFIX, NULL, adapter_addresses, &size);
+   strlcpy(list->entries[0].name, "lo",        sizeof(list->entries[0].name));
+   strlcpy(list->entries[0].host, "127.0.0.1", sizeof(list->entries[0].host));
+   list->size = 1;
 
-   memset(list, 0, sizeof(net_ifinfo_t));
+   if (!sceNetCtlInetGetInfo(SCE_NETCTL_INFO_GET_IP_ADDRESS, &info))
+   {
+      strlcpy(list->entries[1].name, "wlan", sizeof(list->entries[1].name));
+      strlcpy(list->entries[1].host, info.ip_address,
+         sizeof(list->entries[1].host));
+      list->size++;
+   }
 
-   if (rv != ERROR_SUCCESS)
-      goto error;
-#endif
-   for (aa = adapter_addresses; aa != NULL; aa = aa->Next)
+   return true;
+#elif defined(HAVE_LIBNX) || defined(_3DS) || defined(GEKKO)
+   uint32_t addr = 0;
+   if (!(list->entries = (struct net_ifinfo_entry*)calloc(2, sizeof(*list->entries))))
    {
-      char name[PATH_MAX_LENGTH];
-      memset(name, 0, sizeof(name));
+      list->size = 0;
+      return false;
+   }
 
-      WideCharToMultiByte(CP_ACP, 0, aa->FriendlyName, wcslen(aa->FriendlyName),
-            name, PATH_MAX_LENGTH, NULL, NULL);
+   strlcpy(list->entries[0].name, "lo", sizeof(list->entries[0].name));
+   strlcpy(list->entries[0].host, "127.0.0.1", sizeof(list->entries[0].host));
+   list->size = 1;
 
-      for (ua = aa->FirstUnicastAddress; ua != NULL; ua = ua->Next)
-      {
-         char host[PATH_MAX_LENGTH];
-         struct net_ifinfo_entry *ptr = (struct net_ifinfo_entry*)
-            realloc(list->entries, (k+1) * sizeof(struct net_ifinfo_entry));
+#if defined(HAVE_LIBNX)
+   {
+      Result rc = nifmGetCurrentIpAddress(&addr);
+
+      if (!R_SUCCEEDED(rc))
+         return true;
+   }
+#elif defined(_3DS)
+   addr = gethostid();
+#else
+   addr = net_gethostip();
+#endif
+   if (addr)
+   {
+      uint8_t *addr8 = (uint8_t*)&addr;
+      strlcpy(list->entries[1].name,
+#if defined(HAVE_LIBNX)
+         "switch"
+#elif defined(_3DS)
+         "wlan"
+#else
+         "gekko"
+#endif
+      , sizeof(list->entries[1].name));
+      snprintf(list->entries[1].host, sizeof(list->entries[1].host),
+         "%d.%d.%d.%d",
+         (int)addr8[0], (int)addr8[1], (int)addr8[2], (int)addr8[3]);
+      list->size++;
+   }
 
-         if (!ptr)
-            goto error;
+   return true;
+#else
+   struct ifaddrs *addr;
+   struct net_ifinfo_entry *entry;
+   size_t         interfaces = 0;
+   struct ifaddrs *addresses = NULL;
 
-         list->entries          = ptr;
+   list->entries             = NULL;
 
-         memset(host, 0, sizeof(host));
+   if (getifaddrs(&addresses) || !addresses)
+      goto failure;
 
-         getnameinfo(ua->Address.lpSockaddr, ua->Address.iSockaddrLength,
-               host, sizeof(host), NULL, NI_MAXSERV, NI_NUMERICHOST);
+   /* Count the number of valid interfaces first. */
+   addr                      = addresses;
 
-         list->entries[k].name  = strdup(name);
-         list->entries[k].host  = strdup(host);
-         list->size             = k + 1;
+   do
+   {
+      if (!addr->ifa_addr)
+         continue;
+#ifndef WIIU
+      if (!(addr->ifa_flags & IFF_UP))
+         continue;
+#endif
 
-         k++;
+      switch (addr->ifa_addr->sa_family)
+      {
+         case AF_INET:
+#ifdef HAVE_INET6
+         case AF_INET6:
+#endif
+            interfaces++;
+            break;
+         default:
+            break;
       }
-   }
-
-   free(adapter_addresses);
-#else
-   struct ifaddrs *ifa     = NULL;
-   struct ifaddrs *ifaddr  = NULL;
+   } while ((addr = addr->ifa_next));
 
-   memset(list, 0, sizeof(net_ifinfo_t));
+   if (!interfaces)
+      goto failure;
 
-   if (getifaddrs(&ifaddr) == -1)
-      goto error;
+   list->entries =
+      (struct net_ifinfo_entry*)calloc(interfaces, sizeof(*list->entries));
+   if (!list->entries)
+      goto failure;
+   list->size    = 0;
 
-   if (!list)
-      goto error;
+   /* Now create the entries. */
+   addr  = addresses;
+   entry = list->entries;
 
-   for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next)
+   do
    {
-      char host[NI_MAXHOST];
-      struct net_ifinfo_entry *ptr = NULL;
+      socklen_t addrlen;
 
-      if (!ifa->ifa_addr)
+      if (!addr->ifa_addr)
          continue;
-
-      if (ifa->ifa_addr->sa_family != AF_INET)
+#ifndef WIIU
+      if (!(addr->ifa_flags & IFF_UP))
          continue;
+#endif
 
-      if (getnameinfo(ifa->ifa_addr, sizeof(struct sockaddr_in),
-               host, NI_MAXHOST, NULL, 0, NI_NUMERICHOST) != 0)
-         goto error;
+      switch (addr->ifa_addr->sa_family)
+      {
+         case AF_INET:
+            addrlen = sizeof(struct sockaddr_in);
+            break;
+#ifdef HAVE_INET6
+         case AF_INET6:
+            addrlen = sizeof(struct sockaddr_in6);
+            break;
+#endif
+         default:
+            continue;
+      }
 
-      ptr = (struct net_ifinfo_entry*)
-         realloc(list->entries, (k+1) * sizeof(struct net_ifinfo_entry));
+      if (getnameinfo_retro(addr->ifa_addr, addrlen,
+            entry->host, sizeof(entry->host), NULL, 0, NI_NUMERICHOST))
+         continue;
 
-      if (!ptr)
-         goto error;
+      if (addr->ifa_name)
+         strlcpy(entry->name, addr->ifa_name, sizeof(entry->name));
 
-      list->entries          = ptr;
+      if (++list->size >= interfaces)
+         break;
 
-      list->entries[k].name  = strdup(ifa->ifa_name);
-      list->entries[k].host  = strdup(host);
-      list->size             = k + 1;
+      entry++;
+   } while ((addr = addr->ifa_next));
 
-      k++;
-   }
+   freeifaddrs(addresses);
 
-   freeifaddrs(ifaddr);
-#endif
    return true;
 
-error:
-#ifdef _WIN32
-   if (adapter_addresses)
-      free(adapter_addresses);
-#elif !defined(HAVE_LIBNX)
-   freeifaddrs(ifaddr);
-#endif
+failure:
+   freeifaddrs(addresses);
    net_ifinfo_free(list);
 
    return false;
+#endif
+}
+
+void net_ifinfo_free(net_ifinfo_t *list)
+{
+   free(list->entries);
+
+   list->entries = NULL;
+   list->size    = 0;
+}
+
+bool net_ifinfo_best(const char *dst, void *src, bool ipv6)
+{
+   bool ret = false;
+
+/* TODO/FIXME: Implement for other platforms, if necessary. */
+#if defined(_WIN32) && !defined(_XBOX)
+   if (!ipv6)
+   {
+      /* Courtesy of MiniUPnP: https://github.com/miniupnp/miniupnp */
+      DWORD index;
+#ifdef __WINRT__
+      struct sockaddr_in dst_addr = {0};
+#endif
+      ULONG dst_ip               = (ULONG)inet_addr(dst);
+
+      if (!src)
+         return false;
+      if (dst_ip == INADDR_NONE || dst_ip == INADDR_ANY)
+         return false;
+
+#ifdef __WINRT__
+      dst_addr.sin_family      = AF_INET;
+      dst_addr.sin_addr.s_addr = dst_ip;
+      if (GetBestInterfaceEx((struct sockaddr*)&dst_addr, &index) == NO_ERROR)
+#else
+      if (GetBestInterface(dst_ip, &index) == NO_ERROR)
+#endif
+      {
+         /* Microsoft docs recommend doing it this way. */
+         ULONG                 len       = 15 * 1024;
+         PIP_ADAPTER_ADDRESSES addresses =
+            (PIP_ADAPTER_ADDRESSES)calloc(1, len);
+
+         if (addresses)
+         {
+            ULONG flags  = GAA_FLAG_SKIP_ANYCAST | GAA_FLAG_SKIP_MULTICAST |
+               GAA_FLAG_SKIP_DNS_SERVER | GAA_FLAG_SKIP_FRIENDLY_NAME;
+            ULONG result = GetAdaptersAddresses(AF_INET, flags, NULL,
+               addresses, &len);
+
+            if (result == ERROR_BUFFER_OVERFLOW)
+            {
+               PIP_ADAPTER_ADDRESSES new_addresses =
+                  (PIP_ADAPTER_ADDRESSES)realloc(addresses, len);
+
+               if (new_addresses)
+               {
+                  memset(new_addresses, 0, len);
+
+                  addresses = new_addresses;
+                  result    = GetAdaptersAddresses(AF_INET, flags, NULL,
+                     addresses, &len);
+               }
+            }
+
+            if (result == NO_ERROR)
+            {
+               PIP_ADAPTER_ADDRESSES addr = addresses;
+
+               do
+               {
+                  if (addr->IfIndex == index)
+                  {
+                     if (addr->FirstUnicastAddress)
+                     {
+                        struct sockaddr_in *addr_unicast =
+                           (struct sockaddr_in*)
+                              addr->FirstUnicastAddress->Address.lpSockaddr;
+
+                        memcpy(src, &addr_unicast->sin_addr,
+                           sizeof(addr_unicast->sin_addr));
+
+                        ret = true;
+                     }
+
+                     break;
+                  }
+               } while ((addr = addr->Next));
+            }
+
+            free(addresses);
+         }
+      }
+   }
+#endif
+
+   return ret;
 }
diff --git a/src/libretro/libretro-common/net/net_socket.c b/src/libretro/libretro-common/net/net_socket.c
index 7373bc0c9f..039a0b670e 100644
--- a/src/libretro/libretro-common/net/net_socket.c
+++ b/src/libretro/libretro-common/net/net_socket.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2022 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (net_socket.c).
@@ -20,25 +20,34 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-
+#include <stdlib.h>
 #include <stdio.h>
+#include <string.h>
 
 #ifdef _MSC_VER
 #include <compat/msvc.h>
 #endif
 
-#include <net/net_compat.h>
+#include <features/features_cpu.h>
+
 #include <net/net_socket.h>
 
-int socket_init(void **address, uint16_t port, const char *server, enum socket_type type)
+int socket_init(void **address, uint16_t port, const char *server,
+      enum socket_type type, int family)
 {
-   char port_buf[16];
-   struct addrinfo hints = {0};
+   char port_buf[6];
+   struct addrinfo hints      = {0};
    struct addrinfo **addrinfo = (struct addrinfo**)address;
-   struct addrinfo *addr = NULL;
+   struct addrinfo *addr      = NULL;
 
-   if (!network_init())
-      goto error;
+   if (!family)
+#if defined(HAVE_SOCKET_LEGACY) || defined(WIIU)
+      family = AF_INET;
+#else
+      family = AF_UNSPEC;
+#endif
+
+   hints.ai_family = family;
 
    switch (type)
    {
@@ -48,101 +57,162 @@ int socket_init(void **address, uint16_t port, const char *server, enum socket_t
       case SOCKET_TYPE_STREAM:
          hints.ai_socktype = SOCK_STREAM;
          break;
-      case SOCKET_TYPE_SEQPACKET:
-         /* TODO/FIXME - implement? */
-         break;
+      default:
+         return -1;
    }
 
    if (!server)
       hints.ai_flags = AI_PASSIVE;
 
-   port_buf[0] = '\0';
+   if (!network_init())
+      return -1;
 
    snprintf(port_buf, sizeof(port_buf), "%hu", (unsigned short)port);
+   hints.ai_flags |= AI_NUMERICSERV;
 
-   if (getaddrinfo_retro(server, port_buf, &hints, addrinfo) != 0)
-      goto error;
-
-   addr = (struct addrinfo*)*addrinfo;
+   if (getaddrinfo_retro(server, port_buf, &hints, addrinfo))
+      return -1;
 
+   addr = *addrinfo;
    if (!addr)
-      goto error;
+      return -1;
 
    return socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
-
-error:
-   return -1;
 }
 
-int socket_next(void **addrinfo)
+int socket_next(void **address)
 {
-   struct addrinfo *addr = (struct addrinfo*)*addrinfo;
+   struct addrinfo **addrinfo = (struct addrinfo**)address;
+   struct addrinfo *addr      = *addrinfo;
+
    if ((*addrinfo = addr = addr->ai_next))
       return socket(addr->ai_family, addr->ai_socktype, addr->ai_protocol);
-   else
-      return -1;
+
+   return -1;
 }
 
 ssize_t socket_receive_all_nonblocking(int fd, bool *error,
       void *data_, size_t size)
 {
-   const uint8_t *data = (const uint8_t*)data_;
-   ssize_t         ret = recv(fd, (char*)data, size, 0);
+   ssize_t ret = recv(fd, (char*)data_, size, 0);
 
    if (ret > 0)
       return ret;
 
-   if (ret == 0)
-   {
-      /* Socket closed */
-      *error = true;
-      return -1;
-   }
-
-   if (isagain((int)ret))
+   if (ret < 0 && isagain((int)ret))
       return 0;
 
    *error = true;
    return -1;
 }
 
-int socket_receive_all_blocking(int fd, void *data_, size_t size)
+bool socket_receive_all_blocking(int fd, void *data_, size_t size)
 {
    const uint8_t *data = (const uint8_t*)data_;
 
    while (size)
    {
       ssize_t ret = recv(fd, (char*)data, size, 0);
-      if (ret <= 0)
+
+      if (!ret)
          return false;
 
-      data += ret;
-      size -= ret;
+      if (ret < 0)
+      {
+         if (!isagain((int)ret))
+            return false;
+      }
+      else
+      {
+         data += ret;
+         size -= ret;
+      }
    }
 
    return true;
 }
 
-bool socket_nonblock(int fd)
+bool socket_receive_all_blocking_with_timeout(int fd,
+      void *data_, size_t size,
+      int timeout)
 {
-#if defined(__CELLOS_LV2__) || defined(VITA) || defined(WIIU)
-   int i = 1;
-   setsockopt(fd, SOL_SOCKET, SO_NBIO, &i, sizeof(int));
+   const uint8_t *data    = (const uint8_t*)data_;
+   retro_time_t  deadline = cpu_features_get_time_usec();
+
+   if (timeout > 0)
+      deadline += (retro_time_t)timeout * 1000;
+   else
+      deadline += 5000000;
+
+   while (size)
+   {
+      ssize_t ret = recv(fd, (char*)data, size, 0);
+
+      if (!ret)
+         return false;
+
+      if (ret < 0)
+      {
+         int _timeout;
+         bool ready = true;
+
+         if (!isagain((int)ret))
+            return false;
+
+         _timeout = (int)((deadline - cpu_features_get_time_usec()) / 1000);
+         if (_timeout <= 0)
+            return false;
+
+         if (!socket_wait(fd, &ready, NULL, _timeout) || !ready)
+            return false;
+      }
+      else
+      {
+         data += ret;
+         size -= ret;
+      }
+   }
+
    return true;
-#elif defined(_WIN32)
-   u_long mode = 1;
-   return ioctlsocket(fd, FIONBIO, &mode) == 0;
+}
+
+bool socket_set_block(int fd, bool block)
+{
+#if defined(_WIN32)
+   u_long i = !block;
+
+   return !ioctlsocket(fd, FIONBIO, &i);
+#elif defined(__PS3__) || defined(VITA) || defined(WIIU)
+   int i = !block;
+
+   return !setsockopt(fd, SOL_SOCKET, SO_NBIO, &i, sizeof(i));
+#elif defined(GEKKO)
+   u32 i = !block;
+
+   return !net_ioctl(fd, FIONBIO, &i);
 #else
-   return fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | O_NONBLOCK) == 0;
+   int flags = fcntl(fd, F_GETFL);
+
+   if (block)
+      flags &= ~O_NONBLOCK;
+   else
+      flags |= O_NONBLOCK;
+
+   return !fcntl(fd, F_SETFL, flags);
 #endif
 }
 
+bool socket_nonblock(int fd)
+{
+   return socket_set_block(fd, false);
+}
+
 int socket_close(int fd)
 {
 #if defined(_WIN32) && !defined(_XBOX360)
    /* WinSock has headers from the stone age. */
    return closesocket(fd);
-#elif defined(__CELLOS_LV2__) || defined(WIIU)
+#elif defined(__PS3__) || defined(WIIU)
    return socketclose(fd);
 #elif defined(VITA)
    return sceNetSocketClose(fd);
@@ -151,49 +221,423 @@ int socket_close(int fd)
 #endif
 }
 
-int socket_select(int nfds, fd_set *readfs, fd_set *writefds,
+int socket_select(int nfds, fd_set *readfds, fd_set *writefds,
       fd_set *errorfds, struct timeval *timeout)
 {
-#if defined(__CELLOS_LV2__)
-   return socketselect(nfds, readfs, writefds, errorfds, timeout);
+#if defined(__PS3__)
+   return socketselect(nfds, readfds, writefds, errorfds, timeout);
 #elif defined(VITA)
-   extern int retro_epoll_fd;
-   SceNetEpollEvent ev = {0};
+   int i, j;
+   fd_set rfds, wfds, efds;
+   int epoll_fd;
+   SceNetEpollEvent *events     = NULL;
+   int              event_count = 0;
+   int              timeout_us  = -1;
+   int              ret         = -1;
+
+   if (nfds < 0 || nfds > 1024)
+      return SCE_NET_ERROR_EINVAL;
+   if (timeout && (timeout->tv_sec < 0 || timeout->tv_usec < 0))
+      return SCE_NET_ERROR_EINVAL;
+
+   epoll_fd = sceNetEpollCreate("socket_select", 0);
+   if (epoll_fd < 0)
+      return SCE_NET_ERROR_ENOMEM;
+
+   FD_ZERO(&rfds);
+   FD_ZERO(&wfds);
+   FD_ZERO(&efds);
+
+   for (i = 0; i < nfds; i++)
+   {
+      if (readfds && FD_ISSET(i, readfds))
+         event_count++;
+      else if (writefds && FD_ISSET(i, writefds))
+         event_count++;
+      else if (errorfds && FD_ISSET(i, errorfds))
+         event_count++;
+   }
 
-   ev.events = SCE_NET_EPOLLIN | SCE_NET_EPOLLHUP;
-   ev.data.fd = nfds;
+#define ALLOC_EVENTS(count) \
+   events = (SceNetEpollEvent*)calloc((count), sizeof(*events)); \
+   if (!events) \
+   { \
+      ret = SCE_NET_ERROR_ENOMEM; \
+      goto done; \
+   }
 
-   if((sceNetEpollControl(retro_epoll_fd, SCE_NET_EPOLL_CTL_ADD, nfds, &ev)))
+   if (event_count)
    {
-      int ret = sceNetEpollWait(retro_epoll_fd, &ev, 1, 0);
-      sceNetEpollControl(retro_epoll_fd, SCE_NET_EPOLL_CTL_DEL, nfds, NULL);
-      return ret;
+      ALLOC_EVENTS(event_count)
+
+      for (i = 0, j = 0; i < nfds && j < event_count; i++)
+      {
+         SceNetEpollEvent *event = &events[j];
+
+         if (readfds && FD_ISSET(i, readfds))
+            event->events |= SCE_NET_EPOLLIN;
+         if (writefds && FD_ISSET(i, writefds))
+            event->events |= SCE_NET_EPOLLOUT;
+
+         if (event->events || (errorfds && FD_ISSET(i, errorfds)))
+         {
+            event->data.fd = i;
+
+            ret = sceNetEpollControl(epoll_fd, SCE_NET_EPOLL_CTL_ADD,
+               i, event);
+            if (ret < 0)
+            {
+               switch (ret)
+               {
+                  case SCE_NET_ERROR_EBADF:
+                  case SCE_NET_ERROR_ENOMEM:
+                     break;
+                  default:
+                     ret = SCE_NET_ERROR_EBADF;
+                     break;
+               }
+               goto done;
+            }
+
+            j++;
+         }
+      }
+
+      memset(events, 0, event_count * sizeof(*events));
+
+      /* Keep a copy of the original sets for lookup later. */
+      if (readfds)
+         memcpy(&rfds, readfds, sizeof(rfds));
+      if (writefds)
+         memcpy(&wfds, writefds, sizeof(wfds));
+      if (errorfds)
+         memcpy(&efds, errorfds, sizeof(efds));
+   }
+   else
+   {
+      /* Necessary to work with epoll wait. */
+      event_count = 1;
+      ALLOC_EVENTS(1)
    }
-   return 0;
+
+#undef ALLOC_EVENTS
+
+   if (readfds)
+      FD_ZERO(readfds);
+   if (writefds)
+      FD_ZERO(writefds);
+   if (errorfds)
+      FD_ZERO(errorfds);
+
+   /* Vita's epoll takes a microsecond timeout parameter. */
+   if (timeout)
+      timeout_us = (int)(timeout->tv_usec + (timeout->tv_sec * 1000000));
+
+   ret = sceNetEpollWait(epoll_fd, events, event_count, timeout_us);
+   if (ret <= 0)
+      goto done;
+
+#define EPOLL_FD_SET(op, in_set, out_set) \
+   if ((event->events & (op)) && FD_ISSET(event->data.fd, (in_set))) \
+   { \
+      FD_SET(event->data.fd, (out_set)); \
+      j++; \
+   }
+
+   for (i = 0, j = 0; i < ret; i++)
+   {
+      SceNetEpollEvent *event = &events[i];
+
+      /* Sanity check */
+      if (event->data.fd < 0 || event->data.fd >= nfds)
+         continue;
+
+      EPOLL_FD_SET(SCE_NET_EPOLLIN,  &rfds, readfds)
+      EPOLL_FD_SET(SCE_NET_EPOLLOUT, &wfds, writefds)
+      EPOLL_FD_SET(SCE_NET_EPOLLERR, &efds, errorfds)
+   }
+
+   ret = j;
+
+#undef EPOLL_FD_SET
+
+done:
+   free(events);
+   sceNetEpollDestroy(epoll_fd);
+
+   return ret;
 #else
-   return select(nfds, readfs, writefds, errorfds, timeout);
+   return select(nfds, readfds, writefds, errorfds, timeout);
 #endif
 }
 
-int socket_send_all_blocking(int fd, const void *data_, size_t size,
+#ifdef NETWORK_HAVE_POLL
+int socket_poll(struct pollfd *fds, unsigned nfds, int timeout)
+{
+#if defined(_WIN32)
+   return WSAPoll(fds, nfds, timeout);
+#elif defined(VITA)
+   int i, j;
+   int epoll_fd;
+   SceNetEpollEvent *events     = NULL;
+   int              event_count = (int)nfds;
+   int              ret         = -1;
+
+   if (event_count < 0)
+      return SCE_NET_ERROR_EINVAL;
+
+   epoll_fd = sceNetEpollCreate("socket_poll", 0);
+   if (epoll_fd < 0)
+      return SCE_NET_ERROR_ENOMEM;
+
+#define ALLOC_EVENTS(count) \
+   events = (SceNetEpollEvent*)calloc((count), sizeof(*events)); \
+   if (!events) \
+   { \
+      ret = SCE_NET_ERROR_ENOMEM; \
+      goto done; \
+   }
+
+   if (event_count)
+   {
+      ALLOC_EVENTS(event_count)
+
+      for (i = 0; i < event_count; i++)
+      {
+         struct pollfd    *fd    = &fds[i];
+         SceNetEpollEvent *event = &events[i];
+
+         fd->revents = 0;
+
+         if (fd->fd < 0)
+            continue;
+
+         event->events  = fd->events;
+         event->data.fd = fd->fd;
+
+         ret = sceNetEpollControl(epoll_fd, SCE_NET_EPOLL_CTL_ADD,
+            fd->fd, event);
+         if (ret < 0)
+            goto done;
+      }
+
+      memset(events, 0, event_count * sizeof(*events));
+   }
+   else
+   {
+      /* Necessary to work with epoll wait. */
+      event_count = 1;
+      ALLOC_EVENTS(1)
+   }
+
+#undef ALLOC_EVENTS
+
+   /* Vita's epoll takes a microsecond timeout parameter. */
+   if (timeout > 0)
+      timeout *= 1000;
+
+   ret = sceNetEpollWait(epoll_fd, events, event_count, timeout);
+   if (ret <= 0)
+      goto done;
+
+   for (i = 0, j = 0; i < ret; i++)
+   {
+      unsigned k;
+      SceNetEpollEvent *event = &events[i];
+
+      /* Sanity check */
+      if (event->data.fd < 0)
+         continue;
+
+      for (k = 0; k < nfds; k++)
+      {
+         struct pollfd *fd = &fds[k];
+
+         if (fd->fd == event->data.fd)
+         {
+            fd->revents = event->events;
+            j++;
+            break;
+         }
+      }
+   }
+
+   ret = j;
+
+done:
+   free(events);
+   sceNetEpollDestroy(epoll_fd);
+
+   return ret;
+#elif defined(_3DS)
+   int i;
+   int timeout_quotient;
+   int timeout_remainder;
+   int ret = -1;
+
+#define TIMEOUT_DIVISOR 100
+   if (timeout <= TIMEOUT_DIVISOR)
+      return poll(fds, nfds, timeout);
+
+   timeout_quotient = timeout / TIMEOUT_DIVISOR;
+   for (i = 0; i < timeout_quotient; i++)
+   {
+      ret = poll(fds, nfds, TIMEOUT_DIVISOR);
+
+      /* Success or error. */
+      if (ret)
+         return ret;
+   }
+
+   timeout_remainder = timeout % TIMEOUT_DIVISOR;
+   if (timeout_remainder)
+      ret = poll(fds, nfds, timeout_remainder);
+
+   return ret;
+#undef TIMEOUT_DIVISOR
+
+#elif defined(GEKKO)
+   return net_poll(fds, nfds, timeout);
+#else
+   return poll(fds, nfds, timeout);
+#endif
+}
+#endif
+
+bool socket_wait(int fd, bool *rd, bool *wr, int timeout)
+{
+#ifdef NETWORK_HAVE_POLL
+   struct pollfd fds = {0};
+
+   NET_POLL_FD(fd, &fds);
+
+   if (rd && *rd)
+   {
+      NET_POLL_EVENT(POLLIN, &fds);
+      *rd = false;
+   }
+   if (wr && *wr)
+   {
+      NET_POLL_EVENT(POLLOUT, &fds);
+      *wr = false;
+   }
+
+   if (socket_poll(&fds, 1, timeout) < 0)
+      return false;
+
+   if (rd && NET_POLL_HAS_EVENT(POLLIN, &fds))
+      *rd = true;
+   if (wr && NET_POLL_HAS_EVENT(POLLOUT, &fds))
+      *wr = true;
+
+   return !NET_POLL_HAS_EVENT((POLLERR | POLLNVAL), &fds);
+#else
+   fd_set rfd, wfd, efd;
+   struct timeval tv, *ptv = NULL;
+
+   FD_ZERO(&rfd);
+   FD_ZERO(&wfd);
+   FD_ZERO(&efd);
+
+   if (rd && *rd)
+   {
+      FD_SET(fd, &rfd);
+      *rd = false;
+   }
+   if (wr && *wr)
+   {
+      FD_SET(fd, &wfd);
+      *wr = false;
+   }
+   FD_SET(fd, &efd);
+
+   if (timeout >= 0)
+   {
+      tv.tv_sec  = (unsigned)timeout / 1000;
+      tv.tv_usec = ((unsigned)timeout % 1000) * 1000;
+      ptv = &tv;
+   }
+
+   if (socket_select(fd + 1, &rfd, &wfd, &efd, ptv) < 0)
+      return false;
+
+   if (rd && FD_ISSET(fd, &rfd))
+      *rd = true;
+   if (wr && FD_ISSET(fd, &wfd))
+      *wr = true;
+
+   return !FD_ISSET(fd, &efd);
+#endif
+}
+
+bool socket_send_all_blocking(int fd, const void *data_, size_t size,
       bool no_signal)
 {
    const uint8_t *data = (const uint8_t*)data_;
+   int           flags = no_signal ? MSG_NOSIGNAL : 0;
 
    while (size)
    {
-      ssize_t ret = send(fd, (const char*)data, size,
-            no_signal ? MSG_NOSIGNAL : 0);
-      if (ret <= 0)
-      {
-         if (isagain((int)ret))
-            continue;
+      ssize_t ret = send(fd, (const char*)data, size, flags);
 
-         return false;
+      if (!ret)
+         continue;
+
+      if (ret < 0)
+      {
+         if (!isagain((int)ret))
+            return false;
+      }
+      else
+      {
+         data += ret;
+         size -= ret;
       }
+   }
+
+   return true;
+}
+
+bool socket_send_all_blocking_with_timeout(int fd,
+      const void *data_, size_t size,
+      int timeout, bool no_signal)
+{
+   const uint8_t *data    = (const uint8_t*)data_;
+   int           flags    = no_signal ? MSG_NOSIGNAL : 0;
+   retro_time_t  deadline = cpu_features_get_time_usec();
 
-      data += ret;
-      size -= ret;
+   if (timeout > 0)
+      deadline += (retro_time_t)timeout * 1000;
+   else
+      deadline += 5000000;
+
+   while (size)
+   {
+      ssize_t ret = send(fd, (const char*)data, size, flags);
+
+      if (!ret)
+         continue;
+
+      if (ret < 0)
+      {
+         int _timeout;
+         bool ready = true;
+
+         if (!isagain((int)ret))
+            return false;
+
+         _timeout = (int)((deadline - cpu_features_get_time_usec()) / 1000);
+         if (_timeout <= 0)
+            return false;
+
+         if (!socket_wait(fd, NULL, &ready, _timeout) || !ready)
+            return false;
+      }
+      else
+      {
+         data += ret;
+         size -= ret;
+      }
    }
 
    return true;
@@ -203,12 +647,15 @@ ssize_t socket_send_all_nonblocking(int fd, const void *data_, size_t size,
       bool no_signal)
 {
    const uint8_t *data = (const uint8_t*)data_;
-   ssize_t sent = 0;
+   int           flags = no_signal ? MSG_NOSIGNAL : 0;
 
    while (size)
    {
-      ssize_t ret = send(fd, (const char*)data, size,
-            no_signal ? MSG_NOSIGNAL : 0);
+      ssize_t ret = send(fd, (const char*)data, size, flags);
+
+      if (!ret)
+         break;
+
       if (ret < 0)
       {
          if (isagain((int)ret))
@@ -216,61 +663,125 @@ ssize_t socket_send_all_nonblocking(int fd, const void *data_, size_t size,
 
          return -1;
       }
-      else if (ret == 0)
-         break;
-
-      data += ret;
-      size -= ret;
-      sent += ret;
+      else
+      {
+         data += ret;
+         size -= ret;
+      }
    }
 
-   return sent;
+   return (ssize_t)((size_t)data - (size_t)data_);
 }
 
 bool socket_bind(int fd, void *data)
 {
-   int yes               = 1;
-   struct addrinfo *res  = (struct addrinfo*)data;
-   setsockopt(fd, SOL_SOCKET,
-         SO_REUSEADDR, (const char*)&yes, sizeof(int));
-   if (bind(fd, res->ai_addr, res->ai_addrlen) < 0)
-      return false;
-   return true;
+   struct addrinfo *addr = (struct addrinfo*)data;
+
+   {
+      int on = 1;
+
+      setsockopt(fd, SOL_SOCKET, SO_REUSEADDR,
+         (char*)&on, sizeof(on));
+   }
+
+   return !bind(fd, addr->ai_addr, addr->ai_addrlen);
 }
 
-int socket_connect(int fd, void *data, bool timeout_enable)
+int socket_connect(int fd, void *data)
 {
    struct addrinfo *addr = (struct addrinfo*)data;
 
-#if !defined(_WIN32) && !defined(VITA) && !defined(WIIU) && !defined(_3DS)
-   if (timeout_enable)
+#ifdef WIIU
    {
-      struct timeval timeout;
-      timeout.tv_sec  = 4;
-      timeout.tv_usec = 0;
+      int op = 1;
+
+      setsockopt(fd, SOL_SOCKET, SO_WINSCALE, &op, sizeof(op));
+
+      if (addr->ai_socktype == SOCK_STREAM)
+      {
+         int recvsz = WIIU_RCVBUF;
+         int sendsz = WIIU_SNDBUF;
 
-      setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, (char*)&timeout, sizeof timeout);
+         setsockopt(fd, SOL_SOCKET, SO_TCPSACK, &op, sizeof(op));
+         setsockopt(fd, SOL_SOCKET, SO_RUSRBUF, &op, sizeof(op));
+         setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &recvsz, sizeof(recvsz));
+         setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &sendsz, sizeof(sendsz));
+      }
    }
 #endif
 
    return connect(fd, addr->ai_addr, addr->ai_addrlen);
 }
 
-static int domain_get(enum socket_domain type)
+bool socket_connect_with_timeout(int fd, void *data, int timeout)
 {
-   switch (type)
+   int res;
+   struct addrinfo *addr = (struct addrinfo*)data;
+
+   if (!socket_nonblock(fd))
+      return false;
+
+#ifdef WIIU
    {
-      case SOCKET_DOMAIN_INET:
-#ifdef VITA
-         return SCE_NET_AF_INET;
-#else
-         return AF_INET;
+      int op = 1;
+
+      setsockopt(fd, SOL_SOCKET, SO_WINSCALE, &op, sizeof(op));
+
+      if (addr->ai_socktype == SOCK_STREAM)
+      {
+         int recvsz = WIIU_RCVBUF;
+         int sendsz = WIIU_SNDBUF;
+
+         setsockopt(fd, SOL_SOCKET, SO_TCPSACK, &op, sizeof(op));
+         setsockopt(fd, SOL_SOCKET, SO_RUSRBUF, &op, sizeof(op));
+         setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &recvsz, sizeof(recvsz));
+         setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &sendsz, sizeof(sendsz));
+      }
+   }
 #endif
-      default:
-         break;
+
+   res = connect(fd, addr->ai_addr, addr->ai_addrlen);
+   if (res)
+   {
+      bool ready = true;
+
+      if (!isinprogress(res) && !isagain(res))
+         return false;
+
+      if (timeout <= 0)
+         timeout = 5000;
+
+      if (!socket_wait(fd, NULL, &ready, timeout) || !ready)
+         return false;
+   }
+
+#if defined(GEKKO)
+   /* libogc does not have getsockopt implemented */
+   res = connect(fd, addr->ai_addr, addr->ai_addrlen);
+   if (res < 0 && -res != EISCONN)
+      return false;
+#elif defined(_3DS)
+   /* libctru getsockopt does not return expected value */
+   if ((connect(fd, addr->ai_addr, addr->ai_addrlen) < 0) && errno != EISCONN)
+      return false;
+#elif defined(WIIU)
+   /* On WiiU, getsockopt() returns -1 and sets lastsocketerr() (Wii's
+    * equivalent to errno) to 16. */
+   if ((connect(fd, addr->ai_addr, addr->ai_addrlen) == -1)
+         && socketlasterr() != SO_EISCONN)
+      return false;
+#else
+   {
+      int       error = -1;
+      socklen_t errsz = sizeof(error);
+
+      getsockopt(fd, SOL_SOCKET, SO_ERROR, (char*)&error, &errsz);
+      if (error)
+         return false;
    }
+#endif
 
-   return 0;
+   return true;
 }
 
 int socket_create(
@@ -279,39 +790,19 @@ int socket_create(
       enum socket_type     socket_type,
       enum socket_protocol protocol_type)
 {
+   int domain   = 0;
    int type     = 0;
    int protocol = 0;
-   int domain   = domain_get(domain_type);
-#ifdef VITA
-
-   switch (socket_type)
-   {
-      case SOCKET_TYPE_DATAGRAM:
-         type = SCE_NET_SOCK_DGRAM;
-         break;
-      case SOCKET_TYPE_STREAM:
-         type = SCE_NET_SOCK_STREAM;
-         break;
-      case SOCKET_TYPE_SEQPACKET:
-         /* TODO/FIXME - implement */
-         break;
-   }
 
-   switch (protocol_type)
+   switch (domain_type)
    {
-      case SOCKET_PROTOCOL_NONE:
-         protocol = 0;
-         break;
-      case SOCKET_PROTOCOL_TCP:
-         protocol = SCE_NET_IPPROTO_TCP;
+      case SOCKET_DOMAIN_INET:
+         domain = AF_INET;
          break;
-      case SOCKET_PROTOCOL_UDP:
-         protocol = SCE_NET_IPPROTO_UDP;
+      default:
          break;
    }
 
-   return sceNetSocket(name, domain, type, protocol);
-#else
    switch (socket_type)
    {
       case SOCKET_TYPE_DATAGRAM:
@@ -321,23 +812,27 @@ int socket_create(
          type = SOCK_STREAM;
          break;
       case SOCKET_TYPE_SEQPACKET:
+      default:
          /* TODO/FIXME - implement */
          break;
    }
 
    switch (protocol_type)
    {
-      case SOCKET_PROTOCOL_NONE:
-         protocol = 0;
-         break;
       case SOCKET_PROTOCOL_TCP:
          protocol = IPPROTO_TCP;
          break;
       case SOCKET_PROTOCOL_UDP:
          protocol = IPPROTO_UDP;
          break;
+      case SOCKET_PROTOCOL_NONE:
+      default:
+         break;
    }
 
+#ifdef VITA
+   return sceNetSocket(name, domain, type, protocol);
+#else
    return socket(domain, type, protocol);
 #endif
 }
@@ -346,16 +841,18 @@ void socket_set_target(void *data, socket_target_t *in_addr)
 {
    struct sockaddr_in *out_target = (struct sockaddr_in*)data;
 
-   out_target->sin_port   = inet_htons(in_addr->port);
-   out_target->sin_family = domain_get(in_addr->domain);
-#ifdef VITA
-   out_target->sin_addr   = inet_aton(in_addr->server);
-#else
 #ifdef GEKKO
-   out_target->sin_len    = 8;
-#endif
-
-   inet_ptrton(AF_INET, in_addr->server, &out_target->sin_addr);
-
+   out_target->sin_len          = 8;
 #endif
+   switch (in_addr->domain)
+   {
+      case SOCKET_DOMAIN_INET:
+         out_target->sin_family = AF_INET;
+         break;
+      default:
+         out_target->sin_family = 0;
+         break;
+   }
+   out_target->sin_port         = htons(in_addr->port);
+   inet_pton(AF_INET, in_addr->server, &out_target->sin_addr);
 }
diff --git a/src/libretro/libretro-common/playlists/label_sanitization.c b/src/libretro/libretro-common/playlists/label_sanitization.c
index 827ac098ff..50a95ee513 100644
--- a/src/libretro/libretro-common/playlists/label_sanitization.c
+++ b/src/libretro/libretro-common/playlists/label_sanitization.c
@@ -1,7 +1,7 @@
-/* Copyright  (C) 2010-2019 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
- * The following license statement only applies to this file (file_path.h).
+ * The following license statement only applies to this file (label_sanitization.c).
  * ---------------------------------------------------------------------------------------
  *
  * Permission is hereby granted, free of charge,
@@ -26,20 +26,19 @@
 #include <string/stdstring.h>
 #include <string.h>
 
-const size_t disc_strings_length = 3;
+#define DISC_STRINGS_LENGTH   3
+#define REGION_STRINGS_LENGTH 20
 
-const char *disc_strings[3] = {
+const char *disc_strings[DISC_STRINGS_LENGTH] = {
    "(CD",
    "(Disc",
    "(Disk"
 };
 
-const size_t region_strings_length = 20;
-
 /*
  * We'll use the standard No-Intro regions for now.
  */
-const char *region_strings[20] = {
+const char *region_strings[REGION_STRINGS_LENGTH] = {
    "(Australia)", /* Don’t use with Europe */
    "(Brazil)",
    "(Canada)",    /* Don’t use with USA */
@@ -62,9 +61,11 @@ const char *region_strings[20] = {
    "(USA, Europe)"
 };
 
-/*
- * Does not work with nested blocks.
- */
+/**
+ * label_sanitize:
+ *
+ * NOTE: Does not work with nested blocks.
+ **/
 void label_sanitize(char *label, bool (*left)(char*), bool (*right)(char*))
 {
    bool copy = true;
@@ -78,16 +79,25 @@ void label_sanitize(char *label, bool (*left)(char*), bool (*right)(char*))
       {
          /* check for the start of the range */
          if ((*left)(&label[lindex]))
-            copy = false;
-
-         if (copy)
-            new_label[rindex++] = label[lindex];
+            copy                = false;
+         else
+         {
+            const bool whitespace = label[lindex] == ' ' && (rindex == 0 || new_label[rindex - 1] == ' ');
+
+            /* Simplify consecutive whitespaces */
+            if (!whitespace)
+               new_label[rindex++] = label[lindex];
+         }
       }
       else if ((*right)(&label[lindex]))
          copy = true;
    }
 
-   new_label[rindex] = '\0';
+   /* Trim trailing whitespace */
+   if (rindex > 0 && new_label[rindex - 1] == ' ')
+      new_label[rindex - 1] = '\0';
+   else
+      new_label[rindex] = '\0';
 
    strlcpy(label, new_label, PATH_MAX_LENGTH);
 }
@@ -129,16 +139,16 @@ static bool left_exclusion(char *left,
    char exclusion_string[32];
    char comparison_string[32];
 
-   strlcpy(exclusion_string, left, 32);
+   strlcpy(exclusion_string, left, sizeof(exclusion_string));
    string_to_upper(exclusion_string);
 
    for (i = 0; i < (unsigned)strings_count; i++)
    {
-      strlcpy(comparison_string, strings[i], 32);
+      strlcpy(comparison_string, strings[i], sizeof(comparison_string));
       string_to_upper(comparison_string);
 
-      if (string_is_equal_fast(exclusion_string,
-               comparison_string, strlen(comparison_string)))
+      if (string_starts_with(exclusion_string,
+               comparison_string))
          return true;
    }
 
@@ -148,20 +158,20 @@ static bool left_exclusion(char *left,
 static bool left_parens_or_brackets_excluding_region(char *left)
 {
    return left_parens_or_brackets(left)
-      && !left_exclusion(left, region_strings, region_strings_length);
+      && !left_exclusion(left, region_strings, REGION_STRINGS_LENGTH);
 }
 
 static bool left_parens_or_brackets_excluding_disc(char *left)
 {
    return left_parens_or_brackets(left)
-      && !left_exclusion(left, disc_strings, disc_strings_length);
+      && !left_exclusion(left, disc_strings, DISC_STRINGS_LENGTH);
 }
 
 static bool left_parens_or_brackets_excluding_region_or_disc(char *left)
 {
    return left_parens_or_brackets(left)
-      && !left_exclusion(left, region_strings, region_strings_length)
-      && !left_exclusion(left, disc_strings, disc_strings_length);
+      && !left_exclusion(left, region_strings, REGION_STRINGS_LENGTH)
+      && !left_exclusion(left, disc_strings, DISC_STRINGS_LENGTH);
 }
 
 void label_remove_parens(char *label)
@@ -176,20 +186,24 @@ void label_remove_brackets(char *label)
 
 void label_remove_parens_and_brackets(char *label)
 {
-   label_sanitize(label, left_parens_or_brackets, right_parens_or_brackets);
+   label_sanitize(label, left_parens_or_brackets,
+         right_parens_or_brackets);
 }
 
 void label_keep_region(char *label)
 {
-   label_sanitize(label, left_parens_or_brackets_excluding_region, right_parens_or_brackets);
+   label_sanitize(label, left_parens_or_brackets_excluding_region,
+         right_parens_or_brackets);
 }
 
 void label_keep_disc(char *label)
 {
-   label_sanitize(label, left_parens_or_brackets_excluding_disc, right_parens_or_brackets);
+   label_sanitize(label, left_parens_or_brackets_excluding_disc,
+         right_parens_or_brackets);
 }
 
 void label_keep_region_and_disc(char *label)
 {
-   label_sanitize(label, left_parens_or_brackets_excluding_region_or_disc, right_parens_or_brackets);
+   label_sanitize(label, left_parens_or_brackets_excluding_region_or_disc,
+         right_parens_or_brackets);
 }
diff --git a/src/libretro/libretro-common/queues/fifo_queue.c b/src/libretro/libretro-common/queues/fifo_queue.c
index 0ddb89ab1e..05deb18785 100644
--- a/src/libretro/libretro-common/queues/fifo_queue.c
+++ b/src/libretro/libretro-common/queues/fifo_queue.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (fifo_queue.c).
@@ -23,27 +23,69 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include <retro_common_api.h>
+#include <retro_inline.h>
+#include <boolean.h>
+
 #include <queues/fifo_queue.h>
 
+static bool fifo_initialize_internal(fifo_buffer_t *buf, size_t size)
+{
+   uint8_t *buffer    = (uint8_t*)calloc(1, size + 1);
+
+   if (!buffer)
+      return false;
+
+   buf->buffer        = buffer;
+   buf->size          = size + 1;
+   buf->first         = 0;
+   buf->end           = 0;
+
+   return true;
+}
+
+bool fifo_initialize(fifo_buffer_t *buf, size_t size)
+{
+   return (buf && fifo_initialize_internal(buf, size));
+}
+
+void fifo_free(fifo_buffer_t *buffer)
+{
+   if (!buffer)
+      return;
+
+   free(buffer->buffer);
+   free(buffer);
+}
+
+bool fifo_deinitialize(fifo_buffer_t *buffer)
+{
+   if (!buffer)
+      return false;
+
+   if (buffer->buffer)
+      free(buffer->buffer);
+   buffer->buffer = NULL;
+   buffer->size   = 0;
+   buffer->first  = 0;
+   buffer->end    = 0;
+
+   return true;
+}
+
 fifo_buffer_t *fifo_new(size_t size)
 {
-   uint8_t    *buffer = NULL;
-   fifo_buffer_t *buf = (fifo_buffer_t*)calloc(1, sizeof(*buf));
+   fifo_buffer_t *buf = (fifo_buffer_t*)malloc(sizeof(*buf));
 
    if (!buf)
       return NULL;
 
-   buffer = (uint8_t*)calloc(1, size + 1);
-
-   if (!buffer)
+   if (!fifo_initialize_internal(buf, size))
    {
       free(buf);
       return NULL;
    }
 
-   buf->buffer = buffer;
-   buf->size   = size + 1;
-
    return buf;
 }
 
diff --git a/src/libretro/libretro-common/queues/message_queue.c b/src/libretro/libretro-common/queues/message_queue.c
index 2e036496ed..4e7dea061c 100644
--- a/src/libretro/libretro-common/queues/message_queue.c
+++ b/src/libretro/libretro-common/queues/message_queue.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (message_queue.c).
@@ -28,24 +28,24 @@
 #include <compat/strl.h>
 #include <compat/posix_string.h>
 
-struct queue_elem
+bool msg_queue_initialize(msg_queue_t *queue, size_t size)
 {
-   unsigned duration;
-   unsigned prio;
-   char *msg;
+   struct queue_elem **elems = NULL;
 
-   char *title;
-   enum message_queue_icon icon;
-   enum message_queue_category category;
-};
+   if (!queue)
+      return false;
 
-struct msg_queue
-{
-   struct queue_elem **elems;
-   size_t ptr;
-   size_t size;
-   char *tmp_msg;
-};
+   if (!(elems = (struct queue_elem**)
+            calloc(size + 1, sizeof(struct queue_elem*))))
+      return false;
+
+   queue->tmp_msg            = NULL;
+   queue->elems              = elems;
+   queue->ptr                = 1;
+   queue->size               = size + 1;
+
+   return true;
+}
 
 /**
  * msg_queue_new:
@@ -58,26 +58,15 @@ struct msg_queue
  **/
 msg_queue_t *msg_queue_new(size_t size)
 {
-   struct queue_elem **elems = NULL;
-   msg_queue_t *queue        = (msg_queue_t*)calloc(1, sizeof(*queue));
-
-   if (!queue)
-      return NULL;
-
-   queue->size = size + 1;
-
-   elems = (struct queue_elem**)calloc(queue->size,
-         sizeof(struct queue_elem*));
+   msg_queue_t *queue = (msg_queue_t*)malloc(sizeof(*queue));
 
-   if (!elems)
+   if (!msg_queue_initialize(queue, size))
    {
-      free(queue);
+      if (queue)
+         free(queue);
       return NULL;
    }
 
-   queue->elems = elems;
-   queue->ptr   = 1;
-
    return queue;
 }
 
@@ -89,14 +78,26 @@ msg_queue_t *msg_queue_new(size_t size)
  **/
 void msg_queue_free(msg_queue_t *queue)
 {
-   if (queue)
-   {
-      msg_queue_clear(queue);
-      free(queue->elems);
-   }
+   if (!queue)
+      return;
+   msg_queue_clear(queue);
+   free(queue->elems);
    free(queue);
 }
 
+bool msg_queue_deinitialize(msg_queue_t *queue)
+{
+   if (!queue)
+      return false;
+   msg_queue_clear(queue);
+   free(queue->elems);
+   queue->elems   = NULL;
+   queue->tmp_msg = NULL;
+   queue->ptr     = 0;
+   queue->size    = 0;
+   return true;
+}
+
 /**
  * msg_queue_push:
  * @queue             : pointer to queue object
@@ -119,14 +120,15 @@ void msg_queue_push(msg_queue_t *queue, const char *msg,
    if (!queue || queue->ptr >= queue->size)
       return;
 
-   new_elem                      = (struct queue_elem*)
-      calloc(1, sizeof(struct queue_elem));
-   if (!new_elem)
+   if (!(new_elem = (struct queue_elem*)malloc(sizeof(struct queue_elem))))
       return;
 
-   new_elem->prio                = prio;
    new_elem->duration            = duration;
-   new_elem->msg                 = msg ? strdup(msg) : NULL;
+   new_elem->prio                = prio;
+   new_elem->msg                 = msg   ? strdup(msg)   : NULL;
+   new_elem->title               = title ? strdup(title) : NULL;
+   new_elem->icon                = icon;
+   new_elem->category            = category;
 
    queue->elems[queue->ptr]      = new_elem;
 
@@ -165,11 +167,12 @@ void msg_queue_clear(msg_queue_t *queue)
       if (queue->elems[i])
       {
          free(queue->elems[i]->msg);
+         free(queue->elems[i]->title);
          free(queue->elems[i]);
          queue->elems[i] = NULL;
       }
    }
-   queue->ptr = 1;
+   queue->ptr     = 1;
    free(queue->tmp_msg);
    queue->tmp_msg = NULL;
 }
@@ -188,8 +191,6 @@ const char *msg_queue_pull(msg_queue_t *queue)
    struct queue_elem *front  = NULL, *last = NULL;
    size_t tmp_ptr = 1;
 
-   (void)tmp_ptr;
-
    /* Nothing in queue. */
    if (!queue || queue->ptr == 1)
       return NULL;
@@ -203,9 +204,9 @@ const char *msg_queue_pull(msg_queue_t *queue)
    queue->tmp_msg = front->msg;
    front->msg = NULL;
 
-   front = (struct queue_elem*)queue->elems[1];
    last  = (struct queue_elem*)queue->elems[--queue->ptr];
    queue->elems[1] = last;
+   free(front->title);
    free(front);
 
    for (;;)
@@ -243,3 +244,98 @@ const char *msg_queue_pull(msg_queue_t *queue)
 
    return queue->tmp_msg;
 }
+
+/**
+ * msg_queue_extract:
+ * @queue             : pointer to queue object
+ * @queue_entry       : pointer to external queue entry struct
+ *
+ * Removes highest priority message from queue, copying
+ * contents into queue_entry struct.
+ *
+ * Returns: false if no messages in queue, otherwise true
+ **/
+bool msg_queue_extract(msg_queue_t *queue, msg_queue_entry_t *queue_entry)
+{
+   struct queue_elem *front  = NULL, *last = NULL;
+   size_t tmp_ptr = 1;
+
+   /* Ensure arguments are valid and queue is not
+    * empty */
+   if (!queue || queue->ptr == 1 || !queue_entry)
+      return false;
+
+   front = (struct queue_elem*)queue->elems[1];
+   last  = (struct queue_elem*)queue->elems[--queue->ptr];
+   queue->elems[1] = last;
+
+   /* Copy element parameters */
+   queue_entry->duration = front->duration;
+   queue_entry->prio     = front->prio;
+   queue_entry->icon     = front->icon;
+   queue_entry->category = front->category;
+   queue_entry->msg[0]   = '\0';
+   queue_entry->title[0] = '\0';
+
+   if (front->msg)
+      strlcpy(queue_entry->msg, front->msg, sizeof(queue_entry->msg));
+
+   if (front->title)
+      strlcpy(queue_entry->title, front->title, sizeof(queue_entry->title));
+
+   /* Delete element */
+   free(front->msg);
+   free(front->title);
+   free(front);
+
+   for (;;)
+   {
+      struct queue_elem *parent = NULL;
+      struct queue_elem *child  = NULL;
+      size_t switch_index       = tmp_ptr;
+      bool left                 = (tmp_ptr * 2 <= queue->ptr)
+         && (queue->elems[tmp_ptr] < queue->elems[tmp_ptr * 2]);
+      bool right                = (tmp_ptr * 2 + 1 <= queue->ptr)
+         && (queue->elems[tmp_ptr] < queue->elems[tmp_ptr * 2 + 1]);
+
+      if (!left && !right)
+         break;
+
+      if (left && !right)
+         switch_index <<= 1;
+      else if (right && !left)
+         switch_index += switch_index + 1;
+      else
+      {
+         if (queue->elems[tmp_ptr * 2]
+               >= queue->elems[tmp_ptr * 2 + 1])
+            switch_index <<= 1;
+         else
+            switch_index += switch_index + 1;
+      }
+
+      parent = (struct queue_elem*)queue->elems[tmp_ptr];
+      child  = (struct queue_elem*)queue->elems[switch_index];
+      queue->elems[tmp_ptr]      = child;
+      queue->elems[switch_index] = parent;
+      tmp_ptr                    = switch_index;
+   }
+
+   return true;
+}
+
+/**
+ * msg_queue_size:
+ * @queue             : pointer to queue object
+ *
+ * Fetches number of messages in queue.
+ *
+ * Returns: Number of messages in queue.
+ **/
+size_t msg_queue_size(msg_queue_t *queue)
+{
+   if (!queue || queue->ptr <= 1)
+      return 0;
+
+   return queue->ptr - 1;
+}
diff --git a/src/libretro/libretro-common/queues/task_queue.c b/src/libretro/libretro-common/queues/task_queue.c
index 7e0f9e8d54..76670bb71a 100644
--- a/src/libretro/libretro-common/queues/task_queue.c
+++ b/src/libretro/libretro-common/queues/task_queue.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (task_queue.c).
@@ -26,13 +26,10 @@
 
 #include <queues/task_queue.h>
 
+#include <features/features_cpu.h>
+
 #ifdef HAVE_THREADS
 #include <rthreads/rthreads.h>
-#define SLOCK_LOCK(x) slock_lock(x)
-#define SLOCK_UNLOCK(x) slock_unlock(x)
-#else
-#define SLOCK_LOCK(x)
-#define SLOCK_UNLOCK(x)
 #endif
 
 typedef struct
@@ -55,14 +52,25 @@ struct retro_task_impl
    void (*deinit)(void);
 };
 
-static retro_task_queue_msg_t msg_push_bak;
-static task_queue_t tasks_running  = {NULL, NULL};
-static task_queue_t tasks_finished = {NULL, NULL};
+/* TODO/FIXME - static globals */
+static retro_task_queue_msg_t msg_push_bak  = NULL;
+static task_queue_t tasks_running           = {NULL, NULL};
+static task_queue_t tasks_finished          = {NULL, NULL};
 
 static struct retro_task_impl *impl_current = NULL;
 static bool task_threaded_enable            = false;
 
-static uint32_t task_count                  = 0;
+#ifdef HAVE_THREADS
+static uintptr_t main_thread_id             = 0;
+static slock_t *running_lock                = NULL;
+static slock_t *finished_lock               = NULL;
+static slock_t *property_lock               = NULL;
+static slock_t *queue_lock                  = NULL;
+static scond_t *worker_cond                 = NULL;
+static sthread_t *worker_thread             = NULL;
+static bool worker_continue                 = true;
+/* use running_lock when touching it */
+#endif
 
 static void task_queue_msg_push(retro_task_t *task,
       unsigned prio, unsigned duration,
@@ -83,6 +91,13 @@ static void task_queue_msg_push(retro_task_t *task,
 
 static void task_queue_push_progress(retro_task_t *task)
 {
+#ifdef HAVE_THREADS
+   /* msg_push callback interacts directly with the task properties (particularly title).
+    * make sure another thread doesn't modify them while rendering
+    */
+   slock_lock(property_lock);
+#endif
+
    if (task->title && !task->mute)
    {
       if (task->finished)
@@ -105,18 +120,45 @@ static void task_queue_push_progress(retro_task_t *task)
       if (task->progress_cb)
          task->progress_cb(task);
    }
+
+#ifdef HAVE_THREADS
+   slock_unlock(property_lock);
+#endif
 }
 
 static void task_queue_put(task_queue_t *queue, retro_task_t *task)
 {
-   task->next = NULL;
+   task->next                   = NULL;
 
    if (queue->front)
-      queue->back->next = task;
+   {
+      /* Make sure to insert in order - the queue is
+       * sorted by 'when' so items that aren't scheduled
+       * to run immediately are at the back of the queue.
+       * Items with the same 'when' are inserted after
+       * all the other items with the same 'when'.
+       * This primarily affects items with a 'when' of 0.
+       */
+      if (queue->back)
+      {
+         if (queue->back->when > task->when)
+         {
+            retro_task_t** prev = &queue->front;
+            while (*prev && (*prev)->when <= task->when)
+               prev             = &((*prev)->next);
+
+            task->next          = *prev;
+            *prev               = task;
+            return;
+         }
+
+         queue->back->next      = task;
+      }
+   }
    else
-      queue->front = task;
+      queue->front              = task;
 
-   queue->back = task;
+   queue->back                  = task;
 }
 
 static retro_task_t *task_queue_get(task_queue_t *queue)
@@ -126,7 +168,7 @@ static retro_task_t *task_queue_get(task_queue_t *queue)
    if (task)
    {
       queue->front = task->next;
-      task->next = NULL;
+      task->next   = NULL;
    }
 
    return task;
@@ -135,7 +177,7 @@ static retro_task_t *task_queue_get(task_queue_t *queue)
 static void retro_task_internal_gather(void)
 {
    retro_task_t *task = NULL;
-   while ((task = task_queue_get(&tasks_finished)) != NULL)
+   while ((task = task_queue_get(&tasks_finished)))
    {
       task_queue_push_progress(task);
 
@@ -172,7 +214,7 @@ static void retro_task_regular_gather(void)
    retro_task_t *queue = NULL;
    retro_task_t *next  = NULL;
 
-   while ((task = task_queue_get(&tasks_running)) != NULL)
+   while ((task = task_queue_get(&tasks_running)))
    {
       task->next = queue;
       queue = task;
@@ -181,14 +223,18 @@ static void retro_task_regular_gather(void)
    for (task = queue; task; task = next)
    {
       next = task->next;
-      task->handler(task);
 
-      task_queue_push_progress(task);
+      if (!task->when || task->when < cpu_features_get_time_usec())
+      {
+         task->handler(task);
+
+         task_queue_push_progress(task);
+      }
 
       if (task->finished)
          task_queue_put(&tasks_finished, task);
       else
-         retro_task_regular_push_running(task);
+         task_queue_put(&tasks_running, task);
    }
 
    retro_task_internal_gather();
@@ -196,7 +242,7 @@ static void retro_task_regular_gather(void)
 
 static void retro_task_regular_wait(retro_task_condition_fn_t cond, void* data)
 {
-   while (tasks_running.front && (!cond || cond(data)))
+   while ((tasks_running.front && !tasks_running.front->when) && (!cond || cond(data)))
       retro_task_regular_gather();
 }
 
@@ -208,13 +254,8 @@ static void retro_task_regular_reset(void)
       task->cancelled = true;
 }
 
-static void retro_task_regular_init(void)
-{
-}
-
-static void retro_task_regular_deinit(void)
-{
-}
+static void retro_task_regular_init(void) { }
+static void retro_task_regular_deinit(void) { }
 
 static bool retro_task_regular_find(retro_task_finder_t func, void *user_data)
 {
@@ -242,7 +283,8 @@ static void retro_task_regular_retrieve(task_retriever_data_t *data)
          continue;
 
       /* Create new link */
-      info       = (task_retriever_info_t*)malloc(sizeof(task_retriever_info_t));
+      info       = (task_retriever_info_t*)
+         malloc(sizeof(task_retriever_info_t));
       info->data = malloc(data->element_size);
       info->next = NULL;
 
@@ -287,31 +329,20 @@ static struct retro_task_impl impl_regular = {
 };
 
 #ifdef HAVE_THREADS
-static slock_t *running_lock    = NULL;
-static slock_t *finished_lock   = NULL;
-static slock_t *property_lock   = NULL;
-static slock_t *queue_lock      = NULL;
-static scond_t *worker_cond     = NULL;
-static sthread_t *worker_thread = NULL;
-static bool worker_continue     = true; /* use running_lock when touching it */
 
+/* 'queue_lock' must be held for the duration of this function */
 static void task_queue_remove(task_queue_t *queue, retro_task_t *task)
 {
    retro_task_t     *t = NULL;
-   retro_task_t *front = NULL;
-
-   slock_lock(queue_lock);
-   front = queue->front;
-   slock_unlock(queue_lock);
+   retro_task_t *front = queue->front;
 
    /* Remove first element if needed */
    if (task == front)
    {
-      slock_lock(queue_lock);
-      queue->front = task->next;
-      slock_unlock(queue_lock);
-      task->next   = NULL;
-
+      queue->front     = task->next;
+      if (queue->back == task) /* if only element, also update back */
+         queue->back   = NULL;
+      task->next       = NULL;
       return;
    }
 
@@ -325,6 +356,13 @@ static void task_queue_remove(task_queue_t *queue, retro_task_t *task)
       {
          t->next    = task->next;
          task->next = NULL;
+
+         /* When removing the tail of the queue, update the tail pointer */
+         if (queue->back == task)
+         {
+            if (queue->back == task)
+               queue->back = t;
+         }
          break;
       }
 
@@ -365,17 +403,14 @@ static void retro_task_threaded_gather(void)
 {
    retro_task_t *task = NULL;
 
-   slock_lock(property_lock);
    slock_lock(running_lock);
    for (task = tasks_running.front; task; task = task->next)
       task_queue_push_progress(task);
-
    slock_unlock(running_lock);
 
    slock_lock(finished_lock);
    retro_task_internal_gather();
    slock_unlock(finished_lock);
-   slock_unlock(property_lock);
 }
 
 static void retro_task_threaded_wait(retro_task_condition_fn_t cond, void* data)
@@ -387,10 +422,16 @@ static void retro_task_threaded_wait(retro_task_condition_fn_t cond, void* data)
       retro_task_threaded_gather();
 
       slock_lock(running_lock);
-      wait = (tasks_running.front != NULL) &&
-             (!cond || cond(data));
+      wait = (tasks_running.front && !tasks_running.front->when);
       slock_unlock(running_lock);
-   } while (wait);
+
+      if (!wait)
+      {
+         slock_lock(finished_lock);
+         wait = (tasks_finished.front && !tasks_finished.front->when);
+         slock_unlock(finished_lock);
+      }
+   } while (wait && (!cond || cond(data)));
 }
 
 static void retro_task_threaded_reset(void)
@@ -407,7 +448,7 @@ static bool retro_task_threaded_find(
       retro_task_finder_t func, void *user_data)
 {
    retro_task_t *task = NULL;
-   bool result = false;
+   bool        result = false;
 
    slock_lock(running_lock);
    for (task = tasks_running.front; task; task = task->next)
@@ -427,22 +468,18 @@ static void retro_task_threaded_retrieve(task_retriever_data_t *data)
 {
    /* Protect access to running tasks */
    slock_lock(running_lock);
-
    /* Call regular retrieve function */
    retro_task_regular_retrieve(data);
-
    /* Release access to running tasks */
    slock_unlock(running_lock);
 }
 
 static void threaded_worker(void *userdata)
 {
-   (void)userdata;
-
    for (;;)
    {
       retro_task_t *task  = NULL;
-      bool finished = false;
+      bool       finished = false;
 
       if (!worker_continue)
          break; /* should we keep running until all tasks finished? */
@@ -450,14 +487,25 @@ static void threaded_worker(void *userdata)
       slock_lock(running_lock);
 
       /* Get first task to run */
-      task = tasks_running.front;
-      if (task == NULL)
+      if (!(task = tasks_running.front))
       {
          scond_wait(worker_cond, running_lock);
          slock_unlock(running_lock);
          continue;
       }
 
+      if (task->when)
+      {
+         retro_time_t now   = cpu_features_get_time_usec();
+         retro_time_t delay = task->when - now - 500; /* allow half a millisecond for context switching */
+         if (delay > 0)
+         {
+            scond_wait_timeout(worker_cond, running_lock, delay);
+            slock_unlock(running_lock);
+            continue;
+         }
+      }
+
       slock_unlock(running_lock);
 
       task->handler(task);
@@ -466,18 +514,34 @@ static void threaded_worker(void *userdata)
       finished = task->finished;
       slock_unlock(property_lock);
 
-      slock_lock(running_lock);
-      task_queue_remove(&tasks_running, task);
-      slock_unlock(running_lock);
-
       /* Update queue */
       if (!finished)
       {
-         /* Re-add task to running queue */
-         retro_task_threaded_push_running(task);
+         /* Move the task to the back of the queue */
+         /* mimics retro_task_threaded_push_running,
+          * but also includes a task_queue_remove */
+         slock_lock(running_lock);
+         slock_lock(queue_lock);
+
+         /* do nothing if only item in queue */
+         if (task->next)
+         {
+            task_queue_remove(&tasks_running, task);
+            task_queue_put(&tasks_running, task);
+            scond_signal(worker_cond);
+         }
+         slock_unlock(queue_lock);
+         slock_unlock(running_lock);
       }
       else
       {
+         /* Remove task from running queue */
+         slock_lock(running_lock);
+         slock_lock(queue_lock);
+         task_queue_remove(&tasks_running, task);
+         slock_unlock(queue_lock);
+         slock_unlock(running_lock);
+
          /* Add task to finished queue */
          slock_lock(finished_lock);
          task_queue_put(&tasks_finished, task);
@@ -488,17 +552,17 @@ static void threaded_worker(void *userdata)
 
 static void retro_task_threaded_init(void)
 {
-   running_lock  = slock_new();
-   finished_lock = slock_new();
-   property_lock = slock_new();
-   queue_lock    = slock_new();
-   worker_cond   = scond_new();
+   running_lock    = slock_new();
+   finished_lock   = slock_new();
+   property_lock   = slock_new();
+   queue_lock      = slock_new();
+   worker_cond     = scond_new();
 
    slock_lock(running_lock);
    worker_continue = true;
    slock_unlock(running_lock);
 
-   worker_thread = sthread_create(threaded_worker, NULL);
+   worker_thread   = sthread_create(threaded_worker, NULL);
 }
 
 static void retro_task_threaded_deinit(void)
@@ -516,12 +580,12 @@ static void retro_task_threaded_deinit(void)
    slock_free(property_lock);
    slock_free(queue_lock);
 
-   worker_thread = NULL;
-   worker_cond   = NULL;
-   running_lock  = NULL;
-   finished_lock = NULL;
-   property_lock = NULL;
-   queue_lock = NULL;
+   worker_thread   = NULL;
+   worker_cond     = NULL;
+   running_lock    = NULL;
+   finished_lock   = NULL;
+   property_lock   = NULL;
+   queue_lock      = NULL;
 }
 
 static struct retro_task_impl impl_threaded = {
@@ -551,9 +615,9 @@ void task_queue_deinit(void)
 
 void task_queue_init(bool threaded, retro_task_queue_msg_t msg_push)
 {
-   impl_current = &impl_regular;
-
+   impl_current   = &impl_regular;
 #ifdef HAVE_THREADS
+   main_thread_id = sthread_get_current_thread_id();
    if (threaded)
    {
       task_threaded_enable = true;
@@ -584,9 +648,7 @@ bool task_queue_is_threaded(void)
 
 bool task_queue_find(task_finder_data_t *find_data)
 {
-   if (!impl_current->find(find_data->func, find_data->userdata))
-      return false;
-   return true;
+   return impl_current->find(find_data->func, find_data->userdata);
 }
 
 void task_queue_retrieve(task_retriever_data_t *data)
@@ -598,7 +660,7 @@ void task_queue_check(void)
 {
 #ifdef HAVE_THREADS
    bool current_threaded = (impl_current == &impl_threaded);
-   bool want_threaded    = task_queue_is_threaded();
+   bool want_threaded    = task_threaded_enable;
 
    if (want_threaded != current_threaded)
       task_queue_deinit();
@@ -616,9 +678,11 @@ bool task_queue_push(retro_task_t *task)
    if (task->type == TASK_TYPE_BLOCKING)
    {
       retro_task_t *running = NULL;
-      bool found = false;
+      bool            found = false;
 
-      SLOCK_LOCK(queue_lock);
+#ifdef HAVE_THREADS
+      slock_lock(queue_lock);
+#endif
       running = tasks_running.front;
 
       for (; running; running = running->next)
@@ -630,7 +694,9 @@ bool task_queue_push(retro_task_t *task)
          }
       }
 
-      SLOCK_UNLOCK(queue_lock);
+#ifdef HAVE_THREADS
+      slock_unlock(queue_lock);
+#endif
 
       /* skip this task, user must try again later */
       if (found)
@@ -664,16 +730,13 @@ void task_queue_cancel_task(void *task)
 
 void *task_queue_retriever_info_next(task_retriever_info_t **link)
 {
-   void *data = NULL;
-
    /* Grab data and move to next link */
    if (*link)
    {
-      data = (*link)->data;
       *link = (*link)->next;
+      return (*link)->data;
    }
-
-   return data;
+   return NULL;
 }
 
 void task_queue_retriever_info_free(task_retriever_info_t *list)
@@ -690,71 +753,116 @@ void task_queue_retriever_info_free(task_retriever_info_t *list)
    }
 }
 
+bool task_is_on_main_thread(void)
+{
+#ifdef HAVE_THREADS
+   return sthread_get_current_thread_id() == main_thread_id;
+#else
+   return true;
+#endif
+}
+
 void task_set_finished(retro_task_t *task, bool finished)
 {
-   SLOCK_LOCK(property_lock);
+#ifdef HAVE_THREADS
+   slock_lock(property_lock);
+#endif
    task->finished = finished;
-   SLOCK_UNLOCK(property_lock);
+#ifdef HAVE_THREADS
+   slock_unlock(property_lock);
+#endif
 }
 
 void task_set_mute(retro_task_t *task, bool mute)
 {
-   SLOCK_LOCK(property_lock);
+#ifdef HAVE_THREADS
+   slock_lock(property_lock);
+#endif
    task->mute = mute;
-   SLOCK_UNLOCK(property_lock);
+#ifdef HAVE_THREADS
+   slock_unlock(property_lock);
+#endif
 }
 
 void task_set_error(retro_task_t *task, char *error)
 {
-   SLOCK_LOCK(property_lock);
+#ifdef HAVE_THREADS
+   slock_lock(property_lock);
+#endif
    task->error = error;
-   SLOCK_UNLOCK(property_lock);
+#ifdef HAVE_THREADS
+   slock_unlock(property_lock);
+#endif
 }
 
 void task_set_progress(retro_task_t *task, int8_t progress)
 {
-   SLOCK_LOCK(property_lock);
+#ifdef HAVE_THREADS
+   slock_lock(property_lock);
+#endif
    task->progress = progress;
-   SLOCK_UNLOCK(property_lock);
+#ifdef HAVE_THREADS
+   slock_unlock(property_lock);
+#endif
 }
 
 void task_set_title(retro_task_t *task, char *title)
 {
-   SLOCK_LOCK(property_lock);
+#ifdef HAVE_THREADS
+   slock_lock(property_lock);
+#endif
    task->title = title;
-   SLOCK_UNLOCK(property_lock);
+#ifdef HAVE_THREADS
+   slock_unlock(property_lock);
+#endif
 }
 
 void task_set_data(retro_task_t *task, void *data)
 {
-   SLOCK_LOCK(running_lock);
+#ifdef HAVE_THREADS
+   slock_lock(running_lock);
+#endif
    task->task_data = data;
-   SLOCK_UNLOCK(running_lock);
+#ifdef HAVE_THREADS
+   slock_unlock(running_lock);
+#endif
 }
 
 void task_set_cancelled(retro_task_t *task, bool cancelled)
 {
-   SLOCK_LOCK(running_lock);
+#ifdef HAVE_THREADS
+   slock_lock(running_lock);
+#endif
    task->cancelled = cancelled;
-   SLOCK_UNLOCK(running_lock);
+#ifdef HAVE_THREADS
+   slock_unlock(running_lock);
+#endif
 }
 
 void task_free_title(retro_task_t *task)
 {
-   SLOCK_LOCK(property_lock);
+#ifdef HAVE_THREADS
+   slock_lock(property_lock);
+#endif
    if (task->title)
       free(task->title);
    task->title = NULL;
-   SLOCK_UNLOCK(property_lock);
+#ifdef HAVE_THREADS
+   slock_unlock(property_lock);
+#endif
 }
 
 void* task_get_data(retro_task_t *task)
 {
    void *data = NULL;
 
-   SLOCK_LOCK(running_lock);
+#ifdef HAVE_THREADS
+   slock_lock(running_lock);
+#endif
    data = task->task_data;
-   SLOCK_UNLOCK(running_lock);
+#ifdef HAVE_THREADS
+   slock_unlock(running_lock);
+#endif
 
    return data;
 }
@@ -763,9 +871,13 @@ bool task_get_cancelled(retro_task_t *task)
 {
    bool cancelled = false;
 
-   SLOCK_LOCK(running_lock);
+#ifdef HAVE_THREADS
+   slock_lock(running_lock);
+#endif
    cancelled = task->cancelled;
-   SLOCK_UNLOCK(running_lock);
+#ifdef HAVE_THREADS
+   slock_unlock(running_lock);
+#endif
 
    return cancelled;
 }
@@ -774,9 +886,13 @@ bool task_get_finished(retro_task_t *task)
 {
    bool finished = false;
 
-   SLOCK_LOCK(property_lock);
+#ifdef HAVE_THREADS
+   slock_lock(property_lock);
+#endif
    finished = task->finished;
-   SLOCK_UNLOCK(property_lock);
+#ifdef HAVE_THREADS
+   slock_unlock(property_lock);
+#endif
 
    return finished;
 }
@@ -785,9 +901,13 @@ bool task_get_mute(retro_task_t *task)
 {
    bool mute = false;
 
-   SLOCK_LOCK(property_lock);
+#ifdef HAVE_THREADS
+   slock_lock(property_lock);
+#endif
    mute = task->mute;
-   SLOCK_UNLOCK(property_lock);
+#ifdef HAVE_THREADS
+   slock_unlock(property_lock);
+#endif
 
    return mute;
 }
@@ -796,9 +916,13 @@ char* task_get_error(retro_task_t *task)
 {
    char *error = NULL;
 
-   SLOCK_LOCK(property_lock);
+#ifdef HAVE_THREADS
+   slock_lock(property_lock);
+#endif
    error = task->error;
-   SLOCK_UNLOCK(property_lock);
+#ifdef HAVE_THREADS
+   slock_unlock(property_lock);
+#endif
 
    return error;
 }
@@ -807,9 +931,13 @@ int8_t task_get_progress(retro_task_t *task)
 {
    int8_t progress = 0;
 
-   SLOCK_LOCK(property_lock);
+#ifdef HAVE_THREADS
+   slock_lock(property_lock);
+#endif
    progress = task->progress;
-   SLOCK_UNLOCK(property_lock);
+#ifdef HAVE_THREADS
+   slock_unlock(property_lock);
+#endif
 
    return progress;
 }
@@ -818,18 +946,45 @@ char* task_get_title(retro_task_t *task)
 {
    char *title = NULL;
 
-   SLOCK_LOCK(property_lock);
+#ifdef HAVE_THREADS
+   slock_lock(property_lock);
+#endif
    title = task->title;
-   SLOCK_UNLOCK(property_lock);
+#ifdef HAVE_THREADS
+   slock_unlock(property_lock);
+#endif
 
    return title;
 }
 
 retro_task_t *task_init(void)
 {
-   retro_task_t *task      = (retro_task_t*)calloc(1, sizeof(*task));
-
+   /* TODO/FIXME - static local global */
+   static uint32_t task_count = 0;
+   retro_task_t *task         = (retro_task_t*)malloc(sizeof(*task));
+
+   if (!task)
+      return NULL;
+
+   task->handler           = NULL;
+   task->callback          = NULL;
+   task->cleanup           = NULL;
+   task->finished          = false;
+   task->cancelled         = false;
+   task->mute              = false;
+   task->task_data         = NULL;
+   task->user_data         = NULL;
+   task->state             = NULL;
+   task->error             = NULL;
+   task->progress          = 0;
+   task->progress_cb       = NULL;
+   task->title             = NULL;
+   task->type              = TASK_TYPE_NONE;
    task->ident             = task_count++;
+   task->frontend_userdata = NULL;
+   task->alternative_look  = false;
+   task->next              = NULL;
+   task->when              = 0;
 
    return task;
 }
diff --git a/src/libretro/libretro-common/rthreads/ctr_pthread.h b/src/libretro/libretro-common/rthreads/ctr_pthread.h
index 0370c8472e..5582af1a9d 100644
--- a/src/libretro/libretro-common/rthreads/ctr_pthread.h
+++ b/src/libretro/libretro-common/rthreads/ctr_pthread.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (gx_pthread.h).
@@ -30,14 +30,120 @@
 #include <errno.h>
 #include <retro_inline.h>
 
-#define STACKSIZE (4 * 1024)
+#define STACKSIZE (32 * 1024)
+
+#ifndef PTHREAD_SCOPE_PROCESS
+/* An earlier version of devkitARM does not define the pthread types. Can remove in r54+. */
 
 typedef Thread     pthread_t;
 typedef LightLock  pthread_mutex_t;
 typedef void*      pthread_mutexattr_t;
 typedef int        pthread_attr_t;
-typedef LightEvent pthread_cond_t;
+typedef uint32_t   pthread_cond_t;
 typedef int        pthread_condattr_t;
+#endif
+
+#ifndef USE_CTRULIB_2
+/* Backported CondVar API from libctru 2.0, and under its license:
+   https://github.com/devkitPro/libctru
+   Slightly modified for compatibility with older libctru. */
+
+typedef s32 CondVar;
+
+static INLINE Result syncArbitrateAddress(s32* addr, ArbitrationType type, s32 value)
+{
+   return svcArbitrateAddress(__sync_get_arbiter(), (u32)addr, type, value, 0);
+}
+
+static INLINE Result syncArbitrateAddressWithTimeout(s32* addr, ArbitrationType type, s32 value, s64 timeout_ns)
+{
+   return svcArbitrateAddress(__sync_get_arbiter(), (u32)addr, type, value, timeout_ns);
+}
+
+static INLINE void __dmb(void)
+{
+	__asm__ __volatile__("mcr p15, 0, %[val], c7, c10, 5" :: [val] "r" (0) : "memory");
+}
+
+static INLINE void CondVar_BeginWait(CondVar* cv, LightLock* lock)
+{
+	s32 val;
+	do
+		val = __ldrex(cv) - 1;
+	while (__strex(cv, val));
+	LightLock_Unlock(lock);
+}
+
+static INLINE bool CondVar_EndWait(CondVar* cv, s32 num_threads)
+{
+	bool hasWaiters;
+	s32 val;
+
+	do {
+		val = __ldrex(cv);
+		hasWaiters = val < 0;
+		if (hasWaiters)
+		{
+			if (num_threads < 0)
+				val = 0;
+			else if (val <= -num_threads)
+				val += num_threads;
+			else
+				val = 0;
+		}
+	} while (__strex(cv, val));
+
+	return hasWaiters;
+}
+
+static INLINE void CondVar_Init(CondVar* cv)
+{
+	*cv = 0;
+}
+
+static INLINE void CondVar_Wait(CondVar* cv, LightLock* lock)
+{
+	CondVar_BeginWait(cv, lock);
+	syncArbitrateAddress(cv, ARBITRATION_WAIT_IF_LESS_THAN, 0);
+	LightLock_Lock(lock);
+}
+
+static INLINE int CondVar_WaitTimeout(CondVar* cv, LightLock* lock, s64 timeout_ns)
+{
+	CondVar_BeginWait(cv, lock);
+
+	bool timedOut = false;
+	Result rc = syncArbitrateAddressWithTimeout(cv, ARBITRATION_WAIT_IF_LESS_THAN_TIMEOUT, 0, timeout_ns);
+	if (R_DESCRIPTION(rc) == RD_TIMEOUT)
+	{
+		timedOut = CondVar_EndWait(cv, 1);
+		__dmb();
+	}
+
+	LightLock_Lock(lock);
+	return timedOut;
+}
+
+static INLINE void CondVar_WakeUp(CondVar* cv, s32 num_threads)
+{
+	__dmb();
+	if (CondVar_EndWait(cv, num_threads))
+		syncArbitrateAddress(cv, ARBITRATION_SIGNAL, num_threads);
+	else
+		__dmb();
+}
+
+static INLINE void CondVar_Signal(CondVar* cv)
+{
+	CondVar_WakeUp(cv, 1);
+}
+
+static INLINE void CondVar_Broadcast(CondVar* cv)
+{
+	CondVar_WakeUp(cv, ARBITRATION_SIGNAL_ALL);
+}
+/* End libctru 2.0 backport */
+#endif
 
 /* libctru threads return void but pthreads return void pointer */
 static bool mutex_inited = false;
@@ -56,11 +162,18 @@ static INLINE int pthread_create(pthread_t *thread,
 {
    s32 prio = 0;
    Thread new_ctr_thread;
+   int procnum = -2; // use default cpu
+   bool isNew3DS;
+
+   APT_CheckNew3DS(&isNew3DS);
+
+   if (isNew3DS)
+      procnum = 2;
 
    if (!mutex_inited)
    {
-	   LightLock_Init(&safe_double_thread_launch);
-	   mutex_inited = true;
+      LightLock_Init(&safe_double_thread_launch);
+      mutex_inited = true;
    }
 
    /*Must wait if attempting to launch 2 threads at once to prevent corruption of function pointer*/
@@ -69,27 +182,27 @@ static INLINE int pthread_create(pthread_t *thread,
    svcGetThreadPriority(&prio, CUR_THREAD_HANDLE);
 
    start_routine_jump = start_routine;
-   new_ctr_thread     = threadCreate(ctr_thread_launcher, arg, STACKSIZE, prio - 1, -1/*No affinity, use any CPU*/, false);
+   new_ctr_thread     = threadCreate(ctr_thread_launcher, arg, STACKSIZE, prio - 1, procnum, false);
 
    if (!new_ctr_thread)
    {
-	   LightLock_Unlock(&safe_double_thread_launch);
-	   return EAGAIN;
+      LightLock_Unlock(&safe_double_thread_launch);
+      return EAGAIN;
    }
 
-   *thread = new_ctr_thread;
+   *thread = (pthread_t)new_ctr_thread;
    return 0;
 }
 
 static INLINE pthread_t pthread_self(void)
 {
-   return threadGetCurrent();
+   return (pthread_t)threadGetCurrent();
 }
 
 static INLINE int pthread_mutex_init(pthread_mutex_t *mutex,
       const pthread_mutexattr_t *attr)
 {
-   LightLock_Init(mutex);
+   LightLock_Init((LightLock *)mutex);
    return 0;
 }
 
@@ -101,12 +214,13 @@ static INLINE int pthread_mutex_destroy(pthread_mutex_t *mutex)
 
 static INLINE int pthread_mutex_lock(pthread_mutex_t *mutex)
 {
-   return LightLock_TryLock(mutex);
+   LightLock_Lock((LightLock *)mutex);
+   return 0;
 }
 
 static INLINE int pthread_mutex_unlock(pthread_mutex_t *mutex)
 {
-   LightLock_Unlock(mutex);
+   LightLock_Unlock((LightLock *)mutex);
    return 0;
 }
 
@@ -115,80 +229,96 @@ static INLINE void pthread_exit(void *retval)
    /*Yes the pointer to int cast is not ideal*/
    /*threadExit((int)retval);*/
    (void)retval;
+
+   threadExit(0);
 }
 
 static INLINE int pthread_detach(pthread_t thread)
 {
-   /* FIXME: pthread_detach equivalent missing? */
-   (void)thread;
+   threadDetach((Thread)thread);
    return 0;
 }
 
 static INLINE int pthread_join(pthread_t thread, void **retval)
 {
    /*retval is ignored*/
-   return threadJoin(thread, U64_MAX);
+   if (threadJoin((Thread)thread, INT64_MAX))
+      return -1;
+
+   threadFree((Thread)thread);
+
+   return 0;
 }
 
 static INLINE int pthread_mutex_trylock(pthread_mutex_t *mutex)
 {
-   return LightLock_TryLock(mutex);
+   return LightLock_TryLock((LightLock *)mutex);
 }
 
 static INLINE int pthread_cond_wait(pthread_cond_t *cond,
       pthread_mutex_t *mutex)
 {
-   LightEvent_Wait(cond);
+   CondVar_Wait((CondVar *)cond, (LightLock *)mutex);
    return 0;
 }
 
 static INLINE int pthread_cond_timedwait(pthread_cond_t *cond,
       pthread_mutex_t *mutex, const struct timespec *abstime)
 {
-   while (true)
-   {
-       struct timespec now = {0};
-	    /* Missing clock_gettime*/
-       struct timeval tm;
-
-       gettimeofday(&tm, NULL);
-       now.tv_sec = tm.tv_sec;
-       now.tv_nsec = tm.tv_usec * 1000;
-       if (LightEvent_TryWait(cond) != 0 || now.tv_sec > abstime->tv_sec || (now.tv_sec == abstime->tv_sec && now.tv_nsec > abstime->tv_nsec))
-		   break;
-   }
+   /* Missing clock_gettime*/
+   struct timespec now;
+   struct timeval tm;
+   int retval = 0;
 
-   return 0;
+   do
+   {
+      s64 timeout;
+      gettimeofday(&tm, NULL);
+      now.tv_sec  = tm.tv_sec;
+      now.tv_nsec = tm.tv_usec * 1000;
+
+      if ((timeout = (abstime->tv_sec - now.tv_sec) * 1000000000 +
+(abstime->tv_nsec - now.tv_nsec)) < 0)
+      {
+         retval = ETIMEDOUT;
+         break;
+      }
+
+      if (!CondVar_WaitTimeout((CondVar *)cond, (LightLock *)mutex, timeout))
+         break;
+   } while (1);
+
+   return retval;
 }
 
 static INLINE int pthread_cond_init(pthread_cond_t *cond,
       const pthread_condattr_t *attr)
 {
-   LightEvent_Init(cond, RESET_ONESHOT);
+   CondVar_Init((CondVar *)cond);
    return 0;
 }
 
 static INLINE int pthread_cond_signal(pthread_cond_t *cond)
 {
-   LightEvent_Signal(cond);
+   CondVar_Signal((CondVar *)cond);
    return 0;
 }
 
 static INLINE int pthread_cond_broadcast(pthread_cond_t *cond)
 {
-   LightEvent_Signal(cond);
+   CondVar_Broadcast((CondVar *)cond);
    return 0;
 }
 
 static INLINE int pthread_cond_destroy(pthread_cond_t *cond)
 {
-   /*nothing to destroy*/
+   /*Nothing to destroy*/
    return 0;
 }
 
 static INLINE int pthread_equal(pthread_t t1, pthread_t t2)
 {
-	if (threadGetHandle(t1) == threadGetHandle(t2))
+	if (threadGetHandle((Thread)t1) == threadGetHandle((Thread)t2))
 		return 1;
 	return 0;
 }
diff --git a/src/libretro/libretro-common/rthreads/gx_pthread.h b/src/libretro/libretro-common/rthreads/gx_pthread.h
index 055c6afbde..da6efb823f 100644
--- a/src/libretro/libretro-common/rthreads/gx_pthread.h
+++ b/src/libretro/libretro-common/rthreads/gx_pthread.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (gx_pthread.h).
@@ -84,10 +84,13 @@
 
 typedef OSThread pthread_t;
 typedef mutex_t pthread_mutex_t;
+typedef OSCond pthread_cond_t;
+
+#if defined(GX_PTHREAD_LEGACY)
 typedef void* pthread_mutexattr_t;
 typedef int pthread_attr_t;
-typedef OSCond pthread_cond_t;
 typedef OSCond pthread_condattr_t;
+#endif
 
 static INLINE int pthread_create(pthread_t *thread,
       const pthread_attr_t *attr, void *(*start_routine)(void*), void *arg)
@@ -180,6 +183,4 @@ static INLINE int pthread_cond_destroy(pthread_cond_t *cond)
    return LWP_CondDestroy(*cond);
 }
 
-extern int pthread_equal(pthread_t t1, pthread_t t2);
-
 #endif
diff --git a/src/libretro/libretro-common/rthreads/psp_pthread.h b/src/libretro/libretro-common/rthreads/psp_pthread.h
index 7aea08a875..f320969db2 100644
--- a/src/libretro/libretro-common/rthreads/psp_pthread.h
+++ b/src/libretro/libretro-common/rthreads/psp_pthread.h
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2017 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (psp_pthread.h).
@@ -96,7 +96,7 @@ static INLINE int pthread_mutex_init(pthread_mutex_t *mutex,
 
 #ifdef VITA
    *mutex = sceKernelCreateMutex(name_buffer, 0, 0, 0);
-	 if(*mutex<0)
+	 if (*mutex<0)
 	 		return *mutex;
 	 return 0;
 #else
@@ -220,13 +220,13 @@ static INLINE int pthread_cond_init(pthread_cond_t *cond,
 
    pthread_mutex_init(&cond->mutex,NULL);
 
-   if(cond->mutex<0)
+   if (cond->mutex<0)
       return cond->mutex;
 
    snprintf(name_buffer, sizeof(name_buffer), "0x%08X", (unsigned int) cond);
    cond->sema = sceKernelCreateSema(name_buffer, 0, 0, 1, 0);
 
-   if(cond->sema < 0)
+   if (cond->sema < 0)
    {
       pthread_mutex_destroy(&cond->mutex);
       return cond->sema;
@@ -269,7 +269,7 @@ static INLINE int pthread_cond_destroy(pthread_cond_t *cond)
 {
 #ifdef VITA
    int ret = sceKernelDeleteSema(cond->sema);
-   if(ret < 0)
+   if (ret < 0)
     return ret;
 
    return sceKernelDeleteMutex(cond->mutex);
diff --git a/src/libretro/libretro-common/rthreads/rthreads.c b/src/libretro/libretro-common/rthreads/rthreads.c
index 5b3e5d6557..b923a8e290 100644
--- a/src/libretro/libretro-common/rthreads/rthreads.c
+++ b/src/libretro/libretro-common/rthreads/rthreads.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (rthreads.c).
@@ -47,18 +47,16 @@
 #include <mmsystem.h>
 #endif
 #elif defined(GEKKO)
+#include <ogc/lwp_watchdog.h>
 #include "gx_pthread.h"
 #elif defined(_3DS)
 #include "ctr_pthread.h"
-#elif defined(__CELLOS_LV2__)
-#include <pthread.h>
-#include <sys/sys_time.h>
 #else
 #include <pthread.h>
 #include <time.h>
 #endif
 
-#if defined(VITA) || defined(BSD) || defined(ORBIS)
+#if defined(VITA) || defined(BSD) || defined(ORBIS) || defined(__mips__) || defined(_3DS)
 #include <sys/time.h>
 #endif
 
@@ -95,9 +93,9 @@ struct slock
 #ifdef USE_WIN32_THREADS
 /* The syntax we'll use is mind-bending unless we use a struct. Plus, we might want to store more info later */
 /* This will be used as a linked list immplementing a queue of waiting threads */
-struct QueueEntry
+struct queue_entry
 {
-   struct QueueEntry *next;
+   struct queue_entry *next;
 };
 #endif
 
@@ -117,7 +115,7 @@ struct scond
    HANDLE event;
 
    /* the head of the queue; NULL if queue is empty */
-   struct QueueEntry *head;
+   struct queue_entry *head;
 
    /* equivalent to the queue length */
    int waiters;
@@ -164,7 +162,7 @@ sthread_t *sthread_create(void (*thread_func)(void*), void *userdata)
 }
 
 /* TODO/FIXME - this needs to be implemented for Switch/3DS */
-#if !defined(SWITCH) && !defined(USE_WIN32_THREADS) && !defined(_3DS) && !defined(GEKKO) && !defined(__HAIKU__)
+#if !defined(SWITCH) && !defined(USE_WIN32_THREADS) && !defined(_3DS) && !defined(GEKKO) && !defined(__HAIKU__) && !defined(EMSCRIPTEN)
 #define HAVE_THREAD_ATTR
 #endif
 
@@ -191,27 +189,30 @@ sthread_t *sthread_create_with_priority(void (*thread_func)(void*), void *userda
 #endif
    bool thread_created      = false;
    struct thread_data *data = NULL;
-   sthread_t *thread        = (sthread_t*)calloc(1, sizeof(*thread));
+   sthread_t *thread        = (sthread_t*)malloc(sizeof(*thread));
 
    if (!thread)
       return NULL;
 
-   data                     = (struct thread_data*)calloc(1, sizeof(*data));
-   if (!data)
-      goto error;
+   if (!(data = (struct thread_data*)malloc(sizeof(*data))))
+   {
+      free(thread);
+      return NULL;
+   }
 
    data->func               = thread_func;
    data->userdata           = userdata;
 
+   thread->id               = 0;
 #ifdef USE_WIN32_THREADS
-   thread->thread           = CreateThread(NULL, 0, thread_wrap, data, 0, &thread->id);
+   thread->thread           = CreateThread(NULL, 0, thread_wrap,
+         data, 0, &thread->id);
    thread_created           = !!thread->thread;
 #else
-
 #ifdef HAVE_THREAD_ATTR
    pthread_attr_init(&thread_attr);
 
-   if ( (thread_priority >= 1) && (thread_priority <= 100) )
+   if ((thread_priority >= 1) && (thread_priority <= 100))
    {
       struct sched_param sp;
       memset(&sp, 0, sizeof(struct sched_param));
@@ -221,31 +222,32 @@ sthread_t *sthread_create_with_priority(void (*thread_func)(void*), void *userda
 
       thread_attr_needed = true;
    }
-#endif
 
 #if defined(VITA)
    pthread_attr_setstacksize(&thread_attr , 0x10000 );
    thread_attr_needed = true;
+#elif defined(__APPLE__)
+   /* Default stack size on Apple is 512Kb; 
+    * for PS2 disc scanning and other reasons, we'd like 2MB. */
+   pthread_attr_setstacksize(&thread_attr , 0x200000 );
+   thread_attr_needed = true;
 #endif
 
-#ifdef HAVE_THREAD_ATTR
    if (thread_attr_needed)
       thread_created = pthread_create(&thread->id, &thread_attr, thread_wrap, data) == 0;
    else
-#endif
       thread_created = pthread_create(&thread->id, NULL, thread_wrap, data) == 0;
 
-#ifdef HAVE_THREAD_ATTR
    pthread_attr_destroy(&thread_attr);
+#else
+   thread_created    = pthread_create(&thread->id, NULL, thread_wrap, data) == 0;
 #endif
+
 #endif
 
    if (thread_created)
       return thread;
-
-error:
-   if (data)
-      free(data);
+   free(data);
    free(thread);
    return NULL;
 }
@@ -268,7 +270,9 @@ int sthread_detach(sthread_t *thread)
    free(thread);
    return 0;
 #else
-   return pthread_detach(thread->id);
+   int ret = pthread_detach(thread->id);
+   free(thread);
+   return ret;
 #endif
 }
 
@@ -296,6 +300,7 @@ void sthread_join(sthread_t *thread)
    free(thread);
 }
 
+#if !defined(GEKKO)
 /**
  * sthread_isself:
  * @thread                  : pointer to thread object
@@ -304,16 +309,13 @@ void sthread_join(sthread_t *thread)
  */
 bool sthread_isself(sthread_t *thread)
 {
-  /* This thread can't possibly be a null thread */
-  if (!thread)
-     return false;
-
 #ifdef USE_WIN32_THREADS
-   return GetCurrentThreadId() == thread->id;
+   return thread ? GetCurrentThreadId() == thread->id        : false;
 #else
-   return pthread_equal(pthread_self(),thread->id);
+   return thread ? pthread_equal(pthread_self(), thread->id) : false;
 #endif
 }
+#endif
 
 /**
  * slock_new:
@@ -325,26 +327,19 @@ bool sthread_isself(sthread_t *thread)
  **/
 slock_t *slock_new(void)
 {
-   bool mutex_created = false;
    slock_t      *lock = (slock_t*)calloc(1, sizeof(*lock));
    if (!lock)
       return NULL;
-
 #ifdef USE_WIN32_THREADS
    InitializeCriticalSection(&lock->lock);
-   mutex_created = true;
 #else
-   mutex_created = (pthread_mutex_init(&lock->lock, NULL) == 0);
+   if (pthread_mutex_init(&lock->lock, NULL) != 0)
+   {
+      free(lock);
+      return NULL;
+   }
 #endif
-
-   if (!mutex_created)
-      goto error;
-
    return lock;
-
-error:
-   free(lock);
-   return NULL;
 }
 
 /**
@@ -394,12 +389,10 @@ void slock_lock(slock_t *lock)
 **/
 bool slock_try_lock(slock_t *lock)
 {
-   if (!lock)
-      return false;
 #ifdef USE_WIN32_THREADS
-   return TryEnterCriticalSection(&lock->lock);
+   return lock && TryEnterCriticalSection(&lock->lock);
 #else
-   return pthread_mutex_trylock(&lock->lock)==0;
+   return lock && (pthread_mutex_trylock(&lock->lock) == 0);
 #endif
 }
 
@@ -437,7 +430,6 @@ scond_t *scond_new(void)
       return NULL;
 
 #ifdef USE_WIN32_THREADS
-
    /* This is very complex because recreating condition variable semantics
     * with Win32 parts is not easy.
     *
@@ -463,20 +455,15 @@ scond_t *scond_new(void)
     *
     * Note: We might could simplify this using vista+ condition variables,
     * but we wanted an XP compatible solution. */
-   cond->event = CreateEvent(NULL, FALSE, FALSE, NULL);
-   if (!cond->event)
+   if (!(cond->event      = CreateEvent(NULL, FALSE, FALSE, NULL)))
       goto error;
-   cond->hot_potato = CreateEvent(NULL, FALSE, FALSE, NULL);
-   if (!cond->hot_potato)
+   if (!(cond->hot_potato = CreateEvent(NULL, FALSE, FALSE, NULL)))
    {
       CloseHandle(cond->event);
       goto error;
    }
 
    InitializeCriticalSection(&cond->cs);
-   cond->waiters = cond->wakens = 0;
-   cond->head = NULL;
-
 #else
    if (pthread_cond_init(&cond->cond, NULL) != 0)
       goto error;
@@ -513,8 +500,8 @@ void scond_free(scond_t *cond)
 #ifdef USE_WIN32_THREADS
 static bool _scond_wait_win32(scond_t *cond, slock_t *lock, DWORD dwMilliseconds)
 {
-   struct QueueEntry myentry;
-   struct QueueEntry **ptr;
+   struct queue_entry myentry;
+   struct queue_entry **ptr;
 
 #if _WIN32_WINNT >= 0x0500 || defined(_XBOX)
    static LARGE_INTEGER performanceCounterFrequency;
@@ -524,7 +511,6 @@ static bool _scond_wait_win32(scond_t *cond, slock_t *lock, DWORD dwMilliseconds
    static bool beginPeriod = false;
    DWORD tsBegin;
 #endif
-
    DWORD waitResult;
    DWORD dwFinalTimeout = dwMilliseconds; /* Careful! in case we begin in the head,
                                              we don't do the hot potato stuff,
@@ -544,9 +530,7 @@ static bool _scond_wait_win32(scond_t *cond, slock_t *lock, DWORD dwMilliseconds
    }
 
    if (performanceCounterFrequency.QuadPart == 0)
-   {
       QueryPerformanceFrequency(&performanceCounterFrequency);
-   }
 #else
    if (!beginPeriod)
    {
@@ -569,9 +553,9 @@ static bool _scond_wait_win32(scond_t *cond, slock_t *lock, DWORD dwMilliseconds
 
    /* walk to the end of the linked list */
    while (*ptr)
-      ptr = &((*ptr)->next);
+      ptr       = &((*ptr)->next);
 
-   *ptr = &myentry;
+   *ptr         = &myentry;
    myentry.next = NULL;
 
    cond->waiters++;
@@ -660,7 +644,7 @@ static bool _scond_wait_win32(scond_t *cond, slock_t *lock, DWORD dwMilliseconds
          {
             /* It's not our turn and we're out of time. Give up.
              * Remove ourself from the queue and bail. */
-            struct QueueEntry* curr = cond->head;
+            struct queue_entry *curr = cond->head;
 
             while (curr->next != &myentry)
                curr = curr->next;
@@ -745,18 +729,17 @@ void scond_wait(scond_t *cond, slock_t *lock)
 int scond_broadcast(scond_t *cond)
 {
 #ifdef USE_WIN32_THREADS
-   /* remember: we currently have mutex */
-   if (cond->waiters == 0)
-      return 0;
-
-   /* awaken everything which is currently queued up */
-   if (cond->wakens == 0)
-      SetEvent(cond->event);
-   cond->wakens = cond->waiters;
-
-   /* Since there is now at least one pending waken, the potato must be in play */
-   SetEvent(cond->hot_potato);
+   /* Remember, we currently have mutex */
+   if (cond->waiters != 0)
+   {
+      /* Awaken everything which is currently queued up */
+      if (cond->wakens == 0)
+         SetEvent(cond->event);
+      cond->wakens = cond->waiters;
 
+      /* Since there is now at least one pending waken, the potato must be in play */
+      SetEvent(cond->hot_potato);
+   }
    return 0;
 #else
    return pthread_cond_broadcast(&cond->cond);
@@ -829,11 +812,6 @@ bool scond_wait_timeout(scond_t *cond, slock_t *lock, int64_t timeout_us)
     * Someone asking for a 0 timeout clearly wants immediate timeout.
     * Someone asking for a 1 timeout clearly wants an actual timeout
     * of the minimum length */
-
-   /* Someone asking for 1000 or 1001 timeout shouldn't
-    * accidentally get 2ms. */
-   DWORD dwMilliseconds = timeout_us/1000;
-
    /* The implementation of a 0 timeout here with pthreads is sketchy.
     * It isn't clear what happens if pthread_cond_timedwait is called with NOW.
     * Moreover, it is possible that this thread gets pre-empted after the
@@ -844,62 +822,61 @@ bool scond_wait_timeout(scond_t *cond, slock_t *lock, int64_t timeout_us)
    if (timeout_us == 0)
       return false;
    else if (timeout_us < 1000)
-      dwMilliseconds = 1;
-
-   return _scond_wait_win32(cond,lock,dwMilliseconds);
+      return _scond_wait_win32(cond, lock, 1);
+   /* Someone asking for 1000 or 1001 timeout shouldn't
+    * accidentally get 2ms. */
+   return _scond_wait_win32(cond, lock, timeout_us / 1000);
 #else
-   int ret;
    int64_t seconds, remainder;
-   struct timespec now = {0};
-
+   struct timespec now;
 #ifdef __MACH__
    /* OSX doesn't have clock_gettime. */
    clock_serv_t cclock;
    mach_timespec_t mts;
-
    host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
    clock_get_time(cclock, &mts);
    mach_port_deallocate(mach_task_self(), cclock);
    now.tv_sec = mts.tv_sec;
    now.tv_nsec = mts.tv_nsec;
-#elif defined(__CELLOS_LV2__)
+#elif !defined(__PSL1GHT__) && defined(__PS3__)
    sys_time_sec_t s;
    sys_time_nsec_t n;
-
    sys_time_get_current_time(&s, &n);
-   now.tv_sec  = s;
-   now.tv_nsec = n;
+   now.tv_sec            = s;
+   now.tv_nsec           = n;
 #elif defined(PS2)
-   int tickms = clock();
-   now.tv_sec = tickms/1000;
-   now.tv_nsec = tickms * 1000;
-#elif defined(__mips__) || defined(VITA) || defined(_3DS)
+   int tickms            = ps2_clock();
+   now.tv_sec            = tickms / 1000;
+   now.tv_nsec           = tickms * 1000;
+#elif !defined(DINGUX_BETA) && (defined(__mips__) || defined(VITA) || defined(_3DS))
    struct timeval tm;
-
    gettimeofday(&tm, NULL);
-   now.tv_sec = tm.tv_sec;
-   now.tv_nsec = tm.tv_usec * 1000;
+   now.tv_sec            = tm.tv_sec;
+   now.tv_nsec           = tm.tv_usec * 1000;
 #elif defined(RETRO_WIN32_USE_PTHREADS)
    _ftime64_s(&now);
-#elif !defined(GEKKO)
-   /* timeout on libogc is duration, not end time. */
+#elif defined(GEKKO)
+   /* Avoid gettimeofday due to it being reported to be broken */
+   const uint64_t tickms = gettime() / TB_TIMER_CLOCK;
+   now.tv_sec            = tickms / 1000;
+   now.tv_nsec           = tickms * 1000;
+#else
    clock_gettime(CLOCK_REALTIME, &now);
 #endif
 
-   seconds      = timeout_us / INT64_C(1000000);
-   remainder    = timeout_us % INT64_C(1000000);
+   seconds              = timeout_us / INT64_C(1000000);
+   remainder            = timeout_us % INT64_C(1000000);
 
-   now.tv_sec  += seconds;
-   now.tv_nsec += remainder * INT64_C(1000);
+   now.tv_sec          += seconds;
+   now.tv_nsec         += remainder * INT64_C(1000);
 
    if (now.tv_nsec > 1000000000)
    {
-      now.tv_nsec -= 1000000000;
-      now.tv_sec += 1;
+      now.tv_nsec      -= 1000000000;
+      now.tv_sec       += 1;
    }
 
-   ret = pthread_cond_timedwait(&cond->cond, &lock->lock, &now);
-   return (ret == 0);
+   return (pthread_cond_timedwait(&cond->cond, &lock->lock, &now) == 0);
 #endif
 }
 
@@ -943,9 +920,9 @@ bool sthread_tls_set(sthread_tls_t *tls, const void *data)
 
 uintptr_t sthread_get_thread_id(sthread_t *thread)
 {
-   if (!thread)
-      return 0;
-   return (uintptr_t)thread->id;
+   if (thread)
+      return (uintptr_t)thread->id;
+   return 0;
 }
 
 uintptr_t sthread_get_current_thread_id(void)
diff --git a/src/libretro/libretro-common/rthreads/xenon_sdl_threads.c b/src/libretro/libretro-common/rthreads/xenon_sdl_threads.c
index 6c38d89015..186f9ecbd6 100644
--- a/src/libretro/libretro-common/rthreads/xenon_sdl_threads.c
+++ b/src/libretro/libretro-common/rthreads/xenon_sdl_threads.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (xenon_sdl_threads.c).
diff --git a/src/libretro/libretro-common/samples/core_options/README.md b/src/libretro/libretro-common/samples/core_options/README.md
index ea7868b0d9..7406f30cda 100644
--- a/src/libretro/libretro-common/samples/core_options/README.md
+++ b/src/libretro/libretro-common/samples/core_options/README.md
@@ -51,3 +51,9 @@ if (strcmp(key, "mycore_show_speedhacks") == 0)
 ```
 
 For any cores that require this functionality, `example_hide_option/libretro_core_options.h` should be used as a template in place of `example_default/libretro_core_options.h`
+
+## Adding core option categories
+
+Core options v2 adds a mechanism for assigning categories to options. On supported fontends, options of a particular category will be displayed in a submenu/subsection of the main core options menu. This functionality may be used to reduce visual clutter, or to effectively 'hide' advanced settings without requiring a dedicated 'toggle display' option.
+
+A template for enabling categories via the core options v2 interface is provided in `example_categories`. The usage of this code is identical to that described in the `Adding 'enhanced' core options to a core` section, with one addition: the `libretro_set_core_options()` function here includes an additional argument identifying whether the frontend has option category support (a core may wish to selectively hide or reorganise options based upon this variable).
diff --git a/src/libretro/libretro-common/samples/core_options/example_default/libretro_core_options.h b/src/libretro/libretro-common/samples/core_options/example_default/libretro_core_options.h
index 04f9cb9aba..fbb9cfcba0 100644
--- a/src/libretro/libretro-common/samples/core_options/example_default/libretro_core_options.h
+++ b/src/libretro/libretro-common/samples/core_options/example_default/libretro_core_options.h
@@ -116,6 +116,16 @@ struct retro_core_option_definition *option_defs_intl[RETRO_LANGUAGE_LAST] = {
    NULL,           /* RETRO_LANGUAGE_ARABIC */
    NULL,           /* RETRO_LANGUAGE_GREEK */
    NULL,           /* RETRO_LANGUAGE_TURKISH */
+   NULL,           /* RETRO_LANGUAGE_SLOVAK */
+   NULL,           /* RETRO_LANGUAGE_PERSIAN */
+   NULL,           /* RETRO_LANGUAGE_HEBREW */
+   NULL,           /* RETRO_LANGUAGE_ASTURIAN */
+   NULL,           /* RETRO_LANGUAGE_FINNISH */
+   NULL,           /* RETRO_LANGUAGE_INDONESIAN */
+   NULL,           /* RETRO_LANGUAGE_SWEDISH */
+   NULL,           /* RETRO_LANGUAGE_UKRAINIAN */
+   NULL,           /* RETRO_LANGUAGE_CZECH */
+
 };
 #endif
 
@@ -166,12 +176,11 @@ static INLINE void libretro_set_core_options(retro_environment_t environ_cb)
       char **values_buf                = NULL;
 
       /* Determine number of options */
-      while (true)
+      for (;;)
       {
-         if (option_defs_us[num_options].key)
-            num_options++;
-         else
+         if (!option_defs_us[num_options].key)
             break;
+         num_options++;
       }
 
       /* Allocate arrays */
@@ -198,20 +207,18 @@ static INLINE void libretro_set_core_options(retro_environment_t environ_cb)
             size_t num_values = 0;
 
             /* Determine number of values */
-            while (true)
+            for (;;)
             {
-               if (values[num_values].value)
-               {
-                  /* Check if this is the default value */
-                  if (default_value)
-                     if (strcmp(values[num_values].value, default_value) == 0)
-                        default_index = num_values;
-
-                  buf_len += strlen(values[num_values].value);
-                  num_values++;
-               }
-               else
+               if (!values[num_values].value)
                   break;
+
+               /* Check if this is the default value */
+               if (default_value)
+                  if (strcmp(values[num_values].value, default_value) == 0)
+                     default_index = num_values;
+
+               buf_len += strlen(values[num_values].value);
+               num_values++;
             }
 
             /* Build values string */
diff --git a/src/libretro/libretro-common/samples/core_options/example_default/libretro_core_options_intl.h b/src/libretro/libretro-common/samples/core_options/example_default/libretro_core_options_intl.h
index 16cbf7751d..52887882b5 100644
--- a/src/libretro/libretro-common/samples/core_options/example_default/libretro_core_options_intl.h
+++ b/src/libretro/libretro-common/samples/core_options/example_default/libretro_core_options_intl.h
@@ -73,6 +73,16 @@ extern "C" {
 
 /* RETRO_LANGUAGE_TURKISH */
 
+/* RETRO_LANGUAGE_SLOVAK */
+
+/* RETRO_LANGUAGE_PERSIAN */
+
+/* RETRO_LANGUAGE_HEBREW */
+
+/* RETRO_LANGUAGE_ASTURIAN */
+
+/* RETRO_LANGUAGE_FINNISH */
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/libretro/libretro-common/samples/core_options/example_hide_option/libretro_core_options.h b/src/libretro/libretro-common/samples/core_options/example_hide_option/libretro_core_options.h
index f75a7ec12b..df7afdd7e1 100644
--- a/src/libretro/libretro-common/samples/core_options/example_hide_option/libretro_core_options.h
+++ b/src/libretro/libretro-common/samples/core_options/example_hide_option/libretro_core_options.h
@@ -131,6 +131,15 @@ struct retro_core_option_definition *option_defs_intl[RETRO_LANGUAGE_LAST] = {
    NULL,           /* RETRO_LANGUAGE_ARABIC */
    NULL,           /* RETRO_LANGUAGE_GREEK */
    NULL,           /* RETRO_LANGUAGE_TURKISH */
+   NULL,           /* RETRO_LANGUAGE_SLOVAK */
+   NULL,           /* RETRO_LANGUAGE_PERSIAN */
+   NULL,           /* RETRO_LANGUAGE_HEBREW */
+   NULL,           /* RETRO_LANGUAGE_ASTURIAN */
+   NULL,           /* RETRO_LANGUAGE_FINNISH */
+   NULL,           /* RETRO_LANGUAGE_INDONESIAN */
+   NULL,           /* RETRO_LANGUAGE_SWEDISH */
+   NULL,           /* RETRO_LANGUAGE_UKRAINIAN */
+   NULL,           /* RETRO_LANGUAGE_CZECH */
 };
 #endif
 
@@ -187,12 +196,11 @@ static INLINE void libretro_set_core_options(retro_environment_t environ_cb)
        *   but we'll allocate space for all of them. The difference
        *   in resource usage is negligible, and this allows us to
        *   keep the code 'cleaner' */
-      while (true)
+      for (;;)
       {
-         if (option_defs_us[num_options].key)
-            num_options++;
-         else
+         if (!option_defs_us[num_options].key)
             break;
+         num_options++;
       }
 
       /* Allocate arrays */
@@ -224,20 +232,18 @@ static INLINE void libretro_set_core_options(retro_environment_t environ_cb)
             size_t num_values = 0;
 
             /* Determine number of values */
-            while (true)
+            for (;;)
             {
-               if (values[num_values].value)
-               {
-                  /* Check if this is the default value */
-                  if (default_value)
-                     if (strcmp(values[num_values].value, default_value) == 0)
-                        default_index = num_values;
-
-                  buf_len += strlen(values[num_values].value);
-                  num_values++;
-               }
-               else
+               if (!values[num_values].value)
                   break;
+
+               /* Check if this is the default value */
+               if (default_value)
+                  if (strcmp(values[num_values].value, default_value) == 0)
+                     default_index = num_values;
+
+               buf_len += strlen(values[num_values].value);
+               num_values++;
             }
 
             /* Build values string */
diff --git a/src/libretro/libretro-common/samples/core_options/example_hide_option/libretro_core_options_intl.h b/src/libretro/libretro-common/samples/core_options/example_hide_option/libretro_core_options_intl.h
index 16cbf7751d..52887882b5 100644
--- a/src/libretro/libretro-common/samples/core_options/example_hide_option/libretro_core_options_intl.h
+++ b/src/libretro/libretro-common/samples/core_options/example_hide_option/libretro_core_options_intl.h
@@ -73,6 +73,16 @@ extern "C" {
 
 /* RETRO_LANGUAGE_TURKISH */
 
+/* RETRO_LANGUAGE_SLOVAK */
+
+/* RETRO_LANGUAGE_PERSIAN */
+
+/* RETRO_LANGUAGE_HEBREW */
+
+/* RETRO_LANGUAGE_ASTURIAN */
+
+/* RETRO_LANGUAGE_FINNISH */
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/libretro/libretro-common/samples/core_options/example_translation/libretro_core_options.h b/src/libretro/libretro-common/samples/core_options/example_translation/libretro_core_options.h
index d5cd4aa614..7d583cb8c8 100644
--- a/src/libretro/libretro-common/samples/core_options/example_translation/libretro_core_options.h
+++ b/src/libretro/libretro-common/samples/core_options/example_translation/libretro_core_options.h
@@ -116,6 +116,15 @@ struct retro_core_option_definition *option_defs_intl[RETRO_LANGUAGE_LAST] = {
    NULL,           /* RETRO_LANGUAGE_ARABIC */
    NULL,           /* RETRO_LANGUAGE_GREEK */
    NULL,           /* RETRO_LANGUAGE_TURKISH */
+   NULL,           /* RETRO_LANGUAGE_SLOVAK */
+   NULL,           /* RETRO_LANGUAGE_PERSIAN */
+   NULL,           /* RETRO_LANGUAGE_HEBREW */
+   NULL,           /* RETRO_LANGUAGE_ASTURIAN */
+   NULL,           /* RETRO_LANGUAGE_FINNISH */
+   NULL,           /* RETRO_LANGUAGE_INDONESIAN */
+   NULL,           /* RETRO_LANGUAGE_SWEDISH */
+   NULL,           /* RETRO_LANGUAGE_UKRAINIAN */
+   NULL,           /* RETRO_LANGUAGE_CZECH */
 };
 #endif
 
@@ -166,12 +175,11 @@ static INLINE void libretro_set_core_options(retro_environment_t environ_cb)
       char **values_buf                = NULL;
 
       /* Determine number of options */
-      while (true)
+      for (;;)
       {
-         if (option_defs_us[num_options].key)
-            num_options++;
-         else
+         if (!option_defs_us[num_options].key)
             break;
+         num_options++;
       }
 
       /* Allocate arrays */
@@ -198,20 +206,18 @@ static INLINE void libretro_set_core_options(retro_environment_t environ_cb)
             size_t num_values = 0;
 
             /* Determine number of values */
-            while (true)
+            for (;;)
             {
-               if (values[num_values].value)
-               {
-                  /* Check if this is the default value */
-                  if (default_value)
-                     if (strcmp(values[num_values].value, default_value) == 0)
-                        default_index = num_values;
-
-                  buf_len += strlen(values[num_values].value);
-                  num_values++;
-               }
-               else
+               if (!values[num_values].value)
                   break;
+
+               /* Check if this is the default value */
+               if (default_value)
+                  if (strcmp(values[num_values].value, default_value) == 0)
+                     default_index = num_values;
+
+               buf_len += strlen(values[num_values].value);
+               num_values++;
             }
 
             /* Build values string */
diff --git a/src/libretro/libretro-common/samples/core_options/example_translation/libretro_core_options_intl.h b/src/libretro/libretro-common/samples/core_options/example_translation/libretro_core_options_intl.h
index cd5cbb969d..521c8f4798 100644
--- a/src/libretro/libretro-common/samples/core_options/example_translation/libretro_core_options_intl.h
+++ b/src/libretro/libretro-common/samples/core_options/example_translation/libretro_core_options_intl.h
@@ -108,6 +108,16 @@ struct retro_core_option_definition option_defs_fr[] = {
 
 /* RETRO_LANGUAGE_TURKISH */
 
+/* RETRO_LANGUAGE_SLOVAK */
+
+/* RETRO_LANGUAGE_PERSIAN */
+
+/* RETRO_LANGUAGE_HEBREW */
+
+/* RETRO_LANGUAGE_ASTURIAN */
+
+/* RETRO_LANGUAGE_FINNISH */
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/src/libretro/libretro-common/samples/formats/png/Makefile b/src/libretro/libretro-common/samples/formats/png/Makefile
index 521dd0b875..1a4bbba687 100644
--- a/src/libretro/libretro-common/samples/formats/png/Makefile
+++ b/src/libretro/libretro-common/samples/formats/png/Makefile
@@ -32,8 +32,11 @@ SOURCES_C := 	\
 	$(LIBRETRO_COMM_DIR)/file/archive_file.c \
 	$(LIBRETRO_COMM_DIR)/file/archive_file_zlib.c \
 	$(LIBRETRO_COMM_DIR)/file/file_path.c \
+	$(LIBRETRO_COMM_DIR)/file/file_path_io.c \
 	$(LIBRETRO_COMM_DIR)/streams/file_stream.c \
 	$(LIBRETRO_COMM_DIR)/vfs/vfs_implementation.c \
+	$(LIBRETRO_COMM_DIR)/streams/interface_stream.c \
+	$(LIBRETRO_COMM_DIR)/streams/memory_stream.c \
 	$(LIBRETRO_COMM_DIR)/streams/trans_stream.c \
 	$(LIBRETRO_COMM_DIR)/streams/trans_stream_zlib.c \
 	$(LIBRETRO_COMM_DIR)/streams/trans_stream_pipe.c \
diff --git a/src/libretro/libretro-common/samples/formats/png/rpng_test.c b/src/libretro/libretro-common/samples/formats/png/rpng_test.c
index 25351704e6..066a7998d7 100644
--- a/src/libretro/libretro-common/samples/formats/png/rpng_test.c
+++ b/src/libretro/libretro-common/samples/formats/png/rpng_test.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2017 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (rpng_test.c).
@@ -65,7 +65,7 @@ static bool rpng_load_image_argb(const char *path, uint32_t **data,
       goto end;
    }
 
-   if (!rpng_set_buf_ptr(rpng, (uint8_t*)ptr))
+   if (!rpng_set_buf_ptr(rpng, (uint8_t*)ptr, file_len))
    {
       ret = false;
       goto end;
diff --git a/src/libretro/libretro-common/samples/net/Makefile b/src/libretro/libretro-common/samples/net/Makefile
index 4d5908b637..6c523d5e66 100644
--- a/src/libretro/libretro-common/samples/net/Makefile
+++ b/src/libretro/libretro-common/samples/net/Makefile
@@ -1,4 +1,4 @@
-TARGETS  = http_test net_ifinfo
+TARGETS  = http_test http_parse_test net_ifinfo
 
 LIBRETRO_COMM_DIR := ../..
 
@@ -37,6 +37,19 @@ HTTP_TEST_C = \
 
 HTTP_TEST_OBJS := $(HTTP_TEST_C:.c=.o)
 
+HTTP_PARSE_TEST_C = \
+				  $(LIBRETRO_COMM_DIR)/net/net_http.c \
+				  $(LIBRETRO_COMM_DIR)/net/net_http_parse.c \
+				  $(LIBRETRO_COMM_DIR)/net/net_compat.c \
+				  $(LIBRETRO_COMM_DIR)/net/net_socket.c \
+				  $(LIBRETRO_COMM_DIR)/compat/compat_strl.c \
+				  $(LIBRETRO_COMM_DIR)/compat/compat_strcasestr.c \
+				  $(LIBRETRO_COMM_DIR)/encodings/encoding_utf.c \
+				  $(LIBRETRO_COMM_DIR)/string/stdstring.c \
+				  net_http_parse_test.c
+
+HTTP_PARSE_TEST_OBJS := $(HTTP_PARSE_TEST_C:.c=.o)
+
 NET_IFINFO_C = \
 					$(LIBRETRO_COMM_DIR)/net/net_ifinfo.c \
 					net_ifinfo_test.c
@@ -54,6 +67,9 @@ all: $(TARGETS)
 %.o: %.c
 	$(CC) $(INCFLAGS) $< -c $(CFLAGS) -o $@
 
+http_parse_test: $(HTTP_PARSE_TEST_OBJS)
+	$(CC) $(INCFLAGS) $(HTTP_PARSE_TEST_OBJS) $(CFLAGS) -o $@
+
 http_test: $(HTTP_TEST_OBJS)
 	$(CC) $(INCFLAGS) $(HTTP_TEST_OBJS) $(CFLAGS) -o $@
 
@@ -61,4 +77,4 @@ net_ifinfo: $(NET_IFINFO_OBJS)
 	$(CC) $(INCFLAGS) $(NET_IFINFO_OBJS) $(CFLAGS) -o $@
 
 clean:
-	rm -rf $(TARGETS) $(HTTP_TEST_OBJS) $(NET_IFINFO_OBJS)
+	rm -rf $(TARGETS) $(HTTP_TEST_OBJS) $(HTTP_PARSE_TEST_OBJS) $(NET_IFINFO_OBJS)
diff --git a/src/libretro/libretro-common/samples/net/net_http_test.c b/src/libretro/libretro-common/samples/net/net_http_test.c
index 448c6dbdde..ebd0167e42 100644
--- a/src/libretro/libretro-common/samples/net/net_http_test.c
+++ b/src/libretro/libretro-common/samples/net/net_http_test.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2017 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (net_http_test.c).
@@ -52,7 +52,5 @@ int main(void)
    net_http_delete(http1);
    net_http_delete(http3);
 
-   network_deinit();
-
    return 0;
 }
diff --git a/src/libretro/libretro-common/samples/net/net_ifinfo_test.c b/src/libretro/libretro-common/samples/net/net_ifinfo_test.c
index 63da41472f..3705209f02 100644
--- a/src/libretro/libretro-common/samples/net/net_ifinfo_test.c
+++ b/src/libretro/libretro-common/samples/net/net_ifinfo_test.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2017 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (net_ifinfo_test.c).
diff --git a/src/libretro/libretro-common/samples/net/udp-test.c b/src/libretro/libretro-common/samples/net/udp-test.c
index 9ec46d3726..3366cf55cc 100644
--- a/src/libretro/libretro-common/samples/net/udp-test.c
+++ b/src/libretro/libretro-common/samples/net/udp-test.c
@@ -23,37 +23,33 @@ void die(char *s)
 
 int main(void)
 {
-    struct sockaddr_in si_other;
-    int s, i, slen=sizeof(si_other);
-
-    if ( (s=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1)
-    {
-        die("socket");
-    }
-
-    memset((char *) &si_other, 0, sizeof(si_other));
-    si_other.sin_family = AF_INET;
-    si_other.sin_port = htons(PORT);
-
-    if (inet_aton(SERVER , &si_other.sin_addr) == 0)
-    {
-        fprintf(stderr, "inet_aton() failed\n");
-        exit(1);
-    }
-    while(1)
-    {
-
-        char message[10]="128";
-        //send the message
-        if (sendto(s, message, strlen(message) , 0 , (struct sockaddr *) &si_other, slen)==-1)
-        {
-            die("sendto()");
-        }
-        /* sleep for 1 frame (60hz) */
-        usleep(16*1000);
-
-    }
-
-    close(s);
-    return 0;
-}
\ No newline at end of file
+   struct sockaddr_in si_other;
+   int s, i, slen=sizeof(si_other);
+
+   if ( (s=socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP)) == -1)
+      die("socket");
+
+   memset((char *) &si_other, 0, sizeof(si_other));
+   si_other.sin_family = AF_INET;
+   si_other.sin_port = htons(PORT);
+
+   if (inet_aton(SERVER , &si_other.sin_addr) == 0)
+   {
+      fprintf(stderr, "inet_aton() failed\n");
+      exit(1);
+   }
+
+   for (;;)
+   {
+      char message[10]="128";
+      /* send the message */
+      if (sendto(s, message, strlen(message) , 0 , (struct sockaddr *) &si_other, slen)==-1)
+         die("sendto()");
+
+      /* sleep for 1 frame (60hz) */
+      usleep(16*1000);
+   }
+
+   close(s);
+   return 0;
+}
diff --git a/src/libretro/libretro-common/samples/utils/Makefile b/src/libretro/libretro-common/samples/utils/Makefile
index d0ced5fb5c..f69bc92fd6 100644
--- a/src/libretro/libretro-common/samples/utils/Makefile
+++ b/src/libretro/libretro-common/samples/utils/Makefile
@@ -52,6 +52,7 @@ else
 EXE_EXT = .exe
 endif
 
+PWD_DIR := .
 LIBRETRO_COMM_DIR := ../..
 CORE_DIR := $(LIBRETRO_COMM_DIR)/utils
 
@@ -67,23 +68,33 @@ ASMFLAGS := -INEON/asm
 asflags += -mfpu=neon
 endif
 
-OBJS += $(CORE_DIR)/djb2.o \
-		  $(CORE_DIR)/md5.o \
-		  $(CORE_DIR)/sha1.o \
-		  $(CORE_DIR)/sha1_main.o \
-		  $(CORE_DIR)/crc32.o
+DJB2_OBJS := $(CORE_DIR)/djb2.o
+
+MD5_OBJS  := $(CORE_DIR)/md5.o \
+				 $(PWD_DIR)/md5_test.o
+
+SHA1_OBJS := $(CORE_DIR)/sha1.o \
+				 $(PWD_DIR)/sha1_main.o
+
+CRC32_OBJS := $(PWD_DIR)/crc32.o \
+				  $(LIBRETRO_COMM_DIR)/compat/fopen_utf8.o \
+				  $(LIBRETRO_COMM_DIR)/compat/compat_strl.o \
+				  $(LIBRETRO_COMM_DIR)/encodings/encoding_utf.o \
+				  $(LIBRETRO_COMM_DIR)/streams/file_stream.o \
+				  $(LIBRETRO_COMM_DIR)/vfs/vfs_implementation.o \
+			     $(LIBRETRO_COMM_DIR)/encodings/encoding_crc32.o
 
 UTILS := djb2$(EXE_EXT) md5$(EXE_EXT) sha1$(EXE_EXT) crc32$(EXE_EXT)
 
 all: $(UTILS)
 
-djb2$(EXE_EXT): $(CORE_DIR)/djb2.o
+djb2$(EXE_EXT): $(DJB2_OBJS)
 
-md5$(EXE_EXT): $(CORE_DIR)/md5.o
+md5$(EXE_EXT): $(MD5_OBJS)
 
-sha1$(EXE_EXT): $(CORE_DIR)/sha1.o $(CORE_DIR)/sha1_main.o
+sha1$(EXE_EXT): $(SHA1_OBJS)
 
-crc32$(EXE_EXT): $(CORE_DIR)/crc32.o $(CORE_DIR)/../encodings/encoding_crc32.o
+crc32$(EXE_EXT): $(CRC32_OBJS)
 
 %.o: %.S
 	$(CC) -c -o $@ $(asflags) $(LDFLAGS)  $(ASMFLAGS)  $<
diff --git a/src/libretro/libretro-common/streams/chd_stream.c b/src/libretro/libretro-common/streams/chd_stream.c
index 8a7f742453..daa718fbca 100644
--- a/src/libretro/libretro-common/streams/chd_stream.c
+++ b/src/libretro/libretro-common/streams/chd_stream.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (chd_stream.c).
@@ -29,6 +29,7 @@
 #include <streams/chd_stream.h>
 #include <retro_endianness.h>
 #include <libchdr/chd.h>
+#include <string/stdstring.h>
 
 #define SECTOR_SIZE 2352
 #define SUBCODE_SIZE 96
@@ -37,16 +38,8 @@
 struct chdstream
 {
    chd_file *chd;
-   /* Should we swap bytes? */
-   bool swab;
-   /* Size of frame taken from each hunk */
-   uint32_t frame_size;
-   /* Offset of data within frame */
-   uint32_t frame_offset;
-   /* Number of frames per hunk */
-   uint32_t frames_per_hunk;
-   /* First frame of track in chd */
-   uint32_t track_frame;
+   /* Loaded hunk */
+   uint8_t *hunkmem;
    /* Byte offset where track data starts (after pregap) */
    size_t track_start;
    /* Byte offset where track data ends */
@@ -55,15 +48,20 @@ struct chdstream
    size_t offset;
    /* Loaded hunk number */
    int32_t hunknum;
-   /* Loaded hunk */
-   uint8_t *hunkmem;
+   /* Size of frame taken from each hunk */
+   uint32_t frame_size;
+   /* Offset of data within frame */
+   uint32_t frame_offset;
+   /* Number of frames per hunk */
+   uint32_t frames_per_hunk;
+   /* First frame of track in chd */
+   uint32_t track_frame;
+   /* Should we swap bytes? */
+   bool swab;
 };
 
-typedef struct metadata {
-   char type[64];
-   char subtype[32];
-   char pgtype[32];
-   char pgsub[32];
+typedef struct metadata
+{
    uint32_t frame_offset;
    uint32_t frames;
    uint32_t pad;
@@ -71,6 +69,10 @@ typedef struct metadata {
    uint32_t pregap;
    uint32_t postgap;
    uint32_t track;
+   char type[64];
+   char subtype[32];
+   char pgtype[32];
+   char pgsub[32];
 } metadata_t;
 
 static uint32_t padding_frames(uint32_t frames)
@@ -85,6 +87,8 @@ chdstream_get_meta(chd_file *chd, int idx, metadata_t *md)
    uint32_t meta_size = 0;
    chd_error err;
 
+   meta[0] = '\0';
+
    memset(md, 0, sizeof(*md));
 
    err = chd_get_metadata(chd, CDROM_TRACK_METADATA2_TAG, idx, meta,
@@ -138,7 +142,7 @@ chdstream_find_track_number(chd_file *fd, int32_t track, metadata_t *meta)
       if (!chdstream_get_meta(fd, i, meta))
          return false;
 
-      if (track == meta->track)
+      if (track == (int)meta->track)
       {
          meta->frame_offset = frame_offset;
          return true;
@@ -161,12 +165,12 @@ chdstream_find_special_track(chd_file *fd, int32_t track, metadata_t *meta)
       if (!chdstream_find_track_number(fd, i, &iter))
       {
          if (track == CHDSTREAM_TRACK_LAST && i > 1)
-         {
-            *meta = iter;
-            return true;
-         }
-         else if (track == CHDSTREAM_TRACK_PRIMARY && largest_track != 0)
+            return chdstream_find_track_number(fd, i - 1, meta);
+
+         if (track == CHDSTREAM_TRACK_PRIMARY && largest_track != 0)
             return chdstream_find_track_number(fd, largest_track, meta);
+
+         return false;
       }
 
       switch (track)
@@ -181,7 +185,7 @@ chdstream_find_special_track(chd_file *fd, int32_t track, metadata_t *meta)
          case CHDSTREAM_TRACK_PRIMARY:
             if (strcmp(iter.type, "AUDIO") && iter.frames > largest_size)
             {
-               largest_size = iter.frames;
+               largest_size  = iter.frames;
                largest_track = iter.track;
             }
             break;
@@ -202,63 +206,64 @@ chdstream_find_track(chd_file *fd, int32_t track, metadata_t *meta)
 chdstream_t *chdstream_open(const char *path, int32_t track)
 {
    metadata_t meta;
-   uint32_t pregap      = 0;
-   const chd_header *hd = NULL;
-   chdstream_t *stream  = NULL;
-   chd_file *chd        = NULL;
-   chd_error err        = chd_open(path, CHD_OPEN_READ, NULL, &chd);
+   uint32_t pregap         = 0;
+   uint8_t *hunkmem        = NULL;
+   const chd_header *hd    = NULL;
+   chdstream_t *stream     = NULL;
+   chd_file *chd           = NULL;
+   chd_error err           = chd_open(path, CHD_OPEN_READ, NULL, &chd);
 
    if (err != CHDERR_NONE)
-      goto error;
+      return NULL;
 
    if (!chdstream_find_track(chd, track, &meta))
       goto error;
 
-   stream = (chdstream_t*)calloc(1, sizeof(*stream));
+   stream                  = (chdstream_t*)malloc(sizeof(*stream));
    if (!stream)
       goto error;
 
-   hd              = chd_get_header(chd);
-   stream->hunkmem = (uint8_t*)malloc(hd->hunkbytes);
-   if (!stream->hunkmem)
+   stream->chd             = NULL;
+   stream->swab            = false;
+   stream->frame_size      = 0;
+   stream->frame_offset    = 0;
+   stream->frames_per_hunk = 0;
+   stream->track_frame     = 0;
+   stream->track_start     = 0;
+   stream->track_end       = 0;
+   stream->offset          = 0;
+   stream->hunkmem         = NULL;
+   stream->hunknum         = -1;
+
+   hd                      = chd_get_header(chd);
+   hunkmem                 = (uint8_t*)malloc(hd->hunkbytes);
+   if (!hunkmem)
       goto error;
 
-   if (!strcmp(meta.type, "MODE1_RAW"))
-   {
-      stream->frame_size = SECTOR_SIZE;
-      stream->frame_offset = 0;
-   }
-   else if (!strcmp(meta.type, "MODE2_RAW"))
-   {
-      stream->frame_size = SECTOR_SIZE;
-      stream->frame_offset = 0;
-   }
-   else if (!strcmp(meta.type, "AUDIO"))
+   stream->hunkmem         = hunkmem;
+
+   if (string_is_equal(meta.type, "MODE1_RAW"))
+      stream->frame_size   = SECTOR_SIZE;
+   else if (string_is_equal(meta.type, "MODE2_RAW"))
+      stream->frame_size   = SECTOR_SIZE;
+   else if (string_is_equal(meta.type, "AUDIO"))
    {
-      stream->frame_size = SECTOR_SIZE;
-      stream->frame_offset = 0;
-      stream->swab = true;
+      stream->frame_size   = SECTOR_SIZE;
+      stream->swab         = true;
    }
    else
-   {
-      stream->frame_size = hd->unitbytes;
-      stream->frame_offset = 0;
-   }
+      stream->frame_size   = hd->unitbytes;
 
    /* Only include pregap data if it was in the track file */
-   if (!strcmp(meta.type, meta.pgtype))
-      pregap = meta.pregap;
-   else
-      pregap = 0;
+   if (meta.pgtype[0] != 'V')
+      pregap               = meta.pregap;
 
    stream->chd             = chd;
    stream->frames_per_hunk = hd->hunkbytes / hd->unitbytes;
    stream->track_frame     = meta.frame_offset;
-   stream->track_start     = (size_t) pregap * stream->frame_size;
-   stream->track_end       = stream->track_start +
-      (size_t) meta.frames * stream->frame_size;
-   stream->offset          = 0;
-   stream->hunknum         = -1;
+   stream->track_start     = (size_t)pregap * stream->frame_size;
+   stream->track_end       = stream->track_start + 
+                             (size_t)meta.frames * stream->frame_size;
 
    return stream;
 
@@ -274,35 +279,32 @@ chdstream_t *chdstream_open(const char *path, int32_t track)
 
 void chdstream_close(chdstream_t *stream)
 {
-   if (stream)
-   {
-      if (stream->hunkmem)
-         free(stream->hunkmem);
-      if (stream->chd)
-         chd_close(stream->chd);
-      free(stream);
-   }
+   if (!stream)
+      return;
+
+   if (stream->hunkmem)
+      free(stream->hunkmem);
+   if (stream->chd)
+      chd_close(stream->chd);
+   free(stream);
 }
 
 static bool
 chdstream_load_hunk(chdstream_t *stream, uint32_t hunknum)
 {
-   chd_error err;
    uint16_t *array;
-   uint32_t i;
-   uint32_t count;
 
-   if (hunknum == stream->hunknum)
+   if ((int)hunknum == stream->hunknum)
       return true;
 
-   err = chd_read(stream->chd, hunknum, stream->hunkmem);
-   if (err != CHDERR_NONE)
+   if (chd_read(stream->chd, hunknum, stream->hunkmem) != CHDERR_NONE)
       return false;
 
    if (stream->swab)
    {
-      count = chd_get_header(stream->chd)->hunkbytes / 2;
-      array = (uint16_t*) stream->hunkmem;
+      uint32_t i;
+      uint32_t count = chd_get_header(stream->chd)->hunkbytes / 2;
+      array          = (uint16_t*)stream->hunkmem;
       for (i = 0; i < count; ++i)
          array[i] = SWAP16(array[i]);
    }
@@ -314,23 +316,20 @@ chdstream_load_hunk(chdstream_t *stream, uint32_t hunknum)
 ssize_t chdstream_read(chdstream_t *stream, void *data, size_t bytes)
 {
    size_t end;
-   uint32_t frame_offset;
-   uint32_t hunk_offset;
-   uint32_t chd_frame;
-   uint32_t hunk;
-   uint32_t amount;
    size_t data_offset   = 0;
    const chd_header *hd = chd_get_header(stream->chd);
    uint8_t         *out = (uint8_t*)data;
 
    if (stream->track_end - stream->offset < bytes)
-      bytes = stream->track_end - stream->offset;
+      bytes             = stream->track_end - stream->offset;
+
+   end                  = stream->offset + bytes;
 
-   end = stream->offset + bytes;
    while (stream->offset < end)
    {
-      frame_offset = stream->offset % stream->frame_size;
-      amount = stream->frame_size - frame_offset;
+      uint32_t frame_offset = stream->offset % stream->frame_size;
+      uint32_t amount       = stream->frame_size - frame_offset;
+
       if (amount > end - stream->offset)
          amount = (uint32_t)(end - stream->offset);
 
@@ -339,15 +338,15 @@ ssize_t chdstream_read(chdstream_t *stream, void *data, size_t bytes)
          memset(out + data_offset, 0, amount);
       else
       {
-         chd_frame = (uint32_t)(stream->track_frame +
+         uint32_t chd_frame   = (uint32_t)(stream->track_frame +
             (stream->offset - stream->track_start) / stream->frame_size);
-         hunk = chd_frame / stream->frames_per_hunk;
-         hunk_offset = (chd_frame % stream->frames_per_hunk) * hd->unitbytes;
+         uint32_t hunk        = chd_frame / stream->frames_per_hunk;
+         uint32_t hunk_offset = (chd_frame % stream->frames_per_hunk) 
+            * hd->unitbytes;
 
          if (!chdstream_load_hunk(stream, hunk))
-         {
             return -1;
-         }
+
          memcpy(out + data_offset,
                 stream->hunkmem + frame_offset
                 + hunk_offset + stream->frame_offset, amount);
@@ -380,7 +379,7 @@ char *chdstream_gets(chdstream_t *stream, char *buffer, size_t len)
       buffer[offset++] = c;
 
    if (offset < len)
-      buffer[offset] = '\0';
+      buffer[offset]   = '\0';
 
    return buffer;
 }
@@ -417,7 +416,7 @@ int64_t chdstream_seek(chdstream_t *stream, int64_t offset, int whence)
    if (new_offset < 0)
       return -1;
 
-   if (new_offset > stream->track_end)
+   if ((size_t)new_offset > stream->track_end)
       new_offset = stream->track_end;
 
    stream->offset = new_offset;
@@ -426,20 +425,44 @@ int64_t chdstream_seek(chdstream_t *stream, int64_t offset, int whence)
 
 ssize_t chdstream_get_size(chdstream_t *stream)
 {
-   return stream->track_end;
+   return stream->track_end - stream->track_start;
 }
 
-uint32_t chdstream_get_pregap(chdstream_t *stream)
+uint32_t chdstream_get_track_start(chdstream_t *stream)
 {
+   uint32_t i;
    metadata_t meta;
    uint32_t frame_offset = 0;
+
+   for (i = 0; chdstream_get_meta(stream->chd, i, &meta); ++i)
+   {
+      if (stream->track_frame == frame_offset)
+         return meta.pregap * stream->frame_size;
+
+      frame_offset += meta.frames + meta.extra;
+   }
+
+   return 0;
+}
+
+uint32_t chdstream_get_frame_size(chdstream_t *stream)
+{
+   return stream->frame_size;
+}
+
+uint32_t chdstream_get_first_track_sector(chdstream_t* stream)
+{
    uint32_t i;
+   metadata_t meta;
+   uint32_t frame_offset = 0;
+   uint32_t sector_offset = 0;
 
    for (i = 0; chdstream_get_meta(stream->chd, i, &meta); ++i)
    {
       if (stream->track_frame == frame_offset)
-         return meta.pregap;
+         return sector_offset;
 
+      sector_offset += meta.frames;
       frame_offset += meta.frames + meta.extra;
    }
 
diff --git a/src/libretro/libretro-common/streams/file_stream.c b/src/libretro/libretro-common/streams/file_stream.c
index e3e4590752..befb31c701 100644
--- a/src/libretro/libretro-common/streams/file_stream.c
+++ b/src/libretro/libretro-common/streams/file_stream.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (file_stream.c).
@@ -25,17 +25,27 @@
 #include <string.h>
 #include <stdarg.h>
 #include <ctype.h>
-#include <errno.h>
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
 
+#ifdef _MSC_VER
+#include <compat/msvc.h>
+#endif
+
+#include <string/stdstring.h>
 #include <streams/file_stream.h>
 #define VFS_FRONTEND
 #include <vfs/vfs_implementation.h>
 
-static const int64_t vfs_error_return_value      = -1;
+#define VFS_ERROR_RETURN_VALUE -1
+
+struct RFILE
+{
+   struct retro_vfs_file_handle *hfile;
+	bool error_flag;
+};
 
 static retro_vfs_get_path_t filestream_get_path_cb = NULL;
 static retro_vfs_open_t filestream_open_cb         = NULL;
@@ -50,18 +60,12 @@ static retro_vfs_flush_t filestream_flush_cb       = NULL;
 static retro_vfs_remove_t filestream_remove_cb     = NULL;
 static retro_vfs_rename_t filestream_rename_cb     = NULL;
 
-struct RFILE
-{
-   struct retro_vfs_file_handle *hfile;
-	bool error_flag;
-	bool eof_flag;
-};
-
 /* VFS Initialization */
 
 void filestream_vfs_init(const struct retro_vfs_interface_info* vfs_info)
 {
-   const struct retro_vfs_interface* vfs_iface;
+   const struct retro_vfs_interface *
+      vfs_iface           = vfs_info->iface;
 
    filestream_get_path_cb = NULL;
    filestream_open_cb     = NULL;
@@ -76,9 +80,9 @@ void filestream_vfs_init(const struct retro_vfs_interface_info* vfs_info)
    filestream_remove_cb   = NULL;
    filestream_rename_cb   = NULL;
 
-   vfs_iface              = vfs_info->iface;
-
-   if (vfs_info->required_interface_version < FILESTREAM_REQUIRED_VFS_VERSION
+   if (
+             (vfs_info->required_interface_version < 
+             FILESTREAM_REQUIRED_VFS_VERSION)
          || !vfs_iface)
       return;
 
@@ -99,19 +103,20 @@ void filestream_vfs_init(const struct retro_vfs_interface_info* vfs_info)
 /* Callback wrappers */
 bool filestream_exists(const char *path)
 {
-   RFILE *dummy              = NULL;
+   RFILE *dummy           = NULL;
 
    if (!path || !*path)
       return false;
-
-   dummy = filestream_open(path,
+   if (!(dummy = filestream_open(
+         path,
          RETRO_VFS_FILE_ACCESS_READ,
-         RETRO_VFS_FILE_ACCESS_HINT_NONE);
-
-   if (!dummy)
+         RETRO_VFS_FILE_ACCESS_HINT_NONE)))
       return false;
 
-   filestream_close(dummy);
+   if (filestream_close(dummy) != 0)
+      free(dummy);
+
+   dummy = NULL;
    return true;
 }
 
@@ -119,12 +124,13 @@ int64_t filestream_get_size(RFILE *stream)
 {
    int64_t output;
 
-   if (filestream_size_cb != NULL)
+   if (filestream_size_cb)
       output = filestream_size_cb(stream->hfile);
    else
-      output = retro_vfs_file_size_impl((libretro_vfs_implementation_file*)stream->hfile);
+      output = retro_vfs_file_size_impl(
+            (libretro_vfs_implementation_file*)stream->hfile);
 
-   if (output == vfs_error_return_value)
+   if (output == VFS_ERROR_RETURN_VALUE)
       stream->error_flag = true;
 
    return output;
@@ -134,12 +140,13 @@ int64_t filestream_truncate(RFILE *stream, int64_t length)
 {
    int64_t output;
 
-   if (filestream_truncate_cb != NULL)
+   if (filestream_truncate_cb)
       output = filestream_truncate_cb(stream->hfile, length);
    else
-      output = retro_vfs_file_truncate_impl((libretro_vfs_implementation_file*)stream->hfile, length);
+      output = retro_vfs_file_truncate_impl(
+            (libretro_vfs_implementation_file*)stream->hfile, length);
 
-   if (output == vfs_error_return_value)
+   if (output == VFS_ERROR_RETURN_VALUE)
       stream->error_flag = true;
 
    return output;
@@ -152,14 +159,14 @@ int64_t filestream_truncate(RFILE *stream, int64_t length)
  * @hints              :
  *
  * Opens a file for reading or writing, depending on the requested mode.
- * Returns a pointer to an RFILE if opened successfully, otherwise NULL.
+ * @return A pointer to an RFILE if opened successfully, otherwise NULL.
  **/
 RFILE* filestream_open(const char *path, unsigned mode, unsigned hints)
 {
    struct retro_vfs_file_handle  *fp = NULL;
    RFILE* output                     = NULL;
 
-   if (filestream_open_cb != NULL)
+   if (filestream_open_cb)
       fp = (struct retro_vfs_file_handle*)
          filestream_open_cb(path, mode, hints);
    else
@@ -171,7 +178,6 @@ RFILE* filestream_open(const char *path, unsigned mode, unsigned hints)
 
    output             = (RFILE*)malloc(sizeof(RFILE));
    output->error_flag = false;
-   output->eof_flag   = false;
    output->hfile      = fp;
    return output;
 }
@@ -203,22 +209,19 @@ char* filestream_gets(RFILE *stream, char *s, size_t len)
 int filestream_getc(RFILE *stream)
 {
    char c = 0;
-   if (!stream)
-      return EOF;
-   if (filestream_read(stream, &c, 1) == 1)
+   if (stream && filestream_read(stream, &c, 1) == 1)
       return (int)(unsigned char)c;
    return EOF;
 }
 
-int filestream_scanf(RFILE *stream, const char* format, ...)
+int filestream_vscanf(RFILE *stream, const char* format, va_list *args)
 {
    char buf[4096];
    char subfmt[64];
-   va_list args;
-
-   const char * bufiter = buf;
-   int64_t startpos     = filestream_tell(stream);
+   va_list args_copy;
+   const char *bufiter  = buf;
    int        ret       = 0;
+   int64_t startpos     = filestream_tell(stream);
    int64_t maxlen       = filestream_read(stream, buf, sizeof(buf)-1);
 
    if (maxlen <= 0)
@@ -226,14 +229,22 @@ int filestream_scanf(RFILE *stream, const char* format, ...)
 
    buf[maxlen] = '\0';
 
-   va_start(args, format);
+   /* Have to copy the input va_list here
+    * > Calling va_arg() on 'args' directly would
+    *   cause the va_list to have an indeterminate value
+    *   in the function calling filestream_vscanf(),
+    *   leading to unexpected behaviour */
+#ifdef __va_copy
+   __va_copy(args_copy, *args);
+#else
+   va_copy(args_copy, *args);
+#endif
 
    while (*format)
    {
       if (*format == '%')
       {
          int sublen;
-
          char* subfmtiter = subfmt;
          bool asterisk    = false;
 
@@ -243,19 +254,25 @@ int filestream_scanf(RFILE *stream, const char* format, ...)
 
          if (*format == '*')
          {
-            asterisk = true;
+            asterisk      = true;
             *subfmtiter++ = *format++;
          }
 
-         while (isdigit(*format)) *subfmtiter++ = *format++; /* width */
+         while (ISDIGIT((unsigned char)*format))
+            *subfmtiter++ = *format++; /* width */
 
          /* length */
          if (*format == 'h' || *format == 'l')
          {
-            if (format[1] == format[0]) *subfmtiter++ = *format++;
-            *subfmtiter++ = *format++;
+            if (format[1] == format[0])
+               *subfmtiter++ = *format++;
+            *subfmtiter++    = *format++;
          }
-         else if (*format == 'j' || *format == 'z' || *format == 't' || *format == 'L')
+         else if (
+               *format == 'j' || 
+               *format == 'z' || 
+               *format == 't' || 
+               *format == 'L')
          {
             *subfmtiter++ = *format++;
          }
@@ -263,31 +280,44 @@ int filestream_scanf(RFILE *stream, const char* format, ...)
          /* specifier - always a single character (except ]) */
          if (*format == '[')
          {
-            while (*format != ']') *subfmtiter++ = *format++;
-            *subfmtiter++ = *format++;
+            while (*format != ']')
+               *subfmtiter++ = *format++;
+            *subfmtiter++    = *format++;
          }
-         else *subfmtiter++ = *format++;
+         else
+            *subfmtiter++    = *format++;
+
+         *subfmtiter++       = '%';
+         *subfmtiter++       = 'n';
+         *subfmtiter++       = '\0';
 
-         *subfmtiter++ = '%';
-         *subfmtiter++ = 'n';
-         *subfmtiter++ = '\0';
+         if (sizeof(void*) != sizeof(long*))
+            abort(); /* all pointers must have the same size */
 
-         if (sizeof(void*) != sizeof(long*)) abort(); /* all pointers must have the same size */
          if (asterisk)
          {
-            if (sscanf(bufiter, subfmt, &sublen) != 0) break;
+            int v = sscanf(bufiter, subfmt, &sublen);
+            if (v == EOF)
+               return EOF;
+            if (v != 0)
+               break;
          }
          else
          {
-            if (sscanf(bufiter, subfmt, va_arg(args, void*), &sublen) != 1) break;
+            int v = sscanf(bufiter, subfmt, va_arg(args_copy, void*), &sublen);
+            if (v == EOF)
+               return EOF;
+            if (v != 1)
+               break;
          }
 
          ret++;
          bufiter += sublen;
       }
-      else if (isspace(*format))
+      else if (isspace((unsigned char)*format))
       {
-         while (isspace(*bufiter)) bufiter++;
+         while (isspace((unsigned char)*bufiter))
+            bufiter++;
          format++;
       }
       else
@@ -299,43 +329,56 @@ int filestream_scanf(RFILE *stream, const char* format, ...)
       }
    }
 
-   va_end(args);
-   filestream_seek(stream, startpos+(bufiter-buf), RETRO_VFS_SEEK_POSITION_START);
+   va_end(args_copy);
+   filestream_seek(stream, startpos + (bufiter - buf),
+         RETRO_VFS_SEEK_POSITION_START);
 
    return ret;
 }
 
+int filestream_scanf(RFILE *stream, const char* format, ...)
+{
+   int result;
+   va_list vl;
+   va_start(vl, format);
+   result = filestream_vscanf(stream, format, &vl);
+   va_end(vl);
+   return result;
+}
+
 int64_t filestream_seek(RFILE *stream, int64_t offset, int seek_position)
 {
    int64_t output;
 
-   if (filestream_seek_cb != NULL)
+   if (filestream_seek_cb)
       output = filestream_seek_cb(stream->hfile, offset, seek_position);
    else
-      output = retro_vfs_file_seek_impl((libretro_vfs_implementation_file*)stream->hfile, offset, seek_position);
+      output = retro_vfs_file_seek_impl(
+            (libretro_vfs_implementation_file*)stream->hfile,
+            offset, seek_position);
 
-   if (output == vfs_error_return_value)
+   if (output == VFS_ERROR_RETURN_VALUE)
       stream->error_flag = true;
-   stream->eof_flag = false;
 
    return output;
 }
 
 int filestream_eof(RFILE *stream)
 {
-   return stream->eof_flag;
+   return filestream_tell(stream) == filestream_get_size(stream) ? EOF : 0;
 }
 
 int64_t filestream_tell(RFILE *stream)
 {
    int64_t output;
 
-   if (filestream_size_cb != NULL)
+   if (filestream_size_cb)
       output = filestream_tell_cb(stream->hfile);
    else
-      output = retro_vfs_file_tell_impl((libretro_vfs_implementation_file*)stream->hfile);
+      output = retro_vfs_file_tell_impl(
+            (libretro_vfs_implementation_file*)stream->hfile);
 
-   if (output == vfs_error_return_value)
+   if (output == VFS_ERROR_RETURN_VALUE)
       stream->error_flag = true;
 
    return output;
@@ -347,23 +390,20 @@ void filestream_rewind(RFILE *stream)
       return;
    filestream_seek(stream, 0L, RETRO_VFS_SEEK_POSITION_START);
    stream->error_flag = false;
-   stream->eof_flag = false;
 }
 
 int64_t filestream_read(RFILE *stream, void *s, int64_t len)
 {
    int64_t output;
 
-   if (filestream_read_cb != NULL)
+   if (filestream_read_cb)
       output = filestream_read_cb(stream->hfile, s, len);
    else
       output = retro_vfs_file_read_impl(
             (libretro_vfs_implementation_file*)stream->hfile, s, len);
 
-   if (output == vfs_error_return_value)
+   if (output == VFS_ERROR_RETURN_VALUE)
       stream->error_flag = true;
-   if (output < len)
-      stream->eof_flag = true;
 
    return output;
 }
@@ -372,12 +412,13 @@ int filestream_flush(RFILE *stream)
 {
    int output;
 
-   if (filestream_flush_cb != NULL)
+   if (filestream_flush_cb)
       output = filestream_flush_cb(stream->hfile);
    else
-      output = retro_vfs_file_flush_impl((libretro_vfs_implementation_file*)stream->hfile);
+      output = retro_vfs_file_flush_impl(
+            (libretro_vfs_implementation_file*)stream->hfile);
 
-   if (output == vfs_error_return_value)
+   if (output == VFS_ERROR_RETURN_VALUE)
       stream->error_flag = true;
 
    return output;
@@ -385,7 +426,7 @@ int filestream_flush(RFILE *stream)
 
 int filestream_delete(const char *path)
 {
-   if (filestream_remove_cb != NULL)
+   if (filestream_remove_cb)
       return filestream_remove_cb(path);
 
    return retro_vfs_file_remove_impl(path);
@@ -393,7 +434,7 @@ int filestream_delete(const char *path)
 
 int filestream_rename(const char *old_path, const char *new_path)
 {
-   if (filestream_rename_cb != NULL)
+   if (filestream_rename_cb)
       return filestream_rename_cb(old_path, new_path);
 
    return retro_vfs_file_rename_impl(old_path, new_path);
@@ -401,22 +442,24 @@ int filestream_rename(const char *old_path, const char *new_path)
 
 const char* filestream_get_path(RFILE *stream)
 {
-   if (filestream_get_path_cb != NULL)
+   if (filestream_get_path_cb)
       return filestream_get_path_cb(stream->hfile);
 
-   return retro_vfs_file_get_path_impl((libretro_vfs_implementation_file*)stream->hfile);
+   return retro_vfs_file_get_path_impl(
+         (libretro_vfs_implementation_file*)stream->hfile);
 }
 
 int64_t filestream_write(RFILE *stream, const void *s, int64_t len)
 {
    int64_t output;
 
-   if (filestream_write_cb != NULL)
+   if (filestream_write_cb)
       output = filestream_write_cb(stream->hfile, s, len);
    else
-      output = retro_vfs_file_write_impl((libretro_vfs_implementation_file*)stream->hfile, s, len);
+      output = retro_vfs_file_write_impl(
+            (libretro_vfs_implementation_file*)stream->hfile, s, len);
 
-   if (output == vfs_error_return_value)
+   if (output == VFS_ERROR_RETURN_VALUE)
       stream->error_flag = true;
 
    return output;
@@ -427,13 +470,16 @@ int filestream_putc(RFILE *stream, int c)
    char c_char = (char)c;
    if (!stream)
       return EOF;
-   return filestream_write(stream, &c_char, 1)==1 ? (int)(unsigned char)c : EOF;
+   return filestream_write(stream, &c_char, 1) == 1 
+      ? (int)(unsigned char)c 
+      : EOF;
 }
 
 int filestream_vprintf(RFILE *stream, const char* format, va_list args)
 {
    static char buffer[8 * 1024];
-   int64_t num_chars = vsprintf(buffer, format, args);
+   int64_t num_chars = vsnprintf(buffer, sizeof(buffer),
+         format, args);
 
    if (num_chars < 0)
       return -1;
@@ -455,9 +501,7 @@ int filestream_printf(RFILE *stream, const char* format, ...)
 
 int filestream_error(RFILE *stream)
 {
-   if (stream && stream->error_flag)
-      return 1;
-   return 0;
+   return (stream && stream->error_flag);
 }
 
 int filestream_close(RFILE *stream)
@@ -465,10 +509,11 @@ int filestream_close(RFILE *stream)
    int output;
    struct retro_vfs_file_handle* fp = stream->hfile;
 
-   if (filestream_close_cb != NULL)
+   if (filestream_close_cb)
       output = filestream_close_cb(fp);
    else
-      output = retro_vfs_file_close_impl((libretro_vfs_implementation_file*)fp);
+      output = retro_vfs_file_close_impl(
+            (libretro_vfs_implementation_file*)fp);
 
    if (output == 0)
       free(stream);
@@ -481,10 +526,11 @@ int filestream_close(RFILE *stream)
  * @path             : path to file.
  * @buf              : buffer to allocate and read the contents of the
  *                     file into. Needs to be freed manually.
+ * @len              : optional output integer containing bytes read.
  *
  * Read the contents of a file into @buf.
  *
- * Returns: number of items read, -1 on error.
+ * @return Non-zero on success.
  */
 int64_t filestream_read_file(const char *path, void **buf, int64_t *len)
 {
@@ -497,30 +543,24 @@ int64_t filestream_read_file(const char *path, void **buf, int64_t *len)
 
    if (!file)
    {
-      fprintf(stderr, "Failed to open %s: %s\n", path, strerror(errno));
-      goto error;
+      *buf = NULL;
+      return 0;
    }
 
-   content_buf_size = filestream_get_size(file);
-
-   if (content_buf_size < 0)
+   if ((content_buf_size = filestream_get_size(file)) < 0)
       goto error;
 
-   content_buf      = malloc((size_t)(content_buf_size + 1));
-
-   if (!content_buf)
+   if (!(content_buf = malloc((size_t)(content_buf_size + 1))))
       goto error;
    if ((int64_t)(uint64_t)(content_buf_size + 1) != (content_buf_size + 1))
       goto error;
 
-   ret = filestream_read(file, content_buf, (int64_t)content_buf_size);
-   if (ret < 0)
-   {
-      fprintf(stderr, "Failed to read %s: %s\n", path, strerror(errno));
+   if ((ret = filestream_read(file, content_buf, (int64_t)content_buf_size)) <
+         0)
       goto error;
-   }
 
-   filestream_close(file);
+   if (filestream_close(file) != 0)
+      free(file);
 
    *buf    = content_buf;
 
@@ -534,8 +574,8 @@ int64_t filestream_read_file(const char *path, void **buf, int64_t *len)
    return 1;
 
 error:
-   if (file)
-      filestream_close(file);
+   if (filestream_close(file) != 0)
+      free(file);
    if (content_buf)
       free(content_buf);
    if (len)
@@ -552,8 +592,8 @@ int64_t filestream_read_file(const char *path, void **buf, int64_t *len)
  *
  * Writes data to a file.
  *
- * Returns: true (1) on success, false (0) otherwise.
- */
+ * @return true on success, otherwise false.
+ **/
 bool filestream_write_file(const char *path, const void *data, int64_t size)
 {
    int64_t ret   = 0;
@@ -562,18 +602,18 @@ bool filestream_write_file(const char *path, const void *data, int64_t size)
          RETRO_VFS_FILE_ACCESS_HINT_NONE);
    if (!file)
       return false;
-
    ret = filestream_write(file, data, size);
-   filestream_close(file);
-
-   if (ret != size)
-      return false;
-
-   return true;
+   if (filestream_close(file) != 0)
+      free(file);
+   return (ret == size);
 }
 
-/* Returned pointer must be freed by the caller. */
-char* filestream_getline(RFILE *stream)
+/**
+ * filestream_getline:
+ *
+ * Returned pointer must be freed by the caller.
+ **/
+char *filestream_getline(RFILE *stream)
 {
    char *newline_tmp  = NULL;
    size_t cur_size    = 8;
@@ -588,16 +628,15 @@ char* filestream_getline(RFILE *stream)
       return NULL;
    }
 
-   in                 = filestream_getc(stream);
+   in = filestream_getc(stream);
 
    while (in != EOF && in != '\n')
    {
       if (idx == cur_size)
       {
          cur_size    *= 2;
-         newline_tmp  = (char*)realloc(newline, cur_size + 1);
 
-         if (!newline_tmp)
+         if (!(newline_tmp = (char*)realloc(newline, cur_size + 1)))
          {
             free(newline);
             return NULL;
diff --git a/src/libretro/libretro-common/streams/file_stream_transforms.c b/src/libretro/libretro-common/streams/file_stream_transforms.c
index 0a0cd54045..e94a3112ae 100644
--- a/src/libretro/libretro-common/streams/file_stream_transforms.c
+++ b/src/libretro/libretro-common/streams/file_stream_transforms.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
 *
 * ---------------------------------------------------------------------------------------
 * The following license statement only applies to this file (file_stream_transforms.c).
@@ -69,17 +69,27 @@ RFILE* rfopen(const char *path, const char *mode)
 
 int rfclose(RFILE* stream)
 {
+   if (!stream)
+      return EOF;
+
    return filestream_close(stream);
 }
 
 int64_t rftell(RFILE* stream)
 {
+   if (!stream)
+      return -1;
+
    return filestream_tell(stream);
 }
 
 int64_t rfseek(RFILE* stream, int64_t offset, int origin)
 {
    int seek_position = -1;
+
+   if (!stream)
+      return -1;
+
    switch (origin)
    {
       case SEEK_SET:
@@ -99,39 +109,61 @@ int64_t rfseek(RFILE* stream, int64_t offset, int origin)
 int64_t rfread(void* buffer,
    size_t elem_size, size_t elem_count, RFILE* stream)
 {
+   if (!stream || (elem_size == 0) || (elem_count == 0))
+      return 0;
+
    return (filestream_read(stream, buffer, elem_size * elem_count) / elem_size);
 }
 
 char *rfgets(char *buffer, int maxCount, RFILE* stream)
 {
+   if (!stream)
+      return NULL;
+
    return filestream_gets(stream, buffer, maxCount);
 }
 
 int rfgetc(RFILE* stream)
 {
+   if (!stream)
+      return EOF;
+
    return filestream_getc(stream);
 }
 
 int64_t rfwrite(void const* buffer,
    size_t elem_size, size_t elem_count, RFILE* stream)
 {
-   return filestream_write(stream, buffer, elem_size * elem_count);
+   if (!stream || (elem_size == 0) || (elem_count == 0))
+      return 0;
+
+   return (filestream_write(stream, buffer, elem_size * elem_count) / elem_size);
 }
 
 int rfputc(int character, RFILE * stream)
 {
-    return filestream_putc(stream, character);
+   if (!stream)
+      return EOF;
+
+   return filestream_putc(stream, character);
 }
 
 int64_t rfflush(RFILE * stream)
 {
-    return filestream_flush(stream);
+   if (!stream)
+      return EOF;
+
+   return filestream_flush(stream);
 }
 
 int rfprintf(RFILE * stream, const char * format, ...)
 {
    int result;
    va_list vl;
+
+   if (!stream)
+      return -1;
+
    va_start(vl, format);
    result = filestream_vprintf(stream, format, vl);
    va_end(vl);
@@ -152,8 +184,12 @@ int rfscanf(RFILE * stream, const char * format, ...)
 {
    int result;
    va_list vl;
+
+   if (!stream)
+      return 0;
+
    va_start(vl, format);
-   result = filestream_scanf(stream, format, vl);
+   result = filestream_vscanf(stream, format, &vl);
    va_end(vl);
    return result;
 }
diff --git a/src/libretro/libretro-common/streams/interface_stream.c b/src/libretro/libretro-common/streams/interface_stream.c
index 752e23b5ee..5f65c491aa 100644
--- a/src/libretro/libretro-common/streams/interface_stream.c
+++ b/src/libretro/libretro-common/streams/interface_stream.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (interface_stream.c).
@@ -28,11 +28,13 @@
 #ifdef HAVE_CHD
 #include <streams/chd_stream.h>
 #endif
+#if defined(HAVE_ZLIB)
+#include <streams/rzip_stream.h>
+#endif
+#include <encodings/crc32.h>
 
 struct intfstream_internal
 {
-   enum intfstream_type type;
-
    struct
    {
       RFILE *fp;
@@ -40,21 +42,28 @@ struct intfstream_internal
 
    struct
    {
+      memstream_t *fp;
       struct
       {
          uint8_t *data;
          uint64_t size;
       } buf;
-      memstream_t *fp;
       bool writable;
    } memory;
 #ifdef HAVE_CHD
    struct
    {
-      int32_t track;
       chdstream_t *fp;
+      int32_t track;
    } chd;
 #endif
+#if defined(HAVE_ZLIB)
+   struct
+   {
+      rzipstream_t *fp;
+   } rzip;
+#endif
+   enum intfstream_type type;
 };
 
 int64_t intfstream_get_size(intfstream_internal_t *intf)
@@ -73,6 +82,12 @@ int64_t intfstream_get_size(intfstream_internal_t *intf)
         return chdstream_get_size(intf->chd.fp);
 #else
         break;
+#endif
+      case INTFSTREAM_RZIP:
+#if defined(HAVE_ZLIB)
+         return rzipstream_get_size(intf->rzip.fp);
+#else
+         break;
 #endif
    }
 
@@ -99,6 +114,9 @@ bool intfstream_resize(intfstream_internal_t *intf, intfstream_info_t *info)
 #ifdef HAVE_CHD
 #endif
          break;
+      case INTFSTREAM_RZIP:
+         /* Unsupported */
+         return false;
    }
 
    return true;
@@ -130,6 +148,15 @@ bool intfstream_open(intfstream_internal_t *intf, const char *path,
          break;
 #else
          return false;
+#endif
+      case INTFSTREAM_RZIP:
+#if defined(HAVE_ZLIB)
+         intf->rzip.fp = rzipstream_open(path, mode);
+         if (!intf->rzip.fp)
+            return false;
+         break;
+#else
+         return false;
 #endif
    }
 
@@ -147,6 +174,7 @@ int intfstream_flush(intfstream_internal_t *intf)
          return filestream_flush(intf->file.fp);
       case INTFSTREAM_MEMORY:
       case INTFSTREAM_CHD:
+      case INTFSTREAM_RZIP:
          /* Should we stub this for these interfaces? */
          break;
    }
@@ -173,6 +201,12 @@ int intfstream_close(intfstream_internal_t *intf)
 #ifdef HAVE_CHD
          if (intf->chd.fp)
             chdstream_close(intf->chd.fp);
+#endif
+         return 0;
+      case INTFSTREAM_RZIP:
+#if defined(HAVE_ZLIB)
+         if (intf->rzip.fp)
+            return rzipstream_close(intf->rzip.fp);
 #endif
          return 0;
    }
@@ -186,12 +220,24 @@ void *intfstream_init(intfstream_info_t *info)
    if (!info)
       goto error;
 
-   intf = (intfstream_internal_t*)calloc(1, sizeof(*intf));
+   intf = (intfstream_internal_t*)malloc(sizeof(*intf));
 
    if (!intf)
       goto error;
 
-   intf->type = info->type;
+   intf->type            = info->type;
+   intf->file.fp         = NULL;
+   intf->memory.buf.data = NULL;
+   intf->memory.buf.size = 0;
+   intf->memory.fp       = NULL;
+   intf->memory.writable = false;
+#ifdef HAVE_CHD
+   intf->chd.track       = 0;
+   intf->chd.fp          = NULL;
+#endif
+#ifdef HAVE_ZLIB
+   intf->rzip.fp         = NULL;
+#endif
 
    switch (intf->type)
    {
@@ -209,6 +255,8 @@ void *intfstream_init(intfstream_info_t *info)
 #else
          goto error;
 #endif
+      case INTFSTREAM_RZIP:
+         break;
    }
 
    return intf;
@@ -219,7 +267,8 @@ void *intfstream_init(intfstream_info_t *info)
    return NULL;
 }
 
-int64_t intfstream_seek(intfstream_internal_t *intf, int64_t offset, int whence)
+int64_t intfstream_seek(
+      intfstream_internal_t *intf, int64_t offset, int whence)
 {
    if (!intf)
       return -1;
@@ -252,6 +301,9 @@ int64_t intfstream_seek(intfstream_internal_t *intf, int64_t offset, int whence)
 #else
          break;
 #endif
+      case INTFSTREAM_RZIP:
+         /* Unsupported */
+         break;
    }
 
    return -1;
@@ -273,6 +325,12 @@ int64_t intfstream_read(intfstream_internal_t *intf, void *s, uint64_t len)
          return chdstream_read(intf->chd.fp, s, len);
 #else
          break;
+#endif
+      case INTFSTREAM_RZIP:
+#if defined(HAVE_ZLIB)
+         return rzipstream_read(intf->rzip.fp, s, len);
+#else
+         break;
 #endif
    }
 
@@ -293,6 +351,46 @@ int64_t intfstream_write(intfstream_internal_t *intf,
          return memstream_write(intf->memory.fp, s, len);
       case INTFSTREAM_CHD:
          return -1;
+      case INTFSTREAM_RZIP:
+#if defined(HAVE_ZLIB)
+         return rzipstream_write(intf->rzip.fp, s, len);
+#else
+         return -1;
+#endif
+   }
+
+   return 0;
+}
+
+int intfstream_printf(intfstream_internal_t *intf,
+      const char* format, ...)
+{
+   va_list vl;
+   int result;
+
+   if (!intf)
+      return 0;
+
+   switch (intf->type)
+   {
+      case INTFSTREAM_FILE:
+         va_start(vl, format);
+         result = filestream_vprintf(intf->file.fp, format, vl);
+         va_end(vl);
+         return result;
+      case INTFSTREAM_MEMORY:
+         return -1;
+      case INTFSTREAM_CHD:
+         return -1;
+      case INTFSTREAM_RZIP:
+#if defined(HAVE_ZLIB)
+         va_start(vl, format);
+         result = rzipstream_vprintf(intf->rzip.fp, format, vl);
+         va_end(vl);
+         return result;
+#else
+         return -1;
+#endif
    }
 
    return 0;
@@ -311,6 +409,8 @@ int64_t intfstream_get_ptr(intfstream_internal_t* intf)
          return memstream_get_ptr(intf->memory.fp);
       case INTFSTREAM_CHD:
          return -1;
+      case INTFSTREAM_RZIP:
+         return -1;
    }
 
    return 0;
@@ -335,6 +435,12 @@ char *intfstream_gets(intfstream_internal_t *intf,
          return chdstream_gets(intf->chd.fp, buffer, len);
 #else
          break;
+#endif
+      case INTFSTREAM_RZIP:
+#if defined(HAVE_ZLIB)
+         return rzipstream_gets(intf->rzip.fp, buffer, (size_t)len);
+#else
+         break;
 #endif
    }
 
@@ -357,6 +463,12 @@ int intfstream_getc(intfstream_internal_t *intf)
          return chdstream_getc(intf->chd.fp);
 #else
          break;
+#endif
+      case INTFSTREAM_RZIP:
+#if defined(HAVE_ZLIB)
+         return rzipstream_getc(intf->rzip.fp);
+#else
+         break;
 #endif
    }
 
@@ -379,6 +491,40 @@ int64_t intfstream_tell(intfstream_internal_t *intf)
          return (int64_t)chdstream_tell(intf->chd.fp);
 #else
          break;
+#endif
+      case INTFSTREAM_RZIP:
+#if defined(HAVE_ZLIB)
+         return (int64_t)rzipstream_tell(intf->rzip.fp);
+#else
+         break;
+#endif
+   }
+
+   return -1;
+}
+
+int intfstream_eof(intfstream_internal_t *intf)
+{
+   if (!intf)
+      return -1;
+
+   switch (intf->type)
+   {
+      case INTFSTREAM_FILE:
+         return filestream_eof(intf->file.fp);
+      case INTFSTREAM_MEMORY:
+         /* TODO: Add this functionality to
+          * memory_stream interface */
+         break;
+      case INTFSTREAM_CHD:
+         /* TODO: Add this functionality to
+          * chd_stream interface */
+         break;
+      case INTFSTREAM_RZIP:
+#if defined(HAVE_ZLIB)
+         return rzipstream_eof(intf->rzip.fp);
+#else
+         break;
 #endif
    }
 
@@ -398,6 +544,11 @@ void intfstream_rewind(intfstream_internal_t *intf)
       case INTFSTREAM_CHD:
 #ifdef HAVE_CHD
          chdstream_rewind(intf->chd.fp);
+#endif
+         break;
+      case INTFSTREAM_RZIP:
+#if defined(HAVE_ZLIB)
+         rzipstream_rewind(intf->rzip.fp);
 #endif
          break;
    }
@@ -418,19 +569,104 @@ void intfstream_putc(intfstream_internal_t *intf, int c)
          break;
       case INTFSTREAM_CHD:
          break;
+      case INTFSTREAM_RZIP:
+#if defined(HAVE_ZLIB)
+         rzipstream_putc(intf->rzip.fp, c);
+#else
+         break;
+#endif
    }
 }
 
-uint32_t intfstream_get_chd_pregap(intfstream_internal_t *intf)
+uint32_t intfstream_get_offset_to_start(intfstream_internal_t *intf)
 {
+   if (intf)
+   {
 #ifdef HAVE_CHD
-   if (intf->type == INTFSTREAM_CHD)
-      return chdstream_get_pregap(intf->chd.fp);
+      if (intf->type == INTFSTREAM_CHD)
+         return chdstream_get_track_start(intf->chd.fp);
 #endif
+   }
 
    return 0;
 }
 
+uint32_t intfstream_get_frame_size(intfstream_internal_t *intf)
+{
+   if (intf)
+   {
+#ifdef HAVE_CHD
+      if (intf->type == INTFSTREAM_CHD)
+         return chdstream_get_frame_size(intf->chd.fp);
+#endif
+   }
+
+   return 0;
+}
+
+uint32_t intfstream_get_first_sector(intfstream_internal_t* intf)
+{
+   if (intf)
+   {
+#ifdef HAVE_CHD
+      if (intf->type == INTFSTREAM_CHD)
+         return chdstream_get_first_track_sector(intf->chd.fp);
+#endif
+   }
+
+   return 0;
+}
+
+bool intfstream_is_compressed(intfstream_internal_t *intf)
+{
+   if (!intf)
+      return false;
+
+   switch (intf->type)
+   {
+      case INTFSTREAM_FILE:
+         return false;
+      case INTFSTREAM_MEMORY:
+         return false;
+      case INTFSTREAM_CHD:
+         return true;
+      case INTFSTREAM_RZIP:
+#if defined(HAVE_ZLIB)
+         return rzipstream_is_compressed(intf->rzip.fp);
+#else
+         break;
+#endif
+   }
+
+   return false;
+}
+
+bool intfstream_get_crc(intfstream_internal_t *intf, uint32_t *crc)
+{
+   int64_t data_read    = 0;
+   uint32_t accumulator = 0;
+   uint8_t buffer[4096];
+
+   if (!intf || !crc)
+      return false;
+
+   /* Ensure we start at the beginning of the file */
+   intfstream_rewind(intf);
+
+   while ((data_read = intfstream_read(intf, buffer, sizeof(buffer))) > 0)
+      accumulator = encoding_crc32(accumulator, buffer, (size_t)data_read);
+
+   if (data_read < 0)
+      return false;
+
+   *crc = accumulator;
+
+   /* Reset file to the beginning */
+   intfstream_rewind(intf);
+
+   return true;
+}
+
 intfstream_t* intfstream_open_file(const char *path,
       unsigned mode, unsigned hints)
 {
@@ -515,8 +751,6 @@ intfstream_t *intfstream_open_writable_memory(void *data,
    return NULL;
 }
 
-
-
 intfstream_t *intfstream_open_chd_track(const char *path,
       unsigned mode, unsigned hints, int32_t track)
 {
@@ -544,3 +778,29 @@ intfstream_t *intfstream_open_chd_track(const char *path,
    }
    return NULL;
 }
+
+intfstream_t* intfstream_open_rzip_file(const char *path,
+      unsigned mode)
+{
+   intfstream_info_t info;
+   intfstream_t *fd = NULL;
+
+   info.type        = INTFSTREAM_RZIP;
+   fd               = (intfstream_t*)intfstream_init(&info);
+
+   if (!fd)
+      return NULL;
+
+   if (!intfstream_open(fd, path, mode, RETRO_VFS_FILE_ACCESS_HINT_NONE))
+      goto error;
+
+   return fd;
+
+error:
+   if (fd)
+   {
+      intfstream_close(fd);
+      free(fd);
+   }
+   return NULL;
+}
diff --git a/src/libretro/libretro-common/streams/memory_stream.c b/src/libretro/libretro-common/streams/memory_stream.c
index 829ef034ce..2aa1c8081b 100644
--- a/src/libretro/libretro-common/streams/memory_stream.c
+++ b/src/libretro/libretro-common/streams/memory_stream.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (memory_stream.c).
@@ -26,29 +26,24 @@
 
 #include <streams/memory_stream.h>
 
+/* TODO/FIXME - static globals */
 static uint8_t* g_buffer      = NULL;
 static uint64_t g_size         = 0;
 static uint64_t last_file_size = 0;
 
 struct memstream
 {
-   uint8_t *buf;
    uint64_t size;
    uint64_t ptr;
    uint64_t max_ptr;
+   uint8_t *buf;
    unsigned writing;
 };
 
-static void memstream_update_pos(memstream_t *stream)
-{
-   if (stream && stream->ptr > stream->max_ptr)
-      stream->max_ptr = stream->ptr;
-}
-
 void memstream_set_buffer(uint8_t *buffer, uint64_t size)
 {
    g_buffer = buffer;
-   g_size = size;
+   g_size   = size;
 }
 
 uint64_t memstream_get_last_size(void)
@@ -56,30 +51,26 @@ uint64_t memstream_get_last_size(void)
    return last_file_size;
 }
 
-static void memstream_init(memstream_t *stream,
-      uint8_t *buffer, uint64_t max_size, unsigned writing)
-{
-   if (!stream)
-      return;
-
-   stream->buf     = buffer;
-   stream->size    = max_size;
-   stream->ptr     = 0;
-   stream->max_ptr = 0;
-   stream->writing = writing;
-}
-
 memstream_t *memstream_open(unsigned writing)
 {
    memstream_t *stream;
    if (!g_buffer || !g_size)
       return NULL;
 
-   stream = (memstream_t*)calloc(1, sizeof(*stream));
-   memstream_init(stream, g_buffer, g_size, writing);
+   stream = (memstream_t*)malloc(sizeof(*stream));
+
+   if (!stream)
+      return NULL;
+
+   stream->buf       = g_buffer;
+   stream->size      = g_size;
+   stream->ptr       = 0;
+   stream->max_ptr   = 0;
+   stream->writing   = writing;
+
+   g_buffer          = NULL;
+   g_size            = 0;
 
-   g_buffer = NULL;
-   g_size = 0;
    return stream;
 }
 
@@ -104,17 +95,19 @@ uint64_t memstream_read(memstream_t *stream, void *data, uint64_t bytes)
    if (!stream)
       return 0;
 
-   avail = stream->size - stream->ptr;
+   avail               = stream->size - stream->ptr;
    if (bytes > avail)
-      bytes = avail;
+      bytes            = avail;
 
    memcpy(data, stream->buf + stream->ptr, (size_t)bytes);
-   stream->ptr += bytes;
-   memstream_update_pos(stream);
+   stream->ptr        += bytes;
+   if (stream->ptr > stream->max_ptr)
+      stream->max_ptr  = stream->ptr;
    return bytes;
 }
 
-uint64_t memstream_write(memstream_t *stream, const void *data, uint64_t bytes)
+uint64_t memstream_write(memstream_t *stream,
+      const void *data, uint64_t bytes)
 {
    uint64_t avail = 0;
 
@@ -127,7 +120,8 @@ uint64_t memstream_write(memstream_t *stream, const void *data, uint64_t bytes)
 
    memcpy(stream->buf + stream->ptr, data, (size_t)bytes);
    stream->ptr += bytes;
-   memstream_update_pos(stream);
+   if (stream->ptr > stream->max_ptr)
+      stream->max_ptr = stream->ptr;
    return bytes;
 }
 
@@ -181,7 +175,8 @@ int memstream_getc(memstream_t *stream)
       return EOF;
    ret = stream->buf[stream->ptr++];
 
-   memstream_update_pos(stream);
+   if (stream->ptr > stream->max_ptr)
+      stream->max_ptr = stream->ptr;
 
    return ret;
 }
@@ -191,5 +186,6 @@ void memstream_putc(memstream_t *stream, int c)
    if (stream->ptr < stream->size)
       stream->buf[stream->ptr++] = c;
 
-   memstream_update_pos(stream);
+   if (stream->ptr > stream->max_ptr)
+      stream->max_ptr = stream->ptr;
 }
diff --git a/src/libretro/libretro-common/streams/stdin_stream.c b/src/libretro/libretro-common/streams/stdin_stream.c
index cf6fb0e331..80f6e9abd5 100644
--- a/src/libretro/libretro-common/streams/stdin_stream.c
+++ b/src/libretro/libretro-common/streams/stdin_stream.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (stdin_stream.c).
@@ -38,7 +38,7 @@
 #include <retro_environment.h>
 #include <streams/stdin_stream.h>
 
-#if (defined(_WIN32) && defined(_XBOX)) || defined(__CELLOS_LV2__) || defined(__WINRT__)
+#if (defined(_WIN32) && defined(_XBOX)) || defined(__WINRT__) || !defined(__PSL1GHT__) && defined(__PS3__)
 size_t read_stdin(char *buf, size_t size)
 {
    /* Not implemented. */
diff --git a/src/libretro/libretro-common/streams/trans_stream.c b/src/libretro/libretro-common/streams/trans_stream.c
index 92f3207d64..aecb457b66 100644
--- a/src/libretro/libretro-common/streams/trans_stream.c
+++ b/src/libretro/libretro-common/streams/trans_stream.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (trans_stream.c).
@@ -45,13 +45,10 @@ bool trans_stream_trans_full(
    uint32_t rd, wn;
 
    if (data && *data)
-   {
       rdata = *data;
-   }
    else
    {
-      rdata = backend->stream_new();
-      if (!rdata)
+      if (!(rdata = backend->stream_new()))
       {
          if (error)
             *error = TRANS_STREAM_ERROR_ALLOCATION_FAILURE;
diff --git a/src/libretro/libretro-common/streams/trans_stream_pipe.c b/src/libretro/libretro-common/streams/trans_stream_pipe.c
index 5a2e076652..76f8b16f1e 100644
--- a/src/libretro/libretro-common/streams/trans_stream_pipe.c
+++ b/src/libretro/libretro-common/streams/trans_stream_pipe.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (trans_stream_pipe.c).
@@ -34,7 +34,17 @@ struct pipe_trans_stream
 
 static void *pipe_stream_new(void)
 {
-   return (struct pipe_trans_stream*)calloc(1, sizeof(struct pipe_trans_stream));
+   struct pipe_trans_stream *stream = 
+      (struct pipe_trans_stream*)malloc(sizeof(*stream));
+   if (!stream)
+      return NULL;
+
+   stream->in                       = NULL;
+   stream->out                      = NULL;
+   stream->in_size                  = 0;
+   stream->out_size                 = 0;
+
+   return stream;
 }
 
 static void pipe_stream_free(void *data)
@@ -45,15 +55,23 @@ static void pipe_stream_free(void *data)
 static void pipe_set_in(void *data, const uint8_t *in, uint32_t in_size)
 {
    struct pipe_trans_stream *p = (struct pipe_trans_stream *) data;
-   p->in = in;
-   p->in_size = in_size;
+
+   if (!p)
+      return;
+         
+   p->in                       = in;
+   p->in_size                  = in_size;
 }
 
 static void pipe_set_out(void *data, uint8_t *out, uint32_t out_size)
 {
    struct pipe_trans_stream *p = (struct pipe_trans_stream *) data;
-   p->out = out;
-   p->out_size = out_size;
+   
+   if (!p)
+      return;
+
+   p->out                      = out;
+   p->out_size                 = out_size;
 }
 
 static bool pipe_trans(
@@ -66,21 +84,19 @@ static bool pipe_trans(
    if (p->out_size < p->in_size)
    {
       memcpy(p->out, p->in, p->out_size);
-      *rd = *wn = p->out_size;
-      p->in += p->out_size;
+      *rd     = *wn = p->out_size;
+      p->in  += p->out_size;
       p->out += p->out_size;
-      *error = TRANS_STREAM_ERROR_BUFFER_FULL;
+      *error  = TRANS_STREAM_ERROR_BUFFER_FULL;
       return false;
    }
-   else
-   {
-      memcpy(p->out, p->in, p->in_size);
-      *rd = *wn = p->in_size;
-      p->in += p->in_size;
-      p->out += p->in_size;
-      *error = TRANS_STREAM_ERROR_NONE;
-      return true;
-   }
+
+   memcpy(p->out, p->in, p->in_size);
+   *rd     = *wn = p->in_size;
+   p->in  += p->in_size;
+   p->out += p->in_size;
+   *error  = TRANS_STREAM_ERROR_NONE;
+   return true;
 }
 
 const struct trans_stream_backend pipe_backend = {
diff --git a/src/libretro/libretro-common/streams/trans_stream_zlib.c b/src/libretro/libretro-common/streams/trans_stream_zlib.c
index d4f3d5ed48..e5d1a4af78 100644
--- a/src/libretro/libretro-common/streams/trans_stream_zlib.c
+++ b/src/libretro/libretro-common/streams/trans_stream_zlib.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (trans_stream_zlib.c).
@@ -29,27 +29,67 @@
 
 struct zlib_trans_stream
 {
-   bool inited;
-   int ex; /* window_bits or level */
    z_stream z;
+   int ex; /* window_bits or level */
+   bool inited;
 };
 
 static void *zlib_deflate_stream_new(void)
 {
-   struct zlib_trans_stream *ret = (struct zlib_trans_stream*)calloc(1, sizeof(struct zlib_trans_stream));
+   struct zlib_trans_stream *ret = (struct zlib_trans_stream*)
+      malloc(sizeof(*ret));
    if (!ret)
       return NULL;
-   ret->ex = 9;
-   return (void *) ret;
+   ret->inited      = false;
+   ret->ex          = 9;
+
+   ret->z.next_in   = NULL;
+   ret->z.avail_in  = 0;
+   ret->z.total_in  = 0;
+   ret->z.next_out  = NULL;
+   ret->z.avail_out = 0;
+   ret->z.total_out = 0;
+
+   ret->z.msg       = NULL;
+   ret->z.state     = NULL;
+
+   ret->z.zalloc    = NULL;
+   ret->z.zfree     = NULL;
+   ret->z.opaque    = NULL;
+
+   ret->z.data_type = 0;
+   ret->z.adler     = 0;
+   ret->z.reserved  = 0;
+   return (void *)ret;
 }
 
 static void *zlib_inflate_stream_new(void)
 {
-   struct zlib_trans_stream *ret = (struct zlib_trans_stream*)calloc(1, sizeof(struct zlib_trans_stream));
+   struct zlib_trans_stream *ret = (struct zlib_trans_stream*)
+      malloc(sizeof(*ret));
    if (!ret)
       return NULL;
-   ret->ex = MAX_WBITS;
-   return (void *) ret;
+   ret->inited      = false;
+   ret->ex          = MAX_WBITS;
+
+   ret->z.next_in   = NULL;
+   ret->z.avail_in  = 0;
+   ret->z.total_in  = 0;
+   ret->z.next_out  = NULL;
+   ret->z.avail_out = 0;
+   ret->z.total_out = 0;
+
+   ret->z.msg       = NULL;
+   ret->z.state     = NULL;
+
+   ret->z.zalloc    = NULL;
+   ret->z.zfree     = NULL;
+   ret->z.opaque    = NULL;
+
+   ret->z.data_type = 0;
+   ret->z.adler     = 0;
+   ret->z.reserved  = 0;
+   return (void *)ret;
 }
 
 static void zlib_deflate_stream_free(void *data)
@@ -222,9 +262,9 @@ static bool zlib_inflate_trans(
       zt->inited = true;
    }
 
-   pre_avail_in = z->avail_in;
+   pre_avail_in  = z->avail_in;
    pre_avail_out = z->avail_out;
-   zret = inflate(z, flush ? Z_FINISH : Z_NO_FLUSH);
+   zret          = inflate(z, flush ? Z_FINISH : Z_NO_FLUSH);
 
    if (zret == Z_OK)
    {
diff --git a/src/libretro/libretro-common/string/stdstring.c b/src/libretro/libretro-common/string/stdstring.c
index 51258ea424..7f05883d0a 100644
--- a/src/libretro/libretro-common/string/stdstring.c
+++ b/src/libretro/libretro-common/string/stdstring.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2018 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
  *
  * ---------------------------------------------------------------------------------------
  * The following license statement only applies to this file (stdstring.c).
@@ -22,10 +22,44 @@
 
 #include <stdint.h>
 #include <ctype.h>
+#include <string.h>
 
+#include <compat/strl.h>
 #include <string/stdstring.h>
 #include <encodings/utf.h>
 
+const uint8_t lr_char_props[256] = {
+	/*x0   x1   x2   x3   x4   x5   x6   x7   x8   x9   xA   xB   xC   xD   xE   xF */
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x80,0x00,0x00,0x80,0x00,0x00, /* 0x                  */
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 1x                  */
+	0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 2x  !"#$%&'()*+,-./ */
+	0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x00,0x00,0x00,0x00,0x00,0x00, /* 3x 0123456789:;<=>? */
+	0x00,0x23,0x23,0x23,0x23,0x23,0x23,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22, /* 4x @ABCDEFGHIJKLMNO */
+	0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x00,0x00,0x00,0x00,0x08, /* 5x PQRSTUVWXYZ[\]^_ */
+	0x00,0x25,0x25,0x25,0x25,0x25,0x25,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24, /* 6x `abcdefghijklmno */
+	0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x00,0x00,0x00,0x00,0x00, /* 7x pqrstuvwxyz{|}~  */
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 8x                  */
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 9x                  */
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Ax                  */
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Bx                  */
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Cx                  */
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Dx                  */
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Ex                  */
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Fx                  */
+};
+
+char *string_init(const char *src)
+{
+   return src ? strdup(src) : NULL;
+}
+
+void string_set(char **string, const char *src)
+{
+   free(*string);
+   *string = string_init(src);
+}
+
+
 char *string_to_upper(char *s)
 {
    char *cs = (char *)s;
@@ -56,9 +90,11 @@ char *string_ucwords(char *s)
 }
 
 char *string_replace_substring(const char *in,
-      const char *pattern, const char *replacement)
+      const char *pattern, size_t pattern_len,
+      const char *replacement, size_t replacement_len)
 {
-   size_t numhits, pattern_len, replacement_len, outlen;
+   size_t outlen;
+   size_t numhits     = 0;
    const char *inat   = NULL;
    const char *inprev = NULL;
    char          *out = NULL;
@@ -69,9 +105,6 @@ char *string_replace_substring(const char *in,
    if (!pattern || !replacement)
       return strdup(in);
 
-   pattern_len     = strlen(pattern);
-   replacement_len = strlen(replacement);
-   numhits         = 0;
    inat            = in;
 
    while ((inat = strstr(inat, pattern)))
@@ -81,9 +114,8 @@ char *string_replace_substring(const char *in,
    }
 
    outlen          = strlen(in) - pattern_len*numhits + replacement_len*numhits;
-   out             = (char *)malloc(outlen+1);
 
-   if (!out)
+   if (!(out = (char *)malloc(outlen+1)))
       return NULL;
 
    outat           = out;
@@ -96,7 +128,7 @@ char *string_replace_substring(const char *in,
       outat += inat-inprev;
       memcpy(outat, replacement, replacement_len);
       outat += replacement_len;
-      inat += pattern_len;
+      inat  += pattern_len;
       inprev = inat;
    }
    strcpy(outat, inprev);
@@ -104,48 +136,60 @@ char *string_replace_substring(const char *in,
    return out;
 }
 
-/* Remove leading whitespaces */
+/**
+ * string_trim_whitespace_left:
+ *
+ * Remove leading whitespaces
+ **/
 char *string_trim_whitespace_left(char *const s)
 {
-   if(s && *s)
+   if (s && *s)
    {
       size_t len     = strlen(s);
       char *current  = s;
 
-      while(*current && isspace((unsigned char)*current))
+      while (*current && ISSPACE((unsigned char)*current))
       {
          ++current;
          --len;
       }
 
-      if(s != current)
+      if (s != current)
          memmove(s, current, len + 1);
    }
 
    return s;
 }
 
-/* Remove trailing whitespaces */
+/**
+ * string_trim_whitespace_right:
+ *
+ * Remove trailing whitespaces
+ **/
 char *string_trim_whitespace_right(char *const s)
 {
-   if(s && *s)
+   if (s && *s)
    {
       size_t len     = strlen(s);
       char  *current = s + len - 1;
 
-      while(current != s && isspace((unsigned char)*current))
+      while (current != s && ISSPACE((unsigned char)*current))
       {
          --current;
          --len;
       }
 
-      current[isspace((unsigned char)*current) ? 0 : 1] = '\0';
+      current[ISSPACE((unsigned char)*current) ? 0 : 1] = '\0';
    }
 
    return s;
 }
 
-/* Remove leading and trailing whitespaces */
+/**
+ * string_trim_whitespace:
+ *
+ * Remove leading and trailing whitespaces
+ **/
 char *string_trim_whitespace(char *const s)
 {
    string_trim_whitespace_right(s);  /* order matters */
@@ -154,107 +198,262 @@ char *string_trim_whitespace(char *const s)
    return s;
 }
 
-char *word_wrap(char* buffer, const char *string, int line_width, bool unicode, unsigned max_lines)
+/**
+ * word_wrap:
+ * @dst                : pointer to destination buffer.
+ * @dst_size           : size of destination buffer.
+ * @src                : pointer to input string.
+ * @line_width         : max number of characters per line.
+ * @wideglyph_width    : not used, but is necessary to keep
+ *                       compatibility with word_wrap_wideglyph().
+ * @max_lines          : max lines of destination string.
+ *                       0 means no limit.
+ *
+ * Wraps string specified by 'src' to destination buffer
+ * specified by 'dst' and 'dst_size'.
+ * This function assumes that all glyphs in the string
+ * have an on-screen pixel width similar to that of
+ * regular Latin characters - i.e. it will not wrap
+ * correctly any text containing so-called 'wide' Unicode
+ * characters (e.g. CJK languages, emojis, etc.).
+ **/
+size_t word_wrap(
+      char *dst,       size_t dst_size,
+      const char *src, size_t src_len,
+      int line_width,  int wideglyph_width, unsigned max_lines)
 {
-   unsigned i     = 0;
-   unsigned len   = (unsigned)strlen(string);
-   unsigned lines = 1;
+   char *last_space    = NULL;
+   unsigned counter    = 0;
+   unsigned lines      = 1;
+   const char *src_end = src + src_len;
+
+   /* Prevent buffer overflow */
+   if (dst_size < src_len + 1)
+      return 0;
+
+   /* Early return if src string length is less
+    * than line width */
+   if (src_len < (size_t)line_width)
+      return strlcpy(dst, src, dst_size);
 
-   while (i < len)
+   while (*src != '\0')
    {
-      unsigned counter;
-      int pos = (int)(&buffer[i] - buffer);
+      unsigned char_len = (unsigned)(utf8skip(src, 1) - src);
+      counter++;
 
-      /* copy string until the end of the line is reached */
-      for (counter = 1; counter <= (unsigned)line_width; counter++)
+      if (*src == ' ')
+         last_space = dst; /* Remember the location of the whitespace */
+      else if (*src == '\n')
       {
-         const char *character;
-         unsigned char_len;
-         unsigned j = i;
+         /* If newlines embedded in the input,
+          * reset the index */
+         lines++;
+         counter   = 0;
 
-         /* check if end of string reached */
-         if (i == len)
-         {
-            buffer[i] = 0;
-            return buffer;
-         }
+         /* Early return if remaining src string
+          * length is less than line width */
+         if (src_end - src <= line_width)
+            return strlcpy(dst, src, dst_size);
+     }
 
-         character = utf8skip(&string[i], 1);
-         char_len  = (unsigned)(character - &string[i]);
+      while (char_len--)
+         *dst++ = *src++;
 
-         if (!unicode)
-            counter += char_len - 1;
+      if (counter >= (unsigned)line_width)
+      {
+         counter = 0;
 
-         do
-         {
-            buffer[i] = string[i];
-            char_len--;
-            i++;
-         } while(char_len);
-
-         /* check for newlines embedded in the original input
-          * and reset the index */
-         if (buffer[j] == '\n')
+         if (last_space && (max_lines == 0 || lines < max_lines))
          {
+            /* Replace nearest (previous) whitespace
+             * with newline character */
+            *last_space = '\n';
             lines++;
-            counter = 1;
+
+            src        -= dst - last_space - 1;
+            dst         = last_space + 1;
+            last_space  = NULL;
+
+            /* Early return if remaining src string
+             * length is less than line width */
+            if (src_end - src < line_width)
+               return strlcpy(dst, src, dst_size);
          }
       }
+   }
+
+   *dst = '\0';
+   return 0;
+}
+
+/**
+ * word_wrap_wideglyph:
+ * @dst                : pointer to destination buffer.
+ * @dst_size           : size of destination buffer.
+ * @src                : pointer to input string.
+ * @line_width         : max number of characters per line.
+ * @wideglyph_width    : effective width of 'wide' Unicode glyphs.
+ *                       the value here is normalised relative to the
+ *                       typical on-screen pixel width of a regular
+ *                       Latin character:
+ *                       - a regular Latin character is defined to
+ *                         have an effective width of 100
+ *                       - wideglyph_width = 100 * (wide_character_pixel_width / latin_character_pixel_width)
+ *                       - e.g. if 'wide' Unicode characters in 'src'
+ *                         have an on-screen pixel width twice that of
+ *                         regular Latin characters, wideglyph_width
+ *                         would be 200
+ * @max_lines          : max lines of destination string.
+ *                       0 means no limit.
+ *
+ * Wraps string specified by @src to destination buffer
+ * specified by @dst and @dst_size.
+ * This function assumes that all glyphs in the string
+ * are:
+ * - EITHER 'non-wide' Unicode glyphs, with an on-screen
+ *   pixel width similar to that of regular Latin characters
+ * - OR 'wide' Unicode glyphs (e.g. CJK languages, emojis, etc.)
+ *   with an on-screen pixel width defined by @wideglyph_width
+ * Note that wrapping may occur in inappropriate locations
+ * if @src string contains 'wide' Unicode characters whose
+ * on-screen pixel width deviates greatly from the set
+ * @wideglyph_width value.
+ **/
+size_t word_wrap_wideglyph(char *dst, size_t dst_size,
+      const char *src, size_t src_len, int line_width,
+      int wideglyph_width, unsigned max_lines)
+{
+   char *lastspace                   = NULL;
+   char *lastwideglyph               = NULL;
+   const char *src_end               = src + src_len;
+   unsigned lines                    = 1;
+   /* 'line_width' means max numbers of characters per line,
+    * but this metric is only meaningful when dealing with
+    * 'regular' glyphs that have an on-screen pixel width
+    * similar to that of regular Latin characters.
+    * When handing so-called 'wide' Unicode glyphs, it is
+    * necessary to consider the actual on-screen pixel width
+    * of each character.
+    * In order to do this, we create a distinction between
+    * regular Latin 'non-wide' glyphs and 'wide' glyphs, and
+    * normalise all values relative to the on-screen pixel
+    * width of regular Latin characters:
+    * - Regular 'non-wide' glyphs have a normalised width of 100
+    * - 'line_width' is therefore normalised to 100 * (width_in_characters)
+    * - 'wide' glyphs have a normalised width of
+    *   100 * (wide_character_pixel_width / latin_character_pixel_width)
+    * - When a character is detected, the position in the current
+    *   line is incremented by the regular normalised width of 100
+    * - If that character is then determined to be a 'wide'
+    *   glyph, the position in the current line is further incremented
+    *   by the difference between the normalised 'wide' and 'non-wide'
+    *   width values */
+   unsigned counter_normalized       = 0;
+   int line_width_normalized         = line_width * 100;
+   int additional_counter_normalized = wideglyph_width - 100;
+
+   /* Early return if src string length is less
+    * than line width */
+   if (src_end - src < line_width)
+      return strlcpy(dst, src, dst_size);
+
+   while (*src != '\0')
+   {
+      unsigned char_len   = (unsigned)(utf8skip(src, 1) - src);
+      counter_normalized += 100;
+
+      /* Prevent buffer overflow */
+      if (char_len >= dst_size)
+         break;
 
-      /* check for whitespace */
-      if (string[i] == ' ')
+      if (*src == ' ')
+         lastspace          = dst; /* Remember the location of the whitespace */
+      else if (*src == '\n')
       {
-         if ((max_lines == 0 || lines < max_lines))
-         {
-            buffer[i] = '\n';
-            i++;
-            lines++;
-         }
+         /* If newlines embedded in the input,
+          * reset the index */
+         lines++;
+         counter_normalized = 0;
+
+         /* Early return if remaining src string
+          * length is less than line width */
+         if (src_end - src <= line_width)
+            return strlcpy(dst, src, dst_size);
       }
-      else
+      else if (char_len >= 3)
       {
-         int k;
+         /* Remember the location of the first byte
+          * whose length as UTF-8 >= 3*/
+         lastwideglyph       = dst;
+         counter_normalized += additional_counter_normalized;
+      }
 
-         /* check for nearest whitespace back in string */
-         for (k = i; k > 0; k--)
-         {
-            if (string[k] != ' ' || (max_lines != 0 && lines >= max_lines))
-               continue;
+      dst_size -= char_len;
+      while (char_len--)
+         *dst++ = *src++;
+
+      if (counter_normalized >= (unsigned)line_width_normalized)
+      {
+         counter_normalized = 0;
 
-            buffer[k] = '\n';
-            /* set string index back to character after this one */
-            i         = k + 1;
+         if (max_lines != 0 && lines >= max_lines)
+            continue;
+         else if (lastwideglyph && (!lastspace || lastwideglyph > lastspace))
+         {
+            /* Insert newline character */
+            *lastwideglyph = '\n';
             lines++;
-            break;
+            src           -= dst - lastwideglyph;
+            dst            = lastwideglyph + 1;
+            lastwideglyph  = NULL;
+
+            /* Early return if remaining src string
+             * length is less than line width */
+            if (src_end - src <= line_width)
+               return strlcpy(dst, src, dst_size);
+         }
+         else if (lastspace)
+         {
+            /* Replace nearest (previous) whitespace
+             * with newline character */
+            *lastspace = '\n';
+            lines++;
+            src       -= dst - lastspace - 1;
+            dst        = lastspace + 1;
+            lastspace  = NULL;
+
+            /* Early return if remaining src string
+             * length is less than line width */
+            if (src_end - src < line_width)
+               return strlcpy(dst, src, dst_size);
          }
-
-         if (&buffer[i] - buffer == pos)
-            return buffer;
       }
    }
 
-   buffer[i] = 0;
-
-   return buffer;
+   *dst = '\0';
+   return 0;
 }
 
-/* Splits string into tokens seperated by 'delim'
+/**
+ * string_tokenize:
+ *
+ * Splits string into tokens seperated by @delim
  * > Returned token string must be free()'d
  * > Returns NULL if token is not found
- * > After each call, 'str' is set to the position after the
+ * > After each call, @str is set to the position after the
  *   last found token
  * > Tokens *include* empty strings
  * Usage example:
  *    char *str      = "1,2,3,4,5,6,7,,,10,";
  *    char **str_ptr = &str;
  *    char *token    = NULL;
- *    while((token = string_tokenize(str_ptr, ",")))
+ *    while ((token = string_tokenize(str_ptr, ",")))
  *    {
  *        printf("%s\n", token);
  *        free(token);
  *        token = NULL;
  *    }
- */
+ **/
 char* string_tokenize(char **str, const char *delim)
 {
    /* Taken from https://codereview.stackexchange.com/questions/216956/strtok-function-thread-safe-supports-empty-tokens-doesnt-change-string# */
@@ -267,25 +466,20 @@ char* string_tokenize(char **str, const char *delim)
    if (!str || string_is_empty(delim))
       return NULL;
 
-   str_ptr = *str;
 
    /* Note: we don't check string_is_empty() here,
     * empty strings are valid */
-   if (!str_ptr)
+   if (!(str_ptr = *str))
       return NULL;
 
    /* Search for delimiter */
-   delim_ptr = strstr(str_ptr, delim);
-
-   if (delim_ptr)
+   if ((delim_ptr = strstr(str_ptr, delim)))
       token_len = delim_ptr - str_ptr;
    else
       token_len = strlen(str_ptr);
 
    /* Allocate token string */
-   token = (char *)malloc((token_len + 1) * sizeof(char));
-
-   if (!token)
+   if (!(token = (char *)malloc((token_len + 1) * sizeof(char))))
       return NULL;
 
    /* Copy token */
@@ -298,29 +492,53 @@ char* string_tokenize(char **str, const char *delim)
    return token;
 }
 
-/* Removes every instance of character 'c' from 'str' */
+/**
+ * string_remove_all_chars:
+ * @str                : input string (must be non-NULL, otherwise UB)
+ *
+ * Leaf function.
+ *
+ * Removes every instance of character @c from @str
+ **/
 void string_remove_all_chars(char *str, char c)
 {
-   char *read_ptr  = NULL;
-   char *write_ptr = NULL;
-
-   if (string_is_empty(str))
-      return;
-
-   read_ptr  = str;
-   write_ptr = str;
+   char *read_ptr  = str;
+   char *write_ptr = str;
 
    while (*read_ptr != '\0')
    {
       *write_ptr = *read_ptr++;
-      write_ptr += (*write_ptr != c) ? 1 : 0;
+      if (*write_ptr != c)
+         write_ptr++;
    }
 
    *write_ptr = '\0';
 }
 
-/* Converts string to unsigned integer.
- * Returns 0 if string is invalid  */
+/**
+ * string_replace_all_chars:
+ * @str                : input string (must be non-NULL, otherwise UB)
+ * @find               : character to find
+ * @replace            : character to replace @find with
+ *
+ * Replaces every instance of character @find in @str
+ * with character @replace
+ **/
+void string_replace_all_chars(char *str, char find, char replace)
+{
+   char *str_ptr = str;
+   while ((str_ptr = strchr(str_ptr, find)))
+      *str_ptr++ = replace;
+}
+
+/**
+ * string_to_unsigned:
+ * @str                : input string
+ *
+ * Converts string to unsigned integer.
+ *
+ * @return 0 if string is invalid, otherwise > 0
+ **/
 unsigned string_to_unsigned(const char *str)
 {
    const char *ptr = NULL;
@@ -330,9 +548,162 @@ unsigned string_to_unsigned(const char *str)
 
    for (ptr = str; *ptr != '\0'; ptr++)
    {
-      if (!isdigit(*ptr))
+      if (!ISDIGIT((unsigned char)*ptr))
          return 0;
    }
 
    return (unsigned)strtoul(str, NULL, 10);
 }
+
+/**
+ * string_hex_to_unsigned:
+ * @str                : input string (must be non-NULL, otherwise UB)
+ *
+ * Converts hexadecimal string to unsigned integer.
+ * Handles optional leading '0x'.
+ *
+ * @return 0 if string is invalid, otherwise > 0
+ **/
+unsigned string_hex_to_unsigned(const char *str)
+{
+   const char *hex_str = str;
+   const char *ptr     = NULL;
+
+   /* Remove leading '0x', if required */
+   if (str[0] != '\0' && str[1] != '\0')
+   {
+      if ( (str[0] == '0') &&
+          ((str[1] == 'x') ||
+           (str[1] == 'X')))
+      {
+         hex_str = str + 2;
+         if (string_is_empty(hex_str))
+            return 0;
+      }
+   }
+   else
+      return 0;
+
+   /* Check for valid characters */
+   for (ptr = hex_str; *ptr != '\0'; ptr++)
+   {
+      if (!isxdigit((unsigned char)*ptr))
+         return 0;
+   }
+
+   return (unsigned)strtoul(hex_str, NULL, 16);
+}
+
+/**
+ * string_count_occurrences_single_character:
+ *
+ * Leaf function.
+ *
+ * Get the total number of occurrences of character @c in @str.
+ *
+ * @return Total number of occurrences of character @c
+ */
+int string_count_occurrences_single_character(const char *str, char c)
+{
+   int count = 0;
+
+   for (; *str; str++)
+      if (*str == c)
+         count++;
+
+   return count;
+}
+
+/**
+ * string_replace_whitespace_with_single_character:
+ *
+ * Leaf function.
+ *
+ * Replaces all spaces with given character @c.
+ **/
+void string_replace_whitespace_with_single_character(char *str, char c)
+{
+   for (; *str; str++)
+      if (ISSPACE(*str))
+         *str = c;
+}
+
+/**
+ * string_replace_multi_space_with_single_space:
+ *
+ * Leaf function.
+ *
+ * Replaces multiple spaces with a single space in a string.
+ **/
+void string_replace_multi_space_with_single_space(char *str)
+{
+   char *str_trimmed  = str;
+   bool prev_is_space = false;
+   bool curr_is_space = false;
+
+   for (; *str; str++)
+   {
+      curr_is_space  = ISSPACE(*str);
+      if (prev_is_space && curr_is_space)
+         continue;
+      *str_trimmed++ = *str;
+      prev_is_space  = curr_is_space;
+   }
+   *str_trimmed = '\0';
+}
+
+/**
+ * string_remove_all_whitespace:
+ *
+ * Leaf function.
+ *
+ * Remove all spaces from the given string.
+ **/
+void string_remove_all_whitespace(char *str_trimmed, const char *str)
+{
+   for (; *str; str++)
+      if (!ISSPACE(*str))
+         *str_trimmed++ = *str;
+   *str_trimmed = '\0';
+}
+
+/**
+ * Retrieve the last occurance of the given character in a string.
+ */
+int string_index_last_occurance(const char *str, char c)
+{
+   const char *pos = strrchr(str, c);
+   if (pos)
+      return (int)(pos - str);
+   return -1;
+}
+
+/**
+ * string_find_index_substring_string:
+ * @str                : input string (must be non-NULL, otherwise UB)
+ * @substr             : substring to find in @str
+ *
+ * Find the position of substring @substr in string @str.
+ **/
+int string_find_index_substring_string(const char *str, const char *substr)
+{
+   const char *pos = strstr(str, substr);
+   if (pos)
+      return (int)(pos - str);
+   return -1;
+}
+
+/**
+ * string_copy_only_ascii:
+ *
+ * Leaf function.
+ *
+ * Strips non-ASCII characters from a string.
+ **/
+void string_copy_only_ascii(char *str_stripped, const char *str)
+{
+   for (; *str; str++)
+      if (*str > 0x1F && *str < 0x7F)
+         *str_stripped++ = *str;
+   *str_stripped = '\0';
+}
diff --git a/src/libretro/libretro-common/time/rtime.c b/src/libretro/libretro-common/time/rtime.c
new file mode 100644
index 0000000000..fee0dabcb7
--- /dev/null
+++ b/src/libretro/libretro-common/time/rtime.c
@@ -0,0 +1,78 @@
+/* Copyright  (C) 2010-2020 The RetroArch team
+ *
+ * ---------------------------------------------------------------------------------------
+ * The following license statement only applies to this file (rtime.c).
+ * ---------------------------------------------------------------------------------------
+ *
+ * Permission is hereby granted, free of charge,
+ * to any person obtaining a copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifdef HAVE_THREADS
+#include <rthreads/rthreads.h>
+#include <stdlib.h>
+#endif
+
+#include <string.h>
+#include <time/rtime.h>
+
+#ifdef HAVE_THREADS
+/* TODO/FIXME - global */
+slock_t *rtime_localtime_lock = NULL;
+#endif
+
+/* Must be called before using rtime_localtime() */
+void rtime_init(void)
+{
+   rtime_deinit();
+#ifdef HAVE_THREADS
+   if (!rtime_localtime_lock)
+      rtime_localtime_lock = slock_new();
+#endif
+}
+
+/* Must be called upon program termination */
+void rtime_deinit(void)
+{
+#ifdef HAVE_THREADS
+   if (rtime_localtime_lock)
+   {
+      slock_free(rtime_localtime_lock);
+      rtime_localtime_lock = NULL;
+   }
+#endif
+}
+
+/* Thread-safe wrapper for localtime() */
+struct tm *rtime_localtime(const time_t *timep, struct tm *result)
+{
+   struct tm *time_info = NULL;
+
+   /* Lock mutex */
+#ifdef HAVE_THREADS
+   slock_lock(rtime_localtime_lock);
+#endif
+
+   time_info = localtime(timep);
+   if (time_info)
+      memcpy(result, time_info, sizeof(struct tm));
+
+   /* Unlock mutex */
+#ifdef HAVE_THREADS
+   slock_unlock(rtime_localtime_lock);
+#endif
+
+   return result;
+}
diff --git a/src/libretro/libretro-common/utils/md5.c b/src/libretro/libretro-common/utils/md5.c
index 34b3a7e3a1..5deb03ce5b 100644
--- a/src/libretro/libretro-common/utils/md5.c
+++ b/src/libretro/libretro-common/utils/md5.c
@@ -34,7 +34,7 @@
  * optimizations are not included to reduce source code size and avoid
  * compile-time configuration.
  */
-#include <rhash.h>
+#include <lrc_hash.h>
 
 #include <string.h>
 
@@ -293,54 +293,3 @@ void MD5_Final(unsigned char *result, MD5_CTX *ctx)
 
 	memset(ctx, 0, sizeof(*ctx));
 }
-
-#ifdef MD5_BUILD_UTILITY
-
-#include <stdio.h>
-
-int main (int argc, char *argv[])
-{
-   /* For each command line argument in turn:
-    ** filename          -- prints message digest and name of file
-    */
-   int i;
-   MD5_CTX ctx;
-   FILE* file;
-   size_t numread;
-   char buffer[16384];
-   unsigned char result[16];
-
-   for (i = 1; i < argc; i++)
-   {
-      MD5_Init(&ctx);
-      file = fopen(argv[i], "rb");
-
-      if (file)
-      {
-         do
-         {
-            numread = fread((void*)buffer, 1, sizeof(buffer), file);
-
-            if (numread)
-            {
-               MD5_Update(&ctx,(void*)buffer, numread);
-            }
-         }
-         while (numread);
-
-         fclose(file);
-         MD5_Final(result, &ctx);
-         printf("%02x%02x%02x%02x%02x%02x%02x%02x"
-			          "%02x%02x%02x%02x%02x%02x%02x%02x %s\n",
-			          result[ 0 ], result[ 1 ], result[ 2 ], result[ 3 ],
-                result[ 4 ], result[ 5 ], result[ 6 ], result[ 7 ],
-                result[ 8 ], result[ 9 ], result[ 10 ], result[ 11 ],
-                result[ 12 ], result[ 13 ], result[ 14 ], result[ 15 ],
-                argv[i]);
-      }
-   }
-
-   return 0;
-}
-
-#endif
diff --git a/src/libretro/libretro-common/utils/sha1.c b/src/libretro/libretro-common/utils/sha1.c
index 419b3f0c47..3c743cb857 100644
--- a/src/libretro/libretro-common/utils/sha1.c
+++ b/src/libretro/libretro-common/utils/sha1.c
@@ -277,7 +277,7 @@ void SHA1ProcessMessageBlock(SHA1Context *context)
    /*
     *  Initialize the first 16 words in the array W
     */
-   for(t = 0; t < 16; t++)
+   for (t = 0; t < 16; t++)
    {
       W[t] = ((unsigned) context->Message_Block[t * 4]) << 24;
       W[t] |= ((unsigned) context->Message_Block[t * 4 + 1]) << 16;
@@ -285,10 +285,8 @@ void SHA1ProcessMessageBlock(SHA1Context *context)
       W[t] |= ((unsigned) context->Message_Block[t * 4 + 3]);
    }
 
-   for(t = 16; t < 80; t++)
-   {
+   for (t = 16; t < 80; t++)
       W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);
-   }
 
    A = context->Message_Digest[0];
    B = context->Message_Digest[1];
@@ -296,7 +294,7 @@ void SHA1ProcessMessageBlock(SHA1Context *context)
    D = context->Message_Digest[3];
    E = context->Message_Digest[4];
 
-   for(t = 0; t < 20; t++)
+   for (t = 0; t < 20; t++)
    {
       temp =  SHA1CircularShift(5,A) +
          ((B & C) | ((~B) & D)) + E + W[t] + K[0];
@@ -308,7 +306,7 @@ void SHA1ProcessMessageBlock(SHA1Context *context)
       A = temp;
    }
 
-   for(t = 20; t < 40; t++)
+   for (t = 20; t < 40; t++)
    {
       temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1];
       temp &= 0xFFFFFFFF;
@@ -319,7 +317,7 @@ void SHA1ProcessMessageBlock(SHA1Context *context)
       A = temp;
    }
 
-   for(t = 40; t < 60; t++)
+   for (t = 40; t < 60; t++)
    {
       temp = SHA1CircularShift(5,A) +
          ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];
@@ -331,7 +329,7 @@ void SHA1ProcessMessageBlock(SHA1Context *context)
       A = temp;
    }
 
-   for(t = 60; t < 80; t++)
+   for (t = 60; t < 80; t++)
    {
       temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3];
       temp &= 0xFFFFFFFF;
diff --git a/src/libretro/libretro-common/vfs/vfs_implementation.c b/src/libretro/libretro-common/vfs/vfs_implementation.c
index 9a139f6a33..2d958fe05f 100644
--- a/src/libretro/libretro-common/vfs/vfs_implementation.c
+++ b/src/libretro/libretro-common/vfs/vfs_implementation.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2019 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
 *
 * ---------------------------------------------------------------------------------------
 * The following license statement only applies to this file (vfs_implementation.c).
@@ -26,7 +26,7 @@
 #include <errno.h>
 #include <sys/types.h>
 
-#include <string/stdstring.h>
+#include <string/stdstring.h> /* string_is_empty */
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
@@ -51,58 +51,35 @@
 #  if defined(PSP)
 #    include <pspiofilemgr.h>
 #  endif
-#  if defined(PS2)
-#    include <fileXio_rpc.h>
-#    include <fileXio_cdvd.h>
-#  endif
 #  include <sys/types.h>
 #  include <sys/stat.h>
 #  if !defined(VITA)
 #  include <dirent.h>
 #  endif
 #  include <unistd.h>
-#  if defined(ORBIS)
-#  include <sys/fcntl.h>
-#  include <sys/dirent.h>
-#  include <orbisFile.h>
+#  if defined(WIIU)
+#  include <malloc.h>
 #  endif
 #endif
 
-#ifdef __CELLOS_LV2__
-#include <cell/cell_fs.h>
-#define O_RDONLY CELL_FS_O_RDONLY
-#define O_WRONLY CELL_FS_O_WRONLY
-#define O_CREAT CELL_FS_O_CREAT
-#define O_TRUNC CELL_FS_O_TRUNC
-#define O_RDWR CELL_FS_O_RDWR
-#else
 #include <fcntl.h>
-#endif
 
 /* TODO: Some things are duplicated but I'm really afraid of breaking other platforms by touching this */
 #if defined(VITA)
 #  include <psp2/io/fcntl.h>
 #  include <psp2/io/dirent.h>
 #  include <psp2/io/stat.h>
-#elif defined(ORBIS)
-#  include <orbisFile.h>
-#  include <ps4link.h>
-#  include <sys/dirent.h>
-#  include <sys/fcntl.h>
 #elif !defined(_WIN32)
 #  if defined(PSP)
 #    include <pspiofilemgr.h>
 #  endif
-#  if defined(PS2)
-#    include <fileXio_rpc.h>
-#  endif
 #  include <sys/types.h>
 #  include <sys/stat.h>
 #  include <dirent.h>
 #  include <unistd.h>
 #endif
 
-#if (defined(__CELLOS_LV2__) && !defined(__PSL1GHT__)) || defined(__QNX__) || defined(PSP) || defined(PS2)
+#if defined(__QNX__) || defined(PSP)
 #include <unistd.h> /* stat() is defined here */
 #endif
 
@@ -137,29 +114,74 @@
 #include <unistd.h>
 #endif
 
-#if defined(ORBIS)
-#include <orbisFile.h>
-#include <sys/fcntl.h>
-#include <sys/dirent.h>
-#endif
+
 #if defined(PSP)
 #include <pspkernel.h>
 #endif
 
-#if defined(PS2)
-#include <fileXio_rpc.h>
-#include <fileXio.h>
+#if defined(__PS3__) || defined(__PSL1GHT__)
+#define FS_SUCCEEDED 0
+#define FS_TYPE_DIR 1
+#ifdef __PSL1GHT__
+#include <lv2/sysfs.h>
+#ifndef O_RDONLY
+#define O_RDONLY SYS_O_RDONLY
 #endif
-
-#if defined(__CELLOS_LV2__)
+#ifndef O_WRONLY
+#define O_WRONLY SYS_O_WRONLY
+#endif
+#ifndef O_CREAT
+#define O_CREAT SYS_O_CREAT
+#endif
+#ifndef O_TRUNC
+#define O_TRUNC SYS_O_TRUNC
+#endif
+#ifndef O_RDWR
+#define O_RDWR SYS_O_RDWR
+#endif
+#else
 #include <cell/cell_fs.h>
+#ifndef O_RDONLY
+#define O_RDONLY CELL_FS_O_RDONLY
+#endif
+#ifndef O_WRONLY
+#define O_WRONLY CELL_FS_O_WRONLY
+#endif
+#ifndef O_CREAT
+#define O_CREAT CELL_FS_O_CREAT
+#endif
+#ifndef O_TRUNC
+#define O_TRUNC CELL_FS_O_TRUNC
+#endif
+#ifndef O_RDWR
+#define O_RDWR CELL_FS_O_RDWR
+#endif
+#ifndef sysFsStat
+#define sysFsStat cellFsStat
+#endif
+#ifndef sysFSDirent
+#define sysFSDirent CellFsDirent
+#endif
+#ifndef sysFsOpendir
+#define sysFsOpendir cellFsOpendir
+#endif
+#ifndef sysFsReaddir
+#define sysFsReaddir cellFsReaddir
+#endif
+#ifndef sysFSDirent
+#define sysFSDirent CellFsDirent
+#endif
+#ifndef sysFsClosedir
+#define sysFsClosedir cellFsClosedir
+#endif
+#endif
 #endif
 
 #if defined(VITA)
 #define FIO_S_ISDIR SCE_S_ISDIR
 #endif
 
-#if (defined(__CELLOS_LV2__) && !defined(__PSL1GHT__)) || defined(__QNX__) || defined(PSP)
+#if defined(__QNX__) || defined(PSP)
 #include <unistd.h> /* stat() is defined here */
 #endif
 
@@ -173,14 +195,16 @@
 #endif
 
 #if defined(_WIN32)
-#if !defined(_MSC_VER) || (defined(_MSC_VER) && _MSC_VER >= 1400)
+#if defined(_MSC_VER) && _MSC_VER >= 1400
 #define ATLEAST_VC2005
 #endif
 #endif
 
 #include <vfs/vfs_implementation.h>
 #include <libretro.h>
+#if defined(HAVE_MMAP)
 #include <memmap.h>
+#endif
 #include <encodings/utf.h>
 #include <compat/fopen_utf8.h>
 #include <file/file_path.h>
@@ -189,9 +213,17 @@
 #include <vfs/vfs_implementation_cdrom.h>
 #endif
 
+#if (defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE - 0) >= 200112) || (defined(__POSIX_VISIBLE) && __POSIX_VISIBLE >= 200112) || (defined(_POSIX_VERSION) && _POSIX_VERSION >= 200112) || __USE_LARGEFILE || (defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS == 64)
+#ifndef HAVE_64BIT_OFFSETS
+#define HAVE_64BIT_OFFSETS
+#endif
+#endif
+
 #define RFILE_HINT_UNBUFFERED (1 << 8)
 
-int64_t retro_vfs_file_seek_internal(libretro_vfs_implementation_file *stream, int64_t offset, int whence)
+int64_t retro_vfs_file_seek_internal(
+      libretro_vfs_implementation_file *stream,
+      int64_t offset, int whence)
 {
    if (!stream)
       return -1;
@@ -202,28 +234,13 @@ int64_t retro_vfs_file_seek_internal(libretro_vfs_implementation_file *stream, i
       if (stream->scheme == VFS_SCHEME_CDROM)
          return retro_vfs_file_seek_cdrom(stream, offset, whence);
 #endif
-/* VC2005 and up have a special 64-bit fseek */
 #ifdef ATLEAST_VC2005
+      /* VC2005 and up have a special 64-bit fseek */
       return _fseeki64(stream->fp, offset, whence);
-#elif defined(__CELLOS_LV2__) || defined(_MSC_VER) && _MSC_VER <= 1310
-      return fseek(stream->fp, (long)offset, whence);
-#elif defined(PS2)
-      {
-         int64_t ret = fileXioLseek(fileno(stream->fp), (off_t)offset, whence);
-         /* fileXioLseek could return positive numbers */
-         if (ret > 0)
-            return 0;
-         return ret;
-      }
-#elif defined(ORBIS)
-      {
-         int ret = orbisLseek(stream->fd, offset, whence);
-         if (ret < 0)
-            return -1;
-         return 0;
-      }
-#else
+#elif defined(HAVE_64BIT_OFFSETS)
       return fseeko(stream->fp, (off_t)offset, whence);
+#else
+      return fseek(stream->fp, (long)offset, whence);
 #endif
    }
 #ifdef HAVE_MMAP
@@ -263,7 +280,7 @@ int64_t retro_vfs_file_seek_internal(libretro_vfs_implementation_file *stream, i
    }
 #endif
 
-   if (lseek(stream->fd, offset, whence) < 0)
+   if (lseek(stream->fd, (off_t)offset, whence) < 0)
       return -1;
 
    return 0;
@@ -284,45 +301,72 @@ libretro_vfs_implementation_file *retro_vfs_file_open_impl(
 {
    int                                flags = 0;
    const char                     *mode_str = NULL;
-   int                             path_len = (int)strlen(path);
-   libretro_vfs_implementation_file *stream = (libretro_vfs_implementation_file*)
-      calloc(1, sizeof(*stream));
+   libretro_vfs_implementation_file *stream =
+      (libretro_vfs_implementation_file*)
+      malloc(sizeof(*stream));
 
-#ifdef VFS_FRONTEND
-   const char                 *dumb_prefix  = "vfsonly://";
-   size_t                   dumb_prefix_siz = strlen(dumb_prefix);
-   int                      dumb_prefix_len = (int)dumb_prefix_siz;
+   if (!stream)
+      return NULL;
 
-   if (path_len >= dumb_prefix_len)
-   {
-      if (!memcmp(path, dumb_prefix, dumb_prefix_len))
-         path += dumb_prefix_siz;
-   }
+   stream->fd                     = 0;
+   stream->hints                  = hints;
+   stream->size                   = 0;
+   stream->buf                    = NULL;
+   stream->fp                     = NULL;
+#ifdef _WIN32
+   stream->fh                     = 0;
+#endif
+   stream->orig_path              = NULL;
+   stream->mappos                 = 0;
+   stream->mapsize                = 0;
+   stream->mapped                 = NULL;
+   stream->scheme                 = VFS_SCHEME_NONE;
+
+#ifdef VFS_FRONTEND
+   if (     path
+         && path[0] == 'v'
+         && path[1] == 'f'
+         && path[2] == 's'
+         && path[3] == 'o'
+         && path[4] == 'n'
+         && path[5] == 'l'
+         && path[6] == 'y'
+         && path[7] == ':'
+         && path[8] == '/'
+         && path[9] == '/')
+         path             += sizeof("vfsonly://")-1;
 #endif
 
 #ifdef HAVE_CDROM
+   stream->cdrom.cue_buf          = NULL;
+   stream->cdrom.cue_len          = 0;
+   stream->cdrom.byte_pos         = 0;
+   stream->cdrom.drive            = 0;
+   stream->cdrom.cur_min          = 0;
+   stream->cdrom.cur_sec          = 0;
+   stream->cdrom.cur_frame        = 0;
+   stream->cdrom.cur_track        = 0;
+   stream->cdrom.cur_lba          = 0;
+   stream->cdrom.last_frame_lba   = 0;
+   stream->cdrom.last_frame[0]    = '\0';
+   stream->cdrom.last_frame_valid = false;
+
+   if (     path
+         && path[0] == 'c'
+         && path[1] == 'd'
+         && path[2] == 'r'
+         && path[3] == 'o'
+         && path[4] == 'm'
+         && path[5] == ':'
+         && path[6] == '/'
+         && path[7] == '/'
+         && path[8] != '\0')
    {
-      const char *cdrom_prefix = "cdrom://";
-      size_t cdrom_prefix_siz = strlen(cdrom_prefix);
-      int cdrom_prefix_len = (int)cdrom_prefix_siz;
-
-      if (path_len > cdrom_prefix_len)
-      {
-         if (!memcmp(path, cdrom_prefix, cdrom_prefix_len))
-         {
-            path += cdrom_prefix_siz;
-            stream->scheme = VFS_SCHEME_CDROM;
-         }
-      }
+      path             += sizeof("cdrom://")-1;
+      stream->scheme    = VFS_SCHEME_CDROM;
    }
 #endif
 
-   if (!stream)
-      return NULL;
-
-   (void)flags;
-
-   stream->hints           = hints;
    stream->orig_path       = strdup(path);
 
 #ifdef HAVE_MMAP
@@ -347,28 +391,20 @@ libretro_vfs_implementation_file *retro_vfs_file_open_impl(
          mode_str = "wb";
 
          flags    = O_WRONLY | O_CREAT | O_TRUNC;
-#if !defined(ORBIS)
-#if defined(PS2)
-         flags   |= FIO_S_IRUSR | FIO_S_IWUSR;
-#elif !defined(_WIN32)
+#if !defined(_WIN32)
          flags   |= S_IRUSR | S_IWUSR;
 #else
          flags   |= O_BINARY;
-#endif
 #endif
          break;
 
       case RETRO_VFS_FILE_ACCESS_READ_WRITE:
          mode_str = "w+b";
          flags    = O_RDWR | O_CREAT | O_TRUNC;
-#if !defined(ORBIS)
-#if defined(PS2)
-         flags   |= FIO_S_IRUSR | FIO_S_IWUSR;
-#elif !defined(_WIN32)
+#if !defined(_WIN32)
          flags   |= S_IRUSR | S_IWUSR;
 #else
          flags   |= O_BINARY;
-#endif
 #endif
          break;
 
@@ -377,14 +413,10 @@ libretro_vfs_implementation_file *retro_vfs_file_open_impl(
          mode_str = "r+b";
 
          flags    = O_RDWR;
-#if !defined(ORBIS)
-#if defined(PS2)
-         flags   |= FIO_S_IRUSR | FIO_S_IWUSR;
-#elif !defined(_WIN32)
+#if !defined(_WIN32)
          flags   |= S_IRUSR | S_IWUSR;
 #else
          flags   |= O_BINARY;
-#endif
 #endif
          break;
 
@@ -394,15 +426,6 @@ libretro_vfs_implementation_file *retro_vfs_file_open_impl(
 
    if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0)
    {
-#ifdef ORBIS
-      int fd = orbisOpen(path, flags, 0644);
-      if (fd < 0)
-      {
-         stream->fd = -1;
-         goto error;
-      }
-      stream->fd = fd;
-#else
       FILE *fp;
 #ifdef HAVE_CDROM
       if (stream->scheme == VFS_SCHEME_CDROM)
@@ -419,31 +442,43 @@ libretro_vfs_implementation_file *retro_vfs_file_open_impl(
       else
 #endif
       {
-         fp = (FILE*)fopen_utf8(path, mode_str);
-
-         if (!fp)
+         if (!(fp = (FILE*)fopen_utf8(path, mode_str)))
             goto error;
 
          stream->fp  = fp;
       }
+
       /* Regarding setvbuf:
        *
        * https://www.freebsd.org/cgi/man.cgi?query=setvbuf&apropos=0&sektion=0&manpath=FreeBSD+11.1-RELEASE&arch=default&format=html
        *
-       * If the size argument is not zero but buf is NULL, a buffer of the given size will be allocated immediately, and
+       * If the size argument is not zero but buf is NULL,
+       * a buffer of the given size will be allocated immediately, and
        * released on close. This is an extension to ANSI C.
        *
-       * Since C89 does not support specifying a null buffer with a non-zero size, we create and track our own buffer for it.
+       * Since C89 does not support specifying a NULL buffer
+       * with a non-zero size, we create and track our own buffer for it.
        */
-      /* TODO: this is only useful for a few platforms, find which and add ifdef */
-#if !defined(PS2) && !defined(PSP)
+      /* TODO: this is only useful for a few platforms,
+       * find which and add ifdef */
+#if defined(_3DS)
       if (stream->scheme != VFS_SCHEME_CDROM)
       {
+         stream->buf = (char*)calloc(1, 0x10000);
+         if (stream->fp)
+            setvbuf(stream->fp, stream->buf, _IOFBF, 0x10000);
+      }
+#elif defined(WIIU)
+      if (stream->scheme != VFS_SCHEME_CDROM)
+      {
+         const int bufsize = 128 * 1024;
+         stream->buf = (char*)memalign(0x40, bufsize);
+         if (stream->fp)
+            setvbuf(stream->fp, stream->buf, _IOFBF, bufsize);
          stream->buf = (char*)calloc(1, 0x4000);
          if (stream->fp)
             setvbuf(stream->fp, stream->buf, _IOFBF, 0x4000);
       }
-#endif
 #endif
    }
    else
@@ -479,18 +514,12 @@ libretro_vfs_implementation_file *retro_vfs_file_open_impl(
 
          retro_vfs_file_seek_internal(stream, 0, SEEK_SET);
 
-         stream->mapped = (uint8_t*)mmap((void*)0,
-               stream->mapsize, PROT_READ,  MAP_SHARED, stream->fd, 0);
-
-         if (stream->mapped == MAP_FAILED)
+         if ((stream->mapped = (uint8_t*)mmap((void*)0,
+               stream->mapsize, PROT_READ,  MAP_SHARED, stream->fd, 0)) == MAP_FAILED)
             stream->hints &= ~RETRO_VFS_FILE_ACCESS_HINT_FREQUENT_ACCESS;
       }
 #endif
    }
-#ifdef ORBIS
-   stream->size = orbisLseek(stream->fd, 0, SEEK_END);
-   orbisLseek(stream->fd, 0, SEEK_SET);
-#else
 #ifdef HAVE_CDROM
    if (stream->scheme == VFS_SCHEME_CDROM)
    {
@@ -511,7 +540,6 @@ libretro_vfs_implementation_file *retro_vfs_file_open_impl(
 
       retro_vfs_file_seek_internal(stream, 0, SEEK_SET);
    }
-#endif
    return stream;
 
 error:
@@ -535,9 +563,7 @@ int retro_vfs_file_close_impl(libretro_vfs_implementation_file *stream)
    if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0)
    {
       if (stream->fp)
-      {
          fclose(stream->fp);
-      }
    }
    else
    {
@@ -548,14 +574,7 @@ int retro_vfs_file_close_impl(libretro_vfs_implementation_file *stream)
    }
 
    if (stream->fd > 0)
-   {
-#ifdef ORBIS
-      orbisClose(stream->fd);
-      stream->fd = -1;
-#else
       close(stream->fd);
-#endif
-   }
 #ifdef HAVE_CDROM
 end:
    if (stream->cdrom.cue_buf)
@@ -578,12 +597,7 @@ int retro_vfs_file_error_impl(libretro_vfs_implementation_file *stream)
    if (stream->scheme == VFS_SCHEME_CDROM)
       return retro_vfs_file_error_cdrom(stream);
 #endif
-#ifdef ORBIS
-   /* TODO/FIXME - implement this? */
-   return 0;
-#else
    return ferror(stream->fp);
-#endif
 }
 
 int64_t retro_vfs_file_size_impl(libretro_vfs_implementation_file *stream)
@@ -595,18 +609,20 @@ int64_t retro_vfs_file_size_impl(libretro_vfs_implementation_file *stream)
 
 int64_t retro_vfs_file_truncate_impl(libretro_vfs_implementation_file *stream, int64_t length)
 {
-   if (!stream)
-      return -1;
-
 #ifdef _WIN32
-   if (_chsize(_fileno(stream->fp), length) != 0)
-      return -1;
+   if (stream && _chsize(_fileno(stream->fp), length) == 0)
+   {
+	   stream->size = length;
+	   return 0;
+   }
 #elif !defined(VITA) && !defined(PSP) && !defined(PS2) && !defined(ORBIS) && (!defined(SWITCH) || defined(HAVE_LIBNX))
-   if (ftruncate(fileno(stream->fp), length) != 0)
-      return -1;
+   if (stream && ftruncate(fileno(stream->fp), (off_t)length) == 0)
+   {
+      stream->size = length;
+      return 0;
+   }
 #endif
-
-   return 0;
+   return -1;
 }
 
 int64_t retro_vfs_file_tell_impl(libretro_vfs_implementation_file *stream)
@@ -620,26 +636,20 @@ int64_t retro_vfs_file_tell_impl(libretro_vfs_implementation_file *stream)
       if (stream->scheme == VFS_SCHEME_CDROM)
          return retro_vfs_file_tell_cdrom(stream);
 #endif
-#ifdef ORBIS
-      {
-         int64_t ret = orbisLseek(stream->fd, 0, SEEK_CUR);
-         if (ret < 0)
-            return -1;
-         return ret;
-      }
-#else
-      /* VC2005 and up have a special 64-bit ftell */
 #ifdef ATLEAST_VC2005
+      /* VC2005 and up have a special 64-bit ftell */
       return _ftelli64(stream->fp);
+#elif defined(HAVE_64BIT_OFFSETS)
+      return ftello(stream->fp);
 #else
       return ftell(stream->fp);
-#endif
 #endif
    }
 #ifdef HAVE_MMAP
    /* Need to check stream->mapped because this function
     * is called in filestream_open() */
-   if (stream->mapped && stream->hints & RETRO_VFS_FILE_ACCESS_HINT_FREQUENT_ACCESS)
+   if (stream->mapped && stream->hints &
+         RETRO_VFS_FILE_ACCESS_HINT_FREQUENT_ACCESS)
       return stream->mappos;
 #endif
    if (lseek(stream->fd, 0, SEEK_CUR) < 0)
@@ -651,21 +661,7 @@ int64_t retro_vfs_file_tell_impl(libretro_vfs_implementation_file *stream)
 int64_t retro_vfs_file_seek_impl(libretro_vfs_implementation_file *stream,
       int64_t offset, int seek_position)
 {
-   int whence = -1;
-   switch (seek_position)
-   {
-      case RETRO_VFS_SEEK_POSITION_START:
-         whence = SEEK_SET;
-         break;
-      case RETRO_VFS_SEEK_POSITION_CURRENT:
-         whence = SEEK_CUR;
-         break;
-      case RETRO_VFS_SEEK_POSITION_END:
-         whence = SEEK_END;
-         break;
-   }
-
-   return retro_vfs_file_seek_internal(stream, offset, whence);
+   return retro_vfs_file_seek_internal(stream, offset, seek_position);
 }
 
 int64_t retro_vfs_file_read_impl(libretro_vfs_implementation_file *stream,
@@ -680,13 +676,7 @@ int64_t retro_vfs_file_read_impl(libretro_vfs_implementation_file *stream,
       if (stream->scheme == VFS_SCHEME_CDROM)
          return retro_vfs_file_read_cdrom(stream, s, len);
 #endif
-#ifdef ORBIS
-      if (orbisRead(stream->fd, s, (size_t)len) < 0)
-         return -1;
-      return 0;
-#else
       return fread(s, 1, (size_t)len, stream->fp);
-#endif
    }
 #ifdef HAVE_MMAP
    if (stream->hints & RETRO_VFS_FILE_ACCESS_HINT_FREQUENT_ACCESS)
@@ -709,83 +699,80 @@ int64_t retro_vfs_file_read_impl(libretro_vfs_implementation_file *stream,
 
 int64_t retro_vfs_file_write_impl(libretro_vfs_implementation_file *stream, const void *s, uint64_t len)
 {
+   int64_t pos    = 0;
+   ssize_t result = -1;
+
    if (!stream)
       return -1;
 
    if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0)
    {
-#ifdef ORBIS
-      if (orbisWrite(stream->fd, s, (size_t)len) < 0)
-         return -1;
-      return 0;
-#else
-      return fwrite(s, 1, (size_t)len, stream->fp);
-#endif
-   }
+      pos    = retro_vfs_file_tell_impl(stream);
+      result = fwrite(s, 1, (size_t)len, stream->fp);
 
+      if (result != -1 && pos + result > stream->size)
+         stream->size = pos + result;
+
+      return result;
+   }
 #ifdef HAVE_MMAP
    if (stream->hints & RETRO_VFS_FILE_ACCESS_HINT_FREQUENT_ACCESS)
       return -1;
 #endif
-   return write(stream->fd, s, (size_t)len);
+
+   pos    = retro_vfs_file_tell_impl(stream);
+   result = write(stream->fd, s, (size_t)len);
+
+   if (result != -1 && pos + result > stream->size)
+      stream->size = pos + result;
+
+   return result;
 }
 
 int retro_vfs_file_flush_impl(libretro_vfs_implementation_file *stream)
 {
-   if (!stream)
-      return -1;
-#ifdef ORBIS
-   return 0;
-#else
-   return fflush(stream->fp) == 0 ? 0 : -1;
-#endif
+   if (stream && fflush(stream->fp) == 0)
+      return 0;
+   return -1;
 }
 
 int retro_vfs_file_remove_impl(const char *path)
 {
+   if (path && *path)
+   {
+      int ret          = -1;
 #if defined(_WIN32) && !defined(_XBOX)
-   /* Win32 (no Xbox) */
-
+      /* Win32 (no Xbox) */
 #if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0500
-   char *path_local    = NULL;
+      char *path_local = NULL;
+      if ((path_local = utf8_to_local_string_alloc(path)))
+      {
+         /* We need to check if path is a directory */
+         if ((retro_vfs_stat_impl(path, NULL) & RETRO_VFS_STAT_IS_DIRECTORY) != 0)
+            ret = _rmdir(path_local);
+         else
+            ret = remove(path_local);
+         free(path_local);
+      }
 #else
-   wchar_t *path_wide  = NULL;
+      wchar_t *path_wide = NULL;
+      if ((path_wide = utf8_to_utf16_string_alloc(path)))
+      {
+         /* We need to check if path is a directory */
+         if ((retro_vfs_stat_impl(path, NULL) & RETRO_VFS_STAT_IS_DIRECTORY) != 0)
+            ret = _wrmdir(path_wide);
+         else
+            ret = _wremove(path_wide);
+         free(path_wide);
+      }
 #endif
-   if (!path || !*path)
-      return -1;
-#if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0500
-   path_local = utf8_to_local_string_alloc(path);
-
-   if (path_local)
-   {
-      int ret = remove(path_local);
-      free(path_local);
-
-      if (ret == 0)
-         return 0;
-   }
 #else
-   path_wide = utf8_to_utf16_string_alloc(path);
-
-   if (path_wide)
-   {
-      int ret = _wremove(path_wide);
-      free(path_wide);
-
+      ret = remove(path);
+#endif
       if (ret == 0)
          return 0;
    }
-#endif
    return -1;
-#elif defined(ORBIS)
-   /* Orbis
-    * TODO/FIXME - stub for now */
-   return 0;
-#else
-   if (remove(path) == 0)
-      return 0;
-   return -1;
-#endif
 }
 
 int retro_vfs_file_rename_impl(const char *old_path, const char *new_path)
@@ -837,13 +824,6 @@ int retro_vfs_file_rename_impl(const char *old_path, const char *new_path)
 #endif
    return ret;
 
-#elif defined(ORBIS)
-   /* Orbis */
-   /* TODO/FIXME - Stub for now */
-   if (!old_path || !*old_path || !new_path || !*new_path)
-      return -1;
-   return 0;
-
 #else
    /* Every other platform */
    if (!old_path || !*old_path || !new_path || !*new_path)
@@ -863,175 +843,123 @@ const char *retro_vfs_file_get_path_impl(
 
 int retro_vfs_stat_impl(const char *path, int32_t *size)
 {
-#if defined(VITA) || defined(PSP)
-   /* Vita / PSP */
-   SceIoStat buf;
-   int stat_ret;
-   bool is_dir               = false;
-   bool is_character_special = false;
-   char *tmp                 = NULL;
-   size_t len                = 0;
-
-   if (!path || !*path)
-      return 0;
-
-   tmp                       = strdup(path);
-   len                       = strlen(tmp);
-   if (tmp[len-1] == '/')
-      tmp[len-1] = '\0';
-
-   stat_ret = sceIoGetstat(tmp, &buf);
-   free(tmp);
-   if (stat_ret < 0)
-      return 0;
-
-   if (size)
-      *size = (int32_t)buf.st_size;
-
-   is_dir = FIO_S_ISDIR(buf.st_mode);
-
-   return RETRO_VFS_STAT_IS_VALID | (is_dir ? RETRO_VFS_STAT_IS_DIRECTORY : 0) | (is_character_special ? RETRO_VFS_STAT_IS_CHARACTER_SPECIAL : 0);
-
-#elif defined(ORBIS)
-   /* Orbis */
-   bool is_dir, is_character_special;
-   int dir_ret;
+   int ret                   = RETRO_VFS_STAT_IS_VALID;
 
    if (!path || !*path)
       return 0;
-
-   if (size)
-      *size = (int32_t)buf.st_size;
-
-   dir_ret = orbisDopen(path);
-   is_dir  = dir_ret > 0;
-   orbisDclose(dir_ret);
-
-   is_character_special = S_ISCHR(buf.st_mode);
-
-   return RETRO_VFS_STAT_IS_VALID | (is_dir ? RETRO_VFS_STAT_IS_DIRECTORY : 0) | (is_character_special ? RETRO_VFS_STAT_IS_CHARACTER_SPECIAL : 0);
-
-#elif defined(PS2)
-   /* PS2 */
-   iox_stat_t buf;
-   bool is_dir;
-   bool is_character_special = false;
-   char *tmp                 = NULL;
-   size_t len                = 0;
-
-   if (!path || !*path)
-      return 0;
-
-   tmp        = strdup(path);
-   len        = strlen(tmp);
-   if (tmp[len-1] == '/')
-      tmp[len-1] = '\0';
-
-   fileXioGetStat(tmp, &buf);
-   free(tmp);
-
-   if (size)
-      *size = (int32_t)buf.size;
-
-   if (!buf.mode)
    {
-      /* if fileXioGetStat fails */
-      int dir_ret = fileXioDopen(path);
-      is_dir      =  dir_ret > 0;
-      if (is_dir) {
-         fileXioDclose(dir_ret);
-      }
-   }
-   else
-      is_dir = FIO_S_ISDIR(buf.mode);
-
-   return RETRO_VFS_STAT_IS_VALID | (is_dir ? RETRO_VFS_STAT_IS_DIRECTORY : 0) | (is_character_special ? RETRO_VFS_STAT_IS_CHARACTER_SPECIAL : 0);
-
-#elif defined(__CELLOS_LV2__)
-   /* CellOS Lv2 */
-   bool is_dir;
-   bool is_character_special = false;
-   CellFsStat buf;
+#if defined(VITA)
+      /* Vita / PSP */
+      SceIoStat stat_buf;
+      int dir_ret;
+      char *tmp                 = strdup(path);
+      size_t len                = strlen(tmp);
+      if (tmp[len-1] == '/')
+         tmp[len-1]             = '\0';
+
+      dir_ret                   = sceIoGetstat(tmp, &stat_buf);
+      free(tmp);
+      if (dir_ret < 0)
+         return 0;
 
-   if (!path || !*path)
-      return 0;
-   if (cellFsStat(path, &buf) < 0)
-      return 0;
+      if (size)
+         *size                  = (int32_t)stat_buf.st_size;
 
-   if (size)
-      *size = (int32_t)buf.st_size;
+      if (FIO_S_ISDIR(stat_buf.st_mode))
+         ret              |= RETRO_VFS_STAT_IS_DIRECTORY;
+#elif defined(__PSL1GHT__) || defined(__PS3__)
+      /* Lowlevel Lv2 */
+      sysFSStat stat_buf;
 
-   is_dir = ((buf.st_mode & S_IFMT) == S_IFDIR);
+      if (sysFsStat(path, &stat_buf) < 0)
+         return 0;
 
-   return RETRO_VFS_STAT_IS_VALID | (is_dir ? RETRO_VFS_STAT_IS_DIRECTORY : 0) | (is_character_special ? RETRO_VFS_STAT_IS_CHARACTER_SPECIAL : 0);
+      if (size)
+         *size = (int32_t)stat_buf.st_size;
 
+      if ((stat_buf.st_mode & S_IFMT) == S_IFDIR)
+         ret  |= RETRO_VFS_STAT_IS_DIRECTORY;
 #elif defined(_WIN32)
-   /* Windows */
-   bool is_dir;
-   DWORD file_info;
-   struct _stat buf;
-   bool is_character_special = false;
+      /* Windows */
+      struct _stat stat_buf;
 #if defined(LEGACY_WIN32)
-   char *path_local          = NULL;
-#else
-   wchar_t *path_wide        = NULL;
-#endif
+      char *path_local          = utf8_to_local_string_alloc(path);
+      DWORD file_info           = GetFileAttributes(path_local);
 
-   if (!path || !*path)
-      return 0;
-
-#if defined(LEGACY_WIN32)
-   path_local = utf8_to_local_string_alloc(path);
-   file_info  = GetFileAttributes(path_local);
-
-   if (!string_is_empty(path_local))
-      _stat(path_local, &buf);
+      if (!string_is_empty(path_local))
+         _stat(path_local, &stat_buf);
 
-   if (path_local)
-      free(path_local);
+      if (path_local)
+         free(path_local);
 #else
-   path_wide = utf8_to_utf16_string_alloc(path);
-   file_info = GetFileAttributesW(path_wide);
+      wchar_t *path_wide        = utf8_to_utf16_string_alloc(path);
+      DWORD file_info           = GetFileAttributesW(path_wide);
 
-   _wstat(path_wide, &buf);
+      _wstat(path_wide, &stat_buf);
 
-   if (path_wide)
-      free(path_wide);
+      if (path_wide)
+         free(path_wide);
 #endif
+      if (file_info == INVALID_FILE_ATTRIBUTES)
+         return 0;
 
-   if (file_info == INVALID_FILE_ATTRIBUTES)
-      return 0;
+      if (size)
+         *size = (int32_t)stat_buf.st_size;
 
-   if (size)
-      *size = (int32_t)buf.st_size;
+      if (file_info & FILE_ATTRIBUTE_DIRECTORY)
+         ret  |= RETRO_VFS_STAT_IS_DIRECTORY;
+#elif defined(GEKKO)
+      /* On GEKKO platforms, paths cannot have
+       * trailing slashes - we must therefore
+       * remove them */
+      size_t len;
+      char *path_buf = NULL;
+      struct stat stat_buf;
 
-   is_dir = (file_info & FILE_ATTRIBUTE_DIRECTORY);
+      if (!(path_buf = strdup(path)))
+         return 0;
 
-   return RETRO_VFS_STAT_IS_VALID | (is_dir ? RETRO_VFS_STAT_IS_DIRECTORY : 0) | (is_character_special ? RETRO_VFS_STAT_IS_CHARACTER_SPECIAL : 0);
+      if ((len = strlen(path_buf)) > 0)
+         if (path_buf[len - 1] == '/')
+            path_buf[len - 1] = '\0';
 
-#else
-   /* Every other platform */
-   bool is_dir, is_character_special;
-   struct stat buf;
+      if (stat(path_buf, &stat_buf) < 0)
+      {
+         free(path_buf);
+         return 0;
+      }
 
-   if (!path || !*path)
-      return 0;
-   if (stat(path, &buf) < 0)
-      return 0;
+      free(path_buf);
+      
+      if (size)
+         *size = (int32_t)stat_buf.st_size;
 
-   if (size)
-      *size             = (int32_t)buf.st_size;
+      if (S_ISDIR(stat_buf.st_mode))
+         ret |= RETRO_VFS_STAT_IS_DIRECTORY;
+      if (S_ISCHR(stat_buf.st_mode))
+         ret |= RETRO_VFS_STAT_IS_CHARACTER_SPECIAL;
+#else
+      /* Every other platform */
+      struct stat stat_buf;
+
+      if (stat(path, &stat_buf) < 0)
+         return 0;
 
-   is_dir               = S_ISDIR(buf.st_mode);
-   is_character_special = S_ISCHR(buf.st_mode);
+      if (size)
+         *size = (int32_t)stat_buf.st_size;
 
-   return RETRO_VFS_STAT_IS_VALID | (is_dir ? RETRO_VFS_STAT_IS_DIRECTORY : 0) | (is_character_special ? RETRO_VFS_STAT_IS_CHARACTER_SPECIAL : 0);
+      if (S_ISDIR(stat_buf.st_mode))
+         ret |= RETRO_VFS_STAT_IS_DIRECTORY;
+      if (S_ISCHR(stat_buf.st_mode))
+         ret |= RETRO_VFS_STAT_IS_CHARACTER_SPECIAL;
 #endif
+   }
+   return ret;
 }
 
 #if defined(VITA)
 #define path_mkdir_error(ret) (((ret) == SCE_ERROR_ERRNO_EEXIST))
-#elif defined(PSP) || defined(PS2) || defined(_3DS) || defined(WIIU) || defined(SWITCH) || defined(ORBIS)
+#elif defined(PSP) || defined(PS2) || defined(_3DS) || defined(WIIU) || defined(SWITCH)
 #define path_mkdir_error(ret) ((ret) == -1)
 #else
 #define path_mkdir_error(ret) ((ret) < 0 && errno == EEXIST)
@@ -1041,27 +969,45 @@ int retro_vfs_mkdir_impl(const char *dir)
 {
 #if defined(_WIN32)
 #ifdef LEGACY_WIN32
-   int ret       = _mkdir(dir);
+   int ret        = _mkdir(dir);
 #else
-   wchar_t *dirW = utf8_to_utf16_string_alloc(dir);
-   int       ret = -1;
+   wchar_t *dir_w = utf8_to_utf16_string_alloc(dir);
+   int       ret  = -1;
 
-   if (dirW)
+   if (dir_w)
    {
-      ret = _wmkdir(dirW);
-      free(dirW);
+      ret = _wmkdir(dir_w);
+      free(dir_w);
    }
 #endif
 #elif defined(IOS)
    int ret = mkdir(dir, 0755);
-#elif defined(VITA) || defined(PSP)
+#elif defined(VITA)
    int ret = sceIoMkdir(dir, 0777);
-#elif defined(PS2)
-   int ret = fileXioMkdir(dir, 0777);
-#elif defined(ORBIS)
-   int ret = orbisMkdir(dir, 0755);
 #elif defined(__QNX__)
    int ret = mkdir(dir, 0777);
+#elif defined(GEKKO) || defined(WIIU)
+   /* On GEKKO platforms, mkdir() fails if
+    * the path has a trailing slash. We must
+    * therefore remove it. */
+   int ret = -1;
+   if (!string_is_empty(dir))
+   {
+      char *dir_buf = strdup(dir);
+
+      if (dir_buf)
+      {
+         size_t len = strlen(dir_buf);
+
+         if (len > 0)
+            if (dir_buf[len - 1] == '/')
+               dir_buf[len - 1] = '\0';
+
+         ret = mkdir(dir_buf, 0750);
+
+         free(dir_buf);
+      }
+   }
 #else
    int ret = mkdir(dir, 0750);
 #endif
@@ -1087,19 +1033,13 @@ struct libretro_vfs_implementation_dir
    HANDLE directory;
    bool next;
    char path[PATH_MAX_LENGTH];
-#elif defined(VITA) || defined(PSP)
+#elif defined(VITA)
    SceUID directory;
    SceIoDirent entry;
-#elif defined(PS2)
-   int directory;
-   iox_dirent_t entry;
-#elif defined(__CELLOS_LV2__)
-   CellFsErrno error;
-   int directory;
-   CellFsDirent entry;
-#elif defined(ORBIS)
+#elif defined(__PSL1GHT__) || defined(__PS3__)
+   int error;
    int directory;
-   struct dirent entry;
+   sysFSDirent entry;
 #else
    DIR *directory;
    const struct dirent *entry;
@@ -1110,10 +1050,10 @@ static bool dirent_check_error(libretro_vfs_implementation_dir *rdir)
 {
 #if defined(_WIN32)
    return (rdir->directory == INVALID_HANDLE_VALUE);
-#elif defined(VITA) || defined(PSP) || defined(PS2) || defined(ORBIS)
+#elif defined(VITA) || defined(ORBIS)
    return (rdir->directory < 0);
-#elif defined(__CELLOS_LV2__)
-   return (rdir->error != CELL_FS_SUCCEEDED);
+#elif defined(__PSL1GHT__) || defined(__PS3__)
+   return (rdir->error != FS_SUCCEEDED);
 #else
    return !(rdir->directory);
 #endif
@@ -1123,7 +1063,6 @@ libretro_vfs_implementation_dir *retro_vfs_opendir_impl(
       const char *name, bool include_hidden)
 {
 #if defined(_WIN32)
-   unsigned path_len;
    char path_buf[1024];
    size_t copied      = 0;
 #if defined(LEGACY_WIN32)
@@ -1134,28 +1073,25 @@ libretro_vfs_implementation_dir *retro_vfs_opendir_impl(
 #endif
    libretro_vfs_implementation_dir *rdir;
 
-   /*Reject null or empty string paths*/
+   /* Reject NULL or empty string paths*/
    if (!name || (*name == 0))
       return NULL;
 
    /*Allocate RDIR struct. Tidied later with retro_closedir*/
-   rdir = (libretro_vfs_implementation_dir*)calloc(1, sizeof(*rdir));
-   if (!rdir)
+   if (!(rdir = (libretro_vfs_implementation_dir*)
+            calloc(1, sizeof(*rdir))))
       return NULL;
 
    rdir->orig_path       = strdup(name);
 
 #if defined(_WIN32)
-   path_buf[0]           = '\0';
-   path_len              = strlen(name);
-
    copied                = strlcpy(path_buf, name, sizeof(path_buf));
 
    /* Non-NT platforms don't like extra slashes in the path */
-   if (name[path_len - 1] != '\\')
-      path_buf[copied++]   = '\\';
+   if (path_buf[copied - 1] != '\\')
+      path_buf [copied++]  = '\\';
 
-   path_buf[copied]        = '*';
+   path_buf[copied  ]      = '*';
    path_buf[copied+1]      = '\0';
 
 #if defined(LEGACY_WIN32)
@@ -1172,17 +1108,13 @@ libretro_vfs_implementation_dir *retro_vfs_opendir_impl(
       free(path_wide);
 #endif
 
-#elif defined(VITA) || defined(PSP)
+#elif defined(VITA)
    rdir->directory       = sceIoDopen(name);
-#elif defined(PS2)
-   rdir->directory       = ps2fileXioDopen(name);
 #elif defined(_3DS)
    rdir->directory       = !string_is_empty(name) ? opendir(name) : NULL;
    rdir->entry           = NULL;
-#elif defined(__CELLOS_LV2__)
-   rdir->error           = cellFsOpendir(name, &rdir->directory);
-#elif defined(ORBIS)
-   rdir->directory       = orbisDopen(name);
+#elif defined(__PSL1GHT__) || defined(__PS3__)
+   rdir->error           = sysFsOpendir(name, &rdir->directory);
 #else
    rdir->directory       = opendir(name);
    rdir->entry           = NULL;
@@ -1214,19 +1146,12 @@ bool retro_vfs_readdir_impl(libretro_vfs_implementation_dir *rdir)
 
    rdir->next = true;
    return (rdir->directory != INVALID_HANDLE_VALUE);
-#elif defined(VITA) || defined(PSP)
+#elif defined(VITA)
    return (sceIoDread(rdir->directory, &rdir->entry) > 0);
-#elif defined(PS2)
-   iox_dirent_t record;
-   int ret = ps2fileXioDread(rdir->directory, &record);
-   rdir->entry = record;
-   return ( ret > 0);
-#elif defined(__CELLOS_LV2__)
+#elif defined(__PSL1GHT__) || defined(__PS3__)
    uint64_t nread;
-   rdir->error = cellFsReaddir(rdir->directory, &rdir->entry, &nread);
+   rdir->error = sysFsReaddir(rdir->directory, &rdir->entry, &nread);
    return (nread != 0);
-#elif defined(ORBIS)
-   return (orbisDread(rdir->directory, &rdir->entry) > 0);
 #else
    return ((rdir->entry = readdir(rdir->directory)) != NULL);
 #endif
@@ -1236,29 +1161,17 @@ const char *retro_vfs_dirent_get_name_impl(libretro_vfs_implementation_dir *rdir
 {
 #if defined(_WIN32)
 #if defined(LEGACY_WIN32)
-   {
-      char *name_local = local_to_utf8_string_alloc(rdir->entry.cFileName);
-      memset(rdir->entry.cFileName, 0, sizeof(rdir->entry.cFileName));
-      strlcpy(rdir->entry.cFileName, name_local, sizeof(rdir->entry.cFileName));
-
-      if (name_local)
-         free(name_local);
-   }
+   char *name       = local_to_utf8_string_alloc(rdir->entry.cFileName);
 #else
-   {
-      char *name       = utf16_to_utf8_string_alloc(rdir->entry.cFileName);
-      memset(rdir->entry.cFileName, 0, sizeof(rdir->entry.cFileName));
-      strlcpy((char*)rdir->entry.cFileName, name, sizeof(rdir->entry.cFileName));
-
-      if (name)
-         free(name);
-   }
+   char *name       = utf16_to_utf8_string_alloc(rdir->entry.cFileName);
 #endif
+   memset(rdir->entry.cFileName, 0, sizeof(rdir->entry.cFileName));
+   strlcpy((char*)rdir->entry.cFileName, name, sizeof(rdir->entry.cFileName));
+   if (name)
+      free(name);
    return (char*)rdir->entry.cFileName;
-#elif defined(VITA) || defined(PSP) || defined(__CELLOS_LV2__) || defined(ORBIS)
+#elif defined(VITA) || defined(__PSL1GHT__) || defined(__PS3__)
    return rdir->entry.d_name;
-#elif defined(PS2)
-   return rdir->entry.name;
 #else
    if (!rdir || !rdir->entry)
       return NULL;
@@ -1271,25 +1184,12 @@ bool retro_vfs_dirent_is_dir_impl(libretro_vfs_implementation_dir *rdir)
 #if defined(_WIN32)
    const WIN32_FIND_DATA *entry = (const WIN32_FIND_DATA*)&rdir->entry;
    return entry->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
-#elif defined(PSP) || defined(VITA)
-   const SceIoDirent *entry = (const SceIoDirent*)&rdir->entry;
-#if defined(PSP)
-   return (entry->d_stat.st_attr & FIO_SO_IFDIR) == FIO_SO_IFDIR;
 #elif defined(VITA)
+   const SceIoDirent *entry     = (const SceIoDirent*)&rdir->entry;
    return SCE_S_ISDIR(entry->d_stat.st_mode);
-#endif
-#elif defined(PS2)
-   const iox_dirent_t *entry = (const iox_dirent_t*)&rdir->entry;
-   return FIO_S_ISDIR(entry->stat.mode);
-#elif defined(__CELLOS_LV2__)
-   CellFsDirent *entry = (CellFsDirent*)&rdir->entry;
-   return (entry->d_type == CELL_FS_TYPE_DIRECTORY);
-#elif defined(ORBIS)
-   const struct dirent *entry = &rdir->entry;
-   if (entry->d_type == DT_DIR)
-      return true;
-   if (!(entry->d_type == DT_UNKNOWN || entry->d_type == DT_LNK))
-      return false;
+#elif defined(__PSL1GHT__) || defined(__PS3__)
+   sysFSDirent *entry          = (sysFSDirent*)&rdir->entry;
+   return (entry->d_type == FS_TYPE_DIR);
 #else
    struct stat buf;
    char path[PATH_MAX_LENGTH];
@@ -1302,8 +1202,7 @@ bool retro_vfs_dirent_is_dir_impl(libretro_vfs_implementation_dir *rdir)
       return false;
 #endif
    /* dirent struct doesn't have d_type, do it the slow way ... */
-   path[0] = '\0';
-   fill_pathname_join(path, rdir->orig_path, retro_vfs_dirent_get_name_impl(rdir), sizeof(path));
+   fill_pathname_join_special(path, rdir->orig_path, retro_vfs_dirent_get_name_impl(rdir), sizeof(path));
    if (stat(path, &buf) < 0)
       return false;
    return S_ISDIR(buf.st_mode);
@@ -1318,14 +1217,10 @@ int retro_vfs_closedir_impl(libretro_vfs_implementation_dir *rdir)
 #if defined(_WIN32)
    if (rdir->directory != INVALID_HANDLE_VALUE)
       FindClose(rdir->directory);
-#elif defined(VITA) || defined(PSP)
+#elif defined(VITA)
    sceIoDclose(rdir->directory);
-#elif defined(PS2)
-   ps2fileXioDclose(rdir->directory);
-#elif defined(__CELLOS_LV2__)
-   rdir->error = cellFsClosedir(rdir->directory);
-#elif defined(ORBIS)
-   orbisDclose(rdir->directory);
+#elif defined(__PSL1GHT__) || defined(__PS3__)
+   rdir->error = sysFsClosedir(rdir->directory);
 #else
    if (rdir->directory)
       closedir(rdir->directory);
diff --git a/src/libretro/libretro-common/vfs/vfs_implementation_cdrom.c b/src/libretro/libretro-common/vfs/vfs_implementation_cdrom.c
index 537dc7acac..093cd9cc02 100644
--- a/src/libretro/libretro-common/vfs/vfs_implementation_cdrom.c
+++ b/src/libretro/libretro-common/vfs/vfs_implementation_cdrom.c
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2010-2019 The RetroArch team
+/* Copyright  (C) 2010-2020 The RetroArch team
 *
 * ---------------------------------------------------------------------------------------
 * The following license statement only applies to this file (vfs_implementation_cdrom.c).
@@ -30,6 +30,7 @@
 #include <windows.h>
 #endif
 
+/* TODO/FIXME - static global variable */
 static cdrom_toc_t vfs_cdrom_toc = {0};
 
 const cdrom_toc_t* retro_vfs_file_get_cdrom_toc(void)
@@ -37,7 +38,9 @@ const cdrom_toc_t* retro_vfs_file_get_cdrom_toc(void)
    return &vfs_cdrom_toc;
 }
 
-int64_t retro_vfs_file_seek_cdrom(libretro_vfs_implementation_file *stream, int64_t offset, int whence)
+int64_t retro_vfs_file_seek_cdrom(
+      libretro_vfs_implementation_file *stream,
+      int64_t offset, int whence)
 {
    const char *ext = path_get_extension(stream->orig_path);
 
@@ -52,68 +55,84 @@ int64_t retro_vfs_file_seek_cdrom(libretro_vfs_implementation_file *stream, int6
             stream->cdrom.byte_pos += offset;
             break;
          case SEEK_END:
-            stream->cdrom.byte_pos = (stream->cdrom.cue_len - 1) + offset;
+            stream->cdrom.byte_pos  = (stream->cdrom.cue_len - 1) + offset;
             break;
       }
 
 #ifdef CDROM_DEBUG
-      printf("[CDROM] Seek: Path %s Offset %" PRIu64 " is now at %" PRIu64 "\n", stream->orig_path, offset, stream->cdrom.byte_pos);
+      printf("[CDROM] Seek: Path %s Offset %" PRIu64 " is now at %" PRIu64 "\n",
+            stream->orig_path,
+            offset,
+            stream->cdrom.byte_pos);
       fflush(stdout);
 #endif
    }
    else if (string_is_equal_noncase(ext, "bin"))
    {
-      int lba = (offset / 2352);
-      unsigned char min = 0;
-      unsigned char sec = 0;
-      unsigned char frame = 0;
+      int lba               = (offset / 2352);
+      unsigned char min     = 0;
+      unsigned char sec     = 0;
+      unsigned char frame   = 0;
+#ifdef CDROM_DEBUG
       const char *seek_type = "SEEK_SET";
-
-      (void)seek_type;
+#endif
 
       switch (whence)
       {
          case SEEK_CUR:
-         {
-            unsigned new_lba;
-
-            stream->cdrom.byte_pos += offset;
-            new_lba = vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].lba + (stream->cdrom.byte_pos / 2352);
-            seek_type = "SEEK_CUR";
-
-            cdrom_lba_to_msf(new_lba, &min, &sec, &frame);
+            {
+               unsigned new_lba;
+#ifdef CDROM_DEBUG
+               seek_type               = "SEEK_CUR";
+#endif
+               stream->cdrom.byte_pos += offset;
+               new_lba                 = vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].lba + (stream->cdrom.byte_pos / 2352);
 
+               cdrom_lba_to_msf(new_lba, &min, &sec, &frame);
+            }
             break;
-         }
          case SEEK_END:
-         {
-            ssize_t pregap_lba_len = (vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].audio ? 0 : (vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].lba - vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].lba_start));
-            ssize_t lba_len = vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].track_size - pregap_lba_len;
-
-            cdrom_lba_to_msf(lba_len + lba, &min, &sec, &frame);
-
-            stream->cdrom.byte_pos = lba_len * 2352;
-            seek_type = "SEEK_END";
+            {
+               ssize_t pregap_lba_len = (vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].audio 
+                     ? 0 
+                     : (vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].lba - vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].lba_start));
+               ssize_t lba_len        = vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].track_size - pregap_lba_len;
+#ifdef CDROM_DEBUG
+               seek_type              = "SEEK_END";
+#endif
 
+               cdrom_lba_to_msf(lba_len + lba, &min, &sec, &frame);
+               stream->cdrom.byte_pos = lba_len * 2352;
+            }
             break;
-         }
          case SEEK_SET:
          default:
-         {
-            seek_type = "SEEK_SET";
-            stream->cdrom.byte_pos = offset;
-            cdrom_lba_to_msf(vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].lba + (stream->cdrom.byte_pos / 2352), &min, &sec, &frame);
+            {
+#ifdef CDROM_DEBUG
+               seek_type = "SEEK_SET";
+#endif
+               stream->cdrom.byte_pos = offset;
+               cdrom_lba_to_msf(vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].lba + (stream->cdrom.byte_pos / 2352), &min, &sec, &frame);
+            }
             break;
-         }
       }
 
-      stream->cdrom.cur_min = min;
-      stream->cdrom.cur_sec = sec;
+      stream->cdrom.cur_min   = min;
+      stream->cdrom.cur_sec   = sec;
       stream->cdrom.cur_frame = frame;
-      stream->cdrom.cur_lba = cdrom_msf_to_lba(min, sec, frame);
+      stream->cdrom.cur_lba   = cdrom_msf_to_lba(min, sec, frame);
 
 #ifdef CDROM_DEBUG
-      printf("[CDROM] Seek %s: Path %s Offset %" PRIu64 " is now at %" PRIu64 " (MSF %02u:%02u:%02u) (LBA %u)...\n", seek_type, stream->orig_path, offset, stream->cdrom.byte_pos, (unsigned)stream->cdrom.cur_min, (unsigned)stream->cdrom.cur_sec, (unsigned)stream->cdrom.cur_frame, stream->cdrom.cur_lba);
+      printf(
+            "[CDROM] Seek %s: Path %s Offset %" PRIu64 " is now at %" PRIu64 " (MSF %02u:%02u:%02u) (LBA %u)...\n",
+            seek_type,
+            stream->orig_path,
+            offset,
+            stream->cdrom.byte_pos,
+            (unsigned)stream->cdrom.cur_min,
+            (unsigned)stream->cdrom.cur_sec,
+            (unsigned)stream->cdrom.cur_frame,
+            stream->cdrom.cur_lba);
       fflush(stdout);
 #endif
    }
@@ -128,20 +147,21 @@ void retro_vfs_file_open_cdrom(
       const char *path, unsigned mode, unsigned hints)
 {
 #if defined(__linux__) && !defined(ANDROID)
-   char cdrom_path[] = "/dev/sg1";
-   size_t path_len = strlen(path);
-   const char *ext = path_get_extension(path);
+   char cdrom_path[]       = "/dev/sg1";
+   size_t path_len         = strlen(path);
+   const char *ext         = path_get_extension(path);
 
    stream->cdrom.cur_track = 1;
 
-   if (!string_is_equal_noncase(ext, "cue") && !string_is_equal_noncase(ext, "bin"))
+   if (     !string_is_equal_noncase(ext, "cue") 
+         && !string_is_equal_noncase(ext, "bin"))
       return;
 
-   if (path_len >= strlen("drive1-track01.bin"))
+   if (path_len >= STRLEN_CONST("drive1-track01.bin"))
    {
-      if (!memcmp(path, "drive", strlen("drive")))
+      if (!memcmp(path, "drive", STRLEN_CONST("drive")))
       {
-         if (!memcmp(path + 6, "-track", strlen("-track")))
+         if (!memcmp(path + 6, "-track", STRLEN_CONST("-track")))
          {
             if (sscanf(path + 12, "%02u", (unsigned*)&stream->cdrom.cur_track))
             {
@@ -154,13 +174,13 @@ void retro_vfs_file_open_cdrom(
       }
    }
 
-   if (path_len >= strlen("drive1.cue"))
+   if (path_len >= STRLEN_CONST("drive1.cue"))
    {
-      if (!memcmp(path, "drive", strlen("drive")))
+      if (!memcmp(path, "drive", STRLEN_CONST("drive")))
       {
          if (path[5] >= '0' && path[5] <= '9')
          {
-            cdrom_path[7] = path[5];
+            cdrom_path[7]       = path[5];
             stream->cdrom.drive = path[5];
             vfs_cdrom_toc.drive = stream->cdrom.drive;
          }
@@ -184,7 +204,12 @@ void retro_vfs_file_open_cdrom(
          stream->cdrom.cue_buf = NULL;
       }
 
-      cdrom_write_cue(stream, &stream->cdrom.cue_buf, &stream->cdrom.cue_len, stream->cdrom.drive, &vfs_cdrom_toc.num_tracks, &vfs_cdrom_toc);
+      cdrom_write_cue(stream,
+            &stream->cdrom.cue_buf,
+            &stream->cdrom.cue_len,
+            stream->cdrom.drive,
+            &vfs_cdrom_toc.num_tracks,
+            &vfs_cdrom_toc);
       cdrom_get_timeouts(stream, &vfs_cdrom_toc.timeouts);
 
 #ifdef CDROM_DEBUG
@@ -203,15 +228,16 @@ void retro_vfs_file_open_cdrom(
 #endif
 #if defined(_WIN32) && !defined(_XBOX)
    char cdrom_path[] = "\\\\.\\D:";
-   size_t path_len = strlen(path);
-   const char *ext = path_get_extension(path);
+   size_t path_len   = strlen(path);
+   const char *ext   = path_get_extension(path);
 
-   if (!string_is_equal_noncase(ext, "cue") && !string_is_equal_noncase(ext, "bin"))
+   if (     !string_is_equal_noncase(ext, "cue") 
+         && !string_is_equal_noncase(ext, "bin"))
       return;
 
-   if (path_len >= strlen("d:/drive-track01.bin"))
+   if (path_len >= STRLEN_CONST("d:/drive-track01.bin"))
    {
-      if (!memcmp(path + 1, ":/drive-track", strlen(":/drive-track")))
+      if (!memcmp(path + 1, ":/drive-track", STRLEN_CONST(":/drive-track")))
       {
          if (sscanf(path + 14, "%02u", (unsigned*)&stream->cdrom.cur_track))
          {
@@ -223,13 +249,13 @@ void retro_vfs_file_open_cdrom(
       }
    }
 
-   if (path_len >= strlen("d:/drive.cue"))
+   if (path_len >= STRLEN_CONST("d:/drive.cue"))
    {
-      if (!memcmp(path + 1, ":/drive", strlen(":/drive")))
+      if (!memcmp(path + 1, ":/drive", STRLEN_CONST(":/drive")))
       {
          if ((path[0] >= 'A' && path[0] <= 'Z') || (path[0] >= 'a' && path[0] <= 'z'))
          {
-            cdrom_path[4] = path[0];
+            cdrom_path[4]       = path[0];
             stream->cdrom.drive = path[0];
             vfs_cdrom_toc.drive = stream->cdrom.drive;
          }
@@ -240,7 +266,13 @@ void retro_vfs_file_open_cdrom(
    printf("[CDROM] Open: Path %s URI %s\n", cdrom_path, path);
    fflush(stdout);
 #endif
-   stream->fh = CreateFile(cdrom_path, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+   stream->fh = CreateFile(cdrom_path,
+         GENERIC_READ | GENERIC_WRITE,
+         FILE_SHARE_READ | FILE_SHARE_WRITE,
+         NULL,
+         OPEN_EXISTING,
+         FILE_ATTRIBUTE_NORMAL,
+         NULL);
 
    if (stream->fh == INVALID_HANDLE_VALUE)
       return;
@@ -253,8 +285,14 @@ void retro_vfs_file_open_cdrom(
          stream->cdrom.cue_buf = NULL;
       }
 
-      cdrom_write_cue(stream, &stream->cdrom.cue_buf, &stream->cdrom.cue_len, stream->cdrom.drive, &vfs_cdrom_toc.num_tracks, &vfs_cdrom_toc);
-      cdrom_get_timeouts(stream, &vfs_cdrom_toc.timeouts);
+      cdrom_write_cue(stream,
+            &stream->cdrom.cue_buf,
+            &stream->cdrom.cue_len,
+            stream->cdrom.drive,
+            &vfs_cdrom_toc.num_tracks,
+            &vfs_cdrom_toc);
+      cdrom_get_timeouts(stream,
+            &vfs_cdrom_toc.timeouts);
 
 #ifdef CDROM_DEBUG
       if (string_is_empty(stream->cdrom.cue_buf))
@@ -272,17 +310,17 @@ void retro_vfs_file_open_cdrom(
 #endif
    if (vfs_cdrom_toc.num_tracks > 1 && stream->cdrom.cur_track)
    {
-      stream->cdrom.cur_min = vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].min;
-      stream->cdrom.cur_sec = vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].sec;
+      stream->cdrom.cur_min   = vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].min;
+      stream->cdrom.cur_sec   = vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].sec;
       stream->cdrom.cur_frame = vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].frame;
-      stream->cdrom.cur_lba = cdrom_msf_to_lba(stream->cdrom.cur_min, stream->cdrom.cur_sec, stream->cdrom.cur_frame);
+      stream->cdrom.cur_lba   = cdrom_msf_to_lba(stream->cdrom.cur_min, stream->cdrom.cur_sec, stream->cdrom.cur_frame);
    }
    else
    {
-      stream->cdrom.cur_min = vfs_cdrom_toc.track[0].min;
-      stream->cdrom.cur_sec = vfs_cdrom_toc.track[0].sec;
+      stream->cdrom.cur_min   = vfs_cdrom_toc.track[0].min;
+      stream->cdrom.cur_sec   = vfs_cdrom_toc.track[0].sec;
       stream->cdrom.cur_frame = vfs_cdrom_toc.track[0].frame;
-      stream->cdrom.cur_lba = cdrom_msf_to_lba(stream->cdrom.cur_min, stream->cdrom.cur_sec, stream->cdrom.cur_frame);
+      stream->cdrom.cur_lba   = cdrom_msf_to_lba(stream->cdrom.cur_min, stream->cdrom.cur_sec, stream->cdrom.cur_frame);
    }
 }
 
@@ -340,52 +378,69 @@ int64_t retro_vfs_file_read_cdrom(libretro_vfs_implementation_file *stream,
 
    if (string_is_equal_noncase(ext, "cue"))
    {
-      if ((int64_t)len < (int64_t)stream->cdrom.cue_len - stream->cdrom.byte_pos)
-      {
+      if ((int64_t)len >= (int64_t)stream->cdrom.cue_len 
+            - stream->cdrom.byte_pos)
+         len = stream->cdrom.cue_len - stream->cdrom.byte_pos - 1;
 #ifdef CDROM_DEBUG
-         printf("[CDROM] Read: Reading %" PRIu64 " bytes from cuesheet starting at %" PRIu64 "...\n", len, stream->cdrom.byte_pos);
-         fflush(stdout);
+      printf(
+            "[CDROM] Read: Reading %" PRIu64 " bytes from cuesheet starting at %" PRIu64 "...\n",
+            len,
+            stream->cdrom.byte_pos);
+      fflush(stdout);
 #endif
-         memcpy(s, stream->cdrom.cue_buf + stream->cdrom.byte_pos, len);
-         stream->cdrom.byte_pos += len;
+      memcpy(s, stream->cdrom.cue_buf + stream->cdrom.byte_pos, len);
+      stream->cdrom.byte_pos += len;
 
-         return len;
-      }
-      else
-      {
-#ifdef CDROM_DEBUG
-         printf("[CDROM] Read: Reading %" PRIu64 " bytes from cuesheet starting at %" PRIu64 " failed.\n", len, stream->cdrom.byte_pos);
-         fflush(stdout);
-#endif
-         return 0;
-      }
+      return len;
    }
    else if (string_is_equal_noncase(ext, "bin"))
    {
-      size_t skip = stream->cdrom.byte_pos % 2352;
-      unsigned char min = 0;
-      unsigned char sec = 0;
-      unsigned char frame = 0;
-      unsigned char rmin = 0;
-      unsigned char rsec = 0;
+      unsigned char min    = 0;
+      unsigned char sec    = 0;
+      unsigned char frame  = 0;
+      unsigned char rmin   = 0;
+      unsigned char rsec   = 0;
       unsigned char rframe = 0;
+      size_t skip          = stream->cdrom.byte_pos % 2352;
 
-      if (stream->cdrom.byte_pos >= vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].track_bytes)
+      if (stream->cdrom.byte_pos >= 
+            vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].track_bytes)
          return 0;
 
-      if (stream->cdrom.byte_pos + len > vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].track_bytes)
-         len -= (stream->cdrom.byte_pos + len) - vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].track_bytes;
+      if (stream->cdrom.byte_pos + len > 
+            vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].track_bytes)
+         len -= (stream->cdrom.byte_pos + len) 
+            - vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].track_bytes;
 
       cdrom_lba_to_msf(stream->cdrom.cur_lba, &min, &sec, &frame);
-      cdrom_lba_to_msf(stream->cdrom.cur_lba - vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].lba, &rmin, &rsec, &rframe);
+      cdrom_lba_to_msf(stream->cdrom.cur_lba 
+            - vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].lba,
+            &rmin, &rsec, &rframe);
 
 #ifdef CDROM_DEBUG
-      printf("[CDROM] Read: Reading %" PRIu64 " bytes from %s starting at byte offset %" PRIu64 " (rMSF %02u:%02u:%02u aMSF %02u:%02u:%02u) (LBA %u) skip %" PRIu64 "...\n", len, stream->orig_path, stream->cdrom.byte_pos, (unsigned)rmin, (unsigned)rsec, (unsigned)rframe, (unsigned)min, (unsigned)sec, (unsigned)frame, stream->cdrom.cur_lba, skip);
+      printf(
+            "[CDROM] Read: Reading %" PRIu64 " bytes from %s starting at byte offset %" PRIu64 " (rMSF %02u:%02u:%02u aMSF %02u:%02u:%02u) (LBA %u) skip %" PRIu64 "...\n",
+            len,
+            stream->orig_path,
+            stream->cdrom.byte_pos,
+            (unsigned)rmin,
+            (unsigned)rsec,
+            (unsigned)rframe,
+            (unsigned)min,
+            (unsigned)sec,
+            (unsigned)frame,
+            stream->cdrom.cur_lba,
+            skip);
       fflush(stdout);
 #endif
 
-      rv = cdrom_read(stream, &vfs_cdrom_toc.timeouts, min, sec, frame, s, (size_t)len, skip);
-      /*rv = cdrom_read_lba(stream, stream->cdrom.cur_lba, s, (size_t)len, skip);*/
+#if 1
+      rv = cdrom_read(stream, &vfs_cdrom_toc.timeouts, min, sec,
+            frame, s, (size_t)len, skip);
+#else
+      rv = cdrom_read_lba(stream, stream->cdrom.cur_lba, s,
+            (size_t)len, skip);
+#endif
 
       if (rv)
       {
@@ -397,12 +452,28 @@ int64_t retro_vfs_file_read_cdrom(libretro_vfs_implementation_file *stream,
       }
 
       stream->cdrom.byte_pos += len;
-      stream->cdrom.cur_lba = vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].lba + (stream->cdrom.byte_pos / 2352);
+      stream->cdrom.cur_lba   = 
+         vfs_cdrom_toc.track[stream->cdrom.cur_track - 1].lba 
+         + (stream->cdrom.byte_pos / 2352);
 
-      cdrom_lba_to_msf(stream->cdrom.cur_lba, &stream->cdrom.cur_min, &stream->cdrom.cur_sec, &stream->cdrom.cur_frame);
+      cdrom_lba_to_msf(stream->cdrom.cur_lba,
+            &stream->cdrom.cur_min,
+            &stream->cdrom.cur_sec,
+            &stream->cdrom.cur_frame);
 
 #ifdef CDROM_DEBUG
-      printf("[CDROM] read %" PRIu64 " bytes, position is now: %" PRIu64 " (MSF %02u:%02u:%02u) (LBA %u)\n", len, stream->cdrom.byte_pos, (unsigned)stream->cdrom.cur_min, (unsigned)stream->cdrom.cur_sec, (unsigned)stream->cdrom.cur_frame, cdrom_msf_to_lba(stream->cdrom.cur_min, stream->cdrom.cur_sec, stream->cdrom.cur_frame));
+      printf(
+            "[CDROM] read %" PRIu64 " bytes, position is now: %" PRIu64 " (MSF %02u:%02u:%02u) (LBA %u)\n",
+            len,
+            stream->cdrom.byte_pos,
+            (unsigned)stream->cdrom.cur_min,
+            (unsigned)stream->cdrom.cur_sec,
+            (unsigned)stream->cdrom.cur_frame,
+            cdrom_msf_to_lba(
+               stream->cdrom.cur_min,
+               stream->cdrom.cur_sec,
+               stream->cdrom.cur_frame)
+            );
       fflush(stdout);
 #endif
 
@@ -417,7 +488,8 @@ int retro_vfs_file_error_cdrom(libretro_vfs_implementation_file *stream)
    return 0;
 }
 
-const vfs_cdrom_t* retro_vfs_file_get_cdrom_position(const libretro_vfs_implementation_file *stream)
+const vfs_cdrom_t* retro_vfs_file_get_cdrom_position(
+      const libretro_vfs_implementation_file *stream)
 {
    return &stream->cdrom;
 }
diff --git a/src/libretro/libretro-common/vfs/vfs_implementation_uwp.cpp b/src/libretro/libretro-common/vfs/vfs_implementation_uwp.cpp
index f0acba472e..529159461f 100644
--- a/src/libretro/libretro-common/vfs/vfs_implementation_uwp.cpp
+++ b/src/libretro/libretro-common/vfs/vfs_implementation_uwp.cpp
@@ -1,4 +1,4 @@
-/* Copyright  (C) 2018-2019 The RetroArch team
+/* Copyright  (C) 2018-2020 The RetroArch team
 *
 * ---------------------------------------------------------------------------------------
 * The following license statement only applies to this file (vfs_implementation_uwp.cpp).
@@ -27,16 +27,14 @@
 #include <stdio.h>
 #include <wrl.h>
 #include <wrl/implements.h>
-#include <windows.storage.streams.h>
 #include <robuffer.h>
 #include <collection.h>
 #include <functional>
-
-using namespace Windows::Foundation;
-using namespace Windows::Foundation::Collections;
-using namespace Windows::Storage;
-using namespace Windows::Storage::Streams;
-using namespace Windows::Storage::FileProperties;
+#include <fileapifromapp.h>
+#include <AclAPI.h>
+#include <sddl.h>
+#include <io.h>
+#include <fcntl.h>
 
 #ifdef RARCH_INTERNAL
 #ifndef VFS_FRONTEND
@@ -50,675 +48,599 @@ using namespace Windows::Storage::FileProperties;
 #include <encodings/utf.h>
 #include <retro_miscellaneous.h>
 #include <file/file_path.h>
-#include <retro_assert.h>
-#include <verbosity.h>
 #include <string/stdstring.h>
 #include <retro_environment.h>
-#include <uwp/uwp_func.h>
+#include <uwp/uwp_async.h>
+#include <uwp/std_filesystem_compat.h>
 
 namespace
 {
-	/* Dear Microsoft
-	 * I really appreciate all the effort you took to not provide any
-	 * synchronous file APIs and block all attempts to synchronously
-	 * wait for the results of async tasks for "smooth user experience",
-	 * but I'm not going to run and rewrite all RetroArch cores for
-	 * async I/O. I hope you like this hack I made instead.
-	 */
-	template<typename T>
-	T RunAsync(std::function<concurrency::task<T>()> func)
-	{
-		volatile bool finished = false;
-		Platform::Exception^ exception = nullptr;
-		T result;
-
-		func().then([&finished, &exception, &result](concurrency::task<T> t) {
-			try
-			{
-				result = t.get();
-			}
-			catch (Platform::Exception^ exception_)
-			{
-				exception = exception_;
-			}
-			finished = true;
-		});
-
-		/* Don't stall the UI thread - prevents a deadlock */
-		Windows::UI::Core::CoreWindow^ corewindow = Windows::UI::Core::CoreWindow::GetForCurrentThread();
-		while (!finished)
-		{
-			if (corewindow) {
-				corewindow->Dispatcher->ProcessEvents(Windows::UI::Core::CoreProcessEventsOption::ProcessAllIfPresent);
-			}
-		}
-
-		if (exception != nullptr)
-			throw exception;
-		return result;
-	}
-
-	template<typename T>
-	T RunAsyncAndCatchErrors(std::function<concurrency::task<T>()> func, T valueOnError)
-	{
-		try
-		{
-			return RunAsync<T>(func);
-		}
-		catch (Platform::Exception^ e)
-		{
-			return valueOnError;
-		}
-	}
-
-	void windowsize_path(wchar_t* path)
-	{
-		/* UWP deals with paths containing / instead of \ way worse than normal Windows */
-		/* and RetroArch may sometimes mix them (e.g. on archive extraction) */
-		if (!path)
-			return;
-		while (*path)
-		{
-			if (*path == '/')
-				*path = '\\';
-			++path;
-		}
-	}
+   /* UWP deals with paths containing / instead of 
+    * \ way worse than normal Windows */
+   /* and RetroArch may sometimes mix them 
+    * (e.g. on archive extraction) */
+   static void windowsize_path(wchar_t* path)
+   {
+      if (path)
+      {
+         while (*path)
+         {
+            if (*path == '/')
+               *path = '\\';
+            ++path;
+         }
+      }
+   }
 }
 
-namespace
+#ifdef VFS_FRONTEND
+struct retro_vfs_file_handle
+#else
+struct libretro_vfs_implementation_file
+#endif
 {
-	/* Damn you, UWP, why no functions for that either */
-	template<typename T>
-	concurrency::task<T^> GetItemFromPathAsync(Platform::String^ path)
-	{
-		static_assert(false, "StorageFile and StorageFolder only");
-	}
-	template<>
-	concurrency::task<StorageFile^> GetItemFromPathAsync(Platform::String^ path)
-	{
-		return concurrency::create_task(StorageFile::GetFileFromPathAsync(path));
-	}
-	template<>
-	concurrency::task<StorageFolder^> GetItemFromPathAsync(Platform::String^ path)
-	{
-		return concurrency::create_task(StorageFolder::GetFolderFromPathAsync(path));
-	}
-
-	template<typename T>
-	concurrency::task<T^> GetItemInFolderFromPathAsync(StorageFolder^ folder, Platform::String^ path)
-	{
-		static_assert(false, "StorageFile and StorageFolder only");
-	}
-	template<>
-	concurrency::task<StorageFile^> GetItemInFolderFromPathAsync(StorageFolder^ folder, Platform::String^ path)
-	{
-		if (path->IsEmpty())
-			retro_assert(false); /* Attempt to read a folder as a file - this really should have been caught earlier */
-		return concurrency::create_task(folder->GetFileAsync(path));
-	}
-	template<>
-	concurrency::task<StorageFolder^> GetItemInFolderFromPathAsync(StorageFolder^ folder, Platform::String^ path)
-	{
-		if (path->IsEmpty())
-			return concurrency::create_task(concurrency::create_async([folder]() { return folder; }));
-		return concurrency::create_task(folder->GetFolderAsync(path));
-	}
-}
+    int64_t size;
+    uint64_t mappos;
+    uint64_t mapsize;
+    FILE* fp;
+    HANDLE fh;
+    char* buf;
+    char* orig_path;
+    uint8_t* mapped;
+    int fd;
+    unsigned hints;
+    enum vfs_scheme scheme;
+};
 
-namespace
+#define RFILE_HINT_UNBUFFERED (1 << 8)
+
+int retro_vfs_file_close_impl(libretro_vfs_implementation_file* stream)
 {
-	/* A list of all StorageFolder objects returned using from the file picker */
-	Platform::Collections::Vector<StorageFolder^> accessible_directories;
-
-	concurrency::task<Platform::String^> TriggerPickerAddDialog()
-	{
-		auto folderPicker = ref new Windows::Storage::Pickers::FolderPicker();
-		folderPicker->SuggestedStartLocation = Windows::Storage::Pickers::PickerLocationId::Desktop;
-		folderPicker->FileTypeFilter->Append("*");
-
-		return concurrency::create_task(folderPicker->PickSingleFolderAsync()).then([](StorageFolder^ folder) {
-			if (folder == nullptr)
-				throw ref new Platform::Exception(E_ABORT, L"Operation cancelled by user");
-
-			/* TODO: check for duplicates */
-			accessible_directories.Append(folder);
-			return folder->Path;
-		});
-	}
-
-	template<typename T>
-	concurrency::task<T^> LocateStorageItem(Platform::String^ path)
-	{
-		/* Look for a matching directory we can use */
-		for each (StorageFolder^ folder in accessible_directories)
-		{
-			std::wstring folder_path = folder->Path->Data();
-			/* Could be C:\ or C:\Users\somebody - remove the trailing slash to unify them */
-			if (folder_path[folder_path.size() - 1] == '\\')
-				folder_path.erase(folder_path.size() - 1);
-			std::wstring file_path = path->Data();
-			if (file_path.find(folder_path) == 0)
-			{
-				/* Found a match */
-				file_path = file_path.length() > folder_path.length() ? file_path.substr(folder_path.length() + 1) : L"";
-				return concurrency::create_task(GetItemInFolderFromPathAsync<T>(folder, ref new Platform::String(file_path.data())));
-			}
-		}
-
-		/* No matches - try accessing directly, and fallback to user prompt */
-		return concurrency::create_task(GetItemFromPathAsync<T>(path)).then([&](concurrency::task<T^> item) {
-			try
-			{
-				T^ storageItem = item.get();
-				return concurrency::create_task(concurrency::create_async([storageItem]() { return storageItem; }));
-			}
-			catch (Platform::AccessDeniedException^ e)
-			{
-				Windows::UI::Popups::MessageDialog^ dialog =
-					ref new Windows::UI::Popups::MessageDialog("Path \"" + path + "\" is not currently accessible. Please open any containing directory to access it.");
-				dialog->Commands->Append(ref new Windows::UI::Popups::UICommand("Open file picker"));
-				dialog->Commands->Append(ref new Windows::UI::Popups::UICommand("Cancel"));
-				return concurrency::create_task(dialog->ShowAsync()).then([path](Windows::UI::Popups::IUICommand^ cmd) {
-					if (cmd->Label == "Open file picker")
-					{
-						return TriggerPickerAddDialog().then([path](Platform::String^ added_path) {
-							/* Retry */
-							return LocateStorageItem<T>(path);
-						});
-					}
-					else
-					{
-						throw ref new Platform::Exception(E_ABORT, L"Operation cancelled by user");
-					}
-				});
-			}
-		});
-	}
-
-	IStorageItem^ LocateStorageFileOrFolder(Platform::String^ path)
-	{
-		if (!path || path->IsEmpty())
-			return nullptr;
-
-		if (*(path->End() - 1) == '\\')
-		{
-			/* Ends with a slash, so it's definitely a directory */
-			return RunAsyncAndCatchErrors<StorageFolder^>([&]() {
-				return concurrency::create_task(LocateStorageItem<StorageFolder>(path));
-			}, nullptr);
-		}
-		else
-		{
-			/* No final slash - probably a file (since RetroArch usually slash-terminates dirs), but there is still a chance it's a directory */
-			IStorageItem^ item;
-			item = RunAsyncAndCatchErrors<StorageFile^>([&]() {
-				return concurrency::create_task(LocateStorageItem<StorageFile>(path));
-			}, nullptr);
-			if (!item)
-			{
-				item = RunAsyncAndCatchErrors<StorageFolder^>([&]() {
-					return concurrency::create_task(LocateStorageItem<StorageFolder>(path));
-				}, nullptr);
-			}
-			return item;
-		}
-	}
-}
+    if (!stream)
+        return -1;
 
+    if (stream->fp)
+        fclose(stream->fp);
 
-/* This is some pure magic and I have absolutely no idea how it works */
-/* Wraps a raw buffer into a WinRT object */
-/* https://stackoverflow.com/questions/10520335/how-to-wrap-a-char-buffer-in-a-winrt-ibuffer-in-c */
-class NativeBuffer :
-	public Microsoft::WRL::RuntimeClass<Microsoft::WRL::RuntimeClassFlags<Microsoft::WRL::RuntimeClassType::WinRtClassicComMix>,
-	ABI::Windows::Storage::Streams::IBuffer,
-	Windows::Storage::Streams::IBufferByteAccess>
-{
-public:
-	virtual ~NativeBuffer()
-	{
-	}
-
-	HRESULT __stdcall RuntimeClassInitialize(byte *buffer, uint32_t capacity, uint32_t length)
-	{
-		m_buffer = buffer;
-		m_capacity = capacity;
-		m_length = length;
-		return S_OK;
-	}
-
-	HRESULT __stdcall Buffer(byte **value)
-	{
-		if (m_buffer == nullptr)
-			return E_INVALIDARG;
-		*value = m_buffer;
-		return S_OK;
-	}
-
-	HRESULT __stdcall get_Capacity(uint32_t *value)
-	{
-		*value = m_capacity;
-		return S_OK;
-	}
-
-	HRESULT __stdcall get_Length(uint32_t *value)
-	{
-		*value = m_length;
-		return S_OK;
-	}
-
-	HRESULT __stdcall put_Length(uint32_t value)
-	{
-		if (value > m_capacity)
-			return E_INVALIDARG;
-		m_length = value;
-		return S_OK;
-	}
-
-private:
-	byte *m_buffer;
-	uint32_t m_capacity;
-	uint32_t m_length;
-};
+    if (stream->buf != NULL)
+    {
+        free(stream->buf);
+        stream->buf = NULL;
+    }
+    if (stream->orig_path)
+        free(stream->orig_path);
+
+    free(stream);
+
+    return 0;
+}
 
-IBuffer^ CreateNativeBuffer(void* buf, uint32_t capacity, uint32_t length)
+int retro_vfs_file_error_impl(libretro_vfs_implementation_file* stream)
 {
-	Microsoft::WRL::ComPtr<NativeBuffer> nativeBuffer;
-	Microsoft::WRL::Details::MakeAndInitialize<NativeBuffer>(&nativeBuffer, (byte *)buf, capacity, length);
-	auto iinspectable = (IInspectable *)reinterpret_cast<IInspectable *>(nativeBuffer.Get());
-	IBuffer ^buffer = reinterpret_cast<IBuffer ^>(iinspectable);
-	return buffer;
+    return ferror(stream->fp);
 }
 
-#ifdef VFS_FRONTEND
-struct retro_vfs_file_handle
-#else
-struct libretro_vfs_implementation_file
-#endif
+int64_t retro_vfs_file_size_impl(libretro_vfs_implementation_file* stream)
 {
-	IRandomAccessStream^ fp;
-	IBuffer^ bufferp;
-	char* buffer;
-	char* orig_path;
-	size_t buffer_size;
-	int buffer_left;
-	size_t buffer_fill;
-};
+    if (stream)
+        return stream->size;
+    return 0;
+}
 
-libretro_vfs_implementation_file *retro_vfs_file_open_impl(const char *path, unsigned mode, unsigned hints)
+int64_t retro_vfs_file_truncate_impl(libretro_vfs_implementation_file* stream, int64_t length)
 {
-	if (!path || !*path)
-		return NULL;
-
-	if (!path_is_absolute(path))
-	{
-		RARCH_WARN("Something tried to access files from current directory ('%s'). This is not allowed on UWP.\n", path);
-		return NULL;
-	}
-
-	if (path_char_is_slash(path[strlen(path) - 1]))
-	{
-		RARCH_WARN("Trying to open a directory as file?! ('%s')\n", path);
-		return NULL;
-	}
-
-	char* dirpath = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
-	fill_pathname_basedir(dirpath, path, PATH_MAX_LENGTH);
-	wchar_t *dirpath_wide = utf8_to_utf16_string_alloc(dirpath);
-	windowsize_path(dirpath_wide);
-	Platform::String^ dirpath_str = ref new Platform::String(dirpath_wide);
-	free(dirpath_wide);
-	free(dirpath);
-
-	char* filename = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
-	fill_pathname_base(filename, path, PATH_MAX_LENGTH);
-	wchar_t *filename_wide = utf8_to_utf16_string_alloc(filename);
-	Platform::String^ filename_str = ref new Platform::String(filename_wide);
-	free(filename_wide);
-	free(filename);
-
-	retro_assert(!dirpath_str->IsEmpty() && !filename_str->IsEmpty());
-
-	return RunAsyncAndCatchErrors<libretro_vfs_implementation_file*>([&]() {
-		return concurrency::create_task(LocateStorageItem<StorageFolder>(dirpath_str)).then([&](StorageFolder^ dir) {
-			if (mode == RETRO_VFS_FILE_ACCESS_READ)
-				return dir->GetFileAsync(filename_str);
-			else
-				return dir->CreateFileAsync(filename_str, (mode & RETRO_VFS_FILE_ACCESS_UPDATE_EXISTING) != 0 ?
-					CreationCollisionOption::OpenIfExists : CreationCollisionOption::ReplaceExisting);
-		}).then([&](StorageFile^ file) {
-			FileAccessMode accessMode = mode == RETRO_VFS_FILE_ACCESS_READ ?
-				FileAccessMode::Read : FileAccessMode::ReadWrite;
-			return file->OpenAsync(accessMode);
-		}).then([&](IRandomAccessStream^ fpstream) {
-			libretro_vfs_implementation_file *stream = (libretro_vfs_implementation_file*)calloc(1, sizeof(*stream));
-			if (!stream)
-				return (libretro_vfs_implementation_file*)NULL;
-
-			stream->orig_path = strdup(path);
-			stream->fp = fpstream;
-			stream->fp->Seek(0);
-			// Preallocate a small buffer for manually buffered IO, makes short read faster
-			int buf_size = 8 * 1024;
-			stream->buffer = (char*)malloc(buf_size);
-			stream->bufferp = CreateNativeBuffer(stream->buffer, buf_size, 0);
-			stream->buffer_left = 0;
-			stream->buffer_fill = 0;
-			stream->buffer_size = buf_size;
-			return stream;
-		});
-	}, NULL);
+   if (stream && _chsize(_fileno(stream->fp), length) == 0)
+      return 0;
+   return -1;
 }
 
-int retro_vfs_file_close_impl(libretro_vfs_implementation_file *stream)
+int64_t retro_vfs_file_tell_impl(libretro_vfs_implementation_file* stream)
 {
-	if (!stream || !stream->fp)
-		return -1;
+    if (!stream)
+        return -1;
 
-	/* Apparently, this is how you close a file in WinRT */
-	/* Yes, really */
-	stream->fp = nullptr;
-	free(stream->buffer);
+    if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0)
+        return _ftelli64(stream->fp);
+    if (lseek(stream->fd, 0, SEEK_CUR) < 0)
+        return -1;
 
-	return 0;
+    return 0;
 }
 
-int retro_vfs_file_error_impl(libretro_vfs_implementation_file *stream)
+int64_t retro_vfs_file_seek_internal(
+    libretro_vfs_implementation_file* stream,
+    int64_t offset, int whence)
 {
-	return false; /* TODO */
+    if (!stream)
+        return -1;
+
+    if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0)
+        return _fseeki64(stream->fp, offset, whence);
+    if (lseek(stream->fd, (off_t)offset, whence) < 0)
+        return -1;
+
+    return 0;
 }
 
-int64_t retro_vfs_file_size_impl(libretro_vfs_implementation_file *stream)
+int64_t retro_vfs_file_seek_impl(libretro_vfs_implementation_file* stream,
+    int64_t offset, int seek_position)
 {
-	if (!stream || !stream->fp)
-		return 0;
-	return stream->fp->Size;
+    return retro_vfs_file_seek_internal(stream, offset, seek_position);
 }
 
-int64_t retro_vfs_file_truncate_impl(libretro_vfs_implementation_file *stream, int64_t length)
+int64_t retro_vfs_file_read_impl(libretro_vfs_implementation_file* stream,
+    void* s, uint64_t len)
 {
-	if (!stream || !stream->fp)
-		return -1;
-	stream->fp->Size = length;
-	return 0;
+    if (!stream || (!stream->fp && stream->fh == INVALID_HANDLE_VALUE) || !s)
+      return -1;
+
+   if (stream->fh != INVALID_HANDLE_VALUE)
+   {
+      DWORD _bytes_read;
+      ReadFile(stream->fh, (char*)s, len, &_bytes_read, NULL);
+      return (int64_t)_bytes_read;
+   }
+
+    if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0)
+       return fread(s, 1, (size_t)len, stream->fp);
+    return read(stream->fd, s, (size_t)len);
 }
 
-int64_t retro_vfs_file_tell_impl(libretro_vfs_implementation_file *stream)
+
+int64_t retro_vfs_file_write_impl(libretro_vfs_implementation_file* stream, const void* s, uint64_t len)
 {
-	if (!stream || !stream->fp)
-		return -1;
-	return stream->fp->Position - stream->buffer_left;
+    if (!stream || (!stream->fp && stream->fh == INVALID_HANDLE_VALUE) || !s)
+        return -1;
+
+    if (stream->fh != INVALID_HANDLE_VALUE)
+    {
+        DWORD bytes_written;
+        WriteFile(stream->fh, s, len, &bytes_written, NULL);
+        return (int64_t)bytes_written;
+    }
+
+    if ((stream->hints & RFILE_HINT_UNBUFFERED) == 0)
+        return fwrite(s, 1, (size_t)len, stream->fp);
+
+    return write(stream->fd, s, (size_t)len);
 }
 
-int64_t retro_vfs_file_seek_impl(libretro_vfs_implementation_file *stream, int64_t offset, int seek_position)
+int retro_vfs_file_flush_impl(libretro_vfs_implementation_file* stream)
 {
-	if (!stream || !stream->fp)
-		return -1;
+    if (stream && fflush(stream->fp) == 0)
+       return 0;
+    return -1;
+}
 
-	switch (seek_position)
-	{
-	case RETRO_VFS_SEEK_POSITION_START:
-		stream->fp->Seek(offset);
-		break;
+int retro_vfs_file_remove_impl(const char *path)
+{
+   BOOL result;
+   wchar_t *path_wide;
 
-	case RETRO_VFS_SEEK_POSITION_CURRENT:
-		stream->fp->Seek(retro_vfs_file_tell_impl(stream) + offset);
-		break;
+   if (!path || !*path)
+      return -1;
 
-	case RETRO_VFS_SEEK_POSITION_END:
-		stream->fp->Seek(stream->fp->Size - offset);
-		break;
-	}
+   path_wide = utf8_to_utf16_string_alloc(path);
+   windowsize_path(path_wide);
 
-	// For simplicity always flush the buffer on seek
-	stream->buffer_left = 0;
+   /* Try Win32 first, this should work in AppData */
+   result = DeleteFileFromAppW(path_wide);
+   free(path_wide);
+   if (result)
+      return 0;
 
-	return 0;
+   return -1;
 }
 
-int64_t retro_vfs_file_read_impl(libretro_vfs_implementation_file *stream, void *s, uint64_t len)
+libretro_vfs_implementation_file* retro_vfs_file_open_impl(
+    const char* path, unsigned mode, unsigned hints)
 {
-	if (!stream || !stream->fp || !s)
-		return -1;
-
-	int64_t bytes_read = 0;
-
-	if (len <= stream->buffer_size) {
-		// Small read, use manually buffered IO
-		if (stream->buffer_left < len) {
-			// Exhaust the buffer
-			memcpy(s, &stream->buffer[stream->buffer_fill - stream->buffer_left], stream->buffer_left);
-			len -= stream->buffer_left;
-			bytes_read += stream->buffer_left;
-			stream->buffer_left = 0;
-
-			// Fill buffer
-			stream->buffer_left = RunAsyncAndCatchErrors<int64_t>([&]() {
-				return concurrency::create_task(stream->fp->ReadAsync(stream->bufferp, stream->bufferp->Capacity, InputStreamOptions::None)).then([&](IBuffer^ buf) {
-					retro_assert(stream->bufferp == buf);
-					return (int64_t)stream->bufferp->Length;
-				});
-			}, -1);
-			stream->buffer_fill = stream->buffer_left;
-
-			if (stream->buffer_left == -1) {
-				stream->buffer_left = 0;
-				stream->buffer_fill = 0;
-				return -1;
-			}
-
-			if (stream->buffer_left < len) {
-				// EOF
-				memcpy(&((char*)s)[bytes_read], stream->buffer, stream->buffer_left);
-				bytes_read += stream->buffer_left;
-				stream->buffer_left = 0;
-				return bytes_read;
-			}
-
-			memcpy(&((char*)s)[bytes_read], stream->buffer, len);
-			bytes_read += len;
-			stream->buffer_left -= len;
-			return bytes_read;
-		}
-
-		// Internal buffer already contains requested amount
-		memcpy(s, &stream->buffer[stream->buffer_fill - stream->buffer_left], len);
-		stream->buffer_left -= len;
-		return len;
-	}
-
-	// Big read exceeding buffer size, exhaust small buffer and read rest in one go
-	memcpy(s, &stream->buffer[stream->buffer_fill - stream->buffer_left], stream->buffer_left);
-	len -= stream->buffer_left;
-	bytes_read += stream->buffer_left;
-	stream->buffer_left = 0;
-
-	IBuffer^ buffer = CreateNativeBuffer(&((char*)s)[bytes_read], len, 0);
-
-	int64_t ret = RunAsyncAndCatchErrors<int64_t>([&]() {
-		return concurrency::create_task(stream->fp->ReadAsync(buffer, buffer->Capacity - bytes_read, InputStreamOptions::None)).then([&](IBuffer^ buf) {
-			retro_assert(buf == buffer);
-			return (int64_t)buffer->Length;
-		});
-	}, -1);
-
-	if (ret == -1) {
-		return -1;
-	}
-	return bytes_read + ret;
+    HANDLE file_handle;
+    std::wstring path_wstring;
+    DWORD desireAccess;
+    DWORD creationDisposition;
+    wchar_t                       *path_wide = NULL;
+    int                                flags = 0;
+    const char                     *mode_str = NULL;
+    libretro_vfs_implementation_file* stream =
+        (libretro_vfs_implementation_file*)
+        malloc(sizeof(*stream));
+
+    if (!stream)
+        return NULL;
+
+    stream->fd        = 0;
+    stream->hints     = hints;
+    stream->size      = 0;
+    stream->buf       = NULL;
+    stream->fp        = NULL;
+    stream->fh        = 0;
+    stream->orig_path = NULL;
+    stream->mappos    = 0;
+    stream->mapsize   = 0;
+    stream->mapped    = NULL;
+    stream->scheme    = VFS_SCHEME_NONE;
+
+#ifdef VFS_FRONTEND
+   if (     path
+         && path[0] == 'v'
+         && path[1] == 'f'
+         && path[2] == 's'
+         && path[3] == 'o'
+         && path[4] == 'n'
+         && path[5] == 'l'
+         && path[6] == 'y'
+         && path[7] == ':'
+         && path[8] == '/'
+         && path[9] == '/')
+         path             += sizeof("vfsonly://")-1;
+#endif
+
+    path_wide    = utf8_to_utf16_string_alloc(path);
+    windowsize_path(path_wide);
+    path_wstring = path_wide;
+    free(path_wide);
+
+    for (;;)
+    {
+       size_t p = path_wstring.find(L"\\\\");
+       if (p == std::wstring::npos)
+          break;
+       path_wstring.replace(p, 2, L"\\");
+    }
+
+    path_wstring      = L"\\\\?\\" + path_wstring;
+    stream->orig_path = strdup(path);
+
+    stream->hints    &= ~RETRO_VFS_FILE_ACCESS_HINT_FREQUENT_ACCESS;
+
+    switch (mode)
+    {
+       case RETRO_VFS_FILE_ACCESS_READ:
+          mode_str = "rb";
+          flags    = O_RDONLY | O_BINARY;
+          break;
+
+       case RETRO_VFS_FILE_ACCESS_WRITE:
+          mode_str = "wb";
+          flags    = O_WRONLY | O_CREAT | O_TRUNC | O_BINARY;
+          break;
+
+       case RETRO_VFS_FILE_ACCESS_READ_WRITE:
+          mode_str = "w+b";
+          flags    = O_RDWR | O_CREAT | O_TRUNC | O_BINARY;
+          break;
+
+       case RETRO_VFS_FILE_ACCESS_WRITE | RETRO_VFS_FILE_ACCESS_UPDATE_EXISTING:
+       case RETRO_VFS_FILE_ACCESS_READ_WRITE | RETRO_VFS_FILE_ACCESS_UPDATE_EXISTING:
+          mode_str = "r+b";
+          flags    = O_RDWR | O_BINARY;
+          break;
+
+       default:
+          goto error;
+    }
+
+    switch (mode)
+    {
+       case RETRO_VFS_FILE_ACCESS_READ_WRITE:
+          desireAccess = GENERIC_READ | GENERIC_WRITE;
+          break;
+       case RETRO_VFS_FILE_ACCESS_WRITE:
+          desireAccess = GENERIC_WRITE;
+          break;
+       case RETRO_VFS_FILE_ACCESS_READ:
+          desireAccess = GENERIC_READ;
+          break;
+    }
+    if (mode == RETRO_VFS_FILE_ACCESS_READ)
+        creationDisposition = OPEN_EXISTING;
+    else
+        creationDisposition = (mode & RETRO_VFS_FILE_ACCESS_UPDATE_EXISTING) != 0 
+           ? OPEN_ALWAYS
+           : CREATE_ALWAYS;
+
+    if ((file_handle = CreateFile2FromAppW(path_wstring.data(), desireAccess,
+                FILE_SHARE_READ, creationDisposition, NULL)) == INVALID_HANDLE_VALUE)
+       goto error;
+
+    stream->fh      = file_handle;
+    if ((stream->fd = _open_osfhandle((uint64)stream->fh, flags)) == -1)
+        goto error;
+
+    {
+        FILE *fp = _fdopen(stream->fd, mode_str);
+
+        if (!fp)
+            goto error;
+        stream->fp = fp;
+    }
+
+    /* Regarding setvbuf:
+        *
+        * https://www.freebsd.org/cgi/man.cgi?query=setvbuf&apropos=0&sektion=0&manpath=FreeBSD+11.1-RELEASE&arch=default&format=html
+        *
+        * If the size argument is not zero but buf is NULL,
+        * a buffer of the given size will be allocated immediately, and
+        * released on close. This is an extension to ANSI C.
+        *
+        * Since C89 does not support specifying a NULL buffer
+        * with a non-zero size, we create and track our own buffer for it.
+        */
+        /* TODO: this is only useful for a few platforms,
+        * find which and add ifdef */
+    if (stream->scheme != VFS_SCHEME_CDROM)
+    {
+        stream->buf = (char*)calloc(1, 0x4000);
+        if (stream->fp)
+            setvbuf(stream->fp, stream->buf, _IOFBF, 0x4000);
+    }
+
+    retro_vfs_file_seek_internal(stream, 0, SEEK_SET);
+    retro_vfs_file_seek_internal(stream, 0, SEEK_END);
+
+    stream->size = retro_vfs_file_tell_impl(stream);
+
+    retro_vfs_file_seek_internal(stream, 0, SEEK_SET);
+
+    return stream;
+
+error:
+    retro_vfs_file_close_impl(stream);
+    return NULL;
 }
 
-int64_t retro_vfs_file_write_impl(libretro_vfs_implementation_file *stream, const void *s, uint64_t len)
+static int uwp_mkdir_impl(std::experimental::filesystem::path dir)
 {
-	if (!stream || !stream->fp || !s)
-		return -1;
-
-	// const_cast to remove const modifier is undefined behaviour, but the buffer is only read, should be safe
-	IBuffer^ buffer = CreateNativeBuffer(const_cast<void*>(s), len, len);
-	return RunAsyncAndCatchErrors<int64_t>([&]() {
-		return concurrency::create_task(stream->fp->WriteAsync(buffer)).then([&](unsigned int written) {
-			return (int64_t)written;
-		});
-	}, -1);
+    /*I feel like this should create the directory recursively but the existing implementation does not so this update won't
+     *I put in the work but I just commented out the stuff you would need */
+    WIN32_FILE_ATTRIBUTE_DATA lpFileInfo;
+    bool parent_dir_exists = false;
+
+    if (dir.empty())
+        return -1;
+
+    /* Check if file attributes can be gotten successfully  */
+    if (GetFileAttributesExFromAppW(dir.parent_path().wstring().c_str(), GetFileExInfoStandard, &lpFileInfo))
+    {
+        /* Check that the files attributes are not null or empty */
+        if (lpFileInfo.dwFileAttributes != INVALID_FILE_ATTRIBUTES && lpFileInfo.dwFileAttributes != 0)
+        {
+            if (lpFileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+                parent_dir_exists = true;
+        }
+    }
+    if (!parent_dir_exists)
+    {
+        /* Try to create parent dir */
+        int success = uwp_mkdir_impl(dir.parent_path());
+        if (success != 0 && success != -2)
+            return success;
+    }
+
+
+    /* Try Win32 first, this should work in AppData */
+    if (CreateDirectoryFromAppW(dir.wstring().c_str(), NULL))
+        return 0;
+
+    if (GetLastError() == ERROR_ALREADY_EXISTS)
+        return -2;
+
+    return -1;
 }
 
-int retro_vfs_file_flush_impl(libretro_vfs_implementation_file *stream)
+int retro_vfs_mkdir_impl(const char* dir)
 {
-	if (!stream || !stream->fp)
-		return -1;
-
-	return RunAsyncAndCatchErrors<int>([&]() {
-		return concurrency::create_task(stream->fp->FlushAsync()).then([&](bool this_value_is_not_even_documented_wtf) {
-			/* The bool value may be reporting an error or something, but just leave it alone for now */
-			/* https://github.com/MicrosoftDocs/winrt-api/issues/841 */
-			return 0;
-		});
-	}, -1);
+    return uwp_mkdir_impl(std::filesystem::path(dir));
 }
 
-int retro_vfs_file_remove_impl(const char *path)
+/* The first run paramater is used to avoid error checking 
+ * when doing recursion.
+ * Unlike the initial implementation, this can move folders 
+ * even empty ones when you want to move a directory structure.
+ *
+ * This will fail even if a single file cannot be moved.
+ */
+static int uwp_move_path(
+      std::filesystem::path old_path,
+      std::filesystem::path new_path,
+      bool firstrun)
 {
-	if (!path || !*path)
-		return -1;
-
-	wchar_t *path_wide = utf8_to_utf16_string_alloc(path);
-	windowsize_path(path_wide);
-	Platform::String^ path_str = ref new Platform::String(path_wide);
-	free(path_wide);
-
-	return RunAsyncAndCatchErrors<int>([&]() {
-		return concurrency::create_task(LocateStorageItem<StorageFile>(path_str)).then([&](StorageFile^ file) {
-			return file->DeleteAsync(StorageDeleteOption::PermanentDelete);
-		}).then([&]() {
-			return 0;
-		});
-	}, -1);
+    if (old_path.empty() || new_path.empty())
+        return -1;
+
+    if (firstrun)
+    {
+        WIN32_FILE_ATTRIBUTE_DATA lpFileInfo, targetfileinfo;
+        bool parent_dir_exists = false;
+
+        /* Make sure that parent path exists */
+        if (GetFileAttributesExFromAppW(
+                 new_path.parent_path().wstring().c_str(),
+                 GetFileExInfoStandard, &lpFileInfo))
+        {
+            /* Check that the files attributes are not null or empty */
+            if (     lpFileInfo.dwFileAttributes 
+                  != INVALID_FILE_ATTRIBUTES 
+                  && lpFileInfo.dwFileAttributes != 0)
+            {
+               /* Parent path doesn't exist, so we gotta create it  */
+                if (!(lpFileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
+                    uwp_mkdir_impl(new_path.parent_path());
+            }
+        }
+
+        /* Make sure that source path exists */
+        if (GetFileAttributesExFromAppW(old_path.wstring().c_str(), GetFileExInfoStandard, &lpFileInfo))
+        {
+            /* Check that the files attributes are not null or empty */
+            if (     lpFileInfo.dwFileAttributes != INVALID_FILE_ATTRIBUTES 
+                  && lpFileInfo.dwFileAttributes != 0)
+            {
+                /* Check if source path is a dir */
+                if (lpFileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+                {
+                   int result;
+                   /* create the target dir */
+                   CreateDirectoryFromAppW(new_path.wstring().c_str(), NULL);
+                   /* Call move function again but with first run disabled in
+                    * order to move the folder */
+                   if ((result = uwp_move_path(old_path, new_path, false)) != 0)
+                      return result;
+                }
+                else
+                {
+                    /* The file that we want to move exists so we can copy it now
+                     * check if target file already exists. */
+                   if (GetFileAttributesExFromAppW(
+                            new_path.wstring().c_str(),
+                            GetFileExInfoStandard,
+                            &targetfileinfo))
+                    {
+                        if (
+                                 targetfileinfo.dwFileAttributes != INVALID_FILE_ATTRIBUTES
+                              && targetfileinfo.dwFileAttributes != 0
+                              && (!(targetfileinfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)))
+                        {
+                            if (DeleteFileFromAppW(new_path.wstring().c_str()))
+                                return -1;
+                        }
+                    }
+
+                    if (!MoveFileFromAppW(old_path.wstring().c_str(),
+                             new_path.wstring().c_str()))
+                        return -1;
+                    /* Set ACL */
+                    uwp_set_acl(new_path.wstring().c_str(), L"S-1-15-2-1");
+                }
+            }
+        }
+
+    }
+    else
+    {
+       HANDLE searchResults;
+       WIN32_FIND_DATA findDataResult;
+       /* We are bypassing error checking and moving a dir.
+        * First we have to get a list of files in the dir. */
+       wchar_t* filteredPath = wcsdup(old_path.wstring().c_str());
+       wcscat_s(filteredPath, sizeof(L"\\*.*"), L"\\*.*");
+       searchResults         = FindFirstFileExFromAppW(
+             filteredPath, FindExInfoBasic, &findDataResult,
+             FindExSearchNameMatch, NULL, FIND_FIRST_EX_LARGE_FETCH);
+
+       if (searchResults != INVALID_HANDLE_VALUE)
+       {
+          bool fail = false;
+          do
+          {
+             if (     wcscmp(findDataResult.cFileName, L".")  != 0 
+                   && wcscmp(findDataResult.cFileName, L"..") != 0)
+             {
+                std::filesystem::path temp_old = old_path;
+                std::filesystem::path temp_new = new_path;
+                temp_old /= findDataResult.cFileName;
+                temp_new /= findDataResult.cFileName;
+                if (    findDataResult.dwFileAttributes 
+                      & FILE_ATTRIBUTE_DIRECTORY)
+                {
+                   CreateDirectoryFromAppW(temp_new.wstring().c_str(), NULL);
+                   if (uwp_move_path(temp_old, temp_new, false) != 0)
+                      fail = true;
+                }
+                else
+                {
+                   WIN32_FILE_ATTRIBUTE_DATA targetfileinfo;
+                   /* The file that we want to move exists so we can copy
+                    * it now.
+                    * Check if target file already exists. */
+                   if (GetFileAttributesExFromAppW(temp_new.wstring().c_str(),
+                            GetFileExInfoStandard, &targetfileinfo))
+                   {
+                      if (
+                               (targetfileinfo.dwFileAttributes !=
+                                INVALID_FILE_ATTRIBUTES)
+                            && (targetfileinfo.dwFileAttributes != 0)
+                            && (!(targetfileinfo.dwFileAttributes 
+                                  & FILE_ATTRIBUTE_DIRECTORY)))
+                      {
+                         if (DeleteFileFromAppW(temp_new.wstring().c_str()))
+                            fail = true;
+                      }
+                   }
+
+                   if (!MoveFileFromAppW(temp_old.wstring().c_str(),
+                            temp_new.wstring().c_str()))
+                      fail = true;
+                   /* Set ACL - this step sucks or at least used to 
+                    * before I made a whole function
+                    * Don't know if we actually "need" to set the ACL
+                    * though */
+                   uwp_set_acl(temp_new.wstring().c_str(), L"S-1-15-2-1");
+                }
+             }
+          } while (FindNextFile(searchResults, &findDataResult));
+          FindClose(searchResults);
+          if (fail)
+             return -1;
+       }
+       free(filteredPath);
+    }
+    return 0;
 }
 
-/* TODO: this may not work if trying to move a directory */
-int retro_vfs_file_rename_impl(const char *old_path, const char *new_path)
+/* C doesn't support default arguments so we wrap it up in a shell to enable 
+ * us to use default arguments.
+ * Default arguments mean that we can do better recursion */
+int retro_vfs_file_rename_impl(const char* old_path, const char* new_path)
 {
-	if (!old_path || !*old_path || !new_path || !*new_path)
-		return -1;
-
-	wchar_t* old_path_wide = utf8_to_utf16_string_alloc(old_path);
-	Platform::String^ old_path_str = ref new Platform::String(old_path_wide);
-	free(old_path_wide);
-
-	char* new_dir_path = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
-	fill_pathname_basedir(new_dir_path, new_path, PATH_MAX_LENGTH);
-	wchar_t *new_dir_path_wide = utf8_to_utf16_string_alloc(new_dir_path);
-	windowsize_path(new_dir_path_wide);
-	Platform::String^ new_dir_path_str = ref new Platform::String(new_dir_path_wide);
-	free(new_dir_path_wide);
-	free(new_dir_path);
-
-	char* new_file_name = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
-	fill_pathname_base(new_file_name, new_path, PATH_MAX_LENGTH);
-	wchar_t *new_file_name_wide = utf8_to_utf16_string_alloc(new_file_name);
-	Platform::String^ new_file_name_str = ref new Platform::String(new_file_name_wide);
-	free(new_file_name_wide);
-	free(new_file_name);
-
-	retro_assert(!old_path_str->IsEmpty() && !new_dir_path_str->IsEmpty() && !new_file_name_str->IsEmpty());
-
-	return RunAsyncAndCatchErrors<int>([&]() {
-		concurrency::task<StorageFile^> old_file_task = concurrency::create_task(LocateStorageItem<StorageFile>(old_path_str));
-		concurrency::task<StorageFolder^> new_dir_task = concurrency::create_task(LocateStorageItem<StorageFolder>(new_dir_path_str));
-		return concurrency::create_task([&] {
-			/* Run these two tasks in parallel */
-			/* TODO: There may be some cleaner way to express this */
-			concurrency::task_group group;
-			group.run([&] { return old_file_task; });
-			group.run([&] { return new_dir_task; });
-			group.wait();
-		}).then([&]() {
-			return old_file_task.get()->MoveAsync(new_dir_task.get(), new_file_name_str, NameCollisionOption::ReplaceExisting);
-		}).then([&]() {
-			return 0;
-		});
-	}, -1);
+    return uwp_move_path(std::filesystem::path(old_path),
+          std::filesystem::path(old_path), true);
 }
 
 const char *retro_vfs_file_get_path_impl(libretro_vfs_implementation_file *stream)
 {
-	/* should never happen, do something noisy so caller can be fixed */
-	if (!stream)
-		abort();
-	return stream->orig_path;
+   /* Should never happen, do something noisy so caller can be fixed */
+   if (!stream)
+      abort();
+   return stream->orig_path;
 }
 
 int retro_vfs_stat_impl(const char *path, int32_t *size)
 {
-	if (!path || !*path)
-		return 0;
-
-	wchar_t *path_wide = utf8_to_utf16_string_alloc(path);
-	windowsize_path(path_wide);
-	Platform::String^ path_str = ref new Platform::String(path_wide);
-	free(path_wide);
-
-	IStorageItem^ item = LocateStorageFileOrFolder(path_str);
-	if (!item)
-		return 0;
-
-	return RunAsyncAndCatchErrors<int>([&]() {
-		return concurrency::create_task(item->GetBasicPropertiesAsync()).then([&](BasicProperties^ properties) {
-			if (size)
-				*size = properties->Size;
-			return item->IsOfType(StorageItemTypes::Folder) ? RETRO_VFS_STAT_IS_VALID | RETRO_VFS_STAT_IS_DIRECTORY : RETRO_VFS_STAT_IS_VALID;
-		});
-	}, 0);
-}
-
-int retro_vfs_mkdir_impl(const char *dir)
-{
-	if (!dir || !*dir)
-		return -1;
-
-	char* dir_local = strdup(dir);
-	/* If the path ends with a slash, we have to remove it for basename to work */
-	char* tmp = dir_local + strlen(dir_local) - 1;
-	if (path_char_is_slash(*tmp))
-		*tmp = 0;
-
-	char* dir_name = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
-	fill_pathname_base(dir_name, dir_local, PATH_MAX_LENGTH);
-	wchar_t *dir_name_wide = utf8_to_utf16_string_alloc(dir_name);
-	Platform::String^ dir_name_str = ref new Platform::String(dir_name_wide);
-	free(dir_name_wide);
-	free(dir_name);
-
-	char* parent_path = (char*)malloc(PATH_MAX_LENGTH * sizeof(char));
-	fill_pathname_parent_dir(parent_path, dir_local, PATH_MAX_LENGTH);
-	wchar_t *parent_path_wide = utf8_to_utf16_string_alloc(parent_path);
-	windowsize_path(parent_path_wide);
-	Platform::String^ parent_path_str = ref new Platform::String(parent_path_wide);
-	free(parent_path_wide);
-	free(parent_path);
-
-	retro_assert(!dir_name_str->IsEmpty() && !parent_path_str->IsEmpty());
-
-	free(dir_local);
-
-	return RunAsyncAndCatchErrors<int>([&]() {
-		return concurrency::create_task(LocateStorageItem<StorageFolder>(parent_path_str)).then([&](StorageFolder^ parent) {
-			return parent->CreateFolderAsync(dir_name_str);
-		}).then([&](concurrency::task<StorageFolder^> new_dir) {
-			try
-			{
-				new_dir.get();
-			}
-			catch (Platform::COMException^ e)
-			{
-				if (e->HResult == HRESULT_FROM_WIN32(ERROR_ALREADY_EXISTS))
-					return -2;
-				throw;
-			}
-			return 0;
-		});
-	}, -1);
+   wchar_t *path_wide;
+   _WIN32_FILE_ATTRIBUTE_DATA attribdata;
+
+   if (!path || !*path)
+      return 0;
+
+   path_wide = utf8_to_utf16_string_alloc(path);
+   windowsize_path(path_wide);
+
+   /* Try Win32 first, this should work in AppData */
+   if (GetFileAttributesExFromAppW(path_wide,
+            GetFileExInfoStandard, &attribdata))
+   {
+       if (attribdata.dwFileAttributes != INVALID_FILE_ATTRIBUTES)
+       {
+           if (!(attribdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
+           {
+               LARGE_INTEGER sz;
+               if (size)
+               {
+                   sz.HighPart = attribdata.nFileSizeHigh;
+                   sz.LowPart = attribdata.nFileSizeLow;
+                   *size = sz.QuadPart;
+               }
+           }
+           free(path_wide);
+           return (attribdata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) 
+              ? RETRO_VFS_STAT_IS_VALID | RETRO_VFS_STAT_IS_DIRECTORY 
+              : RETRO_VFS_STAT_IS_VALID;
+       }
+   }
+   free(path_wide);
+   return 0;
 }
 
 #ifdef VFS_FRONTEND
@@ -727,101 +649,160 @@ struct retro_vfs_dir_handle
 struct libretro_vfs_implementation_dir
 #endif
 {
-	IVectorView<IStorageItem^>^ directory;
-	IIterator<IStorageItem^>^ entry;
-	char *entry_name;
+    char* orig_path;
+    WIN32_FIND_DATAW entry;
+    HANDLE directory;
+    bool next;
+    char path[PATH_MAX_LENGTH];
 };
 
-libretro_vfs_implementation_dir *retro_vfs_opendir_impl(const char *name, bool include_hidden)
+libretro_vfs_implementation_dir* retro_vfs_opendir_impl(
+    const char* name, bool include_hidden)
 {
-	libretro_vfs_implementation_dir *rdir;
+    char path_buf[1024];
+    size_t copied      = 0;
+    wchar_t* path_wide = NULL;
+    libretro_vfs_implementation_dir* rdir;
+
+    /* Reject NULL or empty string paths*/
+    if (!name || (*name == 0))
+        return NULL;
+
+    /*Allocate RDIR struct. Tidied later with retro_closedir*/
+    if (!(rdir = (libretro_vfs_implementation_dir*)calloc(1, sizeof(*rdir))))
+        return NULL;
+
+    rdir->orig_path = strdup(name);
 
-	if (!name || !*name)
-		return NULL;
+    copied          = strlcpy(path_buf, name, sizeof(path_buf));
 
-	rdir = (libretro_vfs_implementation_dir*)calloc(1, sizeof(*rdir));
-	if (!rdir)
-		return NULL;
+    /* Non-NT platforms don't like extra slashes in the path */
+    if (path_buf[copied - 1] != '\\')
+        path_buf[copied++] = '\\';
 
-	wchar_t *name_wide = utf8_to_utf16_string_alloc(name);
-	windowsize_path(name_wide);
-	Platform::String^ name_str = ref new Platform::String(name_wide);
-	free(name_wide);
+    path_buf[copied]       = '*';
+    path_buf[copied + 1]   = '\0';
 
-	rdir->directory = RunAsyncAndCatchErrors<IVectorView<IStorageItem^>^>([&]() {
-		return concurrency::create_task(LocateStorageItem<StorageFolder>(name_str)).then([&](StorageFolder^ folder) {
-			return folder->GetItemsAsync();
-		});
-	}, nullptr);
+    path_wide              = utf8_to_utf16_string_alloc(path_buf);
+    rdir->directory        = FindFirstFileExFromAppW(
+          path_wide, FindExInfoStandard, &rdir->entry,
+          FindExSearchNameMatch, NULL, FIND_FIRST_EX_LARGE_FETCH);
 
-	if (rdir->directory)
-		return rdir;
+    if (path_wide)
+        free(path_wide);
 
-	free(rdir);
-	return NULL;
+    if (include_hidden)
+        rdir->entry.dwFileAttributes |= FILE_ATTRIBUTE_HIDDEN;
+    else
+        rdir->entry.dwFileAttributes &= ~FILE_ATTRIBUTE_HIDDEN;
+
+    if (rdir->directory && rdir != INVALID_HANDLE_VALUE)
+        return rdir;
+
+    retro_vfs_closedir_impl(rdir);
+    return NULL;
 }
 
-bool retro_vfs_readdir_impl(libretro_vfs_implementation_dir *rdir)
+bool retro_vfs_readdir_impl(libretro_vfs_implementation_dir* rdir)
 {
-	if (!rdir->entry)
-	{
-		rdir->entry = rdir->directory->First();
-		return rdir->entry->HasCurrent;
-	}
-	else
-	{
-		return rdir->entry->MoveNext();
-	}
+    if (rdir->next)
+        return (FindNextFileW(rdir->directory, &rdir->entry) != 0);
+
+    rdir->next = true;
+    return (rdir->directory != INVALID_HANDLE_VALUE);
 }
 
-const char *retro_vfs_dirent_get_name_impl(libretro_vfs_implementation_dir *rdir)
+const char* retro_vfs_dirent_get_name_impl(libretro_vfs_implementation_dir* rdir)
 {
-	if (rdir->entry_name)
-		free(rdir->entry_name);
-	rdir->entry_name = utf16_to_utf8_string_alloc(rdir->entry->Current->Name->Data());
-	return rdir->entry_name;
+    char* name = utf16_to_utf8_string_alloc(rdir->entry.cFileName);
+    memset(rdir->entry.cFileName, 0, sizeof(rdir->entry.cFileName));
+    strlcpy((char*)rdir->entry.cFileName, name, sizeof(rdir->entry.cFileName));
+    if (name)
+        free(name);
+    return (char*)rdir->entry.cFileName;
 }
 
-bool retro_vfs_dirent_is_dir_impl(libretro_vfs_implementation_dir *rdir)
+bool retro_vfs_dirent_is_dir_impl(libretro_vfs_implementation_dir* rdir)
 {
-	return rdir->entry->Current->IsOfType(StorageItemTypes::Folder);
+    const WIN32_FIND_DATA* entry = (const WIN32_FIND_DATA*)&rdir->entry;
+    return entry->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
 }
 
-int retro_vfs_closedir_impl(libretro_vfs_implementation_dir *rdir)
+int retro_vfs_closedir_impl(libretro_vfs_implementation_dir* rdir)
 {
-	if (!rdir)
-		return -1;
+    if (!rdir)
+        return -1;
 
-	if (rdir->entry_name)
-		free(rdir->entry_name);
-	rdir->entry = nullptr;
-	rdir->directory = nullptr;
+    if (rdir->directory != INVALID_HANDLE_VALUE)
+        FindClose(rdir->directory);
 
-	free(rdir);
-	return 0;
-}
-
-bool uwp_drive_exists(const char *path)
-{
-	if (!path || !*path)
-		return 0;
-
-	wchar_t *path_wide = utf8_to_utf16_string_alloc(path);
-	Platform::String^ path_str = ref new Platform::String(path_wide);
-	free(path_wide);
-
-	return RunAsyncAndCatchErrors<bool>([&]() {
-		return concurrency::create_task(StorageFolder::GetFolderFromPathAsync(path_str)).then([](StorageFolder^ properties) {
-			return true;
-		});
-	}, false);
+    if (rdir->orig_path)
+        free(rdir->orig_path);
+    free(rdir);
+    return 0;
 }
 
-char* uwp_trigger_picker(void)
+void uwp_set_acl(const wchar_t* path, const wchar_t* AccessString)
 {
-	return RunAsyncAndCatchErrors<char*>([&]() {
-		return TriggerPickerAddDialog().then([](Platform::String^ path) {
-			return utf16_to_utf8_string_alloc(path->Data());
-		});
-	}, NULL);
+    PSECURITY_DESCRIPTOR SecurityDescriptor = NULL;
+    EXPLICIT_ACCESSW ExplicitAccess         = { 0 };
+    ACL* AccessControlCurrent               = NULL;
+    ACL* AccessControlNew                   = NULL;
+    SECURITY_INFORMATION SecurityInfo       = DACL_SECURITY_INFORMATION;
+    PSID SecurityIdentifier                 = NULL;
+    HANDLE original_file                    = CreateFileFromAppW(path,
+          GENERIC_READ    | GENERIC_WRITE | WRITE_DAC,
+          FILE_SHARE_READ | FILE_SHARE_WRITE,
+          NULL, OPEN_EXISTING, 0, NULL);
+
+    if (original_file != INVALID_HANDLE_VALUE)
+    {
+       if (
+             GetSecurityInfo(
+                original_file,
+                SE_FILE_OBJECT,
+                DACL_SECURITY_INFORMATION,
+                NULL,
+                NULL,
+                &AccessControlCurrent,
+                NULL,
+                &SecurityDescriptor
+                ) == ERROR_SUCCESS
+          )
+       {
+          ConvertStringSidToSidW(AccessString, &SecurityIdentifier);
+          if (SecurityIdentifier)
+          {
+             ExplicitAccess.grfAccessPermissions= GENERIC_READ | GENERIC_EXECUTE | GENERIC_WRITE;
+             ExplicitAccess.grfAccessMode       = SET_ACCESS;
+             ExplicitAccess.grfInheritance      = SUB_CONTAINERS_AND_OBJECTS_INHERIT;
+             ExplicitAccess.Trustee.TrusteeForm = TRUSTEE_IS_SID;
+             ExplicitAccess.Trustee.TrusteeType = TRUSTEE_IS_WELL_KNOWN_GROUP;
+             ExplicitAccess.Trustee.ptstrName   = reinterpret_cast<wchar_t*>(SecurityIdentifier);
+
+             if (
+                   SetEntriesInAclW(
+                      1,
+                      &ExplicitAccess,
+                      AccessControlCurrent,
+                      &AccessControlNew
+                      ) == ERROR_SUCCESS
+                )
+                SetSecurityInfo(
+                      original_file,
+                      SE_FILE_OBJECT,
+                      SecurityInfo,
+                      NULL,
+                      NULL,
+                      AccessControlNew,
+                      NULL
+                      );
+          }
+       }
+       if (SecurityDescriptor)
+          LocalFree(reinterpret_cast<HLOCAL>(SecurityDescriptor));
+       if (AccessControlNew)
+          LocalFree(reinterpret_cast<HLOCAL>(AccessControlNew));
+       CloseHandle(original_file);
+    }
 }
diff --git a/src/libretro/libretro-common/vulkan/vulkan_symbol_wrapper.c b/src/libretro/libretro-common/vulkan/vulkan_symbol_wrapper.c
index 7fe13ea8b9..f816bdce40 100644
--- a/src/libretro/libretro-common/vulkan/vulkan_symbol_wrapper.c
+++ b/src/libretro/libretro-common/vulkan/vulkan_symbol_wrapper.c
@@ -3,6 +3,7 @@
 #include <vulkan/vulkan_symbol_wrapper.h>
 
 PFN_vkCreateInstance vulkan_symbol_wrapper_vkCreateInstance;
+PFN_vkEnumerateInstanceVersion vulkan_symbol_wrapper_vkEnumerateInstanceVersion;
 PFN_vkEnumerateInstanceExtensionProperties vulkan_symbol_wrapper_vkEnumerateInstanceExtensionProperties;
 PFN_vkEnumerateInstanceLayerProperties vulkan_symbol_wrapper_vkEnumerateInstanceLayerProperties;
 PFN_vkDestroyInstance vulkan_symbol_wrapper_vkDestroyInstance;
@@ -156,14 +157,10 @@ PFN_vkCreateDisplayModeKHR vulkan_symbol_wrapper_vkCreateDisplayModeKHR;
 PFN_vkGetDisplayPlaneCapabilitiesKHR vulkan_symbol_wrapper_vkGetDisplayPlaneCapabilitiesKHR;
 PFN_vkCreateDisplayPlaneSurfaceKHR vulkan_symbol_wrapper_vkCreateDisplayPlaneSurfaceKHR;
 PFN_vkCreateSharedSwapchainsKHR vulkan_symbol_wrapper_vkCreateSharedSwapchainsKHR;
-PFN_vkCreateDebugReportCallbackEXT vulkan_symbol_wrapper_vkCreateDebugReportCallbackEXT;
-PFN_vkDestroyDebugReportCallbackEXT vulkan_symbol_wrapper_vkDestroyDebugReportCallbackEXT;
-PFN_vkDebugReportMessageEXT vulkan_symbol_wrapper_vkDebugReportMessageEXT;
-PFN_vkDebugMarkerSetObjectTagEXT vulkan_symbol_wrapper_vkDebugMarkerSetObjectTagEXT;
-PFN_vkDebugMarkerSetObjectNameEXT vulkan_symbol_wrapper_vkDebugMarkerSetObjectNameEXT;
-PFN_vkCmdDebugMarkerBeginEXT vulkan_symbol_wrapper_vkCmdDebugMarkerBeginEXT;
-PFN_vkCmdDebugMarkerEndEXT vulkan_symbol_wrapper_vkCmdDebugMarkerEndEXT;
-PFN_vkCmdDebugMarkerInsertEXT vulkan_symbol_wrapper_vkCmdDebugMarkerInsertEXT;
+
+PFN_vkCreateDebugUtilsMessengerEXT vulkan_symbol_wrapper_vkCreateDebugUtilsMessengerEXT;
+PFN_vkDestroyDebugUtilsMessengerEXT vulkan_symbol_wrapper_vkDestroyDebugUtilsMessengerEXT;
+PFN_vkSetDebugUtilsObjectNameEXT vulkan_symbol_wrapper_vkSetDebugUtilsObjectNameEXT;
 
 static PFN_vkGetInstanceProcAddr GetInstanceProcAddr;
 void vulkan_symbol_wrapper_init(PFN_vkGetInstanceProcAddr get_instance_proc_addr)
@@ -193,6 +190,7 @@ VkBool32 vulkan_symbol_wrapper_load_global_symbols(void)
     if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(NULL, "vkCreateInstance", vkCreateInstance)) return VK_FALSE;
     if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(NULL, "vkEnumerateInstanceExtensionProperties", vkEnumerateInstanceExtensionProperties)) return VK_FALSE;
     if (!VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(NULL, "vkEnumerateInstanceLayerProperties", vkEnumerateInstanceLayerProperties)) return VK_FALSE;
+    VULKAN_SYMBOL_WRAPPER_LOAD_INSTANCE_SYMBOL(NULL, "vkEnumerateInstanceVersion", vkEnumerateInstanceVersion);
     return VK_TRUE;
 }