1 /*-------------------------------------------------------------------------- 2 Copyright (c) 2010-2017, 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) OMX_VIDEO_AVCProfileConstrainedBaseline) && 1706 (m_sParamAVC.eProfile != (OMX_VIDEO_AVCPROFILETYPE) QOMX_VIDEO_AVCProfileConstrainedBaseline)) 1707 m_sParamAVC.nBFrames = pParam->nBFrames; 1708 else 1709 m_sParamAVC.nBFrames = 0; 1710 } 1711 } else { 1712 DEBUG_PRINT_ERROR("ERROR: (QOMX_IndexConfigVideoIntraperiod) Unsupported port index: %u", (unsigned int)pParam->nPortIndex); 1713 return OMX_ErrorBadPortIndex; 1714 } 1715 1716 break; 1717 } 1718 1719 case OMX_IndexConfigVideoIntraVOPRefresh: 1720 { 1721 VALIDATE_OMX_PARAM_DATA(configData, OMX_CONFIG_INTRAREFRESHVOPTYPE); 1722 OMX_CONFIG_INTRAREFRESHVOPTYPE* pParam = 1723 reinterpret_cast<OMX_CONFIG_INTRAREFRESHVOPTYPE*>(configData); 1724 1725 DEBUG_PRINT_HIGH("set_config(): OMX_IndexConfigVideoIntraVOPRefresh"); 1726 if (pParam->nPortIndex == PORT_INDEX_OUT) { 1727 if (handle->venc_set_config(configData, 1728 OMX_IndexConfigVideoIntraVOPRefresh) != true) { 1729 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigVideoIntraVOPRefresh failed"); 1730 return OMX_ErrorUnsupportedSetting; 1731 } 1732 1733 m_sConfigIntraRefreshVOP.IntraRefreshVOP = pParam->IntraRefreshVOP; 1734 } else { 1735 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", (unsigned int)pParam->nPortIndex); 1736 return OMX_ErrorBadPortIndex; 1737 } 1738 1739 break; 1740 } 1741 case OMX_IndexConfigCommonRotate: 1742 { 1743 VALIDATE_OMX_PARAM_DATA(configData, OMX_CONFIG_ROTATIONTYPE); 1744 OMX_CONFIG_ROTATIONTYPE *pParam = 1745 reinterpret_cast<OMX_CONFIG_ROTATIONTYPE*>(configData); 1746 OMX_S32 nRotation; 1747 1748 if (pParam->nPortIndex != PORT_INDEX_OUT) { 1749 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", (unsigned int)pParam->nPortIndex); 1750 return OMX_ErrorBadPortIndex; 1751 } 1752 if ( pParam->nRotation == 0 || 1753 pParam->nRotation == 90 || 1754 pParam->nRotation == 180 || 1755 pParam->nRotation == 270 ) { 1756 DEBUG_PRINT_HIGH("set_config: Rotation Angle %u", (unsigned int)pParam->nRotation); 1757 } else { 1758 DEBUG_PRINT_ERROR("ERROR: un supported Rotation %u", (unsigned int)pParam->nRotation); 1759 return OMX_ErrorUnsupportedSetting; 1760 } 1761 nRotation = pParam->nRotation - m_sConfigFrameRotation.nRotation; 1762 if (nRotation < 0) 1763 nRotation = -nRotation; 1764 if (nRotation == 90 || nRotation == 270) { 1765 DEBUG_PRINT_HIGH("set_config: updating device Dims"); 1766 if (handle->venc_set_config(configData, 1767 OMX_IndexConfigCommonRotate) != true) { 1768 DEBUG_PRINT_ERROR("ERROR: Set OMX_IndexConfigCommonRotate failed"); 1769 return OMX_ErrorUnsupportedSetting; 1770 } else { 1771 OMX_U32 nFrameWidth; 1772 OMX_U32 nFrameHeight; 1773 1774 DEBUG_PRINT_HIGH("set_config: updating port Dims"); 1775 1776 nFrameWidth = m_sOutPortDef.format.video.nFrameWidth; 1777 nFrameHeight = m_sOutPortDef.format.video.nFrameHeight; 1778 m_sOutPortDef.format.video.nFrameWidth = nFrameHeight; 1779 m_sOutPortDef.format.video.nFrameHeight = nFrameWidth; 1780 m_sConfigFrameRotation.nRotation = pParam->nRotation; 1781 } 1782 } else { 1783 m_sConfigFrameRotation.nRotation = pParam->nRotation; 1784 } 1785 break; 1786 } 1787 case OMX_QcomIndexConfigVideoFramePackingArrangement: 1788 { 1789 DEBUG_PRINT_HIGH("set_config(): OMX_QcomIndexConfigVideoFramePackingArrangement"); 1790 if (m_sOutPortFormat.eCompressionFormat == OMX_VIDEO_CodingAVC) { 1791 VALIDATE_OMX_PARAM_DATA(configData, OMX_QCOM_FRAME_PACK_ARRANGEMENT); 1792 OMX_QCOM_FRAME_PACK_ARRANGEMENT *configFmt = 1793 (OMX_QCOM_FRAME_PACK_ARRANGEMENT *) configData; 1794 extra_data_handle.set_frame_pack_data(configFmt); 1795 } else { 1796 DEBUG_PRINT_ERROR("ERROR: FramePackingData not supported for non AVC compression"); 1797 } 1798 break; 1799 } 1800 case QOMX_IndexConfigVideoLTRPeriod: 1801 { 1802 VALIDATE_OMX_PARAM_DATA(configData, QOMX_VIDEO_CONFIG_LTRPERIOD_TYPE); 1803 QOMX_VIDEO_CONFIG_LTRPERIOD_TYPE* pParam = (QOMX_VIDEO_CONFIG_LTRPERIOD_TYPE*)configData; 1804 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)QOMX_IndexConfigVideoLTRPeriod)) { 1805 DEBUG_PRINT_ERROR("ERROR: Setting LTR period failed"); 1806 return OMX_ErrorUnsupportedSetting; 1807 } 1808 memcpy(&m_sConfigLTRPeriod, pParam, sizeof(m_sConfigLTRPeriod)); 1809 break; 1810 } 1811 1812 case OMX_IndexConfigVideoVp8ReferenceFrame: 1813 { 1814 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_VP8REFERENCEFRAMETYPE); 1815 OMX_VIDEO_VP8REFERENCEFRAMETYPE* pParam = (OMX_VIDEO_VP8REFERENCEFRAMETYPE*) configData; 1816 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE) OMX_IndexConfigVideoVp8ReferenceFrame)) { 1817 DEBUG_PRINT_ERROR("ERROR: Setting VP8 reference frame"); 1818 return OMX_ErrorUnsupportedSetting; 1819 } 1820 memcpy(&m_sConfigVp8ReferenceFrame, pParam, sizeof(m_sConfigVp8ReferenceFrame)); 1821 break; 1822 } 1823 1824 case QOMX_IndexConfigVideoLTRUse: 1825 { 1826 VALIDATE_OMX_PARAM_DATA(configData, QOMX_VIDEO_CONFIG_LTRUSE_TYPE); 1827 QOMX_VIDEO_CONFIG_LTRUSE_TYPE* pParam = (QOMX_VIDEO_CONFIG_LTRUSE_TYPE*)configData; 1828 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)QOMX_IndexConfigVideoLTRUse)) { 1829 DEBUG_PRINT_ERROR("ERROR: Setting LTR use failed"); 1830 return OMX_ErrorUnsupportedSetting; 1831 } 1832 memcpy(&m_sConfigLTRUse, pParam, sizeof(m_sConfigLTRUse)); 1833 break; 1834 } 1835 case QOMX_IndexConfigVideoLTRMark: 1836 { 1837 VALIDATE_OMX_PARAM_DATA(configData, QOMX_VIDEO_CONFIG_LTRMARK_TYPE); 1838 QOMX_VIDEO_CONFIG_LTRMARK_TYPE* pParam = (QOMX_VIDEO_CONFIG_LTRMARK_TYPE*)configData; 1839 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)QOMX_IndexConfigVideoLTRMark)) { 1840 DEBUG_PRINT_ERROR("ERROR: Setting LTR mark failed"); 1841 return OMX_ErrorUnsupportedSetting; 1842 } 1843 break; 1844 } 1845 case OMX_IndexConfigVideoAVCIntraPeriod: 1846 { 1847 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_CONFIG_AVCINTRAPERIOD); 1848 OMX_VIDEO_CONFIG_AVCINTRAPERIOD *pParam = (OMX_VIDEO_CONFIG_AVCINTRAPERIOD*) configData; 1849 DEBUG_PRINT_LOW("set_config: OMX_IndexConfigVideoAVCIntraPeriod"); 1850 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)OMX_IndexConfigVideoAVCIntraPeriod)) { 1851 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigVideoAVCIntraPeriod failed"); 1852 return OMX_ErrorUnsupportedSetting; 1853 } 1854 memcpy(&m_sConfigAVCIDRPeriod, pParam, sizeof(m_sConfigAVCIDRPeriod)); 1855 break; 1856 } 1857 case OMX_IndexConfigCommonDeinterlace: 1858 { 1859 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_CONFIG_DEINTERLACE); 1860 OMX_VIDEO_CONFIG_DEINTERLACE *pParam = (OMX_VIDEO_CONFIG_DEINTERLACE*) configData; 1861 DEBUG_PRINT_LOW("set_config: OMX_IndexConfigCommonDeinterlace"); 1862 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)OMX_IndexConfigCommonDeinterlace)) { 1863 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigCommonDeinterlace failed"); 1864 return OMX_ErrorUnsupportedSetting; 1865 } 1866 memcpy(&m_sConfigDeinterlace, pParam, sizeof(m_sConfigDeinterlace)); 1867 break; 1868 } 1869 case OMX_QcomIndexConfigVideoVencPerfMode: 1870 { 1871 VALIDATE_OMX_PARAM_DATA(configData, QOMX_EXTNINDEX_VIDEO_PERFMODE); 1872 QOMX_EXTNINDEX_VIDEO_PERFMODE* pParam = (QOMX_EXTNINDEX_VIDEO_PERFMODE*)configData; 1873 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)OMX_QcomIndexConfigVideoVencPerfMode)) { 1874 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QcomIndexConfigVideoVencPerfMode failed"); 1875 return OMX_ErrorUnsupportedSetting; 1876 } 1877 break; 1878 } 1879 case OMX_IndexConfigPriority: 1880 { 1881 VALIDATE_OMX_PARAM_DATA(configData, OMX_PARAM_U32TYPE); 1882 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_IndexConfigPriority)) { 1883 DEBUG_PRINT_ERROR("Failed to set OMX_IndexConfigPriority"); 1884 return OMX_ErrorUnsupportedSetting; 1885 } 1886 break; 1887 } 1888 case OMX_IndexConfigOperatingRate: 1889 { 1890 VALIDATE_OMX_PARAM_DATA(configData, OMX_PARAM_U32TYPE); 1891 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_IndexConfigOperatingRate)) { 1892 DEBUG_PRINT_ERROR("Failed to set OMX_IndexConfigOperatingRate"); 1893 return handle->hw_overload ? OMX_ErrorInsufficientResources : 1894 OMX_ErrorUnsupportedSetting; 1895 } 1896 break; 1897 } 1898 case OMX_IndexConfigAndroidIntraRefresh: 1899 { 1900 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE); 1901 OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE* pParam = 1902 (OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE*) configData; 1903 if (m_state == OMX_StateLoaded 1904 || m_sInPortDef.bEnabled == OMX_FALSE 1905 || m_sOutPortDef.bEnabled == OMX_FALSE) { 1906 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_IndexConfigAndroidIntraRefresh)) { 1907 DEBUG_PRINT_ERROR("Failed to set OMX_IndexConfigVideoIntraRefreshType"); 1908 return OMX_ErrorUnsupportedSetting; 1909 } 1910 m_sConfigIntraRefresh.nRefreshPeriod = pParam->nRefreshPeriod; 1911 } else { 1912 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigAndroidIntraRefresh supported only at start of session"); 1913 return OMX_ErrorUnsupportedSetting; 1914 } 1915 break; 1916 } 1917 default: 1918 DEBUG_PRINT_ERROR("ERROR: unsupported index %d", (int) configIndex); 1919 break; 1920 } 1921 1922 return OMX_ErrorNone; 1923 } 1924 1925 /* ====================================================================== 1926 FUNCTION 1927 omx_venc::ComponentDeInit 1928 1929 DESCRIPTION 1930 Destroys the component and release memory allocated to the heap. 1931 1932 PARAMETERS 1933 <TBD>. 1934 1935 RETURN VALUE 1936 OMX Error None if everything successful. 1937 1938 ========================================================================== */ 1939 OMX_ERRORTYPE omx_venc::component_deinit(OMX_IN OMX_HANDLETYPE hComp) 1940 { 1941 (void) hComp; 1942 OMX_U32 i = 0; 1943 DEBUG_PRINT_HIGH("omx_venc(): Inside component_deinit()"); 1944 if (OMX_StateLoaded != m_state) { 1945 DEBUG_PRINT_ERROR("WARNING:Rxd DeInit,OMX not in LOADED state %d",\ 1946 m_state); 1947 } 1948 if (m_out_mem_ptr) { 1949 DEBUG_PRINT_LOW("Freeing the Output Memory"); 1950 for (i=0; i< m_sOutPortDef.nBufferCountActual; i++ ) { 1951 if (BITMASK_PRESENT(&m_out_bm_count, i)) { 1952 BITMASK_CLEAR(&m_out_bm_count, i); 1953 free_output_buffer (&m_out_mem_ptr[i]); 1954 } 1955 1956 if (release_output_done()) { 1957 break; 1958 } 1959 } 1960 free(m_out_mem_ptr); 1961 m_out_mem_ptr = NULL; 1962 } 1963 1964 /*Check if the input buffers have to be cleaned up*/ 1965 if (m_inp_mem_ptr 1966 #ifdef _ANDROID_ICS_ 1967 && !meta_mode_enable 1968 #endif 1969 ) { 1970 DEBUG_PRINT_LOW("Freeing the Input Memory"); 1971 for (i=0; i<m_sInPortDef.nBufferCountActual; i++ ) { 1972 if (BITMASK_PRESENT(&m_inp_bm_count, i)) { 1973 BITMASK_CLEAR(&m_inp_bm_count, i); 1974 free_input_buffer (&m_inp_mem_ptr[i]); 1975 } 1976 1977 if (release_input_done()) { 1978 break; 1979 } 1980 } 1981 1982 1983 free(m_inp_mem_ptr); 1984 m_inp_mem_ptr = NULL; 1985 } 1986 1987 // Reset counters in mesg queues 1988 m_ftb_q.m_size=0; 1989 m_cmd_q.m_size=0; 1990 m_etb_q.m_size=0; 1991 m_ftb_q.m_read = m_ftb_q.m_write =0; 1992 m_cmd_q.m_read = m_cmd_q.m_write =0; 1993 m_etb_q.m_read = m_etb_q.m_write =0; 1994 1995 #ifdef _ANDROID_ 1996 // Clear the strong reference 1997 DEBUG_PRINT_HIGH("Calling m_heap_ptr.clear()"); 1998 m_heap_ptr.clear(); 1999 #endif // _ANDROID_ 2000 DEBUG_PRINT_HIGH("Calling venc_close()"); 2001 if (handle) { 2002 handle->venc_close(); 2003 DEBUG_PRINT_HIGH("Deleting HANDLE[%p]", handle); 2004 delete (handle); 2005 handle = NULL; 2006 } 2007 DEBUG_PRINT_INFO("Component Deinit"); 2008 return OMX_ErrorNone; 2009 } 2010 2011 2012 OMX_U32 omx_venc::dev_stop( void) 2013 { 2014 return handle->venc_stop(); 2015 } 2016 2017 2018 OMX_U32 omx_venc::dev_pause(void) 2019 { 2020 return handle->venc_pause(); 2021 } 2022 2023 OMX_U32 omx_venc::dev_start(void) 2024 { 2025 return handle->venc_start(); 2026 } 2027 2028 OMX_U32 omx_venc::dev_flush(unsigned port) 2029 { 2030 return handle->venc_flush(port); 2031 } 2032 OMX_U32 omx_venc::dev_resume(void) 2033 { 2034 return handle->venc_resume(); 2035 } 2036 2037 OMX_U32 omx_venc::dev_start_done(void) 2038 { 2039 return handle->venc_start_done(); 2040 } 2041 2042 OMX_U32 omx_venc::dev_set_message_thread_id(pthread_t tid) 2043 { 2044 return handle->venc_set_message_thread_id(tid); 2045 } 2046 2047 bool omx_venc::dev_use_buf(void *buf_addr,unsigned port,unsigned index) 2048 { 2049 return handle->venc_use_buf(buf_addr,port,index); 2050 } 2051 2052 bool omx_venc::dev_free_buf(void *buf_addr,unsigned port) 2053 { 2054 return handle->venc_free_buf(buf_addr,port); 2055 } 2056 2057 bool omx_venc::dev_empty_buf(void *buffer, void *pmem_data_buf,unsigned index,unsigned fd) 2058 { 2059 bool bret = false; 2060 bret = handle->venc_empty_buf(buffer, pmem_data_buf,index,fd); 2061 hw_overload = handle->hw_overload; 2062 return bret; 2063 } 2064 2065 bool omx_venc::dev_fill_buf(void *buffer, void *pmem_data_buf,unsigned index,unsigned fd) 2066 { 2067 return handle->venc_fill_buf(buffer, pmem_data_buf,index,fd); 2068 } 2069 2070 bool omx_venc::dev_get_seq_hdr(void *buffer, unsigned size, unsigned *hdrlen) 2071 { 2072 return handle->venc_get_seq_hdr(buffer, size, hdrlen); 2073 } 2074 2075 bool omx_venc::dev_get_capability_ltrcount(OMX_U32 *min, OMX_U32 *max, OMX_U32 *step_size) 2076 { 2077 #ifdef _MSM8974_ 2078 (void) min; 2079 (void) max; 2080 (void) step_size; 2081 DEBUG_PRINT_ERROR("Get Capability LTR Count is not supported"); 2082 return false; 2083 #else 2084 return handle->venc_get_capability_ltrcount(min, max, step_size); 2085 #endif 2086 } 2087 2088 bool omx_venc::dev_get_performance_level(OMX_U32 *perflevel) 2089 { 2090 #ifdef _MSM8974_ 2091 return handle->venc_get_performance_level(perflevel); 2092 #else 2093 DEBUG_PRINT_ERROR("Get performance level is not supported"); 2094 return false; 2095 #endif 2096 } 2097 2098 bool omx_venc::dev_get_vui_timing_info(OMX_U32 *enabled) 2099 { 2100 #ifdef _MSM8974_ 2101 return handle->venc_get_vui_timing_info(enabled); 2102 #else 2103 DEBUG_PRINT_ERROR("Get vui timing information is not supported"); 2104 return false; 2105 #endif 2106 } 2107 2108 bool omx_venc::dev_get_peak_bitrate(OMX_U32 *peakbitrate) 2109 { 2110 #ifdef _MSM8974_ 2111 return handle->venc_get_peak_bitrate(peakbitrate); 2112 #else 2113 DEBUG_PRINT_ERROR("Get peak bitrate is not supported"); 2114 return false; 2115 #endif 2116 } 2117 2118 bool omx_venc::dev_get_temporal_layer_caps(OMX_U32 *nMaxLayers, 2119 OMX_U32 *nMaxBLayers) { 2120 return handle->venc_get_temporal_layer_caps(nMaxLayers, nMaxBLayers); 2121 } 2122 2123 bool omx_venc::dev_loaded_start() 2124 { 2125 return handle->venc_loaded_start(); 2126 } 2127 2128 bool omx_venc::dev_loaded_stop() 2129 { 2130 return handle->venc_loaded_stop(); 2131 } 2132 2133 bool omx_venc::dev_loaded_start_done() 2134 { 2135 return handle->venc_loaded_start_done(); 2136 } 2137 2138 bool omx_venc::dev_loaded_stop_done() 2139 { 2140 return handle->venc_loaded_stop_done(); 2141 } 2142 2143 bool omx_venc::dev_get_buf_req(OMX_U32 *min_buff_count, 2144 OMX_U32 *actual_buff_count, 2145 OMX_U32 *buff_size, 2146 OMX_U32 port) 2147 { 2148 return handle->venc_get_buf_req(min_buff_count, 2149 actual_buff_count, 2150 buff_size, 2151 port); 2152 2153 } 2154 2155 bool omx_venc::dev_set_buf_req(OMX_U32 *min_buff_count, 2156 OMX_U32 *actual_buff_count, 2157 OMX_U32 *buff_size, 2158 OMX_U32 port) 2159 { 2160 return handle->venc_set_buf_req(min_buff_count, 2161 actual_buff_count, 2162 buff_size, 2163 port); 2164 2165 } 2166 2167 bool omx_venc::dev_is_video_session_supported(OMX_U32 width, OMX_U32 height) 2168 { 2169 #ifdef _MSM8974_ 2170 return handle->venc_is_video_session_supported(width,height); 2171 #else 2172 DEBUG_PRINT_LOW("Check against video capability not supported"); 2173 return true; 2174 #endif 2175 } 2176 2177 #ifdef _MSM8974_ 2178 int omx_venc::dev_handle_extradata(void *buffer, int index) 2179 { 2180 return handle->handle_extradata(buffer, index); 2181 } 2182 2183 int omx_venc::dev_set_format(int color) 2184 { 2185 return handle->venc_set_format(color); 2186 } 2187 #endif 2188 2189 int omx_venc::async_message_process (void *context, void* message) 2190 { 2191 omx_video* omx = NULL; 2192 struct venc_msg *m_sVenc_msg = NULL; 2193 OMX_BUFFERHEADERTYPE* omxhdr = NULL; 2194 struct venc_buffer *temp_buff = NULL; 2195 2196 if (context == NULL || message == NULL) { 2197 DEBUG_PRINT_ERROR("ERROR: omx_venc::async_message_process invalid i/p params"); 2198 return -1; 2199 } 2200 m_sVenc_msg = (struct venc_msg *)message; 2201 2202 omx = reinterpret_cast<omx_video*>(context); 2203 2204 if (m_sVenc_msg->statuscode != VEN_S_SUCCESS) { 2205 DEBUG_PRINT_ERROR("ERROR: async_msg_process() - Error statuscode = %lu", 2206 m_sVenc_msg->statuscode); 2207 if(m_sVenc_msg->msgcode == VEN_MSG_HW_OVERLOAD) { 2208 omx->omx_report_hw_overload(); 2209 } else 2210 omx->omx_report_error(); 2211 } 2212 2213 DEBUG_PRINT_LOW("omx_venc::async_message_process- msgcode = %lu", 2214 m_sVenc_msg->msgcode); 2215 switch (m_sVenc_msg->msgcode) { 2216 case VEN_MSG_START: 2217 omx->post_event (0,m_sVenc_msg->statuscode,\ 2218 OMX_COMPONENT_GENERATE_START_DONE); 2219 break; 2220 case VEN_MSG_STOP: 2221 omx->post_event (0,m_sVenc_msg->statuscode,\ 2222 OMX_COMPONENT_GENERATE_STOP_DONE); 2223 break; 2224 case VEN_MSG_RESUME: 2225 omx->post_event (0,m_sVenc_msg->statuscode,\ 2226 OMX_COMPONENT_GENERATE_RESUME_DONE); 2227 break; 2228 case VEN_MSG_PAUSE: 2229 omx->post_event (0,m_sVenc_msg->statuscode,\ 2230 OMX_COMPONENT_GENERATE_PAUSE_DONE); 2231 break; 2232 case VEN_MSG_FLUSH_INPUT_DONE: 2233 2234 omx->post_event (0,m_sVenc_msg->statuscode,\ 2235 OMX_COMPONENT_GENERATE_EVENT_INPUT_FLUSH); 2236 break; 2237 case VEN_MSG_FLUSH_OUPUT_DONE: 2238 omx->post_event (0,m_sVenc_msg->statuscode,\ 2239 OMX_COMPONENT_GENERATE_EVENT_OUTPUT_FLUSH); 2240 break; 2241 case VEN_MSG_INPUT_BUFFER_DONE: 2242 omxhdr = (OMX_BUFFERHEADERTYPE* )\ 2243 m_sVenc_msg->buf.clientdata; 2244 2245 if (omxhdr == NULL || 2246 (((OMX_U32)(omxhdr - omx->m_inp_mem_ptr) > omx->m_sInPortDef.nBufferCountActual) && 2247 ((OMX_U32)(omxhdr - omx->meta_buffer_hdr) > omx->m_sInPortDef.nBufferCountActual))) { 2248 omxhdr = NULL; 2249 m_sVenc_msg->statuscode = VEN_S_EFAIL; 2250 } 2251 2252 #ifdef _ANDROID_ICS_ 2253 omx->omx_release_meta_buffer(omxhdr); 2254 #endif 2255 omx->post_event ((unsigned long)omxhdr,m_sVenc_msg->statuscode, 2256 OMX_COMPONENT_GENERATE_EBD); 2257 break; 2258 case VEN_MSG_OUTPUT_BUFFER_DONE: 2259 { 2260 omxhdr = (OMX_BUFFERHEADERTYPE*)m_sVenc_msg->buf.clientdata; 2261 OMX_U32 bufIndex = (OMX_U32)(omxhdr - omx->m_out_mem_ptr); 2262 2263 if ( (omxhdr != NULL) && 2264 (bufIndex < omx->m_sOutPortDef.nBufferCountActual)) { 2265 auto_lock l(omx->m_buf_lock); 2266 if (BITMASK_ABSENT(&(omx->m_out_bm_count), bufIndex)) { 2267 DEBUG_PRINT_ERROR("Recieved FBD for buffer that is already freed !"); 2268 break; 2269 } 2270 if (!omx->is_secure_session() && (m_sVenc_msg->buf.len <= omxhdr->nAllocLen)) { 2271 omxhdr->nFilledLen = m_sVenc_msg->buf.len; 2272 omxhdr->nOffset = m_sVenc_msg->buf.offset; 2273 omxhdr->nTimeStamp = m_sVenc_msg->buf.timestamp; 2274 DEBUG_PRINT_LOW("o/p TS = %u", (unsigned int)m_sVenc_msg->buf.timestamp); 2275 omxhdr->nFlags = m_sVenc_msg->buf.flags; 2276 2277 /*Use buffer case*/ 2278 if (omx->output_use_buffer && !omx->m_use_output_pmem && !omx->is_secure_session()) { 2279 DEBUG_PRINT_LOW("memcpy() for o/p Heap UseBuffer"); 2280 memcpy(omxhdr->pBuffer, 2281 (m_sVenc_msg->buf.ptrbuffer), 2282 m_sVenc_msg->buf.len); 2283 } 2284 } else { 2285 omxhdr->nFilledLen = 0; 2286 } 2287 2288 } else { 2289 omxhdr = NULL; 2290 m_sVenc_msg->statuscode = VEN_S_EFAIL; 2291 } 2292 omx->post_event ((unsigned long)omxhdr,m_sVenc_msg->statuscode, 2293 OMX_COMPONENT_GENERATE_FBD); 2294 break; 2295 } 2296 case VEN_MSG_NEED_OUTPUT_BUFFER: 2297 //TBD what action needs to be done here?? 2298 break; 2299 #ifndef _MSM8974_ 2300 case VEN_MSG_LTRUSE_FAILED: 2301 DEBUG_PRINT_ERROR("LTRUSE Failed!"); 2302 omx->post_event (NULL,m_sVenc_msg->statuscode, 2303 OMX_COMPONENT_GENERATE_LTRUSE_FAILED); 2304 break; 2305 #endif 2306 default: 2307 DEBUG_PRINT_HIGH("Unknown msg received : %lu", m_sVenc_msg->msgcode); 2308 break; 2309 } 2310 return 0; 2311 } 2312 2313 bool omx_venc::dev_color_align(OMX_BUFFERHEADERTYPE *buffer, 2314 OMX_U32 width, OMX_U32 height) 2315 { 2316 if(secure_session) { 2317 DEBUG_PRINT_ERROR("Cannot align colors in secure session."); 2318 return OMX_FALSE; 2319 } 2320 return handle->venc_color_align(buffer, width,height); 2321 } 2322 2323 bool omx_venc::is_secure_session() 2324 { 2325 return secure_session; 2326 } 2327 2328 bool omx_venc::dev_get_output_log_flag() 2329 { 2330 return handle->venc_get_output_log_flag(); 2331 } 2332 2333 int omx_venc::dev_output_log_buffers(const char *buffer, int bufferlen) 2334 { 2335 return handle->venc_output_log_buffers(buffer, bufferlen); 2336 } 2337 2338 int omx_venc::dev_extradata_log_buffers(char *buffer) 2339 { 2340 return handle->venc_extradata_log_buffers(buffer); 2341 } 2342
