1 /*--------------------------------------------------------------------------
2 Copyright (c) 2010-2019, The Linux Foundation. All rights reserved.
3
4 Redistribution and use in source and binary forms, with or without
5 modification, are permitted provided that the following conditions are met:
6 * Redistributions of source code must retain the above copyright
7 notice, this list of conditions and the following disclaimer.
8 * Redistributions in binary form must reproduce the above copyright
9 notice, this list of conditions and the following disclaimer in the
10 documentation and/or other materials provided with the distribution.
11 * Neither the name of The Linux Foundation nor
12 the names of its contributors may be used to endorse or promote
13 products derived from this software without specific prior written
14 permission.
15
16 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
19 NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
20 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
21 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
23 OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24 WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
25 OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
26 ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 --------------------------------------------------------------------------*/
28 #include "omx_video_encoder.h"
29 #include <string.h>
30 #include <stdio.h>
31 #include <fcntl.h>
32 #include <dlfcn.h>
33 #ifdef _ANDROID_ICS_
34 #include <media/hardware/HardwareAPI.h>
35 #endif
36 #ifdef _ANDROID_
37 #include <cutils/properties.h>
38 #endif
39 #ifdef _USE_GLIB_
40 #include <glib.h>
41 #define strlcpy g_strlcpy
42 #endif
43 #include "PlatformConfig.h"
44
45 /* defined in mp-ctl.h */
46 #define MPCTLV3_VIDEO_ENCODE_PB_HINT 0x41C00000
47
48 // factory function executed by the core to create instances
get_omx_component_factory_fn(void)49 void *get_omx_component_factory_fn(void)
50 {
51 return(new omx_venc);
52 }
53
perf_control()54 omx_venc::perf_control::perf_control()
55 {
56 m_perf_control_enable = 0;
57 m_perf_lib = NULL;
58 m_perf_lock_acquire = NULL;
59 m_perf_lock_release = NULL;
60 m_perf_handle = 0;
61 }
62
~perf_control()63 omx_venc::perf_control::~perf_control()
64 {
65 if (!m_perf_control_enable)
66 return;
67 if (m_perf_handle && m_perf_lock_release) {
68 m_perf_lock_release(m_perf_handle);
69 DEBUG_PRINT_HIGH("perflock released");
70 }
71 if (m_perf_lib) {
72 dlclose(m_perf_lib);
73 }
74 }
75
perf_lock_acquire()76 int omx_venc::perf_control::perf_lock_acquire()
77 {
78 int arg[2];
79 if (!m_perf_control_enable)
80 return 0;
81 if (!m_perf_lock_acquire) {
82 DEBUG_PRINT_ERROR("NULL perflock acquire");
83 return -1;
84 }
85 if (m_perf_handle) {
86 DEBUG_PRINT_LOW("perflock already acquired");
87 return 0;
88 }
89
90 DEBUG_PRINT_HIGH("perflock acquire");
91 arg[0] = MPCTLV3_VIDEO_ENCODE_PB_HINT;
92 arg[1] = 1;
93 m_perf_handle = m_perf_lock_acquire(0, 0, arg, sizeof(arg) / sizeof(int));
94 if (m_perf_handle < 0) {
95 DEBUG_PRINT_INFO("perflock acquire failed with error %d", m_perf_handle);
96 m_perf_handle = 0;
97 return -1;
98 }
99 return 0;
100 }
101
perf_lock_release()102 void omx_venc::perf_control::perf_lock_release()
103 {
104 if (!m_perf_control_enable)
105 return;
106 if (!m_perf_lib)
107 return;
108 if (!m_perf_lock_release) {
109 DEBUG_PRINT_ERROR("NULL perflock release");
110 return;
111 }
112 if (!m_perf_handle) {
113 DEBUG_PRINT_LOW("perflock already released");
114 return;
115 }
116 DEBUG_PRINT_HIGH("perflock release");
117 m_perf_lock_release(m_perf_handle);
118 m_perf_handle = 0;
119 }
120
load_perf_library()121 bool omx_venc::perf_control::load_perf_library()
122 {
123 char perf_lib_path[PROPERTY_VALUE_MAX] = {0};
124
125 if (!m_perf_control_enable) {
126 DEBUG_PRINT_HIGH("perf cotrol not enabled");
127 return false;
128 }
129
130 if (m_perf_lib) {
131 DEBUG_PRINT_HIGH("perf cotrol library already opened");
132 return true;
133 }
134
135 if ((property_get("ro.vendor.extension_library", perf_lib_path, NULL) <= 0)) {
136 DEBUG_PRINT_ERROR("vendor library not set in ro.vendor.extension_library");
137 goto handle_err;
138 }
139 if ((m_perf_lib = dlopen(perf_lib_path, RTLD_NOW)) == NULL) {
140 DEBUG_PRINT_ERROR("Failed to open %s : %s",perf_lib_path, dlerror());
141 goto handle_err;
142 } else {
143 m_perf_lock_acquire = (perf_lock_acquire_t)dlsym(m_perf_lib, "perf_lock_acq");
144 if (m_perf_lock_acquire == NULL) {
145 DEBUG_PRINT_ERROR("Failed to load symbol: perf_lock_acq");
146 goto handle_err;
147 }
148 m_perf_lock_release = (perf_lock_release_t)dlsym(m_perf_lib, "perf_lock_rel");
149 if (m_perf_lock_release == NULL) {
150 DEBUG_PRINT_ERROR("Failed to load symbol: perf_lock_rel");
151 goto handle_err;
152 }
153 }
154 return true;
155
156 handle_err:
157 if(m_perf_lib)
158 dlclose(m_perf_lib);
159 m_perf_lib = NULL;
160 m_perf_lock_acquire = NULL;
161 m_perf_lock_release = NULL;
162 return false;
163 }
164
165 //constructor
166
omx_venc()167 omx_venc::omx_venc()
168 {
169 #ifdef _ANDROID_ICS_
170 meta_mode_enable = false;
171 memset(meta_buffer_hdr,0,sizeof(meta_buffer_hdr));
172 memset(meta_buffers,0,sizeof(meta_buffers));
173 memset(opaque_buffer_hdr,0,sizeof(opaque_buffer_hdr));
174 mUseProxyColorFormat = false;
175 get_syntaxhdr_enable = false;
176 #endif
177 char property_value[PROPERTY_VALUE_MAX] = {0};
178 property_get("vendor.vidc.debug.level", property_value, "1");
179 debug_level = strtoul(property_value, NULL, 16);
180 property_value[0] = '\0';
181 handle = NULL;
182 Platform::Config::getInt32(Platform::vidc_perf_control_enable,
183 (int32_t *)&m_perf_control.m_perf_control_enable, 0);
184 if (m_perf_control.m_perf_control_enable) {
185 DEBUG_PRINT_HIGH("perf cotrol enabled");
186 m_perf_control.load_perf_library();
187 }
188 m_perf_control.perf_lock_acquire();
189 }
190
~omx_venc()191 omx_venc::~omx_venc()
192 {
193 get_syntaxhdr_enable = false;
194 m_perf_control.perf_lock_release();
195 }
196
197 /* ======================================================================
198 FUNCTION
199 omx_venc::ComponentInit
200
201 DESCRIPTION
202 Initialize the component.
203
204 PARAMETERS
205 ctxt -- Context information related to the self.
206 id -- Event identifier. This could be any of the following:
207 1. Command completion event
208 2. Buffer done callback event
209 3. Frame done callback event
210
211 RETURN VALUE
212 None.
213
214 ========================================================================== */
component_init(OMX_STRING role)215 OMX_ERRORTYPE omx_venc::component_init(OMX_STRING role)
216 {
217
218 OMX_ERRORTYPE eRet = OMX_ErrorNone;
219
220 int fds[2];
221 int r;
222
223 OMX_VIDEO_CODINGTYPE codec_type;
224
225 DEBUG_PRINT_HIGH("omx_venc(): Inside component_init()");
226 // Copy the role information which provides the decoder m_nkind
227 strlcpy((char *)m_nkind,role,OMX_MAX_STRINGNAME_SIZE);
228 secure_session = false;
229
230 if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc",\
231 OMX_MAX_STRINGNAME_SIZE)) {
232 strlcpy((char *)m_cRole, "video_encoder.avc",OMX_MAX_STRINGNAME_SIZE);
233 codec_type = OMX_VIDEO_CodingAVC;
234 } else if(!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc.secure",\
235 OMX_MAX_STRINGNAME_SIZE)) {
236 strlcpy((char *)m_cRole, "video_encoder.avc",OMX_MAX_STRINGNAME_SIZE);
237 codec_type = OMX_VIDEO_CodingAVC;
238 secure_session = true;
239 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.vp8", \
240 OMX_MAX_STRINGNAME_SIZE)) {
241 strlcpy((char *)m_cRole, "video_encoder.vp8",OMX_MAX_STRINGNAME_SIZE);
242 codec_type = OMX_VIDEO_CodingVP8;
243 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.hevc", \
244 OMX_MAX_STRINGNAME_SIZE) ||
245 !strncmp((char *)m_nkind, "OMX.qcom.video.encoder.hevc.cq", \
246 OMX_MAX_STRINGNAME_SIZE)) {
247 strlcpy((char *)m_cRole, "video_encoder.hevc", OMX_MAX_STRINGNAME_SIZE);
248 codec_type = OMX_VIDEO_CodingHEVC;
249 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.heic", \
250 OMX_MAX_STRINGNAME_SIZE)) {
251 char platform_name[PROP_VALUE_MAX] = {0};
252 char version[PROP_VALUE_MAX] = {0};
253 property_get("ro.board.platform", platform_name, "0"); //HW ID
254 if (!strcmp(platform_name, "sm6150"))
255 {
256 if (property_get("vendor.media.target.version", version, "0") &&
257 (atoi(version) == 0))
258 {
259 //Sku version, HEIC is disabled on this target
260 DEBUG_PRINT_ERROR("heic encoder not supported on this target");
261 eRet = OMX_ErrorInvalidComponentName;
262 } else {
263 strlcpy((char *)m_cRole, "video_encoder.hevc", OMX_MAX_STRINGNAME_SIZE);
264 codec_type = OMX_VIDEO_CodingImageHEIC;
265 }
266 } else {
267 strlcpy((char *)m_cRole, "video_encoder.hevc", OMX_MAX_STRINGNAME_SIZE);
268 codec_type = OMX_VIDEO_CodingImageHEIC;
269 }
270 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.hevc.secure", \
271 OMX_MAX_STRINGNAME_SIZE)) {
272 strlcpy((char *)m_cRole, "video_encoder.hevc", OMX_MAX_STRINGNAME_SIZE);
273 codec_type = OMX_VIDEO_CodingHEVC;
274 secure_session = true;
275 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.tme", \
276 OMX_MAX_STRINGNAME_SIZE)) {
277 char platform_name[PROP_VALUE_MAX] = {0};
278 char version[PROP_VALUE_MAX] = {0};
279 property_get("ro.board.platform", platform_name, "0"); //HW ID
280 if (!strcmp(platform_name, "sm6150")) {
281 if (property_get("vendor.media.target.version", version, "0") &&
282 (atoi(version) == 0)){
283 //Sku version, TME is enabled on this target
284 strlcpy((char *)m_cRole, "video_encoder.tme", OMX_MAX_STRINGNAME_SIZE);
285 codec_type = (OMX_VIDEO_CODINGTYPE)QOMX_VIDEO_CodingTME;
286 }
287 else {
288 //TME is disabled for Moorea
289 DEBUG_PRINT_LOW("TME is not supported");
290 eRet = OMX_ErrorInvalidComponentName;
291 }
292 }
293 else if (!strcmp(platform_name, "atoll")) {
294 //TME is enabled on ATOLL
295 strlcpy((char *)m_cRole, "video_encoder.tme", OMX_MAX_STRINGNAME_SIZE);
296 codec_type = (OMX_VIDEO_CODINGTYPE)QOMX_VIDEO_CodingTME;
297 }
298 else {
299 DEBUG_PRINT_LOW("TME is not supported");
300 eRet = OMX_ErrorInvalidComponentName;
301 }
302 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.tme.secure", \
303 OMX_MAX_STRINGNAME_SIZE)) {
304 char platform_name[PROP_VALUE_MAX] = {0};
305 char version[PROP_VALUE_MAX] = {0};
306 property_get("ro.board.platform", platform_name, "0");
307 if (!strcmp(platform_name, "atoll")) {
308 //TME is enabled on atoll
309 strlcpy((char *)m_cRole, "video_encoder.tme", OMX_MAX_STRINGNAME_SIZE);
310 codec_type = (OMX_VIDEO_CODINGTYPE)QOMX_VIDEO_CodingTME;
311 secure_session = true;
312 }
313 } else {
314 DEBUG_PRINT_ERROR("ERROR: Unknown Component");
315 eRet = OMX_ErrorInvalidComponentName;
316 }
317
318 if (eRet != OMX_ErrorNone) {
319 return eRet;
320 }
321 #ifdef ENABLE_GET_SYNTAX_HDR
322 get_syntaxhdr_enable = true;
323 DEBUG_PRINT_HIGH("Get syntax header enabled");
324 #endif
325
326 handle = new venc_dev(this);
327
328 if (handle == NULL) {
329 DEBUG_PRINT_ERROR("ERROR: handle is NULL");
330 return OMX_ErrorInsufficientResources;
331 }
332
333 if (handle->venc_open(codec_type) != true) {
334 DEBUG_PRINT_ERROR("ERROR: venc_open failed");
335 eRet = OMX_ErrorInsufficientResources;
336 goto init_error;
337 }
338
339 //Intialise the OMX layer variables
340 memset(&m_pCallbacks,0,sizeof(OMX_CALLBACKTYPE));
341
342 OMX_INIT_STRUCT(&m_sPortParam, OMX_PORT_PARAM_TYPE);
343 m_sPortParam.nPorts = 0x2;
344 m_sPortParam.nStartPortNumber = (OMX_U32) PORT_INDEX_IN;
345
346 OMX_INIT_STRUCT(&m_sPortParam_audio, OMX_PORT_PARAM_TYPE);
347 m_sPortParam_audio.nPorts = 0;
348 m_sPortParam_audio.nStartPortNumber = 0;
349
350 OMX_INIT_STRUCT(&m_sPortParam_img, OMX_PORT_PARAM_TYPE);
351 m_sPortParam_img.nPorts = 0;
352 m_sPortParam_img.nStartPortNumber = 0;
353
354 OMX_INIT_STRUCT(&m_sParamBitrate, OMX_VIDEO_PARAM_BITRATETYPE);
355 m_sParamBitrate.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
356 m_sParamBitrate.eControlRate = OMX_Video_ControlRateVariableSkipFrames;
357 m_sParamBitrate.nTargetBitrate = 64000;
358
359 OMX_INIT_STRUCT(&m_sConfigBitrate, OMX_VIDEO_CONFIG_BITRATETYPE);
360 m_sConfigBitrate.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
361 m_sConfigBitrate.nEncodeBitrate = 64000;
362
363 OMX_INIT_STRUCT(&m_sConfigFramerate, OMX_CONFIG_FRAMERATETYPE);
364 m_sConfigFramerate.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
365 m_sConfigFramerate.xEncodeFramerate = 30 << 16;
366
367 OMX_INIT_STRUCT(&m_sConfigIntraRefreshVOP, OMX_CONFIG_INTRAREFRESHVOPTYPE);
368 m_sConfigIntraRefreshVOP.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
369 m_sConfigIntraRefreshVOP.IntraRefreshVOP = OMX_FALSE;
370
371 OMX_INIT_STRUCT(&m_sConfigFrameRotation, OMX_CONFIG_ROTATIONTYPE);
372 m_sConfigFrameRotation.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
373 m_sConfigFrameRotation.nRotation = 0;
374
375 OMX_INIT_STRUCT(&m_sConfigFrameMirror, OMX_CONFIG_MIRRORTYPE);
376 m_sConfigFrameMirror.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
377 m_sConfigFrameMirror.eMirror = OMX_MirrorNone;
378
379 OMX_INIT_STRUCT(&m_sConfigAVCIDRPeriod, OMX_VIDEO_CONFIG_AVCINTRAPERIOD);
380 m_sConfigAVCIDRPeriod.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
381
382 OMX_INIT_STRUCT(&m_sPrependSPSPPS, PrependSPSPPSToIDRFramesParams);
383 m_sPrependSPSPPS.bEnable = OMX_FALSE;
384
385 OMX_INIT_STRUCT(&m_sSessionQuantization, OMX_VIDEO_PARAM_QUANTIZATIONTYPE);
386 m_sSessionQuantization.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
387
388 OMX_INIT_STRUCT(&m_sSessionQPRange, OMX_QCOM_VIDEO_PARAM_IPB_QPRANGETYPE);
389 m_sSessionQPRange.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
390
391 OMX_INIT_STRUCT(&m_sAVCSliceFMO, OMX_VIDEO_PARAM_AVCSLICEFMO);
392 m_sAVCSliceFMO.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
393 m_sAVCSliceFMO.eSliceMode = OMX_VIDEO_SLICEMODE_AVCDefault;
394 m_sAVCSliceFMO.nNumSliceGroups = 0;
395 m_sAVCSliceFMO.nSliceGroupMapType = 0;
396 OMX_INIT_STRUCT(&m_sParamProfileLevel, OMX_VIDEO_PARAM_PROFILELEVELTYPE);
397 m_sParamProfileLevel.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
398
399 OMX_INIT_STRUCT(&m_sIntraperiod, QOMX_VIDEO_INTRAPERIODTYPE);
400 m_sIntraperiod.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
401 m_sIntraperiod.nPFrames = (m_sConfigFramerate.xEncodeFramerate * 2) - 1;
402 /* Consider a scenario where client does get of this and does not modify this
403 and does a set. Then if by default if this is 0 we assume that client is explicitly
404 requesting disabling of B-Frames and our logic to automatically enable bFrames will
405 fail(We do not enable bframes if there is a set of this param with 0 value). We do
406 not want this to happen(also all our default values support auto enabling of B-Frames).
407 We always take care of scenarios where bframes need to be disabled */
408 m_sIntraperiod.nBFrames = 1;
409
410
411 OMX_INIT_STRUCT(&m_sErrorCorrection, OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE);
412 m_sErrorCorrection.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
413 m_sErrorCorrection.bEnableDataPartitioning = OMX_FALSE;
414 m_sErrorCorrection.bEnableHEC = OMX_FALSE;
415 m_sErrorCorrection.bEnableResync = OMX_FALSE;
416 m_sErrorCorrection.bEnableRVLC = OMX_FALSE;
417 m_sErrorCorrection.nResynchMarkerSpacing = 0;
418
419 OMX_INIT_STRUCT(&m_sSliceSpacing, QOMX_VIDEO_PARAM_SLICE_SPACING_TYPE);
420 m_sSliceSpacing.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
421 m_sSliceSpacing.eSliceMode = QOMX_SLICEMODE_MB_COUNT;
422
423 OMX_INIT_STRUCT(&m_sIntraRefresh, OMX_VIDEO_PARAM_INTRAREFRESHTYPE);
424 m_sIntraRefresh.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
425 m_sIntraRefresh.eRefreshMode = OMX_VIDEO_IntraRefreshMax;
426
427 OMX_INIT_STRUCT(&m_sConfigIntraRefresh, OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE);
428 m_sConfigIntraRefresh.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
429 m_sConfigIntraRefresh.nRefreshPeriod = 0;
430
431 OMX_INIT_STRUCT(&m_sConfigColorAspects, DescribeColorAspectsParams);
432 m_sConfigColorAspects.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
433 m_sConfigColorAspects.sAspects.mRange = ColorAspects::RangeUnspecified;
434 m_sConfigColorAspects.sAspects.mPrimaries = ColorAspects::PrimariesUnspecified;
435 m_sConfigColorAspects.sAspects.mMatrixCoeffs = ColorAspects::MatrixUnspecified;
436 m_sConfigColorAspects.sAspects.mTransfer = ColorAspects::TransferUnspecified;
437
438 OMX_INIT_STRUCT(&m_sParamDownScalar, QOMX_INDEXDOWNSCALAR);
439 m_sParamDownScalar.bEnable = OMX_FALSE;
440 m_sParamDownScalar.nOutputWidth = 0;
441 m_sParamDownScalar.nOutputHeight = 0;
442
443 if (codec_type == OMX_VIDEO_CodingAVC) {
444 m_sParamProfileLevel.eProfile = (OMX_U32) OMX_VIDEO_AVCProfileBaseline;
445 m_sParamProfileLevel.eLevel = (OMX_U32) OMX_VIDEO_AVCLevel1;
446 } else if (codec_type == OMX_VIDEO_CodingVP8) {
447 m_sParamProfileLevel.eProfile = (OMX_U32) OMX_VIDEO_VP8ProfileMain;
448 m_sParamProfileLevel.eLevel = (OMX_U32) OMX_VIDEO_VP8Level_Version0;
449 } else if (codec_type == OMX_VIDEO_CodingHEVC) {
450 m_sParamProfileLevel.eProfile = (OMX_U32) OMX_VIDEO_HEVCProfileMain;
451 m_sParamProfileLevel.eLevel = (OMX_U32) OMX_VIDEO_HEVCMainTierLevel1;
452 } else if (codec_type == OMX_VIDEO_CodingImageHEIC) {
453 m_sParamProfileLevel.eProfile = (OMX_U32) OMX_VIDEO_HEVCProfileMainStill;
454 m_sParamProfileLevel.eLevel = (OMX_U32) OMX_VIDEO_HEVCMainTierLevel1;
455 }
456
457 OMX_INIT_STRUCT(&m_sParamEntropy, QOMX_VIDEO_H264ENTROPYCODINGTYPE);
458 m_sParamEntropy.bCabac = OMX_FALSE;
459
460 // Initialize the video parameters for input port
461 OMX_INIT_STRUCT(&m_sInPortDef, OMX_PARAM_PORTDEFINITIONTYPE);
462 m_sInPortDef.nPortIndex= (OMX_U32) PORT_INDEX_IN;
463 m_sInPortDef.bEnabled = OMX_TRUE;
464 m_sInPortDef.bPopulated = OMX_FALSE;
465 m_sInPortDef.eDomain = OMX_PortDomainVideo;
466 m_sInPortDef.eDir = OMX_DirInput;
467 m_sInPortDef.format.video.cMIMEType = (char *)"YUV420";
468 m_sInPortDef.format.video.nFrameWidth = OMX_CORE_QCIF_WIDTH;
469 m_sInPortDef.format.video.nFrameHeight = OMX_CORE_QCIF_HEIGHT;
470 m_sInPortDef.format.video.nStride = OMX_CORE_QCIF_WIDTH;
471 m_sInPortDef.format.video.nSliceHeight = OMX_CORE_QCIF_HEIGHT;
472 m_sInPortDef.format.video.nBitrate = 64000;
473 m_sInPortDef.format.video.xFramerate = 15 << 16;
474 m_sInPortDef.format.video.eColorFormat = (OMX_COLOR_FORMATTYPE)
475 QOMX_DEFAULT_COLOR_FMT;
476 m_sInPortDef.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
477
478 if (dev_get_buf_req(&m_sInPortDef.nBufferCountMin,
479 &m_sInPortDef.nBufferCountActual,
480 &m_sInPortDef.nBufferSize,
481 m_sInPortDef.nPortIndex) != true) {
482 eRet = OMX_ErrorUndefined;
483 goto init_error;
484 }
485
486 // Initialize the video parameters for output port
487 OMX_INIT_STRUCT(&m_sOutPortDef, OMX_PARAM_PORTDEFINITIONTYPE);
488 m_sOutPortDef.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
489 m_sOutPortDef.bEnabled = OMX_TRUE;
490 m_sOutPortDef.bPopulated = OMX_FALSE;
491 m_sOutPortDef.eDomain = OMX_PortDomainVideo;
492 m_sOutPortDef.eDir = OMX_DirOutput;
493 m_sOutPortDef.format.video.nFrameWidth = OMX_CORE_QCIF_WIDTH;
494 m_sOutPortDef.format.video.nFrameHeight = OMX_CORE_QCIF_HEIGHT;
495 m_sOutPortDef.format.video.nBitrate = 64000;
496 m_sOutPortDef.format.video.xFramerate = 15 << 16;
497 m_sOutPortDef.format.video.eColorFormat = OMX_COLOR_FormatUnused;
498 if (codec_type == OMX_VIDEO_CodingAVC) {
499 m_sOutPortDef.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
500 } else if (codec_type == OMX_VIDEO_CodingVP8) {
501 m_sOutPortDef.format.video.eCompressionFormat = OMX_VIDEO_CodingVP8;
502 } else if (codec_type == OMX_VIDEO_CodingHEVC) {
503 m_sOutPortDef.format.video.eCompressionFormat = OMX_VIDEO_CodingHEVC;
504 } else if (codec_type == OMX_VIDEO_CodingImageHEIC) {
505 m_sOutPortDef.format.video.eCompressionFormat = OMX_VIDEO_CodingImageHEIC;
506 } else if (codec_type == (OMX_VIDEO_CODINGTYPE)QOMX_VIDEO_CodingTME) {
507 m_sOutPortDef.format.video.eCompressionFormat = (OMX_VIDEO_CODINGTYPE)QOMX_VIDEO_CodingTME;
508 }
509
510 if (dev_get_buf_req(&m_sOutPortDef.nBufferCountMin,
511 &m_sOutPortDef.nBufferCountActual,
512 &m_sOutPortDef.nBufferSize,
513 m_sOutPortDef.nPortIndex) != true) {
514 eRet = OMX_ErrorUndefined;
515 goto init_error;
516 }
517
518 // Initialize the video color format for input port
519 OMX_INIT_STRUCT(&m_sInPortFormat, OMX_VIDEO_PARAM_PORTFORMATTYPE);
520 m_sInPortFormat.nPortIndex = (OMX_U32) PORT_INDEX_IN;
521 m_sInPortFormat.nIndex = 0;
522 m_sInPortFormat.eColorFormat = (OMX_COLOR_FORMATTYPE)
523 QOMX_DEFAULT_COLOR_FMT;
524 m_sInPortFormat.eCompressionFormat = OMX_VIDEO_CodingUnused;
525
526
527 // Initialize the compression format for output port
528 OMX_INIT_STRUCT(&m_sOutPortFormat, OMX_VIDEO_PARAM_PORTFORMATTYPE);
529 m_sOutPortFormat.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
530 m_sOutPortFormat.nIndex = 0;
531 m_sOutPortFormat.eColorFormat = OMX_COLOR_FormatUnused;
532 if (codec_type == OMX_VIDEO_CodingAVC) {
533 m_sOutPortFormat.eCompressionFormat = OMX_VIDEO_CodingAVC;
534 } else if (codec_type == OMX_VIDEO_CodingVP8) {
535 m_sOutPortFormat.eCompressionFormat = OMX_VIDEO_CodingVP8;
536 } else if (codec_type == OMX_VIDEO_CodingHEVC) {
537 m_sOutPortFormat.eCompressionFormat = OMX_VIDEO_CodingHEVC;
538 } else if (codec_type == OMX_VIDEO_CodingImageHEIC) {
539 m_sOutPortFormat.eCompressionFormat = OMX_VIDEO_CodingImageHEIC;
540 } else if (codec_type == (OMX_VIDEO_CODINGTYPE)QOMX_VIDEO_CodingTME) {
541 m_sOutPortFormat.eCompressionFormat = (OMX_VIDEO_CODINGTYPE)QOMX_VIDEO_CodingTME;
542 }
543
544 // mandatory Indices for kronos test suite
545 OMX_INIT_STRUCT(&m_sPriorityMgmt, OMX_PRIORITYMGMTTYPE);
546
547 OMX_INIT_STRUCT(&m_sInBufSupplier, OMX_PARAM_BUFFERSUPPLIERTYPE);
548 m_sInBufSupplier.nPortIndex = (OMX_U32) PORT_INDEX_IN;
549
550 OMX_INIT_STRUCT(&m_sOutBufSupplier, OMX_PARAM_BUFFERSUPPLIERTYPE);
551 m_sOutBufSupplier.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
552
553 // h264 specific init
554 OMX_INIT_STRUCT(&m_sParamAVC, OMX_VIDEO_PARAM_AVCTYPE);
555 m_sParamAVC.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
556 m_sParamAVC.nSliceHeaderSpacing = 0;
557 m_sParamAVC.nPFrames = (m_sOutPortFormat.xFramerate * 2 - 1); // 2 second intra period for default outport fps
558 m_sParamAVC.nBFrames = 0;
559 m_sParamAVC.bUseHadamard = OMX_FALSE;
560 m_sParamAVC.nRefIdx10ActiveMinus1 = 1;
561 m_sParamAVC.nRefIdx11ActiveMinus1 = 0;
562 m_sParamAVC.bEnableUEP = OMX_FALSE;
563 m_sParamAVC.bEnableFMO = OMX_FALSE;
564 m_sParamAVC.bEnableASO = OMX_FALSE;
565 m_sParamAVC.bEnableRS = OMX_FALSE;
566 /* Since nBFrames = 1 by default, we need a profile which supports B-Frames */
567 m_sParamAVC.eProfile = OMX_VIDEO_AVCProfileHigh;
568 m_sParamAVC.eLevel = OMX_VIDEO_AVCLevel4;
569 m_sParamAVC.nAllowedPictureTypes = 2;
570 m_sParamAVC.bFrameMBsOnly = OMX_FALSE;
571 m_sParamAVC.bMBAFF = OMX_FALSE;
572 m_sParamAVC.bEntropyCodingCABAC = OMX_FALSE;
573 m_sParamAVC.bWeightedPPrediction = OMX_FALSE;
574 m_sParamAVC.nWeightedBipredicitonMode = 0;
575 m_sParamAVC.bconstIpred = OMX_FALSE;
576 m_sParamAVC.bDirect8x8Inference = OMX_FALSE;
577 m_sParamAVC.bDirectSpatialTemporal = OMX_FALSE;
578 m_sParamAVC.nCabacInitIdc = 0;
579 m_sParamAVC.eLoopFilterMode = OMX_VIDEO_AVCLoopFilterEnable;
580
581 // VP8 specific init
582 OMX_INIT_STRUCT(&m_sParamVP8, OMX_VIDEO_PARAM_VP8TYPE);
583 m_sParamVP8.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
584 m_sParamVP8.eProfile = OMX_VIDEO_VP8ProfileMain;
585 m_sParamVP8.eLevel = OMX_VIDEO_VP8Level_Version0;
586 m_sParamVP8.nDCTPartitions = 0;
587 m_sParamVP8.bErrorResilientMode = OMX_FALSE;
588
589 OMX_INIT_STRUCT(&m_sParamVP8Encoder,OMX_VIDEO_PARAM_ANDROID_VP8ENCODERTYPE);
590 m_sParamVP8Encoder.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
591 m_sParamVP8Encoder.nKeyFrameInterval = 30;
592
593 // HEVC specific init
594 OMX_INIT_STRUCT(&m_sParamHEVC, OMX_VIDEO_PARAM_HEVCTYPE);
595 m_sParamHEVC.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
596 m_sParamHEVC.eProfile = OMX_VIDEO_HEVCProfileMain;
597 m_sParamHEVC.eLevel = OMX_VIDEO_HEVCMainTierLevel1;
598
599 // TME specific init
600 OMX_INIT_STRUCT(&m_sParamTME, QOMX_VIDEO_PARAM_TMETYPE);
601 m_sParamTME.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
602 m_sParamTME.eProfile = QOMX_VIDEO_TMEProfile0;
603 m_sParamTME.eLevel = QOMX_VIDEO_TMELevelInteger;
604 m_sParamTME.ePayloadVersion = tme_payload_version;
605
606 // HEIC specific init
607 OMX_INIT_STRUCT(&m_sParamAndroidImageGrid, OMX_VIDEO_PARAM_ANDROID_IMAGEGRIDTYPE);
608 m_sParamAndroidImageGrid.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
609 m_sParamAndroidImageGrid.bEnabled = OMX_FALSE;
610 m_sParamAndroidImageGrid.nTileWidth = DEFAULT_TILE_DIMENSION;
611 m_sParamAndroidImageGrid.nTileHeight = DEFAULT_TILE_DIMENSION;
612 m_sParamAndroidImageGrid.nGridRows = DEFAULT_TILE_ROWS;
613 m_sParamAndroidImageGrid.nGridCols = DEFAULT_TILE_COLS;
614
615 OMX_INIT_STRUCT(&m_sParamLTRCount, QOMX_VIDEO_PARAM_LTRCOUNT_TYPE);
616 m_sParamLTRCount.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
617 m_sParamLTRCount.nCount = 0;
618
619 OMX_INIT_STRUCT(&m_sConfigLTRUse, QOMX_VIDEO_CONFIG_LTRUSE_TYPE);
620 m_sConfigLTRUse.nPortIndex = (OMX_U32) PORT_INDEX_IN;
621 m_sConfigLTRUse.nID = 0;
622
623 OMX_INIT_STRUCT(&m_sConfigLTRMark, QOMX_VIDEO_CONFIG_LTRMARK_TYPE);
624 m_sConfigLTRMark.nPortIndex = (OMX_U32) PORT_INDEX_IN;
625 m_sConfigLTRMark.nID = 0;
626
627 OMX_INIT_STRUCT(&m_sConfigDeinterlace, OMX_VIDEO_CONFIG_DEINTERLACE);
628 m_sConfigDeinterlace.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
629 m_sConfigDeinterlace.nEnable = OMX_FALSE;
630
631 OMX_INIT_STRUCT(&m_sHierLayers, QOMX_VIDEO_HIERARCHICALLAYERS);
632 m_sHierLayers.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
633 m_sHierLayers.nNumLayers = 0;
634 m_sHierLayers.eHierarchicalCodingType = QOMX_HIERARCHICALCODING_P;
635
636 OMX_INIT_STRUCT(&m_sParamTemporalLayers, OMX_VIDEO_PARAM_ANDROID_TEMPORALLAYERINGTYPE);
637 m_sParamTemporalLayers.eSupportedPatterns = OMX_VIDEO_AndroidTemporalLayeringPatternAndroid;
638
639 OMX_INIT_STRUCT(&m_sConfigTemporalLayers, OMX_VIDEO_CONFIG_ANDROID_TEMPORALLAYERINGTYPE);
640
641 OMX_INIT_STRUCT(&m_sParamAVTimerTimestampMode, QOMX_ENABLETYPE);
642 m_sParamAVTimerTimestampMode.bEnable = OMX_FALSE;
643
644 OMX_INIT_STRUCT(&m_sConfigQP, OMX_QCOM_VIDEO_CONFIG_QP);
645 m_sConfigQP.nPortIndex = (OMX_U32) PORT_INDEX_OUT;
646 m_sConfigQP.nQP = 30;
647
648 OMX_INIT_STRUCT(&m_sParamControlInputQueue , QOMX_ENABLETYPE);
649 m_sParamControlInputQueue.bEnable = OMX_FALSE;
650
651 OMX_INIT_STRUCT(&m_sConfigInputTrigTS, OMX_TIME_CONFIG_TIMESTAMPTYPE);
652
653 OMX_INIT_STRUCT(&m_sParamLowLatency, QOMX_EXTNINDEX_VIDEO_LOW_LATENCY_MODE);
654 m_sParamLowLatency.nNumFrames = 0;
655
656 OMX_INIT_STRUCT(&m_sParamColorSpaceConversion , QOMX_ENABLETYPE);
657 m_sParamColorSpaceConversion.bEnable = OMX_FALSE;
658
659 OMX_INIT_STRUCT(&m_sBaseLayerID, OMX_SKYPE_VIDEO_CONFIG_BASELAYERPID);
660
661 OMX_INIT_STRUCT(&m_sParamLinearColorFormat, QOMX_ENABLETYPE);
662 m_sParamLinearColorFormat.bEnable = OMX_FALSE;
663
664 OMX_INIT_STRUCT(&m_sParamNativeRecorder, QOMX_ENABLETYPE);
665 m_sParamNativeRecorder.bEnable = OMX_FALSE;
666
667 m_state = OMX_StateLoaded;
668 m_sExtraData = 0;
669
670 if (eRet == OMX_ErrorNone) {
671 msg_thread_created = true;
672 r = pthread_create(&msg_thread_id,0, message_thread_enc, this);
673 if (r < 0) {
674 DEBUG_PRINT_ERROR("ERROR: message_thread_enc thread creation failed");
675 eRet = OMX_ErrorInsufficientResources;
676 msg_thread_created = false;
677 goto init_error;
678 } else {
679 async_thread_created = true;
680 r = pthread_create(&async_thread_id,0, venc_dev::async_venc_message_thread, this);
681 if (r < 0) {
682 DEBUG_PRINT_ERROR("ERROR: venc_dev::async_venc_message_thread thread creation failed");
683 eRet = OMX_ErrorInsufficientResources;
684 async_thread_created = false;
685 msg_thread_stop = true;
686 pthread_join(msg_thread_id,NULL);
687 msg_thread_created = false;
688 goto init_error;
689 } else
690 dev_set_message_thread_id(async_thread_id);
691 }
692 }
693
694 DEBUG_PRINT_INFO("Component_init : %s : return = 0x%x", m_nkind, eRet);
695
696 {
697 VendorExtensionStore *extStore = const_cast<VendorExtensionStore *>(&mVendorExtensionStore);
698 init_vendor_extensions(*extStore);
699 mVendorExtensionStore.dumpExtensions((const char *)m_nkind);
700 }
701
702 return eRet;
703 init_error:
704 handle->venc_close();
705 delete handle;
706 handle = NULL;
707 return eRet;
708 }
709
710
711 /* ======================================================================
712 FUNCTION
713 omx_venc::Setparameter
714
715 DESCRIPTION
716 OMX Set Parameter method implementation.
717
718 PARAMETERS
719 <TBD>.
720
721 RETURN VALUE
722 OMX Error None if successful.
723
724 ========================================================================== */
set_parameter(OMX_IN OMX_HANDLETYPE hComp,OMX_IN OMX_INDEXTYPE paramIndex,OMX_IN OMX_PTR paramData)725 OMX_ERRORTYPE omx_venc::set_parameter(OMX_IN OMX_HANDLETYPE hComp,
726 OMX_IN OMX_INDEXTYPE paramIndex,
727 OMX_IN OMX_PTR paramData)
728 {
729 (void)hComp;
730 OMX_ERRORTYPE eRet = OMX_ErrorNone;
731
732
733 if (m_state == OMX_StateInvalid) {
734 DEBUG_PRINT_ERROR("ERROR: Set Param in Invalid State");
735 return OMX_ErrorInvalidState;
736 }
737 if (paramData == NULL) {
738 DEBUG_PRINT_ERROR("ERROR: Get Param in Invalid paramData");
739 return OMX_ErrorBadParameter;
740 }
741
742 /*set_parameter can be called in loaded state
743 or disabled port */
744 if (m_state == OMX_StateLoaded
745 || m_sInPortDef.bEnabled == OMX_FALSE
746 || m_sOutPortDef.bEnabled == OMX_FALSE) {
747 DEBUG_PRINT_LOW("Set Parameter called in valid state");
748 } else {
749 DEBUG_PRINT_ERROR("ERROR: Set Parameter called in Invalid State");
750 return OMX_ErrorIncorrectStateOperation;
751 }
752
753 if (reject_param_for_TME_mode(paramIndex)) {
754 DEBUG_PRINT_ERROR("ERROR: Set Parameter 0x%x rejected in TME mode", (int)paramIndex);
755 return OMX_ErrorNone;
756 }
757
758 switch ((int)paramIndex) {
759 case OMX_IndexParamPortDefinition:
760 {
761 VALIDATE_OMX_PARAM_DATA(paramData, OMX_PARAM_PORTDEFINITIONTYPE);
762 OMX_PARAM_PORTDEFINITIONTYPE *portDefn;
763 portDefn = (OMX_PARAM_PORTDEFINITIONTYPE *) paramData;
764 char colorFormatStr[200];
765 dev_get_color_format_as_string(colorFormatStr, sizeof(colorFormatStr), portDefn->format.video.eColorFormat);
766 DEBUG_PRINT_HIGH("set_parameter: OMX_IndexParamPortDefinition: port %d, wxh %dx%d, min %d, actual %d, size %d, colorformat %#x (%s), compression format %#x",
767 portDefn->nPortIndex, portDefn->format.video.nFrameWidth, portDefn->format.video.nFrameHeight,
768 portDefn->nBufferCountMin, portDefn->nBufferCountActual, portDefn->nBufferSize,
769 portDefn->format.video.eColorFormat, colorFormatStr, portDefn->format.video.eCompressionFormat);
770
771 if (PORT_INDEX_IN == portDefn->nPortIndex) {
772 if (portDefn->nBufferCountActual > MAX_NUM_INPUT_BUFFERS) {
773 DEBUG_PRINT_ERROR("ERROR: (In_PORT) actual count (%u) exceeds max(%u)",
774 (unsigned int)portDefn->nBufferCountActual, (unsigned int)MAX_NUM_INPUT_BUFFERS);
775 return OMX_ErrorUnsupportedSetting;
776 }
777 if (m_inp_mem_ptr &&
778 (portDefn->nBufferCountActual != m_sInPortDef.nBufferCountActual ||
779 portDefn->nBufferSize != m_sInPortDef.nBufferSize)) {
780 DEBUG_PRINT_ERROR("ERROR: (In_PORT) buffer count/size can change only if port is unallocated !");
781 return OMX_ErrorInvalidState;
782 }
783 if (m_inp_mem_ptr &&
784 (portDefn->nBufferCountActual != m_sInPortDef.nBufferCountActual ||
785 portDefn->nBufferSize != m_sInPortDef.nBufferSize)) {
786 DEBUG_PRINT_ERROR("ERROR: (In_PORT) buffer count/size can change only if port is unallocated !");
787 return OMX_ErrorInvalidState;
788 }
789 if (portDefn->nBufferCountMin > portDefn->nBufferCountActual) {
790 DEBUG_PRINT_ERROR("ERROR: (In_PORT) Min buffers (%u) > actual count (%u)",
791 (unsigned int)portDefn->nBufferCountMin, (unsigned int)portDefn->nBufferCountActual);
792 return OMX_ErrorUnsupportedSetting;
793 }
794 if (handle->venc_set_param(paramData,OMX_IndexParamPortDefinition) != true) {
795 DEBUG_PRINT_ERROR("ERROR: venc_set_param input failed");
796 return handle->hw_overload ? OMX_ErrorInsufficientResources :
797 OMX_ErrorUnsupportedSetting;
798 }
799
800 memcpy(&m_sInPortDef, portDefn,sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
801
802 #ifdef _ANDROID_ICS_
803 if (portDefn->format.video.eColorFormat ==
804 (OMX_COLOR_FORMATTYPE)QOMX_COLOR_FormatAndroidOpaque) {
805 m_sInPortDef.format.video.eColorFormat = (OMX_COLOR_FORMATTYPE)
806 QOMX_DEFAULT_COLOR_FMT;
807 mUseProxyColorFormat = true;
808 m_input_msg_id = OMX_COMPONENT_GENERATE_ETB_OPQ;
809 } else
810 mUseProxyColorFormat = false;
811 #endif
812 /*Query Input Buffer Requirements*/
813 dev_get_buf_req (&m_sInPortDef.nBufferCountMin,
814 &m_sInPortDef.nBufferCountActual,
815 &m_sInPortDef.nBufferSize,
816 m_sInPortDef.nPortIndex);
817
818 /*Query ouput Buffer Requirements*/
819 dev_get_buf_req (&m_sOutPortDef.nBufferCountMin,
820 &m_sOutPortDef.nBufferCountActual,
821 &m_sOutPortDef.nBufferSize,
822 m_sOutPortDef.nPortIndex);
823 m_sInPortDef.nBufferCountActual = portDefn->nBufferCountActual;
824 } else if (PORT_INDEX_EXTRADATA_OUT == portDefn->nPortIndex) {
825 DEBUG_PRINT_LOW("extradata actual cnt =%u , min cnt =%u ,buffersize requested = %u",
826 (unsigned int)portDefn->nBufferCountActual,(unsigned int)portDefn->nBufferCountMin,
827 (unsigned int)portDefn->nBufferSize);
828 if (portDefn->nBufferCountActual != m_client_out_extradata_info.getBufferCount() ||
829 portDefn->nBufferSize != m_client_out_extradata_info.getSize()) {
830 DEBUG_PRINT_HIGH("ERROR: Bad parameeters request for extradata limit %d size - %d",
831 portDefn->nBufferCountActual, portDefn->nBufferSize);
832 eRet = OMX_ErrorNone;
833 break;
834 }
835 } else if (PORT_INDEX_EXTRADATA_IN == portDefn->nPortIndex) {
836 DEBUG_PRINT_LOW("extradata actual cnt =%u , min cnt =%u ,buffersize requested = %u",
837 (unsigned int)portDefn->nBufferCountActual,(unsigned int)portDefn->nBufferCountMin,
838 (unsigned int)portDefn->nBufferSize);
839 if (portDefn->nBufferCountActual != m_client_in_extradata_info.getBufferCount() ||
840 portDefn->nBufferSize != m_client_in_extradata_info.getSize()) {
841 DEBUG_PRINT_ERROR("ERROR: Bad parameeters request for extradata limit %d size - %d",
842 portDefn->nBufferCountActual, portDefn->nBufferSize);
843 eRet = OMX_ErrorBadParameter;
844 break;
845 }
846 } else if (PORT_INDEX_OUT == portDefn->nPortIndex) {
847
848 if (portDefn->nBufferCountActual > MAX_NUM_OUTPUT_BUFFERS) {
849 DEBUG_PRINT_ERROR("ERROR: (Out_PORT) actual count (%u) exceeds max(%u)",
850 (unsigned int)portDefn->nBufferCountActual, (unsigned int)MAX_NUM_OUTPUT_BUFFERS);
851 return OMX_ErrorUnsupportedSetting;
852 }
853 if (m_out_mem_ptr &&
854 (portDefn->nBufferCountActual != m_sOutPortDef.nBufferCountActual ||
855 portDefn->nBufferSize != m_sOutPortDef.nBufferSize)) {
856 DEBUG_PRINT_ERROR("ERROR: (Out_PORT) buffer count/size can change only if port is unallocated !");
857 return OMX_ErrorInvalidState;
858 }
859
860 if (portDefn->nBufferCountMin > portDefn->nBufferCountActual) {
861 DEBUG_PRINT_ERROR("ERROR: (Out_PORT) Min buffers (%u) > actual count (%u)",
862 (unsigned int)portDefn->nBufferCountMin, (unsigned int)portDefn->nBufferCountActual);
863 return OMX_ErrorUnsupportedSetting;
864 }
865 if (handle->venc_set_param(paramData,OMX_IndexParamPortDefinition) != true) {
866 DEBUG_PRINT_ERROR("ERROR: venc_set_param output failed");
867 return OMX_ErrorUnsupportedSetting;
868 }
869 memcpy(&m_sOutPortDef,portDefn,sizeof(struct OMX_PARAM_PORTDEFINITIONTYPE));
870 /*Query ouput Buffer Requirements*/
871 dev_get_buf_req(&m_sOutPortDef.nBufferCountMin,
872 &m_sOutPortDef.nBufferCountActual,
873 &m_sOutPortDef.nBufferSize,
874 m_sOutPortDef.nPortIndex);
875 update_profile_level(); //framerate , bitrate
876
877 m_sOutPortDef.nBufferCountActual = portDefn->nBufferCountActual;
878 } else {
879 DEBUG_PRINT_ERROR("ERROR: Set_parameter: Bad Port idx %d",
880 (int)portDefn->nPortIndex);
881 eRet = OMX_ErrorBadPortIndex;
882 }
883 m_sConfigFramerate.xEncodeFramerate = portDefn->format.video.xFramerate;
884 m_sConfigBitrate.nEncodeBitrate = portDefn->format.video.nBitrate;
885 m_sParamBitrate.nTargetBitrate = portDefn->format.video.nBitrate;
886 }
887 break;
888
889 case OMX_IndexParamVideoPortFormat:
890 {
891 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_PORTFORMATTYPE);
892 OMX_VIDEO_PARAM_PORTFORMATTYPE *portFmt =
893 (OMX_VIDEO_PARAM_PORTFORMATTYPE *)paramData;
894 char colorFormatStr[200];
895 dev_get_color_format_as_string(colorFormatStr, sizeof(colorFormatStr), portFmt->eColorFormat);
896 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoPortFormat %x (%s)",
897 portFmt->eColorFormat, colorFormatStr);
898 //set the driver with the corresponding values
899 if (PORT_INDEX_IN == portFmt->nPortIndex) {
900 if (handle->venc_set_param(paramData,OMX_IndexParamVideoPortFormat) != true) {
901 return OMX_ErrorUnsupportedSetting;
902 }
903
904 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoPortFormat %x (%s)",
905 portFmt->eColorFormat, colorFormatStr);
906 update_profile_level(); //framerate
907
908 #ifdef _ANDROID_ICS_
909 if (portFmt->eColorFormat ==
910 (OMX_COLOR_FORMATTYPE)QOMX_COLOR_FormatAndroidOpaque) {
911 m_sInPortFormat.eColorFormat = (OMX_COLOR_FORMATTYPE)
912 QOMX_DEFAULT_COLOR_FMT;
913 mUseProxyColorFormat = true;
914 m_input_msg_id = OMX_COMPONENT_GENERATE_ETB_OPQ;
915 } else
916 #endif
917 {
918 m_sInPortFormat.eColorFormat = portFmt->eColorFormat;
919 m_sInPortDef.format.video.eColorFormat = portFmt->eColorFormat;
920 m_input_msg_id = OMX_COMPONENT_GENERATE_ETB;
921 mUseProxyColorFormat = false;
922 }
923 m_sInPortFormat.xFramerate = portFmt->xFramerate;
924 }
925 //TODO if no use case for O/P port,delet m_sOutPortFormat
926 }
927 break;
928 case OMX_IndexParamVideoInit:
929 { //TODO, do we need this index set param
930 VALIDATE_OMX_PARAM_DATA(paramData, OMX_PORT_PARAM_TYPE);
931 OMX_PORT_PARAM_TYPE* pParam = (OMX_PORT_PARAM_TYPE*)(paramData);
932 DEBUG_PRINT_LOW("Set OMX_IndexParamVideoInit called");
933 break;
934 }
935
936 case OMX_IndexParamVideoBitrate:
937 {
938 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_BITRATETYPE);
939 OMX_VIDEO_PARAM_BITRATETYPE* pParam = (OMX_VIDEO_PARAM_BITRATETYPE*)paramData;
940 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoBitrate");
941 if (handle->venc_set_param(paramData,OMX_IndexParamVideoBitrate) != true) {
942 return OMX_ErrorUnsupportedSetting;
943 }
944 m_sParamBitrate.nTargetBitrate = pParam->nTargetBitrate;
945 m_sParamBitrate.eControlRate = pParam->eControlRate;
946 update_profile_level(); //bitrate
947 m_sConfigBitrate.nEncodeBitrate = pParam->nTargetBitrate;
948 m_sInPortDef.format.video.nBitrate = pParam->nTargetBitrate;
949 m_sOutPortDef.format.video.nBitrate = pParam->nTargetBitrate;
950 /* RC mode chan chage buffer requirements on Input port */
951 dev_get_buf_req(&m_sInPortDef.nBufferCountMin,
952 &m_sInPortDef.nBufferCountActual,
953 &m_sInPortDef.nBufferSize,
954 m_sInPortDef.nPortIndex);
955 DEBUG_PRINT_LOW("bitrate = %u", (unsigned int)m_sOutPortDef.format.video.nBitrate);
956 break;
957 }
958 case OMX_IndexParamVideoAvc:
959 {
960 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_AVCTYPE);
961 OMX_VIDEO_PARAM_AVCTYPE* pParam = (OMX_VIDEO_PARAM_AVCTYPE*)paramData;
962 OMX_VIDEO_PARAM_AVCTYPE avc_param;
963 memcpy(&avc_param, pParam, sizeof( struct OMX_VIDEO_PARAM_AVCTYPE));
964 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoAvc");
965
966 avc_param.nBFrames = 0;
967 avc_param.bEntropyCodingCABAC = (OMX_BOOL)(0);
968 avc_param.nCabacInitIdc = 0;
969 if ((pParam->eProfile == OMX_VIDEO_AVCProfileHigh)||
970 (pParam->eProfile == OMX_VIDEO_AVCProfileMain)||
971 (pParam->eProfile == (OMX_VIDEO_AVCPROFILETYPE)OMX_VIDEO_AVCProfileConstrainedHigh)) {
972
973 if (pParam->nBFrames) {
974 avc_param.nBFrames = pParam->nBFrames;
975 DEBUG_PRINT_LOW("B frames set using Client setparam to %d",
976 avc_param.nBFrames);
977 }
978
979 DEBUG_PRINT_HIGH("AVC: BFrames: %u", (unsigned int)avc_param.nBFrames);
980 avc_param.bEntropyCodingCABAC = (OMX_BOOL)(1);
981 avc_param.nCabacInitIdc = 0;
982 } else {
983 if (pParam->nBFrames) {
984 DEBUG_PRINT_HIGH("B frames not supported with profile %x", pParam->eProfile);
985 }
986 }
987
988 if (handle->venc_set_param(&avc_param,OMX_IndexParamVideoAvc) != true) {
989 return OMX_ErrorUnsupportedSetting;
990 }
991 memcpy(&m_sParamAVC,pParam, sizeof(struct OMX_VIDEO_PARAM_AVCTYPE));
992 /* nBFrames is only supported through QOMX_IndexConfigVideoIntraperiod. Don't set here */
993 break;
994 }
995 case (OMX_INDEXTYPE)OMX_IndexParamVideoVp8:
996 {
997 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_VP8TYPE);
998 OMX_VIDEO_PARAM_VP8TYPE* pParam = (OMX_VIDEO_PARAM_VP8TYPE*)paramData;
999 OMX_VIDEO_PARAM_VP8TYPE vp8_param;
1000 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoVp8");
1001 if (pParam->nDCTPartitions != m_sParamVP8.nDCTPartitions ||
1002 pParam->bErrorResilientMode != m_sParamVP8.bErrorResilientMode) {
1003 DEBUG_PRINT_ERROR("VP8 doesn't support nDCTPartitions or bErrorResilientMode");
1004 }
1005 memcpy(&vp8_param, pParam, sizeof( struct OMX_VIDEO_PARAM_VP8TYPE));
1006 if (handle->venc_set_param(&vp8_param, (OMX_INDEXTYPE)OMX_IndexParamVideoVp8) != true) {
1007 return OMX_ErrorUnsupportedSetting;
1008 }
1009 memcpy(&m_sParamVP8,pParam, sizeof(struct OMX_VIDEO_PARAM_VP8TYPE));
1010 break;
1011 }
1012 case (OMX_INDEXTYPE)OMX_IndexParamVideoAndroidVp8Encoder:
1013 {
1014 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_ANDROID_VP8ENCODERTYPE);
1015 OMX_VIDEO_PARAM_ANDROID_VP8ENCODERTYPE* pParam = (OMX_VIDEO_PARAM_ANDROID_VP8ENCODERTYPE*)paramData;
1016 OMX_VIDEO_PARAM_ANDROID_VP8ENCODERTYPE vp8_param;
1017 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoAndroidVp8Encoder");
1018
1019 memcpy(&vp8_param, pParam, sizeof( struct OMX_VIDEO_PARAM_ANDROID_VP8ENCODERTYPE));
1020 if (handle->venc_set_param(&vp8_param, (OMX_INDEXTYPE)OMX_IndexParamVideoAndroidVp8Encoder) != true) {
1021 return OMX_ErrorUnsupportedSetting;
1022 }
1023 memcpy(&m_sParamVP8Encoder, &vp8_param, sizeof(struct OMX_VIDEO_PARAM_ANDROID_VP8ENCODERTYPE));
1024 break;
1025 }
1026 case (OMX_INDEXTYPE)OMX_IndexParamVideoHevc:
1027 {
1028 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_HEVCTYPE);
1029 OMX_VIDEO_PARAM_HEVCTYPE* pParam = (OMX_VIDEO_PARAM_HEVCTYPE*)paramData;
1030 OMX_VIDEO_PARAM_HEVCTYPE hevc_param;
1031 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoHevc");
1032 memcpy(&hevc_param, pParam, sizeof( struct OMX_VIDEO_PARAM_HEVCTYPE));
1033 if (handle->venc_set_param(&hevc_param, (OMX_INDEXTYPE)OMX_IndexParamVideoHevc) != true) {
1034 DEBUG_PRINT_ERROR("Failed : set_parameter: OMX_IndexParamVideoHevc");
1035 return OMX_ErrorUnsupportedSetting;
1036 }
1037 memcpy(&m_sParamHEVC, pParam, sizeof(struct OMX_VIDEO_PARAM_HEVCTYPE));
1038 break;
1039 }
1040 case (OMX_INDEXTYPE)OMX_IndexParamVideoTme:
1041 {
1042 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_VIDEO_PARAM_TMETYPE);
1043 QOMX_VIDEO_PARAM_TMETYPE* pParam = (QOMX_VIDEO_PARAM_TMETYPE*)paramData;
1044 QOMX_VIDEO_PARAM_TMETYPE tme_param;
1045 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoTME");
1046 memcpy(&tme_param, pParam, sizeof( struct QOMX_VIDEO_PARAM_TMETYPE));
1047 if (handle->venc_set_param(&tme_param, (OMX_INDEXTYPE)OMX_IndexParamVideoTme) != true) {
1048 DEBUG_PRINT_ERROR("Failed : set_parameter: OMX_IndexParamVideoTme");
1049 return OMX_ErrorUnsupportedSetting;
1050 }
1051 memcpy(&m_sParamTME, pParam, sizeof(struct QOMX_VIDEO_PARAM_TMETYPE));
1052 m_sParamTME.ePayloadVersion = tme_payload_version;
1053 break;
1054 }
1055 case OMX_IndexParamVideoAndroidImageGrid:
1056 {
1057 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoAndroidImageGrid. Ignore!");
1058 break;
1059 }
1060 case OMX_IndexParamVideoProfileLevelCurrent:
1061 {
1062 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_PROFILELEVELTYPE);
1063 OMX_VIDEO_PARAM_PROFILELEVELTYPE* pParam = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)paramData;
1064 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoProfileLevelCurrent");
1065 if (handle->venc_set_param(pParam,OMX_IndexParamVideoProfileLevelCurrent) != true) {
1066 DEBUG_PRINT_ERROR("set_parameter: OMX_IndexParamVideoProfileLevelCurrent failed for Profile: %u "
1067 "Level :%u", (unsigned int)pParam->eProfile, (unsigned int)pParam->eLevel);
1068 return OMX_ErrorUnsupportedSetting;
1069 }
1070 m_sParamProfileLevel.eProfile = pParam->eProfile;
1071 m_sParamProfileLevel.eLevel = pParam->eLevel;
1072
1073 if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc",\
1074 OMX_MAX_STRINGNAME_SIZE)) {
1075 m_sParamAVC.eProfile = (OMX_VIDEO_AVCPROFILETYPE)m_sParamProfileLevel.eProfile;
1076 m_sParamAVC.eLevel = (OMX_VIDEO_AVCLEVELTYPE)m_sParamProfileLevel.eLevel;
1077 DEBUG_PRINT_LOW("AVC profile = %d, level = %d", m_sParamAVC.eProfile,
1078 m_sParamAVC.eLevel);
1079 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc.secure",\
1080 OMX_MAX_STRINGNAME_SIZE)) {
1081 m_sParamAVC.eProfile = (OMX_VIDEO_AVCPROFILETYPE)m_sParamProfileLevel.eProfile;
1082 m_sParamAVC.eLevel = (OMX_VIDEO_AVCLEVELTYPE)m_sParamProfileLevel.eLevel;
1083 DEBUG_PRINT_LOW("\n AVC profile = %d, level = %d", m_sParamAVC.eProfile,
1084 m_sParamAVC.eLevel);
1085 }
1086 else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.vp8",\
1087 OMX_MAX_STRINGNAME_SIZE)) {
1088 m_sParamVP8.eProfile = (OMX_VIDEO_VP8PROFILETYPE)m_sParamProfileLevel.eProfile;
1089 m_sParamVP8.eLevel = (OMX_VIDEO_VP8LEVELTYPE)m_sParamProfileLevel.eLevel;
1090 DEBUG_PRINT_LOW("VP8 profile = %d, level = %d", m_sParamVP8.eProfile,
1091 m_sParamVP8.eLevel);
1092 }
1093 else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.hevc",\
1094 OMX_MAX_STRINGNAME_SIZE) ||
1095 !strncmp((char*)m_nkind, "OMX.qcom.video.encoder.hevc.cq",\
1096 OMX_MAX_STRINGNAME_SIZE) ||
1097 !strncmp((char*)m_nkind, "OMX.qcom.video.encoder.heic",\
1098 OMX_MAX_STRINGNAME_SIZE)) {
1099 m_sParamHEVC.eProfile = (OMX_VIDEO_HEVCPROFILETYPE)m_sParamProfileLevel.eProfile;
1100 m_sParamHEVC.eLevel = (OMX_VIDEO_HEVCLEVELTYPE)m_sParamProfileLevel.eLevel;
1101 DEBUG_PRINT_LOW("HEVC profile = %d, level = %d", m_sParamHEVC.eProfile,
1102 m_sParamHEVC.eLevel);
1103 }
1104
1105 break;
1106 }
1107 case OMX_IndexParamStandardComponentRole:
1108 {
1109 VALIDATE_OMX_PARAM_DATA(paramData, OMX_PARAM_COMPONENTROLETYPE);
1110 OMX_PARAM_COMPONENTROLETYPE *comp_role;
1111 comp_role = (OMX_PARAM_COMPONENTROLETYPE *) paramData;
1112 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamStandardComponentRole %s",
1113 comp_role->cRole);
1114
1115 if ((m_state == OMX_StateLoaded)&&
1116 !BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING)) {
1117 DEBUG_PRINT_LOW("Set Parameter called in valid state");
1118 } else {
1119 DEBUG_PRINT_ERROR("Set Parameter called in Invalid State");
1120 return OMX_ErrorIncorrectStateOperation;
1121 }
1122
1123 if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.avc",OMX_MAX_STRINGNAME_SIZE)) {
1124 if (!strncmp((char*)comp_role->cRole,"video_encoder.avc",OMX_MAX_STRINGNAME_SIZE)) {
1125 strlcpy((char*)m_cRole,"video_encoder.avc",OMX_MAX_STRINGNAME_SIZE);
1126 } else {
1127 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s", comp_role->cRole);
1128 eRet =OMX_ErrorUnsupportedSetting;
1129 }
1130 } else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.avc.secure",OMX_MAX_STRINGNAME_SIZE)) {
1131 if (!strncmp((char*)comp_role->cRole,"video_encoder.avc",OMX_MAX_STRINGNAME_SIZE)) {
1132 strlcpy((char*)m_cRole,"video_encoder.avc",OMX_MAX_STRINGNAME_SIZE);
1133 } else {
1134 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s\n", comp_role->cRole);
1135 eRet =OMX_ErrorUnsupportedSetting;
1136 }
1137 } else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.vp8",OMX_MAX_STRINGNAME_SIZE)) {
1138 if (!strncmp((const char*)comp_role->cRole,"video_encoder.vp8",OMX_MAX_STRINGNAME_SIZE)) {
1139 strlcpy((char*)m_cRole,"video_encoder.vp8",OMX_MAX_STRINGNAME_SIZE);
1140 } else {
1141 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s", comp_role->cRole);
1142 eRet =OMX_ErrorUnsupportedSetting;
1143 }
1144 } else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.hevc",OMX_MAX_STRINGNAME_SIZE) ||
1145 !strncmp((char*)m_nkind, "OMX.qcom.video.encoder.hevc.cq",OMX_MAX_STRINGNAME_SIZE)) {
1146 if (!strncmp((const char*)comp_role->cRole,"video_encoder.hevc",OMX_MAX_STRINGNAME_SIZE)) {
1147 strlcpy((char*)m_cRole,"video_encoder.hevc",OMX_MAX_STRINGNAME_SIZE);
1148 } else {
1149 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s", comp_role->cRole);
1150 eRet = OMX_ErrorUnsupportedSetting;
1151 }
1152 } else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.hevc.secure",OMX_MAX_STRINGNAME_SIZE)) {
1153 if (!strncmp((const char*)comp_role->cRole,"video_encoder.hevc",OMX_MAX_STRINGNAME_SIZE)) {
1154 strlcpy((char*)m_cRole,"video_encoder.hevc",OMX_MAX_STRINGNAME_SIZE);
1155 } else {
1156 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s", comp_role->cRole);
1157 eRet = OMX_ErrorUnsupportedSetting;
1158 }
1159 } else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.heic",OMX_MAX_STRINGNAME_SIZE)) {
1160 if (!strncmp((const char*)comp_role->cRole,"image_encoder.heic",OMX_MAX_STRINGNAME_SIZE)) {
1161 strlcpy((char*)m_cRole,"video_encoder.hevc",OMX_MAX_STRINGNAME_SIZE);
1162 } else {
1163 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s", comp_role->cRole);
1164 eRet = OMX_ErrorUnsupportedSetting;
1165 }
1166 } else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.tme", OMX_MAX_STRINGNAME_SIZE)) {
1167 if (!strncmp((const char*)comp_role->cRole,"video_encoder.tme",OMX_MAX_STRINGNAME_SIZE)) {
1168 strlcpy((char*)m_cRole,"video_encoder.tme",OMX_MAX_STRINGNAME_SIZE);
1169 } else {
1170 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s", comp_role->cRole);
1171 eRet = OMX_ErrorUnsupportedSetting;
1172 }
1173 }
1174 else {
1175 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown param %s", m_nkind);
1176 eRet = OMX_ErrorInvalidComponentName;
1177 }
1178 break;
1179 }
1180
1181 case OMX_IndexParamPriorityMgmt:
1182 {
1183 VALIDATE_OMX_PARAM_DATA(paramData, OMX_PRIORITYMGMTTYPE);
1184 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamPriorityMgmt");
1185 if (m_state != OMX_StateLoaded) {
1186 DEBUG_PRINT_ERROR("ERROR: Set Parameter called in Invalid State");
1187 return OMX_ErrorIncorrectStateOperation;
1188 }
1189 OMX_PRIORITYMGMTTYPE *priorityMgmtype = (OMX_PRIORITYMGMTTYPE*) paramData;
1190 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamPriorityMgmt %u",
1191 (unsigned int)priorityMgmtype->nGroupID);
1192
1193 DEBUG_PRINT_LOW("set_parameter: priorityMgmtype %u",
1194 (unsigned int)priorityMgmtype->nGroupPriority);
1195
1196 m_sPriorityMgmt.nGroupID = priorityMgmtype->nGroupID;
1197 m_sPriorityMgmt.nGroupPriority = priorityMgmtype->nGroupPriority;
1198
1199 break;
1200 }
1201
1202 case OMX_IndexParamCompBufferSupplier:
1203 {
1204 VALIDATE_OMX_PARAM_DATA(paramData, OMX_PARAM_BUFFERSUPPLIERTYPE);
1205 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamCompBufferSupplier");
1206 OMX_PARAM_BUFFERSUPPLIERTYPE *bufferSupplierType = (OMX_PARAM_BUFFERSUPPLIERTYPE*) paramData;
1207 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamCompBufferSupplier %d",
1208 bufferSupplierType->eBufferSupplier);
1209 if (bufferSupplierType->nPortIndex == 0 || bufferSupplierType->nPortIndex ==1)
1210 m_sInBufSupplier.eBufferSupplier = bufferSupplierType->eBufferSupplier;
1211
1212 else
1213
1214 eRet = OMX_ErrorBadPortIndex;
1215
1216 break;
1217
1218 }
1219 case OMX_GoogleAndroidIndexAllocateNativeHandle:
1220 {
1221 VALIDATE_OMX_PARAM_DATA(paramData, AllocateNativeHandleParams);
1222
1223 AllocateNativeHandleParams* allocateNativeHandleParams = (AllocateNativeHandleParams *) paramData;
1224
1225 if (!secure_session) {
1226 DEBUG_PRINT_INFO("WARN: Enable/Disable allocate-native-handle allowed only in secure session");
1227 eRet = OMX_ErrorUnsupportedSetting;
1228 break;
1229 } else if (allocateNativeHandleParams->nPortIndex != PORT_INDEX_OUT) {
1230 DEBUG_PRINT_INFO("WARN: Enable/Disable allocate-native-handle allowed only on Output port!");
1231 eRet = OMX_ErrorUnsupportedSetting;
1232 break;
1233 } else if (m_out_mem_ptr) {
1234 DEBUG_PRINT_INFO("WARN: Enable/Disable allocate-native-handle is not allowed since Output port is not free !");
1235 eRet = OMX_ErrorInvalidState;
1236 break;
1237 }
1238
1239 if (allocateNativeHandleParams != NULL) {
1240 allocate_native_handle = allocateNativeHandleParams->enable;
1241 }
1242 break;
1243 }
1244 case OMX_IndexParamVideoQuantization:
1245 {
1246 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_QUANTIZATIONTYPE);
1247 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoQuantization");
1248 OMX_VIDEO_PARAM_QUANTIZATIONTYPE *session_qp = (OMX_VIDEO_PARAM_QUANTIZATIONTYPE*) paramData;
1249 if (session_qp->nPortIndex == PORT_INDEX_OUT) {
1250 if (handle->venc_set_param(paramData, OMX_IndexParamVideoQuantization) != true) {
1251 return OMX_ErrorUnsupportedSetting;
1252 }
1253 m_sSessionQuantization.nQpI = session_qp->nQpI;
1254 m_sSessionQuantization.nQpP = session_qp->nQpP;
1255 m_sSessionQuantization.nQpB = session_qp->nQpB;
1256 m_QPSet = ENABLE_I_QP | ENABLE_P_QP | ENABLE_B_QP;
1257 } else {
1258 DEBUG_PRINT_ERROR("ERROR: Unsupported port Index for Session QP setting");
1259 eRet = OMX_ErrorBadPortIndex;
1260 }
1261 break;
1262 }
1263 case OMX_QcomIndexParamVideoIPBQPRange:
1264 {
1265 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QCOM_VIDEO_PARAM_IPB_QPRANGETYPE);
1266 DEBUG_PRINT_LOW("set_parameter: OMX_QcomIndexParamVideoIPBQPRange");
1267 OMX_QCOM_VIDEO_PARAM_IPB_QPRANGETYPE *session_qp_range = (OMX_QCOM_VIDEO_PARAM_IPB_QPRANGETYPE*) paramData;
1268 if (session_qp_range->nPortIndex == PORT_INDEX_OUT) {
1269 if (handle->venc_set_param(paramData, (OMX_INDEXTYPE)OMX_QcomIndexParamVideoIPBQPRange) != true) {
1270 return OMX_ErrorUnsupportedSetting;
1271 }
1272 m_sSessionQPRange.minIQP = session_qp_range->minIQP;
1273 m_sSessionQPRange.maxIQP = session_qp_range->maxIQP;
1274 m_sSessionQPRange.minPQP = session_qp_range->minPQP;
1275 m_sSessionQPRange.maxPQP = session_qp_range->maxPQP;
1276 m_sSessionQPRange.minBQP = session_qp_range->minBQP;
1277 m_sSessionQPRange.maxBQP = session_qp_range->maxBQP;
1278 } else {
1279 DEBUG_PRINT_ERROR("ERROR: Unsupported port Index for QP range setting");
1280 eRet = OMX_ErrorBadPortIndex;
1281 }
1282 break;
1283 }
1284 case QOMX_IndexParamVideoInitialQp:
1285 {
1286 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_EXTNINDEX_VIDEO_INITIALQP);
1287 DEBUG_PRINT_LOW("set_parameter: QOMX_IndexParamVideoInitialQp");
1288 QOMX_EXTNINDEX_VIDEO_INITIALQP *initial_qp = (QOMX_EXTNINDEX_VIDEO_INITIALQP*) paramData;
1289 if (initial_qp->nPortIndex == PORT_INDEX_OUT) {
1290 if (handle->venc_set_param(paramData, (OMX_INDEXTYPE)QOMX_IndexParamVideoInitialQp) != true) {
1291 return OMX_ErrorUnsupportedSetting;
1292 }
1293 m_sSessionQuantization.nQpI = initial_qp->nQpI;
1294 m_sSessionQuantization.nQpP = initial_qp->nQpP;
1295 m_sSessionQuantization.nQpB = initial_qp->nQpB;
1296 m_QPSet = initial_qp->bEnableInitQp;
1297 } else {
1298 DEBUG_PRINT_ERROR("ERROR: Unsupported port Index for initial QP setting");
1299 eRet = OMX_ErrorBadPortIndex;
1300 }
1301 break;
1302 }
1303 case OMX_QcomIndexPortDefn:
1304 {
1305 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QCOM_PARAM_PORTDEFINITIONTYPE);
1306 OMX_QCOM_PARAM_PORTDEFINITIONTYPE* pParam =
1307 (OMX_QCOM_PARAM_PORTDEFINITIONTYPE*)paramData;
1308 DEBUG_PRINT_LOW("set_parameter: OMX_QcomIndexPortDefn");
1309 if (pParam->nPortIndex == (OMX_U32)PORT_INDEX_IN) {
1310 if (pParam->nMemRegion > OMX_QCOM_MemRegionInvalid &&
1311 pParam->nMemRegion < OMX_QCOM_MemRegionMax) {
1312 m_use_input_pmem = OMX_TRUE;
1313 } else {
1314 m_use_input_pmem = OMX_FALSE;
1315 }
1316 } else if (pParam->nPortIndex == (OMX_U32)PORT_INDEX_OUT) {
1317 if (pParam->nMemRegion > OMX_QCOM_MemRegionInvalid &&
1318 pParam->nMemRegion < OMX_QCOM_MemRegionMax) {
1319 m_use_output_pmem = OMX_TRUE;
1320 } else {
1321 m_use_output_pmem = OMX_FALSE;
1322 }
1323 } else {
1324 DEBUG_PRINT_ERROR("ERROR: SetParameter called on unsupported Port Index for QcomPortDefn");
1325 return OMX_ErrorBadPortIndex;
1326 }
1327 break;
1328 }
1329
1330 case OMX_IndexParamVideoErrorCorrection:
1331 {
1332 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE);
1333 DEBUG_PRINT_LOW("OMX_IndexParamVideoErrorCorrection");
1334 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE* pParam =
1335 (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE*)paramData;
1336 if (!handle->venc_set_param(paramData, OMX_IndexParamVideoErrorCorrection)) {
1337 DEBUG_PRINT_ERROR("ERROR: Request for setting Error Resilience failed");
1338 return OMX_ErrorUnsupportedSetting;
1339 }
1340 memcpy(&m_sErrorCorrection,pParam, sizeof(m_sErrorCorrection));
1341 break;
1342 }
1343 case OMX_QcomIndexParamVideoSliceSpacing:
1344 {
1345 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_VIDEO_PARAM_SLICE_SPACING_TYPE);
1346 DEBUG_PRINT_LOW("OMX_QcomIndexParamVideoSliceSpacing");
1347 QOMX_VIDEO_PARAM_SLICE_SPACING_TYPE* pParam =
1348 (QOMX_VIDEO_PARAM_SLICE_SPACING_TYPE*)paramData;
1349 if (!handle->venc_set_param(paramData, (OMX_INDEXTYPE)OMX_QcomIndexParamVideoSliceSpacing)) {
1350 DEBUG_PRINT_ERROR("ERROR: Request for setting slice spacing failed");
1351 return OMX_ErrorUnsupportedSetting;
1352 }
1353 memcpy(&m_sSliceSpacing, pParam, sizeof(m_sSliceSpacing));
1354 break;
1355 }
1356 case OMX_IndexParamVideoIntraRefresh:
1357 {
1358 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_INTRAREFRESHTYPE);
1359 DEBUG_PRINT_LOW("set_param:OMX_IndexParamVideoIntraRefresh");
1360 OMX_VIDEO_PARAM_INTRAREFRESHTYPE* pParam =
1361 (OMX_VIDEO_PARAM_INTRAREFRESHTYPE*)paramData;
1362 if (!handle->venc_set_param(paramData,OMX_IndexParamVideoIntraRefresh)) {
1363 DEBUG_PRINT_ERROR("ERROR: Request for setting intra refresh failed");
1364 return OMX_ErrorUnsupportedSetting;
1365 }
1366 memcpy(&m_sIntraRefresh, pParam, sizeof(m_sIntraRefresh));
1367 break;
1368 }
1369 #ifdef _ANDROID_ICS_
1370 case OMX_QcomIndexParamVideoMetaBufferMode:
1371 {
1372 VALIDATE_OMX_PARAM_DATA(paramData, StoreMetaDataInBuffersParams);
1373 StoreMetaDataInBuffersParams *pParam =
1374 (StoreMetaDataInBuffersParams*)paramData;
1375 DEBUG_PRINT_HIGH("set_parameter:OMX_QcomIndexParamVideoMetaBufferMode: "
1376 "port_index = %u, meta_mode = %d", (unsigned int)pParam->nPortIndex, pParam->bStoreMetaData);
1377 if (pParam->nPortIndex == PORT_INDEX_IN) {
1378 if (pParam->bStoreMetaData != meta_mode_enable) {
1379 if (!handle->venc_set_meta_mode(pParam->bStoreMetaData)) {
1380 DEBUG_PRINT_ERROR("ERROR: set Metabuffer mode %d fail",
1381 pParam->bStoreMetaData);
1382 return OMX_ErrorUnsupportedSetting;
1383 }
1384 meta_mode_enable = pParam->bStoreMetaData;
1385 if (meta_mode_enable) {
1386 m_sInPortDef.nBufferCountActual = m_sInPortDef.nBufferCountMin;
1387 if (handle->venc_set_param(&m_sInPortDef,OMX_IndexParamPortDefinition) != true) {
1388 DEBUG_PRINT_ERROR("ERROR: venc_set_param input failed");
1389 return OMX_ErrorUnsupportedSetting;
1390 }
1391 } else {
1392 /*TODO: reset encoder driver Meta mode*/
1393 dev_get_buf_req (&m_sOutPortDef.nBufferCountMin,
1394 &m_sOutPortDef.nBufferCountActual,
1395 &m_sOutPortDef.nBufferSize,
1396 m_sOutPortDef.nPortIndex);
1397 }
1398 }
1399 } else if (pParam->nPortIndex == PORT_INDEX_OUT && secure_session) {
1400 DEBUG_PRINT_INFO("WARN: set_parameter: metamode is "
1401 "valid for input port only in secure session");
1402 return OMX_ErrorUnsupportedSetting;
1403 } else {
1404 DEBUG_PRINT_INFO("WARN: set_parameter: metamode is "
1405 "valid for input port only");
1406 eRet = OMX_ErrorUnsupportedIndex;
1407 }
1408 }
1409 break;
1410 #endif
1411 case OMX_QcomIndexParamIndexExtraDataType:
1412 {
1413 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_INDEXEXTRADATATYPE);
1414 DEBUG_PRINT_HIGH("set_parameter: OMX_QcomIndexParamIndexExtraDataType");
1415 QOMX_INDEXEXTRADATATYPE *pParam = (QOMX_INDEXEXTRADATATYPE *)paramData;
1416 bool enable = false;
1417 OMX_U32 mask = 0;
1418
1419 if (pParam->nIndex == (OMX_INDEXTYPE)OMX_ExtraDataVideoEncoderSliceInfo) {
1420 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1421 mask = VENC_EXTRADATA_SLICEINFO;
1422
1423 DEBUG_PRINT_HIGH("SliceInfo extradata %s",
1424 ((pParam->bEnabled == OMX_TRUE) ? "enabled" : "disabled"));
1425 } else {
1426 DEBUG_PRINT_ERROR("set_parameter: Slice information is "
1427 "valid for output port only");
1428 eRet = OMX_ErrorUnsupportedIndex;
1429 break;
1430 }
1431 } else if (pParam->nIndex == (OMX_INDEXTYPE)OMX_ExtraDataVideoEncoderMBInfo) {
1432 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1433 mask = VENC_EXTRADATA_MBINFO;
1434
1435 DEBUG_PRINT_HIGH("MBInfo extradata %s",
1436 ((pParam->bEnabled == OMX_TRUE) ? "enabled" : "disabled"));
1437 } else {
1438 DEBUG_PRINT_ERROR("set_parameter: MB information is "
1439 "valid for output port only");
1440 eRet = OMX_ErrorUnsupportedIndex;
1441 break;
1442 }
1443 } else if (pParam->nIndex == (OMX_INDEXTYPE)OMX_ExtraDataFrameDimension) {
1444 if (pParam->nPortIndex == PORT_INDEX_IN) {
1445 mask = VENC_EXTRADATA_FRAMEDIMENSION;
1446 DEBUG_PRINT_HIGH("Frame dimension extradata %s",
1447 ((pParam->bEnabled == OMX_TRUE) ? "enabled" : "disabled"));
1448 } else {
1449 DEBUG_PRINT_ERROR("set_parameter: Frame Dimension is "
1450 "valid for input port only");
1451 eRet = OMX_ErrorUnsupportedIndex;
1452 break;
1453 }
1454 } else if (pParam->nIndex == (OMX_INDEXTYPE)OMX_QTIIndexParamVQZipSEIExtraData) {
1455 if (pParam->nPortIndex == PORT_INDEX_IN) {
1456 mask = VENC_EXTRADATA_VQZIP;
1457 DEBUG_PRINT_HIGH("VQZIP extradata %s",
1458 ((pParam->bEnabled == OMX_TRUE) ? "enabled" : "disabled"));
1459 } else {
1460 DEBUG_PRINT_ERROR("set_parameter: VQZIP is "
1461 "valid for input port only");
1462 eRet = OMX_ErrorUnsupportedIndex;
1463 break;
1464 }
1465 } else if (pParam->nIndex == (OMX_INDEXTYPE)OMX_ExtraDataVideoLTRInfo) {
1466 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1467 if (pParam->bEnabled == OMX_TRUE)
1468 mask = VENC_EXTRADATA_LTRINFO;
1469
1470 DEBUG_PRINT_HIGH("LTRInfo extradata %s",
1471 ((pParam->bEnabled == OMX_TRUE) ? "enabled" : "disabled"));
1472 } else {
1473 DEBUG_PRINT_ERROR("set_parameter: LTR information is "
1474 "valid for output port only");
1475 eRet = OMX_ErrorUnsupportedIndex;
1476 break;
1477 }
1478 } else if (pParam->nIndex == (OMX_INDEXTYPE)OMX_QTIIndexParamVideoEnableRoiInfo) {
1479 if (pParam->nPortIndex == PORT_INDEX_IN) {
1480 if (pParam->bEnabled == OMX_TRUE)
1481 mask = VENC_EXTRADATA_ROI;
1482
1483 DEBUG_PRINT_HIGH("ROIInfo extradata %s",
1484 ((pParam->bEnabled == OMX_TRUE) ? "enabled" : "disabled"));
1485 } else {
1486 DEBUG_PRINT_ERROR("set_parameter: ROI information is "
1487 "valid for input port only");
1488 eRet = OMX_ErrorUnsupportedIndex;
1489 break;
1490 }
1491 } else {
1492 DEBUG_PRINT_ERROR("set_parameter: unsupported extrdata index (%x)",
1493 pParam->nIndex);
1494 eRet = OMX_ErrorUnsupportedIndex;
1495 break;
1496 }
1497
1498
1499 if (pParam->bEnabled == OMX_TRUE)
1500 m_sExtraData |= mask;
1501 else
1502 m_sExtraData &= ~mask;
1503
1504 enable = !!(m_sExtraData & mask);
1505 if (handle->venc_set_param(&enable,
1506 (OMX_INDEXTYPE)pParam->nIndex) != true) {
1507 DEBUG_PRINT_ERROR("ERROR: Setting Extradata (%x) failed", pParam->nIndex);
1508 return OMX_ErrorUnsupportedSetting;
1509 }
1510
1511 if (pParam->nPortIndex == PORT_INDEX_IN) {
1512 m_sInPortDef.nPortIndex = PORT_INDEX_IN;
1513 dev_get_buf_req(&m_sInPortDef.nBufferCountMin,
1514 &m_sInPortDef.nBufferCountActual,
1515 &m_sInPortDef.nBufferSize,
1516 m_sInPortDef.nPortIndex);
1517 DEBUG_PRINT_HIGH("updated in_buf_req: buffer cnt=%u, "
1518 "count min=%u, buffer size=%u",
1519 (unsigned int)m_sInPortDef.nBufferCountActual,
1520 (unsigned int)m_sInPortDef.nBufferCountMin,
1521 (unsigned int)m_sInPortDef.nBufferSize);
1522
1523 } else {
1524 m_sOutPortDef.nPortIndex = PORT_INDEX_OUT;
1525 dev_get_buf_req(&m_sOutPortDef.nBufferCountMin,
1526 &m_sOutPortDef.nBufferCountActual,
1527 &m_sOutPortDef.nBufferSize,
1528 m_sOutPortDef.nPortIndex);
1529 DEBUG_PRINT_HIGH("updated out_buf_req: buffer cnt=%u, "
1530 "count min=%u, buffer size=%u",
1531 (unsigned int)m_sOutPortDef.nBufferCountActual,
1532 (unsigned int)m_sOutPortDef.nBufferCountMin,
1533 (unsigned int)m_sOutPortDef.nBufferSize);
1534 }
1535 break;
1536 }
1537 case OMX_QTIIndexParamVideoClientExtradata:
1538 {
1539 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_EXTRADATA_ENABLE);
1540 DEBUG_PRINT_LOW("set_parameter: OMX_QTIIndexParamVideoClientExtradata");
1541 QOMX_EXTRADATA_ENABLE *pParam = (QOMX_EXTRADATA_ENABLE *)paramData;
1542
1543 if (m_state != OMX_StateLoaded) {
1544 DEBUG_PRINT_ERROR("Set Parameter called in Invalid state");
1545 return OMX_ErrorIncorrectStateOperation;
1546 }
1547
1548 if (pParam->nPortIndex == PORT_INDEX_EXTRADATA_OUT) {
1549 m_client_out_extradata_info.enable_client_extradata(pParam->bEnable);
1550 } else if (pParam->nPortIndex == PORT_INDEX_EXTRADATA_IN) {
1551 m_client_in_extradata_info.enable_client_extradata(pParam->bEnable);
1552 } else {
1553 DEBUG_PRINT_ERROR("Incorrect portIndex - %d", pParam->nPortIndex);
1554 eRet = OMX_ErrorUnsupportedIndex;
1555 }
1556 break;
1557 }
1558 case QOMX_IndexParamVideoLTRCount:
1559 {
1560 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_VIDEO_PARAM_LTRCOUNT_TYPE);
1561 QOMX_VIDEO_PARAM_LTRCOUNT_TYPE* pParam =
1562 (QOMX_VIDEO_PARAM_LTRCOUNT_TYPE*)paramData;
1563 if (!handle->venc_set_param(paramData, (OMX_INDEXTYPE)QOMX_IndexParamVideoLTRCount)) {
1564 DEBUG_PRINT_ERROR("ERROR: Setting LTR count failed");
1565 return OMX_ErrorUnsupportedSetting;
1566 }
1567 memcpy(&m_sParamLTRCount, pParam, sizeof(m_sParamLTRCount));
1568 break;
1569 }
1570 case OMX_QcomIndexParamVideoMaxAllowedBitrateCheck:
1571 {
1572 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_EXTNINDEX_PARAMTYPE);
1573 QOMX_EXTNINDEX_PARAMTYPE* pParam =
1574 (QOMX_EXTNINDEX_PARAMTYPE*)paramData;
1575 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1576 handle->m_max_allowed_bitrate_check =
1577 ((pParam->bEnable == OMX_TRUE) ? true : false);
1578 DEBUG_PRINT_HIGH("set_parameter: max allowed bitrate check %s",
1579 ((pParam->bEnable == OMX_TRUE) ? "enabled" : "disabled"));
1580 } else {
1581 DEBUG_PRINT_ERROR("ERROR: OMX_QcomIndexParamVideoMaxAllowedBitrateCheck "
1582 " called on wrong port(%u)", (unsigned int)pParam->nPortIndex);
1583 return OMX_ErrorBadPortIndex;
1584 }
1585 break;
1586 }
1587 case OMX_QcomIndexEnableSliceDeliveryMode:
1588 {
1589 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_EXTNINDEX_PARAMTYPE);
1590 QOMX_EXTNINDEX_PARAMTYPE* pParam =
1591 (QOMX_EXTNINDEX_PARAMTYPE*)paramData;
1592 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1593 if (!handle->venc_set_param(paramData,
1594 (OMX_INDEXTYPE)OMX_QcomIndexEnableSliceDeliveryMode)) {
1595 DEBUG_PRINT_ERROR("ERROR: Request for setting slice delivery mode failed");
1596 return OMX_ErrorUnsupportedSetting;
1597 }
1598 } else {
1599 DEBUG_PRINT_ERROR("ERROR: OMX_QcomIndexEnableSliceDeliveryMode "
1600 "called on wrong port(%u)", (unsigned int)pParam->nPortIndex);
1601 return OMX_ErrorBadPortIndex;
1602 }
1603 break;
1604 }
1605 case OMX_QcomIndexParamSequenceHeaderWithIDR:
1606 {
1607 VALIDATE_OMX_PARAM_DATA(paramData, PrependSPSPPSToIDRFramesParams);
1608 if(!handle->venc_set_param(paramData,
1609 (OMX_INDEXTYPE)OMX_QcomIndexParamSequenceHeaderWithIDR)) {
1610 DEBUG_PRINT_ERROR("%s: %s",
1611 "OMX_QComIndexParamSequenceHeaderWithIDR:",
1612 "request for inband sps/pps failed.");
1613 return OMX_ErrorUnsupportedSetting;
1614 }
1615 memcpy(&m_sPrependSPSPPS, paramData, sizeof(m_sPrependSPSPPS));
1616 break;
1617 }
1618 case OMX_QcomIndexParamAUDelimiter:
1619 {
1620 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QCOM_VIDEO_CONFIG_AUD);
1621 if(!handle->venc_set_param(paramData,
1622 (OMX_INDEXTYPE)OMX_QcomIndexParamAUDelimiter)) {
1623 DEBUG_PRINT_ERROR("%s: %s",
1624 "OMX_QComIndexParamAUDelimiter:",
1625 "request for AU Delimiters failed.");
1626 return OMX_ErrorUnsupportedSetting;
1627 }
1628 break;
1629 }
1630 case OMX_QcomIndexHierarchicalStructure:
1631 {
1632 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_VIDEO_HIERARCHICALLAYERS);
1633 QOMX_VIDEO_HIERARCHICALLAYERS* pParam =
1634 (QOMX_VIDEO_HIERARCHICALLAYERS*)paramData;
1635 DEBUG_PRINT_LOW("OMX_QcomIndexHierarchicalStructure");
1636 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1637 if (!handle->venc_set_param(paramData,
1638 (OMX_INDEXTYPE)OMX_QcomIndexHierarchicalStructure)) {
1639 DEBUG_PRINT_ERROR("ERROR: Request for setting PlusPType failed");
1640 return OMX_ErrorUnsupportedSetting;
1641 }
1642 if((pParam->eHierarchicalCodingType == QOMX_HIERARCHICALCODING_B) && pParam->nNumLayers)
1643 hier_b_enabled = true;
1644 m_sHierLayers.nNumLayers = pParam->nNumLayers;
1645 m_sHierLayers.eHierarchicalCodingType = pParam->eHierarchicalCodingType;
1646 } else {
1647 DEBUG_PRINT_ERROR("ERROR: OMX_QcomIndexHierarchicalStructure called on wrong port(%u)",
1648 (unsigned int)pParam->nPortIndex);
1649 return OMX_ErrorBadPortIndex;
1650 }
1651 break;
1652
1653 }
1654 case OMX_QcomIndexParamH264VUITimingInfo:
1655 {
1656 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QCOM_VIDEO_PARAM_VUI_TIMING_INFO);
1657 if (!handle->venc_set_param(paramData,
1658 (OMX_INDEXTYPE) OMX_QcomIndexParamH264VUITimingInfo)) {
1659 DEBUG_PRINT_ERROR("ERROR: Setting VUI timing info");
1660 return OMX_ErrorUnsupportedSetting;
1661 }
1662 break;
1663 }
1664 case OMX_QcomIndexParamPeakBitrate:
1665 {
1666 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QCOM_VIDEO_PARAM_PEAK_BITRATE);
1667 if (!handle->venc_set_param(paramData,
1668 (OMX_INDEXTYPE) OMX_QcomIndexParamPeakBitrate)) {
1669 DEBUG_PRINT_ERROR("ERROR: Setting peak bitrate");
1670 return OMX_ErrorUnsupportedSetting;
1671 }
1672 break;
1673 }
1674 case OMX_QcomIndexParamSetMVSearchrange:
1675 {
1676 if (!handle->venc_set_param(paramData,
1677 (OMX_INDEXTYPE) OMX_QcomIndexParamSetMVSearchrange)) {
1678 DEBUG_PRINT_ERROR("ERROR: Setting Searchrange");
1679 return OMX_ErrorUnsupportedSetting;
1680 }
1681 break;
1682 }
1683 case OMX_QcomIndexParamBatchSize:
1684 {
1685 VALIDATE_OMX_PARAM_DATA(paramData, OMX_PARAM_U32TYPE);
1686 if(!handle->venc_set_param(paramData,
1687 (OMX_INDEXTYPE)OMX_QcomIndexParamBatchSize)) {
1688 DEBUG_PRINT_ERROR("Attempting to set batch size failed");
1689 return OMX_ErrorUnsupportedSetting;
1690 }
1691 break;
1692 }
1693 case OMX_QcomIndexConfigH264EntropyCodingCabac:
1694 {
1695 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_VIDEO_H264ENTROPYCODINGTYPE);
1696 if(!handle->venc_set_param(paramData,
1697 (OMX_INDEXTYPE)OMX_QcomIndexConfigH264EntropyCodingCabac)) {
1698 DEBUG_PRINT_ERROR("Attempting to set Entropy failed");
1699 return OMX_ErrorUnsupportedSetting;
1700 }
1701 break;
1702 }
1703 case OMX_QTIIndexParamVQZIPSEIType:
1704 {
1705 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QTI_VIDEO_PARAM_VQZIP_SEI_TYPE);
1706 if (!handle->venc_set_param(paramData,
1707 (OMX_INDEXTYPE) OMX_QTIIndexParamVQZIPSEIType)) {
1708 DEBUG_PRINT_ERROR("ERROR: Setting VQZIP SEI type");
1709 return OMX_ErrorUnsupportedSetting;
1710 }
1711 m_sExtraData |= VENC_EXTRADATA_VQZIP;
1712 break;
1713 }
1714 case OMX_QcomIndexParamVencAspectRatio:
1715 {
1716 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_EXTNINDEX_VIDEO_VENC_SAR);
1717 if (!handle->venc_set_param(paramData,
1718 (OMX_INDEXTYPE)OMX_QcomIndexParamVencAspectRatio)) {
1719 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QcomIndexParamVencAspectRatio failed");
1720 return OMX_ErrorUnsupportedSetting;
1721 }
1722 memcpy(&m_sSar, paramData, sizeof(m_sSar));
1723 break;
1724 }
1725 case OMX_QTIIndexParamVideoEnableRoiInfo:
1726 {
1727 if (!handle->venc_set_param(paramData,
1728 (OMX_INDEXTYPE)OMX_QTIIndexParamVideoEnableRoiInfo)) {
1729 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QTIIndexParamVideoEnableRoiInfo failed");
1730 return OMX_ErrorUnsupportedSetting;
1731 }
1732 m_sExtraData |= VENC_EXTRADATA_ROI;
1733 break;
1734 }
1735 case OMX_IndexParamAndroidVideoTemporalLayering:
1736 {
1737 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_ANDROID_TEMPORALLAYERINGTYPE);
1738 if (!handle->venc_set_param(paramData,
1739 (OMX_INDEXTYPE)OMX_IndexParamAndroidVideoTemporalLayering)) {
1740 DEBUG_PRINT_ERROR("Failed to configure temporal layers");
1741 return OMX_ErrorUnsupportedSetting;
1742 }
1743 // save the actual configuration applied
1744 memcpy(&m_sParamTemporalLayers, paramData, sizeof(m_sParamTemporalLayers));
1745 // keep the config data in sync
1746 m_sConfigTemporalLayers.ePattern = m_sParamTemporalLayers.ePattern;
1747 m_sConfigTemporalLayers.nBLayerCountActual = m_sParamTemporalLayers.nBLayerCountActual;
1748 m_sConfigTemporalLayers.nPLayerCountActual = m_sParamTemporalLayers.nPLayerCountActual;
1749 m_sConfigTemporalLayers.bBitrateRatiosSpecified = m_sParamTemporalLayers.bBitrateRatiosSpecified;
1750 memcpy(&m_sConfigTemporalLayers.nBitrateRatios[0],
1751 &m_sParamTemporalLayers.nBitrateRatios[0],
1752 OMX_VIDEO_ANDROID_MAXTEMPORALLAYERS * sizeof(OMX_U32));
1753 break;
1754 }
1755 case OMX_QTIIndexParamDisablePQ:
1756 {
1757 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_DISABLETYPE);
1758 handle->venc_set_param(paramData,
1759 (OMX_INDEXTYPE)OMX_QTIIndexParamDisablePQ);
1760 break;
1761 }
1762 case OMX_QTIIndexParamIframeSizeType:
1763 {
1764 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_VIDEO_IFRAMESIZE);
1765 if (!handle->venc_set_param(paramData,
1766 (OMX_INDEXTYPE)OMX_QTIIndexParamIframeSizeType)) {
1767 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QTIIndexParamIframeSizeType failed");
1768 return OMX_ErrorUnsupportedSetting;
1769 }
1770 break;
1771 }
1772 case OMX_QTIIndexParamEnableAVTimerTimestamps:
1773 {
1774 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_ENABLETYPE);
1775 if (!handle->venc_set_param(paramData,
1776 (OMX_INDEXTYPE)OMX_QTIIndexParamEnableAVTimerTimestamps)) {
1777 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QTIIndexParamEnableAVTimerTimestamps failed");
1778 return OMX_ErrorUnsupportedSetting;
1779 }
1780 memcpy(&m_sParamAVTimerTimestampMode, paramData, sizeof(QOMX_ENABLETYPE));
1781 break;
1782 }
1783 case OMX_QcomIndexParamVideoDownScalar:
1784 {
1785 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_INDEXDOWNSCALAR);
1786 if(!handle->venc_set_param(paramData,
1787 (OMX_INDEXTYPE)OMX_QcomIndexParamVideoDownScalar)) {
1788 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QcomIndexParamVideodownscalar failed");
1789 return OMX_ErrorUnsupportedSetting;
1790 }
1791 memcpy(&m_sParamDownScalar, paramData, sizeof(QOMX_INDEXDOWNSCALAR));
1792 break;
1793 }
1794 case OMX_QcomIndexParamVencControlInputQueue:
1795 {
1796 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_ENABLETYPE);
1797 memcpy(&m_sParamControlInputQueue, paramData, sizeof(QOMX_ENABLETYPE));
1798 break;
1799 }
1800 case OMX_QTIIndexParamLowLatencyMode:
1801 {
1802 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_EXTNINDEX_VIDEO_LOW_LATENCY_MODE);
1803 if (!handle->venc_set_param(paramData,
1804 (OMX_INDEXTYPE)OMX_QTIIndexParamLowLatencyMode)) {
1805 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QTIIndexParamLowLatencyMode failed");
1806 return OMX_ErrorUnsupportedSetting;
1807 }
1808 memcpy(&m_sParamLowLatency, paramData, sizeof(QOMX_EXTNINDEX_VIDEO_LOW_LATENCY_MODE));
1809 break;
1810 }
1811 case OMX_QTIIndexParamColorSpaceConversion:
1812 {
1813 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_ENABLETYPE);
1814 if (!handle->venc_set_param(paramData,
1815 (OMX_INDEXTYPE)OMX_QTIIndexParamColorSpaceConversion)) {
1816 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QTIIndexParamColorSpaceConversion failed");
1817 return OMX_ErrorUnsupportedSetting;
1818 }
1819 memcpy(&m_sParamColorSpaceConversion, paramData, sizeof(QOMX_ENABLETYPE));
1820 break;
1821 }
1822 case OMX_QTIIndexParamEnableLinearColorFormat:
1823 {
1824 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_ENABLETYPE);
1825 if (!handle->venc_set_param(paramData,
1826 (OMX_INDEXTYPE)OMX_QTIIndexParamEnableLinearColorFormat)) {
1827 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QTIIndexParamEnableLinearColorFormat failed");
1828 return OMX_ErrorUnsupportedSetting;
1829 }
1830 memcpy(&m_sParamLinearColorFormat, paramData, sizeof(QOMX_ENABLETYPE));
1831 break;
1832 }
1833 case OMX_QTIIndexParamVideoEnableBlur:
1834 {
1835 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QTI_VIDEO_CONFIG_BLURINFO);
1836 if (!handle->venc_set_param(paramData,
1837 (OMX_INDEXTYPE)OMX_QTIIndexParamVideoEnableBlur)) {
1838 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QTIIndexParamVideoEnableBlur failed");
1839 return OMX_ErrorUnsupportedSetting;
1840 }
1841 memcpy(&m_blurInfo, paramData, sizeof(OMX_QTI_VIDEO_CONFIG_BLURINFO));
1842 break;
1843 }
1844 case OMX_QTIIndexParamNativeRecorder:
1845 {
1846 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_ENABLETYPE);
1847 if (!handle->venc_set_param(paramData,
1848 (OMX_INDEXTYPE)OMX_QTIIndexParamNativeRecorder)) {
1849 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QTIIndexParamNativeRecorder failed");
1850 return OMX_ErrorUnsupportedSetting;
1851 }
1852 memcpy(&m_sParamNativeRecorder, paramData, sizeof(QOMX_ENABLETYPE));
1853 break;
1854 }
1855 case OMX_IndexParamVideoSliceFMO:
1856 default:
1857 {
1858 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown param %d", paramIndex);
1859 eRet = OMX_ErrorUnsupportedIndex;
1860 break;
1861 }
1862 }
1863 return eRet;
1864 }
1865
update_profile_level()1866 bool omx_venc::update_profile_level()
1867 {
1868 OMX_U32 eProfile, eLevel;
1869
1870 if (!handle->venc_get_profile_level(&eProfile,&eLevel)) {
1871 DEBUG_PRINT_INFO("WARN: Failed to update the profile_level");
1872 return false;
1873 }
1874
1875 m_sParamProfileLevel.eProfile = (OMX_VIDEO_AVCPROFILETYPE)eProfile;
1876 m_sParamProfileLevel.eLevel = (OMX_VIDEO_AVCLEVELTYPE)eLevel;
1877
1878 if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc",\
1879 OMX_MAX_STRINGNAME_SIZE)) {
1880 m_sParamAVC.eProfile = (OMX_VIDEO_AVCPROFILETYPE)eProfile;
1881 m_sParamAVC.eLevel = (OMX_VIDEO_AVCLEVELTYPE)eLevel;
1882 DEBUG_PRINT_LOW("AVC profile = %d, level = %d", m_sParamAVC.eProfile,
1883 m_sParamAVC.eLevel);
1884 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc.secure",\
1885 OMX_MAX_STRINGNAME_SIZE)) {
1886 m_sParamAVC.eProfile = (OMX_VIDEO_AVCPROFILETYPE)eProfile;
1887 m_sParamAVC.eLevel = (OMX_VIDEO_AVCLEVELTYPE)eLevel;
1888 DEBUG_PRINT_LOW("\n AVC profile = %d, level = %d", m_sParamAVC.eProfile,
1889 m_sParamAVC.eLevel);
1890 }
1891 else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.vp8",\
1892 OMX_MAX_STRINGNAME_SIZE)) {
1893 m_sParamVP8.eProfile = (OMX_VIDEO_VP8PROFILETYPE)eProfile;
1894 m_sParamVP8.eLevel = (OMX_VIDEO_VP8LEVELTYPE)eLevel;
1895 DEBUG_PRINT_LOW("VP8 profile = %d, level = %d", m_sParamVP8.eProfile,
1896 m_sParamVP8.eLevel);
1897 }
1898 else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.hevc",\
1899 OMX_MAX_STRINGNAME_SIZE) ||
1900 !strncmp((char *)m_nkind, "OMX.qcom.video.encoder.heic",\
1901 OMX_MAX_STRINGNAME_SIZE)) {
1902 m_sParamHEVC.eProfile = (OMX_VIDEO_HEVCPROFILETYPE)eProfile;
1903 m_sParamHEVC.eLevel = (OMX_VIDEO_HEVCLEVELTYPE)eLevel;
1904 DEBUG_PRINT_LOW("HEVC profile = %d, level = %d", m_sParamHEVC.eProfile,
1905 m_sParamHEVC.eLevel);
1906 }
1907
1908 return true;
1909 }
1910 /* ======================================================================
1911 FUNCTION
1912 omx_video::SetConfig
1913
1914 DESCRIPTION
1915 OMX Set Config method implementation
1916
1917 PARAMETERS
1918 <TBD>.
1919
1920 RETURN VALUE
1921 OMX Error None if successful.
1922 ========================================================================== */
set_config(OMX_IN OMX_HANDLETYPE hComp,OMX_IN OMX_INDEXTYPE configIndex,OMX_IN OMX_PTR configData)1923 OMX_ERRORTYPE omx_venc::set_config(OMX_IN OMX_HANDLETYPE hComp,
1924 OMX_IN OMX_INDEXTYPE configIndex,
1925 OMX_IN OMX_PTR configData)
1926 {
1927 (void)hComp;
1928 if (configData == NULL) {
1929 DEBUG_PRINT_ERROR("ERROR: param is null");
1930 return OMX_ErrorBadParameter;
1931 }
1932
1933 if (m_state == OMX_StateInvalid) {
1934 DEBUG_PRINT_ERROR("ERROR: config called in Invalid state");
1935 return OMX_ErrorIncorrectStateOperation;
1936 }
1937
1938 if (reject_config_for_TME_mode(configIndex)) {
1939 DEBUG_PRINT_ERROR("ERROR: config 0x%x rejected in TME mode", configIndex);
1940 return OMX_ErrorNone;
1941 }
1942
1943 // params will be validated prior to venc_init
1944 switch ((int)configIndex) {
1945 case OMX_IndexConfigVideoBitrate:
1946 {
1947 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_CONFIG_BITRATETYPE);
1948 OMX_VIDEO_CONFIG_BITRATETYPE* pParam =
1949 reinterpret_cast<OMX_VIDEO_CONFIG_BITRATETYPE*>(configData);
1950 DEBUG_PRINT_HIGH("set_config(): OMX_IndexConfigVideoBitrate (%u)", (unsigned int)pParam->nEncodeBitrate);
1951
1952 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1953 if (handle->venc_set_config(configData, OMX_IndexConfigVideoBitrate) != true) {
1954 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigVideoBitrate failed");
1955 return OMX_ErrorUnsupportedSetting;
1956 }
1957
1958 m_sConfigBitrate.nEncodeBitrate = pParam->nEncodeBitrate;
1959 m_sParamBitrate.nTargetBitrate = pParam->nEncodeBitrate;
1960 m_sOutPortDef.format.video.nBitrate = pParam->nEncodeBitrate;
1961 } else {
1962 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", (unsigned int)pParam->nPortIndex);
1963 return OMX_ErrorBadPortIndex;
1964 }
1965 break;
1966 }
1967 case OMX_IndexConfigVideoFramerate:
1968 {
1969 VALIDATE_OMX_PARAM_DATA(configData, OMX_CONFIG_FRAMERATETYPE);
1970 OMX_CONFIG_FRAMERATETYPE* pParam =
1971 reinterpret_cast<OMX_CONFIG_FRAMERATETYPE*>(configData);
1972 DEBUG_PRINT_HIGH("set_config(): OMX_IndexConfigVideoFramerate (0x%x)", (unsigned int)pParam->xEncodeFramerate);
1973
1974 if (pParam->nPortIndex == PORT_INDEX_OUT) {
1975 if (handle->venc_set_config(configData, OMX_IndexConfigVideoFramerate) != true) {
1976 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigVideoFramerate failed");
1977 return OMX_ErrorUnsupportedSetting;
1978 }
1979
1980 m_sConfigFramerate.xEncodeFramerate = pParam->xEncodeFramerate;
1981 m_sOutPortDef.format.video.xFramerate = pParam->xEncodeFramerate;
1982 m_sOutPortFormat.xFramerate = pParam->xEncodeFramerate;
1983 /*
1984 * Frame rate can change buffer requirements. If query is not allowed,
1985 * failure is not FATAL here.
1986 */
1987 dev_get_buf_req(&m_sInPortDef.nBufferCountMin,
1988 &m_sInPortDef.nBufferCountActual,
1989 &m_sInPortDef.nBufferSize,
1990 m_sInPortDef.nPortIndex);
1991 } else {
1992 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", (unsigned int)pParam->nPortIndex);
1993 return OMX_ErrorBadPortIndex;
1994 }
1995
1996 break;
1997 }
1998 case QOMX_IndexConfigVideoIntraperiod:
1999 {
2000 VALIDATE_OMX_PARAM_DATA(configData, QOMX_VIDEO_INTRAPERIODTYPE);
2001 QOMX_VIDEO_INTRAPERIODTYPE* pParam =
2002 reinterpret_cast<QOMX_VIDEO_INTRAPERIODTYPE*>(configData);
2003
2004 DEBUG_PRINT_HIGH("set_config(): QOMX_IndexConfigVideoIntraperiod");
2005 if (pParam->nPortIndex == PORT_INDEX_OUT) {
2006 DEBUG_PRINT_HIGH("Old: P/B frames = %u/%u, New: P/B frames = %u/%u",
2007 (unsigned int)m_sIntraperiod.nPFrames, (unsigned int)m_sIntraperiod.nBFrames,
2008 (unsigned int)pParam->nPFrames, (unsigned int)pParam->nBFrames);
2009 if (m_sIntraperiod.nBFrames != pParam->nBFrames) {
2010 if(hier_b_enabled && m_state == OMX_StateLoaded) {
2011 DEBUG_PRINT_INFO("B-frames setting is supported if HierB is enabled");
2012 }
2013 }
2014 if (handle->venc_set_config(configData, (OMX_INDEXTYPE) QOMX_IndexConfigVideoIntraperiod) != true) {
2015 DEBUG_PRINT_ERROR("ERROR: Setting QOMX_IndexConfigVideoIntraperiod failed");
2016 return OMX_ErrorUnsupportedSetting;
2017 }
2018 m_sIntraperiod.nPFrames = pParam->nPFrames;
2019 m_sIntraperiod.nBFrames = pParam->nBFrames;
2020 m_sIntraperiod.nIDRPeriod = pParam->nIDRPeriod;
2021
2022 m_sParamAVC.nPFrames = pParam->nPFrames;
2023 if ((m_sParamAVC.eProfile != OMX_VIDEO_AVCProfileBaseline) &&
2024 (m_sParamAVC.eProfile != (OMX_VIDEO_AVCPROFILETYPE) QOMX_VIDEO_AVCProfileConstrainedBaseline))
2025 m_sParamAVC.nBFrames = pParam->nBFrames;
2026 else
2027 m_sParamAVC.nBFrames = 0;
2028 } else {
2029 DEBUG_PRINT_ERROR("ERROR: (QOMX_IndexConfigVideoIntraperiod) Unsupported port index: %u", (unsigned int)pParam->nPortIndex);
2030 return OMX_ErrorBadPortIndex;
2031 }
2032
2033 break;
2034 }
2035
2036 case OMX_IndexConfigVideoIntraVOPRefresh:
2037 {
2038 VALIDATE_OMX_PARAM_DATA(configData, OMX_CONFIG_INTRAREFRESHVOPTYPE);
2039 OMX_CONFIG_INTRAREFRESHVOPTYPE* pParam =
2040 reinterpret_cast<OMX_CONFIG_INTRAREFRESHVOPTYPE*>(configData);
2041
2042 DEBUG_PRINT_HIGH("set_config(): OMX_IndexConfigVideoIntraVOPRefresh");
2043 if (pParam->nPortIndex == PORT_INDEX_OUT) {
2044 if (handle->venc_set_config(configData,
2045 OMX_IndexConfigVideoIntraVOPRefresh) != true) {
2046 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigVideoIntraVOPRefresh failed");
2047 return OMX_ErrorUnsupportedSetting;
2048 }
2049
2050 m_sConfigIntraRefreshVOP.IntraRefreshVOP = pParam->IntraRefreshVOP;
2051 } else {
2052 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", (unsigned int)pParam->nPortIndex);
2053 return OMX_ErrorBadPortIndex;
2054 }
2055
2056 break;
2057 }
2058 case OMX_IndexConfigCommonMirror:
2059 {
2060 VALIDATE_OMX_PARAM_DATA(configData, OMX_CONFIG_MIRRORTYPE);
2061 OMX_CONFIG_MIRRORTYPE *pParam = reinterpret_cast<OMX_CONFIG_MIRRORTYPE*>(configData);
2062
2063 if (pParam->nPortIndex != PORT_INDEX_OUT) {
2064 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", (unsigned int)pParam->nPortIndex);
2065 return OMX_ErrorBadPortIndex;
2066 }
2067 if (handle->venc_set_config(configData,OMX_IndexConfigCommonMirror) != true) {
2068 DEBUG_PRINT_ERROR("ERROR: Set OMX_IndexConfigCommonMirror failed");
2069 return OMX_ErrorUnsupportedSetting;
2070 }
2071 m_sConfigFrameMirror.eMirror = pParam->eMirror;
2072 break;
2073 }
2074 case OMX_IndexConfigCommonRotate:
2075 {
2076 VALIDATE_OMX_PARAM_DATA(configData, OMX_CONFIG_ROTATIONTYPE);
2077 OMX_CONFIG_ROTATIONTYPE *pParam =
2078 reinterpret_cast<OMX_CONFIG_ROTATIONTYPE*>(configData);
2079
2080 if (pParam->nPortIndex != PORT_INDEX_OUT) {
2081 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", (unsigned int)pParam->nPortIndex);
2082 return OMX_ErrorBadPortIndex;
2083 }
2084 if ( pParam->nRotation == 0 ||
2085 pParam->nRotation == 90 ||
2086 pParam->nRotation == 180 ||
2087 pParam->nRotation == 270 ) {
2088 DEBUG_PRINT_HIGH("set_config: Rotation Angle %u", (unsigned int)pParam->nRotation);
2089 } else {
2090 DEBUG_PRINT_ERROR("ERROR: un supported Rotation %u", (unsigned int)pParam->nRotation);
2091 return OMX_ErrorUnsupportedSetting;
2092 }
2093
2094 if (handle->venc_set_config(configData,
2095 OMX_IndexConfigCommonRotate) != true) {
2096 DEBUG_PRINT_ERROR("ERROR: Set OMX_IndexConfigCommonRotate failed");
2097 return OMX_ErrorUnsupportedSetting;
2098 }
2099 m_sConfigFrameRotation.nRotation = pParam->nRotation;
2100 break;
2101 }
2102 case OMX_QcomIndexConfigVideoFramePackingArrangement:
2103 {
2104 DEBUG_PRINT_HIGH("set_config(): OMX_QcomIndexConfigVideoFramePackingArrangement");
2105 if (m_sOutPortFormat.eCompressionFormat == OMX_VIDEO_CodingAVC) {
2106 VALIDATE_OMX_PARAM_DATA(configData, OMX_QCOM_FRAME_PACK_ARRANGEMENT);
2107 OMX_QCOM_FRAME_PACK_ARRANGEMENT *configFmt =
2108 (OMX_QCOM_FRAME_PACK_ARRANGEMENT *) configData;
2109 } else {
2110 DEBUG_PRINT_ERROR("ERROR: FramePackingData not supported for non AVC compression");
2111 }
2112 break;
2113 }
2114 case OMX_IndexConfigVideoVp8ReferenceFrame:
2115 {
2116 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_VP8REFERENCEFRAMETYPE);
2117 OMX_VIDEO_VP8REFERENCEFRAMETYPE* pParam = (OMX_VIDEO_VP8REFERENCEFRAMETYPE*) configData;
2118 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE) OMX_IndexConfigVideoVp8ReferenceFrame)) {
2119 DEBUG_PRINT_ERROR("ERROR: Setting VP8 reference frame");
2120 return OMX_ErrorUnsupportedSetting;
2121 }
2122 memcpy(&m_sConfigVp8ReferenceFrame, pParam, sizeof(m_sConfigVp8ReferenceFrame));
2123 break;
2124 }
2125
2126 case QOMX_IndexConfigVideoLTRUse:
2127 {
2128 VALIDATE_OMX_PARAM_DATA(configData, QOMX_VIDEO_CONFIG_LTRUSE_TYPE);
2129 QOMX_VIDEO_CONFIG_LTRUSE_TYPE* pParam = (QOMX_VIDEO_CONFIG_LTRUSE_TYPE*)configData;
2130 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)QOMX_IndexConfigVideoLTRUse)) {
2131 DEBUG_PRINT_ERROR("ERROR: Setting LTR use failed");
2132 return OMX_ErrorUnsupportedSetting;
2133 }
2134 memcpy(&m_sConfigLTRUse, pParam, sizeof(m_sConfigLTRUse));
2135 break;
2136 }
2137 case QOMX_IndexConfigVideoLTRMark:
2138 {
2139 VALIDATE_OMX_PARAM_DATA(configData, QOMX_VIDEO_CONFIG_LTRMARK_TYPE);
2140 QOMX_VIDEO_CONFIG_LTRMARK_TYPE* pParam = (QOMX_VIDEO_CONFIG_LTRMARK_TYPE*)configData;
2141 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)QOMX_IndexConfigVideoLTRMark)) {
2142 DEBUG_PRINT_ERROR("ERROR: Setting LTR mark failed");
2143 return OMX_ErrorUnsupportedSetting;
2144 }
2145 break;
2146 }
2147 case OMX_IndexConfigVideoAVCIntraPeriod:
2148 {
2149 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_CONFIG_AVCINTRAPERIOD);
2150 OMX_VIDEO_CONFIG_AVCINTRAPERIOD *pParam = (OMX_VIDEO_CONFIG_AVCINTRAPERIOD*) configData;
2151 DEBUG_PRINT_LOW("set_config: OMX_IndexConfigVideoAVCIntraPeriod");
2152 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)OMX_IndexConfigVideoAVCIntraPeriod)) {
2153 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigVideoAVCIntraPeriod failed");
2154 return OMX_ErrorUnsupportedSetting;
2155 }
2156 memcpy(&m_sConfigAVCIDRPeriod, pParam, sizeof(m_sConfigAVCIDRPeriod));
2157 break;
2158 }
2159 case OMX_IndexConfigCommonDeinterlace:
2160 {
2161 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_CONFIG_DEINTERLACE);
2162 OMX_VIDEO_CONFIG_DEINTERLACE *pParam = (OMX_VIDEO_CONFIG_DEINTERLACE*) configData;
2163 DEBUG_PRINT_LOW("set_config: OMX_IndexConfigCommonDeinterlace");
2164 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)OMX_IndexConfigCommonDeinterlace)) {
2165 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigCommonDeinterlace failed");
2166 return OMX_ErrorUnsupportedSetting;
2167 }
2168 memcpy(&m_sConfigDeinterlace, pParam, sizeof(m_sConfigDeinterlace));
2169 break;
2170 }
2171 case OMX_QcomIndexConfigNumHierPLayers:
2172 {
2173 VALIDATE_OMX_PARAM_DATA(configData, QOMX_EXTNINDEX_VIDEO_HIER_P_LAYERS);
2174 QOMX_EXTNINDEX_VIDEO_HIER_P_LAYERS* pParam =
2175 (QOMX_EXTNINDEX_VIDEO_HIER_P_LAYERS*)configData;
2176 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)OMX_QcomIndexConfigNumHierPLayers)) {
2177 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QcomIndexConfigNumHierPLayers failed");
2178 return OMX_ErrorUnsupportedSetting;
2179 }
2180 memcpy(&m_sHPlayers, pParam, sizeof(m_sHPlayers));
2181 break;
2182 }
2183 case OMX_QcomIndexConfigBaseLayerId:
2184 {
2185 VALIDATE_OMX_PARAM_DATA(configData, OMX_SKYPE_VIDEO_CONFIG_BASELAYERPID);
2186 OMX_SKYPE_VIDEO_CONFIG_BASELAYERPID* pParam =
2187 (OMX_SKYPE_VIDEO_CONFIG_BASELAYERPID*) configData;
2188 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)OMX_QcomIndexConfigBaseLayerId)) {
2189 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QcomIndexConfigBaseLayerId failed");
2190 return OMX_ErrorUnsupportedSetting;
2191 }
2192 memcpy(&m_sBaseLayerID, pParam, sizeof(m_sBaseLayerID));
2193 break;
2194 }
2195 case OMX_QcomIndexConfigQp:
2196 {
2197 VALIDATE_OMX_PARAM_DATA(configData, OMX_SKYPE_VIDEO_CONFIG_QP);
2198 OMX_SKYPE_VIDEO_CONFIG_QP* pParam =
2199 (OMX_SKYPE_VIDEO_CONFIG_QP*) configData;
2200 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)OMX_QcomIndexConfigQp)) {
2201 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QcomIndexConfigQp failed");
2202 return OMX_ErrorUnsupportedSetting;
2203 }
2204 memcpy(&m_sConfigQP, pParam, sizeof(m_sConfigQP));
2205 break;
2206 }
2207 case OMX_IndexConfigPriority:
2208 {
2209 VALIDATE_OMX_PARAM_DATA(configData, OMX_PARAM_U32TYPE);
2210 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_IndexConfigPriority)) {
2211 DEBUG_PRINT_ERROR("Failed to set OMX_IndexConfigPriority");
2212 return OMX_ErrorUnsupportedSetting;
2213 }
2214 break;
2215 }
2216 case OMX_IndexConfigOperatingRate:
2217 {
2218 VALIDATE_OMX_PARAM_DATA(configData, OMX_PARAM_U32TYPE);
2219 OMX_PARAM_U32TYPE* pParam = (OMX_PARAM_U32TYPE*) configData;
2220 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_IndexConfigOperatingRate)) {
2221 DEBUG_PRINT_ERROR("Failed to set OMX_IndexConfigOperatingRate %u", pParam->nU32 >> 16);
2222 return handle->hw_overload ? OMX_ErrorInsufficientResources :
2223 OMX_ErrorUnsupportedSetting;
2224 }
2225 m_nOperatingRate = pParam->nU32;
2226 break;
2227 }
2228 case OMX_QTIIndexConfigVideoRoiInfo:
2229 {
2230 VALIDATE_OMX_PARAM_DATA(configData, OMX_QTI_VIDEO_CONFIG_ROIINFO);
2231 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_QTIIndexConfigVideoRoiInfo)) {
2232 DEBUG_PRINT_ERROR("Failed to set OMX_QTIIndexConfigVideoRoiInfo");
2233 return OMX_ErrorUnsupportedSetting;
2234 }
2235 break;
2236 }
2237 case OMX_IndexConfigTimePosition:
2238 {
2239 OMX_TIME_CONFIG_TIMESTAMPTYPE* pParam =
2240 (OMX_TIME_CONFIG_TIMESTAMPTYPE*) configData;
2241 unsigned long buf;
2242 unsigned long p2;
2243 unsigned long bufTime;
2244
2245 pthread_mutex_lock(&m_TimeStampInfo.m_lock);
2246 m_TimeStampInfo.ts = (OMX_S64)pParam->nTimestamp;
2247 while (m_TimeStampInfo.deferred_inbufq.m_size &&
2248 !(m_TimeStampInfo.deferred_inbufq.get_q_msg_type() > m_TimeStampInfo.ts)) {
2249 m_TimeStampInfo.deferred_inbufq.pop_entry(&buf,&p2,&bufTime);
2250 DEBUG_PRINT_INFO("Queueing back pending buffer %lu timestamp %lu", buf, bufTime);
2251 this->post_event((unsigned long)hComp, (unsigned long)buf, m_input_msg_id);
2252 }
2253 pthread_mutex_unlock(&m_TimeStampInfo.m_lock);
2254
2255 memcpy(&m_sConfigInputTrigTS, pParam, sizeof(m_sConfigInputTrigTS));
2256 break;
2257 }
2258 case OMX_IndexConfigAndroidIntraRefresh:
2259 {
2260 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE);
2261 OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE* pParam =
2262 (OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE*) configData;
2263 if (m_state == OMX_StateLoaded
2264 || m_sInPortDef.bEnabled == OMX_FALSE
2265 || m_sOutPortDef.bEnabled == OMX_FALSE) {
2266 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_IndexConfigAndroidIntraRefresh)) {
2267 DEBUG_PRINT_ERROR("Failed to set OMX_IndexConfigVideoIntraRefreshType");
2268 return OMX_ErrorUnsupportedSetting;
2269 }
2270 m_sConfigIntraRefresh.nRefreshPeriod = pParam->nRefreshPeriod;
2271 } else {
2272 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigAndroidIntraRefresh supported only at start of session");
2273 return OMX_ErrorUnsupportedSetting;
2274 }
2275 break;
2276 }
2277 case OMX_QTIIndexConfigVideoBlurResolution:
2278 {
2279 VALIDATE_OMX_PARAM_DATA(configData, OMX_QTI_VIDEO_CONFIG_BLURINFO);
2280 OMX_QTI_VIDEO_CONFIG_BLURINFO* pParam =
2281 (OMX_QTI_VIDEO_CONFIG_BLURINFO*) configData;
2282 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_QTIIndexConfigVideoBlurResolution)) {
2283 DEBUG_PRINT_ERROR("Failed to set OMX_QTIIndexConfigVideoBlurResolution");
2284 return OMX_ErrorUnsupportedSetting;
2285 }
2286 memcpy(&m_blurInfo, pParam, sizeof(OMX_QTI_VIDEO_CONFIG_BLURINFO));
2287 break;
2288 }
2289 case OMX_QcomIndexConfigH264Transform8x8:
2290 {
2291 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_QcomIndexConfigH264Transform8x8)) {
2292 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QcomIndexConfigH264Transform8x8 failed");
2293 return OMX_ErrorUnsupportedSetting;
2294 }
2295 break;
2296 }
2297 case OMX_QTIIndexConfigDescribeColorAspects:
2298 {
2299 VALIDATE_OMX_PARAM_DATA(configData, DescribeColorAspectsParams);
2300 DescribeColorAspectsParams *params = (DescribeColorAspectsParams *)configData;
2301 print_debug_color_aspects(&(params->sAspects), "set_config");
2302
2303 // WA: Android client does not set the correct color-aspects (from dataspace).
2304 // Such a dataspace change is detected and set while in executing. This leads to
2305 // a race condition where client is trying to set (wrong) color and component trying
2306 // to set (right) color from ETB.
2307 // Hence ignore this config in Executing state till the framework starts setting right color.
2308 if (m_state == OMX_StateExecuting) {
2309 DEBUG_PRINT_HIGH("Ignoring ColorSpace setting in Executing state");
2310 return OMX_ErrorUnsupportedSetting;
2311 }
2312
2313 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_QTIIndexConfigDescribeColorAspects)) {
2314 DEBUG_PRINT_ERROR("Failed to set OMX_QTIIndexConfigDescribeColorAspects");
2315 return OMX_ErrorUnsupportedSetting;
2316 }
2317 memcpy(&m_sConfigColorAspects, configData, sizeof(m_sConfigColorAspects));
2318 break;
2319 }
2320 case OMX_IndexConfigAndroidVideoTemporalLayering:
2321 {
2322 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_CONFIG_ANDROID_TEMPORALLAYERINGTYPE);
2323 OMX_VIDEO_CONFIG_ANDROID_TEMPORALLAYERINGTYPE* pParam =
2324 (OMX_VIDEO_CONFIG_ANDROID_TEMPORALLAYERINGTYPE*) configData;
2325 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_IndexConfigAndroidVideoTemporalLayering)) {
2326 DEBUG_PRINT_ERROR("Failed to set OMX_VIDEO_CONFIG_ANDROID_TEMPORALLAYERINGTYPE");
2327 return OMX_ErrorUnsupportedSetting;
2328 }
2329 memcpy(&m_sConfigTemporalLayers, pParam, sizeof(m_sConfigTemporalLayers));
2330 break;
2331 }
2332 case OMX_IndexConfigAndroidVendorExtension:
2333 {
2334 VALIDATE_OMX_PARAM_DATA(configData, OMX_CONFIG_ANDROID_VENDOR_EXTENSIONTYPE);
2335
2336 OMX_CONFIG_ANDROID_VENDOR_EXTENSIONTYPE *ext =
2337 reinterpret_cast<OMX_CONFIG_ANDROID_VENDOR_EXTENSIONTYPE *>(configData);
2338 VALIDATE_OMX_VENDOR_EXTENSION_PARAM_DATA(ext);
2339
2340 return set_vendor_extension_config(ext);
2341 }
2342 case OMX_IndexConfigVideoNalSize:
2343 {
2344 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_CONFIG_NALSIZE);
2345
2346 OMX_VIDEO_CONFIG_NALSIZE* pParam =
2347 reinterpret_cast<OMX_VIDEO_CONFIG_NALSIZE*>(configData);
2348 DEBUG_PRINT_HIGH("set_config(): OMX_IndexConfigVideoNalSize (%u)", (unsigned int)pParam->nNaluBytes);
2349
2350 if (pParam->nPortIndex == PORT_INDEX_OUT) {
2351 if (handle->venc_set_config(configData, OMX_IndexConfigVideoNalSize) != true) {
2352 DEBUG_PRINT_LOW("Setting OMX_IndexConfigVideoBitrate failed");
2353 return OMX_ErrorUnsupportedSetting;
2354 }
2355 } else {
2356 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", (unsigned int)pParam->nPortIndex);
2357 return OMX_ErrorBadPortIndex;
2358 }
2359 break;
2360 }
2361 case OMX_QTIIndexConfigVideoRoiRectRegionInfo:
2362 {
2363 VALIDATE_OMX_PARAM_DATA(configData, OMX_QTI_VIDEO_CONFIG_ROI_RECT_REGION_INFO);
2364 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_QTIIndexConfigVideoRoiRectRegionInfo)) {
2365 DEBUG_PRINT_ERROR("Failed to set OMX_QTIIndexConfigVideoRoiRegionInfo");
2366 return OMX_ErrorUnsupportedSetting;
2367 }
2368 break;
2369
2370 }
2371 default:
2372 DEBUG_PRINT_ERROR("ERROR: unsupported index %d", (int) configIndex);
2373 break;
2374 }
2375
2376 return OMX_ErrorNone;
2377 }
2378
2379 /* ======================================================================
2380 FUNCTION
2381 omx_venc::ComponentDeInit
2382
2383 DESCRIPTION
2384 Destroys the component and release memory allocated to the heap.
2385
2386 PARAMETERS
2387 <TBD>.
2388
2389 RETURN VALUE
2390 OMX Error None if everything successful.
2391
2392 ========================================================================== */
component_deinit(OMX_IN OMX_HANDLETYPE hComp)2393 OMX_ERRORTYPE omx_venc::component_deinit(OMX_IN OMX_HANDLETYPE hComp)
2394 {
2395 (void) hComp;
2396 OMX_U32 i = 0;
2397 DEBUG_PRINT_HIGH("omx_venc(): Inside component_deinit()");
2398 if (OMX_StateLoaded != m_state) {
2399 DEBUG_PRINT_ERROR("WARNING:Rxd DeInit,OMX not in LOADED state %d",\
2400 m_state);
2401 }
2402
2403 auto_lock l(m_buf_lock);
2404 if (m_out_mem_ptr) {
2405 DEBUG_PRINT_LOW("Freeing the Output Memory");
2406 for (i=0; i< m_sOutPortDef.nBufferCountActual; i++ ) {
2407 if (BITMASK_PRESENT(&m_out_bm_count, i)) {
2408 BITMASK_CLEAR(&m_out_bm_count, i);
2409 if (BITMASK_PRESENT(&m_client_out_bm_count, i))
2410 BITMASK_CLEAR(&m_client_out_bm_count, i);
2411 free_output_buffer (&m_out_mem_ptr[i]);
2412 }
2413
2414 if (release_output_done()) {
2415 break;
2416 }
2417 }
2418 free(m_out_mem_ptr);
2419 m_out_mem_ptr = NULL;
2420 }
2421
2422 /*Check if the input buffers have to be cleaned up*/
2423 OMX_BUFFERHEADERTYPE* ptr = m_inp_mem_ptr;
2424 #ifdef _ANDROID_ICS_
2425 if (meta_mode_enable) {
2426 ptr = meta_buffer_hdr;
2427 }
2428 #endif
2429 if (ptr) {
2430 DEBUG_PRINT_LOW("Freeing the Input Memory");
2431 for (i=0; i<m_sInPortDef.nBufferCountActual; i++ ) {
2432 if (BITMASK_PRESENT(&m_inp_bm_count, i)) {
2433 BITMASK_CLEAR(&m_inp_bm_count, i);
2434 if (BITMASK_PRESENT(&m_client_in_bm_count, i))
2435 BITMASK_CLEAR(&m_client_in_bm_count, i);
2436 free_input_buffer(ptr + i);
2437 }
2438
2439 if (release_input_done()) {
2440 break;
2441 }
2442 }
2443
2444 if (m_inp_mem_ptr != meta_buffer_hdr)
2445 free(m_inp_mem_ptr);
2446 m_inp_mem_ptr = NULL;
2447 }
2448
2449 // Reset counters in mesg queues
2450 m_ftb_q.m_size=0;
2451 m_cmd_q.m_size=0;
2452 m_etb_q.m_size=0;
2453 m_ftb_q.m_read = m_ftb_q.m_write =0;
2454 m_cmd_q.m_read = m_cmd_q.m_write =0;
2455 m_etb_q.m_read = m_etb_q.m_write =0;
2456
2457 DEBUG_PRINT_HIGH("Calling venc_close()");
2458 if (handle) {
2459 handle->venc_close();
2460 DEBUG_PRINT_HIGH("Deleting HANDLE[%p]", handle);
2461 delete (handle);
2462 handle = NULL;
2463 }
2464 DEBUG_PRINT_INFO("Component Deinit");
2465 return OMX_ErrorNone;
2466 }
2467
2468
dev_stop(void)2469 OMX_U32 omx_venc::dev_stop( void)
2470 {
2471 return handle->venc_stop();
2472 }
2473
2474
dev_pause(void)2475 OMX_U32 omx_venc::dev_pause(void)
2476 {
2477 return handle->venc_pause();
2478 }
2479
dev_start(void)2480 OMX_U32 omx_venc::dev_start(void)
2481 {
2482 return handle->venc_start();
2483 }
2484
dev_flush(unsigned port)2485 OMX_U32 omx_venc::dev_flush(unsigned port)
2486 {
2487 return handle->venc_flush(port);
2488 }
2489
dev_resume(void)2490 OMX_U32 omx_venc::dev_resume(void)
2491 {
2492 return handle->venc_resume();
2493 }
2494
dev_start_done(void)2495 OMX_U32 omx_venc::dev_start_done(void)
2496 {
2497 return handle->venc_start_done();
2498 }
2499
dev_set_message_thread_id(pthread_t tid)2500 OMX_U32 omx_venc::dev_set_message_thread_id(pthread_t tid)
2501 {
2502 return handle->venc_set_message_thread_id(tid);
2503 }
2504
dev_handle_empty_eos_buffer(void)2505 bool omx_venc::dev_handle_empty_eos_buffer(void)
2506 {
2507 return handle->venc_handle_empty_eos_buffer();
2508 }
2509
dev_use_buf(unsigned port)2510 bool omx_venc::dev_use_buf(unsigned port)
2511 {
2512 return handle->allocate_extradata(port);
2513 }
2514
dev_buffer_ready_to_queue(OMX_BUFFERHEADERTYPE * buffer)2515 bool omx_venc::dev_buffer_ready_to_queue(OMX_BUFFERHEADERTYPE *buffer)
2516 {
2517 bool bRet = true;
2518
2519 /* do not defer the buffer if m_TimeStamp is not initialized */
2520 if (!m_sParamControlInputQueue.bEnable)
2521 return true;
2522
2523 pthread_mutex_lock(&m_TimeStampInfo.m_lock);
2524
2525 if ((!m_sParamControlInputQueue.bEnable) ||
2526 (OMX_S64)buffer->nTimeStamp <= (OMX_S64)m_TimeStampInfo.ts) {
2527 DEBUG_PRINT_LOW("ETB is ready to be queued");
2528 } else {
2529 DEBUG_PRINT_INFO(
2530 "ETB is deferred due to timeStamp mismatch buf_ts %lld m_TimeStampInfo.ts %lld",
2531 (OMX_S64)buffer->nTimeStamp, (OMX_S64)m_TimeStampInfo.ts);
2532 m_TimeStampInfo.deferred_inbufq.insert_entry((unsigned long)buffer, 0, buffer->nTimeStamp);
2533 bRet = false;
2534 }
2535 pthread_mutex_unlock(&m_TimeStampInfo.m_lock);
2536 return bRet;
2537 }
2538
dev_free_buf(void * buf_addr,unsigned port)2539 bool omx_venc::dev_free_buf(void *buf_addr,unsigned port)
2540 {
2541 return handle->venc_free_buf(buf_addr,port);
2542 }
2543
dev_empty_buf(void * buffer,void * pmem_data_buf,unsigned index,unsigned fd)2544 bool omx_venc::dev_empty_buf(void *buffer, void *pmem_data_buf,unsigned index,unsigned fd)
2545 {
2546 bool bret = false;
2547 bret = handle->venc_empty_buf(buffer, pmem_data_buf,index,fd);
2548 hw_overload = handle->hw_overload;
2549 return bret;
2550 }
2551
dev_fill_buf(void * buffer,void * pmem_data_buf,unsigned index,unsigned fd)2552 bool omx_venc::dev_fill_buf(void *buffer, void *pmem_data_buf,unsigned index,unsigned fd)
2553 {
2554 return handle->venc_fill_buf(buffer, pmem_data_buf,index,fd);
2555 }
2556
dev_get_seq_hdr(void * buffer,unsigned size,unsigned * hdrlen)2557 bool omx_venc::dev_get_seq_hdr(void *buffer, unsigned size, unsigned *hdrlen)
2558 {
2559 return handle->venc_get_seq_hdr(buffer, size, hdrlen);
2560 }
2561
dev_get_capability_ltrcount(OMX_U32 * min,OMX_U32 * max,OMX_U32 * step_size)2562 bool omx_venc::dev_get_capability_ltrcount(OMX_U32 *min, OMX_U32 *max, OMX_U32 *step_size)
2563 {
2564 (void) min;
2565 (void) max;
2566 (void) step_size;
2567 DEBUG_PRINT_ERROR("Get Capability LTR Count is not supported");
2568 return false;
2569 }
2570
dev_get_vui_timing_info(OMX_U32 * enabled)2571 bool omx_venc::dev_get_vui_timing_info(OMX_U32 *enabled)
2572 {
2573 return handle->venc_get_vui_timing_info(enabled);
2574 }
2575
dev_get_vqzip_sei_info(OMX_U32 * enabled)2576 bool omx_venc::dev_get_vqzip_sei_info(OMX_U32 *enabled)
2577 {
2578 return handle->venc_get_vqzip_sei_info(enabled);
2579 }
2580
dev_get_peak_bitrate(OMX_U32 * peakbitrate)2581 bool omx_venc::dev_get_peak_bitrate(OMX_U32 *peakbitrate)
2582 {
2583 return handle->venc_get_peak_bitrate(peakbitrate);
2584 }
2585
dev_get_batch_size(OMX_U32 * size)2586 bool omx_venc::dev_get_batch_size(OMX_U32 *size)
2587 {
2588 return handle->venc_get_batch_size(size);
2589 }
2590
dev_get_temporal_layer_caps(OMX_U32 * nMaxLayers,OMX_U32 * nMaxBLayers,OMX_VIDEO_ANDROID_TEMPORALLAYERINGPATTERNTYPE * eSupportedPattern)2591 bool omx_venc::dev_get_temporal_layer_caps(OMX_U32 *nMaxLayers,
2592 OMX_U32 *nMaxBLayers, OMX_VIDEO_ANDROID_TEMPORALLAYERINGPATTERNTYPE *eSupportedPattern) {
2593 return handle->venc_get_temporal_layer_caps(nMaxLayers, nMaxBLayers, eSupportedPattern);
2594 }
2595
dev_get_supported_profile_level(OMX_VIDEO_PARAM_PROFILELEVELTYPE * profileLevelType)2596 OMX_ERRORTYPE omx_venc::dev_get_supported_profile_level(OMX_VIDEO_PARAM_PROFILELEVELTYPE *profileLevelType)
2597 {
2598 return handle->venc_get_supported_profile_level(profileLevelType);
2599 }
2600
dev_get_supported_color_format(unsigned index,OMX_U32 * colorFormat)2601 bool omx_venc::dev_get_supported_color_format(unsigned index, OMX_U32 *colorFormat) {
2602 return handle->venc_get_supported_color_format(index, colorFormat);
2603 }
2604
dev_get_color_format_as_string(char * buf,int buf_len,unsigned colorformat)2605 void omx_venc::dev_get_color_format_as_string(char * buf, int buf_len, unsigned colorformat) {
2606 // Try to match with OMX_QCOM_COLOR_FORMATTYPE
2607 switch (colorformat) {
2608 case QOMX_COLOR_FormatYVU420SemiPlanar:
2609 snprintf(buf, buf_len, "QOMX_COLOR_FormatYVU420SemiPlanar");
2610 break;
2611 case QOMX_COLOR_FormatYVU420PackedSemiPlanar32m4ka:
2612 snprintf(buf, buf_len, "QOMX_COLOR_FormatYVU420PackedSemiPlanar32m4ka");
2613 break;
2614 case QOMX_COLOR_FormatYUV420PackedSemiPlanar16m2ka:
2615 snprintf(buf, buf_len, "QOMX_COLOR_FormatYUV420PackedSemiPlanar16m2ka");
2616 break;
2617 case QOMX_COLOR_FormatYUV420PackedSemiPlanar64x32Tile2m8ka:
2618 snprintf(buf, buf_len, "QOMX_COLOR_FormatYUV420PackedSemiPlanar64x32Tile2m8ka");
2619 break;
2620 case QOMX_COLOR_FORMATYUV420PackedSemiPlanar32m:
2621 snprintf(buf, buf_len, "QOMX_COLOR_FORMATYUV420PackedSemiPlanar32m");
2622 break;
2623 case QOMX_COLOR_FORMATYUV420PackedSemiPlanar32mMultiView:
2624 snprintf(buf, buf_len, "QOMX_COLOR_FORMATYUV420PackedSemiPlanar32mMultiView");
2625 break;
2626 case QOMX_COLOR_FORMATYUV420PackedSemiPlanar32mCompressed:
2627 snprintf(buf, buf_len, "QOMX_COLOR_FORMATYUV420PackedSemiPlanar32mCompressed");
2628 break;
2629 case QOMX_COLOR_Format32bitRGBA8888:
2630 snprintf(buf, buf_len, "QOMX_COLOR_Format32bitRGBA8888");
2631 break;
2632 case QOMX_COLOR_Format32bitRGBA8888Compressed:
2633 snprintf(buf, buf_len, "QOMX_COLOR_Format32bitRGBA8888Compressed");
2634 break;
2635 case QOMX_COLOR_FORMATYUV420PackedSemiPlanar32m10bitCompressed:
2636 snprintf(buf, buf_len, "QOMX_COLOR_FORMATYUV420PackedSemiPlanar32m10bitCompressed");
2637 break;
2638 case QOMX_COLOR_FORMATYUV420SemiPlanarP010Venus:
2639 snprintf(buf, buf_len, "QOMX_COLOR_FORMATYUV420SemiPlanarP010Venus");
2640 break;
2641 case QOMX_COLOR_FormatAndroidOpaque:
2642 snprintf(buf, buf_len, "QOMX_COLOR_FormatAndroidOpaque");
2643 break;
2644 default:
2645 snprintf(buf, buf_len, "no match found in OMX_QCOM_COLOR_FORMATTYPE");
2646 return;
2647 }
2648 }
2649
dev_loaded_start()2650 bool omx_venc::dev_loaded_start()
2651 {
2652 return handle->venc_loaded_start();
2653 }
2654
dev_loaded_stop()2655 bool omx_venc::dev_loaded_stop()
2656 {
2657 return handle->venc_loaded_stop();
2658 }
2659
dev_loaded_start_done()2660 bool omx_venc::dev_loaded_start_done()
2661 {
2662 return handle->venc_loaded_start_done();
2663 }
2664
dev_loaded_stop_done()2665 bool omx_venc::dev_loaded_stop_done()
2666 {
2667 return handle->venc_loaded_stop_done();
2668 }
2669
dev_get_buf_req(OMX_U32 * min_buff_count,OMX_U32 * actual_buff_count,OMX_U32 * buff_size,OMX_U32 port)2670 bool omx_venc::dev_get_buf_req(OMX_U32 *min_buff_count,
2671 OMX_U32 *actual_buff_count,
2672 OMX_U32 *buff_size,
2673 OMX_U32 port)
2674 {
2675 return handle->venc_get_buf_req(min_buff_count,
2676 actual_buff_count,
2677 buff_size,
2678 port);
2679
2680 }
2681
dev_get_dimensions(OMX_U32 port,OMX_U32 * width,OMX_U32 * height)2682 bool omx_venc::dev_get_dimensions(OMX_U32 port,
2683 OMX_U32 *width,
2684 OMX_U32 *height)
2685 {
2686 return handle->venc_get_dimensions(port,
2687 width,
2688 height);
2689 }
2690
is_streamon_done(OMX_U32 port)2691 bool omx_venc::is_streamon_done(OMX_U32 port)
2692 {
2693 return handle->is_streamon_done(port);
2694 }
2695
dev_set_buf_req(OMX_U32 * min_buff_count,OMX_U32 * actual_buff_count,OMX_U32 * buff_size,OMX_U32 port)2696 bool omx_venc::dev_set_buf_req(OMX_U32 *min_buff_count,
2697 OMX_U32 *actual_buff_count,
2698 OMX_U32 *buff_size,
2699 OMX_U32 port)
2700 {
2701 return handle->venc_set_buf_req(min_buff_count,
2702 actual_buff_count,
2703 buff_size,
2704 port);
2705
2706 }
2707
dev_is_video_session_supported(OMX_U32 width,OMX_U32 height)2708 bool omx_venc::dev_is_video_session_supported(OMX_U32 width, OMX_U32 height)
2709 {
2710 return handle->venc_is_video_session_supported(width,height);
2711 }
2712
dev_handle_output_extradata(void * buffer,int index)2713 int omx_venc::dev_handle_output_extradata(void *buffer, int index)
2714 {
2715 return handle->handle_output_extradata(buffer, index);
2716 }
2717
dev_set_format(int color)2718 int omx_venc::dev_set_format(int color)
2719 {
2720 return handle->venc_set_format(color);
2721 }
2722
dev_query_cap(struct v4l2_queryctrl & cap)2723 bool omx_venc::dev_query_cap(struct v4l2_queryctrl &cap)
2724
2725 {
2726 return handle->venc_query_cap(cap);
2727 }
2728
async_message_process(void * context,void * message)2729 int omx_venc::async_message_process (void *context, void* message)
2730 {
2731 omx_video* omx = NULL;
2732 struct venc_msg *m_sVenc_msg = NULL;
2733 OMX_BUFFERHEADERTYPE* omxhdr = NULL;
2734 struct venc_buffer *temp_buff = NULL;
2735 native_handle_t *nh = NULL;
2736
2737 if (context == NULL || message == NULL) {
2738 DEBUG_PRINT_ERROR("ERROR: omx_venc::async_message_process invalid i/p params");
2739 return -1;
2740 }
2741 m_sVenc_msg = (struct venc_msg *)message;
2742
2743 omx = reinterpret_cast<omx_video*>(context);
2744
2745 if (m_sVenc_msg->statuscode != VEN_S_SUCCESS) {
2746 DEBUG_PRINT_ERROR("ERROR: async_msg_process() - Error statuscode = %lu",
2747 m_sVenc_msg->statuscode);
2748 if(m_sVenc_msg->msgcode == VEN_MSG_HW_OVERLOAD) {
2749 omx->post_event (0, m_sVenc_msg->statuscode,\
2750 OMX_COMPONENT_GENERATE_HARDWARE_OVERLOAD);
2751 } else {
2752 omx->post_event (0, m_sVenc_msg->statuscode,\
2753 OMX_COMPONENT_GENERATE_HARDWARE_ERROR);
2754 }
2755 }
2756
2757 DEBUG_PRINT_LOW("omx_venc::async_message_process- msgcode = %lu",
2758 m_sVenc_msg->msgcode);
2759 switch (m_sVenc_msg->msgcode) {
2760 case VEN_MSG_START:
2761 omx->post_event (0,m_sVenc_msg->statuscode,\
2762 OMX_COMPONENT_GENERATE_START_DONE);
2763 break;
2764 case VEN_MSG_STOP:
2765 omx->post_event (0,m_sVenc_msg->statuscode,\
2766 OMX_COMPONENT_GENERATE_STOP_DONE);
2767 break;
2768 case VEN_MSG_RESUME:
2769 omx->post_event (0,m_sVenc_msg->statuscode,\
2770 OMX_COMPONENT_GENERATE_RESUME_DONE);
2771 break;
2772 case VEN_MSG_PAUSE:
2773 omx->post_event (0,m_sVenc_msg->statuscode,\
2774 OMX_COMPONENT_GENERATE_PAUSE_DONE);
2775 break;
2776 case VEN_MSG_FLUSH_INPUT_DONE:
2777
2778 omx->post_event (0,m_sVenc_msg->statuscode,\
2779 OMX_COMPONENT_GENERATE_EVENT_INPUT_FLUSH);
2780 break;
2781 case VEN_MSG_FLUSH_OUPUT_DONE:
2782 omx->post_event (0,m_sVenc_msg->statuscode,\
2783 OMX_COMPONENT_GENERATE_EVENT_OUTPUT_FLUSH);
2784 break;
2785 case VEN_MSG_INPUT_BUFFER_DONE:
2786 omxhdr = (OMX_BUFFERHEADERTYPE* )\
2787 m_sVenc_msg->buf.clientdata;
2788
2789 if (omxhdr == NULL ||
2790 (((OMX_U32)(omxhdr - omx->m_inp_mem_ptr) > omx->m_sInPortDef.nBufferCountActual) &&
2791 ((OMX_U32)(omxhdr - omx->meta_buffer_hdr) > omx->m_sInPortDef.nBufferCountActual))) {
2792 omxhdr = NULL;
2793 m_sVenc_msg->statuscode = VEN_S_EFAIL;
2794 }
2795
2796 #ifdef _ANDROID_ICS_
2797 omx->omx_release_meta_buffer(omxhdr);
2798 #endif
2799 omx->post_event ((unsigned long)omxhdr,m_sVenc_msg->statuscode,
2800 OMX_COMPONENT_GENERATE_EBD);
2801 break;
2802 case VEN_MSG_OUTPUT_BUFFER_DONE:
2803 {
2804 omxhdr = (OMX_BUFFERHEADERTYPE*)m_sVenc_msg->buf.clientdata;
2805 OMX_U32 bufIndex = (OMX_U32)(omxhdr - omx->m_out_mem_ptr);
2806
2807 if ( (omxhdr != NULL) &&
2808 (bufIndex < omx->m_sOutPortDef.nBufferCountActual)) {
2809 auto_lock l(omx->m_buf_lock);
2810 if (BITMASK_ABSENT(&(omx->m_out_bm_count), bufIndex)) {
2811 DEBUG_PRINT_ERROR("Recieved FBD for buffer that is already freed !");
2812 break;
2813 }
2814 if (!omx->is_secure_session() && (m_sVenc_msg->buf.len <= omxhdr->nAllocLen)) {
2815 omxhdr->nFilledLen = m_sVenc_msg->buf.len;
2816 omxhdr->nOffset = m_sVenc_msg->buf.offset;
2817 omxhdr->nTimeStamp = m_sVenc_msg->buf.timestamp;
2818 DEBUG_PRINT_LOW("o/p TS = %u", (unsigned int)m_sVenc_msg->buf.timestamp);
2819 omxhdr->nFlags = m_sVenc_msg->buf.flags;
2820
2821 /*Use buffer case*/
2822 if (BITMASK_PRESENT(&(omx->m_client_out_bm_count), bufIndex) &&
2823 omx->output_use_buffer && !omx->m_use_output_pmem && !omx->is_secure_session()) {
2824 DEBUG_PRINT_LOW("memcpy() for o/p Heap UseBuffer");
2825 memcpy(omxhdr->pBuffer,
2826 (m_sVenc_msg->buf.ptrbuffer),
2827 m_sVenc_msg->buf.len);
2828 }
2829 } else if (omx->is_secure_session()) {
2830 if (omx->allocate_native_handle) {
2831 native_handle_t *nh = (native_handle_t *)(omxhdr->pBuffer);
2832 nh->data[1] = m_sVenc_msg->buf.offset;
2833 nh->data[2] = m_sVenc_msg->buf.len;
2834 omxhdr->nFilledLen = m_sVenc_msg->buf.len;
2835 omxhdr->nTimeStamp = m_sVenc_msg->buf.timestamp;
2836 omxhdr->nFlags = m_sVenc_msg->buf.flags;
2837 } else {
2838 output_metabuffer *meta_buf = (output_metabuffer *)(omxhdr->pBuffer);
2839 native_handle_t *nh = meta_buf->nh;
2840 nh->data[1] = m_sVenc_msg->buf.offset;
2841 nh->data[2] = m_sVenc_msg->buf.len;
2842 omxhdr->nFilledLen = sizeof(output_metabuffer);
2843 omxhdr->nTimeStamp = m_sVenc_msg->buf.timestamp;
2844 omxhdr->nFlags = m_sVenc_msg->buf.flags;
2845 }
2846 } else {
2847 omxhdr->nFilledLen = 0;
2848 }
2849
2850 } else {
2851 omxhdr = NULL;
2852 m_sVenc_msg->statuscode = VEN_S_EFAIL;
2853 }
2854 omx->post_event ((unsigned long)omxhdr,m_sVenc_msg->statuscode,
2855 OMX_COMPONENT_GENERATE_FBD);
2856 break;
2857 }
2858 case VEN_MSG_NEED_OUTPUT_BUFFER:
2859 //TBD what action needs to be done here??
2860 break;
2861 default:
2862 DEBUG_PRINT_HIGH("Unknown msg received : %lu", m_sVenc_msg->msgcode);
2863 break;
2864 }
2865 return 0;
2866 }
2867
dev_color_align(OMX_BUFFERHEADERTYPE * buffer,OMX_U32 width,OMX_U32 height)2868 bool omx_venc::dev_color_align(OMX_BUFFERHEADERTYPE *buffer,
2869 OMX_U32 width, OMX_U32 height)
2870 {
2871 if(secure_session) {
2872 DEBUG_PRINT_ERROR("Cannot align colors in secure session.");
2873 return OMX_FALSE;
2874 }
2875 return handle->venc_color_align(buffer, width,height);
2876 }
2877
is_secure_session()2878 bool omx_venc::is_secure_session()
2879 {
2880 return secure_session;
2881 }
2882
dev_get_output_log_flag()2883 bool omx_venc::dev_get_output_log_flag()
2884 {
2885 return handle->venc_get_output_log_flag();
2886 }
2887
dev_output_log_buffers(const char * buffer,int bufferlen,uint64_t timestamp)2888 int omx_venc::dev_output_log_buffers(const char *buffer,
2889 int bufferlen, uint64_t timestamp)
2890 {
2891 return handle->venc_output_log_buffers(buffer, bufferlen, timestamp);
2892 }
2893
dev_extradata_log_buffers(char * buffer,bool input)2894 int omx_venc::dev_extradata_log_buffers(char *buffer, bool input)
2895 {
2896 return handle->venc_extradata_log_buffers(buffer, input);
2897 }
2898
dev_get_hevc_profile(OMX_U32 * profile)2899 bool omx_venc::dev_get_hevc_profile(OMX_U32* profile)
2900 {
2901 return handle->venc_get_hevc_profile(profile);
2902 }
2903
dev_handle_client_input_extradata(void * buffer)2904 bool omx_venc::dev_handle_client_input_extradata(void *buffer)
2905 {
2906 return handle->venc_handle_client_input_extradata(buffer);
2907 }
2908
dev_get_consumer_usage(OMX_U32 * usage)2909 void omx_venc::dev_get_consumer_usage(OMX_U32* usage)
2910 {
2911 return handle->venc_get_consumer_usage(usage);
2912 }
2913