1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.
4  * Copyright (C) 2017 Linaro Ltd.
5  */
6 #include <linux/types.h>
7 #include <media/v4l2-ctrls.h>
8 
9 #include "core.h"
10 #include "venc.h"
11 #include "helpers.h"
12 
13 #define BITRATE_MIN		32000
14 #define BITRATE_MAX		160000000
15 #define BITRATE_DEFAULT		1000000
16 #define BITRATE_DEFAULT_PEAK	(BITRATE_DEFAULT * 2)
17 #define BITRATE_STEP		100
18 #define SLICE_BYTE_SIZE_MAX	1024
19 #define SLICE_BYTE_SIZE_MIN	1024
20 #define SLICE_MB_SIZE_MAX	300
21 #define AT_SLICE_BOUNDARY	\
22 	V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED_AT_SLICE_BOUNDARY
23 #define MAX_LTR_FRAME_COUNT 4
24 
25 static int venc_calc_bpframes(u32 gop_size, u32 conseq_b, u32 *bf, u32 *pf)
26 {
27 	u32 half = (gop_size - 1) >> 1;
28 	u32 b, p, ratio;
29 	bool found = false;
30 
31 	if (!gop_size)
32 		return -EINVAL;
33 
34 	*bf = *pf = 0;
35 
36 	if (!conseq_b) {
37 		*pf = gop_size -  1;
38 		return 0;
39 	}
40 
41 	b = p = half;
42 
43 	for (; b <= gop_size - 1; b++, p--) {
44 		if (b % p)
45 			continue;
46 
47 		ratio = b / p;
48 
49 		if (ratio == conseq_b) {
50 			found = true;
51 			break;
52 		}
53 
54 		if (ratio > conseq_b)
55 			break;
56 	}
57 
58 	if (!found)
59 		return -EINVAL;
60 
61 	if (b + p + 1 != gop_size)
62 		return -EINVAL;
63 
64 	*bf = b;
65 	*pf = p;
66 
67 	return 0;
68 }
69 
70 static int venc_op_s_ctrl(struct v4l2_ctrl *ctrl)
71 {
72 	struct venus_inst *inst = ctrl_to_inst(ctrl);
73 	struct venc_controls *ctr = &inst->controls.enc;
74 	struct hfi_enable en = { .enable = 1 };
75 	struct hfi_bitrate brate;
76 	struct hfi_ltr_use ltr_use;
77 	struct hfi_ltr_mark ltr_mark;
78 	u32 bframes;
79 	u32 ptype;
80 	int ret;
81 
82 	switch (ctrl->id) {
83 	case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
84 		ctr->bitrate_mode = ctrl->val;
85 		break;
86 	case V4L2_CID_MPEG_VIDEO_BITRATE:
87 		ctr->bitrate = ctrl->val;
88 		mutex_lock(&inst->lock);
89 		if (inst->streamon_out && inst->streamon_cap) {
90 			ptype = HFI_PROPERTY_CONFIG_VENC_TARGET_BITRATE;
91 			brate.bitrate = ctr->bitrate;
92 			brate.layer_id = 0;
93 
94 			ret = hfi_session_set_property(inst, ptype, &brate);
95 			if (ret) {
96 				mutex_unlock(&inst->lock);
97 				return ret;
98 			}
99 		}
100 		mutex_unlock(&inst->lock);
101 		break;
102 	case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
103 		ctr->bitrate_peak = ctrl->val;
104 		break;
105 	case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
106 		ctr->h264_entropy_mode = ctrl->val;
107 		break;
108 	case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
109 		ctr->profile.mpeg4 = ctrl->val;
110 		break;
111 	case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
112 		ctr->profile.h264 = ctrl->val;
113 		break;
114 	case V4L2_CID_MPEG_VIDEO_HEVC_PROFILE:
115 		ctr->profile.hevc = ctrl->val;
116 		break;
117 	case V4L2_CID_MPEG_VIDEO_VP8_PROFILE:
118 		ctr->profile.vp8 = ctrl->val;
119 		break;
120 	case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
121 		ctr->level.mpeg4 = ctrl->val;
122 		break;
123 	case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
124 		ctr->level.h264 = ctrl->val;
125 		break;
126 	case V4L2_CID_MPEG_VIDEO_HEVC_LEVEL:
127 		ctr->level.hevc = ctrl->val;
128 		break;
129 	case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP:
130 		ctr->h264_i_qp = ctrl->val;
131 		break;
132 	case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP:
133 		ctr->h264_p_qp = ctrl->val;
134 		break;
135 	case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP:
136 		ctr->h264_b_qp = ctrl->val;
137 		break;
138 	case V4L2_CID_MPEG_VIDEO_H264_MIN_QP:
139 		ctr->h264_min_qp = ctrl->val;
140 		break;
141 	case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_MIN_QP:
142 		ctr->h264_i_min_qp = ctrl->val;
143 		break;
144 	case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_MIN_QP:
145 		ctr->h264_p_min_qp = ctrl->val;
146 		break;
147 	case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_MIN_QP:
148 		ctr->h264_b_min_qp = ctrl->val;
149 		break;
150 	case V4L2_CID_MPEG_VIDEO_H264_MAX_QP:
151 		ctr->h264_max_qp = ctrl->val;
152 		break;
153 	case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_MAX_QP:
154 		ctr->h264_i_max_qp = ctrl->val;
155 		break;
156 	case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_MAX_QP:
157 		ctr->h264_p_max_qp = ctrl->val;
158 		break;
159 	case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_MAX_QP:
160 		ctr->h264_b_max_qp = ctrl->val;
161 		break;
162 	case V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_QP:
163 		ctr->hevc_i_qp = ctrl->val;
164 		break;
165 	case V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_QP:
166 		ctr->hevc_p_qp = ctrl->val;
167 		break;
168 	case V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_QP:
169 		ctr->hevc_b_qp = ctrl->val;
170 		break;
171 	case V4L2_CID_MPEG_VIDEO_HEVC_MIN_QP:
172 		ctr->hevc_min_qp = ctrl->val;
173 		break;
174 	case V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_MIN_QP:
175 		ctr->hevc_i_min_qp = ctrl->val;
176 		break;
177 	case V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_MIN_QP:
178 		ctr->hevc_p_min_qp = ctrl->val;
179 		break;
180 	case V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_MIN_QP:
181 		ctr->hevc_b_min_qp = ctrl->val;
182 		break;
183 	case V4L2_CID_MPEG_VIDEO_HEVC_MAX_QP:
184 		ctr->hevc_max_qp = ctrl->val;
185 		break;
186 	case V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_MAX_QP:
187 		ctr->hevc_i_max_qp = ctrl->val;
188 		break;
189 	case V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_MAX_QP:
190 		ctr->hevc_p_max_qp = ctrl->val;
191 		break;
192 	case V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_MAX_QP:
193 		ctr->hevc_b_max_qp = ctrl->val;
194 		break;
195 	case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE:
196 		ctr->multi_slice_mode = ctrl->val;
197 		break;
198 	case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES:
199 		ctr->multi_slice_max_bytes = ctrl->val;
200 		break;
201 	case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB:
202 		ctr->multi_slice_max_mb = ctrl->val;
203 		break;
204 	case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA:
205 		ctr->h264_loop_filter_alpha = ctrl->val;
206 		break;
207 	case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA:
208 		ctr->h264_loop_filter_beta = ctrl->val;
209 		break;
210 	case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
211 		ctr->h264_loop_filter_mode = ctrl->val;
212 		break;
213 	case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
214 		ctr->header_mode = ctrl->val;
215 		mutex_lock(&inst->lock);
216 		if (inst->streamon_out && inst->streamon_cap) {
217 			if (ctrl->val == V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE)
218 				en.enable = 0;
219 			else
220 				en.enable = 1;
221 			ptype = HFI_PROPERTY_CONFIG_VENC_SYNC_FRAME_SEQUENCE_HEADER;
222 			ret = hfi_session_set_property(inst, ptype, &en);
223 			if (ret) {
224 				mutex_unlock(&inst->lock);
225 				return ret;
226 			}
227 		}
228 		mutex_unlock(&inst->lock);
229 		break;
230 	case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
231 		ret = venc_calc_bpframes(ctrl->val, ctr->num_b_frames, &bframes,
232 					 &ctr->num_p_frames);
233 		if (ret)
234 			return ret;
235 
236 		ctr->gop_size = ctrl->val;
237 		break;
238 	case V4L2_CID_MPEG_VIDEO_H264_I_PERIOD:
239 		ctr->h264_i_period = ctrl->val;
240 		break;
241 	case V4L2_CID_MPEG_VIDEO_VPX_MIN_QP:
242 		ctr->vp8_min_qp = ctrl->val;
243 		break;
244 	case V4L2_CID_MPEG_VIDEO_VPX_MAX_QP:
245 		ctr->vp8_max_qp = ctrl->val;
246 		break;
247 	case V4L2_CID_MPEG_VIDEO_B_FRAMES:
248 		ret = venc_calc_bpframes(ctr->gop_size, ctrl->val, &bframes,
249 					 &ctr->num_p_frames);
250 		if (ret)
251 			return ret;
252 
253 		ctr->num_b_frames = bframes;
254 		break;
255 	case V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME:
256 		mutex_lock(&inst->lock);
257 		if (inst->streamon_out && inst->streamon_cap) {
258 			ptype = HFI_PROPERTY_CONFIG_VENC_REQUEST_SYNC_FRAME;
259 			ret = hfi_session_set_property(inst, ptype, &en);
260 
261 			if (ret) {
262 				mutex_unlock(&inst->lock);
263 				return ret;
264 			}
265 		}
266 		mutex_unlock(&inst->lock);
267 		break;
268 	case V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE:
269 		ctr->rc_enable = ctrl->val;
270 		break;
271 	case V4L2_CID_MPEG_VIDEO_CONSTANT_QUALITY:
272 		ctr->const_quality = ctrl->val;
273 		break;
274 	case V4L2_CID_MPEG_VIDEO_FRAME_SKIP_MODE:
275 		ctr->frame_skip_mode = ctrl->val;
276 		break;
277 	case V4L2_CID_MPEG_VIDEO_BASELAYER_PRIORITY_ID:
278 		ctr->base_priority_id = ctrl->val;
279 		break;
280 	case V4L2_CID_MPEG_VIDEO_AU_DELIMITER:
281 		ctr->aud_enable = ctrl->val;
282 		break;
283 	case V4L2_CID_MPEG_VIDEO_LTR_COUNT:
284 		ctr->ltr_count = ctrl->val;
285 		break;
286 	case V4L2_CID_MPEG_VIDEO_FRAME_LTR_INDEX:
287 		mutex_lock(&inst->lock);
288 		if (inst->streamon_out && inst->streamon_cap) {
289 			ptype = HFI_PROPERTY_CONFIG_VENC_MARKLTRFRAME;
290 			ltr_mark.mark_frame = ctrl->val;
291 			ret = hfi_session_set_property(inst, ptype, &ltr_mark);
292 			if (ret) {
293 				mutex_unlock(&inst->lock);
294 				return ret;
295 			}
296 		}
297 		mutex_unlock(&inst->lock);
298 		break;
299 	case V4L2_CID_MPEG_VIDEO_USE_LTR_FRAMES:
300 		mutex_lock(&inst->lock);
301 		if (inst->streamon_out && inst->streamon_cap) {
302 			ptype = HFI_PROPERTY_CONFIG_VENC_USELTRFRAME;
303 			ltr_use.ref_ltr = ctrl->val;
304 			ltr_use.use_constrnt = true;
305 			ltr_use.frames = 0;
306 			ret = hfi_session_set_property(inst, ptype, &ltr_use);
307 			if (ret) {
308 				mutex_unlock(&inst->lock);
309 				return ret;
310 			}
311 		}
312 		mutex_unlock(&inst->lock);
313 		break;
314 	case V4L2_CID_COLORIMETRY_HDR10_CLL_INFO:
315 		ctr->cll = *ctrl->p_new.p_hdr10_cll;
316 		break;
317 	case V4L2_CID_COLORIMETRY_HDR10_MASTERING_DISPLAY:
318 		ctr->mastering = *ctrl->p_new.p_hdr10_mastering;
319 		break;
320 	case V4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIOD_TYPE:
321 		ctr->intra_refresh_type = ctrl->val;
322 		break;
323 	case V4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIOD:
324 		ctr->intra_refresh_period = ctrl->val;
325 		break;
326 	case V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM:
327 		if (ctr->profile.h264 != V4L2_MPEG_VIDEO_H264_PROFILE_HIGH &&
328 		    ctr->profile.h264 != V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_HIGH)
329 			return -EINVAL;
330 
331 		/*
332 		 * In video firmware, 8x8 transform is supported only for
333 		 * high profile(HP) and constrained high profile(CHP).
334 		 * If client wants to disable 8x8 transform for HP/CHP,
335 		 * it is better to set profile as main profile(MP).
336 		 * Because there is no difference between HP and MP
337 		 * if we disable 8x8 transform for HP.
338 		 */
339 
340 
341 		ctr->h264_8x8_transform = ctrl->val;
342 		break;
343 	default:
344 		return -EINVAL;
345 	}
346 
347 	return 0;
348 }
349 
350 static int venc_op_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
351 {
352 	struct venus_inst *inst = ctrl_to_inst(ctrl);
353 	struct hfi_buffer_requirements bufreq;
354 	enum hfi_version ver = inst->core->res->hfi_version;
355 	int ret;
356 
357 	switch (ctrl->id) {
358 	case V4L2_CID_MIN_BUFFERS_FOR_OUTPUT:
359 		ret = venus_helper_get_bufreq(inst, HFI_BUFFER_INPUT, &bufreq);
360 		if (!ret)
361 			ctrl->val = hfi_bufreq_get_count_min(&bufreq, ver);
362 		break;
363 	default:
364 		return -EINVAL;
365 	}
366 
367 	return 0;
368 }
369 
370 static const struct v4l2_ctrl_ops venc_ctrl_ops = {
371 	.s_ctrl = venc_op_s_ctrl,
372 	.g_volatile_ctrl = venc_op_g_volatile_ctrl,
373 };
374 
375 int venc_ctrl_init(struct venus_inst *inst)
376 {
377 	int ret;
378 	struct v4l2_ctrl_hdr10_mastering_display p_hdr10_mastering = {
379 		{ 34000, 13250, 7500 },
380 		{ 16000, 34500, 3000 }, 15635, 16450, 10000000, 500,
381 	};
382 	struct v4l2_ctrl_hdr10_cll_info p_hdr10_cll = { 1000, 400 };
383 
384 	ret = v4l2_ctrl_handler_init(&inst->ctrl_handler, 59);
385 	if (ret)
386 		return ret;
387 
388 	v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
389 		V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
390 		V4L2_MPEG_VIDEO_BITRATE_MODE_CBR,
391 		~((1 << V4L2_MPEG_VIDEO_BITRATE_MODE_VBR) |
392 		  (1 << V4L2_MPEG_VIDEO_BITRATE_MODE_CBR) |
393 		  (1 << V4L2_MPEG_VIDEO_BITRATE_MODE_CQ)),
394 		V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
395 
396 	v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
397 		V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE,
398 		V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CABAC,
399 		0, V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC);
400 
401 	v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
402 		V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE,
403 		V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_CODING_EFFICIENCY,
404 		~((1 << V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE) |
405 		  (1 << V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_SIMPLE)),
406 		V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE);
407 
408 	v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
409 		V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL,
410 		V4L2_MPEG_VIDEO_MPEG4_LEVEL_5,
411 		0, V4L2_MPEG_VIDEO_MPEG4_LEVEL_0);
412 
413 	v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
414 		V4L2_CID_MPEG_VIDEO_HEVC_PROFILE,
415 		V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_10,
416 		~((1 << V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN) |
417 		  (1 << V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_STILL_PICTURE) |
418 		  (1 << V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN_10)),
419 		V4L2_MPEG_VIDEO_HEVC_PROFILE_MAIN);
420 
421 	v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
422 		V4L2_CID_MPEG_VIDEO_HEVC_LEVEL,
423 		V4L2_MPEG_VIDEO_HEVC_LEVEL_6_2,
424 		0, V4L2_MPEG_VIDEO_HEVC_LEVEL_1);
425 
426 	v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
427 		V4L2_CID_MPEG_VIDEO_H264_PROFILE,
428 		V4L2_MPEG_VIDEO_H264_PROFILE_MULTIVIEW_HIGH,
429 		~((1 << V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE) |
430 		  (1 << V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE) |
431 		  (1 << V4L2_MPEG_VIDEO_H264_PROFILE_MAIN) |
432 		  (1 << V4L2_MPEG_VIDEO_H264_PROFILE_HIGH) |
433 		  (1 << V4L2_MPEG_VIDEO_H264_PROFILE_STEREO_HIGH) |
434 		  (1 << V4L2_MPEG_VIDEO_H264_PROFILE_MULTIVIEW_HIGH)),
435 		V4L2_MPEG_VIDEO_H264_PROFILE_HIGH);
436 
437 	v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
438 		V4L2_CID_MPEG_VIDEO_H264_LEVEL,
439 		V4L2_MPEG_VIDEO_H264_LEVEL_5_1,
440 		0, V4L2_MPEG_VIDEO_H264_LEVEL_1_0);
441 
442 	v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
443 		V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE,
444 		AT_SLICE_BOUNDARY,
445 		0, V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED);
446 
447 	v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
448 		V4L2_CID_MPEG_VIDEO_HEADER_MODE,
449 		V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME,
450 		~((1 << V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE) |
451 		(1 << V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME)),
452 		V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME);
453 
454 	v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
455 		V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE,
456 		V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_MAX_BYTES,
457 		0, V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE);
458 
459 	v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
460 		V4L2_CID_MPEG_VIDEO_VP8_PROFILE,
461 		V4L2_MPEG_VIDEO_VP8_PROFILE_3,
462 		0, V4L2_MPEG_VIDEO_VP8_PROFILE_0);
463 
464 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
465 			  V4L2_CID_MIN_BUFFERS_FOR_OUTPUT, 4, 11, 1, 4);
466 
467 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
468 		V4L2_CID_MPEG_VIDEO_BITRATE, BITRATE_MIN, BITRATE_MAX,
469 		BITRATE_STEP, BITRATE_DEFAULT);
470 
471 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
472 		V4L2_CID_MPEG_VIDEO_BITRATE_PEAK, BITRATE_MIN, BITRATE_MAX,
473 		BITRATE_STEP, BITRATE_DEFAULT_PEAK);
474 
475 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
476 			  V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP, 1, 51, 1, 26);
477 
478 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
479 			  V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP, 1, 51, 1, 28);
480 
481 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
482 			  V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP, 1, 51, 1, 30);
483 
484 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
485 			  V4L2_CID_MPEG_VIDEO_H264_MIN_QP, 1, 51, 1, 1);
486 
487 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
488 			  V4L2_CID_MPEG_VIDEO_H264_I_FRAME_MIN_QP, 1, 51, 1, 1);
489 
490 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
491 			  V4L2_CID_MPEG_VIDEO_H264_8X8_TRANSFORM, 0, 1, 1, 1);
492 
493 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
494 			  V4L2_CID_MPEG_VIDEO_H264_P_FRAME_MIN_QP, 1, 51, 1, 1);
495 
496 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
497 			  V4L2_CID_MPEG_VIDEO_H264_B_FRAME_MIN_QP, 1, 51, 1, 1);
498 
499 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
500 			  V4L2_CID_MPEG_VIDEO_H264_MAX_QP, 1, 51, 1, 51);
501 
502 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
503 			  V4L2_CID_MPEG_VIDEO_H264_I_FRAME_MAX_QP, 1, 51, 1, 51);
504 
505 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
506 			  V4L2_CID_MPEG_VIDEO_H264_P_FRAME_MAX_QP, 1, 51, 1, 51);
507 
508 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
509 			  V4L2_CID_MPEG_VIDEO_H264_B_FRAME_MAX_QP, 1, 51, 1, 51);
510 
511 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
512 			  V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_QP, 1, 63, 1, 26);
513 
514 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
515 			  V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_QP, 1, 63, 1, 28);
516 
517 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
518 			  V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_QP, 1, 63, 1, 30);
519 
520 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
521 			  V4L2_CID_MPEG_VIDEO_HEVC_MIN_QP, 1, 63, 1, 1);
522 
523 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
524 			  V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_MIN_QP, 1, 63, 1, 1);
525 
526 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
527 			  V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_MIN_QP, 1, 63, 1, 1);
528 
529 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
530 			  V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_MIN_QP, 1, 63, 1, 1);
531 
532 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
533 			  V4L2_CID_MPEG_VIDEO_HEVC_MAX_QP, 1, 63, 1, 63);
534 
535 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
536 			  V4L2_CID_MPEG_VIDEO_HEVC_I_FRAME_MAX_QP, 1, 63, 1, 63);
537 
538 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
539 			  V4L2_CID_MPEG_VIDEO_HEVC_P_FRAME_MAX_QP, 1, 63, 1, 63);
540 
541 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
542 			  V4L2_CID_MPEG_VIDEO_HEVC_B_FRAME_MAX_QP, 1, 63, 1, 63);
543 
544 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
545 		V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES, SLICE_BYTE_SIZE_MIN,
546 		SLICE_BYTE_SIZE_MAX, 1, SLICE_BYTE_SIZE_MIN);
547 
548 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
549 		V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB, 1,
550 		SLICE_MB_SIZE_MAX, 1, 1);
551 
552 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
553 		V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA, -6, 6, 1, 0);
554 
555 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
556 		V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA, -6, 6, 1, 0);
557 
558 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
559 		V4L2_CID_MPEG_VIDEO_GOP_SIZE, 0, (1 << 16) - 1, 1, 30);
560 
561 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
562 		V4L2_CID_MPEG_VIDEO_VPX_MIN_QP, 1, 128, 1, 1);
563 
564 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
565 		V4L2_CID_MPEG_VIDEO_VPX_MAX_QP, 1, 128, 1, 128);
566 
567 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
568 		V4L2_CID_MPEG_VIDEO_B_FRAMES, 0, 4, 1, 0);
569 
570 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
571 		V4L2_CID_MPEG_VIDEO_H264_I_PERIOD, 0, (1 << 16) - 1, 1, 0);
572 
573 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
574 			  V4L2_CID_MPEG_VIDEO_FORCE_KEY_FRAME, 0, 0, 0, 0);
575 
576 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
577 			  V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE, 0, 1, 1, 1);
578 
579 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
580 			  V4L2_CID_MPEG_VIDEO_CONSTANT_QUALITY, 0, 100, 1, 0);
581 
582 	v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
583 			       V4L2_CID_MPEG_VIDEO_FRAME_SKIP_MODE,
584 			       V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_BUF_LIMIT,
585 			       ~((1 << V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_DISABLED) |
586 			       (1 << V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_BUF_LIMIT)),
587 			       V4L2_MPEG_VIDEO_FRAME_SKIP_MODE_DISABLED);
588 
589 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
590 			  V4L2_CID_MPEG_VIDEO_BASELAYER_PRIORITY_ID, 0,
591 			  6, 1, 0);
592 
593 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
594 			  V4L2_CID_MPEG_VIDEO_AU_DELIMITER, 0, 1, 1, 0);
595 
596 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
597 			  V4L2_CID_MPEG_VIDEO_USE_LTR_FRAMES, 0,
598 			  ((1 << MAX_LTR_FRAME_COUNT) - 1), 0, 0);
599 
600 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
601 			  V4L2_CID_MPEG_VIDEO_LTR_COUNT, 0,
602 			  MAX_LTR_FRAME_COUNT, 1, 0);
603 
604 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
605 			  V4L2_CID_MPEG_VIDEO_FRAME_LTR_INDEX, 0,
606 			  (MAX_LTR_FRAME_COUNT - 1), 1, 0);
607 
608 	v4l2_ctrl_new_std_compound(&inst->ctrl_handler, &venc_ctrl_ops,
609 				   V4L2_CID_COLORIMETRY_HDR10_CLL_INFO,
610 				   v4l2_ctrl_ptr_create(&p_hdr10_cll));
611 
612 	v4l2_ctrl_new_std_compound(&inst->ctrl_handler, &venc_ctrl_ops,
613 				   V4L2_CID_COLORIMETRY_HDR10_MASTERING_DISPLAY,
614 				   v4l2_ctrl_ptr_create((void *)&p_hdr10_mastering));
615 
616 	v4l2_ctrl_new_std_menu(&inst->ctrl_handler, &venc_ctrl_ops,
617 			       V4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIOD_TYPE,
618 			       V4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIOD_TYPE_CYCLIC,
619 			       0, V4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIOD_TYPE_RANDOM);
620 
621 	v4l2_ctrl_new_std(&inst->ctrl_handler, &venc_ctrl_ops,
622 			  V4L2_CID_MPEG_VIDEO_INTRA_REFRESH_PERIOD, 0,
623 			  ((4096 * 2304) >> 8), 1, 0);
624 
625 	ret = inst->ctrl_handler.error;
626 	if (ret)
627 		goto err;
628 
629 	ret = v4l2_ctrl_handler_setup(&inst->ctrl_handler);
630 	if (ret)
631 		goto err;
632 
633 	return 0;
634 err:
635 	v4l2_ctrl_handler_free(&inst->ctrl_handler);
636 	return ret;
637 }
638 
639 void venc_ctrl_deinit(struct venus_inst *inst)
640 {
641 	v4l2_ctrl_handler_free(&inst->ctrl_handler);
642 }
643