1
2/*
3 * Copyright (C) Texas Instruments - http://www.ti.com/
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 * Lesser General Public License for more details.
15 *
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
20 */
21/* =============================================================================
22*             Texas Instruments OMAP (TM) Platform Software
23*  (c) Copyright Texas Instruments, Incorporated.  All Rights Reserved.
24*
25*  Use of this software is controlled by the terms and conditions found
26*  in the license agreement under which this software has been supplied.
27* ============================================================================*/
28/**
29* @file OMX_Video_Decoder.c
30*
31* This file implements OMX Component for video decoder that
32* is fully compliant with the OMX specification 1.0
33*
34* @path  $(CSLPATH)\
35*
36* @rev  0.1
37*/
38/* ----------------------------------------------------------------------------
39*!
40*! Revision History
41*! ===================================
42*! 24-July-2005 mf:  Initial Version. Change required per OMAPSWxxxxxxxxx
43*! to provide _________________.
44*!
45* ============================================================================*/
46
47/* ------compilation control switches ----------------------------------------*/
48/*******************************************************************************
49*  INCLUDE FILES
50*******************************************************************************/
51/* ----- system and platform files -------------------------------------------*/
52#ifdef UNDER_CE
53#include <windows.h>
54#include <oaf_osal.h>
55#include <omx_core.h>
56#else
57#include <wchar.h>
58#include <unistd.h>
59#include <sys/time.h>
60#include <sys/types.h>
61#include <sys/ioctl.h>
62#include <sys/select.h>
63#include <errno.h>
64#include <pthread.h>
65#endif
66
67#include <string.h>
68#include <fcntl.h>
69#include <stdlib.h>
70#include <stdio.h>
71#include <dbapi.h>
72#include <OMX_Component.h>
73#include "OMX_VideoDecoder.h"
74#include "OMX_VideoDec_Utils.h"
75#include "OMX_VideoDec_DSP.h"
76#include "OMX_VideoDec_Thread.h"
77#include "OMX_VidDec_CustomCmd.h"
78
79/* For PPM fps measurements */
80static int mDebugFps = 0;
81
82#ifdef RESOURCE_MANAGER_ENABLED
83/*#ifndef UNDER_CE*/
84#include <ResourceManagerProxyAPI.h>
85/*#endif*/
86#endif
87
88/*******************************************************************************
89*  EXTERNAL REFERENCES NOTE : only use if not found in header file
90*******************************************************************************/
91/*--------data declarations --------------------------------------------------*/
92
93/*--------function prototypes ------------------------------------------------*/
94extern OMX_ERRORTYPE VIDDEC_Start_ComponentThread(OMX_HANDLETYPE pHandle);
95extern OMX_ERRORTYPE VIDDEC_Stop_ComponentThread(OMX_HANDLETYPE pComponent);
96/*extern OMX_ERRORTYPE VIDDEC_HandleCommandMarkBuffer(VIDDEC_COMPONENT_PRIVATE *pComponentPrivate, OMX_U32 nParam1, OMX_PTR pCmdData);
97extern OMX_ERRORTYPE VIDDEC_HandleCommandFlush(VIDDEC_COMPONENT_PRIVATE *pComponentPrivate, OMX_U32 nParam1, OMX_PTR pCmdData);*/
98extern OMX_ERRORTYPE VIDDEC_Load_Defaults (VIDDEC_COMPONENT_PRIVATE* pComponentPrivate, OMX_S32 nPassing);
99extern OMX_ERRORTYPE IncrementCount (OMX_U8 * pCounter, pthread_mutex_t *pMutex);
100extern OMX_ERRORTYPE DecrementCount (OMX_U8 * pCounter, pthread_mutex_t *pMutex);
101
102/*******************************************************************************
103*  PUBLIC DECLARATIONS Defined here, used elsewhere
104*******************************************************************************/
105/*--------data declarations --------------------------------------------------*/
106OMX_STRING cVideoDecodeName = "OMX.TI.Video.Decoder";
107
108VIDDEC_CUSTOM_PARAM sVideoDecCustomParams[] =                                {{VIDDEC_CUSTOMPARAM_PROCESSMODE, VideoDecodeCustomParamProcessMode},
109                                                                             {VIDDEC_CUSTOMPARAM_H264BITSTREAMFORMAT, VideoDecodeCustomParamH264BitStreamFormat},
110                                                                             {VIDDEC_CUSTOMPARAM_WMVPROFILE, VideoDecodeCustomParamWMVProfile},
111                                                                             {VIDDEC_CUSTOMPARAM_WMVFILETYPE, VideoDecodeCustomParamWMVFileType},
112                                                                             {VIDDEC_CUSTOMPARAM_PARSERENABLED, VideoDecodeCustomParamParserEnabled},
113                                                                             {VIDDEC_CUSTOMCONFIG_DEBUG, VideoDecodeCustomConfigDebug},
114#ifdef VIDDEC_SPARK_CODE
115                                                                             {VIDDEC_CUSTOMPARAM_ISNALBIGENDIAN, VideoDecodeCustomParamIsNALBigEndian},
116                                                                             {VIDDEC_CUSTOMPARAM_ISSPARKINPUT, VideoDecodeCustomParamIsSparkInput}};
117#else
118                                                                             {VIDDEC_CUSTOMPARAM_ISNALBIGENDIAN, VideoDecodeCustomParamIsNALBigEndian}};
119#endif
120/* H.263 Supported Levels & profiles */
121VIDEO_PROFILE_LEVEL_TYPE SupportedH263ProfileLevels[] = {
122  {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level10},
123  {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level20},
124  {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level30},
125  {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level40},
126  {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level45},
127  {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level50},
128  {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level60},
129  {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level70},
130  {-1, -1}};
131
132/* MPEG4 Supported Levels & profiles */
133VIDEO_PROFILE_LEVEL_TYPE SupportedMPEG4ProfileLevels[] ={
134  {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level0},
135  {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level0b},
136  {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level1},
137  {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level2},
138  {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level3},
139  {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level4},
140  {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level4a},
141  {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level5},
142  {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level0},
143  {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level0b},
144  {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level1},
145  {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level2},
146  {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level3},
147  {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level4},
148  {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level5},
149  {-1,-1}};
150
151/* AVC Supported Levels & profiles */
152VIDEO_PROFILE_LEVEL_TYPE SupportedAVCProfileLevels[] ={
153  {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel1},
154  {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel1b},
155  {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel11},
156  {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel12},
157  {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel13},
158  {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel2},
159  {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel21},
160  {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel22},
161  {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel3},
162  {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel31},
163  {-1,-1}};
164/*--------function prototypes ------------------------------------------------*/
165
166/*******************************************************************************
167*  PRIVATE DECLARATIONS Defined here, used only here
168*******************************************************************************/
169/*--------data declarations --------------------------------------------------*/
170/*SetConfig defines*/
171#define SET_CONFIG_MUTEX_BASE           0x0000FF00
172#define SET_CONFIG_ONMUTEX              0x0000FF01
173#define SET_CONFIG_OFFMUTEX             0x0000FF00
174
175/*--------macro definitions --------------------------------------------------*/
176
177/*-------function prototypes -------------------------------------------------*/
178static OMX_ERRORTYPE VIDDEC_SetCallbacks (OMX_HANDLETYPE hComp,
179                                          OMX_CALLBACKTYPE* pCallBacks,
180                                          OMX_PTR pAppData);
181
182static OMX_ERRORTYPE VIDDEC_GetComponentVersion (OMX_HANDLETYPE hComp,
183                                                 OMX_STRING pComponentName,
184                                                 OMX_VERSIONTYPE* pComponent,
185                                                 OMX_VERSIONTYPE* pSpecVersion,
186                                                 OMX_UUIDTYPE* pComponentUUID);
187
188static OMX_ERRORTYPE VIDDEC_SendCommand (OMX_HANDLETYPE hComponent,
189                                         OMX_COMMANDTYPE Cmd,
190                                         OMX_U32 nParam1,
191                                         OMX_PTR pCmdData);
192
193static OMX_ERRORTYPE VIDDEC_GetParameter (OMX_HANDLETYPE hComponent,
194                                          OMX_INDEXTYPE nParamIndex,
195                                          OMX_PTR ComponentParamStruct);
196
197static OMX_ERRORTYPE VIDDEC_SetParameter (OMX_HANDLETYPE hComp,
198                                          OMX_INDEXTYPE nParamIndex,
199                                          OMX_PTR ComponentParamStruct);
200
201static OMX_ERRORTYPE VIDDEC_GetConfig (OMX_HANDLETYPE hComp,
202                                       OMX_INDEXTYPE nConfigIndex,
203                                       OMX_PTR pComponentConfigStructure);
204
205static OMX_ERRORTYPE VIDDEC_SetConfig (OMX_HANDLETYPE hComp,
206                                       OMX_INDEXTYPE nConfigIndex,
207                                       OMX_PTR pComponentConfigStructure);
208
209static OMX_ERRORTYPE VIDDEC_EmptyThisBuffer (OMX_HANDLETYPE hComp,
210                                             OMX_BUFFERHEADERTYPE* pBuffer);
211
212static OMX_ERRORTYPE VIDDEC_FillThisBuffer (OMX_HANDLETYPE hComp,
213                                            OMX_BUFFERHEADERTYPE* pBuffer);
214
215static OMX_ERRORTYPE VIDDEC_GetState (OMX_HANDLETYPE hComp, OMX_STATETYPE* pState);
216
217static OMX_ERRORTYPE VIDDEC_ComponentTunnelRequest (OMX_IN OMX_HANDLETYPE hComp,
218                                                    OMX_IN OMX_U32 nPort,
219                                                    OMX_IN OMX_HANDLETYPE hTunneledComp,
220                                                    OMX_IN OMX_U32 nTunneledPort,
221                                                    OMX_INOUT OMX_TUNNELSETUPTYPE* pTunnelSetup);
222
223static OMX_ERRORTYPE VIDDEC_UseBuffer (OMX_IN OMX_HANDLETYPE hComponent,
224                                OMX_INOUT OMX_BUFFERHEADERTYPE** ppBufferHdr,
225                                OMX_IN OMX_U32 nPortIndex,
226                                OMX_IN OMX_PTR pAppPrivate,
227                                OMX_IN OMX_U32 nSizeBytes,
228                                OMX_IN OMX_U8* pBuffer);
229
230static OMX_ERRORTYPE VIDDEC_AllocateBuffer (OMX_IN OMX_HANDLETYPE hComponent,
231                                     OMX_INOUT OMX_BUFFERHEADERTYPE** pBuffer,
232                                     OMX_IN OMX_U32 nPortIndex,
233                                     OMX_IN OMX_PTR pAppPrivate,
234                                     OMX_IN OMX_U32 nSizeBytes);
235
236static OMX_ERRORTYPE VIDDEC_FreeBuffer (OMX_IN OMX_HANDLETYPE hComponent,
237                                        OMX_IN OMX_U32 nPortIndex,
238                                        OMX_IN OMX_BUFFERHEADERTYPE* pBuffer);
239
240static OMX_ERRORTYPE VIDDEC_ComponentDeInit (OMX_HANDLETYPE hComponent);
241
242static OMX_ERRORTYPE VIDDEC_VerifyTunnelConnection (VIDDEC_PORT_TYPE *pPort,
243                                                    OMX_HANDLETYPE hTunneledComp,
244                                                    OMX_PARAM_PORTDEFINITIONTYPE* pPortDef);
245
246static OMX_ERRORTYPE VIDDEC_Allocate_DSPResources (OMX_IN VIDDEC_COMPONENT_PRIVATE *pComponentPrivate,
247                                                   OMX_IN OMX_U32 nPortIndex);
248
249static OMX_ERRORTYPE VIDDEC_GetExtensionIndex(OMX_IN OMX_HANDLETYPE hComponent,
250                                              OMX_IN OMX_STRING cParameterName,
251                                              OMX_OUT OMX_INDEXTYPE* pIndexType);
252
253#ifdef KHRONOS_1_1
254static OMX_ERRORTYPE ComponentRoleEnum(
255                OMX_IN OMX_HANDLETYPE hComponent,
256                OMX_OUT OMX_U8 *cRole,
257                OMX_IN OMX_U32 nIndex);
258#endif
259
260/*----------------------------------------------------------------------------*/
261/**
262  * OMX_ComponentInit() Set the all the function pointers of component
263  *
264  * This method will update the component function pointer to the handle
265  *
266  * @param hComp         handle for this instance of the component
267  *
268  * @retval OMX_NoError              Success, ready to roll
269  *         OMX_ErrorInsufficientResources If the malloc fails
270  **/
271/*----------------------------------------------------------------------------*/
272
273OMX_ERRORTYPE OMX_ComponentInit (OMX_HANDLETYPE hComponent)
274{
275    OMX_ERRORTYPE eError = OMX_ErrorNone;
276    OMX_COMPONENTTYPE *pHandle = NULL;
277    VIDDEC_COMPONENT_PRIVATE *pComponentPrivate = NULL;
278    OMX_U32 nMemUsage = 0;
279#ifdef __ENV_CHANGE__
280    char EnvChangeValue[VIDDEC_MAX_NAMESIZE];
281    char* EnvChangeValueu = NULL;
282#endif
283#ifdef ANDROID
284    /* print to logcat to verify that we are running a TI OMX codec*/
285    ALOGI("TI Video Decoder \n");
286#endif
287
288    OMX_CONF_CHECK_CMD(hComponent, OMX_TRUE, OMX_TRUE);
289    pHandle = (OMX_COMPONENTTYPE *)hComponent;
290
291    OMX_MALLOC_STRUCT(pHandle->pComponentPrivate, VIDDEC_COMPONENT_PRIVATE, nMemUsage);
292    if (pHandle->pComponentPrivate == NULL) {
293        eError = OMX_ErrorInsufficientResources;
294        goto EXIT;
295    }
296    pComponentPrivate = (VIDDEC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate;
297    pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0] += nMemUsage;
298
299#ifdef __PERF_INSTRUMENTATION__
300    pComponentPrivate->pPERF = PERF_Create(PERF_FOURS("VD  "),
301                                           PERF_ModuleLLMM | PERF_ModuleVideoDecode);
302#endif
303    OMX_DBG_INIT(pComponentPrivate->dbg, "OMX_DBG_VIDDEC");
304    ((VIDDEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate)->pHandle = pHandle;
305
306    pHandle->SetCallbacks                   = VIDDEC_SetCallbacks;
307    pHandle->GetComponentVersion            = VIDDEC_GetComponentVersion;
308    pHandle->SendCommand                    = VIDDEC_SendCommand;
309    pHandle->GetParameter                   = VIDDEC_GetParameter;
310    pHandle->SetParameter                   = VIDDEC_SetParameter;
311    pHandle->GetConfig                      = VIDDEC_GetConfig;
312    pHandle->SetConfig                      = VIDDEC_SetConfig;
313    pHandle->GetState                       = VIDDEC_GetState;
314    pHandle->ComponentTunnelRequest         = VIDDEC_ComponentTunnelRequest;
315    pHandle->UseBuffer                      = VIDDEC_UseBuffer;
316    pHandle->AllocateBuffer                 = VIDDEC_AllocateBuffer;
317    pHandle->FreeBuffer                     = VIDDEC_FreeBuffer;
318    pHandle->EmptyThisBuffer                = VIDDEC_EmptyThisBuffer;
319    pHandle->FillThisBuffer                 = VIDDEC_FillThisBuffer;
320    pHandle->ComponentDeInit                = VIDDEC_ComponentDeInit;
321    pHandle->GetExtensionIndex              = VIDDEC_GetExtensionIndex;
322#ifdef KHRONOS_1_1
323    pHandle->ComponentRoleEnum              = ComponentRoleEnum;
324#endif
325
326    /*mutex protection*/
327    if (pthread_mutex_init(&(pComponentPrivate->mutexInputBFromApp), NULL) != 0) {
328        eError = OMX_ErrorUndefined;
329        return eError;
330    }
331    if (pthread_mutex_init(&(pComponentPrivate->mutexOutputBFromApp), NULL) != 0) {
332        eError = OMX_ErrorUndefined;
333        return eError;
334    }
335    if (pthread_mutex_init(&(pComponentPrivate->mutexInputBFromDSP), NULL) != 0) {
336        eError = OMX_ErrorUndefined;
337        return eError;
338    }
339    if (pthread_mutex_init(&(pComponentPrivate->mutexOutputBFromDSP), NULL) != 0) {
340        eError = OMX_ErrorUndefined;
341        return eError;
342    }
343    VIDDEC_PTHREAD_MUTEX_INIT(pComponentPrivate->outputFlushCompletionMutex);
344    pComponentPrivate->bIsOutputFlushPending = OMX_FALSE;
345    VIDDEC_PTHREAD_MUTEX_INIT(pComponentPrivate->inputFlushCompletionMutex);
346    pComponentPrivate->bIsInputFlushPending = OMX_FALSE;
347    OMX_MALLOC_STRUCT(pComponentPrivate->pPortParamType, OMX_PORT_PARAM_TYPE,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0]);
348#ifdef __STD_COMPONENT__
349    OMX_MALLOC_STRUCT(pComponentPrivate->pPortParamTypeAudio, OMX_PORT_PARAM_TYPE,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0]);
350    OMX_MALLOC_STRUCT(pComponentPrivate->pPortParamTypeImage, OMX_PORT_PARAM_TYPE,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0]);
351    OMX_MALLOC_STRUCT(pComponentPrivate->pPortParamTypeOthers, OMX_PORT_PARAM_TYPE,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0]);
352#endif
353    OMX_MALLOC_STRUCT(pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT], VIDDEC_PORT_TYPE,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0]);
354    OMX_MALLOC_STRUCT(pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT], VIDDEC_PORT_TYPE,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0]);
355    OMX_MALLOC_STRUCT(pComponentPrivate->pInPortDef, OMX_PARAM_PORTDEFINITIONTYPE,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0]);
356    OMX_MALLOC_STRUCT(pComponentPrivate->pOutPortDef, OMX_PARAM_PORTDEFINITIONTYPE,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0]);
357    OMX_MALLOC_STRUCT(pComponentPrivate->pInPortFormat, OMX_VIDEO_PARAM_PORTFORMATTYPE,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0]);
358    OMX_MALLOC_STRUCT(pComponentPrivate->pOutPortFormat, OMX_VIDEO_PARAM_PORTFORMATTYPE,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0]);
359    OMX_MALLOC_STRUCT(pComponentPrivate->pPriorityMgmt, OMX_PRIORITYMGMTTYPE,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0]);
360    OMX_MALLOC_STRUCT(pComponentPrivate->pInBufSupplier, OMX_PARAM_BUFFERSUPPLIERTYPE,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0]);
361    OMX_MALLOC_STRUCT(pComponentPrivate->pOutBufSupplier, OMX_PARAM_BUFFERSUPPLIERTYPE,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0]);
362    OMX_MALLOC_STRUCT(pComponentPrivate->pMpeg4, OMX_VIDEO_PARAM_MPEG4TYPE,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0]);
363    OMX_MALLOC_STRUCT(pComponentPrivate->pMpeg2, OMX_VIDEO_PARAM_MPEG2TYPE,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0]);
364    OMX_MALLOC_STRUCT(pComponentPrivate->pH264, OMX_VIDEO_PARAM_AVCTYPE,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0]);
365    OMX_MALLOC_STRUCT(pComponentPrivate->pH263, OMX_VIDEO_PARAM_H263TYPE,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0]);
366    OMX_MALLOC_STRUCT(pComponentPrivate->pWMV, OMX_VIDEO_PARAM_WMVTYPE,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0]);
367    OMX_MALLOC_STRUCT(pComponentPrivate->pDeblockingParamType, OMX_PARAM_DEBLOCKINGTYPE, pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0]);
368    OMX_MALLOC_STRUCT(pComponentPrivate->pPVCapabilityFlags, PV_OMXComponentCapabilityFlagsType, pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0]);
369
370    OMX_MALLOC_STRUCT_SIZED(pComponentPrivate->cComponentName, char, VIDDEC_MAX_NAMESIZE + 1,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0]);
371    if (pComponentPrivate->cComponentName == NULL) {
372        OMX_TRACE4(pComponentPrivate->dbg, "Error: Malloc failed\n");
373        eError = OMX_ErrorInsufficientResources;
374        goto EXIT;
375    }
376    strncpy(pComponentPrivate->cComponentName, cVideoDecodeName, VIDDEC_MAX_NAMESIZE);
377    OMX_CONF_INIT_STRUCT( &pComponentPrivate->componentRole, OMX_PARAM_COMPONENTROLETYPE, pComponentPrivate->dbg);
378    VIDDEC_Load_Defaults( pComponentPrivate, VIDDEC_INIT_ALL);
379#ifdef __ENV_CHANGE__
380#ifdef KHRONOS_1_1
381    EnvChangeValueu = getenv(ENV_CHANGE_NAME_VALUE);
382    if(EnvChangeValueu != NULL) {
383        strcpy( EnvChangeValue, EnvChangeValueu);
384        if( strcmp( EnvChangeValueu, ENV_CHANGE_SET_H263) == 0) {
385            eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_H263);
386            if( pComponentPrivate->pOutPortFormat->eColorFormat != VIDDEC_COLORFORMAT420) {
387                eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_PLANAR420);
388            }
389            strcpy((char*)pComponentPrivate->componentRole.cRole, VIDDEC_COMPONENTROLES_H263);
390        }
391        else if( strcmp( EnvChangeValueu, ENV_CHANGE_SET_H264) == 0 ||  strcmp( EnvChangeValueu, ENV_CHANGE_SET_AVC) == 0) {
392            eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_H264);
393            if( pComponentPrivate->pOutPortFormat->eColorFormat != VIDDEC_COLORFORMAT420) {
394                eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_PLANAR420);
395            }
396            strcpy((char*)pComponentPrivate->componentRole.cRole, VIDDEC_COMPONENTROLES_H264);
397        }
398        else if( strcmp( EnvChangeValueu, ENV_CHANGE_SET_MPEG2) == 0) {
399            eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_MPEG2);
400            if( pComponentPrivate->pOutPortFormat->eColorFormat != VIDDEC_COLORFORMAT420) {
401                eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_PLANAR420);
402            }
403            strcpy((char*)pComponentPrivate->componentRole.cRole, VIDDEC_COMPONENTROLES_MPEG2);
404        }
405        else if( strcmp( EnvChangeValueu, ENV_CHANGE_SET_WMV9) == 0) {
406            eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_WMV9);
407            if( pComponentPrivate->pOutPortFormat->eColorFormat != VIDDEC_COLORFORMAT420) {
408                eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_PLANAR420);
409            }
410            strcpy((char*)pComponentPrivate->componentRole.cRole, VIDDEC_COMPONENTROLES_MPEG4);
411        }
412#ifdef VIDDEC_SPARK_CODE
413        else if( strcmp( EnvChangeValueu, ENV_CHANGE_SET_SPARK) == 0) {
414            eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_SPARK);
415            if( pComponentPrivate->pOutPortFormat->eColorFormat != VIDDEC_COLORFORMAT420) {
416                eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_PLANAR420);
417            }
418            strcpy((char*)pComponentPrivate->componentRole.cRole, VIDDEC_COMPONENTROLES_H263);
419        }
420#endif
421        else {
422            eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_MPEG4);
423            if( pComponentPrivate->pOutPortFormat->eColorFormat != VIDDEC_COLORFORMAT420) {
424                eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_PLANAR420);
425            }
426            strcpy((char*)pComponentPrivate->componentRole.cRole, VIDDEC_COMPONENTROLES_WMV9);
427        }
428    }
429    else
430    {
431        if( pComponentPrivate->pOutPortFormat->eColorFormat != VIDDEC_COLORFORMAT420) {
432            eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_PLANAR420);
433        }
434        strcpy((char*)pComponentPrivate->componentRole.cRole, VIDDEC_COMPONENTROLES_MPEG4);
435    }
436#else
437    EnvChangeValueu = getenv(ENV_CHANGE_NAME_VALUE);
438    if(EnvChangeValueu != NULL) {
439        strcpy( EnvChangeValue, EnvChangeValueu);
440        if( strcmp( EnvChangeValueu, ENV_CHANGE_SET_H263) == 0) {
441            VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_H263);
442        }
443        else if( strcmp( EnvChangeValueu, ENV_CHANGE_SET_H264) == 0) {
444            VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_H264);
445        }
446        else if( strcmp( EnvChangeValueu, ENV_CHANGE_SET_MPEG2) == 0) {
447            VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_MPEG2);
448        }
449        else if( strcmp( EnvChangeValueu, ENV_CHANGE_SET_WMV9) == 0) {
450            VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_WMV9);
451        }
452#ifdef VIDDEC_SPARK_CODE
453        else if( strcmp( EnvChangeValueu, ENV_CHANGE_SET_SPARK) == 0) {
454            VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_SPARK);
455        }
456#endif
457        else {
458            VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_MPEG4);
459        }
460        if( pComponentPrivate->pOutPortFormat->eColorFormat != VIDDEC_COLORFORMAT420) {
461            eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_PLANAR420);
462        }
463    }
464#endif
465#endif
466
467#ifdef RESOURCE_MANAGER_ENABLED
468/*#ifndef UNDER_CE*/
469    /* load the ResourceManagerProxy thread */
470    eError = RMProxy_NewInitalizeEx(OMX_COMPONENTTYPE_VIDEO);
471    if (eError != OMX_ErrorNone) {
472        pComponentPrivate->eRMProxyState = VidDec_RMPROXY_State_Unload;
473        OMX_PRMGR4(pComponentPrivate->dbg, "Error returned from loading ResourceManagerProxy thread\n");
474        goto EXIT;
475    }
476    else{
477        pComponentPrivate->eRMProxyState = VidDec_RMPROXY_State_Load;
478    }
479/*#endif*/
480#endif
481
482    /* Start the component thread */
483    eError = VIDDEC_Start_ComponentThread(pHandle);
484    if (eError != OMX_ErrorNone) {
485        OMX_ERROR4(pComponentPrivate->dbg, "Error returned from the Component\n");
486        goto EXIT;
487    }
488
489EXIT:
490    return eError;
491}
492
493/*----------------------------------------------------------------------------*/
494/**
495  *  VIDDEC_SetCallbacks() Sets application callbacks to the component
496  *
497  * This method will update application callbacks
498  * the application.
499  *
500  * @param pComp         handle for this instance of the component
501  * @param pCallBacks    application callbacks
502  * @param ptr           pointer to the appdata structure
503  *
504  * @retval OMX_NoError              Success, ready to roll
505  *         OMX_Error_BadParameter   The input parameter pointer is null
506  **/
507/*----------------------------------------------------------------------------*/
508
509static OMX_ERRORTYPE VIDDEC_SetCallbacks (OMX_HANDLETYPE pComponent,
510                                          OMX_CALLBACKTYPE* pCallBacks,
511                                          OMX_PTR pAppData)
512{
513    OMX_ERRORTYPE eError = OMX_ErrorNone;
514    OMX_COMPONENTTYPE *pHandle = NULL;
515    VIDDEC_COMPONENT_PRIVATE *pComponentPrivate = NULL;
516
517    OMX_CONF_CHECK_CMD(pComponent, pCallBacks, OMX_TRUE);
518
519    pHandle = (OMX_COMPONENTTYPE*)pComponent;
520    pComponentPrivate = (VIDDEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
521
522    /* Copy the callbacks of the application to the component private  */
523    memcpy (&(pComponentPrivate->cbInfo), pCallBacks, sizeof(OMX_CALLBACKTYPE));
524
525    /* copy the application private data to component memory */
526    pHandle->pApplicationPrivate = pAppData;
527
528    pComponentPrivate->eState = OMX_StateLoaded;
529
530EXIT:
531    return eError;
532}
533
534/*----------------------------------------------------------------------------*/
535/**
536  *  VIDDEC_GetComponentVersion() Sets application callbacks to the component
537  *
538  * This method will update application callbacks
539  * the application.
540  *
541  * @param pComp         handle for this instance of the component
542  * @param pCallBacks    application callbacks
543  * @param ptr
544  *
545  * @retval OMX_NoError              Success, ready to roll
546  *         OMX_Error_BadParameter   The input parameter pointer is null
547  **/
548/*----------------------------------------------------------------------------*/
549
550static OMX_ERRORTYPE VIDDEC_GetComponentVersion (OMX_HANDLETYPE hComp,
551                                                 OMX_STRING pComponentName,
552                                                 OMX_VERSIONTYPE* pComponentVersion,
553                                                 OMX_VERSIONTYPE* pSpecVersion,
554                                                 OMX_UUIDTYPE* pComponentUUID)
555{
556    OMX_ERRORTYPE eError = OMX_ErrorNone;
557    OMX_COMPONENTTYPE* pHandle = NULL;
558    VIDDEC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
559
560    if (!hComp || !pComponentName || !pComponentVersion || !pSpecVersion) {
561        eError = OMX_ErrorBadParameter;
562        goto EXIT;
563    }
564    pHandle = (OMX_COMPONENTTYPE*)hComp;
565    pComponentPrivate = (VIDDEC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate;
566
567    strcpy(pComponentName, pComponentPrivate->cComponentName);
568    memcpy(pComponentVersion, &(pComponentPrivate->pComponentVersion.s), sizeof(pComponentPrivate->pComponentVersion.s));
569    memcpy(pSpecVersion, &(pComponentPrivate->pSpecVersion.s), sizeof(pComponentPrivate->pSpecVersion.s));
570
571    if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
572        memcpy(pComponentUUID, (OMX_UUIDTYPE *)&STRING_H264VDSOCKET_TI_UUID, STRING_UUID_LENGHT);
573    }
574    else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV) {
575        memcpy(pComponentUUID, (OMX_UUIDTYPE *)&STRING_WMVDSOCKET_TI_UUID, STRING_UUID_LENGHT);
576    }
577    else if ((pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4) ||
578             (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263)) {
579        memcpy(pComponentUUID, (OMX_UUIDTYPE *)&STRING_MP4DSOCKET_TI_UUID, STRING_UUID_LENGHT);
580    }
581    else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG2) {
582        memcpy(pComponentUUID, (OMX_UUIDTYPE *)&STRING_MP2DSOCKET_TI_UUID, STRING_UUID_LENGHT);
583    }
584#ifdef VIDDEC_SPARK_CODE
585    else if (VIDDEC_SPARKCHECK) {
586            memcpy(pComponentUUID, (OMX_UUIDTYPE *)&STRING_SPARKDSOCKET_TI_UUID, STRING_UUID_LENGHT);
587    }
588#endif
589    else {
590        memcpy(pComponentUUID, (OMX_UUIDTYPE *)&STRING_MP4DSOCKET_TI_UUID, STRING_UUID_LENGHT);
591    }
592EXIT:
593    return eError;
594}
595
596/*----------------------------------------------------------------------------*/
597/**
598  *  VIDDEC_SendCommand() Sets application callbacks to the component
599  *
600  * This method will update application callbacks
601  * the application.
602  *
603  * @param pComp         handle for this instance of the component
604  * @param pCallBacks    application callbacks
605  * @param ptr
606  *
607  * @retval OMX_NoError              Success, ready to roll
608  *         OMX_Error_BadParameter   The input parameter pointer is null
609  **/
610/*----------------------------------------------------------------------------*/
611static OMX_ERRORTYPE VIDDEC_SendCommand (OMX_HANDLETYPE hComponent,
612                                         OMX_COMMANDTYPE Cmd,
613                                         OMX_U32 nParam1,
614                                         OMX_PTR pCmdData)
615{
616    OMX_ERRORTYPE eError = OMX_ErrorNone;
617    OMX_S32 nRet;
618    OMX_COMPONENTTYPE* pHandle = NULL;
619    VIDDEC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
620    OMX_CONF_CHECK_CMD(hComponent, OMX_TRUE, OMX_TRUE);
621
622    pHandle = (OMX_COMPONENTTYPE*)hComponent;
623    pComponentPrivate = (VIDDEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
624
625    if (pComponentPrivate->eState == OMX_StateInvalid) {
626        eError = OMX_ErrorInvalidState;
627        goto EXIT;
628    }
629
630#ifdef __PERF_INSTRUMENTATION__
631    PERF_SendingCommand(pComponentPrivate->pPERF,
632                        Cmd, (Cmd == OMX_CommandMarkBuffer) ? (OMX_U32) pCmdData : nParam1,
633                        PERF_ModuleComponent);
634#endif
635
636    switch (Cmd) {
637        case OMX_CommandStateSet:
638            ALOGD("VIDDEC_SendCommand: Received request from omx client to change state to %d", nParam1);
639            /* Add a pending transition */
640            if(AddStateTransition(pComponentPrivate) != OMX_ErrorNone) {
641                return OMX_ErrorUndefined;
642            }
643            pComponentPrivate->eIdleToLoad = nParam1;
644            pComponentPrivate->eExecuteToIdle = nParam1;
645            nRet = write(pComponentPrivate->cmdPipe[VIDDEC_PIPE_WRITE], &Cmd, sizeof(Cmd));
646            if (nRet == -1) {
647                if(RemoveStateTransition(pComponentPrivate, OMX_FALSE) != OMX_ErrorNone) {
648                   return OMX_ErrorUndefined;
649                }
650                return OMX_ErrorUndefined;
651            }
652            nRet = write(pComponentPrivate->cmdDataPipe[VIDDEC_PIPE_WRITE], &nParam1, sizeof(nParam1));
653            if (nRet == -1) {
654                if(RemoveStateTransition(pComponentPrivate, OMX_FALSE) != OMX_ErrorNone) {
655                   return OMX_ErrorUndefined;
656                }
657                return OMX_ErrorUndefined;
658            }
659            break;
660        case OMX_CommandPortDisable:
661            if (nParam1 == VIDDEC_INPUT_PORT) {
662                pComponentPrivate->pInPortDef->bEnabled = OMX_FALSE;
663                OMX_PRBUFFER2(pComponentPrivate->dbg, "Disabling VIDDEC_INPUT_PORT 0x%x\n",pComponentPrivate->pInPortDef->bEnabled);
664                VIDDEC_HandleCommandFlush(pComponentPrivate, 0, OMX_FALSE);
665            }
666            else if (nParam1 == VIDDEC_OUTPUT_PORT) {
667                pComponentPrivate->pOutPortDef->bEnabled = OMX_FALSE;
668                OMX_PRBUFFER2(pComponentPrivate->dbg, "Disabling VIDDEC_OUTPUT_PORT 0x%x\n",pComponentPrivate->pOutPortDef->bEnabled);
669                VIDDEC_HandleCommandFlush(pComponentPrivate, 1, OMX_FALSE);
670            }
671            else if (nParam1 == OMX_ALL) {
672                pComponentPrivate->pInPortDef->bEnabled = OMX_FALSE;
673                pComponentPrivate->pOutPortDef->bEnabled = OMX_FALSE;
674                OMX_PRBUFFER2(pComponentPrivate->dbg, "Disabling OMX_ALL IN 0x%x OUT 0x%x\n",pComponentPrivate->pInPortDef->bEnabled,
675                    pComponentPrivate->pOutPortDef->bEnabled);
676                VIDDEC_HandleCommandFlush(pComponentPrivate, -1, OMX_FALSE);
677            }
678            else {
679                eError = OMX_ErrorBadParameter;
680                goto EXIT;
681            }
682            nRet = write(pComponentPrivate->cmdPipe[VIDDEC_PIPE_WRITE], &Cmd, sizeof(Cmd));
683            if (nRet == -1) {
684                eError = OMX_ErrorUndefined;
685                goto EXIT;
686            }
687            nRet = write(pComponentPrivate->cmdDataPipe[VIDDEC_PIPE_WRITE], &nParam1, sizeof(nParam1));
688            if (nRet == -1) {
689                eError = OMX_ErrorUndefined;
690                goto EXIT;
691            }
692#ifdef ANDROID
693            /*Workaround version to handle pv app */
694            /*After ports is been flush*/
695
696            if (nParam1 == VIDDEC_INPUT_PORT &&
697                    pComponentPrivate->bDynamicConfigurationInProgress == OMX_TRUE &&
698                    pComponentPrivate->bInPortSettingsChanged == OMX_TRUE) {
699                VIDDEC_PTHREAD_MUTEX_SIGNAL(pComponentPrivate->sDynConfigMutex);
700            }
701#endif
702            break;
703        case OMX_CommandPortEnable:
704            if (nParam1 == VIDDEC_INPUT_PORT) {
705                pComponentPrivate->pInPortDef->bEnabled = OMX_TRUE;
706                OMX_PRBUFFER2(pComponentPrivate->dbg, "Enabling VIDDEC_INPUT_PORT 0x%x\n",pComponentPrivate->pInPortDef->bEnabled);
707            }
708            else if (nParam1 == VIDDEC_OUTPUT_PORT) {
709                pComponentPrivate->pOutPortDef->bEnabled = OMX_TRUE;
710                OMX_PRBUFFER2(pComponentPrivate->dbg, "Enabling VIDDEC_OUTPUT_PORT 0x%x\n",pComponentPrivate->pOutPortDef->bEnabled);
711            }
712            else if (nParam1 == OMX_ALL) {
713                pComponentPrivate->pInPortDef->bEnabled = OMX_TRUE;
714                pComponentPrivate->pOutPortDef->bEnabled = OMX_TRUE;
715                OMX_PRBUFFER2(pComponentPrivate->dbg, "Enabling VIDDEC_INPUT_PORT 0x%x\n",pComponentPrivate->pInPortDef->bEnabled);
716            }
717            nRet = write(pComponentPrivate->cmdPipe[VIDDEC_PIPE_WRITE], &Cmd, sizeof(Cmd));
718            if (nRet == -1) {
719                eError = OMX_ErrorUndefined;
720                goto EXIT;
721            }
722            nRet = write(pComponentPrivate->cmdDataPipe[VIDDEC_PIPE_WRITE], &nParam1, sizeof(nParam1));
723            if (nRet == -1) {
724                eError = OMX_ErrorUndefined;
725                goto EXIT;
726            }
727            break;
728        case OMX_CommandFlush:
729            if ( nParam1 > 1 && nParam1 != -1 ) {
730                eError = OMX_ErrorBadPortIndex;
731                goto EXIT;
732            }
733            nRet = write(pComponentPrivate->cmdPipe[VIDDEC_PIPE_WRITE], &Cmd, sizeof(Cmd));
734            if (nRet == -1) {
735                eError = OMX_ErrorUndefined;
736                goto EXIT;
737            }
738            nRet = write(pComponentPrivate->cmdDataPipe[VIDDEC_PIPE_WRITE], &nParam1, sizeof(nParam1));
739            if (nRet == -1) {
740                eError = OMX_ErrorUndefined;
741                goto EXIT;
742            }
743            break;
744        case OMX_CommandMarkBuffer:
745            if ( nParam1 > VIDDEC_OUTPUT_PORT ){
746                eError = OMX_ErrorBadPortIndex;
747                goto EXIT;
748            }
749            nRet = write(pComponentPrivate->cmdPipe[VIDDEC_PIPE_WRITE], &Cmd, sizeof(Cmd));
750            if (nRet == -1) {
751                eError = OMX_ErrorUndefined;
752                goto EXIT;
753            }
754            nRet = write(pComponentPrivate->cmdDataPipe[VIDDEC_PIPE_WRITE], &nParam1, sizeof(nParam1));
755            if (nRet == -1) {
756                eError = OMX_ErrorUndefined;
757                goto EXIT;
758            }
759            nRet = write(pComponentPrivate->cmdDataPipe[VIDDEC_PIPE_WRITE], &pCmdData, sizeof(pCmdData));
760            if (nRet == -1) {
761                eError = OMX_ErrorUndefined;
762                goto EXIT;
763            }
764            break;
765        case OMX_CommandMax:
766            break;
767        default:
768            eError = OMX_ErrorUndefined;
769    }
770
771EXIT:
772    return eError;
773}
774
775/*----------------------------------------------------------------------------*/
776/**
777  *  VIDDEC_GetParameter() Sets application callbacks to the component
778  *
779  * This method will update application callbacks
780  * the application.
781  *
782  * @param pComp         handle for this instance of the component
783  * @param pCallBacks    application callbacks
784  * @param ptr
785  *
786  * @retval OMX_NoError              Success, ready to roll
787  *         OMX_Error_BadParameter   The input parameter pointer is null
788  **/
789/*----------------------------------------------------------------------------*/
790
791static OMX_ERRORTYPE VIDDEC_GetParameter (OMX_IN OMX_HANDLETYPE hComponent,
792                                          OMX_IN  OMX_INDEXTYPE nParamIndex,
793                                          OMX_INOUT OMX_PTR ComponentParameterStructure)
794{
795    OMX_COMPONENTTYPE* pComp = NULL;
796    VIDDEC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
797    OMX_ERRORTYPE eError = OMX_ErrorNone;
798#ifdef KHRONOS_1_1
799    OMX_PARAM_COMPONENTROLETYPE *pRole = NULL;
800#endif
801    OMX_CONF_CHECK_CMD(hComponent, ComponentParameterStructure, OMX_TRUE);
802
803    pComp = (OMX_COMPONENTTYPE*)hComponent;
804    pComponentPrivate = (VIDDEC_COMPONENT_PRIVATE*)pComp->pComponentPrivate;
805
806    if (pComponentPrivate->eState == OMX_StateInvalid) {
807        OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorIncorrectStateOperation);
808    }
809
810    switch (nParamIndex) {
811        case OMX_IndexConfigVideoMBErrorReporting: /**< reference: OMX_CONFIG_MBERRORREPORTINGTYPE */
812        {
813            if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 ||
814                pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263 ||
815                pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
816                OMX_CONFIG_MBERRORREPORTINGTYPE* pMBErrorReportTo = ComponentParameterStructure;
817                /*OMX_CONF_CHK_VERSION( pMBErrorReportTo, OMX_CONFIG_MBERRORREPORTINGTYPE, eError, pComponentPrivate->dbg);*/
818                pMBErrorReportTo->bEnabled = pComponentPrivate->eMBErrorReport.bEnabled;
819            }
820            else {
821                eError = OMX_ErrorUnsupportedIndex;
822            }
823            break;
824        }
825        case OMX_IndexParamVideoInit:
826            memcpy(ComponentParameterStructure, pComponentPrivate->pPortParamType, sizeof(OMX_PORT_PARAM_TYPE));
827            break;
828#ifdef __STD_COMPONENT__
829        case OMX_IndexParamAudioInit:
830            memcpy(ComponentParameterStructure, pComponentPrivate->pPortParamTypeAudio, sizeof(OMX_PORT_PARAM_TYPE));
831            break;
832        case OMX_IndexParamImageInit:
833            memcpy(ComponentParameterStructure, pComponentPrivate->pPortParamTypeImage, sizeof(OMX_PORT_PARAM_TYPE));
834            break;
835        case OMX_IndexParamOtherInit:
836            memcpy(ComponentParameterStructure, pComponentPrivate->pPortParamTypeOthers, sizeof(OMX_PORT_PARAM_TYPE));
837            break;
838#ifdef KHRONOS_1_1
839        case OMX_IndexParamVideoMacroblocksPerFrame:/**< reference: OMX_PARAM_MACROBLOCKSTYPE */
840        {
841            OMX_PARAM_MACROBLOCKSTYPE* pMBBlocksTypeTo = ComponentParameterStructure;
842            /*OMX_CONF_CHK_VERSION( pMBBlocksTypeTo, OMX_PARAM_MACROBLOCKSTYPE, eError, pComponentPrivate->dbg);*/
843            pMBBlocksTypeTo->nMacroblocks = pComponentPrivate->pOutPortDef->format.video.nFrameWidth *
844                                            pComponentPrivate->pOutPortDef->format.video.nFrameHeight / 256;
845            break;
846        }
847        case OMX_IndexParamVideoProfileLevelQuerySupported:
848            {
849                VIDEO_PROFILE_LEVEL_TYPE* pProfileLevel = NULL;
850                OMX_U32 nNumberOfProfiles = 0;
851                OMX_VIDEO_PARAM_PROFILELEVELTYPE *pParamProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)ComponentParameterStructure;
852                pParamProfileLevel->nPortIndex = pComponentPrivate->pInPortDef->nPortIndex;
853
854                /* Choose table based on compression format */
855                switch(pComponentPrivate->pInPortDef->format.video.eCompressionFormat)
856                {
857                   case OMX_VIDEO_CodingH263:
858					    pProfileLevel = SupportedH263ProfileLevels;
859	                    nNumberOfProfiles = sizeof(SupportedH263ProfileLevels) / sizeof (VIDEO_PROFILE_LEVEL_TYPE);
860                      break;
861                   case OMX_VIDEO_CodingMPEG4:
862					    pProfileLevel = SupportedMPEG4ProfileLevels;
863	                    nNumberOfProfiles = sizeof(SupportedMPEG4ProfileLevels) / sizeof (VIDEO_PROFILE_LEVEL_TYPE);
864                      break;
865                   case OMX_VIDEO_CodingAVC:
866					    pProfileLevel = SupportedAVCProfileLevels;
867                        nNumberOfProfiles = sizeof(SupportedAVCProfileLevels) / sizeof (VIDEO_PROFILE_LEVEL_TYPE);
868                      break;
869                    default:
870                        return OMX_ErrorBadParameter;
871                  }
872
873                if((pParamProfileLevel->nProfileIndex < 0) || (pParamProfileLevel->nProfileIndex >= (nNumberOfProfiles - 1)))
874                    return OMX_ErrorBadParameter;
875                  /* Point to table entry based on index */
876                  pProfileLevel += pParamProfileLevel->nProfileIndex;
877
878                  /* -1 indicates end of table */
879                  if(pProfileLevel->nProfile != -1) {
880                     pParamProfileLevel->eProfile = pProfileLevel->nProfile;
881                     pParamProfileLevel->eLevel = pProfileLevel->nLevel;
882                     eError = OMX_ErrorNone;
883                  }
884                  else {
885                     eError = OMX_ErrorNoMore;
886                  }
887                  break;
888                  }
889        case OMX_IndexParamVideoProfileLevelCurrent:
890        {
891           OMX_VIDEO_PARAM_PROFILELEVELTYPE *pParamProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)ComponentParameterStructure;
892           if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
893           ALOGW("Getparameter OMX_IndexParamVideoProfileLevelCurrent AVC");
894           pParamProfileLevel->eProfile = pComponentPrivate->pH264->eProfile;
895           pParamProfileLevel->eLevel = pComponentPrivate->pH264->eLevel;
896        }
897        else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4) {
898           ALOGW("Getparameter OMX_IndexParamVideoProfileLevelCurrent MPEG4");
899           pParamProfileLevel->eProfile = pComponentPrivate->pMpeg4->eProfile;
900           pParamProfileLevel->eLevel = pComponentPrivate->pMpeg4->eLevel;
901        }
902        else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) {
903           ALOGW("Getparameter OMX_IndexParamVideoProfileLevelCurrent H.263");
904           pParamProfileLevel->eProfile = pComponentPrivate->pH263->eProfile;
905           pParamProfileLevel->eLevel = pComponentPrivate->pH263->eLevel;
906        }
907        else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG2) {
908           pParamProfileLevel->eProfile = pComponentPrivate->pMpeg2->eProfile;
909           pParamProfileLevel->eLevel = pComponentPrivate->pMpeg2->eLevel;
910        }
911        else {
912           ALOGD("Error in Getparameter OMX_IndexParamVideoProfileLevelCurrent");
913           eError = OMX_ErrorBadParameter;
914         }
915      }
916      break;
917        case OMX_IndexParamStandardComponentRole:
918            if (ComponentParameterStructure != NULL) {
919                pRole = (OMX_PARAM_COMPONENTROLETYPE *)ComponentParameterStructure;
920                /*OMX_CONF_CHK_VERSION( pRole, OMX_PARAM_COMPONENTROLETYPE, eError, pComponentPrivate->dbg);*/
921                memcpy( pRole, &pComponentPrivate->componentRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
922            }
923            else {
924                eError = OMX_ErrorBadParameter;
925            }
926            break;
927#endif
928#endif
929        case OMX_IndexParamPortDefinition:
930            {
931                if (((OMX_PARAM_PORTDEFINITIONTYPE*)(ComponentParameterStructure))->nPortIndex ==
932                        pComponentPrivate->pInPortDef->nPortIndex) {
933                    OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = pComponentPrivate->pInPortDef;
934                    OMX_PARAM_PORTDEFINITIONTYPE *pPortDefParam = (OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure;
935                    memcpy(pPortDefParam, pPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
936                }
937                else if (((OMX_PARAM_PORTDEFINITIONTYPE*)(ComponentParameterStructure))->nPortIndex ==
938                        pComponentPrivate->pOutPortDef->nPortIndex) {
939                    OMX_PARAM_PORTDEFINITIONTYPE *pPortDefParam = (OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure;
940                    OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = pComponentPrivate->pOutPortDef;
941                    memcpy(pPortDefParam, pPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
942                }
943                else {
944                    eError = OMX_ErrorBadPortIndex;
945                }
946
947                OMX_PRBUFFER1(pComponentPrivate->dbg, "CountActual 0x%x CountMin 0x%x Size %d bEnabled %x bPopulated %x compression %x %x-%x\n",
948                                (int )((OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure)->nBufferCountActual,
949                                (int )((OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure)->nBufferCountMin,
950                                (int )((OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure)->nBufferSize,
951                                (int )((OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure)->bEnabled,
952                                (int )((OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure)->bPopulated,
953                                (int )((OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure)->format.video.nFrameWidth,
954                                (int )((OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure)->format.video.nFrameHeight,
955                                (int )((OMX_PARAM_PORTDEFINITIONTYPE *)ComponentParameterStructure)->format.video.eCompressionFormat);
956            }
957            break;
958        case OMX_IndexParamVideoPortFormat:
959            {
960                OMX_VIDEO_PARAM_PORTFORMATTYPE* pPortFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE*)ComponentParameterStructure;
961                if (pPortFormat->nPortIndex == pComponentPrivate->pInPortFormat->nPortIndex) {
962                    switch (pPortFormat->nIndex) {
963                        case VIDDEC_DEFAULT_INPUT_INDEX_H263:
964                            OMX_PRINT1(pComponentPrivate->dbg, "eCompressionFormat = OMX_VIDEO_CodingH263\n");
965                            pComponentPrivate->pInPortFormat->nIndex                        = VIDDEC_DEFAULT_INPUT_INDEX_H263;
966                            pComponentPrivate->pInPortFormat->eCompressionFormat            = OMX_VIDEO_CodingH263;
967                            pComponentPrivate->pInPortDef->format.video.eCompressionFormat  = OMX_VIDEO_CodingH263;
968                            break;
969                        case VIDDEC_DEFAULT_INPUT_INDEX_H264:
970                            OMX_PRINT1(pComponentPrivate->dbg, "eCompressionFormat = OMX_VIDEO_CodingAVC\n");
971                            pComponentPrivate->pInPortFormat->nIndex                        = VIDDEC_DEFAULT_INPUT_INDEX_H264;
972                            pComponentPrivate->pInPortFormat->eCompressionFormat            = OMX_VIDEO_CodingAVC;
973                            pComponentPrivate->pInPortDef->format.video.eCompressionFormat  = OMX_VIDEO_CodingAVC;
974                            break;
975                        case VIDDEC_DEFAULT_INPUT_INDEX_MPEG2:
976                            pComponentPrivate->pInPortFormat->nIndex                        = VIDDEC_DEFAULT_INPUT_INDEX_MPEG2;
977                            pComponentPrivate->pInPortFormat->eCompressionFormat            = OMX_VIDEO_CodingMPEG2;
978                            pComponentPrivate->pInPortDef->format.video.eCompressionFormat  = OMX_VIDEO_CodingMPEG2;
979                            break;
980                        case VIDDEC_DEFAULT_INPUT_INDEX_MPEG4:
981                            OMX_PRINT1(pComponentPrivate->dbg, "eCompressionFormat = VIDDEC_DEFAULT_INPUT_INDEX_MPEG4\n");
982                            pComponentPrivate->pInPortFormat->nIndex                        = VIDDEC_DEFAULT_INPUT_INDEX_MPEG4;
983                            pComponentPrivate->pInPortFormat->eCompressionFormat            = OMX_VIDEO_CodingMPEG4;
984                            pComponentPrivate->pInPortDef->format.video.eCompressionFormat  = OMX_VIDEO_CodingMPEG4;
985                            break;
986                        case VIDDEC_DEFAULT_INPUT_INDEX_WMV9:
987                            pComponentPrivate->pInPortFormat->nIndex                        = VIDDEC_DEFAULT_INPUT_INDEX_WMV9;
988                            pComponentPrivate->pInPortFormat->eCompressionFormat            = OMX_VIDEO_CodingWMV;
989                            pComponentPrivate->pInPortDef->format.video.eCompressionFormat  = OMX_VIDEO_CodingWMV;
990                            break;
991#ifdef VIDDEC_SPARK_CODE
992                        case VIDDEC_DEFAULT_INPUT_INDEX_SPARK:
993                            pComponentPrivate->pInPortFormat->nIndex                        = VIDDEC_DEFAULT_INPUT_INDEX_SPARK;
994                            pComponentPrivate->pInPortFormat->eCompressionFormat            = OMX_VIDEO_CodingUnused;
995                            pComponentPrivate->pInPortDef->format.video.eCompressionFormat  = OMX_VIDEO_CodingUnused;
996                            break;
997#endif
998                        default:
999                            OMX_PRINT1(pComponentPrivate->dbg, "Input Index= %lu; OMX_ErrorNoMore\n", pPortFormat->nIndex);
1000                            eError = OMX_ErrorNoMore;
1001                            break;
1002                    }
1003                    if(eError == OMX_ErrorNone) {
1004                        memcpy(ComponentParameterStructure, pComponentPrivate->pInPortFormat,
1005                                sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
1006                    }
1007                }
1008                else if (pPortFormat->nPortIndex == pComponentPrivate->pOutPortFormat->nPortIndex) {
1009                    if(eError == OMX_ErrorNone) {
1010                        memcpy(ComponentParameterStructure, pComponentPrivate->pOutPortFormat,
1011                            sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
1012                    }
1013                }
1014                else {
1015                    eError = OMX_ErrorBadPortIndex;
1016                }
1017            }
1018            break;
1019        case OMX_IndexParamPriorityMgmt:
1020            memcpy(ComponentParameterStructure, pComponentPrivate->pPriorityMgmt, sizeof(OMX_PRIORITYMGMTTYPE));
1021            break;
1022        case  OMX_IndexParamVideoWmv:
1023            {
1024                if (((OMX_VIDEO_PARAM_WMVTYPE*)(ComponentParameterStructure))->nPortIndex ==
1025                        pComponentPrivate->pWMV->nPortIndex) {
1026                    memcpy(ComponentParameterStructure, pComponentPrivate->pWMV, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
1027                }
1028                else {
1029                    eError = OMX_ErrorBadPortIndex;
1030                }
1031            }
1032            break;
1033        case  OMX_IndexParamVideoMpeg4:
1034            {
1035                if (((OMX_VIDEO_PARAM_MPEG4TYPE*)(ComponentParameterStructure))->nPortIndex ==
1036                        pComponentPrivate->pMpeg4->nPortIndex) {
1037                    memcpy(ComponentParameterStructure, pComponentPrivate->pMpeg4, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1038                }
1039                else {
1040                    eError = OMX_ErrorBadPortIndex;
1041                }
1042            }
1043            break;
1044        case  OMX_IndexParamVideoMpeg2:
1045            {
1046                if (((OMX_VIDEO_PARAM_MPEG2TYPE*)(ComponentParameterStructure))->nPortIndex ==
1047                        pComponentPrivate->pMpeg2->nPortIndex) {
1048                    memcpy(ComponentParameterStructure, pComponentPrivate->pMpeg2, sizeof(OMX_VIDEO_PARAM_MPEG2TYPE));
1049                }
1050                else {
1051                    eError = OMX_ErrorBadPortIndex;
1052                }
1053            }
1054            break;
1055        case OMX_IndexParamVideoAvc:
1056            {
1057
1058                if (((OMX_VIDEO_PARAM_AVCTYPE*)(ComponentParameterStructure))->nPortIndex ==
1059                        pComponentPrivate->pH264->nPortIndex) {
1060                    memcpy(ComponentParameterStructure, pComponentPrivate->pH264, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1061                }
1062                else {
1063                    eError = OMX_ErrorBadPortIndex;
1064                }
1065            }
1066            break;
1067        case OMX_IndexParamVideoH263:
1068            {
1069
1070                if (((OMX_VIDEO_PARAM_H263TYPE*)(ComponentParameterStructure))->nPortIndex ==
1071                        pComponentPrivate->pH263->nPortIndex) {
1072                    memcpy(ComponentParameterStructure, pComponentPrivate->pH263, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1073                }
1074                else {
1075                    eError = OMX_ErrorBadPortIndex;
1076                }
1077            }
1078            break;
1079        case OMX_IndexParamCompBufferSupplier:
1080            {
1081                OMX_PARAM_BUFFERSUPPLIERTYPE* pBuffSupplierParam = (OMX_PARAM_BUFFERSUPPLIERTYPE*)ComponentParameterStructure;
1082
1083                if (pBuffSupplierParam->nPortIndex == 1) {
1084                    pBuffSupplierParam->eBufferSupplier = pComponentPrivate->pCompPort[pBuffSupplierParam->nPortIndex]->eSupplierSetting;
1085                }
1086                else if (pBuffSupplierParam->nPortIndex == 0) {
1087                    pBuffSupplierParam->eBufferSupplier = pComponentPrivate->pCompPort[pBuffSupplierParam->nPortIndex]->eSupplierSetting;
1088                }
1089                else {
1090                    eError = OMX_ErrorBadPortIndex;
1091                    break;
1092                }
1093            }
1094            break;
1095        case VideoDecodeCustomParamProcessMode:
1096            *((OMX_U32 *)ComponentParameterStructure) = pComponentPrivate->ProcessMode;
1097            break;
1098        case VideoDecodeCustomParamParserEnabled:
1099            *((OMX_BOOL *)ComponentParameterStructure) = pComponentPrivate->bParserEnabled;
1100            break;
1101        case VideoDecodeCustomParamH264BitStreamFormat:
1102            *((OMX_U32 *)ComponentParameterStructure) = pComponentPrivate->H264BitStreamFormat;
1103            break;
1104        case VideoDecodeCustomParamWMVProfile:
1105            {
1106                *((VIDDEC_WMV_PROFILES *)ComponentParameterStructure) = pComponentPrivate->wmvProfile;
1107            }
1108            break;
1109        case VideoDecodeCustomParamWMVFileType:
1110            *((OMX_U32 *)ComponentParameterStructure) = pComponentPrivate->nWMVFileType;
1111            break;
1112        case VideoDecodeCustomParamIsNALBigEndian:
1113            *((OMX_BOOL *)ComponentParameterStructure) = pComponentPrivate->bIsNALBigEndian;
1114
1115            break;
1116#ifdef VIDDEC_SPARK_CODE
1117        case VideoDecodeCustomParamIsSparkInput:
1118            *((OMX_U32 *)ComponentParameterStructure) = pComponentPrivate->bIsSparkInput;
1119
1120            break;
1121#endif
1122        case OMX_IndexParamCommonDeblocking: /**< reference: OMX_PARAM_DEBLOCKINGTYPE */
1123        {
1124            memcpy(ComponentParameterStructure, pComponentPrivate->pDeblockingParamType, sizeof(OMX_PARAM_DEBLOCKINGTYPE));
1125            break;
1126        }
1127#ifdef ANDROID
1128        /* Opencore specific */
1129        case (OMX_INDEXTYPE) PV_OMX_COMPONENT_CAPABILITY_TYPE_INDEX: /** Obtain the capabilities of the OMX component **/
1130                memcpy(ComponentParameterStructure, pComponentPrivate->pPVCapabilityFlags,
1131                        sizeof(PV_OMXComponentCapabilityFlagsType));
1132                eError = OMX_ErrorNone;
1133            break;
1134#endif
1135        default:
1136            eError = OMX_ErrorUnsupportedIndex;
1137            break;
1138        }
1139
1140EXIT:
1141    return eError;
1142}
1143
1144/*----------------------------------------------------------------------------*/
1145/**
1146  *  VIDDEC_CheckSetParameter() checks when it is valid calling OMX_SetParameter
1147  *
1148  * This method will update application callbacks
1149  * the application.
1150  *
1151  * @param pComponentPrivate         handle for this instance of the component
1152  * @param pCompParam                pointer to the parameter structure
1153  * @param nParamIndex               parameter index
1154  *
1155  * @retval OMX_NoError              Success, ready to roll
1156  *         OMX_ErrorIncorrectStateOperation   if the checks fails
1157  **/
1158/*----------------------------------------------------------------------------*/
1159
1160OMX_ERRORTYPE VIDDEC_CheckSetParameter(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate, OMX_PTR pCompParam, OMX_INDEXTYPE nParamIndex) {
1161    OMX_ERRORTYPE eError = OMX_ErrorNone;
1162
1163    if (pComponentPrivate->eState == OMX_StateInvalid) {
1164        OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorIncorrectStateOperation);
1165    }
1166
1167    if (pComponentPrivate->eState != OMX_StateLoaded && pComponentPrivate->eState != OMX_StateWaitForResources) {
1168        /*using OMX_CONFIG_ROTATIONTYPE because it is smallest structure that contains nPortIndex;*/
1169        OMX_CONFIG_ROTATIONTYPE* pTempFormat = (OMX_CONFIG_ROTATIONTYPE*)pCompParam;
1170
1171        switch (nParamIndex) {
1172            /*the indices corresponding to the parameter structures containing the field "nPortIndex"*/
1173            case OMX_IndexParamCompBufferSupplier:
1174            case OMX_IndexParamVideoPortFormat:
1175            case OMX_IndexParamPortDefinition:
1176            case OMX_IndexParamVideoWmv:
1177            case OMX_IndexParamVideoMpeg4:
1178            case OMX_IndexParamVideoMpeg2:
1179            case OMX_IndexParamVideoAvc:
1180            case OMX_IndexParamVideoH263:
1181            case OMX_IndexConfigVideoMBErrorReporting:
1182            case OMX_IndexParamCommonDeblocking:
1183                if (pTempFormat->nPortIndex ==  pComponentPrivate->pInPortDef->nPortIndex) {
1184                    if (pComponentPrivate->pInPortDef->bEnabled){
1185                        OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorIncorrectStateOperation);
1186                    }
1187                }
1188                else if (pTempFormat->nPortIndex == pComponentPrivate->pOutPortDef->nPortIndex) {
1189                    if (pComponentPrivate->pOutPortDef->bEnabled){
1190                        OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorIncorrectStateOperation);
1191                    }
1192                }/*it cannot be -1 because structure assignment will happen on one port*/
1193                else {
1194                    eError = OMX_ErrorBadPortIndex;
1195                }
1196                break;
1197            default:
1198                /*all other cases where pCompParam is integer or it doesn't support nPortIndex*/
1199                if (!(pComponentPrivate->pInPortDef->bEnabled == OMX_FALSE ||
1200                    pComponentPrivate->pOutPortDef->bEnabled == OMX_FALSE)) {
1201                    OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorIncorrectStateOperation);
1202                }
1203        }
1204    }
1205EXIT:
1206    return eError;
1207}
1208
1209/*----------------------------------------------------------------------------*/
1210/**
1211  *  VIDDEC_SetParameter() Sets application callbacks to the component
1212  *
1213  * This method will update application callbacks
1214  * the application.
1215  *
1216  * @param pComp         handle for this instance of the component
1217  * @param pCallBacks    application callbacks
1218  * @param ptr
1219  *
1220  * @retval OMX_NoError              Success, ready to roll
1221  *         OMX_Error_BadParameter   The input parameter pointer is null
1222  **/
1223/*----------------------------------------------------------------------------*/
1224
1225static OMX_ERRORTYPE VIDDEC_SetParameter (OMX_HANDLETYPE hComp,
1226                                          OMX_INDEXTYPE nParamIndex,
1227                                          OMX_PTR pCompParam)
1228{
1229    OMX_COMPONENTTYPE* pHandle= NULL;
1230    VIDDEC_COMPONENT_PRIVATE *pComponentPrivate = NULL;
1231    OMX_ERRORTYPE eError = OMX_ErrorNone;
1232
1233#ifdef KHRONOS_1_1
1234    OMX_PARAM_COMPONENTROLETYPE *pRole = NULL;
1235#endif
1236    OMX_CONF_CHECK_CMD(hComp, pCompParam, OMX_TRUE);
1237    pHandle= (OMX_COMPONENTTYPE*)hComp;
1238    pComponentPrivate = pHandle->pComponentPrivate;
1239
1240    eError = VIDDEC_CheckSetParameter(pComponentPrivate, pCompParam, nParamIndex);
1241
1242    if (eError != OMX_ErrorNone)
1243        OMX_CONF_SET_ERROR_BAIL(eError , OMX_ErrorIncorrectStateOperation);
1244
1245    switch (nParamIndex) {
1246        case OMX_IndexParamVideoPortFormat:
1247            {
1248                OMX_VIDEO_PARAM_PORTFORMATTYPE* pPortFormat = (OMX_VIDEO_PARAM_PORTFORMATTYPE*)pCompParam;
1249                if (pPortFormat->nPortIndex == pComponentPrivate->pInPortFormat->nPortIndex) {
1250                    if(pPortFormat->eColorFormat == OMX_COLOR_FormatUnused) {
1251                        switch (pPortFormat->eCompressionFormat) {
1252                            case OMX_VIDEO_CodingH263:
1253                                pComponentPrivate->pInPortDef->format.video.eCompressionFormat  = OMX_VIDEO_CodingH263;
1254                                break;
1255                            case OMX_VIDEO_CodingAVC:
1256                                pComponentPrivate->pInPortDef->format.video.eCompressionFormat  = OMX_VIDEO_CodingAVC;
1257                                OMX_PRINT1(pComponentPrivate->dbg, "eCompressionFormat = OMX_VIDEO_CodingAVC\n");
1258                                break;
1259                            case OMX_VIDEO_CodingMPEG2:
1260                                pComponentPrivate->pInPortDef->format.video.eCompressionFormat  = OMX_VIDEO_CodingMPEG2;
1261                                break;
1262                            case OMX_VIDEO_CodingMPEG4:
1263                                OMX_PRINT1(pComponentPrivate->dbg, "eCompressionFormat = OMX_VIDEO_CodingMPEG4\n");
1264                                pComponentPrivate->pInPortDef->format.video.eCompressionFormat  = OMX_VIDEO_CodingMPEG4;
1265                                break;
1266                            case OMX_VIDEO_CodingWMV:
1267                                OMX_PRINT1(pComponentPrivate->dbg, "eCompressionFormat = OMX_VIDEO_CodingWMV\n");
1268                                pComponentPrivate->pInPortDef->format.video.eCompressionFormat  = OMX_VIDEO_CodingWMV;
1269                                break;
1270
1271#ifdef VIDDEC_SPARK_CODE
1272                            case OMX_VIDEO_CodingUnused:
1273                                if (pComponentPrivate->bIsSparkInput) {
1274                                    pComponentPrivate->pInPortDef->format.video.eCompressionFormat  = OMX_VIDEO_CodingUnused;
1275                                }
1276                                else {
1277                                    eError = OMX_ErrorNoMore;
1278                                }
1279                                break;
1280#endif
1281                            default:
1282                                eError = OMX_ErrorNoMore;
1283                                break;
1284                        }
1285                    }
1286                    else {
1287                        eError = OMX_ErrorBadParameter;
1288                    }
1289                    if(eError == OMX_ErrorNone) {
1290                        memcpy(pComponentPrivate->pInPortFormat, pPortFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
1291                    }
1292                }
1293                else if (pPortFormat->nPortIndex == pComponentPrivate->pOutPortFormat->nPortIndex) {
1294                    if(pPortFormat->eCompressionFormat == OMX_VIDEO_CodingUnused) {
1295                        switch (pPortFormat->eColorFormat) {
1296                            case OMX_COLOR_FormatYUV420Planar:
1297                                pComponentPrivate->pOutPortDef->format.video.eColorFormat = VIDDEC_COLORFORMAT420;
1298                                break;
1299                            case OMX_COLOR_FormatCbYCrY:
1300                                pComponentPrivate->pOutPortDef->format.video.eColorFormat = VIDDEC_COLORFORMAT422;
1301                                break;
1302                            default:
1303                                eError = OMX_ErrorNoMore;
1304                                break;
1305                        }
1306                    }
1307                    else {
1308                        eError = OMX_ErrorBadParameter;
1309                    }
1310                    if(eError == OMX_ErrorNone) {
1311                        memcpy(pComponentPrivate->pOutPortFormat, pPortFormat, sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
1312                    }
1313                }
1314                else {
1315                    eError = OMX_ErrorBadPortIndex;
1316                }
1317            }
1318            break;
1319        case OMX_IndexParamVideoInit:
1320            memcpy(pComponentPrivate->pPortParamType, (OMX_PORT_PARAM_TYPE*)pCompParam, sizeof(OMX_PORT_PARAM_TYPE));
1321            break;
1322#ifdef __STD_COMPONENT__
1323        case OMX_IndexParamAudioInit:
1324            memcpy(pComponentPrivate->pPortParamTypeAudio, (OMX_PORT_PARAM_TYPE*)pCompParam, sizeof(OMX_PORT_PARAM_TYPE));
1325            break;
1326        case OMX_IndexParamImageInit:
1327            memcpy(pComponentPrivate->pPortParamTypeImage, (OMX_PORT_PARAM_TYPE*)pCompParam, sizeof(OMX_PORT_PARAM_TYPE));
1328            break;
1329        case OMX_IndexParamOtherInit:
1330            memcpy(pComponentPrivate->pPortParamTypeOthers, (OMX_PORT_PARAM_TYPE*)pCompParam, sizeof(OMX_PORT_PARAM_TYPE));
1331            break;
1332#endif
1333        case OMX_IndexParamPortDefinition:
1334            {
1335                OMX_PARAM_PORTDEFINITIONTYPE* pComponentParam = (OMX_PARAM_PORTDEFINITIONTYPE*)pCompParam;
1336                if (pComponentParam->nPortIndex == pComponentPrivate->pInPortDef->nPortIndex) {
1337                    OMX_PARAM_PORTDEFINITIONTYPE *pPortDefParam = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParam;
1338                    OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = pComponentPrivate->pInPortDef;
1339                    memcpy(pPortDef, pPortDefParam, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1340                    if ( pPortDef->nBufferSize == 0 )
1341                    {
1342                        pPortDef->nBufferSize = pPortDef->format.video.nFrameWidth *
1343                                                pPortDef->format.video.nFrameHeight;
1344                    }
1345
1346                    OMX_PRINT1(pComponentPrivate->dbg, "Set i/p size: %dx%d", pPortDefParam->format.video.nFrameWidth, pPortDefParam->format.video.nFrameHeight);
1347                }
1348                else if (pComponentParam->nPortIndex == pComponentPrivate->pOutPortDef->nPortIndex) {
1349                    OMX_PARAM_PORTDEFINITIONTYPE *pPortDefParam = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParam;
1350                    OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = pComponentPrivate->pOutPortDef;
1351                    memcpy(pPortDef, pPortDefParam, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1352                    pPortDef->nBufferSize = pPortDef->format.video.nFrameWidth *
1353                                            pPortDef->format.video.nFrameHeight *
1354                                            ((pComponentPrivate->pOutPortFormat->eColorFormat == VIDDEC_COLORFORMAT420) ? VIDDEC_FACTORFORMAT420 : VIDDEC_FACTORFORMAT422);
1355
1356                    OMX_PRINT1(pComponentPrivate->dbg, "Set OUT/p size: %dx%d", pPortDefParam->format.video.nFrameWidth, pPortDefParam->format.video.nFrameHeight);
1357                }
1358                else {
1359                    eError = OMX_ErrorBadPortIndex;
1360                }
1361                OMX_PRBUFFER1(pComponentPrivate->dbg, "CountActual 0x%x CountMin 0x%x Size %d bEnabled %x bPopulated %x\n",
1362                                (int )pComponentParam->nBufferCountActual,
1363                                (int )pComponentParam->nBufferCountMin,
1364                                (int )pComponentParam->nBufferSize,
1365                                (int )pComponentParam->bEnabled,
1366                                (int )pComponentParam->bPopulated);
1367            }
1368            break;
1369        case OMX_IndexParamVideoWmv:
1370            {
1371                OMX_VIDEO_PARAM_WMVTYPE* pComponentParam = (OMX_VIDEO_PARAM_WMVTYPE*)pCompParam;
1372                if (pComponentParam->nPortIndex == pComponentPrivate->pWMV->nPortIndex) {
1373                    memcpy(pComponentPrivate->pWMV, pCompParam, sizeof(OMX_VIDEO_PARAM_WMVTYPE));
1374                }
1375                else {
1376                    eError = OMX_ErrorBadPortIndex;
1377                }
1378            }
1379            break;
1380        case OMX_IndexParamVideoMpeg4:
1381            {
1382                OMX_VIDEO_PARAM_MPEG4TYPE* pComponentParam = (OMX_VIDEO_PARAM_MPEG4TYPE*)pCompParam;
1383                if (pComponentParam->nPortIndex == pComponentPrivate->pMpeg4->nPortIndex) {
1384                    memcpy(pComponentPrivate->pMpeg4, pCompParam, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1385                }
1386                else {
1387                    eError = OMX_ErrorBadPortIndex;
1388                }
1389            }
1390            break;
1391        case OMX_IndexParamVideoMpeg2:
1392            {
1393                OMX_VIDEO_PARAM_MPEG2TYPE* pComponentParam = (OMX_VIDEO_PARAM_MPEG2TYPE*)pCompParam;
1394                if (pComponentParam->nPortIndex == pComponentPrivate->pMpeg2->nPortIndex) {
1395                    memcpy(pComponentPrivate->pMpeg2, pCompParam, sizeof(OMX_VIDEO_PARAM_MPEG2TYPE));
1396                }
1397                else {
1398                    eError = OMX_ErrorBadPortIndex;
1399                }
1400            }
1401            break;
1402        case OMX_IndexParamVideoAvc:
1403            {
1404                OMX_VIDEO_PARAM_AVCTYPE* pComponentParam = (OMX_VIDEO_PARAM_AVCTYPE *)pCompParam;
1405                if (pComponentParam->nPortIndex == pComponentPrivate->pH264->nPortIndex) {
1406                    memcpy(pComponentPrivate->pH264, pCompParam, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1407                }
1408                else {
1409                    eError = OMX_ErrorBadPortIndex;
1410                }
1411            }
1412            break;
1413        case OMX_IndexParamVideoH263:
1414            {
1415                OMX_VIDEO_PARAM_H263TYPE* pComponentParam = (OMX_VIDEO_PARAM_H263TYPE *)pCompParam;
1416                if (pComponentParam->nPortIndex == pComponentPrivate->pH263->nPortIndex) {
1417                    memcpy(pComponentPrivate->pH263, pCompParam, sizeof(OMX_VIDEO_PARAM_H263TYPE));
1418                }
1419                else {
1420                    eError = OMX_ErrorBadPortIndex;
1421                }
1422            }
1423            break;
1424        case OMX_IndexParamPriorityMgmt:
1425            memcpy(pComponentPrivate->pPriorityMgmt, (OMX_PRIORITYMGMTTYPE*)pCompParam, sizeof(OMX_PRIORITYMGMTTYPE));
1426            break;
1427        case OMX_IndexParamCompBufferSupplier:
1428            {
1429                OMX_PARAM_BUFFERSUPPLIERTYPE* pBuffSupplierParam = (OMX_PARAM_BUFFERSUPPLIERTYPE*)pCompParam;
1430
1431                if (pBuffSupplierParam->nPortIndex == 1) {
1432                    pComponentPrivate->pCompPort[pBuffSupplierParam->nPortIndex]->eSupplierSetting = pBuffSupplierParam->eBufferSupplier;
1433                }
1434                else if (pBuffSupplierParam->nPortIndex == 0) {
1435                    pComponentPrivate->pCompPort[pBuffSupplierParam->nPortIndex]->eSupplierSetting = pBuffSupplierParam->eBufferSupplier;
1436                }
1437                else {
1438                    eError = OMX_ErrorBadPortIndex;
1439                    break;
1440                }
1441            }
1442            break;
1443        /* Video decode custom parameters */
1444        case VideoDecodeCustomParamProcessMode:
1445            pComponentPrivate->ProcessMode = (OMX_U32)(*((OMX_U32 *)pCompParam));
1446            break;
1447        case VideoDecodeCustomParamParserEnabled:
1448            pComponentPrivate->bParserEnabled = (OMX_BOOL)(*((OMX_BOOL *)pCompParam));
1449            break;
1450        case VideoDecodeCustomParamH264BitStreamFormat:
1451            pComponentPrivate->H264BitStreamFormat = (OMX_U32)(*((OMX_U32 *)pCompParam));
1452            break;
1453        case VideoDecodeCustomParamWMVProfile:
1454            {
1455                pComponentPrivate->wmvProfile = *((VIDDEC_WMV_PROFILES *)pCompParam);
1456            }
1457            break;
1458#ifdef KHRONOS_1_1
1459        case OMX_IndexParamStandardComponentRole:
1460            if (pCompParam != NULL) {
1461                OMX_U8* cTempRole = NULL;
1462                cTempRole = (OMX_U8*)pComponentPrivate->componentRole.cRole;
1463                pRole = (OMX_PARAM_COMPONENTROLETYPE *)pCompParam;
1464                /*OMX_CONF_CHK_VERSION( pRole, OMX_PARAM_COMPONENTROLETYPE, eError, pComponentPrivate->dbg);*/
1465                if(strcmp( (char*)pRole->cRole, VIDDEC_COMPONENTROLES_H263) == 0) {
1466                    eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_H263);
1467                }
1468                else if(strcmp( (char*)pRole->cRole, VIDDEC_COMPONENTROLES_H264) == 0) {
1469                    eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_H264);
1470                }
1471                else if(strcmp( (char*)pRole->cRole, VIDDEC_COMPONENTROLES_MPEG2) == 0) {
1472                    eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_MPEG2);
1473                }
1474                else if(strcmp( (char*)pRole->cRole, VIDDEC_COMPONENTROLES_MPEG4) == 0) {
1475                    eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_MPEG4);
1476                }
1477                else if(strcmp( (char*)pRole->cRole, VIDDEC_COMPONENTROLES_WMV9) == 0) {
1478                    eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_WMV9);
1479                }
1480#ifdef VIDDEC_SPARK_CODE
1481                else if(strcmp( (char*)pRole->cRole, VIDDEC_COMPONENTROLES_SPARK) == 0) {
1482                    eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_SPARK);
1483                }
1484#endif
1485                else {
1486                    eError = OMX_ErrorBadParameter;
1487                }
1488                if(eError != OMX_ErrorNone) {
1489                    goto EXIT;
1490                }
1491#ifdef ANDROID
1492                /* Set format according with hw accelerated rendering */
1493                if( pComponentPrivate->pOutPortFormat->eColorFormat != VIDDEC_COLORFORMAT422) {
1494                    eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_INTERLEAVED422);
1495                }
1496#else
1497                if( pComponentPrivate->pOutPortFormat->eColorFormat != VIDDEC_COLORFORMAT420) {
1498                    eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_PLANAR420);
1499                }
1500#endif
1501                memcpy( (void *)&pComponentPrivate->componentRole, (void *)pRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1502            }
1503            else {
1504                eError = OMX_ErrorBadParameter;
1505            }
1506            break;
1507#endif
1508        case VideoDecodeCustomParamWMVFileType:
1509            pComponentPrivate->nWMVFileType = (OMX_U32)(*((OMX_U32 *)pCompParam));
1510
1511            break;
1512        case VideoDecodeCustomParamIsNALBigEndian:
1513            pComponentPrivate->bIsNALBigEndian = (OMX_BOOL)(*((OMX_BOOL *)pCompParam));
1514            break;
1515#ifdef VIDDEC_SPARK_CODE
1516        case VideoDecodeCustomParamIsSparkInput:
1517            pComponentPrivate->bIsSparkInput = (OMX_BOOL)(*((OMX_BOOL *)pCompParam));
1518            break;
1519#endif
1520#ifdef KHRONOS_1_1
1521        case OMX_IndexConfigVideoMBErrorReporting:/**< reference: OMX_CONFIG_MBERRORREPORTINGTYPE */
1522        {
1523            if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 ||
1524                pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263 ||
1525                pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
1526                OMX_CONFIG_MBERRORREPORTINGTYPE* pMBErrorReportFrom = pCompParam;
1527                /*OMX_CONF_CHK_VERSION( pMBErrorReportFrom, OMX_CONFIG_MBERRORREPORTINGTYPE, eError, pComponentPrivate->dbg);*/
1528                pComponentPrivate->eMBErrorReport.bEnabled = pMBErrorReportFrom->bEnabled;
1529            }
1530            else {
1531                eError = OMX_ErrorUnsupportedIndex;
1532            }
1533            break;
1534        }
1535        case OMX_IndexParamCommonDeblocking: /**< reference: OMX_PARAM_DEBLOCKINGTYPE */
1536        {
1537            char value[PROPERTY_VALUE_MAX];
1538            property_get("debug.video.showfps", value, "0");
1539            mDebugFps = atoi(value);
1540            ALOGD_IF(mDebugFps, "Not setting deblocking to measure fps");
1541            if (mDebugFps == OMX_FALSE) {
1542                if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 ||
1543                        pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263){
1544                        /*pComponentPrivate->pDeblockingParamType->bDeblocking =
1545                            ((OMX_PARAM_DEBLOCKINGTYPE*)pCompParam)->bDeblocking;*/
1546                        /*codec is not supporting deblocking by now*/
1547                        pComponentPrivate->pDeblockingParamType->bDeblocking = OMX_FALSE;
1548                        eError = OMX_ErrorUnsupportedIndex;
1549                    break;
1550                }
1551            }
1552            else {
1553                eError = OMX_ErrorUnsupportedIndex;
1554                break;
1555            }
1556        }
1557
1558        case OMX_IndexParamVideoMacroblocksPerFrame:
1559        case OMX_IndexParamNumAvailableStreams:
1560        case OMX_IndexParamActiveStream:
1561        case OMX_IndexParamSuspensionPolicy:
1562        case OMX_IndexParamComponentSuspended:
1563        case OMX_IndexAutoPauseAfterCapture:
1564        case OMX_IndexParamCustomContentPipe:
1565        case OMX_IndexParamDisableResourceConcealment:
1566#ifdef KHRONOS_1_2
1567            case OMX_IndexConfigMetadataItemCount:
1568            case OMX_IndexConfigContainerNodeCount:
1569            case OMX_IndexConfigMetadataItem:
1570            case OMX_IndexConfigCounterNodeID:
1571            case OMX_IndexParamMetadataFilterType:
1572            case OMX_IndexConfigCommonTransitionEffect:
1573            case OMX_IndexKhronosExtensions:
1574#else
1575            case OMX_IndexConfigMetaDataSize:
1576            case OMX_IndexConfigMetaDataAtIndex:
1577            case OMX_IndexConfigMetaDataAtKey:
1578            case OMX_IndexConfigMetaDataNodeCount:
1579            case OMX_IndexConfigMetaDataNode:
1580            case OMX_IndexConfigMetaDataItemCount:
1581#endif
1582        case OMX_IndexParamMetadataKeyFilter:
1583        case OMX_IndexConfigPriorityMgmt:
1584        case OMX_IndexConfigAudioChannelVolume:
1585        case OMX_IndexConfigFlashControl:
1586        case OMX_IndexParamVideoProfileLevelQuerySupported:
1587           break;
1588        case OMX_IndexParamVideoProfileLevelCurrent:
1589        {
1590           VIDEO_PROFILE_LEVEL_TYPE* pProfileLevel = NULL;
1591           OMX_VIDEO_PARAM_PROFILELEVELTYPE *pParamProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pCompParam;
1592
1593           /* Choose table based on compression format */
1594           switch(pComponentPrivate->pInPortDef->format.video.eCompressionFormat)
1595           {
1596              case OMX_VIDEO_CodingH263:
1597                 pProfileLevel = SupportedH263ProfileLevels;
1598                 break;
1599              case OMX_VIDEO_CodingMPEG4:
1600                 pProfileLevel = SupportedMPEG4ProfileLevels;
1601                 break;
1602              case OMX_VIDEO_CodingAVC:
1603                 pProfileLevel = SupportedAVCProfileLevels;
1604                 break;
1605             default:
1606                 return OMX_ErrorBadParameter;
1607            }
1608
1609            /* Check validity of profile & level parameters */
1610            while((pProfileLevel->nProfile != (OMX_S32)pParamProfileLevel->eProfile) ||
1611                 (pProfileLevel->nLevel != (OMX_S32)pParamProfileLevel->eLevel)) {
1612               pProfileLevel++;
1613               if(pProfileLevel->nProfile == -1) break;
1614             }
1615
1616            if(pProfileLevel->nProfile != -1) {
1617            /* Update profile & level values in the compression format specific structure */
1618               switch(pComponentPrivate->pInPortDef->format.video.eCompressionFormat) {
1619                  case OMX_VIDEO_CodingH263:
1620                     pComponentPrivate->pH263->eProfile = pParamProfileLevel->eProfile;
1621                     pComponentPrivate->pH263->eLevel = pParamProfileLevel->eLevel;
1622                     break;
1623                  case OMX_VIDEO_CodingMPEG4:
1624                     pComponentPrivate->pMpeg4->eProfile = pParamProfileLevel->eProfile;
1625                     pComponentPrivate->pMpeg4->eLevel = pParamProfileLevel->eLevel;
1626                     break;
1627                  case OMX_VIDEO_CodingAVC:
1628                     pComponentPrivate->pH264->eProfile = pParamProfileLevel->eProfile;
1629                     pComponentPrivate->pH264->eLevel = pParamProfileLevel->eLevel;
1630                 default:
1631                     return OMX_ErrorBadParameter;
1632               }
1633               eError = OMX_ErrorNone;
1634            }
1635            else {
1636               eError = OMX_ErrorBadParameter;
1637            }
1638            break;
1639            }
1640
1641        case OMX_IndexConfigVideoBitrate:
1642        case OMX_IndexConfigVideoFramerate:
1643        case OMX_IndexConfigVideoIntraVOPRefresh:
1644        case OMX_IndexConfigVideoIntraMBRefresh:
1645        case OMX_IndexConfigVideoMacroBlockErrorMap:
1646        case OMX_IndexParamVideoSliceFMO:
1647        case OMX_IndexConfigVideoAVCIntraPeriod:
1648        case OMX_IndexConfigVideoNalSize:
1649        case OMX_IndexConfigCommonExposureValue:
1650        case OMX_IndexConfigCommonOutputSize:
1651        case OMX_IndexParamCommonExtraQuantData:
1652        case OMX_IndexConfigCommonFocusRegion:
1653        case OMX_IndexConfigCommonFocusStatus:
1654        case OMX_IndexParamContentURI:
1655        case OMX_IndexConfigCaptureMode:
1656        case OMX_IndexConfigCapturing:
1657#endif
1658        default:
1659            eError = OMX_ErrorUnsupportedIndex;
1660            break;
1661    }
1662EXIT:
1663    return eError;
1664}
1665
1666/*----------------------------------------------------------------------------*/
1667/**
1668  *  VIDDEC_GetConfig() Sets application callbacks to the component
1669  *
1670  * This method will update application callbacks
1671  * the application.
1672  *
1673  * @param pComp         handle for this instance of the component
1674  * @param pCallBacks    application callbacks
1675  * @param ptr
1676  *
1677  * @retval OMX_NoError              Success, ready to roll
1678  *         OMX_Error_BadParameter   The input parameter pointer is null
1679  **/
1680/*----------------------------------------------------------------------------*/
1681
1682static OMX_ERRORTYPE VIDDEC_GetConfig (OMX_HANDLETYPE hComp,
1683                                       OMX_INDEXTYPE nConfigIndex,
1684                                       OMX_PTR ComponentConfigStructure)
1685{
1686    OMX_ERRORTYPE eError = OMX_ErrorNone;
1687    OMX_COMPONENTTYPE* pHandle = NULL;
1688    VIDDEC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
1689
1690    OMX_CONF_CHECK_CMD(hComp, ComponentConfigStructure, OMX_TRUE);
1691
1692    pHandle = (OMX_COMPONENTTYPE*)hComp;
1693    pComponentPrivate = (VIDDEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
1694
1695    if (pComponentPrivate->eState == OMX_StateInvalid) {
1696        OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorIncorrectStateOperation);
1697    }
1698    else {
1699        switch ((OMX_S32) nConfigIndex)
1700        {
1701            case OMX_IndexParamPortDefinition:
1702                {
1703                    OMX_PARAM_PORTDEFINITIONTYPE *pPortDefParam = (OMX_PARAM_PORTDEFINITIONTYPE *)ComponentConfigStructure;
1704                    if (((OMX_PARAM_PORTDEFINITIONTYPE*)(ComponentConfigStructure))->nPortIndex ==
1705                            pComponentPrivate->pInPortDef->nPortIndex) {
1706                        OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = pComponentPrivate->pInPortDef;
1707                        memcpy(pPortDefParam, pPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1708                    }
1709                    else if (((OMX_PARAM_PORTDEFINITIONTYPE*)(ComponentConfigStructure))->nPortIndex ==
1710                            pComponentPrivate->pOutPortDef->nPortIndex) {
1711                        OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = pComponentPrivate->pOutPortDef;
1712                        memcpy(pPortDefParam, pPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1713                    }
1714                    else {
1715                        eError = OMX_ErrorBadPortIndex;
1716                    }
1717                }
1718                break;
1719            case VideoDecodeCustomConfigDebug:/**< reference: struct OMX_TI_Debug */
1720                OMX_DBG_GETCONFIG(pComponentPrivate->dbg, ComponentConfigStructure);
1721                break;
1722#ifdef KHRONOS_1_1
1723            case OMX_IndexConfigVideoMBErrorReporting:/**< reference: OMX_CONFIG_MBERRORREPORTINGTYPE */
1724            {
1725                if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 ||
1726                    pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263 ||
1727                    pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
1728                    OMX_CONFIG_MBERRORREPORTINGTYPE* pMBErrorReportTo = ComponentConfigStructure;
1729                    /*OMX_CONF_CHK_VERSION( pMBErrorReportTo, OMX_CONFIG_MBERRORREPORTINGTYPE, eError, pComponentPrivate->dbg);*/
1730                    pMBErrorReportTo->bEnabled = pComponentPrivate->eMBErrorReport.bEnabled;
1731                }
1732                else {
1733                    eError = OMX_ErrorUnsupportedIndex;
1734                }
1735                break;
1736            }
1737            case OMX_IndexConfigVideoMacroBlockErrorMap: /**< reference: OMX_CONFIG_MACROBLOCKERRORMAPTYPE */
1738            {
1739                if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 ||
1740                    pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263 ||
1741                    pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
1742                    OMX_CONFIG_MACROBLOCKERRORMAPTYPE_TI* pMBErrorMapTypeFrom = &pComponentPrivate->eMBErrorMapType[pComponentPrivate->cMBErrorIndexOut];
1743                    OMX_CONFIG_MACROBLOCKERRORMAPTYPE_TI* pMBErrorMapTypeTo = ComponentConfigStructure;
1744                    OMX_U8* ErrMapFrom = pMBErrorMapTypeFrom->ErrMap;
1745                    OMX_U8* ErrMapTo = pMBErrorMapTypeTo->ErrMap;
1746                    /*OMX_CONF_CHK_VERSION( pRole, OMX_CONFIG_MBERRORREPORTINGTYPE, eError, pComponentPrivate->dbg);*/
1747                    pMBErrorMapTypeTo->nErrMapSize = pMBErrorMapTypeFrom->nErrMapSize;
1748                    memcpy(ErrMapTo, ErrMapFrom, pMBErrorMapTypeFrom->nErrMapSize);
1749                    pComponentPrivate->cMBErrorIndexOut++;
1750                    pComponentPrivate->cMBErrorIndexOut %= pComponentPrivate->pOutPortDef->nBufferCountActual;
1751                }
1752                else {
1753                    eError = OMX_ErrorUnsupportedIndex;
1754                }
1755                break;
1756            }
1757            case OMX_IndexParamVideoMacroblocksPerFrame:/**< reference: OMX_PARAM_MACROBLOCKSTYPE */
1758            {
1759                if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 ||
1760                    pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263 ||
1761                    pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
1762                    OMX_PARAM_MACROBLOCKSTYPE* pMBBlocksTypeTo = ComponentConfigStructure;
1763                    /*OMX_CONF_CHK_VERSION( pMBBlocksTypeTo, OMX_PARAM_MACROBLOCKSTYPE, eError, pComponentPrivate->dbg);*/
1764                    pMBBlocksTypeTo->nMacroblocks = pComponentPrivate->pOutPortDef->format.video.nFrameWidth *
1765                                                    pComponentPrivate->pOutPortDef->format.video.nFrameHeight / 256;
1766                }
1767                else {
1768                    eError = OMX_ErrorUnsupportedIndex;
1769                }
1770                break;
1771            }
1772            case OMX_IndexParamNumAvailableStreams:
1773            case OMX_IndexParamActiveStream:
1774            case OMX_IndexParamSuspensionPolicy:
1775            case OMX_IndexParamComponentSuspended:
1776            case OMX_IndexAutoPauseAfterCapture:
1777            case OMX_IndexParamCustomContentPipe:
1778            case OMX_IndexParamDisableResourceConcealment:
1779#ifdef KHRONOS_1_2
1780            case OMX_IndexConfigMetadataItemCount:
1781            case OMX_IndexConfigContainerNodeCount:
1782            case OMX_IndexConfigMetadataItem:
1783            case OMX_IndexConfigCounterNodeID:
1784            case OMX_IndexParamMetadataFilterType:
1785            case OMX_IndexConfigCommonTransitionEffect:
1786            case OMX_IndexKhronosExtensions:
1787#else
1788            case OMX_IndexConfigMetaDataSize:
1789            case OMX_IndexConfigMetaDataAtIndex:
1790            case OMX_IndexConfigMetaDataAtKey:
1791            case OMX_IndexConfigMetaDataNodeCount:
1792            case OMX_IndexConfigMetaDataNode:
1793            case OMX_IndexConfigMetaDataItemCount:
1794#endif
1795            case OMX_IndexParamMetadataKeyFilter:
1796            case OMX_IndexConfigPriorityMgmt:
1797            case OMX_IndexParamStandardComponentRole:
1798            case OMX_IndexConfigAudioChannelVolume:
1799            case OMX_IndexConfigFlashControl:
1800            case OMX_IndexParamVideoProfileLevelQuerySupported:
1801            case OMX_IndexParamVideoProfileLevelCurrent:
1802            case OMX_IndexConfigVideoBitrate:
1803            case OMX_IndexConfigVideoFramerate:
1804            case OMX_IndexConfigVideoIntraVOPRefresh:
1805            case OMX_IndexConfigVideoIntraMBRefresh:
1806            case OMX_IndexParamVideoSliceFMO:
1807            case OMX_IndexConfigVideoAVCIntraPeriod:
1808            case OMX_IndexConfigVideoNalSize:
1809            case OMX_IndexConfigCommonExposureValue:
1810            case OMX_IndexConfigCommonOutputSize:
1811            case OMX_IndexParamCommonExtraQuantData:
1812            case OMX_IndexConfigCommonFocusRegion:
1813            case OMX_IndexConfigCommonFocusStatus:
1814            case OMX_IndexParamContentURI:
1815            case OMX_IndexConfigCaptureMode:
1816            case OMX_IndexConfigCapturing:
1817#endif
1818            case OMX_IndexComponentStartUnused:
1819            case OMX_IndexParamPriorityMgmt:    /**< reference: OMX_PRIORITYMGMTTYPE */
1820            case OMX_IndexParamAudioInit:       /**< reference: OMX_PORT_PARAM_TYPE  */
1821            case OMX_IndexParamImageInit:       /**< reference: OMX_PORT_PARAM_TYPE  */
1822            case OMX_IndexParamVideoInit:       /**< reference: OMX_PORT_PARAM_TYPE  */
1823            case OMX_IndexParamOtherInit:       /**< reference: OMX_PORT_PARAM_TYPE  */
1824
1825            case OMX_IndexPortStartUnused:
1826            case OMX_IndexParamCompBufferSupplier: /**< reference: OMX_PARAM_BUFFERSUPPLIERTYPE (*/
1827            case OMX_IndexReservedStartUnused:
1828
1829            /* Audio parameters and configurations */
1830            case OMX_IndexAudioStartUnused:
1831            case OMX_IndexParamAudioPortFormat: /**< reference: OMX_AUDIO_PARAM_PORTFORMATTYPE */
1832            case OMX_IndexParamAudioPcm:        /**< reference: OMX_AUDIO_PARAM_PCMMODETYPE */
1833            case OMX_IndexParamAudioAac:        /**< reference: OMX_AUDIO_PARAM_AACPROFILETYPE */
1834            case OMX_IndexParamAudioRa:         /**< reference: OMX_AUDIO_PARAM_RATYPE */
1835            case OMX_IndexParamAudioMp3:        /**< reference: OMX_AUDIO_PARAM_MP3TYPE */
1836            case OMX_IndexParamAudioAdpcm:      /**< reference: OMX_AUDIO_PARAM_ADPCMTYPE */
1837            case OMX_IndexParamAudioG723:       /**< reference: OMX_AUDIO_PARAM_G723TYPE */
1838            case OMX_IndexParamAudioG729:       /**< reference: OMX_AUDIO_PARAM_G729TYPE */
1839            case OMX_IndexParamAudioAmr:        /**< reference: OMX_AUDIO_PARAM_AMRTYPE */
1840            case OMX_IndexParamAudioWma:        /**< reference: OMX_AUDIO_PARAM_WMATYPE */
1841            case OMX_IndexParamAudioSbc:        /**< reference: OMX_AUDIO_PARAM_SBCTYPE */
1842            case OMX_IndexParamAudioMidi:       /**< reference: OMX_AUDIO_PARAM_MIDITYPE */
1843            case OMX_IndexParamAudioGsm_FR:     /**< reference: OMX_AUDIO_PARAM__GSMFRTYPE */
1844            case OMX_IndexParamAudioMidiLoadUserSound: /**< reference: OMX_AUDIO_PARAM_MIDILOADUSERSOUNDTYPE */
1845            case OMX_IndexParamAudioG726:       /**< reference: OMX_AUDIO_PARAM_G726TYPE */
1846            case OMX_IndexParamAudioGsm_EFR:    /**< reference: OMX_AUDIO_PARAM__GSMEFRTYPE */
1847            case OMX_IndexParamAudioGsm_HR:     /**< reference: OMX_AUDIO_PARAM__GSMHRTYPE */
1848            case OMX_IndexParamAudioPdc_FR:     /**< reference: OMX_AUDIO_PARAM__PDCFRTYPE */
1849            case OMX_IndexParamAudioPdc_EFR:    /**< reference: OMX_AUDIO_PARAM__PDCEFRTYPE */
1850            case OMX_IndexParamAudioPdc_HR:     /**< reference: OMX_AUDIO_PARAM__PDCHRTYPE */
1851            case OMX_IndexParamAudioTdma_FR:    /**< reference: OMX_AUDIO_PARAM__TDMAFRTYPE */
1852            case OMX_IndexParamAudioTdma_EFR:   /**< reference: OMX_AUDIO_PARAM__TDMAEFRTYPE */
1853            case OMX_IndexParamAudioQcelp8:     /**< reference: OMX_AUDIO_PARAM__QCELP8TYPE */
1854            case OMX_IndexParamAudioQcelp13:    /**< reference: OMX_AUDIO_PARAM__QCELP13TYPE */
1855            case OMX_IndexParamAudioEvrc:       /**< reference: OMX_AUDIO_PARAM__EVRCTYPE */
1856            case OMX_IndexParamAudioSmv:        /**< reference: OMX_AUDIO_PARAM__SMVTYPE */
1857            case OMX_IndexParamAudioVorbis:     /**< reference: OMX_AUDIO_PARAM__VORBISTYPE */
1858
1859            case OMX_IndexConfigAudioMidiImmediateEvent:   /**< OMX_AUDIO_CONFIG_MIDIIMMEDIATEEVENTTYPE */
1860            case OMX_IndexConfigAudioMidiControl:          /**< reference: OMX_AUDIO_CONFIG_MIDICONTROLTYPE */
1861            case OMX_IndexConfigAudioMidiSoundBankProgram: /**< reference: OMX_AUDIO_CONFIG_MIDISOUNDBANKPROGRAMTYPE */
1862            case OMX_IndexConfigAudioMidiStatus:           /**< reference: OMX_AUDIO_CONFIG_MIDISTATUSTYPE */
1863            case OMX_IndexConfigAudioMidiMetaEvent:        /**< reference: OMX_AUDIO_CONFIG_MIDIMETAEVENTTYPE */
1864            case OMX_IndexConfigAudioMidiMetaEventData:    /**< reference: OMX_AUDIO_CONFIG_MIDIMETAEVENTDATATYPE */
1865            case OMX_IndexConfigAudioVolume:               /**< reference: OMX_AUDIO_CONFIG_VOLUMETYPE */
1866            case OMX_IndexConfigAudioBalance:              /**< reference: OMX_AUDIO_CONFIG_BALANCETYPE */
1867            case OMX_IndexConfigAudioChannelMute:          /**< reference: OMX_AUDIO_CONFIG_CHANNELMUTETYPE */
1868            case OMX_IndexConfigAudioMute:                 /**< reference: OMX_AUDIO_CONFIG_MUTETYPE */
1869            case OMX_IndexConfigAudioLoudness:             /**< reference: OMX_AUDIO_CONFIG_LOUDNESSTYPE */
1870            case OMX_IndexConfigAudioEchoCancelation:      /**< reference: OMX_AUDIO_CONFIG_ECHOCANCELATIONTYPE */
1871            case OMX_IndexConfigAudioNoiseReduction:       /**< reference: OMX_AUDIO_CONFIG_NOISEREDUCTIONTYPE */
1872            case OMX_IndexConfigAudioBass:                 /**< reference: OMX_AUDIO_CONFIG_BASSTYPE */
1873            case OMX_IndexConfigAudioTreble:               /**< reference: OMX_AUDIO_CONFIG_TREBLETYPE */
1874            case OMX_IndexConfigAudioStereoWidening:       /**< reference: OMX_AUDIO_CONFIG_STEREOWIDENINGTYPE */
1875            case OMX_IndexConfigAudioChorus:               /**< reference: OMX_AUDIO_CONFIG_CHORUSTYPE */
1876            case OMX_IndexConfigAudioEqualizer:            /**< reference: OMX_AUDIO_CONFIG_EQUALIZERTYPE */
1877            case OMX_IndexConfigAudioReverberation:        /**< reference: OMX_AUDIO_CONFIG_REVERBERATIONTYPE */
1878
1879            /* Image specific parameters and configurations */
1880            case OMX_IndexImageStartUnused:
1881            case OMX_IndexParamImagePortFormat:   /**< reference: OMX_IMAGE_PARAM_PORTFORMATTYPE */
1882            case OMX_IndexParamFlashControl:      /**< refer to OMX_IMAGE_PARAM_FLASHCONTROLTYPE */
1883            case OMX_IndexConfigFocusControl:     /**< refer to OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE */
1884            case OMX_IndexParamQFactor:           /**< refer to OMX_IMAGE_PARAM_QFACTORTYPE */
1885            case OMX_IndexParamQuantizationTable: /**< refer to OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE */
1886            case OMX_IndexParamHuffmanTable:      /**< For jpeg, refer to OMX_IMAGE_PARAM_HUFFMANTTABLETYPE */
1887
1888            /* Video specific parameters and configurations */
1889            case OMX_IndexVideoStartUnused:
1890            case OMX_IndexParamVideoPortFormat:   /**< reference: OMX_VIDEO_PARAM_PORTFORMATTYPE */
1891            case OMX_IndexParamVideoQuantization: /**< reference: OMX_VIDEO_PARAM_QUANTIZATIONPARAMTYPE */
1892            case OMX_IndexParamVideoFastUpdate:   /**< reference: OMX_VIDEO_PARAM_VIDEOFASTUPDATETYPE */
1893            case OMX_IndexParamVideoBitrate:      /**< reference: OMX_VIDEO_PARAM_BITRATETYPE */
1894            case OMX_IndexParamVideoMotionVector: /**< reference: OMX_VIDEO_PARAM_MOTIONVECTORTYPE */
1895            case OMX_IndexParamVideoIntraRefresh: /**< reference: OMX_VIDEO_PARAM_INTRAREFRESHTYPE */
1896            case OMX_IndexParamVideoErrorCorrection: /**< reference: OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE */
1897            case OMX_IndexParamVideoVBSMC: /**< reference:OMX_VIDEO_PARAM_VBSMCTYPE */
1898            case OMX_IndexParamVideoMpeg2: /**< reference:OMX_VIDEO_PARAM_MPEG2TYPE */
1899            case OMX_IndexParamVideoMpeg4: /**< reference: OMX_VIDEO_CONFIG_MPEG4TYPE */
1900            case OMX_IndexParamVideoWmv:   /**< reference:OMX_VIDEO_PARAM_WMVTYPE */
1901            case OMX_IndexParamVideoRv:    /**< reference:OMX_VIDEO_PARAM_RVTYPE */
1902            case OMX_IndexParamVideoAvc:   /**< reference:OMX_VIDEO_PARAM_AVCTYPE */
1903            case OMX_IndexParamVideoH263:  /**< reference:OMX_VIDEO_PARAM_H263TYPE */
1904
1905            /* Image & Video common Configurations */
1906            case OMX_IndexCommonStartUnused:
1907            case OMX_IndexParamCommonDeblocking: /**< reference: OMX_PARAM_DEBLOCKINGTYPE */
1908            case OMX_IndexParamCommonSensorMode: /**< reference: OMX_PARAM_SENSORMODETYPE */
1909            case OMX_IndexParamCommonInterleave: /** reference: OMX_PARAM_INTERLEAVETYPE */
1910            case OMX_IndexConfigCommonColorFormatConversion: /**< reference: OMX_CONFIG_COLORCONVERSIONTYPE */
1911            case OMX_IndexConfigCommonScale:            /**< reference: OMX_CONFIG_SCALEFACTORTYPE */
1912            case OMX_IndexConfigCommonImageFilter:      /**< reference: OMX_CONFIG_IMAGEFILTERTYPE */
1913            case OMX_IndexConfigCommonColorEnhancement: /**< reference: OMX_CONFIG_COLORENHANCEMENTTYPE */
1914            case OMX_IndexConfigCommonColorKey:         /**< reference: OMX_CONFIG_COLORKEYTYPE */
1915            case OMX_IndexConfigCommonColorBlend:       /**< reference: OMX_CONFIG_COLORBLENDTYPE */
1916            case OMX_IndexConfigCommonFrameStabilisation: /**< reference: OMX_CONFIG_FRAMESTABTYPE */
1917            case OMX_IndexConfigCommonRotate:         /**< reference: OMX_CONFIG_ROTATIONTYPE */
1918            case OMX_IndexConfigCommonMirror:         /**< reference: OMX_CONFIG_MIRRORTYPE */
1919            case OMX_IndexConfigCommonOutputPosition: /**< reference: OMX_CONFIG_POINTTYPE */
1920            case OMX_IndexConfigCommonInputCrop:      /**< reference: OMX_CONFIG_RECTTYPE */
1921            case OMX_IndexConfigCommonOutputCrop:     /**< reference: OMX_CONFIG_RECTTYPE */
1922            case OMX_IndexConfigCommonDigitalZoom:    /**< reference: OMX_SCALEFACTORTYPE */
1923            case OMX_IndexConfigCommonOpticalZoom:    /**< reference: OMX_SCALEFACTORTYPE*/
1924            case OMX_IndexConfigCommonWhiteBalance:   /**< reference: OMX_CONFIG_WHITEBALCONTROLTYPE */
1925            case OMX_IndexConfigCommonExposure:       /**< reference: OMX_CONFIG_EXPOSURECONTROLTYPE */
1926            case OMX_IndexConfigCommonContrast:       /**< reference to OMX_CONFIG_CONTRASTTYPE */
1927            case OMX_IndexConfigCommonBrightness:     /**< reference to OMX_CONFIG_BRIGHTNESSTYPE */
1928            case OMX_IndexConfigCommonBacklight:      /**< reference to OMX_CONFIG_BACKLIGHTTYPE */
1929            case OMX_IndexConfigCommonGamma:          /**< reference to OMX_CONFIG_GAMMATYPE */
1930            case OMX_IndexConfigCommonSaturation:     /**< reference to OMX_CONFIG_SATURATIONTYPE */
1931            case OMX_IndexConfigCommonLightness:      /**< reference to OMX_CONFIG_LIGHTNESSTYPE */
1932            case OMX_IndexConfigCommonExclusionRect:  /** reference: OMX_CONFIG_RECTTYPE */
1933            case OMX_IndexConfigCommonDithering:      /**< reference: OMX_TIME_CONFIG_DITHERTYPE */
1934            case OMX_IndexConfigCommonPlaneBlend:     /** reference: OMX_CONFIG_PLANEBLENDTYPE */
1935
1936            /* Reserved Configuration range */
1937            case OMX_IndexOtherStartUnused:
1938            case OMX_IndexParamOtherPortFormat: /**< reference: OMX_OTHER_PARAM_PORTFORMATTYPE */
1939            case OMX_IndexConfigOtherPower:     /**< reference: OMX_OTHER_CONFIG_POWERTYPE */
1940            case OMX_IndexConfigOtherStats:     /**< reference: OMX_OTHER_CONFIG_STATSTYPE */
1941
1942            /* Reserved Time range */
1943            case OMX_IndexTimeStartUnused:
1944            case OMX_IndexConfigTimeScale:      /**< reference: OMX_TIME_CONFIG_SCALETYPE */
1945            case OMX_IndexConfigTimeClockState: /**< reference: OMX_TIME_CONFIG_CLOCKSTATETYPE */
1946            case OMX_IndexConfigTimeActiveRefClock:   /**< reference: OMX_TIME_CONFIG_ACTIVEREFCLOCKTYPE */
1947            case OMX_IndexConfigTimeCurrentMediaTime: /**< reference: OMX_TIME_CONFIG_TIMESTAMPTYPE (read only)*/
1948            case OMX_IndexConfigTimeCurrentWallTime:  /**< reference: OMX_TIME_CONFIG_TIMESTAMPTYPE (read only)*/
1949            case OMX_IndexConfigTimeCurrentAudioReference: /**< reference: OMX_TIME_CONFIG_TIMESTAMPTYPE (write only) */
1950            case OMX_IndexConfigTimeCurrentVideoReference: /**< reference: OMX_TIME_CONFIG_TIMESTAMPTYPE (write only) */
1951            case OMX_IndexConfigTimeMediaTimeRequest:      /**< reference: OMX_TIME_CONFIG_MEDIATIMEREQUESTTYPE (write only) */
1952            case OMX_IndexConfigTimeClientStartTime:       /**<reference:  OMX_TIME_CONFIG_TIMESTAMPTYPE (write only) */
1953            case OMX_IndexConfigTimePosition:              /**< reference: OMX_TIME_CONFIG_TIMESTAMPTYPE */
1954            case OMX_IndexConfigTimeSeekMode:              /**< reference: OMX_TIME_CONFIG_SEEKMODETYPE */
1955
1956            /* Vendor specific area */
1957#ifdef KHRONOS_1_2
1958            case OMX_IndexVendorStartUnused:
1959#else
1960            case OMX_IndexIndexVendorStartUnused:
1961#endif
1962            /* Vendor specific structures should be in the range of 0xFF000000
1963               to 0xFFFFFFFF.  This range is not broken out by vendor, so
1964               private indexes are not guaranteed unique and therefore should
1965               only be sent to the appropriate component. */
1966
1967            case OMX_IndexMax:
1968                eError = OMX_ErrorUnsupportedIndex;
1969            break;
1970        }
1971    }
1972EXIT:
1973    return eError;
1974}
1975/*----------------------------------------------------------------------------*/
1976/**
1977  *  VIDDEC_SetConfig() Sets application callbacks to the component
1978  *
1979  * This method will update application callbacks
1980  * the application.
1981  *
1982  * @param pComp         handle for this instance of the component
1983  * @param pCallBacks    application callbacks
1984  * @param ptr
1985  *
1986  * @retval OMX_NoError              Success, ready to roll
1987  *         OMX_Error_BadParameter   The input parameter pointer is null
1988  **/
1989/*----------------------------------------------------------------------------*/
1990
1991static OMX_ERRORTYPE VIDDEC_SetConfig (OMX_HANDLETYPE hComp,
1992                                       OMX_INDEXTYPE nConfigIndex,
1993                                       OMX_PTR ComponentConfigStructure)
1994{
1995    OMX_ERRORTYPE eError = OMX_ErrorNone;
1996    OMX_PARAM_PORTDEFINITIONTYPE* pComponentConfig = NULL;
1997    OMX_COMPONENTTYPE* pHandle = NULL;
1998    VIDDEC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
1999    OMX_S32 nConfigIndexTemp = 0;
2000
2001    OMX_CONF_CHECK_CMD(hComp, ComponentConfigStructure, OMX_TRUE);
2002
2003    pComponentConfig = (OMX_PARAM_PORTDEFINITIONTYPE*)ComponentConfigStructure;
2004    pHandle = (OMX_COMPONENTTYPE*)hComp;
2005    pComponentPrivate = (VIDDEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
2006
2007    if (pComponentPrivate->eState == OMX_StateInvalid) {
2008        eError = OMX_ErrorInvalidState;
2009        OMX_PRSTATE4(pComponentPrivate->dbg, "state invalid for SetConfig...............\n");
2010        goto EXIT;
2011    }
2012    else {
2013        nConfigIndexTemp = nConfigIndex;
2014        switch (nConfigIndexTemp) {
2015            case OMX_IndexParamPortDefinition:
2016            {
2017                OMX_PARAM_PORTDEFINITIONTYPE* pPortDef = NULL;
2018                if (pComponentConfig->nPortIndex == VIDDEC_INPUT_PORT) {
2019                    OMX_MALLOC_STRUCT(pPortDef, OMX_PARAM_PORTDEFINITIONTYPE,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel4]);
2020                    if (pPortDef == NULL) {
2021                        OMX_TRACE4(pComponentPrivate->dbg, "malloc failed\n");
2022                        eError = OMX_ErrorInsufficientResources;
2023                        goto EXIT;
2024                    }
2025                    ((VIDDEC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate)->pPortDef[VIDDEC_INPUT_PORT] = pPortDef;
2026                    memcpy(pPortDef, pComponentConfig, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
2027                    free(pPortDef);
2028                }
2029                else if (pComponentConfig->nPortIndex == VIDDEC_OUTPUT_PORT) {
2030                    OMX_MALLOC_STRUCT(pPortDef, OMX_PARAM_PORTDEFINITIONTYPE,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel4]);
2031                    if (pPortDef == NULL) {
2032                        OMX_TRACE4(pComponentPrivate->dbg, "malloc failed\n");
2033                        eError = OMX_ErrorInsufficientResources;
2034                        goto EXIT;
2035                    }
2036                    ((VIDDEC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate)->pPortDef[VIDDEC_OUTPUT_PORT] = pPortDef;
2037                    memcpy(pPortDef, pComponentConfig, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
2038                    free(pPortDef);
2039                }
2040                break;
2041            }
2042            case VideoDecodeCustomConfigDebug:/**< reference: struct OMX_TI_Debug */
2043                OMX_DBG_SETCONFIG(pComponentPrivate->dbg, ComponentConfigStructure);
2044                break;
2045#ifdef KHRONOS_1_1
2046            case OMX_IndexConfigVideoMBErrorReporting:/**< reference: OMX_CONFIG_MBERRORREPORTINGTYPE */
2047            {
2048                if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 ||
2049                    pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263 ||
2050                    pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
2051                    OMX_CONFIG_MBERRORREPORTINGTYPE* pMBErrorReportFrom = ComponentConfigStructure;
2052                    /*OMX_CONF_CHK_VERSION( pMBErrorReportFrom, OMX_CONFIG_MBERRORREPORTINGTYPE, eError, pComponentPrivate->dbg);*/
2053                    pComponentPrivate->eMBErrorReport.bEnabled = pMBErrorReportFrom->bEnabled;
2054                }
2055                else {
2056                    eError = OMX_ErrorUnsupportedIndex;
2057                }
2058                break;
2059            }
2060            case OMX_IndexParamVideoMacroblocksPerFrame:
2061            case OMX_IndexParamNumAvailableStreams:
2062            case OMX_IndexParamActiveStream:
2063            case OMX_IndexParamSuspensionPolicy:
2064            case OMX_IndexParamComponentSuspended:
2065            case OMX_IndexAutoPauseAfterCapture:
2066            case OMX_IndexParamCustomContentPipe:
2067            case OMX_IndexParamDisableResourceConcealment:
2068#ifdef KHRONOS_1_2
2069            case OMX_IndexConfigMetadataItemCount:
2070            case OMX_IndexConfigContainerNodeCount:
2071            case OMX_IndexConfigMetadataItem:
2072            case OMX_IndexConfigCounterNodeID:
2073            case OMX_IndexParamMetadataFilterType:
2074            case OMX_IndexConfigCommonTransitionEffect:
2075            case OMX_IndexKhronosExtensions:
2076#else
2077            case OMX_IndexConfigMetaDataSize:
2078            case OMX_IndexConfigMetaDataAtIndex:
2079            case OMX_IndexConfigMetaDataAtKey:
2080            case OMX_IndexConfigMetaDataNodeCount:
2081            case OMX_IndexConfigMetaDataNode:
2082            case OMX_IndexConfigMetaDataItemCount:
2083#endif
2084            case OMX_IndexParamMetadataKeyFilter:
2085            case OMX_IndexConfigPriorityMgmt:
2086            case OMX_IndexParamStandardComponentRole:
2087            case OMX_IndexConfigAudioChannelVolume:
2088            case OMX_IndexConfigFlashControl:
2089            case OMX_IndexParamVideoProfileLevelQuerySupported:
2090            case OMX_IndexParamVideoProfileLevelCurrent:
2091            case OMX_IndexConfigVideoBitrate:
2092            case OMX_IndexConfigVideoFramerate:
2093            case OMX_IndexConfigVideoIntraVOPRefresh:
2094            case OMX_IndexConfigVideoIntraMBRefresh:
2095            case OMX_IndexParamVideoSliceFMO:
2096            case OMX_IndexConfigVideoAVCIntraPeriod:
2097            case OMX_IndexConfigVideoNalSize:
2098            case OMX_IndexConfigVideoMacroBlockErrorMap:
2099            case OMX_IndexConfigCommonExposureValue:
2100            case OMX_IndexConfigCommonOutputSize:
2101            case OMX_IndexParamCommonExtraQuantData:
2102            case OMX_IndexConfigCommonFocusRegion:
2103            case OMX_IndexConfigCommonFocusStatus:
2104            case OMX_IndexParamContentURI:
2105            case OMX_IndexConfigCaptureMode:
2106            case OMX_IndexConfigCapturing:
2107#endif
2108            case OMX_IndexComponentStartUnused:
2109            case OMX_IndexParamPriorityMgmt:    /**< reference: OMX_PRIORITYMGMTTYPE */
2110            case OMX_IndexParamAudioInit:       /**< reference: OMX_PORT_PARAM_TYPE  */
2111            case OMX_IndexParamImageInit:       /**< reference: OMX_PORT_PARAM_TYPE  */
2112            case OMX_IndexParamVideoInit:       /**< reference: OMX_PORT_PARAM_TYPE  */
2113            case OMX_IndexParamOtherInit:       /**< reference: OMX_PORT_PARAM_TYPE  */
2114
2115            case OMX_IndexPortStartUnused:
2116            case OMX_IndexParamCompBufferSupplier: /**< reference: OMX_PARAM_BUFFERSUPPLIERTYPE (*/
2117            case OMX_IndexReservedStartUnused:
2118
2119            /* Audio parameters and configurations */
2120            case OMX_IndexAudioStartUnused:
2121            case OMX_IndexParamAudioPortFormat: /**< reference: OMX_AUDIO_PARAM_PORTFORMATTYPE */
2122            case OMX_IndexParamAudioPcm:        /**< reference: OMX_AUDIO_PARAM_PCMMODETYPE */
2123            case OMX_IndexParamAudioAac:        /**< reference: OMX_AUDIO_PARAM_AACPROFILETYPE */
2124            case OMX_IndexParamAudioRa:         /**< reference: OMX_AUDIO_PARAM_RATYPE */
2125            case OMX_IndexParamAudioMp3:        /**< reference: OMX_AUDIO_PARAM_MP3TYPE */
2126            case OMX_IndexParamAudioAdpcm:      /**< reference: OMX_AUDIO_PARAM_ADPCMTYPE */
2127            case OMX_IndexParamAudioG723:       /**< reference: OMX_AUDIO_PARAM_G723TYPE */
2128            case OMX_IndexParamAudioG729:       /**< reference: OMX_AUDIO_PARAM_G729TYPE */
2129            case OMX_IndexParamAudioAmr:        /**< reference: OMX_AUDIO_PARAM_AMRTYPE */
2130            case OMX_IndexParamAudioWma:        /**< reference: OMX_AUDIO_PARAM_WMATYPE */
2131            case OMX_IndexParamAudioSbc:        /**< reference: OMX_AUDIO_PARAM_SBCTYPE */
2132            case OMX_IndexParamAudioMidi:       /**< reference: OMX_AUDIO_PARAM_MIDITYPE */
2133            case OMX_IndexParamAudioGsm_FR:     /**< reference: OMX_AUDIO_PARAM__GSMFRTYPE */
2134            case OMX_IndexParamAudioMidiLoadUserSound: /**< reference: OMX_AUDIO_PARAM_MIDILOADUSERSOUNDTYPE */
2135            case OMX_IndexParamAudioG726:       /**< reference: OMX_AUDIO_PARAM_G726TYPE */
2136            case OMX_IndexParamAudioGsm_EFR:    /**< reference: OMX_AUDIO_PARAM__GSMEFRTYPE */
2137            case OMX_IndexParamAudioGsm_HR:     /**< reference: OMX_AUDIO_PARAM__GSMHRTYPE */
2138            case OMX_IndexParamAudioPdc_FR:     /**< reference: OMX_AUDIO_PARAM__PDCFRTYPE */
2139            case OMX_IndexParamAudioPdc_EFR:    /**< reference: OMX_AUDIO_PARAM__PDCEFRTYPE */
2140            case OMX_IndexParamAudioPdc_HR:     /**< reference: OMX_AUDIO_PARAM__PDCHRTYPE */
2141            case OMX_IndexParamAudioTdma_FR:    /**< reference: OMX_AUDIO_PARAM__TDMAFRTYPE */
2142            case OMX_IndexParamAudioTdma_EFR:   /**< reference: OMX_AUDIO_PARAM__TDMAEFRTYPE */
2143            case OMX_IndexParamAudioQcelp8:     /**< reference: OMX_AUDIO_PARAM__QCELP8TYPE */
2144            case OMX_IndexParamAudioQcelp13:    /**< reference: OMX_AUDIO_PARAM__QCELP13TYPE */
2145            case OMX_IndexParamAudioEvrc:       /**< reference: OMX_AUDIO_PARAM__EVRCTYPE */
2146            case OMX_IndexParamAudioSmv:        /**< reference: OMX_AUDIO_PARAM__SMVTYPE */
2147            case OMX_IndexParamAudioVorbis:     /**< reference: OMX_AUDIO_PARAM__VORBISTYPE */
2148
2149            case OMX_IndexConfigAudioMidiImmediateEvent:   /**< OMX_AUDIO_CONFIG_MIDIIMMEDIATEEVENTTYPE */
2150            case OMX_IndexConfigAudioMidiControl:          /**< reference: OMX_AUDIO_CONFIG_MIDICONTROLTYPE */
2151            case OMX_IndexConfigAudioMidiSoundBankProgram: /**< reference: OMX_AUDIO_CONFIG_MIDISOUNDBANKPROGRAMTYPE */
2152            case OMX_IndexConfigAudioMidiStatus:           /**< reference: OMX_AUDIO_CONFIG_MIDISTATUSTYPE */
2153            case OMX_IndexConfigAudioMidiMetaEvent:        /**< reference: OMX_AUDIO_CONFIG_MIDIMETAEVENTTYPE */
2154            case OMX_IndexConfigAudioMidiMetaEventData:    /**< reference: OMX_AUDIO_CONFIG_MIDIMETAEVENTDATATYPE */
2155            case OMX_IndexConfigAudioVolume:               /**< reference: OMX_AUDIO_CONFIG_VOLUMETYPE */
2156            case OMX_IndexConfigAudioBalance:              /**< reference: OMX_AUDIO_CONFIG_BALANCETYPE */
2157            case OMX_IndexConfigAudioChannelMute:          /**< reference: OMX_AUDIO_CONFIG_CHANNELMUTETYPE */
2158            case OMX_IndexConfigAudioMute:                 /**< reference: OMX_AUDIO_CONFIG_MUTETYPE */
2159            case OMX_IndexConfigAudioLoudness:             /**< reference: OMX_AUDIO_CONFIG_LOUDNESSTYPE */
2160            case OMX_IndexConfigAudioEchoCancelation:      /**< reference: OMX_AUDIO_CONFIG_ECHOCANCELATIONTYPE */
2161            case OMX_IndexConfigAudioNoiseReduction:       /**< reference: OMX_AUDIO_CONFIG_NOISEREDUCTIONTYPE */
2162            case OMX_IndexConfigAudioBass:                 /**< reference: OMX_AUDIO_CONFIG_BASSTYPE */
2163            case OMX_IndexConfigAudioTreble:               /**< reference: OMX_AUDIO_CONFIG_TREBLETYPE */
2164            case OMX_IndexConfigAudioStereoWidening:       /**< reference: OMX_AUDIO_CONFIG_STEREOWIDENINGTYPE */
2165            case OMX_IndexConfigAudioChorus:               /**< reference: OMX_AUDIO_CONFIG_CHORUSTYPE */
2166            case OMX_IndexConfigAudioEqualizer:            /**< reference: OMX_AUDIO_CONFIG_EQUALIZERTYPE */
2167            case OMX_IndexConfigAudioReverberation:        /**< reference: OMX_AUDIO_CONFIG_REVERBERATIONTYPE */
2168
2169            /* Image specific parameters and configurations */
2170            case OMX_IndexImageStartUnused:
2171            case OMX_IndexParamImagePortFormat:   /**< reference: OMX_IMAGE_PARAM_PORTFORMATTYPE */
2172            case OMX_IndexParamFlashControl:      /**< refer to OMX_IMAGE_PARAM_FLASHCONTROLTYPE */
2173            case OMX_IndexConfigFocusControl:     /**< refer to OMX_IMAGE_CONFIG_FOCUSCONTROLTYPE */
2174            case OMX_IndexParamQFactor:           /**< refer to OMX_IMAGE_PARAM_QFACTORTYPE */
2175            case OMX_IndexParamQuantizationTable: /**< refer to OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE */
2176            case OMX_IndexParamHuffmanTable:      /**< For jpeg, refer to OMX_IMAGE_PARAM_HUFFMANTTABLETYPE */
2177
2178            /* Video specific parameters and configurations */
2179            case OMX_IndexVideoStartUnused:
2180            case OMX_IndexParamVideoPortFormat:   /**< reference: OMX_VIDEO_PARAM_PORTFORMATTYPE */
2181            case OMX_IndexParamVideoQuantization: /**< reference: OMX_VIDEO_PARAM_QUANTIZATIONPARAMTYPE */
2182            case OMX_IndexParamVideoFastUpdate:   /**< reference: OMX_VIDEO_PARAM_VIDEOFASTUPDATETYPE */
2183            case OMX_IndexParamVideoBitrate:      /**< reference: OMX_VIDEO_PARAM_BITRATETYPE */
2184            case OMX_IndexParamVideoMotionVector: /**< reference: OMX_VIDEO_PARAM_MOTIONVECTORTYPE */
2185            case OMX_IndexParamVideoIntraRefresh: /**< reference: OMX_VIDEO_PARAM_INTRAREFRESHTYPE */
2186            case OMX_IndexParamVideoErrorCorrection: /**< reference: OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE */
2187            case OMX_IndexParamVideoVBSMC: /**< reference:OMX_VIDEO_PARAM_VBSMCTYPE */
2188            case OMX_IndexParamVideoMpeg2: /**< reference:OMX_VIDEO_PARAM_MPEG2TYPE */
2189            case OMX_IndexParamVideoMpeg4: /**< reference: OMX_VIDEO_CONFIG_MPEG4TYPE */
2190            case OMX_IndexParamVideoWmv:   /**< reference:OMX_VIDEO_PARAM_WMVTYPE */
2191            case OMX_IndexParamVideoRv:    /**< reference:OMX_VIDEO_PARAM_RVTYPE */
2192            case OMX_IndexParamVideoAvc:   /**< reference:OMX_VIDEO_PARAM_AVCTYPE */
2193            case OMX_IndexParamVideoH263:  /**< reference:OMX_VIDEO_PARAM_H263TYPE */
2194
2195            /* Image & Video common Configurations */
2196            case OMX_IndexCommonStartUnused:
2197            case OMX_IndexParamCommonDeblocking: /**< reference: OMX_PARAM_DEBLOCKINGTYPE */
2198            case OMX_IndexParamCommonSensorMode: /**< reference: OMX_PARAM_SENSORMODETYPE */
2199            case OMX_IndexParamCommonInterleave: /** reference: OMX_PARAM_INTERLEAVETYPE */
2200            case OMX_IndexConfigCommonColorFormatConversion: /**< reference: OMX_CONFIG_COLORCONVERSIONTYPE */
2201            case OMX_IndexConfigCommonScale:            /**< reference: OMX_CONFIG_SCALEFACTORTYPE */
2202            case OMX_IndexConfigCommonImageFilter:      /**< reference: OMX_CONFIG_IMAGEFILTERTYPE */
2203            case OMX_IndexConfigCommonColorEnhancement: /**< reference: OMX_CONFIG_COLORENHANCEMENTTYPE */
2204            case OMX_IndexConfigCommonColorKey:         /**< reference: OMX_CONFIG_COLORKEYTYPE */
2205            case OMX_IndexConfigCommonColorBlend:       /**< reference: OMX_CONFIG_COLORBLENDTYPE */
2206            case OMX_IndexConfigCommonFrameStabilisation: /**< reference: OMX_CONFIG_FRAMESTABTYPE */
2207            case OMX_IndexConfigCommonRotate:         /**< reference: OMX_CONFIG_ROTATIONTYPE */
2208            case OMX_IndexConfigCommonMirror:         /**< reference: OMX_CONFIG_MIRRORTYPE */
2209            case OMX_IndexConfigCommonOutputPosition: /**< reference: OMX_CONFIG_POINTTYPE */
2210            case OMX_IndexConfigCommonInputCrop:      /**< reference: OMX_CONFIG_RECTTYPE */
2211            case OMX_IndexConfigCommonOutputCrop:     /**< reference: OMX_CONFIG_RECTTYPE */
2212            case OMX_IndexConfigCommonDigitalZoom:    /**< reference: OMX_SCALEFACTORTYPE */
2213            case OMX_IndexConfigCommonOpticalZoom:    /**< reference: OMX_SCALEFACTORTYPE*/
2214            case OMX_IndexConfigCommonWhiteBalance:   /**< reference: OMX_CONFIG_WHITEBALCONTROLTYPE */
2215            case OMX_IndexConfigCommonExposure:       /**< reference: OMX_CONFIG_EXPOSURECONTROLTYPE */
2216            case OMX_IndexConfigCommonContrast:       /**< reference to OMX_CONFIG_CONTRASTTYPE */
2217            case OMX_IndexConfigCommonBrightness:     /**< reference to OMX_CONFIG_BRIGHTNESSTYPE */
2218            case OMX_IndexConfigCommonBacklight:      /**< reference to OMX_CONFIG_BACKLIGHTTYPE */
2219            case OMX_IndexConfigCommonGamma:          /**< reference to OMX_CONFIG_GAMMATYPE */
2220            case OMX_IndexConfigCommonSaturation:     /**< reference to OMX_CONFIG_SATURATIONTYPE */
2221            case OMX_IndexConfigCommonLightness:      /**< reference to OMX_CONFIG_LIGHTNESSTYPE */
2222            case OMX_IndexConfigCommonExclusionRect:  /** reference: OMX_CONFIG_RECTTYPE */
2223            case OMX_IndexConfigCommonDithering:      /**< reference: OMX_TIME_CONFIG_DITHERTYPE */
2224            case OMX_IndexConfigCommonPlaneBlend:     /** reference: OMX_CONFIG_PLANEBLENDTYPE */
2225
2226            /* Reserved Configuration range */
2227            case OMX_IndexOtherStartUnused:
2228            case OMX_IndexParamOtherPortFormat: /**< reference: OMX_OTHER_PARAM_PORTFORMATTYPE */
2229            case OMX_IndexConfigOtherPower:     /**< reference: OMX_OTHER_CONFIG_POWERTYPE */
2230            case OMX_IndexConfigOtherStats:     /**< reference: OMX_OTHER_CONFIG_STATSTYPE */
2231
2232            /* Reserved Time range */
2233            case OMX_IndexTimeStartUnused:
2234            case OMX_IndexConfigTimeScale:      /**< reference: OMX_TIME_CONFIG_SCALETYPE */
2235            case OMX_IndexConfigTimeClockState: /**< reference: OMX_TIME_CONFIG_CLOCKSTATETYPE */
2236            case OMX_IndexConfigTimeActiveRefClock:   /**< reference: OMX_TIME_CONFIG_ACTIVEREFCLOCKTYPE */
2237            case OMX_IndexConfigTimeCurrentMediaTime: /**< reference: OMX_TIME_CONFIG_TIMESTAMPTYPE (read only)*/
2238            case OMX_IndexConfigTimeCurrentWallTime:  /**< reference: OMX_TIME_CONFIG_TIMESTAMPTYPE (read only)*/
2239            case OMX_IndexConfigTimeCurrentAudioReference: /**< reference: OMX_TIME_CONFIG_TIMESTAMPTYPE (write only) */
2240            case OMX_IndexConfigTimeCurrentVideoReference: /**< reference: OMX_TIME_CONFIG_TIMESTAMPTYPE (write only) */
2241            case OMX_IndexConfigTimeMediaTimeRequest:      /**< reference: OMX_TIME_CONFIG_MEDIATIMEREQUESTTYPE (write only) */
2242            case OMX_IndexConfigTimeClientStartTime:       /**<reference:  OMX_TIME_CONFIG_TIMESTAMPTYPE (write only) */
2243            case OMX_IndexConfigTimePosition:              /**< reference: OMX_TIME_CONFIG_TIMESTAMPTYPE */
2244            case OMX_IndexConfigTimeSeekMode:              /**< reference: OMX_TIME_CONFIG_SEEKMODETYPE */
2245
2246            /* Vendor specific area */
2247#ifdef KHRONOS_1_2
2248            case OMX_IndexVendorStartUnused:
2249#else
2250            case OMX_IndexIndexVendorStartUnused:
2251#endif            /* Vendor specific structures should be in the range of 0xFF000000
2252               to 0xFFFFFFFF.  This range is not broken out by vendor, so
2253               private indexes are not guaranteed unique and therefore should
2254               only be sent to the appropriate component. */
2255
2256            case OMX_IndexMax:
2257                eError = OMX_ErrorUnsupportedIndex;
2258            break;
2259        }
2260    }
2261
2262EXIT:
2263    return eError;
2264}
2265
2266/*----------------------------------------------------------------------------*/
2267/**
2268  *  VIDDEC_GetState() Sets application callbacks to the component
2269  *
2270  * This method will update application callbacks
2271  * the application.
2272  *
2273  * @param pComp         handle for this instance of the component
2274  * @param pCallBacks    application callbacks
2275  * @param ptr
2276  *
2277  * @retval OMX_NoError              Success, ready to roll
2278  *         OMX_Error_BadParameter   The input parameter pointer is null
2279  **/
2280/*----------------------------------------------------------------------------*/
2281
2282static OMX_ERRORTYPE VIDDEC_GetState (OMX_HANDLETYPE hComponent,
2283                                      OMX_STATETYPE* pState)
2284{
2285    OMX_ERRORTYPE eError                        = OMX_ErrorNone;
2286    OMX_COMPONENTTYPE* pHandle = NULL;
2287
2288    VIDDEC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
2289    struct timespec abs_time = {0,0};
2290    int nPendingStateChangeRequests = 0;
2291    int ret = 0;
2292    /* Set to sufficiently high value */
2293    int mutex_timeout = 3;
2294
2295    if(hComponent == NULL || pState == NULL) {
2296        return OMX_ErrorBadParameter;
2297    }
2298
2299    pHandle = (OMX_COMPONENTTYPE*)hComponent;
2300    pComponentPrivate = (VIDDEC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate;
2301
2302    /* Retrieve current state */
2303    if (pHandle && pHandle->pComponentPrivate) {
2304        /* Check for any pending state transition requests */
2305        if(pthread_mutex_lock(&pComponentPrivate->mutexStateChangeRequest)) {
2306            return OMX_ErrorUndefined;
2307        }
2308        nPendingStateChangeRequests = pComponentPrivate->nPendingStateChangeRequests;
2309        if(!nPendingStateChangeRequests) {
2310           if(pthread_mutex_unlock(&pComponentPrivate->mutexStateChangeRequest)) {
2311               return OMX_ErrorUndefined;
2312           }
2313
2314           /* No pending state transitions */
2315          *pState = ((VIDDEC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate)->eState;
2316            eError = OMX_ErrorNone;
2317        }
2318        else {
2319                  /* Wait for component to complete state transition */
2320           clock_gettime(CLOCK_REALTIME, &abs_time);
2321           abs_time.tv_sec += mutex_timeout;
2322           abs_time.tv_nsec = 0;
2323          ret = pthread_cond_timedwait(&(pComponentPrivate->StateChangeCondition), &(pComponentPrivate->mutexStateChangeRequest), &abs_time);
2324           if (!ret) {
2325              /* Component has completed state transitions*/
2326              *pState = ((VIDDEC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate)->eState;
2327              if(pthread_mutex_unlock(&pComponentPrivate->mutexStateChangeRequest)) {
2328                  return OMX_ErrorUndefined;
2329              }
2330              eError = OMX_ErrorNone;
2331           }
2332           else if(ret == ETIMEDOUT) {
2333              /* Unlock mutex in case of timeout */
2334              OMX_ERROR4(pComponentPrivate->dbg, "VIDDEC_GetState timed out\n");
2335              pthread_mutex_unlock(&pComponentPrivate->mutexStateChangeRequest);
2336              *pState = OMX_StateInvalid;
2337              return OMX_ErrorNone;
2338           }
2339        }
2340     }
2341     else {
2342        eError = OMX_ErrorInvalidComponent;
2343        *pState = OMX_StateInvalid;
2344     }
2345
2346    return eError;
2347}
2348
2349/*----------------------------------------------------------------------------*/
2350/**
2351  *  VIDDEC_EmptyThisBuffer() Sets application callbacks to the component
2352  *
2353  * This method will update application callbacks
2354  * the application.
2355  *
2356  * @param pComp         handle for this instance of the component
2357  * @param pCallBacks    application callbacks
2358  * @param ptr
2359  *
2360  * @retval OMX_NoError              Success, ready to roll
2361  *         OMX_Error_BadParameter   The input parameter pointer is null
2362  **/
2363/*----------------------------------------------------------------------------*/
2364
2365static OMX_ERRORTYPE VIDDEC_EmptyThisBuffer (OMX_HANDLETYPE pComponent,
2366                                             OMX_BUFFERHEADERTYPE* pBuffHead)
2367{
2368    OMX_ERRORTYPE eError = OMX_ErrorNone;
2369    OMX_COMPONENTTYPE *pHandle = NULL;
2370    VIDDEC_COMPONENT_PRIVATE *pComponentPrivate = NULL;
2371    VIDDEC_BUFFER_PRIVATE* pBufferPrivate = NULL;
2372    OMX_S32 ret = 0;
2373
2374    OMX_CONF_CHECK_CMD(pComponent, OMX_TRUE, OMX_TRUE);
2375
2376    pHandle = (OMX_COMPONENTTYPE *)pComponent;
2377    pComponentPrivate = (VIDDEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
2378
2379    OMX_PRBUFFER1(pComponentPrivate->dbg, "+++Entering pHandle 0x%p pBuffer 0x%p Index %lu  state %x  nflags  %x  isfirst %x\n",pComponent,
2380            pBuffHead, pBuffHead->nInputPortIndex,pComponentPrivate->eState,pBuffHead->nFlags,pComponentPrivate->bFirstHeader);
2381
2382    OMX_BOOL bIsInputFlushPending = OMX_FALSE;
2383    VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->inputFlushCompletionMutex);
2384    bIsInputFlushPending = pComponentPrivate->bIsInputFlushPending;
2385    VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->inputFlushCompletionMutex);
2386    if (bIsInputFlushPending) {
2387        ALOGE("Unable to process any OMX_EmptyThisBuffer requsts with input flush pending");
2388        return OMX_ErrorIncorrectStateOperation;
2389    }
2390#ifdef __PERF_INSTRUMENTATION__
2391    PERF_ReceivedFrame(pComponentPrivate->pPERF,
2392                       pBuffHead->pBuffer,
2393                       pBuffHead->nFilledLen,
2394                       PERF_ModuleHLMM);
2395#endif
2396
2397    OMX_PRBUFFER1(pComponentPrivate->dbg, "pComponentPrivate->pInPortDef->bEnabled %d\n",
2398        pComponentPrivate->pInPortDef->bEnabled);
2399    if(!pComponentPrivate->pInPortDef->bEnabled)
2400        OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorIncorrectStateOperation);
2401
2402    if(pBuffHead->nInputPortIndex != VIDDEC_INPUT_PORT)
2403        OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorBadPortIndex);
2404
2405    if(pComponentPrivate->eState != OMX_StateExecuting &&
2406        pComponentPrivate->eState != OMX_StatePause &&
2407        pComponentPrivate->eState != OMX_StateIdle)
2408        OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorIncorrectStateOperation);
2409
2410    OMX_CONF_CHK_VERSION(pBuffHead, OMX_BUFFERHEADERTYPE, eError, pComponentPrivate->dbg);
2411
2412    if ((pComponentPrivate->bParserEnabled == OMX_FALSE) &&
2413        (pComponentPrivate->bFirstHeader == OMX_FALSE) &&
2414        (pBuffHead->nFilledLen > pBuffHead->nAllocLen)) {
2415        pBuffHead->nFilledLen = pBuffHead->nAllocLen;
2416    }
2417
2418    pBufferPrivate = (VIDDEC_BUFFER_PRIVATE* )pBuffHead->pInputPortPrivate;
2419    ret = pBufferPrivate->eBufferOwner;
2420    pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_COMPONENT;
2421    eError = IncrementCount (&(pComponentPrivate->nCountInputBFromApp), &(pComponentPrivate->mutexInputBFromApp));
2422    if (eError != OMX_ErrorNone) {
2423        return eError;
2424    }
2425
2426    OMX_PRBUFFER1(pComponentPrivate->dbg, "Writing pBuffer 0x%p OldeBufferOwner %ld nAllocLen %lu nFilledLen %lu eBufferOwner %d\n",
2427        pBuffHead, ret,pBuffHead->nAllocLen,pBuffHead->nFilledLen,pBufferPrivate->eBufferOwner);
2428
2429    ret = write (pComponentPrivate->filled_inpBuf_Q[VIDDEC_PIPE_WRITE], &(pBuffHead), sizeof(pBuffHead));
2430    if (ret == -1) {
2431        /*like function returns error buffer still with Client IL*/
2432        pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_CLIENT;
2433        OMX_PRCOMM4(pComponentPrivate->dbg, "Error in Writing to the Data pipe\n");
2434        DecrementCount (&(pComponentPrivate->nCountInputBFromApp), &(pComponentPrivate->mutexInputBFromApp));
2435        eError = OMX_ErrorHardware;
2436        goto EXIT;
2437    }
2438
2439EXIT:
2440    if (pComponentPrivate)
2441        OMX_PRBUFFER1(pComponentPrivate->dbg, "---Exiting 0x%x\n", eError);
2442    return eError;
2443}
2444
2445/*----------------------------------------------------------------------------*/
2446/**
2447  *  VIDDEC_FillThisBuffer() Sets application callbacks to the component
2448  *
2449  * This method will update application callbacks
2450  * the application.
2451  *
2452  * @param pComp         handle for this instance of the component
2453  * @param pCallBacks    application callbacks
2454  * @param ptr
2455  *
2456  * @retval OMX_NoError              Success, ready to roll
2457  *         OMX_Error_BadParameter   The input parameter pointer is null
2458  **/
2459/*----------------------------------------------------------------------------*/
2460
2461static OMX_ERRORTYPE VIDDEC_FillThisBuffer (OMX_HANDLETYPE pComponent,
2462                                            OMX_BUFFERHEADERTYPE* pBuffHead)
2463{
2464    OMX_ERRORTYPE eError = OMX_ErrorNone;
2465    OMX_COMPONENTTYPE *pHandle = NULL;
2466    VIDDEC_COMPONENT_PRIVATE *pComponentPrivate = NULL;
2467    VIDDEC_BUFFER_PRIVATE* pBufferPrivate = NULL;
2468    int ret = 0;
2469    OMX_CONF_CHECK_CMD(pComponent, pBuffHead, OMX_TRUE);
2470    pHandle = (OMX_COMPONENTTYPE *)pComponent;
2471    pComponentPrivate = (VIDDEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
2472
2473    OMX_PRBUFFER1(pComponentPrivate->dbg, "+++Entering pHandle 0x%p pBuffer 0x%p Index %lu\n",pComponent,
2474            pBuffHead, pBuffHead->nOutputPortIndex);
2475
2476    OMX_BOOL bIsOutputFlushPending = OMX_FALSE;
2477    VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->outputFlushCompletionMutex);
2478    bIsOutputFlushPending = pComponentPrivate->bIsOutputFlushPending;
2479    VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->outputFlushCompletionMutex);
2480    if (bIsOutputFlushPending) {
2481        ALOGE("Unable to process any OMX_FillThisBuffer requsts with flush pending");
2482        return OMX_ErrorIncorrectStateOperation;
2483    }
2484
2485#ifdef __PERF_INSTRUMENTATION__
2486    PERF_ReceivedFrame(pComponentPrivate->pPERF,
2487                       pBuffHead->pBuffer,
2488                       0,
2489                       PERF_ModuleHLMM);
2490#endif
2491
2492    OMX_PRBUFFER1(pComponentPrivate->dbg, "pComponentPrivate->pOutPortDef->bEnabled %d\n",
2493        pComponentPrivate->pOutPortDef->bEnabled);
2494    if(!pComponentPrivate->pOutPortDef->bEnabled)
2495        OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorIncorrectStateOperation);
2496
2497    if(pBuffHead->nOutputPortIndex != 0x1)
2498        OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorBadPortIndex);
2499
2500    if(pComponentPrivate->eState != OMX_StateExecuting &&
2501        pComponentPrivate->eState != OMX_StatePause &&
2502        pComponentPrivate->eState != OMX_StateIdle)
2503        OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorIncorrectStateOperation);
2504
2505    OMX_CONF_CHK_VERSION(pBuffHead, OMX_BUFFERHEADERTYPE, eError, pComponentPrivate->dbg);
2506
2507    if ((pComponentPrivate->bParserEnabled == OMX_FALSE) &&
2508        (pComponentPrivate->bFirstHeader == OMX_FALSE) &&
2509        (pBuffHead->nFilledLen > pBuffHead->nAllocLen)) {
2510        OMX_PRINT1(pComponentPrivate->dbg, "bFirstHeader: nFilledLen= %lu <- nAllocLen= %lu\n", pBuffHead->nFilledLen, pBuffHead->nAllocLen);
2511
2512        pBuffHead->nFilledLen = pBuffHead->nAllocLen;
2513    }
2514
2515    pBufferPrivate = (VIDDEC_BUFFER_PRIVATE* )pBuffHead->pOutputPortPrivate;
2516    ret = pBufferPrivate->eBufferOwner;
2517    pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_COMPONENT;
2518    eError = IncrementCount (&(pComponentPrivate->nCountOutputBFromApp), &(pComponentPrivate->mutexOutputBFromApp));
2519    if (eError != OMX_ErrorNone) {
2520        return eError;
2521    }
2522    pBuffHead->nFilledLen = 0;
2523    pBuffHead->nFlags = 0;
2524    OMX_PRBUFFER1(pComponentPrivate->dbg, "Writing pBuffer 0x%p OldeBufferOwner %d eBufferOwner %d nFilledLen %lu\n",
2525        pBuffHead, ret,pBufferPrivate->eBufferOwner,pBuffHead->nFilledLen);
2526    ret = write (pComponentPrivate->free_outBuf_Q[1], &(pBuffHead), sizeof (pBuffHead));
2527    if (ret == -1) {
2528        /*like function returns error buffer still with Client IL*/
2529        pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_CLIENT;
2530        OMX_PRCOMM4(pComponentPrivate->dbg, "Error in Writing to the Data pipe\n");
2531        DecrementCount (&(pComponentPrivate->nCountOutputBFromApp), &(pComponentPrivate->mutexOutputBFromApp));
2532        eError = OMX_ErrorHardware;
2533        goto EXIT;
2534    }
2535
2536EXIT:
2537    if (pComponentPrivate)
2538        OMX_PRBUFFER1(pComponentPrivate->dbg, "---Exiting 0x%x\n", eError);
2539    return eError;
2540}
2541
2542/*----------------------------------------------------------------------------*/
2543/**
2544  * VIDDEC_ComponentDeinit() Sets application callbacks to the component
2545  *
2546  * This method will update application callbacks
2547  * the application.
2548  *
2549  * @param pComp         handle for this instance of the component
2550  * @param pCallBacks    application callbacks
2551  * @param ptr
2552  *
2553  * @retval OMX_NoError              Success, ready to roll
2554  *         OMX_Error_BadParameter   The input parameter pointer is null
2555  **/
2556/*----------------------------------------------------------------------------*/
2557
2558static OMX_ERRORTYPE VIDDEC_ComponentDeInit(OMX_HANDLETYPE hComponent)
2559{
2560    OMX_ERRORTYPE eError = OMX_ErrorNone;
2561    OMX_COMPONENTTYPE* pHandle = NULL;
2562    VIDDEC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
2563    OMX_COMMANDTYPE Cmd = OMX_CommandStateSet;
2564    OMX_U32 nParam1 = -1;
2565    OMX_U32 buffcount = 0;
2566    OMX_U32 i = 0;
2567    OMX_U32 iCount = 0;
2568
2569    OMX_CONF_CHECK_CMD(hComponent, OMX_TRUE, OMX_TRUE);
2570
2571    pHandle = (OMX_COMPONENTTYPE*)hComponent;
2572    pComponentPrivate = (VIDDEC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate;
2573
2574#ifdef __PERF_INSTRUMENTATION__
2575    PERF_Boundary(pComponentPrivate->pPERF,
2576                  PERF_BoundaryStart | PERF_BoundaryCleanup);
2577    PERF_SendingCommand(pComponentPrivate->pPERF,
2578                        Cmd, nParam1, PERF_ModuleComponent);
2579#endif
2580    if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
2581        pComponentPrivate->pModLCML != NULL &&
2582        pComponentPrivate->pLCML != NULL){
2583        LCML_DSP_INTERFACE *pLcmlHandle = NULL;
2584        pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
2585        LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, EMMCodecControlDestroy, NULL);
2586        pComponentPrivate->eLCMLState = VidDec_LCML_State_Destroy;
2587    }
2588    if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
2589        pComponentPrivate->pModLCML != NULL){
2590        if(pComponentPrivate->pModLCML != NULL){
2591            dlclose(pComponentPrivate->pModLCML);
2592            pComponentPrivate->pModLCML = NULL;
2593            pComponentPrivate->pLCML = NULL;
2594            pComponentPrivate->eLCMLState = VidDec_LCML_State_Unload;
2595        }
2596    }
2597    eError = write(pComponentPrivate->cmdPipe[VIDDEC_PIPE_WRITE], &Cmd, sizeof(Cmd));
2598    if (eError == -1) {
2599        eError = OMX_ErrorUndefined;
2600        goto EXIT;
2601    }
2602    eError = write(pComponentPrivate->cmdDataPipe[VIDDEC_PIPE_WRITE], &nParam1, sizeof(nParam1));
2603    if (eError == -1) {
2604       eError = OMX_ErrorUndefined;
2605       goto EXIT;
2606    }
2607
2608    eError = VIDDEC_Stop_ComponentThread(pHandle);
2609    if (eError != OMX_ErrorNone) {
2610        OMX_ERROR4(pComponentPrivate->dbg, "Error returned from the Component\n");
2611    }
2612
2613    if (pComponentPrivate->pInternalConfigBufferAVC != NULL)
2614      free(pComponentPrivate->pInternalConfigBufferAVC);
2615    for (iCount = 0; iCount < MAX_PRIVATE_BUFFERS; iCount++) {
2616        if(pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT]->pBufferPrivate[iCount]->pBufferHdr != NULL) {
2617            OMX_BUFFERHEADERTYPE* pBuffHead = NULL;
2618            pBuffHead = pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT]->pBufferPrivate[iCount]->pBufferHdr;
2619            if(pBuffHead != NULL){
2620                if(pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT]->pBufferPrivate[iCount]->bAllocByComponent == OMX_TRUE){
2621                    OMX_MEMFREE_STRUCT_DSPALIGN(pBuffHead->pBuffer,OMX_U8);
2622                }
2623                free(pBuffHead);
2624                pBuffHead = NULL;
2625                pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT]->pBufferPrivate[iCount]->pBufferHdr = NULL;
2626            }
2627        }
2628    }
2629
2630    for (iCount = 0; iCount < MAX_PRIVATE_BUFFERS; iCount++) {
2631        if(pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[iCount]->pBufferHdr != NULL) {
2632            OMX_BUFFERHEADERTYPE* pBuffHead = NULL;
2633            pBuffHead = pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[iCount]->pBufferHdr;
2634            if(pBuffHead != NULL){
2635	         if(pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[iCount]->bAllocByComponent == OMX_TRUE){
2636                    OMX_MEMFREE_STRUCT_DSPALIGN(pBuffHead->pBuffer,OMX_U8);
2637	         }
2638                free(pBuffHead);
2639                pBuffHead = NULL;
2640                pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[iCount]->pBufferHdr = NULL;
2641            }
2642        }
2643    }
2644
2645#ifdef RESOURCE_MANAGER_ENABLED
2646    if(pComponentPrivate->eRMProxyState == VidDec_RMPROXY_State_Registered){
2647        OMX_PRMGR2(pComponentPrivate->dbg, "memory usage 0 %d : %d bytes\n",(unsigned int)pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0],(unsigned int)VIDDEC_MEMUSAGE);
2648        if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
2649            eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_FreeResource, OMX_H264_Decode_COMPONENT, 0, VIDDEC_MEMUSAGE, NULL);
2650            if (eError != OMX_ErrorNone) {
2651                 OMX_PRMGR4(pComponentPrivate->dbg, "Error returned from destroy ResourceManagerProxy thread\n");
2652            }
2653        }
2654        else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV) {
2655            eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_FreeResource, OMX_WMV_Decode_COMPONENT, 0, VIDDEC_MEMUSAGE, NULL);
2656            if (eError != OMX_ErrorNone) {
2657                 OMX_PRMGR4(pComponentPrivate->dbg, "Error returned from destroy ResourceManagerProxy thread\n");
2658            }
2659        }
2660        else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4) {
2661            eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_FreeResource, OMX_MPEG4_Decode_COMPONENT, 0, VIDDEC_MEMUSAGE, NULL);
2662            if (eError != OMX_ErrorNone) {
2663                 OMX_PRMGR4(pComponentPrivate->dbg, "Error returned from destroy ResourceManagerProxy thread\n");
2664            }
2665        }
2666        else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) {
2667            eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_FreeResource, OMX_H263_Decode_COMPONENT, 0, VIDDEC_MEMUSAGE, NULL);
2668            if (eError != OMX_ErrorNone) {
2669                 OMX_PRMGR4(pComponentPrivate->dbg, "Error returned from destroy ResourceManagerProxy thread\n");
2670            }
2671        }
2672        else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG2) {
2673            eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_FreeResource, OMX_MPEG2_Decode_COMPONENT, 0, VIDDEC_MEMUSAGE, NULL);
2674            if (eError != OMX_ErrorNone) {
2675                 OMX_PRMGR4(pComponentPrivate->dbg, "Error returned from destroy ResourceManagerProxy thread\n");
2676            }
2677        }
2678#ifdef VIDDEC_SPARK_CODE
2679        else if (VIDDEC_SPARKCHECK) {
2680            eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_FreeResource, OMX_MPEG4_Decode_COMPONENT, 0, VIDDEC_MEMUSAGE, NULL);
2681            if (eError != OMX_ErrorNone) {
2682                 OMX_PRMGR4(pComponentPrivate->dbg, "Error returned from destroy ResourceManagerProxy thread\n");
2683            }
2684        }
2685#endif
2686        else {
2687            eError = OMX_ErrorUnsupportedSetting;
2688            goto EXIT;
2689        }
2690        pComponentPrivate->eRMProxyState = VidDec_RMPROXY_State_Load;
2691    }
2692    if(pComponentPrivate->eRMProxyState != VidDec_RMPROXY_State_Unload){
2693        eError = RMProxy_DeinitalizeEx(OMX_COMPONENTTYPE_VIDEO);
2694        if (eError != OMX_ErrorNone) {
2695            OMX_PRMGR4(pComponentPrivate->dbg, "Error returned from destroy ResourceManagerProxy thread\n");
2696        }
2697        pComponentPrivate->eRMProxyState = VidDec_RMPROXY_State_Unload;
2698    }
2699#endif
2700
2701    VIDDEC_CircBuf_DeInit(pComponentPrivate, VIDDEC_CBUFFER_TIMESTAMP, VIDDEC_INPUT_PORT);
2702    VIDDEC_Queue_Free(&pComponentPrivate->qBuffMark);
2703    VIDDEC_Queue_Free(&pComponentPrivate->qCmdMarkData);
2704    VIDDEC_Queue_Free(&pComponentPrivate->qBytesSent);
2705    /* Free Resources */
2706    if(pComponentPrivate->pPortParamType) {
2707        free(pComponentPrivate->pPortParamType);
2708        pComponentPrivate->pPortParamType = NULL;
2709    }
2710#ifdef __STD_COMPONENT__
2711    if(pComponentPrivate->pPortParamTypeAudio) {
2712        free(pComponentPrivate->pPortParamTypeAudio);
2713        pComponentPrivate->pPortParamTypeAudio = NULL;
2714    }
2715    if(pComponentPrivate->pPortParamTypeImage) {
2716        free(pComponentPrivate->pPortParamTypeImage);
2717        pComponentPrivate->pPortParamTypeImage = NULL;
2718    }
2719    if(pComponentPrivate->pPortParamTypeOthers) {
2720        free(pComponentPrivate->pPortParamTypeOthers);
2721        pComponentPrivate->pPortParamTypeOthers = NULL;
2722    }
2723#endif
2724
2725    buffcount = MAX_PRIVATE_BUFFERS;
2726    for (i = 0; i < buffcount; i++) {
2727        if(pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT]->pBufferPrivate[i]) {
2728            OMX_PRBUFFER1(pComponentPrivate->dbg, "BufferPrivate cleared 0x%p\n",
2729                    pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT]->pBufferPrivate[i]);
2730            free(pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT]->pBufferPrivate[i]);
2731            pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT]->pBufferPrivate[i] = NULL;
2732        }
2733    }
2734
2735    buffcount = MAX_PRIVATE_BUFFERS;
2736    for (i = 0; i < buffcount; i++) {
2737        if(pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[i]) {
2738            OMX_PRBUFFER1(pComponentPrivate->dbg, "BufferPrivate cleared 0x%p\n",
2739                    pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[i]);
2740            free(pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[i]);
2741            pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[i] = NULL;
2742        }
2743    }
2744    if(pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]) {
2745        free(pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]);
2746        pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT] = NULL;
2747    }
2748
2749    if(pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT]) {
2750        free(pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT]);
2751        pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT] = NULL;
2752    }
2753
2754    if(pComponentPrivate->pInPortDef) {
2755        free(pComponentPrivate->pInPortDef);
2756        pComponentPrivate->pInPortDef = NULL;
2757    }
2758    if(pComponentPrivate->pOutPortDef) {
2759        free(pComponentPrivate->pOutPortDef);
2760        pComponentPrivate->pOutPortDef = NULL;
2761    }
2762    if(pComponentPrivate->pInPortFormat) {
2763        free(pComponentPrivate->pInPortFormat);
2764        pComponentPrivate->pInPortFormat = NULL;
2765    }
2766    if(pComponentPrivate->pOutPortFormat) {
2767        free(pComponentPrivate->pOutPortFormat);
2768        pComponentPrivate->pOutPortFormat = NULL;
2769    }
2770    if(pComponentPrivate->pPriorityMgmt) {
2771        free(pComponentPrivate->pPriorityMgmt);
2772        pComponentPrivate->pPriorityMgmt = NULL;
2773    }
2774    if(pComponentPrivate->pInBufSupplier) {
2775        free(pComponentPrivate->pInBufSupplier);
2776        pComponentPrivate->pInBufSupplier = NULL;
2777    }
2778    if(pComponentPrivate->pOutBufSupplier) {
2779        free(pComponentPrivate->pOutBufSupplier);
2780        pComponentPrivate->pOutBufSupplier = NULL;
2781    }
2782    if(pComponentPrivate->pMpeg4 != NULL) {
2783        free(pComponentPrivate->pMpeg4);
2784        pComponentPrivate->pMpeg4 = NULL;
2785    }
2786    if(pComponentPrivate->pMpeg2 != NULL) {
2787        free(pComponentPrivate->pMpeg2);
2788        pComponentPrivate->pMpeg2 = NULL;
2789    }
2790    if(pComponentPrivate->pH264 != NULL) {
2791        free(pComponentPrivate->pH264);
2792        pComponentPrivate->pH264 = NULL;
2793    }
2794    if(pComponentPrivate->pH263 != NULL) {
2795        free(pComponentPrivate->pH263);
2796        pComponentPrivate->pH263 = NULL;
2797    }
2798    if(pComponentPrivate->pWMV != NULL) {
2799        free(pComponentPrivate->pWMV);
2800        pComponentPrivate->pWMV = NULL;
2801    }
2802    if(pComponentPrivate->pDeblockingParamType != NULL) {
2803        free(pComponentPrivate->pDeblockingParamType);
2804        pComponentPrivate->pDeblockingParamType = NULL;
2805    }
2806#ifdef ANDROID
2807    if(pComponentPrivate->pPVCapabilityFlags != NULL) {
2808        free(pComponentPrivate->pPVCapabilityFlags);
2809        pComponentPrivate->pPVCapabilityFlags = NULL;
2810    }
2811#endif
2812    if(pComponentPrivate->cComponentName != NULL) {
2813        free(pComponentPrivate->cComponentName);
2814        pComponentPrivate->cComponentName = NULL;
2815    }
2816
2817    pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0]  = 0;
2818    pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel1]  = 0;
2819    pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel2]  = 0;
2820    pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel3]  = 0;
2821    pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel4]  = 0;
2822
2823#ifdef __PERF_INSTRUMENTATION__
2824    PERF_Boundary(pComponentPrivate->pPERF,
2825                  PERF_BoundaryComplete | PERF_BoundaryCleanup);
2826    PERF_Done(pComponentPrivate->pPERF);
2827#endif
2828
2829    OMX_DBG_CLOSE(pComponentPrivate->dbg);
2830
2831#ifndef UNDER_CE
2832    if(pComponentPrivate->eFirstBuffer.pFirstBufferSaved){
2833        free(pComponentPrivate->eFirstBuffer.pFirstBufferSaved);
2834        pComponentPrivate->eFirstBuffer.pFirstBufferSaved = NULL;
2835        pComponentPrivate->eFirstBuffer.bSaveFirstBuffer = OMX_FALSE;
2836        pComponentPrivate->eFirstBuffer.nFilledLen = 0;
2837    }
2838    if(pComponentPrivate->pCodecData){
2839        free(pComponentPrivate->pCodecData);
2840        pComponentPrivate->pCodecData = NULL;
2841        pComponentPrivate->nCodecDataSize = 0;
2842    }
2843    VIDDEC_PTHREAD_MUTEX_DESTROY(pComponentPrivate->sMutex);
2844    VIDDEC_PTHREAD_SEMAPHORE_DESTROY(pComponentPrivate->sInSemaphore);
2845    VIDDEC_PTHREAD_SEMAPHORE_DESTROY(pComponentPrivate->sOutSemaphore);
2846    VIDDEC_PTHREAD_MUTEX_DESTROY(pComponentPrivate->inputFlushCompletionMutex);
2847    VIDDEC_PTHREAD_MUTEX_DESTROY(pComponentPrivate->outputFlushCompletionMutex);
2848#endif
2849    pthread_mutex_destroy(&(pComponentPrivate->mutexInputBFromApp));
2850    pthread_mutex_destroy(&(pComponentPrivate->mutexOutputBFromApp));
2851    pthread_mutex_destroy(&(pComponentPrivate->mutexInputBFromDSP));
2852    pthread_mutex_destroy(&(pComponentPrivate->mutexOutputBFromDSP));
2853
2854    pthread_mutex_destroy(&pComponentPrivate->mutexStateChangeRequest);
2855    pthread_cond_destroy(&pComponentPrivate->StateChangeCondition);
2856
2857    if(pComponentPrivate->pUalgParams != NULL){
2858        OMX_U8* pTemp = NULL;
2859        pTemp = (OMX_U8*)(pComponentPrivate->pUalgParams);
2860        pTemp -= VIDDEC_PADDING_HALF;
2861        pComponentPrivate->pUalgParams = (OMX_PTR*)pTemp;
2862        free(pComponentPrivate->pUalgParams);
2863        pComponentPrivate->pUalgParams = NULL;
2864    }
2865    if(pHandle->pComponentPrivate != NULL) {
2866        free(pHandle->pComponentPrivate);
2867        pHandle->pComponentPrivate = NULL;
2868        pComponentPrivate = NULL;
2869    }
2870EXIT:
2871    return eError;
2872}
2873
2874/*----------------------------------------------------------------------------*/
2875/**
2876  *  VIDDEC_UseBuffer()
2877  *
2878  *
2879  *
2880  *
2881  * @param
2882  * @param
2883  * @param
2884  *
2885  * @retval OMX_NoError              Success, ready to roll
2886  *         OMX_Error_BadParameter   The input parameter pointer is null
2887  **/
2888/*----------------------------------------------------------------------------*/
2889
2890static OMX_ERRORTYPE VIDDEC_UseBuffer(OMX_IN OMX_HANDLETYPE hComponent,
2891                               OMX_INOUT OMX_BUFFERHEADERTYPE** ppBufferHdr,
2892                               OMX_IN OMX_U32 nPortIndex,
2893                               OMX_IN OMX_PTR pAppPrivate,
2894                               OMX_IN OMX_U32 nSizeBytes,
2895                               OMX_IN OMX_U8* pBuffer)
2896{
2897    OMX_ERRORTYPE eError = OMX_ErrorNone;
2898    OMX_COMPONENTTYPE* pHandle = NULL;
2899    VIDDEC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
2900    OMX_PARAM_PORTDEFINITIONTYPE* pPortDef = NULL;
2901    VIDDEC_PORT_TYPE* pCompPort = NULL;
2902    OMX_U8 pBufferCnt = 0;
2903
2904    OMX_CONF_CHECK_CMD(hComponent, pBuffer, OMX_TRUE);
2905
2906    pHandle = (OMX_COMPONENTTYPE*)hComponent;
2907    pComponentPrivate = (VIDDEC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate;
2908
2909    OMX_PRBUFFER1(pComponentPrivate->dbg, "+++Entering pHandle 0x%p ppBufferHdr 0x%p pBuffer 0x%p nPortIndex 0x%lx nSizeBytes 0x%lx\n",
2910        hComponent, *ppBufferHdr, pBuffer, nPortIndex, nSizeBytes);
2911
2912#ifdef __PERF_INSTRUMENTATION__
2913    PERF_ReceivedFrame(pComponentPrivate->pPERF,
2914                       pBuffer,
2915                       nSizeBytes,
2916                       PERF_ModuleHLMM);
2917#endif
2918
2919    if (nPortIndex == pComponentPrivate->pInPortFormat->nPortIndex) {
2920        pCompPort = pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT];
2921        pBufferCnt = pCompPort->nBufferCnt;
2922        pPortDef = pComponentPrivate->pInPortDef;
2923    }
2924    else if (nPortIndex == pComponentPrivate->pOutPortFormat->nPortIndex) {
2925        pCompPort = pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT];
2926        pBufferCnt = pCompPort->nBufferCnt;
2927        pPortDef = pComponentPrivate->pOutPortDef;
2928    }
2929    else {
2930        eError = OMX_ErrorBadPortIndex;
2931        goto EXIT;
2932    }
2933
2934    if(!pPortDef->bEnabled){
2935        OMX_ERROR4(pComponentPrivate->dbg, "Error: port disabled\n");
2936        eError = OMX_ErrorIncorrectStateOperation;
2937        goto EXIT;
2938    }
2939
2940    OMX_PRBUFFER1(pComponentPrivate->dbg, "pPortDef->nBufferSize %d nSizeBytes %d %d\n", (int )pPortDef->nBufferSize,
2941        (int )nSizeBytes,(int )(pPortDef->nBufferSize > nSizeBytes));
2942    pPortDef->nBufferSize = nSizeBytes;
2943    if(nSizeBytes != pPortDef->nBufferSize || pPortDef->bPopulated){
2944        OMX_PRBUFFER4(pComponentPrivate->dbg, "Error: badparameter\n");
2945        eError = OMX_ErrorBadParameter;
2946        goto EXIT;
2947    }
2948
2949    OMX_MALLOC_STRUCT(pCompPort->pBufferPrivate[pBufferCnt]->pBufferHdr, OMX_BUFFERHEADERTYPE,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel1]);
2950    if (!pCompPort->pBufferPrivate[pBufferCnt]->pBufferHdr) {
2951        OMX_TRACE4(pComponentPrivate->dbg, "Error: Malloc failed\n");
2952        eError = OMX_ErrorInsufficientResources;
2953        pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
2954                                               pComponentPrivate->pHandle->pApplicationPrivate,
2955                                               OMX_EventError,
2956                                               eError,
2957                                               OMX_TI_ErrorMajor,
2958                                               NULL);
2959        goto EXIT;
2960    }
2961
2962    *ppBufferHdr = pCompPort->pBufferPrivate[pBufferCnt]->pBufferHdr;
2963    memset(*ppBufferHdr, 0, sizeof(OMX_BUFFERHEADERTYPE));
2964    OMX_CONF_INIT_STRUCT(pCompPort->pBufferPrivate[pBufferCnt]->pBufferHdr, OMX_BUFFERHEADERTYPE, pComponentPrivate->dbg);
2965
2966    (*ppBufferHdr)->pBuffer = pBuffer;
2967    (*ppBufferHdr)->nAllocLen = nSizeBytes;
2968    (*ppBufferHdr)->pAppPrivate = pAppPrivate;
2969    (*ppBufferHdr)->pMarkData = NULL;
2970#ifndef VIDDEC_WMVPOINTERFIXED
2971    if (pComponentPrivate->nWMVFileType == VIDDEC_WMV_ELEMSTREAM &&
2972        pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV &&
2973        pComponentPrivate->ProcessMode == 0 &&
2974        nPortIndex == VIDDEC_INPUT_PORT) {
2975        /* vc-1 fix */
2976        (*ppBufferHdr)->nOffset = VIDDEC_WMV_BUFFER_OFFSET;
2977    }
2978#endif
2979    if (pCompPort->hTunnelComponent != NULL) {
2980        if (pPortDef->eDir == OMX_DirInput) {
2981            (*ppBufferHdr)->nInputPortIndex  = nPortIndex;
2982            (*ppBufferHdr)->nOutputPortIndex = pComponentPrivate->pCompPort[nPortIndex]->nTunnelPort;
2983        }
2984        else {
2985            (*ppBufferHdr)->nInputPortIndex  = pComponentPrivate->pCompPort[nPortIndex]->nTunnelPort;
2986            (*ppBufferHdr)->nOutputPortIndex = nPortIndex;
2987        }
2988    }
2989    else {
2990        if (nPortIndex == VIDDEC_INPUT_PORT) {
2991            (*ppBufferHdr)->nInputPortIndex  = VIDDEC_INPUT_PORT;
2992            (*ppBufferHdr)->nOutputPortIndex = VIDDEC_NOPORT;
2993        }
2994        else {
2995            (*ppBufferHdr)->nInputPortIndex  = VIDDEC_NOPORT;
2996            (*ppBufferHdr)->nOutputPortIndex = VIDDEC_OUTPUT_PORT;
2997        }
2998    }
2999
3000    if (nPortIndex == VIDDEC_INPUT_PORT) {
3001        (*ppBufferHdr)->pInputPortPrivate = pComponentPrivate->pCompPort[nPortIndex]->pBufferPrivate[pBufferCnt];
3002    }
3003    else {
3004        (*ppBufferHdr)->pOutputPortPrivate = pComponentPrivate->pCompPort[nPortIndex]->pBufferPrivate[pBufferCnt];
3005    }
3006    pComponentPrivate->pCompPort[nPortIndex]->pBufferPrivate[pBufferCnt]->bAllocByComponent = OMX_FALSE;
3007
3008    if (pCompPort->hTunnelComponent != NULL) {
3009        pComponentPrivate->pCompPort[nPortIndex]->pBufferPrivate[pBufferCnt]->eBufferOwner = VIDDEC_BUFFER_WITH_TUNNELEDCOMP;
3010    }
3011    else {
3012        pComponentPrivate->pCompPort[nPortIndex]->pBufferPrivate[pBufferCnt]->eBufferOwner = VIDDEC_BUFFER_WITH_CLIENT;
3013    }
3014
3015    OMX_PRBUFFER1(pComponentPrivate->dbg, "ppBufferHdr 0x%p pBuffer 0x%p nAllocLen %lu eBufferOwner %d\n",
3016        *ppBufferHdr, pCompPort->pBufferPrivate[pBufferCnt]->pBufferHdr->pBuffer, (*ppBufferHdr)->nAllocLen,
3017        pCompPort->pBufferPrivate[pBufferCnt]->eBufferOwner);
3018
3019    eError = VIDDEC_Allocate_DSPResources(pComponentPrivate, nPortIndex);
3020    if (eError != OMX_ErrorNone) {
3021        eError = OMX_ErrorInsufficientResources;
3022        pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
3023                                               pComponentPrivate->pHandle->pApplicationPrivate,
3024                                               OMX_EventError,
3025                                               eError,
3026                                               OMX_TI_ErrorMajor,
3027                                               NULL);
3028        goto EXIT;
3029    }
3030
3031    pCompPort->nBufferCnt++;
3032
3033    if (pCompPort->nBufferCnt == pPortDef->nBufferCountActual) {
3034        pPortDef->bPopulated = OMX_TRUE;
3035#ifndef UNDER_CE
3036        if (nPortIndex == VIDDEC_INPUT_PORT) {
3037            VIDDEC_PTHREAD_SEMAPHORE_POST(pComponentPrivate->sInSemaphore);
3038        }
3039        else {
3040            VIDDEC_PTHREAD_SEMAPHORE_POST(pComponentPrivate->sOutSemaphore);
3041        }
3042#endif
3043    }
3044EXIT:
3045    if (pComponentPrivate)
3046        OMX_PRBUFFER1(pComponentPrivate->dbg, "---Exiting eError 0x%x\n", \
3047                                                         eError);
3048    return eError;
3049}
3050
3051/*----------------------------------------------------------------------------*/
3052/**
3053  *  VIDDEC_FreeBuffer()
3054  *
3055  *
3056  *
3057  *
3058  * @param
3059  * @param
3060  * @param
3061  *
3062  * @retval OMX_NoError              Success, ready to roll
3063  *         OMX_Error_BadParameter   The input parameter pointer is null
3064  **/
3065/*----------------------------------------------------------------------------*/
3066
3067static OMX_ERRORTYPE VIDDEC_FreeBuffer (OMX_IN OMX_HANDLETYPE hComponent,
3068                                 OMX_IN OMX_U32 nPortIndex,
3069                                 OMX_IN OMX_BUFFERHEADERTYPE* pBuffHead)
3070{
3071    OMX_ERRORTYPE eError = OMX_ErrorNone;
3072    OMX_COMPONENTTYPE* pHandle = NULL;
3073    VIDDEC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
3074    VIDDEC_BUFFER_PRIVATE* pBufferPrivate = NULL;
3075    OMX_PARAM_PORTDEFINITIONTYPE* pPortDefIn = NULL;
3076    OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = NULL;
3077    VIDDEC_PORT_TYPE* pCompPort = NULL;
3078    OMX_PARAM_PORTDEFINITIONTYPE* pPortDef = NULL;
3079    OMX_U8* pTemp = NULL;
3080    OMX_U32 i = 0;
3081    VIDDEC_PORT_TYPE* pInCompPort = NULL;
3082    OMX_U8 pInBufferCnt = 0;
3083    VIDDEC_PORT_TYPE* pOutCompPort = NULL;
3084    OMX_U8 pOutBufferCnt = 0;
3085    OMX_U32 buffcount = 0;
3086    OMX_STATETYPE TunnelState = OMX_StateInvalid;
3087    OMX_BOOL bTransIdle = OMX_FALSE;
3088
3089    OMX_CONF_CHECK_CMD(hComponent, pBuffHead, OMX_TRUE);
3090
3091    pHandle = (OMX_COMPONENTTYPE*)hComponent;
3092    pComponentPrivate = (VIDDEC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate;
3093
3094    OMX_PRBUFFER1(pComponentPrivate->dbg, "+++Entering pHandle 0x%p pBuffHead 0x%p nPortIndex %lu nFilledLen %lx nAllocLen %lx\n",
3095        hComponent, pBuffHead, nPortIndex,pBuffHead->nFilledLen,pBuffHead->nAllocLen);
3096
3097    pPortDefIn = pComponentPrivate->pInPortDef;
3098    pPortDefOut = pComponentPrivate->pOutPortDef;
3099
3100    pInCompPort = pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT];
3101    pInBufferCnt = pInCompPort->nBufferCnt;
3102    pOutCompPort = pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT];
3103    pOutBufferCnt = pOutCompPort->nBufferCnt;
3104
3105    if (nPortIndex == pComponentPrivate->pInPortFormat->nPortIndex) {
3106        pPortDef = pComponentPrivate->pInPortDef;
3107        pCompPort = pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT];
3108        pBufferPrivate = pBuffHead->pInputPortPrivate;
3109    }
3110    else if (nPortIndex == pComponentPrivate->pOutPortFormat->nPortIndex) {
3111        pPortDef = pComponentPrivate->pOutPortDef;
3112        pCompPort = pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT];
3113        pBufferPrivate = pBuffHead->pOutputPortPrivate;
3114    }
3115    else {
3116        eError = OMX_ErrorBadPortIndex;
3117        goto EXIT;
3118    }
3119
3120    /*if(pPortDef->bEnabled && pComponentPrivate->eState != OMX_StateIdle){
3121        OMX_ERROR4(pComponentPrivate->dbg, "Error: port disabled\n");
3122        eError = OMX_ErrorIncorrectStateOperation;
3123        goto EXIT;
3124    }*/
3125
3126    if (pPortDefIn->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 ||
3127        pPortDefIn->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) {
3128        if (nPortIndex == pComponentPrivate->pInPortFormat->nPortIndex) {
3129            OMX_MEMFREE_STRUCT_DSPALIGN(pBufferPrivate->pUalgParam,OMX_PTR);
3130            pBufferPrivate->nUalgParamSize = 0;
3131        }
3132        else if (nPortIndex == pComponentPrivate->pOutPortFormat->nPortIndex) {
3133            OMX_MEMFREE_STRUCT_DSPALIGN(pBufferPrivate->pUalgParam,OMX_PTR);
3134            pBufferPrivate->nUalgParamSize = 0;
3135        }
3136        else {
3137            eError = OMX_ErrorBadPortIndex;
3138            goto EXIT;
3139        }
3140    }
3141#ifdef VIDDEC_SPARK_CODE
3142    else if (VIDDEC_SPARKCHECK) {
3143        if (nPortIndex == pComponentPrivate->pInPortFormat->nPortIndex) {
3144            OMX_MEMFREE_STRUCT_DSPALIGN(pBufferPrivate->pUalgParam,OMX_PTR);
3145            pBufferPrivate->nUalgParamSize = 0;
3146        }
3147        else if (nPortIndex == pComponentPrivate->pOutPortFormat->nPortIndex) {
3148            OMX_MEMFREE_STRUCT_DSPALIGN(pBufferPrivate->pUalgParam,OMX_PTR);
3149            pBufferPrivate->nUalgParamSize = 0;
3150        }
3151        else {
3152            eError = OMX_ErrorBadPortIndex;
3153            goto EXIT;
3154        }
3155    }
3156#endif
3157    else if (pPortDefIn->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG2) {
3158        if (nPortIndex == pComponentPrivate->pInPortFormat->nPortIndex) {
3159            OMX_MEMFREE_STRUCT_DSPALIGN(pBufferPrivate->pUalgParam,OMX_PTR);
3160            pBufferPrivate->nUalgParamSize = 0;
3161        }
3162        else if (nPortIndex == pComponentPrivate->pOutPortFormat->nPortIndex) {
3163            OMX_MEMFREE_STRUCT_DSPALIGN(pBufferPrivate->pUalgParam,OMX_PTR);
3164            pBufferPrivate->nUalgParamSize = 0;
3165        }
3166        else {
3167            eError = OMX_ErrorBadPortIndex;
3168            goto EXIT;
3169        }
3170    }
3171    else if (pPortDefIn->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
3172        if (nPortIndex == pComponentPrivate->pInPortFormat->nPortIndex) {
3173            OMX_MEMFREE_STRUCT_DSPALIGN(pBufferPrivate->pUalgParam,OMX_PTR);
3174            pBufferPrivate->nUalgParamSize = 0;
3175        }
3176        else if (nPortIndex == pComponentPrivate->pOutPortFormat->nPortIndex) {
3177            OMX_MEMFREE_STRUCT_DSPALIGN(pBufferPrivate->pUalgParam,OMX_PTR);
3178            pBufferPrivate->nUalgParamSize = 0;
3179        }
3180        else {
3181            eError = OMX_ErrorBadPortIndex;
3182            goto EXIT;
3183        }
3184    }
3185    else if (pPortDefIn->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV) {
3186        if (nPortIndex == pComponentPrivate->pInPortFormat->nPortIndex) {
3187            OMX_MEMFREE_STRUCT_DSPALIGN(pBufferPrivate->pUalgParam,OMX_PTR);
3188            pBufferPrivate->nUalgParamSize = 0;
3189        }
3190        else if (nPortIndex == pComponentPrivate->pOutPortFormat->nPortIndex) {
3191            OMX_MEMFREE_STRUCT_DSPALIGN(pBufferPrivate->pUalgParam,OMX_PTR);
3192            pBufferPrivate->nUalgParamSize = 0;
3193        }
3194        else {
3195            eError = OMX_ErrorBadPortIndex;
3196            goto EXIT;
3197        }
3198    }
3199    else {
3200        OMX_ERROR4(pComponentPrivate->dbg, "Error: Invalid Compression Type\n");
3201        goto EXIT;
3202    }
3203    OMX_PRBUFFER1(pComponentPrivate->dbg, "bAllocByComponent 0x%x pBuffer 0x%p\n", (int )pBufferPrivate->bAllocByComponent,
3204        pBuffHead->pBuffer);
3205    if (pBufferPrivate->bAllocByComponent == OMX_TRUE) {
3206        if(pBuffHead->pBuffer != NULL){
3207#ifdef __PERF_INSTRUMENTATION__
3208           PERF_SendingFrame(pComponentPrivate->pPERFcomp,
3209                             pBuffHead->pBuffer,
3210                             pBuffHead->nAllocLen,
3211                             PERF_ModuleMemory);
3212#endif
3213
3214      /* Freeing the original buffer position were data buffer was allocated */
3215           if(pBufferPrivate->pOriginalBuffer != NULL){
3216              pBuffHead->pBuffer = pBufferPrivate->pOriginalBuffer;
3217              pBufferPrivate->pOriginalBuffer = NULL;
3218              OMX_FREE_VIDDEC(pBuffHead->pBuffer);
3219           } else{
3220               OMX_FREE_BUFFER_VIDDEC(pBuffHead, pCompPort);
3221           }
3222        }
3223    }
3224
3225    buffcount = pPortDef->nBufferCountActual;
3226    for(i = 0; i < buffcount; i++){
3227        if (pCompPort->pBufferPrivate[i]->pBufferHdr == pBuffHead){
3228            OMX_PRBUFFER1(pComponentPrivate->dbg, "buffcount %lu eBufferOwner 0x%x\n", i, pCompPort->pBufferPrivate[i]->eBufferOwner);
3229            free(pCompPort->pBufferPrivate[i]->pBufferHdr);
3230            pCompPort->pBufferPrivate[i]->pBufferHdr = NULL;
3231            pBuffHead = NULL;
3232        }
3233    }
3234    if(pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->hTunnelComponent != NULL){
3235        eError = OMX_GetState(pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->hTunnelComponent,&TunnelState);
3236        if(eError != OMX_ErrorNone) {
3237            OMX_ERROR4(pComponentPrivate->dbg, "GetState Invalid return\n");
3238            goto EXIT;
3239        }
3240        OMX_PRCOMM2(pComponentPrivate->dbg, "TunnelState %d\n", TunnelState);
3241    }
3242    if((pComponentPrivate->eState == OMX_StateIdle) && (pComponentPrivate->eIdleToLoad == OMX_StateLoaded)){
3243        bTransIdle = OMX_TRUE;
3244    }
3245    else {
3246        bTransIdle = OMX_FALSE;
3247    }
3248    if (nPortIndex == pComponentPrivate->pInPortFormat->nPortIndex) {
3249        pInBufferCnt--;
3250        pInCompPort->nBufferCnt--;
3251        if (pInBufferCnt == 0) {
3252            pPortDefIn->bPopulated = OMX_FALSE;
3253#ifndef UNDER_CE
3254            if (nPortIndex == VIDDEC_INPUT_PORT) {
3255                VIDDEC_PTHREAD_SEMAPHORE_POST(pComponentPrivate->sInSemaphore);
3256            }
3257            else {
3258                VIDDEC_PTHREAD_SEMAPHORE_POST(pComponentPrivate->sOutSemaphore);
3259            }
3260#endif
3261            if (bTransIdle) {
3262                i = 0;
3263            }
3264            else if ((!pPortDef->bEnabled && (pComponentPrivate->eState == OMX_StateIdle ||
3265                      pComponentPrivate->eState == OMX_StateExecuting
3266                      || pComponentPrivate->eState == OMX_StatePause))) {
3267                i = 0;
3268            }
3269            else {
3270                if (pComponentPrivate->eState != OMX_StateInvalid) {
3271                pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
3272                                                        pComponentPrivate->pHandle->pApplicationPrivate,
3273                                                        OMX_EventError,
3274                                                        OMX_ErrorPortUnpopulated,
3275                                                        OMX_TI_ErrorMinor,
3276                                                        "Input Port Unpopulated");
3277                }
3278            }
3279        }
3280    }
3281
3282    else if (nPortIndex == pComponentPrivate->pOutPortFormat->nPortIndex) {
3283        pOutBufferCnt--;
3284        pOutCompPort->nBufferCnt--;
3285        if (pOutBufferCnt == 0) {
3286            pPortDefOut->bPopulated = OMX_FALSE;
3287#ifndef UNDER_CE
3288            if (nPortIndex == VIDDEC_INPUT_PORT) {
3289                VIDDEC_PTHREAD_SEMAPHORE_POST(pComponentPrivate->sInSemaphore);
3290            }
3291            else {
3292                VIDDEC_PTHREAD_SEMAPHORE_POST(pComponentPrivate->sOutSemaphore);
3293            }
3294#endif
3295            if ((pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->hTunnelComponent == NULL) &&  bTransIdle) {
3296                i = 0;
3297            }
3298            else if ((pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->hTunnelComponent != NULL) &&  (TunnelState == OMX_StateIdle)) {
3299                i = 0;
3300            }
3301            else if ((!pPortDef->bEnabled && (pComponentPrivate->eState == OMX_StateIdle ||
3302                      pComponentPrivate->eState == OMX_StateExecuting
3303                      || pComponentPrivate->eState == OMX_StatePause))) {
3304                i = 0;
3305            }
3306            else {
3307                if (pComponentPrivate->eState != OMX_StateInvalid) {
3308                pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
3309                                                        pComponentPrivate->pHandle->pApplicationPrivate,
3310                                                        OMX_EventError,
3311                                                        OMX_ErrorPortUnpopulated,
3312                                                        OMX_TI_ErrorMinor,
3313                                                        "Output Port Unpopulated");
3314                }
3315            }
3316        }
3317    }
3318
3319EXIT:
3320    if (pComponentPrivate)
3321        OMX_PRBUFFER1(pComponentPrivate->dbg, "---Exiting eError 0x%x\n", \
3322                                                        eError);
3323    return eError;
3324}
3325
3326/*----------------------------------------------------------------------------*/
3327/**
3328  *  VIDDEC_AllocateBuffer()
3329  *
3330  *
3331  *
3332  *
3333  * @param
3334  * @param
3335  * @param
3336  *
3337  * @retval OMX_NoError              Success, ready to roll
3338  *         OMX_Error_BadParameter   The input parameter pointer is null
3339  **/
3340/*----------------------------------------------------------------------------*/
3341
3342static OMX_ERRORTYPE VIDDEC_AllocateBuffer (OMX_IN OMX_HANDLETYPE hComponent,
3343                                     OMX_INOUT OMX_BUFFERHEADERTYPE** pBuffHead,
3344                                     OMX_IN OMX_U32 nPortIndex,
3345                                     OMX_IN OMX_PTR pAppPrivate,
3346                                     OMX_IN OMX_U32 nSizeBytes)
3347{
3348    OMX_ERRORTYPE eError = OMX_ErrorNone;
3349    OMX_COMPONENTTYPE* pHandle = NULL;
3350    VIDDEC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
3351    OMX_PARAM_PORTDEFINITIONTYPE* pPortDef = NULL;
3352    VIDDEC_PORT_TYPE* pCompPort = NULL;
3353    OMX_U8 pBufferCnt = 0;
3354
3355    OMX_CONF_CHECK_CMD(hComponent, OMX_TRUE, OMX_TRUE);
3356
3357    pHandle = (OMX_COMPONENTTYPE*)hComponent;
3358    pComponentPrivate = (VIDDEC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate;
3359
3360    OMX_PRBUFFER1(pComponentPrivate->dbg, "+++Entering pHandle 0x%p pBuffHead 0x%p nPortIndex 0x%lx nSizeBytes 0x%lx\n",
3361        hComponent, *pBuffHead, nPortIndex, nSizeBytes);
3362
3363
3364    if (nPortIndex == pComponentPrivate->pInPortFormat->nPortIndex) {
3365        pCompPort = pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT];
3366        pBufferCnt = pCompPort->nBufferCnt;
3367        pPortDef = pComponentPrivate->pInPortDef;
3368    }
3369    else if (nPortIndex == pComponentPrivate->pOutPortFormat->nPortIndex) {
3370        pCompPort = pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT];
3371        pBufferCnt = pCompPort->nBufferCnt;
3372        pPortDef = pComponentPrivate->pOutPortDef;
3373    }
3374    else {
3375        eError = OMX_ErrorBadPortIndex;
3376        goto EXIT;
3377    }
3378
3379    OMX_MALLOC_STRUCT(pCompPort->pBufferPrivate[pBufferCnt]->pBufferHdr, OMX_BUFFERHEADERTYPE,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel1]);
3380    if (!pCompPort->pBufferPrivate[pBufferCnt]->pBufferHdr) {
3381        eError = OMX_ErrorInsufficientResources;
3382        pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
3383                                               pComponentPrivate->pHandle->pApplicationPrivate,
3384                                               OMX_EventError,
3385                                               eError,
3386                                               OMX_TI_ErrorMajor,
3387                                               NULL);
3388        goto EXIT;
3389    }
3390
3391    *pBuffHead = pCompPort->pBufferPrivate[pBufferCnt]->pBufferHdr;
3392    memset(*pBuffHead, 0, sizeof(OMX_BUFFERHEADERTYPE));
3393    OMX_CONF_INIT_STRUCT(pCompPort->pBufferPrivate[pBufferCnt]->pBufferHdr, OMX_BUFFERHEADERTYPE, pComponentPrivate->dbg);
3394    /* Allocate Video Decoder buffer */
3395    OMX_MALLOC_STRUCT_SIZED((*pBuffHead)->pBuffer, OMX_U8, OMX_GET_DATABUFF_SIZE(nSizeBytes), NULL);
3396    if (!((*pBuffHead)->pBuffer)) {
3397        eError = OMX_ErrorInsufficientResources;
3398        pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
3399                                               pComponentPrivate->pHandle->pApplicationPrivate,
3400                                               OMX_EventError,
3401                                               eError,
3402                                               OMX_TI_ErrorMajor,
3403                                               NULL);
3404        goto EXIT;
3405    }
3406    /* Align and add padding for data buffer */
3407    pCompPort->pBufferPrivate[pBufferCnt]->pOriginalBuffer = (*pBuffHead)->pBuffer;
3408    (*pBuffHead)->pBuffer += VIDDEC_PADDING_HALF;
3409    OMX_ALIGN_BUFFER((*pBuffHead)->pBuffer, VIDDEC_ALIGNMENT);
3410#ifdef VIDDEC_WMVPOINTERFIXED
3411    pCompPort->pBufferPrivate[pBufferCnt]->pTempBuffer = (*pBuffHead)->pBuffer;
3412    (*pBuffHead)->nOffset = 0;
3413#endif
3414
3415    (*pBuffHead)->pBuffer = (pCompPort->pBufferPrivate[pBufferCnt]->pBufferHdr->pBuffer);
3416    (*pBuffHead)->nAllocLen = nSizeBytes;
3417    (*pBuffHead)->pAppPrivate = pAppPrivate;
3418    (*pBuffHead)->pPlatformPrivate = NULL;
3419    (*pBuffHead)->pInputPortPrivate = NULL;
3420    (*pBuffHead)->pOutputPortPrivate = NULL;
3421    (*pBuffHead)->nFlags = VIDDEC_CLEARFLAGS;
3422    (*pBuffHead)->pMarkData = NULL;
3423
3424#ifdef __PERF_INSTRUMENTATION__
3425    PERF_ReceivedFrame(pComponentPrivate->pPERFcomp,
3426                       (*pBuffHead)->pBuffer,
3427                       (*pBuffHead)->nAllocLen,
3428                       PERF_ModuleMemory);
3429#endif
3430
3431
3432    if (pCompPort->hTunnelComponent != NULL) {
3433        if (pPortDef->eDir == OMX_DirInput) {
3434            (*pBuffHead)->nInputPortIndex  = nPortIndex;
3435            (*pBuffHead)->nOutputPortIndex = pCompPort->nTunnelPort;
3436        }
3437        else {
3438            (*pBuffHead)->nInputPortIndex  = pCompPort->nTunnelPort;
3439            (*pBuffHead)->nOutputPortIndex = nPortIndex;
3440        }
3441    }
3442    else {
3443        if (nPortIndex == VIDDEC_INPUT_PORT) {
3444            (*pBuffHead)->nInputPortIndex  = VIDDEC_INPUT_PORT;
3445            (*pBuffHead)->nOutputPortIndex = VIDDEC_NOPORT;
3446        }
3447        else {
3448            (*pBuffHead)->nInputPortIndex  = VIDDEC_NOPORT;
3449            (*pBuffHead)->nOutputPortIndex = VIDDEC_OUTPUT_PORT;
3450        }
3451    }
3452
3453    if (nPortIndex == VIDDEC_INPUT_PORT) {
3454        (*pBuffHead)->pInputPortPrivate = pCompPort->pBufferPrivate[pBufferCnt];
3455        (*pBuffHead)->pOutputPortPrivate = NULL;
3456    }
3457    else {
3458        (*pBuffHead)->pOutputPortPrivate = pCompPort->pBufferPrivate[pBufferCnt];
3459        (*pBuffHead)->pInputPortPrivate = NULL;
3460    }
3461    pCompPort->pBufferPrivate[pBufferCnt]->bAllocByComponent = OMX_TRUE;
3462
3463    if (pCompPort->hTunnelComponent != NULL) {
3464        pCompPort->pBufferPrivate[pBufferCnt]->eBufferOwner = VIDDEC_BUFFER_WITH_TUNNELEDCOMP;
3465    }
3466    else {
3467        pCompPort->pBufferPrivate[pBufferCnt]->eBufferOwner = VIDDEC_BUFFER_WITH_CLIENT;
3468    }
3469
3470    pPortDef->nBufferSize = nSizeBytes;
3471    OMX_PRBUFFER1(pComponentPrivate->dbg, "pBuffHead 0x%p nAllocLen 0x%lx pBuffer %p eBufferOwner %d\n",
3472        *pBuffHead, (*pBuffHead)->nAllocLen, pCompPort->pBufferPrivate[pBufferCnt]->pBufferHdr->pBuffer,
3473        pCompPort->pBufferPrivate[pBufferCnt]->eBufferOwner);
3474
3475    eError = VIDDEC_Allocate_DSPResources(pComponentPrivate, nPortIndex);
3476    if (eError != OMX_ErrorNone) {
3477        OMX_PRDSP4(pComponentPrivate->dbg, "Error: Allocating DSP resources\n");
3478        eError = OMX_ErrorInsufficientResources;
3479        pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
3480                                               pComponentPrivate->pHandle->pApplicationPrivate,
3481                                               OMX_EventError,
3482                                               eError,
3483                                               OMX_TI_ErrorMajor,
3484                                               NULL);
3485        goto EXIT;
3486    }
3487
3488    pCompPort->nBufferCnt++;
3489    pCompPort->pBufferPrivate[pBufferCnt]->nNumber = pCompPort->nBufferCnt;
3490
3491    OMX_PRBUFFER1(pComponentPrivate->dbg, "eBufferOwner 0x%x nBufferCountActual %lu nBufferCnt %u nnumber %lu\n",
3492        pCompPort->pBufferPrivate[pBufferCnt]->eBufferOwner, pPortDef->nBufferCountActual,
3493        pCompPort->nBufferCnt,pCompPort->pBufferPrivate[pBufferCnt]->nNumber);
3494    if (pCompPort->nBufferCnt == pPortDef->nBufferCountActual) {
3495        pPortDef->bPopulated = OMX_TRUE;
3496#ifndef UNDER_CE
3497            if (nPortIndex == VIDDEC_INPUT_PORT) {
3498                VIDDEC_PTHREAD_SEMAPHORE_POST(pComponentPrivate->sInSemaphore);
3499            }
3500            else {
3501                VIDDEC_PTHREAD_SEMAPHORE_POST(pComponentPrivate->sOutSemaphore);
3502            }
3503#endif
3504    }
3505
3506EXIT:
3507    if (pComponentPrivate)
3508        OMX_PRBUFFER1(pComponentPrivate->dbg, "---Exiting eError 0x%x\n", \
3509                                                         eError);
3510    return eError;
3511}
3512
3513#ifdef KHRONOS_1_1
3514/*-------------------------------------------------------------------*/
3515/**
3516  * IsTIOMXComponent()
3517  *
3518  * Check if the component is TI component.
3519  *
3520  * @param hTunneledComp Component Tunnel Pipe
3521  *
3522  * @retval OMX_TRUE   Input is a TI component.
3523  *         OMX_FALSE  Input is a not a TI component.
3524  *
3525  **/
3526/*-------------------------------------------------------------------*/
3527static OMX_BOOL IsTIOMXComponent(OMX_HANDLETYPE hComp, struct OMX_TI_Debug *dbg)
3528{
3529    OMX_ERRORTYPE eError = OMX_ErrorNone;
3530    /*OMX_PARAM_BUFFERSUPPLIERTYPE sBufferSupplier;*/
3531    OMX_STRING pTunnelcComponentName = NULL;
3532    OMX_VERSIONTYPE* pTunnelComponentVersion = NULL;
3533    OMX_VERSIONTYPE* pSpecVersion = NULL;
3534    OMX_UUIDTYPE* pComponentUUID = NULL;
3535    char *pSubstring = NULL;
3536    OMX_BOOL bResult = OMX_TRUE;
3537
3538    pTunnelcComponentName = malloc(128);
3539    if (pTunnelcComponentName == NULL) {
3540        eError = OMX_ErrorInsufficientResources;
3541        OMX_TRACE4(*dbg, "Error in Video Decoder OMX_ErrorInsufficientResources\n");
3542        goto EXIT;
3543    }
3544
3545    pTunnelComponentVersion = malloc(sizeof(OMX_VERSIONTYPE));
3546    if (pTunnelComponentVersion == NULL) {
3547        OMX_TRACE4(*dbg, "Error in Video Decoder OMX_ErrorInsufficientResources\n");
3548        eError = OMX_ErrorInsufficientResources;
3549        goto EXIT;
3550    }
3551
3552    pSpecVersion = malloc(sizeof(OMX_VERSIONTYPE));
3553    if (pSpecVersion == NULL) {
3554        OMX_TRACE4(*dbg, "Error in Video Decoder OMX_ErrorInsufficientResources\n");
3555        eError = OMX_ErrorInsufficientResources;
3556        goto EXIT;
3557    }
3558
3559    pComponentUUID = malloc(sizeof(OMX_UUIDTYPE));
3560    if (pComponentUUID == NULL) {
3561        OMX_TRACE4(*dbg, "Error in Video Decoder OMX_ErrorInsufficientResources\n");
3562        eError = OMX_ErrorInsufficientResources;
3563        goto EXIT;
3564    }
3565
3566    eError = OMX_GetComponentVersion (hComp, pTunnelcComponentName, pTunnelComponentVersion, pSpecVersion, pComponentUUID);
3567
3568    /* Check if tunneled component is a TI component */
3569    pSubstring = strstr(pTunnelcComponentName, "OMX.TI.");
3570    if(pSubstring == NULL) {
3571                bResult = OMX_FALSE;
3572    }
3573
3574EXIT:
3575    free(pTunnelcComponentName);
3576    free(pTunnelComponentVersion);
3577    free(pSpecVersion);
3578    free(pComponentUUID);
3579
3580    return bResult;
3581} /* End of IsTIOMXComponent */
3582#endif
3583
3584/*----------------------------------------------------------------------------*/
3585/**
3586  *  VIDDEC_VerifyTunnelConnection()
3587  *
3588  *
3589  *
3590  *
3591  * @param
3592  * @param
3593  * @param
3594  *
3595  * @retval OMX_NoError              Success, ready to roll
3596  *         OMX_Error_BadParameter   The input parameter pointer is null
3597  **/
3598/*----------------------------------------------------------------------------*/
3599
3600static OMX_ERRORTYPE VIDDEC_VerifyTunnelConnection (VIDDEC_PORT_TYPE *pPort,
3601                                             OMX_HANDLETYPE hTunneledComp,
3602                                             OMX_PARAM_PORTDEFINITIONTYPE* pPortDef)
3603{
3604    OMX_PARAM_PORTDEFINITIONTYPE sPortDef;
3605    OMX_ERRORTYPE eError = OMX_ErrorNone;
3606
3607    sPortDef.nSize                    = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
3608    sPortDef.nVersion.s.nVersionMajor = VERSION_MAJOR;
3609    sPortDef.nVersion.s.nVersionMinor = VERSION_MINOR;
3610    sPortDef.nVersion.s.nRevision     = VERSION_REVISION;
3611    sPortDef.nVersion.s.nStep         = VERSION_STEP;
3612    sPortDef.nPortIndex               = pPort->nTunnelPort;
3613
3614    eError = OMX_GetParameter(hTunneledComp, OMX_IndexParamPortDefinition, &sPortDef);
3615    if (eError != OMX_ErrorNone) {
3616        return eError;
3617    }
3618
3619    switch (pPortDef->eDomain) {
3620        case OMX_PortDomainOther:
3621            if (sPortDef.format.other.eFormat != pPortDef->format.other.eFormat) {
3622                pPort->hTunnelComponent = 0;
3623                pPort->nTunnelPort      = 0;
3624                return OMX_ErrorPortsNotCompatible;
3625            }
3626            break;
3627        case OMX_PortDomainAudio:
3628            if (sPortDef.format.audio.eEncoding != pPortDef->format.audio.eEncoding) {
3629                pPort->hTunnelComponent = 0;
3630                pPort->nTunnelPort      = 0;
3631                return OMX_ErrorPortsNotCompatible;
3632            }
3633            break;
3634        case OMX_PortDomainVideo:
3635            if (sPortDef.format.video.eCompressionFormat != pPortDef->format.video.eCompressionFormat) {
3636                pPort->hTunnelComponent = 0;
3637                pPort->nTunnelPort      = 0;
3638                return OMX_ErrorPortsNotCompatible;
3639            }
3640            break;
3641        case OMX_PortDomainImage:
3642            if (sPortDef.format.image.eCompressionFormat != pPortDef->format.image.eCompressionFormat) {
3643                pPort->hTunnelComponent = 0;
3644                pPort->nTunnelPort      = 0;
3645                return OMX_ErrorPortsNotCompatible;
3646            }
3647            break;
3648        default:
3649            pPort->hTunnelComponent = 0;
3650            pPort->nTunnelPort      = 0;
3651            return OMX_ErrorPortsNotCompatible;     /* Our current port is not set up correctly */
3652    }
3653    return eError;
3654}
3655
3656/*----------------------------------------------------------------------------*/
3657/**
3658  *  VIDDEC_ComponentTunnelRequest() Sets application callbacks to the component
3659  *
3660  * This method will update application callbacks
3661  * the application.
3662  *
3663  * @param pComp         handle for this instance of the component
3664  * @param pCallBacks    application callbacks
3665  * @param ptr
3666  *
3667  * @retval OMX_NoError              Success, ready to roll
3668  *         OMX_Error_BadParameter   The input parameter pointer is null
3669  **/
3670/*----------------------------------------------------------------------------*/
3671
3672static OMX_ERRORTYPE VIDDEC_ComponentTunnelRequest (OMX_IN OMX_HANDLETYPE hComponent,
3673                                             OMX_IN OMX_U32 nPort,
3674                                             OMX_IN OMX_HANDLETYPE hTunneledComp,
3675                                             OMX_IN OMX_U32 nTunneledPort,
3676                                             OMX_INOUT OMX_TUNNELSETUPTYPE* pTunnelSetup)
3677{
3678    OMX_ERRORTYPE eError = OMX_ErrorNone;
3679    OMX_COMPONENTTYPE* pHandle = NULL;
3680    VIDDEC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
3681    OMX_PARAM_BUFFERSUPPLIERTYPE sBufferSupplier;
3682    VIDDEC_PORT_TYPE *pPort = NULL;
3683    OMX_PARAM_PORTDEFINITIONTYPE* pPortDef = NULL;
3684
3685    OMX_CONF_CHECK_CMD(hComponent, OMX_TRUE, OMX_TRUE);
3686
3687    pHandle = (OMX_COMPONENTTYPE*)hComponent;
3688    pComponentPrivate = (VIDDEC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate;
3689
3690    pPort = pComponentPrivate->pCompPort[nPort];
3691    pPortDef = pComponentPrivate->pInPortDef;
3692
3693    if (nPort == pComponentPrivate->pInPortFormat->nPortIndex) {
3694        pPortDef = pComponentPrivate->pInPortDef;
3695    }
3696    else if (nPort == pComponentPrivate->pOutPortFormat->nPortIndex) {
3697        pPortDef = pComponentPrivate->pOutPortDef;
3698    }
3699
3700    if (pTunnelSetup == NULL || hTunneledComp == 0) {
3701        pPort->hTunnelComponent = NULL;
3702        pPort->nTunnelPort = 0;
3703        pPort->eSupplierSetting = OMX_BufferSupplyUnspecified;
3704    }
3705    else {
3706        if (pPortDef->eDir != OMX_DirInput && pPortDef->eDir != OMX_DirOutput) {
3707            return OMX_ErrorBadParameter;
3708        }
3709
3710#ifdef KHRONOS_1_1
3711        /* Check if the other component is developed by TI */
3712        if(IsTIOMXComponent(hTunneledComp, &pComponentPrivate->dbg) != OMX_TRUE) {
3713            eError = OMX_ErrorTunnelingUnsupported;
3714            goto EXIT;
3715        }
3716#endif
3717        pPort->hTunnelComponent = hTunneledComp;
3718        pPort->nTunnelPort = nTunneledPort;
3719
3720        if (pPortDef->eDir == OMX_DirOutput) {
3721            pTunnelSetup->eSupplier = pPort->eSupplierSetting;
3722        }
3723        else {
3724            /* Component is the input (sink of data) */
3725            eError = VIDDEC_VerifyTunnelConnection(pPort, hTunneledComp, pPortDef);
3726            if (OMX_ErrorNone != eError) {
3727                OMX_ERROR4(pComponentPrivate->dbg, "Error: PP VerifyTunnelConnection failed\n");
3728                /* Invalid connection formats. Return eError */
3729                return OMX_ErrorPortsNotCompatible;
3730            }
3731
3732            /* If specified, obey output port's preferences. Otherwise choose output */
3733            pPort->eSupplierSetting = pTunnelSetup->eSupplier;
3734            if (OMX_BufferSupplyUnspecified == pPort->eSupplierSetting) {
3735                pPort->eSupplierSetting = pTunnelSetup->eSupplier = OMX_BufferSupplyOutput;
3736            }
3737
3738            /* Tell the output port who the supplier is */
3739            sBufferSupplier.nSize                    = sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE);
3740            sBufferSupplier.nVersion.s.nVersionMajor = VERSION_MAJOR;
3741            sBufferSupplier.nVersion.s.nVersionMinor = VERSION_MAJOR;
3742            sBufferSupplier.nVersion.s.nRevision     = VERSION_REVISION;
3743            sBufferSupplier.nVersion.s.nStep         = VERSION_STEP;
3744            sBufferSupplier.nPortIndex               = nTunneledPort;
3745            sBufferSupplier.eBufferSupplier          = pPort->eSupplierSetting;
3746
3747            eError = OMX_SetParameter(hTunneledComp, OMX_IndexParamCompBufferSupplier, &sBufferSupplier);
3748
3749            eError = OMX_GetParameter(hTunneledComp, OMX_IndexParamCompBufferSupplier, &sBufferSupplier);
3750
3751            if (sBufferSupplier.eBufferSupplier != pPort->eSupplierSetting) {
3752                OMX_ERROR4(pComponentPrivate->dbg, "SetParameter: OMX_IndexParamCompBufferSupplier failed to change setting\n" );
3753                return OMX_ErrorUndefined;
3754            }
3755        }
3756    }
3757
3758EXIT:
3759    return eError;
3760}
3761
3762/*----------------------------------------------------------------------------*/
3763/**
3764  *  VIDDEC_Allocate_DSPResources()
3765  *
3766  *
3767  *
3768  *
3769  * @param
3770  * @param
3771  * @param
3772  *
3773  * @retval OMX_NoError              Success, ready to roll
3774  *         OMX_Error_BadParameter   The input parameter pointer is null
3775  **/
3776/*----------------------------------------------------------------------------*/
3777
3778static OMX_ERRORTYPE VIDDEC_Allocate_DSPResources(VIDDEC_COMPONENT_PRIVATE *pComponentPrivate, OMX_IN OMX_U32 nPortIndex)
3779{
3780    OMX_ERRORTYPE eError = OMX_ErrorNone;
3781    /*todo remove array, fix it to variable,
3782    it means just one variable for both index*/
3783    void *pUalgOutParams[1];
3784    void *pUalgInpParams[1];
3785    OMX_U8* pTemp = NULL;
3786    OMX_U8 nBufferCnt = pComponentPrivate->pCompPort[nPortIndex]->nBufferCnt;
3787    OMX_PARAM_PORTDEFINITIONTYPE* pPortDefIn = pComponentPrivate->pInPortDef;
3788    VIDDEC_BUFFER_PRIVATE* pBufferPrivate = NULL;
3789
3790    pBufferPrivate =
3791         (VIDDEC_BUFFER_PRIVATE*)(pComponentPrivate->pCompPort[nPortIndex]->pBufferPrivate[nBufferCnt]);
3792
3793    if (nPortIndex == pComponentPrivate->pInPortFormat->nPortIndex) {
3794        if (pPortDefIn->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 ||
3795            pPortDefIn->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) {
3796            OMX_MALLOC_STRUCT_SIZED(pUalgInpParams[0], MP4VD_GPP_SN_UALGInputParams, sizeof(MP4VD_GPP_SN_UALGInputParams) + VIDDEC_PADDING_FULL,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel1]);
3797            /*pUalgInpParams[0] = (MP4VD_GPP_SN_UALGInputParams*)malloc(sizeof(MP4VD_GPP_SN_UALGInputParams) + VIDDEC_PADDING_FULL);*/
3798            if ((MP4VD_GPP_SN_UALGInputParams*)(!pUalgInpParams[0])) {
3799                OMX_TRACE4(pComponentPrivate->dbg, "Error: Malloc failed\n");
3800                eError = OMX_ErrorInsufficientResources;
3801                goto EXIT;
3802            }
3803            pTemp = (OMX_U8*)pUalgInpParams[0];
3804            pTemp += VIDDEC_PADDING_HALF;
3805            pUalgInpParams[0] = pTemp;
3806            pBufferPrivate->pUalgParam = (MP4VD_GPP_SN_UALGInputParams*)(pUalgInpParams[0]);
3807            pBufferPrivate->nUalgParamSize = sizeof(MP4VD_GPP_SN_UALGInputParams);
3808        }
3809#ifdef VIDDEC_SPARK_CODE
3810        else if (VIDDEC_SPARKCHECK) {
3811            OMX_MALLOC_STRUCT_SIZED(pUalgInpParams[0], SPARKVD_GPP_SN_UALGInputParams, sizeof(SPARKVD_GPP_SN_UALGInputParams) + VIDDEC_PADDING_FULL,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel1]);
3812            /*pUalgInpParams[0] = (SPARKVD_GPP_SN_UALGInputParams*)malloc(sizeof(SPARKVD_GPP_SN_UALGInputParams) + VIDDEC_PADDING_FULL);*/
3813            if ((SPARKVD_GPP_SN_UALGInputParams*)(!pUalgInpParams[0])) {
3814                OMX_TRACE4(pComponentPrivate->dbg, "Error: Malloc failed\n");
3815                eError = OMX_ErrorInsufficientResources;
3816                goto EXIT;
3817            }
3818            pTemp = (OMX_U8*)pUalgInpParams[0];
3819            pTemp += VIDDEC_PADDING_HALF;
3820            pUalgInpParams[0] = pTemp;
3821            pBufferPrivate->pUalgParam = (SPARKVD_GPP_SN_UALGInputParams*)(pUalgInpParams[0]);
3822            pBufferPrivate->nUalgParamSize = sizeof(SPARKVD_GPP_SN_UALGInputParams);
3823        }
3824#endif
3825        else if (pPortDefIn->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG2) {
3826            OMX_MALLOC_STRUCT_SIZED(pUalgInpParams[0], MP2VDEC_UALGInputParam, sizeof(MP2VDEC_UALGInputParam) + VIDDEC_PADDING_FULL,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel1]);
3827            /*pUalgInpParams[0] = (MP2VDEC_UALGInputParam*)malloc(sizeof(MP2VDEC_UALGInputParam) + VIDDEC_PADDING_FULL);*/
3828            if ((MP2VDEC_UALGInputParam*)(!pUalgInpParams[0])) {
3829                OMX_TRACE4(pComponentPrivate->dbg, "Error: Malloc failed\n");
3830                eError = OMX_ErrorInsufficientResources;
3831                goto EXIT;
3832            }
3833            pTemp = (OMX_U8*)pUalgInpParams[0];
3834            pTemp += VIDDEC_PADDING_HALF;
3835            pUalgInpParams[0] = pTemp;
3836            pBufferPrivate->pUalgParam = (MP2VDEC_UALGInputParam*)(pUalgInpParams[0]);
3837            pBufferPrivate->nUalgParamSize = sizeof(MP2VDEC_UALGInputParam);
3838        }
3839        else if (pPortDefIn->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
3840            OMX_MALLOC_STRUCT_SIZED(pUalgInpParams[0], H264VDEC_UALGInputParam, sizeof(H264VDEC_UALGInputParam) + VIDDEC_PADDING_FULL,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel1]);
3841            /*pUalgInpParams[0] = (H264VDEC_UALGInputParam*)malloc(sizeof(H264VDEC_UALGInputParam) + VIDDEC_PADDING_FULL);*/
3842            if ((H264VDEC_UALGInputParam*)(!pUalgInpParams[0])) {
3843                OMX_TRACE4(pComponentPrivate->dbg, "Error: Malloc failed\n");
3844                eError = OMX_ErrorInsufficientResources;
3845                goto EXIT;
3846            }
3847            pTemp = (OMX_U8*)pUalgInpParams[0];
3848            pTemp += VIDDEC_PADDING_HALF;
3849            pUalgInpParams[0] = pTemp;
3850            pBufferPrivate->pUalgParam = (H264VDEC_UALGInputParam*)(pUalgInpParams[0]);
3851            pBufferPrivate->nUalgParamSize = sizeof(H264VDEC_UALGInputParam);
3852        }
3853        else if (pPortDefIn->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV) {
3854            OMX_MALLOC_STRUCT_SIZED(pUalgInpParams[0], WMV9DEC_UALGInputParam, sizeof(WMV9DEC_UALGInputParam) + VIDDEC_PADDING_FULL,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel1]);
3855            /*pUalgInpParams[0] = (WMV9DEC_UALGInputParam*)malloc(sizeof(WMV9DEC_UALGInputParam) + VIDDEC_PADDING_FULL);*/
3856            if ((WMV9DEC_UALGInputParam*)(!pUalgInpParams[0])) {
3857                OMX_TRACE4(pComponentPrivate->dbg, "Error: Malloc failed\n");
3858                eError = OMX_ErrorInsufficientResources;
3859                goto EXIT;
3860            }
3861            pTemp = (OMX_U8*)pUalgInpParams[0];
3862            pTemp += VIDDEC_PADDING_HALF;
3863            pUalgInpParams[0] = pTemp;
3864            pBufferPrivate->pUalgParam = (WMV9DEC_UALGInputParam*)(pUalgInpParams[0]);
3865            pBufferPrivate->nUalgParamSize = sizeof(WMV9DEC_UALGInputParam);
3866        }
3867        else {
3868            OMX_ERROR4(pComponentPrivate->dbg, "Error: Invalid Compression Type\n");
3869            goto EXIT;
3870        }
3871    }
3872    else if (nPortIndex == pComponentPrivate->pOutPortFormat->nPortIndex) {
3873        if (pPortDefIn->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 ||
3874            pPortDefIn->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) {
3875            OMX_MALLOC_STRUCT_SIZED(pUalgOutParams[0], MP4VD_GPP_SN_UALGOutputParams, sizeof(MP4VD_GPP_SN_UALGOutputParams) + VIDDEC_PADDING_FULL,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel1]);
3876            /*pUalgOutParams[0] = (MP4VD_GPP_SN_UALGOutputParams*)malloc(sizeof(MP4VD_GPP_SN_UALGOutputParams) + VIDDEC_PADDING_FULL);*/
3877            if ((MP4VD_GPP_SN_UALGOutputParams*)(!pUalgOutParams[0])) {
3878                OMX_TRACE4(pComponentPrivate->dbg, "Error: Malloc failed\n");
3879                eError = OMX_ErrorInsufficientResources;
3880                goto EXIT;
3881            }
3882            pTemp = (OMX_U8*)pUalgOutParams[0];
3883            pTemp += VIDDEC_PADDING_HALF;
3884            pUalgOutParams[0] = pTemp;
3885            pBufferPrivate->pUalgParam = (MP4VD_GPP_SN_UALGOutputParams*)(pUalgOutParams[0]);
3886            pBufferPrivate->nUalgParamSize = sizeof(MP4VD_GPP_SN_UALGOutputParams);
3887        }
3888#ifdef VIDDEC_SPARK_CODE
3889        else if (VIDDEC_SPARKCHECK) {
3890            OMX_MALLOC_STRUCT_SIZED(pUalgOutParams[0], SPARKVD_GPP_SN_UALGOutputParams, sizeof(SPARKVD_GPP_SN_UALGOutputParams) + VIDDEC_PADDING_FULL,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel1]);
3891            /*pUalgOutParams[0] = (SPARKVD_GPP_SN_UALGOutputParams*)malloc(sizeof(SPARKVD_GPP_SN_UALGOutputParams) + VIDDEC_PADDING_FULL);*/
3892            if ((SPARKVD_GPP_SN_UALGOutputParams*)(!pUalgOutParams[0])) {
3893                OMX_TRACE4(pComponentPrivate->dbg, "Error: Malloc failed\n");
3894                eError = OMX_ErrorInsufficientResources;
3895                goto EXIT;
3896            }
3897            pTemp = (OMX_U8*)pUalgOutParams[0];
3898            pTemp += VIDDEC_PADDING_HALF;
3899            pUalgOutParams[0] = pTemp;
3900            pBufferPrivate->pUalgParam = (SPARKVD_GPP_SN_UALGOutputParams*)(pUalgOutParams[0]);
3901            pBufferPrivate->nUalgParamSize = sizeof(SPARKVD_GPP_SN_UALGOutputParams);
3902        }
3903#endif
3904        else if (pPortDefIn->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG2) {
3905            OMX_MALLOC_STRUCT_SIZED(pUalgOutParams[0], MP2VDEC_UALGOutputParam, sizeof(MP2VDEC_UALGOutputParam) + VIDDEC_PADDING_FULL,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel1]);
3906            /*pUalgOutParams[0] = (MP2VDEC_UALGOutputParam*)malloc(sizeof(MP2VDEC_UALGOutputParam) + VIDDEC_PADDING_FULL);*/
3907            if ((MP2VDEC_UALGOutputParam*)(!pUalgOutParams[0])) {
3908                OMX_TRACE4(pComponentPrivate->dbg, "Error: Malloc failed\n");
3909                eError = OMX_ErrorInsufficientResources;
3910                goto EXIT;
3911            }
3912            pTemp = (OMX_U8*)pUalgOutParams[0];
3913            pTemp += VIDDEC_PADDING_HALF;
3914            pUalgOutParams[0] = pTemp;
3915            pBufferPrivate->pUalgParam = (MP2VDEC_UALGOutputParam*)(pUalgOutParams[0]);
3916            pBufferPrivate->nUalgParamSize = sizeof(MP2VDEC_UALGOutputParam);
3917        }
3918        else if (pPortDefIn->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
3919            OMX_MALLOC_STRUCT_SIZED(pUalgOutParams[0], H264VDEC_UALGOutputParam, sizeof(H264VDEC_UALGOutputParam) + VIDDEC_PADDING_FULL,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel1]);
3920            /*pUalgOutParams[0] = (H264VDEC_UALGOutputParam*)malloc(sizeof(H264VDEC_UALGOutputParam) + VIDDEC_PADDING_FULL);*/
3921            if ((H264VDEC_UALGOutputParam*)(!pUalgOutParams[0])) {
3922                OMX_TRACE4(pComponentPrivate->dbg, "Error: Malloc failed\n");
3923                eError = OMX_ErrorInsufficientResources;
3924                goto EXIT;
3925            }
3926            pTemp = (OMX_U8*)pUalgOutParams[0];
3927            pTemp += VIDDEC_PADDING_HALF;
3928            pUalgOutParams[0] = pTemp;
3929            pBufferPrivate->pUalgParam = (H264VDEC_UALGOutputParam*)(pUalgOutParams[0]);
3930            pBufferPrivate->nUalgParamSize = sizeof(H264VDEC_UALGOutputParam);
3931        }
3932        else if (pPortDefIn->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV) {
3933            OMX_MALLOC_STRUCT_SIZED(pUalgOutParams[0], WMV9DEC_UALGOutputParam, sizeof(WMV9DEC_UALGOutputParam) + VIDDEC_PADDING_FULL,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel1]);
3934            /*pUalgOutParams[0] = (WMV9DEC_UALGOutputParam*)malloc(sizeof(WMV9DEC_UALGOutputParam) + VIDDEC_PADDING_FULL);*/
3935            if ((WMV9DEC_UALGOutputParam*)(!pUalgOutParams[0])) {
3936                OMX_TRACE4(pComponentPrivate->dbg, "Error: Malloc failed\n");
3937                eError = OMX_ErrorInsufficientResources;
3938                goto EXIT;
3939            }
3940            pTemp = (OMX_U8*)pUalgOutParams[0];
3941            pTemp += VIDDEC_PADDING_HALF;
3942            pUalgOutParams[0] = pTemp;
3943            pBufferPrivate->pUalgParam = (WMV9DEC_UALGOutputParam*)(pUalgOutParams[0]);
3944            pBufferPrivate->nUalgParamSize = sizeof(WMV9DEC_UALGOutputParam);
3945        }
3946        else {
3947            OMX_ERROR4(pComponentPrivate->dbg, "Error: Invalid Compression Type\n");
3948            eError = OMX_ErrorUnsupportedSetting;
3949            goto EXIT;
3950        }
3951    }
3952    else {
3953        eError = OMX_ErrorBadPortIndex;
3954        goto EXIT;
3955    }
3956
3957EXIT:
3958    return eError;
3959}
3960
3961/*-------------------------------------------------------------------*/
3962/**
3963  * VIDDEC_GetExtensionIndex()
3964  *
3965  *
3966  *
3967  * @retval OMX_ErrorNone                    Successful operation.
3968  *         OMX_ErrorBadParameter            Invalid operation.
3969  *         OMX_ErrorIncorrectStateOperation If called when port is disabled.
3970  **/
3971/*-------------------------------------------------------------------*/
3972static OMX_ERRORTYPE VIDDEC_GetExtensionIndex(OMX_IN OMX_HANDLETYPE hComponent, OMX_IN OMX_STRING cParameterName, OMX_OUT OMX_INDEXTYPE* pIndexType)
3973{
3974    int nIndex;
3975    OMX_ERRORTYPE eError = OMX_ErrorUndefined;
3976
3977    OMX_CONF_CHECK_CMD(hComponent, OMX_TRUE, OMX_TRUE);
3978    for(nIndex = 0; nIndex < sizeof(sVideoDecCustomParams)/sizeof(VIDDEC_CUSTOM_PARAM); nIndex++) {
3979        if(strcmp((char *)cParameterName, (char *)&(sVideoDecCustomParams[nIndex].cCustomParamName)) == 0) {
3980            *pIndexType = sVideoDecCustomParams[nIndex].nCustomParamIndex;
3981            eError = OMX_ErrorNone;
3982            break;
3983        }
3984    }
3985EXIT:
3986    return eError;
3987}
3988
3989#ifdef KHRONOS_1_1
3990/*-------------------------------------------------------------------*/
3991/**
3992  * ComponentRoleEnum()
3993  *
3994  *
3995  *
3996  * @retval OMX_ErrorNone                    Successful operation.
3997  *         OMX_ErrorBadParameter            Invalid operation.
3998  *         OMX_ErrorIncorrectStateOperation If called when port is disabled.
3999  **/
4000/*-------------------------------------------------------------------*/
4001
4002static OMX_ERRORTYPE ComponentRoleEnum(
4003        OMX_IN OMX_HANDLETYPE hComponent,
4004                OMX_OUT OMX_U8 *cRole,
4005                OMX_IN OMX_U32 nIndex)
4006{
4007    VIDDEC_COMPONENT_PRIVATE *pComponentPrivate;
4008
4009    OMX_ERRORTYPE eError = OMX_ErrorNone;
4010    pComponentPrivate = (VIDDEC_COMPONENT_PRIVATE *)(((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate);
4011
4012    memset(cRole, 0x0, OMX_MAX_STRINGNAME_SIZE);
4013    switch (nIndex) {
4014        case VIDDEC_DEFAULT_INPUT_INDEX_H263:
4015            eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_H263);
4016            if( pComponentPrivate->pOutPortFormat->eColorFormat != VIDDEC_COLORFORMAT420) {
4017                eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_PLANAR420);
4018            }
4019            strcpy((char*)cRole, VIDDEC_COMPONENTROLES_H263);
4020            break;
4021        case VIDDEC_DEFAULT_INPUT_INDEX_H264:
4022            eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_H264);
4023            if( pComponentPrivate->pOutPortFormat->eColorFormat != VIDDEC_COLORFORMAT420) {
4024                eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_PLANAR420);
4025            }
4026            strcpy((char*)cRole, VIDDEC_COMPONENTROLES_H264);
4027            break;
4028        case VIDDEC_DEFAULT_INPUT_INDEX_MPEG2:
4029            eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_MPEG2);
4030            if( pComponentPrivate->pOutPortFormat->eColorFormat != VIDDEC_COLORFORMAT420) {
4031                eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_PLANAR420);
4032            }
4033            strcpy((char*)cRole, VIDDEC_COMPONENTROLES_MPEG2);
4034            break;
4035        case VIDDEC_DEFAULT_INPUT_INDEX_MPEG4:
4036            eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_MPEG4);
4037            if( pComponentPrivate->pOutPortFormat->eColorFormat != VIDDEC_COLORFORMAT420) {
4038                eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_PLANAR420);
4039            }
4040            strcpy((char*)cRole, VIDDEC_COMPONENTROLES_MPEG4);
4041            break;
4042        case VIDDEC_DEFAULT_INPUT_INDEX_WMV9:
4043            eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_WMV9);
4044            if( pComponentPrivate->pOutPortFormat->eColorFormat != VIDDEC_COLORFORMAT420) {
4045                eError = VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_PLANAR420);
4046            }
4047            strcpy((char*)cRole, VIDDEC_COMPONENTROLES_WMV9);
4048            break;
4049        /*todo add spark, it was not added because it is not in khronos spec, yet*/
4050        default:
4051            eError = OMX_ErrorNoMore;
4052            break;
4053    }
4054    if(eError != OMX_ErrorNone) {
4055        goto EXIT;
4056    }
4057
4058EXIT:
4059    return eError;
4060}
4061#endif
4062
4063