Add rewind code from binjgb

Author: binji

CMakeLists.txt

@@ -40,6 +40,7 @@ if (NOT EMSCRIPTEN)
       src/host-gl.c
       src/host-ui-simple.c
       src/joypad.c
+      src/rewind.c
     )
     target_link_libraries(binjnes SDL2::SDL2 SDL2::SDL2main ${OPENGL_gl_LIBRARY})
 
@@ -68,6 +69,7 @@ else (EMSCRIPTEN)
     src/memory.c
     src/emulator.c
     src/joypad.c
+    src/rewind.c
     src/emscripten/wrapper.c)
   set(EXPORTED_JSON ${PROJECT_SOURCE_DIR}/src/emscripten/exported.json)
   target_include_directories(binjnes PUBLIC ${PROJECT_SOURCE_DIR}/src)

src/binjnes.c

@@ -12,6 +12,9 @@
 // TODO: make these configurable?
 #define AUDIO_FREQUENCY 44100
 #define AUDIO_FRAMES 2048 /* ~46ms of latency at 44.1kHz */
+#define REWIND_FRAMES_PER_BASE_STATE 45
+#define REWIND_BUFFER_CAPACITY MEGABYTES(32)
+#define REWIND_CYCLES_PER_FRAME (89432 * 3 / 2) /* Rewind at 1.5x */
 
 static struct Emulator* e;
 static struct Host* host;
@@ -22,18 +25,48 @@ static Bool s_running = TRUE;
 static Bool s_step_frame;
 static Bool s_paused;
 static f32 s_audio_volume = 0.5f;
+static Bool s_rewinding;
+static Ticks s_rewind_start;
 static u32 s_render_scale = 4;
 
+static void begin_rewind(void) {
+  if (!s_rewinding) {
+    host_begin_rewind(host);
+    s_rewinding = TRUE;
+    s_rewind_start = emulator_get_ticks(e);
+  }
+}
+
+static void rewind_by(Ticks delta) {
+  Ticks now = emulator_get_ticks(e);
+  Ticks then = now;
+  if (now >= delta) {
+    then = now - delta;
+    host_rewind_to_ticks(host, then);
+  }
+}
+
+static void end_rewind(void) {
+  host_end_rewind(host);
+  s_rewinding = FALSE;
+}
+
 static void key_down(HostHookContext *ctx, HostKeycode code) {
   switch (code) {
     case HOST_KEYCODE_N: s_step_frame = TRUE; s_paused = FALSE; break;
     case HOST_KEYCODE_SPACE: s_paused ^= 1; break;
     case HOST_KEYCODE_ESCAPE: s_running = FALSE; break;
+    case HOST_KEYCODE_BACKSPACE: begin_rewind(); break;
     default: break;
   }
 }
 
