Gitiles
Code Review Sign In
gerrit-public.fairphone.software / kernel / msm-4.9 / 140a23e0dfec6ddf09d3426b288e2653251f666d / . / drivers / media / platform / msm / vidc_3x / msm_venc.c
blob: 50ec4bdb3bffda5b1457d2d312c3d6a75491b378 [file] [log] [blame]
Srinu Gorlecf8c6752018-01-19 18:36:13 +0530[diff] [blame]1/* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
2 *
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License version 2 and
5 * only version 2 as published by the Free Software Foundation.
6 *
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
11 *
12 */
13#include <linux/slab.h>
14#include "msm_vidc_internal.h"
15#include "msm_vidc_common.h"
16#include "vidc_hfi_api.h"
17#include "msm_vidc_debug.h"
18#include "msm_vidc_dcvs.h"
19
20#define MSM_VENC_DVC_NAME "msm_venc_8974"
21#define MIN_NUM_OUTPUT_BUFFERS 4
22#define MIN_NUM_CAPTURE_BUFFERS 4
23#define MIN_BIT_RATE 32000
24#define MAX_BIT_RATE 300000000
25#define DEFAULT_BIT_RATE 64000
26#define BIT_RATE_STEP 100
27#define DEFAULT_FRAME_RATE 15
28#define MAX_OPERATING_FRAME_RATE (300 << 16)
29#define OPERATING_FRAME_RATE_STEP (1 << 16)
30#define MAX_SLICE_BYTE_SIZE ((MAX_BIT_RATE)>>3)
31#define MIN_SLICE_BYTE_SIZE 512
32#define MAX_SLICE_MB_SIZE ((4096 * 2304) >> 8)
33#define I_FRAME_QP 26
34#define P_FRAME_QP 28
35#define B_FRAME_QP 30
36#define MAX_INTRA_REFRESH_MBS ((4096 * 2304) >> 8)
37#define MAX_NUM_B_FRAMES 4
38#define MAX_LTR_FRAME_COUNT 10
39#define MAX_HYBRID_HIER_P_LAYERS 6
40
41#define L_MODE V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED_AT_SLICE_BOUNDARY
42#define CODING V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_CODING_EFFICIENCY
43#define BITSTREAM_RESTRICT_ENABLED \
44 V4L2_MPEG_VIDC_VIDEO_H264_VUI_BITSTREAM_RESTRICT_ENABLED
45#define BITSTREAM_RESTRICT_DISABLED \
46 V4L2_MPEG_VIDC_VIDEO_H264_VUI_BITSTREAM_RESTRICT_DISABLED
47#define MIN_TIME_RESOLUTION 1
48#define MAX_TIME_RESOLUTION 0xFFFFFF
49#define DEFAULT_TIME_RESOLUTION 0x7530
50
51/*
52 * Default 601 to 709 conversion coefficients for resolution: 176x144 negative
53 * coeffs are converted to s4.9 format (e.g. -22 converted to ((1 << 13) - 22)
54 * 3x3 transformation matrix coefficients in s4.9 fixed point format
55 */
56static u32 vpe_csc_601_to_709_matrix_coeff[HAL_MAX_MATRIX_COEFFS] = {
57 470, 8170, 8148, 0, 490, 50, 0, 34, 483
58};
59
60/* offset coefficients in s9 fixed point format */
61static u32 vpe_csc_601_to_709_bias_coeff[HAL_MAX_BIAS_COEFFS] = {
62 34, 0, 4
63};
64
65/* clamping value for Y/U/V([min,max] for Y/U/V) */
66static u32 vpe_csc_601_to_709_limit_coeff[HAL_MAX_LIMIT_COEFFS] = {
67 16, 235, 16, 240, 16, 240
68};
69
70static const char *const mpeg_video_rate_control[] = {
71 "No Rate Control",
72 "VBR VFR",
73 "VBR CFR",
74 "CBR VFR",
75 "CBR CFR",
76 "MBR CFR",
77 "MBR VFR",
78 NULL
79};
80
81static const char *const mpeg_video_rotation[] = {
82 "No Rotation",
83 "90 Degree Rotation",
84 "180 Degree Rotation",
85 "270 Degree Rotation",
86 NULL
87};
88
89static const char *const h264_video_entropy_cabac_model[] = {
90 "Model 0",
91 "Model 1",
92 "Model 2",
93 NULL
94};
95
96static const char *const h263_level[] = {
97 "1.0",
98 "2.0",
99 "3.0",
100 "4.0",
101 "4.5",
102 "5.0",
103 "6.0",
104 "7.0",
105};
106
107static const char *const h263_profile[] = {
108 "Baseline",
109 "H320 Coding",
110 "Backward Compatible",
111 "ISWV2",
112 "ISWV3",
113 "High Compression",
114 "Internet",
115 "Interlace",
116 "High Latency",
117};
118
119static const char *const hevc_tier_level[] = {
120 "Main Tier Level 1",
121 "Main Tier Level 2",
122 "Main Tier Level 2.1",
123 "Main Tier Level 3",
124 "Main Tier Level 3.1",
125 "Main Tier Level 4",
126 "Main Tier Level 4.1",
127 "Main Tier Level 5",
128 "Main Tier Level 5.1",
129 "Main Tier Level 5.2",
130 "Main Tier Level 6",
131 "Main Tier Level 6.1",
132 "Main Tier Level 6.2",
133 "High Tier Level 1",
134 "High Tier Level 2",
135 "High Tier Level 2.1",
136 "High Tier Level 3",
137 "High Tier Level 3.1",
138 "High Tier Level 4",
139 "High Tier Level 4.1",
140 "High Tier Level 5",
141 "High Tier Level 5.1",
142 "High Tier Level 5.2",
143 "High Tier Level 6",
144 "High Tier Level 6.1",
145 "High Tier Level 6.2",
146};
147
148static const char *const hevc_profile[] = {
149 "Main",
150 "Main10",
151 "Main Still Pic",
152};
153
154static const char *const vp8_profile_level[] = {
155 "Unused",
156 "0.0",
157 "1.0",
158 "2.0",
159 "3.0",
160};
161
162static const char *const perf_level[] = {
163 "Nominal",
164 "Performance",
165 "Turbo"
166};
167
168static const char *const mbi_statistics[] = {
169 "Camcorder Default",
170 "Mode 1",
171 "Mode 2",
172 "Mode 3"
173};
174
175static const char *const intra_refresh_modes[] = {
176 "None",
177 "Cyclic",
178 "Adaptive",
179 "Cyclic Adaptive",
180 "Random"
181};
182
183static const char *const timestamp_mode[] = {
184 "Honor",
185 "Ignore",
186};
187
188static const char *const iframe_sizes[] = {
189 "Default",
190 "Medium",
191 "Huge",
192 "Unlimited"
193};
194
195static struct msm_vidc_ctrl msm_venc_ctrls[] = {
196 {
197 .id = V4L2_CID_MPEG_VIDC_VIDEO_IDR_PERIOD,
198 .name = "IDR Period",
199 .type = V4L2_CTRL_TYPE_INTEGER,
200 .minimum = 1,
201 .maximum = INT_MAX,
202 .default_value = DEFAULT_FRAME_RATE,
203 .step = 1,
204 .menu_skip_mask = 0,
205 .qmenu = NULL,
206 },
207 {
208 .id = V4L2_CID_MPEG_VIDC_VIDEO_NUM_P_FRAMES,
209 .name = "Intra Period for P frames",
210 .type = V4L2_CTRL_TYPE_INTEGER,
211 .minimum = 0,
212 .maximum = INT_MAX,
213 .default_value = 2*DEFAULT_FRAME_RATE-1,
214 .step = 1,
215 .menu_skip_mask = 0,
216 .qmenu = NULL,
217 },
218 {
219 .id = V4L2_CID_MPEG_VIDC_VIDEO_NUM_B_FRAMES,
220 .name = "Intra Period for B frames",
221 .type = V4L2_CTRL_TYPE_INTEGER,
222 .minimum = 0,
223 .maximum = INT_MAX,
224 .default_value = 0,
225 .step = 1,
226 .menu_skip_mask = 0,
227 .qmenu = NULL,
228 },
229 {
230 .id = V4L2_CID_MPEG_VIDC_VIDEO_REQUEST_IFRAME,
231 .name = "Request I Frame",
232 .type = V4L2_CTRL_TYPE_BUTTON,
233 .minimum = 0,
234 .maximum = 0,
235 .default_value = 0,
236 .step = 0,
237 .menu_skip_mask = 0,
238 .qmenu = NULL,
239 },
240 {
241 .id = V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL,
242 .name = "Video Framerate and Bitrate Control",
243 .type = V4L2_CTRL_TYPE_MENU,
244 .minimum = V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_OFF,
245 .maximum = V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_MBR_VFR,
246 .default_value = V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_OFF,
247 .step = 0,
248 .menu_skip_mask = ~(
249 (1 << V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_OFF) |
250 (1 << V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_VBR_VFR) |
251 (1 << V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_VBR_CFR) |
252 (1 << V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_CBR_VFR) |
253 (1 << V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_CBR_CFR) |
254 (1 << V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_MBR_CFR) |
255 (1 << V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_MBR_VFR)
256 ),
257 .qmenu = mpeg_video_rate_control,
258 },
259 {
260 .id = V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
261 .name = "Bitrate Control",
262 .type = V4L2_CTRL_TYPE_MENU,
263 .minimum = V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
264 .maximum = V4L2_MPEG_VIDEO_BITRATE_MODE_CBR,
265 .default_value = V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
266 .step = 0,
267 .menu_skip_mask = ~(
268 (1 << V4L2_MPEG_VIDEO_BITRATE_MODE_VBR) |
269 (1 << V4L2_MPEG_VIDEO_BITRATE_MODE_CBR)
270 ),
271 .qmenu = NULL,
272 },
273 {
274 .id = V4L2_CID_MPEG_VIDEO_BITRATE,
275 .name = "Bit Rate",
276 .type = V4L2_CTRL_TYPE_INTEGER,
277 .minimum = MIN_BIT_RATE,
278 .maximum = MAX_BIT_RATE,
279 .default_value = DEFAULT_BIT_RATE,
280 .step = BIT_RATE_STEP,
281 .menu_skip_mask = 0,
282 .qmenu = NULL,
283 },
284 {
285 .id = V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
286 .name = "Peak Bit Rate",
287 .type = V4L2_CTRL_TYPE_INTEGER,
288 .minimum = MIN_BIT_RATE,
289 .maximum = MAX_BIT_RATE,
290 .default_value = DEFAULT_BIT_RATE,
291 .step = BIT_RATE_STEP,
292 .menu_skip_mask = 0,
293 .qmenu = NULL,
294 },
295 {
296 .id = V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE,
297 .name = "Entropy Mode",
298 .type = V4L2_CTRL_TYPE_MENU,
299 .minimum = V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC,
300 .maximum = V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CABAC,
301 .default_value = V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC,
302 .menu_skip_mask = ~(
303 (1 << V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC) |
304 (1 << V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CABAC)
305 ),
306 },
307 {
308 .id = V4L2_CID_MPEG_VIDC_VIDEO_H264_CABAC_MODEL,
309 .name = "CABAC Model",
310 .type = V4L2_CTRL_TYPE_MENU,
311 .minimum = V4L2_CID_MPEG_VIDC_VIDEO_H264_CABAC_MODEL_0,
312 .maximum = V4L2_CID_MPEG_VIDC_VIDEO_H264_CABAC_MODEL_1,
313 .default_value = V4L2_CID_MPEG_VIDC_VIDEO_H264_CABAC_MODEL_0,
314 .menu_skip_mask = ~(
315 (1 << V4L2_CID_MPEG_VIDC_VIDEO_H264_CABAC_MODEL_0) |
316 (1 << V4L2_CID_MPEG_VIDC_VIDEO_H264_CABAC_MODEL_1) |
317 (1 << V4L2_CID_MPEG_VIDC_VIDEO_H264_CABAC_MODEL_2)
318 ),
319 .qmenu = h264_video_entropy_cabac_model,
320 },
321 {
322 .id = V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE,
323 .name = "MPEG4 Profile",
324 .type = V4L2_CTRL_TYPE_MENU,
325 .minimum = V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE,
326 .maximum = CODING,
327 .default_value = V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE,
328 .menu_skip_mask = 0,
329 },
330 {
331 .id = V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL,
332 .name = "MPEG4 Level",
333 .type = V4L2_CTRL_TYPE_MENU,
334 .minimum = V4L2_MPEG_VIDEO_MPEG4_LEVEL_0,
335 .maximum = V4L2_MPEG_VIDEO_MPEG4_LEVEL_5,
336 .default_value = V4L2_MPEG_VIDEO_MPEG4_LEVEL_0,
337 .menu_skip_mask = 0,
338 },
339 {
340 .id = V4L2_CID_MPEG_VIDEO_H264_PROFILE,
341 .name = "H264 Profile",
342 .type = V4L2_CTRL_TYPE_MENU,
343 .minimum = V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE,
344 .maximum = V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_HIGH,
345 .default_value = V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE,
346 .menu_skip_mask = 0,
347 },
348 {
349 .id = V4L2_CID_MPEG_VIDEO_H264_LEVEL,
350 .name = "H264 Level",
351 .type = V4L2_CTRL_TYPE_MENU,
352 .minimum = V4L2_MPEG_VIDEO_H264_LEVEL_1_0,
353 .maximum = V4L2_MPEG_VIDEO_H264_LEVEL_5_2,
354 .default_value = V4L2_MPEG_VIDEO_H264_LEVEL_1_0,
355 .menu_skip_mask = 0,
356 },
357 {
358 .id = V4L2_CID_MPEG_VIDC_VIDEO_H263_PROFILE,
359 .name = "H263 Profile",
360 .type = V4L2_CTRL_TYPE_MENU,
361 .minimum = V4L2_MPEG_VIDC_VIDEO_H263_PROFILE_BASELINE,
362 .maximum = V4L2_MPEG_VIDC_VIDEO_H263_PROFILE_HIGHLATENCY,
363 .default_value = V4L2_MPEG_VIDC_VIDEO_H263_PROFILE_BASELINE,
364 .menu_skip_mask = ~(
365 (1 << V4L2_MPEG_VIDC_VIDEO_H263_PROFILE_BASELINE) |
366 (1 << V4L2_MPEG_VIDC_VIDEO_H263_PROFILE_H320CODING) |
367 (1 << V4L2_MPEG_VIDC_VIDEO_H263_PROFILE_BACKWARDCOMPATIBLE) |
368 (1 << V4L2_MPEG_VIDC_VIDEO_H263_PROFILE_ISWV2) |
369 (1 << V4L2_MPEG_VIDC_VIDEO_H263_PROFILE_ISWV3) |
370 (1 << V4L2_MPEG_VIDC_VIDEO_H263_PROFILE_HIGHCOMPRESSION) |
371 (1 << V4L2_MPEG_VIDC_VIDEO_H263_PROFILE_INTERNET) |
372 (1 << V4L2_MPEG_VIDC_VIDEO_H263_PROFILE_INTERLACE) |
373 (1 << V4L2_MPEG_VIDC_VIDEO_H263_PROFILE_HIGHLATENCY)
374 ),
375 .qmenu = h263_profile,
376 },
377 {
378 .id = V4L2_CID_MPEG_VIDC_VIDEO_H263_LEVEL,
379 .name = "H263 Level",
380 .type = V4L2_CTRL_TYPE_MENU,
381 .minimum = V4L2_MPEG_VIDC_VIDEO_H263_LEVEL_1_0,
382 .maximum = V4L2_MPEG_VIDC_VIDEO_H263_LEVEL_7_0,
383 .default_value = V4L2_MPEG_VIDC_VIDEO_H263_LEVEL_1_0,
384 .menu_skip_mask = ~(
385 (1 << V4L2_MPEG_VIDC_VIDEO_H263_LEVEL_1_0) |
386 (1 << V4L2_MPEG_VIDC_VIDEO_H263_LEVEL_2_0) |
387 (1 << V4L2_MPEG_VIDC_VIDEO_H263_LEVEL_3_0) |
388 (1 << V4L2_MPEG_VIDC_VIDEO_H263_LEVEL_4_0) |
389 (1 << V4L2_MPEG_VIDC_VIDEO_H263_LEVEL_5_0) |
390 (1 << V4L2_MPEG_VIDC_VIDEO_H263_LEVEL_6_0) |
391 (1 << V4L2_MPEG_VIDC_VIDEO_H263_LEVEL_7_0)
392 ),
393 .qmenu = h263_level,
394 },
395 {
396 .id = V4L2_CID_MPEG_VIDC_VIDEO_VP8_PROFILE_LEVEL,
397 .name = "VP8 Profile Level",
398 .type = V4L2_CTRL_TYPE_MENU,
399 .minimum = V4L2_MPEG_VIDC_VIDEO_VP8_UNUSED,
400 .maximum = V4L2_MPEG_VIDC_VIDEO_VP8_VERSION_1,
401 .default_value = V4L2_MPEG_VIDC_VIDEO_VP8_VERSION_0,
402 .menu_skip_mask = ~(
403 (1 << V4L2_MPEG_VIDC_VIDEO_VP8_UNUSED) |
404 (1 << V4L2_MPEG_VIDC_VIDEO_VP8_VERSION_0) |
405 (1 << V4L2_MPEG_VIDC_VIDEO_VP8_VERSION_1)
406 ),
407 .qmenu = vp8_profile_level,
408 },
409 {
410 .id = V4L2_CID_MPEG_VIDC_VIDEO_HEVC_PROFILE,
411 .name = "HEVC Profile",
412 .type = V4L2_CTRL_TYPE_MENU,
413 .minimum = V4L2_MPEG_VIDC_VIDEO_HEVC_PROFILE_MAIN,
414 .maximum = V4L2_MPEG_VIDC_VIDEO_HEVC_PROFILE_MAIN_STILL_PIC,
415 .default_value = V4L2_MPEG_VIDC_VIDEO_HEVC_PROFILE_MAIN,
416 .menu_skip_mask = ~(
417 (1 << V4L2_MPEG_VIDC_VIDEO_HEVC_PROFILE_MAIN) |
418 (1 << V4L2_MPEG_VIDC_VIDEO_HEVC_PROFILE_MAIN10) |
419 (1 << V4L2_MPEG_VIDC_VIDEO_HEVC_PROFILE_MAIN_STILL_PIC)
420 ),
421 .qmenu = hevc_profile,
422 },
423 {
424 .id = V4L2_CID_MPEG_VIDC_VIDEO_HEVC_TIER_LEVEL,
425 .name = "HEVC Tier and Level",
426 .type = V4L2_CTRL_TYPE_MENU,
427 .minimum = V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_MAIN_TIER_LEVEL_1,
428 .maximum = V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_HIGH_TIER_LEVEL_5_2,
429 .default_value =
430 V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_MAIN_TIER_LEVEL_1,
431 .menu_skip_mask = ~(
432 (1 << V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_HIGH_TIER_LEVEL_1) |
433 (1 << V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_HIGH_TIER_LEVEL_2) |
434 (1 << V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_HIGH_TIER_LEVEL_2_1) |
435 (1 << V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_HIGH_TIER_LEVEL_3) |
436 (1 << V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_HIGH_TIER_LEVEL_3_1) |
437 (1 << V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_HIGH_TIER_LEVEL_4) |
438 (1 << V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_HIGH_TIER_LEVEL_4_1) |
439 (1 << V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_HIGH_TIER_LEVEL_5) |
440 (1 << V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_HIGH_TIER_LEVEL_5_1) |
441 (1 << V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_HIGH_TIER_LEVEL_5_2) |
442 (1 << V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_MAIN_TIER_LEVEL_1) |
443 (1 << V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_MAIN_TIER_LEVEL_2) |
444 (1 << V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_MAIN_TIER_LEVEL_2_1) |
445 (1 << V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_MAIN_TIER_LEVEL_3) |
446 (1 << V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_MAIN_TIER_LEVEL_3_1) |
447 (1 << V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_MAIN_TIER_LEVEL_4) |
448 (1 << V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_MAIN_TIER_LEVEL_4_1) |
449 (1 << V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_MAIN_TIER_LEVEL_5) |
450 (1 << V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_MAIN_TIER_LEVEL_5_1)
451 ),
452 .qmenu = hevc_tier_level,
453 },
454 {
455 .id = V4L2_CID_MPEG_VIDC_VIDEO_ROTATION,
456 .name = "Rotation",
457 .type = V4L2_CTRL_TYPE_MENU,
458 .minimum = V4L2_CID_MPEG_VIDC_VIDEO_ROTATION_NONE,
459 .maximum = V4L2_CID_MPEG_VIDC_VIDEO_ROTATION_270,
460 .default_value = V4L2_CID_MPEG_VIDC_VIDEO_ROTATION_NONE,
461 .menu_skip_mask = ~(
462 (1 << V4L2_CID_MPEG_VIDC_VIDEO_ROTATION_NONE) |
463 (1 << V4L2_CID_MPEG_VIDC_VIDEO_ROTATION_90) |
464 (1 << V4L2_CID_MPEG_VIDC_VIDEO_ROTATION_180) |
465 (1 << V4L2_CID_MPEG_VIDC_VIDEO_ROTATION_270)
466 ),
467 .qmenu = mpeg_video_rotation,
468 },
469 {
470 .id = V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP,
471 .name = "H264 I Frame Quantization",
472 .type = V4L2_CTRL_TYPE_INTEGER,
473 .minimum = 0,
474 .maximum = 127,
475 .default_value = I_FRAME_QP,
476 .step = 1,
477 .menu_skip_mask = 0,
478 .qmenu = NULL,
479 },
480 {
481 .id = V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP,
482 .name = "H264 P Frame Quantization",
483 .type = V4L2_CTRL_TYPE_INTEGER,
484 .minimum = 0,
485 .maximum = 127,
486 .default_value = P_FRAME_QP,
487 .step = 1,
488 .menu_skip_mask = 0,
489 .qmenu = NULL,
490 },
491 {
492 .id = V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP,
493 .name = "H264 B Frame Quantization",
494 .type = V4L2_CTRL_TYPE_INTEGER,
495 .minimum = 0,
496 .maximum = 127,
497 .default_value = B_FRAME_QP,
498 .step = 1,
499 .menu_skip_mask = 0,
500 .qmenu = NULL,
501 },
502 {
503 .id = V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP,
504 .name = "H263 I Frame Quantization",
505 .type = V4L2_CTRL_TYPE_INTEGER,
506 .minimum = 1,
507 .maximum = 31,
508 .default_value = I_FRAME_QP,
509 .step = 1,
510 .menu_skip_mask = 0,
511 .qmenu = NULL,
512 },
513 {
514 .id = V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP,
515 .name = "H263 P Frame Quantization",
516 .type = V4L2_CTRL_TYPE_INTEGER,
517 .minimum = 1,
518 .maximum = 31,
519 .default_value = P_FRAME_QP,
520 .step = 1,
521 .menu_skip_mask = 0,
522 .qmenu = NULL,
523 },
524 {
525 .id = V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP,
526 .name = "H263 B Frame Quantization",
527 .type = V4L2_CTRL_TYPE_INTEGER,
528 .minimum = 1,
529 .maximum = 31,
530 .default_value = B_FRAME_QP,
531 .step = 1,
532 .menu_skip_mask = 0,
533 .qmenu = NULL,
534 },
535 {
536 .id = V4L2_CID_MPEG_VIDEO_VPX_I_FRAME_QP,
537 .name = "VPX I Frame Quantization",
538 .type = V4L2_CTRL_TYPE_INTEGER,
539 .minimum = 0,
540 .maximum = 127,
541 .default_value = I_FRAME_QP,
542 .step = 1,
543 .menu_skip_mask = 0,
544 .qmenu = NULL,
545 },
546 {
547 .id = V4L2_CID_MPEG_VIDEO_VPX_P_FRAME_QP,
548 .name = "VPX P Frame Quantization",
549 .type = V4L2_CTRL_TYPE_INTEGER,
550 .minimum = 0,
551 .maximum = 127,
552 .default_value = P_FRAME_QP,
553 .step = 1,
554 .menu_skip_mask = 0,
555 .qmenu = NULL,
556 },
557 {
558 .id = V4L2_CID_MPEG_VIDEO_H264_MIN_QP,
559 .name = "H264 Minimum QP",
560 .type = V4L2_CTRL_TYPE_INTEGER,
561 .minimum = 1,
562 .maximum = 51,
563 .default_value = 1,
564 .step = 1,
565 .menu_skip_mask = 0,
566 .qmenu = NULL,
567 },
568 {
569 .id = V4L2_CID_MPEG_VIDEO_H264_MAX_QP,
570 .name = "H264 Maximum QP",
571 .type = V4L2_CTRL_TYPE_INTEGER,
572 .minimum = 1,
573 .maximum = 51,
574 .default_value = 51,
575 .step = 1,
576 .menu_skip_mask = 0,
577 .qmenu = NULL,
578 },
579 {
580 .id = V4L2_CID_MPEG_VIDEO_VPX_MIN_QP,
581 .name = "VPX Minimum QP",
582 .type = V4L2_CTRL_TYPE_INTEGER,
583 .minimum = 0,
584 .maximum = 127,
585 .default_value = 0,
586 .step = 1,
587 },
588 {
589 .id = V4L2_CID_MPEG_VIDEO_VPX_MAX_QP,
590 .name = "VPX Maximum QP",
591 .type = V4L2_CTRL_TYPE_INTEGER,
592 .minimum = 0,
593 .maximum = 127,
594 .default_value = 127,
595 .step = 1,
596 },
597 {
598 .id = V4L2_CID_MPEG_VIDC_VIDEO_VP8_MIN_QP,
599 .name = "VP8 Minimum QP",
600 .type = V4L2_CTRL_TYPE_INTEGER,
601 .minimum = 1,
602 .maximum = 128,
603 .default_value = 1,
604 .step = 1,
605 },
606 {
607 .id = V4L2_CID_MPEG_VIDC_VIDEO_VP8_MAX_QP,
608 .name = "VP8 Maximum QP",
609 .type = V4L2_CTRL_TYPE_INTEGER,
610 .minimum = 1,
611 .maximum = 128,
612 .default_value = 128,
613 .step = 1,
614 },
615 {
616 .id = V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP,
617 .name = "MPEG4 Minimum QP",
618 .type = V4L2_CTRL_TYPE_INTEGER,
619 .minimum = 1,
620 .maximum = 31,
621 .default_value = 1,
622 .step = 1,
623 },
624 {
625 .id = V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP,
626 .name = "MPEG4 Maximum QP",
627 .type = V4L2_CTRL_TYPE_INTEGER,
628 .minimum = 1,
629 .maximum = 31,
630 .default_value = 31,
631 .step = 1,
632 },
633 {
634 .id = V4L2_CID_MPEG_VIDEO_MIN_QP_PACKED,
635 .name = "H264 Minimum QP PACKED",
636 .type = V4L2_CTRL_TYPE_INTEGER,
637 .minimum = 0x00010101,
638 .maximum = 0x00333333,
639 .default_value = 0x00010101,
640 .step = 1,
641 .menu_skip_mask = 0,
642 .qmenu = NULL,
643 },
644 {
645 .id = V4L2_CID_MPEG_VIDEO_MAX_QP_PACKED,
646 .name = "H264 Maximum QP PACKED",
647 .type = V4L2_CTRL_TYPE_INTEGER,
648 .minimum = 0x00010101,
649 .maximum = 0x00333333,
650 .default_value = 0x00333333,
651 .step = 1,
652 .menu_skip_mask = 0,
653 .qmenu = NULL,
654 },
655 {
656 .id = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE,
657 .name = "Slice Mode",
658 .type = V4L2_CTRL_TYPE_MENU,
659 .minimum = V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE,
660 .maximum = V4L2_MPEG_VIDEO_MULTI_SLICE_GOB,
661 .default_value = V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE,
662 .menu_skip_mask = ~(
663 (1 << V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE) |
664 (1 << V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_MB) |
665 (1 << V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_BYTES) |
666 (1 << V4L2_MPEG_VIDEO_MULTI_SLICE_GOB)
667 ),
668 },
669 {
670 .id = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES,
671 .name = "Slice Byte Size",
672 .type = V4L2_CTRL_TYPE_INTEGER,
673 .minimum = MIN_SLICE_BYTE_SIZE,
674 .maximum = MAX_SLICE_BYTE_SIZE,
675 .default_value = MIN_SLICE_BYTE_SIZE,
676 .step = 1,
677 .menu_skip_mask = 0,
678 .qmenu = NULL,
679 },
680 {
681 .id = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB,
682 .name = "Slice MB Size",
683 .type = V4L2_CTRL_TYPE_INTEGER,
684 .minimum = 1,
685 .maximum = MAX_SLICE_MB_SIZE,
686 .default_value = 1,
687 .step = 1,
688 .menu_skip_mask = 0,
689 .qmenu = NULL,
690 },
691 {
692 .id = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_GOB,
693 .name = "Slice GOB",
694 .type = V4L2_CTRL_TYPE_INTEGER,
695 .minimum = 1,
696 .maximum = MAX_SLICE_MB_SIZE,
697 .default_value = 1,
698 .step = 1,
699 .menu_skip_mask = 0,
700 .qmenu = NULL,
701 },
702 {
703 .id = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_DELIVERY_MODE,
704 .name = "Slice delivery mode",
705 .type = V4L2_CTRL_TYPE_BUTTON,
706 .minimum = 0,
707 .maximum = 1,
708 .default_value = 0,
709 .step = 1,
710 .menu_skip_mask = 0,
711 .qmenu = NULL,
712 },
713 {
714 .id = V4L2_CID_MPEG_VIDC_VIDEO_INTRA_REFRESH_MODE,
715 .name = "Intra Refresh Mode",
716 .type = V4L2_CTRL_TYPE_MENU,
717 .minimum = V4L2_CID_MPEG_VIDC_VIDEO_INTRA_REFRESH_NONE,
718 .maximum = V4L2_CID_MPEG_VIDC_VIDEO_INTRA_REFRESH_RANDOM,
719 .default_value = V4L2_CID_MPEG_VIDC_VIDEO_INTRA_REFRESH_NONE,
720 .menu_skip_mask = ~(
721 (1 << V4L2_CID_MPEG_VIDC_VIDEO_INTRA_REFRESH_NONE) |
722 (1 << V4L2_CID_MPEG_VIDC_VIDEO_INTRA_REFRESH_CYCLIC) |
723 (1 << V4L2_CID_MPEG_VIDC_VIDEO_INTRA_REFRESH_ADAPTIVE) |
724 (1 << V4L2_CID_MPEG_VIDC_VIDEO_INTRA_REFRESH_CYCLIC_ADAPTIVE) |
725 (1 << V4L2_CID_MPEG_VIDC_VIDEO_INTRA_REFRESH_RANDOM)
726 ),
727 .qmenu = intra_refresh_modes,
728 },
729 {
730 .id = V4L2_CID_MPEG_VIDC_VIDEO_AIR_MBS,
731 .name = "Intra Refresh AIR MBS",
732 .type = V4L2_CTRL_TYPE_INTEGER,
733 .minimum = 0,
734 .maximum = MAX_INTRA_REFRESH_MBS,
735 .default_value = 0,
736 .step = 1,
737 .menu_skip_mask = 0,
738 .qmenu = NULL,
739 },
740 {
741 .id = V4L2_CID_MPEG_VIDC_VIDEO_AIR_REF,
742 .name = "Intra Refresh AIR REF",
743 .type = V4L2_CTRL_TYPE_INTEGER,
744 .minimum = 0,
745 .maximum = MAX_INTRA_REFRESH_MBS,
746 .default_value = 0,
747 .step = 1,
748 .menu_skip_mask = 0,
749 .qmenu = NULL,
750 },
751 {
752 .id = V4L2_CID_MPEG_VIDC_VIDEO_CIR_MBS,
753 .name = "Intra Refresh CIR MBS",
754 .type = V4L2_CTRL_TYPE_INTEGER,
755 .minimum = 0,
756 .maximum = MAX_INTRA_REFRESH_MBS,
757 .default_value = 0,
758 .step = 1,
759 .menu_skip_mask = 0,
760 .qmenu = NULL,
761 },
762 {
763 .id = V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA,
764 .name = "H.264 Loop Filter Alpha Offset",
765 .type = V4L2_CTRL_TYPE_INTEGER,
766 .minimum = -6,
767 .maximum = 6,
768 .default_value = 0,
769 .step = 1,
770 .menu_skip_mask = 0,
771 .qmenu = NULL,
772 },
773 {
774 .id = V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA,
775 .name = "H.264 Loop Filter Beta Offset",
776 .type = V4L2_CTRL_TYPE_INTEGER,
777 .minimum = -6,
778 .maximum = 6,
779 .default_value = 0,
780 .step = 1,
781 .menu_skip_mask = 0,
782 .qmenu = NULL,
783 },
784 {
785 .id = V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE,
786 .name = "H.264 Loop Filter Mode",
787 .type = V4L2_CTRL_TYPE_MENU,
788 .minimum = V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED,
789 .maximum = L_MODE,
790 .default_value = V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED,
791 .menu_skip_mask = ~(
792 (1 << V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED) |
793 (1 << V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED) |
794 (1 << L_MODE)
795 ),
796 },
797 {
798 .id = V4L2_CID_MPEG_VIDEO_HEADER_MODE,
799 .name = "Sequence Header Mode",
800 .type = V4L2_CTRL_TYPE_MENU,
801 .minimum = V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE,
802 .maximum = V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_I_FRAME,
803 .default_value =
804 V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_I_FRAME,
805 .menu_skip_mask = ~(
806 (1 << V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE) |
807 (1 << V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_I_FRAME)
808 ),
809 },
810 {
811 .id = V4L2_CID_MPEG_VIDC_VIDEO_SECURE,
812 .name = "Secure mode",
813 .type = V4L2_CTRL_TYPE_BUTTON,
814 .minimum = 0,
815 .maximum = 0,
816 .default_value = 0,
817 .step = 0,
818 .menu_skip_mask = 0,
819 .qmenu = NULL,
820 },
821 {
822 .id = V4L2_CID_MPEG_VIDC_VIDEO_EXTRADATA,
823 .name = "Extradata Type",
824 .type = V4L2_CTRL_TYPE_MENU,
825 .minimum = V4L2_MPEG_VIDC_EXTRADATA_NONE,
826 .maximum = V4L2_MPEG_VIDC_EXTRADATA_PQ_INFO,
827 .default_value = V4L2_MPEG_VIDC_EXTRADATA_NONE,
828 .menu_skip_mask = ~(
829 (1 << V4L2_MPEG_VIDC_EXTRADATA_NONE) |
830 (1 << V4L2_MPEG_VIDC_EXTRADATA_MB_QUANTIZATION) |
831 (1 << V4L2_MPEG_VIDC_EXTRADATA_INTERLACE_VIDEO) |
832 (1 << V4L2_MPEG_VIDC_EXTRADATA_VC1_FRAMEDISP) |
833 (1 << V4L2_MPEG_VIDC_EXTRADATA_VC1_SEQDISP) |
834 (1 << V4L2_MPEG_VIDC_EXTRADATA_TIMESTAMP) |
835 (1 << V4L2_MPEG_VIDC_EXTRADATA_S3D_FRAME_PACKING) |
836 (1 << V4L2_MPEG_VIDC_EXTRADATA_FRAME_RATE) |
837 (1 << V4L2_MPEG_VIDC_EXTRADATA_PANSCAN_WINDOW) |
838 (1 << V4L2_MPEG_VIDC_EXTRADATA_RECOVERY_POINT_SEI) |
839 (1 << V4L2_MPEG_VIDC_EXTRADATA_MULTISLICE_INFO) |
840 (1 << V4L2_MPEG_VIDC_EXTRADATA_NUM_CONCEALED_MB) |
841 (1 << V4L2_MPEG_VIDC_EXTRADATA_METADATA_FILLER) |
842 (1 << V4L2_MPEG_VIDC_EXTRADATA_INPUT_CROP) |
843 (1 << V4L2_MPEG_VIDC_EXTRADATA_DIGITAL_ZOOM) |
844 (1 << V4L2_MPEG_VIDC_EXTRADATA_ASPECT_RATIO) |
845 (1 << V4L2_MPEG_VIDC_EXTRADATA_LTR) |
846 (1 << V4L2_MPEG_VIDC_EXTRADATA_METADATA_MBI) |
847 (1 << V4L2_MPEG_VIDC_EXTRADATA_YUV_STATS)|
848 (1 << V4L2_MPEG_VIDC_EXTRADATA_ROI_QP) |
849 (1 << V4L2_MPEG_VIDC_EXTRADATA_PQ_INFO)
850 ),
851 .qmenu = mpeg_video_vidc_extradata,
852 },
853 {
854 .id = V4L2_CID_MPEG_VIDC_VIDEO_H264_VUI_TIMING_INFO,
855 .name = "H264 VUI Timing Info",
856 .type = V4L2_CTRL_TYPE_BOOLEAN,
857 .minimum = V4L2_MPEG_VIDC_VIDEO_H264_VUI_TIMING_INFO_DISABLED,
858 .maximum = V4L2_MPEG_VIDC_VIDEO_H264_VUI_TIMING_INFO_ENABLED,
859 .default_value =
860 V4L2_MPEG_VIDC_VIDEO_H264_VUI_TIMING_INFO_DISABLED,
861 .step = 1,
862 },
863 {
864 .id = V4L2_CID_MPEG_VIDC_VIDEO_AU_DELIMITER,
865 .name = "H264 AU Delimiter",
866 .type = V4L2_CTRL_TYPE_BOOLEAN,
867 .minimum = V4L2_MPEG_VIDC_VIDEO_AU_DELIMITER_DISABLED,
868 .maximum = V4L2_MPEG_VIDC_VIDEO_AU_DELIMITER_ENABLED,
869 .step = 1,
870 .default_value =
871 V4L2_MPEG_VIDC_VIDEO_AU_DELIMITER_DISABLED,
872 },
873 {
874 .id = V4L2_CID_MPEG_VIDC_SET_PERF_LEVEL,
875 .name = "Encoder Performance Level",
876 .type = V4L2_CTRL_TYPE_MENU,
877 .minimum = V4L2_CID_MPEG_VIDC_PERF_LEVEL_NOMINAL,
878 .maximum = V4L2_CID_MPEG_VIDC_PERF_LEVEL_TURBO,
879 .default_value = V4L2_CID_MPEG_VIDC_PERF_LEVEL_NOMINAL,
880 .menu_skip_mask = ~(
881 (1 << V4L2_CID_MPEG_VIDC_PERF_LEVEL_NOMINAL) |
882 (1 << V4L2_CID_MPEG_VIDC_PERF_LEVEL_TURBO)),
883 .qmenu = perf_level,
884 },
885 {
886 .id = V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB,
887 .name = "Intra Refresh CIR MBS",
888 .type = V4L2_CTRL_TYPE_INTEGER,
889 .minimum = 0,
890 .maximum = MAX_INTRA_REFRESH_MBS,
891 .default_value = 0,
892 .step = 1,
893 .menu_skip_mask = 0,
894 .qmenu = NULL,
895 },
896 {
897 .id = V4L2_CID_MPEG_VIDC_VIDEO_H264_VUI_BITSTREAM_RESTRICT,
898 .name = "H264 VUI Timing Info",
899 .type = V4L2_CTRL_TYPE_BOOLEAN,
900 .minimum = BITSTREAM_RESTRICT_DISABLED,
901 .maximum = BITSTREAM_RESTRICT_ENABLED,
902 .default_value = BITSTREAM_RESTRICT_ENABLED,
903 .step = 1,
904 },
905 {
906 .id = V4L2_CID_MPEG_VIDC_VIDEO_PRESERVE_TEXT_QUALITY,
907 .name = "Preserve Text Qualty",
908 .type = V4L2_CTRL_TYPE_BOOLEAN,
909 .minimum = V4L2_MPEG_VIDC_VIDEO_PRESERVE_TEXT_QUALITY_DISABLED,
910 .maximum = V4L2_MPEG_VIDC_VIDEO_PRESERVE_TEXT_QUALITY_ENABLED,
911 .default_value =
912 V4L2_MPEG_VIDC_VIDEO_PRESERVE_TEXT_QUALITY_DISABLED,
913 .step = 1,
914 },
915 {
916 .id = V4L2_CID_MPEG_VIDC_VIDEO_DEINTERLACE,
917 .name = "Deinterlace for encoder",
918 .type = V4L2_CTRL_TYPE_BOOLEAN,
919 .minimum = V4L2_CID_MPEG_VIDC_VIDEO_DEINTERLACE_DISABLED,
920 .maximum = V4L2_CID_MPEG_VIDC_VIDEO_DEINTERLACE_ENABLED,
921 .default_value = V4L2_CID_MPEG_VIDC_VIDEO_DEINTERLACE_DISABLED,
922 .step = 1,
923 },
924 {
925 .id = V4L2_CID_MPEG_VIDC_VIDEO_MPEG4_TIME_RESOLUTION,
926 .name = "Vop time increment resolution",
927 .type = V4L2_CTRL_TYPE_INTEGER,
928 .minimum = MIN_TIME_RESOLUTION,
929 .maximum = MAX_TIME_RESOLUTION,
930 .default_value = DEFAULT_TIME_RESOLUTION,
931 .step = 1,
932 .menu_skip_mask = 0,
933 .qmenu = NULL,
934 },
935 {
936 .id = V4L2_CID_MPEG_VIDC_VIDEO_REQUEST_SEQ_HEADER,
937 .name = "Request Seq Header",
938 .type = V4L2_CTRL_TYPE_BUTTON,
939 .minimum = 0,
940 .maximum = 0,
941 .default_value = 0,
942 .step = 0,
943 .menu_skip_mask = 0,
944 .qmenu = NULL,
945 },
946 {
947 .id = V4L2_CID_MPEG_VIDC_VIDEO_USELTRFRAME,
948 .name = "H264 Use LTR",
949 .type = V4L2_CTRL_TYPE_INTEGER,
950 .minimum = 0,
951 .maximum = (MAX_LTR_FRAME_COUNT - 1),
952 .default_value = 0,
953 .step = 1,
954 .qmenu = NULL,
955 },
956 {
957 .id = V4L2_CID_MPEG_VIDC_VIDEO_LTRCOUNT,
958 .name = "Ltr Count",
959 .type = V4L2_CTRL_TYPE_INTEGER,
960 .minimum = 0,
961 .maximum = MAX_LTR_FRAME_COUNT,
962 .default_value = 0,
963 .step = 1,
964 .qmenu = NULL,
965 },
966 {
967 .id = V4L2_CID_MPEG_VIDC_VIDEO_LTRMODE,
968 .name = "Ltr Mode",
969 .type = V4L2_CTRL_TYPE_INTEGER,
970 .minimum = V4L2_MPEG_VIDC_VIDEO_LTR_MODE_DISABLE,
971 .maximum = V4L2_MPEG_VIDC_VIDEO_LTR_MODE_MANUAL,
972 .default_value = V4L2_MPEG_VIDC_VIDEO_LTR_MODE_DISABLE,
973 .step = 1,
974 .qmenu = NULL,
975 },
976 {
977 .id = V4L2_CID_MPEG_VIDC_VIDEO_MARKLTRFRAME,
978 .name = "H264 Mark LTR",
979 .type = V4L2_CTRL_TYPE_INTEGER,
980 .minimum = 0,
981 .maximum = (MAX_LTR_FRAME_COUNT - 1),
982 .default_value = 0,
983 .step = 1,
984 .qmenu = NULL,
985 },
986 {
987 .id = V4L2_CID_MPEG_VIDC_VIDEO_HIER_P_NUM_LAYERS,
988 .name = "Set Hier P num layers",
989 .type = V4L2_CTRL_TYPE_INTEGER,
990 .minimum = 0,
991 .maximum = 6,
992 .default_value = 0,
993 .step = 1,
994 .qmenu = NULL,
995 },
996 {
997 .id = V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_TIMESTAMP_MODE,
998 .name = "Encoder Timestamp Mode",
999 .type = V4L2_CTRL_TYPE_MENU,
1000 .minimum =
1001 V4L2_MPEG_VIDC_VIDEO_RATE_CONTROL_TIMESTAMP_MODE_HONOR,
1002 .maximum =
1003 V4L2_MPEG_VIDC_VIDEO_RATE_CONTROL_TIMESTAMP_MODE_IGNORE,
1004 .default_value =
1005 V4L2_MPEG_VIDC_VIDEO_RATE_CONTROL_TIMESTAMP_MODE_HONOR,
1006 .menu_skip_mask = ~(
1007 (1 << V4L2_MPEG_VIDC_VIDEO_RATE_CONTROL_TIMESTAMP_MODE_HONOR) |
1008 (1 << V4L2_MPEG_VIDC_VIDEO_RATE_CONTROL_TIMESTAMP_MODE_IGNORE)),
1009 .qmenu = timestamp_mode,
1010 },
1011 {
1012 .id = V4L2_CID_MPEG_VIDC_VIDEO_VPX_ERROR_RESILIENCE,
1013 .name = "VP8 Error Resilience mode",
1014 .type = V4L2_CTRL_TYPE_BOOLEAN,
1015 .minimum = V4L2_MPEG_VIDC_VIDEO_VPX_ERROR_RESILIENCE_DISABLED,
1016 .maximum = V4L2_MPEG_VIDC_VIDEO_VPX_ERROR_RESILIENCE_ENABLED,
1017 .default_value =
1018 V4L2_MPEG_VIDC_VIDEO_VPX_ERROR_RESILIENCE_DISABLED,
1019 .step = 1,
1020 .qmenu = NULL,
1021 },
1022 {
1023 .id = V4L2_CID_MPEG_VIDC_VIDEO_ENABLE_INITIAL_QP,
1024 .name = "Enable setting initial QP",
1025 .type = V4L2_CTRL_TYPE_BITMASK,
1026 .minimum = 0,
1027 .maximum = V4L2_CID_MPEG_VIDC_VIDEO_ENABLE_INITIAL_QP_IFRAME |
1028 V4L2_CID_MPEG_VIDC_VIDEO_ENABLE_INITIAL_QP_PFRAME |
1029 V4L2_CID_MPEG_VIDC_VIDEO_ENABLE_INITIAL_QP_BFRAME,
1030 .default_value = 0,
1031 .step = 0,
1032 },
1033 {
1034 .id = V4L2_CID_MPEG_VIDC_VIDEO_INITIAL_I_FRAME_QP,
1035 .name = "Iframe initial QP",
1036 .type = V4L2_CTRL_TYPE_INTEGER,
1037 .minimum = 1,
1038 .maximum = 127,
1039 .default_value = 1,
1040 .step = 1,
1041 .qmenu = NULL,
1042 },
1043 {
1044 .id = V4L2_CID_MPEG_VIDC_VIDEO_INITIAL_P_FRAME_QP,
1045 .name = "Pframe initial QP",
1046 .type = V4L2_CTRL_TYPE_INTEGER,
1047 .minimum = 1,
1048 .maximum = 127,
1049 .default_value = 1,
1050 .step = 1,
1051 .qmenu = NULL,
1052 },
1053 {
1054 .id = V4L2_CID_MPEG_VIDC_VIDEO_INITIAL_B_FRAME_QP,
1055 .name = "Bframe initial QP",
1056 .type = V4L2_CTRL_TYPE_INTEGER,
1057 .minimum = 1,
1058 .maximum = 127,
1059 .default_value = 1,
1060 .step = 1,
1061 .qmenu = NULL,
1062 },
1063 {
1064 .id = V4L2_CID_MPEG_VIDC_VIDEO_I_FRAME_QP,
1065 .name = "Iframe initial QP",
1066 .type = V4L2_CTRL_TYPE_INTEGER,
1067 .minimum = 1,
1068 .maximum = 51,
1069 .default_value = 1,
1070 .step = 1,
1071 .qmenu = NULL,
1072 },
1073 {
1074 .id = V4L2_CID_MPEG_VIDC_VIDEO_P_FRAME_QP,
1075 .name = "Pframe initial QP",
1076 .type = V4L2_CTRL_TYPE_INTEGER,
1077 .minimum = 1,
1078 .maximum = 51,
1079 .default_value = 1,
1080 .step = 1,
1081 .qmenu = NULL,
1082 },
1083 {
1084 .id = V4L2_CID_MPEG_VIDC_VIDEO_B_FRAME_QP,
1085 .name = "Bframe initial QP",
1086 .type = V4L2_CTRL_TYPE_INTEGER,
1087 .minimum = 1,
1088 .maximum = 51,
1089 .default_value = 1,
1090 .step = 1,
1091 .qmenu = NULL,
1092 },
1093 {
1094 .id = V4L2_CID_MPEG_VIDC_VIDEO_IFRAME_X_RANGE,
1095 .name = "I-Frame X coordinate search range",
1096 .type = V4L2_CTRL_TYPE_INTEGER,
1097 .minimum = 4,
1098 .maximum = 128,
1099 .default_value = 4,
1100 .step = 1,
1101 .menu_skip_mask = 0,
1102 .qmenu = NULL,
1103 },
1104 {
1105 .id = V4L2_CID_MPEG_VIDC_VIDEO_IFRAME_Y_RANGE,
1106 .name = "I-Frame Y coordinate search range",
1107 .type = V4L2_CTRL_TYPE_INTEGER,
1108 .minimum = 4,
1109 .maximum = 128,
1110 .default_value = 4,
1111 .step = 1,
1112 .menu_skip_mask = 0,
1113 .qmenu = NULL,
1114 },
1115 {
1116 .id = V4L2_CID_MPEG_VIDC_VIDEO_PFRAME_X_RANGE,
1117 .name = "P-Frame X coordinate search range",
1118 .type = V4L2_CTRL_TYPE_INTEGER,
1119 .minimum = 4,
1120 .maximum = 128,
1121 .default_value = 4,
1122 .step = 1,
1123 .menu_skip_mask = 0,
1124 .qmenu = NULL,
1125 },
1126 {
1127 .id = V4L2_CID_MPEG_VIDC_VIDEO_PFRAME_Y_RANGE,
1128 .name = "P-Frame Y coordinate search range",
1129 .type = V4L2_CTRL_TYPE_INTEGER,
1130 .minimum = 4,
1131 .maximum = 128,
1132 .default_value = 4,
1133 .step = 1,
1134 .menu_skip_mask = 0,
1135 .qmenu = NULL,
1136 },
1137 {
1138 .id = V4L2_CID_MPEG_VIDC_VIDEO_BFRAME_X_RANGE,
1139 .name = "B-Frame X coordinate search range",
1140 .type = V4L2_CTRL_TYPE_INTEGER,
1141 .minimum = 4,
1142 .maximum = 128,
1143 .default_value = 4,
1144 .step = 1,
1145 .menu_skip_mask = 0,
1146 .qmenu = NULL,
1147 },
1148 {
1149 .id = V4L2_CID_MPEG_VIDC_VIDEO_BFRAME_Y_RANGE,
1150 .name = "B-Frame Y coordinate search range",
1151 .type = V4L2_CTRL_TYPE_INTEGER,
1152 .minimum = 4,
1153 .maximum = 128,
1154 .default_value = 4,
1155 .step = 1,
1156 .menu_skip_mask = 0,
1157 .qmenu = NULL,
1158 },
1159 {
1160 .id = V4L2_CID_MPEG_VIDC_VIDEO_H264_NAL_SVC,
1161 .name = "Enable H264 SVC NAL",
1162 .type = V4L2_CTRL_TYPE_BOOLEAN,
1163 .minimum = V4L2_CID_MPEG_VIDC_VIDEO_H264_NAL_SVC_DISABLED,
1164 .maximum = V4L2_CID_MPEG_VIDC_VIDEO_H264_NAL_SVC_ENABLED,
1165 .default_value = V4L2_CID_MPEG_VIDC_VIDEO_H264_NAL_SVC_DISABLED,
1166 .step = 1,
1167 },
1168 {
1169 .id = V4L2_CID_MPEG_VIDC_VIDEO_PERF_MODE,
1170 .name = "Set Encoder performance mode",
1171 .type = V4L2_CTRL_TYPE_INTEGER,
1172 .minimum = V4L2_MPEG_VIDC_VIDEO_PERF_MAX_QUALITY,
1173 .maximum = V4L2_MPEG_VIDC_VIDEO_PERF_POWER_SAVE,
1174 .default_value = V4L2_MPEG_VIDC_VIDEO_PERF_MAX_QUALITY,
1175 .step = 1,
1176 .qmenu = NULL,
1177 },
1178 {
1179 .id = V4L2_CID_MPEG_VIDC_VIDEO_HIER_B_NUM_LAYERS,
1180 .name = "Set Hier B num layers",
1181 .type = V4L2_CTRL_TYPE_INTEGER,
1182 .minimum = 0,
1183 .maximum = 3,
1184 .default_value = 0,
1185 .step = 1,
1186 .qmenu = NULL,
1187 },
1188 {
1189 .id = V4L2_CID_MPEG_VIDC_VIDEO_HYBRID_HIERP_MODE,
1190 .name = "Set Hybrid Hier P mode",
1191 .type = V4L2_CTRL_TYPE_INTEGER,
1192 .minimum = 0,
1193 .maximum = 5,
1194 .default_value = 0,
1195 .step = 1,
1196 .qmenu = NULL,
1197 },
1198 {
1199 .id = V4L2_CID_MPEG_VIDC_VIDEO_MBI_STATISTICS_MODE,
1200 .name = "MBI Statistics Mode",
1201 .type = V4L2_CTRL_TYPE_MENU,
1202 .minimum = V4L2_CID_MPEG_VIDC_VIDEO_MBI_MODE_DEFAULT,
1203 .maximum = V4L2_CID_MPEG_VIDC_VIDEO_MBI_MODE_3,
1204 .default_value = V4L2_CID_MPEG_VIDC_VIDEO_MBI_MODE_DEFAULT,
1205 .menu_skip_mask = ~(
1206 (1 << V4L2_CID_MPEG_VIDC_VIDEO_MBI_MODE_DEFAULT) |
1207 (1 << V4L2_CID_MPEG_VIDC_VIDEO_MBI_MODE_1) |
1208 (1 << V4L2_CID_MPEG_VIDC_VIDEO_MBI_MODE_2) |
1209 (1 << V4L2_CID_MPEG_VIDC_VIDEO_MBI_MODE_3)),
1210 .qmenu = mbi_statistics,
1211 },
1212 {
1213 .id = V4L2_CID_VIDC_QBUF_MODE,
1214 .name = "Allows batching of buffers for power savings",
1215 .type = V4L2_CTRL_TYPE_BOOLEAN,
1216 .minimum = V4L2_VIDC_QBUF_STANDARD,
1217 .maximum = V4L2_VIDC_QBUF_BATCHED,
1218 .default_value = V4L2_VIDC_QBUF_STANDARD,
1219 .step = 1,
1220 },
1221 {
1222 .id = V4L2_CID_MPEG_VIDC_VIDEO_MAX_HIERP_LAYERS,
1223 .name = "Set Max Hier P num layers sessions",
1224 .type = V4L2_CTRL_TYPE_INTEGER,
1225 .minimum = 0,
1226 .maximum = 6,
1227 .default_value = 0,
1228 .step = 1,
1229 .qmenu = NULL,
1230 },
1231 {
1232 .id = V4L2_CID_MPEG_VIDC_VIDEO_BASELAYER_ID,
1233 .name = "Set Base Layer ID for Hier-P",
1234 .type = V4L2_CTRL_TYPE_INTEGER,
1235 .minimum = 0,
1236 .maximum = 6,
1237 .default_value = 0,
1238 .step = 1,
1239 .qmenu = NULL,
1240 },
1241 {
1242 .id = V4L2_CID_MPEG_VIDC_VIDEO_CONFIG_QP,
1243 .name = "Set frame level QP",
1244 .type = V4L2_CTRL_TYPE_INTEGER,
1245 .minimum = 1,
1246 .maximum = 127,
1247 .default_value = 1,
1248 .step = 1,
1249 .qmenu = NULL,
1250 },
1251 {
1252 .id = V4L2_CID_MPEG_VIDC_VENC_PARAM_SAR_WIDTH,
1253 .name = "SAR Width",
1254 .type = V4L2_CTRL_TYPE_INTEGER,
1255 .minimum = 1,
1256 .maximum = 4096,
1257 .default_value = 1,
1258 .step = 1,
1259 .qmenu = NULL,
1260 },
1261 {
1262 .id = V4L2_CID_MPEG_VIDC_VENC_PARAM_SAR_HEIGHT,
1263 .name = "SAR Height",
1264 .type = V4L2_CTRL_TYPE_INTEGER,
1265 .minimum = 1,
1266 .maximum = 2160,
1267 .default_value = 1,
1268 .step = 1,
1269 .qmenu = NULL,
1270 },
1271 {
1272 .id = V4L2_CID_MPEG_VIDC_VIDEO_PRIORITY,
1273 .name = "Session Priority",
1274 .type = V4L2_CTRL_TYPE_BOOLEAN,
1275 .minimum = V4L2_MPEG_VIDC_VIDEO_PRIORITY_REALTIME_ENABLE,
1276 .maximum = V4L2_MPEG_VIDC_VIDEO_PRIORITY_REALTIME_DISABLE,
1277 .default_value = V4L2_MPEG_VIDC_VIDEO_PRIORITY_REALTIME_DISABLE,
1278 .step = 1,
1279 },
1280 {
1281 .id = V4L2_CID_MPEG_VIDC_VIDEO_VQZIP_SEI,
1282 .name = "VQZIP SEI",
1283 .type = V4L2_CTRL_TYPE_BOOLEAN,
1284 .minimum = V4L2_CID_MPEG_VIDC_VIDEO_VQZIP_SEI_DISABLE,
1285 .maximum = V4L2_CID_MPEG_VIDC_VIDEO_VQZIP_SEI_ENABLE,
1286 .default_value = V4L2_CID_MPEG_VIDC_VIDEO_VQZIP_SEI_DISABLE,
1287 .step = 1,
1288 },
1289 {
1290 .id = V4L2_CID_MPEG_VIDC_VENC_PARAM_LAYER_BITRATE,
1291 .name = "Layer wise bitrate for H264/H265 Hybrid HP",
1292 .type = V4L2_CTRL_TYPE_INTEGER,
1293 .minimum = MIN_BIT_RATE,
1294 .maximum = MAX_BIT_RATE,
1295 .default_value = DEFAULT_BIT_RATE,
1296 .step = BIT_RATE_STEP,
1297 .menu_skip_mask = 0,
1298 .qmenu = NULL,
1299 },
1300 {
1301 .id = V4L2_CID_MPEG_VIDC_VIDEO_OPERATING_RATE,
1302 .name = "Set Encoder Operating rate",
1303 .type = V4L2_CTRL_TYPE_INTEGER,
1304 .minimum = 0,
1305 .maximum = MAX_OPERATING_FRAME_RATE,
1306 .default_value = 0,
1307 .step = OPERATING_FRAME_RATE_STEP,
1308 },
1309 {
1310 .id = V4L2_CID_MPEG_VIDC_VIDEO_VENC_BITRATE_TYPE,
1311 .name = "BITRATE TYPE",
1312 .type = V4L2_CTRL_TYPE_BOOLEAN,
1313 .minimum = V4L2_CID_MPEG_VIDC_VIDEO_VENC_BITRATE_DISABLE,
1314 .maximum = V4L2_CID_MPEG_VIDC_VIDEO_VENC_BITRATE_ENABLE,
1315 .default_value = V4L2_CID_MPEG_VIDC_VIDEO_VENC_BITRATE_ENABLE,
1316 .step = 1,
1317 },
1318 {
1319 .id = V4L2_CID_MPEG_VIDC_VIDEO_H264_PIC_ORDER_CNT,
1320 .name = "Set H264 Picture Order Count",
1321 .type = V4L2_CTRL_TYPE_INTEGER,
1322 .minimum = 0,
1323 .maximum = 2,
1324 .default_value = 0,
1325 .step = 2,
1326 .qmenu = NULL,
1327 },
1328 {
1329 .id = V4L2_CID_MPEG_VIDC_VIDEO_VPE_CSC,
1330 .name = "Set VPE Color space conversion coefficients",
1331 .type = V4L2_CTRL_TYPE_INTEGER,
1332 .minimum = V4L2_CID_MPEG_VIDC_VIDEO_VPE_CSC_DISABLE,
1333 .maximum = V4L2_CID_MPEG_VIDC_VIDEO_VPE_CSC_ENABLE,
1334 .default_value = V4L2_CID_MPEG_VIDC_VIDEO_VPE_CSC_DISABLE,
1335 .step = 1,
1336 },
1337 {
1338 .id = V4L2_CID_MPEG_VIDC_VIDEO_LOWLATENCY_MODE,
1339 .name = "Low Latency Mode",
1340 .type = V4L2_CTRL_TYPE_BOOLEAN,
1341 .minimum = V4L2_CID_MPEG_VIDC_VIDEO_LOWLATENCY_DISABLE,
1342 .maximum = V4L2_CID_MPEG_VIDC_VIDEO_LOWLATENCY_ENABLE,
1343 .default_value = V4L2_CID_MPEG_VIDC_VIDEO_LOWLATENCY_DISABLE,
1344 .step = 1,
1345 },
1346 {
1347 .id = V4L2_CID_MPEG_VIDC_VIDEO_BLUR_WIDTH,
1348 .name = "Set Blur width",
1349 .type = V4L2_CTRL_TYPE_INTEGER,
1350 .minimum = 0,
1351 .maximum = 2048,
1352 .default_value = 0,
1353 .step = 1,
1354 },
1355 {
1356 .id = V4L2_CID_MPEG_VIDC_VIDEO_BLUR_HEIGHT,
1357 .name = "Set Blur height",
1358 .type = V4L2_CTRL_TYPE_INTEGER,
1359 .minimum = 0,
1360 .maximum = 2048,
1361 .default_value = 0,
1362 .step = 1,
1363 },
1364 {
1365 .id = V4L2_CID_MPEG_VIDC_VIDEO_COLOR_SPACE,
1366 .name = "Set Color space",
1367 .type = V4L2_CTRL_TYPE_INTEGER,
1368 .minimum = MSM_VIDC_BT709_5,
1369 .maximum = MSM_VIDC_BT2020,
1370 .default_value = MSM_VIDC_BT601_6_625,
1371 .step = 1,
1372 .qmenu = NULL,
1373 },
1374 {
1375 .id = V4L2_CID_MPEG_VIDC_VIDEO_FULL_RANGE,
1376 .name = "Set Color space range",
1377 .type = V4L2_CTRL_TYPE_BOOLEAN,
1378 .minimum = V4L2_CID_MPEG_VIDC_VIDEO_FULL_RANGE_DISABLE,
1379 .maximum = V4L2_CID_MPEG_VIDC_VIDEO_FULL_RANGE_ENABLE,
1380 .default_value = V4L2_CID_MPEG_VIDC_VIDEO_FULL_RANGE_DISABLE,
1381 .step = 1,
1382 },
1383 {
1384 .id = V4L2_CID_MPEG_VIDC_VIDEO_TRANSFER_CHARS,
1385 .name = "Set Color space transfer characterstics",
1386 .type = V4L2_CTRL_TYPE_INTEGER,
1387 .minimum = MSM_VIDC_TRANSFER_BT709_5,
1388 .maximum = MSM_VIDC_TRANSFER_BT_2020_12,
1389 .default_value = MSM_VIDC_TRANSFER_601_6_625,
1390 .step = 1,
1391 .qmenu = NULL,
1392 },
1393 {
1394 .id = V4L2_CID_MPEG_VIDC_VIDEO_MATRIX_COEFFS,
1395 .name = "Set Color space matrix coefficients",
1396 .type = V4L2_CTRL_TYPE_INTEGER,
1397 .minimum = MSM_VIDC_MATRIX_BT_709_5,
1398 .maximum = MSM_VIDC_MATRIX_BT_2020_CONST,
1399 .default_value = MSM_VIDC_MATRIX_601_6_625,
1400 .step = 1,
1401 .qmenu = NULL,
1402 },
1403 {
1404 .id = V4L2_CID_MPEG_VIDC_VIDEO_H264_TRANSFORM_8x8,
1405 .name = "Transform 8x8",
1406 .type = V4L2_CTRL_TYPE_BOOLEAN,
1407 .minimum = V4L2_MPEG_VIDC_VIDEO_H264_TRANSFORM_8x8_DISABLE,
1408 .maximum = V4L2_MPEG_VIDC_VIDEO_H264_TRANSFORM_8x8_ENABLE,
1409 .default_value = V4L2_MPEG_VIDC_VIDEO_H264_TRANSFORM_8x8_ENABLE,
1410 .step = 1,
1411 },
1412 {
1413 .id = V4L2_CID_MPEG_VIDC_VIDEO_IFRAME_SIZE_TYPE,
1414 .name = "Bounds of I-frame size",
1415 .type = V4L2_CTRL_TYPE_MENU,
1416 .minimum = V4L2_CID_MPEG_VIDC_VIDEO_IFRAME_SIZE_DEFAULT,
1417 .maximum = V4L2_CID_MPEG_VIDC_VIDEO_IFRAME_SIZE_UNLIMITED,
1418 .default_value = V4L2_CID_MPEG_VIDC_VIDEO_IFRAME_SIZE_DEFAULT,
1419 .menu_skip_mask = ~(
1420 (1 << V4L2_CID_MPEG_VIDC_VIDEO_IFRAME_SIZE_DEFAULT) |
1421 (1 << V4L2_CID_MPEG_VIDC_VIDEO_IFRAME_SIZE_MEDIUM) |
1422 (1 << V4L2_CID_MPEG_VIDC_VIDEO_IFRAME_SIZE_HUGE) |
1423 (1 << V4L2_CID_MPEG_VIDC_VIDEO_IFRAME_SIZE_UNLIMITED)),
1424 .qmenu = iframe_sizes,
1425 },
1426};
1427
1428#define NUM_CTRLS ARRAY_SIZE(msm_venc_ctrls)
1429
1430static u32 get_frame_size_nv12(int plane, u32 height, u32 width)
1431{
1432 return VENUS_BUFFER_SIZE(COLOR_FMT_NV12, width, height);
1433}
1434
1435static u32 get_frame_size_nv12_ubwc(int plane, u32 height, u32 width)
1436{
1437 return VENUS_BUFFER_SIZE(COLOR_FMT_NV12_UBWC, width, height);
1438}
1439
1440static u32 get_frame_size_rgba(int plane, u32 height, u32 width)
1441{
1442 return VENUS_BUFFER_SIZE(COLOR_FMT_RGBA8888, width, height);
1443}
1444
1445static u32 get_frame_size_rgba_ubwc(int plane, u32 height, u32 width)
1446{
1447 return VENUS_BUFFER_SIZE(COLOR_FMT_RGBA8888_UBWC, width, height);
1448}
1449
1450static u32 get_frame_size_nv21(int plane, u32 height, u32 width)
1451{
1452 return VENUS_BUFFER_SIZE(COLOR_FMT_NV21, width, height);
1453}
1454
1455static u32 get_frame_size_compressed(int plane, u32 height, u32 width)
1456{
1457 int sz = ALIGN(height, 32) * ALIGN(width, 32) * 3 / 2;
1458
1459 return ALIGN(sz, SZ_4K);
1460}
1461
1462static struct msm_vidc_format venc_formats[] = {
1463 {
1464 .name = "YCbCr Semiplanar 4:2:0",
1465 .description = "Y/CbCr 4:2:0",
1466 .fourcc = V4L2_PIX_FMT_NV12,
1467 .num_planes = 1,
1468 .get_frame_size = get_frame_size_nv12,
1469 .type = OUTPUT_PORT,
1470 },
1471 {
1472 .name = "UBWC YCbCr Semiplanar 4:2:0",
1473 .description = "UBWC Y/CbCr 4:2:0",
1474 .fourcc = V4L2_PIX_FMT_NV12_UBWC,
1475 .num_planes = 1,
1476 .get_frame_size = get_frame_size_nv12_ubwc,
1477 .type = OUTPUT_PORT,
1478 },
1479 {
1480 .name = "RGBA 8:8:8:8",
1481 .description = "RGBA 8:8:8:8",
1482 .fourcc = V4L2_PIX_FMT_RGB32,
1483 .num_planes = 1,
1484 .get_frame_size = get_frame_size_rgba,
1485 .type = OUTPUT_PORT,
1486 },
1487 {
1488 .name = "UBWC RGBA 8:8:8:8",
1489 .description = "UBWC RGBA 8:8:8:8",
1490 .fourcc = V4L2_PIX_FMT_RGBA8888_UBWC,
1491 .num_planes = 1,
1492 .get_frame_size = get_frame_size_rgba_ubwc,
1493 .type = OUTPUT_PORT,
1494 },
1495 {
1496 .name = "Mpeg4",
1497 .description = "Mpeg4 compressed format",
1498 .fourcc = V4L2_PIX_FMT_MPEG4,
1499 .num_planes = 1,
1500 .get_frame_size = get_frame_size_compressed,
1501 .type = CAPTURE_PORT,
1502 },
1503 {
1504 .name = "H263",
1505 .description = "H263 compressed format",
1506 .fourcc = V4L2_PIX_FMT_H263,
1507 .num_planes = 1,
1508 .get_frame_size = get_frame_size_compressed,
1509 .type = CAPTURE_PORT,
1510 },
1511 {
1512 .name = "H264",
1513 .description = "H264 compressed format",
1514 .fourcc = V4L2_PIX_FMT_H264,
1515 .num_planes = 1,
1516 .get_frame_size = get_frame_size_compressed,
1517 .type = CAPTURE_PORT,
1518 },
1519 {
1520 .name = "VP8",
1521 .description = "VP8 compressed format",
1522 .fourcc = V4L2_PIX_FMT_VP8,
1523 .num_planes = 1,
1524 .get_frame_size = get_frame_size_compressed,
1525 .type = CAPTURE_PORT,
1526 },
1527 {
1528 .name = "HEVC",
1529 .description = "HEVC compressed format",
1530 .fourcc = V4L2_PIX_FMT_HEVC,
1531 .num_planes = 1,
1532 .get_frame_size = get_frame_size_compressed,
1533 .type = CAPTURE_PORT,
1534 },
1535 {
1536 .name = "YCrCb Semiplanar 4:2:0",
1537 .description = "Y/CrCb 4:2:0",
1538 .fourcc = V4L2_PIX_FMT_NV21,
1539 .num_planes = 1,
1540 .get_frame_size = get_frame_size_nv21,
1541 .type = OUTPUT_PORT,
1542 },
1543};
1544
1545static void msm_venc_update_plane_count(struct msm_vidc_inst *inst, int type)
1546{
1547 struct v4l2_ctrl *ctrl = NULL;
1548 u32 extradata = 0;
1549
1550 if (!inst)
1551 return;
1552
1553 inst->fmts[type].num_planes = 1;
1554
1555 ctrl = v4l2_ctrl_find(&inst->ctrl_handler,
1556 V4L2_CID_MPEG_VIDC_VIDEO_EXTRADATA);
1557
1558 if (ctrl)
1559 extradata = v4l2_ctrl_g_ctrl(ctrl);
1560
1561 if (type == CAPTURE_PORT) {
1562 switch (extradata) {
1563 case V4L2_MPEG_VIDC_EXTRADATA_MULTISLICE_INFO:
1564 case V4L2_MPEG_VIDC_EXTRADATA_NUM_CONCEALED_MB:
1565 case V4L2_MPEG_VIDC_EXTRADATA_METADATA_FILLER:
1566 case V4L2_MPEG_VIDC_EXTRADATA_LTR:
1567 case V4L2_MPEG_VIDC_EXTRADATA_METADATA_MBI:
1568 inst->fmts[CAPTURE_PORT].num_planes = 2;
1569 default:
1570 break;
1571 }
1572 } else if (type == OUTPUT_PORT) {
1573 switch (extradata) {
1574 case V4L2_MPEG_VIDC_EXTRADATA_INPUT_CROP:
1575 case V4L2_MPEG_VIDC_EXTRADATA_DIGITAL_ZOOM:
1576 case V4L2_MPEG_VIDC_EXTRADATA_ASPECT_RATIO:
1577 case V4L2_MPEG_VIDC_EXTRADATA_YUV_STATS:
1578 case V4L2_MPEG_VIDC_EXTRADATA_ROI_QP:
1579 case V4L2_MPEG_VIDC_EXTRADATA_PQ_INFO:
1580 inst->fmts[OUTPUT_PORT].num_planes = 2;
1581 break;
1582 default:
1583 break;
1584 }
1585 }
1586}
1587
1588static int msm_venc_set_csc(struct msm_vidc_inst *inst);
1589
1590static int msm_venc_queue_setup(struct vb2_queue *q,
1591 unsigned int *num_buffers,
1592 unsigned int *num_planes, unsigned int sizes[],
1593 struct device *alloc_ctxs[])
1594{
1595 int i, temp, rc = 0;
1596 struct msm_vidc_inst *inst;
1597 struct hal_buffer_count_actual new_buf_count;
1598 enum hal_property property_id;
1599 struct hfi_device *hdev;
1600 struct hal_buffer_requirements *buff_req;
1601 u32 extra_idx = 0;
1602 struct hal_buffer_requirements *buff_req_buffer = NULL;
1603
1604 if (!q || !q->drv_priv) {
1605 dprintk(VIDC_ERR, "Invalid input\n");
1606 return -EINVAL;
1607 }
1608 inst = q->drv_priv;
1609
1610 if (!inst || !inst->core || !inst->core->device) {
1611 dprintk(VIDC_ERR, "%s invalid parameters\n", __func__);
1612 return -EINVAL;
1613 }
1614 hdev = inst->core->device;
1615
1616 rc = msm_comm_try_state(inst, MSM_VIDC_OPEN_DONE);
1617 if (rc) {
1618 dprintk(VIDC_ERR, "Failed to open instance\n");
1619 return rc;
1620 }
1621
1622 rc = msm_comm_try_get_bufreqs(inst);
1623 if (rc) {
1624 dprintk(VIDC_ERR,
1625 "Failed to get buffer requirements: %d\n", rc);
1626 return rc;
1627 }
1628
1629 switch (q->type) {
1630 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
1631 *num_planes = 1;
1632
1633 buff_req = get_buff_req_buffer(inst, HAL_BUFFER_OUTPUT);
1634 if (buff_req) {
1635
1636 /* Pretend as if the FW itself is asking for additional
1637 * buffers, which are required for DCVS
1638 */
1639 unsigned int min_req_buffers =
1640 buff_req->buffer_count_min +
1641 msm_dcvs_get_extra_buff_count(inst);
1642 *num_buffers = max(*num_buffers, min_req_buffers);
1643 }
1644
1645 if (*num_buffers < MIN_NUM_CAPTURE_BUFFERS ||
1646 *num_buffers > VB2_MAX_FRAME) {
1647 int temp = *num_buffers;
1648
1649 *num_buffers = clamp_val(*num_buffers,
1650 MIN_NUM_CAPTURE_BUFFERS,
1651 VB2_MAX_FRAME);
1652 dprintk(VIDC_INFO,
1653 "Changing buffer count on CAPTURE_MPLANE from %d to %d for best effort encoding\n",
1654 temp, *num_buffers);
1655 }
1656
1657 msm_venc_update_plane_count(inst, CAPTURE_PORT);
1658 *num_planes = inst->fmts[CAPTURE_PORT].num_planes;
1659
1660 for (i = 0; i < *num_planes; i++) {
1661 int extra_idx = EXTRADATA_IDX(*num_planes);
1662
1663 buff_req_buffer = get_buff_req_buffer(inst,
1664 HAL_BUFFER_OUTPUT);
1665
1666 sizes[i] = buff_req_buffer ?
1667 buff_req_buffer->buffer_size : 0;
1668
1669 if (extra_idx && i == extra_idx &&
1670 extra_idx < VIDEO_MAX_PLANES) {
1671 buff_req_buffer = get_buff_req_buffer(inst,
1672 HAL_BUFFER_EXTRADATA_OUTPUT);
1673 if (!buff_req_buffer) {
1674 dprintk(VIDC_ERR,
1675 "%s: failed - invalid buffer req\n",
1676 __func__);
1677 return -EINVAL;
1678 }
1679
1680 sizes[i] = buff_req_buffer->buffer_size;
1681 }
1682 }
1683
1684 dprintk(VIDC_DBG, "actual output buffer count set to fw = %d\n",
1685 *num_buffers);
1686 property_id = HAL_PARAM_BUFFER_COUNT_ACTUAL;
1687 new_buf_count.buffer_type = HAL_BUFFER_OUTPUT;
1688 new_buf_count.buffer_count_actual = *num_buffers;
1689 rc = call_hfi_op(hdev, session_set_property, inst->session,
1690 property_id, &new_buf_count);
1691
1692 break;
1693 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
1694 *num_planes = 1;
1695
1696 *num_buffers = inst->buff_req.buffer[0].buffer_count_actual =
1697 max(*num_buffers, inst->buff_req.buffer[0].
1698 buffer_count_min);
1699
1700 temp = *num_buffers;
1701
1702 *num_buffers = clamp_val(*num_buffers,
1703 MIN_NUM_OUTPUT_BUFFERS,
1704 VB2_MAX_FRAME);
1705 dprintk(VIDC_INFO,
1706 "Changing buffer count on OUTPUT_MPLANE from %d to %d for best effort encoding\n",
1707 temp, *num_buffers);
1708
1709 property_id = HAL_PARAM_BUFFER_COUNT_ACTUAL;
1710 new_buf_count.buffer_type = HAL_BUFFER_INPUT;
1711 new_buf_count.buffer_count_actual = *num_buffers;
1712
1713 dprintk(VIDC_DBG, "actual input buffer count set to fw = %d\n",
1714 *num_buffers);
1715 msm_venc_update_plane_count(inst, OUTPUT_PORT);
1716 *num_planes = inst->fmts[OUTPUT_PORT].num_planes;
1717
1718 rc = call_hfi_op(hdev, session_set_property, inst->session,
1719 property_id, &new_buf_count);
1720 if (rc)
1721 dprintk(VIDC_ERR, "failed to set count to fw\n");
1722
1723 dprintk(VIDC_DBG, "size = %d, alignment = %d, count = %d\n",
1724 inst->buff_req.buffer[0].buffer_size,
1725 inst->buff_req.buffer[0].buffer_alignment,
1726 inst->buff_req.buffer[0].buffer_count_actual);
1727 sizes[0] = inst->fmts[OUTPUT_PORT].get_frame_size(
1728 0, inst->prop.height[OUTPUT_PORT],
1729 inst->prop.width[OUTPUT_PORT]);
1730
1731 extra_idx =
1732 EXTRADATA_IDX(inst->fmts[OUTPUT_PORT].num_planes);
1733 if (extra_idx && (extra_idx < VIDEO_MAX_PLANES)) {
1734 buff_req_buffer = get_buff_req_buffer(inst,
1735 HAL_BUFFER_EXTRADATA_INPUT);
1736 if (!buff_req_buffer) {
1737 dprintk(VIDC_ERR,
1738 "%s: failed - invalid buffer req\n",
1739 __func__);
1740 return -EINVAL;
1741 }
1742
1743 sizes[extra_idx] = buff_req_buffer->buffer_size;
1744 }
1745
1746 break;
1747 default:
1748 dprintk(VIDC_ERR, "Invalid q type = %d\n", q->type);
1749 rc = -EINVAL;
1750 break;
1751 }
1752 return rc;
1753}
1754
1755static int msm_venc_toggle_hier_p(struct msm_vidc_inst *inst, int layers)
1756{
1757 int num_enh_layers = 0;
1758 u32 property_id = 0;
1759 struct hfi_device *hdev = NULL;
1760 int rc = 0;
1761
1762 if (!inst || !inst->core || !inst->core->device) {
1763 dprintk(VIDC_ERR, "%s invalid parameters\n", __func__);
1764 return -EINVAL;
1765 }
1766
1767 if (inst->fmts[CAPTURE_PORT].fourcc != V4L2_PIX_FMT_VP8)
1768 return 0;
1769
1770 num_enh_layers = layers ? : 0;
1771 dprintk(VIDC_DBG, "%s Hier-P in firmware\n",
1772 num_enh_layers ? "Enable" : "Disable");
1773
1774 hdev = inst->core->device;
1775 property_id = HAL_PARAM_VENC_HIER_P_MAX_ENH_LAYERS;
1776 rc = call_hfi_op(hdev, session_set_property,
1777 (void *)inst->session, property_id,
1778 (void *)&num_enh_layers);
1779 if (rc) {
1780 dprintk(VIDC_ERR,
1781 "%s: failed with error = %d\n", __func__, rc);
1782 }
1783 return rc;
1784}
1785
1786static inline int msm_venc_power_save_mode_enable(struct msm_vidc_inst *inst)
1787{
1788 u32 rc = 0;
1789 u32 prop_id = 0, power_save_min = 0, power_save_max = 0, inst_load = 0;
1790 void *pdata = NULL;
1791 struct hfi_device *hdev = NULL;
1792 enum hal_perf_mode venc_mode;
1793 enum load_calc_quirks quirks = LOAD_CALC_IGNORE_TURBO_LOAD |
1794 LOAD_CALC_IGNORE_THUMBNAIL_LOAD;
1795
1796 if (!inst || !inst->core || !inst->core->device) {
1797 dprintk(VIDC_ERR, "%s invalid parameters\n", __func__);
1798 return -EINVAL;
1799 }
1800
1801 inst_load = msm_comm_get_inst_load(inst, quirks);
1802 power_save_min = inst->capability.mbs_per_sec_power_save.min;
1803 power_save_max = inst->capability.mbs_per_sec_power_save.max;
1804
1805 dprintk(VIDC_DBG,
1806 "Power Save Mode min mb's %d max mb's %d inst load %d\n",
1807 power_save_min, power_save_max, inst_load);
1808
1809 if (!power_save_min || !power_save_max)
1810 return rc;
1811
1812 hdev = inst->core->device;
1813 if (inst_load >= power_save_min) {
1814 prop_id = HAL_CONFIG_VENC_PERF_MODE;
1815 venc_mode = HAL_PERF_MODE_POWER_SAVE;
1816 pdata = &venc_mode;
1817 rc = call_hfi_op(hdev, session_set_property,
1818 (void *)inst->session, prop_id, pdata);
1819 if (rc) {
1820 dprintk(VIDC_ERR,
1821 "%s: Failed to set power save mode for inst: %pK\n",
1822 __func__, inst);
1823 goto fail_power_mode_set;
1824 }
1825 inst->flags |= VIDC_LOW_POWER;
1826 msm_dcvs_enc_set_power_save_mode(inst, true);
1827 dprintk(VIDC_INFO, "Power Save Mode set for inst: %pK\n", inst);
1828 }
1829
1830fail_power_mode_set:
1831 return rc;
1832}
1833
1834static inline int start_streaming(struct msm_vidc_inst *inst)
1835{
1836 int rc = 0;
1837
1838 if (!inst || !inst->core || !inst->core->device) {
1839 dprintk(VIDC_ERR, "%s invalid parameters\n", __func__);
1840 return -EINVAL;
1841 }
1842 msm_venc_power_save_mode_enable(inst);
1843 if (inst->capability.pixelprocess_capabilities &
1844 HAL_VIDEO_ENCODER_SCALING_CAPABILITY)
1845 rc = msm_vidc_check_scaling_supported(inst);
1846 if (rc) {
1847 dprintk(VIDC_ERR, "H/w scaling is not in valid range\n");
1848 return -EINVAL;
1849 }
1850 rc = msm_comm_try_get_bufreqs(inst);
1851 if (rc) {
1852 dprintk(VIDC_ERR,
1853 "Failed to get Buffer Requirements : %d\n", rc);
1854 goto fail_start;
1855 }
1856 rc = msm_comm_set_scratch_buffers(inst);
1857 if (rc) {
1858 dprintk(VIDC_ERR, "Failed to set scratch buffers: %d\n", rc);
1859 goto fail_start;
1860 }
1861 rc = msm_comm_set_persist_buffers(inst);
1862 if (rc) {
1863 dprintk(VIDC_ERR, "Failed to set persist buffers: %d\n", rc);
1864 goto fail_start;
1865 }
1866
1867 msm_comm_scale_clocks_and_bus(inst);
1868
1869 rc = msm_comm_try_state(inst, MSM_VIDC_START_DONE);
1870 if (rc) {
1871 dprintk(VIDC_ERR,
1872 "Failed to move inst: %pK to start done state\n", inst);
1873 goto fail_start;
1874 }
1875 msm_dcvs_init_load(inst);
1876
1877fail_start:
1878 return rc;
1879}
1880
1881static int msm_venc_start_streaming(struct vb2_queue *q, unsigned int count)
1882{
1883 struct msm_vidc_inst *inst;
1884 int rc = 0;
1885
1886 if (!q || !q->drv_priv) {
1887 dprintk(VIDC_ERR, "Invalid input, q = %pK\n", q);
1888 return -EINVAL;
1889 }
1890 inst = q->drv_priv;
1891 dprintk(VIDC_DBG, "Streamon called on: %d capability for inst: %pK\n",
1892 q->type, inst);
1893 switch (q->type) {
1894 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
1895 if (inst->bufq[CAPTURE_PORT].vb2_bufq.streaming)
1896 rc = start_streaming(inst);
1897 break;
1898 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
1899 if (inst->bufq[OUTPUT_PORT].vb2_bufq.streaming)
1900 rc = start_streaming(inst);
1901 break;
1902 default:
1903 dprintk(VIDC_ERR, "Queue type is not supported: %d\n", q->type);
1904 rc = -EINVAL;
1905 goto stream_start_failed;
1906 }
1907 if (rc) {
1908 dprintk(VIDC_ERR,
1909 "Streamon failed on: %d capability for inst: %pK\n",
1910 q->type, inst);
1911 goto stream_start_failed;
1912 }
1913
1914 rc = msm_comm_qbuf(inst, NULL);
1915 if (rc) {
1916 dprintk(VIDC_ERR,
1917 "Failed to commit buffers queued before STREAM_ON to hardware: %d\n",
1918 rc);
1919 goto stream_start_failed;
1920 }
1921
1922stream_start_failed:
1923 return rc;
1924}
1925
1926static void msm_venc_stop_streaming(struct vb2_queue *q)
1927{
1928 struct msm_vidc_inst *inst;
1929 int rc = 0;
1930
1931 if (!q || !q->drv_priv) {
1932 dprintk(VIDC_ERR, "%s - Invalid input, q = %pK\n", __func__, q);
1933 return;
1934 }
1935
1936 inst = q->drv_priv;
1937 dprintk(VIDC_DBG, "Streamoff called on: %d capability\n", q->type);
1938 switch (q->type) {
1939 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
1940 break;
1941 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
1942 rc = msm_comm_try_state(inst, MSM_VIDC_RELEASE_RESOURCES_DONE);
1943 break;
1944 default:
1945 dprintk(VIDC_ERR, "Q-type is not supported: %d\n", q->type);
1946 rc = -EINVAL;
1947 break;
1948 }
1949
1950 msm_comm_scale_clocks_and_bus(inst);
1951
1952 if (rc)
1953 dprintk(VIDC_ERR,
1954 "Failed to move inst: %pK, cap = %d to state: %d\n",
1955 inst, q->type, MSM_VIDC_CLOSE_DONE);
1956}
1957
1958static void msm_venc_buf_queue(struct vb2_buffer *vb)
1959{
1960 int rc = msm_comm_qbuf(vb2_get_drv_priv(vb->vb2_queue), vb);
1961
1962 if (rc)
1963 dprintk(VIDC_ERR, "Failed to queue buffer: %d\n", rc);
1964}
1965
1966static const struct vb2_ops msm_venc_vb2q_ops = {
1967 .queue_setup = msm_venc_queue_setup,
1968 .start_streaming = msm_venc_start_streaming,
1969 .buf_queue = msm_venc_buf_queue,
1970 .stop_streaming = msm_venc_stop_streaming,
1971};
1972
1973const struct vb2_ops *msm_venc_get_vb2q_ops(void)
1974{
1975 return &msm_venc_vb2q_ops;
1976}
1977
1978static struct v4l2_ctrl *get_ctrl_from_cluster(int id,
1979 struct v4l2_ctrl **cluster, int ncontrols)
1980{
1981 int c;
1982
1983 for (c = 0; c < ncontrols; ++c)
1984 if (cluster[c]->id == id)
1985 return cluster[c];
1986 return NULL;
1987}
1988
1989/* Helper function to translate V4L2_* to HAL_* */
1990static inline int venc_v4l2_to_hal(int id, int value)
1991{
1992 switch (id) {
1993 /* MPEG4 */
1994 case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
1995 switch (value) {
1996 case V4L2_MPEG_VIDEO_MPEG4_LEVEL_0:
1997 return HAL_MPEG4_LEVEL_0;
1998 case V4L2_MPEG_VIDEO_MPEG4_LEVEL_0B:
1999 return HAL_MPEG4_LEVEL_0b;
2000 case V4L2_MPEG_VIDEO_MPEG4_LEVEL_1:
2001 return HAL_MPEG4_LEVEL_1;
2002 case V4L2_MPEG_VIDEO_MPEG4_LEVEL_2:
2003 return HAL_MPEG4_LEVEL_2;
2004 case V4L2_MPEG_VIDEO_MPEG4_LEVEL_3:
2005 return HAL_MPEG4_LEVEL_3;
2006 case V4L2_MPEG_VIDEO_MPEG4_LEVEL_4:
2007 return HAL_MPEG4_LEVEL_4;
2008 case V4L2_MPEG_VIDEO_MPEG4_LEVEL_5:
2009 return HAL_MPEG4_LEVEL_5;
2010 default:
2011 goto unknown_value;
2012 }
2013 case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
2014 switch (value) {
2015 case V4L2_MPEG_VIDEO_MPEG4_PROFILE_SIMPLE:
2016 return HAL_MPEG4_PROFILE_SIMPLE;
2017 case V4L2_MPEG_VIDEO_MPEG4_PROFILE_ADVANCED_SIMPLE:
2018 return HAL_MPEG4_PROFILE_ADVANCEDSIMPLE;
2019 default:
2020 goto unknown_value;
2021 }
2022 /* H264 */
2023 case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
2024 switch (value) {
2025 case V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE:
2026 return HAL_H264_PROFILE_BASELINE;
2027 case V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_BASELINE:
2028 return HAL_H264_PROFILE_CONSTRAINED_BASE;
2029 case V4L2_MPEG_VIDEO_H264_PROFILE_MAIN:
2030 return HAL_H264_PROFILE_MAIN;
2031 case V4L2_MPEG_VIDEO_H264_PROFILE_EXTENDED:
2032 return HAL_H264_PROFILE_EXTENDED;
2033 case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH:
2034 return HAL_H264_PROFILE_HIGH;
2035 case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_10:
2036 return HAL_H264_PROFILE_HIGH10;
2037 case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_422:
2038 return HAL_H264_PROFILE_HIGH422;
2039 case V4L2_MPEG_VIDEO_H264_PROFILE_HIGH_444_PREDICTIVE:
2040 return HAL_H264_PROFILE_HIGH444;
2041 case V4L2_MPEG_VIDEO_H264_PROFILE_CONSTRAINED_HIGH:
2042 return HAL_H264_PROFILE_CONSTRAINED_HIGH;
2043 default:
2044 goto unknown_value;
2045 }
2046 case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
2047 switch (value) {
2048 case V4L2_MPEG_VIDEO_H264_LEVEL_1_0:
2049 return HAL_H264_LEVEL_1;
2050 case V4L2_MPEG_VIDEO_H264_LEVEL_1B:
2051 return HAL_H264_LEVEL_1b;
2052 case V4L2_MPEG_VIDEO_H264_LEVEL_1_1:
2053 return HAL_H264_LEVEL_11;
2054 case V4L2_MPEG_VIDEO_H264_LEVEL_1_2:
2055 return HAL_H264_LEVEL_12;
2056 case V4L2_MPEG_VIDEO_H264_LEVEL_1_3:
2057 return HAL_H264_LEVEL_13;
2058 case V4L2_MPEG_VIDEO_H264_LEVEL_2_0:
2059 return HAL_H264_LEVEL_2;
2060 case V4L2_MPEG_VIDEO_H264_LEVEL_2_1:
2061 return HAL_H264_LEVEL_21;
2062 case V4L2_MPEG_VIDEO_H264_LEVEL_2_2:
2063 return HAL_H264_LEVEL_22;
2064 case V4L2_MPEG_VIDEO_H264_LEVEL_3_0:
2065 return HAL_H264_LEVEL_3;
2066 case V4L2_MPEG_VIDEO_H264_LEVEL_3_1:
2067 return HAL_H264_LEVEL_31;
2068 case V4L2_MPEG_VIDEO_H264_LEVEL_3_2:
2069 return HAL_H264_LEVEL_32;
2070 case V4L2_MPEG_VIDEO_H264_LEVEL_4_0:
2071 return HAL_H264_LEVEL_4;
2072 case V4L2_MPEG_VIDEO_H264_LEVEL_4_1:
2073 return HAL_H264_LEVEL_41;
2074 case V4L2_MPEG_VIDEO_H264_LEVEL_4_2:
2075 return HAL_H264_LEVEL_42;
2076 case V4L2_MPEG_VIDEO_H264_LEVEL_5_0:
2077 return HAL_H264_LEVEL_5;
2078 case V4L2_MPEG_VIDEO_H264_LEVEL_5_1:
2079 return HAL_H264_LEVEL_51;
2080 case V4L2_MPEG_VIDEO_H264_LEVEL_5_2:
2081 return HAL_H264_LEVEL_52;
2082 default:
2083 goto unknown_value;
2084 }
2085 /* H263 */
2086 case V4L2_CID_MPEG_VIDC_VIDEO_H263_PROFILE:
2087 switch (value) {
2088 case V4L2_MPEG_VIDC_VIDEO_H263_PROFILE_BASELINE:
2089 return HAL_H263_PROFILE_BASELINE;
2090 case V4L2_MPEG_VIDC_VIDEO_H263_PROFILE_H320CODING:
2091 return HAL_H263_PROFILE_H320CODING;
2092 case V4L2_MPEG_VIDC_VIDEO_H263_PROFILE_BACKWARDCOMPATIBLE:
2093 return HAL_H263_PROFILE_BACKWARDCOMPATIBLE;
2094 case V4L2_MPEG_VIDC_VIDEO_H263_PROFILE_ISWV2:
2095 return HAL_H263_PROFILE_ISWV2;
2096 case V4L2_MPEG_VIDC_VIDEO_H263_PROFILE_ISWV3:
2097 return HAL_H263_PROFILE_ISWV3;
2098 case V4L2_MPEG_VIDC_VIDEO_H263_PROFILE_HIGHCOMPRESSION:
2099 return HAL_H263_PROFILE_HIGHCOMPRESSION;
2100 case V4L2_MPEG_VIDC_VIDEO_H263_PROFILE_INTERNET:
2101 return HAL_H263_PROFILE_INTERNET;
2102 case V4L2_MPEG_VIDC_VIDEO_H263_PROFILE_INTERLACE:
2103 return HAL_H263_PROFILE_INTERLACE;
2104 case V4L2_MPEG_VIDC_VIDEO_H263_PROFILE_HIGHLATENCY:
2105 return HAL_H263_PROFILE_HIGHLATENCY;
2106 default:
2107 goto unknown_value;
2108 }
2109 case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
2110 switch (value) {
2111 case V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CAVLC:
2112 return HAL_H264_ENTROPY_CAVLC;
2113 case V4L2_MPEG_VIDEO_H264_ENTROPY_MODE_CABAC:
2114 return HAL_H264_ENTROPY_CABAC;
2115 default:
2116 goto unknown_value;
2117 }
2118 case V4L2_CID_MPEG_VIDC_VIDEO_H264_CABAC_MODEL:
2119 switch (value) {
2120 case V4L2_CID_MPEG_VIDC_VIDEO_H264_CABAC_MODEL_0:
2121 return HAL_H264_CABAC_MODEL_0;
2122 case V4L2_CID_MPEG_VIDC_VIDEO_H264_CABAC_MODEL_1:
2123 return HAL_H264_CABAC_MODEL_1;
2124 case V4L2_CID_MPEG_VIDC_VIDEO_H264_CABAC_MODEL_2:
2125 return HAL_H264_CABAC_MODEL_2;
2126 default:
2127 goto unknown_value;
2128 }
2129 case V4L2_CID_MPEG_VIDC_VIDEO_H263_LEVEL:
2130 switch (value) {
2131 case V4L2_MPEG_VIDC_VIDEO_H263_LEVEL_1_0:
2132 return HAL_H263_LEVEL_10;
2133 case V4L2_MPEG_VIDC_VIDEO_H263_LEVEL_2_0:
2134 return HAL_H263_LEVEL_20;
2135 case V4L2_MPEG_VIDC_VIDEO_H263_LEVEL_3_0:
2136 return HAL_H263_LEVEL_30;
2137 case V4L2_MPEG_VIDC_VIDEO_H263_LEVEL_4_0:
2138 return HAL_H263_LEVEL_40;
2139 case V4L2_MPEG_VIDC_VIDEO_H263_LEVEL_4_5:
2140 return HAL_H263_LEVEL_45;
2141 case V4L2_MPEG_VIDC_VIDEO_H263_LEVEL_5_0:
2142 return HAL_H263_LEVEL_50;
2143 case V4L2_MPEG_VIDC_VIDEO_H263_LEVEL_6_0:
2144 return HAL_H263_LEVEL_60;
2145 case V4L2_MPEG_VIDC_VIDEO_H263_LEVEL_7_0:
2146 return HAL_H263_LEVEL_70;
2147 default:
2148 goto unknown_value;
2149 }
2150 case V4L2_CID_MPEG_VIDC_VIDEO_VP8_PROFILE_LEVEL:
2151 switch (value) {
2152 case V4L2_MPEG_VIDC_VIDEO_VP8_VERSION_0:
2153 return HAL_VPX_PROFILE_VERSION_0;
2154 case V4L2_MPEG_VIDC_VIDEO_VP8_VERSION_1:
2155 return HAL_VPX_PROFILE_VERSION_1;
2156 case V4L2_MPEG_VIDC_VIDEO_VP8_VERSION_2:
2157 return HAL_VPX_PROFILE_VERSION_2;
2158 case V4L2_MPEG_VIDC_VIDEO_VP8_VERSION_3:
2159 return HAL_VPX_PROFILE_VERSION_3;
2160 case V4L2_MPEG_VIDC_VIDEO_VP8_UNUSED:
2161 return HAL_VPX_PROFILE_UNUSED;
2162 default:
2163 goto unknown_value;
2164 }
2165 case V4L2_CID_MPEG_VIDC_VIDEO_HEVC_PROFILE:
2166 switch (value) {
2167 case V4L2_MPEG_VIDC_VIDEO_HEVC_PROFILE_MAIN:
2168 return HAL_HEVC_PROFILE_MAIN;
2169 case V4L2_MPEG_VIDC_VIDEO_HEVC_PROFILE_MAIN10:
2170 return HAL_HEVC_PROFILE_MAIN10;
2171 case V4L2_MPEG_VIDC_VIDEO_HEVC_PROFILE_MAIN_STILL_PIC:
2172 return HAL_HEVC_PROFILE_MAIN_STILL_PIC;
2173 default:
2174 goto unknown_value;
2175 }
2176 case V4L2_CID_MPEG_VIDC_VIDEO_HEVC_TIER_LEVEL:
2177 switch (value) {
2178 case V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_MAIN_TIER_LEVEL_1:
2179 return HAL_HEVC_MAIN_TIER_LEVEL_1;
2180 case V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_MAIN_TIER_LEVEL_2:
2181 return HAL_HEVC_MAIN_TIER_LEVEL_2;
2182 case V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_MAIN_TIER_LEVEL_2_1:
2183 return HAL_HEVC_MAIN_TIER_LEVEL_2_1;
2184 case V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_MAIN_TIER_LEVEL_3:
2185 return HAL_HEVC_MAIN_TIER_LEVEL_3;
2186 case V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_MAIN_TIER_LEVEL_3_1:
2187 return HAL_HEVC_MAIN_TIER_LEVEL_3_1;
2188 case V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_MAIN_TIER_LEVEL_4:
2189 return HAL_HEVC_MAIN_TIER_LEVEL_4;
2190 case V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_MAIN_TIER_LEVEL_4_1:
2191 return HAL_HEVC_MAIN_TIER_LEVEL_4_1;
2192 case V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_MAIN_TIER_LEVEL_5:
2193 return HAL_HEVC_MAIN_TIER_LEVEL_5;
2194 case V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_MAIN_TIER_LEVEL_5_1:
2195 return HAL_HEVC_MAIN_TIER_LEVEL_5_1;
2196 case V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_MAIN_TIER_LEVEL_5_2:
2197 return HAL_HEVC_MAIN_TIER_LEVEL_5_2;
2198 case V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_MAIN_TIER_LEVEL_6:
2199 return HAL_HEVC_MAIN_TIER_LEVEL_6;
2200 case V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_MAIN_TIER_LEVEL_6_1:
2201 return HAL_HEVC_MAIN_TIER_LEVEL_6_1;
2202 case V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_MAIN_TIER_LEVEL_6_2:
2203 return HAL_HEVC_MAIN_TIER_LEVEL_6_2;
2204 case V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_HIGH_TIER_LEVEL_1:
2205 return HAL_HEVC_HIGH_TIER_LEVEL_1;
2206 case V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_HIGH_TIER_LEVEL_2:
2207 return HAL_HEVC_HIGH_TIER_LEVEL_2;
2208 case V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_HIGH_TIER_LEVEL_2_1:
2209 return HAL_HEVC_HIGH_TIER_LEVEL_2_1;
2210 case V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_HIGH_TIER_LEVEL_3:
2211 return HAL_HEVC_HIGH_TIER_LEVEL_3;
2212 case V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_HIGH_TIER_LEVEL_3_1:
2213 return HAL_HEVC_HIGH_TIER_LEVEL_3_1;
2214 case V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_HIGH_TIER_LEVEL_4:
2215 return HAL_HEVC_HIGH_TIER_LEVEL_4;
2216 case V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_HIGH_TIER_LEVEL_4_1:
2217 return HAL_HEVC_HIGH_TIER_LEVEL_4_1;
2218 case V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_HIGH_TIER_LEVEL_5:
2219 return HAL_HEVC_HIGH_TIER_LEVEL_5;
2220 case V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_HIGH_TIER_LEVEL_5_1:
2221 return HAL_HEVC_HIGH_TIER_LEVEL_5_1;
2222 case V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_HIGH_TIER_LEVEL_5_2:
2223 return HAL_HEVC_HIGH_TIER_LEVEL_5_2;
2224 case V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_HIGH_TIER_LEVEL_6:
2225 return HAL_HEVC_HIGH_TIER_LEVEL_6;
2226 case V4L2_MPEG_VIDC_VIDEO_HEVC_LEVEL_HIGH_TIER_LEVEL_6_1:
2227 return HAL_HEVC_HIGH_TIER_LEVEL_6_1;
2228 default:
2229 goto unknown_value;
2230 }
2231 case V4L2_CID_MPEG_VIDC_VIDEO_ROTATION:
2232 switch (value) {
2233 case V4L2_CID_MPEG_VIDC_VIDEO_ROTATION_NONE:
2234 return HAL_ROTATE_NONE;
2235 case V4L2_CID_MPEG_VIDC_VIDEO_ROTATION_90:
2236 return HAL_ROTATE_90;
2237 case V4L2_CID_MPEG_VIDC_VIDEO_ROTATION_180:
2238 return HAL_ROTATE_180;
2239 case V4L2_CID_MPEG_VIDC_VIDEO_ROTATION_270:
2240 return HAL_ROTATE_270;
2241 default:
2242 goto unknown_value;
2243 }
2244 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
2245 switch (value) {
2246 case V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_DISABLED:
2247 return HAL_H264_DB_MODE_DISABLE;
2248 case V4L2_MPEG_VIDEO_H264_LOOP_FILTER_MODE_ENABLED:
2249 return HAL_H264_DB_MODE_ALL_BOUNDARY;
2250 case L_MODE:
2251 return HAL_H264_DB_MODE_SKIP_SLICE_BOUNDARY;
2252 default:
2253 goto unknown_value;
2254 }
2255 case V4L2_CID_MPEG_VIDC_VIDEO_MBI_STATISTICS_MODE:
2256 switch (value) {
2257 case V4L2_CID_MPEG_VIDC_VIDEO_MBI_MODE_DEFAULT:
2258 return HAL_STATISTICS_MODE_DEFAULT;
2259 case V4L2_CID_MPEG_VIDC_VIDEO_MBI_MODE_1:
2260 return HAL_STATISTICS_MODE_1;
2261 case V4L2_CID_MPEG_VIDC_VIDEO_MBI_MODE_2:
2262 return HAL_STATISTICS_MODE_2;
2263 case V4L2_CID_MPEG_VIDC_VIDEO_MBI_MODE_3:
2264 return HAL_STATISTICS_MODE_3;
2265 default:
2266 goto unknown_value;
2267 }
2268 case V4L2_CID_MPEG_VIDC_VIDEO_IFRAME_SIZE_TYPE:
2269 switch (value) {
2270 case V4L2_CID_MPEG_VIDC_VIDEO_IFRAME_SIZE_DEFAULT:
2271 return HAL_IFRAMESIZE_TYPE_DEFAULT;
2272 case V4L2_CID_MPEG_VIDC_VIDEO_IFRAME_SIZE_MEDIUM:
2273 return HAL_IFRAMESIZE_TYPE_MEDIUM;
2274 case V4L2_CID_MPEG_VIDC_VIDEO_IFRAME_SIZE_HUGE:
2275 return HAL_IFRAMESIZE_TYPE_HUGE;
2276 case V4L2_CID_MPEG_VIDC_VIDEO_IFRAME_SIZE_UNLIMITED:
2277 return HAL_IFRAMESIZE_TYPE_UNLIMITED;
2278 default:
2279 goto unknown_value;
2280 }
2281 }
2282
2283unknown_value:
2284 dprintk(VIDC_WARN, "Unknown control (%x, %d)\n", id, value);
2285 return -EINVAL;
2286}
2287
2288/* Small helper macro for quickly getting a control and err checking */
2289#define TRY_GET_CTRL(__ctrl_id) ({ \
2290 struct v4l2_ctrl *__temp; \
2291 __temp = get_ctrl_from_cluster( \
2292 __ctrl_id, \
2293 ctrl->cluster, ctrl->ncontrols); \
2294 if (!__temp) { \
2295 dprintk(VIDC_ERR, "Can't find %s (%x) in cluster\n", \
2296 #__ctrl_id, __ctrl_id); \
2297 /* Clusters are hardcoded, if we can't find */ \
2298 /* something then things are massively screwed up */ \
2299 WARN_ON(VIDC_DBG_WARN_ENABLE); \
2300 } \
2301 __temp; \
2302 })
2303
2304static int msm_venc_validate_qp_value(struct msm_vidc_inst *inst,
2305 struct v4l2_ctrl *ctrl)
2306{
2307 int rc = 0, min, max;
2308 struct v4l2_ctrl *temp_ctrl = NULL;
2309 int qp_value = ctrl->val;
2310
2311#define VALIDATE_BOUNDARIES(__min, __max, __val) ({\
2312 int __rc = __val >= __min && \
2313 __val <= __max; \
2314 if (!__rc) \
2315 dprintk(VIDC_ERR, "QP beyond range: min(%d) max(%d) val(%d)", \
2316 __min, __max, __val); \
2317 __rc; \
2318})
2319
2320 switch (inst->fmts[CAPTURE_PORT].fourcc) {
2321 case V4L2_PIX_FMT_VP8:
2322 temp_ctrl = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_VPX_MAX_QP);
2323 max = temp_ctrl->maximum;
2324 temp_ctrl = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_VPX_MIN_QP);
2325 min = temp_ctrl->minimum;
2326 if (!VALIDATE_BOUNDARIES(min, max, qp_value))
2327 rc = -EINVAL;
2328 break;
2329 case V4L2_PIX_FMT_H263:
2330 case V4L2_PIX_FMT_MPEG4:
2331 temp_ctrl = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP);
2332 max = temp_ctrl->maximum;
2333 temp_ctrl = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP);
2334 min = temp_ctrl->minimum;
2335 if (!VALIDATE_BOUNDARIES(min, max, qp_value))
2336 rc = -EINVAL;
2337 break;
2338 case V4L2_PIX_FMT_H264:
2339 case V4L2_PIX_FMT_HEVC:
2340 temp_ctrl = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_H264_MAX_QP);
2341 max = temp_ctrl->maximum;
2342 temp_ctrl = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_H264_MIN_QP);
2343 min = temp_ctrl->minimum;
2344 if (!VALIDATE_BOUNDARIES(min, max, qp_value))
2345 rc = -EINVAL;
2346 break;
2347 default:
2348 dprintk(VIDC_ERR, "%s Invalid Codec\n", __func__);
2349 return -EINVAL;
2350 }
2351 return rc;
2352#undef VALIDATE_BOUNDARIES
2353}
2354
2355
2356static int try_set_ctrl(struct msm_vidc_inst *inst, struct v4l2_ctrl *ctrl)
2357{
2358 int rc = 0;
2359 struct hal_request_iframe request_iframe;
2360 struct hal_bitrate bitrate;
2361 struct hal_profile_level profile_level;
2362 struct hal_h264_entropy_control h264_entropy_control;
2363 struct hal_quantization quantization;
2364 struct hal_intra_period intra_period;
2365 struct hal_idr_period idr_period;
2366 struct hal_operations operations;
2367 struct hal_intra_refresh intra_refresh;
2368 struct hal_multi_slice_control multi_slice_control;
2369 struct hal_h264_db_control h264_db_control;
2370 struct hal_enable enable;
2371 struct hal_h264_vui_timing_info vui_timing_info;
2372 struct hal_quantization_range qp_range;
2373 struct hal_h264_vui_bitstream_restrc vui_bitstream_restrict;
2374 struct hal_preserve_text_quality preserve_text_quality;
2375 u32 property_id = 0, property_val = 0;
2376 void *pdata = NULL;
2377 struct v4l2_ctrl *temp_ctrl = NULL;
2378 struct hfi_device *hdev;
2379 struct hal_extradata_enable extra;
2380 struct hal_mpeg4_time_resolution time_res;
2381 struct hal_ltr_use use_ltr;
2382 struct hal_ltr_mark mark_ltr;
2383 struct hal_hybrid_hierp hyb_hierp;
2384 u32 hier_p_layers = 0, hier_b_layers = 0, mbi_statistics_mode = 0;
2385 enum hal_perf_mode venc_mode;
2386 int max_hierp_layers;
2387 int baselayerid = 0;
2388 int frameqp = 0;
2389 int pic_order_cnt = 0;
2390 struct hal_video_signal_info signal_info = {0};
2391 enum hal_iframesize_type iframesize_type = HAL_IFRAMESIZE_TYPE_DEFAULT;
2392
2393 if (!inst || !inst->core || !inst->core->device) {
2394 dprintk(VIDC_ERR, "%s invalid parameters\n", __func__);
2395 return -EINVAL;
2396 }
2397 hdev = inst->core->device;
2398
2399 /*
2400 * Unlock the control prior to setting to the hardware. Otherwise
2401 * lower level code that attempts to do a get_ctrl() will end up
2402 * deadlocking.
2403 */
2404 v4l2_ctrl_unlock(ctrl);
2405
2406 switch (ctrl->id) {
2407 case V4L2_CID_MPEG_VIDC_VIDEO_IDR_PERIOD:
2408 if (inst->fmts[CAPTURE_PORT].fourcc != V4L2_PIX_FMT_H264 &&
2409 inst->fmts[CAPTURE_PORT].fourcc !=
2410 V4L2_PIX_FMT_H264_NO_SC &&
2411 inst->fmts[CAPTURE_PORT].fourcc !=
2412 V4L2_PIX_FMT_HEVC) {
2413 dprintk(VIDC_ERR,
2414 "Control %#x only valid for H264 and HEVC\n",
2415 ctrl->id);
2416 rc = -ENOTSUPP;
2417 break;
2418 }
2419
2420 property_id = HAL_CONFIG_VENC_IDR_PERIOD;
2421 idr_period.idr_period = ctrl->val;
2422 pdata = &idr_period;
2423 break;
2424 case V4L2_CID_MPEG_VIDC_VIDEO_NUM_B_FRAMES:
2425 case V4L2_CID_MPEG_VIDC_VIDEO_NUM_P_FRAMES:
2426 {
2427 int num_p, num_b;
2428 u32 max_num_b_frames;
2429
2430 temp_ctrl = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_NUM_B_FRAMES);
2431 num_b = temp_ctrl->val;
2432
2433 temp_ctrl = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_NUM_P_FRAMES);
2434 num_p = temp_ctrl->val;
2435
2436 if (ctrl->id == V4L2_CID_MPEG_VIDC_VIDEO_NUM_P_FRAMES)
2437 num_p = ctrl->val;
2438 else if (ctrl->id == V4L2_CID_MPEG_VIDC_VIDEO_NUM_B_FRAMES)
2439 num_b = ctrl->val;
2440
2441 max_num_b_frames = num_b ? MAX_NUM_B_FRAMES : 0;
2442 property_id = HAL_PARAM_VENC_MAX_NUM_B_FRAMES;
2443 pdata = &max_num_b_frames;
2444 rc = call_hfi_op(hdev, session_set_property,
2445 (void *)inst->session, property_id, pdata);
2446 if (rc) {
2447 dprintk(VIDC_ERR,
2448 "Failed : Setprop MAX_NUM_B_FRAMES %d\n",
2449 rc);
2450 break;
2451 }
2452
2453 property_id = HAL_CONFIG_VENC_INTRA_PERIOD;
2454 intra_period.pframes = num_p;
2455 intra_period.bframes = num_b;
2456
2457 /*
2458 *Incase firmware does not have B-Frame support,
2459 *offload the b-frame count to p-frame to make up
2460 *for the requested Intraperiod
2461 */
2462 if (!inst->capability.bframe.max) {
2463 intra_period.pframes = num_p + num_b;
2464 intra_period.bframes = 0;
2465 dprintk(VIDC_DBG,
2466 "No bframe support, changing pframe from %d to %d\n",
2467 num_p, intra_period.pframes);
2468 }
2469 pdata = &intra_period;
2470 break;
2471 }
2472 case V4L2_CID_MPEG_VIDC_VIDEO_REQUEST_IFRAME:
2473 property_id = HAL_CONFIG_VENC_REQUEST_IFRAME;
2474 request_iframe.enable = true;
2475 pdata = &request_iframe;
2476 break;
2477 case V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL:
2478 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
2479 {
2480 int final_mode = 0;
2481 struct v4l2_ctrl update_ctrl = {.id = 0};
2482
2483 /* V4L2_CID_MPEG_VIDEO_BITRATE_MODE and _RATE_CONTROL
2484 * manipulate the same thing. If one control's state
2485 * changes, try to mirror the state in the other control's
2486 * value
2487 */
2488 if (ctrl->id == V4L2_CID_MPEG_VIDEO_BITRATE_MODE) {
2489 if (ctrl->val == V4L2_MPEG_VIDEO_BITRATE_MODE_VBR) {
2490 final_mode = HAL_RATE_CONTROL_VBR_CFR;
2491 update_ctrl.val =
2492 V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_VBR_CFR;
2493 } else {/* ...if (ctrl->val == _BITRATE_MODE_CBR) */
2494 final_mode = HAL_RATE_CONTROL_CBR_CFR;
2495 update_ctrl.val =
2496 V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_CBR_CFR;
2497 }
2498
2499 update_ctrl.id = V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL;
2500
2501 } else if (ctrl->id == V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL) {
2502 switch (ctrl->val) {
2503 case V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_OFF:
2504 case V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_VBR_VFR:
2505 case V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_VBR_CFR:
2506 update_ctrl.val =
2507 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR;
2508 break;
2509 case V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_CBR_VFR:
2510 case V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_CBR_CFR:
2511 case V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_MBR_CFR:
2512 case V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_MBR_VFR:
2513 update_ctrl.val =
2514 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR;
2515 break;
2516 }
2517
2518 final_mode = ctrl->val;
2519 update_ctrl.id = V4L2_CID_MPEG_VIDEO_BITRATE_MODE;
2520 }
2521
2522 if (update_ctrl.id) {
2523 temp_ctrl = TRY_GET_CTRL(update_ctrl.id);
2524 temp_ctrl->val = update_ctrl.val;
2525 }
2526
2527 property_id = HAL_PARAM_VENC_RATE_CONTROL;
2528 property_val = final_mode;
2529 pdata = &property_val;
2530
2531 break;
2532 }
2533 case V4L2_CID_MPEG_VIDEO_BITRATE:
2534 {
2535 property_id = HAL_CONFIG_VENC_TARGET_BITRATE;
2536 bitrate.bit_rate = ctrl->val;
2537 bitrate.layer_id = 0;
2538 pdata = &bitrate;
2539 break;
2540 }
2541 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
2542 {
2543 struct v4l2_ctrl *avg_bitrate = TRY_GET_CTRL(
2544 V4L2_CID_MPEG_VIDEO_BITRATE);
2545
2546 if (ctrl->val < avg_bitrate->val) {
2547 dprintk(VIDC_ERR,
2548 "Peak bitrate (%d) is lower than average bitrate (%d)\n",
2549 ctrl->val, avg_bitrate->val);
2550 rc = -EINVAL;
2551 break;
2552 } else if (ctrl->val < avg_bitrate->val * 2) {
2553 dprintk(VIDC_WARN,
2554 "Peak bitrate (%d) ideally should be twice the average bitrate (%d)\n",
2555 ctrl->val, avg_bitrate->val);
2556 }
2557
2558 property_id = HAL_CONFIG_VENC_MAX_BITRATE;
2559 bitrate.bit_rate = ctrl->val;
2560 bitrate.layer_id = 0;
2561 pdata = &bitrate;
2562 break;
2563 }
2564 case V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE:
2565 temp_ctrl = TRY_GET_CTRL(
2566 V4L2_CID_MPEG_VIDC_VIDEO_H264_CABAC_MODEL);
2567
2568 property_id = HAL_PARAM_VENC_H264_ENTROPY_CONTROL;
2569 h264_entropy_control.entropy_mode = venc_v4l2_to_hal(
2570 V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE, ctrl->val);
2571 h264_entropy_control.cabac_model = venc_v4l2_to_hal(
2572 V4L2_CID_MPEG_VIDC_VIDEO_H264_CABAC_MODEL,
2573 temp_ctrl->val);
2574 pdata = &h264_entropy_control;
2575 break;
2576 case V4L2_CID_MPEG_VIDC_VIDEO_H264_CABAC_MODEL:
2577 temp_ctrl = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE);
2578
2579 property_id = HAL_PARAM_VENC_H264_ENTROPY_CONTROL;
2580 h264_entropy_control.cabac_model = venc_v4l2_to_hal(
2581 V4L2_CID_MPEG_VIDEO_H264_ENTROPY_MODE, ctrl->val);
2582 h264_entropy_control.entropy_mode = venc_v4l2_to_hal(
2583 V4L2_CID_MPEG_VIDC_VIDEO_H264_CABAC_MODEL,
2584 temp_ctrl->val);
2585 pdata = &h264_entropy_control;
2586 break;
2587 case V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE:
2588 temp_ctrl = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL);
2589
2590 property_id = HAL_PARAM_PROFILE_LEVEL_CURRENT;
2591 profile_level.profile = venc_v4l2_to_hal(ctrl->id,
2592 ctrl->val);
2593 profile_level.level = venc_v4l2_to_hal(
2594 V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL,
2595 temp_ctrl->val);
2596 pdata = &profile_level;
2597 break;
2598 case V4L2_CID_MPEG_VIDEO_MPEG4_LEVEL:
2599 temp_ctrl = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE);
2600
2601 property_id = HAL_PARAM_PROFILE_LEVEL_CURRENT;
2602 profile_level.level = venc_v4l2_to_hal(ctrl->id,
2603 ctrl->val);
2604 profile_level.profile = venc_v4l2_to_hal(
2605 V4L2_CID_MPEG_VIDEO_MPEG4_PROFILE,
2606 temp_ctrl->val);
2607 pdata = &profile_level;
2608 break;
2609 case V4L2_CID_MPEG_VIDEO_H264_PROFILE:
2610 temp_ctrl = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_H264_LEVEL);
2611
2612 property_id = HAL_PARAM_PROFILE_LEVEL_CURRENT;
2613 profile_level.profile = venc_v4l2_to_hal(ctrl->id,
2614 ctrl->val);
2615 profile_level.level = venc_v4l2_to_hal(
2616 V4L2_CID_MPEG_VIDEO_H264_LEVEL,
2617 temp_ctrl->val);
2618 pdata = &profile_level;
2619 dprintk(VIDC_DBG, "\nprofile: %d\n",
2620 profile_level.profile);
2621 break;
2622 case V4L2_CID_MPEG_VIDEO_H264_LEVEL:
2623 temp_ctrl = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_H264_PROFILE);
2624
2625 property_id = HAL_PARAM_PROFILE_LEVEL_CURRENT;
2626 profile_level.level = venc_v4l2_to_hal(ctrl->id,
2627 ctrl->val);
2628 profile_level.profile = venc_v4l2_to_hal(
2629 V4L2_CID_MPEG_VIDEO_H264_PROFILE,
2630 temp_ctrl->val);
2631 pdata = &profile_level;
2632 dprintk(VIDC_DBG, "\nLevel: %d\n",
2633 profile_level.level);
2634 break;
2635 case V4L2_CID_MPEG_VIDC_VIDEO_H263_PROFILE:
2636 temp_ctrl = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_H263_LEVEL);
2637
2638 property_id = HAL_PARAM_PROFILE_LEVEL_CURRENT;
2639 profile_level.profile = venc_v4l2_to_hal(ctrl->id,
2640 ctrl->val);
2641 profile_level.level = venc_v4l2_to_hal(
2642 V4L2_CID_MPEG_VIDC_VIDEO_H263_LEVEL,
2643 temp_ctrl->val);
2644 pdata = &profile_level;
2645 break;
2646 case V4L2_CID_MPEG_VIDC_VIDEO_H263_LEVEL:
2647 temp_ctrl = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_H263_PROFILE);
2648
2649 property_id = HAL_PARAM_PROFILE_LEVEL_CURRENT;
2650 profile_level.level = venc_v4l2_to_hal(ctrl->id,
2651 ctrl->val);
2652 profile_level.profile = venc_v4l2_to_hal(
2653 V4L2_CID_MPEG_VIDC_VIDEO_H263_PROFILE,
2654 ctrl->val);
2655 pdata = &profile_level;
2656 break;
2657 case V4L2_CID_MPEG_VIDC_VIDEO_VP8_PROFILE_LEVEL:
2658 property_id = HAL_PARAM_PROFILE_LEVEL_CURRENT;
2659 profile_level.profile = venc_v4l2_to_hal(
2660 V4L2_CID_MPEG_VIDC_VIDEO_VP8_PROFILE_LEVEL,
2661 ctrl->val);
2662 profile_level.level = HAL_VPX_PROFILE_UNUSED;
2663 pdata = &profile_level;
2664 break;
2665 case V4L2_CID_MPEG_VIDC_VIDEO_HEVC_PROFILE:
2666 temp_ctrl =
2667 TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_HEVC_TIER_LEVEL);
2668
2669 property_id = HAL_PARAM_PROFILE_LEVEL_CURRENT;
2670 profile_level.profile = venc_v4l2_to_hal(ctrl->id,
2671 ctrl->val);
2672 profile_level.level = venc_v4l2_to_hal(
2673 V4L2_CID_MPEG_VIDC_VIDEO_HEVC_TIER_LEVEL,
2674 temp_ctrl->val);
2675 pdata = &profile_level;
2676 break;
2677 case V4L2_CID_MPEG_VIDC_VIDEO_HEVC_TIER_LEVEL:
2678 temp_ctrl = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_HEVC_PROFILE);
2679
2680 property_id = HAL_PARAM_PROFILE_LEVEL_CURRENT;
2681 profile_level.level = venc_v4l2_to_hal(ctrl->id,
2682 ctrl->val);
2683 profile_level.profile = venc_v4l2_to_hal(
2684 V4L2_CID_MPEG_VIDC_VIDEO_HEVC_PROFILE,
2685 temp_ctrl->val);
2686 pdata = &profile_level;
2687 break;
2688 case V4L2_CID_MPEG_VIDC_VIDEO_ROTATION:
2689 {
2690 struct v4l2_ctrl *deinterlace = NULL;
2691
2692 if (!(inst->capability.pixelprocess_capabilities &
2693 HAL_VIDEO_ENCODER_ROTATION_CAPABILITY)) {
2694 dprintk(VIDC_ERR, "Rotation not supported: %#x\n",
2695 ctrl->id);
2696 rc = -ENOTSUPP;
2697 break;
2698 }
2699 deinterlace =
2700 TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_DEINTERLACE);
2701 if (ctrl->val && deinterlace && deinterlace->val !=
2702 V4L2_CID_MPEG_VIDC_VIDEO_DEINTERLACE_DISABLED) {
2703 dprintk(VIDC_ERR,
2704 "Rotation not supported with deinterlacing\n");
2705 rc = -EINVAL;
2706 break;
2707 }
2708 property_id = HAL_CONFIG_VPE_OPERATIONS;
2709 operations.rotate = venc_v4l2_to_hal(
2710 V4L2_CID_MPEG_VIDC_VIDEO_ROTATION,
2711 ctrl->val);
2712 operations.flip = HAL_FLIP_NONE;
2713 pdata = &operations;
2714 break;
2715 }
2716 case V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP: {
2717 struct v4l2_ctrl *qpp, *qpb;
2718
2719 rc = msm_venc_validate_qp_value(inst, ctrl);
2720 if (rc)
2721 break;
2722 qpp = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP);
2723 qpb = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP);
2724
2725 property_id = HAL_PARAM_VENC_SESSION_QP;
2726 quantization.qpi = ctrl->val;
2727 quantization.qpp = qpp->val;
2728 quantization.qpb = qpb->val;
2729 quantization.layer_id = 0;
2730
2731 pdata = &quantization;
2732 break;
2733 }
2734 case V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP: {
2735 struct v4l2_ctrl *qpi, *qpb;
2736
2737 rc = msm_venc_validate_qp_value(inst, ctrl);
2738 if (rc)
2739 break;
2740 qpi = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP);
2741 qpb = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP);
2742
2743 property_id = HAL_PARAM_VENC_SESSION_QP;
2744 quantization.qpp = ctrl->val;
2745 quantization.qpi = qpi->val;
2746 quantization.qpb = qpb->val;
2747 quantization.layer_id = 0;
2748
2749 pdata = &quantization;
2750 break;
2751 }
2752 case V4L2_CID_MPEG_VIDEO_H264_B_FRAME_QP: {
2753 struct v4l2_ctrl *qpi, *qpp;
2754
2755 rc = msm_venc_validate_qp_value(inst, ctrl);
2756 if (rc)
2757 break;
2758 qpi = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_H264_I_FRAME_QP);
2759 qpp = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_H264_P_FRAME_QP);
2760
2761 property_id = HAL_PARAM_VENC_SESSION_QP;
2762 quantization.qpb = ctrl->val;
2763 quantization.qpi = qpi->val;
2764 quantization.qpp = qpp->val;
2765 quantization.layer_id = 0;
2766
2767 pdata = &quantization;
2768 break;
2769 }
2770 case V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP: {
2771 struct v4l2_ctrl *qpp, *qpb;
2772
2773 qpp = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP);
2774 qpb = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP);
2775
2776 property_id = HAL_PARAM_VENC_SESSION_QP;
2777 quantization.qpi = ctrl->val;
2778 quantization.qpp = qpp->val;
2779 quantization.qpb = qpb->val;
2780 quantization.layer_id = 0;
2781
2782 pdata = &quantization;
2783 break;
2784 }
2785 case V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP: {
2786 struct v4l2_ctrl *qpi, *qpb;
2787
2788 qpi = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP);
2789 qpb = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP);
2790
2791 property_id = HAL_PARAM_VENC_SESSION_QP;
2792 quantization.qpp = ctrl->val;
2793 quantization.qpi = qpi->val;
2794 quantization.qpb = qpb->val;
2795 quantization.layer_id = 0;
2796
2797 pdata = &quantization;
2798 break;
2799 }
2800 case V4L2_CID_MPEG_VIDEO_H263_B_FRAME_QP: {
2801 struct v4l2_ctrl *qpi, *qpp;
2802
2803 qpi = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_H263_I_FRAME_QP);
2804 qpp = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_H263_P_FRAME_QP);
2805
2806 property_id = HAL_PARAM_VENC_SESSION_QP;
2807 quantization.qpb = ctrl->val;
2808 quantization.qpi = qpi->val;
2809 quantization.qpp = qpp->val;
2810 quantization.layer_id = 0;
2811
2812 pdata = &quantization;
2813 break;
2814 }
2815 case V4L2_CID_MPEG_VIDEO_VPX_I_FRAME_QP: {
2816 struct v4l2_ctrl *qpp;
2817
2818 qpp = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_VPX_P_FRAME_QP);
2819
2820 property_id = HAL_PARAM_VENC_SESSION_QP;
2821 quantization.qpi = ctrl->val;
2822 quantization.qpp = qpp->val;
2823 /* Bframes are not supported for VPX */
2824 quantization.qpb = 0;
2825 quantization.layer_id = 0;
2826
2827 pdata = &quantization;
2828 break;
2829 }
2830 case V4L2_CID_MPEG_VIDEO_VPX_P_FRAME_QP: {
2831 struct v4l2_ctrl *qpi;
2832
2833 qpi = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_VPX_I_FRAME_QP);
2834
2835 property_id = HAL_PARAM_VENC_SESSION_QP;
2836 quantization.qpp = ctrl->val;
2837 quantization.qpi = qpi->val;
2838 /* Bframes are not supported for VPX */
2839 quantization.qpb = 0;
2840 quantization.layer_id = 0;
2841
2842 pdata = &quantization;
2843 break;
2844 }
2845 case V4L2_CID_MPEG_VIDEO_H264_MIN_QP: {
2846 struct v4l2_ctrl *qp_max;
2847
2848 qp_max = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_H264_MAX_QP);
2849 if (ctrl->val >= qp_max->val) {
2850 dprintk(VIDC_ERR,
2851 "Bad range: Min QP (%d) > Max QP(%d)\n",
2852 ctrl->val, qp_max->val);
2853 rc = -ERANGE;
2854 break;
2855 }
2856
2857 property_id = HAL_PARAM_VENC_SESSION_QP_RANGE;
2858 qp_range.layer_id = 0;
2859 qp_range.max_qp = qp_max->val;
2860 qp_range.min_qp = ctrl->val;
2861
2862 pdata = &qp_range;
2863 break;
2864 }
2865 case V4L2_CID_MPEG_VIDEO_H264_MAX_QP: {
2866 struct v4l2_ctrl *qp_min;
2867
2868 qp_min = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_H264_MIN_QP);
2869 if (ctrl->val <= qp_min->val) {
2870 dprintk(VIDC_ERR,
2871 "Bad range: Max QP (%d) < Min QP(%d)\n",
2872 ctrl->val, qp_min->val);
2873 rc = -ERANGE;
2874 break;
2875 }
2876
2877 property_id = HAL_PARAM_VENC_SESSION_QP_RANGE;
2878 qp_range.layer_id = 0;
2879 qp_range.max_qp = ctrl->val;
2880 qp_range.min_qp = qp_min->val;
2881
2882 pdata = &qp_range;
2883 break;
2884 }
2885 case V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP: {
2886 struct v4l2_ctrl *qp_max;
2887
2888 qp_max = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP);
2889 if (ctrl->val >= qp_max->val) {
2890 dprintk(VIDC_ERR,
2891 "Bad range: Min QP (%d) > Max QP(%d)\n",
2892 ctrl->val, qp_max->val);
2893 rc = -ERANGE;
2894 break;
2895 }
2896
2897 property_id = HAL_PARAM_VENC_SESSION_QP_RANGE;
2898 qp_range.layer_id = 0;
2899 qp_range.max_qp = qp_max->val;
2900 qp_range.min_qp = ctrl->val;
2901
2902 pdata = &qp_range;
2903 break;
2904 }
2905 case V4L2_CID_MPEG_VIDEO_MPEG4_MAX_QP: {
2906 struct v4l2_ctrl *qp_min;
2907
2908 qp_min = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_MPEG4_MIN_QP);
2909 if (ctrl->val <= qp_min->val) {
2910 dprintk(VIDC_ERR,
2911 "Bad range: Max QP (%d) < Min QP(%d)\n",
2912 ctrl->val, qp_min->val);
2913 rc = -ERANGE;
2914 break;
2915 }
2916
2917 property_id = HAL_PARAM_VENC_SESSION_QP_RANGE;
2918 qp_range.layer_id = 0;
2919 qp_range.max_qp = ctrl->val;
2920 qp_range.min_qp = qp_min->val;
2921
2922 pdata = &qp_range;
2923 break;
2924 }
2925 case V4L2_CID_MPEG_VIDEO_VPX_MIN_QP: {
2926 struct v4l2_ctrl *qp_max;
2927
2928 qp_max = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_VPX_MAX_QP);
2929 if (ctrl->val >= qp_max->val) {
2930 dprintk(VIDC_ERR,
2931 "Bad range: Min QP (%d) > Max QP(%d)\n",
2932 ctrl->val, qp_max->val);
2933 rc = -ERANGE;
2934 break;
2935 }
2936 property_id = HAL_PARAM_VENC_SESSION_QP_RANGE;
2937 qp_range.layer_id = 0;
2938 qp_range.max_qp = qp_max->val;
2939 qp_range.min_qp = ctrl->val;
2940 pdata = &qp_range;
2941 break;
2942 }
2943 case V4L2_CID_MPEG_VIDEO_VPX_MAX_QP: {
2944 struct v4l2_ctrl *qp_min;
2945
2946 qp_min = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_VPX_MIN_QP);
2947 if (ctrl->val <= qp_min->val) {
2948 dprintk(VIDC_ERR,
2949 "Bad range: Max QP (%d) < Min QP(%d)\n",
2950 ctrl->val, qp_min->val);
2951 rc = -ERANGE;
2952 break;
2953 }
2954 property_id = HAL_PARAM_VENC_SESSION_QP_RANGE;
2955 qp_range.layer_id = 0;
2956 qp_range.max_qp = ctrl->val;
2957 qp_range.min_qp = qp_min->val;
2958 pdata = &qp_range;
2959 break;
2960 }
2961 case V4L2_CID_MPEG_VIDC_VIDEO_VP8_MIN_QP: {
2962 struct v4l2_ctrl *qp_max;
2963
2964 qp_max = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_VP8_MAX_QP);
2965 property_id = HAL_PARAM_VENC_SESSION_QP_RANGE;
2966 qp_range.layer_id = 0;
2967 qp_range.max_qp = qp_max->val;
2968 qp_range.min_qp = ctrl->val;
2969 pdata = &qp_range;
2970 break;
2971 }
2972 case V4L2_CID_MPEG_VIDC_VIDEO_VP8_MAX_QP: {
2973 struct v4l2_ctrl *qp_min;
2974
2975 qp_min = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_VP8_MIN_QP);
2976 property_id = HAL_PARAM_VENC_SESSION_QP_RANGE;
2977 qp_range.layer_id = 0;
2978 qp_range.max_qp = ctrl->val;
2979 qp_range.min_qp = qp_min->val;
2980 pdata = &qp_range;
2981 break;
2982 }
2983 case V4L2_CID_MPEG_VIDEO_MIN_QP_PACKED: {
2984 struct v4l2_ctrl *qp_max;
2985
2986 qp_max = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_MAX_QP_PACKED);
2987 if (ctrl->val >= qp_max->val) {
2988 dprintk(VIDC_ERR,
2989 "Bad range: Min QP PACKED (0x%x) > Max QP PACKED (0x%x)\n",
2990 ctrl->val, qp_max->val);
2991 rc = -ERANGE;
2992 break;
2993 }
2994
2995 property_id = HAL_PARAM_VENC_SESSION_QP_RANGE_PACKED;
2996 qp_range.layer_id = 0;
2997 qp_range.max_qp = qp_max->val;
2998 qp_range.min_qp = ctrl->val;
2999
3000 pdata = &qp_range;
3001 break;
3002 }
3003 case V4L2_CID_MPEG_VIDEO_MAX_QP_PACKED: {
3004 struct v4l2_ctrl *qp_min;
3005
3006 qp_min = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_MIN_QP_PACKED);
3007 if (ctrl->val <= qp_min->val) {
3008 dprintk(VIDC_ERR,
3009 "Bad range: Max QP PACKED (%d) < Min QP PACKED (%d)\n",
3010 ctrl->val, qp_min->val);
3011 rc = -ERANGE;
3012 break;
3013 }
3014
3015 property_id = HAL_PARAM_VENC_SESSION_QP_RANGE_PACKED;
3016 qp_range.layer_id = 0;
3017 qp_range.max_qp = ctrl->val;
3018 qp_range.min_qp = qp_min->val;
3019
3020 pdata = &qp_range;
3021 break;
3022 }
3023 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE: {
3024 int temp = 0;
3025
3026 switch (ctrl->val) {
3027 case V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_MB:
3028 temp = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB;
3029 break;
3030 case V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_BYTES:
3031 temp = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES;
3032 break;
3033 case V4L2_MPEG_VIDEO_MULTI_SLICE_GOB:
3034 temp = V4L2_CID_MPEG_VIDEO_MULTI_SLICE_GOB;
3035 break;
3036 case V4L2_MPEG_VIDEO_MULTI_SLICE_MODE_SINGLE:
3037 default:
3038 temp = 0;
3039 break;
3040 }
3041
3042 if (temp)
3043 temp_ctrl = TRY_GET_CTRL(temp);
3044
3045 property_id = HAL_PARAM_VENC_MULTI_SLICE_CONTROL;
3046 multi_slice_control.multi_slice = ctrl->val;
3047 multi_slice_control.slice_size = temp ? temp_ctrl->val : 0;
3048
3049 pdata = &multi_slice_control;
3050 break;
3051 }
3052 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_BYTES:
3053 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MAX_MB:
3054 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_GOB:
3055 temp_ctrl = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE);
3056
3057 property_id = HAL_PARAM_VENC_MULTI_SLICE_CONTROL;
3058 multi_slice_control.multi_slice = temp_ctrl->val;
3059 multi_slice_control.slice_size = ctrl->val;
3060 pdata = &multi_slice_control;
3061 break;
3062 case V4L2_CID_MPEG_VIDEO_MULTI_SLICE_DELIVERY_MODE: {
3063 bool codec_avc =
3064 inst->fmts[CAPTURE_PORT].fourcc == V4L2_PIX_FMT_H264 ||
3065 inst->fmts[CAPTURE_PORT].fourcc ==
3066 V4L2_PIX_FMT_H264_NO_SC;
3067
3068 temp_ctrl = TRY_GET_CTRL(V4L2_CID_MPEG_VIDEO_MULTI_SLICE_MODE);
3069 if (codec_avc && temp_ctrl->val ==
3070 V4L2_MPEG_VIDEO_MULTI_SICE_MODE_MAX_MB) {
3071 property_id = HAL_PARAM_VENC_SLICE_DELIVERY_MODE;
3072 enable.enable = true;
3073 } else {
3074 dprintk(VIDC_WARN,
3075 "Failed : slice delivery mode is not supported\n");
3076 enable.enable = false;
3077 }
3078 pdata = &enable;
3079 break;
3080 }
3081 case V4L2_CID_MPEG_VIDC_VIDEO_INTRA_REFRESH_MODE: {
3082 struct v4l2_ctrl *air_mbs, *air_ref, *cir_mbs;
3083 bool is_cont_intra_supported = false;
3084
3085 air_mbs = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_AIR_MBS);
3086 air_ref = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_AIR_REF);
3087 cir_mbs = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_CIR_MBS);
3088
3089 is_cont_intra_supported =
3090 (inst->fmts[CAPTURE_PORT].fourcc == V4L2_PIX_FMT_H264) ||
3091 (inst->fmts[CAPTURE_PORT].fourcc == V4L2_PIX_FMT_HEVC);
3092
3093 if (is_cont_intra_supported) {
3094 if (ctrl->val != HAL_INTRA_REFRESH_NONE)
3095 enable.enable = true;
3096 else
3097 enable.enable = false;
3098
3099 rc = call_hfi_op(hdev, session_set_property,
3100 (void *)inst->session,
3101 HAL_PARAM_VENC_CONSTRAINED_INTRA_PRED, &enable);
3102 if (rc) {
3103 dprintk(VIDC_ERR,
3104 "Failed to set constrained intra\n");
3105 rc = -EINVAL;
3106 break;
3107 }
3108 }
3109
3110 property_id = HAL_PARAM_VENC_INTRA_REFRESH;
3111
3112 intra_refresh.mode = ctrl->val;
3113 intra_refresh.air_mbs = air_mbs->val;
3114 intra_refresh.air_ref = air_ref->val;
3115 intra_refresh.cir_mbs = cir_mbs->val;
3116
3117 pdata = &intra_refresh;
3118 break;
3119 }
3120 case V4L2_CID_MPEG_VIDC_VIDEO_AIR_MBS: {
3121 struct v4l2_ctrl *ir_mode, *air_ref, *cir_mbs;
3122
3123 ir_mode = TRY_GET_CTRL(
3124 V4L2_CID_MPEG_VIDC_VIDEO_INTRA_REFRESH_MODE);
3125 air_ref = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_AIR_REF);
3126 cir_mbs = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_CIR_MBS);
3127
3128 property_id = HAL_PARAM_VENC_INTRA_REFRESH;
3129
3130 intra_refresh.air_mbs = ctrl->val;
3131 intra_refresh.mode = ir_mode->val;
3132 intra_refresh.air_ref = air_ref->val;
3133 intra_refresh.cir_mbs = cir_mbs->val;
3134
3135 pdata = &intra_refresh;
3136 break;
3137 }
3138 case V4L2_CID_MPEG_VIDC_VIDEO_AIR_REF: {
3139 struct v4l2_ctrl *ir_mode, *air_mbs, *cir_mbs;
3140
3141 ir_mode = TRY_GET_CTRL(
3142 V4L2_CID_MPEG_VIDC_VIDEO_INTRA_REFRESH_MODE);
3143 air_mbs = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_AIR_MBS);
3144 cir_mbs = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_CIR_MBS);
3145
3146 property_id = HAL_PARAM_VENC_INTRA_REFRESH;
3147
3148 intra_refresh.air_ref = ctrl->val;
3149 intra_refresh.air_mbs = air_mbs->val;
3150 intra_refresh.mode = ir_mode->val;
3151 intra_refresh.cir_mbs = cir_mbs->val;
3152
3153 pdata = &intra_refresh;
3154 break;
3155 }
3156 case V4L2_CID_MPEG_VIDC_VIDEO_CIR_MBS: {
3157 struct v4l2_ctrl *ir_mode, *air_mbs, *air_ref;
3158
3159 ir_mode = TRY_GET_CTRL(
3160 V4L2_CID_MPEG_VIDC_VIDEO_INTRA_REFRESH_MODE);
3161 air_mbs = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_AIR_MBS);
3162 air_ref = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_AIR_REF);
3163
3164 property_id = HAL_PARAM_VENC_INTRA_REFRESH;
3165
3166 intra_refresh.cir_mbs = ctrl->val;
3167 intra_refresh.air_mbs = air_mbs->val;
3168 intra_refresh.air_ref = air_ref->val;
3169 intra_refresh.mode = ir_mode->val;
3170
3171 pdata = &intra_refresh;
3172 break;
3173 }
3174 case V4L2_CID_MPEG_VIDEO_CYCLIC_INTRA_REFRESH_MB: {
3175 struct v4l2_ctrl *air_mbs, *air_ref;
3176
3177 air_mbs = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_AIR_MBS);
3178 air_ref = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_AIR_REF);
3179
3180 property_id = HAL_PARAM_VENC_INTRA_REFRESH;
3181
3182 intra_refresh.cir_mbs = ctrl->val;
3183 intra_refresh.air_mbs = air_mbs->val;
3184 intra_refresh.air_ref = air_ref->val;
3185 intra_refresh.mode = HAL_INTRA_REFRESH_CYCLIC;
3186
3187 pdata = &intra_refresh;
3188 break;
3189 }
3190 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE:
3191 {
3192 struct v4l2_ctrl *alpha, *beta;
3193
3194 alpha = TRY_GET_CTRL(
3195 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA);
3196 beta = TRY_GET_CTRL(
3197 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA);
3198
3199 property_id = HAL_PARAM_VENC_H264_DEBLOCK_CONTROL;
3200 h264_db_control.slice_alpha_offset = alpha->val;
3201 h264_db_control.slice_beta_offset = beta->val;
3202 h264_db_control.mode = venc_v4l2_to_hal(
3203 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE,
3204 ctrl->val);
3205 pdata = &h264_db_control;
3206 break;
3207 }
3208 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA:
3209 {
3210 struct v4l2_ctrl *mode, *beta;
3211
3212 mode = TRY_GET_CTRL(
3213 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE);
3214 beta = TRY_GET_CTRL(
3215 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA);
3216
3217 property_id = HAL_PARAM_VENC_H264_DEBLOCK_CONTROL;
3218 h264_db_control.slice_alpha_offset = ctrl->val;
3219 h264_db_control.slice_beta_offset = beta->val;
3220 h264_db_control.mode = venc_v4l2_to_hal(
3221 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE,
3222 mode->val);
3223 pdata = &h264_db_control;
3224 break;
3225 }
3226 case V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_BETA:
3227 {
3228 struct v4l2_ctrl *mode, *alpha;
3229
3230 mode = TRY_GET_CTRL(
3231 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE);
3232 alpha = TRY_GET_CTRL(
3233 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_ALPHA);
3234 property_id = HAL_PARAM_VENC_H264_DEBLOCK_CONTROL;
3235 h264_db_control.slice_alpha_offset = alpha->val;
3236 h264_db_control.slice_beta_offset = ctrl->val;
3237 h264_db_control.mode = venc_v4l2_to_hal(
3238 V4L2_CID_MPEG_VIDEO_H264_LOOP_FILTER_MODE,
3239 mode->val);
3240 pdata = &h264_db_control;
3241 break;
3242 }
3243 case V4L2_CID_MPEG_VIDEO_HEADER_MODE:
3244 property_id = HAL_PARAM_VENC_SYNC_FRAME_SEQUENCE_HEADER;
3245
3246 switch (ctrl->val) {
3247 case V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE:
3248 enable.enable = 0;
3249 break;
3250 case V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_I_FRAME:
3251 enable.enable = 1;
3252 break;
3253 case V4L2_MPEG_VIDEO_HEADER_MODE_JOINED_WITH_1ST_FRAME:
3254 default:
3255 rc = -ENOTSUPP;
3256 break;
3257 }
3258 pdata = &enable;
3259 break;
3260 case V4L2_CID_MPEG_VIDC_VIDEO_SECURE:
3261 inst->flags |= VIDC_SECURE;
3262 dprintk(VIDC_INFO, "Setting secure mode to: %d\n",
3263 !!(inst->flags & VIDC_SECURE));
3264 break;
3265 case V4L2_CID_MPEG_VIDC_VIDEO_EXTRADATA:
3266 property_id = HAL_PARAM_INDEX_EXTRADATA;
3267 extra.index = msm_comm_get_hal_extradata_index(ctrl->val);
3268 extra.enable = 1;
3269 pdata = &extra;
3270 break;
3271 case V4L2_CID_MPEG_VIDC_VIDEO_H264_VUI_TIMING_INFO:
3272 {
3273 struct v4l2_ctrl *rc_mode;
3274 bool cfr = false;
3275
3276 property_id = HAL_PARAM_VENC_H264_VUI_TIMING_INFO;
3277 rc_mode = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL);
3278
3279 switch (rc_mode->val) {
3280 case V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_VBR_CFR:
3281 case V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_CBR_CFR:
3282 cfr = true;
3283 break;
3284 default:
3285 cfr = false;
3286 break;
3287 }
3288
3289 switch (ctrl->val) {
3290 case V4L2_MPEG_VIDC_VIDEO_H264_VUI_TIMING_INFO_DISABLED:
3291 vui_timing_info.enable = 0;
3292 break;
3293 case V4L2_MPEG_VIDC_VIDEO_H264_VUI_TIMING_INFO_ENABLED:
3294 vui_timing_info.enable = 1;
3295 vui_timing_info.fixed_frame_rate = cfr;
3296 vui_timing_info.time_scale = NSEC_PER_SEC;
3297 }
3298
3299 pdata = &vui_timing_info;
3300 break;
3301 }
3302 case V4L2_CID_MPEG_VIDC_VIDEO_AU_DELIMITER:
3303 property_id = HAL_PARAM_VENC_GENERATE_AUDNAL;
3304
3305 switch (ctrl->val) {
3306 case V4L2_MPEG_VIDC_VIDEO_AU_DELIMITER_DISABLED:
3307 enable.enable = 0;
3308 break;
3309 case V4L2_MPEG_VIDC_VIDEO_AU_DELIMITER_ENABLED:
3310 enable.enable = 1;
3311 break;
3312 default:
3313 rc = -ENOTSUPP;
3314 break;
3315 }
3316
3317 pdata = &enable;
3318 break;
3319 case V4L2_CID_MPEG_VIDC_SET_PERF_LEVEL:
3320 switch (ctrl->val) {
3321 case V4L2_CID_MPEG_VIDC_PERF_LEVEL_NOMINAL:
3322 if (inst->flags & VIDC_TURBO) {
3323 inst->flags &= ~VIDC_TURBO;
3324 msm_dcvs_init_load(inst);
3325 }
3326 break;
3327 case V4L2_CID_MPEG_VIDC_PERF_LEVEL_TURBO:
3328 inst->flags |= VIDC_TURBO;
3329 break;
3330 default:
3331 dprintk(VIDC_ERR, "Perf mode %x not supported\n",
3332 ctrl->val);
3333 rc = -ENOTSUPP;
3334 break;
3335 }
3336 msm_comm_scale_clocks_and_bus(inst);
3337 break;
3338 case V4L2_CID_MPEG_VIDC_VIDEO_H264_VUI_BITSTREAM_RESTRICT:
3339 property_id = HAL_PARAM_VENC_H264_VUI_BITSTREAM_RESTRC;
3340 vui_bitstream_restrict.enable = ctrl->val;
3341 pdata = &vui_bitstream_restrict;
3342 break;
3343 case V4L2_CID_MPEG_VIDC_VIDEO_PRESERVE_TEXT_QUALITY:
3344 property_id = HAL_PARAM_VENC_PRESERVE_TEXT_QUALITY;
3345 preserve_text_quality.enable = ctrl->val;
3346 pdata = &preserve_text_quality;
3347 break;
3348 case V4L2_CID_MPEG_VIDC_VIDEO_MPEG4_TIME_RESOLUTION:
3349 property_id = HAL_PARAM_VENC_MPEG4_TIME_RESOLUTION;
3350 time_res.time_increment_resolution = ctrl->val;
3351 pdata = &time_res;
3352 break;
3353
3354 case V4L2_CID_MPEG_VIDC_VIDEO_DEINTERLACE:
3355 {
3356 struct v4l2_ctrl *rotation = NULL;
3357
3358 if (!(inst->capability.pixelprocess_capabilities &
3359 HAL_VIDEO_ENCODER_DEINTERLACE_CAPABILITY)) {
3360 dprintk(VIDC_ERR, "Deinterlace not supported: %#x\n",
3361 ctrl->id);
3362 rc = -ENOTSUPP;
3363 break;
3364 }
3365 rotation = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_ROTATION);
3366 if (ctrl->val && rotation && rotation->val !=
3367 V4L2_CID_MPEG_VIDC_VIDEO_ROTATION_NONE) {
3368 dprintk(VIDC_ERR,
3369 "Deinterlacing not supported with rotation");
3370 rc = -EINVAL;
3371 break;
3372 }
3373 property_id = HAL_CONFIG_VPE_DEINTERLACE;
3374 switch (ctrl->val) {
3375 case V4L2_CID_MPEG_VIDC_VIDEO_DEINTERLACE_ENABLED:
3376 enable.enable = 1;
3377 break;
3378 case V4L2_CID_MPEG_VIDC_VIDEO_DEINTERLACE_DISABLED:
3379 default:
3380 enable.enable = 0;
3381 break;
3382 }
3383 pdata = &enable;
3384 break;
3385 }
3386 case V4L2_CID_MPEG_VIDC_VIDEO_REQUEST_SEQ_HEADER:
3387 atomic_inc(&inst->seq_hdr_reqs);
3388 break;
3389 case V4L2_CID_MPEG_VIDC_VIDEO_USELTRFRAME:
3390 property_id = HAL_CONFIG_VENC_USELTRFRAME;
3391 use_ltr.ref_ltr = ctrl->val;
3392 use_ltr.use_constraint = false;
3393 use_ltr.frames = 0;
3394 pdata = &use_ltr;
3395 break;
3396 case V4L2_CID_MPEG_VIDC_VIDEO_MARKLTRFRAME:
3397 if (ctrl->val < inst->capability.ltr_count.min ||
3398 ctrl->val >= inst->capability.ltr_count.max) {
3399 dprintk(VIDC_ERR,
3400 "Error setting markltr %d range: [%d,%d)\n",
3401 ctrl->val, inst->capability.ltr_count.min,
3402 inst->capability.ltr_count.max);
3403 rc = -ENOTSUPP;
3404 break;
3405 }
3406 property_id = HAL_CONFIG_VENC_MARKLTRFRAME;
3407 mark_ltr.mark_frame = ctrl->val;
3408 pdata = &mark_ltr;
3409 break;
3410 case V4L2_CID_MPEG_VIDC_VIDEO_HIER_P_NUM_LAYERS:
3411 property_id = HAL_CONFIG_VENC_HIER_P_NUM_FRAMES;
3412 hier_p_layers = ctrl->val;
3413 if (hier_p_layers > inst->capability.hier_p.max) {
3414 dprintk(VIDC_ERR,
3415 "Error setting hier p num layers %d max supported is %d\n",
3416 hier_p_layers, inst->capability.hier_p.max);
3417 rc = -ENOTSUPP;
3418 break;
3419 }
3420 pdata = &hier_p_layers;
3421 break;
3422 case V4L2_CID_MPEG_VIDC_VIDEO_RATE_CONTROL_TIMESTAMP_MODE:
3423 property_id = HAL_PARAM_VENC_DISABLE_RC_TIMESTAMP;
3424 enable.enable = (ctrl->val ==
3425 V4L2_MPEG_VIDC_VIDEO_RATE_CONTROL_TIMESTAMP_MODE_IGNORE);
3426 pdata = &enable;
3427 break;
3428 case V4L2_CID_MPEG_VIDC_VIDEO_VPX_ERROR_RESILIENCE:
3429 property_id = HAL_PARAM_VENC_VPX_ERROR_RESILIENCE_MODE;
3430 enable.enable = ctrl->val;
3431 pdata = &enable;
3432 break;
3433 case V4L2_CID_MPEG_VIDC_VIDEO_H264_NAL_SVC:
3434 property_id = HAL_PARAM_VENC_H264_NAL_SVC_EXT;
3435 enable.enable = ctrl->val;
3436 pdata = &enable;
3437 break;
3438 case V4L2_CID_MPEG_VIDC_VIDEO_PERF_MODE:
3439 property_id = HAL_CONFIG_VENC_PERF_MODE;
3440
3441 switch (ctrl->val) {
3442 case V4L2_MPEG_VIDC_VIDEO_PERF_POWER_SAVE:
3443 inst->flags |= VIDC_LOW_POWER;
3444 venc_mode = HAL_PERF_MODE_POWER_SAVE;
3445 break;
3446 case V4L2_MPEG_VIDC_VIDEO_PERF_MAX_QUALITY:
3447 inst->flags &= ~VIDC_LOW_POWER;
3448 venc_mode = HAL_PERF_MODE_POWER_MAX_QUALITY;
3449 break;
3450 default:
3451 dprintk(VIDC_ERR, "Power save mode %x not supported\n",
3452 ctrl->val);
3453 rc = -ENOTSUPP;
3454 property_id = 0;
3455 break;
3456 }
3457 pdata = &venc_mode;
3458
3459 msm_dcvs_enc_set_power_save_mode(inst,
3460 ctrl->val == V4L2_MPEG_VIDC_VIDEO_PERF_POWER_SAVE);
3461 break;
3462 case V4L2_CID_MPEG_VIDC_VIDEO_HIER_B_NUM_LAYERS:
3463 if (inst->fmts[CAPTURE_PORT].fourcc != V4L2_PIX_FMT_HEVC) {
3464 dprintk(VIDC_ERR, "Hier B supported for HEVC only\n");
3465 rc = -ENOTSUPP;
3466 break;
3467 }
3468 property_id = HAL_PARAM_VENC_HIER_B_MAX_ENH_LAYERS;
3469 hier_b_layers = ctrl->val;
3470 pdata = &hier_b_layers;
3471 break;
3472 case V4L2_CID_MPEG_VIDC_VIDEO_HYBRID_HIERP_MODE:
3473 property_id = HAL_PARAM_VENC_HIER_P_HYBRID_MODE;
3474 hyb_hierp.layers = ctrl->val;
3475 pdata = &hyb_hierp;
3476 break;
3477 case V4L2_CID_MPEG_VIDC_VIDEO_MBI_STATISTICS_MODE:
3478 property_id = HAL_PARAM_VENC_MBI_STATISTICS_MODE;
3479 mbi_statistics_mode = venc_v4l2_to_hal(
3480 V4L2_CID_MPEG_VIDC_VIDEO_MBI_STATISTICS_MODE,
3481 ctrl->val);
3482 pdata = &mbi_statistics_mode;
3483 break;
3484 case V4L2_CID_VIDC_QBUF_MODE:
3485 property_id = HAL_PARAM_SYNC_BASED_INTERRUPT;
3486 enable.enable = ctrl->val == V4L2_VIDC_QBUF_BATCHED;
3487 pdata = &enable;
3488 break;
3489 case V4L2_CID_MPEG_VIDC_VIDEO_MAX_HIERP_LAYERS:
3490 property_id = HAL_PARAM_VENC_HIER_P_MAX_ENH_LAYERS;
3491 max_hierp_layers = ctrl->val;
3492 if (max_hierp_layers > inst->capability.hier_p.max) {
3493 dprintk(VIDC_ERR,
3494 "Error max HP layers(%d)>max supported(%d)\n",
3495 max_hierp_layers, inst->capability.hier_p.max);
3496 rc = -ENOTSUPP;
3497 break;
3498 }
3499 pdata = &max_hierp_layers;
3500 break;
3501 case V4L2_CID_MPEG_VIDC_VIDEO_BASELAYER_ID:
3502 property_id = HAL_CONFIG_VENC_BASELAYER_PRIORITYID;
3503 baselayerid = ctrl->val;
3504 pdata = &baselayerid;
3505 break;
3506 case V4L2_CID_MPEG_VIDC_VIDEO_CONFIG_QP:
3507 /* Sanity check for the QP boundaries as we are using
3508 * same control to set dynamic QP for all the codecs
3509 */
3510 rc = msm_venc_validate_qp_value(inst, ctrl);
3511 if (rc) {
3512 dprintk(VIDC_ERR, "Invalid QP Config QP Range\n");
3513 break;
3514 }
3515 property_id = HAL_CONFIG_VENC_FRAME_QP;
3516 frameqp = ctrl->val;
3517 pdata = &frameqp;
3518 break;
3519 case V4L2_CID_MPEG_VIDC_VIDEO_INITIAL_I_FRAME_QP:
3520 {
3521 rc = msm_venc_validate_qp_value(inst, ctrl);
3522 if (rc) {
3523 dprintk(VIDC_ERR, "Invalid Initial I QP\n");
3524 break;
3525 }
3526 /*
3527 * Defer sending property from here, set_ext_ctrl
3528 * will send it based on the rc value.
3529 */
3530 property_id = 0;
3531 break;
3532 }
3533 case V4L2_CID_MPEG_VIDC_VIDEO_INITIAL_B_FRAME_QP:
3534 {
3535 rc = msm_venc_validate_qp_value(inst, ctrl);
3536 if (rc) {
3537 dprintk(VIDC_ERR, "Invalid Initial B QP\n");
3538 break;
3539 }
3540 /*
3541 * Defer sending property from here, set_ext_ctrl
3542 * will send it based on the rc value.
3543 */
3544 property_id = 0;
3545 break;
3546 }
3547 case V4L2_CID_MPEG_VIDC_VIDEO_INITIAL_P_FRAME_QP:
3548 {
3549 rc = msm_venc_validate_qp_value(inst, ctrl);
3550 if (rc) {
3551 dprintk(VIDC_ERR, "Invalid Initial P QP\n");
3552 break;
3553 }
3554 /*
3555 * Defer sending property from here, set_ext_ctrl
3556 * will send it based on the rc value.
3557 */
3558 property_id = 0;
3559 break;
3560 }
3561 case V4L2_CID_MPEG_VIDC_VIDEO_VQZIP_SEI:
3562 property_id = HAL_PARAM_VENC_VQZIP_SEI;
3563 enable.enable = ctrl->val;
3564 pdata = &enable;
3565 break;
3566 case V4L2_CID_MPEG_VIDC_VIDEO_PRIORITY:
3567 property_id = HAL_CONFIG_REALTIME;
3568 /* firmware has inverted values for realtime and
3569 * non-realtime priority
3570 */
3571 enable.enable = !(ctrl->val);
3572 pdata = &enable;
3573 break;
3574 case V4L2_CID_MPEG_VIDC_VIDEO_OPERATING_RATE:
3575 break;
3576 case V4L2_CID_MPEG_VIDC_VIDEO_VENC_BITRATE_TYPE:
3577 {
3578 property_id = HAL_PARAM_VENC_BITRATE_TYPE;
3579 enable.enable = ctrl->val;
3580 pdata = &enable;
3581 break;
3582 }
3583 case V4L2_CID_MPEG_VIDC_VIDEO_H264_PIC_ORDER_CNT:
3584 {
3585 property_id = HAL_PARAM_VENC_H264_PIC_ORDER_CNT;
3586 pic_order_cnt = ctrl->val;
3587 pdata = &pic_order_cnt;
3588 break;
3589 }
3590 case V4L2_CID_MPEG_VIDC_VIDEO_COLOR_SPACE:
3591 {
3592 signal_info.color_space = ctrl->val;
3593 temp_ctrl = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_FULL_RANGE);
3594 signal_info.full_range = temp_ctrl ? temp_ctrl->val : 0;
3595 temp_ctrl =
3596 TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_TRANSFER_CHARS);
3597 signal_info.transfer_chars = temp_ctrl ? temp_ctrl->val : 0;
3598 temp_ctrl =
3599 TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_MATRIX_COEFFS);
3600 signal_info.matrix_coeffs = temp_ctrl ? temp_ctrl->val : 0;
3601 property_id = HAL_PARAM_VENC_VIDEO_SIGNAL_INFO;
3602 pdata = &signal_info;
3603 break;
3604 }
3605 case V4L2_CID_MPEG_VIDC_VIDEO_FULL_RANGE:
3606 {
3607 signal_info.full_range = ctrl->val;
3608 temp_ctrl = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_COLOR_SPACE);
3609 signal_info.color_space = temp_ctrl ? temp_ctrl->val : 0;
3610 temp_ctrl =
3611 TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_TRANSFER_CHARS);
3612 signal_info.transfer_chars = temp_ctrl ? temp_ctrl->val : 0;
3613 temp_ctrl =
3614 TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_MATRIX_COEFFS);
3615 signal_info.matrix_coeffs = temp_ctrl ? temp_ctrl->val : 0;
3616 property_id = HAL_PARAM_VENC_VIDEO_SIGNAL_INFO;
3617 pdata = &signal_info;
3618 break;
3619 }
3620 case V4L2_CID_MPEG_VIDC_VIDEO_TRANSFER_CHARS:
3621 {
3622 signal_info.transfer_chars = ctrl->val;
3623 temp_ctrl = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_FULL_RANGE);
3624 signal_info.full_range = temp_ctrl ? temp_ctrl->val : 0;
3625 temp_ctrl = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_COLOR_SPACE);
3626 signal_info.color_space = temp_ctrl ? temp_ctrl->val : 0;
3627 temp_ctrl =
3628 TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_MATRIX_COEFFS);
3629 signal_info.matrix_coeffs = temp_ctrl ? temp_ctrl->val : 0;
3630 property_id = HAL_PARAM_VENC_VIDEO_SIGNAL_INFO;
3631 pdata = &signal_info;
3632 break;
3633 }
3634 case V4L2_CID_MPEG_VIDC_VIDEO_MATRIX_COEFFS:
3635 {
3636 signal_info.matrix_coeffs = ctrl->val;
3637 temp_ctrl = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_FULL_RANGE);
3638 signal_info.full_range = temp_ctrl ? temp_ctrl->val : 0;
3639 temp_ctrl =
3640 TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_TRANSFER_CHARS);
3641 signal_info.transfer_chars = temp_ctrl ? temp_ctrl->val : 0;
3642 temp_ctrl = TRY_GET_CTRL(V4L2_CID_MPEG_VIDC_VIDEO_COLOR_SPACE);
3643 signal_info.color_space = temp_ctrl ? temp_ctrl->val : 0;
3644 property_id = HAL_PARAM_VENC_VIDEO_SIGNAL_INFO;
3645 pdata = &signal_info;
3646 break;
3647 }
3648 case V4L2_CID_MPEG_VIDC_VIDEO_VPE_CSC:
3649 if (ctrl->val == V4L2_CID_MPEG_VIDC_VIDEO_VPE_CSC_ENABLE) {
3650 rc = msm_venc_set_csc(inst);
3651 if (rc)
3652 dprintk(VIDC_ERR, "fail to set csc: %d\n", rc);
3653 }
3654 break;
3655 case V4L2_CID_MPEG_VIDC_VIDEO_LOWLATENCY_MODE:
3656 {
3657 property_id = HAL_PARAM_VENC_LOW_LATENCY;
3658 if (ctrl->val ==
3659 V4L2_CID_MPEG_VIDC_VIDEO_LOWLATENCY_ENABLE)
3660 enable.enable = 1;
3661 else
3662 enable.enable = 0;
3663 pdata = &enable;
3664 break;
3665 }
3666 case V4L2_CID_MPEG_VIDC_VIDEO_H264_TRANSFORM_8x8:
3667 property_id = HAL_PARAM_VENC_H264_TRANSFORM_8x8;
3668 switch (ctrl->val) {
3669 case V4L2_MPEG_VIDC_VIDEO_H264_TRANSFORM_8x8_ENABLE:
3670 enable.enable = 1;
3671 break;
3672 case V4L2_MPEG_VIDC_VIDEO_H264_TRANSFORM_8x8_DISABLE:
3673 enable.enable = 0;
3674 break;
3675 default:
3676 dprintk(VIDC_ERR,
3677 "Invalid H264 8x8 transform control value %d\n",
3678 ctrl->val);
3679 rc = -ENOTSUPP;
3680 break;
3681 }
3682 pdata = &enable;
3683 break;
3684 case V4L2_CID_MPEG_VIDC_VIDEO_IFRAME_SIZE_TYPE:
3685 property_id = HAL_PARAM_VENC_IFRAMESIZE_TYPE;
3686 iframesize_type = venc_v4l2_to_hal(
3687 V4L2_CID_MPEG_VIDC_VIDEO_IFRAME_SIZE_TYPE,
3688 ctrl->val);
3689 pdata = &iframesize_type;
3690 break;
3691 default:
3692 dprintk(VIDC_ERR, "Unsupported index: %x\n", ctrl->id);
3693 rc = -ENOTSUPP;
3694 break;
3695 }
3696
3697 v4l2_ctrl_lock(ctrl);
3698
3699 if (!rc && property_id) {
3700 dprintk(VIDC_DBG, "Control: HAL property=%x,ctrl_value=%d\n",
3701 property_id,
3702 ctrl->val);
3703 rc = call_hfi_op(hdev, session_set_property,
3704 (void *)inst->session, property_id, pdata);
3705 }
3706
3707 return rc;
3708}
3709#undef TRY_GET_CTRL
3710
3711static int try_set_ext_ctrl(struct msm_vidc_inst *inst,
3712 struct v4l2_ext_controls *ctrl)
3713{
3714 int rc = 0, i;
3715 struct v4l2_ext_control *control;
3716 struct hfi_device *hdev;
3717 struct hal_ltr_mode ltr_mode;
3718 struct hal_vc1e_perf_cfg_type search_range = { {0} };
3719 u32 property_id = 0;
3720 void *pdata = NULL;
3721 struct msm_vidc_capability *cap = NULL;
3722 struct hal_initial_quantization quant;
3723 struct hal_aspect_ratio sar;
3724 struct hal_bitrate bitrate;
3725 struct hal_frame_size blur_res;
3726 struct v4l2_control temp_ctrl;
3727
3728 if (!inst || !inst->core || !inst->core->device || !ctrl) {
3729 dprintk(VIDC_ERR, "%s invalid parameters\n", __func__);
3730 return -EINVAL;
3731 }
3732
3733 hdev = inst->core->device;
3734 cap = &inst->capability;
3735
3736 control = ctrl->controls;
3737 for (i = 0; i < ctrl->count; i++) {
3738 switch (control[i].id) {
3739 case V4L2_CID_MPEG_VIDC_VIDEO_LTRMODE:
3740 if (control[i].value !=
3741 V4L2_MPEG_VIDC_VIDEO_LTR_MODE_DISABLE) {
3742 rc = msm_venc_toggle_hier_p(inst, false);
3743 if (rc)
3744 break;
3745 }
3746 ltr_mode.mode = control[i].value;
3747 ltr_mode.trust_mode = 1;
3748 property_id = HAL_PARAM_VENC_LTRMODE;
3749 pdata = &ltr_mode;
3750 break;
3751 case V4L2_CID_MPEG_VIDC_VIDEO_LTRCOUNT:
3752 ltr_mode.count = control[i].value;
3753 if (ltr_mode.count > cap->ltr_count.max) {
3754 dprintk(VIDC_ERR,
3755 "Invalid LTR count %d. Supported max: %d\n",
3756 ltr_mode.count,
3757 cap->ltr_count.max);
3758 /*
3759 * FIXME: Return an error (-EINVALID)
3760 * here once VP8 supports LTR count
3761 * capability
3762 */
3763 ltr_mode.count = 1;
3764 }
3765 ltr_mode.trust_mode = 1;
3766 property_id = HAL_PARAM_VENC_LTRMODE;
3767 pdata = &ltr_mode;
3768 break;
3769 case V4L2_CID_MPEG_VIDC_VIDEO_ENABLE_INITIAL_QP:
3770 property_id = HAL_PARAM_VENC_ENABLE_INITIAL_QP;
3771 quant.init_qp_enable = control[i].value;
3772 pdata = &quant;
3773 break;
3774 case V4L2_CID_MPEG_VIDC_VIDEO_I_FRAME_QP:
3775 quant.qpi = control[i].value;
3776 property_id = HAL_PARAM_VENC_ENABLE_INITIAL_QP;
3777 pdata = &quant;
3778 break;
3779 case V4L2_CID_MPEG_VIDC_VIDEO_P_FRAME_QP:
3780 quant.qpp = control[i].value;
3781 property_id = HAL_PARAM_VENC_ENABLE_INITIAL_QP;
3782 pdata = &quant;
3783 break;
3784 case V4L2_CID_MPEG_VIDC_VIDEO_B_FRAME_QP:
3785 quant.qpb = control[i].value;
3786 property_id = HAL_PARAM_VENC_ENABLE_INITIAL_QP;
3787 pdata = &quant;
3788 break;
3789 case V4L2_CID_MPEG_VIDC_VIDEO_INITIAL_I_FRAME_QP:
3790 /* Sanity check for the QP boundaries as we are using
3791 * same control to set Initial QP for all the codecs
3792 */
3793 temp_ctrl.id =
3794 V4L2_CID_MPEG_VIDC_VIDEO_INITIAL_I_FRAME_QP;
3795 temp_ctrl.value = control[i].value;
3796
3797 rc = msm_comm_s_ctrl(inst, &temp_ctrl);
3798 if (rc) {
3799 dprintk(VIDC_ERR,
3800 "%s Failed setting Initial I Frame QP : %d\n",
3801 __func__, rc);
3802 break;
3803 }
3804 quant.qpi = control[i].value;
3805 property_id = HAL_PARAM_VENC_ENABLE_INITIAL_QP;
3806 pdata = &quant;
3807 break;
3808 case V4L2_CID_MPEG_VIDC_VIDEO_INITIAL_P_FRAME_QP:
3809 temp_ctrl.id =
3810 V4L2_CID_MPEG_VIDC_VIDEO_INITIAL_P_FRAME_QP;
3811 temp_ctrl.value = control[i].value;
3812 rc = msm_comm_s_ctrl(inst, &temp_ctrl);
3813 if (rc) {
3814 dprintk(VIDC_ERR,
3815 "%s Failed setting Initial P Frame QP : %d\n",
3816 __func__, rc);
3817 break;
3818 }
3819 quant.qpp = control[i].value;
3820 property_id = HAL_PARAM_VENC_ENABLE_INITIAL_QP;
3821 pdata = &quant;
3822 break;
3823 case V4L2_CID_MPEG_VIDC_VIDEO_INITIAL_B_FRAME_QP:
3824 temp_ctrl.id =
3825 V4L2_CID_MPEG_VIDC_VIDEO_INITIAL_B_FRAME_QP;
3826 temp_ctrl.value = control[i].value;
3827 rc = msm_comm_s_ctrl(inst, &temp_ctrl);
3828 if (rc) {
3829 dprintk(VIDC_ERR,
3830 "%s Failed setting Initial B Frame QP : %d\n",
3831 __func__, rc);
3832 break;
3833 }
3834 quant.qpb = control[i].value;
3835 property_id = HAL_PARAM_VENC_ENABLE_INITIAL_QP;
3836 pdata = &quant;
3837 break;
3838 case V4L2_CID_MPEG_VIDC_VIDEO_IFRAME_X_RANGE:
3839 search_range.i_frame.x_subsampled = control[i].value;
3840 property_id = HAL_PARAM_VENC_SEARCH_RANGE;
3841 pdata = &search_range;
3842 break;
3843 case V4L2_CID_MPEG_VIDC_VIDEO_IFRAME_Y_RANGE:
3844 search_range.i_frame.y_subsampled = control[i].value;
3845 property_id = HAL_PARAM_VENC_SEARCH_RANGE;
3846 pdata = &search_range;
3847 break;
3848 case V4L2_CID_MPEG_VIDC_VIDEO_PFRAME_X_RANGE:
3849 search_range.p_frame.x_subsampled = control[i].value;
3850 property_id = HAL_PARAM_VENC_SEARCH_RANGE;
3851 pdata = &search_range;
3852 break;
3853 case V4L2_CID_MPEG_VIDC_VIDEO_PFRAME_Y_RANGE:
3854 search_range.p_frame.y_subsampled = control[i].value;
3855 property_id = HAL_PARAM_VENC_SEARCH_RANGE;
3856 pdata = &search_range;
3857 break;
3858 case V4L2_CID_MPEG_VIDC_VIDEO_BFRAME_X_RANGE:
3859 search_range.b_frame.x_subsampled = control[i].value;
3860 property_id = HAL_PARAM_VENC_SEARCH_RANGE;
3861 pdata = &search_range;
3862 break;
3863 case V4L2_CID_MPEG_VIDC_VIDEO_BFRAME_Y_RANGE:
3864 search_range.b_frame.y_subsampled = control[i].value;
3865 property_id = HAL_PARAM_VENC_SEARCH_RANGE;
3866 pdata = &search_range;
3867 break;
3868 case V4L2_CID_MPEG_VIDC_VENC_PARAM_SAR_WIDTH:
3869 sar.aspect_width = control[i].value;
3870 property_id = HAL_PROPERTY_PARAM_VENC_ASPECT_RATIO;
3871 pdata = &sar;
3872 break;
3873 case V4L2_CID_MPEG_VIDC_VENC_PARAM_SAR_HEIGHT:
3874 sar.aspect_height = control[i].value;
3875 property_id = HAL_PROPERTY_PARAM_VENC_ASPECT_RATIO;
3876 pdata = &sar;
3877 break;
3878 case V4L2_CID_MPEG_VIDC_VENC_PARAM_LAYER_BITRATE:
3879 {
3880 if (control[i].value) {
3881 bitrate.layer_id = i;
3882 bitrate.bit_rate = control[i].value;
3883 property_id = HAL_CONFIG_VENC_TARGET_BITRATE;
3884 pdata = &bitrate;
3885 dprintk(VIDC_DBG, "bitrate for layer(%d)=%d\n",
3886 i, bitrate.bit_rate);
3887 rc = call_hfi_op(hdev, session_set_property,
3888 (void *)inst->session, property_id,
3889 pdata);
3890 if (rc) {
3891 dprintk(VIDC_DBG, "prop %x failed\n",
3892 property_id);
3893 return rc;
3894 }
3895 if (i == MAX_HYBRID_HIER_P_LAYERS - 1) {
3896 dprintk(VIDC_DBG, "HAL property=%x\n",
3897 property_id);
3898 property_id = 0;
3899 rc = 0;
3900 }
3901 }
3902 break;
3903 }
3904 case V4L2_CID_MPEG_VIDC_VIDEO_BLUR_WIDTH:
3905 property_id = HAL_CONFIG_VENC_BLUR_RESOLUTION;
3906 blur_res.width = control[i].value;
3907 blur_res.buffer_type = HAL_BUFFER_INPUT;
3908 property_id = HAL_CONFIG_VENC_BLUR_RESOLUTION;
3909 pdata = &blur_res;
3910 break;
3911 case V4L2_CID_MPEG_VIDC_VIDEO_BLUR_HEIGHT:
3912 blur_res.height = control[i].value;
3913 blur_res.buffer_type = HAL_BUFFER_INPUT;
3914 property_id = HAL_CONFIG_VENC_BLUR_RESOLUTION;
3915 pdata = &blur_res;
3916 break;
3917 default:
3918 dprintk(VIDC_ERR, "Invalid id set: %d\n",
3919 control[i].id);
3920 rc = -ENOTSUPP;
3921 break;
3922 }
3923 if (rc)
3924 break;
3925 }
3926
3927 if (!rc && property_id) {
3928 dprintk(VIDC_DBG, "Control: HAL property=%x\n", property_id);
3929 rc = call_hfi_op(hdev, session_set_property,
3930 (void *)inst->session, property_id, pdata);
3931 }
3932 return rc;
3933}
3934
3935static int msm_venc_op_s_ctrl(struct v4l2_ctrl *ctrl)
3936{
3937
3938 int rc = 0, c = 0;
3939
3940 struct msm_vidc_inst *inst = container_of(ctrl->handler,
3941 struct msm_vidc_inst, ctrl_handler);
3942
3943 if (!inst) {
3944 dprintk(VIDC_ERR, "%s invalid parameters\n", __func__);
3945 return -EINVAL;
3946 }
3947
3948 rc = msm_comm_try_state(inst, MSM_VIDC_OPEN_DONE);
3949
3950 if (rc) {
3951 dprintk(VIDC_ERR,
3952 "Failed to move inst: %pK to start done state\n", inst);
3953 goto failed_open_done;
3954 }
3955
3956 for (c = 0; c < ctrl->ncontrols; ++c) {
3957 if (ctrl->cluster[c]->is_new) {
3958 struct v4l2_ctrl *temp = ctrl->cluster[c];
3959
3960 rc = try_set_ctrl(inst, temp);
3961 if (rc) {
3962 dprintk(VIDC_ERR, "Failed setting %s (%x)\n",
3963 v4l2_ctrl_get_name(temp->id),
3964 temp->id);
3965 break;
3966 }
3967 }
3968 }
3969failed_open_done:
3970 if (rc)
3971 dprintk(VIDC_ERR, "Failed setting control: %x (%s)",
3972 ctrl->id, v4l2_ctrl_get_name(ctrl->id));
3973 return rc;
3974}
3975
3976static int msm_venc_op_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
3977{
3978 return 0;
3979}
3980
3981static const struct v4l2_ctrl_ops msm_venc_ctrl_ops = {
3982
3983 .s_ctrl = msm_venc_op_s_ctrl,
3984 .g_volatile_ctrl = msm_venc_op_g_volatile_ctrl,
3985};
3986
3987const struct v4l2_ctrl_ops *msm_venc_get_ctrl_ops(void)
3988{
3989 return &msm_venc_ctrl_ops;
3990}
3991
3992int msm_venc_inst_init(struct msm_vidc_inst *inst)
3993{
3994 int rc = 0;
3995
3996 if (!inst) {
3997 dprintk(VIDC_ERR, "Invalid input = %pK\n", inst);
3998 return -EINVAL;
3999 }
4000 inst->prop.height[CAPTURE_PORT] = DEFAULT_HEIGHT;
4001 inst->prop.width[CAPTURE_PORT] = DEFAULT_WIDTH;
4002 inst->prop.height[OUTPUT_PORT] = DEFAULT_HEIGHT;
4003 inst->prop.width[OUTPUT_PORT] = DEFAULT_WIDTH;
4004 inst->capability.height.min = MIN_SUPPORTED_HEIGHT;
4005 inst->capability.height.max = DEFAULT_HEIGHT;
4006 inst->capability.width.min = MIN_SUPPORTED_WIDTH;
4007 inst->capability.width.max = DEFAULT_WIDTH;
4008 inst->capability.alloc_mode_in = HAL_BUFFER_MODE_STATIC;
4009 inst->capability.alloc_mode_out = HAL_BUFFER_MODE_STATIC;
4010 inst->capability.secure_output2_threshold.min = 0;
4011 inst->capability.secure_output2_threshold.max = 0;
4012 inst->buffer_mode_set[OUTPUT_PORT] = HAL_BUFFER_MODE_STATIC;
4013 inst->buffer_mode_set[CAPTURE_PORT] = HAL_BUFFER_MODE_STATIC;
4014 inst->prop.fps = DEFAULT_FPS;
4015 inst->capability.pixelprocess_capabilities = 0;
4016 memcpy(&inst->fmts[CAPTURE_PORT], &venc_formats[4],
4017 sizeof(struct msm_vidc_format));
4018 memcpy(&inst->fmts[OUTPUT_PORT], &venc_formats[0],
4019 sizeof(struct msm_vidc_format));
4020 return rc;
4021}
4022
4023int msm_venc_s_ext_ctrl(struct msm_vidc_inst *inst,
4024 struct v4l2_ext_controls *ctrl)
4025{
4026 int rc = 0;
4027
4028 rc = try_set_ext_ctrl(inst, ctrl);
4029 if (rc) {
4030 dprintk(VIDC_ERR, "Error setting extended control\n");
4031 return rc;
4032 }
4033 return rc;
4034}
4035
4036int msm_venc_querycap(struct msm_vidc_inst *inst, struct v4l2_capability *cap)
4037{
4038 if (!inst || !cap) {
4039 dprintk(VIDC_ERR,
4040 "Invalid input, inst = %pK, cap = %pK\n", inst, cap);
4041 return -EINVAL;
4042 }
4043 strlcpy(cap->driver, MSM_VIDC_DRV_NAME, sizeof(cap->driver));
4044 strlcpy(cap->card, MSM_VENC_DVC_NAME, sizeof(cap->card));
4045 cap->bus_info[0] = 0;
4046 cap->version = MSM_VIDC_VERSION;
4047 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE_MPLANE |
4048 V4L2_CAP_VIDEO_OUTPUT_MPLANE |
4049 V4L2_CAP_STREAMING;
4050 memset(cap->reserved, 0, sizeof(cap->reserved));
4051 return 0;
4052}
4053
4054int msm_venc_enum_fmt(struct msm_vidc_inst *inst, struct v4l2_fmtdesc *f)
4055{
4056 const struct msm_vidc_format *fmt = NULL;
4057 int rc = 0;
4058
4059 if (!inst || !f) {
4060 dprintk(VIDC_ERR,
4061 "Invalid input, inst = %pK, f = %pK\n", inst, f);
4062 return -EINVAL;
4063 }
4064 if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
4065 fmt = msm_comm_get_pixel_fmt_index(venc_formats,
4066 ARRAY_SIZE(venc_formats), f->index, CAPTURE_PORT);
4067 } else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
4068 fmt = msm_comm_get_pixel_fmt_index(venc_formats,
4069 ARRAY_SIZE(venc_formats), f->index, OUTPUT_PORT);
4070 f->flags = V4L2_FMT_FLAG_COMPRESSED;
4071 }
4072
4073 memset(f->reserved, 0, sizeof(f->reserved));
4074 if (fmt) {
4075 strlcpy(f->description, fmt->description,
4076 sizeof(f->description));
4077 f->pixelformat = fmt->fourcc;
4078 } else {
4079 dprintk(VIDC_DBG, "No more formats found\n");
4080 rc = -EINVAL;
4081 }
4082 return rc;
4083}
4084
4085static int msm_venc_set_csc(struct msm_vidc_inst *inst)
4086{
4087 int rc = 0;
4088 int count = 0;
4089 struct hal_vpe_color_space_conversion vpe_csc;
4090
4091 while (count < HAL_MAX_MATRIX_COEFFS) {
4092 if (count < HAL_MAX_BIAS_COEFFS)
4093 vpe_csc.csc_bias[count] =
4094 vpe_csc_601_to_709_bias_coeff[count];
4095 if (count < HAL_MAX_LIMIT_COEFFS)
4096 vpe_csc.csc_limit[count] =
4097 vpe_csc_601_to_709_limit_coeff[count];
4098 vpe_csc.csc_matrix[count] =
4099 vpe_csc_601_to_709_matrix_coeff[count];
4100 count = count + 1;
4101 }
4102 rc = msm_comm_try_set_prop(inst,
4103 HAL_PARAM_VPE_COLOR_SPACE_CONVERSION, &vpe_csc);
4104 if (rc)
4105 dprintk(VIDC_ERR, "Setting VPE coefficients failed\n");
4106
4107 return rc;
4108}
4109
4110int msm_venc_s_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f)
4111{
4112 struct msm_vidc_format *fmt = NULL;
4113 int rc = 0;
4114 int i;
4115 struct hfi_device *hdev;
4116
4117 if (!inst || !f) {
4118 dprintk(VIDC_ERR,
4119 "Invalid input, inst = %pK, format = %pK\n", inst, f);
4120 return -EINVAL;
4121 }
4122
4123 if (!inst->core || !inst->core->device) {
4124 dprintk(VIDC_ERR, "%s invalid parameters\n", __func__);
4125 return -EINVAL;
4126 }
4127 hdev = inst->core->device;
4128
4129 if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
4130 fmt = msm_comm_get_pixel_fmt_fourcc(venc_formats,
4131 ARRAY_SIZE(venc_formats), f->fmt.pix_mp.pixelformat,
4132 CAPTURE_PORT);
4133 if (!fmt || fmt->type != CAPTURE_PORT) {
4134 dprintk(VIDC_ERR,
4135 "Format: %d not supported on CAPTURE port\n",
4136 f->fmt.pix_mp.pixelformat);
4137 rc = -EINVAL;
4138 goto exit;
4139 }
4140 memcpy(&inst->fmts[fmt->type], fmt,
4141 sizeof(struct msm_vidc_format));
4142
4143 msm_venc_update_plane_count(inst, CAPTURE_PORT);
4144 fmt->num_planes = inst->fmts[CAPTURE_PORT].num_planes;
4145
4146 rc = msm_comm_try_state(inst, MSM_VIDC_OPEN_DONE);
4147 if (rc) {
4148 dprintk(VIDC_ERR, "Failed to open instance\n");
4149 goto exit;
4150 }
4151
4152 inst->prop.width[CAPTURE_PORT] = f->fmt.pix_mp.width;
4153 inst->prop.height[CAPTURE_PORT] = f->fmt.pix_mp.height;
4154 rc = msm_vidc_check_session_supported(inst);
4155 if (rc) {
4156 dprintk(VIDC_ERR,
4157 "%s: session not supported\n", __func__);
4158 goto exit;
4159 }
4160 } else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
4161 struct hal_frame_size frame_sz;
4162
4163 inst->prop.width[OUTPUT_PORT] = f->fmt.pix_mp.width;
4164 inst->prop.height[OUTPUT_PORT] = f->fmt.pix_mp.height;
4165
4166 rc = msm_vidc_check_session_supported(inst);
4167 if (rc) {
4168 dprintk(VIDC_ERR,
4169 "%s: session not supported\n", __func__);
4170 goto exit;
4171 }
4172
4173 frame_sz.buffer_type = HAL_BUFFER_INPUT;
4174 frame_sz.width = inst->prop.width[OUTPUT_PORT];
4175 frame_sz.height = inst->prop.height[OUTPUT_PORT];
4176 dprintk(VIDC_DBG, "width = %d, height = %d\n",
4177 frame_sz.width, frame_sz.height);
4178 rc = call_hfi_op(hdev, session_set_property, (void *)
4179 inst->session, HAL_PARAM_FRAME_SIZE, &frame_sz);
4180 if (rc) {
4181 dprintk(VIDC_ERR,
4182 "Failed to set framesize for Output port\n");
4183 goto exit;
4184 }
4185
4186 fmt = msm_comm_get_pixel_fmt_fourcc(venc_formats,
4187 ARRAY_SIZE(venc_formats), f->fmt.pix_mp.pixelformat,
4188 OUTPUT_PORT);
4189 if (!fmt || fmt->type != OUTPUT_PORT) {
4190 dprintk(VIDC_ERR,
4191 "Format: %d not supported on OUTPUT port\n",
4192 f->fmt.pix_mp.pixelformat);
4193 rc = -EINVAL;
4194 goto exit;
4195 }
4196 memcpy(&inst->fmts[fmt->type], fmt,
4197 sizeof(struct msm_vidc_format));
4198
4199 msm_venc_update_plane_count(inst, OUTPUT_PORT);
4200 fmt->num_planes = inst->fmts[OUTPUT_PORT].num_planes;
4201
4202 msm_comm_set_color_format(inst, HAL_BUFFER_INPUT, fmt->fourcc);
4203 } else {
4204 dprintk(VIDC_ERR, "%s - Unsupported buf type: %d\n",
4205 __func__, f->type);
4206 rc = -EINVAL;
4207 goto exit;
4208 }
4209
4210 f->fmt.pix_mp.num_planes = fmt->num_planes;
4211
4212 if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
4213 struct hal_frame_size frame_sz = {0};
4214 struct hal_buffer_requirements *bufreq = NULL;
4215
4216 frame_sz.width = inst->prop.width[CAPTURE_PORT];
4217 frame_sz.height = inst->prop.height[CAPTURE_PORT];
4218 frame_sz.buffer_type = HAL_BUFFER_OUTPUT;
4219 rc = call_hfi_op(hdev, session_set_property, (void *)
4220 inst->session, HAL_PARAM_FRAME_SIZE,
4221 &frame_sz);
4222 if (rc) {
4223 dprintk(VIDC_ERR,
4224 "Failed to set OUTPUT framesize\n");
4225 goto exit;
4226 }
4227 rc = msm_comm_try_get_bufreqs(inst);
4228 if (rc) {
4229 dprintk(VIDC_WARN,
4230 "%s : Getting buffer reqs failed: %d\n",
4231 __func__, rc);
4232 goto exit;
4233 }
4234 bufreq = get_buff_req_buffer(inst, HAL_BUFFER_OUTPUT);
4235 f->fmt.pix_mp.plane_fmt[0].sizeimage =
4236 bufreq ? bufreq->buffer_size : 0;
4237 } else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
4238 struct hal_buffer_requirements *bufreq = NULL;
4239 int extra_idx = 0;
4240
4241 for (i = 0; i < inst->fmts[fmt->type].num_planes; ++i) {
4242 f->fmt.pix_mp.plane_fmt[i].sizeimage =
4243 inst->fmts[fmt->type].get_frame_size(i,
4244 f->fmt.pix_mp.height, f->fmt.pix_mp.width);
4245 }
4246 extra_idx = EXTRADATA_IDX(inst->fmts[fmt->type].num_planes);
4247 if (extra_idx && (extra_idx < VIDEO_MAX_PLANES)) {
4248 bufreq = get_buff_req_buffer(inst,
4249 HAL_BUFFER_EXTRADATA_INPUT);
4250 f->fmt.pix_mp.plane_fmt[extra_idx].sizeimage =
4251 bufreq ? bufreq->buffer_size : 0;
4252 }
4253 }
4254exit:
4255 return rc;
4256}
4257
4258int msm_venc_g_fmt(struct msm_vidc_inst *inst, struct v4l2_format *f)
4259{
4260 const struct msm_vidc_format *fmt = NULL;
4261 int rc = 0;
4262 int i;
4263 u32 height, width, num_planes;
4264 unsigned int extra_idx = 0;
4265 struct hal_buffer_requirements *bufreq = NULL;
4266
4267 if (!inst || !f) {
4268 dprintk(VIDC_ERR,
4269 "Invalid input, inst = %pK, format = %pK\n", inst, f);
4270 return -EINVAL;
4271 }
4272
4273 rc = msm_comm_try_get_bufreqs(inst);
4274 if (rc) {
4275 dprintk(VIDC_WARN, "Getting buffer requirements failed: %d\n",
4276 rc);
4277 return rc;
4278 }
4279
4280 if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
4281 fmt = &inst->fmts[CAPTURE_PORT];
4282 height = inst->prop.height[CAPTURE_PORT];
4283 width = inst->prop.width[CAPTURE_PORT];
4284 msm_venc_update_plane_count(inst, CAPTURE_PORT);
4285 num_planes = inst->fmts[CAPTURE_PORT].num_planes;
4286 } else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
4287 fmt = &inst->fmts[OUTPUT_PORT];
4288 height = inst->prop.height[OUTPUT_PORT];
4289 width = inst->prop.width[OUTPUT_PORT];
4290 msm_venc_update_plane_count(inst, OUTPUT_PORT);
4291 num_planes = inst->fmts[OUTPUT_PORT].num_planes;
4292 } else {
4293 dprintk(VIDC_ERR, "Invalid type: %x\n", f->type);
4294 return -ENOTSUPP;
4295 }
4296
4297 f->fmt.pix_mp.pixelformat = fmt->fourcc;
4298 f->fmt.pix_mp.height = height;
4299 f->fmt.pix_mp.width = width;
4300 f->fmt.pix_mp.num_planes = num_planes;
4301
4302 if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
4303 for (i = 0; i < num_planes; ++i) {
4304 f->fmt.pix_mp.plane_fmt[i].sizeimage =
4305 fmt->get_frame_size(i, height, width);
4306 }
4307 } else if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
4308 bufreq = get_buff_req_buffer(inst,
4309 HAL_BUFFER_OUTPUT);
4310
4311 f->fmt.pix_mp.plane_fmt[0].sizeimage =
4312 bufreq ? bufreq->buffer_size : 0;
4313 }
4314 extra_idx = EXTRADATA_IDX(num_planes);
4315 if (extra_idx && (extra_idx < VIDEO_MAX_PLANES)) {
4316 if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
4317 bufreq = get_buff_req_buffer(inst,
4318 HAL_BUFFER_EXTRADATA_OUTPUT);
4319 else if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE)
4320 bufreq = get_buff_req_buffer(inst,
4321 HAL_BUFFER_EXTRADATA_INPUT);
4322
4323 f->fmt.pix_mp.plane_fmt[extra_idx].sizeimage =
4324 bufreq ? bufreq->buffer_size : 0;
4325 }
4326
4327 for (i = 0; i < num_planes; ++i) {
4328 if (f->type == V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE) {
4329 inst->bufq[OUTPUT_PORT].plane_sizes[i] =
4330 f->fmt.pix_mp.plane_fmt[i].sizeimage;
4331 } else if (f->type == V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE) {
4332 inst->bufq[CAPTURE_PORT].plane_sizes[i] =
4333 f->fmt.pix_mp.plane_fmt[i].sizeimage;
4334 }
4335 }
4336 return rc;
4337}
4338
4339int msm_venc_reqbufs(struct msm_vidc_inst *inst, struct v4l2_requestbuffers *b)
4340{
4341 struct buf_queue *q = NULL;
4342 int rc = 0;
4343
4344 if (!inst || !b) {
4345 dprintk(VIDC_ERR,
4346 "Invalid input, inst = %pK, buffer = %pK\n", inst, b);
4347 return -EINVAL;
4348 }
4349 q = msm_comm_get_vb2q(inst, b->type);
4350 if (!q) {
4351 dprintk(VIDC_ERR,
4352 "Failed to find buffer queue for type = %d\n", b->type);
4353 return -EINVAL;
4354 }
4355
4356 mutex_lock(&q->lock);
4357 rc = vb2_reqbufs(&q->vb2_bufq, b);
4358 mutex_unlock(&q->lock);
4359 if (rc)
4360 dprintk(VIDC_DBG, "Failed to get reqbufs, %d\n", rc);
4361 return rc;
4362}
4363
4364int msm_venc_prepare_buf(struct msm_vidc_inst *inst,
4365 struct v4l2_buffer *b)
4366{
4367 int rc = 0;
4368 int i;
4369 struct vidc_buffer_addr_info buffer_info = {0};
4370 struct hfi_device *hdev;
4371 int extra_idx = 0;
4372
4373 if (!inst || !inst->core || !inst->core->device) {
4374 dprintk(VIDC_ERR, "%s invalid parameters\n", __func__);
4375 return -EINVAL;
4376 }
4377
4378 hdev = inst->core->device;
4379
4380 if (inst->state == MSM_VIDC_CORE_INVALID ||
4381 inst->core->state == VIDC_CORE_INVALID) {
4382 dprintk(VIDC_ERR,
4383 "Core %pK in bad state, ignoring prepare buf\n",
4384 inst->core);
4385 goto exit;
4386 }
4387
4388 switch (b->type) {
4389 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
4390 break;
4391 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
4392 if (b->length != inst->fmts[CAPTURE_PORT].num_planes) {
4393 dprintk(VIDC_ERR,
4394 "Planes mismatch: needed: %d, allocated: %d\n",
4395 inst->fmts[CAPTURE_PORT].num_planes,
4396 b->length);
4397 rc = -EINVAL;
4398 break;
4399 }
4400
4401 for (i = 0; i < min_t(int, b->length, VIDEO_MAX_PLANES); i++) {
4402 dprintk(VIDC_DBG, "device_addr = %#lx, size = %d\n",
4403 b->m.planes[i].m.userptr,
4404 b->m.planes[i].length);
4405 }
4406 buffer_info.buffer_size = b->m.planes[0].length;
4407 buffer_info.buffer_type = HAL_BUFFER_OUTPUT;
4408 buffer_info.num_buffers = 1;
4409 buffer_info.align_device_addr =
4410 b->m.planes[0].m.userptr;
4411
4412 extra_idx = EXTRADATA_IDX(b->length);
4413 if (extra_idx && (extra_idx < VIDEO_MAX_PLANES)) {
4414 buffer_info.extradata_addr =
4415 b->m.planes[extra_idx].m.userptr;
4416 dprintk(VIDC_DBG, "extradata: %#lx\n",
4417 b->m.planes[extra_idx].m.userptr);
4418 buffer_info.extradata_size =
4419 b->m.planes[extra_idx].length;
4420 }
4421
4422 rc = call_hfi_op(hdev, session_set_buffers,
4423 (void *)inst->session, &buffer_info);
4424 if (rc)
4425 dprintk(VIDC_ERR,
4426 "vidc_hal_session_set_buffers failed\n");
4427 break;
4428 default:
4429 dprintk(VIDC_ERR,
4430 "Buffer type not recognized: %d\n", b->type);
4431 break;
4432 }
4433exit:
4434 return rc;
4435}
4436
4437int msm_venc_release_buf(struct msm_vidc_inst *inst,
4438 struct v4l2_buffer *b)
4439{
4440 int i, rc = 0, extra_idx = 0;
4441 struct vidc_buffer_addr_info buffer_info = {0};
4442 struct hfi_device *hdev;
4443
4444 if (!inst || !inst->core || !inst->core->device) {
4445 dprintk(VIDC_ERR, "%s invalid parameters\n", __func__);
4446 return -EINVAL;
4447 }
4448
4449 hdev = inst->core->device;
4450
4451 rc = msm_comm_try_state(inst, MSM_VIDC_RELEASE_RESOURCES_DONE);
4452 if (rc) {
4453 dprintk(VIDC_ERR,
4454 "Failed to move inst: %pK to release res done state\n",
4455 inst);
4456 goto exit;
4457 }
4458 switch (b->type) {
4459 case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
4460 break;
4461 case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE: {
4462 if (b->length !=
4463 inst->fmts[CAPTURE_PORT].num_planes) {
4464 dprintk(VIDC_ERR,
4465 "Planes mismatch: needed: %d, to release: %d\n",
4466 inst->fmts[CAPTURE_PORT].num_planes,
4467 b->length);
4468 rc = -EINVAL;
4469 break;
4470 }
4471 for (i = 0; i < b->length; i++) {
4472 dprintk(VIDC_DBG,
4473 "Release device_addr = %#lx, size = %d, %d\n",
4474 b->m.planes[i].m.userptr,
4475 b->m.planes[i].length, inst->state);
4476 }
4477 buffer_info.buffer_size = b->m.planes[0].length;
4478 buffer_info.buffer_type = HAL_BUFFER_OUTPUT;
4479 buffer_info.num_buffers = 1;
4480 buffer_info.align_device_addr =
4481 b->m.planes[0].m.userptr;
4482 extra_idx = EXTRADATA_IDX(b->length);
4483 if (extra_idx && (extra_idx < VIDEO_MAX_PLANES))
4484 buffer_info.extradata_addr =
4485 b->m.planes[extra_idx].m.userptr;
4486 buffer_info.response_required = false;
4487 rc = call_hfi_op(hdev, session_release_buffers,
4488 (void *)inst->session, &buffer_info);
4489 if (rc)
4490 dprintk(VIDC_ERR,
4491 "vidc_hal_session_release_buffers failed\n");
4492 }
4493 break;
4494 default:
4495 dprintk(VIDC_ERR, "Buffer type not recognized: %d\n", b->type);
4496 break;
4497 }
4498exit:
4499 return rc;
4500}
4501
4502int msm_venc_qbuf(struct msm_vidc_inst *inst, struct v4l2_buffer *b)
4503{
4504 struct buf_queue *q = NULL;
4505 int rc = 0;
4506
4507 q = msm_comm_get_vb2q(inst, b->type);
4508 if (!q) {
4509 dprintk(VIDC_ERR,
4510 "Failed to find buffer queue for type = %d\n", b->type);
4511 return -EINVAL;
4512 }
4513 mutex_lock(&q->lock);
4514 rc = vb2_qbuf(&q->vb2_bufq, b);
4515 mutex_unlock(&q->lock);
4516 if (rc)
4517 dprintk(VIDC_ERR, "Failed to qbuf, %d\n", rc);
4518 return rc;
4519}
4520
4521int msm_venc_dqbuf(struct msm_vidc_inst *inst, struct v4l2_buffer *b)
4522{
4523 struct buf_queue *q = NULL;
4524 int rc = 0;
4525
4526 q = msm_comm_get_vb2q(inst, b->type);
4527 if (!q) {
4528 dprintk(VIDC_ERR,
4529 "Failed to find buffer queue for type = %d\n", b->type);
4530 return -EINVAL;
4531 }
4532 mutex_lock(&q->lock);
4533 rc = vb2_dqbuf(&q->vb2_bufq, b, true);
4534 mutex_unlock(&q->lock);
4535 if (rc)
4536 dprintk(VIDC_DBG, "Failed to dqbuf, %d\n", rc);
4537 return rc;
4538}
4539
4540int msm_venc_streamon(struct msm_vidc_inst *inst, enum v4l2_buf_type i)
4541{
4542 int rc = 0;
4543 struct buf_queue *q;
4544
4545 q = msm_comm_get_vb2q(inst, i);
4546 if (!q) {
4547 dprintk(VIDC_ERR,
4548 "Failed to find buffer queue for type = %d\n", i);
4549 return -EINVAL;
4550 }
4551 dprintk(VIDC_DBG, "Calling streamon\n");
4552 mutex_lock(&q->lock);
4553 rc = vb2_streamon(&q->vb2_bufq, i);
4554 mutex_unlock(&q->lock);
4555 if (rc)
4556 dprintk(VIDC_ERR, "streamon failed on port: %d\n", i);
4557 return rc;
4558}
4559
4560int msm_venc_streamoff(struct msm_vidc_inst *inst, enum v4l2_buf_type i)
4561{
4562 int rc = 0;
4563 struct buf_queue *q;
4564
4565 q = msm_comm_get_vb2q(inst, i);
4566 if (!q) {
4567 dprintk(VIDC_ERR,
4568 "Failed to find buffer queue for type = %d\n", i);
4569 return -EINVAL;
4570 }
4571 dprintk(VIDC_DBG, "Calling streamoff on port: %d\n", i);
4572 mutex_lock(&q->lock);
4573 rc = vb2_streamoff(&q->vb2_bufq, i);
4574 mutex_unlock(&q->lock);
4575 if (rc)
4576 dprintk(VIDC_ERR, "streamoff failed on port: %d\n", i);
4577 return rc;
4578}
4579
4580int msm_venc_ctrl_init(struct msm_vidc_inst *inst)
4581{
4582 return msm_comm_ctrl_init(inst, msm_venc_ctrls,
4583 ARRAY_SIZE(msm_venc_ctrls), &msm_venc_ctrl_ops);
4584}