include/core/advdumper.hpp

   1 #ifndef _advdumper__hpp__included__
   2 #define _advdumper__hpp__included__
   3
   4 #include <string>
   5 #include <set>
   6 #include <stdexcept>
   7 #include <iostream>
   8
   9 #include "library/framebuffer.hpp"
  10 #include "library/dispatch.hpp"
  11 #include "library/threads.hpp"
  12
  13 class master_dumper;
  14 class dumper_factory_base;
  15 class dumper_base;
  16 class lua_state;
  17
  18 class dumper_factory_base
  19 {
  20 public:
  21 /**
  22  * Notifier base.
  23  */
  24         class notifier
  25         {
  26         public:
  27                 virtual ~notifier() throw();
  28                 virtual void dumpers_updated() throw() = 0;
  29         };
  30 /**
  31  * Detail flags.
  32  */
  33         static const unsigned target_type_mask;
  34         static const unsigned target_type_file;
  35         static const unsigned target_type_prefix;
  36         static const unsigned target_type_special;
  37 /**
  38  * Register a dumper.
  39  *
  40  * Parameter id: The ID of dumper.
  41  * Throws std::bad_alloc: Not enough memory.
  42  */
  43         dumper_factory_base(const std::string& id) throw(std::bad_alloc);
  44 /**
  45  * Unregister a dumper.
  46  */
  47         ~dumper_factory_base();
  48 /**
  49  * Get ID of dumper.
  50  *
  51  * Returns: The id.
  52  */
  53         const std::string& id() throw();
  54 /**
  55  * Get set of all dumpers.
  56  *
  57  * Returns: The set.
  58  * Throws std::bad_alloc: Not enough memory.
  59  */
  60         static std::set<dumper_factory_base*> get_dumper_set() throw(std::bad_alloc);
  61 /**
  62  * List all valid submodes.
  63  *
  64  * Returns: List of all valid submodes. Empty list means this dumper has no submodes.
  65  * Throws std::bad_alloc: Not enough memory.
  66  */
  67         virtual std::set<std::string> list_submodes() throw(std::bad_alloc) = 0;
  68 /**
  69  * Get mode details
  70  *
  71  * parameter mode: The submode.
  72  * Returns: Mode details flags
  73  */
  74         virtual unsigned mode_details(const std::string& mode) throw() = 0;
  75 /**
  76  * Get mode extensions. Only called if mode details specifies that output is a single file.
  77  *
  78  * parameter mode: The submode.
  79  * Returns: Mode extension
  80  */
  81         virtual std::string mode_extension(const std::string& mode) throw() = 0;
  82 /**
  83  * Get human-readable name for this dumper.
  84  *
  85  * Returns: The name.
  86  * Throws std::bad_alloc: Not enough memory.
  87  */
  88         virtual std::string name() throw(std::bad_alloc) = 0;
  89 /**
  90  * Get human-readable name for submode.
  91  *
  92  * Parameter mode: The submode.
  93  * Returns: The name.
  94  * Throws std::bad_alloc: Not enough memory.
  95  */
  96         virtual std::string modename(const std::string& mode) throw(std::bad_alloc) = 0;
  97 /**
  98  * Start dump.
  99  *
 100  * parameter mode: The mode to dump using.
 101  * parameter targetname: The target filename or prefix.
 102  * returns: The dumper object.
 103  * Throws std::bad_alloc: Not enough memory.
 104  * Throws std::runtime_error: Can't start dump.
 105  */
 106         virtual dumper_base* start(master_dumper& _mdumper, const std::string& mode, const std::string& targetname)
 107                 throw(std::bad_alloc, std::runtime_error) = 0;
 108 /**
 109  * Is hidden?
 110  */
 111         virtual bool hidden() const { return false; }
 112 /**
 113  * Add dumper update notifier object.
 114  */
 115         static void add_notifier(notifier& n);
 116 /**
 117  * Remove dumper update notifier object.
 118  */
 119         static void drop_notifier(notifier& n);
 120 /**
 121  * Notify ctor finished.
 122  */
 123         void ctor_notify();
 124 /**
 125  * Notify dumper change.
 126  */
 127         static void run_notify();
 128 private:
 129         std::string d_id;
 130 };
 131
 132 class master_dumper
 133 {
 134 public:
 135 /**
 136  * Information about run.
 137  */
 138         struct gameinfo
 139         {
 140         public:
 141 /**
 142  * Construct game info.
 143  */
 144                 gameinfo() throw(std::bad_alloc);
 145 /**
 146  * Game name.
 147  */
 148                 std::string gamename;
 149 /**
 150  * Run length in seconds.
 151  */
 152                 double length;
 153 /**
 154  * Rerecord count (base 10 ASCII)
 155  */
 156                 std::string rerecords;
 157 /**
 158  * Authors. The first components are real names, the second components are nicknames. Either (but not both) may be
 159  * blank.
 160  */
 161                 std::vector<std::pair<std::string, std::string>> authors;
 162 /**
 163  * Format human-redable representation of the length.
 164  *
 165  * Parameter digits: Number of sub-second digits to use.
 166  * Returns: The time formated.
 167  * Throws std::bad_alloc: Not enough memory.
 168  */
 169                 std::string get_readable_time(unsigned digits) const throw(std::bad_alloc);
 170 /**
 171  * Get number of authors.
 172  *
 173  * Returns: Number of authors.
 174  */
 175                 size_t get_author_count() const throw();
 176 /**
 177  * Get short name of author (nickname if present, otherwise full name).
 178  *
 179  * Parameter idx: Index of author (0-based).
 180  * Returns: The short name.
 181  * Throws std::bad_alloc: Not enough memory.
 182  */
 183                 std::string get_author_short(size_t idx) const throw(std::bad_alloc);
 184 /**
 185  * Get long name of author (full name and nickname if present).
 186  *
 187  * Parameter idx: Index of author (0-based).
 188  * Returns: The long name.
 189  * Throws std::bad_alloc: Not enough memory.
 190  */
 191                 std::string get_author_long(size_t idx) const throw(std::bad_alloc);
 192 /**
 193  * Get rerecord count as a number. If rerecord count is too high, returns the maximum representatible count.
 194  *
 195  * Returns: The rerecord count.
 196  */
 197                 uint64_t get_rerecords() const throw();
 198         };
 199 /**
 200  * Notifier.
 201  */
 202         class notifier
 203         {
 204         public:
 205                 virtual ~notifier() throw();
 206                 virtual void dump_status_change() = 0;
 207         };
 208 /**
 209  * Ctor.
 210  */
 211         master_dumper(lua_state& _lua2);
 212 /**
 213  * Get instance for specified dumper.
 214  */
 215         dumper_base* get_instance(dumper_factory_base* dumper) throw();
 216 /**
 217  * Is dumper busy in this instance?
 218  */
 219         bool busy(dumper_factory_base* dumper) throw()
 220         {
 221                 return get_instance(dumper) != NULL;
 222         }
 223 /**
 224  * Call start on dumper.
 225  */
 226         dumper_base* start(dumper_factory_base& factory, const std::string& mode, const std::string& targetname)
 227                 throw(std::bad_alloc, std::runtime_error);
 228 /**
 229  * Add dumper update notifier object.
 230  */
 231         void add_notifier(notifier& n);
 232 /**
 233  * Remove dumper update notifier object.
 234  */
 235         void drop_notifier(notifier& n);
 236 /**
 237  * Add dumper update notifier object.
 238  */
 239         void add_dumper(dumper_base& n);
 240 /**
 241  * Remove dumper update notifier object.
 242  */
 243         void drop_dumper(dumper_base& n);
 244 /**
 245  * Get number of active dumpers.
 246  */
 247         unsigned get_dumper_count() throw();
 248 /**
 249  * Call all notifiers (on_frame).
 250  */
 251         void on_frame(struct framebuffer::raw& _frame, uint32_t fps_n, uint32_t fps_d);
 252 /**
 253  * Call all notifiers (on_sample).
 254  */
 255         void on_sample(short l, short r);
 256 /**
 257  * Call all notifiers (on_rate_change)
 258  *
 259  * Also changes builtin rate variables.
 260  */
 261         void on_rate_change(uint32_t n, uint32_t d);
 262 /**
 263  * Call all notifiers (on_gameinfo_change)
 264  *
 265  * Also changes builtin gameinfo structure.
 266  */
 267         void on_gameinfo_change(const gameinfo& gi);
 268 /**
 269  * Get current sound rate in effect.
 270  */
 271         std::pair<uint32_t, uint32_t> get_rate();
 272 /**
 273  * Get current gameinfo in effect.
 274  */
 275         const gameinfo& get_gameinfo();
 276 /**
 277  * End all dumps.
 278  */
 279         void end_dumps();
 280 /**
 281  * Set output stream.
 282  */
 283         void set_output(std::ostream* _output);
 284 /**
 285  * Render Lua HUD on video.
 286  *
 287  * Parameter target: The target screen to render on.
 288  * Parameter source: The source screen to read.
 289  * Parameter hscl: The horizontal scale factor.
 290  * Parameter vscl: The vertical scale factor.
 291  * Parameter lgap: Left gap.
 292  * Parameter tgap: Top gap.
 293  * Parameter rgap: Right gap
 294  * Parameter bgap: Bottom gap.
 295  * Parameter fn: Function to call between running lua hooks and actually rendering.
 296  * Returns: True if frame should be dumped, false if not.
 297  */
 298         template<bool X> bool render_video_hud(struct framebuffer::fb<X>& target, struct framebuffer::raw& source,
 299                 uint32_t hscl, uint32_t vscl, uint32_t lgap, uint32_t tgap, uint32_t rgap, uint32_t bgap,
 300                 std::function<void()> fn);
 301 /**
 302  * Calculate number of sound samples to drop due to dropped frame.
 303  */
 304         uint64_t killed_audio_length(uint32_t fps_n, uint32_t fps_d, double& fraction);
 305 private:
 306         void statuschange();
 307         friend class dumper_base;
 308         std::map<dumper_factory_base*, dumper_base*> dumpers;
 309         std::set<notifier*> notifications;
 310         std::set<dumper_base*> sdumpers;
 311         uint32_t current_rate_n;
 312         uint32_t current_rate_d;
 313         gameinfo current_gi;
 314         std::ostream* output;
 315         threads::rlock lock;
 316         lua_state& lua2;
 317 };
 318
 319 class dumper_base
 320 {
 321 public:
 322         dumper_base();
 323         dumper_base(master_dumper& _mdumper, dumper_factory_base& _fbase);
 324         virtual ~dumper_base() throw();
 325 /**
 326  * New frame available.
 327  */
 328         virtual void on_frame(struct framebuffer::raw& _frame, uint32_t fps_n, uint32_t fps_d) = 0;
 329 /**
 330  * New sample available.
 331  */
 332         virtual void on_sample(short l, short r) = 0;
 333 /**
 334  * Sample rate is changing.
 335  */
 336         virtual void on_rate_change(uint32_t n, uint32_t d) = 0;
 337 /**
 338  * Gameinfo is changing.
 339  */
 340         virtual void on_gameinfo_change(const master_dumper::gameinfo& gi) = 0;
 341 /**
 342  * Dump is being forcibly ended.
 343  */
 344         virtual void on_end() = 0;
 345 /**
 346  * Render Lua HUD on video. samples_killed is incremented if needed.
 347  *
 348  * Parameter target: The target screen to render on.
 349  * Parameter source: The source screen to read.
 350  * Parameter fps_n: Fps numerator.
 351  * Parameter fps_d: Fps denominator.
 352  * Parameter hscl: The horizontal scale factor.
 353  * Parameter vscl: The vertical scale factor.
 354  * Parameter lgap: Left gap.
 355  * Parameter tgap: Top gap.
 356  * Parameter rgap: Right gap
 357  * Parameter bgap: Bottom gap.
 358  * Parameter fn: Function to call between running lua hooks and actually rendering.
 359  * Returns: True if frame should be dumped, false if not.
 360  */
 361         template<bool X> bool render_video_hud(struct framebuffer::fb<X>& target, struct framebuffer::raw& source,
 362                 uint32_t fps_n, uint32_t fps_d, uint32_t hscl, uint32_t vscl, uint32_t lgap, uint32_t tgap,
 363                 uint32_t rgap, uint32_t bgap, std::function<void()> fn)
 364         {
 365                 bool r = mdumper->render_video_hud(target, source, hscl, vscl, lgap, tgap, rgap, bgap, fn);
 366                 if(!r)
 367                         samples_killed += mdumper->killed_audio_length(fps_n, fps_d, akillfrac);
 368                 return r;
 369         }
 370 private:
 371         friend class master_dumper;
 372         uint64_t samples_killed;
 373         master_dumper* mdumper;
 374         dumper_factory_base* fbase;
 375         double akillfrac;
 376 };
 377
 378 #endif