guard statestream related code on ifdefs

Author: JoeOsborn

Makefile

@@ -1,4 +1,5 @@
 HAVE_FILE_LOGGER=1
+HAVE_STATESTREAM?=1
 NEED_CXX_LINKER?=0
 NEED_GOLD_LINKER?=0
 MISSING_DECLS   =0

Makefile.common

@@ -25,6 +25,10 @@ ifeq ($(HAVE_SAPI), 1)
    LIBS += sapi.dll
 endif
 
+ifeq ($(HAVE_STATESTREAM), 1)
+   DEF_FLAGS += -DHAVE_STATESTREAM
+endif
+
 ifeq ($(HAVE_GL_CONTEXT),)
    HAVE_GL_CONTEXT = 0
    HAVE_GL_MODERN  = 0

Makefile.emscripten

@@ -14,6 +14,7 @@ OBJ :=
 DEFINES := -DRARCH_INTERNAL -DHAVE_MAIN -DEMSCRIPTEN
 DEFINES += -DHAVE_FILTERS_BUILTIN -DHAVE_ONLINE_UPDATER -DHAVE_UPDATE_ASSETS -DHAVE_UPDATE_CORE_INFO
 
+HAVE_STATESTREAM ?= 1
 HAVE_PATCH = 1
 HAVE_DSP_FILTER = 1
 HAVE_VIDEO_FILTER = 1

input/bsv/bsvmovie.c

@@ -7,7 +7,9 @@
 #include "../../tasks/task_content.h"
 #include "../../libretro-db/rmsgpack.h"
 #include "../../libretro-db/rmsgpack_dom.h"
+#ifdef HAVE_STATESTREAM
 #include "input/bsv/uint32s_index.h"
+#endif
 #include "libretro.h"
 #include "streams/interface_stream.h"
 #ifdef HAVE_CHEEVOS
@@ -48,20 +50,27 @@
 
 /* Forward declarations */
 void bsv_movie_free(bsv_movie_t*);
+
+#ifdef HAVE_STATESTREAM
 int64_t bsv_movie_write_deduped_state(bsv_movie_t *movie, uint8_t *state, size_t state_size, uint8_t *output, size_t output_capacity);
 bool bsv_movie_read_deduped_state(bsv_movie_t *movie,
       uint8_t *encoded, size_t encoded_size, bool output);
