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); } }