streamtools/outputs/x264.cpp

   1 #include <cstring>
   2 #include "outputs/internal.hpp"
   3 #include "outputs/I420.hpp"
   4 #include "outputs/argexpand.hpp"
   5 #include <cstdio>
   6 #include <stdexcept>
   7 #include <vector>
   8 #include <string>
   9 #include <sstream>
  10
  11 namespace
  12 {
  13         std::string expand_options(const std::string& opts, uint32_t rn, uint32_t rd)
  14         {
  15                 std::ostringstream ret;
  16                 if(rd)
  17                         ret << "--fps " << rn << "/" << rd << " ";
  18                 ret << expand_arguments_common(opts, "--", " ");
  19                 return ret.str();
  20         }
  21
  22         class output_driver_x264 : public output_driver
  23         {
  24         public:
  25                 output_driver_x264(const std::string& _filename, const std::string& _options, bool _newres)
  26                 {
  27                         filename = _filename;
  28                         options = _options;
  29                         set_video_callback(make_bound_method(*this, &output_driver_x264::video_callback));
  30                         newres = _newres;
  31                 }
  32
  33                 ~output_driver_x264()
  34                 {
  35                         pclose(out);
  36                 }
  37
  38                 void ready()
  39                 {
  40                         const video_settings& v = get_video_settings();
  41                         framesize = 4 * v.get_width() * v.get_height();
  42                         width = v.get_width();
  43                         height = v.get_height();
  44
  45                         std::stringstream commandline;
  46                         commandline << "x264 ";
  47                         commandline << expand_options(options, v.get_rate_num(), v.get_rate_denum());
  48                         commandline << " -o " << filename << " - ";
  49                         if(newres)
  50                                 commandline << "--input-res ";
  51                         commandline << v.get_width() << "x" << v.get_height();
  52                         std::string s = commandline.str();
  53                         std::cerr << s << std::endl;
  54                         out = popen(s.c_str(), "w");
  55                         if(!out) {
  56                                 std::stringstream str;
  57                                 str << "Can't run x264 (" << s << ")";
  58                                 throw std::runtime_error(str.str());
  59                         }
  60                 }
  61
  62                 void video_callback(uint64_t timestamp, const uint8_t* raw_rgbx_data)
  63                 {
  64                         I420_convert_common(raw_rgbx_data, width, height, out, true);
  65                 }
  66         private:
  67                 FILE* out;
  68                 std::string filename;
  69                 std::string options;
  70                 size_t framesize;
  71                 uint32_t width;
  72                 uint32_t height;
  73                 bool newres;
  74         };
  75
  76         class output_driver_x264_factory : output_driver_factory
  77         {
  78         public:
  79                 output_driver_x264_factory()
  80                         : output_driver_factory("x264")
  81                 {
  82                 }
  83
  84                 output_driver& make(const std::string& type, const std::string& name, const std::string& parameters)
  85                 {
  86                         return *new output_driver_x264(name, parameters, false);
  87                 }
  88         } factory1;
  89
  90         class output_driver_x264n_factory : output_driver_factory
  91         {
  92         public:
  93                 output_driver_x264n_factory()
  94                         : output_driver_factory("x264n")
  95                 {
  96                 }
  97
  98                 output_driver& make(const std::string& type, const std::string& name, const std::string& parameters)
  99                 {
 100                         return *new output_driver_x264(name, parameters, true);
 101                 }
 102         } factory2;
 103 }