From 2c29e599e820a96d3350d455d57b728bc400fcc9 Mon Sep 17 00:00:00 2001 From: twinaphex Date: Thu, 22 Sep 2016 16:28:45 +0200 Subject: [PATCH] Revert this code back to what it was --- tasks/task_save.c | 253 ++++++++++++++++++++++++++-------------------- 1 file changed, 142 insertions(+), 111 deletions(-) diff --git a/tasks/task_save.c b/tasks/task_save.c index f9d7fa5d54..b4c0c026d4 100644 --- a/tasks/task_save.c +++ b/tasks/task_save.c @@ -324,112 +324,6 @@ void autosave_deinit(void) } #endif -static unsigned content_allocate_save_blocks(struct sram_block **blocks) -{ - unsigned i; - unsigned num_blocks = 0; - settings_t *settings = config_get_ptr(); - - /* Checking of SRAM overwrite, the backing up of it and - flushing. */ - if (settings->block_sram_overwrite && task_save_files - && task_save_files->size) - { - RARCH_LOG("%s.\n", - msg_hash_to_str(MSG_BLOCKING_SRAM_OVERWRITE)); - *blocks = (struct sram_block*) - calloc(task_save_files->size, sizeof(*blocks)); - - if (*blocks) - { - num_blocks = task_save_files->size; - for (i = 0; i < num_blocks; i++) - { - struct sram_block *block = (struct sram_block*)&blocks[i]; - block->type = task_save_files->elems[i].attr.i; - } - } - } - - for (i = 0; i < num_blocks; i++) - { - retro_ctx_memory_info_t mem_info; - struct sram_block *block = (struct sram_block*)&blocks[i]; - - mem_info.id = block->type; - core_get_memory(&mem_info); - - block->size = mem_info.size; - } - - for (i = 0; i < num_blocks; i++) - { - struct sram_block *block = (struct sram_block*)&blocks[i]; - if (block->size) - block->data = malloc(block->size); - } - - /* Backup current SRAM which is overwritten by unserialize. */ - for (i = 0; i < num_blocks; i++) - { - retro_ctx_memory_info_t mem_info; - void *dst = NULL; - const void *src = NULL; - struct sram_block *block = (struct sram_block*)&blocks[i]; - - if (!block->data) - continue; - - mem_info.id = block->type; - - core_get_memory(&mem_info); - - src = mem_info.data; - dst = block->data; - if (src) - memcpy(dst, src, block->size); - } - - return num_blocks; -} - -static void content_flush_save_blocks(struct sram_block **blocks, - unsigned num_blocks) -{ - unsigned i; - - /* Flush back. */ - for (i = 0; i < num_blocks; i++) - { - retro_ctx_memory_info_t mem_info; - const void *src = NULL; - void *dst = NULL; - struct sram_block *block = (struct sram_block*)&blocks[i]; - - if (!block->data) - continue; - - mem_info.id = block->type; - - core_get_memory(&mem_info); - - src = block->data; - dst = mem_info.data; - if (dst) - memcpy(dst, src, block->size); - } - - for (i = 0; i < num_blocks; i++) - { - struct sram_block *block = (struct sram_block*)&blocks[i]; - - if (!block || !block->data) - continue; - - free(block->data); - } -} - /** * undo_load_state: * Revert to the state before a state was loaded. @@ -438,12 +332,14 @@ static void content_flush_save_blocks(struct sram_block **blocks, **/ bool content_undo_load_state(void) { + unsigned i; retro_ctx_serialize_info_t serial_info; size_t temp_data_size; bool ret = false; - void* temp_data = NULL; unsigned num_blocks = 0; + void* temp_data = NULL; struct sram_block *blocks = NULL; + settings_t *settings = config_get_ptr(); RARCH_LOG("%s: \"%s\".\n", msg_hash_to_str(MSG_LOADING_STATE), @@ -454,7 +350,55 @@ bool content_undo_load_state(void) undo_load_buf.size, msg_hash_to_str(MSG_BYTES)); - num_blocks = content_allocate_save_blocks(&blocks); + /* TODO/FIXME - This checking of SRAM overwrite, the backing up of it and + its flushing could all be in their own functions... */ + if (settings->block_sram_overwrite && task_save_files + && task_save_files->size) + { + RARCH_LOG("%s.\n", + msg_hash_to_str(MSG_BLOCKING_SRAM_OVERWRITE)); + blocks = (struct sram_block*) + calloc(task_save_files->size, sizeof(*blocks)); + + if (blocks) + { + num_blocks = task_save_files->size; + for (i = 0; i < num_blocks; i++) + blocks[i].type = task_save_files->elems[i].attr.i; + } + } + + for (i = 0; i < num_blocks; i++) + { + retro_ctx_memory_info_t mem_info; + + mem_info.id = blocks[i].type; + core_get_memory(&mem_info); + + blocks[i].size = mem_info.size; + } + + for (i = 0; i < num_blocks; i++) + if (blocks[i].size) + blocks[i].data = malloc(blocks[i].size); + + /* Backup current SRAM which is overwritten by unserialize. */ + for (i = 0; i < num_blocks; i++) + { + if (blocks[i].data) + { + retro_ctx_memory_info_t mem_info; + const void *ptr = NULL; + + mem_info.id = blocks[i].type; + + core_get_memory(&mem_info); + + ptr = mem_info.data; + if (ptr) + memcpy(blocks[i].data, ptr, blocks[i].size); + } + } /* We need to make a temporary copy of the buffer, to allow the swap below */ temp_data = malloc(undo_load_buf.size); @@ -474,7 +418,26 @@ bool content_undo_load_state(void) free(temp_data); temp_data = NULL; - content_flush_save_blocks(&blocks, num_blocks); + /* Flush back. */ + for (i = 0; i < num_blocks; i++) + { + if (blocks[i].data) + { + retro_ctx_memory_info_t mem_info; + void *ptr = NULL; + + mem_info.id = blocks[i].type; + + core_get_memory(&mem_info); + + ptr = mem_info.data; + if (ptr) + memcpy(ptr, blocks[i].data, blocks[i].size); + } + } + + for (i = 0; i < num_blocks; i++) + free(blocks[i].data); free(blocks); if (!ret) @@ -624,12 +587,14 @@ bool content_save_state(const char *path, bool save_to_disk) **/ bool content_load_state(const char *path, bool load_to_backup_buffer) { + unsigned i; ssize_t size; retro_ctx_serialize_info_t serial_info; unsigned num_blocks = 0; void *buf = NULL; struct sram_block *blocks = NULL; bool ret = filestream_read_file(path, &buf, &size); + settings_t *settings = config_get_ptr(); RARCH_LOG("%s: \"%s\".\n", msg_hash_to_str(MSG_LOADING_STATE), @@ -666,7 +631,54 @@ bool content_load_state(const char *path, bool load_to_backup_buffer) return true; } - num_blocks = content_allocate_save_blocks(&blocks); + if (settings->block_sram_overwrite && task_save_files + && task_save_files->size) + { + RARCH_LOG("%s.\n", + msg_hash_to_str(MSG_BLOCKING_SRAM_OVERWRITE)); + blocks = (struct sram_block*) + calloc(task_save_files->size, sizeof(*blocks)); + + if (blocks) + { + num_blocks = task_save_files->size; + for (i = 0; i < num_blocks; i++) + blocks[i].type = task_save_files->elems[i].attr.i; + } + } + + + for (i = 0; i < num_blocks; i++) + { + retro_ctx_memory_info_t mem_info; + + mem_info.id = blocks[i].type; + core_get_memory(&mem_info); + + blocks[i].size = mem_info.size; + } + + for (i = 0; i < num_blocks; i++) + if (blocks[i].size) + blocks[i].data = malloc(blocks[i].size); + + /* Backup current SRAM which is overwritten by unserialize. */ + for (i = 0; i < num_blocks; i++) + { + if (blocks[i].data) + { + retro_ctx_memory_info_t mem_info; + const void *ptr = NULL; + + mem_info.id = blocks[i].type; + + core_get_memory(&mem_info); + + ptr = mem_info.data; + if (ptr) + memcpy(blocks[i].data, ptr, blocks[i].size); + } + } serial_info.data_const = buf; serial_info.size = size; @@ -676,7 +688,26 @@ bool content_load_state(const char *path, bool load_to_backup_buffer) ret = core_unserialize(&serial_info); - content_flush_save_blocks(&blocks, num_blocks); + /* Flush back. */ + for (i = 0; i < num_blocks; i++) + { + if (blocks[i].data) + { + retro_ctx_memory_info_t mem_info; + void *ptr = NULL; + + mem_info.id = blocks[i].type; + + core_get_memory(&mem_info); + + ptr = mem_info.data; + if (ptr) + memcpy(ptr, blocks[i].data, blocks[i].size); + } + } + + for (i = 0; i < num_blocks; i++) + free(blocks[i].data); free(blocks); if (!ret)