From d04907f3c772f1073e768934461dea5ef38a90f9 Mon Sep 17 00:00:00 2001 From: Sergio Martin Date: Tue, 6 Feb 2024 19:12:04 +0100 Subject: [PATCH] Progress with serialization --- source/quickerNES/core/core.hpp | 301 ++++++++++++++++++++------------ 1 file changed, 194 insertions(+), 107 deletions(-) diff --git a/source/quickerNES/core/core.hpp b/source/quickerNES/core/core.hpp index 8758a08..22c3c9f 100644 --- a/source/quickerNES/core/core.hpp +++ b/source/quickerNES/core/core.hpp @@ -153,6 +153,137 @@ class Core : private Cpu reset(true, true); } + static inline void serializeBlock( + const uint8_t* __restrict__ inputData, + const size_t inputDataSize, + uint8_t* __restrict__ outputData, + size_t* outputDataPos, + const bool useDifferentialCompression = false, + const uint8_t* __restrict__ referenceData = nullptr, + size_t* referenceDataPos = 0, + const size_t outputMaxSize = 0, + const bool useZlib = false + ) + { + // If not using differential compression, process the entire input block + if (useDifferentialCompression == false) + { + // Only perform memcpy if the input block is not null + if (outputData != nullptr) memcpy(&outputData[*outputDataPos], inputData, inputDataSize); + *outputDataPos += inputDataSize; + } + + // If using differential compression + if (useDifferentialCompression == true) + { + // Only perform compression if input is not null + if (outputData != nullptr) + { + // Variable to store difference count + auto diffCount = (usize_t*)&outputData[*outputDataPos]; + + // Advancing position pointer to store the difference counter + *outputDataPos += sizeof(usize_t); + + // If we reached maximum output, stop here + if (*outputDataPos >= outputMaxSize) + { + fprintf(stderr, "[Error] Maximum output data position reached before differential encode (%lu)\n", outputMaxSize); + exit(-1); + } + + // Encoding differential + int ret = xd3_encode_memory( + inputData, + inputDataSize, + &referenceData[*referenceDataPos], + inputDataSize, + &outputData[*outputDataPos], + diffCount, + outputMaxSize - *outputDataPos, + useZlib ? 0 : XD3_NOCOMPRESS + ); + + // If an error happened, print it here + if (ret != 0) + { + fprintf(stderr, "[Error] unexpected error while encoding differential compression. Diff count: %u\n", *diffCount); + exit(-1); + } + + // Increasing output data position pointer + *outputDataPos += *diffCount; + + // If exceeded size, report it + if ((usize_t)*outputDataPos > outputMaxSize) + { + fprintf(stderr, "[Error] Differential compression size (%u) exceeded output maximum size (%lu).\n", *diffCount, outputMaxSize); + exit(-1); + } + } + } + + // Finally, increasing reference data position pointer + *referenceDataPos += inputDataSize; + } + + static inline void deserializeBlock( + uint8_t* __restrict__ outputData, + const size_t outputDataSize, + const uint8_t* __restrict__ inputData, + size_t* inputDataPos, + const bool useDifferentialCompression = false, + const uint8_t* __restrict__ referenceData = nullptr, + size_t* referenceDataPos = 0, + const bool useZlib = false + ) + { + // If not using differential compression, process the entire input block + if (useDifferentialCompression == false) + { + // Only perform memcpy if the input block is not null + if (outputData != nullptr) memcpy(outputData, &inputData[*inputDataPos], outputDataSize); + *inputDataPos += outputDataSize; + } + + // If using differential compression + if (useDifferentialCompression == true) + { + // Reading differential count + usize_t diffCount; + memcpy(&diffCount, &inputData[*inputDataPos], sizeof(usize_t)); + + // Advancing position pointer to store the difference counter + *inputDataPos += sizeof(usize_t); + + // Encoding differential + usize_t output_size; + int ret = xd3_decode_memory( + &inputData[*inputDataPos], + diffCount, + &referenceData[*referenceDataPos], + outputDataSize, + outputData, + &output_size, + outputDataSize, + useZlib ? 0 : XD3_NOCOMPRESS + ); + + // If an error happened, print it here + if (ret != 0) + { + fprintf(stderr, "[Error] unexpected error while decoding differential compression. Diff count: %u\n", diffCount); + exit(-1); + } + + // Increasing output data position pointer + *inputDataPos += diffCount; + } + + // Finally, increasing reference data position pointer + *referenceDataPos += outputDataSize; + } + static inline void serializeContiguousData(const uint8_t* __restrict__ inputData, const size_t inputDataSize, uint8_t* __restrict__ outputData, size_t* outputDataPos) { // Only perform memcpy if the input block is not null @@ -273,6 +404,7 @@ class Core : private Cpu *referenceDataPos += outputDataSize; } + size_t serializeState( uint8_t* __restrict__ outputData, const bool useDifferentialCompression = false, @@ -283,16 +415,12 @@ class Core : private Cpu size_t outputDataPos = 0; size_t referenceDataPos = 0; - std::string headerCode; const uint32_t headerSize = sizeof(char) * 4; - uint32_t blockSize = 0; - void *dataSource; - blockSize = 0xFFFFFFFF; if (HEADBlockEnabled == true) { - headerCode = "NESS"; // NESS Block - if (outputData != nullptr) memcpy(&outputData[outputDataPos], headerCode.data(), headerSize); + const uint32_t blockSize = 0xFFFFFFFF; + if (outputData != nullptr) memcpy(&outputData[outputDataPos], "NESS", headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; if (outputData != nullptr) memcpy(&outputData[outputDataPos], &blockSize, headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; @@ -302,19 +430,19 @@ class Core : private Cpu { nes_state_t state = nes; state.timestamp *= 5; - blockSize = sizeof(nes_state_t); - dataSource = (void *)&state; + + const auto blockSize = sizeof(nes_state_t); + const auto inputData = (uint8_t *)&state; if (HEADBlockEnabled == true) { - headerCode = "TIME"; // TIME Block - if (outputData != nullptr) memcpy(&outputData[outputDataPos], headerCode.data(), headerSize); + if (outputData != nullptr) memcpy(&outputData[outputDataPos], "TIME", headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; if (outputData != nullptr) memcpy(&outputData[outputDataPos], &blockSize, headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; } - if (outputData != nullptr) memcpy(&outputData[outputDataPos], dataSource, blockSize); + if (outputData != nullptr) memcpy(&outputData[outputDataPos], inputData, blockSize); outputDataPos += blockSize; referenceDataPos += blockSize; } @@ -328,129 +456,122 @@ class Core : private Cpu s.x = r.x; s.y = r.y; s.p = r.status; - blockSize = sizeof(cpu_state_t); - dataSource = (void *)&s; + + const auto blockSize = sizeof(cpu_state_t); + const auto inputData = (uint8_t *)&s; if (HEADBlockEnabled == true) { - headerCode = "CPUR"; // CPUR Block - if (outputData != nullptr) memcpy(&outputData[outputDataPos], headerCode.data(), headerSize); + if (outputData != nullptr) memcpy(&outputData[outputDataPos], "CPUR", headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; if (outputData != nullptr) memcpy(&outputData[outputDataPos], &blockSize, headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; } - if (outputData != nullptr) memcpy(&outputData[outputDataPos], dataSource, blockSize); + if (outputData != nullptr) memcpy(&outputData[outputDataPos], inputData, blockSize); outputDataPos += blockSize; referenceDataPos += blockSize; } if (PPURBlockEnabled == true) { - blockSize = sizeof(ppu_state_t); - dataSource = (void *)&ppu; + const auto blockSize = sizeof(ppu_state_t); + const auto inputData = (const uint8_t *)&ppu; if (HEADBlockEnabled == true) { - headerCode = "PPUR"; // PPUR Block - if (outputData != nullptr) memcpy(&outputData[outputDataPos], headerCode.data(), headerSize); + if (outputData != nullptr) memcpy(&outputData[outputDataPos], "PPUR", headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; if (outputData != nullptr) memcpy(&outputData[outputDataPos], &blockSize, headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; } - if (useDifferentialCompression == false) serializeContiguousData((uint8_t*)dataSource, blockSize, outputData, &outputDataPos); - if (useDifferentialCompression == true) serializeDifferentialData((uint8_t*)dataSource, blockSize, outputData, &outputDataPos, referenceData, &referenceDataPos, outputMaxSize, useZlib); + serializeBlock(inputData, blockSize, outputData, &outputDataPos, useDifferentialCompression, referenceData, &referenceDataPos, outputMaxSize, useZlib); } if (APURBlockEnabled == true) { Apu::apu_state_t apuState; impl->apu.save_state(&apuState); - blockSize = sizeof(Apu::apu_state_t); + + const auto blockSize = sizeof(Apu::apu_state_t); + const auto inputData = (uint8_t *)&apuState; if (HEADBlockEnabled == true) { - headerCode = "APUR"; // APUR Block - if (outputData != nullptr) memcpy(&outputData[outputDataPos], headerCode.data(), headerSize); + if (outputData != nullptr) memcpy(&outputData[outputDataPos], "APUR", headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; if (outputData != nullptr) memcpy(&outputData[outputDataPos], &blockSize, headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; } - if (outputData != nullptr) memcpy(&outputData[outputDataPos], &apuState, blockSize); + if (outputData != nullptr) memcpy(&outputData[outputDataPos], inputData, blockSize); outputDataPos += blockSize; referenceDataPos += blockSize; } if (CTRLBlockEnabled == true) { - blockSize = sizeof(joypad_state_t); - dataSource = (void *)&joypad; + const auto blockSize = sizeof(joypad_state_t); + const auto inputData = (uint8_t *)&joypad; if (HEADBlockEnabled == true) { - headerCode = "CTRL"; // CTRL Block - if (outputData != nullptr) memcpy(&outputData[outputDataPos], headerCode.data(), headerSize); + if (outputData != nullptr) memcpy(&outputData[outputDataPos], "CTRL", headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; if (outputData != nullptr) memcpy(&outputData[outputDataPos], &blockSize, headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; } - if (outputData != nullptr) memcpy(&outputData[outputDataPos], dataSource, blockSize); + if (outputData != nullptr) memcpy(&outputData[outputDataPos], inputData, blockSize); outputDataPos += blockSize; referenceDataPos += blockSize; } if (MAPRBlockEnabled == true) { - blockSize = mapper->state_size; - dataSource = (void *)mapper->state; + const auto blockSize = mapper->state_size; + const auto inputData = (uint8_t *)mapper->state; if (HEADBlockEnabled == true) { - headerCode = "MAPR"; // MAPR Block - if (outputData != nullptr) memcpy(&outputData[outputDataPos], headerCode.data(), headerSize); + if (outputData != nullptr) memcpy(&outputData[outputDataPos], "MAPR", headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; if (outputData != nullptr) memcpy(&outputData[outputDataPos], &blockSize, headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; } - if (outputData != nullptr) memcpy(&outputData[outputDataPos], dataSource, blockSize); + if (outputData != nullptr) memcpy(&outputData[outputDataPos], inputData, blockSize); outputDataPos += blockSize; referenceDataPos += blockSize; } if (LRAMBlockEnabled == true) { - blockSize = low_ram_size; - dataSource = (void *)low_mem; + const auto blockSize = low_ram_size; + const auto inputData = (uint8_t *)low_mem; if (HEADBlockEnabled == true) { - headerCode = "LRAM"; // LRAM Block - if (outputData != nullptr) memcpy(&outputData[outputDataPos], headerCode.data(), headerSize); + if (outputData != nullptr) memcpy(&outputData[outputDataPos], "LRAM", headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; if (outputData != nullptr) memcpy(&outputData[outputDataPos], &blockSize, headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; } - if (useDifferentialCompression == false) serializeContiguousData((uint8_t*)dataSource, blockSize, outputData, &outputDataPos); - if (useDifferentialCompression == true) serializeDifferentialData((uint8_t*)dataSource, blockSize, outputData, &outputDataPos, referenceData, &referenceDataPos, outputMaxSize, useZlib); + serializeBlock(inputData, blockSize, outputData, &outputDataPos, useDifferentialCompression, referenceData, &referenceDataPos, outputMaxSize, useZlib); } if (SPRTBlockEnabled == true) { - blockSize = Ppu::spr_ram_size; - dataSource = (void *)ppu.spr_ram; + const auto blockSize = Ppu::spr_ram_size; + const auto inputData = (uint8_t *)ppu.spr_ram; if (HEADBlockEnabled == true) { - headerCode = "SPRT"; // SPRT Block - if (outputData != nullptr) memcpy(&outputData[outputDataPos], headerCode.data(), headerSize); + if (outputData != nullptr) memcpy(&outputData[outputDataPos], "SPRT", headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; if (outputData != nullptr) memcpy(&outputData[outputDataPos], &blockSize, headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; } - if (useDifferentialCompression == false) serializeContiguousData((uint8_t*)dataSource, blockSize, outputData, &outputDataPos); - if (useDifferentialCompression == true) serializeDifferentialData((uint8_t*)dataSource, blockSize, outputData, &outputDataPos, referenceData, &referenceDataPos, outputMaxSize, useZlib); + serializeBlock(inputData, blockSize, outputData, &outputDataPos, useDifferentialCompression, referenceData, &referenceDataPos, outputMaxSize, useZlib); } if (NTABBlockEnabled == true) @@ -458,40 +579,36 @@ class Core : private Cpu size_t nametable_size = 0x800; if (ppu.nt_banks[3] >= &ppu.impl->nt_ram[0xC00]) nametable_size = 0x1000; - blockSize = nametable_size; - dataSource = (void *)ppu.impl->nt_ram; + const auto blockSize = nametable_size; + const auto inputData = (uint8_t *)ppu.impl->nt_ram; if (HEADBlockEnabled == true) { - headerCode = "NTAB"; // NTAB Block - if (outputData != nullptr) memcpy(&outputData[outputDataPos], headerCode.data(), headerSize); + if (outputData != nullptr) memcpy(&outputData[outputDataPos], "NTAB", headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; if (outputData != nullptr) memcpy(&outputData[outputDataPos], &blockSize, headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; } - if (useDifferentialCompression == false) serializeContiguousData((uint8_t*)dataSource, blockSize, outputData, &outputDataPos); - if (useDifferentialCompression == true) serializeDifferentialData((uint8_t*)dataSource, blockSize, outputData, &outputDataPos, referenceData, &referenceDataPos, outputMaxSize, useZlib); + serializeBlock(inputData, blockSize, outputData, &outputDataPos, useDifferentialCompression, referenceData, &referenceDataPos, outputMaxSize, useZlib); } if (CHRRBlockEnabled == true) { if (ppu.chr_is_writable) { - blockSize = ppu.chr_size; - dataSource = (void *)ppu.impl->chr_ram; + const auto blockSize = ppu.chr_size; + const auto inputData = (uint8_t *)ppu.impl->chr_ram; if (HEADBlockEnabled == true) { - headerCode = "CHRR"; // CHRR Block - if (outputData != nullptr) memcpy(&outputData[outputDataPos], headerCode.data(), headerSize); + if (outputData != nullptr) memcpy(&outputData[outputDataPos], "CHRR", headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; if (outputData != nullptr) memcpy(&outputData[outputDataPos], &blockSize, headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; } - if (useDifferentialCompression == false) serializeContiguousData((uint8_t*)dataSource, blockSize, outputData, &outputDataPos); - if (useDifferentialCompression == true) serializeDifferentialData((uint8_t*)dataSource, blockSize, outputData, &outputDataPos, referenceData, &referenceDataPos, outputMaxSize, useZlib); + serializeBlock(inputData, blockSize, outputData, &outputDataPos, useDifferentialCompression, referenceData, &referenceDataPos, outputMaxSize, useZlib); } } @@ -499,28 +616,25 @@ class Core : private Cpu { if (sram_present) { - blockSize = impl->sram_size; - dataSource = (void *)impl->sram; + const auto blockSize = impl->sram_size; + const auto inputData = (uint8_t *)impl->sram; if (HEADBlockEnabled == true) { - headerCode = "SRAM"; // SRAM Block - if (outputData != nullptr) memcpy(&outputData[outputDataPos], headerCode.data(), headerSize); + if (outputData != nullptr) memcpy(&outputData[outputDataPos], "SRAM", headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; if (outputData != nullptr) memcpy(&outputData[outputDataPos], &blockSize, headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; } - if (useDifferentialCompression == false) serializeContiguousData((uint8_t*)dataSource, blockSize, outputData, &outputDataPos); - if (useDifferentialCompression == true) serializeDifferentialData((uint8_t*)dataSource, blockSize, outputData, &outputDataPos, referenceData, &referenceDataPos, outputMaxSize, useZlib); + serializeBlock(inputData, blockSize, outputData, &outputDataPos, useDifferentialCompression, referenceData, &referenceDataPos, outputMaxSize, useZlib); } } if (HEADBlockEnabled == true) { - headerCode = "gend"; // gend Block - blockSize = 0; - if (outputData != nullptr) memcpy(&outputData[outputDataPos], headerCode.data(), headerSize); + const uint32_t blockSize = 0; + if (outputData != nullptr) memcpy(&outputData[outputDataPos], "gend", headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; if (outputData != nullptr) memcpy(&outputData[outputDataPos], &blockSize, headerSize); outputDataPos += headerSize; referenceDataPos += headerSize; @@ -535,7 +649,6 @@ class Core : private Cpu error_count = 0; ppu.burst_phase = 0; // avoids shimmer when seeking to same time over and over - size_t inputDataPos = 0; size_t referenceDataPos = 0; const uint32_t headerSize = sizeof(char) * 4; @@ -575,22 +688,18 @@ class Core : private Cpu // PPUR Block if (PPURBlockEnabled == true) { - auto outputData = (uint8_t *)&ppu; blockSize = sizeof(ppu_state_t); if (HEADBlockEnabled == true) { inputDataPos += 2 * headerSize; referenceDataPos += 2 * headerSize; } - - if (useDifferentialCompression == false) deserializeContiguousData(outputData, blockSize, inputStateData, &inputDataPos); - if (useDifferentialCompression == true) deserializeDifferentialData(outputData, blockSize, inputStateData, &inputDataPos, referenceData, &referenceDataPos, useZlib); + deserializeBlock((uint8_t *)&ppu, blockSize, inputStateData, &inputDataPos, useDifferentialCompression, referenceData, &referenceDataPos, useZlib); } // APUR Block if (APURBlockEnabled == true) { Apu::apu_state_t apuState; - auto outputData = (uint8_t *)&apuState; blockSize = sizeof(Apu::apu_state_t); if (HEADBlockEnabled == true) { inputDataPos += 2 * headerSize; referenceDataPos += 2 * headerSize; } - memcpy(outputData, &inputStateData[inputDataPos], blockSize); + memcpy(&apuState, &inputStateData[inputDataPos], blockSize); inputDataPos += blockSize; impl->apu.load_state(apuState); impl->apu.end_frame(-(int)nes.timestamp / ppu_overclock); @@ -599,10 +708,9 @@ class Core : private Cpu // CTRL Block if (CTRLBlockEnabled == true) { - auto outputData = (uint8_t *)&joypad; blockSize = sizeof(joypad_state_t); if (HEADBlockEnabled == true) { inputDataPos += 2 * headerSize; referenceDataPos += 2 * headerSize; } - memcpy(outputData, &inputStateData[inputDataPos], blockSize); + memcpy((void *)&joypad, &inputStateData[inputDataPos], blockSize); inputDataPos += blockSize; } @@ -610,38 +718,27 @@ class Core : private Cpu if (MAPRBlockEnabled == true) { mapper->default_reset_state(); - - auto outputData = (uint8_t *)&mapper->state; blockSize = mapper->state_size; - if (HEADBlockEnabled == true) { inputDataPos += 2 * headerSize; referenceDataPos += 2 * headerSize; } - - memcpy(outputData, &inputStateData[inputDataPos], blockSize); + memcpy((void *)mapper->state, &inputStateData[inputDataPos], blockSize); inputDataPos += blockSize; - mapper->apply_mapping(); } // LRAM Block if (LRAMBlockEnabled == true) { - auto outputData = (uint8_t *)low_mem; blockSize = low_ram_size; if (HEADBlockEnabled == true) { inputDataPos += 2 * headerSize; referenceDataPos += 2 * headerSize; } - - if (useDifferentialCompression == false) deserializeContiguousData(outputData, blockSize, inputStateData, &inputDataPos); - if (useDifferentialCompression == true) deserializeDifferentialData(outputData, blockSize, inputStateData, &inputDataPos, referenceData, &referenceDataPos, useZlib); + deserializeBlock((uint8_t *)&low_mem, blockSize, inputStateData, &inputDataPos, useDifferentialCompression, referenceData, &referenceDataPos, useZlib); } // SPRT Block if (SPRTBlockEnabled == true) { - auto outputData = (uint8_t *)ppu.spr_ram; blockSize = Ppu::spr_ram_size; if (HEADBlockEnabled == true) { inputDataPos += 2 * headerSize; referenceDataPos += 2 * headerSize; } - - if (useDifferentialCompression == false) deserializeContiguousData(outputData, blockSize, inputStateData, &inputDataPos); - if (useDifferentialCompression == true) deserializeDifferentialData(outputData, blockSize, inputStateData, &inputDataPos, referenceData, &referenceDataPos, useZlib); + deserializeBlock((uint8_t *)&ppu.spr_ram, blockSize, inputStateData, &inputDataPos, useDifferentialCompression, referenceData, &referenceDataPos, useZlib); } // NTAB Block @@ -649,41 +746,31 @@ class Core : private Cpu { size_t nametable_size = 0x800; if (ppu.nt_banks[3] >= &ppu.impl->nt_ram[0xC00]) nametable_size = 0x1000; - auto outputData = (uint8_t *)ppu.impl->nt_ram; blockSize = nametable_size; if (HEADBlockEnabled == true) { inputDataPos += 2 * headerSize; referenceDataPos += 2 * headerSize; } - - if (useDifferentialCompression == false) deserializeContiguousData(outputData, blockSize, inputStateData, &inputDataPos); - if (useDifferentialCompression == true) deserializeDifferentialData(outputData, blockSize, inputStateData, &inputDataPos, referenceData, &referenceDataPos, useZlib); + deserializeBlock((uint8_t *)&ppu.impl->nt_ram, blockSize, inputStateData, &inputDataPos, useDifferentialCompression, referenceData, &referenceDataPos, useZlib); } - // CHRR Block if (CHRRBlockEnabled == true) { if (ppu.chr_is_writable) { - auto outputData = (uint8_t *)ppu.impl->chr_ram; + // CHRR Block blockSize = ppu.chr_size; if (HEADBlockEnabled == true) { inputDataPos += 2 * headerSize; referenceDataPos += 2 * headerSize; } - - if (useDifferentialCompression == false) deserializeContiguousData(outputData, blockSize, inputStateData, &inputDataPos); - if (useDifferentialCompression == true) deserializeDifferentialData(outputData, blockSize, inputStateData, &inputDataPos, referenceData, &referenceDataPos, useZlib); - + deserializeBlock((uint8_t *)&ppu.impl->chr_ram, blockSize, inputStateData, &inputDataPos, useDifferentialCompression, referenceData, &referenceDataPos, useZlib); ppu.all_tiles_modified(); } } - // SRAM Block if (SRAMBlockEnabled == true) { if (sram_present) { - auto outputData = (uint8_t *)impl->sram; + // SRAM Block blockSize = impl->sram_size; if (HEADBlockEnabled == true) { inputDataPos += 2 * headerSize; referenceDataPos += 2 * headerSize; } - - if (useDifferentialCompression == false) deserializeContiguousData(outputData, blockSize, inputStateData, &inputDataPos); - if (useDifferentialCompression == true) deserializeDifferentialData(outputData, blockSize, inputStateData, &inputDataPos, referenceData, &referenceDataPos, useZlib); + deserializeBlock((uint8_t *)&impl->sram, blockSize, inputStateData, &inputDataPos, useDifferentialCompression, referenceData, &referenceDataPos, useZlib); } }