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