// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.
 * Copyright (C) 2017 Linaro Ltd.
 */
#include <linux/types.h>
#include <media/v4l2-ctrls.h>

#include "core.h"
#include "venc.h"
#include "helpers.h"

#define BITRATE_MIN  32000
#define BITRATE_MAX  160000000
#define BITRATE_DEFAULT  1000000
#define BITRATE_DEFAULT_PEAK (BITRATE_DEFAULT * 2)
#define BITRATE_STEP  100
#define SLICE_BYTE_SIZE_MAX 1024
#define SLICE_BYTE_SIZE_MIN 1024
#define SLICE_MB_SIZE_MAX 300
#define AT_SLICE_BOUNDARY \
 V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED_AT_SLICE_BOUNDARY
#define MAX_LTR_FRAME_COUNT 4

static int venc_calc_bpframes(u32 gop_size, u32 conseq_b, u32 *bf, u32 *pf)
{
 u32 half = (gop_size - 1) >> 1;
 u32 b, p, ratio;
 bool found = false;

 if (!gop_size)
  return -EINVAL;

 *bf = *pf = 0;

 if (!conseq_b) {
  *pf = gop_size -  1;
  return 0;
 }

 b = p = half;

 for (; b <= gop_size - 1; b++, p--) {
  if (b % p)
   continue;

  ratio = b / p;

  if (ratio == conseq_b) {
   found = true;
   break;
  }

  if (ratio > conseq_b)
   break;
 }

 if (!found)
  return -EINVAL;

 if (b + p + 1 != gop_size)
  return -EINVAL;

 *bf = b;
 *pf = p;

 return 0;
}

static int dynamic_bitrate_update(struct venus_inst *inst, u32 bitrate,
      u32 layer_id)
{
 int ret = 0;

 mutex_lock(&inst->lock);
 if (inst->streamon_out && inst->streamon_cap) {
  u32 ptype = HFI_PROPERTY_CONFIG_VENC_TARGET_BITRATE;
  struct hfi_bitrate brate = { .bitrate = bitrate, .layer_id = layer_id };

  ret = hfi_session_set_property(inst, ptype, &brate);
 }
 mutex_unlock(&inst->lock);

 return ret;
}

