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