include/core/moviefile.hpp

   1 #ifndef _moviefile__hpp__included__
   2 #define _moviefile__hpp__included__
   3
   4 #include <string>
   5 #include <vector>
   6 #include <stdexcept>
   7 #include <map>
   8 #include "core/controllerframe.hpp"
   9 #include "core/rom-small.hpp"
  10 #include "core/subtitles.hpp"
  11 #include "interface/romtype.hpp"
  12 #include "library/rrdata.hpp"
  13 #include "library/zip.hpp"
  14
  15 class loaded_rom;
  16
  17 /**
  18  * Dynamic state parts of movie file.
  19  */
  20 struct dynamic_state
  21 {
  22 /**
  23  * Ctor.
  24  */
  25         dynamic_state();
  26 /**
  27  * Contents of SRAM on time of savestate (if is_savestate is true).
  28  */
  29         std::map<std::string, std::vector<char>> sram;
  30 /**
  31  * Core savestate (if is_savestate is true).
  32  */
  33         std::vector<char> savestate;            //Savestate to load (if is_savestate is true).
  34 /**
  35  * Host memory (if is_savestate is true).
  36  */
  37         std::vector<char> host_memory;
  38 /**
  39  * Screenshot (if is_savestate is true).
  40  */
  41         std::vector<char> screenshot;
  42 /**
  43  * Current frame (if is_savestate is true).
  44  */
  45         uint64_t save_frame;
  46 /**
  47  * Number of lagged frames (if is_savestate is true).
  48  */
  49         uint64_t lagged_frames;
  50 /**
  51  * Poll counters (if is_savestate is true).
  52  */
  53         std::vector<uint32_t> pollcounters;
  54 /**
  55  * Poll flag.
  56  */
  57         unsigned poll_flag;
  58 /**
  59  * Current RTC second.
  60  */
  61         int64_t rtc_second;
  62 /**
  63  * Current RTC subsecond.
  64  */
  65         int64_t rtc_subsecond;
  66 /**
  67  * Active macros at savestate.
  68  */
  69         std::map<std::string, uint64_t> active_macros;
  70 /**
  71  * Clear the state to power-on defaults.
  72  */
  73         void clear(int64_t sec, int64_t ssec, const std::map<std::string, std::vector<char>>& initsram);
  74 /**
  75  * Swap the dynamic state with another.
  76  */
  77         void swap(dynamic_state& s) throw();
  78 };
  79
  80 /**
  81  * This structure gives parsed representationg of movie file, as result of decoding or for encoding.
  82  */
  83 struct moviefile
  84 {
  85 /**
  86  * Brief information
  87  */
  88         struct brief_info
  89         {
  90                 brief_info() { current_frame = 0; rerecords = 0; }
  91                 brief_info(const std::string& filename);
  92                 std::string sysregion;
  93                 std::string corename;
  94                 std::string projectid;
  95                 std::string hash[ROM_SLOT_COUNT];
  96                 std::string hashxml[ROM_SLOT_COUNT];
  97                 std::string hint[ROM_SLOT_COUNT];
  98                 uint64_t current_frame;
  99                 uint64_t rerecords;
 100         private:
 101                 void load(zip::reader& r);
 102                 void binary_io(int s);
 103         };
 104 /**
 105  * Extract branches.
 106  */
 107         struct branch_extractor
 108         {
 109                 branch_extractor(const std::string& filename);
 110                 virtual ~branch_extractor();
 111                 virtual std::set<std::string> enumerate() { return real->enumerate(); }
 112                 virtual void read(const std::string& name, portctrl::frame_vector& v) { real->read(name, v); }
 113         protected:
 114                 branch_extractor() { real = NULL; }
 115         private:
 116                 branch_extractor* real;
 117         };
 118 /**
 119  * Extract SRAMs.
 120  */
 121         struct sram_extractor
 122         {
 123                 sram_extractor(const std::string& filename);
 124                 virtual ~sram_extractor();
 125                 virtual std::set<std::string> enumerate() { return real->enumerate(); }
 126                 virtual void read(const std::string& name, std::vector<char>& v) { real->read(name, v); }
 127         protected:
 128                 sram_extractor() { real = NULL; }
 129         private:
 130                 sram_extractor* real;
 131         };
 132 /**
 133  * Identify if file is movie/savestate file or not.
 134  */
 135         static bool is_movie_or_savestate(const std::string& filename);
 136 /**
 137  * This constructor construct movie structure with default settings.
 138  *
 139  * throws std::bad_alloc: Not enough memory.
 140  */
 141         moviefile() throw(std::bad_alloc);
 142
 143 /**
 144  * This constructor loads a movie/savestate file and fills structure accordingly.
 145  *
 146  * parameter filename: The file to load.
 147  * parameter romtype: Type of ROM.
 148  * throws std::bad_alloc: Not enough memory.
 149  * throws std::runtime_error: Can't load the movie file
 150  */
 151         moviefile(const std::string& filename, core_type& romtype) throw(std::bad_alloc, std::runtime_error);
 152
 153 /**
 154  * Fill a stub movie with specified loaded ROM.
 155  *
 156  * Parameter rom: The rom.
 157  * Parameter settings: The settings.
 158  * Parameter rtc_sec: The RTC seconds value.
 159  * Parameter rtc_subsec: The RTC subseconds value.
 160  */
 161         moviefile(loaded_rom& rom, std::map<std::string, std::string>& c_settings, uint64_t rtc_sec,
 162                 uint64_t rtc_subsec);
 163
 164 /**
 165  * Reads this movie structure and saves it into file.
 166  *
 167  * parameter filename: The file to save to.
 168  * parameter compression: The compression level 0-9. 0 is uncompressed.
 169  * parameter binary: Save in binary form if true.
 170  * parameter rrd: The rerecords data.
 171  * throws std::bad_alloc: Not enough memory.
 172  * throws std::runtime_error: Can't save the movie file.
 173  */
 174         void save(const std::string& filename, unsigned compression, bool binary, rrdata_set& rrd, bool as_state)
 175                 throw(std::bad_alloc, std::runtime_error);
 176 /**
 177  * Reads this movie structure and saves it to stream (uncompressed ZIP).
 178  */
 179         void save(std::ostream& outstream, rrdata_set& rrd, bool as_state) throw(std::bad_alloc, std::runtime_error);
 180 /**
 181  * Force loading as corrupt.
 182  */
 183         bool force_corrupt;
 184 /**
 185  * What is the ROM type and region?
 186  */
 187         core_sysregion* gametype;
 188 /**
 189  * Settings.
 190  */
 191         std::map<std::string, std::string> settings;
 192 /**
 193  * Emulator Core version string.
 194  */
 195         std::string coreversion;
 196 /**
 197  * Name of the game
 198  */
 199         std::string gamename;
 200 /**
 201  * Project ID (used to identify if two movies are from the same project).
 202  */
 203         std::string projectid;
 204 /**
 205  * Rerecord count (only saved).
 206  */
 207         std::string rerecords;
 208 /**
 209  * Rerecord count (memory saves only).
 210  */
 211         uint64_t rerecords_mem;
 212 /**
 213  * SHA-256 of ROM (empty string if none).
 214  */
 215         std::string romimg_sha256[ROM_SLOT_COUNT];
 216 /**
 217  * SHA-256 of ROM XML (empty string if none).
 218  */
 219         std::string romxml_sha256[ROM_SLOT_COUNT];
 220 /**
 221  * ROM name hint (empty string if none).
 222  */
 223         std::string namehint[ROM_SLOT_COUNT];
 224 /**
 225  * Authors of the run, first in each pair is full name, second is nickname.
 226  */
 227         std::vector<std::pair<std::string, std::string>> authors;
 228 /**
 229  * Contents of SRAM on time of initial powerup.
 230  */
 231         std::map<std::string, std::vector<char>> movie_sram;
 232 /**
 233  * Contents of RAM on time of initial powerup.
 234  */
 235         std::map<std::string, std::vector<char>> ramcontent;
 236 /**
 237  * Anchoring core savestate (if not empty).
 238  */
 239         std::vector<char> anchor_savestate;
 240 /**
 241  * Compressed rrdata.
 242  */
 243         std::vector<char> c_rrdata;
 244 /**
 245  * Input for each (sub)frame (points to active branch).
 246  */
 247         portctrl::frame_vector* input;
 248 /**
 249  * Branches.
 250  */
 251         std::map<std::string, portctrl::frame_vector> branches;
 252 /**
 253  * Movie starting RTC second.
 254  */
 255         int64_t movie_rtc_second;
 256 /**
 257  * Movie starting RTC subsecond.
 258  */
 259         int64_t movie_rtc_subsecond;
 260 /**
 261  * Start paused flag.
 262  */
 263         bool start_paused;
 264 /**
 265  * Lazy project create flag.
 266  */
 267         bool lazy_project_create;
 268 /**
 269  * Subtitles.
 270  */
 271         std::map<moviefile_subtiming, std::string> subtitles;
 272 /**
 273  * Dynamic state.
 274  */
 275         dynamic_state dyn;
 276 /**
 277  * Get number of frames in movie.
 278  *
 279  * returns: Number of frames.
 280  */
 281         uint64_t get_frame_count() throw();
 282 /**
 283  * Get length of the movie
 284  *
 285  * returns: Length of the movie in milliseconds.
 286  */
 287         uint64_t get_movie_length() throw();
 288 /**
 289  * Return reference to memory slot.
 290  */
 291         static moviefile*& memref(const std::string& slot);
 292
 293 /**
 294  * Copy data.
 295  */
 296         void copy_fields(const moviefile& mv);
 297
 298 /**
 299  * Create a default branch.
 300  */
 301         void create_default_branch(portctrl::type_set& ports);
 302 /**
 303  * Get name of current branch.
 304  */
 305         const std::string& current_branch();
 306 /**
 307  * Fork a branch.
 308  */
 309         void fork_branch(const std::string& oldname, const std::string& newname);
 310 /**
 311  * Fixup input pointer post-copy.
 312  */
 313         void fixup_current_branch(const moviefile& mv);
 314 /**
 315  * Clear the dynamic state to power-on defaults.
 316  */
 317         void clear_dynstate();
 318 private:
 319         moviefile(const moviefile&);
 320         moviefile& operator=(const moviefile&);
 321         void binary_io(int stream, rrdata_set& rrd, bool as_state) throw(std::bad_alloc, std::runtime_error);
 322         void binary_io(int stream, struct core_type& romtype) throw(std::bad_alloc, std::runtime_error);
 323         void save(zip::writer& w, rrdata_set& rrd, bool as_state) throw(std::bad_alloc, std::runtime_error);
 324         void load(zip::reader& r, core_type& romtype) throw(std::bad_alloc, std::runtime_error);
 325         memtracker::autorelease tracker;
 326 };
 327
 328 void emerg_save_movie(const moviefile& mv, rrdata_set& rrd);
 329
 330 #endif