src/lua/movie.cpp

   1 #include "lua/internal.hpp"
   2 #include "lua/unsaferewind.hpp"
   3 #include "core/instance.hpp"
   4 #include "core/moviedata.hpp"
   5 #include "core/mainloop.hpp"
   6
   7 namespace
   8 {
   9         int currentframe(lua::state& L, lua::parameters& P)
  10         {
  11                 auto& m = CORE().mlogic->get_movie();
  12                 L.pushnumber(m.get_current_frame());
  13                 return 1;
  14         }
  15
  16         int lagcounter(lua::state& L, lua::parameters& P)
  17         {
  18                 auto& m = CORE().mlogic->get_movie();
  19                 L.pushnumber(m.get_lag_frames());
  20                 return 1;
  21         }
  22
  23         int framecount(lua::state& L, lua::parameters& P)
  24         {
  25                 auto& m = CORE().mlogic->get_movie();
  26                 L.pushnumber(m.get_frame_count());
  27                 return 1;
  28         }
  29
  30         int rerecords(lua::state& L, lua::parameters& P)
  31         {
  32                 L.pushnumber(CORE().mlogic->get_rrdata().count());
  33                 return 1;
  34         }
  35
  36         int readonly(lua::state& L, lua::parameters& P)
  37         {
  38                 auto& m = CORE().mlogic->get_movie();
  39                 L.pushboolean(m.readonly_mode() ? 1 : 0);
  40                 return 1;
  41         }
  42
  43         int readwrite(lua::state& L, lua::parameters& P)
  44         {
  45                 auto& m = CORE().mlogic->get_movie();
  46                 m.readonly_mode(false);
  47                 return 0;
  48         }
  49
  50         int frame_subframes(lua::state& L, lua::parameters& P)
  51         {
  52                 uint64_t frame;
  53
  54                 P(frame);
  55
  56                 auto& m = CORE().mlogic->get_movie();
  57                 L.pushnumber(m.frame_subframes(frame));
  58                 return 1;
  59         }
  60
  61         int read_subframes(lua::state& L, lua::parameters& P)
  62         {
  63                 uint64_t frame, subframe;
  64
  65                 P(frame, subframe);
  66
  67                 auto& m = CORE().mlogic->get_movie();
  68                 controller_frame r = m.read_subframe(frame, subframe);
  69                 L.newtable();
  70
  71                 for(size_t i = 0; i < r.get_index_count(); i++) {
  72                         L.pushnumber(i);
  73                         L.pushnumber(r.axis2(i));
  74                         L.settable(-3);
  75                 }
  76                 return 1;
  77         }
  78
  79         int read_rtc(lua::state& L, lua::parameters& P)
  80         {
  81                 auto& core = CORE();
  82                 L.pushnumber(core.mlogic->get_mfile().rtc_second);
  83                 L.pushnumber(core.mlogic->get_mfile().rtc_subsecond);
  84                 return 2;
  85         }
  86
  87         int unsafe_rewind(lua::state& L, lua::parameters& P)
  88         {
  89                 if(P.is_novalue()) {
  90                         //Start process to mark save.
  91                         mainloop_signal_need_rewind(NULL);
  92                 } else if(P.is<lua_unsaferewind>()) {
  93                         //Load the save.
  94                         lua::objpin<lua_unsaferewind> pin;
  95
  96                         P(pin);
  97
  98                         mainloop_signal_need_rewind(new lua::objpin<lua_unsaferewind>(pin));
  99                 } else
 100                         P.expected("UNSAFEREWIND or nil");
 101                 return 0;
 102         }
 103
 104         int to_rewind(lua::state& L, lua::parameters& P)
 105         {
 106                 auto& core = CORE();
 107                 std::string filename;
 108
 109                 P(filename);
 110
 111                 moviefile mfile(filename, core.rom->get_internal_rom_type());
 112                 if(!mfile.is_savestate)
 113                         throw std::runtime_error("movie.to_rewind only allows savestates");
 114                 lua_unsaferewind* u2 = lua::_class<lua_unsaferewind>::create(L);
 115                 u2->state = mfile.savestate;
 116                 if(u2->state.size() >= 32)
 117                         u2->state.resize(u2->state.size() - 32);
 118                 u2->secs = mfile.rtc_second;
 119                 u2->ssecs = mfile.rtc_subsecond;
 120                 u2->pollcounters = mfile.pollcounters;
 121                 u2->lag = mfile.lagged_frames;
 122                 u2->frame = mfile.save_frame;
 123                 u2->hostmemory = mfile.host_memory;
 124                 //Now the remaining field ptr is somewhat nastier.
 125                 uint64_t f = 0;
 126                 uint64_t s = mfile.input->size();
 127                 u2->ptr = 0;
 128                 while(++f < u2->frame) {
 129                         if(u2->ptr < s)
 130                                 u2->ptr++;
 131                         while(u2->ptr < s && !(*mfile.input)[u2->ptr].sync())
 132                                 u2->ptr++;
 133                 }
 134                 return 1;
 135         }
 136
 137         lua::functions LUA_movie_fns(lua_func_misc, "movie", {
 138                 {"currentframe", currentframe},
 139                 {"lagcount", lagcounter},
 140                 {"framecount", framecount},
 141                 {"rerecords", rerecords},
 142                 {"readonly", readonly},
 143                 {"readwrite", readwrite},
 144                 {"frame_subframes", frame_subframes},
 145                 {"read_subframes", read_subframes},
 146                 {"read_rtc", read_rtc},
 147                 {"unsafe_rewind", unsafe_rewind},
 148                 {"to_rewind", to_rewind},
 149         });
 150 }