+#endif
 
 bool bsv_movie_reset_recording(bsv_movie_t *handle)
 {
    retro_ctx_serialize_info_t serial_info;
    size_t state_size, state_size_;
    uint8_t compression = handle->checkpoint_compression;
+#if HAVE_STATESTREAM
    uint8_t encoding    = REPLAY_CHECKPOINT2_ENCODING_STATESTREAM;
    /* If recording, we simply reset
     * the starting point. Nice and easy. */
    uint32s_index_clear(handle->superblocks);
    uint32s_index_clear(handle->blocks);
+#else
+   uint8_t encoding    = REPLAY_CHECKPOINT2_ENCODING_RAW;
+#endif
 
    intfstream_seek(handle->file, REPLAY_HEADER_LEN_BYTES, SEEK_SET);
    intfstream_truncate(handle->file, REPLAY_HEADER_LEN_BYTES);
@@ -123,8 +132,10 @@ void bsv_movie_frame_rewind()
       handle->frame_counter = 0;
       intfstream_seek(handle->file, (int)handle->min_file_pos, SEEK_SET);
       /* clear incremental checkpoint table data.  We do this both on recording and playback for simplicity. */
+#ifdef HAVE_STATESTREAM
       uint32s_index_remove_after(handle->superblocks, 0);
       uint32s_index_remove_after(handle->blocks, 0);
+#endif
       if (recording)
          intfstream_truncate(handle->file, (int)handle->min_file_pos);
       else
@@ -143,8 +154,10 @@ void bsv_movie_frame_rewind()
          handle->frame_counter -= delta;
       else
          handle->frame_counter = 0;
+#ifdef HAVE_STATESTREAM
       uint32s_index_remove_after(handle->superblocks, handle->frame_counter);
       uint32s_index_remove_after(handle->blocks, handle->frame_counter);
+#endif
       RARCH_LOG("[REPLAY] rewound to %d\n", handle->frame_counter);
       intfstream_seek(handle->file, (int)handle->frame_pos[handle->frame_counter & handle->frame_mask], SEEK_SET);
       if (recording)
@@ -160,8 +173,10 @@ void bsv_movie_frame_rewind()
       if (handle->playback)
       {
          intfstream_seek(handle->file, (int)handle->min_file_pos, SEEK_SET);
+#ifdef HAVE_STATESTREAM
          uint32s_index_remove_after(handle->superblocks, 0);
          uint32s_index_remove_after(handle->blocks, 0);
+#endif
          bsv_movie_read_next_events(handle, false);
       }
       else
@@ -356,6 +371,7 @@ bool bsv_movie_load_checkpoint(bsv_movie_t *handle, uint8_t compression, uint8_t
          else
             encoded_data = NULL;
          break;
+#ifdef HAVE_STATESTREAM
       case REPLAY_CHECKPOINT2_ENCODING_STATESTREAM:
          if(!bsv_movie_read_deduped_state(handle, encoded_data, encoded_size, !just_update_structures))
          {
@@ -364,6 +380,7 @@ bool bsv_movie_load_checkpoint(bsv_movie_t *handle, uint8_t compression, uint8_t
             goto exit;
          }
          break;
+#endif
       default:
          RARCH_WARN("[Replay] Unrecognized encoding scheme %d\n", encoding);
          ret = false;
@@ -373,6 +390,7 @@ bool bsv_movie_load_checkpoint(bsv_movie_t *handle, uint8_t compression, uint8_t
       goto exit;
    serial_info.data_const = handle->cur_save;
    serial_info.size       = size;
+   /* TODO: should this happen at the end of the current frame, or at the beginning before inputs have been polled/etc?  FCEUMM and PPSSPP have some jankiness here */
    if (!core_unserialize(&serial_info))
    {
       abort();
@@ -419,12 +437,14 @@ int64_t bsv_movie_write_checkpoint(bsv_movie_t *handle, uint8_t compression, uin
          encoded_size = serial_info.size;
          encoded_data = serial_info.data;
          break;
+#ifdef HAVE_STATESTREAM
       case REPLAY_CHECKPOINT2_ENCODING_STATESTREAM:
          encoded_size = serial_info.size + serial_info.size / 2;
          encoded_data = malloc(encoded_size);
          owns_encoded = true;
          encoded_size = bsv_movie_write_deduped_state(handle, serial_info.data, serial_info.size, encoded_data, encoded_size);
          break;
+#endif
       default:
          RARCH_ERR("[Replay] Unrecognized encoding scheme %d\n", encoding);
          ret = -1;
@@ -702,7 +722,11 @@ void bsv_movie_next_frame(input_driver_state_t *input_st)
          uint8_t frame_tok   = REPLAY_TOKEN_CHECKPOINT2_FRAME;
          retro_ctx_serialize_info_t serial_info;
          uint8_t compression = handle->checkpoint_compression;
+#if HAVE_STATESTREAM
          uint8_t encoding    = REPLAY_CHECKPOINT2_ENCODING_STATESTREAM;
+#else
+         uint8_t encoding    = REPLAY_CHECKPOINT2_ENCODING_RAW;
+#endif
          /* "next frame is a checkpoint" */
          intfstream_write(handle->file, (uint8_t *)(&frame_tok), sizeof(uint8_t));
          /* compression and encoding schemes */
@@ -1001,8 +1025,10 @@ bool replay_set_serialized_data(void* buf)
                      MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_WARNING);
                RARCH_WARN("[Replay] %s.\n", _msg);
             }
+#ifdef HAVE_STATESTREAM
             uint32s_index_remove_after(handle->superblocks, 0);
             uint32s_index_remove_after(handle->blocks, 0);
+#endif
             intfstream_rewind(handle->file);
             intfstream_write(handle->file, header, loaded_len);
             /* also need to update/reinit frame_pos,
@@ -1014,8 +1040,10 @@ bool replay_set_serialized_data(void* buf)
          }
          else
          {
+#ifdef HAVE_STATESTREAM
             uint32s_index_remove_after(handle->superblocks, 0);
             uint32s_index_remove_after(handle->blocks, 0);
+#endif
             intfstream_seek(handle->file, loaded_len, SEEK_SET);
             /* TODO: in the future, don't clear indices above and only
                update frame counter and remove index entries after the
@@ -1092,6 +1120,7 @@ int16_t bsv_movie_read_state(input_driver_state_t *input_st,
    return 0;
 }
 
+#ifdef HAVE_STATESTREAM
 int64_t bsv_movie_write_deduped_state(bsv_movie_t *movie, uint8_t *state, size_t state_size, uint8_t *output, size_t output_capacity)
 {
    static uint32_t skipped_blocks = 0;
@@ -1415,3 +1444,4 @@ bool bsv_movie_read_deduped_state(bsv_movie_t *movie,
    RARCH_DBG("[STATESTREAM] Total statestream decodes %d ; net time (secs): %f\n", total_decode_count, (double)total_decode_micros / (1000000.0));
    return ret;
 }
+#endif

input/bsv/uint32s_index.c

@@ -1,3 +1,4 @@
+#ifdef HAVE_STATESTREAM
 #include "uint32s_index.h"
 #include <string.h>
 #include <array/rhmap.h>
@@ -363,3 +364,4 @@ void uint32s_index_print_count_data(uint32s_index_t *index)
    }
 }
 #endif
+#endif

input/bsv/uint32s_index.h

@@ -1,6 +1,6 @@
 #ifndef __UINT32S_INDEX__H
 #define __UINT32S_INDEX__H
-
+#ifdef HAVE_STATESTREAM
 #include <stdint.h>
 #include <stdlib.h>
 #include <stddef.h>
@@ -66,5 +66,5 @@ uint32_t uint32s_index_count(uint32s_index_t *index);
 void uint32s_index_print_count_data(uint32s_index_t *index);
 #endif
 RETRO_END_DECLS
-
+#endif
 #endif /* __UINT32S_INDEX__H */

input/input_driver.h

@@ -261,13 +261,15 @@ struct bsv_movie
    bool first_rewind;
    bool did_rewind;
 
+#ifdef HAVE_STATESTREAM
    /* Block index and superblock index for incremental checkpoints */
    uint32s_index_t *superblocks;
    uint32s_index_t *blocks;
    uint32_t *superblock_seq;
    uint8_t commit_interval, commit_threshold;
+#endif
 
-   uint8_t checkpoint_compression;
+   uint8_t checkpoint_compression, checkpoint_encoding;
 
    uint8_t *last_save, *cur_save;
    size_t last_save_size, cur_save_size;

tasks/task_movie.c

@@ -45,6 +45,7 @@
 #include "../input/input_driver.h"
 #include "../input/bsv/bsvmovie.h"
 
+#ifdef HAVE_STATESTREAM
 #if DEBUG
 #include "input/bsv/uint32s_index.h"
 #endif
@@ -60,6 +61,8 @@
 #define SMALL_SUPERBLOCK_SIZE 16  /* measured in blocks */
 #define SMALL_BLOCK_SIZE      128 /* measured in bytes  */
 
+#endif
+
 /* Forward declaration */
 bool content_load_state_in_progress(void* data);
 
@@ -71,8 +74,10 @@ static bool bsv_movie_init_playback(bsv_movie_t *handle, const char *path)
    uint32_t state_size         = 0;
    uint32_t header[REPLAY_HEADER_LEN] = {0};
    uint32_t vsn                = 0;
+#ifdef HAVE_STATESTREAM
    uint32_t superblock_size    = DEFAULT_SUPERBLOCK_SIZE,
       block_size = DEFAULT_BLOCK_SIZE/4;
+#endif
    intfstream_t *file          = intfstream_open_file(path,
          RETRO_VFS_FILE_ACCESS_READ,
          RETRO_VFS_FILE_ACCESS_HINT_NONE);
@@ -137,6 +142,7 @@ static bool bsv_movie_init_playback(bsv_movie_t *handle, const char *path)
    {
       retro_ctx_serialize_info_t serial_info;
       uint8_t compression, encoding;
+#ifdef HAVE_STATESTREAM
       uint32_t commit_settings = header[REPLAY_HEADER_CHECKPOINT_CONFIG_INDEX];
       superblock_size = swap_if_big32(header[REPLAY_HEADER_SUPERBLOCK_SIZE_INDEX]);
       block_size = swap_if_big32(header[REPLAY_HEADER_BLOCK_SIZE_INDEX]);
@@ -145,6 +151,7 @@ static bool bsv_movie_init_playback(bsv_movie_t *handle, const char *path)
       handle->checkpoint_compression = (commit_settings >> 8) & 0x000000FF;
       handle->superblocks = uint32s_index_new(superblock_size,handle->commit_interval,handle->commit_threshold);
       handle->blocks = uint32s_index_new(block_size/4,handle->commit_interval,handle->commit_threshold);
+#endif
 
       if (intfstream_read(handle->file, &(compression), sizeof(uint8_t)) != sizeof(uint8_t) ||
             intfstream_read(handle->file, &(encoding), sizeof(uint8_t)) != sizeof(uint8_t))
@@ -172,10 +179,12 @@ static bool bsv_movie_init_record(
    intfstream_t *file           = intfstream_open_file(path,
          RETRO_VFS_FILE_ACCESS_WRITE | RETRO_VFS_FILE_ACCESS_READ,
          RETRO_VFS_FILE_ACCESS_HINT_NONE);
+   settings_t *settings         = config_get_ptr();
+#ifdef HAVE_STATESTREAM
    bool is_small                = false;
    uint32_t superblock_size;
    uint32_t block_size;
-   settings_t *settings         = config_get_ptr();
+#endif
 
    if (!file)
    {
@@ -185,8 +194,10 @@ static bool bsv_movie_init_record(
 
    handle->file             = file;
    handle->version          = REPLAY_FORMAT_VERSION;
+#ifdef HAVE_STATESTREAM
    handle->commit_interval  = REPLAY_DEFAULT_COMMIT_INTERVAL;
    handle->commit_threshold = REPLAY_DEFAULT_COMMIT_THRESHOLD;
+#endif
    handle->checkpoint_compression = REPLAY_CHECKPOINT2_COMPRESSION_NONE;
    if (settings->bools.savestate_file_compression)
 #if defined(HAVE_ZSTD)
@@ -205,23 +216,32 @@ static bool bsv_movie_init_record(
 
    info_size                = core_serialize_size();
    state_size               = (unsigned)info_size;
+#ifdef HAVE_STATESTREAM
    is_small                 = info_size < SMALL_STATE_THRESHOLD;
    superblock_size          = is_small ? SMALL_SUPERBLOCK_SIZE : DEFAULT_SUPERBLOCK_SIZE;
    block_size               = is_small ? SMALL_BLOCK_SIZE : DEFAULT_BLOCK_SIZE;
+#endif
    header[REPLAY_HEADER_STATE_SIZE_INDEX]      = 0; /* Will fill this in later */
    header[REPLAY_HEADER_FRAME_COUNT_INDEX]     = 0;
+#ifdef HAVE_STATESTREAM
    header[REPLAY_HEADER_BLOCK_SIZE_INDEX]      = swap_if_big32(block_size);
    header[REPLAY_HEADER_SUPERBLOCK_SIZE_INDEX] = swap_if_big32(superblock_size);
    header[REPLAY_HEADER_CHECKPOINT_CONFIG_INDEX] = (((uint32_t)handle->commit_interval) << 24) |
       ((uint32_t)handle->commit_threshold << 16) |
       (((uint32_t)handle->checkpoint_compression) << 8);
+#else
+   header[REPLAY_HEADER_BLOCK_SIZE_INDEX]      = 0;
+   header[REPLAY_HEADER_SUPERBLOCK_SIZE_INDEX] = 0;
+   header[REPLAY_HEADER_CHECKPOINT_CONFIG_INDEX] = 0;
+#endif
    handle->identifier       = (int64_t)t;
    *((int64_t *)(header+REPLAY_HEADER_IDENTIFIER_INDEX)) = time_lil;
    intfstream_write(handle->file, header, REPLAY_HEADER_LEN_BYTES);
 
+#ifdef HAVE_STATESTREAM
    handle->superblocks      = uint32s_index_new(superblock_size, handle->commit_interval, handle->commit_threshold);
    handle->blocks           = uint32s_index_new(block_size/4, handle->commit_interval, handle->commit_threshold);
-
+#endif
    if (state_size)
       return bsv_movie_reset_recording(handle);
 
@@ -237,9 +257,11 @@ void bsv_movie_free(bsv_movie_t *handle)
 
    free(handle->frame_pos);
 
+#ifdef HAVE_STATESTREAM
    uint32s_index_free(handle->superblocks);
    uint32s_index_free(handle->blocks);
    free(handle->superblock_seq);
+#endif
    if (handle->last_save)
       free(handle->last_save);
    if (handle->cur_save)
@@ -408,11 +430,13 @@ bool movie_stop_playback(input_driver_state_t *input_st)
    /* Checks if movie is being played back. */
    if (!(input_st->bsv_movie_state.flags & BSV_FLAG_MOVIE_PLAYBACK))
       return false;
+#ifdef HAVE_STATESTREAM
 #if DEBUG
    RARCH_DBG("[Replay] superblock histogram\n");
    uint32s_index_print_count_data(input_st->bsv_movie_state_handle->superblocks);
    RARCH_DBG("[Replay] block histogram\n");
    uint32s_index_print_count_data(input_st->bsv_movie_state_handle->blocks);
+#endif
 #endif
    _msg = msg_hash_to_str(MSG_MOVIE_PLAYBACK_ENDED);
    runloop_msg_queue_push(_msg, strlen(_msg), 2, 180, false, NULL,
@@ -437,11 +461,13 @@ bool movie_stop_record(input_driver_state_t *input_st)
    runloop_msg_queue_push(_msg, strlen(_msg), 2, 180, true, NULL,
          MESSAGE_QUEUE_ICON_DEFAULT, MESSAGE_QUEUE_CATEGORY_INFO);
    RARCH_LOG("[Replay] %s\n", _msg);
+#ifdef HAVE_STATESTREAM
 #if DEBUG
    RARCH_DBG("[Replay] superblock histogram\n");
    uint32s_index_print_count_data(movie->superblocks);
    RARCH_DBG("[Replay] block histogram\n");
    uint32s_index_print_count_data(movie->blocks);
+#endif
 #endif
    frame_count = swap_if_big32(movie->frame_counter);
    intfstream_seek(movie->file, REPLAY_HEADER_FRAME_COUNT_INDEX*sizeof(uint32_t), SEEK_SET);