movie.hpp

   1 #ifndef _movie__hpp__included__
   2 #define _movie__hpp__included__
   3
   4 #include <string>
   5 #include <cstdint>
   6 #include <stdexcept>
   7 #include "controllerdata.hpp"
   8
   9 /**
  10  * \brief Movie being played back or recorded
  11  */
  12 class movie
  13 {
  14 public:
  15 /**
  16  * \brief Construct new empty movie.
  17  * \throws std::bad_alloc Not enough memory.
  18  */
  19         movie() throw(std::bad_alloc);
  20
  21 /**
  22  * \brief Is the movie in readonly mode?
  23  *
  24  * \return True if in read-only mode, false if in read-write mode.
  25  */
  26         bool readonly_mode() throw();
  27
  28 /**
  29  * \brief Switch between modes
  30  *
  31  * Switches movie to read-only or read-write mode. If switching to read-write mode, the movie is truncated.
  32  *
  33  * \param enable If true, switch to read-only mode, else to read-write mode.
  34  * \throws std::bad_alloc Not enough memory.
  35  */
  36         void readonly_mode(bool enable) throw(std::bad_alloc);
  37
  38 /**
  39  * \brief Get movie rerecord count
  40  *
  41  * Returns the movie rerecord count (this is not the same thing as global rerecord count).
  42  *
  43  * \return The movie rerecord count
  44  * \throws std::bad_alloc Not enough memory.
  45  */
  46         std::string rerecord_count() throw(std::bad_alloc);
  47
  48 /**
  49  * \brief Set movie rerecord count
  50  *
  51  * Sets the movie rerecord count (this is not the same thing as global rerecord count).
  52  *
  53  * \param count The new rerecord count
  54  * \throws std::bad_alloc Not enough memory.
  55  */
  56         void rerecord_count(const std::string& count) throw(std::bad_alloc);
  57
  58 /**
  59  * \brief Read project ID
  60  * \return The project ID
  61  * \throws std::bad_alloc Not enough memory.
  62  */
  63         std::string project_id() throw(std::bad_alloc);
  64
  65 /**
  66  * \brief Set project ID
  67  * \param id New project ID.
  68  * \throws std::bad_alloc Not enough memory.
  69  */
  70         void project_id(const std::string& id) throw(std::bad_alloc);
  71
  72 /**
  73  * \brief Get number of frames in movie
  74  * \return The number of frames.
  75  */
  76         uint64_t get_frame_count() throw();
  77
  78 /**
  79  * \brief Get number of currnet frame in movie
  80  *
  81  * The first frame in movie is 1. 0 is "before first frame" value.
  82  *
  83  * \return The number of frame
  84  */
  85         uint64_t get_current_frame() throw();
  86
  87 /**
  88  * \brief Get number of lag frames so far
  89  * \return The number of lag frames.
  90  */
  91         uint64_t get_lag_frames() throw();
  92
  93 /**
  94  * \brief Advance to next frame.
  95  *
  96  * This function advances to next frame in movie, discarding subframes not used. If the frame is lag frame, it is
  97  * counted as lag frame and subframe entry for it is made (if in readwrite mode).
  98  *
  99  * \throw std::bad_alloc Not enough memory.
 100  */
 101         void next_frame() throw(std::bad_alloc);
 102
 103 /**
 104  * \brief Get data ready flag for control index
 105  *
 106  * Reads the data ready flag. On new frame, all data ready flags are unset. On reading control, its data ready
 107  * flag is unset.
 108  *
 109  * \param controlindex The index of control to read it for.
 110  * \return The read value.
 111  * \throws std::logic_error Invalid control index.
 112  */
 113         bool get_DRDY(unsigned controlindex) throw(std::logic_error);
 114
 115 /**
 116  * \brief Get data ready flag for given (port,controller,index) index
 117  *
 118  * Reads the data ready flag. On new frame, all data ready flags are unset. On reading control, its data ready
 119  * flag is unset.
 120  *
 121  * This differs from get_DRDY(unsigned) in that this takes (port, controller,index) tuple.
 122  *
 123  * \param port The port controller is connected to (0 or 1)
 124  * \param controller The controller number within port (0 to 3)
 125  * \param index The index of control in controller (0 to 11)
 126  * \return The read value.
 127  * \throws std::logic_error Invalid control index.
 128  */
 129         bool get_DRDY(unsigned port, unsigned controller, unsigned index) throw(std::logic_error);
 130
 131 /**
 132  * \brief Set all data ready flags
 133  */
 134         void set_all_DRDY() throw();
 135
 136 /**
 137  * \brief Poll next value for given control index
 138  *
 139  * Poll a control. Note that index 0 (sync flag) always reads as released.
 140  *
 141  * \param controlindex The index
 142  * \return The read value
 143  * \throws std::bad_alloc Not enough memory.
 144  * \throws std::logic_error Invalid control index or before movie start.
 145  */
 146         short next_input(unsigned controlindex) throw(std::bad_alloc, std::logic_error);
 147
 148 /**
 149  * \brief Poll next value for given (port, controller, index) index
 150  *
 151  * Poll a control.
 152  *
 153  * \param port The port controller is connected to (0 or 1)
 154  * \param controller The controller number within port (0 to 3)
 155  * \param index The index of control in controller (0 to 11)
 156  * \return The read value
 157  * \throws std::bad_alloc Not enough memory.
 158  * \throws std::logic_error Invalid port, controller or index or before movie start.
 159  */
 160         short next_input(unsigned port, unsigned controller, unsigned index) throw(std::bad_alloc, std::logic_error);
 161
 162 /**
 163  * \brief Set values of current controls
 164  *
 165  * Set current control values. These are read in readwrite mode.
 166  *
 167  * \param controls The new controls.
 168  */
 169         void set_controls(controls_t controls) throw();
 170
 171 /**
 172  * \brief Get values of current controls
 173  *
 174  * Get current control values in effect.
 175  *
 176  * \return Controls
 177  */
 178         controls_t get_controls() throw();
 179
 180 /**
 181  * \brief Load a movie.
 182  *
 183  * Loads a movie plus some other parameters. The playback pointer is positioned to start of movie and readonly
 184  * mode is enabled.
 185  *
 186  * \param rerecs Movie rerecord count.
 187  * \param project_id Project ID of movie.
 188  * \param input The input track.
 189  * \throws std::bad_alloc Not enough memory.
 190  * \throws std::runtime_error Bad movie data.
 191  */
 192         void load(const std::string& rerecs, const std::string& project_id, const std::vector<controls_t>& input)
 193                 throw(std::bad_alloc, std::runtime_error);
 194
 195 /**
 196  * \brief Save a movie.
 197  *
 198  * Saves the movie data.
 199  *
 200  * \return The movie data.
 201  * \throws std::bad_alloc Not enough memory.
 202  */
 203         std::vector<controls_t> save() throw(std::bad_alloc);
 204
 205 /**
 206  * \brief Save the state of movie code
 207  *
 208  * This method serializes the state of movie code.
 209  *
 210  * \return The serialized state.
 211  * \throws std::bad_alloc Not enough memory.
 212  */
 213         std::vector<uint8_t> save_state() throw(std::bad_alloc);
 214
 215 /**
 216  * \brief Restore the state of movie code
 217  *
 218  * Given previous serialized state from this movie, restore the state.
 219  *
 220  * \param state The state to restore.
 221  * \param ro If true, restore in readonly mode, otherwise in readwrite mode.
 222  * \throw std::bad_alloc Not enough memory.
 223  * \throw std::runtime_error State is not from this movie or states is corrupt.
 224  */
 225         size_t restore_state(const std::vector<uint8_t>& state, bool ro) throw(std::bad_alloc, std::runtime_error);
 226
 227 /**
 228  * \brief Get reset status for current frame.
 229  *
 230  * \return -1 if current frame doesn't have a reset. Otherwise number of cycles to wait for delayed reset (0 is
 231  *      immediate reset).
 232  */
 233         long get_reset_status() throw();
 234
 235 /**
 236  * \brief Commit a reset.
 237  */
 238         void commit_reset(long delay) throw(std::bad_alloc);
 239
 240 /**
 241  * \brief Get how manyth poll in the frame next poll would be.
 242  *
 243  * \return Poll number.
 244  */
 245         unsigned next_poll_number();
 246
 247         uint64_t frame_subframes(uint64_t frame);
 248         controls_t read_subframe(uint64_t frame, uint64_t subframe);
 249 private:
 250         //TRUE if readonly mode is active.
 251         bool readonly;
 252         //Movie (not global!) rerecord count.
 253         std::string rerecords;
 254         //Project ID.
 255         std::string _project_id;
 256         //The actual controller data.
 257         std::vector<controls_t> movie_data;
 258         //Current frame + 1 (0 before next_frame() has been called.
 259         uint64_t current_frame;
 260         //First subframe in current frame (movie_data.size() if no subframes have been stored).
 261         uint64_t current_frame_first_subframe;
 262         //How many times has each control been polled (bit 31 is data ready bit)?
 263         uint32_t pollcounters[TOTAL_CONTROLS];
 264         //Current state of buttons.
 265         controls_t current_controls;
 266         //Number of known lag frames.
 267         uint64_t lag_frames;
 268         //Number of frames in movie.
 269         uint64_t frames_in_movie;
 270         //Cached subframes.
 271         void clear_caches();
 272         uint64_t cached_frame;
 273         uint64_t cached_subframe;
 274         //Count present subframes in frame starting from first_subframe (returns 0 if out of movie).
 275         uint32_t count_changes(uint64_t first_subframe);
 276 };
 277
 278 /**
 279  * \brief Class encapsulating bridge logic between bsnes interface and movie code.
 280  */
 281 class movie_logic
 282 {
 283 public:
 284 /**
 285  * \brief Create new bridge.
 286  *
 287  * \param m The movie to manipulate.
 288  */
 289         movie_logic(movie& m) throw();
 290
 291 /**
 292  * \brief Destructor.
 293  */
 294         virtual ~movie_logic() throw();
 295
 296 /**
 297  * \brief Get the movie instance associated.
 298  */
 299         movie& get_movie() throw();
 300
 301 /**
 302  * \brief Notify about new frame starting.
 303  *
 304  * \return Reset status for the new frame.
 305  */
 306         long new_frame_starting(bool dont_poll) throw(std::bad_alloc, std::runtime_error);
 307
 308 /**
 309  * \brief Poll for input.
 310  *
 311  * \return Value for polled input.
 312  */
 313         short input_poll(bool port, unsigned dev, unsigned id) throw(std::bad_alloc, std::runtime_error);
 314
 315 /**
 316  * \brief Called when movie code needs new controls snapshot.
 317  *
 318  * \param subframe True if this is for subframe update, false if for frame update.
 319  */
 320         virtual controls_t update_controls(bool subframe) throw(std::bad_alloc, std::runtime_error) = 0;
 321 private:
 322         movie& mov;
 323 };
 324
 325
 326 /**
 327  * \brief Global rerecord count.
 328  */
 329 extern std::string global_rerecord_count;
 330
 331 #endif