avidump/avidump.hpp

   1 #ifndef _avidump__hpp__included__
   2 #define _avidump__hpp__included__
   3
   4 #include <cstdint>
   5 #include <iostream>
   6 #include <fstream>
   7 #include <vector>
   8 #include <list>
   9 #include <stdexcept>
  10
  11
  12 #ifndef NO_THREADS
  13 #include <thread>
  14 #include <condition_variable>
  15 #include <mutex>
  16
  17 /**
  18  * Class of thread.
  19  */
  20 typedef std::thread thread_class;
  21
  22 /**
  23  * Class of condition variables.
  24  */
  25 typedef std::condition_variable cv_class;
  26
  27 /**
  28  * Class of mutexes.
  29  */
  30 typedef std::mutex mutex_class;
  31
  32 /**
  33  * Class of unique mutexes (for condition variable waiting).
  34  */
  35 typedef std::unique_lock<std::mutex> umutex_class;
  36
  37 #else
  38
  39 /**
  40  * Class of thread.
  41  */
  42 struct thread_class
  43 {
  44 /**
  45  * Does nothing.
  46  */
  47         template<typename T, typename... args>
  48         thread_class(T obj, args... a) {}
  49 /**
  50  * Does nothing.
  51  */
  52         void join() {}
  53 };
  54
  55 /**
  56  * Class of mutexes.
  57  */
  58 typedef struct mutex_class
  59 {
  60 /**
  61  * Does nothing.
  62  */
  63         void lock() {}
  64 /**
  65  * Does nothing.
  66  */
  67         void unlock() {}
  68 } umutex_class;
  69
  70 /**
  71  * Class of condition variables.
  72  */
  73 struct cv_class
  74 {
  75 /**
  76  * Does nothing.
  77  */
  78         void wait(umutex_class& m) {}
  79 /**
  80  * Does nothing.
  81  */
  82         void notify_all() {}
  83 };
  84
  85 #endif
  86
  87 /**
  88  * Size of audio buffer (enough to buffer 3 frames).
  89  */
  90 #define AVIDUMPER_AUDIO_BUFFER 4096
  91
  92 /**
  93  * Information about frame in AVI.
  94  */
  95 struct avi_frame
  96 {
  97 /**
  98  * Constructor.
  99  *
 100  * parameter _flags: Flags for frame.
 101  * parameter _type: AVI type for frame (big-endian!).
 102  * parameter _offset: Offset of frame from start of MOVI.
 103  * parameter _size: Size of frame data.
 104  */
 105         avi_frame(uint32_t _flags, uint32_t _type, uint32_t _offset, uint32_t _size);
 106
 107 /**
 108  * Write the index entry for frame.
 109  *
 110  * parameter buf: Buffer to write to.
 111  */
 112         void write(uint8_t* buf);
 113
 114 /**
 115  * Flags.
 116  */
 117         uint32_t flags;
 118
 119 /**
 120  * Chunk type.
 121  */
 122         uint32_t type;
 123
 124 /**
 125  * Chunk offset.
 126  */
 127         uint32_t offset;
 128
 129 /**
 130  * Chunk size.
 131  */
 132         uint32_t size;
 133 };
 134
 135 /**
 136  * Parameters for AVI dumping.
 137  */
 138 struct avi_info
 139 {
 140 /**
 141  * Zlib compression level (0-9).
 142  */
 143         unsigned compression_level;
 144
 145 /**
 146  * Audio sampling rate to write to AVI.
 147  */
 148         uint32_t audio_sampling_rate;
 149
 150 /**
 151  * Interval of keyframes (WARNING: >1 gives non-keyframes which AVISource() doesn't like).
 152  */
 153         uint32_t keyframe_interval;
 154 /**
 155  * Maximum number of frames per segement (0 => infinite)
 156  */
 157         uint32_t max_frames_per_segment;
 158 };
 159
 160 /**
 161  * The actual AVI dumper.
 162  */
 163 class avidumper
 164 {
 165 public:
 166         avidumper(const std::string& _prefix, struct avi_info parameters);
 167         ~avidumper() throw();
 168
 169 /**
 170  * Waits for the encode thread. Not needed: Operations that need to synchronize synchronize themselves.
 171  */
 172         void wait_idle() throw();
 173
 174 /**
 175  * Dump a frame (new segment starts if needed). Pixel byte order is BGRx.
 176  *
 177  * parameter data: The frame data.
 178  * parameter width: Width of frame.
 179  * parameter height: Height of frame.
 180  * parameter fps_n: Numerator of fps value.
 181  * parameter fps_d: Denomerator of fps value.
 182  * throws std::bad_alloc: Not enough memory.
 183  * throws std::runtime_error: Error dumping frame.
 184  */
 185         void on_frame(const uint32_t* data, uint16_t width, uint16_t height, uint32_t fps_n, uint32_t fps_d)
 186                 throw(std::bad_alloc, std::runtime_error);
 187
 188 /**
 189  * Dump an audio sample
 190  *
 191  * parameter left: Signed sample for left channel (-32768 - 327678).
 192  * parameter right: Signed sample for right channel (-32768 - 327678).
 193  * throws std::bad_alloc: Not enough memory.
 194  * throws std::runtime_error: Error dumping sample.
 195  */
 196         void on_sample(short left, short right) throw(std::bad_alloc, std::runtime_error);
 197
 198 /**
 199  * Notify end of dump.
 200  *
 201  * throws std::bad_alloc: Not enough memory.
 202  * throws std::runtime_error: Error closing dump.
 203  */
 204         void on_end() throw(std::bad_alloc, std::runtime_error);
 205
 206 /**
 207  * Causes current thread to become encode thread. Do not call this, the code internally uses it.
 208  *
 209  * returns: Return status for the thread.
 210  */
 211         int encode_thread();
 212
 213 /**
 214  * Set capture errored flag.
 215  *
 216  * parameter err: The error message.
 217  */
 218         void set_capture_error(const char* err) throw();
 219 private:
 220         void print_summary(std::ostream& str);
 221         void on_frame_threaded(const uint32_t* data, uint16_t width, uint16_t height, uint32_t fps_n, uint32_t fps_d)
 222                 throw(std::bad_alloc, std::runtime_error);
 223         void flush_audio_to(unsigned commit_ptr);
 224         void open_and_write_avi_header(uint16_t width, uint16_t height, uint32_t fps_n, uint32_t fps_d);
 225         void fixup_avi_header_and_close();
 226         std::ofstream avi_stream;
 227         bool capture_error;
 228         std::string capture_error_str;
 229         bool avi_open;
 230         //Global settings.
 231         unsigned compression_level;
 232         uint32_t audio_sampling_rate;
 233         uint32_t keyframe_interval;
 234         uint32_t maxframes;
 235         //Previous frame.
 236         uint16_t pwidth;
 237         uint16_t pheight;
 238         uint32_t pfps_n;
 239         uint32_t pfps_d;
 240         //Current segment.
 241         uint32_t segment_movi_ptr;
 242         uint32_t segment_frames;
 243         uint32_t segment_samples;
 244         uint32_t segment_last_keyframe;
 245         uint32_t current_segment;
 246         uint32_t fixup_avi_size;
 247         uint32_t fixup_avi_frames;
 248         uint32_t fixup_avi_length;
 249         uint32_t fixup_avi_a_length;
 250         uint32_t fixup_movi_size;
 251         std::list<avi_frame> segment_chunks;
 252         //Global info.
 253         std::string prefix;
 254         uint64_t total_data;
 255         uint64_t total_frames;
 256         uint64_t total_samples;
 257         //Temporary buffers.
 258         std::vector<uint8_t> pframe;
 259         std::vector<uint8_t> tframe;
 260         std::vector<uint8_t> cframe;
 261         short audio_buffer[AVIDUMPER_AUDIO_BUFFER];
 262         unsigned audio_put_ptr;
 263         unsigned audio_get_ptr;
 264         volatile unsigned audio_commit_ptr;     //Protected by frame_mutex.
 265         //Multithreading stuff.
 266         thread_class* frame_thread;
 267         cv_class frame_cond;
 268         mutex_class frame_mutex;
 269         const uint32_t* mt_data;
 270         volatile uint16_t mt_width;
 271         volatile uint16_t mt_height;
 272         volatile uint32_t mt_fps_n;
 273         volatile uint32_t mt_fps_d;
 274         volatile bool sigquit;
 275 };
 276
 277 #endif