-static void key_up(HostHookContext *ctx, HostKeycode code) {}
+static void key_up(HostHookContext *ctx, HostKeycode code) {
+  switch (code) {
+    case HOST_KEYCODE_BACKSPACE: end_rewind(); break;
+    default: break;
+  }
+}
 
 int main(int argc, char **argv) {
   int result = 1;
@@ -60,12 +93,16 @@ int main(int argc, char **argv) {
   host_init.audio_frequency = AUDIO_FREQUENCY;
   host_init.audio_frames = AUDIO_FRAMES;
   host_init.audio_volume = s_audio_volume;
+  host_init.rewind.frames_per_base_state = REWIND_FRAMES_PER_BASE_STATE;
+  host_init.rewind.buffer_capacity = REWIND_BUFFER_CAPACITY;
   host = host_new(&host_init, e);
   CHECK(host != NULL);
 
   f64 refresh_ms = host_get_monitor_refresh_ms(host);
   while (s_running && host_poll_events(host)) {
-    if (!s_paused) {
+    if (s_rewinding) {
+      rewind_by(REWIND_CYCLES_PER_FRAME);
+    } else if (!s_paused) {
       EmulatorEvent event = host_run_ms(host, refresh_ms);
       if (event & EMULATOR_EVENT_INVALID_OPCODE) {
         // set_status_text("invalid opcode!");

src/emulator.c

@@ -12,6 +12,9 @@
 
 #include "emulator.h"
 
+#define SAVE_STATE_VERSION (0)
+#define SAVE_STATE_HEADER (u32)(0x23557a7e + SAVE_STATE_VERSION)
+
 #define LOGLEVEL 0
 #define DISASM 0
 
@@ -1216,8 +1219,8 @@ void cpu_write(E *e, u16 addr, u8 val) {
   }
 }
 
-static void set_mirror(E *e, Mirror mirror) {
-  switch (mirror) {
+static void update_nt_map(E* e) {
+  switch (e->s.p.mirror) {
     case MIRROR_HORIZONTAL:
       e->nt_map[0] = e->nt_map[1] = e->s.p.ram;
       e->nt_map[2] = e->nt_map[3] = e->s.p.ram + 0x400;
@@ -1236,17 +1239,27 @@ static void set_mirror(E *e, Mirror mirror) {
   }
 }
 
-static void set_chr1k_map(E *e, u8 bank0, u8 bank1, u8 bank2, u8 bank3,
-                          u8 bank4, u8 bank5, u8 bank6, u8 bank7) {
-  u8 banks[] = {bank0, bank1, bank2, bank3, bank4, bank5, bank6, bank7};
-  for (size_t i = 0; i < ARRAY_SIZE(banks); ++i) {
-    u8 bank = banks[i] & (e->ci.chr1k_banks - 1);
+static void set_mirror(E *e, Mirror mirror) {
+  e->s.p.mirror = mirror;
+  update_nt_map(e);
+}
+
+static void update_chr1k_map(E* e) {
+  for (size_t i = 0; i < ARRAY_SIZE(e->s.m.chr1k_bank); ++i) {
+    u8 bank = e->s.m.chr1k_bank[i] & (e->ci.chr1k_banks - 1);
     e->chr_map[i] = e->ci.chr_data + (bank << 10);
     // TODO: chr_data_write always points into chr_ram (which is fixed at 8KiB).
     e->chr_map_write[i] = e->ci.chr_data_write + ((bank & 7) << 10);
   }
 }
 
+static void set_chr1k_map(E *e, u8 bank0, u8 bank1, u8 bank2, u8 bank3,
+                          u8 bank4, u8 bank5, u8 bank6, u8 bank7) {
+  u8 banks[] = {bank0, bank1, bank2, bank3, bank4, bank5, bank6, bank7};
+  memcpy(e->s.m.chr1k_bank, banks, sizeof(e->s.m.chr1k_bank));
+  update_chr1k_map(e);
+}
+
 static void set_chr4k_map(E *e, u8 bank0, u8 bank1) {
   bank0 &= (e->ci.chr4k_banks - 1);
   bank1 &= (e->ci.chr4k_banks - 1);
@@ -1259,14 +1272,19 @@ static void set_chr8k_map(E *e, u8 bank) {
   set_chr4k_map(e, bank * 2, bank * 2 + 1);
 }
 
-static void set_prg8k_map(E *e, u8 bank0, u8 bank1, u8 bank2, u8 bank3) {
-  u8 banks[] = {bank0, bank1, bank2, bank3};
-  for (size_t i = 0; i < ARRAY_SIZE(banks); ++i) {
-    u8 bank = banks[i] & (e->ci.prg8k_banks - 1);
+static void update_prg8k_map(E* e) {
+  for (size_t i = 0; i < ARRAY_SIZE(e->s.m.prg8k_bank); ++i) {
+    u8 bank = e->s.m.prg8k_bank[i] & (e->ci.prg8k_banks - 1);
     e->prg_rom_map[i] = e->ci.prg_data + (bank << 13);
   }
 }
 
+static void set_prg8k_map(E *e, u8 bank0, u8 bank1, u8 bank2, u8 bank3) {
+  u8 banks[] = {bank0, bank1, bank2, bank3};
+  memcpy(e->s.m.prg8k_bank, banks, sizeof(e->s.m.prg8k_bank));
+  update_prg8k_map(e);
+}
+
 static void set_prg16k_map(E *e, u8 bank0, u8 bank1) {
   bank0 &= (e->ci.prg16k_banks - 1);
   bank1 &= (e->ci.prg16k_banks - 1);
@@ -2328,6 +2346,36 @@ EEvent emulator_run_until(E *e, Ticks until_ticks) {
   return e->s.event;
 }
 
+void emulator_init_state_file_data(FileData* file_data) {
+  file_data->size = sizeof(S);
+  file_data->data = xmalloc(file_data->size);
+}
+
+Result emulator_read_state(Emulator *e, const FileData *file_data) {
+  CHECK_MSG(file_data->size == sizeof(S),
+            "save state file is wrong size: %ld, expected %ld.\n",
+            (long)file_data->size, (long)sizeof(S));
+  S *new_state = (S *)file_data->data;
+  CHECK_MSG(new_state->header == SAVE_STATE_HEADER,
+            "header mismatch: %u, expected %u.\n", new_state->header,
+            SAVE_STATE_HEADER);
+  memcpy(&e->s, new_state, sizeof(S));
+  // Fix pointers.
+  update_chr1k_map(e);
+  update_prg8k_map(e);
+  update_nt_map(e);
+  return OK;
+  ON_ERROR_RETURN;
+}
+
+Result emulator_write_state(Emulator *e, FileData *file_data) {
+  CHECK(file_data->size >= sizeof(S));
+  e->s.header = SAVE_STATE_HEADER;
+  memcpy(file_data->data, &e->s, file_data->size);
+  return OK;
+  ON_ERROR_RETURN;
+}
+
 // Debug stuff /////////////////////////////////////////////////////////////////
 
 static const char* s_opcode_mnemonic[256];

src/emulator.h

@@ -89,7 +89,8 @@ typedef struct {
 } CartInfo;
 
 typedef struct {
-  u8 chr_bank[6], prg_bank[2];
+  u8 chr1k_bank[8], prg8k_bank[4]; // Actual mapped bank indexes.
+  u8 chr_bank[6], prg_bank[2];     // Mapper's selected bank indexes.
   union {
     struct {
       u8 bits, data, ctrl;
@@ -133,6 +134,7 @@ typedef struct {
   u32 fbidx, bits_mask, frame;
   Spr spr;
   u64 read_status_cy, last_vram_access_cy, a12_low_count;
+  Mirror mirror;
 } P;
 
 typedef struct {
@@ -154,6 +156,7 @@ typedef struct {
 } J;
 
 typedef struct {
+  u32 header;
   u64 cy;
   EmulatorEvent event;
   C c;
@@ -187,6 +190,10 @@ AudioBuffer* emulator_get_audio_buffer(Emulator*);
 u32 audio_buffer_get_frames(AudioBuffer*);
 Ticks emulator_get_ticks(Emulator*);
 
+void emulator_init_state_file_data(FileData*);
+Result emulator_read_state(Emulator*, const FileData*);
+Result emulator_write_state(Emulator*, FileData*);
+
 EmulatorEvent emulator_step(Emulator*);
 EmulatorEvent emulator_run_until(Emulator*, Ticks until_ticks);
 

src/host.c

@@ -10,6 +10,7 @@
 
 #include "host-gl.h"
 #include "host-ui.h"
+#include "rewind.h"
 
 #define HOOK0(name)                           \
   do                                          \
@@ -47,6 +48,12 @@ typedef struct {
   f32 volume; /* [0..1] */
 } Audio;
 
+typedef struct {
+  RewindResult rewind_result;
+  JoypadPlayback joypad_playback;
+  Bool rewinding;
+} RewindState;
+
 typedef struct Host {
   HostInit init;
   HostConfig config;
@@ -60,6 +67,8 @@ typedef struct Host {
   struct HostUI* ui;
   HostTexture* fb_texture;
   JoypadBuffer* joypad_buffer;
+  RewindBuffer* rewind_buffer;
+  RewindState rewind_state;
   JoypadPlayback joypad_playback;
   Ticks last_ticks;
   Bool key_state[HOST_KEYCODE_COUNT];
@@ -291,11 +300,36 @@ Result host_write_joypad_to_file(struct Host* host, const char* filename) {
   return result;
 }
 
+static void append_rewind_state(Host* host) {
+  if (host->rewind_state.rewinding) {
+    return;
+  }
+
+  rewind_append(host->rewind_buffer, host_get_emulator(host));
+}
+
+Ticks host_get_rewind_oldest_ticks(struct Host* host) {
+  return rewind_get_oldest_ticks(host->rewind_buffer);
+}
+
+Ticks host_get_rewind_newest_ticks(struct Host* host) {
+  return rewind_get_newest_ticks(host->rewind_buffer);
+}
+
+JoypadStats host_get_joypad_stats(struct Host* host) {
+  return joypad_get_stats(host->joypad_buffer);
+}
+
+RewindStats host_get_rewind_stats(struct Host* host) {
+  return rewind_get_stats(host->rewind_buffer);
+}
+
 static void host_handle_event(Host* host, EmulatorEvent event) {
   Emulator* e = host_get_emulator(host);
   if (event & EMULATOR_EVENT_NEW_FRAME) {
     host_upload_texture(host, host->fb_texture, SCREEN_WIDTH, SCREEN_HEIGHT,
                         *emulator_get_frame_buffer(e));
+    append_rewind_state(host);
   }
   if (event & EMULATOR_EVENT_AUDIO_BUFFER_FULL) {
     host_render_audio(host);
@@ -315,6 +349,60 @@ static EmulatorEvent host_run_until_ticks(struct Host* host, Ticks ticks) {
   return event;
 }
 
+void host_begin_rewind(Host* host) {
+  assert(!host->rewind_state.rewinding);
+  host->rewind_state.rewinding = TRUE;
+}
+
+Result host_rewind_to_ticks(Host* host, Ticks ticks) {
+  assert(host->rewind_state.rewinding);
+
+  RewindResult* result = &host->rewind_state.rewind_result;
+  CHECK(SUCCESS(rewind_to_ticks(host->rewind_buffer, ticks, result)));
+
+  Emulator* e = host_get_emulator(host);
+  CHECK(SUCCESS(emulator_read_state(e, &result->file_data)));
+  assert(emulator_get_ticks(e) == result->info->ticks);
+
+  if (emulator_get_ticks(e) < ticks) {
+    /* Save old joypad callback. */
+    JoypadCallbackInfo old_jci = emulator_get_joypad_callback(e);
+    emulator_set_joypad_playback_callback(e, host->joypad_buffer,
+                                          &host->rewind_state.joypad_playback);
+    host_run_until_ticks(host, ticks);
+    /* Restore old joypad callback. */
+    emulator_set_joypad_callback(e, old_jci.callback, old_jci.user_data);
+  }
+
+  return OK;
+  ON_ERROR_RETURN;
+}
+
+void host_end_rewind(Host* host) {
+  Ticks ticks = emulator_get_ticks(host_get_emulator(host));
+  assert(host->rewind_state.rewinding);
+
+  if (host->rewind_state.rewind_result.info) {
+    Emulator* e = host_get_emulator(host);
+    rewind_truncate_to(host->rewind_buffer, e,
+                       &host->rewind_state.rewind_result);
+    if (!host->init.joypad_filename) {
+      joypad_truncate_to(host->joypad_buffer,
+                         host->rewind_state.joypad_playback.current);
+      /* Append the current joypad state. */
+      JoypadButtons buttons;
+      joypad_callback(&buttons, host);
+    }
+    host->last_ticks = emulator_get_ticks(e);
+  }
+
+  memset(&host->rewind_state, 0, sizeof(host->rewind_state));
+}
+
+Bool host_is_rewinding(Host* host) {
+  return host->rewind_state.rewinding;
+}
+
 Result host_init(Host* host, Emulator* e) {
   CHECK_MSG(
       SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_GAMECONTROLLER) == 0,
@@ -323,12 +411,14 @@ Result host_init(Host* host, Emulator* e) {
   CHECK(SUCCESS(host_init_video(host)));
   CHECK(SUCCESS(host_init_audio(host)));
   host_init_joypad(host, e);
+  host->rewind_buffer = rewind_new(&host->init.rewind, e);
   host->last_ticks = emulator_get_ticks(e);
   return OK;
   ON_ERROR_RETURN;
 }
 
 EmulatorEvent host_run_ms(struct Host* host, f64 delta_ms) {
+  assert(!host->rewind_state.rewinding);
   Emulator* e = host_get_emulator(host);
   Ticks delta_ticks = (Ticks)(delta_ms * PPU_TICKS_PER_SECOND / 1000);
   Ticks until_ticks = emulator_get_ticks(e) + delta_ticks;
@@ -338,6 +428,7 @@ EmulatorEvent host_run_ms(struct Host* host, f64 delta_ms) {
 }
 
 EmulatorEvent host_step(Host* host) {
+  assert(!host->rewind_state.rewinding);
   Emulator* e = host_get_emulator(host);
   EmulatorEvent event = emulator_step(e);
   host_handle_event(host, event);
@@ -364,6 +455,8 @@ void host_delete(Host* host) {
     SDL_GL_DeleteContext(host->gl_context);
     SDL_DestroyWindow(host->window);
     SDL_Quit();
+    joypad_delete(host->joypad_buffer);
+    rewind_delete(host->rewind_buffer);
     xfree(host->audio.buffer);
     xfree(host);
   }

src/host.h

@@ -10,6 +10,7 @@
 #include "common.h"
 #include "emulator.h"
 #include "joypad.h"
+#include "rewind.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -124,6 +125,7 @@ typedef struct HostInit {
   int audio_frequency;
   int audio_frames;
   f32 audio_volume;
+  RewindInit rewind;
   const char* joypad_filename;
 } HostInit;
 
@@ -162,6 +164,23 @@ void host_set_palette(struct Host*, RGBA palette[4]);
 void host_enable_palette(struct Host*, Bool enabled);
 void host_render_screen_overlay(struct Host*, struct HostTexture*);
 
+/* Rewind support. */
+
+Ticks host_oldest_ticks(struct Host*);
+Ticks host_newest_ticks(struct Host*);
+
+Ticks host_get_rewind_oldest_ticks(struct Host*);
+Ticks host_get_rewind_newest_ticks(struct Host*);
+JoypadStats host_get_joypad_stats(struct Host*);
+RewindStats host_get_rewind_stats(struct Host*);
+
+Result host_write_joypad_to_file(struct Host*, const char* filename);
+
+void host_begin_rewind(struct Host*);
+Result host_rewind_to_ticks(struct Host*, Ticks ticks);
+void host_end_rewind(struct Host*);
+Bool host_is_rewinding(struct Host*);
+
 HostTexture* host_get_frame_buffer_texture(struct Host*);
 HostTexture* host_create_texture(struct Host*, int w, int h, HostTextureFormat);
 void host_upload_texture(struct Host*, HostTexture*, int w, int h,

src/rewind.c

@@ -0,0 +1,116 @@
+/*
+ * Copyright (C) 2018 Ben Smith
+ *
+ * This software may be modified and distributed under the terms
+ * of the MIT license.  See the LICENSE file for details.
+ */
+#ifndef BINJNES_REWIND_H_
+#define BINJNES_REWIND_H_
+
+#include "common.h"
+
+struct Emulator;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+  RewindInfoKind_Base,
+  RewindInfoKind_Diff,
+} RewindInfoKind;
+
+typedef struct {
+  Ticks ticks;
+  u8* data;
+  size_t size;
+  RewindInfoKind kind;
+} RewindInfo;
+
+typedef struct {
+  RewindInfo* begin; /* begin <= end; if begin == end range is empty. */
+  RewindInfo* end;   /* end is exclusive. */
+} RewindInfoRange;
+
+typedef struct {
+  u8* begin;
+  u8* end;
+} RewindDataRange;
+
+typedef struct {
+  int info_range_index;
+  RewindInfo* info;
+  FileData file_data;
+} RewindResult;
+
+typedef struct {
+  size_t buffer_capacity;
+  int frames_per_base_state;
+} RewindInit;
+
+typedef struct RewindBuffer {
+ /*
+  * |                  rewind buffer                      |
+  * |                                                     |
+  * | dr[0] | ... | dr[1] | ....... | ir[1] | ... | ir[0] |
+  *
+  * (dr == data_range, ir == info_range)
+  *
+  * All RewindInfo in ir[0] has a corresponding data range in dr[0]. Similarly,
+  * all RewindInfo in ir[1] has a corresponding data range in dr[1].
+  *
+  * When new data is written, ir[0].begin moves left, which my overwrite old
+  * data in ir[1]. The data is written after dr[0].end. If the newly written
+  * data overlaps the beginning of dr[1], the associated RewindInfo in ir[1] is
+  * removed.
+  *
+  * When ir[1].begin and dr[1].end cross, the buffer is filled. At this point,
+  * dr[0] is moved to dr[1], and ir[0] is moved to ir[1]. (Just the pointers
+  * move, not the actual data). Then dr[0] is reset to an empty data range and
+  * ir[0] is reset to an empty info range.
+  *
+  * TODO(binji):: you can always recalculate the data ranges from the
+  * information in the info ranges. Remove?
+  *
+  */
+  RewindInit init;
+  RewindDataRange data_range[2];
+  RewindInfoRange info_range[2];
+  FileData last_state;
+  FileData last_base_state;
+  Ticks last_base_state_ticks;
+  int frames_until_next_base;
+
+  /* Data is decompressed into these states when rewinding. */
+  FileData rewind_diff_state;
+
+  /* Stats */
+  size_t total_kind_bytes[2];
+  size_t total_uncompressed_bytes;
+} RewindBuffer;
+
+typedef struct {
+  size_t base_bytes;
+  size_t diff_bytes;
+  size_t uncompressed_bytes;
+  size_t used_bytes;
+  size_t capacity_bytes;
+
+  size_t data_ranges[4];
+  size_t info_ranges[4];
+} RewindStats;
+
+RewindBuffer* rewind_new(const RewindInit*, struct Emulator*);
+void rewind_delete(RewindBuffer*);
+void rewind_append(RewindBuffer*, struct Emulator*);
+Result rewind_to_ticks(RewindBuffer*, Ticks, RewindResult*);
+void rewind_truncate_to(RewindBuffer*, struct Emulator*, RewindResult*);
+Ticks rewind_get_oldest_ticks(RewindBuffer*);
+Ticks rewind_get_newest_ticks(RewindBuffer*);
+RewindStats rewind_get_stats(RewindBuffer*);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* BINJNES_REWIND_H_ */