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