static int venc_op_s_ctrl(struct v4l2_ctrl *ctrl)
{
 struct venus_inst *inst = ctrl_to_inst(ctrl);
 struct venc_controls *ctr = &inst->controls.enc;
 struct hfi_enable en = { .enable = 1 };
 struct hfi_ltr_use ltr_use;
 struct hfi_ltr_mark ltr_mark;
 u32 bframes;
 u32 ptype;
 int ret;

 switch (ctrl->id) {
 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
  ctr->bitrate_mode = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_BITRATE:
  ctr->bitrate = ctrl->val;
  ret = dynamic_bitrate_update(inst, ctr->bitrate, 0);
  if (ret)
   return ret;
  break;
 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
  ctr->bitrate_peak = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
  ctr->h264_entropy_mode = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
  ctr->profile.mpeg4 = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
  ctr->profile.h264 = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_HEVC_PROFILE:
  ctr->profile.hevc = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_VP8_PROFILE:
  ctr->profile.vp8 = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
  ctr->level.mpeg4 = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
  ctr->level.h264 = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_HEVC_LEVEL:
  ctr->level.hevc = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP:
  ctr->h264_i_qp = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP:
  ctr->h264_p_qp = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP:
  ctr->h264_b_qp = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_MIN_QP:
  ctr->h264_min_qp = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_MIN_QP:
  ctr->h264_i_min_qp = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_MIN_QP:
  ctr->h264_p_min_qp = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_MIN_QP:
  ctr->h264_b_min_qp = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_MAX_QP:
  ctr->h264_max_qp = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_MAX_QP:
  ctr->h264_i_max_qp = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_MAX_QP:
  ctr->h264_p_max_qp = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_MAX_QP:
  ctr->h264_b_max_qp = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_QP:
  ctr->hevc_i_qp = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_QP:
  ctr->hevc_p_qp = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_QP:
  ctr->hevc_b_qp = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_HEVC_MIN_QP:
  ctr->hevc_min_qp = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_MIN_QP:
  ctr->hevc_i_min_qp = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_MIN_QP:
  ctr->hevc_p_min_qp = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_MIN_QP:
  ctr->hevc_b_min_qp = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_HEVC_MAX_QP:
  ctr->hevc_max_qp = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_MAX_QP:
  ctr->hevc_i_max_qp = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_MAX_QP:
  ctr->hevc_p_max_qp = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_MAX_QP:
  ctr->hevc_b_max_qp = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
  ctr->multi_slice_mode = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES:
  ctr->multi_slice_max_bytes = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB:
  ctr->multi_slice_max_mb = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA:
  ctr->h264_loop_filter_alpha = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA:
  ctr->h264_loop_filter_beta = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
  ctr->h264_loop_filter_mode = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
  ctr->header_mode = ctrl->val;
  mutex_lock(&inst->lock);
  if (inst->streamon_out && inst->streamon_cap) {
   if (ctrl->val == V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE)
    en.enable = 0;
   else
    en.enable = 1;
   ptype = HFI_PROPERTY_CONFIG_VENC_SYNC_FRAME_SEQUENCE_HEADER;
   ret = hfi_session_set_property(inst, ptype, &en);
   if (ret) {
    mutex_unlock(&inst->lock);
    return ret;
   }
  }
  mutex_unlock(&inst->lock);
  break;
 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
  ret = venc_calc_bpframes(ctrl->val, ctr->num_b_frames, &bframes,
      &ctr->num_p_frames);
  if (ret)
   return ret;

  ctr->gop_size = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_I_PERIOD:
  ctr->h264_i_period = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_VPX_MIN_QP:
  ctr->vp8_min_qp = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_VPX_MAX_QP:
  ctr->vp8_max_qp = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
  ret = venc_calc_bpframes(ctr->gop_size, ctrl->val, &bframes,
      &ctr->num_p_frames);
  if (ret)
   return ret;

  ctr->num_b_frames = bframes;
  break;
 case V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME:
  mutex_lock(&inst->lock);
  if (inst->streamon_out && inst->streamon_cap) {
   ptype = HFI_PROPERTY_CONFIG_VENC_REQUEST_SYNC_FRAME;
   ret = hfi_session_set_property(inst, ptype, &en);

   if (ret) {
    mutex_unlock(&inst->lock);
    return ret;
   }
  }
  mutex_unlock(&inst->lock);
  break;
 case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:
  ctr->rc_enable = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_CONSTANT_QUALITY:
  ctr->const_quality = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_FRAME_SKIP_MODE:
  ctr->frame_skip_mode = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_BASELAYER_PRIORITY_ID:
  ctr->base_priority_id = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_AU_DELIMITER:
  ctr->aud_enable = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_LTR_COUNT:
  ctr->ltr_count = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_FRAME_LTR_INDEX:
  mutex_lock(&inst->lock);
  if (inst->streamon_out && inst->streamon_cap) {
   ptype = HFI_PROPERTY_CONFIG_VENC_MARKLTRFRAME;
   ltr_mark.mark_frame = ctrl->val;
   ret = hfi_session_set_property(inst, ptype, <r_mark);
   if (ret) {
    mutex_unlock(&inst->lock);
    return ret;
   }
  }
  mutex_unlock(&inst->lock);
  break;
 case V4L2_CID_MPEG_VIDEO_USE_LTR_FRAMES:
  mutex_lock(&inst->lock);
  if (inst->streamon_out && inst->streamon_cap) {
   ptype = HFI_PROPERTY_CONFIG_VENC_USELTRFRAME;
   ltr_use.ref_ltr = ctrl->val;
   ltr_use.use_constrnt = true;
   ltr_use.frames = 0;
   ret = hfi_session_set_property(inst, ptype, <r_use);
   if (ret) {
    mutex_unlock(&inst->lock);
    return ret;
   }
  }
  mutex_unlock(&inst->lock);
  break;
 case V4L2_CID_COLORIMETRY_HDR10_CLL_INFO:
  ctr->cll = *ctrl->p_new.p_hdr10_cll;
  break;
 case V4L2_CID_COLORIMETRY_HDR10_MASTERING_DISPLAY:
  ctr->mastering = *ctrl->p_new.p_hdr10_mastering;
  break;
 case V4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIOD_TYPE:
  ctr->intra_refresh_type = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIOD:
  ctr->intra_refresh_period = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM:
  if (ctr->profile.h264 != V4L2_MPEG_VIDEO_H264_PROFILE_HIGH &&
      ctr->profile.h264 != V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_HIGH)
   return -EINVAL;

  /*
   * In video firmware, 8x8 transform is supported only for
   * high profile(HP) and constrained high profile(CHP).
   * If client wants to disable 8x8 transform for HP/CHP,
   * it is better to set profile as main profile(MP).
   * Because there is no difference between HP and MP
   * if we disable 8x8 transform for HP.
 */


  ctr->h264_8x8_transform = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_TYPE:
  if (ctrl->val != V4L2_MPEG_VIDEO_H264_HIERARCHICAL_CODING_P)
   return -EINVAL;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING:
  ctr->layer_bitrate = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER:
  if (ctrl->val > VIDC_MAX_HIER_CODING_LAYER)
   return -EINVAL;
  ctr->h264_hier_layers = ctrl->val;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L0_BR:
  ctr->h264_hier_layer_bitrate[0] = ctrl->val;
  ret = dynamic_bitrate_update(inst, ctr->h264_hier_layer_bitrate[0], 0);
  if (ret)
   return ret;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L1_BR:
  ctr->h264_hier_layer_bitrate[1] = ctrl->val;
  ret = dynamic_bitrate_update(inst, ctr->h264_hier_layer_bitrate[1], 1);
  if (ret)
   return ret;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L2_BR:
  ctr->h264_hier_layer_bitrate[2] = ctrl->val;
  ret = dynamic_bitrate_update(inst, ctr->h264_hier_layer_bitrate[2], 2);
  if (ret)
   return ret;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L3_BR:
  ctr->h264_hier_layer_bitrate[3] = ctrl->val;
  ret = dynamic_bitrate_update(inst, ctr->h264_hier_layer_bitrate[3], 3);
  if (ret)
   return ret;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L4_BR:
  ctr->h264_hier_layer_bitrate[4] = ctrl->val;
  ret = dynamic_bitrate_update(inst, ctr->h264_hier_layer_bitrate[4], 4);
  if (ret)
   return ret;
  break;
 case V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L5_BR:
  ctr->h264_hier_layer_bitrate[5] = ctrl->val;
  ret = dynamic_bitrate_update(inst, ctr->h264_hier_layer_bitrate[5], 5);
  if (ret)
   return ret;
  break;

 default:
  return -EINVAL;
 }

 return 0;
}

