EncoderInfo: encoder setting factorys (#35940)

system/loggerd/encoder/encoder.cc

@@ -21,7 +21,7 @@ void VideoEncoder::publisher_publish(int segment_num, uint32_t idx, VisionIpcBuf
   edata.setFrameId(extra.frame_id);
   edata.setTimestampSof(extra.timestamp_sof);
   edata.setTimestampEof(extra.timestamp_eof);
-  edata.setType(encoder_info.encode_type);
+  edata.setType(encoder_info.settings.encode_type);
   edata.setEncodeId(cnt++);
   edata.setSegmentNum(segment_num);
   edata.setSegmentId(idx);

system/loggerd/encoder/ffmpeg_encoder.cc

@@ -46,7 +46,7 @@ FfmpegEncoder::~FfmpegEncoder() {
 }
 
 void FfmpegEncoder::encoder_open() {
-  auto codec_id = encoder_info.encode_type == cereal::EncodeIndex::Type::QCAMERA_H264
+  auto codec_id = encoder_info.settings.encode_type == cereal::EncodeIndex::Type::QCAMERA_H264
                       ? AV_CODEC_ID_H264
                       : AV_CODEC_ID_FFVHUFF;
   const AVCodec *codec = avcodec_find_encoder(codec_id);

system/loggerd/encoder/v4l_encoder.cc

@@ -155,6 +155,8 @@ V4LEncoder::V4LEncoder(const EncoderInfo &encoder_info, int in_width, int in_hei
   assert(strcmp((const char *)cap.driver, "msm_vidc_driver") == 0);
   assert(strcmp((const char *)cap.card, "msm_vidc_venc") == 0);
 
+  bool is_h265 = encoder_info.settings.encode_type == cereal::EncodeIndex::Type::FULL_H_E_V_C;
+
   struct v4l2_format fmt_out = {
     .type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE,
     .fmt = {
@@ -162,7 +164,7 @@ V4LEncoder::V4LEncoder(const EncoderInfo &encoder_info, int in_width, int in_hei
         // downscales are free with v4l
         .width = (unsigned int)(out_width),
         .height = (unsigned int)(out_height),
-        .pixelformat = (encoder_info.encode_type == cereal::EncodeIndex::Type::FULL_H_E_V_C) ? V4L2_PIX_FMT_HEVC : V4L2_PIX_FMT_H264,
+        .pixelformat = is_h265 ? V4L2_PIX_FMT_HEVC : V4L2_PIX_FMT_H264,
         .field = V4L2_FIELD_ANY,
         .colorspace = V4L2_COLORSPACE_DEFAULT,
       }
@@ -205,8 +207,10 @@ V4LEncoder::V4LEncoder(const EncoderInfo &encoder_info, int in_width, int in_hei
   // shared ctrls
   {
     struct v4l2_control ctrls[] = {
+      { .id = V4L2_CID_MPEG_VIDEO_BITRATE, .value = encoder_info.settings.bitrate},
+      { .id = V4L2_CID_MPEG_VIDC_VIDEO_NUM_P_FRAMES, .value = encoder_info.settings.gop_size - encoder_info.settings.b_frames - 1},
+      { .id = V4L2_CID_MPEG_VIDC_VIDEO_NUM_B_FRAMES, .value = encoder_info.settings.b_frames},
       { .id = V4L2_CID_MPEG_VIDEO_HEADER_MODE, .value = V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE},
-      { .id = V4L2_CID_MPEG_VIDEO_BITRATE, .value = encoder_info.bitrate},
       { .id = V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL, .value = V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_VBR_CFR},
       { .id = V4L2_CID_MPEG_VIDC_VIDEO_PRIORITY, .value = V4L2_MPEG_VIDC_VIDEO_PRIORITY_REALTIME_DISABLE},
       { .id = V4L2_CID_MPEG_VIDC_VIDEO_IDR_PERIOD, .value = 1},
@@ -216,13 +220,11 @@ V4LEncoder::V4LEncoder(const EncoderInfo &encoder_info, int in_width, int in_hei
     }
   }
 
-  if (encoder_info.encode_type == cereal::EncodeIndex::Type::FULL_H_E_V_C) {
+  if (is_h265) {
     struct v4l2_control ctrls[] = {
       { .id = V4L2_CID_MPEG_VIDC_VIDEO_HEVC_PROFILE, .value = V4L2_MPEG_VIDC_VIDEO_HEVC_PROFILE_MAIN},
       { .id = V4L2_CID_MPEG_VIDC_VIDEO_HEVC_TIER_LEVEL, .value = V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_HIGH_TIER_LEVEL_5},
       { .id = V4L2_CID_MPEG_VIDC_VIDEO_VUI_TIMING_INFO, .value = V4L2_MPEG_VIDC_VIDEO_VUI_TIMING_INFO_ENABLED},
-      { .id = V4L2_CID_MPEG_VIDC_VIDEO_NUM_P_FRAMES, .value = 29},
-      { .id = V4L2_CID_MPEG_VIDC_VIDEO_NUM_B_FRAMES, .value = 0},
     };
     for (auto ctrl : ctrls) {
       util::safe_ioctl(fd, VIDIOC_S_CTRL, &ctrl, "VIDIOC_S_CTRL failed");
@@ -231,8 +233,6 @@ V4LEncoder::V4LEncoder(const EncoderInfo &encoder_info, int in_width, int in_hei
     struct v4l2_control ctrls[] = {
       { .id = V4L2_CID_MPEG_VIDEO_H264_PROFILE, .value = V4L2_MPEG_VIDEO_H264_PROFILE_HIGH},
       { .id = V4L2_CID_MPEG_VIDEO_H264_LEVEL, .value = V4L2_MPEG_VIDEO_H264_LEVEL_UNKNOWN},
-      { .id = V4L2_CID_MPEG_VIDC_VIDEO_NUM_P_FRAMES, .value = 14},
-      { .id = V4L2_CID_MPEG_VIDC_VIDEO_NUM_B_FRAMES, .value = 0},
       { .id = V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE, .value = V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CABAC},
       { .id = V4L2_CID_MPEG_VIDC_VIDEO_H264_CABAC_MODEL, .value = V4L2_CID_MPEG_VIDC_VIDEO_H264_CABAC_MODEL_0},
       { .id = V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE, .value = 0},

system/loggerd/loggerd.h

@@ -13,10 +13,7 @@
 #include "system/loggerd/logger.h"
 
 constexpr int MAIN_FPS = 20;
-const int MAIN_BITRATE = 1e7;
+const auto MAIN_ENCODE_TYPE = Hardware::PC() ? cereal::EncodeIndex::Type::BIG_BOX_LOSSLESS : cereal::EncodeIndex::Type::FULL_H_E_V_C;
-const int LIVESTREAM_BITRATE = 1e6;
-const int QCAM_BITRATE = 256000;
-
 #define NO_CAMERA_PATIENCE 500  // fall back to time-based rotation if all cameras are dead
 
 #define INIT_ENCODE_FUNCTIONS(encode_type)                                \
@@ -29,6 +26,31 @@ const int SEGMENT_LENGTH = LOGGERD_TEST ? atoi(getenv("LOGGERD_SEGMENT_LENGTH"))
 
 constexpr char PRESERVE_ATTR_NAME[] = "user.preserve";
 constexpr char PRESERVE_ATTR_VALUE = '1';
+
+struct EncoderSettings {
+  cereal::EncodeIndex::Type encode_type;
+  int bitrate;
+  int gop_size;
+  int b_frames = 0; // we don't use b frames
+
+  static EncoderSettings MainEncoderSettings() {
+  //static EncoderSettings MainEncoderSettings(int in_width) {
+    //if (in_width <= 1344) {
+    //  return EncoderSettings{.bitrate = 5'000'000, .gop_size = 20};
+    //} else {
+    return EncoderSettings{.encode_type = MAIN_ENCODE_TYPE, .bitrate = 10'000'000, .gop_size = 30};
+    //}
+  }
+
+  static EncoderSettings QcamEncoderSettings() {
+    return EncoderSettings{.encode_type = cereal::EncodeIndex::Type::QCAMERA_H264, .bitrate = 256'000, .gop_size = 15};
+  }
+
+  static EncoderSettings StreamEncoderSettings() {
+    return EncoderSettings{.encode_type = cereal::EncodeIndex::Type::QCAMERA_H264, .bitrate = 1'000'000, .gop_size = 15};
+  }
+};
+
 class EncoderInfo {
 public:
   const char *publish_name;
@@ -39,9 +61,8 @@ public:
   int frame_width = -1;
   int frame_height = -1;
   int fps = MAIN_FPS;
-  int bitrate = MAIN_BITRATE;
+  EncoderSettings settings;
-  cereal::EncodeIndex::Type encode_type = Hardware::PC() ? cereal::EncodeIndex::Type::BIG_BOX_LOSSLESS
+
-                                                         : cereal::EncodeIndex::Type::FULL_H_E_V_C;
   ::cereal::EncodeData::Reader (cereal::Event::Reader::*get_encode_data_func)() const;
   void (cereal::Event::Builder::*set_encode_idx_func)(::cereal::EncodeIndex::Reader);
   cereal::EncodeData::Builder (cereal::Event::Builder::*init_encode_data_func)();
@@ -59,12 +80,14 @@ const EncoderInfo main_road_encoder_info = {
   .publish_name = "roadEncodeData",
   .thumbnail_name = "thumbnail",
   .filename = "fcamera.hevc",
+  .settings = EncoderSettings::MainEncoderSettings(),
   INIT_ENCODE_FUNCTIONS(RoadEncode),
 };
 
 const EncoderInfo main_wide_road_encoder_info = {
   .publish_name = "wideRoadEncodeData",
   .filename = "ecamera.hevc",
+  .settings = EncoderSettings::MainEncoderSettings(),
   INIT_ENCODE_FUNCTIONS(WideRoadEncode),
 };
 
@@ -72,39 +95,36 @@ const EncoderInfo main_driver_encoder_info = {
   .publish_name = "driverEncodeData",
   .filename = "dcamera.hevc",
   .record = Params().getBool("RecordFront"),
+  .settings = EncoderSettings::MainEncoderSettings(),
   INIT_ENCODE_FUNCTIONS(DriverEncode),
 };
 
 const EncoderInfo stream_road_encoder_info = {
   .publish_name = "livestreamRoadEncodeData",
   //.thumbnail_name = "thumbnail",
-  .encode_type = cereal::EncodeIndex::Type::QCAMERA_H264,
   .record = false,
-  .bitrate = LIVESTREAM_BITRATE,
+  .settings = EncoderSettings::StreamEncoderSettings(),
   INIT_ENCODE_FUNCTIONS(LivestreamRoadEncode),
 };
 
 const EncoderInfo stream_wide_road_encoder_info = {
   .publish_name = "livestreamWideRoadEncodeData",
-  .encode_type = cereal::EncodeIndex::Type::QCAMERA_H264,
   .record = false,
-  .bitrate = LIVESTREAM_BITRATE,
+  .settings = EncoderSettings::StreamEncoderSettings(),
   INIT_ENCODE_FUNCTIONS(LivestreamWideRoadEncode),
 };
 
 const EncoderInfo stream_driver_encoder_info = {
   .publish_name = "livestreamDriverEncodeData",
-  .encode_type = cereal::EncodeIndex::Type::QCAMERA_H264,
   .record = false,
-  .bitrate = LIVESTREAM_BITRATE,
+  .settings = EncoderSettings::StreamEncoderSettings(),
   INIT_ENCODE_FUNCTIONS(LivestreamDriverEncode),
 };
 
 const EncoderInfo qcam_encoder_info = {
   .publish_name = "qRoadEncodeData",
   .filename = "qcamera.ts",
-  .bitrate = QCAM_BITRATE,
+  .settings = EncoderSettings::QcamEncoderSettings(),
-  .encode_type = cereal::EncodeIndex::Type::QCAMERA_H264,
   .frame_width = 526,
   .frame_height = 330,
   .include_audio = Params().getBool("RecordAudio"),