1/*-------------------------------------------------------------------------- 2Copyright (c) 2010-2014, The Linux Foundation. All rights reserved. 3 4Redistribution and use in source and binary forms, with or without 5modification, 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 16THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 17AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 19NON-INFRINGEMENT ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 20CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 21EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 22PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; 23OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 24WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 25OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF 26ADVISED 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 51extern int m_pipe; 52static int bframes; 53static int entropy; 54static int perfmode; 55static int hybrid_hp; 56// factory function executed by the core to create instances 57void *get_omx_component_factory_fn(void) 58{ 59 return(new omx_venc); 60} 61 62//constructor 63 64omx_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 94omx_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 ========================================================================== */ 118OMX_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 m_state = OMX_StateLoaded; 474 m_sExtraData = 0; 475 476 if (eRet == OMX_ErrorNone) { 477 if (pipe(fds)) { 478 DEBUG_PRINT_ERROR("ERROR: pipe creation failed"); 479 eRet = OMX_ErrorInsufficientResources; 480 } else { 481 if (fds[0] == 0 || fds[1] == 0) { 482 if (pipe(fds)) { 483 DEBUG_PRINT_ERROR("ERROR: pipe creation failed"); 484 eRet = OMX_ErrorInsufficientResources; 485 } 486 } 487 if (eRet == OMX_ErrorNone) { 488 m_pipe_in = fds[0]; 489 m_pipe_out = fds[1]; 490 } 491 } 492 msg_thread_created = true; 493 r = pthread_create(&msg_thread_id,0, message_thread, this); 494 if (r < 0) { 495 eRet = OMX_ErrorInsufficientResources; 496 msg_thread_created = false; 497 } else { 498 async_thread_created = true; 499 r = pthread_create(&async_thread_id,0, venc_dev::async_venc_message_thread, this); 500 if (r < 0) { 501 eRet = OMX_ErrorInsufficientResources; 502 async_thread_created = false; 503 } else 504 dev_set_message_thread_id(async_thread_id); 505 } 506 } 507 508 if (perfmode) { 509 QOMX_EXTNINDEX_VIDEO_PERFMODE pParam; 510 pParam.nPerfMode = perfmode; 511 DEBUG_PRINT_LOW("Perfmode = 0x%x", pParam.nPerfMode); 512 if (!handle->venc_set_config(&pParam, (OMX_INDEXTYPE)OMX_QcomIndexConfigVideoVencPerfMode)) 513 DEBUG_PRINT_ERROR("Failed setting PerfMode to %d", pParam.nPerfMode); 514 } 515 516 if (hybrid_hp) 517 { 518 if (hybrid_hp <= MAX_HYB_HIERP_LAYERS) { 519 QOMX_EXTNINDEX_VIDEO_HYBRID_HP_MODE hyb_hp; 520 hyb_hp.nHpLayers = hybrid_hp; 521 DEBUG_PRINT_LOW("hybrid_hp = 0x%x", hyb_hp.nHpLayers); 522 if (!handle->venc_set_param(&hyb_hp, (OMX_INDEXTYPE)OMX_QcomIndexParamVideoHybridHierpMode)) { 523 DEBUG_PRINT_ERROR("Failed setting hybrid_hp to %d", hyb_hp.nHpLayers); 524 } 525 } else { 526 DEBUG_PRINT_ERROR("Max hybrid_hp layers supported is %d", hybrid_hp); 527 } 528 } 529 DEBUG_PRINT_INFO("Component_init : %s : return = 0x%x", m_nkind, eRet); 530 return eRet; 531init_error: 532 handle->venc_close(); 533 delete handle; 534 handle = NULL; 535 return eRet; 536} 537 538 539/* ====================================================================== 540 FUNCTION 541 omx_venc::Setparameter 542 543 DESCRIPTION 544 OMX Set Parameter method implementation. 545 546 PARAMETERS 547 <TBD>. 548 549 RETURN VALUE 550 OMX Error None if successful. 551 552 ========================================================================== */ 553OMX_ERRORTYPE omx_venc::set_parameter(OMX_IN OMX_HANDLETYPE hComp, 554 OMX_IN OMX_INDEXTYPE paramIndex, 555 OMX_IN OMX_PTR paramData) 556{ 557 (void)hComp; 558 OMX_ERRORTYPE eRet = OMX_ErrorNone; 559 560 561 if (m_state == OMX_StateInvalid) { 562 DEBUG_PRINT_ERROR("ERROR: Set Param in Invalid State"); 563 return OMX_ErrorInvalidState; 564 } 565 if (paramData == NULL) { 566 DEBUG_PRINT_ERROR("ERROR: Get Param in Invalid paramData"); 567 return OMX_ErrorBadParameter; 568 } 569 570 /*set_parameter can be called in loaded state 571 or disabled port */ 572 if (m_state == OMX_StateLoaded 573 || m_sInPortDef.bEnabled == OMX_FALSE 574 || m_sOutPortDef.bEnabled == OMX_FALSE) { 575 DEBUG_PRINT_LOW("Set Parameter called in valid state"); 576 } else { 577 DEBUG_PRINT_ERROR("ERROR: Set Parameter called in Invalid State"); 578 return OMX_ErrorIncorrectStateOperation; 579 } 580 581 switch ((int)paramIndex) { 582 case OMX_IndexParamPortDefinition: 583 { 584 VALIDATE_OMX_PARAM_DATA(paramData, OMX_PARAM_PORTDEFINITIONTYPE); 585 OMX_PARAM_PORTDEFINITIONTYPE *portDefn; 586 portDefn = (OMX_PARAM_PORTDEFINITIONTYPE *) paramData; 587 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamPortDefinition H= %d, W = %d", 588 (int)portDefn->format.video.nFrameHeight, 589 (int)portDefn->format.video.nFrameWidth); 590 591 if (PORT_INDEX_IN == portDefn->nPortIndex) { 592 if (!dev_is_video_session_supported(portDefn->format.video.nFrameWidth, 593 portDefn->format.video.nFrameHeight)) { 594 DEBUG_PRINT_ERROR("video session not supported"); 595 omx_report_unsupported_setting(); 596 return OMX_ErrorUnsupportedSetting; 597 } 598 DEBUG_PRINT_LOW("i/p actual cnt requested = %u", (unsigned int)portDefn->nBufferCountActual); 599 DEBUG_PRINT_LOW("i/p min cnt requested = %u", (unsigned int)portDefn->nBufferCountMin); 600 DEBUG_PRINT_LOW("i/p buffersize requested = %u", (unsigned int)portDefn->nBufferSize); 601 if (portDefn->nBufferCountActual > MAX_NUM_INPUT_BUFFERS) { 602 DEBUG_PRINT_ERROR("ERROR: (In_PORT) actual count (%u) exceeds max(%u)", 603 (unsigned int)portDefn->nBufferCountActual, (unsigned int)MAX_NUM_INPUT_BUFFERS); 604 return OMX_ErrorUnsupportedSetting; 605 } 606 if (portDefn->nBufferCountMin > portDefn->nBufferCountActual) { 607 DEBUG_PRINT_ERROR("ERROR: (In_PORT) Min buffers (%u) > actual count (%u)", 608 (unsigned int)portDefn->nBufferCountMin, (unsigned int)portDefn->nBufferCountActual); 609 return OMX_ErrorUnsupportedSetting; 610 } 611 if (handle->venc_set_param(paramData,OMX_IndexParamPortDefinition) != true) { 612 DEBUG_PRINT_ERROR("ERROR: venc_set_param input failed"); 613 return handle->hw_overload ? OMX_ErrorInsufficientResources : 614 OMX_ErrorUnsupportedSetting; 615 } 616 617 DEBUG_PRINT_LOW("i/p previous actual cnt = %u", (unsigned int)m_sInPortDef.nBufferCountActual); 618 DEBUG_PRINT_LOW("i/p previous min cnt = %u", (unsigned int)m_sInPortDef.nBufferCountMin); 619 memcpy(&m_sInPortDef, portDefn,sizeof(OMX_PARAM_PORTDEFINITIONTYPE)); 620 621#ifdef _ANDROID_ICS_ 622 if (portDefn->format.video.eColorFormat == 623 (OMX_COLOR_FORMATTYPE)QOMX_COLOR_FormatAndroidOpaque) { 624 m_sInPortDef.format.video.eColorFormat = (OMX_COLOR_FORMATTYPE) 625 QOMX_COLOR_FORMATYUV420PackedSemiPlanar32m; 626 if (!mUseProxyColorFormat) { 627 if (!c2d_conv.init()) { 628 DEBUG_PRINT_ERROR("C2D init failed"); 629 return OMX_ErrorUnsupportedSetting; 630 } 631 DEBUG_PRINT_HIGH("C2D init is successful"); 632 } 633 mUseProxyColorFormat = true; 634 m_input_msg_id = OMX_COMPONENT_GENERATE_ETB_OPQ; 635 } else 636 mUseProxyColorFormat = false; 637#endif 638 /*Query Input Buffer Requirements*/ 639 dev_get_buf_req (&m_sInPortDef.nBufferCountMin, 640 &m_sInPortDef.nBufferCountActual, 641 &m_sInPortDef.nBufferSize, 642 m_sInPortDef.nPortIndex); 643 644 /*Query ouput Buffer Requirements*/ 645 dev_get_buf_req (&m_sOutPortDef.nBufferCountMin, 646 &m_sOutPortDef.nBufferCountActual, 647 &m_sOutPortDef.nBufferSize, 648 m_sOutPortDef.nPortIndex); 649 m_sInPortDef.nBufferCountActual = portDefn->nBufferCountActual; 650 } else if (PORT_INDEX_OUT == portDefn->nPortIndex) { 651 DEBUG_PRINT_LOW("o/p actual cnt requested = %u", (unsigned int)portDefn->nBufferCountActual); 652 DEBUG_PRINT_LOW("o/p min cnt requested = %u", (unsigned int)portDefn->nBufferCountMin); 653 DEBUG_PRINT_LOW("o/p buffersize requested = %u", (unsigned int)portDefn->nBufferSize); 654 655 if (portDefn->nBufferCountActual > MAX_NUM_OUTPUT_BUFFERS) { 656 DEBUG_PRINT_ERROR("ERROR: (Out_PORT) actual count (%u) exceeds max(%u)", 657 (unsigned int)portDefn->nBufferCountActual, (unsigned int)MAX_NUM_OUTPUT_BUFFERS); 658 return OMX_ErrorUnsupportedSetting; 659 } 660 if (portDefn->nBufferCountMin > portDefn->nBufferCountActual) { 661 DEBUG_PRINT_ERROR("ERROR: (Out_PORT) Min buffers (%u) > actual count (%u)", 662 (unsigned int)portDefn->nBufferCountMin, (unsigned int)portDefn->nBufferCountActual); 663 return OMX_ErrorUnsupportedSetting; 664 } 665 if (handle->venc_set_param(paramData,OMX_IndexParamPortDefinition) != true) { 666 DEBUG_PRINT_ERROR("ERROR: venc_set_param output failed"); 667 return OMX_ErrorUnsupportedSetting; 668 } 669#ifdef _MSM8974_ 670 /*Query ouput Buffer Requirements*/ 671 dev_get_buf_req(&m_sOutPortDef.nBufferCountMin, 672 &m_sOutPortDef.nBufferCountActual, 673 &m_sOutPortDef.nBufferSize, 674 m_sOutPortDef.nPortIndex); 675#endif 676 memcpy(&m_sOutPortDef,portDefn,sizeof(struct OMX_PARAM_PORTDEFINITIONTYPE)); 677 update_profile_level(); //framerate , bitrate 678 679 DEBUG_PRINT_LOW("o/p previous actual cnt = %u", (unsigned int)m_sOutPortDef.nBufferCountActual); 680 DEBUG_PRINT_LOW("o/p previous min cnt = %u", (unsigned int)m_sOutPortDef.nBufferCountMin); 681 m_sOutPortDef.nBufferCountActual = portDefn->nBufferCountActual; 682 } else { 683 DEBUG_PRINT_ERROR("ERROR: Set_parameter: Bad Port idx %d", 684 (int)portDefn->nPortIndex); 685 eRet = OMX_ErrorBadPortIndex; 686 } 687 m_sConfigFramerate.xEncodeFramerate = portDefn->format.video.xFramerate; 688 m_sConfigBitrate.nEncodeBitrate = portDefn->format.video.nBitrate; 689 m_sParamBitrate.nTargetBitrate = portDefn->format.video.nBitrate; 690 } 691 break; 692 693 case OMX_IndexParamVideoPortFormat: 694 { 695 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_PORTFORMATTYPE); 696 OMX_VIDEO_PARAM_PORTFORMATTYPE *portFmt = 697 (OMX_VIDEO_PARAM_PORTFORMATTYPE *)paramData; 698 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoPortFormat %d", 699 portFmt->eColorFormat); 700 //set the driver with the corresponding values 701 if (PORT_INDEX_IN == portFmt->nPortIndex) { 702 if (handle->venc_set_param(paramData,OMX_IndexParamVideoPortFormat) != true) { 703 return OMX_ErrorUnsupportedSetting; 704 } 705 706 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoPortFormat %d", 707 portFmt->eColorFormat); 708 update_profile_level(); //framerate 709 710#ifdef _ANDROID_ICS_ 711 if (portFmt->eColorFormat == 712 (OMX_COLOR_FORMATTYPE)QOMX_COLOR_FormatAndroidOpaque) { 713 m_sInPortFormat.eColorFormat = (OMX_COLOR_FORMATTYPE) 714 QOMX_COLOR_FORMATYUV420PackedSemiPlanar32m; 715 if (!mUseProxyColorFormat) { 716 if (!c2d_conv.init()) { 717 DEBUG_PRINT_ERROR("C2D init failed"); 718 return OMX_ErrorUnsupportedSetting; 719 } 720 DEBUG_PRINT_HIGH("C2D init is successful"); 721 } 722 mUseProxyColorFormat = true; 723 m_input_msg_id = OMX_COMPONENT_GENERATE_ETB_OPQ; 724 } else 725#endif 726 { 727 m_sInPortFormat.eColorFormat = portFmt->eColorFormat; 728 m_sInPortDef.format.video.eColorFormat = portFmt->eColorFormat; 729 m_input_msg_id = OMX_COMPONENT_GENERATE_ETB; 730 mUseProxyColorFormat = false; 731 } 732 m_sInPortFormat.xFramerate = portFmt->xFramerate; 733 } 734 //TODO if no use case for O/P port,delet m_sOutPortFormat 735 } 736 break; 737 case OMX_IndexParamVideoInit: 738 { //TODO, do we need this index set param 739 VALIDATE_OMX_PARAM_DATA(paramData, OMX_PORT_PARAM_TYPE); 740 OMX_PORT_PARAM_TYPE* pParam = (OMX_PORT_PARAM_TYPE*)(paramData); 741 DEBUG_PRINT_LOW("Set OMX_IndexParamVideoInit called"); 742 break; 743 } 744 745 case OMX_IndexParamVideoBitrate: 746 { 747 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_BITRATETYPE); 748 OMX_VIDEO_PARAM_BITRATETYPE* pParam = (OMX_VIDEO_PARAM_BITRATETYPE*)paramData; 749 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoBitrate"); 750 if (handle->venc_set_param(paramData,OMX_IndexParamVideoBitrate) != true) { 751 return OMX_ErrorUnsupportedSetting; 752 } 753 m_sParamBitrate.nTargetBitrate = pParam->nTargetBitrate; 754 m_sParamBitrate.eControlRate = pParam->eControlRate; 755 update_profile_level(); //bitrate 756 m_sConfigBitrate.nEncodeBitrate = pParam->nTargetBitrate; 757 m_sInPortDef.format.video.nBitrate = pParam->nTargetBitrate; 758 m_sOutPortDef.format.video.nBitrate = pParam->nTargetBitrate; 759 DEBUG_PRINT_LOW("bitrate = %u", (unsigned int)m_sOutPortDef.format.video.nBitrate); 760 break; 761 } 762 case OMX_IndexParamVideoMpeg4: 763 { 764 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_MPEG4TYPE); 765 OMX_VIDEO_PARAM_MPEG4TYPE* pParam = (OMX_VIDEO_PARAM_MPEG4TYPE*)paramData; 766 OMX_VIDEO_PARAM_MPEG4TYPE mp4_param; 767 memcpy(&mp4_param, pParam, sizeof(struct OMX_VIDEO_PARAM_MPEG4TYPE)); 768 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoMpeg4"); 769 if (pParam->eProfile == OMX_VIDEO_MPEG4ProfileAdvancedSimple) { 770#ifdef MAX_RES_1080P 771 if (pParam->nBFrames) { 772 DEBUG_PRINT_HIGH("INFO: Only 1 Bframe is supported"); 773 mp4_param.nBFrames = 1; 774 } 775#else 776 if (pParam->nBFrames) { 777 DEBUG_PRINT_ERROR("Warning: B frames not supported"); 778 mp4_param.nBFrames = 0; 779 } 780#endif 781#ifdef _MSM8974_ 782 if (pParam->nBFrames || bframes) 783 mp4_param.nBFrames = (pParam->nBFrames > (unsigned int) bframes)? pParam->nBFrames : bframes; 784 DEBUG_PRINT_HIGH("MPEG4: %u BFrames are being set", (unsigned int)mp4_param.nBFrames); 785#endif 786 787 } else { 788 if (pParam->nBFrames) { 789 DEBUG_PRINT_ERROR("Warning: B frames not supported"); 790 mp4_param.nBFrames = 0; 791 } 792 } 793 if (handle->venc_set_param(&mp4_param,OMX_IndexParamVideoMpeg4) != true) { 794 return OMX_ErrorUnsupportedSetting; 795 } 796 memcpy(&m_sParamMPEG4,pParam, sizeof(struct OMX_VIDEO_PARAM_MPEG4TYPE)); 797 m_sIntraperiod.nPFrames = m_sParamMPEG4.nPFrames; 798 if (pParam->nBFrames || bframes) 799 m_sIntraperiod.nBFrames = m_sParamMPEG4.nBFrames = mp4_param.nBFrames; 800 else 801 m_sIntraperiod.nBFrames = m_sParamMPEG4.nBFrames; 802 break; 803 } 804 case OMX_IndexParamVideoH263: 805 { 806 OMX_VIDEO_PARAM_H263TYPE* pParam = (OMX_VIDEO_PARAM_H263TYPE*)paramData; 807 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoH263"); 808 if (handle->venc_set_param(paramData,OMX_IndexParamVideoH263) != true) { 809 return OMX_ErrorUnsupportedSetting; 810 } 811 memcpy(&m_sParamH263,pParam, sizeof(struct OMX_VIDEO_PARAM_H263TYPE)); 812 m_sIntraperiod.nPFrames = m_sParamH263.nPFrames; 813 m_sIntraperiod.nBFrames = m_sParamH263.nBFrames; 814 break; 815 } 816 case OMX_IndexParamVideoAvc: 817 { 818 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_AVCTYPE); 819 OMX_VIDEO_PARAM_AVCTYPE* pParam = (OMX_VIDEO_PARAM_AVCTYPE*)paramData; 820 OMX_VIDEO_PARAM_AVCTYPE avc_param; 821 memcpy(&avc_param, pParam, sizeof( struct OMX_VIDEO_PARAM_AVCTYPE)); 822 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoAvc"); 823 824 if ((pParam->eProfile == OMX_VIDEO_AVCProfileHigh)|| 825 (pParam->eProfile == OMX_VIDEO_AVCProfileMain)) { 826#ifdef MAX_RES_1080P 827 if (pParam->nBFrames) { 828 DEBUG_PRINT_HIGH("INFO: Only 1 Bframe is supported"); 829 avc_param.nBFrames = 1; 830 } 831 if (pParam->nRefFrames != 2) { 832 DEBUG_PRINT_ERROR("Warning: 2 RefFrames are needed, changing RefFrames from %u to 2", (unsigned int)pParam->nRefFrames); 833 avc_param.nRefFrames = 2; 834 } 835#else 836 if (pParam->nBFrames) { 837 DEBUG_PRINT_ERROR("Warning: B frames not supported"); 838 avc_param.nBFrames = 0; 839 } 840 if (pParam->nRefFrames != 1) { 841 DEBUG_PRINT_ERROR("Warning: Only 1 RefFrame is supported, changing RefFrame from %u to 1)", (unsigned int)pParam->nRefFrames); 842 avc_param.nRefFrames = 1; 843 } 844#endif 845#ifdef _MSM8974_ 846 if (pParam->nBFrames || bframes) { 847 avc_param.nBFrames = (pParam->nBFrames > (unsigned int) bframes)? pParam->nBFrames : bframes; 848 avc_param.nRefFrames = (avc_param.nBFrames < 4)? avc_param.nBFrames + 1 : 4; 849 } 850 DEBUG_PRINT_HIGH("AVC: RefFrames: %u, BFrames: %u", (unsigned int)avc_param.nRefFrames, (unsigned int)avc_param.nBFrames); 851 852 avc_param.bEntropyCodingCABAC = (OMX_BOOL)(avc_param.bEntropyCodingCABAC && entropy); 853 avc_param.nCabacInitIdc = entropy ? avc_param.nCabacInitIdc : 0; 854#endif 855 } else { 856 if (pParam->nRefFrames != 1) { 857 DEBUG_PRINT_ERROR("Warning: Only 1 RefFrame is supported, changing RefFrame from %u to 1)", (unsigned int)pParam->nRefFrames); 858 avc_param.nRefFrames = 1; 859 } 860 if (pParam->nBFrames) { 861 DEBUG_PRINT_ERROR("Warning: B frames not supported"); 862 avc_param.nBFrames = 0; 863 } 864 } 865 if (handle->venc_set_param(&avc_param,OMX_IndexParamVideoAvc) != true) { 866 return OMX_ErrorUnsupportedSetting; 867 } 868 memcpy(&m_sParamAVC,pParam, sizeof(struct OMX_VIDEO_PARAM_AVCTYPE)); 869 m_sIntraperiod.nPFrames = m_sParamAVC.nPFrames; 870 if (pParam->nBFrames || bframes) 871 m_sIntraperiod.nBFrames = m_sParamAVC.nBFrames = avc_param.nBFrames; 872 else 873 m_sIntraperiod.nBFrames = m_sParamAVC.nBFrames; 874 break; 875 } 876 case (OMX_INDEXTYPE)OMX_IndexParamVideoVp8: 877 { 878 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_VP8TYPE); 879 OMX_VIDEO_PARAM_VP8TYPE* pParam = (OMX_VIDEO_PARAM_VP8TYPE*)paramData; 880 OMX_VIDEO_PARAM_VP8TYPE vp8_param; 881 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoVp8"); 882 if (pParam->nDCTPartitions != m_sParamVP8.nDCTPartitions || 883 pParam->bErrorResilientMode != m_sParamVP8.bErrorResilientMode) { 884 DEBUG_PRINT_ERROR("VP8 doesn't support nDCTPartitions or bErrorResilientMode"); 885 } 886 memcpy(&vp8_param, pParam, sizeof( struct OMX_VIDEO_PARAM_VP8TYPE)); 887 if (handle->venc_set_param(&vp8_param, (OMX_INDEXTYPE)OMX_IndexParamVideoVp8) != true) { 888 return OMX_ErrorUnsupportedSetting; 889 } 890 memcpy(&m_sParamVP8,pParam, sizeof(struct OMX_VIDEO_PARAM_VP8TYPE)); 891 break; 892 } 893 case (OMX_INDEXTYPE)OMX_IndexParamVideoHevc: 894 { 895 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_HEVCTYPE); 896 OMX_VIDEO_PARAM_HEVCTYPE* pParam = (OMX_VIDEO_PARAM_HEVCTYPE*)paramData; 897 OMX_VIDEO_PARAM_HEVCTYPE hevc_param; 898 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoHevc"); 899 memcpy(&hevc_param, pParam, sizeof( struct OMX_VIDEO_PARAM_HEVCTYPE)); 900 if (handle->venc_set_param(&hevc_param, (OMX_INDEXTYPE)OMX_IndexParamVideoHevc) != true) { 901 DEBUG_PRINT_ERROR("Failed : set_parameter: OMX_IndexParamVideoHevc"); 902 return OMX_ErrorUnsupportedSetting; 903 } 904 memcpy(&m_sParamHEVC, pParam, sizeof(struct OMX_VIDEO_PARAM_HEVCTYPE)); 905 break; 906 } 907 case OMX_IndexParamVideoProfileLevelCurrent: 908 { 909 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_PROFILELEVELTYPE); 910 OMX_VIDEO_PARAM_PROFILELEVELTYPE* pParam = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)paramData; 911 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoProfileLevelCurrent"); 912 if (handle->venc_set_param(pParam,OMX_IndexParamVideoProfileLevelCurrent) != true) { 913 DEBUG_PRINT_ERROR("set_parameter: OMX_IndexParamVideoProfileLevelCurrent failed for Profile: %u " 914 "Level :%u", (unsigned int)pParam->eProfile, (unsigned int)pParam->eLevel); 915 return OMX_ErrorUnsupportedSetting; 916 } 917 m_sParamProfileLevel.eProfile = pParam->eProfile; 918 m_sParamProfileLevel.eLevel = pParam->eLevel; 919 920 if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.mpeg4",\ 921 OMX_MAX_STRINGNAME_SIZE)) { 922 m_sParamMPEG4.eProfile = (OMX_VIDEO_MPEG4PROFILETYPE)m_sParamProfileLevel.eProfile; 923 m_sParamMPEG4.eLevel = (OMX_VIDEO_MPEG4LEVELTYPE)m_sParamProfileLevel.eLevel; 924 DEBUG_PRINT_LOW("MPEG4 profile = %d, level = %d", m_sParamMPEG4.eProfile, 925 m_sParamMPEG4.eLevel); 926 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.h263",\ 927 OMX_MAX_STRINGNAME_SIZE)) { 928 m_sParamH263.eProfile = (OMX_VIDEO_H263PROFILETYPE)m_sParamProfileLevel.eProfile; 929 m_sParamH263.eLevel = (OMX_VIDEO_H263LEVELTYPE)m_sParamProfileLevel.eLevel; 930 DEBUG_PRINT_LOW("H263 profile = %d, level = %d", m_sParamH263.eProfile, 931 m_sParamH263.eLevel); 932 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc",\ 933 OMX_MAX_STRINGNAME_SIZE)) { 934 m_sParamAVC.eProfile = (OMX_VIDEO_AVCPROFILETYPE)m_sParamProfileLevel.eProfile; 935 m_sParamAVC.eLevel = (OMX_VIDEO_AVCLEVELTYPE)m_sParamProfileLevel.eLevel; 936 DEBUG_PRINT_LOW("AVC profile = %d, level = %d", m_sParamAVC.eProfile, 937 m_sParamAVC.eLevel); 938 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc.secure",\ 939 OMX_MAX_STRINGNAME_SIZE)) { 940 m_sParamAVC.eProfile = (OMX_VIDEO_AVCPROFILETYPE)m_sParamProfileLevel.eProfile; 941 m_sParamAVC.eLevel = (OMX_VIDEO_AVCLEVELTYPE)m_sParamProfileLevel.eLevel; 942 DEBUG_PRINT_LOW("\n AVC profile = %d, level = %d", m_sParamAVC.eProfile, 943 m_sParamAVC.eLevel); 944 } 945 else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.vp8",\ 946 OMX_MAX_STRINGNAME_SIZE)) { 947 m_sParamVP8.eProfile = (OMX_VIDEO_VP8PROFILETYPE)m_sParamProfileLevel.eProfile; 948 m_sParamVP8.eLevel = (OMX_VIDEO_VP8LEVELTYPE)m_sParamProfileLevel.eLevel; 949 DEBUG_PRINT_LOW("VP8 profile = %d, level = %d", m_sParamVP8.eProfile, 950 m_sParamVP8.eLevel); 951 } 952 else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.hevc",\ 953 OMX_MAX_STRINGNAME_SIZE)) { 954 m_sParamHEVC.eProfile = (OMX_VIDEO_HEVCPROFILETYPE)m_sParamProfileLevel.eProfile; 955 m_sParamHEVC.eLevel = (OMX_VIDEO_HEVCLEVELTYPE)m_sParamProfileLevel.eLevel; 956 DEBUG_PRINT_LOW("HEVC profile = %d, level = %d", m_sParamHEVC.eProfile, 957 m_sParamHEVC.eLevel); 958 } 959 960 break; 961 } 962 case OMX_IndexParamStandardComponentRole: 963 { 964 VALIDATE_OMX_PARAM_DATA(paramData, OMX_PARAM_COMPONENTROLETYPE); 965 OMX_PARAM_COMPONENTROLETYPE *comp_role; 966 comp_role = (OMX_PARAM_COMPONENTROLETYPE *) paramData; 967 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamStandardComponentRole %s", 968 comp_role->cRole); 969 970 if ((m_state == OMX_StateLoaded)&& 971 !BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING)) { 972 DEBUG_PRINT_LOW("Set Parameter called in valid state"); 973 } else { 974 DEBUG_PRINT_ERROR("Set Parameter called in Invalid State"); 975 return OMX_ErrorIncorrectStateOperation; 976 } 977 978 if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.avc",OMX_MAX_STRINGNAME_SIZE)) { 979 if (!strncmp((char*)comp_role->cRole,"video_encoder.avc",OMX_MAX_STRINGNAME_SIZE)) { 980 strlcpy((char*)m_cRole,"video_encoder.avc",OMX_MAX_STRINGNAME_SIZE); 981 } else { 982 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s", comp_role->cRole); 983 eRet =OMX_ErrorUnsupportedSetting; 984 } 985 } else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.avc.secure",OMX_MAX_STRINGNAME_SIZE)) { 986 if (!strncmp((char*)comp_role->cRole,"video_encoder.avc",OMX_MAX_STRINGNAME_SIZE)) { 987 strlcpy((char*)m_cRole,"video_encoder.avc",OMX_MAX_STRINGNAME_SIZE); 988 } else { 989 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s\n", comp_role->cRole); 990 eRet =OMX_ErrorUnsupportedSetting; 991 } 992 } else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.mpeg4",OMX_MAX_STRINGNAME_SIZE)) { 993 if (!strncmp((const char*)comp_role->cRole,"video_encoder.mpeg4",OMX_MAX_STRINGNAME_SIZE)) { 994 strlcpy((char*)m_cRole,"video_encoder.mpeg4",OMX_MAX_STRINGNAME_SIZE); 995 } else { 996 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s", comp_role->cRole); 997 eRet = OMX_ErrorUnsupportedSetting; 998 } 999 } else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.h263",OMX_MAX_STRINGNAME_SIZE)) { 1000 if (!strncmp((const char*)comp_role->cRole,"video_encoder.h263",OMX_MAX_STRINGNAME_SIZE)) { 1001 strlcpy((char*)m_cRole,"video_encoder.h263",OMX_MAX_STRINGNAME_SIZE); 1002 } else { 1003 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s", comp_role->cRole); 1004 eRet =OMX_ErrorUnsupportedSetting; 1005 } 1006 } 1007#ifdef _MSM8974_ 1008 else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.vp8",OMX_MAX_STRINGNAME_SIZE)) { 1009 if (!strncmp((const char*)comp_role->cRole,"video_encoder.vp8",OMX_MAX_STRINGNAME_SIZE)) { 1010 strlcpy((char*)m_cRole,"video_encoder.vp8",OMX_MAX_STRINGNAME_SIZE); 1011 } else { 1012 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s", comp_role->cRole); 1013 eRet =OMX_ErrorUnsupportedSetting; 1014 } 1015 } 1016#endif 1017 else if (!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.hevc",OMX_MAX_STRINGNAME_SIZE)) { 1018 if (!strncmp((const char*)comp_role->cRole,"video_encoder.hevc",OMX_MAX_STRINGNAME_SIZE)) { 1019 strlcpy((char*)m_cRole,"video_encoder.hevc",OMX_MAX_STRINGNAME_SIZE); 1020 } else { 1021 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s", comp_role->cRole); 1022 eRet = OMX_ErrorUnsupportedSetting; 1023 } 1024 } 1025 1026 else { 1027 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown param %s", m_nkind); 1028 eRet = OMX_ErrorInvalidComponentName; 1029 } 1030 break; 1031 } 1032 1033 case OMX_IndexParamPriorityMgmt: 1034 { 1035 VALIDATE_OMX_PARAM_DATA(paramData, OMX_PRIORITYMGMTTYPE); 1036 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamPriorityMgmt"); 1037 if (m_state != OMX_StateLoaded) { 1038 DEBUG_PRINT_ERROR("ERROR: Set Parameter called in Invalid State"); 1039 return OMX_ErrorIncorrectStateOperation; 1040 } 1041 OMX_PRIORITYMGMTTYPE *priorityMgmtype = (OMX_PRIORITYMGMTTYPE*) paramData; 1042 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamPriorityMgmt %u", 1043 (unsigned int)priorityMgmtype->nGroupID); 1044 1045 DEBUG_PRINT_LOW("set_parameter: priorityMgmtype %u", 1046 (unsigned int)priorityMgmtype->nGroupPriority); 1047 1048 m_sPriorityMgmt.nGroupID = priorityMgmtype->nGroupID; 1049 m_sPriorityMgmt.nGroupPriority = priorityMgmtype->nGroupPriority; 1050 1051 break; 1052 } 1053 1054 case OMX_IndexParamCompBufferSupplier: 1055 { 1056 VALIDATE_OMX_PARAM_DATA(paramData, OMX_PARAM_BUFFERSUPPLIERTYPE); 1057 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamCompBufferSupplier"); 1058 OMX_PARAM_BUFFERSUPPLIERTYPE *bufferSupplierType = (OMX_PARAM_BUFFERSUPPLIERTYPE*) paramData; 1059 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamCompBufferSupplier %d", 1060 bufferSupplierType->eBufferSupplier); 1061 if (bufferSupplierType->nPortIndex == 0 || bufferSupplierType->nPortIndex ==1) 1062 m_sInBufSupplier.eBufferSupplier = bufferSupplierType->eBufferSupplier; 1063 1064 else 1065 1066 eRet = OMX_ErrorBadPortIndex; 1067 1068 break; 1069 1070 } 1071 case OMX_IndexParamVideoQuantization: 1072 { 1073 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_QUANTIZATIONTYPE); 1074 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoQuantization"); 1075 OMX_VIDEO_PARAM_QUANTIZATIONTYPE *session_qp = (OMX_VIDEO_PARAM_QUANTIZATIONTYPE*) paramData; 1076 if (session_qp->nPortIndex == PORT_INDEX_OUT) { 1077 if (handle->venc_set_param(paramData, OMX_IndexParamVideoQuantization) != true) { 1078 return OMX_ErrorUnsupportedSetting; 1079 } 1080 m_sSessionQuantization.nQpI = session_qp->nQpI; 1081 m_sSessionQuantization.nQpP = session_qp->nQpP; 1082 m_sSessionQuantization.nQpB = session_qp->nQpB; 1083 } else { 1084 DEBUG_PRINT_ERROR("ERROR: Unsupported port Index for Session QP setting"); 1085 eRet = OMX_ErrorBadPortIndex; 1086 } 1087 break; 1088 } 1089 1090 case OMX_QcomIndexParamVideoQPRange: 1091 { 1092 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QCOM_VIDEO_PARAM_QPRANGETYPE); 1093 DEBUG_PRINT_LOW("set_parameter: OMX_QcomIndexParamVideoQPRange"); 1094 OMX_QCOM_VIDEO_PARAM_QPRANGETYPE *qp_range = (OMX_QCOM_VIDEO_PARAM_QPRANGETYPE*) paramData; 1095 if (qp_range->nPortIndex == PORT_INDEX_OUT) { 1096 if (handle->venc_set_param(paramData, 1097 (OMX_INDEXTYPE)OMX_QcomIndexParamVideoQPRange) != true) { 1098 return OMX_ErrorUnsupportedSetting; 1099 } 1100 m_sSessionQPRange.minQP= qp_range->minQP; 1101 m_sSessionQPRange.maxQP= qp_range->maxQP; 1102 } else { 1103 DEBUG_PRINT_ERROR("ERROR: Unsupported port Index for QP range setting"); 1104 eRet = OMX_ErrorBadPortIndex; 1105 } 1106 break; 1107 } 1108 1109 case OMX_QcomIndexPortDefn: 1110 { 1111 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QCOM_PARAM_PORTDEFINITIONTYPE); 1112 OMX_QCOM_PARAM_PORTDEFINITIONTYPE* pParam = 1113 (OMX_QCOM_PARAM_PORTDEFINITIONTYPE*)paramData; 1114 DEBUG_PRINT_LOW("set_parameter: OMX_QcomIndexPortDefn"); 1115 if (pParam->nPortIndex == (OMX_U32)PORT_INDEX_IN) { 1116 if (pParam->nMemRegion > OMX_QCOM_MemRegionInvalid && 1117 pParam->nMemRegion < OMX_QCOM_MemRegionMax) { 1118 m_use_input_pmem = OMX_TRUE; 1119 } else { 1120 m_use_input_pmem = OMX_FALSE; 1121 } 1122 } else if (pParam->nPortIndex == (OMX_U32)PORT_INDEX_OUT) { 1123 if (pParam->nMemRegion > OMX_QCOM_MemRegionInvalid && 1124 pParam->nMemRegion < OMX_QCOM_MemRegionMax) { 1125 m_use_output_pmem = OMX_TRUE; 1126 } else { 1127 m_use_output_pmem = OMX_FALSE; 1128 } 1129 } else { 1130 DEBUG_PRINT_ERROR("ERROR: SetParameter called on unsupported Port Index for QcomPortDefn"); 1131 return OMX_ErrorBadPortIndex; 1132 } 1133 break; 1134 } 1135 1136 case OMX_IndexParamVideoErrorCorrection: 1137 { 1138 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE); 1139 DEBUG_PRINT_LOW("OMX_IndexParamVideoErrorCorrection"); 1140 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE* pParam = 1141 (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE*)paramData; 1142 if (!handle->venc_set_param(paramData, OMX_IndexParamVideoErrorCorrection)) { 1143 DEBUG_PRINT_ERROR("ERROR: Request for setting Error Resilience failed"); 1144 return OMX_ErrorUnsupportedSetting; 1145 } 1146 memcpy(&m_sErrorCorrection,pParam, sizeof(m_sErrorCorrection)); 1147 break; 1148 } 1149 case OMX_IndexParamVideoIntraRefresh: 1150 { 1151 VALIDATE_OMX_PARAM_DATA(paramData, OMX_VIDEO_PARAM_INTRAREFRESHTYPE); 1152 DEBUG_PRINT_LOW("set_param:OMX_IndexParamVideoIntraRefresh"); 1153 OMX_VIDEO_PARAM_INTRAREFRESHTYPE* pParam = 1154 (OMX_VIDEO_PARAM_INTRAREFRESHTYPE*)paramData; 1155 if (!handle->venc_set_param(paramData,OMX_IndexParamVideoIntraRefresh)) { 1156 DEBUG_PRINT_ERROR("ERROR: Request for setting intra refresh failed"); 1157 return OMX_ErrorUnsupportedSetting; 1158 } 1159 memcpy(&m_sIntraRefresh, pParam, sizeof(m_sIntraRefresh)); 1160 break; 1161 } 1162#ifdef _ANDROID_ICS_ 1163 case OMX_QcomIndexParamVideoMetaBufferMode: 1164 { 1165 VALIDATE_OMX_PARAM_DATA(paramData, StoreMetaDataInBuffersParams); 1166 StoreMetaDataInBuffersParams *pParam = 1167 (StoreMetaDataInBuffersParams*)paramData; 1168 DEBUG_PRINT_HIGH("set_parameter:OMX_QcomIndexParamVideoMetaBufferMode: " 1169 "port_index = %u, meta_mode = %d", (unsigned int)pParam->nPortIndex, pParam->bStoreMetaData); 1170 if (pParam->nPortIndex == PORT_INDEX_IN) { 1171 if (pParam->bStoreMetaData != meta_mode_enable) { 1172 if (!handle->venc_set_meta_mode(pParam->bStoreMetaData)) { 1173 DEBUG_PRINT_ERROR("ERROR: set Metabuffer mode %d fail", 1174 pParam->bStoreMetaData); 1175 return OMX_ErrorUnsupportedSetting; 1176 } 1177 meta_mode_enable = pParam->bStoreMetaData; 1178 if (meta_mode_enable) { 1179 m_sInPortDef.nBufferCountActual = m_sInPortDef.nBufferCountMin; 1180 if (handle->venc_set_param(&m_sInPortDef,OMX_IndexParamPortDefinition) != true) { 1181 DEBUG_PRINT_ERROR("ERROR: venc_set_param input failed"); 1182 return OMX_ErrorUnsupportedSetting; 1183 } 1184 } else { 1185 /*TODO: reset encoder driver Meta mode*/ 1186 dev_get_buf_req (&m_sOutPortDef.nBufferCountMin, 1187 &m_sOutPortDef.nBufferCountActual, 1188 &m_sOutPortDef.nBufferSize, 1189 m_sOutPortDef.nPortIndex); 1190 } 1191 } 1192 } else if (pParam->nPortIndex == PORT_INDEX_OUT && secure_session) { 1193 if (pParam->bStoreMetaData != meta_mode_enable) { 1194 if (!handle->venc_set_meta_mode(pParam->bStoreMetaData)) { 1195 DEBUG_PRINT_ERROR("\nERROR: set Metabuffer mode %d fail", 1196 pParam->bStoreMetaData); 1197 return OMX_ErrorUnsupportedSetting; 1198 } 1199 meta_mode_enable = pParam->bStoreMetaData; 1200 } 1201 } else { 1202 DEBUG_PRINT_ERROR("set_parameter: metamode is " 1203 "valid for input port only"); 1204 eRet = OMX_ErrorUnsupportedIndex; 1205 } 1206 } 1207 break; 1208#endif 1209#if !defined(MAX_RES_720P) || defined(_MSM8974_) 1210 case OMX_QcomIndexParamIndexExtraDataType: 1211 { 1212 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_INDEXEXTRADATATYPE); 1213 DEBUG_PRINT_HIGH("set_parameter: OMX_QcomIndexParamIndexExtraDataType"); 1214 QOMX_INDEXEXTRADATATYPE *pParam = (QOMX_INDEXEXTRADATATYPE *)paramData; 1215 bool enable = false; 1216 OMX_U32 mask = 0; 1217 1218 if (pParam->nIndex == (OMX_INDEXTYPE)OMX_ExtraDataVideoEncoderSliceInfo) { 1219 if (pParam->nPortIndex == PORT_INDEX_OUT) { 1220 mask = VEN_EXTRADATA_SLICEINFO; 1221 1222 DEBUG_PRINT_HIGH("SliceInfo extradata %s", 1223 ((pParam->bEnabled == OMX_TRUE) ? "enabled" : "disabled")); 1224 } else { 1225 DEBUG_PRINT_ERROR("set_parameter: Slice information is " 1226 "valid for output port only"); 1227 eRet = OMX_ErrorUnsupportedIndex; 1228 break; 1229 } 1230 } else if (pParam->nIndex == (OMX_INDEXTYPE)OMX_ExtraDataVideoEncoderMBInfo) { 1231 if (pParam->nPortIndex == PORT_INDEX_OUT) { 1232 mask = VEN_EXTRADATA_MBINFO; 1233 1234 DEBUG_PRINT_HIGH("MBInfo extradata %s", 1235 ((pParam->bEnabled == OMX_TRUE) ? "enabled" : "disabled")); 1236 } else { 1237 DEBUG_PRINT_ERROR("set_parameter: MB information is " 1238 "valid for output port only"); 1239 eRet = OMX_ErrorUnsupportedIndex; 1240 break; 1241 } 1242 } 1243#ifndef _MSM8974_ 1244 else if (pParam->nIndex == (OMX_INDEXTYPE)OMX_ExtraDataVideoLTRInfo) { 1245 if (pParam->nPortIndex == PORT_INDEX_OUT) { 1246 if (pParam->bEnabled == OMX_TRUE) 1247 mask = VEN_EXTRADATA_LTRINFO; 1248 1249 DEBUG_PRINT_HIGH("LTRInfo extradata %s", 1250 ((pParam->bEnabled == OMX_TRUE) ? "enabled" : "disabled")); 1251 } else { 1252 DEBUG_PRINT_ERROR("set_parameter: LTR information is " 1253 "valid for output port only"); 1254 eRet = OMX_ErrorUnsupportedIndex; 1255 break; 1256 } 1257 } 1258#endif 1259 else { 1260 DEBUG_PRINT_ERROR("set_parameter: unsupported extrdata index (%x)", 1261 pParam->nIndex); 1262 eRet = OMX_ErrorUnsupportedIndex; 1263 break; 1264 } 1265 1266 1267 if (pParam->bEnabled == OMX_TRUE) 1268 m_sExtraData |= mask; 1269 else 1270 m_sExtraData &= ~mask; 1271 1272 enable = !!(m_sExtraData & mask); 1273 if (handle->venc_set_param(&enable, 1274 (OMX_INDEXTYPE)pParam->nIndex) != true) { 1275 DEBUG_PRINT_ERROR("ERROR: Setting Extradata (%x) failed", pParam->nIndex); 1276 return OMX_ErrorUnsupportedSetting; 1277 } else { 1278 m_sOutPortDef.nPortIndex = PORT_INDEX_OUT; 1279 dev_get_buf_req(&m_sOutPortDef.nBufferCountMin, 1280 &m_sOutPortDef.nBufferCountActual, 1281 &m_sOutPortDef.nBufferSize, 1282 m_sOutPortDef.nPortIndex); 1283 DEBUG_PRINT_HIGH("updated out_buf_req: buffer cnt=%u, " 1284 "count min=%u, buffer size=%u", 1285 (unsigned int)m_sOutPortDef.nBufferCountActual, 1286 (unsigned int)m_sOutPortDef.nBufferCountMin, 1287 (unsigned int)m_sOutPortDef.nBufferSize); 1288 } 1289 break; 1290 } 1291 case QOMX_IndexParamVideoLTRMode: 1292 { 1293 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_VIDEO_PARAM_LTRMODE_TYPE); 1294 QOMX_VIDEO_PARAM_LTRMODE_TYPE* pParam = 1295 (QOMX_VIDEO_PARAM_LTRMODE_TYPE*)paramData; 1296 if (!handle->venc_set_param(paramData, (OMX_INDEXTYPE)QOMX_IndexParamVideoLTRMode)) { 1297 DEBUG_PRINT_ERROR("ERROR: Setting LTR mode failed"); 1298 return OMX_ErrorUnsupportedSetting; 1299 } 1300 memcpy(&m_sParamLTRMode, pParam, sizeof(m_sParamLTRMode)); 1301 break; 1302 } 1303 case QOMX_IndexParamVideoLTRCount: 1304 { 1305 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_VIDEO_PARAM_LTRCOUNT_TYPE); 1306 QOMX_VIDEO_PARAM_LTRCOUNT_TYPE* pParam = 1307 (QOMX_VIDEO_PARAM_LTRCOUNT_TYPE*)paramData; 1308 if (!handle->venc_set_param(paramData, (OMX_INDEXTYPE)QOMX_IndexParamVideoLTRCount)) { 1309 DEBUG_PRINT_ERROR("ERROR: Setting LTR count failed"); 1310 return OMX_ErrorUnsupportedSetting; 1311 } 1312 memcpy(&m_sParamLTRCount, pParam, sizeof(m_sParamLTRCount)); 1313 break; 1314 } 1315#endif 1316 case OMX_QcomIndexParamVideoMaxAllowedBitrateCheck: 1317 { 1318 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_EXTNINDEX_PARAMTYPE); 1319 QOMX_EXTNINDEX_PARAMTYPE* pParam = 1320 (QOMX_EXTNINDEX_PARAMTYPE*)paramData; 1321 if (pParam->nPortIndex == PORT_INDEX_OUT) { 1322 handle->m_max_allowed_bitrate_check = 1323 ((pParam->bEnable == OMX_TRUE) ? true : false); 1324 DEBUG_PRINT_HIGH("set_parameter: max allowed bitrate check %s", 1325 ((pParam->bEnable == OMX_TRUE) ? "enabled" : "disabled")); 1326 } else { 1327 DEBUG_PRINT_ERROR("ERROR: OMX_QcomIndexParamVideoMaxAllowedBitrateCheck " 1328 " called on wrong port(%u)", (unsigned int)pParam->nPortIndex); 1329 return OMX_ErrorBadPortIndex; 1330 } 1331 break; 1332 } 1333#ifdef MAX_RES_1080P 1334 case OMX_QcomIndexEnableSliceDeliveryMode: 1335 { 1336 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_EXTNINDEX_PARAMTYPE); 1337 QOMX_EXTNINDEX_PARAMTYPE* pParam = 1338 (QOMX_EXTNINDEX_PARAMTYPE*)paramData; 1339 if (pParam->nPortIndex == PORT_INDEX_OUT) { 1340 if (!handle->venc_set_param(paramData, 1341 (OMX_INDEXTYPE)OMX_QcomIndexEnableSliceDeliveryMode)) { 1342 DEBUG_PRINT_ERROR("ERROR: Request for setting slice delivery mode failed"); 1343 return OMX_ErrorUnsupportedSetting; 1344 } 1345 } else { 1346 DEBUG_PRINT_ERROR("ERROR: OMX_QcomIndexEnableSliceDeliveryMode " 1347 "called on wrong port(%u)", (unsigned int)pParam->nPortIndex); 1348 return OMX_ErrorBadPortIndex; 1349 } 1350 break; 1351 } 1352#endif 1353 case OMX_QcomIndexEnableH263PlusPType: 1354 { 1355 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_EXTNINDEX_PARAMTYPE); 1356 QOMX_EXTNINDEX_PARAMTYPE* pParam = 1357 (QOMX_EXTNINDEX_PARAMTYPE*)paramData; 1358 DEBUG_PRINT_LOW("OMX_QcomIndexEnableH263PlusPType"); 1359 if (pParam->nPortIndex == PORT_INDEX_OUT) { 1360 if (!handle->venc_set_param(paramData, 1361 (OMX_INDEXTYPE)OMX_QcomIndexEnableH263PlusPType)) { 1362 DEBUG_PRINT_ERROR("ERROR: Request for setting PlusPType failed"); 1363 return OMX_ErrorUnsupportedSetting; 1364 } 1365 } else { 1366 DEBUG_PRINT_ERROR("ERROR: OMX_QcomIndexEnableH263PlusPType " 1367 "called on wrong port(%u)", (unsigned int)pParam->nPortIndex); 1368 return OMX_ErrorBadPortIndex; 1369 } 1370 break; 1371 } 1372 case OMX_QcomIndexParamSequenceHeaderWithIDR: 1373 { 1374 VALIDATE_OMX_PARAM_DATA(paramData, PrependSPSPPSToIDRFramesParams); 1375 if(!handle->venc_set_param(paramData, 1376 (OMX_INDEXTYPE)OMX_QcomIndexParamSequenceHeaderWithIDR)) { 1377 DEBUG_PRINT_ERROR("%s: %s", 1378 "OMX_QComIndexParamSequenceHeaderWithIDR:", 1379 "request for inband sps/pps failed."); 1380 return OMX_ErrorUnsupportedSetting; 1381 } 1382 break; 1383 } 1384 case OMX_QcomIndexParamH264AUDelimiter: 1385 { 1386 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QCOM_VIDEO_CONFIG_H264_AUD); 1387 if(!handle->venc_set_param(paramData, 1388 (OMX_INDEXTYPE)OMX_QcomIndexParamH264AUDelimiter)) { 1389 DEBUG_PRINT_ERROR("%s: %s", 1390 "OMX_QComIndexParamh264AUDelimiter:", 1391 "request for AU Delimiters failed."); 1392 return OMX_ErrorUnsupportedSetting; 1393 } 1394 break; 1395 } 1396 case OMX_QcomIndexHierarchicalStructure: 1397 { 1398 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_VIDEO_HIERARCHICALLAYERS); 1399 QOMX_VIDEO_HIERARCHICALLAYERS* pParam = 1400 (QOMX_VIDEO_HIERARCHICALLAYERS*)paramData; 1401 DEBUG_PRINT_LOW("OMX_QcomIndexHierarchicalStructure"); 1402 if (pParam->nPortIndex == PORT_INDEX_OUT) { 1403 if (!handle->venc_set_param(paramData, 1404 (OMX_INDEXTYPE)OMX_QcomIndexHierarchicalStructure)) { 1405 DEBUG_PRINT_ERROR("ERROR: Request for setting PlusPType failed"); 1406 return OMX_ErrorUnsupportedSetting; 1407 } 1408 if((pParam->eHierarchicalCodingType == QOMX_HIERARCHICALCODING_B) && pParam->nNumLayers) 1409 hier_b_enabled = true; 1410 m_sHierLayers.nNumLayers = pParam->nNumLayers; 1411 m_sHierLayers.eHierarchicalCodingType = pParam->eHierarchicalCodingType; 1412 } else { 1413 DEBUG_PRINT_ERROR("ERROR: OMX_QcomIndexHierarchicalStructure called on wrong port(%u)", 1414 (unsigned int)pParam->nPortIndex); 1415 return OMX_ErrorBadPortIndex; 1416 } 1417 break; 1418 1419 } 1420 case OMX_QcomIndexParamPerfLevel: 1421 { 1422 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QCOM_VIDEO_PARAM_PERF_LEVEL); 1423 if (!handle->venc_set_param(paramData, 1424 (OMX_INDEXTYPE) OMX_QcomIndexParamPerfLevel)) { 1425 DEBUG_PRINT_ERROR("ERROR: Setting performance level"); 1426 return OMX_ErrorUnsupportedSetting; 1427 } 1428 break; 1429 } 1430 case OMX_QcomIndexParamH264VUITimingInfo: 1431 { 1432 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QCOM_VIDEO_PARAM_VUI_TIMING_INFO); 1433 if (!handle->venc_set_param(paramData, 1434 (OMX_INDEXTYPE) OMX_QcomIndexParamH264VUITimingInfo)) { 1435 DEBUG_PRINT_ERROR("ERROR: Setting VUI timing info"); 1436 return OMX_ErrorUnsupportedSetting; 1437 } 1438 break; 1439 } 1440 case OMX_QcomIndexParamPeakBitrate: 1441 { 1442 VALIDATE_OMX_PARAM_DATA(paramData, OMX_QCOM_VIDEO_PARAM_PEAK_BITRATE); 1443 if (!handle->venc_set_param(paramData, 1444 (OMX_INDEXTYPE) OMX_QcomIndexParamPeakBitrate)) { 1445 DEBUG_PRINT_ERROR("ERROR: Setting peak bitrate"); 1446 return OMX_ErrorUnsupportedSetting; 1447 } 1448 break; 1449 } 1450 case QOMX_IndexParamVideoInitialQp: 1451 { 1452 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_EXTNINDEX_VIDEO_INITIALQP); 1453 if(!handle->venc_set_param(paramData, 1454 (OMX_INDEXTYPE)QOMX_IndexParamVideoInitialQp)) { 1455 DEBUG_PRINT_ERROR("Request to Enable initial QP failed"); 1456 return OMX_ErrorUnsupportedSetting; 1457 } 1458 memcpy(&m_sParamInitqp, paramData, sizeof(m_sParamInitqp)); 1459 break; 1460 } 1461 case OMX_QcomIndexParamSetMVSearchrange: 1462 { 1463 if (!handle->venc_set_param(paramData, 1464 (OMX_INDEXTYPE) OMX_QcomIndexParamSetMVSearchrange)) { 1465 DEBUG_PRINT_ERROR("ERROR: Setting Searchrange"); 1466 return OMX_ErrorUnsupportedSetting; 1467 } 1468 break; 1469 } 1470 case OMX_QcomIndexParamVideoHybridHierpMode: 1471 { 1472 VALIDATE_OMX_PARAM_DATA(paramData, QOMX_EXTNINDEX_VIDEO_HYBRID_HP_MODE); 1473 if(!handle->venc_set_param(paramData, 1474 (OMX_INDEXTYPE)OMX_QcomIndexParamVideoHybridHierpMode)) { 1475 DEBUG_PRINT_ERROR("Request to Enable Hybrid Hier-P failed"); 1476 return OMX_ErrorUnsupportedSetting; 1477 } 1478 break; 1479 } 1480 case OMX_IndexParamVideoSliceFMO: 1481 default: 1482 { 1483 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown param %d", paramIndex); 1484 eRet = OMX_ErrorUnsupportedIndex; 1485 break; 1486 } 1487 } 1488 return eRet; 1489} 1490 1491bool omx_venc::update_profile_level() 1492{ 1493 OMX_U32 eProfile, eLevel; 1494 1495 if (!handle->venc_get_profile_level(&eProfile,&eLevel)) { 1496 DEBUG_PRINT_ERROR("Failed to update the profile_level"); 1497 return false; 1498 } 1499 1500 m_sParamProfileLevel.eProfile = (OMX_VIDEO_MPEG4PROFILETYPE)eProfile; 1501 m_sParamProfileLevel.eLevel = (OMX_VIDEO_MPEG4LEVELTYPE)eLevel; 1502 1503 if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.mpeg4",\ 1504 OMX_MAX_STRINGNAME_SIZE)) { 1505 m_sParamMPEG4.eProfile = (OMX_VIDEO_MPEG4PROFILETYPE)eProfile; 1506 m_sParamMPEG4.eLevel = (OMX_VIDEO_MPEG4LEVELTYPE)eLevel; 1507 DEBUG_PRINT_LOW("MPEG4 profile = %d, level = %d", m_sParamMPEG4.eProfile, 1508 m_sParamMPEG4.eLevel); 1509 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.h263",\ 1510 OMX_MAX_STRINGNAME_SIZE)) { 1511 m_sParamH263.eProfile = (OMX_VIDEO_H263PROFILETYPE)eProfile; 1512 m_sParamH263.eLevel = (OMX_VIDEO_H263LEVELTYPE)eLevel; 1513 DEBUG_PRINT_LOW("H263 profile = %d, level = %d", m_sParamH263.eProfile, 1514 m_sParamH263.eLevel); 1515 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc",\ 1516 OMX_MAX_STRINGNAME_SIZE)) { 1517 m_sParamAVC.eProfile = (OMX_VIDEO_AVCPROFILETYPE)eProfile; 1518 m_sParamAVC.eLevel = (OMX_VIDEO_AVCLEVELTYPE)eLevel; 1519 DEBUG_PRINT_LOW("AVC profile = %d, level = %d", m_sParamAVC.eProfile, 1520 m_sParamAVC.eLevel); 1521 } else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc.secure",\ 1522 OMX_MAX_STRINGNAME_SIZE)) { 1523 m_sParamAVC.eProfile = (OMX_VIDEO_AVCPROFILETYPE)eProfile; 1524 m_sParamAVC.eLevel = (OMX_VIDEO_AVCLEVELTYPE)eLevel; 1525 DEBUG_PRINT_LOW("\n AVC profile = %d, level = %d", m_sParamAVC.eProfile, 1526 m_sParamAVC.eLevel); 1527 } 1528 else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.vp8",\ 1529 OMX_MAX_STRINGNAME_SIZE)) { 1530 m_sParamVP8.eProfile = (OMX_VIDEO_VP8PROFILETYPE)eProfile; 1531 m_sParamVP8.eLevel = (OMX_VIDEO_VP8LEVELTYPE)eLevel; 1532 DEBUG_PRINT_LOW("VP8 profile = %d, level = %d", m_sParamVP8.eProfile, 1533 m_sParamVP8.eLevel); 1534 } 1535 else if (!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.hevc",\ 1536 OMX_MAX_STRINGNAME_SIZE)) { 1537 m_sParamHEVC.eProfile = (OMX_VIDEO_HEVCPROFILETYPE)eProfile; 1538 m_sParamHEVC.eLevel = (OMX_VIDEO_HEVCLEVELTYPE)eLevel; 1539 DEBUG_PRINT_LOW("HEVC profile = %d, level = %d", m_sParamHEVC.eProfile, 1540 m_sParamHEVC.eLevel); 1541 } 1542 1543 return true; 1544} 1545/* ====================================================================== 1546 FUNCTION 1547 omx_video::SetConfig 1548 1549 DESCRIPTION 1550 OMX Set Config method implementation 1551 1552 PARAMETERS 1553 <TBD>. 1554 1555 RETURN VALUE 1556 OMX Error None if successful. 1557 ========================================================================== */ 1558OMX_ERRORTYPE omx_venc::set_config(OMX_IN OMX_HANDLETYPE hComp, 1559 OMX_IN OMX_INDEXTYPE configIndex, 1560 OMX_IN OMX_PTR configData) 1561{ 1562 (void)hComp; 1563 if (configData == NULL) { 1564 DEBUG_PRINT_ERROR("ERROR: param is null"); 1565 return OMX_ErrorBadParameter; 1566 } 1567 1568 if (m_state == OMX_StateInvalid) { 1569 DEBUG_PRINT_ERROR("ERROR: config called in Invalid state"); 1570 return OMX_ErrorIncorrectStateOperation; 1571 } 1572 1573 // params will be validated prior to venc_init 1574 switch ((int)configIndex) { 1575 case OMX_IndexConfigVideoBitrate: 1576 { 1577 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_CONFIG_BITRATETYPE); 1578 OMX_VIDEO_CONFIG_BITRATETYPE* pParam = 1579 reinterpret_cast<OMX_VIDEO_CONFIG_BITRATETYPE*>(configData); 1580 DEBUG_PRINT_HIGH("set_config(): OMX_IndexConfigVideoBitrate (%u)", (unsigned int)pParam->nEncodeBitrate); 1581 1582 if (pParam->nPortIndex == PORT_INDEX_OUT) { 1583 if (handle->venc_set_config(configData, OMX_IndexConfigVideoBitrate) != true) { 1584 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigVideoBitrate failed"); 1585 return OMX_ErrorUnsupportedSetting; 1586 } 1587 1588 m_sConfigBitrate.nEncodeBitrate = pParam->nEncodeBitrate; 1589 m_sParamBitrate.nTargetBitrate = pParam->nEncodeBitrate; 1590 m_sOutPortDef.format.video.nBitrate = pParam->nEncodeBitrate; 1591 } else { 1592 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", (unsigned int)pParam->nPortIndex); 1593 return OMX_ErrorBadPortIndex; 1594 } 1595 break; 1596 } 1597 case OMX_IndexConfigVideoFramerate: 1598 { 1599 VALIDATE_OMX_PARAM_DATA(configData, OMX_CONFIG_FRAMERATETYPE); 1600 OMX_CONFIG_FRAMERATETYPE* pParam = 1601 reinterpret_cast<OMX_CONFIG_FRAMERATETYPE*>(configData); 1602 DEBUG_PRINT_HIGH("set_config(): OMX_IndexConfigVideoFramerate (0x%x)", (unsigned int)pParam->xEncodeFramerate); 1603 1604 if (pParam->nPortIndex == PORT_INDEX_OUT) { 1605 if (handle->venc_set_config(configData, OMX_IndexConfigVideoFramerate) != true) { 1606 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigVideoFramerate failed"); 1607 return OMX_ErrorUnsupportedSetting; 1608 } 1609 1610 m_sConfigFramerate.xEncodeFramerate = pParam->xEncodeFramerate; 1611 m_sOutPortDef.format.video.xFramerate = pParam->xEncodeFramerate; 1612 m_sOutPortFormat.xFramerate = pParam->xEncodeFramerate; 1613 } else { 1614 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", (unsigned int)pParam->nPortIndex); 1615 return OMX_ErrorBadPortIndex; 1616 } 1617 1618 break; 1619 } 1620 case QOMX_IndexConfigVideoIntraperiod: 1621 { 1622 VALIDATE_OMX_PARAM_DATA(configData, QOMX_VIDEO_INTRAPERIODTYPE); 1623 QOMX_VIDEO_INTRAPERIODTYPE* pParam = 1624 reinterpret_cast<QOMX_VIDEO_INTRAPERIODTYPE*>(configData); 1625 1626 DEBUG_PRINT_HIGH("set_config(): QOMX_IndexConfigVideoIntraperiod"); 1627 if (pParam->nPortIndex == PORT_INDEX_OUT) { 1628#ifdef MAX_RES_720P 1629 if (pParam->nBFrames > 0) { 1630 DEBUG_PRINT_ERROR("B frames not supported"); 1631 return OMX_ErrorUnsupportedSetting; 1632 } 1633#endif 1634 DEBUG_PRINT_HIGH("Old: P/B frames = %u/%u, New: P/B frames = %u/%u", 1635 (unsigned int)m_sIntraperiod.nPFrames, (unsigned int)m_sIntraperiod.nBFrames, 1636 (unsigned int)pParam->nPFrames, (unsigned int)pParam->nBFrames); 1637 if (m_sIntraperiod.nBFrames != pParam->nBFrames) { 1638 if(hier_b_enabled && m_state == OMX_StateLoaded) { 1639 DEBUG_PRINT_INFO("B-frames setting is supported if HierB is enabled"); 1640 } 1641 else { 1642 DEBUG_PRINT_HIGH("Dynamically changing B-frames not supported"); 1643 return OMX_ErrorUnsupportedSetting; 1644 } 1645 } 1646 if (handle->venc_set_config(configData, (OMX_INDEXTYPE) QOMX_IndexConfigVideoIntraperiod) != true) { 1647 DEBUG_PRINT_ERROR("ERROR: Setting QOMX_IndexConfigVideoIntraperiod failed"); 1648 return OMX_ErrorUnsupportedSetting; 1649 } 1650 m_sIntraperiod.nPFrames = pParam->nPFrames; 1651 m_sIntraperiod.nBFrames = pParam->nBFrames; 1652 m_sIntraperiod.nIDRPeriod = pParam->nIDRPeriod; 1653 1654 if (m_sOutPortFormat.eCompressionFormat == OMX_VIDEO_CodingMPEG4) { 1655 m_sParamMPEG4.nPFrames = pParam->nPFrames; 1656 if (m_sParamMPEG4.eProfile != OMX_VIDEO_MPEG4ProfileSimple) 1657 m_sParamMPEG4.nBFrames = pParam->nBFrames; 1658 else 1659 m_sParamMPEG4.nBFrames = 0; 1660 } else if (m_sOutPortFormat.eCompressionFormat == OMX_VIDEO_CodingH263) { 1661 m_sParamH263.nPFrames = pParam->nPFrames; 1662 } else { 1663 m_sParamAVC.nPFrames = pParam->nPFrames; 1664 if ((m_sParamAVC.eProfile != OMX_VIDEO_AVCProfileBaseline) && 1665 (m_sParamAVC.eProfile != (OMX_VIDEO_AVCPROFILETYPE) QOMX_VIDEO_AVCProfileConstrainedBaseline)) 1666 m_sParamAVC.nBFrames = pParam->nBFrames; 1667 else 1668 m_sParamAVC.nBFrames = 0; 1669 } 1670 } else { 1671 DEBUG_PRINT_ERROR("ERROR: (QOMX_IndexConfigVideoIntraperiod) Unsupported port index: %u", (unsigned int)pParam->nPortIndex); 1672 return OMX_ErrorBadPortIndex; 1673 } 1674 1675 break; 1676 } 1677 1678 case OMX_IndexConfigVideoIntraVOPRefresh: 1679 { 1680 VALIDATE_OMX_PARAM_DATA(configData, OMX_CONFIG_INTRAREFRESHVOPTYPE); 1681 OMX_CONFIG_INTRAREFRESHVOPTYPE* pParam = 1682 reinterpret_cast<OMX_CONFIG_INTRAREFRESHVOPTYPE*>(configData); 1683 1684 DEBUG_PRINT_HIGH("set_config(): OMX_IndexConfigVideoIntraVOPRefresh"); 1685 if (pParam->nPortIndex == PORT_INDEX_OUT) { 1686 if (handle->venc_set_config(configData, 1687 OMX_IndexConfigVideoIntraVOPRefresh) != true) { 1688 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigVideoIntraVOPRefresh failed"); 1689 return OMX_ErrorUnsupportedSetting; 1690 } 1691 1692 m_sConfigIntraRefreshVOP.IntraRefreshVOP = pParam->IntraRefreshVOP; 1693 } else { 1694 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", (unsigned int)pParam->nPortIndex); 1695 return OMX_ErrorBadPortIndex; 1696 } 1697 1698 break; 1699 } 1700 case OMX_IndexConfigCommonRotate: 1701 { 1702 VALIDATE_OMX_PARAM_DATA(configData, OMX_CONFIG_ROTATIONTYPE); 1703 OMX_CONFIG_ROTATIONTYPE *pParam = 1704 reinterpret_cast<OMX_CONFIG_ROTATIONTYPE*>(configData); 1705 OMX_S32 nRotation; 1706 1707 if (pParam->nPortIndex != PORT_INDEX_OUT) { 1708 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", (unsigned int)pParam->nPortIndex); 1709 return OMX_ErrorBadPortIndex; 1710 } 1711 if ( pParam->nRotation == 0 || 1712 pParam->nRotation == 90 || 1713 pParam->nRotation == 180 || 1714 pParam->nRotation == 270 ) { 1715 DEBUG_PRINT_HIGH("set_config: Rotation Angle %u", (unsigned int)pParam->nRotation); 1716 } else { 1717 DEBUG_PRINT_ERROR("ERROR: un supported Rotation %u", (unsigned int)pParam->nRotation); 1718 return OMX_ErrorUnsupportedSetting; 1719 } 1720 nRotation = pParam->nRotation - m_sConfigFrameRotation.nRotation; 1721 if (nRotation < 0) 1722 nRotation = -nRotation; 1723 if (nRotation == 90 || nRotation == 270) { 1724 DEBUG_PRINT_HIGH("set_config: updating device Dims"); 1725 if (handle->venc_set_config(configData, 1726 OMX_IndexConfigCommonRotate) != true) { 1727 DEBUG_PRINT_ERROR("ERROR: Set OMX_IndexConfigCommonRotate failed"); 1728 return OMX_ErrorUnsupportedSetting; 1729 } else { 1730 OMX_U32 nFrameWidth; 1731 OMX_U32 nFrameHeight; 1732 1733 DEBUG_PRINT_HIGH("set_config: updating port Dims"); 1734 1735 nFrameWidth = m_sOutPortDef.format.video.nFrameWidth; 1736 nFrameHeight = m_sOutPortDef.format.video.nFrameHeight; 1737 m_sOutPortDef.format.video.nFrameWidth = nFrameHeight; 1738 m_sOutPortDef.format.video.nFrameHeight = nFrameWidth; 1739 m_sConfigFrameRotation.nRotation = pParam->nRotation; 1740 } 1741 } else { 1742 m_sConfigFrameRotation.nRotation = pParam->nRotation; 1743 } 1744 break; 1745 } 1746 case OMX_QcomIndexConfigVideoFramePackingArrangement: 1747 { 1748 DEBUG_PRINT_HIGH("set_config(): OMX_QcomIndexConfigVideoFramePackingArrangement"); 1749 if (m_sOutPortFormat.eCompressionFormat == OMX_VIDEO_CodingAVC) { 1750 VALIDATE_OMX_PARAM_DATA(configData, OMX_QCOM_FRAME_PACK_ARRANGEMENT); 1751 OMX_QCOM_FRAME_PACK_ARRANGEMENT *configFmt = 1752 (OMX_QCOM_FRAME_PACK_ARRANGEMENT *) configData; 1753 extra_data_handle.set_frame_pack_data(configFmt); 1754 } else { 1755 DEBUG_PRINT_ERROR("ERROR: FramePackingData not supported for non AVC compression"); 1756 } 1757 break; 1758 } 1759 case QOMX_IndexConfigVideoLTRPeriod: 1760 { 1761 VALIDATE_OMX_PARAM_DATA(configData, QOMX_VIDEO_CONFIG_LTRPERIOD_TYPE); 1762 QOMX_VIDEO_CONFIG_LTRPERIOD_TYPE* pParam = (QOMX_VIDEO_CONFIG_LTRPERIOD_TYPE*)configData; 1763 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)QOMX_IndexConfigVideoLTRPeriod)) { 1764 DEBUG_PRINT_ERROR("ERROR: Setting LTR period failed"); 1765 return OMX_ErrorUnsupportedSetting; 1766 } 1767 memcpy(&m_sConfigLTRPeriod, pParam, sizeof(m_sConfigLTRPeriod)); 1768 break; 1769 } 1770 1771 case OMX_IndexConfigVideoVp8ReferenceFrame: 1772 { 1773 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_VP8REFERENCEFRAMETYPE); 1774 OMX_VIDEO_VP8REFERENCEFRAMETYPE* pParam = (OMX_VIDEO_VP8REFERENCEFRAMETYPE*) configData; 1775 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE) OMX_IndexConfigVideoVp8ReferenceFrame)) { 1776 DEBUG_PRINT_ERROR("ERROR: Setting VP8 reference frame"); 1777 return OMX_ErrorUnsupportedSetting; 1778 } 1779 memcpy(&m_sConfigVp8ReferenceFrame, pParam, sizeof(m_sConfigVp8ReferenceFrame)); 1780 break; 1781 } 1782 1783 case QOMX_IndexConfigVideoLTRUse: 1784 { 1785 VALIDATE_OMX_PARAM_DATA(configData, QOMX_VIDEO_CONFIG_LTRUSE_TYPE); 1786 QOMX_VIDEO_CONFIG_LTRUSE_TYPE* pParam = (QOMX_VIDEO_CONFIG_LTRUSE_TYPE*)configData; 1787 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)QOMX_IndexConfigVideoLTRUse)) { 1788 DEBUG_PRINT_ERROR("ERROR: Setting LTR use failed"); 1789 return OMX_ErrorUnsupportedSetting; 1790 } 1791 memcpy(&m_sConfigLTRUse, pParam, sizeof(m_sConfigLTRUse)); 1792 break; 1793 } 1794 case QOMX_IndexConfigVideoLTRMark: 1795 { 1796 VALIDATE_OMX_PARAM_DATA(configData, QOMX_VIDEO_CONFIG_LTRMARK_TYPE); 1797 QOMX_VIDEO_CONFIG_LTRMARK_TYPE* pParam = (QOMX_VIDEO_CONFIG_LTRMARK_TYPE*)configData; 1798 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)QOMX_IndexConfigVideoLTRMark)) { 1799 DEBUG_PRINT_ERROR("ERROR: Setting LTR mark failed"); 1800 return OMX_ErrorUnsupportedSetting; 1801 } 1802 break; 1803 } 1804 case OMX_IndexConfigVideoAVCIntraPeriod: 1805 { 1806 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_CONFIG_AVCINTRAPERIOD); 1807 OMX_VIDEO_CONFIG_AVCINTRAPERIOD *pParam = (OMX_VIDEO_CONFIG_AVCINTRAPERIOD*) configData; 1808 DEBUG_PRINT_LOW("set_config: OMX_IndexConfigVideoAVCIntraPeriod"); 1809 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)OMX_IndexConfigVideoAVCIntraPeriod)) { 1810 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigVideoAVCIntraPeriod failed"); 1811 return OMX_ErrorUnsupportedSetting; 1812 } 1813 memcpy(&m_sConfigAVCIDRPeriod, pParam, sizeof(m_sConfigAVCIDRPeriod)); 1814 break; 1815 } 1816 case OMX_IndexConfigCommonDeinterlace: 1817 { 1818 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_CONFIG_DEINTERLACE); 1819 OMX_VIDEO_CONFIG_DEINTERLACE *pParam = (OMX_VIDEO_CONFIG_DEINTERLACE*) configData; 1820 DEBUG_PRINT_LOW("set_config: OMX_IndexConfigCommonDeinterlace"); 1821 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)OMX_IndexConfigCommonDeinterlace)) { 1822 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigCommonDeinterlace failed"); 1823 return OMX_ErrorUnsupportedSetting; 1824 } 1825 memcpy(&m_sConfigDeinterlace, pParam, sizeof(m_sConfigDeinterlace)); 1826 break; 1827 } 1828 case OMX_QcomIndexConfigVideoVencPerfMode: 1829 { 1830 VALIDATE_OMX_PARAM_DATA(configData, QOMX_EXTNINDEX_VIDEO_PERFMODE); 1831 QOMX_EXTNINDEX_VIDEO_PERFMODE* pParam = (QOMX_EXTNINDEX_VIDEO_PERFMODE*)configData; 1832 if (!handle->venc_set_config(pParam, (OMX_INDEXTYPE)OMX_QcomIndexConfigVideoVencPerfMode)) { 1833 DEBUG_PRINT_ERROR("ERROR: Setting OMX_QcomIndexConfigVideoVencPerfMode failed"); 1834 return OMX_ErrorUnsupportedSetting; 1835 } 1836 break; 1837 } 1838 case OMX_IndexConfigPriority: 1839 { 1840 VALIDATE_OMX_PARAM_DATA(configData, OMX_PARAM_U32TYPE); 1841 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_IndexConfigPriority)) { 1842 DEBUG_PRINT_ERROR("Failed to set OMX_IndexConfigPriority"); 1843 return OMX_ErrorUnsupportedSetting; 1844 } 1845 break; 1846 } 1847 case OMX_IndexConfigOperatingRate: 1848 { 1849 VALIDATE_OMX_PARAM_DATA(configData, OMX_PARAM_U32TYPE); 1850 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_IndexConfigOperatingRate)) { 1851 DEBUG_PRINT_ERROR("Failed to set OMX_IndexConfigOperatingRate"); 1852 return handle->hw_overload ? OMX_ErrorInsufficientResources : 1853 OMX_ErrorUnsupportedSetting; 1854 } 1855 break; 1856 } 1857 case OMX_IndexConfigAndroidIntraRefresh: 1858 { 1859 VALIDATE_OMX_PARAM_DATA(configData, OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE); 1860 OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE* pParam = 1861 (OMX_VIDEO_CONFIG_ANDROID_INTRAREFRESHTYPE*) configData; 1862 if (m_state == OMX_StateLoaded 1863 || m_sInPortDef.bEnabled == OMX_FALSE 1864 || m_sOutPortDef.bEnabled == OMX_FALSE) { 1865 if (!handle->venc_set_config(configData, (OMX_INDEXTYPE)OMX_IndexConfigAndroidIntraRefresh)) { 1866 DEBUG_PRINT_ERROR("Failed to set OMX_IndexConfigVideoIntraRefreshType"); 1867 return OMX_ErrorUnsupportedSetting; 1868 } 1869 m_sConfigIntraRefresh.nRefreshPeriod = pParam->nRefreshPeriod; 1870 } else { 1871 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigAndroidIntraRefresh supported only at start of session"); 1872 return OMX_ErrorUnsupportedSetting; 1873 } 1874 break; 1875 } 1876 default: 1877 DEBUG_PRINT_ERROR("ERROR: unsupported index %d", (int) configIndex); 1878 break; 1879 } 1880 1881 return OMX_ErrorNone; 1882} 1883 1884/* ====================================================================== 1885 FUNCTION 1886 omx_venc::ComponentDeInit 1887 1888 DESCRIPTION 1889 Destroys the component and release memory allocated to the heap. 1890 1891 PARAMETERS 1892 <TBD>. 1893 1894 RETURN VALUE 1895 OMX Error None if everything successful. 1896 1897 ========================================================================== */ 1898OMX_ERRORTYPE omx_venc::component_deinit(OMX_IN OMX_HANDLETYPE hComp) 1899{ 1900 (void) hComp; 1901 OMX_U32 i = 0; 1902 DEBUG_PRINT_HIGH("omx_venc(): Inside component_deinit()"); 1903 if (OMX_StateLoaded != m_state) { 1904 DEBUG_PRINT_ERROR("WARNING:Rxd DeInit,OMX not in LOADED state %d",\ 1905 m_state); 1906 } 1907 if (m_out_mem_ptr) { 1908 DEBUG_PRINT_LOW("Freeing the Output Memory"); 1909 for (i=0; i< m_sOutPortDef.nBufferCountActual; i++ ) { 1910 if (BITMASK_PRESENT(&m_out_bm_count, i)) { 1911 BITMASK_CLEAR(&m_out_bm_count, i); 1912 free_output_buffer (&m_out_mem_ptr[i]); 1913 } 1914 1915 if (release_output_done()) { 1916 break; 1917 } 1918 } 1919 free(m_out_mem_ptr); 1920 m_out_mem_ptr = NULL; 1921 } 1922 1923 /*Check if the input buffers have to be cleaned up*/ 1924 if (m_inp_mem_ptr 1925#ifdef _ANDROID_ICS_ 1926 && !meta_mode_enable 1927#endif 1928 ) { 1929 DEBUG_PRINT_LOW("Freeing the Input Memory"); 1930 for (i=0; i<m_sInPortDef.nBufferCountActual; i++ ) { 1931 if (BITMASK_PRESENT(&m_inp_bm_count, i)) { 1932 BITMASK_CLEAR(&m_inp_bm_count, i); 1933 free_input_buffer (&m_inp_mem_ptr[i]); 1934 } 1935 1936 if (release_input_done()) { 1937 break; 1938 } 1939 } 1940 1941 1942 free(m_inp_mem_ptr); 1943 m_inp_mem_ptr = NULL; 1944 } 1945 1946 // Reset counters in mesg queues 1947 m_ftb_q.m_size=0; 1948 m_cmd_q.m_size=0; 1949 m_etb_q.m_size=0; 1950 m_ftb_q.m_read = m_ftb_q.m_write =0; 1951 m_cmd_q.m_read = m_cmd_q.m_write =0; 1952 m_etb_q.m_read = m_etb_q.m_write =0; 1953 1954#ifdef _ANDROID_ 1955 // Clear the strong reference 1956 DEBUG_PRINT_HIGH("Calling m_heap_ptr.clear()"); 1957 m_heap_ptr.clear(); 1958#endif // _ANDROID_ 1959 DEBUG_PRINT_HIGH("Calling venc_close()"); 1960 if (handle) { 1961 handle->venc_close(); 1962 DEBUG_PRINT_HIGH("Deleting HANDLE[%p]", handle); 1963 delete (handle); 1964 handle = NULL; 1965 } 1966 DEBUG_PRINT_INFO("Component Deinit"); 1967 return OMX_ErrorNone; 1968} 1969 1970 1971OMX_U32 omx_venc::dev_stop( void) 1972{ 1973 return handle->venc_stop(); 1974} 1975 1976 1977OMX_U32 omx_venc::dev_pause(void) 1978{ 1979 return handle->venc_pause(); 1980} 1981 1982OMX_U32 omx_venc::dev_start(void) 1983{ 1984 return handle->venc_start(); 1985} 1986 1987OMX_U32 omx_venc::dev_flush(unsigned port) 1988{ 1989 return handle->venc_flush(port); 1990} 1991OMX_U32 omx_venc::dev_resume(void) 1992{ 1993 return handle->venc_resume(); 1994} 1995 1996OMX_U32 omx_venc::dev_start_done(void) 1997{ 1998 return handle->venc_start_done(); 1999} 2000 2001OMX_U32 omx_venc::dev_set_message_thread_id(pthread_t tid) 2002{ 2003 return handle->venc_set_message_thread_id(tid); 2004} 2005 2006bool omx_venc::dev_use_buf(void *buf_addr,unsigned port,unsigned index) 2007{ 2008 return handle->venc_use_buf(buf_addr,port,index); 2009} 2010 2011bool omx_venc::dev_free_buf(void *buf_addr,unsigned port) 2012{ 2013 return handle->venc_free_buf(buf_addr,port); 2014} 2015 2016bool omx_venc::dev_empty_buf(void *buffer, void *pmem_data_buf,unsigned index,unsigned fd) 2017{ 2018 bool bret = false; 2019 bret = handle->venc_empty_buf(buffer, pmem_data_buf,index,fd); 2020 hw_overload = handle->hw_overload; 2021 return bret; 2022} 2023 2024bool omx_venc::dev_fill_buf(void *buffer, void *pmem_data_buf,unsigned index,unsigned fd) 2025{ 2026 return handle->venc_fill_buf(buffer, pmem_data_buf,index,fd); 2027} 2028 2029bool omx_venc::dev_get_seq_hdr(void *buffer, unsigned size, unsigned *hdrlen) 2030{ 2031 return handle->venc_get_seq_hdr(buffer, size, hdrlen); 2032} 2033 2034bool omx_venc::dev_get_capability_ltrcount(OMX_U32 *min, OMX_U32 *max, OMX_U32 *step_size) 2035{ 2036#ifdef _MSM8974_ 2037 (void) min; 2038 (void) max; 2039 (void) step_size; 2040 DEBUG_PRINT_ERROR("Get Capability LTR Count is not supported"); 2041 return false; 2042#else 2043 return handle->venc_get_capability_ltrcount(min, max, step_size); 2044#endif 2045} 2046 2047bool omx_venc::dev_get_performance_level(OMX_U32 *perflevel) 2048{ 2049#ifdef _MSM8974_ 2050 return handle->venc_get_performance_level(perflevel); 2051#else 2052 DEBUG_PRINT_ERROR("Get performance level is not supported"); 2053 return false; 2054#endif 2055} 2056 2057bool omx_venc::dev_get_vui_timing_info(OMX_U32 *enabled) 2058{ 2059#ifdef _MSM8974_ 2060 return handle->venc_get_vui_timing_info(enabled); 2061#else 2062 DEBUG_PRINT_ERROR("Get vui timing information is not supported"); 2063 return false; 2064#endif 2065} 2066 2067bool omx_venc::dev_get_peak_bitrate(OMX_U32 *peakbitrate) 2068{ 2069#ifdef _MSM8974_ 2070 return handle->venc_get_peak_bitrate(peakbitrate); 2071#else 2072 DEBUG_PRINT_ERROR("Get peak bitrate is not supported"); 2073 return false; 2074#endif 2075} 2076 2077bool omx_venc::dev_loaded_start() 2078{ 2079 return handle->venc_loaded_start(); 2080} 2081 2082bool omx_venc::dev_loaded_stop() 2083{ 2084 return handle->venc_loaded_stop(); 2085} 2086 2087bool omx_venc::dev_loaded_start_done() 2088{ 2089 return handle->venc_loaded_start_done(); 2090} 2091 2092bool omx_venc::dev_loaded_stop_done() 2093{ 2094 return handle->venc_loaded_stop_done(); 2095} 2096 2097bool omx_venc::dev_get_buf_req(OMX_U32 *min_buff_count, 2098 OMX_U32 *actual_buff_count, 2099 OMX_U32 *buff_size, 2100 OMX_U32 port) 2101{ 2102 return handle->venc_get_buf_req(min_buff_count, 2103 actual_buff_count, 2104 buff_size, 2105 port); 2106 2107} 2108 2109bool omx_venc::dev_set_buf_req(OMX_U32 *min_buff_count, 2110 OMX_U32 *actual_buff_count, 2111 OMX_U32 *buff_size, 2112 OMX_U32 port) 2113{ 2114 return handle->venc_set_buf_req(min_buff_count, 2115 actual_buff_count, 2116 buff_size, 2117 port); 2118 2119} 2120 2121bool omx_venc::dev_is_video_session_supported(OMX_U32 width, OMX_U32 height) 2122{ 2123#ifdef _MSM8974_ 2124 return handle->venc_is_video_session_supported(width,height); 2125#else 2126 DEBUG_PRINT_LOW("Check against video capability not supported"); 2127 return true; 2128#endif 2129} 2130 2131#ifdef _MSM8974_ 2132int omx_venc::dev_handle_extradata(void *buffer, int index) 2133{ 2134 return handle->handle_extradata(buffer, index); 2135} 2136 2137int omx_venc::dev_set_format(int color) 2138{ 2139 return handle->venc_set_format(color); 2140} 2141#endif 2142 2143int omx_venc::async_message_process (void *context, void* message) 2144{ 2145 omx_video* omx = NULL; 2146 struct venc_msg *m_sVenc_msg = NULL; 2147 OMX_BUFFERHEADERTYPE* omxhdr = NULL; 2148 struct venc_buffer *temp_buff = NULL; 2149 2150 if (context == NULL || message == NULL) { 2151 DEBUG_PRINT_ERROR("ERROR: omx_venc::async_message_process invalid i/p params"); 2152 return -1; 2153 } 2154 m_sVenc_msg = (struct venc_msg *)message; 2155 2156 omx = reinterpret_cast<omx_video*>(context); 2157 2158 if (m_sVenc_msg->statuscode != VEN_S_SUCCESS) { 2159 DEBUG_PRINT_ERROR("ERROR: async_msg_process() - Error statuscode = %lu", 2160 m_sVenc_msg->statuscode); 2161 if(m_sVenc_msg->msgcode == VEN_MSG_HW_OVERLOAD) { 2162 omx->omx_report_hw_overload(); 2163 } else 2164 omx->omx_report_error(); 2165 } 2166 2167 DEBUG_PRINT_LOW("omx_venc::async_message_process- msgcode = %lu", 2168 m_sVenc_msg->msgcode); 2169 switch (m_sVenc_msg->msgcode) { 2170 case VEN_MSG_START: 2171 omx->post_event (0,m_sVenc_msg->statuscode,\ 2172 OMX_COMPONENT_GENERATE_START_DONE); 2173 break; 2174 case VEN_MSG_STOP: 2175 omx->post_event (0,m_sVenc_msg->statuscode,\ 2176 OMX_COMPONENT_GENERATE_STOP_DONE); 2177 break; 2178 case VEN_MSG_RESUME: 2179 omx->post_event (0,m_sVenc_msg->statuscode,\ 2180 OMX_COMPONENT_GENERATE_RESUME_DONE); 2181 break; 2182 case VEN_MSG_PAUSE: 2183 omx->post_event (0,m_sVenc_msg->statuscode,\ 2184 OMX_COMPONENT_GENERATE_PAUSE_DONE); 2185 break; 2186 case VEN_MSG_FLUSH_INPUT_DONE: 2187 2188 omx->post_event (0,m_sVenc_msg->statuscode,\ 2189 OMX_COMPONENT_GENERATE_EVENT_INPUT_FLUSH); 2190 break; 2191 case VEN_MSG_FLUSH_OUPUT_DONE: 2192 omx->post_event (0,m_sVenc_msg->statuscode,\ 2193 OMX_COMPONENT_GENERATE_EVENT_OUTPUT_FLUSH); 2194 break; 2195 case VEN_MSG_INPUT_BUFFER_DONE: 2196 omxhdr = (OMX_BUFFERHEADERTYPE* )\ 2197 m_sVenc_msg->buf.clientdata; 2198 2199 if (omxhdr == NULL || 2200 (((OMX_U32)(omxhdr - omx->m_inp_mem_ptr) > omx->m_sInPortDef.nBufferCountActual) && 2201 ((OMX_U32)(omxhdr - omx->meta_buffer_hdr) > omx->m_sInPortDef.nBufferCountActual))) { 2202 omxhdr = NULL; 2203 m_sVenc_msg->statuscode = VEN_S_EFAIL; 2204 } 2205 2206#ifdef _ANDROID_ICS_ 2207 omx->omx_release_meta_buffer(omxhdr); 2208#endif 2209 omx->post_event ((unsigned long)omxhdr,m_sVenc_msg->statuscode, 2210 OMX_COMPONENT_GENERATE_EBD); 2211 break; 2212 case VEN_MSG_OUTPUT_BUFFER_DONE: 2213 omxhdr = (OMX_BUFFERHEADERTYPE*)m_sVenc_msg->buf.clientdata; 2214 2215 if ( (omxhdr != NULL) && 2216 ((OMX_U32)(omxhdr - omx->m_out_mem_ptr) < omx->m_sOutPortDef.nBufferCountActual)) { 2217 if (m_sVenc_msg->buf.len <= omxhdr->nAllocLen) { 2218 omxhdr->nFilledLen = m_sVenc_msg->buf.len; 2219 omxhdr->nOffset = m_sVenc_msg->buf.offset; 2220 omxhdr->nTimeStamp = m_sVenc_msg->buf.timestamp; 2221 DEBUG_PRINT_LOW("o/p TS = %u", (unsigned int)m_sVenc_msg->buf.timestamp); 2222 omxhdr->nFlags = m_sVenc_msg->buf.flags; 2223 2224 /*Use buffer case*/ 2225 if (omx->output_use_buffer && !omx->m_use_output_pmem && !omx->is_secure_session()) { 2226 DEBUG_PRINT_LOW("memcpy() for o/p Heap UseBuffer"); 2227 memcpy(omxhdr->pBuffer, 2228 (m_sVenc_msg->buf.ptrbuffer), 2229 m_sVenc_msg->buf.len); 2230 } 2231 } else { 2232 omxhdr->nFilledLen = 0; 2233 } 2234 2235 } else { 2236 omxhdr = NULL; 2237 m_sVenc_msg->statuscode = VEN_S_EFAIL; 2238 } 2239 omx->post_event ((unsigned long)omxhdr,m_sVenc_msg->statuscode, 2240 OMX_COMPONENT_GENERATE_FBD); 2241 break; 2242 case VEN_MSG_NEED_OUTPUT_BUFFER: 2243 //TBD what action needs to be done here?? 2244 break; 2245#ifndef _MSM8974_ 2246 case VEN_MSG_LTRUSE_FAILED: 2247 DEBUG_PRINT_ERROR("LTRUSE Failed!"); 2248 omx->post_event (NULL,m_sVenc_msg->statuscode, 2249 OMX_COMPONENT_GENERATE_LTRUSE_FAILED); 2250 break; 2251#endif 2252 default: 2253 DEBUG_PRINT_HIGH("Unknown msg received : %lu", m_sVenc_msg->msgcode); 2254 break; 2255 } 2256 return 0; 2257} 2258 2259bool omx_venc::dev_color_align(OMX_BUFFERHEADERTYPE *buffer, 2260 OMX_U32 width, OMX_U32 height) 2261{ 2262 if(secure_session) { 2263 DEBUG_PRINT_ERROR("Cannot align colors in secure session."); 2264 return OMX_FALSE; 2265 } 2266 return handle->venc_color_align(buffer, width,height); 2267} 2268 2269bool omx_venc::is_secure_session() 2270{ 2271 return secure_session; 2272} 2273 2274bool omx_venc::dev_get_output_log_flag() 2275{ 2276 return handle->venc_get_output_log_flag(); 2277} 2278 2279int omx_venc::dev_output_log_buffers(const char *buffer, int bufferlen) 2280{ 2281 return handle->venc_output_log_buffers(buffer, bufferlen); 2282} 2283 2284int omx_venc::dev_extradata_log_buffers(char *buffer) 2285{ 2286 return handle->venc_extradata_log_buffers(buffer); 2287} 2288