Merge branch 'master' of http://8.136.234.80:10002/WangYongJun/GameConsole

app/src/main/cpp/config.def.h

@@ -825,13 +825,13 @@
 #define DEFAULT_GLOBAL_CORE_OPTIONS false
 #define DEFAULT_AUTO_SHADERS_ENABLE true
 
-#define DEFAULT_SORT_SAVEFILES_ENABLE true
-#define DEFAULT_SORT_SAVESTATES_ENABLE true
+#define DEFAULT_SORT_SAVEFILES_ENABLE false
+#define DEFAULT_SORT_SAVESTATES_ENABLE false
 #define DEFAULT_SORT_SAVEFILES_BY_CONTENT_ENABLE false
 #define DEFAULT_SORT_SAVESTATES_BY_CONTENT_ENABLE false
 #define DEFAULT_SORT_SCREENSHOTS_BY_CONTENT_ENABLE false
 
-#define DEFAULT_SAVESTATES_IN_CONTENT_DIR false
+#define DEFAULT_SAVESTATES_IN_CONTENT_DIR true
 #define DEFAULT_SAVEFILES_IN_CONTENT_DIR false
 #define DEFAULT_SYSTEMFILES_IN_CONTENT_DIR false
 #define DEFAULT_SCREENSHOTS_IN_CONTENT_DIR false

app/src/main/cpp/input/input_autodetect_builtin.c

@@ -101,7 +101,7 @@ DECL_BTN(b, 96) \
 DECL_BTN(x, 100) \
 DECL_BTN(y, 99) \
 DECL_BTN(start, 108) \
-DECL_BTN(select, 4) \
+DECL_BTN(select, 109) \
 DECL_BTN(up, h0up) \
 DECL_BTN(down, h0down) \
 DECL_BTN(left, h0left) \

app/src/main/cpp/tasks/task_autodetect.c

@@ -536,7 +536,7 @@ static void input_autoconfigure_connect_handler(retro_task_t *task)
          /* A valid autoconfig was applied */
          if (!(autoconfig_handle->flags & AUTOCONF_FLAG_SUPPRESS_NOTIFICATIONS))
             snprintf(task_title, sizeof(task_title),
-                  msg_hash_to_str(MSG_DEVICE_CONFIGURED_IN_PORT_NR),
+                  "%s configured in port %u",
                   device_display_name,
                   autoconfig_handle->port + 1);
       }
@@ -544,7 +544,7 @@ static void input_autoconfigure_connect_handler(retro_task_t *task)
        * incorrect) fallback definition was used... */
       else
          snprintf(task_title, sizeof(task_title),
-                  msg_hash_to_str(MSG_DEVICE_NOT_CONFIGURED_FALLBACK_NR),
+                  "%s (%u/%u) not configured, using fallback",
                   device_display_name,
                   autoconfig_handle->device_info.vid,
                   autoconfig_handle->device_info.pid);
@@ -552,7 +552,7 @@ static void input_autoconfigure_connect_handler(retro_task_t *task)
    /* Autoconfig failed */
    else
          snprintf(task_title, sizeof(task_title),
-                  msg_hash_to_str(MSG_DEVICE_NOT_CONFIGURED_NR),
+                  "%s (%u/%u) not configured",
                   device_display_name,
                   autoconfig_handle->device_info.vid,
                   autoconfig_handle->device_info.pid);

app/src/main/cpp/tasks/task_overlay.c

