avsnoop.hpp

   1 #ifndef _avsnoop__hpp__included__
   2 #define _avsnoop__hpp__included__
   3
   4 #include "render.hpp"
   5 #include <list>
   6 #include <string>
   7 #include <stdexcept>
   8 #include "window.hpp"
   9
  10 /**
  11  * A/V snooper.
  12  */
  13 class av_snooper
  14 {
  15 public:
  16 /**
  17  * Create new A/V snooper.
  18  *
  19  * throws std::bad_alloc: Not enough memory.
  20  */
  21         av_snooper() throw(std::bad_alloc);
  22
  23 /**
  24  * Destroy A/V snooper. This will not call end method.
  25  */
  26         ~av_snooper() throw();
  27
  28 /**
  29  * Dump a frame.
  30  *
  31  * parameter _frame: The frame to dump.
  32  * parameter fps_n: Current fps numerator.
  33  * parameter fps_d: Current fps denomerator.
  34  * throws std::bad_alloc: Not enough memory.
  35  * throws std::runtime_error: Error dumping frame.
  36  */
  37         virtual void frame(struct lcscreen& _frame, uint32_t fps_n, uint32_t fps_d, window* win, bool dummy)
  38                 throw(std::bad_alloc, std::runtime_error) = 0;
  39
  40 /**
  41  * Dump a frame.
  42  *
  43  * parameter _frame: The frame to dump.
  44  * parameter fps_n: Current fps numerator.
  45  * parameter fps_d: Current fps denomerator.
  46  * parameter win: Graphics system handle.
  47  */
  48         static void frame(struct lcscreen& _frame, uint32_t fps_n, uint32_t fps_d, window* win) throw();
  49
  50 /**
  51  * Dump a sample.
  52  *
  53  * parameter l: Left channel sample.
  54  * parameter r: Right channel sample.
  55  * throws std::bad_alloc: Not enough memory.
  56  * throws std::runtime_error: Error dumping sample.
  57  */
  58         virtual void sample(short l, short r) throw(std::bad_alloc, std::runtime_error) = 0;
  59
  60 /**
  61  * Dump a sample.
  62  *
  63  * parameter l: Left channel sample.
  64  * parameter r: Right channel sample.
  65  * parameter win: Graphics system handle.
  66  */
  67         static void sample(short l, short r, window* win) throw();
  68
  69 /**
  70  * End dump.
  71  *
  72  * throws std::bad_alloc: Not enough memory.
  73  * throws std::runtime_error: Error dumping sample.
  74  */
  75         virtual void end() throw(std::bad_alloc, std::runtime_error) = 0;
  76
  77 /**
  78  * End dump.
  79  *
  80  * parameter win: Graphics system handle.
  81  */
  82         static void end(window* win) throw();
  83
  84 /**
  85  * Notify game information.
  86  *
  87  * parameter gamename: Name of the game.
  88  * parameter authors: Authors of the run.
  89  * parameter gametime: Game time.
  90  * parameter rercords: Rerecord count.
  91  * throws std::bad_alloc: Not enough memory.
  92  * throws std::runtime_error: Error recording this info.
  93  */
  94         virtual void gameinfo(const std::string& gamename, const std::list<std::pair<std::string, std::string>>&
  95                 authors, double gametime, const std::string& rerecords) throw(std::bad_alloc, std::runtime_error) = 0;
  96
  97 /**
  98  * Notify game information.
  99  *
 100  * parameter gamename: Name of the game.
 101  * parameter authors: Authors of the run.
 102  * parameter gametime: Game time.
 103  * parameter rercords: Rerecord count.
 104  * parameter win: Graphics system handle.
 105  * throws std::bad_alloc Not enough memory.
 106  */
 107         static void gameinfo(const std::string& gamename, const std::list<std::pair<std::string, std::string>>&
 108                 authors, double gametime, const std::string& rerecords, window* win) throw(std::bad_alloc);
 109
 110 /**
 111  * Send game info. This causes gameinfo method to be called on object this method is called on.
 112  */
 113         void send_gameinfo() throw();
 114
 115 /**
 116  * Is there dump in progress?
 117  *
 118  * returns: True if dump is in progress, false if not.
 119  */
 120         static bool dump_in_progress() throw();
 121
 122 /**
 123  * Notifier for dumps starting/ending.
 124  */
 125         class dump_notification
 126         {
 127         public:
 128 /**
 129  * Destructor.
 130  */
 131                 virtual ~dump_notification() throw();
 132 /**
 133  * New dump starting.
 134  */
 135                 virtual void dump_starting() throw();
 136 /**
 137  * Dump ending.
 138  */
 139                 virtual void dump_ending() throw();
 140         };
 141
 142 /**
 143  * Add a notifier.
 144  *
 145  * parameter notifier: New notifier to add.
 146  */
 147         static void add_dump_notifier(dump_notification& notifier) throw(std::bad_alloc);
 148
 149 /**
 150  * Remove a notifier.
 151  *
 152  * parameter notifier: Existing notifier to remove.
 153  */
 154         static void remove_dump_notifier(dump_notification& notifier) throw();
 155 };
 156
 157 #endif