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
  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 /**
  66  * Force loading as corrupt.
  67  */
  68         bool force_corrupt;
  69 /**
  70  * What is the ROM type and region?
  71  */
  72         core_sysregion* gametype;
  73 /**
  74  * Settings.
  75  */
  76         std::map<std::string, std::string> settings;
  77 /**
  78  * Emulator Core version string.
  79  */
  80         std::string coreversion;
  81 /**
  82  * Name of the game
  83  */
  84         std::string gamename;
  85 /**
  86  * Project ID (used to identify if two movies are from the same project).
  87  */
  88         std::string projectid;
  89 /**
  90  * Rerecord count (only saved).
  91  */
  92         std::string rerecords;
  93 /**
  94  * Rerecord count (memory saves only).
  95  */
  96         uint64_t rerecords_mem;
  97 /**
  98  * SHA-256 of ROM (empty string if none).
  99  */
 100         std::string romimg_sha256[ROM_SLOT_COUNT];
 101 /**
 102  * SHA-256 of ROM XML (empty string if none).
 103  */
 104         std::string romxml_sha256[ROM_SLOT_COUNT];
 105 /**
 106  * ROM name hint (empty string if none).
 107  */
 108         std::string namehint[ROM_SLOT_COUNT];
 109 /**
 110  * Authors of the run, first in each pair is full name, second is nickname.
 111  */
 112         std::vector<std::pair<std::string, std::string>> authors;
 113 /**
 114  * Contents of SRAM on time of initial powerup.
 115  */
 116         std::map<std::string, std::vector<char>> movie_sram;
 117 /**
 118  * Contents of RAM on time of initial powerup.
 119  */
 120         std::map<std::string, std::vector<char>> ramcontent;
 121 /**
 122  * True if savestate, false if movie.
 123  */
 124         bool is_savestate;
 125 /**
 126  * Contents of SRAM on time of savestate (if is_savestate is true).
 127  */
 128         std::map<std::string, std::vector<char>> sram;
 129 /**
 130  * Core savestate (if is_savestate is true).
 131  */
 132         std::vector<char> savestate;            //Savestate to load (if is_savestate is true).
 133 /**
 134  * Anchoring core savestate (if not empty).
 135  */
 136         std::vector<char> anchor_savestate;
 137 /**
 138  * Host memory (if is_savestate is true).
 139  */
 140         std::vector<char> host_memory;
 141 /**
 142  * Screenshot (if is_savestate is true).
 143  */
 144         std::vector<char> screenshot;
 145 /**
 146  * Current frame (if is_savestate is true).
 147  */
 148         uint64_t save_frame;
 149 /**
 150  * Number of lagged frames (if is_savestate is true).
 151  */
 152         uint64_t lagged_frames;
 153 /**
 154  * Poll counters (if is_savestate is true).
 155  */
 156         std::vector<uint32_t> pollcounters;
 157 /**
 158  * Poll flag.
 159  */
 160         unsigned poll_flag;
 161 /**
 162  * Compressed rrdata.
 163  */
 164         std::vector<char> c_rrdata;
 165 /**
 166  * Input for each (sub)frame.
 167  */
 168         controller_frame_vector input;          //Input for each frame.
 169 /**
 170  * Current RTC second.
 171  */
 172         int64_t rtc_second;
 173 /**
 174  * Current RTC subsecond.
 175  */
 176         int64_t rtc_subsecond;
 177 /**
 178  * Movie starting RTC second.
 179  */
 180         int64_t movie_rtc_second;
 181 /**
 182  * Movie starting RTC subsecond.
 183  */
 184         int64_t movie_rtc_subsecond;
 185 /**
 186  * Start paused flag.
 187  */
 188         bool start_paused;
 189 /**
 190  * Lazy project create flag.
 191  */
 192         bool lazy_project_create;
 193 /**
 194  * Subtitles.
 195  */
 196         std::map<moviefile_subtiming, std::string> subtitles;
 197 /**
 198  * Active macros at savestate.
 199  */
 200         std::map<std::string, uint64_t> active_macros;
 201 /**
 202  * Get number of frames in movie.
 203  *
 204  * returns: Number of frames.
 205  */
 206         uint64_t get_frame_count() throw();
 207 /**
 208  * Get length of the movie
 209  *
 210  * returns: Length of the movie in nanoseconds.
 211  */
 212         uint64_t get_movie_length() throw();
 213 private:
 214         void binary_io(std::ostream& stream) throw(std::bad_alloc, std::runtime_error);
 215         void binary_io(std::istream& stream, struct core_type& romtype) throw(std::bad_alloc, std::runtime_error);
 216 };
 217
 218 #endif