@@ -1,1100 +0,0 @@
-/*  RetroArch - A frontend for libretro.
- *  Copyright (C) 2011-2017 - Daniel De Matteis
- *
- *  RetroArch is free software: you can redistribute it and/or modify it under the terms
- *  of the GNU General Public License as published by the Free Software Found-
- *  ation, either version 3 of the License, or (at your option) any later version.
- *
- *  RetroArch is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
- *  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
- *  PURPOSE.  See the GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along with RetroArch.
- *  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <stdlib.h>
-
-#include <compat/strl.h>
-#include <compat/posix_string.h>
-#include <retro_miscellaneous.h>
-#include <file/file_path.h>
-#include <file/config_file.h>
-#include <lists/string_list.h>
-#include <streams/file_stream.h>
-#include <string/stdstring.h>
-#include <lrc_hash.h>
-
-#include "tasks_internal.h"
-
-#include "../gfx/video_driver.h"
-#include "../input/input_driver.h"
-#include "../input/input_overlay.h"
-#include "../input/input_remapping.h"
-#include "../verbosity.h"
-
-typedef struct overlay_loader overlay_loader_t;
-
-struct overlay_loader
-{
-   config_file_t *conf;
-   char *overlay_path;
-   struct overlay *overlays;
-   struct overlay *active;
-
-   size_t resolve_pos;
-   unsigned size;
-   unsigned pos;
-   unsigned pos_increment;
-
-   float overlay_opacity;
-   overlay_layout_desc_t layout_desc;
-
-   enum overlay_status state;
-   enum overlay_image_transfer_status loading_status;
-
-   uint16_t overlay_types;
-
-   uint8_t flags;
-};
-
-static void task_overlay_image_done(struct overlay *overlay)
-{
-   overlay->pos           = 0;
-   /* Divide iteration steps by half of total descs if size is even,
-    * otherwise default to 8 (arbitrary value for now to speed things up). */
-   overlay->pos_increment = (overlay->size / 2) ? ((unsigned)(overlay->size / 2)) : 8;
-}
-
-static void task_overlay_load_desc_image(
-      overlay_loader_t *loader,
-      struct overlay_desc *desc,
-      struct overlay *input_overlay,
-      unsigned ol_idx, unsigned desc_idx)
-{
-   char overlay_desc_image_key[32];
-   char image_path[PATH_MAX_LENGTH];
-   config_file_t              *conf = loader->conf;
-
-   overlay_desc_image_key[0]        = '\0';
-   image_path[0]                    = '\0';
-
-   snprintf(overlay_desc_image_key, sizeof(overlay_desc_image_key),
-         "overlay%u_desc%u_overlay", ol_idx, desc_idx);
-
-   if (config_get_path(conf, overlay_desc_image_key,
-            image_path, sizeof(image_path)))
-   {
-      struct texture_image image_tex;
-      char path[PATH_MAX_LENGTH];
-      fill_pathname_resolve_relative(path, loader->overlay_path,
-            image_path, sizeof(path));
-
-      image_tex.supports_rgba = (loader->flags & OVERLAY_LOADER_RGBA_SUPPORT);
-
-      if (image_texture_load(&image_tex, path))
-      {
-         input_overlay->load_images[input_overlay->load_images_size++] = image_tex;
-         desc->image       = image_tex;
-         desc->image_index = input_overlay->load_images_size - 1;
-      }
-   }
-
-   input_overlay->pos ++;
-}
-
-static void task_overlay_redefine_eightway_direction(
-      char *str, input_bits_t *data)
-{
-   char *tok, *save;
-   unsigned bit;
-
-   BIT256_CLEAR_ALL(*data);
-
-   for (tok = strtok_r(str, "|", &save); tok;
-         tok = strtok_r(NULL, "|", &save))
-   {
-      bit = input_config_translate_str_to_bind_id(tok);
-      if (bit < RARCH_CUSTOM_BIND_LIST_END)
-         BIT256_SET(*data, bit);
-   }
-}
-
-static void task_overlay_desc_populate_eightway_config(
-      overlay_loader_t *loader,
-      struct overlay_desc *desc,
-      unsigned ol_idx, unsigned desc_idx)
-{
-   input_driver_state_t *input_st = input_state_get_ptr();
-   overlay_eightway_config_t *eightway;
-   char conf_key_base[20];
-   char conf_key[64];
-   char *str;
-
-   desc->eightway_config = (overlay_eightway_config_t *)
-         calloc(1, sizeof(overlay_eightway_config_t));
-   eightway              = desc->eightway_config;
-
-   /* Populate default vals for the eightway type.
-    */
-   switch (desc->type)
-   {
-      case OVERLAY_TYPE_DPAD_AREA:
-         BIT256_SET(eightway->up,    RETRO_DEVICE_ID_JOYPAD_UP);
-         BIT256_SET(eightway->down,  RETRO_DEVICE_ID_JOYPAD_DOWN);
-         BIT256_SET(eightway->left,  RETRO_DEVICE_ID_JOYPAD_LEFT);
-         BIT256_SET(eightway->right, RETRO_DEVICE_ID_JOYPAD_RIGHT);
-
-         eightway->slope_low  = &input_st->overlay_eightway_dpad_slopes[0];
-         eightway->slope_high = &input_st->overlay_eightway_dpad_slopes[1];
-         break;
-
-      case OVERLAY_TYPE_ABXY_AREA:
-         BIT256_SET(eightway->up,    RETRO_DEVICE_ID_JOYPAD_X);
-         BIT256_SET(eightway->down,  RETRO_DEVICE_ID_JOYPAD_B);
-         BIT256_SET(eightway->left,  RETRO_DEVICE_ID_JOYPAD_Y);
-         BIT256_SET(eightway->right, RETRO_DEVICE_ID_JOYPAD_A);
-
-         eightway->slope_low  = &input_st->overlay_eightway_abxy_slopes[0];
-         eightway->slope_high = &input_st->overlay_eightway_abxy_slopes[1];
-         break;
-
-      default:
-         free(eightway);
-         desc->eightway_config = NULL;
-         return;
-   }
-
-   snprintf(conf_key_base, sizeof(conf_key_base), "overlay%u_desc%u", ol_idx, desc_idx);
-
-   /* Redefine eightway vals if specified in conf
-    */
-   strlcpy(conf_key, conf_key_base, sizeof(conf_key));
-   strlcat(conf_key, "_up", sizeof(conf_key));
-   if (config_get_string(loader->conf, conf_key, &str))
-   {
-      task_overlay_redefine_eightway_direction(str, &eightway->up);
-      free(str);
-   }
-
-   strlcpy(conf_key, conf_key_base, sizeof(conf_key));
-   strlcat(conf_key, "_down", sizeof(conf_key));
-   if (config_get_string(loader->conf, conf_key, &str))
-   {
-      task_overlay_redefine_eightway_direction(str, &eightway->down);
-      free(str);
-   }
-
-   strlcpy(conf_key, conf_key_base, sizeof(conf_key));
-   strlcat(conf_key, "_right", sizeof(conf_key));
-   if (config_get_string(loader->conf, conf_key, &str))
-   {
-      task_overlay_redefine_eightway_direction(str, &eightway->right);
-      free(str);
-   }
-
-   strlcpy(conf_key, conf_key_base, sizeof(conf_key));
-   strlcat(conf_key, "_left", sizeof(conf_key));
-   if (config_get_string(loader->conf, conf_key, &str))
-   {
-      task_overlay_redefine_eightway_direction(str, &eightway->left);
-      free(str);
-   }
-
-   /* Prepopulate diagonals.
-    */
-   bits_or_bits(eightway->up_right.data, eightway->up.data,
-         CUSTOM_BINDS_U32_COUNT);
-   bits_or_bits(eightway->up_right.data, eightway->right.data,
-         CUSTOM_BINDS_U32_COUNT);
-
-   bits_or_bits(eightway->up_left.data, eightway->up.data,
-         CUSTOM_BINDS_U32_COUNT);
-   bits_or_bits(eightway->up_left.data, eightway->left.data,
-         CUSTOM_BINDS_U32_COUNT);
-
-   bits_or_bits(eightway->down_right.data, eightway->down.data,
-         CUSTOM_BINDS_U32_COUNT);
-   bits_or_bits(eightway->down_right.data, eightway->right.data,
-         CUSTOM_BINDS_U32_COUNT);
-
-   bits_or_bits(eightway->down_left.data, eightway->down.data,
-         CUSTOM_BINDS_U32_COUNT);
-   bits_or_bits(eightway->down_left.data, eightway->left.data,
-         CUSTOM_BINDS_U32_COUNT);
-}
-
-static bool task_overlay_load_desc(
-      overlay_loader_t *loader,
-      struct overlay_desc *desc,
-      struct overlay *input_overlay,
-      unsigned ol_idx, unsigned desc_idx,
-      unsigned width, unsigned height,
-      bool normalized, float alpha_mod, float range_mod)
-{
-   float width_mod, height_mod;
-   char conf_key[64];
-   char overlay_desc_key[32];
-   char overlay_desc_normalized_key[32];
-   char overlay[256];
-   float tmp_float                      = 0.0f;
-   bool tmp_bool                        = false;
-   bool ret                             = true;
-   bool by_pixel                        = false;
-   char *key                            = NULL;
-   struct string_list list              = {0};
-   const char *x                        = NULL;
-   const char *y                        = NULL;
-   const char *box                      = NULL;
-   config_file_t *conf                  = loader->conf;
-
-   overlay_desc_key[0]                  = 
-      conf_key[0]                       =
-      overlay[0]                        = '\0';
-
-   snprintf(overlay_desc_key, sizeof(overlay_desc_key),
-         "overlay%u_desc%u", ol_idx, desc_idx);
-
-   strlcpy(overlay_desc_normalized_key, overlay_desc_key,
-         sizeof(overlay_desc_normalized_key));
-   strlcat(overlay_desc_normalized_key, "_normalized",
-         sizeof(overlay_desc_normalized_key));
-   if (config_get_bool(conf, overlay_desc_normalized_key, &tmp_bool))
-      normalized = tmp_bool;
-
-   by_pixel = !normalized;
-
-   if (by_pixel && (width == 0 || height == 0))
-   {
-      RARCH_ERR("[Overlay]: Base overlay is not set and not using normalized coordinates.\n");
-      ret = false;
-      goto end;
-   }
-
-   if (!config_get_array(conf, overlay_desc_key, overlay, sizeof(overlay)))
-   {
-      RARCH_ERR("[Overlay]: Didn't find key: %s.\n", overlay_desc_key);
-      ret = false;
-      goto end;
-   }
-
-   string_list_initialize(&list);
-   if (!string_split_noalloc(&list, overlay, ", "))
-   {
-      RARCH_ERR("[Overlay]: Failed to split overlay desc.\n");
-      ret = false;
-      goto end;
-   }
-
-   if (list.size < 6)
-   {
-      RARCH_ERR("[Overlay]: Overlay desc is invalid. Requires at least 6 tokens.\n");
-      ret = false;
-      goto end;
-   }
-
-   key            = list.elems[0].data;
-   x              = list.elems[1].data;
-   y              = list.elems[2].data;
-   box            = list.elems[3].data;
-
-   desc->retro_key_idx = 0;
-   BIT256_CLEAR_ALL(desc->button_mask);
-
-   if (string_is_equal(key, "analog_left"))
-      desc->type          = OVERLAY_TYPE_ANALOG_LEFT;
-   else if (string_is_equal(key, "analog_right"))
-      desc->type          = OVERLAY_TYPE_ANALOG_RIGHT;
-   else if (string_is_equal(key, "dpad_area"))
-      desc->type          = OVERLAY_TYPE_DPAD_AREA;
-   else if (string_is_equal(key, "abxy_area"))
-      desc->type          = OVERLAY_TYPE_ABXY_AREA;
-   else if (strstr(key, "retrok_") == key)
-   {
-      desc->type          = OVERLAY_TYPE_KEYBOARD;
-      desc->retro_key_idx = input_config_translate_str_to_rk(key + 7);
-   }
-   else
-   {
-      char      *save = NULL;
-      const char *tmp = strtok_r(key, "|", &save);
-
-      desc->type = OVERLAY_TYPE_BUTTONS;
-
-      for (; tmp; tmp = strtok_r(NULL, "|", &save))
-      {
-         if (!string_is_equal(tmp, "nul"))
-            BIT256_SET(desc->button_mask, input_config_translate_str_to_bind_id(tmp));
-      }
-
-      if (BIT256_GET(desc->button_mask, RARCH_OVERLAY_NEXT))
-      {
-         char overlay_target_key[64];
-         strlcpy(overlay_target_key, overlay_desc_key,
-               sizeof(overlay_target_key));
-         strlcat(overlay_target_key, "_next_target",
-               sizeof(overlay_target_key));
-         config_get_array(conf, overlay_target_key,
-               desc->next_index_name, sizeof(desc->next_index_name));
-      }
-   }
-
-   BIT16_SET(loader->overlay_types, desc->type);
-
-   width_mod  = 1.0f;
-   height_mod = 1.0f;
-
-   if (by_pixel)
-   {
-      width_mod  /= width;
-      height_mod /= height;
-   }
-
-   desc->x       = (float)strtod(x, NULL) * width_mod;
-   desc->y       = (float)strtod(y, NULL) * height_mod;
-   desc->x_shift = desc->x;
-   desc->y_shift = desc->y;
-
-   if (string_is_equal(box, "radial"))
-      desc->hitbox = OVERLAY_HITBOX_RADIAL;
-   else if (string_is_equal(box, "rect"))
-      desc->hitbox = OVERLAY_HITBOX_RECT;
-   else
-   {
-      RARCH_ERR("[Overlay]: Hitbox type (%s) is invalid. Use \"radial\" or \"rect\".\n", box);
-      ret = false;
-      goto end;
-   }
-
-   switch (desc->type)
-   {
-      case OVERLAY_TYPE_ANALOG_LEFT:
-      case OVERLAY_TYPE_ANALOG_RIGHT:
-         {
-            char overlay_analog_saturate_key[64];
-
-            overlay_analog_saturate_key[0] = '\0';
-
-            if (desc->hitbox != OVERLAY_HITBOX_RADIAL)
-            {
-               RARCH_ERR("[Overlay]: Analog hitbox type must be \"radial\".\n");
-               ret = false;
-               goto end;
-            }
-
-            strlcpy(overlay_analog_saturate_key, overlay_desc_key,
-                  sizeof(overlay_analog_saturate_key));
-            strlcat(overlay_analog_saturate_key, "_saturate_pct",
-                  sizeof(overlay_analog_saturate_key));
-            if (config_get_float(conf, overlay_analog_saturate_key,
-                     &tmp_float))
-               desc->analog_saturate_pct = tmp_float;
-            else
-               desc->analog_saturate_pct = 1.0f;
-         }
-         break;
-      case OVERLAY_TYPE_DPAD_AREA:
-      case OVERLAY_TYPE_ABXY_AREA:
-         task_overlay_desc_populate_eightway_config(
-               loader, desc, ol_idx, desc_idx);
-         break;
-      default:
-         /* OVERLAY_TYPE_BUTTONS  - unhandled */
-         /* OVERLAY_TYPE_KEYBOARD - unhandled */
-         break;
-   }
-
-   desc->range_x = (float)strtod(list.elems[4].data, NULL) * width_mod;
-   desc->range_y = (float)strtod(list.elems[5].data, NULL) * height_mod;
-
-   strlcpy(conf_key, overlay_desc_key, sizeof(conf_key));
-   strlcat(conf_key, "_reach_right",   sizeof(conf_key));
-   desc->reach_right = 1.0f;
-   if (config_get_float(conf, conf_key, &tmp_float))
-      desc->reach_right = tmp_float;
-
-   strlcpy(conf_key, overlay_desc_key, sizeof(conf_key));
-   strlcat(conf_key, "_reach_left",   sizeof(conf_key));
-   desc->reach_left = 1.0f;
-   if (config_get_float(conf, conf_key, &tmp_float))
-      desc->reach_left = tmp_float;
-
-   strlcpy(conf_key, overlay_desc_key, sizeof(conf_key));
-   strlcat(conf_key, "_reach_up",   sizeof(conf_key));
-   desc->reach_up = 1.0f;
-   if (config_get_float(conf, conf_key, &tmp_float))
-      desc->reach_up = tmp_float;
-
-   strlcpy(conf_key, overlay_desc_key, sizeof(conf_key));
-   strlcat(conf_key, "_reach_down",   sizeof(conf_key));
-   desc->reach_down = 1.0f;
-   if (config_get_float(conf, conf_key, &tmp_float))
-      desc->reach_down = tmp_float;
-
-   strlcpy(conf_key, overlay_desc_key, sizeof(conf_key));
-   strlcat(conf_key, "_reach_x",   sizeof(conf_key));
-   if (config_get_float(conf, conf_key, &tmp_float))
-   {
-      desc->reach_right = tmp_float;
-      desc->reach_left  = tmp_float;
-   }
-
-   strlcpy(conf_key, overlay_desc_key, sizeof(conf_key));
-   strlcat(conf_key, "_reach_y",   sizeof(conf_key));
-   if (config_get_float(conf, conf_key, &tmp_float))
-   {
-      desc->reach_up   = tmp_float;
-      desc->reach_down = tmp_float;
-   }
-
-   if (     (desc->reach_left == 0.0f && desc->reach_right == 0.0f)
-         || (desc->reach_up   == 0.0f && desc->reach_down  == 0.0f))
-      desc->hitbox = OVERLAY_HITBOX_NONE;
-
-   desc->mod_x   = desc->x - desc->range_x;
-   desc->mod_w   = 2.0f * desc->range_x;
-   desc->mod_y   = desc->y - desc->range_y;
-   desc->mod_h   = 2.0f * desc->range_y;
-
-   strlcpy(conf_key, overlay_desc_key, sizeof(conf_key));
-   strlcat(conf_key, "_alpha_mod",   sizeof(conf_key));
-   desc->alpha_mod = alpha_mod;
-   if (config_get_float(conf, conf_key, &tmp_float))
-         desc->alpha_mod = tmp_float;
-
-   strlcpy(conf_key, overlay_desc_key, sizeof(conf_key));
-   strlcat(conf_key, "_range_mod",   sizeof(conf_key));
-   desc->range_mod = range_mod;
-   if (config_get_float(conf, conf_key, &tmp_float))
-      desc->range_mod = tmp_float;
-
-   strlcpy(conf_key, overlay_desc_key, sizeof(conf_key));
-   strlcat(conf_key, "_exclusive",   sizeof(conf_key));
-   desc->flags &= ~OVERLAY_DESC_EXCLUSIVE;
-   if (config_get_bool(conf, conf_key, &tmp_bool)
-         && tmp_bool)
-      desc->flags |= OVERLAY_DESC_EXCLUSIVE;
-
-   strlcpy(conf_key, overlay_desc_key, sizeof(conf_key));
-   strlcat(conf_key, "_range_mod_exclusive",   sizeof(conf_key));
-   desc->flags &= ~OVERLAY_DESC_RANGE_MOD_EXCLUSIVE;
-   if (config_get_bool(conf, conf_key, &tmp_bool)
-         && tmp_bool)
-      desc->flags |= OVERLAY_DESC_RANGE_MOD_EXCLUSIVE;
-
-   strlcpy(conf_key, overlay_desc_key, sizeof(conf_key));
-   strlcat(conf_key, "_movable",   sizeof(conf_key));
-   desc->flags    &= ~OVERLAY_DESC_MOVABLE;
-   desc->delta_x   = 0.0f;
-   desc->delta_y   = 0.0f;
-
-   if (config_get_bool(conf, conf_key, &tmp_bool)
-         && tmp_bool)
-      desc->flags |= OVERLAY_DESC_MOVABLE;
-
-   input_overlay->pos ++;
-
-end:
-   string_list_deinitialize(&list);
-   return ret;
-}
-
-static ssize_t task_overlay_find_index(const struct overlay *ol,
-      const char *name, size_t size)
-{
-   size_t i;
-
-   if (!ol)
-      return -1;
-
-   for (i = 0; i < size; i++)
-   {
-      if (string_is_equal(ol[i].name, name))
-         return i;
-   }
-
-   return -1;
-}
-
-static bool task_overlay_resolve_targets(struct overlay *ol,
-      size_t idx, size_t size)
-{
-   unsigned i;
-   struct overlay *current = (struct overlay*)&ol[idx];
-
-   for (i = 0; i < current->size; i++)
-   {
-      struct overlay_desc *desc = (struct overlay_desc*)&current->descs[i];
-      const char *next          = desc->next_index_name;
-      ssize_t         next_idx  = (idx + 1) % size;
-
-      if (!string_is_empty(next))
-      {
-         next_idx = task_overlay_find_index(ol, next, size);
-
-         if (next_idx < 0)
-         {
-            RARCH_ERR("[Overlay]: Couldn't find overlay called: \"%s\".\n",
-                  next);
-            return false;
-         }
-      }
-
-      desc->next_index = (unsigned)next_idx;
-   }
-
-   return true;
-}
-
-static void task_overlay_resolve_iterate(retro_task_t *task)
-{
-   overlay_loader_t *loader  = (overlay_loader_t*)task->state;
-   bool             not_done = loader->resolve_pos < loader->size;
-
-   if (!not_done)
-   {
-      loader->state = OVERLAY_STATUS_DEFERRED_DONE;
-      return;
-   }
-
-   if (!task_overlay_resolve_targets(loader->overlays,
-            loader->resolve_pos, loader->size))
-   {
-      RARCH_ERR("[Overlay]: Failed to resolve next targets.\n");
-      task_set_cancelled(task, true);
-      loader->state   = OVERLAY_STATUS_DEFERRED_ERROR;
-      return;
-   }
-
-   if (loader->resolve_pos == 0)
-   {
-      loader->active = &loader->overlays[0];
-
-#if 0
-      /* TODO: MOVE TO MAIN THREAD / CALLBACK */
-      input_overlay_load_active(loader->deferred.opacity);
-      input_overlay_enable(loader->deferred.enable);
-#endif
-   }
-
-   loader->resolve_pos += 1;
-}
-
-static void task_overlay_deferred_loading(retro_task_t *task)
-{
-   size_t i                  = 0;
-   overlay_loader_t *loader  = (overlay_loader_t*)task->state;
-   struct overlay *overlay   = &loader->overlays[loader->pos];
-   bool not_done             = loader->pos < loader->size;
-
-   if (!not_done)
-   {
-      loader->state = OVERLAY_STATUS_DEFERRED_LOADING_RESOLVE;
-      return;
-   }
-
-   switch (loader->loading_status)
-   {
-      case OVERLAY_IMAGE_TRANSFER_NONE:
-      case OVERLAY_IMAGE_TRANSFER_BUSY:
-         loader->loading_status = OVERLAY_IMAGE_TRANSFER_DONE;
-	 /* fall-through */
-      case OVERLAY_IMAGE_TRANSFER_DONE:
-         task_overlay_image_done(&loader->overlays[loader->pos]);
-         loader->loading_status = OVERLAY_IMAGE_TRANSFER_DESC_IMAGE_ITERATE;
-         loader->overlays[loader->pos].pos = 0;
-         break;
-      case OVERLAY_IMAGE_TRANSFER_DESC_IMAGE_ITERATE:
-         for (i = 0; i < overlay->pos_increment; i++)
-         {
-            if (overlay->pos < overlay->size)
-            {
-               task_overlay_load_desc_image(loader,
-                     &overlay->descs[overlay->pos], overlay,
-                     loader->pos, (unsigned)overlay->pos);
-            }
-            else
-            {
-               overlay->pos       = 0;
-               loader->loading_status = OVERLAY_IMAGE_TRANSFER_DESC_ITERATE;
-               break;
-            }
-
-         }
-         break;
-      case OVERLAY_IMAGE_TRANSFER_DESC_ITERATE:
-         for (i = 0; i < overlay->pos_increment; i++)
-         {
-            if (overlay->pos < overlay->size)
-            {
-               if (!task_overlay_load_desc(loader,
-                        &overlay->descs[overlay->pos], overlay,
-                        loader->pos, (unsigned)overlay->pos,
-                        overlay->image.width, overlay->image.height,
-                        overlay->config.normalized,
-                        overlay->config.alpha_mod, overlay->config.range_mod))
-               {
-                  RARCH_ERR("[Overlay]: Failed to load overlay descs for overlay #%u.\n",
-                        (unsigned)overlay->pos);
-                  task_set_cancelled(task, true);
-                  loader->state   = OVERLAY_STATUS_DEFERRED_ERROR;
-                  break;
-               }
-            }
-            else
-            {
-               overlay->pos       = 0;
-               loader->loading_status = OVERLAY_IMAGE_TRANSFER_DESC_DONE;
-               break;
-            }
-         }
-         break;
-      case OVERLAY_IMAGE_TRANSFER_DESC_DONE:
-         if (loader->pos == 0)
-            task_overlay_resolve_iterate(task);
-
-         loader->pos += 1;
-         loader->loading_status = OVERLAY_IMAGE_TRANSFER_NONE;
-         break;
-      case OVERLAY_IMAGE_TRANSFER_ERROR:
-         task_set_cancelled(task, true);
-         loader->state   = OVERLAY_STATUS_DEFERRED_ERROR;
-         break;
-   }
-}
-
-static void task_overlay_deferred_load(retro_task_t *task)
-{
-   unsigned i;
-   overlay_loader_t *loader  = (overlay_loader_t*)task->state;
-   config_file_t       *conf = loader->conf;
-
-   for (i = 0; i < loader->pos_increment; i++, loader->pos++)
-   {
-      char conf_key_base[10];
-      char conf_key[32];
-      char overlay_full_screen_key[32];
-      char tmp_str[PATH_MAX_LENGTH];
-      float tmp_float                   = 0.0;
-      bool tmp_bool                     = false;
-      struct texture_image *texture_img = NULL;
-      struct overlay_desc *overlay_desc = NULL;
-      struct overlay          *overlay  = NULL;
-      bool                     to_cont  = loader->pos < loader->size;
-
-      if (!to_cont)
-      {
-         loader->pos   = 0;
-         loader->state = OVERLAY_STATUS_DEFERRED_LOADING;
-         break;
-      }
-
-      tmp_str[0] = '\0';
-
-      overlay = &loader->overlays[loader->pos];
-
-      snprintf(conf_key_base, sizeof(conf_key_base), "overlay%u", loader->pos);
-
-      strlcpy(overlay->config.descs.key, conf_key_base,
-            sizeof(overlay->config.descs.key));
-      strlcat(overlay->config.descs.key, "_descs",
-            sizeof(overlay->config.descs.key));
-
-      if (!config_get_uint(conf, overlay->config.descs.key,
-               &overlay->config.descs.size))
-      {
-         RARCH_ERR("[Overlay]: Failed to read number of descs from config key: %s.\n",
-               overlay->config.descs.key);
-         goto error;
-      }
-
-      overlay_desc = (struct overlay_desc*)
-         calloc(overlay->config.descs.size, sizeof(*overlay->descs));
-
-      if (!overlay_desc)
-      {
-         RARCH_ERR("[Overlay]: Failed to allocate descs.\n");
-         goto error;
-      }
-
-      overlay->descs = overlay_desc;
-      overlay->size  = overlay->config.descs.size;
-
-      strlcpy(overlay_full_screen_key, conf_key_base,
-            sizeof(overlay_full_screen_key));
-      strlcat(overlay_full_screen_key, "_full_screen",
-            sizeof(overlay_full_screen_key));
-      overlay->flags &= ~OVERLAY_FULL_SCREEN;
-      if (config_get_bool(conf, overlay_full_screen_key, &tmp_bool)
-            && tmp_bool)
-         overlay->flags |= OVERLAY_FULL_SCREEN;
-
-      overlay->config.normalized = false;
-      overlay->config.alpha_mod  = 1.0f;
-      overlay->config.range_mod  = 1.0f;
-
-      strlcpy(conf_key, conf_key_base,  sizeof(conf_key));
-      strlcat(conf_key, "_normalized", sizeof(conf_key));
-            
-      if (config_get_bool(conf, conf_key, &tmp_bool)
-            && tmp_bool)
-         overlay->config.normalized = tmp_bool;
-
-      strlcpy(conf_key, conf_key_base,  sizeof(conf_key));
-      strlcat(conf_key, "_alpha_mod", sizeof(conf_key));
-      if (config_get_float(conf, conf_key, &tmp_float))
-         overlay->config.alpha_mod = tmp_float;
-
-      strlcpy(conf_key, conf_key_base,  sizeof(conf_key));
-      strlcat(conf_key, "_range_mod", sizeof(conf_key));
-      if (config_get_float(conf, conf_key, &tmp_float))
-         overlay->config.range_mod = tmp_float;
-
-      /* Precache load image array for simplicity. */
-      texture_img = (struct texture_image*)
-         calloc(1 + overlay->size, sizeof(struct texture_image));
-
-      if (!texture_img)
-      {
-         RARCH_ERR("[Overlay]: Failed to allocate load_images.\n");
-         goto error;
-      }
-
-      overlay->load_images = texture_img;
-
-      strlcpy(overlay->config.paths.key, conf_key_base,
-            sizeof(overlay->config.paths.key));
-      strlcat(overlay->config.paths.key, "_overlay",
-            sizeof(overlay->config.paths.key));
-
-      if (config_get_path(conf, overlay->config.paths.key,
-               tmp_str, sizeof(tmp_str)))
-         strlcpy(overlay->config.paths.path,
-               tmp_str, sizeof(overlay->config.paths.path));
-
-      if (!string_is_empty(overlay->config.paths.path))
-      {
-         struct texture_image image_tex;
-         char overlay_resolved_path[PATH_MAX_LENGTH];
-
-         overlay_resolved_path[0] = '\0';
-
-         fill_pathname_resolve_relative(overlay_resolved_path,
-               loader->overlay_path,
-               overlay->config.paths.path, sizeof(overlay_resolved_path));
-
-         image_tex.supports_rgba =
-               (loader->flags & OVERLAY_LOADER_RGBA_SUPPORT);
-
-         if (!image_texture_load(&image_tex, overlay_resolved_path))
-         {
-            RARCH_ERR("[Overlay]: Failed to load image: %s.\n",
-                  overlay_resolved_path);
-            loader->loading_status = OVERLAY_IMAGE_TRANSFER_ERROR;
-            goto error;
-         }
-
-         overlay->load_images[overlay->load_images_size++] = image_tex;
-         overlay->image = image_tex;
-      }
-
-      strlcpy(overlay->config.names.key, conf_key_base,
-            sizeof(overlay->config.names.key));
-      strlcat(overlay->config.names.key, "_name",
-            sizeof(overlay->config.names.key));
-      config_get_array(conf, overlay->config.names.key,
-            overlay->name, sizeof(overlay->name));
-
-      /* Attempt to determine native aspect ratio */
-      strlcpy(conf_key, conf_key_base, sizeof(conf_key));
-      strlcat(conf_key, "_aspect_ratio", sizeof(conf_key));
-      overlay->aspect_ratio = 0.0f;
-      if (config_get_float(conf, conf_key, &tmp_float))
-         overlay->aspect_ratio = tmp_float;
-
-      if (overlay->aspect_ratio <= 0.0f)
-      {
-         /* No ratio has been set - assume 16:9
-          * (or 16:9 rotated) */
-
-         /* Check whether overlay name indicates a
-          * portrait layout */
-         if (strstr(overlay->name, "portrait"))
-            overlay->aspect_ratio = 0.5625f;    /* 1 / (16/9) */
-         else
-            overlay->aspect_ratio = 1.7777778f; /* 16/9 */
-      }
-
-      /* By default, we stretch the overlay out in full. */
-      overlay->x = overlay->y = 0.0f;
-      overlay->w = overlay->h = 1.0f;
-
-      strlcpy(overlay->config.rect.key, conf_key_base,
-            sizeof(overlay->config.rect.key));
-      strlcat(overlay->config.rect.key, "_rect",
-            sizeof(overlay->config.rect.key));
-
-      if (config_get_array(conf, overlay->config.rect.key,
-               overlay->config.rect.array, sizeof(overlay->config.rect.array)))
-      {
-         struct string_list  list = {0};
-
-         string_list_initialize(&list);
-
-         if (     !string_split_noalloc(
-                  &list, overlay->config.rect.array, ", ")  
-               || list.size < 4)
-         {
-            RARCH_ERR("[Overlay]: Failed to split rect \"%s\" into at least four tokens.\n",
-                  overlay->config.rect.array);
-            string_list_deinitialize(&list);
-            goto error;
-         }
-
-         overlay->x = (float)strtod(list.elems[0].data, NULL);
-         overlay->y = (float)strtod(list.elems[1].data, NULL);
-         overlay->w = (float)strtod(list.elems[2].data, NULL);
-         overlay->h = (float)strtod(list.elems[3].data, NULL);
-         string_list_deinitialize(&list);
-      }
-
-      /* Assume for now that scaling center is in the middle.
-       * TODO: Make this configurable. */
-      overlay->flags      &= ~OVERLAY_BLOCK_SCALE;
-      overlay->center_x    = overlay->x + 0.5f * overlay->w;
-      overlay->center_y    = overlay->y + 0.5f * overlay->h;
-
-      /* Check whether x/y separation are force disabled
-       * for this overlay */
-      strlcpy(conf_key, conf_key_base, sizeof(conf_key));
-      strlcat(conf_key, "_block_x_separation", sizeof(conf_key));
-      overlay->flags    &= ~OVERLAY_BLOCK_X_SEPARATION;
-      if (config_get_bool(conf, conf_key, &tmp_bool)
-            && tmp_bool)
-         overlay->flags |=  OVERLAY_BLOCK_X_SEPARATION;
-
-      strlcpy(conf_key, conf_key_base, sizeof(conf_key));
-      strlcat(conf_key, "_block_y_separation", sizeof(conf_key));
-      overlay->flags    &= ~OVERLAY_BLOCK_Y_SEPARATION;
-      if (config_get_bool(conf, conf_key, &tmp_bool)
-            && tmp_bool)
-         overlay->flags |=  OVERLAY_BLOCK_Y_SEPARATION;
-
-      /* Check whether x/y separation are enabled
-       * for this overlay in auto-scale mode */
-      strlcpy(conf_key, conf_key_base, sizeof(conf_key));
-      strlcat(conf_key, "_auto_x_separation", sizeof(conf_key));
-      overlay->flags    |=  OVERLAY_AUTO_X_SEPARATION;
-      if (config_get_bool(conf, conf_key, &tmp_bool))
-      {
-         if (!tmp_bool)
-            overlay->flags &= ~OVERLAY_AUTO_X_SEPARATION;
-      }
-      else
-      {
-         if (overlay->flags & OVERLAY_BLOCK_X_SEPARATION
-               || overlay->image.width != 0)
-            overlay->flags &= ~OVERLAY_AUTO_X_SEPARATION;
-      }
-
-      strlcpy(conf_key, conf_key_base, sizeof(conf_key));
-      strlcat(conf_key, "_auto_y_separation", sizeof(conf_key));
-      overlay->flags    &= ~OVERLAY_AUTO_Y_SEPARATION;
-      if (config_get_bool(conf, conf_key, &tmp_bool)
-            && tmp_bool)
-         overlay->flags |=  OVERLAY_AUTO_Y_SEPARATION;
-   }
-
-   return;
-
-error:
-   task_set_cancelled(task, true);
-   loader->pos     = 0;
-   loader->state   = OVERLAY_STATUS_DEFERRED_ERROR;
-}
-
-static void task_overlay_free(retro_task_t *task)
-{
-   unsigned i;
-   overlay_loader_t *loader  = (overlay_loader_t*)task->state;
-   struct overlay *overlay   = &loader->overlays[loader->pos];
-
-   if (loader->overlay_path)
-      free(loader->overlay_path);
-
-   if (task_get_cancelled(task))
-   {
-      for (i = 0; i < overlay->load_images_size; i++)
-      {
-         struct texture_image *ti = &overlay->load_images[i];
-         image_texture_free(ti);
-      }
-
-      for (i = 0; i < loader->size; i++)
-         input_overlay_free_overlay(&loader->overlays[i]);
-
-      free(loader->overlays);
-   }
-
-   if (loader->conf)
-      config_file_free(loader->conf);
-
-   free(loader);
-}
-
-static void task_overlay_handler(retro_task_t *task)
-{
-   overlay_loader_t *loader  = (overlay_loader_t*)task->state;
-
-   switch (loader->state)
-   {
-      case OVERLAY_STATUS_DEFERRED_LOADING:
-         task_overlay_deferred_loading(task);
-         break;
-      case OVERLAY_STATUS_DEFERRED_LOAD:
-         task_overlay_deferred_load(task);
-         break;
-      case OVERLAY_STATUS_DEFERRED_LOADING_RESOLVE:
-         task_overlay_resolve_iterate(task);
-         break;
-      case OVERLAY_STATUS_DEFERRED_ERROR:
-         task_set_cancelled(task, true);
-         break;
-      case OVERLAY_STATUS_DEFERRED_DONE:
-      default:
-      case OVERLAY_STATUS_NONE:
-         task_set_finished(task, true);
-         break;
-   }
-
-   if (task_get_finished(task) && !task_get_cancelled(task))
-   {
-      overlay_task_data_t *data = (overlay_task_data_t*)
-         calloc(1, sizeof(*data));
-
-      data->overlays                    = loader->overlays;
-      data->active                      = loader->active;
-      data->size                        = loader->size;
-      data->overlay_opacity             = loader->overlay_opacity;
-      data->flags                       = loader->flags;
-      data->overlay_types               = loader->overlay_types;
-
-      memcpy(&data->layout_desc, &loader->layout_desc,
-            sizeof(overlay_layout_desc_t));
-
-      task_set_data(task, data);
-   }
-}
-
-static bool task_overlay_finder(retro_task_t *task, void *user_data)
-{
-   overlay_loader_t *loader = NULL;
-
-   if (!task || (task->handler != task_overlay_handler))
-      return false;
-
-   if (!user_data)
-      return false;
-
-   loader = (overlay_loader_t*)task->state;
-   if (!loader)
-      return false;
-
-   return string_is_equal(loader->overlay_path, (const char*)user_data);
-}
-
-bool task_push_overlay_load_default(
-      retro_task_callback_t cb,
-      const char *overlay_path,
-      bool overlay_hide_in_menu,
-      bool overlay_hide_when_gamepad_connected,
-      bool input_overlay_enable,
-      float input_overlay_opacity,
-      overlay_layout_desc_t *layout_desc,
-      void *user_data)
-{
-   task_finder_data_t find_data;
-   retro_task_t *t          = NULL;
-   config_file_t *conf      = NULL;
-   overlay_loader_t *loader = NULL;
-
-   if (string_is_empty(overlay_path) || !layout_desc)
-      return false;
-
-   /* Prevent overlay from being loaded if it already is being loaded */
-   find_data.func           = task_overlay_finder;
-   find_data.userdata       = (void*)overlay_path;
-
-   if (task_queue_find(&find_data))
-      return false;
-
-   loader                   = (overlay_loader_t*)calloc(1, sizeof(*loader));
-
-   if (!loader)
-      return false;
-
-   if (!(conf = config_file_new_from_path_to_string(overlay_path)))
-   {
-      free(loader);
-      return false;
-   }
-
-   if (!config_get_uint(conf, "overlays", &loader->size))
-   {
-      /* Error - overlays varaible not defined in config. */
-      config_file_free(conf);
-      free(loader);
-      return false;
-   }
-
-   loader->overlays         = (struct overlay*)
-      calloc(loader->size, sizeof(*loader->overlays));
-
-   if (!loader->overlays)
-   {
-      config_file_free(conf);
-      free(loader);
-      return false;
-   }
-
-   loader->overlay_opacity  = input_overlay_opacity;
-   loader->conf             = conf;
-   loader->state            = OVERLAY_STATUS_DEFERRED_LOAD;
-   loader->pos_increment    = (loader->size / 4) ? (loader->size / 4) : 4;
-
-   if (overlay_hide_in_menu)
-      loader->flags        |= OVERLAY_LOADER_HIDE_IN_MENU;
-   if (overlay_hide_when_gamepad_connected)
-      loader->flags        |= OVERLAY_LOADER_HIDE_WHEN_GAMEPAD_CONNECTED;
-   if (input_overlay_enable)
-      loader->flags        |= OVERLAY_LOADER_ENABLE;
-#ifdef RARCH_INTERNAL
-   if (video_driver_supports_rgba())
-      loader->flags        |= OVERLAY_LOADER_RGBA_SUPPORT;
-#endif
-
-   memcpy(&loader->layout_desc, layout_desc,
-         sizeof(overlay_layout_desc_t));
-
-   t                        = task_init();
-
-   if (!t)
-   {
-      config_file_free(conf);
-      free(loader->overlays);
-      free(loader);
-      return false;
-   }
-
-   loader->overlay_path     = strdup(overlay_path);
-
-   t->handler               = task_overlay_handler;
-   t->cleanup               = task_overlay_free;
-   t->state                 = loader;
-   t->callback              = cb;
-   t->user_data             = user_data;
-
-   task_queue_push(t);
-
-   return true;
-}