bool task_audio_mixer_load_handler(retro_task_t *task)
{
nbio_handle_t *nbio = (nbio_handle_t*)task->state;
struct audio_mixer_handle *image = (struct audio_mixer_handle*)nbio->data;
if (
nbio->is_finished
&& (image && !image->is_finished)
&& (image->copy_data_over)
&& (!task_get_cancelled(task)))
{
nbio_buf_t *img = (nbio_buf_t*)calloc(1, sizeof(*img));
if (img)
{
img->buf = image->buffer->buf;
img->bufsize = image->buffer->bufsize;
}
task_set_data(task, img);
image->copy_data_over = false;
image->is_finished = true;
return false;
}
return true;
}
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);
}
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);
}
}
