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