static int venc_op_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
{
 struct venus_inst *inst = ctrl_to_inst(ctrl);
 struct hfi_buffer_requirements bufreq;
 enum hfi_version ver = inst->core->res->hfi_version;
 int ret;

 switch (ctrl->id) {
 case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT:
  ret = venus_helper_get_bufreq(inst, HFI_BUFFER_INPUT, &bufreq);
  if (!ret)
   ctrl->val = hfi_bufreq_get_count_min(&bufreq, ver);
  break;
 default:
  return -EINVAL;
 }

 return 0;
}

static const struct v4l2_ctrl_ops venc_ctrl_ops = {
 .s_ctrl = venc_op_s_ctrl,
 .g_volatile_ctrl = venc_op_g_volatile_ctrl,
};

int venc_ctrl_init(struct venus_inst *inst)
{
 int ret;
 struct v4l2_ctrl_hdr10_mastering_display p_hdr10_mastering = {
  { 34000, 13250, 7500 },
  { 16000, 34500, 3000 }, 15635, 16450, 10000000, 500,
 };
 struct v4l2_ctrl_hdr10_cll_info p_hdr10_cll = { 1000, 400 };

 ret = v4l2_ctrl_handler_init(&inst->ctrl_handler, 59);
 if (ret)
  return ret;

 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
  V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
  V4L2_MPEG_VIDEO_BITRATE_MODE_CBR,
  ~((1 << V4L2_MPEG_VIDEO_BITRATE_MODE_VBR) |
    (1 << V4L2_MPEG_VIDEO_BITRATE_MODE_CBR) |
    (1 << V4L2_MPEG_VIDEO_BITRATE_MODE_CQ)),
  V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);

 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
  V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE,
  V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CABAC,
  0, V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC);

 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
  V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE,
  V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_CODING_EFFICIENCY,
  ~((1 << V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE) |
    (1 << V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_SIMPLE)),
  V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE);

 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
  V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL,
  V4L2_MPEG_VIDEO_MPEG4_LEVEL_5,
  0, V4L2_MPEG_VIDEO_MPEG4_LEVEL_0);

 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
  V4L2_CID_MPEG_VIDEO_HEVC_PROFILE,
  V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_10,
  ~((1 << V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN) |
    (1 << V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_STILL_PICTURE) |
    (1 << V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_10)),
  V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN);

 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
  V4L2_CID_MPEG_VIDEO_HEVC_LEVEL,
  V4L2_MPEG_VIDEO_HEVC_LEVEL_6_2,
  0, V4L2_MPEG_VIDEO_HEVC_LEVEL_1);

 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
  V4L2_CID_MPEG_VIDEO_H264_PROFILE,
  V4L2_MPEG_VIDEO_H264_PROFILE_MULTIVIEW_HIGH,
  ~((1 << V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE) |
    (1 << V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE) |
    (1 << V4L2_MPEG_VIDEO_H264_PROFILE_MAIN) |
    (1 << V4L2_MPEG_VIDEO_H264_PROFILE_HIGH) |
    (1 << V4L2_MPEG_VIDEO_H264_PROFILE_STEREO_HIGH) |
    (1 << V4L2_MPEG_VIDEO_H264_PROFILE_MULTIVIEW_HIGH)),
  V4L2_MPEG_VIDEO_H264_PROFILE_HIGH);

 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
  V4L2_CID_MPEG_VIDEO_H264_LEVEL,
  V4L2_MPEG_VIDEO_H264_LEVEL_5_1,
  0, V4L2_MPEG_VIDEO_H264_LEVEL_1_0);

 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
  V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE,
  AT_SLICE_BOUNDARY,
  0, V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED);

 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
  V4L2_CID_MPEG_VIDEO_HEADER_MODE,
  V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME,
  ~((1 << V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE) |
  (1 << V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME)),
  V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME);

 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
  V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE,
  V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_MAX_BYTES,
  0, V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE);

 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
  V4L2_CID_MPEG_VIDEO_VP8_PROFILE,
  V4L2_MPEG_VIDEO_VP8_PROFILE_3,
  0, V4L2_MPEG_VIDEO_VP8_PROFILE_0);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MIN_BUFFERS_FOR_OUTPUT, 4, 11, 1, 4);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
  V4L2_CID_MPEG_VIDEO_BITRATE, BITRATE_MIN, BITRATE_MAX,
  BITRATE_STEP, BITRATE_DEFAULT);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
  V4L2_CID_MPEG_VIDEO_BITRATE_PEAK, BITRATE_MIN, BITRATE_MAX,
  BITRATE_STEP, BITRATE_DEFAULT_PEAK);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP, 1, 51, 1, 26);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP, 1, 51, 1, 28);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP, 1, 51, 1, 30);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_H264_MIN_QP, 1, 51, 1, 1);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_H264_I_FRAME_MIN_QP, 1, 51, 1, 1);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM, 0, 1, 1, 1);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_H264_P_FRAME_MIN_QP, 1, 51, 1, 1);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_H264_B_FRAME_MIN_QP, 1, 51, 1, 1);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_H264_MAX_QP, 1, 51, 1, 51);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_H264_I_FRAME_MAX_QP, 1, 51, 1, 51);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_H264_P_FRAME_MAX_QP, 1, 51, 1, 51);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_H264_B_FRAME_MAX_QP, 1, 51, 1, 51);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_QP, 1, 63, 1, 26);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_QP, 1, 63, 1, 28);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_QP, 1, 63, 1, 30);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_HEVC_MIN_QP, 1, 63, 1, 1);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_MIN_QP, 1, 63, 1, 1);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_MIN_QP, 1, 63, 1, 1);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_MIN_QP, 1, 63, 1, 1);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_HEVC_MAX_QP, 1, 63, 1, 63);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_MAX_QP, 1, 63, 1, 63);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_MAX_QP, 1, 63, 1, 63);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_MAX_QP, 1, 63, 1, 63);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
  V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES, SLICE_BYTE_SIZE_MIN,
  SLICE_BYTE_SIZE_MAX, 1, SLICE_BYTE_SIZE_MIN);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
  V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB, 1,
  SLICE_MB_SIZE_MAX, 1, 1);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
  V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA, -6, 6, 1, 0);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
  V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA, -6, 6, 1, 0);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
  V4L2_CID_MPEG_VIDEO_GOP_SIZE, 0, (1 << 16) - 1, 1, 30);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
  V4L2_CID_MPEG_VIDEO_VPX_MIN_QP, 1, 128, 1, 1);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
  V4L2_CID_MPEG_VIDEO_VPX_MAX_QP, 1, 128, 1, 128);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
  V4L2_CID_MPEG_VIDEO_B_FRAMES, 0, 4, 1, 0);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
  V4L2_CID_MPEG_VIDEO_H264_I_PERIOD, 0, (1 << 16) - 1, 1, 0);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME, 0, 0, 0, 0);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE, 0, 1, 1, 1);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_CONSTANT_QUALITY, 0, 100, 1, 0);

 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
          V4L2_CID_MPEG_VIDEO_FRAME_SKIP_MODE,
          V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_BUF_LIMIT,
          ~((1 << V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_DISABLED) |
          (1 << V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_BUF_LIMIT)),
          V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_DISABLED);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_BASELAYER_PRIORITY_ID, 0,
     6, 1, 0);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_AU_DELIMITER, 0, 1, 1, 0);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_USE_LTR_FRAMES, 0,
     ((1 << MAX_LTR_FRAME_COUNT) - 1), 0, 0);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_LTR_COUNT, 0,
     MAX_LTR_FRAME_COUNT, 1, 0);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_FRAME_LTR_INDEX, 0,
     (MAX_LTR_FRAME_COUNT - 1), 1, 0);

 v4l2_ctrl_new_std_compound(&inst->ctrl_handler, &venc_ctrl_ops,
       V4L2_CID_COLORIMETRY_HDR10_CLL_INFO,
       v4l2_ctrl_ptr_create(&p_hdr10_cll),
       v4l2_ctrl_ptr_create(NULL),
       v4l2_ctrl_ptr_create(NULL));

 v4l2_ctrl_new_std_compound(&inst->ctrl_handler, &venc_ctrl_ops,
       V4L2_CID_COLORIMETRY_HDR10_MASTERING_DISPLAY,
       v4l2_ctrl_ptr_create((void *)&p_hdr10_mastering),
       v4l2_ctrl_ptr_create(NULL),
       v4l2_ctrl_ptr_create(NULL));


 v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
          V4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIOD_TYPE,
          V4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIOD_TYPE_CYCLIC,
          0, V4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIOD_TYPE_RANDOM);

 v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
     V4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIOD, 0,
     ((4096 * 2304) >> 8), 1, 0);

 if (IS_V4(inst->core) || IS_V6(inst->core)) {
  v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
           V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_TYPE,
           V4L2_MPEG_VIDEO_H264_HIERARCHICAL_CODING_P,
           1, V4L2_MPEG_VIDEO_H264_HIERARCHICAL_CODING_P);

  v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
      V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING, 0, 1, 1, 0);

  v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
      V4L2_CID_MPEG_VIDEO_H264_HIERARCHICAL_CODING_LAYER, 0,
      VIDC_MAX_HIER_CODING_LAYER, 1, 0);

  v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
      V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L0_BR,
      BITRATE_MIN, BITRATE_MAX, BITRATE_STEP, BITRATE_DEFAULT);

  v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
      V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L1_BR,
      BITRATE_MIN, BITRATE_MAX,
      BITRATE_STEP, BITRATE_DEFAULT);

  v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
      V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L2_BR,
      BITRATE_MIN, BITRATE_MAX,
      BITRATE_STEP, BITRATE_DEFAULT);

  v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
      V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L3_BR,
      BITRATE_MIN, BITRATE_MAX,
      BITRATE_STEP, BITRATE_DEFAULT);

  v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
      V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L4_BR,
      BITRATE_MIN, BITRATE_MAX,
      BITRATE_STEP, BITRATE_DEFAULT);

  v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
      V4L2_CID_MPEG_VIDEO_H264_HIER_CODING_L5_BR,
      BITRATE_MIN, BITRATE_MAX,
      BITRATE_STEP, BITRATE_DEFAULT);
 }

 ret = inst->ctrl_handler.error;
 if (ret)
  goto err;

 ret = v4l2_ctrl_handler_setup(&inst->ctrl_handler);
 if (ret)
  goto err;

 return 0;
err:
 v4l2_ctrl_handler_free(&inst->ctrl_handler);
 return ret;
}