drivers/mxc/vpu_windsor/vpu_encoder_ctrl.c - linux-imx - Git at Google

 /*
  * Copyright(c) 2018 NXP. All rights reserved.
  *
  * The code contained herein is licensed under the GNU General Public
  * License. You may obtain a copy of the GNU General Public License
  * Version 2 or later at the following locations:
  *
  * http://www.opensource.org/licenses/gpl-license.html
  * http://www.gnu.org/copyleft/gpl.html
  *
  * @file vpu_encoder_ctrl.c
  *
  * Author Ming Qian<ming.qian@nxp.com>
  */

 #define TAG	"[VPU Encoder Ctrl]\t "
 #include <media/v4l2-ctrls.h>

 #include "vpu_encoder_b0.h"
 #include "vpu_encoder_ctrl.h"

 // H264 level is maped like level 5.1 to uLevel 51, except level 1b to uLevel 14
 const u_int32 h264_level[] = {
 	[V4L2_MPEG_VIDEO_H264_LEVEL_1_0] = 10,
 	[V4L2_MPEG_VIDEO_H264_LEVEL_1B]  = 14,
 	[V4L2_MPEG_VIDEO_H264_LEVEL_1_1] = 11,
 	[V4L2_MPEG_VIDEO_H264_LEVEL_1_2] = 12,
 	[V4L2_MPEG_VIDEO_H264_LEVEL_1_3] = 13,
 	[V4L2_MPEG_VIDEO_H264_LEVEL_2_0] = 20,
 	[V4L2_MPEG_VIDEO_H264_LEVEL_2_1] = 21,
 	[V4L2_MPEG_VIDEO_H264_LEVEL_2_2] = 22,
 	[V4L2_MPEG_VIDEO_H264_LEVEL_3_0] = 30,
 	[V4L2_MPEG_VIDEO_H264_LEVEL_3_1] = 31,
 	[V4L2_MPEG_VIDEO_H264_LEVEL_3_2] = 32,
 	[V4L2_MPEG_VIDEO_H264_LEVEL_4_0] = 40,
 	[V4L2_MPEG_VIDEO_H264_LEVEL_4_1] = 41,
 	[V4L2_MPEG_VIDEO_H264_LEVEL_4_2] = 42,
 	[V4L2_MPEG_VIDEO_H264_LEVEL_5_0] = 50,
 	[V4L2_MPEG_VIDEO_H264_LEVEL_5_1] = 51
 };

 static int set_h264_profile(struct v4l2_ctrl *ctrl)
 {
 	struct vpu_ctx *ctx = v4l2_ctrl_to_ctx(ctrl);
 	struct vpu_attr *attr = get_vpu_ctx_attr(ctx);
 	pMEDIAIP_ENC_PARAM  param = &attr->param;

 	mutex_lock(&ctx->instance_mutex);
 	switch (ctrl->val) {
 	case V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE:
 		vpu_dbg(LVL_CTRL, "set h264 profile baseline\n");
 		param->eProfile = MEDIAIP_ENC_PROF_H264_BP;
 		break;
 	case V4L2_MPEG_VIDEO_H264_PROFILE_MAIN:
 		vpu_dbg(LVL_CTRL, "set h264 profile main\n");
 		param->eProfile = MEDIAIP_ENC_PROF_H264_MP;
 		break;
 	case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH:
 		vpu_dbg(LVL_CTRL, "set h264 profile high\n");
 		param->eProfile = MEDIAIP_ENC_PROF_H264_HP;
 		break;
 	default:
 		vpu_err("not support H264 profile %d, set to main\n",
 				ctrl->val);
 		param->eProfile = MEDIAIP_ENC_PROF_H264_MP;
 		break;
 	}
 	mutex_unlock(&ctx->instance_mutex);

 	return 0;
 }

 static int set_h264_level(struct v4l2_ctrl *ctrl)
 {
 	struct vpu_ctx *ctx = v4l2_ctrl_to_ctx(ctrl);
 	struct vpu_attr *attr = get_vpu_ctx_attr(ctx);
 	pMEDIAIP_ENC_PARAM  param = &attr->param;

 	mutex_lock(&ctx->instance_mutex);
 	param->uLevel = h264_level[ctrl->val];
 	mutex_unlock(&ctx->instance_mutex);

 	vpu_dbg(LVL_CTRL, "set h264 level to %d (%d)\n",
 			ctrl->val, h264_level[ctrl->val]);

 	return 0;
 }

 static int set_bitrate_mode(struct v4l2_ctrl *ctrl)
 {
 	struct vpu_ctx *ctx = v4l2_ctrl_to_ctx(ctrl);
 	struct vpu_attr *attr = get_vpu_ctx_attr(ctx);
 	pMEDIAIP_ENC_PARAM  param = &attr->param;

 	mutex_lock(&ctx->instance_mutex);
 	switch (ctrl->val) {
 	case V4L2_MPEG_VIDEO_BITRATE_MODE_VBR:
 		vpu_dbg(LVL_CTRL, "set bitrate mode VBR\n");
 		param->eBitRateMode =
 				MEDIAIP_ENC_BITRATECONTROLMODE_CONSTANT_QP;
 		break;
 	case V4L2_MPEG_VIDEO_BITRATE_MODE_CBR:
 		vpu_dbg(LVL_CTRL, "set bitrate mode CBR\n");
 		param->eBitRateMode = MEDIAIP_ENC_BITRATECONTROLMODE_CBR;
 		break;
 	default:
 		vpu_err("not support bitrate mode %d, set to cbr\n",
 				ctrl->val);
 		param->eBitRateMode = MEDIAIP_ENC_BITRATECONTROLMODE_CBR;
 		break;
 	}
 	mutex_unlock(&ctx->instance_mutex);

 	return 0;
 }

 static int set_bitrate(struct v4l2_ctrl *ctrl)
 {
 	struct vpu_ctx *ctx = v4l2_ctrl_to_ctx(ctrl);
 	struct vpu_attr *attr = get_vpu_ctx_attr(ctx);
 	pMEDIAIP_ENC_PARAM  param = &attr->param;

 	vpu_dbg(LVL_CTRL, "set bitrate %d\n", ctrl->val);
 	mutex_lock(&ctx->instance_mutex);
 	param->uTargetBitrate = ctrl->val / BITRATE_COEF;
 	if (param->uMaxBitRate < param->uTargetBitrate)
 		param->uMaxBitRate = param->uTargetBitrate;
 	mutex_unlock(&ctx->instance_mutex);

 	return 0;
 }

 static int set_bitrate_peak(struct v4l2_ctrl *ctrl)
 {
 	struct vpu_ctx *ctx = v4l2_ctrl_to_ctx(ctrl);
 	struct vpu_attr *attr = get_vpu_ctx_attr(ctx);
 	pMEDIAIP_ENC_PARAM  param = &attr->param;

 	vpu_dbg(LVL_CTRL, "set peak bitrate %d\n", ctrl->val);
 	mutex_lock(&ctx->instance_mutex);
 	param->uMaxBitRate = ctrl->val / BITRATE_COEF;
 	if (param->uTargetBitrate > param->uMaxBitRate)
 		param->uTargetBitrate = param->uMaxBitRate;
 	mutex_unlock(&ctx->instance_mutex);

 	return 0;
 }

 static int set_gop_size(struct v4l2_ctrl *ctrl)
 {
 	struct vpu_ctx *ctx = v4l2_ctrl_to_ctx(ctrl);
 	struct vpu_attr *attr = get_vpu_ctx_attr(ctx);
 	pMEDIAIP_ENC_PARAM  param = &attr->param;

 	vpu_dbg(LVL_CTRL, "set gop size %d\n", ctrl->val);
 	mutex_lock(&ctx->instance_mutex);
 	param->uIFrameInterval = ctrl->val;
 	mutex_unlock(&ctx->instance_mutex);

 	return 0;
 }

 static int set_i_period(struct v4l2_ctrl *ctrl)
 {
 	struct vpu_ctx *ctx = v4l2_ctrl_to_ctx(ctrl);
 	struct vpu_attr *attr = get_vpu_ctx_attr(ctx);
 	pMEDIAIP_ENC_PARAM  param = &attr->param;

 	vpu_dbg(LVL_CTRL, "set iframe interval %d\n", ctrl->val);
 	mutex_lock(&ctx->instance_mutex);
 	param->uIFrameInterval = ctrl->val;
 	mutex_unlock(&ctx->instance_mutex);

 	return 0;
 }

 static int get_gop_size(struct v4l2_ctrl *ctrl)
 {
 	struct vpu_ctx *ctx = v4l2_ctrl_to_ctx(ctrl);
 	struct vpu_attr *attr = get_vpu_ctx_attr(ctx);
 	pMEDIAIP_ENC_PARAM  param = &attr->param;

 	vpu_dbg(LVL_CTRL, "get gop size\n");
 	ctrl->val = param->uIFrameInterval;

 	return 0;
 }

 static int set_b_frames(struct v4l2_ctrl *ctrl)
 {
 	struct vpu_ctx *ctx = v4l2_ctrl_to_ctx(ctrl);
 	struct vpu_attr *attr = get_vpu_ctx_attr(ctx);
 	pMEDIAIP_ENC_PARAM  param = &attr->param;

 	vpu_dbg(LVL_CTRL, "set bframes %d\n", ctrl->val);
 	mutex_lock(&ctx->instance_mutex);
 	param->uGopBLength = ctrl->val;
 	mutex_unlock(&ctx->instance_mutex);

 	return 0;
 }

 static int set_qp(struct v4l2_ctrl *ctrl)
 {
 	struct vpu_ctx *ctx = v4l2_ctrl_to_ctx(ctrl);
 	struct vpu_attr *attr = get_vpu_ctx_attr(ctx);
 	pMEDIAIP_ENC_PARAM  param = &attr->param;

 	vpu_dbg(LVL_CTRL, "set qp %d\n", ctrl->val);
 	mutex_lock(&ctx->instance_mutex);
 	param->uInitSliceQP = ctrl->val;
 	mutex_unlock(&ctx->instance_mutex);

 	return 0;
 }

 static int get_min_buffers_for_output(struct v4l2_ctrl *ctrl)
 {
 	vpu_dbg(LVL_CTRL, "get min buffers for output\n");

 	ctrl->val = MIN_BUFFER_COUNT;

 	return 0;
 }

 static int set_display_re_ordering(struct v4l2_ctrl *ctrl)
 {
 	struct vpu_ctx *ctx = v4l2_ctrl_to_ctx(ctrl);
 	struct vpu_attr *attr = get_vpu_ctx_attr(ctx);
 	pMEDIAIP_ENC_PARAM  param = &attr->param;

 	vpu_dbg(LVL_CTRL, "set lowlatencymode %d\n", ctrl->val);
 	mutex_lock(&ctx->instance_mutex);
 	if (ctrl->val)
 		param->uLowLatencyMode = 1;
 	else
 		param->uLowLatencyMode = 0;
 	mutex_unlock(&ctx->instance_mutex);

 	return 0;
 }

 static int set_force_key_frame(struct v4l2_ctrl *ctrl)
 {
 	struct vpu_ctx *ctx = v4l2_ctrl_to_ctx(ctrl);

 	vpu_dbg(LVL_CTRL, "force key frame\n");
 	set_bit(VPU_ENC_STATUS_KEY_FRAME, &ctx->status);

 	return 0;
 }

 static int add_ctrl_h264_profile(struct vpu_ctx *ctx)
 {
 	static const struct v4l2_ctrl_ops ctrl_h264_profile_ops = {
 		.s_ctrl = set_h264_profile,
 	};
 	struct v4l2_ctrl *ctrl;

 	ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrl_handler,
 				      &ctrl_h264_profile_ops,
 				      V4L2_CID_MPEG_VIDEO_H264_PROFILE,
 				      V4L2_MPEG_VIDEO_H264_PROFILE_HIGH,
 				      0xa,
 				      V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE);
 	if (!ctrl) {
 		vpu_err("add ctrl h264 profile fail\n");
 		return -EINVAL;
 	}

 	return 0;
 }

 static int add_ctrl_h264_level(struct vpu_ctx *ctx)
 {
 	static const struct v4l2_ctrl_ops ctrl_h264_level_ops = {
 		.s_ctrl = set_h264_level,
 	};
 	struct v4l2_ctrl *ctrl;

 	ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrl_handler,
 				      &ctrl_h264_level_ops,
 				      V4L2_CID_MPEG_VIDEO_H264_LEVEL,
 				      V4L2_MPEG_VIDEO_H264_LEVEL_5_1,
 				      0x0,
 				      V4L2_MPEG_VIDEO_H264_LEVEL_4_0);
 	if (!ctrl) {
 		vpu_err("add ctrl h264 level fail\n");
 		return -EINVAL;
 	}

 	return 0;
 }

 static int add_ctrl_bitrate_mode(struct vpu_ctx *ctx)
 {
 	static const struct v4l2_ctrl_ops ctrl_bitrate_mode_ops = {
 		.s_ctrl = set_bitrate_mode,
 	};
 	struct v4l2_ctrl *ctrl;

 	ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrl_handler,
 				      &ctrl_bitrate_mode_ops,
 				      V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
 				      V4L2_MPEG_VIDEO_BITRATE_MODE_CBR,
 				      0x0,
 				      V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
 	if (!ctrl) {
 		vpu_err("add ctrl bitrate mode fail\n");
 		return -EINVAL;
 	}

 	return 0;
 }

 static int add_ctrl_bitrate(struct vpu_ctx *ctx)
 {
 	static const struct v4l2_ctrl_ops ctrl_bitrate_ops = {
 		.s_ctrl = set_bitrate,
 	};
 	struct v4l2_ctrl *ctrl;

 	ctrl = v4l2_ctrl_new_std(&ctx->ctrl_handler,
 				 &ctrl_bitrate_ops,
 				 V4L2_CID_MPEG_VIDEO_BITRATE,
 				 BITRATE_LOW_THRESHOLD * BITRATE_COEF,
 				 BITRATE_HIGH_THRESHOLD * BITRATE_COEF,
 				 BITRATE_COEF,
 				 BITRATE_DEFAULT_TARGET * BITRATE_COEF);
 	if (!ctrl) {
 		vpu_err("add ctrl bitrate fail\n");
 		return -EINVAL;
 	}

 	return 0;
 }

 static int add_ctrl_bitrate_peak(struct vpu_ctx *ctx)
 {
 	static const struct v4l2_ctrl_ops ctrl_bitrate_ops = {
 		.s_ctrl = set_bitrate_peak,
 	};
 	struct v4l2_ctrl *ctrl;

 	ctrl = v4l2_ctrl_new_std(&ctx->ctrl_handler,
 				 &ctrl_bitrate_ops,
 				 V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
 				 BITRATE_LOW_THRESHOLD * BITRATE_COEF,
 				 BITRATE_HIGH_THRESHOLD * BITRATE_COEF,
 				 BITRATE_COEF,
 				 BITRATE_DEFAULT_PEAK * BITRATE_COEF);
 	if (!ctrl) {
 		vpu_err("add ctrl bitrate peak fail\n");
 		return -EINVAL;
 	}

 	return 0;
 }

 static int add_ctrl_gop_size(struct vpu_ctx *ctx)
 {
 	static const struct v4l2_ctrl_ops ctrl_gop_ops = {
 		.s_ctrl = set_gop_size,
 		.g_volatile_ctrl = get_gop_size,
 	};
 	struct v4l2_ctrl *ctrl;

 	ctrl = v4l2_ctrl_new_std(&ctx->ctrl_handler,
 				 &ctrl_gop_ops,
 				 V4L2_CID_MPEG_VIDEO_GOP_SIZE,
 				 GOP_L_THRESHOLD,
 				 GOP_H_THRESHOLD,
 				 1,
 				 GOP_DEFAULT);
 	if (!ctrl) {
 		vpu_err("add ctrl gop size fail\n");
 		return -EINVAL;
 	}

 	ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
 	ctrl->flags |= V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;

 	return 0;
 }

 static int add_ctrl_i_period(struct vpu_ctx *ctx)
 {
 	static const struct v4l2_ctrl_ops ctrl_i_period_ops = {
 		.s_ctrl = set_i_period,
 		.g_volatile_ctrl = get_gop_size,
 	};
 	struct v4l2_ctrl *ctrl;

 	ctrl = v4l2_ctrl_new_std(&ctx->ctrl_handler,
 			&ctrl_i_period_ops,
 			V4L2_CID_MPEG_VIDEO_H264_I_PERIOD,
 			GOP_L_THRESHOLD,
 			GOP_H_THRESHOLD,
 			1,
 			GOP_DEFAULT);

 	if (!ctrl) {
 		vpu_err("add ctrl i period fail\n");
 		return -EINVAL;
 	}

 	ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;
 	ctrl->flags |= V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;

 	return 0;
 }

 static int add_ctrl_b_frames(struct vpu_ctx *ctx)
 {
 	static const struct v4l2_ctrl_ops ctrl_b_frames = {
 		.s_ctrl = set_b_frames,
 	};
 	struct v4l2_ctrl *ctrl;

 	ctrl = v4l2_ctrl_new_std(&ctx->ctrl_handler,
 			&ctrl_b_frames,
 			V4L2_CID_MPEG_VIDEO_B_FRAMES,
 			BFRAMES_L_THRESHOLD,
 			BFRAMES_H_THRESHOLD,
 			1,
 			BFRAMES_DEFAULT);

 	if (!ctrl) {
 		vpu_err("add ctrl b frames fail\n");
 		return -EINVAL;
 	}

 	return 0;
 }

 static int add_ctrl_i_frame_qp(struct vpu_ctx *ctx)
 {
 	static const struct v4l2_ctrl_ops ctrl_iframe_qp_ops = {
 		.s_ctrl = set_qp,
 	};
 	struct v4l2_ctrl *ctrl;

 	ctrl = v4l2_ctrl_new_std(&ctx->ctrl_handler,
 				 &ctrl_iframe_qp_ops,
 				 V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP,
 				 QP_MIN,
 				 QP_MAX,
 				 1,
 				 QP_DEFAULT);
 	if (!ctrl) {
 		vpu_err("add ctrl h264 I frame qp fail\n");
 		return -EINVAL;
 	}

 	return 0;
 }

 static int add_ctrl_p_frame_qp(struct vpu_ctx *ctx)
 {
 	static const struct v4l2_ctrl_ops ctrl_pframe_qp_ops = {
 		.s_ctrl = set_qp,
 	};
 	struct v4l2_ctrl *ctrl;

 	ctrl = v4l2_ctrl_new_std(&ctx->ctrl_handler,
 				 &ctrl_pframe_qp_ops,
 				 V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP,
 				 QP_MIN,
 				 QP_MAX,
 				 1,
 				 QP_DEFAULT);
 	if (!ctrl) {
 		vpu_err("add ctrl h264 P frame qp fail\n");
 		return -EINVAL;
 	}

 	return 0;
 }

 static int add_ctrl_b_frame_qp(struct vpu_ctx *ctx)
 {
 	static const struct v4l2_ctrl_ops ctrl_bframe_qp_ops = {
 		.s_ctrl = set_qp,
 	};
 	struct v4l2_ctrl *ctrl;

 	ctrl = v4l2_ctrl_new_std(&ctx->ctrl_handler,
 				 &ctrl_bframe_qp_ops,
 				 V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP,
 				 QP_MIN,
 				 QP_MAX,
 				 1,
 				 QP_DEFAULT);
 	if (!ctrl) {
 		vpu_err("add ctrl h264 B frame qp fail\n");
 		return -EINVAL;
 	}

 	return 0;
 }

 static int add_ctrl_min_buffers_for_output(struct vpu_ctx *ctx)
 {
 	static const struct v4l2_ctrl_ops ctrl_min_buffers_ops = {
 		.g_volatile_ctrl = get_min_buffers_for_output,
 	};
 	struct v4l2_ctrl *ctrl;

 	ctrl = v4l2_ctrl_new_std(&ctx->ctrl_handler,
 				 &ctrl_min_buffers_ops,
 				 V4L2_CID_MIN_BUFFERS_FOR_OUTPUT,
 				 1,
 				 32,
 				 1,
 				 MIN_BUFFER_COUNT);
 	if (!ctrl) {
 		vpu_err("add ctrl min buffers for output fail\n");
 		return -EINVAL;
 	}

 	ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE;

 	return 0;
 }

 static int add_ctrl_display_re_ordering(struct vpu_ctx *ctx)
 {
 	static const struct v4l2_ctrl_ops re_ordering_ops = {
 		.s_ctrl = set_display_re_ordering,
 	};
 	struct v4l2_ctrl *ctrl;

 	ctrl = v4l2_ctrl_new_std(&ctx->ctrl_handler,
 			&re_ordering_ops,
 			V4L2_CID_MPEG_VIDEO_H264_ASO,
 			0, 1, 1, 1);
 	if (!ctrl) {
 		vpu_err("add ctrl display re ordering fail\n");
 		return -EINVAL;
 	}

 	return 0;
 }

 static int add_ctrl_force_key_frame(struct vpu_ctx *ctx)
 {
 	static const struct v4l2_ctrl_ops force_key_frame_ops = {
 		.s_ctrl = set_force_key_frame,
 	};
 	struct v4l2_ctrl *ctrl;

 	ctrl = v4l2_ctrl_new_std(&ctx->ctrl_handler,
 			&force_key_frame_ops,
 			V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME,
 			0, 0, 0, 0);
 	if (!ctrl) {
 		vpu_err("add ctrl force key frame fail\n");
 		return -EINVAL;
 	}

 	return 0;
 }

 static int vpu_enc_register_ctrls(struct vpu_ctx *ctx)
 {
 	add_ctrl_h264_profile(ctx);
 	add_ctrl_h264_level(ctx);
 	add_ctrl_bitrate_mode(ctx);
 	add_ctrl_bitrate(ctx);
 	add_ctrl_bitrate_peak(ctx);
 	add_ctrl_gop_size(ctx);
 	add_ctrl_i_period(ctx);
 	add_ctrl_b_frames(ctx);
 	add_ctrl_i_frame_qp(ctx);
 	add_ctrl_p_frame_qp(ctx);
 	add_ctrl_b_frame_qp(ctx);
 	add_ctrl_min_buffers_for_output(ctx);
 	add_ctrl_display_re_ordering(ctx);
 	add_ctrl_force_key_frame(ctx);

 	return 0;
 }

 int vpu_enc_setup_ctrls(struct vpu_ctx *ctx)
 {
 	vpu_log_func();

 	v4l2_ctrl_handler_init(&ctx->ctrl_handler, 11);
 	vpu_enc_register_ctrls(ctx);
 	if (ctx->ctrl_handler.error) {
 		vpu_err("control initialization error (%d)\n",
 			ctx->ctrl_handler.error);
 		return -EINVAL;
 	}
 	ctx->ctrl_inited = true;
 	return v4l2_ctrl_handler_setup(&ctx->ctrl_handler);
 }

 int vpu_enc_free_ctrls(struct vpu_ctx *ctx)
 {
 	vpu_log_func();

 	if (ctx->ctrl_inited) {
 		v4l2_ctrl_handler_free(&ctx->ctrl_handler);
 		ctx->ctrl_inited = false;
 	}

 	return 0;
 }
	/*
	* Copyright(c) 2018 NXP. All rights reserved.
	*
	* The code contained herein is licensed under the GNU General Public
	* License. You may obtain a copy of the GNU General Public License
	* Version 2 or later at the following locations:
	*
	* http://www.opensource.org/licenses/gpl-license.html
	* http://www.gnu.org/copyleft/gpl.html
	*
	* @file vpu_encoder_ctrl.c
	*
	* Author Ming Qian<ming.qian@nxp.com>
	*/

	#define TAG "[VPU Encoder Ctrl]\t "
	#include <media/v4l2-ctrls.h>

	#include "vpu_encoder_b0.h"
	#include "vpu_encoder_ctrl.h"

	// H264 level is maped like level 5.1 to uLevel 51, except level 1b to uLevel 14
	const u_int32 h264_level[] = {
	[V4L2_MPEG_VIDEO_H264_LEVEL_1_0] = 10,
	[V4L2_MPEG_VIDEO_H264_LEVEL_1B] = 14,
	[V4L2_MPEG_VIDEO_H264_LEVEL_1_1] = 11,
	[V4L2_MPEG_VIDEO_H264_LEVEL_1_2] = 12,
	[V4L2_MPEG_VIDEO_H264_LEVEL_1_3] = 13,
	[V4L2_MPEG_VIDEO_H264_LEVEL_2_0] = 20,
	[V4L2_MPEG_VIDEO_H264_LEVEL_2_1] = 21,
	[V4L2_MPEG_VIDEO_H264_LEVEL_2_2] = 22,
	[V4L2_MPEG_VIDEO_H264_LEVEL_3_0] = 30,
	[V4L2_MPEG_VIDEO_H264_LEVEL_3_1] = 31,
	[V4L2_MPEG_VIDEO_H264_LEVEL_3_2] = 32,
	[V4L2_MPEG_VIDEO_H264_LEVEL_4_0] = 40,
	[V4L2_MPEG_VIDEO_H264_LEVEL_4_1] = 41,
	[V4L2_MPEG_VIDEO_H264_LEVEL_4_2] = 42,
	[V4L2_MPEG_VIDEO_H264_LEVEL_5_0] = 50,
	[V4L2_MPEG_VIDEO_H264_LEVEL_5_1] = 51
	};

	static int set_h264_profile(struct v4l2_ctrl *ctrl)
	{
	struct vpu_ctx *ctx = v4l2_ctrl_to_ctx(ctrl);
	struct vpu_attr *attr = get_vpu_ctx_attr(ctx);
	pMEDIAIP_ENC_PARAM param = &attr->param;

	mutex_lock(&ctx->instance_mutex);
	switch (ctrl->val) {
	case V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE:
	vpu_dbg(LVL_CTRL, "set h264 profile baseline\n");
	param->eProfile = MEDIAIP_ENC_PROF_H264_BP;
	break;
	case V4L2_MPEG_VIDEO_H264_PROFILE_MAIN:
	vpu_dbg(LVL_CTRL, "set h264 profile main\n");
	param->eProfile = MEDIAIP_ENC_PROF_H264_MP;
	break;
	case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH:
	vpu_dbg(LVL_CTRL, "set h264 profile high\n");
	param->eProfile = MEDIAIP_ENC_PROF_H264_HP;
	break;
	default:
	vpu_err("not support H264 profile %d, set to main\n",
	ctrl->val);
	param->eProfile = MEDIAIP_ENC_PROF_H264_MP;
	break;
	}
	mutex_unlock(&ctx->instance_mutex);

	return 0;
	}

	static int set_h264_level(struct v4l2_ctrl *ctrl)
	{
	struct vpu_ctx *ctx = v4l2_ctrl_to_ctx(ctrl);
	struct vpu_attr *attr = get_vpu_ctx_attr(ctx);
	pMEDIAIP_ENC_PARAM param = &attr->param;

	mutex_lock(&ctx->instance_mutex);
	param->uLevel = h264_level[ctrl->val];
	mutex_unlock(&ctx->instance_mutex);

	vpu_dbg(LVL_CTRL, "set h264 level to %d (%d)\n",
	ctrl->val, h264_level[ctrl->val]);

	return 0;
	}

	static int set_bitrate_mode(struct v4l2_ctrl *ctrl)
	{
	struct vpu_ctx *ctx = v4l2_ctrl_to_ctx(ctrl);
	struct vpu_attr *attr = get_vpu_ctx_attr(ctx);
	pMEDIAIP_ENC_PARAM param = &attr->param;

	mutex_lock(&ctx->instance_mutex);
	switch (ctrl->val) {
	case V4L2_MPEG_VIDEO_BITRATE_MODE_VBR:
	vpu_dbg(LVL_CTRL, "set bitrate mode VBR\n");
	param->eBitRateMode =
	MEDIAIP_ENC_BITRATECONTROLMODE_CONSTANT_QP;
	break;
	case V4L2_MPEG_VIDEO_BITRATE_MODE_CBR:
	vpu_dbg(LVL_CTRL, "set bitrate mode CBR\n");
	param->eBitRateMode = MEDIAIP_ENC_BITRATECONTROLMODE_CBR;
	break;
	default:
	vpu_err("not support bitrate mode %d, set to cbr\n",
	ctrl->val);
	param->eBitRateMode = MEDIAIP_ENC_BITRATECONTROLMODE_CBR;
	break;
	}
	mutex_unlock(&ctx->instance_mutex);

	return 0;
	}

	static int set_bitrate(struct v4l2_ctrl *ctrl)
	{
	struct vpu_ctx *ctx = v4l2_ctrl_to_ctx(ctrl);
	struct vpu_attr *attr = get_vpu_ctx_attr(ctx);
	pMEDIAIP_ENC_PARAM param = &attr->param;

	vpu_dbg(LVL_CTRL, "set bitrate %d\n", ctrl->val);
	mutex_lock(&ctx->instance_mutex);
	param->uTargetBitrate = ctrl->val / BITRATE_COEF;
	if (param->uMaxBitRate < param->uTargetBitrate)
	param->uMaxBitRate = param->uTargetBitrate;
	mutex_unlock(&ctx->instance_mutex);

	return 0;
	}

	static int set_bitrate_peak(struct v4l2_ctrl *ctrl)
	{
	struct vpu_ctx *ctx = v4l2_ctrl_to_ctx(ctrl);
	struct vpu_attr *attr = get_vpu_ctx_attr(ctx);
	pMEDIAIP_ENC_PARAM param = &attr->param;

	vpu_dbg(LVL_CTRL, "set peak bitrate %d\n", ctrl->val);
	mutex_lock(&ctx->instance_mutex);
	param->uMaxBitRate = ctrl->val / BITRATE_COEF;
	if (param->uTargetBitrate > param->uMaxBitRate)
	param->uTargetBitrate = param->uMaxBitRate;
	mutex_unlock(&ctx->instance_mutex);

	return 0;
	}

	static int set_gop_size(struct v4l2_ctrl *ctrl)
	{
	struct vpu_ctx *ctx = v4l2_ctrl_to_ctx(ctrl);
	struct vpu_attr *attr = get_vpu_ctx_attr(ctx);
	pMEDIAIP_ENC_PARAM param = &attr->param;

	vpu_dbg(LVL_CTRL, "set gop size %d\n", ctrl->val);
	mutex_lock(&ctx->instance_mutex);
	param->uIFrameInterval = ctrl->val;
	mutex_unlock(&ctx->instance_mutex);

	return 0;
	}

	static int set_i_period(struct v4l2_ctrl *ctrl)
	{
	struct vpu_ctx *ctx = v4l2_ctrl_to_ctx(ctrl);
	struct vpu_attr *attr = get_vpu_ctx_attr(ctx);
	pMEDIAIP_ENC_PARAM param = &attr->param;

	vpu_dbg(LVL_CTRL, "set iframe interval %d\n", ctrl->val);
	mutex_lock(&ctx->instance_mutex);
	param->uIFrameInterval = ctrl->val;
	mutex_unlock(&ctx->instance_mutex);

	return 0;
	}

	static int get_gop_size(struct v4l2_ctrl *ctrl)
	{
	struct vpu_ctx *ctx = v4l2_ctrl_to_ctx(ctrl);
	struct vpu_attr *attr = get_vpu_ctx_attr(ctx);
	pMEDIAIP_ENC_PARAM param = &attr->param;

	vpu_dbg(LVL_CTRL, "get gop size\n");
	ctrl->val = param->uIFrameInterval;

	return 0;
	}

	static int set_b_frames(struct v4l2_ctrl *ctrl)
	{
	struct vpu_ctx *ctx = v4l2_ctrl_to_ctx(ctrl);
	struct vpu_attr *attr = get_vpu_ctx_attr(ctx);
	pMEDIAIP_ENC_PARAM param = &attr->param;

	vpu_dbg(LVL_CTRL, "set bframes %d\n", ctrl->val);
	mutex_lock(&ctx->instance_mutex);
	param->uGopBLength = ctrl->val;
	mutex_unlock(&ctx->instance_mutex);

	return 0;
	}

	static int set_qp(struct v4l2_ctrl *ctrl)
	{
	struct vpu_ctx *ctx = v4l2_ctrl_to_ctx(ctrl);
	struct vpu_attr *attr = get_vpu_ctx_attr(ctx);
	pMEDIAIP_ENC_PARAM param = &attr->param;

	vpu_dbg(LVL_CTRL, "set qp %d\n", ctrl->val);
	mutex_lock(&ctx->instance_mutex);
	param->uInitSliceQP = ctrl->val;
	mutex_unlock(&ctx->instance_mutex);

	return 0;
	}

	static int get_min_buffers_for_output(struct v4l2_ctrl *ctrl)
	{
	vpu_dbg(LVL_CTRL, "get min buffers for output\n");

	ctrl->val = MIN_BUFFER_COUNT;

	return 0;
	}

	static int set_display_re_ordering(struct v4l2_ctrl *ctrl)
	{
	struct vpu_ctx *ctx = v4l2_ctrl_to_ctx(ctrl);
	struct vpu_attr *attr = get_vpu_ctx_attr(ctx);
	pMEDIAIP_ENC_PARAM param = &attr->param;

	vpu_dbg(LVL_CTRL, "set lowlatencymode %d\n", ctrl->val);
	mutex_lock(&ctx->instance_mutex);
	if (ctrl->val)
	param->uLowLatencyMode = 1;
	else
	param->uLowLatencyMode = 0;
	mutex_unlock(&ctx->instance_mutex);

	return 0;
	}

	static int set_force_key_frame(struct v4l2_ctrl *ctrl)
	{
	struct vpu_ctx *ctx = v4l2_ctrl_to_ctx(ctrl);

	vpu_dbg(LVL_CTRL, "force key frame\n");
	set_bit(VPU_ENC_STATUS_KEY_FRAME, &ctx->status);

	return 0;
	}

	static int add_ctrl_h264_profile(struct vpu_ctx *ctx)
	{
	static const struct v4l2_ctrl_ops ctrl_h264_profile_ops = {
	.s_ctrl = set_h264_profile,
	};
	struct v4l2_ctrl *ctrl;

	ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrl_handler,
	&ctrl_h264_profile_ops,
	V4L2_CID_MPEG_VIDEO_H264_PROFILE,
	V4L2_MPEG_VIDEO_H264_PROFILE_HIGH,
	0xa,
	V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE);
	if (!ctrl) {
	vpu_err("add ctrl h264 profile fail\n");
	return -EINVAL;
	}

	return 0;
	}

	static int add_ctrl_h264_level(struct vpu_ctx *ctx)
	{
	static const struct v4l2_ctrl_ops ctrl_h264_level_ops = {
	.s_ctrl = set_h264_level,
	};
	struct v4l2_ctrl *ctrl;

	ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrl_handler,
	&ctrl_h264_level_ops,
	V4L2_CID_MPEG_VIDEO_H264_LEVEL,
	V4L2_MPEG_VIDEO_H264_LEVEL_5_1,
	0x0,
	V4L2_MPEG_VIDEO_H264_LEVEL_4_0);
	if (!ctrl) {
	vpu_err("add ctrl h264 level fail\n");
	return -EINVAL;
	}

	return 0;
	}

	static int add_ctrl_bitrate_mode(struct vpu_ctx *ctx)
	{
	static const struct v4l2_ctrl_ops ctrl_bitrate_mode_ops = {
	.s_ctrl = set_bitrate_mode,
	};
	struct v4l2_ctrl *ctrl;

	ctrl = v4l2_ctrl_new_std_menu(&ctx->ctrl_handler,
	&ctrl_bitrate_mode_ops,
	V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
	V4L2_MPEG_VIDEO_BITRATE_MODE_CBR,
	0x0,
	V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
	if (!ctrl) {
	vpu_err("add ctrl bitrate mode fail\n");
	return -EINVAL;
	}

	return 0;
	}

	static int add_ctrl_bitrate(struct vpu_ctx *ctx)
	{
	static const struct v4l2_ctrl_ops ctrl_bitrate_ops = {
	.s_ctrl = set_bitrate,
	};
	struct v4l2_ctrl *ctrl;

	ctrl = v4l2_ctrl_new_std(&ctx->ctrl_handler,
	&ctrl_bitrate_ops,
	V4L2_CID_MPEG_VIDEO_BITRATE,
	BITRATE_LOW_THRESHOLD * BITRATE_COEF,
	BITRATE_HIGH_THRESHOLD * BITRATE_COEF,
	BITRATE_COEF,
	BITRATE_DEFAULT_TARGET * BITRATE_COEF);
	if (!ctrl) {
	vpu_err("add ctrl bitrate fail\n");
	return -EINVAL;
	}

	return 0;
	}

	static int add_ctrl_bitrate_peak(struct vpu_ctx *ctx)
	{
	static const struct v4l2_ctrl_ops ctrl_bitrate_ops = {
	.s_ctrl = set_bitrate_peak,
	};
	struct v4l2_ctrl *ctrl;

	ctrl = v4l2_ctrl_new_std(&ctx->ctrl_handler,
	&ctrl_bitrate_ops,
	V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
	BITRATE_LOW_THRESHOLD * BITRATE_COEF,
	BITRATE_HIGH_THRESHOLD * BITRATE_COEF,
	BITRATE_COEF,
	BITRATE_DEFAULT_PEAK * BITRATE_COEF);
	if (!ctrl) {
	vpu_err("add ctrl bitrate peak fail\n");
	return -EINVAL;
	}

	return 0;
	}

	static int add_ctrl_gop_size(struct vpu_ctx *ctx)
	{
	static const struct v4l2_ctrl_ops ctrl_gop_ops = {
	.s_ctrl = set_gop_size,
	.g_volatile_ctrl = get_gop_size,
	};
	struct v4l2_ctrl *ctrl;

	ctrl = v4l2_ctrl_new_std(&ctx->ctrl_handler,
	&ctrl_gop_ops,
	V4L2_CID_MPEG_VIDEO_GOP_SIZE,
	GOP_L_THRESHOLD,
	GOP_H_THRESHOLD,
	1,
	GOP_DEFAULT);
	if (!ctrl) {
	vpu_err("add ctrl gop size fail\n");
	return -EINVAL;
	}

	ctrl->flags \|= V4L2_CTRL_FLAG_VOLATILE;
	ctrl->flags \|= V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;

	return 0;
	}

	static int add_ctrl_i_period(struct vpu_ctx *ctx)
	{
	static const struct v4l2_ctrl_ops ctrl_i_period_ops = {
	.s_ctrl = set_i_period,
	.g_volatile_ctrl = get_gop_size,
	};
	struct v4l2_ctrl *ctrl;

	ctrl = v4l2_ctrl_new_std(&ctx->ctrl_handler,
	&ctrl_i_period_ops,
	V4L2_CID_MPEG_VIDEO_H264_I_PERIOD,
	GOP_L_THRESHOLD,
	GOP_H_THRESHOLD,
	1,
	GOP_DEFAULT);

	if (!ctrl) {
	vpu_err("add ctrl i period fail\n");
	return -EINVAL;
	}

	ctrl->flags \|= V4L2_CTRL_FLAG_VOLATILE;
	ctrl->flags \|= V4L2_CTRL_FLAG_EXECUTE_ON_WRITE;

	return 0;
	}

	static int add_ctrl_b_frames(struct vpu_ctx *ctx)
	{
	static const struct v4l2_ctrl_ops ctrl_b_frames = {
	.s_ctrl = set_b_frames,
	};
	struct v4l2_ctrl *ctrl;

	ctrl = v4l2_ctrl_new_std(&ctx->ctrl_handler,
	&ctrl_b_frames,
	V4L2_CID_MPEG_VIDEO_B_FRAMES,
	BFRAMES_L_THRESHOLD,
	BFRAMES_H_THRESHOLD,
	1,
	BFRAMES_DEFAULT);

	if (!ctrl) {
	vpu_err("add ctrl b frames fail\n");
	return -EINVAL;
	}

	return 0;
	}

	static int add_ctrl_i_frame_qp(struct vpu_ctx *ctx)
	{
	static const struct v4l2_ctrl_ops ctrl_iframe_qp_ops = {
	.s_ctrl = set_qp,
	};
	struct v4l2_ctrl *ctrl;

	ctrl = v4l2_ctrl_new_std(&ctx->ctrl_handler,
	&ctrl_iframe_qp_ops,
	V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP,
	QP_MIN,
	QP_MAX,
	1,
	QP_DEFAULT);
	if (!ctrl) {
	vpu_err("add ctrl h264 I frame qp fail\n");
	return -EINVAL;
	}

	return 0;
	}

	static int add_ctrl_p_frame_qp(struct vpu_ctx *ctx)
	{
	static const struct v4l2_ctrl_ops ctrl_pframe_qp_ops = {
	.s_ctrl = set_qp,
	};
	struct v4l2_ctrl *ctrl;

	ctrl = v4l2_ctrl_new_std(&ctx->ctrl_handler,
	&ctrl_pframe_qp_ops,
	V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP,
	QP_MIN,
	QP_MAX,
	1,
	QP_DEFAULT);
	if (!ctrl) {
	vpu_err("add ctrl h264 P frame qp fail\n");
	return -EINVAL;
	}

	return 0;
	}

	static int add_ctrl_b_frame_qp(struct vpu_ctx *ctx)
	{
	static const struct v4l2_ctrl_ops ctrl_bframe_qp_ops = {
	.s_ctrl = set_qp,
	};
	struct v4l2_ctrl *ctrl;

	ctrl = v4l2_ctrl_new_std(&ctx->ctrl_handler,
	&ctrl_bframe_qp_ops,
	V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP,
	QP_MIN,
	QP_MAX,
	1,
	QP_DEFAULT);
	if (!ctrl) {
	vpu_err("add ctrl h264 B frame qp fail\n");
	return -EINVAL;
	}

	return 0;
	}

	static int add_ctrl_min_buffers_for_output(struct vpu_ctx *ctx)
	{
	static const struct v4l2_ctrl_ops ctrl_min_buffers_ops = {
	.g_volatile_ctrl = get_min_buffers_for_output,
	};
	struct v4l2_ctrl *ctrl;

	ctrl = v4l2_ctrl_new_std(&ctx->ctrl_handler,
	&ctrl_min_buffers_ops,
	V4L2_CID_MIN_BUFFERS_FOR_OUTPUT,
	1,
	32,
	1,
	MIN_BUFFER_COUNT);
	if (!ctrl) {
	vpu_err("add ctrl min buffers for output fail\n");
	return -EINVAL;
	}

	ctrl->flags \|= V4L2_CTRL_FLAG_VOLATILE;

	return 0;
	}

	static int add_ctrl_display_re_ordering(struct vpu_ctx *ctx)
	{
	static const struct v4l2_ctrl_ops re_ordering_ops = {
	.s_ctrl = set_display_re_ordering,
	};
	struct v4l2_ctrl *ctrl;

	ctrl = v4l2_ctrl_new_std(&ctx->ctrl_handler,
	&re_ordering_ops,
	V4L2_CID_MPEG_VIDEO_H264_ASO,
	0, 1, 1, 1);
	if (!ctrl) {
	vpu_err("add ctrl display re ordering fail\n");
	return -EINVAL;
	}

	return 0;
	}

	static int add_ctrl_force_key_frame(struct vpu_ctx *ctx)
	{
	static const struct v4l2_ctrl_ops force_key_frame_ops = {
	.s_ctrl = set_force_key_frame,
	};
	struct v4l2_ctrl *ctrl;

	ctrl = v4l2_ctrl_new_std(&ctx->ctrl_handler,
	&force_key_frame_ops,
	V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME,
	0, 0, 0, 0);
	if (!ctrl) {
	vpu_err("add ctrl force key frame fail\n");
	return -EINVAL;
	}

	return 0;
	}

	static int vpu_enc_register_ctrls(struct vpu_ctx *ctx)
	{
	add_ctrl_h264_profile(ctx);
	add_ctrl_h264_level(ctx);
	add_ctrl_bitrate_mode(ctx);
	add_ctrl_bitrate(ctx);
	add_ctrl_bitrate_peak(ctx);
	add_ctrl_gop_size(ctx);
	add_ctrl_i_period(ctx);
	add_ctrl_b_frames(ctx);
	add_ctrl_i_frame_qp(ctx);
	add_ctrl_p_frame_qp(ctx);
	add_ctrl_b_frame_qp(ctx);
	add_ctrl_min_buffers_for_output(ctx);
	add_ctrl_display_re_ordering(ctx);
	add_ctrl_force_key_frame(ctx);

	return 0;
	}

	int vpu_enc_setup_ctrls(struct vpu_ctx *ctx)
	{
	vpu_log_func();

	v4l2_ctrl_handler_init(&ctx->ctrl_handler, 11);
	vpu_enc_register_ctrls(ctx);
	if (ctx->ctrl_handler.error) {
	vpu_err("control initialization error (%d)\n",
	ctx->ctrl_handler.error);
	return -EINVAL;
	}
	ctx->ctrl_inited = true;
	return v4l2_ctrl_handler_setup(&ctx->ctrl_handler);
	}

	int vpu_enc_free_ctrls(struct vpu_ctx *ctx)
	{
	vpu_log_func();

	if (ctx->ctrl_inited) {
	v4l2_ctrl_handler_free(&ctx->ctrl_handler);
	ctx->ctrl_inited = false;
	}

	return 0;
	}