static void input_autoconfigure_connect_handler(retro_task_t *task)
{
autoconfig_params_t *params = (autoconfig_params_t*)task->state;
if (!params || string_is_empty(params->name))
goto end;
if ( !input_autoconfigure_joypad_from_conf_dir(params, task)
&& !input_autoconfigure_joypad_from_conf_internal(params, task))
{
char msg[255];
msg[0] = '\0';
#ifdef ANDROID
if (!string_is_empty(params->name))
free(params->name);
params->name = strdup("Android Gamepad");
if (input_autoconfigure_joypad_from_conf_internal(params, task))
{
RARCH_LOG("[Autoconf]: no profiles found for %s (%d/%d). Using fallback\n",
!string_is_empty(params->name) ? params->name : "N/A",
params->vid, params->pid);
snprintf(msg, sizeof(msg), "%s (%ld/%ld) %s.",
!string_is_empty(params->name) ? params->name : "N/A",
(long)params->vid, (long)params->pid,
msg_hash_to_str(MSG_DEVICE_NOT_CONFIGURED_FALLBACK));
}
#else
RARCH_LOG("[Autoconf]: no profiles found for %s (%d/%d).\n",
!string_is_empty(params->name) ? params->name : "N/A",
params->vid, params->pid);
snprintf(msg, sizeof(msg), "%s (%ld/%ld) %s.",
!string_is_empty(params->name) ? params->name : "N/A",
(long)params->vid, (long)params->pid,
msg_hash_to_str(MSG_DEVICE_NOT_CONFIGURED));
#endif
task_free_title(task);
task_set_title(task, strdup(msg));
}
end:
if (params)
{
input_autoconfigure_params_free(params);
free(params);
}
task_set_finished(task, true);
}
static void input_autoconfigure_disconnect_handler(retro_task_t *task)
{
autoconfig_disconnect_t *params = (autoconfig_disconnect_t*)task->state;
task_set_title(task, strdup(params->msg));
task_set_finished(task, true);
RARCH_LOG("%s: %s\n", msg_hash_to_str(MSG_AUTODETECT), params->msg);
if (!string_is_empty(params->msg))
free(params->msg);
free(params);
}
static void task_powerstate_handler(retro_task_t *task)
{
const frontend_ctx_driver_t *frontend = frontend_get_ptr();
powerstate_t *powerstate = (powerstate_t*)task->state;
if (frontend && frontend->get_powerstate)
{
int seconds = 0;
powerstate->state = frontend->get_powerstate(&seconds, &powerstate->percent);
}
task_set_data(task, powerstate);
task_set_finished(task, true);
}
static void task_netplay_lan_scan_handler(retro_task_t *task)
{
if (init_netplay_discovery())
{
netplay_discovery_driver_ctl(
RARCH_NETPLAY_DISCOVERY_CTL_LAN_CLEAR_RESPONSES, NULL);
netplay_discovery_driver_ctl(
RARCH_NETPLAY_DISCOVERY_CTL_LAN_SEND_QUERY, NULL);
}
task_set_progress(task, 100);
task_set_finished(task, true);
return;
}
/**
* task_screenshot_handler:
* @task : the task being worked on
*
* Saves a screenshot to disk.
**/
static void task_screenshot_handler(retro_task_t *task)
{
screenshot_task_state_t *state = (screenshot_task_state_t*)task->state;
bool ret = false;
if (task_get_progress(task) == 100)
{
task_set_finished(task, true);
if (task->title)
task_free_title(task);
if (state->userbuf)
free(state->userbuf);
free(state);
return;
}
ret = screenshot_dump_direct(state);
#ifdef HAVE_IMAGEVIEWER
if ( ret &&
!state->silence &&
state->history_list_enable
)
command_playlist_push_write(
g_defaults.image_history,
state->filename,
NULL,
"builtin",
"imageviewer",
NULL,
NULL);
#endif
task_set_progress(task, 100);
if (!ret)
{
char *msg = strdup(msg_hash_to_str(MSG_FAILED_TO_TAKE_SCREENSHOT));
runloop_msg_queue_push(msg, 1, state->is_paused ? 1 : 180, true, NULL, MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
free(msg);
}
if (task->title)
task_free_title(task);
}
static void task_database_handler(retro_task_t *task)
{
const char *name = NULL;
database_info_handle_t *dbinfo = NULL;
database_state_handle_t *dbstate = NULL;
db_handle_t *db = NULL;
if (!task)
goto task_finished;
db = (db_handle_t*)task->state;
if (!db)
goto task_finished;
if (!db->scan_started)
{
db->scan_started = true;
if (!string_is_empty(db->fullpath))
{
if (db->is_directory)
db->handle = database_info_dir_init(db->fullpath, DATABASE_TYPE_ITERATE, task, db->show_hidden_files);
else
db->handle = database_info_file_init(db->fullpath, DATABASE_TYPE_ITERATE, task);
}
task_free_title(task);
if (db->handle)
db->handle->status = DATABASE_STATUS_ITERATE_BEGIN;
}
dbinfo = db->handle;
dbstate = &db->state;
if (!dbinfo || task_get_cancelled(task))
goto task_finished;
switch (dbinfo->status)
{
case DATABASE_STATUS_ITERATE_BEGIN:
if (dbstate && !dbstate->list)
{
if (!string_is_empty(db->content_database_path))
dbstate->list = dir_list_new(
db->content_database_path,
"rdb", false,
db->show_hidden_files,
false, false);
/* If the scan path matches a database path exactly then
* save time by only processing that database. */
if (dbstate->list && db->is_directory)
{
size_t i;
char *dirname = NULL;
if (!string_is_empty(db->fullpath))
dirname = find_last_slash(db->fullpath) + 1;
if (!string_is_empty(dirname))
{
for (i = 0; i < dbstate->list->size; i++)
{
const char *data = dbstate->list->elems[i].data;
char *dbname = NULL;
bool strmatch = false;
char *dbpath = strdup(data);
path_remove_extension(dbpath);
dbname = find_last_slash(dbpath) + 1;
strmatch = strcasecmp(dbname, dirname) == 0;
free(dbpath);
if (strmatch)
{
struct string_list *single_list = string_list_new();
string_list_append(single_list,
data,
dbstate->list->elems[i].attr);
dir_list_free(dbstate->list);
dbstate->list = single_list;
break;
}
}
}
}
}
dbinfo->status = DATABASE_STATUS_ITERATE_START;
break;
case DATABASE_STATUS_ITERATE_START:
name = database_info_get_current_element_name(dbinfo);
task_database_cleanup_state(dbstate);
dbstate->list_index = 0;
dbstate->entry_index = 0;
task_database_iterate_start(dbinfo, name);
break;
case DATABASE_STATUS_ITERATE:
if (task_database_iterate(db, dbstate, dbinfo) == 0)
{
dbinfo->status = DATABASE_STATUS_ITERATE_NEXT;
dbinfo->type = DATABASE_TYPE_ITERATE;
}
break;
case DATABASE_STATUS_ITERATE_NEXT:
if (task_database_iterate_next(dbinfo) == 0)
{
dbinfo->status = DATABASE_STATUS_ITERATE_START;
dbinfo->type = DATABASE_TYPE_ITERATE;
}
else
{
const char *msg = NULL;
if (db->is_directory)
msg = msg_hash_to_str(MSG_SCANNING_OF_DIRECTORY_FINISHED);
else
msg = msg_hash_to_str(MSG_SCANNING_OF_FILE_FINISHED);
#ifdef RARCH_INTERNAL
runloop_msg_queue_push(msg, 0, 180, true);
#else
fprintf(stderr, "msg: %s\n", msg);
#endif
ui_companion_driver_notify_refresh();
goto task_finished;
}
break;
default:
case DATABASE_STATUS_FREE:
case DATABASE_STATUS_NONE:
goto task_finished;
}
return;
task_finished:
if (task)
task_set_finished(task, true);
if (dbstate)
{
if (dbstate->list)
dir_list_free(dbstate->list);
}
if (db)
{
if (!string_is_empty(db->playlist_directory))
free(db->playlist_directory);
if (!string_is_empty(db->content_database_path))
free(db->content_database_path);
if (!string_is_empty(db->fullpath))
free(db->fullpath);
if (db->state.buf)
free(db->state.buf);
if (db->handle)
database_info_free(db->handle);
free(db);
}
if (dbinfo)
free(dbinfo);
}
static void task_database_handler(retro_task_t *task)
{
const char *name = NULL;
database_info_handle_t *dbinfo = NULL;
database_state_handle_t *dbstate = NULL;
db_handle_t *db = NULL;
if (!task)
goto task_finished;
db = (db_handle_t*)task->state;
if (!db)
goto task_finished;
if (!db->scan_started)
{
db->scan_started = true;
if (db->is_directory)
db->handle = database_info_dir_init(db->fullpath, DATABASE_TYPE_ITERATE, task);
else
db->handle = database_info_file_init(db->fullpath, DATABASE_TYPE_ITERATE, task);
task_free_title(task);
if (db->handle)
db->handle->status = DATABASE_STATUS_ITERATE_BEGIN;
}
dbinfo = db->handle;
dbstate = &db->state;
if (!dbinfo || task_get_cancelled(task))
goto task_finished;
switch (dbinfo->status)
{
case DATABASE_STATUS_ITERATE_BEGIN:
if (dbstate && !dbstate->list)
{
dbstate->list = dir_list_new_special(
db->content_database_path,
DIR_LIST_DATABASES, NULL);
}
dbinfo->status = DATABASE_STATUS_ITERATE_START;
break;
case DATABASE_STATUS_ITERATE_START:
name = database_info_get_current_element_name(dbinfo);
task_database_cleanup_state(dbstate);
dbstate->list_index = 0;
dbstate->entry_index = 0;
task_database_iterate_start(dbinfo, name);
break;
case DATABASE_STATUS_ITERATE:
if (task_database_iterate(db, dbstate, dbinfo) == 0)
{
dbinfo->status = DATABASE_STATUS_ITERATE_NEXT;
dbinfo->type = DATABASE_TYPE_ITERATE;
}
break;
case DATABASE_STATUS_ITERATE_NEXT:
if (task_database_iterate_next(dbinfo) == 0)
{
dbinfo->status = DATABASE_STATUS_ITERATE_START;
dbinfo->type = DATABASE_TYPE_ITERATE;
}
else
{
runloop_msg_queue_push(
msg_hash_to_str(MSG_SCANNING_OF_DIRECTORY_FINISHED),
0, 180, true);
goto task_finished;
}
break;
default:
case DATABASE_STATUS_FREE:
case DATABASE_STATUS_NONE:
goto task_finished;
}
return;
task_finished:
if (task)
task_set_finished(task, true);
if (dbstate)
{
if (dbstate->list)
dir_list_free(dbstate->list);
}
if (db)
{
if (db->state.buf)
free(db->state.buf);
if (db->handle)
database_info_free(db->handle);
free(db);
}
if (dbinfo)
free(dbinfo);
}
static void task_http_transfer_handler(retro_task_t *task)
{
http_transfer_data_t *data = NULL;
http_handle_t *http = (http_handle_t*)task->state;
if (task_get_cancelled(task))
goto task_finished;
switch (http->status)
{
case HTTP_STATUS_CONNECTION_TRANSFER_PARSE:
task_http_conn_iterate_transfer_parse(http);
http->status = HTTP_STATUS_TRANSFER;
break;
case HTTP_STATUS_CONNECTION_TRANSFER:
if (!task_http_con_iterate_transfer(http))
http->status = HTTP_STATUS_CONNECTION_TRANSFER_PARSE;
break;
case HTTP_STATUS_TRANSFER:
if (!task_http_iterate_transfer(task))
goto task_finished;
break;
case HTTP_STATUS_TRANSFER_PARSE:
goto task_finished;
default:
break;
}
if (http->error)
goto task_finished;
return;
task_finished:
task_set_finished(task, true);
if (http->handle)
{
size_t len = 0;
char *tmp = (char*)net_http_data(http->handle, &len, false);
if (tmp && http->cb)
http->cb(tmp, len);
if (net_http_error(http->handle) || task_get_cancelled(task))
{
tmp = (char*)net_http_data(http->handle, &len, true);
if (tmp)
free(tmp);
if (task_get_cancelled(task))
task_set_error(task, strdup("Task cancelled."));
else
task_set_error(task, strdup("Download failed."));
}
else
{
data = (http_transfer_data_t*)calloc(1, sizeof(*data));
data->data = tmp;
data->len = len;
task_set_data(task, data);
}
net_http_delete(http->handle);
} else if (http->error)
task_set_error(task, strdup("Internal error."));
free(http);
}
/**
* task_screenshot_handler:
* @task : the task being worked on
*
* Saves a screenshot to disk.
**/
static void task_screenshot_handler(retro_task_t *task)
{
#ifdef HAVE_RBMP
enum rbmp_source_type bmp_type = RBMP_SOURCE_TYPE_DONT_CARE;
#endif
screenshot_task_state_t *state = (screenshot_task_state_t*)task->state;
struct scaler_ctx *scaler = (struct scaler_ctx*)&state->scaler;
bool ret = false;
if (task_get_progress(task) == 100)
{
task_set_finished(task, true);
if (state->userbuf)
free(state->userbuf);
free(state);
return;
}
#ifdef HAVE_RBMP
(void)bmp_type;
#endif
#if defined(_XBOX1)
if (XGWriteSurfaceToFile(state->surf, state->filename) == S_OK)
ret = true;
state->surf->Release();
#elif defined(HAVE_RPNG)
if (state->bgr24)
scaler->in_fmt = SCALER_FMT_BGR24;
else if (state->pixel_format_type == RETRO_PIXEL_FORMAT_XRGB8888)
scaler->in_fmt = SCALER_FMT_ARGB8888;
else
scaler->in_fmt = SCALER_FMT_RGB565;
video_frame_convert_to_bgr24(
scaler,
state->out_buffer,
(const uint8_t*)state->frame + ((int)state->height - 1)
* state->pitch,
state->width, state->height,
-state->pitch);
scaler_ctx_gen_reset(&state->scaler);
ret = rpng_save_image_bgr24(
state->filename,
state->out_buffer,
state->width,
state->height,
state->width * 3
);
free(state->out_buffer);
#elif defined(HAVE_RBMP)
if (state->bgr24)
bmp_type = RBMP_SOURCE_TYPE_BGR24;
else if (state->pixel_format_type == RETRO_PIXEL_FORMAT_XRGB8888)
bmp_type = RBMP_SOURCE_TYPE_XRGB888;
ret = rbmp_save_image(state->filename,
state->frame,
state->width,
state->height,
state->pitch,
bmp_type);
#endif
#ifdef HAVE_IMAGEVIEWER
if (ret && !state->silence)
{
if (
state->history_list_enable
&& g_defaults.image_history
&& playlist_push(
g_defaults.image_history,
state->filename,
NULL,
"builtin",
"imageviewer",
NULL,
NULL
)
)
playlist_write_file(g_defaults.image_history);
}
#endif
task_set_progress(task, 100);
if (!ret)
{
char *msg = strdup(msg_hash_to_str(MSG_FAILED_TO_TAKE_SCREENSHOT));
runloop_msg_queue_push(msg, 1, state->is_paused ? 1 : 180, true);
free(msg);
}
}
void task_file_load_handler(retro_task_t *task)
{
nbio_handle_t *nbio = (nbio_handle_t*)task->state;
if (nbio)
{
switch (nbio->status)
{
case NBIO_STATUS_INIT:
if (nbio && !string_is_empty(nbio->path))
{
struct nbio_t *handle = (struct nbio_t*)nbio_open(nbio->path, NBIO_READ);
if (handle)
{
nbio->handle = handle;
nbio->status = NBIO_STATUS_TRANSFER;
nbio_begin_read(handle);
return;
}
else
task_set_cancelled(task, true);
}
break;
case NBIO_STATUS_TRANSFER_PARSE:
if (!nbio || task_file_transfer_iterate_parse(nbio) == -1)
task_set_cancelled(task, true);
nbio->status = NBIO_STATUS_TRANSFER_FINISHED;
break;
case NBIO_STATUS_TRANSFER:
if (!nbio || task_file_transfer_iterate_transfer(nbio) == -1)
nbio->status = NBIO_STATUS_TRANSFER_PARSE;
break;
case NBIO_STATUS_TRANSFER_FINISHED:
break;
}
switch (nbio->type)
{
case NBIO_TYPE_PNG:
case NBIO_TYPE_JPEG:
case NBIO_TYPE_TGA:
case NBIO_TYPE_BMP:
if (!task_image_load_handler(task))
task_set_finished(task, true);
break;
case NBIO_TYPE_MP3:
case NBIO_TYPE_FLAC:
case NBIO_TYPE_OGG:
case NBIO_TYPE_MOD:
case NBIO_TYPE_WAV:
if (!task_audio_mixer_load_handler(task))
task_set_finished(task, true);
break;
case NBIO_TYPE_NONE:
default:
if (nbio->is_finished)
task_set_finished(task, true);
break;
}
}
if (task_get_cancelled(task))
{
task_set_error(task, strdup("Task canceled."));
task_set_finished(task, true);
}
}
void task_file_load_handler(retro_task_t *task)
{
nbio_handle_t *nbio = (nbio_handle_t*)task->state;
if (nbio)
{
switch (nbio->status)
{
case NBIO_STATUS_INIT:
if (nbio && !string_is_empty(nbio->path))
{
const char *fullpath = nbio->path;
struct nbio_t *handle = nbio_open(fullpath, NBIO_READ);
if (handle)
{
nbio->handle = handle;
nbio->status = NBIO_STATUS_TRANSFER;
if (strstr(fullpath, file_path_str(FILE_PATH_PNG_EXTENSION)))
nbio->image_type = IMAGE_TYPE_PNG;
else if (strstr(fullpath, file_path_str(FILE_PATH_JPEG_EXTENSION))
|| strstr(fullpath, file_path_str(FILE_PATH_JPG_EXTENSION)))
nbio->image_type = IMAGE_TYPE_JPEG;
else if (strstr(fullpath, file_path_str(FILE_PATH_BMP_EXTENSION)))
nbio->image_type = IMAGE_TYPE_BMP;
else if (strstr(fullpath, file_path_str(FILE_PATH_TGA_EXTENSION)))
nbio->image_type = IMAGE_TYPE_TGA;
nbio_begin_read(handle);
return;
}
else
task_set_cancelled(task, true);
}
break;
case NBIO_STATUS_TRANSFER_PARSE:
if (task_file_transfer_iterate_parse(nbio) == -1)
task_set_cancelled(task, true);
nbio->status = NBIO_STATUS_TRANSFER_PARSE_FREE;
break;
case NBIO_STATUS_TRANSFER:
if (task_file_transfer_iterate_transfer(nbio) == -1)
nbio->status = NBIO_STATUS_TRANSFER_PARSE;
break;
case NBIO_STATUS_TRANSFER_PARSE_FREE:
case NBIO_STATUS_POLL:
default:
break;
}
switch (nbio->image_type)
{
case IMAGE_TYPE_PNG:
case IMAGE_TYPE_JPEG:
case IMAGE_TYPE_TGA:
case IMAGE_TYPE_BMP:
if (!task_image_load_handler(task))
task_set_finished(task, true);
break;
case 0:
if (nbio->is_finished)
task_set_finished(task, true);
break;
}
}
if (task_get_cancelled(task))
{
task_set_error(task, strdup("Task canceled."));
task_set_finished(task, true);
}
}
