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