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