streamtools/output-drv.hpp

   1 #ifndef _output_drv__hpp__included__
   2 #define _output_drv__hpp__included__
   3
   4 #include <stdint.h>
   5 #include <string>
   6 #include <map>
   7 #include "resize.hpp"
   8 #include "digital-filter.hpp"
   9
  10 class audio_settings
  11 {
  12 public:
  13         audio_settings(uint32_t _rate);
  14         uint32_t get_rate() const;
  15 private:
  16         uint32_t rate;
  17 };
  18
  19 class audio_dyncall_base
  20 {
  21 public:
  22         virtual ~audio_dyncall_base();
  23         virtual void operator()(short left, short right) = 0;
  24 };
  25
  26 class audio_end_dyncall_base
  27 {
  28 public:
  29         virtual ~audio_end_dyncall_base();
  30         virtual void operator()() = 0;
  31 };
  32
  33 template<class T>
  34 class audio_dyncall : public audio_dyncall_base
  35 {
  36 public:
  37         audio_dyncall(T& _object, void (T::*_ptr)(short left, short right))
  38                 : object(_object)
  39         {
  40                 ptr = _ptr;
  41         }
  42
  43         ~audio_dyncall()
  44         {
  45         }
  46
  47         void operator()(short left, short right)
  48         {
  49                 (object.*ptr)(left, right);
  50         }
  51 private:
  52         T& object;
  53         void (T::*ptr)(short left, short right);
  54 };
  55
  56 template<class T>
  57 class audio_end_dyncall : public audio_end_dyncall_base
  58 {
  59 public:
  60         audio_end_dyncall(T& _object, void (T::*_ptr)())
  61                 : object(_object)
  62         {
  63                 ptr = _ptr;
  64         }
  65
  66         ~audio_end_dyncall()
  67         {
  68         }
  69
  70         void operator()()
  71         {
  72                 (object.*ptr)();
  73         }
  74 private:
  75         T& object;
  76         void (T::*ptr)();
  77 };
  78
  79 class video_settings
  80 {
  81 public:
  82         video_settings(uint32_t _width, uint32_t _height, uint32_t _rate_num, uint32_t _rate_denum);
  83         uint32_t get_width() const;
  84         uint32_t get_height() const;
  85         uint32_t get_rate_num() const;
  86         uint32_t get_rate_denum() const;        //WARNING: Zero if framerate is variable!
  87 private:
  88         uint32_t width;
  89         uint32_t height;
  90         uint32_t rate_num;
  91         uint32_t rate_denum;
  92 };
  93
  94 class video_dyncall_base
  95 {
  96 public:
  97         virtual ~video_dyncall_base();
  98         virtual void operator()(uint64_t timestamp, const uint8_t* raw_rgbx_data) = 0;
  99 };
 100
 101 template<class T>
 102 class video_dyncall : public video_dyncall_base
 103 {
 104 public:
 105         video_dyncall(T& _object, void (T::*_ptr)(uint64_t timestamp, const uint8_t* raw_rgbx_data))
 106                 : object(_object)
 107         {
 108                 ptr = _ptr;
 109         }
 110
 111         ~video_dyncall()
 112         {
 113         }
 114
 115         void operator()(uint64_t timestamp, const uint8_t* raw_rgbx_data)
 116         {
 117                 (object.*ptr)(timestamp, raw_rgbx_data);
 118         }
 119 private:
 120         T& object;
 121         void (T::*ptr)(uint64_t timestamp, const uint8_t* raw_rgbx_data);
 122 };
 123
 124 class subtitle_settings
 125 {
 126 public:
 127         subtitle_settings();
 128 private:
 129 };
 130
 131 class subtitle_dyncall_base
 132 {
 133 public:
 134         virtual ~subtitle_dyncall_base();
 135         virtual void operator()(uint64_t basetime, uint64_t duration, const uint8_t* text) = 0;
 136 };
 137
 138 template<class T>
 139 class subtitle_dyncall : public subtitle_dyncall_base
 140 {
 141 public:
 142         subtitle_dyncall(T& _object, void (T::*_ptr)(uint64_t basetime, uint64_t duration, const uint8_t* text))
 143                 : object(_object)
 144         {
 145                 ptr = _ptr;
 146         }
 147
 148         ~subtitle_dyncall()
 149         {
 150         }
 151
 152         void operator()(uint64_t basetime, uint64_t duration, const uint8_t* text)
 153         {
 154                 (object.*ptr)(basetime, duration, text);
 155         }
 156 private:
 157         T& object;
 158         void (T::*ptr)(uint64_t basetime, uint64_t duration, const uint8_t* text);
 159 };
 160
 161
 162 class output_driver
 163 {
 164 public:
 165         output_driver();
 166         virtual ~output_driver();
 167         virtual void ready() = 0;
 168         void set_audio_settings(audio_settings a);
 169         void set_video_settings(video_settings v);
 170         void set_subtitle_settings(subtitle_settings s);
 171         const audio_settings& get_audio_settings();
 172         const video_settings& get_video_settings();
 173         const subtitle_settings& get_subtitle_settings();
 174         template<class T> void set_audio_callback(T& object, void (T::*ptr)(short left, short right))
 175         {
 176                 audio_dyncall_base* old = audio_handler;
 177                 audio_handler = new audio_dyncall<T>(object, ptr);
 178                 delete old;
 179         }
 180
 181         template<class T> void set_audio_end_callback(T& object, void (T::*ptr)())
 182         {
 183                 audio_end_dyncall_base* old = audio_end_handler;
 184                 audio_end_handler = new audio_end_dyncall<T>(object, ptr);
 185                 delete old;
 186         }
 187
 188         template<class T> void set_video_callback(T& object, void (T::*ptr)(uint64_t timestamp,
 189                 const uint8_t* raw_rgbx_data))
 190         {
 191                 video_dyncall_base* old = video_handler;
 192                 video_handler = new video_dyncall<T>(object, ptr);
 193                 not_default_video_handler = true;
 194                 delete old;
 195         }
 196
 197         template<class T> void set_subtitle_callback(T& object, void (T::*ptr)(uint64_t basetime, uint64_t duration,
 198                 const uint8_t* text))
 199         {
 200                 subtitle_dyncall_base* old = subtitle_handler;
 201                 subtitle_handler = new subtitle_dyncall<T>(object, ptr);
 202                 delete old;
 203         }
 204
 205         void do_audio_callback(short left, short right);
 206         void do_audio_end_callback();
 207         void do_video_callback(uint64_t timestamp, const uint8_t* raw_rgbx_data);
 208         void do_subtitle_callback(uint64_t basetime, uint64_t duration, const uint8_t* text);
 209         bool not_default_video_handler;
 210 private:
 211         output_driver(const output_driver&);
 212         output_driver& operator=(const output_driver&);
 213         audio_dyncall_base* audio_handler;
 214         audio_end_dyncall_base* audio_end_handler;
 215         video_dyncall_base* video_handler;
 216         subtitle_dyncall_base* subtitle_handler;
 217         audio_settings asettings;
 218         video_settings vsettings;
 219         subtitle_settings ssettings;
 220 };
 221
 222 void distribute_audio_callback(short left, short right);
 223 void distribute_audio_callback(npair<short> sample);
 224 void distribute_video_callback(uint64_t timestamp, const uint8_t* raw_rgbx_data);
 225 void distribute_subtitle_callback(uint64_t basetime, uint64_t duration, const uint8_t* text);
 226 void distribute_subtitle_callback(struct packet& p);
 227 void set_audio_parameters(audio_settings a);
 228 void set_video_parameters(video_settings v);
 229 void set_subtitle_parameters(subtitle_settings s);
 230 void add_output_driver(const std::string& type, const std::string& name, const std::string& parameters);
 231 void close_output_drivers();
 232
 233 std::string get_output_driver_list();
 234
 235 class output_driver_factory
 236 {
 237 public:
 238         output_driver_factory(const std::string& type);
 239         virtual ~output_driver_factory();
 240         static output_driver& make_by_type(const std::string& type, const std::string& name,
 241                 const std::string& parameters);
 242         virtual output_driver& make(const std::string& type, const std::string& name,
 243                 const std::string& parameters) = 0;
 244 private:
 245         static std::map<std::string, output_driver_factory*>* factories;
 246         friend std::string get_output_driver_list();
 247 };
 248
 249 std::string expand_arguments_common(std::string spec, std::string commaexpand, std::string equalsexpand);
 250 void I420_convert_common(const uint8_t* raw_rgbx_data, uint32_t width, uint32_t height, FILE* out, bool uvswap);
 251 void I420_convert_common(const uint8_t* raw_rgbx_data, uint32_t width, uint32_t height, std::ostream& out,
 252         bool uvswap);
 253
 254 #endif