1 /*-------------------------------------------------------------------------- 2 Copyright (c) 2010-2012, 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 Code Aurora 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 "video_encoder_device.h" 31 #include <stdio.h> 32 #ifdef _ANDROID_ICS_ 33 #include <media/hardware/HardwareAPI.h> 34 #endif 35 #ifdef _ANDROID_ 36 #include <cutils/properties.h> 37 #endif 38 #ifndef _ANDROID_ 39 #include <glib.h> 40 #define strlcpy g_strlcpy 41 #endif 42 /*---------------------------------------------------------------------------- 43 * Preprocessor Definitions and Constants 44 * -------------------------------------------------------------------------*/ 45 46 #define OMX_SPEC_VERSION 0x00000101 47 #define OMX_INIT_STRUCT(_s_, _name_) \ 48 memset((_s_), 0x0, sizeof(_name_)); \ 49 (_s_)->nSize = sizeof(_name_); \ 50 (_s_)->nVersion.nVersion = OMX_SPEC_VERSION 51 52 extern int m_pipe; 53 54 // factory function executed by the core to create instances 55 void *get_omx_component_factory_fn(void) 56 { 57 return(new omx_venc); 58 } 59 60 //constructor 61 62 omx_venc::omx_venc() 63 { 64 #ifdef _ANDROID_ICS_ 65 meta_mode_enable = false; 66 memset(meta_buffer_hdr,0,sizeof(meta_buffer_hdr)); 67 memset(meta_buffers,0,sizeof(meta_buffers)); 68 memset(opaque_buffer_hdr,0,sizeof(opaque_buffer_hdr)); 69 mUseProxyColorFormat = false; 70 #endif 71 } 72 73 omx_venc::~omx_venc() 74 { 75 //nothing to do 76 } 77 78 /* ====================================================================== 79 FUNCTION 80 omx_venc::ComponentInit 81 82 DESCRIPTION 83 Initialize the component. 84 85 PARAMETERS 86 ctxt -- Context information related to the self. 87 id -- Event identifier. This could be any of the following: 88 1. Command completion event 89 2. Buffer done callback event 90 3. Frame done callback event 91 92 RETURN VALUE 93 None. 94 95 ========================================================================== */ 96 OMX_ERRORTYPE omx_venc::component_init(OMX_STRING role) 97 { 98 99 OMX_ERRORTYPE eRet = OMX_ErrorNone; 100 101 int fds[2]; 102 int r; 103 104 OMX_VIDEO_CODINGTYPE codec_type; 105 106 DEBUG_PRINT_HIGH("\n omx_venc(): Inside component_init()"); 107 // Copy the role information which provides the decoder m_nkind 108 strlcpy((char *)m_nkind,role,OMX_MAX_STRINGNAME_SIZE); 109 110 if(!strncmp((char *)m_nkind,"OMX.qcom.video.encoder.mpeg4",\ 111 OMX_MAX_STRINGNAME_SIZE)) 112 { 113 strlcpy((char *)m_cRole, "video_encoder.mpeg4",\ 114 OMX_MAX_STRINGNAME_SIZE); 115 codec_type = OMX_VIDEO_CodingMPEG4; 116 } 117 else if(!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.h263",\ 118 OMX_MAX_STRINGNAME_SIZE)) 119 { 120 strlcpy((char *)m_cRole, "video_encoder.h263",OMX_MAX_STRINGNAME_SIZE); 121 codec_type = OMX_VIDEO_CodingH263; 122 } 123 else if(!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc",\ 124 OMX_MAX_STRINGNAME_SIZE)) 125 { 126 strlcpy((char *)m_cRole, "video_encoder.avc",OMX_MAX_STRINGNAME_SIZE); 127 codec_type = OMX_VIDEO_CodingAVC; 128 } 129 else if(!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc.secure",\ 130 OMX_MAX_STRINGNAME_SIZE)) 131 { 132 strlcpy((char *)m_cRole, "video_encoder.avc",OMX_MAX_STRINGNAME_SIZE); 133 codec_type = OMX_VIDEO_CodingAVC; 134 secure_session = true; 135 } 136 else 137 { 138 DEBUG_PRINT_ERROR("\nERROR: Unknown Component\n"); 139 eRet = OMX_ErrorInvalidComponentName; 140 } 141 142 143 if(eRet != OMX_ErrorNone) 144 { 145 return eRet; 146 } 147 148 handle = new venc_dev(this); 149 150 if(handle == NULL) 151 { 152 DEBUG_PRINT_ERROR("\nERROR: handle is NULL"); 153 return OMX_ErrorInsufficientResources; 154 } 155 156 if(handle->venc_open(codec_type) != true) 157 { 158 DEBUG_PRINT_ERROR("\nERROR: venc_open failed"); 159 return OMX_ErrorInsufficientResources; 160 } 161 162 //Intialise the OMX layer variables 163 memset(&m_pCallbacks,0,sizeof(OMX_CALLBACKTYPE)); 164 165 OMX_INIT_STRUCT(&m_sPortParam, OMX_PORT_PARAM_TYPE); 166 m_sPortParam.nPorts = 0x2; 167 m_sPortParam.nStartPortNumber = (OMX_U32) PORT_INDEX_IN; 168 169 OMX_INIT_STRUCT(&m_sPortParam_audio, OMX_PORT_PARAM_TYPE); 170 m_sPortParam_audio.nPorts = 0; 171 m_sPortParam_audio.nStartPortNumber = 0; 172 173 OMX_INIT_STRUCT(&m_sPortParam_img, OMX_PORT_PARAM_TYPE); 174 m_sPortParam_img.nPorts = 0; 175 m_sPortParam_img.nStartPortNumber = 0; 176 177 OMX_INIT_STRUCT(&m_sParamBitrate, OMX_VIDEO_PARAM_BITRATETYPE); 178 m_sParamBitrate.nPortIndex = (OMX_U32) PORT_INDEX_OUT; 179 m_sParamBitrate.eControlRate = OMX_Video_ControlRateVariableSkipFrames; 180 m_sParamBitrate.nTargetBitrate = 64000; 181 182 OMX_INIT_STRUCT(&m_sConfigBitrate, OMX_VIDEO_CONFIG_BITRATETYPE); 183 m_sConfigBitrate.nPortIndex = (OMX_U32) PORT_INDEX_OUT; 184 m_sConfigBitrate.nEncodeBitrate = 64000; 185 186 OMX_INIT_STRUCT(&m_sConfigFramerate, OMX_CONFIG_FRAMERATETYPE); 187 m_sConfigFramerate.nPortIndex = (OMX_U32) PORT_INDEX_OUT; 188 m_sConfigFramerate.xEncodeFramerate = 30 << 16; 189 190 OMX_INIT_STRUCT(&m_sConfigIntraRefreshVOP, OMX_CONFIG_INTRAREFRESHVOPTYPE); 191 m_sConfigIntraRefreshVOP.nPortIndex = (OMX_U32) PORT_INDEX_OUT; 192 m_sConfigIntraRefreshVOP.IntraRefreshVOP = OMX_FALSE; 193 194 OMX_INIT_STRUCT(&m_sConfigFrameRotation, OMX_CONFIG_ROTATIONTYPE); 195 m_sConfigFrameRotation.nPortIndex = (OMX_U32) PORT_INDEX_IN; 196 m_sConfigFrameRotation.nRotation = 0; 197 198 OMX_INIT_STRUCT(&m_sSessionQuantization, OMX_VIDEO_PARAM_QUANTIZATIONTYPE); 199 m_sSessionQuantization.nPortIndex = (OMX_U32) PORT_INDEX_OUT; 200 m_sSessionQuantization.nQpI = 9; 201 m_sSessionQuantization.nQpP = 6; 202 m_sSessionQuantization.nQpB = 2; 203 204 OMX_INIT_STRUCT(&m_sAVCSliceFMO, OMX_VIDEO_PARAM_AVCSLICEFMO); 205 m_sAVCSliceFMO.nPortIndex = (OMX_U32) PORT_INDEX_OUT; 206 m_sAVCSliceFMO.eSliceMode = OMX_VIDEO_SLICEMODE_AVCDefault; 207 m_sAVCSliceFMO.nNumSliceGroups = 0; 208 m_sAVCSliceFMO.nSliceGroupMapType = 0; 209 OMX_INIT_STRUCT(&m_sParamProfileLevel, OMX_VIDEO_PARAM_PROFILELEVELTYPE); 210 m_sParamProfileLevel.nPortIndex = (OMX_U32) PORT_INDEX_OUT; 211 212 OMX_INIT_STRUCT(&m_sIntraperiod, QOMX_VIDEO_INTRAPERIODTYPE); 213 m_sIntraperiod.nPortIndex = (OMX_U32) PORT_INDEX_OUT; 214 m_sIntraperiod.nPFrames = (m_sConfigFramerate.xEncodeFramerate * 2) - 1; 215 216 OMX_INIT_STRUCT(&m_sErrorCorrection, OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE); 217 m_sErrorCorrection.nPortIndex = (OMX_U32) PORT_INDEX_OUT; 218 m_sErrorCorrection.bEnableDataPartitioning = OMX_FALSE; 219 m_sErrorCorrection.bEnableHEC = OMX_FALSE; 220 m_sErrorCorrection.bEnableResync = OMX_FALSE; 221 m_sErrorCorrection.bEnableRVLC = OMX_FALSE; 222 m_sErrorCorrection.nResynchMarkerSpacing = 0; 223 224 OMX_INIT_STRUCT(&m_sIntraRefresh, OMX_VIDEO_PARAM_INTRAREFRESHTYPE); 225 m_sIntraRefresh.nPortIndex = (OMX_U32) PORT_INDEX_OUT; 226 m_sIntraRefresh.eRefreshMode = OMX_VIDEO_IntraRefreshMax; 227 228 if(codec_type == OMX_VIDEO_CodingMPEG4) 229 { 230 m_sParamProfileLevel.eProfile = (OMX_U32) OMX_VIDEO_MPEG4ProfileSimple; 231 m_sParamProfileLevel.eLevel = (OMX_U32) OMX_VIDEO_MPEG4Level0; 232 } 233 else if(codec_type == OMX_VIDEO_CodingH263) 234 { 235 m_sParamProfileLevel.eProfile = (OMX_U32) OMX_VIDEO_H263ProfileBaseline; 236 m_sParamProfileLevel.eLevel = (OMX_U32) OMX_VIDEO_H263Level10; 237 } 238 else if(codec_type == OMX_VIDEO_CodingAVC) 239 { 240 m_sParamProfileLevel.eProfile = (OMX_U32) OMX_VIDEO_AVCProfileBaseline; 241 m_sParamProfileLevel.eLevel = (OMX_U32) OMX_VIDEO_AVCLevel1; 242 } 243 244 // Initialize the video parameters for input port 245 OMX_INIT_STRUCT(&m_sInPortDef, OMX_PARAM_PORTDEFINITIONTYPE); 246 m_sInPortDef.nPortIndex= (OMX_U32) PORT_INDEX_IN; 247 m_sInPortDef.bEnabled = OMX_TRUE; 248 m_sInPortDef.bPopulated = OMX_FALSE; 249 m_sInPortDef.eDomain = OMX_PortDomainVideo; 250 m_sInPortDef.eDir = OMX_DirInput; 251 m_sInPortDef.format.video.cMIMEType = "YUV420"; 252 m_sInPortDef.format.video.nFrameWidth = OMX_CORE_QCIF_WIDTH; 253 m_sInPortDef.format.video.nFrameHeight = OMX_CORE_QCIF_HEIGHT; 254 m_sInPortDef.format.video.nStride = OMX_CORE_QCIF_WIDTH; 255 m_sInPortDef.format.video.nSliceHeight = OMX_CORE_QCIF_HEIGHT; 256 m_sInPortDef.format.video.nBitrate = 64000; 257 m_sInPortDef.format.video.xFramerate = 15 << 16; 258 m_sInPortDef.format.video.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar; 259 m_sInPortDef.format.video.eCompressionFormat = OMX_VIDEO_CodingUnused; 260 261 if(dev_get_buf_req(&m_sInPortDef.nBufferCountMin, 262 &m_sInPortDef.nBufferCountActual, 263 &m_sInPortDef.nBufferSize, 264 m_sInPortDef.nPortIndex) != true) 265 { 266 eRet = OMX_ErrorUndefined; 267 268 } 269 270 // Initialize the video parameters for output port 271 OMX_INIT_STRUCT(&m_sOutPortDef, OMX_PARAM_PORTDEFINITIONTYPE); 272 m_sOutPortDef.nPortIndex = (OMX_U32) PORT_INDEX_OUT; 273 m_sOutPortDef.bEnabled = OMX_TRUE; 274 m_sOutPortDef.bPopulated = OMX_FALSE; 275 m_sOutPortDef.eDomain = OMX_PortDomainVideo; 276 m_sOutPortDef.eDir = OMX_DirOutput; 277 m_sOutPortDef.format.video.nFrameWidth = OMX_CORE_QCIF_WIDTH; 278 m_sOutPortDef.format.video.nFrameHeight = OMX_CORE_QCIF_HEIGHT; 279 m_sOutPortDef.format.video.nBitrate = 64000; 280 m_sOutPortDef.format.video.xFramerate = 15 << 16; 281 m_sOutPortDef.format.video.eColorFormat = OMX_COLOR_FormatUnused; 282 if(codec_type == OMX_VIDEO_CodingMPEG4) 283 { 284 m_sOutPortDef.format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4; 285 } 286 else if(codec_type == OMX_VIDEO_CodingH263) 287 { 288 m_sOutPortDef.format.video.eCompressionFormat = OMX_VIDEO_CodingH263; 289 } 290 else 291 { 292 m_sOutPortDef.format.video.eCompressionFormat = OMX_VIDEO_CodingAVC; 293 } 294 if(dev_get_buf_req(&m_sOutPortDef.nBufferCountMin, 295 &m_sOutPortDef.nBufferCountActual, 296 &m_sOutPortDef.nBufferSize, 297 m_sOutPortDef.nPortIndex) != true) 298 { 299 eRet = OMX_ErrorUndefined; 300 } 301 302 // Initialize the video color format for input port 303 OMX_INIT_STRUCT(&m_sInPortFormat, OMX_VIDEO_PARAM_PORTFORMATTYPE); 304 m_sInPortFormat.nPortIndex = (OMX_U32) PORT_INDEX_IN; 305 m_sInPortFormat.nIndex = 0; 306 m_sInPortFormat.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar; 307 m_sInPortFormat.eCompressionFormat = OMX_VIDEO_CodingUnused; 308 309 310 // Initialize the compression format for output port 311 OMX_INIT_STRUCT(&m_sOutPortFormat, OMX_VIDEO_PARAM_PORTFORMATTYPE); 312 m_sOutPortFormat.nPortIndex = (OMX_U32) PORT_INDEX_OUT; 313 m_sOutPortFormat.nIndex = 0; 314 m_sOutPortFormat.eColorFormat = OMX_COLOR_FormatUnused; 315 if(codec_type == OMX_VIDEO_CodingMPEG4) 316 { 317 m_sOutPortFormat.eCompressionFormat = OMX_VIDEO_CodingMPEG4; 318 } 319 else if(codec_type == OMX_VIDEO_CodingH263) 320 { 321 m_sOutPortFormat.eCompressionFormat = OMX_VIDEO_CodingH263; 322 } 323 else 324 { 325 m_sOutPortFormat.eCompressionFormat = OMX_VIDEO_CodingAVC; 326 } 327 328 // mandatory Indices for kronos test suite 329 OMX_INIT_STRUCT(&m_sPriorityMgmt, OMX_PRIORITYMGMTTYPE); 330 331 OMX_INIT_STRUCT(&m_sInBufSupplier, OMX_PARAM_BUFFERSUPPLIERTYPE); 332 m_sInBufSupplier.nPortIndex = (OMX_U32) PORT_INDEX_IN; 333 334 OMX_INIT_STRUCT(&m_sOutBufSupplier, OMX_PARAM_BUFFERSUPPLIERTYPE); 335 m_sOutBufSupplier.nPortIndex = (OMX_U32) PORT_INDEX_OUT; 336 337 338 // mp4 specific init 339 OMX_INIT_STRUCT(&m_sParamMPEG4, OMX_VIDEO_PARAM_MPEG4TYPE); 340 m_sParamMPEG4.nPortIndex = (OMX_U32) PORT_INDEX_OUT; 341 m_sParamMPEG4.eProfile = OMX_VIDEO_MPEG4ProfileSimple; 342 m_sParamMPEG4.eLevel = OMX_VIDEO_MPEG4Level0; 343 m_sParamMPEG4.nSliceHeaderSpacing = 0; 344 m_sParamMPEG4.bSVH = OMX_FALSE; 345 m_sParamMPEG4.bGov = OMX_FALSE; 346 m_sParamMPEG4.nPFrames = (m_sOutPortFormat.xFramerate * 2 - 1); // 2 second intra period for default outport fps 347 m_sParamMPEG4.bACPred = OMX_TRUE; 348 m_sParamMPEG4.nTimeIncRes = 30; // delta = 2 @ 15 fps 349 m_sParamMPEG4.nAllowedPictureTypes = 2; // pframe and iframe 350 m_sParamMPEG4.nHeaderExtension = 1; // number of video packet headers per vop 351 m_sParamMPEG4.bReversibleVLC = OMX_FALSE; 352 353 // h263 specific init 354 OMX_INIT_STRUCT(&m_sParamH263, OMX_VIDEO_PARAM_H263TYPE); 355 m_sParamH263.nPortIndex = (OMX_U32) PORT_INDEX_OUT; 356 m_sParamH263.nPFrames = (m_sOutPortFormat.xFramerate * 2 - 1); // 2 second intra period for default outport fps 357 m_sParamH263.nBFrames = 0; 358 m_sParamH263.eProfile = OMX_VIDEO_H263ProfileBaseline; 359 m_sParamH263.eLevel = OMX_VIDEO_H263Level10; 360 m_sParamH263.bPLUSPTYPEAllowed = OMX_FALSE; 361 m_sParamH263.nAllowedPictureTypes = 2; 362 m_sParamH263.bForceRoundingTypeToZero = OMX_TRUE; 363 m_sParamH263.nPictureHeaderRepetition = 0; 364 m_sParamH263.nGOBHeaderInterval = 1; 365 366 // h264 specific init 367 OMX_INIT_STRUCT(&m_sParamAVC, OMX_VIDEO_PARAM_AVCTYPE); 368 m_sParamAVC.nPortIndex = (OMX_U32) PORT_INDEX_OUT; 369 m_sParamAVC.nSliceHeaderSpacing = 0; 370 m_sParamAVC.nPFrames = (m_sOutPortFormat.xFramerate * 2 - 1); // 2 second intra period for default outport fps 371 m_sParamAVC.nBFrames = 0; 372 m_sParamAVC.bUseHadamard = OMX_FALSE; 373 m_sParamAVC.nRefFrames = 1; 374 m_sParamAVC.nRefIdx10ActiveMinus1 = 1; 375 m_sParamAVC.nRefIdx11ActiveMinus1 = 0; 376 m_sParamAVC.bEnableUEP = OMX_FALSE; 377 m_sParamAVC.bEnableFMO = OMX_FALSE; 378 m_sParamAVC.bEnableASO = OMX_FALSE; 379 m_sParamAVC.bEnableRS = OMX_FALSE; 380 m_sParamAVC.eProfile = OMX_VIDEO_AVCProfileBaseline; 381 m_sParamAVC.eLevel = OMX_VIDEO_AVCLevel1; 382 m_sParamAVC.nAllowedPictureTypes = 2; 383 m_sParamAVC.bFrameMBsOnly = OMX_FALSE; 384 m_sParamAVC.bMBAFF = OMX_FALSE; 385 m_sParamAVC.bEntropyCodingCABAC = OMX_FALSE; 386 m_sParamAVC.bWeightedPPrediction = OMX_FALSE; 387 m_sParamAVC.nWeightedBipredicitonMode = 0; 388 m_sParamAVC.bconstIpred = OMX_FALSE; 389 m_sParamAVC.bDirect8x8Inference = OMX_FALSE; 390 m_sParamAVC.bDirectSpatialTemporal = OMX_FALSE; 391 m_sParamAVC.nCabacInitIdc = 0; 392 m_sParamAVC.eLoopFilterMode = OMX_VIDEO_AVCLoopFilterEnable; 393 394 m_state = OMX_StateLoaded; 395 m_sExtraData = 0; 396 m_sDebugSliceinfo = 0; 397 398 // For H264 enable some parameters in VUI by default 399 if (codec_type == OMX_VIDEO_CodingAVC) 400 { 401 QOMX_VUI_BITSTREAM_RESTRICT parm; 402 OMX_INIT_STRUCT(&parm, QOMX_VUI_BITSTREAM_RESTRICT); 403 parm.bEnable = OMX_TRUE; 404 if (set_parameter(NULL, (OMX_INDEXTYPE)OMX_QcomIndexParamEnableVUIStreamRestrictFlag, 405 (OMX_PTR)&parm)) { 406 // Don't treat this as a fatal error 407 DEBUG_PRINT_ERROR("Unable to set EnableVUIStreamRestrictFlag as default"); 408 } 409 } 410 411 #ifdef _ANDROID_ 412 char value[PROPERTY_VALUE_MAX] = {0}; 413 property_get("vidc.venc.debug.sliceinfo", value, "0"); 414 m_sDebugSliceinfo = (OMX_U32)atoi(value); 415 DEBUG_PRINT_HIGH("vidc.venc.debug.sliceinfo value is %d", m_sDebugSliceinfo); 416 #endif 417 418 if(eRet == OMX_ErrorNone) 419 { 420 if(pipe(fds)) 421 { 422 DEBUG_PRINT_ERROR("ERROR: pipe creation failed\n"); 423 eRet = OMX_ErrorInsufficientResources; 424 } 425 else 426 { 427 if(fds[0] == 0 || fds[1] == 0) 428 { 429 if(pipe(fds)) 430 { 431 DEBUG_PRINT_ERROR("ERROR: pipe creation failed\n"); 432 eRet = OMX_ErrorInsufficientResources; 433 } 434 } 435 if(eRet == OMX_ErrorNone) 436 { 437 m_pipe_in = fds[0]; 438 m_pipe_out = fds[1]; 439 } 440 } 441 r = pthread_create(&msg_thread_id,0,message_thread,this); 442 443 if(r < 0) 444 { 445 eRet = OMX_ErrorInsufficientResources; 446 } 447 else 448 { 449 r = pthread_create(&async_thread_id,0,async_venc_message_thread,this); 450 if(r < 0) 451 { 452 eRet = OMX_ErrorInsufficientResources; 453 } 454 } 455 } 456 457 DEBUG_PRINT_HIGH("\n Component_init return value = 0x%x", eRet); 458 return eRet; 459 } 460 461 462 /* ====================================================================== 463 FUNCTION 464 omx_venc::Setparameter 465 466 DESCRIPTION 467 OMX Set Parameter method implementation. 468 469 PARAMETERS 470 <TBD>. 471 472 RETURN VALUE 473 OMX Error None if successful. 474 475 ========================================================================== */ 476 OMX_ERRORTYPE omx_venc::set_parameter(OMX_IN OMX_HANDLETYPE hComp, 477 OMX_IN OMX_INDEXTYPE paramIndex, 478 OMX_IN OMX_PTR paramData) 479 { 480 OMX_ERRORTYPE eRet = OMX_ErrorNone; 481 482 483 if(m_state == OMX_StateInvalid) 484 { 485 DEBUG_PRINT_ERROR("ERROR: Set Param in Invalid State\n"); 486 return OMX_ErrorInvalidState; 487 } 488 if(paramData == NULL) 489 { 490 DEBUG_PRINT_ERROR("ERROR: Get Param in Invalid paramData \n"); 491 return OMX_ErrorBadParameter; 492 } 493 494 /*set_parameter can be called in loaded state 495 or disabled port */ 496 if(m_state == OMX_StateLoaded 497 || m_sInPortDef.bEnabled == OMX_FALSE 498 || m_sOutPortDef.bEnabled == OMX_FALSE) 499 { 500 DEBUG_PRINT_LOW("Set Parameter called in valid state"); 501 } 502 else 503 { 504 DEBUG_PRINT_ERROR("ERROR: Set Parameter called in Invalid State\n"); 505 return OMX_ErrorIncorrectStateOperation; 506 } 507 508 switch(paramIndex) 509 { 510 case OMX_IndexParamPortDefinition: 511 { 512 OMX_PARAM_PORTDEFINITIONTYPE *portDefn; 513 portDefn = (OMX_PARAM_PORTDEFINITIONTYPE *) paramData; 514 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamPortDefinition H= %d, W = %d\n", 515 (int)portDefn->format.video.nFrameHeight, 516 (int)portDefn->format.video.nFrameWidth); 517 518 if(PORT_INDEX_IN == portDefn->nPortIndex) 519 { 520 DEBUG_PRINT_LOW("\n i/p actual cnt requested = %d\n", portDefn->nBufferCountActual); 521 DEBUG_PRINT_LOW("\n i/p min cnt requested = %d\n", portDefn->nBufferCountMin); 522 DEBUG_PRINT_LOW("\n i/p buffersize requested = %d\n", portDefn->nBufferSize); 523 if(handle->venc_set_param(paramData,OMX_IndexParamPortDefinition) != true) 524 { 525 DEBUG_PRINT_ERROR("\nERROR: venc_set_param input failed"); 526 return OMX_ErrorUnsupportedSetting; 527 } 528 529 DEBUG_PRINT_LOW("\n i/p previous actual cnt = %d\n", m_sInPortDef.nBufferCountActual); 530 DEBUG_PRINT_LOW("\n i/p previous min cnt = %d\n", m_sInPortDef.nBufferCountMin); 531 memcpy(&m_sInPortDef, portDefn,sizeof(OMX_PARAM_PORTDEFINITIONTYPE)); 532 533 #ifdef _ANDROID_ICS_ 534 if (portDefn->format.video.eColorFormat == (OMX_COLOR_FORMATTYPE)QOMX_COLOR_FormatAndroidOpaque) { 535 m_sInPortDef.format.video.eColorFormat = 536 OMX_COLOR_FormatYUV420SemiPlanar; 537 if(secure_session) { 538 secure_color_format = (int) QOMX_COLOR_FormatAndroidOpaque; 539 mUseProxyColorFormat = false; 540 m_input_msg_id = OMX_COMPONENT_GENERATE_ETB; 541 } else if(!mUseProxyColorFormat){ 542 if (!c2d_conv.init()) { 543 DEBUG_PRINT_ERROR("\n C2D init failed"); 544 return OMX_ErrorUnsupportedSetting; 545 } 546 DEBUG_PRINT_ERROR("\nC2D init is successful"); 547 mUseProxyColorFormat = true; 548 m_input_msg_id = OMX_COMPONENT_GENERATE_ETB_OPQ; 549 } 550 } else 551 mUseProxyColorFormat = false; 552 #endif 553 /*Query Input Buffer Requirements*/ 554 dev_get_buf_req (&m_sInPortDef.nBufferCountMin, 555 &m_sInPortDef.nBufferCountActual, 556 &m_sInPortDef.nBufferSize, 557 m_sInPortDef.nPortIndex); 558 559 /*Query ouput Buffer Requirements*/ 560 dev_get_buf_req (&m_sOutPortDef.nBufferCountMin, 561 &m_sOutPortDef.nBufferCountActual, 562 &m_sOutPortDef.nBufferSize, 563 m_sOutPortDef.nPortIndex); 564 m_sInPortDef.nBufferCountActual = portDefn->nBufferCountActual; 565 } 566 else if(PORT_INDEX_OUT == portDefn->nPortIndex) 567 { 568 DEBUG_PRINT_LOW("\n o/p actual cnt requested = %d\n", portDefn->nBufferCountActual); 569 DEBUG_PRINT_LOW("\n o/p min cnt requested = %d\n", portDefn->nBufferCountMin); 570 DEBUG_PRINT_LOW("\n o/p buffersize requested = %d\n", portDefn->nBufferSize); 571 if(handle->venc_set_param(paramData,OMX_IndexParamPortDefinition) != true) 572 { 573 DEBUG_PRINT_ERROR("\nERROR: venc_set_param output failed"); 574 return OMX_ErrorUnsupportedSetting; 575 } 576 memcpy(&m_sOutPortDef,portDefn,sizeof(struct OMX_PARAM_PORTDEFINITIONTYPE)); 577 update_profile_level(); //framerate , bitrate 578 579 DEBUG_PRINT_LOW("\n o/p previous actual cnt = %d\n", m_sOutPortDef.nBufferCountActual); 580 DEBUG_PRINT_LOW("\n o/p previous min cnt = %d\n", m_sOutPortDef.nBufferCountMin); 581 m_sOutPortDef.nBufferCountActual = portDefn->nBufferCountActual; 582 } 583 else 584 { 585 DEBUG_PRINT_ERROR("ERROR: Set_parameter: Bad Port idx %d", 586 (int)portDefn->nPortIndex); 587 eRet = OMX_ErrorBadPortIndex; 588 } 589 m_sConfigFramerate.xEncodeFramerate = portDefn->format.video.xFramerate; 590 m_sConfigBitrate.nEncodeBitrate = portDefn->format.video.nBitrate; 591 m_sParamBitrate.nTargetBitrate = portDefn->format.video.nBitrate; 592 } 593 break; 594 595 case OMX_IndexParamVideoPortFormat: 596 { 597 OMX_VIDEO_PARAM_PORTFORMATTYPE *portFmt = 598 (OMX_VIDEO_PARAM_PORTFORMATTYPE *)paramData; 599 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoPortFormat %d\n", 600 portFmt->eColorFormat); 601 //set the driver with the corresponding values 602 if(PORT_INDEX_IN == portFmt->nPortIndex) 603 { 604 if(handle->venc_set_param(paramData,OMX_IndexParamVideoPortFormat) != true) 605 { 606 return OMX_ErrorUnsupportedSetting; 607 } 608 609 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoPortFormat %d\n", 610 portFmt->eColorFormat); 611 update_profile_level(); //framerate 612 613 #ifdef _ANDROID_ICS_ 614 if (portFmt->eColorFormat == 615 (OMX_COLOR_FORMATTYPE)QOMX_COLOR_FormatAndroidOpaque) { 616 m_sInPortFormat.eColorFormat = OMX_COLOR_FormatYUV420SemiPlanar; 617 if(secure_session) { 618 secure_color_format = (int) QOMX_COLOR_FormatAndroidOpaque; 619 mUseProxyColorFormat = false; 620 m_input_msg_id = OMX_COMPONENT_GENERATE_ETB; 621 } else if(!mUseProxyColorFormat){ 622 if (!c2d_conv.init()) { 623 DEBUG_PRINT_ERROR("\n C2D init failed"); 624 return OMX_ErrorUnsupportedSetting; 625 } 626 DEBUG_PRINT_ERROR("\nC2D init is successful"); 627 mUseProxyColorFormat = true; 628 m_input_msg_id = OMX_COMPONENT_GENERATE_ETB_OPQ; 629 } 630 } 631 else 632 #endif 633 { 634 m_sInPortFormat.eColorFormat = portFmt->eColorFormat; 635 m_input_msg_id = OMX_COMPONENT_GENERATE_ETB; 636 mUseProxyColorFormat = false; 637 } 638 m_sInPortFormat.xFramerate = portFmt->xFramerate; 639 } 640 //TODO if no use case for O/P port,delet m_sOutPortFormat 641 } 642 break; 643 case OMX_IndexParamVideoInit: 644 { //TODO, do we need this index set param 645 OMX_PORT_PARAM_TYPE* pParam = (OMX_PORT_PARAM_TYPE*)(paramData); 646 DEBUG_PRINT_LOW("\n Set OMX_IndexParamVideoInit called"); 647 break; 648 } 649 650 case OMX_IndexParamVideoBitrate: 651 { 652 OMX_VIDEO_PARAM_BITRATETYPE* pParam = (OMX_VIDEO_PARAM_BITRATETYPE*)paramData; 653 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoBitrate"); 654 if(handle->venc_set_param(paramData,OMX_IndexParamVideoBitrate) != true) 655 { 656 return OMX_ErrorUnsupportedSetting; 657 } 658 m_sParamBitrate.nTargetBitrate = pParam->nTargetBitrate; 659 m_sParamBitrate.eControlRate = pParam->eControlRate; 660 update_profile_level(); //bitrate 661 m_sConfigBitrate.nEncodeBitrate = pParam->nTargetBitrate; 662 m_sInPortDef.format.video.nBitrate = pParam->nTargetBitrate; 663 m_sOutPortDef.format.video.nBitrate = pParam->nTargetBitrate; 664 DEBUG_PRINT_LOW("\nbitrate = %u", m_sOutPortDef.format.video.nBitrate); 665 break; 666 } 667 case OMX_IndexParamVideoMpeg4: 668 { 669 OMX_VIDEO_PARAM_MPEG4TYPE* pParam = (OMX_VIDEO_PARAM_MPEG4TYPE*)paramData; 670 OMX_VIDEO_PARAM_MPEG4TYPE mp4_param; 671 memcpy(&mp4_param, pParam, sizeof(struct OMX_VIDEO_PARAM_MPEG4TYPE)); 672 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoMpeg4"); 673 if(pParam->eProfile == OMX_VIDEO_MPEG4ProfileAdvancedSimple) 674 { 675 #ifdef MAX_RES_1080P 676 if(pParam->nBFrames) 677 { 678 DEBUG_PRINT_HIGH("INFO: Only 1 Bframe is supported"); 679 mp4_param.nBFrames = 1; 680 } 681 #else 682 if(pParam->nBFrames) 683 { 684 DEBUG_PRINT_ERROR("Warning: B frames not supported\n"); 685 mp4_param.nBFrames = 0; 686 } 687 #endif 688 } 689 else 690 { 691 if(pParam->nBFrames) 692 { 693 DEBUG_PRINT_ERROR("Warning: B frames not supported\n"); 694 mp4_param.nBFrames = 0; 695 } 696 } 697 if(handle->venc_set_param(&mp4_param,OMX_IndexParamVideoMpeg4) != true) 698 { 699 return OMX_ErrorUnsupportedSetting; 700 } 701 memcpy(&m_sParamMPEG4,pParam, sizeof(struct OMX_VIDEO_PARAM_MPEG4TYPE)); 702 break; 703 } 704 case OMX_IndexParamVideoH263: 705 { 706 OMX_VIDEO_PARAM_H263TYPE* pParam = (OMX_VIDEO_PARAM_H263TYPE*)paramData; 707 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoH263"); 708 if(handle->venc_set_param(paramData,OMX_IndexParamVideoH263) != true) 709 { 710 return OMX_ErrorUnsupportedSetting; 711 } 712 memcpy(&m_sParamH263,pParam, sizeof(struct OMX_VIDEO_PARAM_H263TYPE)); 713 break; 714 } 715 case OMX_IndexParamVideoAvc: 716 { 717 OMX_VIDEO_PARAM_AVCTYPE* pParam = (OMX_VIDEO_PARAM_AVCTYPE*)paramData; 718 OMX_VIDEO_PARAM_AVCTYPE avc_param; 719 memcpy(&avc_param, pParam, sizeof( struct OMX_VIDEO_PARAM_AVCTYPE)); 720 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoAvc"); 721 722 if((pParam->eProfile == OMX_VIDEO_AVCProfileHigh)|| 723 (pParam->eProfile == OMX_VIDEO_AVCProfileMain)) 724 { 725 #ifdef MAX_RES_1080P 726 if(pParam->nBFrames) 727 { 728 DEBUG_PRINT_HIGH("INFO: Only 1 Bframe is supported"); 729 avc_param.nBFrames = 1; 730 } 731 if(pParam->nRefFrames != 2) 732 { 733 DEBUG_PRINT_ERROR("Warning: 2 RefFrames are needed, changing RefFrames from %d to 2", pParam->nRefFrames); 734 avc_param.nRefFrames = 2; 735 } 736 #else 737 if(pParam->nBFrames) 738 { 739 DEBUG_PRINT_ERROR("Warning: B frames not supported\n"); 740 avc_param.nBFrames = 0; 741 } 742 if(pParam->nRefFrames != 1) 743 { 744 DEBUG_PRINT_ERROR("Warning: Only 1 RefFrame is supported, changing RefFrame from %d to 1)", pParam->nRefFrames); 745 avc_param.nRefFrames = 1; 746 } 747 #endif 748 } 749 else 750 { 751 if(pParam->nRefFrames != 1) 752 { 753 DEBUG_PRINT_ERROR("Warning: Only 1 RefFrame is supported, changing RefFrame from %d to 1)", pParam->nRefFrames); 754 avc_param.nRefFrames = 1; 755 } 756 if(pParam->nBFrames) 757 { 758 DEBUG_PRINT_ERROR("Warning: B frames not supported\n"); 759 avc_param.nBFrames = 0; 760 } 761 } 762 if(handle->venc_set_param(&avc_param,OMX_IndexParamVideoAvc) != true) 763 { 764 return OMX_ErrorUnsupportedSetting; 765 } 766 767 memcpy(&m_sParamAVC,pParam, sizeof(struct OMX_VIDEO_PARAM_AVCTYPE)); 768 break; 769 } 770 case OMX_IndexParamVideoProfileLevelCurrent: 771 { 772 OMX_VIDEO_PARAM_PROFILELEVELTYPE* pParam = (OMX_VIDEO_PARAM_PROFILELEVELTYPE*)paramData; 773 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoProfileLevelCurrent"); 774 if(handle->venc_set_param(pParam,OMX_IndexParamVideoProfileLevelCurrent) != true) 775 { 776 DEBUG_PRINT_ERROR("set_parameter: OMX_IndexParamVideoProfileLevelCurrent failed for Profile: %d " 777 "Level :%d", pParam->eProfile, pParam->eLevel); 778 return OMX_ErrorUnsupportedSetting; 779 } 780 m_sParamProfileLevel.eProfile = pParam->eProfile; 781 m_sParamProfileLevel.eLevel = pParam->eLevel; 782 783 if(!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.mpeg4",\ 784 OMX_MAX_STRINGNAME_SIZE)) 785 { 786 m_sParamMPEG4.eProfile = (OMX_VIDEO_MPEG4PROFILETYPE)m_sParamProfileLevel.eProfile; 787 m_sParamMPEG4.eLevel = (OMX_VIDEO_MPEG4LEVELTYPE)m_sParamProfileLevel.eLevel; 788 DEBUG_PRINT_LOW("\n MPEG4 profile = %d, level = %d", m_sParamMPEG4.eProfile, 789 m_sParamMPEG4.eLevel); 790 } 791 else if(!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.h263",\ 792 OMX_MAX_STRINGNAME_SIZE)) 793 { 794 m_sParamH263.eProfile = (OMX_VIDEO_H263PROFILETYPE)m_sParamProfileLevel.eProfile; 795 m_sParamH263.eLevel = (OMX_VIDEO_H263LEVELTYPE)m_sParamProfileLevel.eLevel; 796 DEBUG_PRINT_LOW("\n H263 profile = %d, level = %d", m_sParamH263.eProfile, 797 m_sParamH263.eLevel); 798 } 799 else if(!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc",\ 800 OMX_MAX_STRINGNAME_SIZE)) 801 { 802 m_sParamAVC.eProfile = (OMX_VIDEO_AVCPROFILETYPE)m_sParamProfileLevel.eProfile; 803 m_sParamAVC.eLevel = (OMX_VIDEO_AVCLEVELTYPE)m_sParamProfileLevel.eLevel; 804 DEBUG_PRINT_LOW("\n AVC profile = %d, level = %d", m_sParamAVC.eProfile, 805 m_sParamAVC.eLevel); 806 } 807 break; 808 } 809 case OMX_IndexParamStandardComponentRole: 810 { 811 OMX_PARAM_COMPONENTROLETYPE *comp_role; 812 comp_role = (OMX_PARAM_COMPONENTROLETYPE *) paramData; 813 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamStandardComponentRole %s\n", 814 comp_role->cRole); 815 816 if((m_state == OMX_StateLoaded)&& 817 !BITMASK_PRESENT(&m_flags,OMX_COMPONENT_IDLE_PENDING)) 818 { 819 DEBUG_PRINT_LOW("Set Parameter called in valid state"); 820 } 821 else 822 { 823 DEBUG_PRINT_ERROR("Set Parameter called in Invalid State\n"); 824 return OMX_ErrorIncorrectStateOperation; 825 } 826 827 if(!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.avc",OMX_MAX_STRINGNAME_SIZE)) 828 { 829 if(!strncmp((char*)comp_role->cRole,"video_encoder.avc",OMX_MAX_STRINGNAME_SIZE)) 830 { 831 strlcpy((char*)m_cRole,"video_encoder.avc",OMX_MAX_STRINGNAME_SIZE); 832 } 833 else 834 { 835 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s\n", comp_role->cRole); 836 eRet =OMX_ErrorUnsupportedSetting; 837 } 838 } 839 else if(!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.mpeg4",OMX_MAX_STRINGNAME_SIZE)) 840 { 841 if(!strncmp((const char*)comp_role->cRole,"video_encoder.mpeg4",OMX_MAX_STRINGNAME_SIZE)) 842 { 843 strlcpy((char*)m_cRole,"video_encoder.mpeg4",OMX_MAX_STRINGNAME_SIZE); 844 } 845 else 846 { 847 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s\n", comp_role->cRole); 848 eRet = OMX_ErrorUnsupportedSetting; 849 } 850 } 851 else if(!strncmp((char*)m_nkind, "OMX.qcom.video.encoder.h263",OMX_MAX_STRINGNAME_SIZE)) 852 { 853 if(!strncmp((const char*)comp_role->cRole,"video_encoder.h263",OMX_MAX_STRINGNAME_SIZE)) 854 { 855 strlcpy((char*)m_cRole,"video_encoder.h263",OMX_MAX_STRINGNAME_SIZE); 856 } 857 else 858 { 859 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown Index %s\n", comp_role->cRole); 860 eRet =OMX_ErrorUnsupportedSetting; 861 } 862 } 863 else 864 { 865 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown param %s\n", m_nkind); 866 eRet = OMX_ErrorInvalidComponentName; 867 } 868 break; 869 } 870 871 case OMX_IndexParamPriorityMgmt: 872 { 873 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamPriorityMgmt"); 874 if(m_state != OMX_StateLoaded) 875 { 876 DEBUG_PRINT_ERROR("ERROR: Set Parameter called in Invalid State\n"); 877 return OMX_ErrorIncorrectStateOperation; 878 } 879 OMX_PRIORITYMGMTTYPE *priorityMgmtype = (OMX_PRIORITYMGMTTYPE*) paramData; 880 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamPriorityMgmt %d\n", 881 priorityMgmtype->nGroupID); 882 883 DEBUG_PRINT_LOW("set_parameter: priorityMgmtype %d\n", 884 priorityMgmtype->nGroupPriority); 885 886 m_sPriorityMgmt.nGroupID = priorityMgmtype->nGroupID; 887 m_sPriorityMgmt.nGroupPriority = priorityMgmtype->nGroupPriority; 888 889 break; 890 } 891 892 case OMX_IndexParamCompBufferSupplier: 893 { 894 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamCompBufferSupplier"); 895 OMX_PARAM_BUFFERSUPPLIERTYPE *bufferSupplierType = (OMX_PARAM_BUFFERSUPPLIERTYPE*) paramData; 896 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamCompBufferSupplier %d\n", 897 bufferSupplierType->eBufferSupplier); 898 if(bufferSupplierType->nPortIndex == 0 || bufferSupplierType->nPortIndex ==1) 899 m_sInBufSupplier.eBufferSupplier = bufferSupplierType->eBufferSupplier; 900 901 else 902 903 eRet = OMX_ErrorBadPortIndex; 904 905 break; 906 907 } 908 case OMX_IndexParamVideoQuantization: 909 { 910 DEBUG_PRINT_LOW("set_parameter: OMX_IndexParamVideoQuantization\n"); 911 OMX_VIDEO_PARAM_QUANTIZATIONTYPE *session_qp = (OMX_VIDEO_PARAM_QUANTIZATIONTYPE*) paramData; 912 if(session_qp->nPortIndex == PORT_INDEX_OUT) 913 { 914 if(handle->venc_set_param(paramData, OMX_IndexParamVideoQuantization) != true) 915 { 916 return OMX_ErrorUnsupportedSetting; 917 } 918 m_sSessionQuantization.nQpI = session_qp->nQpI; 919 m_sSessionQuantization.nQpP = session_qp->nQpP; 920 } 921 else 922 { 923 DEBUG_PRINT_ERROR("\nERROR: Unsupported port Index for Session QP setting\n"); 924 eRet = OMX_ErrorBadPortIndex; 925 } 926 break; 927 } 928 929 case OMX_QcomIndexPortDefn: 930 { 931 OMX_QCOM_PARAM_PORTDEFINITIONTYPE* pParam = 932 (OMX_QCOM_PARAM_PORTDEFINITIONTYPE*)paramData; 933 DEBUG_PRINT_LOW("set_parameter: OMX_QcomIndexPortDefn"); 934 if(pParam->nPortIndex == (OMX_U32)PORT_INDEX_IN) 935 { 936 if(pParam->nMemRegion > OMX_QCOM_MemRegionInvalid && 937 pParam->nMemRegion < OMX_QCOM_MemRegionMax) 938 { 939 m_use_input_pmem = OMX_TRUE; 940 } 941 else 942 { 943 m_use_input_pmem = OMX_FALSE; 944 } 945 } 946 else if (pParam->nPortIndex == (OMX_U32)PORT_INDEX_OUT) 947 { 948 if(pParam->nMemRegion > OMX_QCOM_MemRegionInvalid && 949 pParam->nMemRegion < OMX_QCOM_MemRegionMax) 950 { 951 m_use_output_pmem = OMX_TRUE; 952 } 953 else 954 { 955 m_use_output_pmem = OMX_FALSE; 956 } 957 } 958 else 959 { 960 DEBUG_PRINT_ERROR("ERROR: SetParameter called on unsupported Port Index for QcomPortDefn"); 961 return OMX_ErrorBadPortIndex; 962 } 963 break; 964 } 965 966 case OMX_IndexParamVideoErrorCorrection: 967 { 968 DEBUG_PRINT_LOW("OMX_IndexParamVideoErrorCorrection\n"); 969 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE* pParam = 970 (OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE*)paramData; 971 if(!handle->venc_set_param(paramData, OMX_IndexParamVideoErrorCorrection)) 972 { 973 DEBUG_PRINT_ERROR("\nERROR: Request for setting Error Resilience failed"); 974 return OMX_ErrorUnsupportedSetting; 975 } 976 memcpy(&m_sErrorCorrection,pParam, sizeof(m_sErrorCorrection)); 977 break; 978 } 979 case OMX_IndexParamVideoIntraRefresh: 980 { 981 DEBUG_PRINT_LOW("set_param:OMX_IndexParamVideoIntraRefresh\n"); 982 OMX_VIDEO_PARAM_INTRAREFRESHTYPE* pParam = 983 (OMX_VIDEO_PARAM_INTRAREFRESHTYPE*)paramData; 984 if(!handle->venc_set_param(paramData,OMX_IndexParamVideoIntraRefresh)) 985 { 986 DEBUG_PRINT_ERROR("\nERROR: Request for setting intra refresh failed"); 987 return OMX_ErrorUnsupportedSetting; 988 } 989 memcpy(&m_sIntraRefresh, pParam, sizeof(m_sIntraRefresh)); 990 break; 991 } 992 #ifdef _ANDROID_ICS_ 993 case OMX_QcomIndexParamVideoMetaBufferMode: 994 { 995 StoreMetaDataInBuffersParams *pParam = 996 (StoreMetaDataInBuffersParams*)paramData; 997 if(pParam->nPortIndex == PORT_INDEX_IN) 998 { 999 if(pParam->bStoreMetaData != meta_mode_enable) 1000 { 1001 if(!handle->venc_set_meta_mode(pParam->bStoreMetaData)) 1002 { 1003 DEBUG_PRINT_ERROR("\nERROR: set Metabuffer mode %d fail", 1004 pParam->bStoreMetaData); 1005 return OMX_ErrorUnsupportedSetting; 1006 } 1007 meta_mode_enable = pParam->bStoreMetaData; 1008 if(meta_mode_enable) { 1009 m_sInPortDef.nBufferCountActual = 4; 1010 if(handle->venc_set_param(&m_sInPortDef,OMX_IndexParamPortDefinition) != true) 1011 { 1012 DEBUG_PRINT_ERROR("\nERROR: venc_set_param input failed"); 1013 return OMX_ErrorUnsupportedSetting; 1014 } 1015 } else { 1016 /*TODO: reset encoder driver Meta mode*/ 1017 dev_get_buf_req (&m_sOutPortDef.nBufferCountMin, 1018 &m_sOutPortDef.nBufferCountActual, 1019 &m_sOutPortDef.nBufferSize, 1020 m_sOutPortDef.nPortIndex); 1021 } 1022 } 1023 } else { 1024 DEBUG_PRINT_ERROR("set_parameter: metamode is " 1025 "valid for input port only"); 1026 eRet = OMX_ErrorUnsupportedSetting; 1027 } 1028 break; 1029 } 1030 #endif 1031 #ifndef MAX_RES_720P 1032 case OMX_QcomIndexParamIndexExtraDataType: 1033 { 1034 DEBUG_PRINT_LOW("set_parameter: OMX_QcomIndexParamIndexExtraDataType"); 1035 QOMX_INDEXEXTRADATATYPE *pParam = (QOMX_INDEXEXTRADATATYPE *)paramData; 1036 if (pParam->nIndex == (OMX_INDEXTYPE)OMX_ExtraDataVideoEncoderSliceInfo) 1037 { 1038 if (pParam->nPortIndex == PORT_INDEX_OUT) 1039 { 1040 if (pParam->bEnabled == OMX_TRUE) 1041 m_sExtraData |= VEN_EXTRADATA_SLICEINFO; 1042 else 1043 m_sExtraData &= ~VEN_EXTRADATA_SLICEINFO; 1044 DEBUG_PRINT_HIGH("set_param: m_sExtraData=%x", m_sExtraData); 1045 if(handle->venc_set_param(&m_sExtraData, 1046 (OMX_INDEXTYPE)OMX_ExtraDataVideoEncoderSliceInfo) != true) 1047 { 1048 DEBUG_PRINT_ERROR("ERROR: Setting " 1049 "OMX_QcomIndexParamIndexExtraDataType failed"); 1050 return OMX_ErrorUnsupportedSetting; 1051 } 1052 else 1053 { 1054 m_sOutPortDef.nPortIndex = PORT_INDEX_OUT; 1055 dev_get_buf_req(&m_sOutPortDef.nBufferCountMin, 1056 &m_sOutPortDef.nBufferCountActual, 1057 &m_sOutPortDef.nBufferSize, 1058 m_sOutPortDef.nPortIndex); 1059 DEBUG_PRINT_HIGH("updated out_buf_req: buffer cnt=%d, " 1060 "count min=%d, buffer size=%d", 1061 m_sOutPortDef.nBufferCountActual, 1062 m_sOutPortDef.nBufferCountMin, 1063 m_sOutPortDef.nBufferSize); 1064 } 1065 } 1066 else 1067 { 1068 DEBUG_PRINT_ERROR("set_parameter: slice information is " 1069 "valid for output port only"); 1070 eRet = OMX_ErrorUnsupportedIndex; 1071 } 1072 } 1073 else 1074 { 1075 DEBUG_PRINT_ERROR("set_parameter: unsupported index (%x), " 1076 "only slice information extradata is supported", pParam->nIndex); 1077 eRet = OMX_ErrorUnsupportedIndex; 1078 } 1079 break; 1080 } 1081 #endif 1082 case OMX_QcomIndexParamVideoMaxAllowedBitrateCheck: 1083 { 1084 QOMX_EXTNINDEX_PARAMTYPE* pParam = 1085 (QOMX_EXTNINDEX_PARAMTYPE*)paramData; 1086 if(pParam->nPortIndex == PORT_INDEX_OUT) 1087 { 1088 handle->m_max_allowed_bitrate_check = 1089 ((pParam->bEnable == OMX_TRUE) ? true : false); 1090 DEBUG_PRINT_HIGH("set_parameter: max allowed bitrate check %s", 1091 ((pParam->bEnable == OMX_TRUE) ? "enabled" : "disabled")); 1092 } 1093 else 1094 { 1095 DEBUG_PRINT_ERROR("ERROR: OMX_QcomIndexParamVideoMaxAllowedBitrateCheck " 1096 " called on wrong port(%d)", pParam->nPortIndex); 1097 return OMX_ErrorBadPortIndex; 1098 } 1099 break; 1100 } 1101 #ifdef MAX_RES_1080P 1102 case OMX_QcomIndexEnableSliceDeliveryMode: 1103 { 1104 QOMX_EXTNINDEX_PARAMTYPE* pParam = 1105 (QOMX_EXTNINDEX_PARAMTYPE*)paramData; 1106 if(pParam->nPortIndex == PORT_INDEX_OUT) 1107 { 1108 if(!handle->venc_set_param(paramData, 1109 (OMX_INDEXTYPE)OMX_QcomIndexEnableSliceDeliveryMode)) 1110 { 1111 DEBUG_PRINT_ERROR("ERROR: Request for setting slice delivery mode failed"); 1112 return OMX_ErrorUnsupportedSetting; 1113 } 1114 } 1115 else 1116 { 1117 DEBUG_PRINT_ERROR("ERROR: OMX_QcomIndexEnableSliceDeliveryMode " 1118 "called on wrong port(%d)", pParam->nPortIndex); 1119 return OMX_ErrorBadPortIndex; 1120 } 1121 break; 1122 } 1123 #endif 1124 case OMX_QcomIndexParamSequenceHeaderWithIDR: 1125 { 1126 if(!handle->venc_set_param(paramData, 1127 (OMX_INDEXTYPE)OMX_QcomIndexParamSequenceHeaderWithIDR)) 1128 { 1129 DEBUG_PRINT_ERROR("ERROR: Request for setting inband sps/pps failed"); 1130 return OMX_ErrorUnsupportedSetting; 1131 } 1132 break; 1133 } 1134 case OMX_QcomIndexParamEnableVUIStreamRestrictFlag: 1135 { 1136 if(!handle->venc_set_param(paramData, 1137 (OMX_INDEXTYPE)OMX_QcomIndexParamEnableVUIStreamRestrictFlag)) 1138 { 1139 DEBUG_PRINT_ERROR("ERROR: Request for enabling bitstream_restrict " 1140 "flag in VUI failed"); 1141 return OMX_ErrorUnsupportedSetting; 1142 } 1143 break; 1144 } 1145 case OMX_IndexParamVideoSliceFMO: 1146 default: 1147 { 1148 DEBUG_PRINT_ERROR("ERROR: Setparameter: unknown param %d\n", paramIndex); 1149 eRet = OMX_ErrorUnsupportedIndex; 1150 break; 1151 } 1152 } 1153 return eRet; 1154 } 1155 1156 bool omx_venc::update_profile_level() 1157 { 1158 OMX_U32 eProfile, eLevel; 1159 1160 if(!handle->venc_get_profile_level(&eProfile,&eLevel)) 1161 { 1162 DEBUG_PRINT_ERROR("\nFailed to update the profile_level\n"); 1163 return false; 1164 } 1165 1166 m_sParamProfileLevel.eProfile = (OMX_VIDEO_MPEG4PROFILETYPE)eProfile; 1167 m_sParamProfileLevel.eLevel = (OMX_VIDEO_MPEG4LEVELTYPE)eLevel; 1168 1169 if(!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.mpeg4",\ 1170 OMX_MAX_STRINGNAME_SIZE)) 1171 { 1172 m_sParamMPEG4.eProfile = (OMX_VIDEO_MPEG4PROFILETYPE)eProfile; 1173 m_sParamMPEG4.eLevel = (OMX_VIDEO_MPEG4LEVELTYPE)eLevel; 1174 DEBUG_PRINT_LOW("\n MPEG4 profile = %d, level = %d", m_sParamMPEG4.eProfile, 1175 m_sParamMPEG4.eLevel); 1176 } 1177 else if(!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.h263",\ 1178 OMX_MAX_STRINGNAME_SIZE)) 1179 { 1180 m_sParamH263.eProfile = (OMX_VIDEO_H263PROFILETYPE)eProfile; 1181 m_sParamH263.eLevel = (OMX_VIDEO_H263LEVELTYPE)eLevel; 1182 DEBUG_PRINT_LOW("\n H263 profile = %d, level = %d", m_sParamH263.eProfile, 1183 m_sParamH263.eLevel); 1184 } 1185 else if(!strncmp((char *)m_nkind, "OMX.qcom.video.encoder.avc",\ 1186 OMX_MAX_STRINGNAME_SIZE)) 1187 { 1188 m_sParamAVC.eProfile = (OMX_VIDEO_AVCPROFILETYPE)eProfile; 1189 m_sParamAVC.eLevel = (OMX_VIDEO_AVCLEVELTYPE)eLevel; 1190 DEBUG_PRINT_LOW("\n AVC profile = %d, level = %d", m_sParamAVC.eProfile, 1191 m_sParamAVC.eLevel); 1192 } 1193 return true; 1194 } 1195 /* ====================================================================== 1196 FUNCTION 1197 omx_video::SetConfig 1198 1199 DESCRIPTION 1200 OMX Set Config method implementation 1201 1202 PARAMETERS 1203 <TBD>. 1204 1205 RETURN VALUE 1206 OMX Error None if successful. 1207 ========================================================================== */ 1208 OMX_ERRORTYPE omx_venc::set_config(OMX_IN OMX_HANDLETYPE hComp, 1209 OMX_IN OMX_INDEXTYPE configIndex, 1210 OMX_IN OMX_PTR configData) 1211 { 1212 if(configData == NULL) 1213 { 1214 DEBUG_PRINT_ERROR("ERROR: param is null"); 1215 return OMX_ErrorBadParameter; 1216 } 1217 1218 if(m_state == OMX_StateInvalid) 1219 { 1220 DEBUG_PRINT_ERROR("ERROR: config called in Invalid state"); 1221 return OMX_ErrorIncorrectStateOperation; 1222 } 1223 1224 // params will be validated prior to venc_init 1225 switch(configIndex) 1226 { 1227 case OMX_IndexConfigVideoBitrate: 1228 { 1229 OMX_VIDEO_CONFIG_BITRATETYPE* pParam = 1230 reinterpret_cast<OMX_VIDEO_CONFIG_BITRATETYPE*>(configData); 1231 DEBUG_PRINT_LOW("\n omx_venc:: set_config(): OMX_IndexConfigVideoBitrate"); 1232 1233 if(pParam->nPortIndex == PORT_INDEX_OUT) 1234 { 1235 if(handle->venc_set_config(configData, OMX_IndexConfigVideoBitrate) != true) 1236 { 1237 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigVideoBitrate failed"); 1238 return OMX_ErrorUnsupportedSetting; 1239 } 1240 1241 m_sConfigBitrate.nEncodeBitrate = pParam->nEncodeBitrate; 1242 m_sParamBitrate.nTargetBitrate = pParam->nEncodeBitrate; 1243 m_sOutPortDef.format.video.nBitrate = pParam->nEncodeBitrate; 1244 } 1245 else 1246 { 1247 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", pParam->nPortIndex); 1248 return OMX_ErrorBadPortIndex; 1249 } 1250 break; 1251 } 1252 case OMX_IndexConfigVideoFramerate: 1253 { 1254 OMX_CONFIG_FRAMERATETYPE* pParam = 1255 reinterpret_cast<OMX_CONFIG_FRAMERATETYPE*>(configData); 1256 DEBUG_PRINT_LOW("\n omx_venc:: set_config(): OMX_IndexConfigVideoFramerate"); 1257 1258 if(pParam->nPortIndex == PORT_INDEX_OUT) 1259 { 1260 if(handle->venc_set_config(configData, OMX_IndexConfigVideoFramerate) != true) 1261 { 1262 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigVideoFramerate failed"); 1263 return OMX_ErrorUnsupportedSetting; 1264 } 1265 1266 m_sConfigFramerate.xEncodeFramerate = pParam->xEncodeFramerate; 1267 m_sOutPortDef.format.video.xFramerate = pParam->xEncodeFramerate; 1268 m_sOutPortFormat.xFramerate = pParam->xEncodeFramerate; 1269 } 1270 else 1271 { 1272 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", pParam->nPortIndex); 1273 return OMX_ErrorBadPortIndex; 1274 } 1275 1276 break; 1277 } 1278 case QOMX_IndexConfigVideoIntraperiod: 1279 { 1280 QOMX_VIDEO_INTRAPERIODTYPE* pParam = 1281 reinterpret_cast<QOMX_VIDEO_INTRAPERIODTYPE*>(configData); 1282 1283 if(pParam->nPortIndex == PORT_INDEX_OUT) 1284 { 1285 #ifdef MAX_RES_720P 1286 if(pParam->nBFrames > 0) 1287 { 1288 DEBUG_PRINT_ERROR("B frames not supported\n"); 1289 return OMX_ErrorUnsupportedSetting; 1290 } 1291 #endif 1292 if(handle->venc_set_config(configData, (OMX_INDEXTYPE) QOMX_IndexConfigVideoIntraperiod) != true) 1293 { 1294 DEBUG_PRINT_ERROR("ERROR: Setting QOMX_IndexConfigVideoIntraperiod failed"); 1295 return OMX_ErrorUnsupportedSetting; 1296 } 1297 m_sIntraperiod.nPFrames = pParam->nPFrames; 1298 m_sIntraperiod.nBFrames = pParam->nBFrames; 1299 m_sIntraperiod.nIDRPeriod = pParam->nIDRPeriod; 1300 1301 if(m_sOutPortFormat.eCompressionFormat == OMX_VIDEO_CodingMPEG4) 1302 { 1303 m_sParamMPEG4.nPFrames = pParam->nPFrames; 1304 if(m_sParamMPEG4.eProfile != OMX_VIDEO_MPEG4ProfileSimple) 1305 m_sParamMPEG4.nBFrames = pParam->nBFrames; 1306 else 1307 m_sParamMPEG4.nBFrames = 0; 1308 } 1309 else if(m_sOutPortFormat.eCompressionFormat == OMX_VIDEO_CodingH263) 1310 { 1311 m_sParamH263.nPFrames = pParam->nPFrames; 1312 } 1313 else 1314 { 1315 m_sParamAVC.nPFrames = pParam->nPFrames; 1316 if(m_sParamAVC.eProfile != OMX_VIDEO_AVCProfileBaseline) 1317 m_sParamAVC.nBFrames = pParam->nBFrames; 1318 else 1319 m_sParamAVC.nBFrames = 0; 1320 } 1321 } 1322 else 1323 { 1324 DEBUG_PRINT_ERROR("ERROR: (QOMX_IndexConfigVideoIntraperiod) Unsupported port index: %u", pParam->nPortIndex); 1325 return OMX_ErrorBadPortIndex; 1326 } 1327 1328 break; 1329 } 1330 1331 case OMX_IndexConfigVideoIntraVOPRefresh: 1332 { 1333 OMX_CONFIG_INTRAREFRESHVOPTYPE* pParam = 1334 reinterpret_cast<OMX_CONFIG_INTRAREFRESHVOPTYPE*>(configData); 1335 1336 if(pParam->nPortIndex == PORT_INDEX_OUT) 1337 { 1338 if(handle->venc_set_config(configData, 1339 OMX_IndexConfigVideoIntraVOPRefresh) != true) 1340 { 1341 DEBUG_PRINT_ERROR("ERROR: Setting OMX_IndexConfigVideoIntraVOPRefresh failed"); 1342 return OMX_ErrorUnsupportedSetting; 1343 } 1344 1345 m_sConfigIntraRefreshVOP.IntraRefreshVOP = pParam->IntraRefreshVOP; 1346 } 1347 else 1348 { 1349 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", pParam->nPortIndex); 1350 return OMX_ErrorBadPortIndex; 1351 } 1352 1353 break; 1354 } 1355 case OMX_IndexConfigCommonRotate: 1356 { 1357 OMX_CONFIG_ROTATIONTYPE *pParam = 1358 reinterpret_cast<OMX_CONFIG_ROTATIONTYPE*>(configData); 1359 OMX_S32 nRotation; 1360 1361 if(pParam->nPortIndex != PORT_INDEX_IN){ 1362 DEBUG_PRINT_ERROR("ERROR: Unsupported port index: %u", pParam->nPortIndex); 1363 return OMX_ErrorBadPortIndex; 1364 } 1365 if( pParam->nRotation == 0 || 1366 pParam->nRotation == 90 || 1367 pParam->nRotation == 180 || 1368 pParam->nRotation == 270 ) { 1369 DEBUG_PRINT_HIGH("\nset_config: Rotation Angle %u", pParam->nRotation); 1370 } else { 1371 DEBUG_PRINT_ERROR("ERROR: un supported Rotation %u", pParam->nRotation); 1372 return OMX_ErrorUnsupportedSetting; 1373 } 1374 nRotation = pParam->nRotation - m_sConfigFrameRotation.nRotation; 1375 if(nRotation < 0) 1376 nRotation = -nRotation; 1377 if(nRotation == 90 || nRotation == 270) { 1378 DEBUG_PRINT_HIGH("\nset_config: updating device Dims"); 1379 if(handle->venc_set_config(configData, 1380 OMX_IndexConfigCommonRotate) != true) { 1381 DEBUG_PRINT_ERROR("ERROR: Set OMX_IndexConfigCommonRotate failed"); 1382 return OMX_ErrorUnsupportedSetting; 1383 } else { 1384 OMX_U32 nFrameWidth; 1385 1386 DEBUG_PRINT_HIGH("\nset_config: updating port Dims"); 1387 1388 nFrameWidth = m_sInPortDef.format.video.nFrameWidth; 1389 m_sInPortDef.format.video.nFrameWidth = 1390 m_sInPortDef.format.video.nFrameHeight; 1391 m_sInPortDef.format.video.nFrameHeight = nFrameWidth; 1392 1393 m_sOutPortDef.format.video.nFrameWidth = 1394 m_sInPortDef.format.video.nFrameWidth; 1395 m_sOutPortDef.format.video.nFrameHeight = 1396 m_sInPortDef.format.video.nFrameHeight; 1397 m_sConfigFrameRotation.nRotation = pParam->nRotation; 1398 } 1399 } else { 1400 m_sConfigFrameRotation.nRotation = pParam->nRotation; 1401 } 1402 break; 1403 } 1404 case OMX_QcomIndexConfigVideoFramePackingArrangement: 1405 { 1406 if(m_sOutPortFormat.eCompressionFormat == OMX_VIDEO_CodingAVC) 1407 { 1408 OMX_QCOM_FRAME_PACK_ARRANGEMENT *configFmt = 1409 (OMX_QCOM_FRAME_PACK_ARRANGEMENT *) configData; 1410 extra_data_handle.set_frame_pack_data(configFmt); 1411 } 1412 else 1413 { 1414 DEBUG_PRINT_ERROR("ERROR: FramePackingData not supported for non AVC compression"); 1415 } 1416 break; 1417 } 1418 default: 1419 DEBUG_PRINT_ERROR("ERROR: unsupported index %d", (int) configIndex); 1420 break; 1421 } 1422 1423 return OMX_ErrorNone; 1424 } 1425 1426 /* ====================================================================== 1427 FUNCTION 1428 omx_venc::ComponentDeInit 1429 1430 DESCRIPTION 1431 Destroys the component and release memory allocated to the heap. 1432 1433 PARAMETERS 1434 <TBD>. 1435 1436 RETURN VALUE 1437 OMX Error None if everything successful. 1438 1439 ========================================================================== */ 1440 OMX_ERRORTYPE omx_venc::component_deinit(OMX_IN OMX_HANDLETYPE hComp) 1441 { 1442 OMX_U32 i = 0; 1443 DEBUG_PRINT_HIGH("\n omx_venc(): Inside component_deinit()"); 1444 if(OMX_StateLoaded != m_state) 1445 { 1446 DEBUG_PRINT_ERROR("WARNING:Rxd DeInit,OMX not in LOADED state %d\n",\ 1447 m_state); 1448 } 1449 if(m_out_mem_ptr) 1450 { 1451 DEBUG_PRINT_LOW("Freeing the Output Memory\n"); 1452 for(i=0; i< m_sOutPortDef.nBufferCountActual; i++ ) 1453 { 1454 free_output_buffer (&m_out_mem_ptr[i]); 1455 } 1456 free(m_out_mem_ptr); 1457 m_out_mem_ptr = NULL; 1458 } 1459 1460 /*Check if the input buffers have to be cleaned up*/ 1461 if(m_inp_mem_ptr 1462 #ifdef _ANDROID_ICS_ 1463 && !meta_mode_enable 1464 #endif 1465 ) 1466 { 1467 DEBUG_PRINT_LOW("Freeing the Input Memory\n"); 1468 for(i=0; i<m_sInPortDef.nBufferCountActual; i++ ) 1469 { 1470 free_input_buffer (&m_inp_mem_ptr[i]); 1471 } 1472 1473 1474 free(m_inp_mem_ptr); 1475 m_inp_mem_ptr = NULL; 1476 } 1477 1478 // Reset counters in mesg queues 1479 m_ftb_q.m_size=0; 1480 m_cmd_q.m_size=0; 1481 m_etb_q.m_size=0; 1482 m_ftb_q.m_read = m_ftb_q.m_write =0; 1483 m_cmd_q.m_read = m_cmd_q.m_write =0; 1484 m_etb_q.m_read = m_etb_q.m_write =0; 1485 1486 #ifdef _ANDROID_ 1487 // Clear the strong reference 1488 DEBUG_PRINT_HIGH("Calling m_heap_ptr.clear()\n"); 1489 m_heap_ptr.clear(); 1490 #endif // _ANDROID_ 1491 DEBUG_PRINT_HIGH("Calling venc_close()\n"); 1492 handle->venc_close(); 1493 DEBUG_PRINT_HIGH("Deleting HANDLE[%p]\n", handle); 1494 delete (handle); 1495 DEBUG_PRINT_HIGH("OMX_Venc:Component Deinit\n"); 1496 return OMX_ErrorNone; 1497 } 1498 1499 1500 OMX_U32 omx_venc::dev_stop( void) 1501 { 1502 return handle->venc_stop(); 1503 } 1504 1505 1506 OMX_U32 omx_venc::dev_pause(void) 1507 { 1508 return handle->venc_pause(); 1509 } 1510 1511 OMX_U32 omx_venc::dev_start(void) 1512 { 1513 return handle->venc_start(); 1514 } 1515 1516 OMX_U32 omx_venc::dev_flush(unsigned port) 1517 { 1518 return handle->venc_flush(port); 1519 } 1520 OMX_U32 omx_venc::dev_resume(void) 1521 { 1522 return handle->venc_resume(); 1523 } 1524 1525 OMX_U32 omx_venc::dev_start_done(void) 1526 { 1527 return handle->venc_start_done(); 1528 } 1529 1530 OMX_U32 omx_venc::dev_stop_done(void) 1531 { 1532 return handle->venc_stop_done(); 1533 } 1534 1535 bool omx_venc::dev_use_buf(void *buf_addr,unsigned port,unsigned index) 1536 { 1537 return handle->venc_use_buf(buf_addr,port,index); 1538 } 1539 1540 bool omx_venc::dev_free_buf(void *buf_addr,unsigned port) 1541 { 1542 return handle->venc_free_buf(buf_addr,port); 1543 } 1544 1545 bool omx_venc::dev_empty_buf(void *buffer, void *pmem_data_buf,unsigned index,unsigned fd) 1546 { 1547 return handle->venc_empty_buf(buffer, pmem_data_buf,index,fd); 1548 } 1549 1550 bool omx_venc::dev_fill_buf(void *buffer, void *pmem_data_buf,unsigned index,unsigned fd) 1551 { 1552 return handle->venc_fill_buf(buffer, pmem_data_buf,index,fd); 1553 } 1554 1555 bool omx_venc::dev_get_seq_hdr(void *buffer, unsigned size, unsigned *hdrlen) 1556 { 1557 return handle->venc_get_seq_hdr(buffer, size, hdrlen); 1558 } 1559 1560 bool omx_venc::dev_loaded_start() 1561 { 1562 return handle->venc_loaded_start(); 1563 } 1564 1565 bool omx_venc::dev_loaded_stop() 1566 { 1567 return handle->venc_loaded_stop(); 1568 } 1569 1570 bool omx_venc::dev_loaded_start_done() 1571 { 1572 return handle->venc_loaded_start_done(); 1573 } 1574 1575 bool omx_venc::dev_loaded_stop_done() 1576 { 1577 return handle->venc_loaded_stop_done(); 1578 } 1579 1580 bool omx_venc::dev_get_buf_req(OMX_U32 *min_buff_count, 1581 OMX_U32 *actual_buff_count, 1582 OMX_U32 *buff_size, 1583 OMX_U32 port) 1584 { 1585 return handle->venc_get_buf_req(min_buff_count, 1586 actual_buff_count, 1587 buff_size, 1588 port); 1589 1590 } 1591 1592 bool omx_venc::dev_set_buf_req(OMX_U32 *min_buff_count, 1593 OMX_U32 *actual_buff_count, 1594 OMX_U32 *buff_size, 1595 OMX_U32 port) 1596 { 1597 return handle->venc_set_buf_req(min_buff_count, 1598 actual_buff_count, 1599 buff_size, 1600 port); 1601 1602 } 1603 1604 int omx_venc::async_message_process (void *context, void* message) 1605 { 1606 omx_video* omx = NULL; 1607 struct venc_msg *m_sVenc_msg = NULL; 1608 OMX_BUFFERHEADERTYPE* omxhdr = NULL; 1609 struct venc_buffer *temp_buff = NULL; 1610 1611 if(context == NULL || message == NULL) 1612 { 1613 DEBUG_PRINT_ERROR("\nERROR: omx_venc::async_message_process invalid i/p params"); 1614 return -1; 1615 } 1616 m_sVenc_msg = (struct venc_msg *)message; 1617 1618 omx = reinterpret_cast<omx_video*>(context); 1619 1620 if(m_sVenc_msg->statuscode != VEN_S_SUCCESS) 1621 { 1622 DEBUG_PRINT_ERROR("\nERROR: async_msg_process() - Error statuscode = %d\n", 1623 m_sVenc_msg->statuscode); 1624 omx->omx_report_error(); 1625 } 1626 1627 DEBUG_PRINT_LOW("\n omx_venc::async_message_process- msgcode = %d\n", 1628 m_sVenc_msg->msgcode); 1629 switch(m_sVenc_msg->msgcode) 1630 { 1631 1632 case VEN_MSG_START: 1633 omx->post_event (NULL,m_sVenc_msg->statuscode,\ 1634 OMX_COMPONENT_GENERATE_START_DONE); 1635 break; 1636 1637 case VEN_MSG_STOP: 1638 omx->post_event (NULL,m_sVenc_msg->statuscode,\ 1639 OMX_COMPONENT_GENERATE_STOP_DONE); 1640 break; 1641 1642 case VEN_MSG_RESUME: 1643 omx->post_event (NULL,m_sVenc_msg->statuscode,\ 1644 OMX_COMPONENT_GENERATE_RESUME_DONE); 1645 break; 1646 1647 case VEN_MSG_PAUSE: 1648 omx->post_event (NULL,m_sVenc_msg->statuscode,\ 1649 OMX_COMPONENT_GENERATE_PAUSE_DONE); 1650 1651 break; 1652 1653 case VEN_MSG_FLUSH_INPUT_DONE: 1654 1655 omx->post_event (NULL,m_sVenc_msg->statuscode,\ 1656 OMX_COMPONENT_GENERATE_EVENT_INPUT_FLUSH); 1657 break; 1658 case VEN_MSG_FLUSH_OUPUT_DONE: 1659 omx->post_event (NULL,m_sVenc_msg->statuscode,\ 1660 OMX_COMPONENT_GENERATE_EVENT_OUTPUT_FLUSH); 1661 break; 1662 case VEN_MSG_INPUT_BUFFER_DONE: 1663 omxhdr = (OMX_BUFFERHEADERTYPE* )\ 1664 m_sVenc_msg->buf.clientdata; 1665 1666 if(omxhdr == NULL || 1667 (((OMX_U32)(omxhdr - omx->m_inp_mem_ptr) > omx->m_sInPortDef.nBufferCountActual) && 1668 ((OMX_U32)(omxhdr - omx->meta_buffer_hdr) > omx->m_sInPortDef.nBufferCountActual))) 1669 { 1670 omxhdr = NULL; 1671 m_sVenc_msg->statuscode = VEN_S_EFAIL; 1672 } 1673 1674 #ifdef _ANDROID_ICS_ 1675 omx->omx_release_meta_buffer(omxhdr); 1676 #endif 1677 omx->post_event ((unsigned int)omxhdr,m_sVenc_msg->statuscode, 1678 OMX_COMPONENT_GENERATE_EBD); 1679 break; 1680 case VEN_MSG_OUTPUT_BUFFER_DONE: 1681 1682 omxhdr = (OMX_BUFFERHEADERTYPE*)m_sVenc_msg->buf.clientdata; 1683 1684 if( (omxhdr != NULL) && 1685 ((OMX_U32)(omxhdr - omx->m_out_mem_ptr) < omx->m_sOutPortDef.nBufferCountActual)) 1686 { 1687 if(m_sVenc_msg->buf.len <= omxhdr->nAllocLen) 1688 { 1689 omxhdr->nFilledLen = m_sVenc_msg->buf.len; 1690 omxhdr->nOffset = m_sVenc_msg->buf.offset; 1691 omxhdr->nTimeStamp = m_sVenc_msg->buf.timestamp; 1692 DEBUG_PRINT_LOW("\n o/p TS = %u", (OMX_U32)m_sVenc_msg->buf.timestamp); 1693 omxhdr->nFlags = m_sVenc_msg->buf.flags; 1694 1695 /*Use buffer case*/ 1696 if(omx->output_use_buffer && !omx->m_use_output_pmem) 1697 { 1698 DEBUG_PRINT_LOW("\n memcpy() for o/p Heap UseBuffer"); 1699 memcpy(omxhdr->pBuffer, 1700 (m_sVenc_msg->buf.ptrbuffer), 1701 m_sVenc_msg->buf.len); 1702 } 1703 } 1704 else 1705 { 1706 omxhdr->nFilledLen = 0; 1707 } 1708 1709 } 1710 else 1711 { 1712 omxhdr = NULL; 1713 m_sVenc_msg->statuscode = VEN_S_EFAIL; 1714 } 1715 1716 omx->post_event ((unsigned int)omxhdr,m_sVenc_msg->statuscode, 1717 OMX_COMPONENT_GENERATE_FBD); 1718 break; 1719 case VEN_MSG_NEED_OUTPUT_BUFFER: 1720 //TBD what action needs to be done here?? 1721 break; 1722 default: 1723 break; 1724 } 1725 return 0; 1726 } 1727 bool omx_venc::is_secure_session() 1728 { 1729 return secure_session; 1730 } 1731
