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