Home | History | Annotate | Download | only in src
      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_Dec_Utils.c
     30 *
     31 * This file implements OMX Component for MPEG-4 decoder that
     32 * is fully compliant with the Khronos OMX specification 1.0.
     33 *
     34 * @path  $(CSLPATH)\src
     35 *
     36 * @rev  0.1
     37 */
     38 /* -------------------------------------------------------------------------- */
     39 /* =============================================================================
     40 *!
     41 *! Revision History
     42 *! ===================================
     43 *!
     44 *! 02-Feb-2006 mf: Revisions appear in reverse chronological order;
     45 *! that is, newest first.  The date format is dd-Mon-yyyy.
     46 * =========================================================================== */
     47 
     48 /* ------compilation control switches ----------------------------------------*/
     49 /*******************************************************************************
     50 *  INCLUDE FILES
     51 *******************************************************************************/
     52 /* ----- system and platform files -------------------------------------------*/
     53 #include "OMX_VideoDecoder.h"
     54 #include "OMX_VideoDec_Utils.h"
     55 #include "OMX_VideoDec_DSP.h"
     56 #include "OMX_VideoDec_Thread.h"
     57 #define LOG_TAG "TI_Video_Decoder"
     58 /*----------------------------------------------------------------------------*/
     59 /**
     60   * VIDDEC_GetRMFrecuency() Return the value for frecuecny to use RM.
     61   **/
     62 /*----------------------------------------------------------------------------*/
     63 OMX_U32 VIDDEC_GetRMFrecuency(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate)
     64 {
     65    OMX_U32 nReturnValue = VIDDEC_MPU;
     66 
     67    OMX_PRINT1(pComponentPrivate->dbg, "+++ENTERING\n");
     68 #ifdef RESOURCE_MANAGER_ENABLED
     69         /*resolution for greater than CIF*/
     70         if ((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth > VIDDEC_CIF_WIDTH) ||
     71             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight > VIDDEC_CIF_HEIGHT)) {
     72             if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
     73                 nReturnValue = VIDDEC_RM_FREC_H264_VGA;
     74             }
     75             else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV) {
     76                 nReturnValue = VIDDEC_RM_FREC_WMV_VGA;
     77             }
     78             else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4) {
     79                 if ((OMX_U16)pComponentPrivate->pInPortDef->format.video.nFrameHeight > VIDDEC_D1MAX_HEIGHT ||
     80                     (OMX_U16)pComponentPrivate->pInPortDef->format.video.nFrameWidth > VIDDEC_D1MAX_WIDTH)
     81                 {
     82                     nReturnValue = VIDDEC_RM_FREC_MPEG4_720P;
     83                 }
     84                 else
     85                 {
     86                     nReturnValue = VIDDEC_RM_FREC_MPEG4_VGA;
     87                 }
     88             }
     89             else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG2) {
     90                 nReturnValue = VIDDEC_RM_FREC_MPEG2_VGA;
     91             }
     92             else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) {
     93                 nReturnValue = VIDDEC_RM_FREC_H263_VGA;
     94             }
     95 #ifdef VIDDEC_SPARK_CODE
     96             else if (VIDDEC_SPARKCHECK) {
     97                 nReturnValue = VIDDEC_RM_FREC_SPARK_VGA;
     98             }
     99 #endif
    100             else {
    101                 nReturnValue = VIDDEC_MPU;
    102             }
    103         }
    104         /*resolution from QCIF up to CIF*/
    105         else if (((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth <= VIDDEC_CIF_WIDTH) &&
    106             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth > VIDDEC_QCIF_WIDTH)) ||
    107             ((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight <= VIDDEC_CIF_HEIGHT) &&
    108             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight > VIDDEC_QCIF_HEIGHT))) {
    109             if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
    110                 nReturnValue = VIDDEC_RM_FREC_H264_CIF;
    111             }
    112             else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV) {
    113                 nReturnValue = VIDDEC_RM_FREC_WMV_CIF;
    114             }
    115             else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4) {
    116                 nReturnValue = VIDDEC_RM_FREC_MPEG4_CIF;
    117             }
    118             else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG2) {
    119                 nReturnValue = VIDDEC_RM_FREC_MPEG2_CIF;
    120             }
    121             else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) {
    122                 nReturnValue = VIDDEC_RM_FREC_H263_CIF;
    123             }
    124 #ifdef VIDDEC_SPARK_CODE
    125             else if (VIDDEC_SPARKCHECK) {
    126                 nReturnValue = VIDDEC_RM_FREC_SPARK_CIF;
    127             }
    128 #endif
    129             else {
    130                 nReturnValue = VIDDEC_MPU;
    131             }
    132         }
    133         /*resolution up to QCIF*/
    134         else if (((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth <= VIDDEC_QCIF_WIDTH) &&
    135             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth >= VIDDEC_MIN_WIDTH)) ||
    136             ((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight <= VIDDEC_QCIF_HEIGHT) &&
    137             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight >= VIDDEC_MIN_HEIGHT))) {
    138             if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
    139                 nReturnValue = VIDDEC_RM_FREC_H264_QCIF;
    140             }
    141             else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV) {
    142                 nReturnValue = VIDDEC_RM_FREC_WMV_QCIF;
    143             }
    144             else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4) {
    145                 nReturnValue = VIDDEC_RM_FREC_MPEG4_QCIF;
    146             }
    147             else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG2) {
    148                 nReturnValue = VIDDEC_RM_FREC_MPEG2_QCIF;
    149             }
    150             else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) {
    151                 nReturnValue = VIDDEC_RM_FREC_H263_QCIF;
    152             }
    153 #ifdef VIDDEC_SPARK_CODE
    154             else if (VIDDEC_SPARKCHECK) {
    155                 nReturnValue = VIDDEC_RM_FREC_SPARK_QCIF;
    156             }
    157 #endif
    158             else {
    159                 nReturnValue = VIDDEC_MPU;
    160             }
    161         }
    162         else {
    163             nReturnValue = VIDDEC_MPU;
    164     }
    165     OMX_PRDSP2(pComponentPrivate->dbg, "Used RM Frec value = %d\n",(int)nReturnValue);
    166 #else
    167     OMX_PRDSP2(pComponentPrivate->dbg, "Used RM Frec defaulted value = %d\n",(int)nReturnValue);
    168 #endif
    169     OMX_PRINT1(pComponentPrivate->dbg, "---EXITING\n");
    170     return nReturnValue;
    171 
    172 }
    173 
    174 OMX_ERRORTYPE VIDDEC_Queue_Init(VIDDEC_QUEUE_TYPE *queue, VIDDEC_QUEUE_TYPES type)
    175 {
    176     OMX_ERRORTYPE eError = OMX_ErrorUndefined;
    177     OMX_U32 count;
    178 
    179     queue->nHead = 0;
    180     queue->nTail = 0;
    181     queue->nElements = 0;
    182 
    183     switch(type)
    184     {
    185         case VIDDEC_QUEUE_OMX_U32:
    186             queue->Elements = (void*)malloc(VIDDEC_MAX_QUEUE_SIZE*sizeof(OMX_U32));
    187             /*OMX_MALLOC_STRUCT_SIZED(queue->Elements, void, VIDDEC_MAX_QUEUE_SIZE*sizeof(OMX_U32));*/
    188             break;
    189         case VIDDEC_QUEUE_OMX_MARKTYPE:
    190             queue->Elements = (void*)malloc(VIDDEC_MAX_QUEUE_SIZE*sizeof(OMX_MARKTYPE));
    191             /*OMX_MALLOC_STRUCT_SIZED(queue->Elements, void, VIDDEC_MAX_QUEUE_SIZE*sizeof(OMX_MARKTYPE));*/
    192             break;
    193     }
    194 
    195     pthread_mutex_init(&(queue->mMutex), NULL);
    196 
    197     for(count=0; count < VIDDEC_MAX_QUEUE_SIZE; count++)
    198     {
    199         queue->CounterElements[count] = 0;
    200     }
    201 
    202     eError = OMX_ErrorNone;
    203 /*EXIT:*/
    204     return eError;
    205 }
    206 
    207 OMX_ERRORTYPE VIDDEC_Queue_Flush(VIDDEC_QUEUE_TYPE *queue)
    208 {
    209     OMX_ERRORTYPE eError = OMX_ErrorUndefined;
    210     OMX_U32 count;
    211 
    212     if (pthread_mutex_lock (&(queue->mMutex)) != 0) {
    213         eError = OMX_ErrorUndefined;
    214         goto EXIT;
    215     }
    216     queue->nHead = 0;
    217     queue->nTail = 0;
    218     queue->nElements = 0;
    219 
    220     for(count=0; count < VIDDEC_MAX_QUEUE_SIZE; count++)
    221     {
    222         queue->CounterElements[count] = 0;
    223     }
    224     eError = OMX_ErrorNone;
    225 
    226     if (pthread_mutex_unlock (&(queue->mMutex)) != 0) {
    227         eError = OMX_ErrorUndefined;
    228     }
    229 
    230 EXIT:
    231     return eError;
    232 }
    233 
    234 OMX_ERRORTYPE VIDDEC_Queue_Add(VIDDEC_QUEUE_TYPE *queue, OMX_PTR pElement, VIDDEC_QUEUE_TYPES type)
    235 {
    236     OMX_ERRORTYPE eError = OMX_ErrorUndefined;
    237 
    238     if (pthread_mutex_lock (&(queue->mMutex)) != 0) {
    239         eError = OMX_ErrorUndefined;
    240         goto EXIT;
    241     }
    242     if(queue->nElements == 0)
    243     {
    244         switch(type)
    245         {
    246             case VIDDEC_QUEUE_OMX_U32:
    247                 {
    248                     OMX_U32 *pLocal = (OMX_U32 *)queue->Elements;
    249                     pLocal[queue->nHead] = *(OMX_U32 *)pElement;
    250                 }
    251                 break;
    252             case VIDDEC_QUEUE_OMX_MARKTYPE:
    253                 {
    254                     OMX_MARKTYPE *pLocal = (OMX_MARKTYPE *)queue->Elements;
    255                     pLocal[queue->nHead] = *(OMX_MARKTYPE *)pElement;
    256                     /*memcpy(&pLocal[queue->nHead], pElement, sizeof(OMX_MARKTYPE));*/
    257                 }
    258                 break;
    259         }
    260         queue->CounterElements[queue->nHead] = 1;
    261         queue->nElements++;
    262         eError = OMX_ErrorNone;
    263     }
    264     else
    265     {
    266         switch(type)
    267         {
    268             case VIDDEC_QUEUE_OMX_U32:
    269                 {
    270                     OMX_U32 *pLocal = (OMX_U32 *)queue->Elements;
    271 
    272                     if(pLocal[queue->nHead] == *(OMX_U32 *)pElement)
    273                     {
    274                         queue->CounterElements[queue->nHead]++;
    275                         eError = OMX_ErrorNone;
    276                     }
    277                     else
    278                     {
    279                         if(queue->nElements >= VIDDEC_MAX_QUEUE_SIZE)
    280                         {
    281                             eError = OMX_ErrorInsufficientResources;
    282                             goto UNLOCK;
    283                         }
    284                         queue->nHead++;
    285                         if(queue->nHead >= VIDDEC_MAX_QUEUE_SIZE)
    286                         {
    287                             queue->nHead = 0;
    288                         }
    289                         pLocal[queue->nHead] = *(OMX_U32 *)pElement;
    290                         queue->CounterElements[queue->nHead] = 1;
    291                         queue->nElements++;
    292                     }
    293                 }
    294                 break;
    295             case VIDDEC_QUEUE_OMX_MARKTYPE:
    296                 {
    297                     OMX_MARKTYPE *pLocal = (OMX_MARKTYPE *)queue->Elements;
    298 
    299                     if(pLocal[queue->nHead].hMarkTargetComponent == ((OMX_MARKTYPE *)pElement)->hMarkTargetComponent
    300                         && pLocal[queue->nHead].pMarkData == ((OMX_MARKTYPE *)pElement)->pMarkData)
    301                     {
    302                         queue->CounterElements[queue->nHead]++;
    303                         eError = OMX_ErrorNone;
    304                     }
    305                     else
    306                     {
    307                         if(queue->nElements >= VIDDEC_MAX_QUEUE_SIZE)
    308                         {
    309                             eError = OMX_ErrorInsufficientResources;
    310                             goto UNLOCK;
    311                         }
    312                         queue->nHead++;
    313                         if(queue->nHead >= VIDDEC_MAX_QUEUE_SIZE)
    314                         {
    315                             queue->nHead = 0;
    316                         }
    317                         pLocal[queue->nHead] = *(OMX_MARKTYPE *)pElement;
    318                         queue->CounterElements[queue->nHead] = 1;
    319                         queue->nElements++;
    320                     }
    321                 }
    322                 break;
    323         }
    324 
    325         eError = OMX_ErrorNone;
    326     }
    327 UNLOCK:
    328     if (pthread_mutex_unlock (&(queue->mMutex)) != 0) {
    329         eError = OMX_ErrorUndefined;
    330     }
    331 EXIT:
    332     return eError;
    333 
    334 }
    335 
    336 OMX_ERRORTYPE VIDDEC_Queue_Remove(VIDDEC_QUEUE_TYPE *queue, OMX_PTR pElement, VIDDEC_QUEUE_TYPES type)
    337 {
    338     OMX_ERRORTYPE eError = OMX_ErrorUndefined;
    339 
    340     if (pthread_mutex_lock (&(queue->mMutex)) != 0) {
    341         eError = OMX_ErrorUndefined;
    342         goto EXIT;
    343     }
    344 
    345     if(queue->nElements > 0)
    346     {
    347         if(pElement)
    348         {
    349             switch(type)
    350             {
    351                 case VIDDEC_QUEUE_OMX_U32:
    352                 {
    353                     OMX_U32 *pLocal = (OMX_U32 *)queue->Elements;
    354                     *(OMX_U32 *)pElement = pLocal[queue->nTail];
    355                     break;
    356                 }
    357                 case VIDDEC_QUEUE_OMX_MARKTYPE:
    358                 {
    359                     OMX_MARKTYPE *pLocal = (OMX_MARKTYPE *)queue->Elements;
    360                     *(OMX_MARKTYPE *)pElement = pLocal[queue->nTail];
    361                     break;
    362                 }
    363             }
    364         }
    365         queue->CounterElements[queue->nTail]--;
    366         if(queue->CounterElements[queue->nTail] == 0)
    367         {
    368             queue->nElements--;
    369             if(queue->nElements > 0)
    370             {
    371                 queue->nTail++;
    372                 if(queue->nTail == VIDDEC_MAX_QUEUE_SIZE)
    373                 {
    374                     queue->nTail = 0;
    375                 }
    376             }
    377         }
    378         eError = OMX_ErrorNone;
    379     }
    380 
    381     if (pthread_mutex_unlock (&(queue->mMutex)) != 0) {
    382         eError = OMX_ErrorUndefined;
    383     }
    384 EXIT:
    385     return eError;
    386 }
    387 
    388 OMX_ERRORTYPE VIDDEC_Queue_Get_Tail(VIDDEC_QUEUE_TYPE *queue, OMX_PTR pElement, VIDDEC_QUEUE_TYPES type)
    389 {
    390     OMX_ERRORTYPE eError = OMX_ErrorUndefined;
    391 
    392     if (pthread_mutex_lock (&(queue->mMutex)) != 0) {
    393         eError = OMX_ErrorUndefined;
    394         goto EXIT;
    395     }
    396     if(queue->nElements > 0)
    397     {
    398         switch(type)
    399         {
    400             case VIDDEC_QUEUE_OMX_U32:
    401             {
    402                 OMX_U32 *pLocal = (OMX_U32 *)queue->Elements;
    403                 *(OMX_U32 *)pElement = pLocal[queue->nTail];
    404                 break;
    405             }
    406             case VIDDEC_QUEUE_OMX_MARKTYPE:
    407             {
    408                 OMX_MARKTYPE *pLocal = (OMX_MARKTYPE *)queue->Elements;
    409                 *(OMX_MARKTYPE *)pElement = pLocal[queue->nTail];
    410                 break;
    411             }
    412         }
    413         eError = OMX_ErrorNone;
    414     }
    415     if (pthread_mutex_unlock (&(queue->mMutex)) != 0) {
    416         eError = OMX_ErrorUndefined;
    417     }
    418 
    419 EXIT:
    420     return eError;
    421 }
    422 
    423 OMX_ERRORTYPE VIDDEC_Queue_Replace_Tail(VIDDEC_QUEUE_TYPE *queue, OMX_PTR pElement, VIDDEC_QUEUE_TYPES type)
    424 {
    425     OMX_ERRORTYPE eError = OMX_ErrorUndefined;
    426 
    427     if (pthread_mutex_lock (&(queue->mMutex)) != 0) {
    428         eError = OMX_ErrorUndefined;
    429         goto EXIT;
    430     }
    431     if(queue->nElements > 0)
    432     {
    433         switch(type)
    434         {
    435             case VIDDEC_QUEUE_OMX_U32:
    436             {
    437                 OMX_U32 *pLocal = (OMX_U32 *)queue->Elements;
    438                 if(*(OMX_U32 *)pElement != pLocal[queue->nTail])
    439                 {
    440                     if(queue->CounterElements[queue->nTail] != 1)
    441                     {
    442                         if(queue->nElements >= VIDDEC_MAX_QUEUE_SIZE)
    443                         {
    444                             eError = OMX_ErrorInsufficientResources;
    445                             goto UNLOCK;
    446                         }
    447                         queue->CounterElements[queue->nTail]--;
    448                         queue->nTail--;
    449                         if(queue->nTail >= VIDDEC_MAX_QUEUE_SIZE)
    450                         {
    451                             queue->nTail = VIDDEC_MAX_QUEUE_SIZE-1;
    452                         }
    453                         queue->CounterElements[queue->nTail] = 1;
    454                         queue->nElements++;
    455                     }
    456                     pLocal[queue->nTail] = *(OMX_U32 *)pElement;
    457                     eError = OMX_ErrorNone;
    458                     goto UNLOCK;
    459                 }
    460                 break;
    461             }
    462             case VIDDEC_QUEUE_OMX_MARKTYPE:
    463             {
    464                 OMX_MARKTYPE *pLocal = (OMX_MARKTYPE *)queue->Elements;
    465                 if(pLocal[queue->nTail].hMarkTargetComponent != ((OMX_MARKTYPE *)pElement)->hMarkTargetComponent
    466                     || pLocal[queue->nTail].pMarkData != ((OMX_MARKTYPE *)pElement)->pMarkData)
    467                 {
    468                     if(queue->CounterElements[queue->nTail] != 1)
    469                     {
    470                         if(queue->nElements >= VIDDEC_MAX_QUEUE_SIZE)
    471                         {
    472                             eError = OMX_ErrorInsufficientResources;
    473                             goto UNLOCK;
    474                         }
    475                         queue->CounterElements[queue->nTail]--;
    476                         queue->nTail--;
    477                         if(queue->nTail >= VIDDEC_MAX_QUEUE_SIZE)
    478                         {
    479                             queue->nTail = VIDDEC_MAX_QUEUE_SIZE-1;
    480                         }
    481                         queue->CounterElements[queue->nTail] = 1;
    482                         queue->nElements++;
    483                     }
    484                     pLocal[queue->nTail] = *(OMX_MARKTYPE *)pElement;
    485                     eError = OMX_ErrorNone;
    486                     goto UNLOCK;
    487                 }
    488                 break;
    489             }
    490         }
    491     }
    492 UNLOCK:
    493     if (pthread_mutex_unlock (&(queue->mMutex)) != 0) {
    494         eError = OMX_ErrorUndefined;
    495     }
    496 EXIT:
    497     return eError;
    498 }
    499 
    500 OMX_ERRORTYPE VIDDEC_Queue_Free(VIDDEC_QUEUE_TYPE *queue)
    501 {
    502     OMX_ERRORTYPE eError = OMX_ErrorUndefined;
    503 
    504     queue->nHead = 0;
    505     queue->nTail = 0;
    506     queue->nElements = 0;
    507 
    508     if(queue->Elements)
    509     {
    510         free(queue->Elements);
    511     }
    512     queue->Elements = NULL;
    513 
    514     if (pthread_mutex_destroy (&(queue->mMutex)) != 0) {
    515         eError = OMX_ErrorUndefined;
    516         goto EXIT;
    517     }
    518 
    519     eError = OMX_ErrorNone;
    520 EXIT:
    521     return eError;
    522 }
    523 
    524 /*----------------------------------------------------------------------------*/
    525 /**
    526   * VIDDEC_CircBuf_Init()
    527   **/
    528 /*----------------------------------------------------------------------------*/
    529 OMX_ERRORTYPE VIDDEC_CircBuf_Init(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate, VIDDEC_CBUFFER_TYPE nTypeIndex, VIDDEC_PORT_INDEX nPortIndex)
    530 {
    531     OMX_ERRORTYPE eError = OMX_ErrorNone;
    532     VIDDEC_CIRCULAR_BUFFER *pTempCBuffer = NULL;
    533     OMX_U32 nCount = 0;
    534 
    535     if(nTypeIndex == VIDDEC_CBUFFER_TIMESTAMP){
    536         pTempCBuffer = &pComponentPrivate->pCompPort[nPortIndex]->eTimeStamp;
    537     }
    538     else {
    539         eError = OMX_ErrorBadParameter;
    540         return eError;
    541     }
    542 #ifdef VIDDEC_CBUFFER_LOCK
    543     if(pTempCBuffer->m_lock != NULL) {
    544         free(pTempCBuffer->m_lock);
    545         pTempCBuffer->m_lock = NULL;
    546     }
    547     OMX_MALLOC_STRUCT(pTempCBuffer->m_lock, pthread_mutex_t,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel3]);
    548     /*pTempCBuffer->m_lock = malloc(sizeof(pthread_mutex_t));*/
    549     pthread_mutex_init(pTempCBuffer->m_lock, NULL);
    550 #endif
    551     for(nCount = 0; nCount >= CBUFFER_SIZE; nCount++) {
    552         pTempCBuffer->pElement[nCount] = NULL;
    553     }
    554 EXIT:
    555     pTempCBuffer->nCount = 0;
    556     pTempCBuffer->nHead = 0;
    557     pTempCBuffer->nTail = 0;
    558 
    559     return eError;
    560 }
    561 
    562 /*----------------------------------------------------------------------------*/
    563 /**
    564   * VIDDEC_CircBuf_Flush()
    565   **/
    566 /*----------------------------------------------------------------------------*/
    567 OMX_ERRORTYPE VIDDEC_CircBuf_Flush(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate, VIDDEC_CBUFFER_TYPE nTypeIndex, VIDDEC_PORT_INDEX nPortIndex)
    568 {
    569     OMX_ERRORTYPE eError = OMX_ErrorNone;
    570     VIDDEC_CIRCULAR_BUFFER *pTempCBuffer = NULL;
    571     OMX_U32 nCount = 0;
    572 
    573     if(nTypeIndex == VIDDEC_CBUFFER_TIMESTAMP){
    574         pTempCBuffer = &pComponentPrivate->pCompPort[nPortIndex]->eTimeStamp;
    575     }
    576     else {
    577         eError = OMX_ErrorBadParameter;
    578         return eError;
    579     }
    580 #ifdef VIDDEC_CBUFFER_LOCK
    581     if(pthread_mutex_lock(pTempCBuffer->m_lock) != 0) {
    582         eError = OMX_ErrorHardware;
    583         return eError;
    584     }
    585 #endif
    586     for (nCount = pTempCBuffer->nTail; nCount <= pTempCBuffer->nHead; nCount++){
    587         pTempCBuffer->pElement[nCount] = NULL;
    588     }
    589     pTempCBuffer->nCount = 0;
    590     pTempCBuffer->nHead = 0;
    591     pTempCBuffer->nTail = 0;
    592 
    593 #ifdef VIDDEC_CBUFFER_LOCK
    594     if(pthread_mutex_unlock(pTempCBuffer->m_lock) != 0) {
    595         eError = OMX_ErrorHardware;
    596         return eError;
    597     }
    598 #endif
    599     return eError;
    600 }
    601 
    602 /*----------------------------------------------------------------------------*/
    603 /**
    604   * VIDDEC_CircBuf_DeInit()
    605   **/
    606 /*----------------------------------------------------------------------------*/
    607 OMX_ERRORTYPE VIDDEC_CircBuf_DeInit(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate, VIDDEC_CBUFFER_TYPE nTypeIndex, VIDDEC_PORT_INDEX nPortIndex)
    608 {
    609     OMX_ERRORTYPE eError = OMX_ErrorNone;
    610     VIDDEC_CIRCULAR_BUFFER *pTempCBuffer = NULL;
    611     OMX_U32 nCount = 0;
    612 
    613     if(nTypeIndex == VIDDEC_CBUFFER_TIMESTAMP){
    614         pTempCBuffer = &pComponentPrivate->pCompPort[nPortIndex]->eTimeStamp;
    615     }
    616     else {
    617         eError = OMX_ErrorBadParameter;
    618         return eError;
    619     }
    620 #ifdef VIDDEC_CBUFFER_LOCK
    621     if(pTempCBuffer->m_lock != NULL) {
    622         free(pTempCBuffer->m_lock);
    623         pTempCBuffer->m_lock = NULL;
    624     }
    625 #endif
    626     for(nCount = 0; nCount >= CBUFFER_SIZE; nCount++) {
    627         pTempCBuffer->pElement[nCount] = NULL;
    628     }
    629     return eError;
    630 }
    631 
    632 /*----------------------------------------------------------------------------*/
    633 /**
    634   * VIDDEC_CircBuf_Add() set the last element in the Circular Buffer
    635   * return the error number in case of exist an error.
    636   **/
    637 /*----------------------------------------------------------------------------*/
    638 OMX_ERRORTYPE VIDDEC_CircBuf_Add(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate, VIDDEC_CBUFFER_TYPE nTypeIndex, VIDDEC_PORT_INDEX nPortIndex, OMX_PTR pElement)
    639 {
    640     OMX_ERRORTYPE eError = OMX_ErrorNone;
    641     VIDDEC_CIRCULAR_BUFFER *pTempCBuffer = NULL;
    642 
    643     if(nTypeIndex == VIDDEC_CBUFFER_TIMESTAMP){
    644         pTempCBuffer = &pComponentPrivate->pCompPort[nPortIndex]->eTimeStamp;
    645     }
    646     else {
    647         eError = OMX_ErrorBadParameter;
    648         return eError;
    649     }
    650 #ifdef VIDDEC_CBUFFER_LOCK
    651     if(pthread_mutex_lock(pTempCBuffer->m_lock) != 0) {
    652         eError = OMX_ErrorHardware;
    653         return eError;
    654     }
    655 #endif
    656     pTempCBuffer->pElement[pTempCBuffer->nHead++] = pElement;
    657     pTempCBuffer->nCount++;
    658     if(pTempCBuffer->nHead >= CBUFFER_SIZE){
    659         pTempCBuffer->nHead = 0;
    660     }
    661 #ifdef VIDDEC_CBUFFER_LOCK
    662     if(pthread_mutex_unlock(pTempCBuffer->m_lock) != 0) {
    663         eError = OMX_ErrorHardware;
    664         return eError;
    665     }
    666 #endif
    667     return eError;
    668 }
    669 
    670 /*----------------------------------------------------------------------------*/
    671 /**
    672   * VIDDEC_CircBuf_Remove() get the first element in the Circular Buffer
    673   * return the error number in case of exist an error.
    674   **/
    675 /*----------------------------------------------------------------------------*/
    676 OMX_ERRORTYPE VIDDEC_CircBuf_Remove(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate, VIDDEC_CBUFFER_TYPE nTypeIndex, VIDDEC_PORT_INDEX nPortIndex, OMX_PTR* pElement)
    677 {
    678     OMX_ERRORTYPE eError = OMX_ErrorNone;
    679     VIDDEC_CIRCULAR_BUFFER *pTempCBuffer = NULL;
    680 
    681     if(nTypeIndex == VIDDEC_CBUFFER_TIMESTAMP){
    682         pTempCBuffer = &pComponentPrivate->pCompPort[nPortIndex]->eTimeStamp;
    683     }
    684     else {
    685         eError = OMX_ErrorBadParameter;
    686         return eError;
    687     }
    688 #ifdef VIDDEC_CBUFFER_LOCK
    689     if(pthread_mutex_lock(pTempCBuffer->m_lock) != 0) {
    690         eError = OMX_ErrorHardware;
    691         return eError;
    692     }
    693 #endif
    694     if(pTempCBuffer->nCount)
    695     {
    696         *pElement = pTempCBuffer->pElement[pTempCBuffer->nTail];
    697         pTempCBuffer->pElement[pTempCBuffer->nTail++] = NULL;
    698         pTempCBuffer->nCount--;
    699         if(pTempCBuffer->nTail >= CBUFFER_SIZE){
    700             pTempCBuffer->nTail = 0;
    701         }
    702     }
    703     else
    704     {
    705         *pElement = NULL;
    706     }
    707 #ifdef VIDDEC_CBUFFER_LOCK
    708     if(pthread_mutex_unlock(pTempCBuffer->m_lock) != 0) {
    709         eError = OMX_ErrorHardware;
    710         return eError;
    711     }
    712 #endif
    713     return eError;
    714 }
    715 
    716 /*----------------------------------------------------------------------------*/
    717 /**
    718   * VIDDEC_CircBuf_Count() get the number of elements in the Circular Buffer
    719   * return the error number in case of exist an error.
    720   **/
    721 /*----------------------------------------------------------------------------*/
    722 OMX_ERRORTYPE VIDDEC_CircBuf_Count(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate, VIDDEC_CBUFFER_TYPE nTypeIndex, VIDDEC_PORT_INDEX nPortIndex, OMX_U8* pCount)
    723 {
    724     OMX_ERRORTYPE eError = OMX_ErrorNone;
    725     VIDDEC_CIRCULAR_BUFFER *pTempCBuffer = NULL;
    726 
    727     if(nTypeIndex == VIDDEC_CBUFFER_TIMESTAMP){
    728         pTempCBuffer = &pComponentPrivate->pCompPort[nPortIndex]->eTimeStamp;
    729     }
    730     else {
    731         eError = OMX_ErrorBadParameter;
    732         pCount = 0;
    733         return eError;
    734     }
    735 #ifdef VIDDEC_CBUFFER_LOCK
    736     if(pthread_mutex_lock(pTempCBuffer->m_lock) != 0) {
    737         eError = OMX_ErrorHardware;
    738         return eError;
    739     }
    740 #endif
    741 
    742     *pCount = pTempCBuffer->nCount;
    743 
    744 #ifdef VIDDEC_CBUFFER_LOCK
    745     if(pthread_mutex_unlock(pTempCBuffer->m_lock) != 0) {
    746         eError = OMX_ErrorHardware;
    747         return eError;
    748     }
    749 #endif
    750     return eError;
    751 }
    752 
    753 /*----------------------------------------------------------------------------*/
    754 /**
    755   * VIDDEC_CircBuf_Head() get the number of elements in the Circular Buffer
    756   * return the error number in case of exist an error.
    757   **/
    758 /*----------------------------------------------------------------------------*/
    759 OMX_U8 VIDDEC_CircBuf_GetHead(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate, VIDDEC_CBUFFER_TYPE nTypeIndex, VIDDEC_PORT_INDEX nPortIndex)
    760 {
    761     /*OMX_ERRORTYPE eError = OMX_ErrorNone;*/
    762     VIDDEC_CIRCULAR_BUFFER *pTempCBuffer = NULL;
    763     OMX_U8 ucHead = 0;
    764 
    765     if(nTypeIndex == VIDDEC_CBUFFER_TIMESTAMP){
    766         pTempCBuffer = &pComponentPrivate->pCompPort[nPortIndex]->eTimeStamp;
    767     }
    768     else {
    769         ucHead = 0;
    770         return 0;
    771     }
    772 #ifdef VIDDEC_CBUFFER_LOCK
    773     if(pthread_mutex_lock(pTempCBuffer->m_lock) != 0) {
    774         return 0;
    775     }
    776 #endif
    777 
    778     ucHead = pTempCBuffer->nHead;
    779 
    780 #ifdef VIDDEC_CBUFFER_LOCK
    781     if(pthread_mutex_unlock(pTempCBuffer->m_lock) != 0) {
    782         return 0;
    783     }
    784 #endif
    785     return ucHead;
    786 }
    787 
    788 /* ========================================================================== */
    789 /**
    790   *  VIDDEC_Load_Defaults() function will be called by the component to
    791   *
    792   *                         load the default values
    793   *
    794   * @param pComponentPrivate         Pointer to the pComponentPrivatePrivate
    795   *
    796   * @retval OMX_NoError              Success, ready to roll
    797  **/
    798 /* ========================================================================== */
    799 
    800 OMX_ERRORTYPE VIDDEC_Load_Defaults (VIDDEC_COMPONENT_PRIVATE* pComponentPrivate, OMX_S32 nPassing)
    801 {
    802     OMX_U32 iCount = 0;
    803     OMX_ERRORTYPE eError = OMX_ErrorNone;
    804 
    805     switch(nPassing){
    806         case VIDDEC_INIT_ALL:
    807         case VIDDEC_INIT_STRUCTS:
    808             pComponentPrivate->nInBufIndex  = 0;
    809             pComponentPrivate->nOutBufIndex = 0;
    810             pComponentPrivate->nInMarkBufIndex  = 0;
    811             pComponentPrivate->nOutMarkBufIndex = 0;
    812             pComponentPrivate->nInCmdMarkBufIndex  = 0;
    813             pComponentPrivate->nOutCmdMarkBufIndex = 0;
    814 
    815             pComponentPrivate->pCompPort[0]->hTunnelComponent = NULL;
    816             pComponentPrivate->pCompPort[1]->hTunnelComponent = NULL;
    817 
    818             /* Set component version */
    819             pComponentPrivate->pComponentVersion.s.nVersionMajor                = VERSION_MAJOR;
    820             pComponentPrivate->pComponentVersion.s.nVersionMinor                = VERSION_MINOR;
    821             pComponentPrivate->pComponentVersion.s.nRevision                    = VERSION_REVISION;
    822             pComponentPrivate->pComponentVersion.s.nStep                        = VERSION_STEP;
    823 
    824             /* Set spec version */
    825             pComponentPrivate->pSpecVersion.s.nVersionMajor                     = VERSION_MAJOR;
    826             pComponentPrivate->pSpecVersion.s.nVersionMinor                     = VERSION_MINOR;
    827             pComponentPrivate->pSpecVersion.s.nRevision                         = VERSION_REVISION;
    828             pComponentPrivate->pSpecVersion.s.nStep                             = VERSION_STEP;
    829 
    830             pComponentPrivate->pHandle->pApplicationPrivate = NULL;
    831             /* Set pPortParamType defaults */
    832             OMX_CONF_INIT_STRUCT(pComponentPrivate->pPortParamType, OMX_PORT_PARAM_TYPE, pComponentPrivate->dbg);
    833             pComponentPrivate->pPortParamType->nPorts                           = NUM_OF_PORTS;
    834             pComponentPrivate->pPortParamType->nStartPortNumber                 = VIDDEC_INPUT_PORT;
    835 #ifdef __STD_COMPONENT__
    836             OMX_CONF_INIT_STRUCT(pComponentPrivate->pPortParamTypeAudio, OMX_PORT_PARAM_TYPE, pComponentPrivate->dbg);
    837             pComponentPrivate->pPortParamTypeAudio->nPorts                      = VIDDEC_ZERO;
    838             pComponentPrivate->pPortParamTypeAudio->nStartPortNumber            = VIDDEC_ZERO;
    839             OMX_CONF_INIT_STRUCT(pComponentPrivate->pPortParamTypeImage, OMX_PORT_PARAM_TYPE, pComponentPrivate->dbg);
    840             pComponentPrivate->pPortParamTypeImage->nPorts                      = VIDDEC_ZERO;
    841             pComponentPrivate->pPortParamTypeImage->nStartPortNumber            = VIDDEC_ZERO;
    842             OMX_CONF_INIT_STRUCT(pComponentPrivate->pPortParamTypeOthers, OMX_PORT_PARAM_TYPE, pComponentPrivate->dbg);
    843             pComponentPrivate->pPortParamTypeOthers->nPorts                     = VIDDEC_ZERO;
    844             pComponentPrivate->pPortParamTypeOthers->nStartPortNumber           = VIDDEC_ZERO;
    845 #endif
    846 
    847             pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT]->nBufferCnt         = 0;
    848             pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->nBufferCnt        = 0;
    849 
    850             /* Set pInPortDef defaults */
    851             OMX_CONF_INIT_STRUCT(pComponentPrivate->pInPortDef, OMX_PARAM_PORTDEFINITIONTYPE, pComponentPrivate->dbg);
    852             pComponentPrivate->pInPortDef->nPortIndex                           = VIDDEC_INPUT_PORT;
    853             pComponentPrivate->pInPortDef->eDir                                 = OMX_DirInput;
    854             pComponentPrivate->pInPortDef->nBufferCountActual                   = MAX_PRIVATE_IN_BUFFERS;
    855             pComponentPrivate->pInPortDef->nBufferCountMin                      = VIDDEC_BUFFERMINCOUNT;
    856             pComponentPrivate->pInPortDef->nBufferSize                          = VIDDEC_DEFAULT_INPUT_BUFFER_SIZE;
    857             pComponentPrivate->pInPortDef->bEnabled                             = VIDDEC_PORT_ENABLED;
    858             pComponentPrivate->pInPortDef->bPopulated                           = VIDDEC_PORT_POPULATED;
    859             pComponentPrivate->pInPortDef->eDomain                              = VIDDEC_PORT_DOMAIN;
    860 #ifdef KHRONOS_1_2
    861             pComponentPrivate->pInPortDef->bBuffersContiguous                   = OMX_FALSE;
    862             pComponentPrivate->pInPortDef->nBufferAlignment                     = OMX_FALSE;
    863 #endif
    864             pComponentPrivate->pInPortDef->format.video.pNativeRender           = VIDDEC_INPUT_PORT_NATIVERENDER;
    865             pComponentPrivate->pInPortDef->format.video.nFrameWidth             = VIDDEC_DEFAULT_WIDTH;
    866             pComponentPrivate->pInPortDef->format.video.nFrameHeight            = VIDDEC_DEFAULT_HEIGHT;
    867             pComponentPrivate->pInPortDef->format.video.nStride                 = VIDDEC_INPUT_PORT_STRIDE;
    868             pComponentPrivate->pInPortDef->format.video.nSliceHeight            = VIDDEC_INPUT_PORT_SLICEHEIGHT;
    869             pComponentPrivate->pInPortDef->format.video.nBitrate                = VIDDEC_INPUT_PORT_BITRATE;
    870             pComponentPrivate->pInPortDef->format.video.xFramerate              = VIDDEC_INPUT_PORT_FRAMERATE;
    871             pComponentPrivate->pInPortDef->format.video.cMIMEType               = VIDDEC_MIMETYPEMPEG4;
    872             pComponentPrivate->pInPortDef->format.video.bFlagErrorConcealment   = VIDDEC_INPUT_PORT_FLAGERRORCONCEALMENT;
    873             pComponentPrivate->pInPortDef->format.video.eCompressionFormat      = VIDDEC_INPUT_PORT_COMPRESSIONFORMAT;
    874             pComponentPrivate->pInPortDef->format.video.eColorFormat            = VIDDEC_COLORFORMATUNUSED;
    875 #ifdef KHRONOS_1_1
    876             pComponentPrivate->pInPortDef->format.video.pNativeWindow           = 0;
    877 #endif
    878 
    879             /* Set pOutPortDef defaults */
    880             OMX_CONF_INIT_STRUCT(pComponentPrivate->pOutPortDef, OMX_PARAM_PORTDEFINITIONTYPE, pComponentPrivate->dbg);
    881             pComponentPrivate->pOutPortDef->nPortIndex                          = VIDDEC_OUTPUT_PORT;
    882             pComponentPrivate->pOutPortDef->eDir                                = OMX_DirOutput;
    883             pComponentPrivate->pOutPortDef->nBufferCountActual                  = MAX_PRIVATE_OUT_BUFFERS;
    884             pComponentPrivate->pOutPortDef->nBufferCountMin                     = VIDDEC_BUFFERMINCOUNT;
    885             pComponentPrivate->pOutPortDef->nBufferSize                         = VIDDEC_DEFAULT_OUTPUT_BUFFER_SIZE;
    886             pComponentPrivate->pOutPortDef->bEnabled                            = VIDDEC_PORT_ENABLED;
    887             pComponentPrivate->pOutPortDef->bPopulated                          = VIDDEC_PORT_POPULATED;
    888             pComponentPrivate->pOutPortDef->eDomain                             = VIDDEC_PORT_DOMAIN;
    889 #ifdef KHRONOS_1_2
    890             pComponentPrivate->pInPortDef->bBuffersContiguous                   = OMX_FALSE;
    891             pComponentPrivate->pInPortDef->nBufferAlignment                     = OMX_FALSE;
    892 #endif
    893             pComponentPrivate->pOutPortDef->format.video.cMIMEType              = VIDDEC_MIMETYPEYUV;
    894             pComponentPrivate->pOutPortDef->format.video.pNativeRender          = VIDDEC_OUTPUT_PORT_NATIVERENDER;
    895             pComponentPrivate->pOutPortDef->format.video.nFrameWidth            = VIDDEC_DEFAULT_WIDTH;
    896             pComponentPrivate->pOutPortDef->format.video.nFrameHeight           = VIDDEC_DEFAULT_HEIGHT;
    897             pComponentPrivate->pOutPortDef->format.video.nStride                = VIDDEC_OUTPUT_PORT_STRIDE;
    898             pComponentPrivate->pOutPortDef->format.video.nSliceHeight           = VIDDEC_OUTPUT_PORT_SLICEHEIGHT;
    899             pComponentPrivate->pOutPortDef->format.video.nBitrate               = VIDDEC_OUTPUT_PORT_BITRATE;
    900             pComponentPrivate->pOutPortDef->format.video.xFramerate             = VIDDEC_OUTPUT_PORT_FRAMERATE;
    901             pComponentPrivate->pOutPortDef->format.video.bFlagErrorConcealment  = VIDDEC_OUTPUT_PORT_FLAGERRORCONCEALMENT;
    902             pComponentPrivate->pOutPortDef->format.video.eCompressionFormat     = VIDDEC_OUTPUT_PORT_COMPRESSIONFORMAT;
    903             pComponentPrivate->pOutPortDef->format.video.eColorFormat           = VIDDEC_COLORFORMAT420;
    904 #ifdef KHRONOS_1_1
    905             pComponentPrivate->pOutPortDef->format.video.pNativeWindow           = 0;
    906 #endif
    907             for (iCount = 0; iCount < MAX_PRIVATE_BUFFERS; iCount++) {
    908                 OMX_MALLOC_STRUCT(pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT]->pBufferPrivate[iCount], VIDDEC_BUFFER_PRIVATE,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0]);
    909                 pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT]->pBufferPrivate[iCount]->pBufferHdr = NULL;
    910             }
    911 
    912             for (iCount = 0; iCount < MAX_PRIVATE_BUFFERS; iCount++) {
    913                 OMX_MALLOC_STRUCT(pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[iCount], VIDDEC_BUFFER_PRIVATE,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0]);
    914                 pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[iCount]->pBufferHdr = NULL;
    915             }
    916 
    917             /* Set pInPortFormat defaults */
    918             OMX_CONF_INIT_STRUCT(pComponentPrivate->pInPortFormat, OMX_VIDEO_PARAM_PORTFORMATTYPE, pComponentPrivate->dbg);
    919             pComponentPrivate->pInPortFormat->nPortIndex                        = VIDDEC_INPUT_PORT;
    920             pComponentPrivate->pInPortFormat->nIndex                            = VIDDEC_DEFAULT_INPUT_INDEX_MPEG4;
    921             pComponentPrivate->pInPortFormat->eCompressionFormat                = VIDDEC_INPUT_PORT_COMPRESSIONFORMAT;
    922             pComponentPrivate->pInPortFormat->eColorFormat                      = VIDDEC_COLORFORMATUNUSED;
    923 #ifdef KHRONOS_1_1
    924             pComponentPrivate->pInPortFormat->xFramerate                        = VIDDEC_INPUT_PORT_FRAMERATE;
    925 #endif
    926 
    927             /* Set pOutPortFormat defaults */
    928             OMX_CONF_INIT_STRUCT(pComponentPrivate->pOutPortFormat, OMX_VIDEO_PARAM_PORTFORMATTYPE, pComponentPrivate->dbg);
    929             pComponentPrivate->pOutPortFormat->nPortIndex                       = VIDDEC_OUTPUT_PORT;
    930             pComponentPrivate->pOutPortFormat->nIndex                           = VIDDEC_DEFAULT_OUTPUT_INDEX_PLANAR420;
    931             pComponentPrivate->pOutPortFormat->eCompressionFormat               = VIDDEC_OUTPUT_PORT_COMPRESSIONFORMAT;
    932             pComponentPrivate->pOutPortFormat->eColorFormat                     = VIDDEC_COLORFORMAT420;
    933 #ifdef KHRONOS_1_1
    934             pComponentPrivate->pOutPortFormat->xFramerate                       = VIDDEC_INPUT_PORT_FRAMERATE;
    935 #endif
    936             /* Set pPriorityMgmt defaults */
    937             OMX_CONF_INIT_STRUCT(pComponentPrivate->pPriorityMgmt, OMX_PRIORITYMGMTTYPE, pComponentPrivate->dbg);
    938             pComponentPrivate->pPriorityMgmt->nGroupPriority                    = -1;
    939             pComponentPrivate->pPriorityMgmt->nGroupID                          = -1;
    940 
    941             /* Buffer supplier setting */
    942             pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT]->eSupplierSetting   = OMX_BufferSupplyOutput;
    943 
    944             /* Set pInBufSupplier defaults */
    945             OMX_CONF_INIT_STRUCT(pComponentPrivate->pInBufSupplier, OMX_PARAM_BUFFERSUPPLIERTYPE , pComponentPrivate->dbg);
    946             pComponentPrivate->pInBufSupplier->nPortIndex                       = VIDDEC_INPUT_PORT;
    947             pComponentPrivate->pInBufSupplier->eBufferSupplier                  = VIDDEC_INPUT_PORT_BUFFERSUPPLIER;
    948 
    949             /* Set pOutBufSupplier defaults */
    950             OMX_CONF_INIT_STRUCT(pComponentPrivate->pOutBufSupplier, OMX_PARAM_BUFFERSUPPLIERTYPE , pComponentPrivate->dbg);
    951             pComponentPrivate->pOutBufSupplier->nPortIndex                      = VIDDEC_OUTPUT_PORT;
    952             pComponentPrivate->pOutBufSupplier->eBufferSupplier                 = VIDDEC_OUTPUT_PORT_BUFFERSUPPLIER;
    953 
    954 #ifdef KHRONOS_1_1
    955             /*MBError Reporting code       */
    956             /* Set eMBErrorReport defaults */
    957             OMX_CONF_INIT_STRUCT(&pComponentPrivate->eMBErrorReport, OMX_CONFIG_MBERRORREPORTINGTYPE , pComponentPrivate->dbg);
    958             pComponentPrivate->eMBErrorReport.nPortIndex  = VIDDEC_OUTPUT_PORT;
    959             pComponentPrivate->eMBErrorReport.bEnabled    = OMX_FALSE;
    960             /*MBError Reporting code       */
    961             /* Set eMBErrorMapType defaults */
    962             for (iCount = 0; iCount < MAX_PRIVATE_BUFFERS; iCount++) {
    963                 OMX_CONF_INIT_STRUCT(&pComponentPrivate->eMBErrorMapType[iCount], OMX_CONFIG_MACROBLOCKERRORMAPTYPE_TI , pComponentPrivate->dbg);
    964                 pComponentPrivate->eMBErrorMapType[iCount].nPortIndex  = VIDDEC_OUTPUT_PORT;
    965                 pComponentPrivate->eMBErrorMapType[iCount].nErrMapSize = (VIDDEC_DEFAULT_WIDTH * VIDDEC_DEFAULT_HEIGHT) / 256;
    966             }
    967             pComponentPrivate->cMBErrorIndexIn = 0;
    968             pComponentPrivate->cMBErrorIndexOut = 0;
    969 
    970 #endif
    971 
    972             pComponentPrivate->nPendingStateChangeRequests = 0;
    973             if(pthread_mutex_init(&pComponentPrivate->mutexStateChangeRequest, NULL)) {
    974                 return OMX_ErrorUndefined;
    975             }
    976             if(pthread_cond_init (&pComponentPrivate->StateChangeCondition, NULL)) {
    977                 return OMX_ErrorUndefined;
    978             }
    979 
    980             /* Set pMpeg4 defaults */
    981             OMX_CONF_INIT_STRUCT (pComponentPrivate->pMpeg4, OMX_VIDEO_PARAM_MPEG4TYPE, pComponentPrivate->dbg);
    982             pComponentPrivate->pMpeg4->nPortIndex               = VIDDEC_DEFAULT_MPEG4_PORTINDEX;
    983             pComponentPrivate->pMpeg4->nSliceHeaderSpacing      = VIDDEC_DEFAULT_MPEG4_SLICEHEADERSPACING;
    984             pComponentPrivate->pMpeg4->bSVH                     = VIDDEC_DEFAULT_MPEG4_SVH;
    985             pComponentPrivate->pMpeg4->bGov                     = VIDDEC_DEFAULT_MPEG4_GOV;
    986             pComponentPrivate->pMpeg4->nPFrames                 = VIDDEC_DEFAULT_MPEG4_PFRAMES;
    987             pComponentPrivate->pMpeg4->nBFrames                 = VIDDEC_DEFAULT_MPEG4_BFRAMES;
    988             pComponentPrivate->pMpeg4->nIDCVLCThreshold         = VIDDEC_DEFAULT_MPEG4_IDCVLCTHRESHOLD;
    989             pComponentPrivate->pMpeg4->bACPred                  = VIDDEC_DEFAULT_MPEG4_ACPRED;
    990             pComponentPrivate->pMpeg4->nMaxPacketSize           = VIDDEC_DEFAULT_MPEG4_MAXPACKETSIZE;
    991             pComponentPrivate->pMpeg4->nTimeIncRes              = VIDDEC_DEFAULT_MPEG4_TIMEINCRES;
    992             pComponentPrivate->pMpeg4->eProfile                 = VIDDEC_DEFAULT_MPEG4_PROFILE;
    993             pComponentPrivate->pMpeg4->eLevel                   = VIDDEC_DEFAULT_MPEG4_LEVEL;
    994             pComponentPrivate->pMpeg4->nAllowedPictureTypes     = VIDDEC_DEFAULT_MPEG4_ALLOWEDPICTURETYPES;
    995             pComponentPrivate->pMpeg4->nHeaderExtension         = VIDDEC_DEFAULT_MPEG4_HEADEREXTENSION;
    996             pComponentPrivate->pMpeg4->bReversibleVLC           = VIDDEC_DEFAULT_MPEG4_REVERSIBLEVLC;
    997 
    998             /* Set pMpeg2 defaults */
    999             OMX_CONF_INIT_STRUCT (pComponentPrivate->pMpeg2, OMX_VIDEO_PARAM_MPEG2TYPE, pComponentPrivate->dbg);
   1000             pComponentPrivate->pMpeg2->nPortIndex               = VIDDEC_DEFAULT_MPEG2_PORTINDEX;
   1001             pComponentPrivate->pMpeg2->nPFrames                 = VIDDEC_DEFAULT_MPEG2_PFRAMES;
   1002             pComponentPrivate->pMpeg2->nBFrames                 = VIDDEC_DEFAULT_MPEG2_BFRAMES;
   1003             pComponentPrivate->pMpeg2->eProfile                 = VIDDEC_DEFAULT_MPEG2_PROFILE;
   1004             pComponentPrivate->pMpeg2->eLevel                   = VIDDEC_DEFAULT_MPEG2_LEVEL;
   1005 
   1006             /* Set pH264 defaults */
   1007             OMX_CONF_INIT_STRUCT(pComponentPrivate->pH264, OMX_VIDEO_PARAM_AVCTYPE, pComponentPrivate->dbg);
   1008             pComponentPrivate->pH264->nPortIndex                = VIDDEC_DEFAULT_H264_PORTINDEX;
   1009             pComponentPrivate->pH264->nSliceHeaderSpacing       = VIDDEC_DEFAULT_H264_SLICEHEADERSPACING;
   1010             pComponentPrivate->pH264->nPFrames                  = VIDDEC_DEFAULT_H264_PFRAMES;
   1011             pComponentPrivate->pH264->nBFrames                  = VIDDEC_DEFAULT_H264_BFRAMES;
   1012             pComponentPrivate->pH264->bUseHadamard              = VIDDEC_DEFAULT_H264_USEHADAMARD;
   1013             pComponentPrivate->pH264->nRefFrames                = VIDDEC_DEFAULT_H264_REFFRAMES;
   1014             pComponentPrivate->pH264->nRefIdx10ActiveMinus1     = VIDDEC_DEFAULT_H264_REFIDX10ACTIVEMINUS1;
   1015             pComponentPrivate->pH264->nRefIdx11ActiveMinus1     = VIDDEC_DEFAULT_H264_REFIDX11ACTIVEMINUS1;
   1016             pComponentPrivate->pH264->bEnableUEP                = VIDDEC_DEFAULT_H264_ENABLEUEP;
   1017             pComponentPrivate->pH264->bEnableFMO                = VIDDEC_DEFAULT_H264_ENABLEFMO;
   1018             pComponentPrivate->pH264->bEnableASO                = VIDDEC_DEFAULT_H264_ENABLEASO;
   1019             pComponentPrivate->pH264->bEnableRS                 = VIDDEC_DEFAULT_H264_ENABLERS;
   1020             pComponentPrivate->pH264->eProfile                  = VIDDEC_DEFAULT_H264_PROFILE;
   1021             pComponentPrivate->pH264->eLevel                    = VIDDEC_DEFAULT_H264_LEVEL;
   1022             pComponentPrivate->pH264->nAllowedPictureTypes      = VIDDEC_DEFAULT_H264_ALLOWEDPICTURETYPES;
   1023             pComponentPrivate->pH264->bFrameMBsOnly             = VIDDEC_DEFAULT_H264_FRAMEMBSONLY;
   1024             pComponentPrivate->pH264->bMBAFF                    = VIDDEC_DEFAULT_H264_MBAFF;
   1025             pComponentPrivate->pH264->bEntropyCodingCABAC       = VIDDEC_DEFAULT_H264_ENTROPYCODINGCABAC;
   1026             pComponentPrivate->pH264->bWeightedPPrediction      = VIDDEC_DEFAULT_H264_WEIGHTEDPPREDICTION;
   1027             pComponentPrivate->pH264->nWeightedBipredicitonMode = VIDDEC_DEFAULT_H264_WEIGHTEDBIPREDICITONMODE;
   1028             pComponentPrivate->pH264->bconstIpred               = VIDDEC_DEFAULT_H264_CONSTIPRED;
   1029             pComponentPrivate->pH264->bDirect8x8Inference       = VIDDEC_DEFAULT_H264_DIRECT8X8INFERENCE;
   1030             pComponentPrivate->pH264->bDirectSpatialTemporal    = VIDDEC_DEFAULT_H264_DIRECTSPATIALTEMPORAL;
   1031             pComponentPrivate->pH264->nCabacInitIdc             = VIDDEC_DEFAULT_H264_CABACINITIDC;
   1032             pComponentPrivate->pH264->eLoopFilterMode           = VIDDEC_DEFAULT_H264_LOOPFILTERMODE;
   1033             pComponentPrivate->H264BitStreamFormat              = VIDDEC_DEFAULT_H264BITSTRMFMT;
   1034 
   1035             pComponentPrivate->pH263->nPortIndex                = VIDDEC_DEFAULT_H263_PORTINDEX;
   1036             pComponentPrivate->pH263->nPFrames                  = VIDDEC_DEFAULT_H263_PFRAMES;
   1037             pComponentPrivate->pH263->nBFrames                  = VIDDEC_DEFAULT_H263_BFRAMES;
   1038             pComponentPrivate->pH263->eProfile                  = VIDDEC_DEFAULT_H263_PROFILE;
   1039             pComponentPrivate->pH263->eLevel                    = VIDDEC_DEFAULT_H263_LEVEL;
   1040             pComponentPrivate->pH263->bPLUSPTYPEAllowed         = VIDDEC_DEFAULT_H263_PLUSPTYPEALLOWED;
   1041             pComponentPrivate->pH263->nAllowedPictureTypes      = VIDDEC_DEFAULT_H263_ALLOWEDPICTURETYPES;
   1042             pComponentPrivate->pH263->bForceRoundingTypeToZero  = VIDDEC_DEFAULT_H263_FORCEROUNDINGTYPETOZERO;
   1043             pComponentPrivate->pH263->nPictureHeaderRepetition  = VIDDEC_DEFAULT_H263_PICTUREHEADERREPETITION;
   1044             pComponentPrivate->pH263->nGOBHeaderInterval        = VIDDEC_DEFAULT_H263_GOBHEADERINTERVAL;
   1045 
   1046             OMX_CONF_INIT_STRUCT(pComponentPrivate->pWMV, OMX_VIDEO_PARAM_WMVTYPE, pComponentPrivate->dbg);
   1047             pComponentPrivate->pWMV->nPortIndex                 = VIDDEC_DEFAULT_WMV_PORTINDEX;
   1048             pComponentPrivate->pWMV->eFormat                    = VIDDEC_DEFAULT_WMV_FORMAT;
   1049             pComponentPrivate->nWMVFileType                     = VIDDEC_WMV_RCVSTREAM; /* RCVSTREAM must be the default value*/
   1050             pComponentPrivate->wmvProfile                       = VIDDEC_WMV_PROFILEMAX;
   1051 #ifdef UNDER_CE
   1052             pComponentPrivate->bIsNALBigEndian                   = OMX_TRUE;
   1053 #else
   1054             pComponentPrivate->bIsNALBigEndian                   = OMX_FALSE;
   1055 #endif
   1056             pComponentPrivate->eLCMLState                       = VidDec_LCML_State_Unload;
   1057             pComponentPrivate->bLCMLHalted                      = OMX_TRUE;
   1058 #ifndef UNDER_CE
   1059             pComponentPrivate->bLCMLOut                         = OMX_FALSE;
   1060 #endif
   1061             pComponentPrivate->eRMProxyState                    = VidDec_RMPROXY_State_Unload;
   1062             pComponentPrivate->ProcessMode                      = VIDDEC_DEFAULT_PROCESSMODE;
   1063             pComponentPrivate->bParserEnabled                   = OMX_TRUE;
   1064 
   1065             VIDDEC_CircBuf_Init(pComponentPrivate, VIDDEC_CBUFFER_TIMESTAMP, VIDDEC_INPUT_PORT);
   1066 #ifndef UNDER_CE
   1067             VIDDEC_PTHREAD_MUTEX_INIT(pComponentPrivate->sMutex);
   1068             VIDDEC_PTHREAD_SEMAPHORE_INIT(pComponentPrivate->sInSemaphore);
   1069             VIDDEC_PTHREAD_SEMAPHORE_INIT(pComponentPrivate->sOutSemaphore);
   1070 #endif
   1071             for (iCount = 0; iCount < CBUFFER_SIZE; iCount++) {
   1072                 pComponentPrivate->aBufferFlags[iCount].nTimeStamp = 0;
   1073                 pComponentPrivate->aBufferFlags[iCount].nFlags = 0;
   1074                 pComponentPrivate->aBufferFlags[iCount].pMarkData = NULL;
   1075                 pComponentPrivate->aBufferFlags[iCount].hMarkTargetComponent = NULL;
   1076             }
   1077             pComponentPrivate->pBufferRCV.sStructRCV.nNumFrames = 0xFFFFFF; /*Infinite frame number*/
   1078             pComponentPrivate->pBufferRCV.sStructRCV.nFrameType = 0x85; /*85*/
   1079             pComponentPrivate->pBufferRCV.sStructRCV.nID = 0x04; /*WMV3*/
   1080             pComponentPrivate->pBufferRCV.sStructRCV.nStructData = 0x018a3106; /*0x06318a01zero fill 0x018a3106*/
   1081             pComponentPrivate->pBufferRCV.sStructRCV.nVertSize = 352; /*720*/
   1082             pComponentPrivate->pBufferRCV.sStructRCV.nHorizSize = 288; /*576*/
   1083             OMX_CONF_INIT_STRUCT( &pComponentPrivate->pBufferTemp, OMX_BUFFERHEADERTYPE, pComponentPrivate->dbg);
   1084             pComponentPrivate->pBufferTemp.nFilledLen = sizeof(VIDDEC_WMV_RCV_header);
   1085             pComponentPrivate->pBufferTemp.nAllocLen = sizeof(VIDDEC_WMV_RCV_header);
   1086 
   1087 #ifdef ANDROID
   1088             /*Set PV (opencore) capability flags*/
   1089             pComponentPrivate->pPVCapabilityFlags->iIsOMXComponentMultiThreaded = OMX_TRUE;
   1090             pComponentPrivate->pPVCapabilityFlags->iOMXComponentSupportsExternalOutputBufferAlloc = OMX_TRUE;
   1091             pComponentPrivate->pPVCapabilityFlags->iOMXComponentSupportsExternalInputBufferAlloc = OMX_FALSE;
   1092             pComponentPrivate->pPVCapabilityFlags->iOMXComponentSupportsMovableInputBuffers = OMX_FALSE;
   1093             pComponentPrivate->pPVCapabilityFlags->iOMXComponentSupportsPartialFrames = OMX_FALSE;
   1094             pComponentPrivate->pPVCapabilityFlags->iOMXComponentCanHandleIncompleteFrames = OMX_FALSE;
   1095 
   1096 
   1097             if (pComponentPrivate->ProcessMode == 0 && pComponentPrivate->H264BitStreamFormat == 0) {
   1098                 /* frame mode + bytestream */
   1099                 pComponentPrivate->pPVCapabilityFlags->iOMXComponentUsesNALStartCodes = OMX_TRUE;
   1100             }
   1101             else if (pComponentPrivate->ProcessMode == 0 && pComponentPrivate->H264BitStreamFormat >= 1) {
   1102                 /* frame mode + NAL-bitstream */
   1103                 pComponentPrivate->pPVCapabilityFlags->iOMXComponentUsesNALStartCodes = OMX_FALSE;
   1104             }
   1105             else if (pComponentPrivate->ProcessMode == 1 && pComponentPrivate->H264BitStreamFormat == 0) {
   1106                 /* stream mode + bytestream */
   1107                 pComponentPrivate->pPVCapabilityFlags->iOMXComponentUsesNALStartCodes = OMX_TRUE;
   1108             }
   1109             else if (pComponentPrivate->ProcessMode == 1 && pComponentPrivate->H264BitStreamFormat >= 1) {
   1110                 /* stream mode + NAL-bitstream */
   1111                 /* not supported */
   1112             }
   1113             else {
   1114             }
   1115 
   1116             if (pComponentPrivate->ProcessMode == 0 && pComponentPrivate->H264BitStreamFormat == 0) {
   1117                 /* frame mode + bytestream */
   1118                 pComponentPrivate->pPVCapabilityFlags->iOMXComponentUsesFullAVCFrames = OMX_TRUE;
   1119             }
   1120             else if (pComponentPrivate->ProcessMode == 0 && pComponentPrivate->H264BitStreamFormat >= 1) {
   1121                 /* frame mode + NAL-bitstream */
   1122                 pComponentPrivate->pPVCapabilityFlags->iOMXComponentUsesFullAVCFrames = OMX_TRUE;
   1123             }
   1124             else if (pComponentPrivate->ProcessMode == 1 && pComponentPrivate->H264BitStreamFormat == 0) {
   1125                 /* stream mode + bytestream */
   1126                 pComponentPrivate->pPVCapabilityFlags->iOMXComponentUsesFullAVCFrames = OMX_FALSE;
   1127             }
   1128             else if (pComponentPrivate->ProcessMode == 1 && pComponentPrivate->H264BitStreamFormat >= 1) {
   1129                 /* stream mode + NAL-bitstream */
   1130                 /* not supported */
   1131             }
   1132             else {
   1133             }
   1134 #endif
   1135             /* Set default deblocking value for default format MPEG4 */
   1136             OMX_CONF_INIT_STRUCT(pComponentPrivate->pDeblockingParamType, OMX_PARAM_DEBLOCKINGTYPE, pComponentPrivate->dbg);
   1137             pComponentPrivate->pDeblockingParamType->nPortIndex = VIDDEC_OUTPUT_PORT;
   1138             pComponentPrivate->pDeblockingParamType->bDeblocking = OMX_FALSE;
   1139 
   1140 
   1141         case VIDDEC_INIT_VARS:
   1142             /* Set the process mode to zero, frame = 0, stream = 1 */
   1143             VIDDEC_CircBuf_Flush(pComponentPrivate, VIDDEC_CBUFFER_TIMESTAMP, VIDDEC_INPUT_PORT);
   1144             pComponentPrivate->bIsPaused                        = 0;
   1145             pComponentPrivate->bIsStopping                      = 0;
   1146             pComponentPrivate->bFirstBuffer                     = 1;
   1147             pComponentPrivate->eIdleToLoad                      = OMX_StateInvalid;
   1148             pComponentPrivate->iEndofInputSent                  = 0;
   1149             pComponentPrivate->nCountInputBFromDsp                  = 0;
   1150             pComponentPrivate->nCountOutputBFromDsp                 = 0;
   1151             pComponentPrivate->nCountInputBFromApp                  = 0;
   1152             pComponentPrivate->nCountOutputBFromApp                 = 0;
   1153             pComponentPrivate->frameCounter                     = 0;
   1154             pComponentPrivate->bMult16Size                      = OMX_FALSE;
   1155             pComponentPrivate->bFlushOut                        = OMX_FALSE;
   1156             pComponentPrivate->nBytesConsumed                   = 0;
   1157             pComponentPrivate->bBuffMarkTaked                   = OMX_FALSE;
   1158             pComponentPrivate->bBuffalreadyMarked               = OMX_FALSE;
   1159             pComponentPrivate->bFirstHeader                     = OMX_FALSE;
   1160             pComponentPrivate->nDisplayWidth                    = 0;
   1161             pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel1]  = 0;
   1162             pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel2]  = 0;
   1163             pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel3]  = 0;
   1164             pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel4]  = 0;
   1165             pComponentPrivate->bVC1Fix                          = OMX_TRUE;
   1166             pComponentPrivate->eFirstBuffer.pFirstBufferSaved   = NULL;
   1167             pComponentPrivate->eFirstBuffer.bSaveFirstBuffer    = OMX_FALSE;
   1168             pComponentPrivate->eFirstBuffer.nFilledLen          = 0;
   1169             pComponentPrivate->bDynamicConfigurationInProgress  = OMX_FALSE;
   1170             pComponentPrivate->nInternalConfigBufferFilledAVC = 0;
   1171             pComponentPrivate->eMBErrorReport.bEnabled            = OMX_FALSE;
   1172             pComponentPrivate->firstBufferEos                    = OMX_FALSE;
   1173         break;
   1174 
   1175 case VIDDEC_INIT_IDLEEXECUTING:
   1176             /* Set the process mode to zero, frame = 0, stream = 1 */
   1177             pComponentPrivate->bIsPaused                        = 0;
   1178             pComponentPrivate->bIsStopping                      = 0;
   1179             pComponentPrivate->bFirstBuffer                     = 1;
   1180             pComponentPrivate->iEndofInputSent                  = 0;
   1181             pComponentPrivate->nCountInputBFromDsp                  = 0;
   1182             pComponentPrivate->nCountOutputBFromDsp                 = 0;
   1183             pComponentPrivate->nCountInputBFromApp                  = 0;
   1184             pComponentPrivate->nCountOutputBFromApp                 = 0;
   1185             pComponentPrivate->frameCounter                     = 0;
   1186             pComponentPrivate->bMult16Size                      = OMX_FALSE;
   1187             pComponentPrivate->bFlushOut                        = OMX_FALSE;
   1188             pComponentPrivate->bFirstHeader                     = OMX_FALSE;
   1189             pComponentPrivate->nInBufIndex  = 0;
   1190             pComponentPrivate->nOutBufIndex = 0;
   1191             pComponentPrivate->nInMarkBufIndex  = 0;
   1192             pComponentPrivate->nOutMarkBufIndex = 0;
   1193             pComponentPrivate->nInCmdMarkBufIndex  = 0;
   1194             pComponentPrivate->nOutCmdMarkBufIndex = 0;
   1195         break;
   1196 
   1197         case VIDDEC_INIT_H263:
   1198             pComponentPrivate->pH263->nPortIndex                            = VIDDEC_DEFAULT_H263_PORTINDEX;
   1199             pComponentPrivate->pH263->nPFrames                              = VIDDEC_DEFAULT_H263_PFRAMES;
   1200             pComponentPrivate->pH263->nBFrames                              = VIDDEC_DEFAULT_H263_BFRAMES;
   1201             pComponentPrivate->pH263->eProfile                              = OMX_VIDEO_H263ProfileBaseline;
   1202             pComponentPrivate->pH263->eLevel                                = OMX_VIDEO_H263Level10;
   1203             pComponentPrivate->pH263->bPLUSPTYPEAllowed                     = VIDDEC_DEFAULT_H263_PLUSPTYPEALLOWED;
   1204             pComponentPrivate->pH263->nAllowedPictureTypes                  = VIDDEC_DEFAULT_H263_ALLOWEDPICTURETYPES;
   1205             pComponentPrivate->pH263->bForceRoundingTypeToZero              = VIDDEC_DEFAULT_H263_FORCEROUNDINGTYPETOZERO;
   1206             pComponentPrivate->pH263->nPictureHeaderRepetition              = VIDDEC_DEFAULT_H263_PICTUREHEADERREPETITION;
   1207             pComponentPrivate->pH263->nGOBHeaderInterval                    = VIDDEC_DEFAULT_H263_GOBHEADERINTERVAL;
   1208 
   1209             pComponentPrivate->pInPortFormat->nPortIndex                     = VIDDEC_INPUT_PORT;
   1210             pComponentPrivate->pInPortFormat->nIndex                        = VIDDEC_DEFAULT_INPUT_INDEX_H263;
   1211             pComponentPrivate->pInPortFormat->eCompressionFormat            = OMX_VIDEO_CodingH263;
   1212             pComponentPrivate->pInPortFormat->eColorFormat                  = OMX_COLOR_FormatUnused;
   1213 #ifdef KHRONOS_1_1
   1214             pComponentPrivate->pInPortFormat->xFramerate                    = VIDDEC_INPUT_PORT_FRAMERATE;
   1215 #endif
   1216             pComponentPrivate->pInPortDef->format.video.nFrameWidth         = VIDDEC_DEFAULT_WIDTH;
   1217             pComponentPrivate->pInPortDef->format.video.nFrameHeight        = VIDDEC_DEFAULT_HEIGHT;
   1218             pComponentPrivate->pInPortDef->format.video.nBitrate            = VIDDEC_INPUT_PORT_BITRATE;
   1219             pComponentPrivate->pInPortDef->format.video.xFramerate          = VIDDEC_INPUT_PORT_FRAMERATE;
   1220             pComponentPrivate->pInPortDef->format.video.eCompressionFormat  = OMX_VIDEO_CodingH263;
   1221             pComponentPrivate->pInPortDef->format.video.eColorFormat        = OMX_COLOR_FormatUnused;
   1222             pComponentPrivate->pInPortDef->nBufferSize                      = pComponentPrivate->pInPortDef->format.video.nFrameWidth *
   1223                                                                               pComponentPrivate->pInPortDef->format.video.nFrameHeight *
   1224                                                                               VIDDEC_FACTORFORMAT420;
   1225             pComponentPrivate->pDeblockingParamType->bDeblocking            = OMX_FALSE;
   1226             pComponentPrivate->bIsSparkInput = OMX_FALSE;
   1227             break;
   1228 #ifdef VIDDEC_SPARK_CODE
   1229         case VIDDEC_INIT_SPARK:
   1230             pComponentPrivate->pInPortFormat->nPortIndex                     = VIDDEC_INPUT_PORT;
   1231             pComponentPrivate->pInPortFormat->nIndex                        = VIDDEC_DEFAULT_INPUT_INDEX_H263;
   1232             pComponentPrivate->pInPortFormat->eCompressionFormat            = OMX_VIDEO_CodingUnused;
   1233             pComponentPrivate->pInPortFormat->eColorFormat                  = OMX_COLOR_FormatUnused;
   1234 #ifdef KHRONOS_1_1
   1235             pComponentPrivate->pInPortFormat->xFramerate                    = VIDDEC_INPUT_PORT_FRAMERATE;
   1236 #endif
   1237             pComponentPrivate->pInPortDef->format.video.nFrameWidth         = VIDDEC_DEFAULT_WIDTH;
   1238             pComponentPrivate->pInPortDef->format.video.nFrameHeight        = VIDDEC_DEFAULT_HEIGHT;
   1239             pComponentPrivate->pInPortDef->format.video.nBitrate            = VIDDEC_INPUT_PORT_BITRATE;
   1240             pComponentPrivate->pInPortDef->format.video.xFramerate          = VIDDEC_INPUT_PORT_FRAMERATE;
   1241             pComponentPrivate->pInPortDef->format.video.eCompressionFormat  = pComponentPrivate->pInPortFormat->eCompressionFormat;
   1242             pComponentPrivate->pInPortDef->format.video.eColorFormat        = pComponentPrivate->pInPortFormat->eColorFormat;
   1243             pComponentPrivate->pInPortDef->nBufferSize                      = pComponentPrivate->pInPortDef->format.video.nFrameWidth *
   1244                                                                               pComponentPrivate->pInPortDef->format.video.nFrameHeight *
   1245                                                                               VIDDEC_FACTORFORMAT420;
   1246             pComponentPrivate->pDeblockingParamType->bDeblocking            = OMX_FALSE;
   1247             pComponentPrivate->bIsSparkInput = OMX_TRUE;
   1248             break;
   1249 #endif
   1250 
   1251         case VIDDEC_INIT_H264:
   1252             pComponentPrivate->pH264->nPortIndex                            = VIDDEC_DEFAULT_H264_PORTINDEX;
   1253             pComponentPrivate->pH264->nPFrames                              = VIDDEC_DEFAULT_H264_PFRAMES;
   1254             pComponentPrivate->pH264->nBFrames                              = VIDDEC_DEFAULT_H264_BFRAMES;
   1255             pComponentPrivate->pH264->eProfile                              = OMX_VIDEO_AVCProfileBaseline;
   1256             pComponentPrivate->pH264->eLevel                                = OMX_VIDEO_AVCLevelMax;
   1257 
   1258             pComponentPrivate->pInPortFormat->nPortIndex                    = VIDDEC_INPUT_PORT;
   1259             pComponentPrivate->pInPortFormat->nIndex                        = VIDDEC_DEFAULT_INPUT_INDEX_H264;
   1260             pComponentPrivate->pInPortFormat->eCompressionFormat            = OMX_VIDEO_CodingAVC;
   1261             pComponentPrivate->pInPortFormat->eColorFormat                  = OMX_COLOR_FormatUnused;
   1262 #ifdef KHRONOS_1_1
   1263             pComponentPrivate->pInPortFormat->xFramerate                    = VIDDEC_INPUT_PORT_FRAMERATE;
   1264 #endif
   1265             pComponentPrivate->pInPortDef->format.video.nFrameWidth         = VIDDEC_DEFAULT_WIDTH;
   1266             pComponentPrivate->pInPortDef->format.video.nFrameHeight        = VIDDEC_DEFAULT_HEIGHT;
   1267             pComponentPrivate->pInPortDef->format.video.nBitrate            = VIDDEC_INPUT_PORT_BITRATE;
   1268             pComponentPrivate->pInPortDef->format.video.xFramerate          = VIDDEC_INPUT_PORT_FRAMERATE;
   1269             pComponentPrivate->pInPortDef->format.video.eCompressionFormat  = OMX_VIDEO_CodingAVC;
   1270             pComponentPrivate->pInPortDef->format.video.eColorFormat        = OMX_COLOR_FormatUnused;
   1271             pComponentPrivate->pInPortDef->nBufferSize                      = pComponentPrivate->pInPortDef->format.video.nFrameWidth *
   1272                                                                               pComponentPrivate->pInPortDef->format.video.nFrameHeight *
   1273                                                                               VIDDEC_FACTORFORMAT420;
   1274             pComponentPrivate->pDeblockingParamType->bDeblocking            = OMX_TRUE; /* Always enable */
   1275             pComponentPrivate->bIsSparkInput                                = OMX_FALSE;
   1276             break;
   1277 
   1278         case VIDDEC_INIT_MPEG2:
   1279             pComponentPrivate->pMpeg2->nPortIndex                           = VIDDEC_DEFAULT_MPEG2_PORTINDEX;
   1280             pComponentPrivate->pMpeg2->nPFrames                             = VIDDEC_DEFAULT_MPEG2_PFRAMES;
   1281             pComponentPrivate->pMpeg2->nBFrames                             = VIDDEC_DEFAULT_MPEG2_BFRAMES;
   1282             pComponentPrivate->pMpeg2->eProfile                             = OMX_VIDEO_MPEG2ProfileSimple;
   1283             pComponentPrivate->pMpeg2->eLevel                               = OMX_VIDEO_MPEG2LevelLL;
   1284 
   1285             pComponentPrivate->pInPortFormat->nPortIndex                    = VIDDEC_INPUT_PORT;
   1286             pComponentPrivate->pInPortFormat->nIndex                        = VIDDEC_DEFAULT_INPUT_INDEX_MPEG2;
   1287             pComponentPrivate->pInPortFormat->eCompressionFormat            = OMX_VIDEO_CodingMPEG2;
   1288             pComponentPrivate->pInPortFormat->eColorFormat                  = OMX_COLOR_FormatUnused;
   1289 #ifdef KHRONOS_1_1
   1290             pComponentPrivate->pInPortFormat->xFramerate                    = VIDDEC_INPUT_PORT_FRAMERATE;
   1291 #endif
   1292             pComponentPrivate->pInPortDef->format.video.nFrameWidth         = VIDDEC_DEFAULT_WIDTH;
   1293             pComponentPrivate->pInPortDef->format.video.nFrameHeight        = VIDDEC_DEFAULT_HEIGHT;
   1294             pComponentPrivate->pInPortDef->format.video.nBitrate            = VIDDEC_INPUT_PORT_BITRATE;
   1295             pComponentPrivate->pInPortDef->format.video.xFramerate          = VIDDEC_INPUT_PORT_FRAMERATE;
   1296             pComponentPrivate->pInPortDef->format.video.eCompressionFormat  = OMX_VIDEO_CodingMPEG2;
   1297             pComponentPrivate->pInPortDef->format.video.eColorFormat        = OMX_COLOR_FormatUnused;
   1298             pComponentPrivate->pInPortDef->nBufferSize                      = pComponentPrivate->pInPortDef->format.video.nFrameWidth *
   1299                                                                               pComponentPrivate->pInPortDef->format.video.nFrameHeight *
   1300                                                                               VIDDEC_FACTORFORMAT420;
   1301             pComponentPrivate->pDeblockingParamType->bDeblocking            = OMX_FALSE; /*TODO: Verify with algo team*/
   1302             pComponentPrivate->bIsSparkInput                                = OMX_FALSE;
   1303             break;
   1304 
   1305         case VIDDEC_INIT_MPEG4:
   1306             pComponentPrivate->pMpeg4->nPortIndex                           = VIDDEC_DEFAULT_MPEG4_PORTINDEX;
   1307             pComponentPrivate->pMpeg4->nPFrames                             = VIDDEC_DEFAULT_MPEG4_PFRAMES;
   1308             pComponentPrivate->pMpeg4->nBFrames                             = VIDDEC_DEFAULT_MPEG4_BFRAMES;
   1309             pComponentPrivate->pMpeg4->eProfile                             = OMX_VIDEO_MPEG4ProfileSimple;
   1310 #ifdef KHRONOS_1_1
   1311             pComponentPrivate->pMpeg4->eLevel                               = OMX_VIDEO_MPEG4Level1;
   1312 #else
   1313             pComponentPrivate->pMpeg4->eLevel                               = OMX_VIDEO_MPEG4Levell;
   1314 #endif
   1315             pComponentPrivate->pInPortFormat->nPortIndex                    = VIDDEC_INPUT_PORT;
   1316             pComponentPrivate->pInPortFormat->nIndex                        = VIDDEC_DEFAULT_INPUT_INDEX_MPEG4;
   1317             pComponentPrivate->pInPortFormat->eCompressionFormat            = OMX_VIDEO_CodingMPEG4;
   1318             pComponentPrivate->pInPortFormat->eColorFormat                  = OMX_COLOR_FormatUnused;
   1319 #ifdef KHRONOS_1_1
   1320             pComponentPrivate->pInPortFormat->xFramerate                    = VIDDEC_INPUT_PORT_FRAMERATE;
   1321 #endif
   1322             pComponentPrivate->pInPortDef->format.video.nFrameWidth         = VIDDEC_DEFAULT_WIDTH;
   1323             pComponentPrivate->pInPortDef->format.video.nFrameHeight        = VIDDEC_DEFAULT_HEIGHT;
   1324             pComponentPrivate->pInPortDef->format.video.nBitrate            = VIDDEC_INPUT_PORT_BITRATE;
   1325             pComponentPrivate->pInPortDef->format.video.xFramerate          = VIDDEC_INPUT_PORT_FRAMERATE;
   1326             pComponentPrivate->pInPortDef->format.video.eCompressionFormat  = OMX_VIDEO_CodingMPEG4;
   1327             pComponentPrivate->pInPortDef->format.video.eColorFormat        = OMX_COLOR_FormatUnused;
   1328             pComponentPrivate->pInPortDef->nBufferSize                      = pComponentPrivate->pInPortDef->format.video.nFrameWidth *
   1329                                                                               pComponentPrivate->pInPortDef->format.video.nFrameHeight *
   1330                                                                               VIDDEC_FACTORFORMAT420;
   1331             pComponentPrivate->pDeblockingParamType->bDeblocking            = OMX_FALSE;
   1332             pComponentPrivate->bIsSparkInput                                = OMX_FALSE;
   1333             break;
   1334 
   1335         case VIDDEC_INIT_WMV9:
   1336             pComponentPrivate->pWMV->nPortIndex                             = VIDDEC_DEFAULT_WMV_PORTINDEX;
   1337             pComponentPrivate->pWMV->eFormat                                = OMX_VIDEO_WMVFormat9;
   1338 
   1339             pComponentPrivate->pInPortFormat->nPortIndex                    = VIDDEC_INPUT_PORT;
   1340             pComponentPrivate->pInPortFormat->nIndex                        = VIDDEC_DEFAULT_INPUT_INDEX_WMV9;
   1341             pComponentPrivate->pInPortFormat->eCompressionFormat            = OMX_VIDEO_CodingWMV;
   1342             pComponentPrivate->pInPortFormat->eColorFormat                  = OMX_COLOR_FormatUnused;
   1343 #ifdef KHRONOS_1_1
   1344             pComponentPrivate->pInPortFormat->xFramerate                    = VIDDEC_INPUT_PORT_FRAMERATE;
   1345 #endif
   1346             pComponentPrivate->pInPortDef->format.video.nFrameWidth         = VIDDEC_DEFAULT_WIDTH;
   1347             pComponentPrivate->pInPortDef->format.video.nFrameHeight        = VIDDEC_DEFAULT_HEIGHT;
   1348             pComponentPrivate->pInPortDef->format.video.nBitrate            = VIDDEC_INPUT_PORT_BITRATE;
   1349             pComponentPrivate->pInPortDef->format.video.xFramerate          = VIDDEC_INPUT_PORT_FRAMERATE;
   1350             pComponentPrivate->pInPortDef->format.video.eCompressionFormat  = OMX_VIDEO_CodingWMV;
   1351             pComponentPrivate->pInPortDef->format.video.eColorFormat        = OMX_COLOR_FormatUnused;
   1352             pComponentPrivate->pInPortDef->nBufferSize                      = pComponentPrivate->pInPortDef->format.video.nFrameWidth *
   1353                                                                               pComponentPrivate->pInPortDef->format.video.nFrameHeight *
   1354                                                                               VIDDEC_FACTORFORMAT420;
   1355 
   1356             pComponentPrivate->nWMVFileType                                 = VIDDEC_WMV_RCVSTREAM; /* RCVSTREAM must be the default value*/
   1357             pComponentPrivate->pDeblockingParamType->bDeblocking            = OMX_TRUE; /* Always enable */
   1358             pComponentPrivate->bIsSparkInput                                = OMX_FALSE;
   1359             break;
   1360 
   1361         case VIDDEC_INIT_PLANAR420:
   1362 
   1363             pComponentPrivate->pOutPortFormat->nPortIndex                   = VIDDEC_OUTPUT_PORT;
   1364             pComponentPrivate->pOutPortFormat->nIndex                       = VIDDEC_DEFAULT_OUTPUT_INDEX_PLANAR420;
   1365             pComponentPrivate->pOutPortFormat->eCompressionFormat           = OMX_VIDEO_CodingUnused;
   1366             pComponentPrivate->pOutPortFormat->eColorFormat                 = VIDDEC_COLORFORMAT420;
   1367 #ifdef KHRONOS_1_1
   1368             pComponentPrivate->pOutPortFormat->xFramerate                   = VIDDEC_INPUT_PORT_FRAMERATE;
   1369 #endif
   1370             pComponentPrivate->pOutPortDef->format.video.nFrameWidth        = VIDDEC_DEFAULT_WIDTH;
   1371             pComponentPrivate->pOutPortDef->format.video.nFrameHeight       = VIDDEC_DEFAULT_HEIGHT;
   1372             pComponentPrivate->pOutPortDef->format.video.nBitrate           = VIDDEC_OUTPUT_PORT_BITRATE;
   1373             pComponentPrivate->pOutPortDef->format.video.xFramerate         = VIDDEC_OUTPUT_PORT_FRAMERATE;
   1374             pComponentPrivate->pOutPortDef->format.video.eCompressionFormat = VIDDEC_OUTPUT_PORT_COMPRESSIONFORMAT;
   1375             pComponentPrivate->pOutPortDef->format.video.eColorFormat       = VIDDEC_COLORFORMAT420;
   1376             pComponentPrivate->pOutPortDef->nBufferSize                     = pComponentPrivate->pOutPortDef->format.video.nFrameWidth *
   1377                                                                               pComponentPrivate->pOutPortDef->format.video.nFrameHeight *
   1378                                                                               VIDDEC_FACTORFORMAT420;
   1379 
   1380             break;
   1381 
   1382         case VIDDEC_INIT_INTERLEAVED422:
   1383             pComponentPrivate->pOutPortFormat->nPortIndex                   = VIDDEC_OUTPUT_PORT;
   1384             pComponentPrivate->pOutPortFormat->nIndex                       = VIDDEC_DEFAULT_OUTPUT_INDEX_INTERLEAVED422;
   1385             pComponentPrivate->pOutPortFormat->eCompressionFormat           = OMX_VIDEO_CodingUnused;
   1386             pComponentPrivate->pOutPortFormat->eColorFormat                 = VIDDEC_COLORFORMAT422;
   1387 #ifdef KHRONOS_1_1
   1388             pComponentPrivate->pOutPortFormat->xFramerate                   = VIDDEC_INPUT_PORT_FRAMERATE;
   1389 #endif
   1390             pComponentPrivate->pOutPortDef->format.video.nFrameWidth        = VIDDEC_DEFAULT_WIDTH;
   1391             pComponentPrivate->pOutPortDef->format.video.nFrameHeight       = VIDDEC_DEFAULT_HEIGHT;
   1392             pComponentPrivate->pOutPortDef->format.video.nBitrate           = VIDDEC_OUTPUT_PORT_BITRATE;
   1393             pComponentPrivate->pOutPortDef->format.video.xFramerate         = VIDDEC_OUTPUT_PORT_FRAMERATE;
   1394             pComponentPrivate->pOutPortDef->format.video.eCompressionFormat = VIDDEC_OUTPUT_PORT_COMPRESSIONFORMAT;
   1395             pComponentPrivate->pOutPortDef->format.video.eColorFormat       = VIDDEC_COLORFORMAT422;
   1396             pComponentPrivate->pOutPortDef->nBufferSize                     = pComponentPrivate->pOutPortDef->format.video.nFrameWidth *
   1397                                                                               pComponentPrivate->pOutPortDef->format.video.nFrameHeight *
   1398                                                                               VIDDEC_FACTORFORMAT422;
   1399 
   1400             break;
   1401 
   1402     }
   1403 
   1404 EXIT:
   1405     return(eError);
   1406 }
   1407 
   1408 /*----------------------------------------------------------------------------*/
   1409 /**
   1410   * VIDDEC_Start_ComponentThread() starts the component thread and all the pipes
   1411   * to achieve communication between dsp and application for commands and buffer
   1412   * interchanging
   1413   **/
   1414 /*----------------------------------------------------------------------------*/
   1415 OMX_ERRORTYPE VIDDEC_Start_ComponentThread(OMX_HANDLETYPE hComponent)
   1416 {
   1417     OMX_ERRORTYPE eError = OMX_ErrorNone;
   1418     OMX_COMPONENTTYPE* pComp = (OMX_COMPONENTTYPE*)hComponent;
   1419     VIDDEC_COMPONENT_PRIVATE* pComponentPrivate = (VIDDEC_COMPONENT_PRIVATE*)pComp->pComponentPrivate;
   1420 
   1421     pComponentPrivate->bIsStopping =    0;
   1422 
   1423     OMX_PRINT1(pComponentPrivate->dbg, "+++ENTERING\n");
   1424     /* create the pipe used to maintain free input buffers*/
   1425     eError = pipe(pComponentPrivate->free_inpBuf_Q);
   1426     if (eError) {
   1427         eError = OMX_ErrorInsufficientResources;
   1428         goto EXIT;
   1429     }
   1430 
   1431     /* create the pipe used to maintain free input buffers*/
   1432     eError = pipe(pComponentPrivate->free_outBuf_Q);
   1433     if (eError) {
   1434         eError = OMX_ErrorInsufficientResources;
   1435         goto EXIT;
   1436     }
   1437 
   1438     /* create the pipe used to maintain input buffers*/
   1439     eError = pipe(pComponentPrivate->filled_inpBuf_Q);
   1440     if (eError) {
   1441         eError = OMX_ErrorInsufficientResources;
   1442         goto EXIT;
   1443     }
   1444 
   1445     /* create the pipe used to maintain dsp output/encoded buffers*/
   1446     eError = pipe(pComponentPrivate->filled_outBuf_Q);
   1447     if (eError) {
   1448         eError = OMX_ErrorInsufficientResources;
   1449         goto EXIT;
   1450     }
   1451 
   1452     /* create the pipe used to send commands to the thread */
   1453     eError = pipe(pComponentPrivate->cmdPipe);
   1454     if (eError) {
   1455         eError = OMX_ErrorInsufficientResources;
   1456         goto EXIT;
   1457     }
   1458 
   1459     /* create the pipe used to send commands to the thread */
   1460     eError = pipe(pComponentPrivate->cmdDataPipe);
   1461     if (eError) {
   1462         eError = OMX_ErrorInsufficientResources;
   1463         goto EXIT;
   1464     }
   1465 
   1466     /* Create the Component Thread */
   1467     eError = pthread_create(&(pComponentPrivate->ComponentThread),
   1468                             NULL,
   1469                             OMX_VidDec_Thread,
   1470                             pComponentPrivate);
   1471 
   1472     OMX_TRACE2(pComponentPrivate->dbg, "pthread_create 0x%lx\n",(OMX_U32) pComponentPrivate->ComponentThread);
   1473     if (eError || !pComponentPrivate->ComponentThread) {
   1474         OMX_TRACE4(pComponentPrivate->dbg, "pthread_create  0x%x\n",eError);
   1475         eError = OMX_ErrorInsufficientResources;
   1476         goto EXIT;
   1477     }
   1478 
   1479 #ifdef __PERF_INSTRUMENTATION__
   1480     PERF_ThreadCreated(pComponentPrivate->pPERF,
   1481                        pComponentPrivate->ComponentThread,
   1482                        PERF_FOURS("VD T"));
   1483 #endif
   1484 
   1485 EXIT:
   1486     OMX_PRINT1(pComponentPrivate->dbg, "---EXITING(0x%x)\n",eError);
   1487     return eError;
   1488 }
   1489 
   1490 /* ========================================================================== */
   1491 /**
   1492 * @Stop_ComponentThread() This function is called by the component during
   1493 * de-init to close component thread, Command pipe & data pipes.
   1494 *
   1495 * @param pComponent  handle for this instance of the component
   1496 *
   1497 * @pre
   1498 *
   1499 * @post
   1500 *
   1501 * @return none
   1502 */
   1503 /* ========================================================================== */
   1504 OMX_ERRORTYPE VIDDEC_Stop_ComponentThread(OMX_HANDLETYPE pComponent)
   1505 {
   1506     OMX_ERRORTYPE eError = OMX_ErrorNone;
   1507     OMX_COMPONENTTYPE* pHandle = (OMX_COMPONENTTYPE*)pComponent;
   1508     VIDDEC_COMPONENT_PRIVATE* pComponentPrivate = (VIDDEC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate;
   1509     OMX_ERRORTYPE threadError = OMX_ErrorNone;
   1510     OMX_ERRORTYPE err = OMX_ErrorNone;
   1511     int pthreadError = 0;
   1512 
   1513     /* Join the component thread */
   1514     OMX_PRINT1(pComponentPrivate->dbg, "+++ENTERING\n");
   1515     OMX_TRACE2(pComponentPrivate->dbg, "pthread_join 0x%lx\n",(OMX_U32) pComponentPrivate->ComponentThread);
   1516 
   1517 #ifdef UNDER_CE
   1518     pthreadError = pthread_join(pComponentPrivate->ComponentThread, (void*)&threadError);
   1519     if (0 != pthreadError) {
   1520         eError = OMX_ErrorHardware;
   1521     }
   1522 #else
   1523     if(pComponentPrivate->bLCMLOut == OMX_TRUE) {
   1524         /*pthreadError = pthread_cancel(pComponentPrivate->ComponentThread);*/
   1525         if (0 != pthreadError) {
   1526             eError = OMX_ErrorHardware;
   1527         }
   1528     }
   1529     else{
   1530         pthreadError = pthread_join(pComponentPrivate->ComponentThread, (void*)&threadError);
   1531         if (0 != pthreadError) {
   1532             eError = OMX_ErrorHardware;
   1533         }
   1534     }
   1535 #endif
   1536 
   1537     /* Check for the errors */
   1538     if (OMX_ErrorNone != eError) {
   1539         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   1540                                                pComponentPrivate->pHandle->pApplicationPrivate,
   1541                                                OMX_EventError,
   1542                                                eError,
   1543                                                OMX_TI_ErrorSevere,
   1544                                                "Error while closing Component Thread\n");
   1545     }
   1546 
   1547     /* close the data pipe handles */
   1548     err = close(pComponentPrivate->free_inpBuf_Q[VIDDEC_PIPE_READ]);
   1549     if (0 != err) {
   1550         eError = OMX_ErrorHardware;
   1551         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   1552                                                pComponentPrivate->pHandle->pApplicationPrivate,
   1553                                                OMX_EventError,
   1554                                                eError,
   1555                                                OMX_TI_ErrorMajor,
   1556                                                "Error while closing data pipe\n");
   1557     }
   1558 
   1559     err = close(pComponentPrivate->free_outBuf_Q[VIDDEC_PIPE_READ]);
   1560     if (0 != err) {
   1561         eError = OMX_ErrorHardware;
   1562         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   1563                                                pComponentPrivate->pHandle->pApplicationPrivate,
   1564                                                OMX_EventError,
   1565                                                eError,
   1566                                                OMX_TI_ErrorMajor,
   1567                                                "Error while closing data pipe\n");
   1568     }
   1569 
   1570     err = close(pComponentPrivate->filled_inpBuf_Q[VIDDEC_PIPE_READ]);
   1571     if (0 != err) {
   1572         eError = OMX_ErrorHardware;
   1573         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   1574                                                pComponentPrivate->pHandle->pApplicationPrivate,
   1575                                                OMX_EventError,
   1576                                                eError,
   1577                                                OMX_TI_ErrorMajor,
   1578                                                "Error while closing data pipe\n");
   1579     }
   1580 
   1581     err = close(pComponentPrivate->filled_outBuf_Q[VIDDEC_PIPE_READ]);
   1582     if (0 != err) {
   1583         eError = OMX_ErrorHardware;
   1584         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   1585                                                pComponentPrivate->pHandle->pApplicationPrivate,
   1586                                                OMX_EventError,
   1587                                                eError,
   1588                                                OMX_TI_ErrorMajor,
   1589                                                "Error while closing data pipe\n");
   1590     }
   1591 
   1592     err = close(pComponentPrivate->free_inpBuf_Q[VIDDEC_PIPE_WRITE]);
   1593     if (0 != err) {
   1594         eError = OMX_ErrorHardware;
   1595         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   1596                                                pComponentPrivate->pHandle->pApplicationPrivate,
   1597                                                OMX_EventError,
   1598                                                eError,
   1599                                                OMX_TI_ErrorMajor,
   1600                                                "Error while closing data pipe\n");
   1601     }
   1602 
   1603     err = close(pComponentPrivate->free_outBuf_Q[VIDDEC_PIPE_WRITE]);
   1604     if (0 != err) {
   1605         eError = OMX_ErrorHardware;
   1606         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   1607                                                pComponentPrivate->pHandle->pApplicationPrivate,
   1608                                                OMX_EventError,
   1609                                                eError,
   1610                                                OMX_TI_ErrorMajor,
   1611                                                "Error while closing data pipe\n");
   1612     }
   1613 
   1614     err = close(pComponentPrivate->filled_inpBuf_Q[VIDDEC_PIPE_WRITE]);
   1615     if (0 != err) {
   1616         eError = OMX_ErrorHardware;
   1617         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   1618                                                pComponentPrivate->pHandle->pApplicationPrivate,
   1619                                                OMX_EventError,
   1620                                                eError,
   1621                                                OMX_TI_ErrorMajor,
   1622                                                "Error while closing data pipe\n");
   1623     }
   1624 
   1625     err = close(pComponentPrivate->filled_outBuf_Q[VIDDEC_PIPE_WRITE]);
   1626     if (0 != err) {
   1627         eError = OMX_ErrorHardware;
   1628         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   1629                                                pComponentPrivate->pHandle->pApplicationPrivate,
   1630                                                OMX_EventError,
   1631                                                eError,
   1632                                                OMX_TI_ErrorMajor,
   1633                                                "Error while closing data pipe\n");
   1634     }
   1635 
   1636     /* Close the command pipe handles */
   1637     err = close(pComponentPrivate->cmdPipe[VIDDEC_PIPE_READ]);
   1638     if (0 != err) {
   1639         eError = OMX_ErrorHardware;
   1640         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   1641                                                pComponentPrivate->pHandle->pApplicationPrivate,
   1642                                                OMX_EventError,
   1643                                                eError,
   1644                                                OMX_TI_ErrorMajor,
   1645                                                "Error while closing cmd pipe\n");
   1646     }
   1647 
   1648     err = close(pComponentPrivate->cmdPipe[VIDDEC_PIPE_WRITE]);
   1649     if (0 != err) {
   1650         eError = OMX_ErrorHardware;
   1651         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   1652                                                pComponentPrivate->pHandle->pApplicationPrivate,
   1653                                                OMX_EventError,
   1654                                                eError,
   1655                                                OMX_TI_ErrorMajor,
   1656                                                "Error while closing cmd pipe\n");
   1657     }
   1658 
   1659     /* Close the command data pipe handles */
   1660     err = close (pComponentPrivate->cmdDataPipe[VIDDEC_PIPE_READ]);
   1661     if (0 != err) {
   1662         eError = OMX_ErrorHardware;
   1663         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   1664                                                pComponentPrivate->pHandle->pApplicationPrivate,
   1665                                                OMX_EventError,
   1666                                                eError,
   1667                                                OMX_TI_ErrorMajor,
   1668                                                "Error while closing cmd pipe\n");
   1669     }
   1670 
   1671     err = close (pComponentPrivate->cmdDataPipe[VIDDEC_PIPE_WRITE]);
   1672     if (0 != err) {
   1673         eError = OMX_ErrorHardware;
   1674         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   1675                                                pComponentPrivate->pHandle->pApplicationPrivate,
   1676                                                OMX_EventError,
   1677                                                eError,
   1678                                                OMX_TI_ErrorMajor,
   1679                                                "Error while closing cmd pipe\n");
   1680     }
   1681     OMX_PRINT1(pComponentPrivate->dbg, "---EXITING(0x%x)\n",eError);
   1682     return eError;
   1683 }
   1684 
   1685 /* ========================================================================== */
   1686 /**
   1687   * Disable Port()
   1688   *
   1689   * Called by component thread, handles commands sent by the app.
   1690   *
   1691   * @param
   1692   *
   1693   * @retval OMX_ErrorNone                  success, ready to roll
   1694   *
   1695   **/
   1696 /* ========================================================================== */
   1697 
   1698 OMX_ERRORTYPE VIDDEC_DisablePort (VIDDEC_COMPONENT_PRIVATE* pComponentPrivate, OMX_U32 nParam1)
   1699 {
   1700     OMX_ERRORTYPE eError = OMX_ErrorNone;
   1701     static OMX_BOOL bFirstTimeToUnLoadCodec = OMX_TRUE; /*Needed when port disable is been call for input & output ports*/
   1702     OMX_PRINT1(pComponentPrivate->dbg, "+++ENTERING\n");
   1703     OMX_PRINT1(pComponentPrivate->dbg, "pComponentPrivate 0x%p nParam1 0x%lx\n",pComponentPrivate, nParam1);
   1704 
   1705     /* Protect VIDDEC_UnloadCodec() to be called twice while doing Dynamic port configuration*/
   1706     if(pComponentPrivate->bDynamicConfigurationInProgress && bFirstTimeToUnLoadCodec){
   1707         OMX_PRINT1(pComponentPrivate->dbg, "VIDDEC_UnloadCodec\n");
   1708         eError = VIDDEC_UnloadCodec(pComponentPrivate);
   1709         if (eError != OMX_ErrorNone) {
   1710             goto EXIT;
   1711         }
   1712         bFirstTimeToUnLoadCodec = OMX_FALSE;
   1713     }
   1714 
   1715     eError = VIDDEC_HandleCommandFlush(pComponentPrivate, -1, OMX_FALSE);
   1716 
   1717 
   1718 
   1719 #ifdef UNDER_CE
   1720     while(1) {
   1721         if (nParam1 == VIDDEC_INPUT_PORT && !pComponentPrivate->pInPortDef->bPopulated) {
   1722             /* return cmdcomplete event if input unpopulated */
   1723             OMX_PRBUFFER2(pComponentPrivate->dbg, "Unpopulated VIDDEC_INPUT_PORT IN 0x%x\n",pComponentPrivate->pInPortDef->bPopulated);
   1724             pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
   1725                                                     pComponentPrivate->pHandle->pApplicationPrivate,
   1726                                                     OMX_EventCmdComplete,
   1727                                                     OMX_CommandPortDisable,
   1728                                                     VIDDEC_INPUT_PORT,
   1729                                                     NULL);
   1730             break;
   1731         }
   1732         else if (nParam1 == VIDDEC_OUTPUT_PORT && !pComponentPrivate->pOutPortDef->bPopulated) {
   1733             /* return cmdcomplete event if output unpopulated */
   1734             OMX_PRBUFFER2(pComponentPrivate->dbg, "Unpopulated VIDDEC_OUTPUT_PORT OUT 0x%x\n",pComponentPrivate->pOutPortDef->bPopulated);
   1735             pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
   1736                                                     pComponentPrivate->pHandle->pApplicationPrivate,
   1737                                                     OMX_EventCmdComplete,
   1738                                                     OMX_CommandPortDisable,
   1739                                                     VIDDEC_OUTPUT_PORT,
   1740                                                     NULL);
   1741             break;
   1742         }
   1743         else if (nParam1 == VIDDEC_BOTH_PORT && !pComponentPrivate->pInPortDef->bPopulated &&
   1744                                   !pComponentPrivate->pOutPortDef->bPopulated) {
   1745             /* return cmdcomplete event if inout & output unpopulated */
   1746             OMX_PRBUFFER2(pComponentPrivate->dbg, "Unpopulated VIDDEC_INPUT_PORT IN 0x%x\n",pComponentPrivate->pInPortDef->bPopulated);
   1747             pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
   1748                                                     pComponentPrivate->pHandle->pApplicationPrivate,
   1749                                                     OMX_EventCmdComplete,
   1750                                                     OMX_CommandPortDisable,
   1751                                                     VIDDEC_INPUT_PORT,
   1752                                                     NULL);
   1753             OMX_PRBUFFER2(pComponentPrivate->dbg, "Unpopulated VIDDEC_OUTPUT_PORT OUT 0x%x\n",pComponentPrivate->pOutPortDef->bPopulated);
   1754             pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
   1755                                                     pComponentPrivate->pHandle->pApplicationPrivate,
   1756                                                     OMX_EventCmdComplete,
   1757                                                     OMX_CommandPortDisable,
   1758                                                     VIDDEC_OUTPUT_PORT,
   1759                                                     NULL);
   1760             break;
   1761         }
   1762         else if (nParam1 == VIDDEC_BOTH_PORT && !pComponentPrivate->pInPortDef->bPopulated &&
   1763                                   (pComponentPrivate->pCompPort[1]->hTunnelComponent != NULL)) {
   1764             /* return cmdcomplete event if inout & output unpopulated */
   1765             OMX_PRBUFFER2(pComponentPrivate->dbg, "Unpopulated VIDDEC_INPUT_PORT IN 0x%x\n",pComponentPrivate->pInPortDef->bPopulated);
   1766             pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
   1767                                                     pComponentPrivate->pHandle->pApplicationPrivate,
   1768                                                     OMX_EventCmdComplete,
   1769                                                     OMX_CommandPortDisable,
   1770                                                     VIDDEC_INPUT_PORT,
   1771                                                     NULL);
   1772             break;
   1773         }
   1774         VIDDEC_WAIT_CODE();
   1775     }
   1776 #else
   1777     if (nParam1 == VIDDEC_INPUT_PORT) {
   1778         if((!(pComponentPrivate->eState == OMX_StateLoaded) && pComponentPrivate->pInPortDef->bPopulated) ||
   1779             pComponentPrivate->sInSemaphore.bSignaled) {
   1780             VIDDEC_PTHREAD_SEMAPHORE_WAIT(pComponentPrivate->sInSemaphore);
   1781         }
   1782         OMX_PRBUFFER2(pComponentPrivate->dbg, "Unpopulated VIDDEC_INPUT_PORT IN 0x%x\n",pComponentPrivate->pInPortDef->bPopulated);
   1783         pComponentPrivate->bInPortSettingsChanged = OMX_FALSE;
   1784         OMX_PRBUFFER1(pComponentPrivate->dbg, "bInPortSettingsChanged = OMX_FALSE;\n");
   1785         pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
   1786                                                 pComponentPrivate->pHandle->pApplicationPrivate,
   1787                                                 OMX_EventCmdComplete,
   1788                                                 OMX_CommandPortDisable,
   1789                                                 VIDDEC_INPUT_PORT,
   1790                                                 NULL);
   1791     }
   1792     else if (nParam1 == VIDDEC_OUTPUT_PORT) {
   1793         if((!(pComponentPrivate->eState == OMX_StateLoaded) && pComponentPrivate->pOutPortDef->bPopulated) ||
   1794                 pComponentPrivate->sOutSemaphore.bSignaled) {
   1795             VIDDEC_PTHREAD_SEMAPHORE_WAIT(pComponentPrivate->sOutSemaphore);
   1796         }
   1797 
   1798         OMX_PRBUFFER2(pComponentPrivate->dbg, "Unpopulated VIDDEC_OUTPUT_PORT OUT 0x%x\n",pComponentPrivate->pOutPortDef->bPopulated);
   1799         OMX_PRBUFFER1(pComponentPrivate->dbg, "bOutPortSettingsChanged = OMX_FALSE;\n");
   1800         pComponentPrivate->bOutPortSettingsChanged = OMX_FALSE;
   1801         pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
   1802                                                 pComponentPrivate->pHandle->pApplicationPrivate,
   1803                                                 OMX_EventCmdComplete,
   1804                                                 OMX_CommandPortDisable,
   1805                                                 VIDDEC_OUTPUT_PORT,
   1806                                                 NULL);
   1807     }
   1808     else if (nParam1 == OMX_ALL) {
   1809         if(pComponentPrivate->pCompPort[1]->hTunnelComponent != NULL) {
   1810             if((!(pComponentPrivate->eState == OMX_StateLoaded) && pComponentPrivate->pInPortDef->bPopulated) ||
   1811                 pComponentPrivate->sInSemaphore.bSignaled) {
   1812                 VIDDEC_PTHREAD_SEMAPHORE_WAIT(pComponentPrivate->sInSemaphore);
   1813             }
   1814             OMX_PRBUFFER2(pComponentPrivate->dbg, "Unpopulated VIDDEC_INPUT_PORT IN 0x%x\n",pComponentPrivate->pInPortDef->bPopulated);
   1815             pComponentPrivate->bInPortSettingsChanged = OMX_FALSE;
   1816             pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
   1817                                                     pComponentPrivate->pHandle->pApplicationPrivate,
   1818                                                     OMX_EventCmdComplete,
   1819                                                     OMX_CommandPortDisable,
   1820                                                     VIDDEC_INPUT_PORT,
   1821                                                     NULL);
   1822         }
   1823         else {
   1824             if((!(pComponentPrivate->eState == OMX_StateLoaded) && pComponentPrivate->pInPortDef->bPopulated) ||
   1825                 pComponentPrivate->sInSemaphore.bSignaled) {
   1826                 VIDDEC_PTHREAD_SEMAPHORE_WAIT(pComponentPrivate->sInSemaphore);
   1827             }
   1828             OMX_PRBUFFER2(pComponentPrivate->dbg, "Populated VIDDEC_INPUT_PORT IN 0x%x\n",pComponentPrivate->pInPortDef->bPopulated);
   1829             pComponentPrivate->bInPortSettingsChanged = OMX_FALSE;
   1830             pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
   1831                                                     pComponentPrivate->pHandle->pApplicationPrivate,
   1832                                                     OMX_EventCmdComplete,
   1833                                                     OMX_CommandPortDisable,
   1834                                                     VIDDEC_INPUT_PORT,
   1835                                                     NULL);
   1836             if((!(pComponentPrivate->eState == OMX_StateLoaded) && pComponentPrivate->pOutPortDef->bPopulated) ||
   1837                 pComponentPrivate->sOutSemaphore.bSignaled) {
   1838                 VIDDEC_PTHREAD_SEMAPHORE_WAIT(pComponentPrivate->sOutSemaphore);
   1839             }
   1840             OMX_PRBUFFER2(pComponentPrivate->dbg, "Populated VIDDEC_OUTPUT_PORT IN 0x%x\n",pComponentPrivate->pInPortDef->bPopulated);
   1841             pComponentPrivate->bOutPortSettingsChanged = OMX_FALSE;
   1842             pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
   1843                                                     pComponentPrivate->pHandle->pApplicationPrivate,
   1844                                                     OMX_EventCmdComplete,
   1845                                                     OMX_CommandPortDisable,
   1846                                                     VIDDEC_OUTPUT_PORT,
   1847                                                     NULL);
   1848         }
   1849     }
   1850 #endif
   1851 
   1852         /* Reset values to initial state*/
   1853     if(pComponentPrivate->bDynamicConfigurationInProgress){
   1854         if(pComponentPrivate->bOutPortSettingsChanged == OMX_FALSE && pComponentPrivate->bInPortSettingsChanged == OMX_FALSE){
   1855             pComponentPrivate->bDynamicConfigurationInProgress = OMX_FALSE;
   1856             bFirstTimeToUnLoadCodec = OMX_TRUE;
   1857             OMX_PRBUFFER1(pComponentPrivate->dbg, "bDynamicConfigurationInProgress = OMX_FALSE;\n");
   1858         }
   1859     }
   1860 
   1861 EXIT:
   1862     OMX_PRINT1(pComponentPrivate->dbg, "---EXITING(0x%x)\n",eError);
   1863     return eError;
   1864 }
   1865 
   1866 OMX_ERRORTYPE VIDDEC_EmptyBufferDone(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate, OMX_BUFFERHEADERTYPE* pBufferHeader)
   1867 {
   1868     //LOGI("VIDDEC_EmptyBufferDone: header %p buffer %p", pBufferHeader, pBufferHeader->pBuffer);
   1869     ((VIDDEC_BUFFER_PRIVATE* )pBufferHeader->pInputPortPrivate)->eBufferOwner = VIDDEC_BUFFER_WITH_CLIENT;
   1870 
   1871     // No buffer flag EOS event needs to be sent for INPUT port
   1872 
   1873     OMX_ERRORTYPE ret = pComponentPrivate->cbInfo.EmptyBufferDone(pComponentPrivate->pHandle,
   1874                                                      pComponentPrivate->pHandle->pApplicationPrivate,
   1875                                                      pBufferHeader);
   1876 
   1877     VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->inputFlushCompletionMutex);
   1878     OMX_U32 nCountInputBFromDsp = 0;
   1879     pthread_mutex_lock(&pComponentPrivate->mutexInputBFromDSP);
   1880     nCountInputBFromDsp = pComponentPrivate->nCountInputBFromDsp;
   1881     pthread_mutex_unlock(&pComponentPrivate->mutexInputBFromDSP);
   1882     if (pComponentPrivate->bIsInputFlushPending && nCountInputBFromDsp == 0) {
   1883         VIDDEC_PTHREAD_MUTEX_SIGNAL(pComponentPrivate->inputFlushCompletionMutex);
   1884     }
   1885     VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->inputFlushCompletionMutex);
   1886 
   1887     return ret;
   1888 }
   1889 
   1890 OMX_ERRORTYPE VIDDEC_FillBufferDone(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate, OMX_BUFFERHEADERTYPE* pBufferHeader)
   1891 {
   1892     //LOGI("VIDDEC_FillBufferDone: header %p buffer %p", pBufferHeader, pBufferHeader->pBuffer);
   1893     ((VIDDEC_BUFFER_PRIVATE* )pBufferHeader->pOutputPortPrivate)->eBufferOwner = VIDDEC_BUFFER_WITH_CLIENT;
   1894 
   1895     // OpenMAX-IL standard specifies that a component generates the OMX_EventBufferFlag event when an OUTPUT port
   1896     // emits a buffer with the OMX_BUFFERFLAG_EOS flag set in the nFlags field
   1897     if (pBufferHeader->nFlags & OMX_BUFFERFLAG_EOS) {
   1898         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   1899                                                pComponentPrivate->pHandle->pApplicationPrivate,
   1900                                                OMX_EventBufferFlag,
   1901                                                VIDDEC_OUTPUT_PORT,
   1902                                                pBufferHeader->nFlags,
   1903                                                NULL);
   1904     }
   1905 
   1906     OMX_ERRORTYPE ret = pComponentPrivate->cbInfo.FillBufferDone(pComponentPrivate->pHandle,
   1907                                                      pComponentPrivate->pHandle->pApplicationPrivate,
   1908                                                      pBufferHeader);
   1909 
   1910     VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->outputFlushCompletionMutex);
   1911     OMX_U32 nCountOutputBFromDsp = 0;
   1912     pthread_mutex_lock(&pComponentPrivate->mutexOutputBFromDSP);
   1913     nCountOutputBFromDsp = pComponentPrivate->nCountOutputBFromDsp;
   1914     pthread_mutex_unlock(&pComponentPrivate->mutexOutputBFromDSP);
   1915     if (pComponentPrivate->bIsOutputFlushPending && nCountOutputBFromDsp == 0) {
   1916         VIDDEC_PTHREAD_MUTEX_SIGNAL(pComponentPrivate->outputFlushCompletionMutex);
   1917     }
   1918     VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->outputFlushCompletionMutex);
   1919 
   1920     return ret;
   1921 }
   1922 /* ========================================================================== */
   1923 /**
   1924   * Return Buffers()
   1925   *
   1926   * Called by Disable and Enable Buffers, return the buffers to their respective source.
   1927   *
   1928   * @param
   1929   *
   1930   * @retval OMX_ErrorNone                  success, ready to roll
   1931   *
   1932   **/
   1933 /* ========================================================================== */
   1934 OMX_ERRORTYPE VIDDEC_ReturnBuffers (VIDDEC_COMPONENT_PRIVATE* pComponentPrivate, OMX_U32 nParam1, OMX_BOOL bRetDSP)
   1935 {
   1936     OMX_U8 i = 0;
   1937     OMX_ERRORTYPE eError = OMX_ErrorNone;
   1938     OMX_BUFFERHEADERTYPE *pBuffHead;
   1939 
   1940     OMX_PRBUFFER1(pComponentPrivate->dbg, "+++ENTERING\n");
   1941     OMX_PRBUFFER1(pComponentPrivate->dbg, "pComponentPrivate 0x%p nParam1 0x%lx bRetDSP 0x%x\n",pComponentPrivate,nParam1,bRetDSP);
   1942     OMX_VidDec_Return(pComponentPrivate);
   1943     if (nParam1 == pComponentPrivate->pInPortFormat->nPortIndex || nParam1 == OMX_ALL) {
   1944             for (i = 0; i < pComponentPrivate->pInPortDef->nBufferCountActual; i++) {
   1945                     if((pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT]->pBufferPrivate[i]->eBufferOwner == VIDDEC_BUFFER_WITH_DSP) && bRetDSP){
   1946                         OMX_PRBUFFER1(pComponentPrivate->dbg, "inBuffer 0x%p eBufferOwner 0x%x\n",pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT]->pBufferPrivate[i]->pBufferHdr,
   1947                             pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT]->pBufferPrivate[i]->eBufferOwner);
   1948                         pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT]->pBufferPrivate[i]->eBufferOwner = VIDDEC_BUFFER_WITH_CLIENT;
   1949                         pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT]->pBufferPrivate[i]->pBufferHdr->nFilledLen = 0;
   1950 
   1951 #ifdef __PERF_INSTRUMENTATION__
   1952                         PERF_SendingFrame(pComponentPrivate->pPERFcomp,
   1953                                           pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT]->pBufferPrivate[i]->pBufferHdr->pBuffer,
   1954                                           pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT]->pBufferPrivate[i]->pBufferHdr->nFilledLen,
   1955                                           PERF_ModuleHLMM);
   1956 #endif
   1957 
   1958                         eError = VIDDEC_EmptyBufferDone(pComponentPrivate, pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT]->pBufferPrivate[i]->pBufferHdr);
   1959                     }
   1960             }
   1961        }
   1962     if (nParam1 == pComponentPrivate->pOutPortFormat->nPortIndex || nParam1 == OMX_ALL) {
   1963             if (pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->hTunnelComponent != NULL) {
   1964                 for (i = 0; i < pComponentPrivate->pOutPortDef->nBufferCountActual; i++) {
   1965                    OMX_PRBUFFER1(pComponentPrivate->dbg, "tunnelVideoDecBuffer[%x]=%x-%lx\n",i,
   1966                    pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[i]->eBufferOwner,pComponentPrivate->pOutPortDef->nBufferCountActual);
   1967                         OMX_PRBUFFER1(pComponentPrivate->dbg, "enter return %lx\n",pComponentPrivate->pOutPortDef->nBufferCountActual);
   1968                         if((pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[i]->eBufferOwner == VIDDEC_BUFFER_WITH_DSP) && bRetDSP){
   1969                                pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[i]->eBufferOwner = VIDDEC_BUFFER_WITH_TUNNELEDCOMP;
   1970                                 OMX_PRBUFFER1(pComponentPrivate->dbg, "Buffer 0x%x eBufferOwner 0x%x\n",(int)pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[i]->pBufferHdr
   1971                                 ,pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[i]->eBufferOwner);
   1972                             pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[i]->pBufferHdr->nFilledLen = 0;
   1973 
   1974 #ifdef __PERF_INSTRUMENTATION__
   1975                             PERF_SendingFrame(pComponentPrivate->pPERFcomp,
   1976                                               pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[i]->pBufferHdr->pBuffer,
   1977                                               pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[i]->pBufferHdr->nFilledLen,
   1978                                               PERF_ModuleLLMM);
   1979 #endif
   1980 
   1981                             OMX_PRBUFFER1(pComponentPrivate->dbg, "VideDec->PostProc EmptyThisBuffer\n");
   1982                             OMX_PRBUFFER1(pComponentPrivate->dbg, "wait to return buffer\n");
   1983                             pBuffHead = (OMX_BUFFERHEADERTYPE*)pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[i]->pBufferHdr;
   1984                             VIDDEC_Propagate_Mark(pComponentPrivate, pBuffHead);
   1985                             eError = OMX_EmptyThisBuffer(pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->hTunnelComponent, pBuffHead);
   1986                         }
   1987                 }
   1988             }
   1989             else {
   1990                 OMX_PRINT1(pComponentPrivate->dbg, "non tunneling\n");
   1991                 for (i = 0; i < pComponentPrivate->pOutPortDef->nBufferCountActual; i++) {
   1992                         if((pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[i]->eBufferOwner == VIDDEC_BUFFER_WITH_DSP) && bRetDSP){
   1993                             OMX_PRBUFFER1(pComponentPrivate->dbg, "xBuffer 0x%p eBufferOwner 0x%x\n",pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[i]->pBufferHdr,
   1994                                 pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[i]->eBufferOwner);
   1995                             pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[i]->eBufferOwner = VIDDEC_BUFFER_WITH_CLIENT;
   1996                             pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[i]->pBufferHdr->nFilledLen = 0;
   1997 
   1998 #ifdef __PERF_INSTRUMENTATION__
   1999                             PERF_SendingFrame(pComponentPrivate->pPERFcomp,
   2000                                               pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[i]->pBufferHdr->pBuffer,
   2001                                               pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[i]->pBufferHdr->nFilledLen,
   2002                                               PERF_ModuleHLMM);
   2003 #endif
   2004 
   2005                             pBuffHead = (OMX_BUFFERHEADERTYPE*)pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[i]->pBufferHdr;
   2006                             VIDDEC_Propagate_Mark(pComponentPrivate, pBuffHead);
   2007                             eError = VIDDEC_FillBufferDone(pComponentPrivate, pBuffHead);
   2008                        }
   2009                 }
   2010            }
   2011         }
   2012     OMX_PRBUFFER1(pComponentPrivate->dbg, "---EXITING(0x%x)\n",eError);
   2013     return eError;
   2014 }
   2015 
   2016 
   2017 /* ========================================================================== */
   2018 /**
   2019   * Enable Port()
   2020   *
   2021   * Called by component thread, handles commands sent by the app.
   2022   *
   2023   * @param
   2024   *
   2025   * @retval OMX_ErrorNone                  success, ready to roll
   2026   *
   2027   **/
   2028 /* ========================================================================== */
   2029 OMX_ERRORTYPE VIDDEC_EnablePort (VIDDEC_COMPONENT_PRIVATE* pComponentPrivate, OMX_U32 nParam1)
   2030 {
   2031     OMX_ERRORTYPE eError = OMX_ErrorNone;
   2032     OMX_PRINT1(pComponentPrivate->dbg, "+++ENTERING\n");
   2033     OMX_PRINT1(pComponentPrivate->dbg, "pComponentPrivate 0x%p nParam1 0x%lx\n",pComponentPrivate, nParam1);
   2034 
   2035 #ifdef UNDER_CE
   2036     while(1) {
   2037         if (nParam1 == VIDDEC_INPUT_PORT && (pComponentPrivate->eState == OMX_StateLoaded || pComponentPrivate->pInPortDef->bPopulated)) {
   2038             /* return cmdcomplete event if input unpopulated */
   2039             OMX_PRBUFFER2(pComponentPrivate->dbg, "Populated VIDDEC_INPUT_PORT 0x%x\n",pComponentPrivate->pInPortDef->bEnabled);
   2040             pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
   2041                                                     pComponentPrivate->pHandle->pApplicationPrivate,
   2042                                                     OMX_EventCmdComplete,
   2043                                                     OMX_CommandPortEnable,
   2044                                                     VIDDEC_INPUT_PORT,
   2045                                                     NULL);
   2046             break;
   2047         }
   2048         else if (nParam1 == VIDDEC_OUTPUT_PORT && (pComponentPrivate->eState == OMX_StateLoaded ||
   2049                                     pComponentPrivate->pOutPortDef->bPopulated)) {
   2050             /* return cmdcomplete event if output unpopulated */
   2051             OMX_PRBUFFER2(pComponentPrivate->dbg, "Populated VIDDEC_OUTPUT_PORT 0x%x\n",pComponentPrivate->pOutPortDef->bEnabled);
   2052             pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
   2053                                                     pComponentPrivate->pHandle->pApplicationPrivate,
   2054                                                     OMX_EventCmdComplete,
   2055                                                     OMX_CommandPortEnable,
   2056                                                     VIDDEC_OUTPUT_PORT,
   2057                                                     NULL);
   2058             break;
   2059         }
   2060         else if (nParam1 == VIDDEC_BOTH_PORT && (pComponentPrivate->eState == OMX_StateLoaded ||
   2061                                     (pComponentPrivate->pInPortDef->bPopulated &&
   2062                                     pComponentPrivate->pOutPortDef->bPopulated))) {
   2063             /* return cmdcomplete event if inout & output unpopulated */
   2064             OMX_PRBUFFER2(pComponentPrivate->dbg, "Enabling VIDDEC_OUTPUT_PORT 0x%x\n",pComponentPrivate->pOutPortDef->bEnabled);
   2065             OMX_PRBUFFER2(pComponentPrivate->dbg, "Populated VIDDEC_INPUT_PORT 0x%x\n",pComponentPrivate->pOutPortDef->bEnabled);
   2066             pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
   2067                                                     pComponentPrivate->pHandle->pApplicationPrivate,
   2068                                                     OMX_EventCmdComplete,
   2069                                                     OMX_CommandPortEnable,
   2070                                                     VIDDEC_INPUT_PORT,
   2071                                                     NULL);
   2072             OMX_PRBUFFER2(pComponentPrivate->dbg, "Populated VIDDEC_OUTPUT_PORT 0x%x\n",pComponentPrivate->pOutPortDef->bEnabled);
   2073             pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
   2074                                                     pComponentPrivate->pHandle->pApplicationPrivate,
   2075                                                     OMX_EventCmdComplete,
   2076                                                     OMX_CommandPortEnable,
   2077                                                     VIDDEC_OUTPUT_PORT,
   2078                                                     NULL);
   2079             break;
   2080         }
   2081         else if (nParam1 == OMX_ALL && && (pComponentPrivate->eState == OMX_StateLoaded ||
   2082                                     pComponentPrivate->pInPortDef->bPopulated) &&
   2083                                   (pComponentPrivate->pCompPort[1]->hTunnelComponent != NULL)) {
   2084             /* return cmdcomplete event if inout & output unpopulated */
   2085             OMX_PRBUFFER2(pComponentPrivate->dbg, "Enabling VIDDEC_OUTPUT_PORT 0x%x\n",pComponentPrivate->pOutPortDef->bEnabled);
   2086             OMX_PRBUFFER2(pComponentPrivate->dbg, "Populated VIDDEC_INPUT_PORT 0x%x\n",pComponentPrivate->pOutPortDef->bEnabled);
   2087             pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
   2088                                                     pComponentPrivate->pHandle->pApplicationPrivate,
   2089                                                     OMX_EventCmdComplete,
   2090                                                     OMX_CommandPortEnable,
   2091                                                     VIDDEC_INPUT_PORT,
   2092                                                     NULL);
   2093             break;
   2094         }
   2095         VIDDEC_WAIT_CODE();
   2096     }
   2097 #else
   2098     if (nParam1 == VIDDEC_INPUT_PORT) {
   2099         OMX_PRBUFFER2(pComponentPrivate->dbg, "Populated VIDDEC_INPUT_PORT IN 0x%x\n",pComponentPrivate->pInPortDef->bPopulated);
   2100         if((!(pComponentPrivate->eState == OMX_StateLoaded) && !pComponentPrivate->pInPortDef->bPopulated) ||
   2101             pComponentPrivate->sInSemaphore.bSignaled) {
   2102             VIDDEC_PTHREAD_SEMAPHORE_WAIT(pComponentPrivate->sInSemaphore);
   2103         }
   2104 
   2105 
   2106             if(pComponentPrivate->eLCMLState == VidDec_LCML_State_Unload &&
   2107                     pComponentPrivate->bDynamicConfigurationInProgress == OMX_FALSE &&
   2108                     pComponentPrivate->pInPortDef->bEnabled == OMX_TRUE &&
   2109                     pComponentPrivate->pOutPortDef->bEnabled == OMX_TRUE){
   2110             OMX_PRBUFFER1(pComponentPrivate->dbg, "BSC VIDDEC_INPUT_PORT\n");
   2111             eError = VIDDEC_LoadCodec(pComponentPrivate);
   2112             if(eError != OMX_ErrorNone){
   2113                 goto EXIT;
   2114             }
   2115         }
   2116         pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
   2117                                                 pComponentPrivate->pHandle->pApplicationPrivate,
   2118                                                 OMX_EventCmdComplete,
   2119                                                 OMX_CommandPortEnable,
   2120                                                 VIDDEC_INPUT_PORT,
   2121                                                 NULL);
   2122     }
   2123     else if (nParam1 == VIDDEC_OUTPUT_PORT) {
   2124 
   2125         OMX_PRBUFFER2(pComponentPrivate->dbg, "Populated VIDDEC_OUTPUT_PORT OUT 0x%x\n",pComponentPrivate->pOutPortDef->bPopulated);
   2126         if((!(pComponentPrivate->eState == OMX_StateLoaded) && !pComponentPrivate->pOutPortDef->bPopulated) ||
   2127             pComponentPrivate->sOutSemaphore.bSignaled) {
   2128             VIDDEC_PTHREAD_SEMAPHORE_WAIT(pComponentPrivate->sOutSemaphore);
   2129         }
   2130 
   2131         if(pComponentPrivate->eLCMLState == VidDec_LCML_State_Unload &&
   2132                 pComponentPrivate->bDynamicConfigurationInProgress == OMX_FALSE &&
   2133                 pComponentPrivate->pInPortDef->bEnabled == OMX_TRUE &&
   2134                 pComponentPrivate->pOutPortDef->bEnabled == OMX_TRUE){
   2135             OMX_PRBUFFER1(pComponentPrivate->dbg, "BSC VIDDEC_OUTPUT_PORT\n");
   2136             eError = VIDDEC_LoadCodec(pComponentPrivate);
   2137             if(eError != OMX_ErrorNone){
   2138                 goto EXIT;
   2139             }
   2140         }
   2141         pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
   2142                                                 pComponentPrivate->pHandle->pApplicationPrivate,
   2143                                                 OMX_EventCmdComplete,
   2144                                                 OMX_CommandPortEnable,
   2145                                                 VIDDEC_OUTPUT_PORT,
   2146                                                 NULL);
   2147     }
   2148     else if (nParam1 == OMX_ALL) {
   2149         if(pComponentPrivate->pCompPort[1]->hTunnelComponent != NULL) {
   2150             OMX_PRBUFFER2(pComponentPrivate->dbg, "Populated VIDDEC_INPUT_PORT IN 0x%x\n",pComponentPrivate->pInPortDef->bPopulated);
   2151             if((!(pComponentPrivate->eState == OMX_StateLoaded) && !pComponentPrivate->pInPortDef->bPopulated) ||
   2152                 pComponentPrivate->sInSemaphore.bSignaled) {
   2153                 VIDDEC_PTHREAD_SEMAPHORE_WAIT(pComponentPrivate->sInSemaphore);
   2154             }
   2155 
   2156             if(pComponentPrivate->eLCMLState == VidDec_LCML_State_Unload){
   2157                 eError = VIDDEC_LoadCodec(pComponentPrivate);
   2158                 if(eError != OMX_ErrorNone){
   2159                     goto EXIT;
   2160                 }
   2161             }
   2162             pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
   2163                                                     pComponentPrivate->pHandle->pApplicationPrivate,
   2164                                                     OMX_EventCmdComplete,
   2165                                                     OMX_CommandPortEnable,
   2166                                                     VIDDEC_INPUT_PORT,
   2167                                                     NULL);
   2168         }
   2169         else {
   2170             if((!(pComponentPrivate->eState == OMX_StateLoaded) && !pComponentPrivate->pInPortDef->bPopulated) ||
   2171                 pComponentPrivate->sInSemaphore.bSignaled) {
   2172                 VIDDEC_PTHREAD_SEMAPHORE_WAIT(pComponentPrivate->sInSemaphore);
   2173             }
   2174             if(pComponentPrivate->eLCMLState == VidDec_LCML_State_Unload){
   2175                 OMX_PRBUFFER1(pComponentPrivate->dbg, "BSC OMX_ALL\n");
   2176                 eError = VIDDEC_LoadCodec(pComponentPrivate);
   2177                 if(eError != OMX_ErrorNone){
   2178                     goto EXIT;
   2179                 }
   2180             }
   2181             OMX_PRBUFFER2(pComponentPrivate->dbg, "Populated VIDDEC_INPUT_PORT IN 0x%x\n",pComponentPrivate->pInPortDef->bPopulated);
   2182             pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
   2183                                                     pComponentPrivate->pHandle->pApplicationPrivate,
   2184                                                     OMX_EventCmdComplete,
   2185                                                     OMX_CommandPortEnable,
   2186                                                     VIDDEC_INPUT_PORT,
   2187                                                     NULL);
   2188             if((!(pComponentPrivate->eState == OMX_StateLoaded) && !pComponentPrivate->pOutPortDef->bPopulated) ||
   2189                 pComponentPrivate->sOutSemaphore.bSignaled) {
   2190                 VIDDEC_PTHREAD_SEMAPHORE_WAIT(pComponentPrivate->sOutSemaphore);
   2191             }
   2192             OMX_PRBUFFER2(pComponentPrivate->dbg, "Populated VIDDEC_INPUT_PORT IN 0x%x\n",pComponentPrivate->pInPortDef->bPopulated);
   2193             pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
   2194                                                     pComponentPrivate->pHandle->pApplicationPrivate,
   2195                                                     OMX_EventCmdComplete,
   2196                                                     OMX_CommandPortEnable,
   2197                                                     VIDDEC_OUTPUT_PORT,
   2198                                                     NULL);
   2199         }
   2200     }
   2201 #endif
   2202 EXIT:
   2203     OMX_PRINT1(pComponentPrivate->dbg, "---EXITING(0x%x)\n",eError);
   2204     return eError;
   2205 }
   2206 
   2207 /* ========================================================================== */
   2208 /**
   2209   * HandleCommandFlush()
   2210   *
   2211   * Called by component thread, handles the flush command from thread.
   2212   *
   2213   * @param
   2214   *
   2215   * @retval OMX_ErrorNone                  success, ready to roll
   2216   *
   2217   **/
   2218 /* ========================================================================== */
   2219 
   2220 OMX_ERRORTYPE VIDDEC_HandleCommandFlush(VIDDEC_COMPONENT_PRIVATE *pComponentPrivate, OMX_U32 nParam1, OMX_BOOL bPass)
   2221 {
   2222     OMX_ERRORTYPE eError = OMX_ErrorNone;
   2223     OMX_U32 aParam[4];
   2224     LCML_DSP_INTERFACE *pLcmlHandle = NULL;
   2225 
   2226     OMX_PRINT1(pComponentPrivate->dbg, "+++ENTERING\n");
   2227     OMX_PRINT1(pComponentPrivate->dbg, "pComponentPrivate 0x%p nParam1 0x%lx\n",pComponentPrivate, nParam1);
   2228 
   2229     if ( nParam1 == VIDDEC_INPUT_PORT || nParam1 == OMX_ALL){
   2230         if(bPass) {
   2231             OMX_VidDec_Return(pComponentPrivate);
   2232         }
   2233 
   2234         if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   2235             pComponentPrivate->eLCMLState != VidDec_LCML_State_Destroy &&
   2236             pComponentPrivate->pLCML != NULL && pComponentPrivate->bLCMLHalted != OMX_TRUE){
   2237             aParam[0] = USN_STRMCMD_FLUSH;
   2238             aParam[1] = VIDDEC_INPUT_PORT;
   2239             aParam[2] = 0;
   2240             VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->sMutex);
   2241             pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
   2242             eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,EMMCodecControlStrmCtrl, (void*)aParam);
   2243             if (eError != OMX_ErrorNone) {
   2244                 eError = OMX_ErrorHardware;
   2245                 VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   2246                 goto EXIT;
   2247             }
   2248             VIDDEC_PTHREAD_MUTEX_WAIT(pComponentPrivate->sMutex);
   2249             VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   2250 
   2251         }
   2252         VIDDEC_CircBuf_Flush(pComponentPrivate, VIDDEC_CBUFFER_TIMESTAMP, VIDDEC_INPUT_PORT);
   2253         OMX_VidDec_Return(pComponentPrivate);
   2254         if(bPass) {
   2255             VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->inputFlushCompletionMutex);
   2256             pComponentPrivate->bIsInputFlushPending = OMX_TRUE;
   2257             OMX_U32 nCountInputBFromDsp = 0;
   2258             pthread_mutex_lock(&pComponentPrivate->mutexInputBFromDSP);
   2259             nCountInputBFromDsp = pComponentPrivate->nCountInputBFromDsp;
   2260             pthread_mutex_unlock(&pComponentPrivate->mutexInputBFromDSP);
   2261             if (nCountInputBFromDsp > 0) {
   2262                 VIDDEC_PTHREAD_MUTEX_WAIT(pComponentPrivate->inputFlushCompletionMutex);
   2263             }
   2264             pComponentPrivate->bIsInputFlushPending = OMX_FALSE;
   2265             VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->inputFlushCompletionMutex);
   2266             pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   2267                                                 pComponentPrivate->pHandle->pApplicationPrivate,
   2268                                                 OMX_EventCmdComplete,
   2269                                                 OMX_CommandFlush,
   2270                                                 VIDDEC_INPUT_PORT,
   2271                                                 NULL);
   2272         }
   2273     }
   2274 
   2275     if ( nParam1 == VIDDEC_OUTPUT_PORT || nParam1 == OMX_ALL){
   2276         if(bPass){
   2277             OMX_VidDec_Return(pComponentPrivate);
   2278         }
   2279         if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   2280             pComponentPrivate->eLCMLState != VidDec_LCML_State_Destroy &&
   2281             pComponentPrivate->pLCML != NULL && pComponentPrivate->bLCMLHalted != OMX_TRUE){
   2282             aParam[0] = USN_STRMCMD_FLUSH;
   2283             aParam[1] = VIDDEC_OUTPUT_PORT;
   2284             aParam[2] = 0;
   2285             VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->sMutex);
   2286             pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
   2287             eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,EMMCodecControlStrmCtrl, (void*)aParam);
   2288             if (eError != OMX_ErrorNone) {
   2289                 eError = OMX_ErrorHardware;
   2290                 VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   2291                 goto EXIT;
   2292             }
   2293             VIDDEC_PTHREAD_MUTEX_WAIT(pComponentPrivate->sMutex);
   2294             VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   2295         }
   2296         OMX_VidDec_Return(pComponentPrivate);
   2297         if(bPass) {
   2298             VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->outputFlushCompletionMutex);
   2299             pComponentPrivate->bIsOutputFlushPending = OMX_TRUE;
   2300             OMX_U32 nCountOutputBFromDsp = 0;
   2301             pthread_mutex_lock(&pComponentPrivate->mutexOutputBFromDSP);
   2302             nCountOutputBFromDsp = pComponentPrivate->nCountOutputBFromDsp;
   2303             pthread_mutex_unlock(&pComponentPrivate->mutexOutputBFromDSP);
   2304             if (nCountOutputBFromDsp > 0) {
   2305                 VIDDEC_PTHREAD_MUTEX_WAIT(pComponentPrivate->outputFlushCompletionMutex);
   2306             }
   2307             pComponentPrivate->bIsOutputFlushPending = OMX_FALSE;
   2308             VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->outputFlushCompletionMutex);
   2309             pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   2310                                                 pComponentPrivate->pHandle->pApplicationPrivate,
   2311                                                 OMX_EventCmdComplete,
   2312                                                 OMX_CommandFlush,
   2313                                                 VIDDEC_OUTPUT_PORT,
   2314                                                 NULL);
   2315 
   2316         }
   2317     }
   2318 EXIT:
   2319     OMX_PRINT1(pComponentPrivate->dbg, "---EXITING(0x%x)\n",eError);
   2320     return eError;
   2321 
   2322 }
   2323 
   2324 /* ========================================================================== */
   2325 /**
   2326   * HandleCommandMarkBuffer()
   2327   *
   2328   * Called by component thread, handles the Mark Buffer command from thread.
   2329   *
   2330   * @param
   2331   *
   2332   * @retval OMX_ErrorNone                  success, ready to roll
   2333   *
   2334   **/
   2335 /* ========================================================================== */
   2336 
   2337 OMX_ERRORTYPE VIDDEC_HandleCommandMarkBuffer(VIDDEC_COMPONENT_PRIVATE *pComponentPrivate, OMX_U32 nParam1, OMX_PTR pCmdData)
   2338 {
   2339     OMX_ERRORTYPE eError = OMX_ErrorNone;
   2340     OMX_PRBUFFER1(pComponentPrivate->dbg, "+++ENTERING\n");
   2341     OMX_PRBUFFER1(pComponentPrivate->dbg, "pComponentPrivate 0x%p nParam1 0x%lx pCmdData 0x%p\n",pComponentPrivate, nParam1, pCmdData);
   2342     OMX_PRBUFFER1(pComponentPrivate->dbg, "---EXITING(0x%x)\n",eError);
   2343     return eError;
   2344 
   2345 }
   2346 /* ========================================================================== */
   2347 /**
   2348   * OMX_HandleCommand() state machine in charge of interpretation of every
   2349   * command received from application, depending on which state the component
   2350   * is.
   2351   **/
   2352 /* ========================================================================== */
   2353 
   2354 OMX_ERRORTYPE VIDDEC_HandleCommand (OMX_HANDLETYPE phandle, OMX_U32 nParam1)
   2355 {
   2356     OMX_U32 message[4];
   2357     OMX_U32 iCount = 0;
   2358     VIDDEC_COMPONENT_PRIVATE* pComponentPrivate = (VIDDEC_COMPONENT_PRIVATE*)phandle;
   2359     LCML_DSP_INTERFACE *pLcmlHandle = NULL;
   2360     OMX_PARAM_PORTDEFINITIONTYPE* pPortDefIn = pComponentPrivate->pInPortDef;
   2361     OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = pComponentPrivate->pOutPortDef;
   2362     OMX_ERRORTYPE eError = OMX_ErrorNone;
   2363     unsigned int cmd_rcv = 0;
   2364     OMX_HANDLETYPE hLCML = NULL;
   2365     void* p = NULL;
   2366 
   2367 #ifdef UNDER_CE
   2368    typedef OMX_ERRORTYPE (*LPFNDLLFUNC1)(OMX_HANDLETYPE);
   2369    HINSTANCE hDLL;
   2370    LPFNDLLFUNC1 fpGetHandle1;
   2371 #else
   2372    void* pMyLCML;
   2373    VIDDEC_fpo fpGetHandle;
   2374    char* error;
   2375 #endif
   2376 
   2377     OMX_PRINT1(pComponentPrivate->dbg, "+++ENTERING\n");
   2378     OMX_PRINT1(pComponentPrivate->dbg, "pComponentPrivate 0x%p phandle 0x%lx\n",pComponentPrivate, nParam1);
   2379     pComponentPrivate->frameCounter = 0;
   2380 
   2381     message[0] = 0x400;
   2382     message[1] = 100;
   2383     message[2] = 0;
   2384     p = (void*)&message;
   2385     cmd_rcv = (unsigned int)nParam1;
   2386 
   2387     switch (nParam1) {
   2388         case OMX_StateIdle:
   2389         LOGD("Handle request for state transition: %d => OMX_StateIdle", pComponentPrivate->eState);
   2390         if (pComponentPrivate->eState == OMX_StateIdle) {
   2391             eError = OMX_ErrorSameState;
   2392             OMX_PRSTATE4(pComponentPrivate->dbg, "Same State 0x%x\n", eError);
   2393             pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   2394                                                    pComponentPrivate->pHandle->pApplicationPrivate,
   2395                                                    OMX_EventError,
   2396                                                    OMX_ErrorSameState,
   2397                                                    OMX_TI_ErrorMinor,
   2398                                                    "Same state");
   2399             break;
   2400         }
   2401         else if (( pComponentPrivate->eState == OMX_StateLoaded) || pComponentPrivate->eState == OMX_StateWaitForResources ) {
   2402 #ifdef __PERF_INSTRUMENTATION__
   2403             PERF_Boundary(pComponentPrivate->pPERFcomp,
   2404                           PERF_BoundaryStart | PERF_BoundarySetup);
   2405 #endif
   2406 
   2407             if ((pPortDefIn->bEnabled == OMX_TRUE && pPortDefOut->bEnabled == OMX_TRUE) ||
   2408                 (pPortDefIn->bEnabled == OMX_TRUE && pComponentPrivate->pCompPort[1]->hTunnelComponent != NULL)) {
   2409                 OMX_PRBUFFER1(pComponentPrivate->dbg, "Before pPortDefIn->bEnabled 0x%x pPortDefOut->bEnabled 0x%x\n",pPortDefIn->bEnabled, pPortDefOut->bEnabled);
   2410 #ifdef UNDER_CE
   2411                 while (1) {
   2412                     if (pPortDefIn->bPopulated && pComponentPrivate->pCompPort[1]->hTunnelComponent != NULL) {
   2413                         OMX_PRBUFFER1(pComponentPrivate->dbg, "tunneling pPortDefIn->bEnabled 0x%x pPortDefOut->bEnabled 0x%x\n",
   2414                             pPortDefIn->bEnabled, pPortDefOut->bEnabled);
   2415                         break;
   2416                     }
   2417                     if (pPortDefIn->bPopulated && pPortDefOut->bPopulated) {
   2418                         OMX_PRINT1(pComponentPrivate->dbg, "Standalone pPortDefIn->bEnabled 0x%x pPortDefOut->bEnabled 0x%x\n",
   2419                             pPortDefIn->bEnabled, pPortDefOut->bEnabled);
   2420                         break;
   2421                     }
   2422                     /* Sleep for a while, so the application thread can allocate buffers */
   2423                     VIDDEC_WAIT_CODE();
   2424                 }
   2425 #else
   2426                 if(pComponentPrivate->pCompPort[1]->hTunnelComponent != NULL) {
   2427                     if((!pComponentPrivate->pInPortDef->bPopulated) || pComponentPrivate->sInSemaphore.bSignaled) {
   2428                         VIDDEC_PTHREAD_SEMAPHORE_WAIT(pComponentPrivate->sInSemaphore);
   2429                         OMX_PRBUFFER1(pComponentPrivate->dbg, "tunneling pPortDefIn->bEnabled 0x%x pPortDefOut->bEnabled 0x%x\n",
   2430                             pPortDefIn->bEnabled, pPortDefOut->bEnabled);
   2431                     }
   2432                 }
   2433                 else {
   2434                     if((!pComponentPrivate->pOutPortDef->bPopulated) || pComponentPrivate->sOutSemaphore.bSignaled) {
   2435                         VIDDEC_PTHREAD_SEMAPHORE_WAIT(pComponentPrivate->sInSemaphore);
   2436                         VIDDEC_PTHREAD_SEMAPHORE_WAIT(pComponentPrivate->sOutSemaphore);
   2437                         OMX_PRBUFFER1(pComponentPrivate->dbg, "Standalone pPortDefIn->bEnabled 0x%x pPortDefOut->bEnabled 0x%x\n",
   2438                             pPortDefIn->bEnabled, pPortDefOut->bEnabled);
   2439                     }
   2440                 }
   2441 #endif
   2442                 OMX_PRBUFFER1(pComponentPrivate->dbg, "After pPortDefIn->bEnabled 0x%x pPortDefOut->bEnabled 0x%x\n",pPortDefIn->bEnabled, pPortDefOut->bEnabled);
   2443             }
   2444 #ifndef UNDER_CE
   2445             else {
   2446                 if(pComponentPrivate->pCompPort[1]->hTunnelComponent != NULL) {
   2447                     if(pComponentPrivate->sInSemaphore.bSignaled){
   2448                         VIDDEC_PTHREAD_SEMAPHORE_WAIT(pComponentPrivate->sInSemaphore);
   2449                     }
   2450                 }
   2451                 else {
   2452                     if(pComponentPrivate->sInSemaphore.bSignaled){
   2453                         VIDDEC_PTHREAD_SEMAPHORE_WAIT(pComponentPrivate->sInSemaphore);
   2454                     }
   2455                     if(pComponentPrivate->sOutSemaphore.bSignaled){
   2456                         VIDDEC_PTHREAD_SEMAPHORE_WAIT(pComponentPrivate->sOutSemaphore);
   2457                     }
   2458                 }
   2459             }
   2460 #endif
   2461 
   2462 #if 1
   2463 #ifndef UNDER_CE
   2464                 pMyLCML = dlopen("libLCML.so", RTLD_LAZY);
   2465                 if (!pMyLCML) {
   2466                     OMX_PRDSP4(pComponentPrivate->dbg, "OMX_ErrorBadParameter\n");
   2467                     fputs(dlerror(), stderr);
   2468                     eError = OMX_ErrorBadParameter;
   2469                     goto EXIT;
   2470                 }
   2471                 fpGetHandle = dlsym(pMyLCML, "GetHandle");
   2472                 if ((error = dlerror()) != NULL) {
   2473                     OMX_PRDSP4(pComponentPrivate->dbg, "OMX_ErrorBadParameter\n");
   2474                     fputs(error, stderr);
   2475                     dlclose(pMyLCML);
   2476                     pMyLCML = NULL;
   2477                     eError = OMX_ErrorBadParameter;
   2478                     goto EXIT;
   2479                 }
   2480                 eError = (*fpGetHandle)(&hLCML);
   2481                 if (eError != OMX_ErrorNone) {
   2482                     OMX_PRDSP4(pComponentPrivate->dbg, "OMX_ErrorBadParameter\n");
   2483                     dlclose(pMyLCML);
   2484                     pMyLCML = NULL;
   2485                     eError = OMX_ErrorBadParameter;
   2486                     goto EXIT;
   2487                 }
   2488                 pComponentPrivate->pModLCML = pMyLCML;
   2489 #else
   2490                 hDLL = LoadLibraryEx(TEXT("OAF_BML.dll"), NULL, 0);
   2491                 if (hDLL == NULL) {
   2492                     OMX_PRDSP4(pComponentPrivate->dbg, "BML Load Failed!!!\n");
   2493                     eError = OMX_ErrorBadParameter;
   2494                     goto EXIT;
   2495                 }
   2496                 fpGetHandle1 = (LPFNDLLFUNC1)GetProcAddress(hDLL,TEXT("GetHandle"));
   2497                 if (!fpGetHandle1) {
   2498                     /* handle the error */
   2499                     OMX_PRDSP4(pComponentPrivate->dbg, "OMX_ErrorBadParameter\n");
   2500                     FreeLibrary(hDLL);
   2501                     hDLL = NULL;
   2502                     eError = OMX_ErrorBadParameter;
   2503                     goto EXIT;
   2504                 }
   2505                 /* call the function */
   2506                 eError = fpGetHandle1(&hLCML);
   2507                 if (eError != OMX_ErrorNone) {
   2508                     OMX_PRDSP4(pComponentPrivate->dbg, "OMX_ErrorBadParameter\n");
   2509                     FreeLibrary(hDLL);
   2510                     hDLL = NULL;
   2511                     eError = OMX_ErrorBadParameter;
   2512                     goto EXIT;
   2513                 }
   2514                 pComponentPrivate->pModLCML = hDLL;
   2515 #endif
   2516 
   2517                 pComponentPrivate->eLCMLState = VidDec_LCML_State_Load;
   2518                 OMX_PRDSP2(pComponentPrivate->dbg, "LCML Handler 0x%p\n",hLCML);
   2519                 /*(LCML_DSP_INTERFACE*)pComponentPrivate->pLCML = (LCML_DSP_INTERFACE*)hLCML;*/
   2520                 pComponentPrivate->pLCML = (LCML_DSP_INTERFACE*)hLCML;
   2521                 pComponentPrivate->pLCML->pComponentPrivate = pComponentPrivate;
   2522 #endif
   2523 
   2524 #ifdef __PERF_INSTRUMENTATION__
   2525                 pComponentPrivate->lcml_nCntOpReceived = 0;
   2526 #endif
   2527                 eError = OMX_ErrorNone;
   2528 #ifndef UNDER_CE
   2529                 pComponentPrivate->bLCMLOut = OMX_TRUE;
   2530 #endif
   2531                 if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
   2532                     eError = VIDDEC_InitDSP_H264Dec(pComponentPrivate);
   2533                 }
   2534                 else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 ||
   2535                          pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) {
   2536                     eError = VIDDEC_InitDSP_Mpeg4Dec(pComponentPrivate);
   2537                 }
   2538                 else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG2) {
   2539                     eError = VIDDEC_InitDSP_Mpeg2Dec(pComponentPrivate);
   2540                 }
   2541                 else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV) {
   2542                     eError = VIDDEC_InitDSP_WMVDec(pComponentPrivate);
   2543                 }
   2544 #ifdef VIDDEC_SPARK_CODE
   2545                 else if (VIDDEC_SPARKCHECK) {
   2546                     eError = VIDDEC_InitDSP_SparkDec(pComponentPrivate);
   2547                 }
   2548 #endif
   2549                 else {
   2550                     OMX_ERROR4(pComponentPrivate->dbg, "OMX_ErrorUnsupportedSetting\n");
   2551                     eError = OMX_ErrorUnsupportedSetting;
   2552                     pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   2553                                                            pComponentPrivate->pHandle->pApplicationPrivate,
   2554                                                            OMX_EventError,
   2555                                                            OMX_ErrorUnsupportedSetting,
   2556                                                            OMX_TI_ErrorMinor,
   2557                                                            "DSP Initialization");
   2558                     goto EXIT;
   2559                 }
   2560                 /************************************************************************/
   2561                 /************************************************************************/
   2562                 /************************************************************************/
   2563                 if(eError != OMX_ErrorNone){
   2564                     if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   2565                         pComponentPrivate->pModLCML != NULL){
   2566 #ifndef UNDER_CE
   2567                         if(pComponentPrivate->pModLCML != NULL){
   2568                             dlclose(pComponentPrivate->pModLCML);
   2569                             pComponentPrivate->pModLCML = NULL;
   2570                             pComponentPrivate->pLCML = NULL;
   2571                             pComponentPrivate->eLCMLState = VidDec_LCML_State_Unload;
   2572                         }
   2573 #else
   2574                         if(pComponentPrivate->pModLCML != NULL){
   2575                             FreeLibrary(pComponentPrivate->pModLCML);
   2576                             pComponentPrivate->pModLCML = NULL;
   2577                             pComponentPrivate->pLCML = NULL;
   2578                             pComponentPrivate->eLCMLState = VidDec_LCML_State_Unload;
   2579                         }
   2580 #endif
   2581 
   2582                         pComponentPrivate->bLCMLHalted = OMX_TRUE;
   2583                     }
   2584                     OMX_PRDSP4(pComponentPrivate->dbg, "LCML Error %x\n", pComponentPrivate->eState);
   2585                     pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   2586                                                            pComponentPrivate->pHandle->pApplicationPrivate,
   2587                                                            OMX_EventError,
   2588                                                            eError,
   2589                                                            OMX_TI_ErrorSevere,
   2590                                                            "DSP Initialization");
   2591                      goto EXIT;
   2592                 }
   2593 
   2594 #ifndef UNDER_CE
   2595                 pComponentPrivate->bLCMLOut = OMX_FALSE;
   2596 #endif
   2597                 pComponentPrivate->bLCMLHalted = OMX_FALSE;
   2598                 pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
   2599                 if (!pLcmlHandle) {
   2600                     OMX_PRDSP4(pComponentPrivate->dbg, "OMX_ErrorBadParameter\n");
   2601                     eError = OMX_ErrorHardware;
   2602                     pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   2603                                                            pComponentPrivate->pHandle->pApplicationPrivate,
   2604                                                            OMX_EventError,
   2605                                                            OMX_ErrorHardware,
   2606                                                            OMX_TI_ErrorSevere,
   2607                                                            "Lcml Handle NULL");
   2608                     goto EXIT;
   2609                 }
   2610                 pComponentPrivate->eLCMLState = VidDec_LCML_State_Init;
   2611                 OMX_PRINT1(pComponentPrivate->dbg, "OUTPUT width=%lu height=%lu\n", pComponentPrivate->pOutPortDef->format.video.nFrameWidth, pComponentPrivate->pOutPortDef->format.video.nFrameHeight);
   2612                 OMX_PRINT1(pComponentPrivate->dbg, "INPUT width=%lu height=%lu\n", pComponentPrivate->pInPortDef->format.video.nFrameWidth, pComponentPrivate->pInPortDef->format.video.nFrameHeight);
   2613 
   2614 
   2615 #if 1
   2616 #ifdef RESOURCE_MANAGER_ENABLED
   2617                 pComponentPrivate->rmproxyCallback.RMPROXY_Callback = (void *) VIDDEC_ResourceManagerCallback;
   2618                 if(pComponentPrivate->eRMProxyState != VidDec_RMPROXY_State_Unload){
   2619                     OMX_PRMGR2(pComponentPrivate->dbg, "memory usage 1 %u : %u bytes\n",(unsigned int)pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0],(unsigned int)VIDDEC_MEMUSAGE);
   2620                     if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
   2621                         eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_RequestResource, OMX_H264_Decode_COMPONENT, VIDDEC_GetRMFrecuency(pComponentPrivate), VIDDEC_MEMUSAGE, &(pComponentPrivate->rmproxyCallback));
   2622                     }
   2623                     else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4) {
   2624                         eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_RequestResource, OMX_MPEG4_Decode_COMPONENT, VIDDEC_GetRMFrecuency(pComponentPrivate), VIDDEC_MEMUSAGE, &(pComponentPrivate->rmproxyCallback));
   2625                     }
   2626                     else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) {
   2627                         eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_RequestResource, OMX_H263_Decode_COMPONENT, VIDDEC_GetRMFrecuency(pComponentPrivate), VIDDEC_MEMUSAGE, &(pComponentPrivate->rmproxyCallback));
   2628                     }
   2629                     else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG2) {
   2630                         eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_RequestResource, OMX_MPEG2_Decode_COMPONENT, VIDDEC_GetRMFrecuency(pComponentPrivate), VIDDEC_MEMUSAGE, &(pComponentPrivate->rmproxyCallback));
   2631                     }
   2632                     else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV) {
   2633                         eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_RequestResource, OMX_WMV_Decode_COMPONENT, VIDDEC_GetRMFrecuency(pComponentPrivate), VIDDEC_MEMUSAGE, &(pComponentPrivate->rmproxyCallback));
   2634                     }
   2635 #ifdef VIDDEC_SPARK_CODE
   2636                     else if (VIDDEC_SPARKCHECK) {
   2637                         eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_RequestResource, OMX_MPEG4_Decode_COMPONENT, VIDDEC_GetRMFrecuency(pComponentPrivate), VIDDEC_MEMUSAGE, &(pComponentPrivate->rmproxyCallback));
   2638                     }
   2639 #endif
   2640                     else {
   2641                         eError = OMX_ErrorUnsupportedSetting;
   2642                         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   2643                                                                pComponentPrivate->pHandle->pApplicationPrivate,
   2644                                                                OMX_EventError,
   2645                                                                OMX_ErrorUnsupportedSetting,
   2646                                                                OMX_TI_ErrorMajor,
   2647                                                                "RM SendCommand OMX_ErrorUnsupportedSetting Error");
   2648                         OMX_PRMGR4(pComponentPrivate->dbg, "OMX_ErrorUnsupportedSetting 0x%x\n",eError);
   2649                         goto EXIT;
   2650                     }
   2651                     if (eError != OMX_ErrorNone) {
   2652                         pComponentPrivate->eState = OMX_StateLoaded;
   2653                         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   2654                                                                pComponentPrivate->pHandle->pApplicationPrivate,
   2655                                                                OMX_EventError,
   2656                                                                OMX_ErrorInsufficientResources,
   2657                                                                OMX_TI_ErrorMajor,
   2658                                                                "RM SendCommand Error");
   2659                         OMX_PRMGR4(pComponentPrivate->dbg, "OMX_ErrorUnsupportedSetting 0x%x\n",eError);
   2660                         break;
   2661                     }
   2662                     pComponentPrivate->eRMProxyState = VidDec_RMPROXY_State_Registered;
   2663                 }
   2664 #endif
   2665 #endif
   2666                 /* Send command to USN to do the propagation of the EOS flag */
   2667                 if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   2668                     pComponentPrivate->eLCMLState != VidDec_LCML_State_Destroy &&
   2669                     pComponentPrivate->pLCML != NULL &&
   2670                     pComponentPrivate->bLCMLHalted != OMX_TRUE){
   2671                     OMX_PRDSP2(pComponentPrivate->dbg, "LCML_ControlCodec called EMMCodecControlUsnEos 0x%p\n",pLcmlHandle);
   2672                     eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,EMMCodecControlUsnEos, NULL);
   2673                     if (eError != OMX_ErrorNone) {
   2674                         OMX_PRDSP4(pComponentPrivate->dbg, "error in EMMCodecControlUsnEos %x\n",eError);
   2675                         eError = OMX_ErrorHardware;
   2676                         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   2677                                                                pComponentPrivate->pHandle->pApplicationPrivate,
   2678                                                                OMX_EventError,
   2679                                                                OMX_ErrorHardware,
   2680                                                                OMX_TI_ErrorSevere,
   2681                                                                "LCML_ControlCodec EMMCodecControlUsnEos function");
   2682                         OMX_ERROR4(pComponentPrivate->dbg, "OMX_ErrorHardware 0x%x\n",eError);
   2683                         goto EXIT;
   2684                     }
   2685                 }
   2686                if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat != OMX_VIDEO_CodingWMV) {
   2687                 if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   2688                     pComponentPrivate->eLCMLState != VidDec_LCML_State_Destroy &&
   2689                     pComponentPrivate->pLCML != NULL &&
   2690                     pComponentPrivate->bLCMLHalted != OMX_TRUE){
   2691                     if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
   2692                         message[1] = 4;
   2693                     }
   2694                     else {
   2695                         message[1] = 100;
   2696                     }
   2697                     message[0] = 0x400;
   2698                     message[2] = 0;
   2699                     p = (void*)&message;
   2700                     VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->sMutex);
   2701                     OMX_PRDSP2(pComponentPrivate->dbg, "LCML_ControlCodec called EMMCodecControlSendDspMessage 0x%p\n",pLcmlHandle);
   2702                     eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,EMMCodecControlSendDspMessage, (void *)p);
   2703                     if (eError != OMX_ErrorNone) {
   2704                         OMX_PRDSP4(pComponentPrivate->dbg, "error in EMMCodecControlSendDspMessage %x\n",eError);
   2705                         eError = OMX_ErrorHardware;
   2706                         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   2707                                                                pComponentPrivate->pHandle->pApplicationPrivate,
   2708                                                                OMX_EventError,
   2709                                                                OMX_ErrorHardware,
   2710                                                                OMX_TI_ErrorSevere,
   2711                                                                "LCML_ControlCodec function");
   2712                         OMX_ERROR4(pComponentPrivate->dbg, "OMX_ErrorHardware 0x%x\n",eError);
   2713                         VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   2714                         goto EXIT;
   2715                     }
   2716                     VIDDEC_PTHREAD_MUTEX_WAIT(pComponentPrivate->sMutex);
   2717                     VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   2718                 }
   2719                }
   2720 
   2721                 pComponentPrivate->eState = OMX_StateIdle;
   2722                 pComponentPrivate->bIsPaused = 0;
   2723 
   2724                 /* Decrement reference count with signal enabled */
   2725                 if(RemoveStateTransition(pComponentPrivate, OMX_TRUE) != OMX_ErrorNone) {
   2726                       return OMX_ErrorUndefined;
   2727                 }
   2728 
   2729                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   2730                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   2731                                                        OMX_EventCmdComplete,
   2732                                                        OMX_CommandStateSet,
   2733                                                        pComponentPrivate->eState,
   2734                                                        NULL);
   2735                LOGD("OMX_StateIdle state reached");
   2736                break;
   2737             }
   2738             else if (pComponentPrivate->eState == OMX_StateExecuting || pComponentPrivate->eState == OMX_StatePause) {
   2739                 /*Set the bIsStopping bit*/
   2740                 if (pComponentPrivate->bDynamicConfigurationInProgress == OMX_TRUE) {
   2741 	            pComponentPrivate->bDynamicConfigurationInProgress = OMX_FALSE;
   2742                     OMX_PRSTATE1(pComponentPrivate->dbg, "We were doing DynamicConfiguration, canceling it. %d \n",pComponentPrivate->bDynamicConfigurationInProgress);
   2743                 }
   2744                 pComponentPrivate->bIsStopping = 1;
   2745                 OMX_PRSTATE1(pComponentPrivate->dbg, "bIsStopping 0x%lx\n",pComponentPrivate->bIsStopping);
   2746                 OMX_PRSTATE1(pComponentPrivate->dbg, "eExecuteToIdle 0x%x\n",pComponentPrivate->eExecuteToIdle);
   2747                 OMX_VidDec_Return(pComponentPrivate);
   2748 
   2749 #ifdef __PERF_INSTRUMENTATION__
   2750                 PERF_Boundary(pComponentPrivate->pPERFcomp,
   2751                               PERF_BoundaryComplete | PERF_BoundarySteadyState);
   2752 #endif
   2753                     pComponentPrivate->bIsPaused = 0;
   2754                     pComponentPrivate->iEndofInputSent = 0;
   2755 /********************************************************************************************************************/
   2756            if (pComponentPrivate->bIsStopping == OMX_TRUE) {
   2757                 pComponentPrivate->bIsPaused = OMX_FALSE;
   2758                 if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   2759                     pComponentPrivate->eLCMLState != VidDec_LCML_State_Destroy &&
   2760                     pComponentPrivate->pLCML != NULL &&
   2761                     pComponentPrivate->bLCMLHalted != OMX_TRUE){
   2762                     VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->sMutex);
   2763                     pLcmlHandle = (LCML_DSP_INTERFACE *)pComponentPrivate->pLCML;
   2764                     eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, MMCodecControlStop, NULL);
   2765                     if (eError != OMX_ErrorNone) {
   2766                         eError = OMX_ErrorHardware;
   2767                         OMX_PRDSP4(pComponentPrivate->dbg, "Error Occurred in Codec Stop...\n");
   2768                         VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   2769                         break;
   2770                     }
   2771                     pComponentPrivate->eLCMLState = VidDec_LCML_State_Stop;
   2772                     VIDDEC_PTHREAD_MUTEX_WAIT(pComponentPrivate->sMutex);
   2773                     VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   2774                 }
   2775                 VIDDEC_HandleCommandFlush(pComponentPrivate, -1, OMX_FALSE);
   2776 
   2777 #if 1
   2778 #ifdef RESOURCE_MANAGER_ENABLED
   2779             if(pComponentPrivate->eRMProxyState != VidDec_RMPROXY_State_Unload){
   2780                 OMX_PRMGR2(pComponentPrivate->dbg, "memory usage 2 %d : %d bytes\n",(unsigned int)pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0],(unsigned int)VIDDEC_MEMUSAGE);
   2781                 if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
   2782                     eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_StateSet, OMX_H264_Decode_COMPONENT, OMX_StateIdle, VIDDEC_MEMUSAGE, NULL);
   2783                 }
   2784                 else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4) {
   2785                     eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_StateSet, OMX_MPEG4_Decode_COMPONENT, OMX_StateIdle, VIDDEC_MEMUSAGE, NULL);
   2786                 }
   2787                 else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) {
   2788                     eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_StateSet, OMX_H263_Decode_COMPONENT, OMX_StateIdle, VIDDEC_MEMUSAGE, NULL);
   2789                 }
   2790                 else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG2) {
   2791                     eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_StateSet, OMX_MPEG2_Decode_COMPONENT, OMX_StateIdle, VIDDEC_MEMUSAGE, NULL);
   2792                 }
   2793                 else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV) {
   2794                     eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_StateSet, OMX_WMV_Decode_COMPONENT, OMX_StateIdle, VIDDEC_MEMUSAGE, NULL);
   2795                 }
   2796 #ifdef VIDDEC_SPARK_CODE
   2797                 else if (VIDDEC_SPARKCHECK) {
   2798                     eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_StateSet, OMX_MPEG4_Decode_COMPONENT, OMX_StateIdle, VIDDEC_MEMUSAGE, NULL);
   2799                 }
   2800 #endif
   2801             }
   2802 #endif
   2803 #endif
   2804                 OMX_MEMFREE_STRUCT_DSPALIGN(pComponentPrivate->pUalgParams,OMX_PTR);
   2805 
   2806                 pComponentPrivate->bIsStopping = OMX_FALSE;
   2807                 pComponentPrivate->eState = OMX_StateIdle;
   2808                 /* Decrement reference count with signal enabled */
   2809                 if(RemoveStateTransition(pComponentPrivate, OMX_TRUE) != OMX_ErrorNone) {
   2810                       return OMX_ErrorUndefined;
   2811                 }
   2812                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   2813                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   2814                                                        OMX_EventCmdComplete,
   2815                                                        OMX_CommandStateSet,
   2816                                                        pComponentPrivate->eState,
   2817                                                        NULL);
   2818                 LOGD("OMX_StateIdle state reached");
   2819                 eError = OMX_ErrorNone;
   2820                 pComponentPrivate->bTransPause = 0;
   2821                 pComponentPrivate->bIsPaused = 0;
   2822                 pComponentPrivate->eExecuteToIdle = OMX_StateInvalid;
   2823             }
   2824 /********************************************************************************************************************/
   2825 
   2826             }
   2827             else {
   2828                 eError = OMX_ErrorIncorrectStateTransition;
   2829                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   2830                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   2831                                                        OMX_EventError,
   2832                                                        OMX_ErrorIncorrectStateTransition,
   2833                                                        OMX_TI_ErrorMinor,
   2834                                                        NULL);
   2835                 OMX_ERROR4(pComponentPrivate->dbg, "OMX_ErrorHardware 0x%x\n",eError);
   2836             }
   2837             pComponentPrivate->eExecuteToIdle = OMX_StateInvalid;
   2838             OMX_PRSTATE1(pComponentPrivate->dbg, "Passing bIsStopping 0x%lx\n",pComponentPrivate->bIsStopping);
   2839             OMX_PRSTATE1(pComponentPrivate->dbg, "Passing eExecuteToIdle 0x%x\n",pComponentPrivate->eExecuteToIdle);
   2840             break;
   2841 
   2842         case OMX_StateExecuting:
   2843 #ifdef __PERF_INSTRUMENTATION__
   2844                 pComponentPrivate->lcml_nCntOpReceived = 0;
   2845 #endif
   2846             OMX_PRSTATE2(pComponentPrivate->dbg, "Transitioning to OMX_StateExecuting C 0x%x N 0x%lx\n",pComponentPrivate->eState, nParam1);
   2847             if (pComponentPrivate->eState == OMX_StateExecuting) {
   2848                 eError = OMX_ErrorSameState;
   2849                 pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
   2850                                                         pComponentPrivate->pHandle->pApplicationPrivate,
   2851                                                         OMX_EventError,
   2852                                                         OMX_ErrorSameState,
   2853                                                         OMX_TI_ErrorMinor,
   2854                                                         "Invalid State");
   2855                  OMX_PRSTATE4(pComponentPrivate->dbg, "OMX_ErrorSameState 0x%x\n",eError);
   2856             }
   2857             else if (pComponentPrivate->eState == OMX_StateIdle || pComponentPrivate->eState == OMX_StatePause) {
   2858                 pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
   2859                 pComponentPrivate->bIsPaused = 0;
   2860                 pComponentPrivate->bFirstBuffer = 1;
   2861                 if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   2862                     pComponentPrivate->eLCMLState != VidDec_LCML_State_Destroy &&
   2863                     pComponentPrivate->pLCML != NULL &&
   2864                     pComponentPrivate->bLCMLHalted != OMX_TRUE){
   2865                     OMX_PRDSP2(pComponentPrivate->dbg, "LCML_ControlCodec called EMMCodecControlStart 0x%p\n",pLcmlHandle);
   2866                     eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,EMMCodecControlStart,NULL);
   2867                     if (eError != OMX_ErrorNone) {
   2868                         eError = OMX_ErrorHardware;
   2869                         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   2870                                                                pComponentPrivate->pHandle->pApplicationPrivate,
   2871                                                                OMX_EventError,
   2872                                                                OMX_ErrorHardware,
   2873                                                                OMX_TI_ErrorSevere,
   2874                                                                "LCML_ControlCodec Start");
   2875                         break;
   2876                         OMX_PRDSP4(pComponentPrivate->dbg, "Occurred in Codec Start... 0x%x\n",eError);
   2877                     }
   2878                 }
   2879                 pComponentPrivate->eLCMLState = VidDec_LCML_State_Start;
   2880                 if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC &&
   2881                     pComponentPrivate->eState == OMX_StateIdle) {
   2882                     H264_Iualg_Cmd_SetStatus* pDynParams = NULL;
   2883                     char* pTmp = NULL;
   2884                     OMX_U32 cmdValues[3] = {0, 0, 0};
   2885 
   2886                     VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_IDLEEXECUTING);
   2887                     OMX_PRDSP2(pComponentPrivate->dbg, "Initializing DSP for h264 eCompressionFormat 0x%x\n",
   2888                     pComponentPrivate->pInPortDef->format.video.eCompressionFormat);
   2889                     OMX_MALLOC_STRUCT_SIZED(pDynParams, H264_Iualg_Cmd_SetStatus, sizeof(H264_Iualg_Cmd_SetStatus) + VIDDEC_PADDING_FULL,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel4]);
   2890                     if (pDynParams == NULL) {
   2891                        OMX_TRACE4(pComponentPrivate->dbg, "Error: Malloc failed\n");
   2892                        eError = OMX_ErrorInsufficientResources;
   2893                        goto EXIT;
   2894                    }
   2895                     memset(pDynParams, 0, sizeof(H264_Iualg_Cmd_SetStatus) + VIDDEC_PADDING_FULL);
   2896                     pTmp = (char*)pDynParams;
   2897                     pTmp += VIDDEC_PADDING_HALF;
   2898                     pDynParams = (H264_Iualg_Cmd_SetStatus*)pTmp;
   2899 #ifdef VIDDEC_SN_R8_14
   2900                     pDynParams->size = sizeof(H264_Iualg_Cmd_SetStatus);
   2901 #endif
   2902                     pDynParams->ulDecodeHeader = 1;
   2903                     pDynParams->ulDisplayWidth = 0;
   2904                     pDynParams->ulFrameSkipMode = 0;
   2905                     pDynParams->ulPPType = 0;
   2906 
   2907                     cmdValues[0] = IUALG_CMD_SETSTATUS;
   2908                     cmdValues[1] = (OMX_U32)(pDynParams);
   2909                     cmdValues[2] = sizeof(H264_Iualg_Cmd_SetStatus);
   2910 
   2911                     p = (void*)&cmdValues;
   2912                     if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   2913                         pComponentPrivate->eLCMLState != VidDec_LCML_State_Destroy &&
   2914                         pComponentPrivate->pLCML != NULL &&
   2915                         pComponentPrivate->bLCMLHalted != OMX_TRUE){
   2916                         VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->sMutex);
   2917                         eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
   2918                                                    EMMCodecControlAlgCtrl,
   2919                                                    (void*)p);
   2920                         if (eError != OMX_ErrorNone) {
   2921                             eError = OMX_ErrorHardware;
   2922                             VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   2923                             OMX_MEMFREE_STRUCT_DSPALIGN(pDynParams,H264_Iualg_Cmd_SetStatus);
   2924                             break;
   2925                         }
   2926                         VIDDEC_PTHREAD_MUTEX_WAIT(pComponentPrivate->sMutex);
   2927                         VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   2928                     }
   2929 
   2930                     OMX_MEMFREE_STRUCT_DSPALIGN(pDynParams,H264_Iualg_Cmd_SetStatus);
   2931 
   2932                     if (eError != OMX_ErrorNone) {
   2933                         OMX_PRDSP4(pComponentPrivate->dbg, "Codec AlgCtrl 0x%x\n",eError);
   2934                         goto EXIT;
   2935                     }
   2936                 }
   2937                 else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG2 &&
   2938                     pComponentPrivate->eState == OMX_StateIdle) {
   2939                     MP2VDEC_UALGDynamicParams* pDynParams = NULL;
   2940                     char* pTmp = NULL;
   2941                     OMX_U32 cmdValues[3] = {0, 0, 0};
   2942 
   2943                     VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_IDLEEXECUTING);
   2944                     OMX_PRDSP2(pComponentPrivate->dbg, "Initializing DSP for wmv9 eCompressionFormat 0x%x\n",
   2945                         pComponentPrivate->pInPortDef->format.video.eCompressionFormat);
   2946                     OMX_MALLOC_STRUCT_SIZED(pDynParams, MP2VDEC_UALGDynamicParams, sizeof(MP2VDEC_UALGDynamicParams) + VIDDEC_PADDING_FULL,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel4]);
   2947                     memset(pDynParams, 0, sizeof(MP2VDEC_UALGDynamicParams) + VIDDEC_PADDING_FULL);
   2948                     pTmp = (char*)pDynParams;
   2949                     pTmp += VIDDEC_PADDING_HALF;
   2950                     pDynParams = (MP2VDEC_UALGDynamicParams*)pTmp;
   2951 
   2952 #ifdef VIDDEC_SN_R8_14
   2953                     pDynParams->size = sizeof(MP2VDEC_UALGDynamicParams);
   2954 #endif
   2955                     if (pComponentPrivate->nDisplayWidth > 0) {
   2956                         if (pComponentPrivate->pInPortDef->format.video.nFrameWidth > pComponentPrivate->nDisplayWidth) {
   2957                             pComponentPrivate->nDisplayWidth = pComponentPrivate->pInPortDef->format.video.nFrameWidth;
   2958                         }
   2959                         pDynParams->ulDisplayWidth = (((pComponentPrivate->nDisplayWidth + 15) >> 4) << 4);
   2960                         if (pComponentPrivate->nDisplayWidth != pDynParams->ulDisplayWidth ) {
   2961                             pComponentPrivate->nDisplayWidth = pDynParams->ulDisplayWidth;
   2962                             OMX_PRINT2(pComponentPrivate->dbg, "warning Display Width adjusted to %lu\n",pDynParams->ulDisplayWidth);
   2963                         }
   2964                     }
   2965                     else if (pComponentPrivate->pCompPort[1]->hTunnelComponent != NULL){
   2966                         if (pComponentPrivate->pInPortDef->format.video.nFrameWidth > pComponentPrivate->nDisplayWidth) {
   2967                             pComponentPrivate->nDisplayWidth = pComponentPrivate->pInPortDef->format.video.nFrameWidth;
   2968                         }
   2969                         pDynParams->ulDisplayWidth = (((pComponentPrivate->nDisplayWidth + 15) >> 4) << 4);
   2970                         if (pComponentPrivate->nDisplayWidth != pDynParams->ulDisplayWidth ) {
   2971                             pComponentPrivate->nDisplayWidth = pDynParams->ulDisplayWidth;
   2972                             OMX_PRINT2(pComponentPrivate->dbg, "warning Display Width adjusted to %lu\n",pDynParams->ulDisplayWidth);
   2973                         }
   2974                     }
   2975                     else {
   2976                         pDynParams->ulDisplayWidth = 0;
   2977                     }
   2978                     pDynParams->ulDecodeHeader = 0;
   2979                     pDynParams->ulFrameSkipMode = 0;
   2980                     pDynParams->ulPPType = 0;
   2981                     pDynParams->ulPpNone = 0;
   2982                     if (pComponentPrivate->pOutPortDef->format.video.eColorFormat == VIDDEC_COLORFORMAT422) {
   2983                         pDynParams->ulDyna_chroma_format = MP2VIDDEC_YUVFORMAT_INTERLEAVED422;
   2984                     }
   2985                     else {
   2986                         pDynParams->ulDyna_chroma_format = MP2VIDDEC_YUVFORMAT_PLANAR420;
   2987                     }
   2988 
   2989                     cmdValues[0] = IUALG_CMD_SETSTATUS;
   2990                     cmdValues[1] = (OMX_U32)(pDynParams);
   2991                     cmdValues[2] = sizeof(MP2VDEC_UALGDynamicParams);
   2992 
   2993                     pComponentPrivate->bTransPause = 0;
   2994                     p = (void*)&cmdValues;
   2995                     if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   2996                         pComponentPrivate->eLCMLState != VidDec_LCML_State_Destroy &&
   2997                         pComponentPrivate->pLCML != NULL &&
   2998                         pComponentPrivate->bLCMLHalted != OMX_TRUE){
   2999                         eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
   3000                                                    EMMCodecControlAlgCtrl,
   3001                                                    (void*)p);
   3002                          if(eError != OMX_ErrorNone){
   3003                             eError = OMX_ErrorHardware;
   3004                             pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3005                                                                    pComponentPrivate->pHandle->pApplicationPrivate,
   3006                                                                    OMX_EventError,
   3007                                                                    eError,
   3008                                                                    0x0,
   3009                                                                    "LCML_ControlCodec function");
   3010                             OMX_MEMFREE_STRUCT_DSPALIGN(pDynParams,MP2VDEC_UALGDynamicParams);
   3011                             goto EXIT;
   3012                         }
   3013                         while(1) {
   3014                             if(pComponentPrivate->bTransPause != 0) {
   3015                                  pComponentPrivate->bTransPause = 0;
   3016                                  break;
   3017                             }
   3018                             VIDDEC_WAIT_CODE();
   3019                         }
   3020                     }
   3021 
   3022                     OMX_MEMFREE_STRUCT_DSPALIGN(pDynParams,MP2VDEC_UALGDynamicParams);
   3023 
   3024                     if (eError != OMX_ErrorNone) {
   3025                         OMX_PRDSP4(pComponentPrivate->dbg, "Codec AlgCtrl 0x%x\n",eError);
   3026                         goto EXIT;
   3027                     }
   3028                 }
   3029 #ifdef VIDDEC_SPARK_CODE
   3030                 else if (VIDDEC_SPARKCHECK) {
   3031                     if(pComponentPrivate->eState == OMX_StateIdle) {
   3032                         SPARKVDEC_UALGDynamicParams* pDynParams = NULL;
   3033                         char* pTmp = NULL;
   3034                         OMX_U32 cmdValues[3] = {0, 0, 0};
   3035 
   3036                         VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_IDLEEXECUTING);
   3037                         OMX_PRDSP2(pComponentPrivate->dbg, "Initializing DSP for mpeg4 and h263 eCompressionFormat 0x%x\n",
   3038                         pComponentPrivate->pInPortDef->format.video.eCompressionFormat);
   3039                         OMX_MALLOC_STRUCT_SIZED(pDynParams, SPARKVDEC_UALGDynamicParams, sizeof(SPARKVDEC_UALGDynamicParams) + VIDDEC_PADDING_FULL,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel4]);
   3040                         if (pDynParams == NULL) {
   3041                            OMX_TRACE4(pComponentPrivate->dbg, "Error: Malloc failed\n");
   3042                            eError = OMX_ErrorInsufficientResources;
   3043                            goto EXIT;
   3044                         }
   3045                         memset(pDynParams, 0, sizeof(SPARKVDEC_UALGDynamicParams) + VIDDEC_PADDING_FULL);
   3046                         pTmp = (char*)pDynParams;
   3047                         pTmp += VIDDEC_PADDING_HALF;
   3048                         pDynParams = (SPARKVDEC_UALGDynamicParams*)pTmp;
   3049     #ifdef VIDDEC_SN_R8_14
   3050                         pDynParams->size = sizeof(SPARKVDEC_UALGDynamicParams);
   3051     #endif
   3052                         pDynParams->ulDecodeHeader = 0;
   3053                         pDynParams->ulDisplayWidth = 0;
   3054                         pDynParams->ulFrameSkipMode = 0;
   3055                         pDynParams->ulPPType = 0;
   3056 
   3057                         cmdValues[0] = IUALG_CMD_SETSTATUS;
   3058                         cmdValues[1] = (OMX_U32)(pDynParams);
   3059                         cmdValues[2] = sizeof(SPARKVDEC_UALGDynamicParams);
   3060 
   3061                         /*pComponentPrivate->bTransPause = 0;*//*flag to wait for the generated event*/
   3062                         VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->sMutex);
   3063                         p = (void*)&cmdValues;
   3064                         if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   3065                             pComponentPrivate->eLCMLState != VidDec_LCML_State_Destroy &&
   3066                             pComponentPrivate->pLCML != NULL &&
   3067                             pComponentPrivate->bLCMLHalted != OMX_TRUE){
   3068                             eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
   3069                                                        EMMCodecControlAlgCtrl,
   3070                                                        (void*)p);
   3071                             if (eError != OMX_ErrorNone) {
   3072                                 eError = OMX_ErrorHardware;
   3073                                 OMX_MEMFREE_STRUCT_DSPALIGN(pDynParams,SPARKVDEC_UALGDynamicParams);
   3074                                 goto EXIT;
   3075                             }
   3076                             VIDDEC_PTHREAD_MUTEX_WAIT(pComponentPrivate->sMutex);
   3077                             VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   3078                         }
   3079 
   3080                         OMX_MEMFREE_STRUCT_DSPALIGN(pDynParams,SPARKVDEC_UALGDynamicParams);
   3081 
   3082                         if (eError != OMX_ErrorNone) {
   3083                             OMX_PRDSP4(pComponentPrivate->dbg, "Codec AlgCtrl 0x%x\n",eError);
   3084                             goto EXIT;
   3085                         }
   3086                     }
   3087                 }
   3088 #endif
   3089                 else {
   3090                     if(pComponentPrivate->eState == OMX_StateIdle) {
   3091                         eError = VIDDEC_SetMpeg4_Parameters(pComponentPrivate);
   3092                         if (eError != OMX_ErrorNone){
   3093                             goto EXIT;
   3094                         }
   3095                     }
   3096                 }
   3097 
   3098                 /* Start existing code */
   3099 #if 1
   3100 #ifdef RESOURCE_MANAGER_ENABLED
   3101             if(pComponentPrivate->eRMProxyState != VidDec_RMPROXY_State_Unload){
   3102                 OMX_PRMGR2(pComponentPrivate->dbg, "memory usage 3 %d : %d bytes\n",(unsigned int)pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0],(unsigned int)VIDDEC_MEMUSAGE);
   3103                 if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
   3104                     eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_StateSet, OMX_H264_Decode_COMPONENT, OMX_StateExecuting, VIDDEC_MEMUSAGE, NULL);
   3105                 }
   3106                 else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4) {
   3107                     eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_StateSet, OMX_MPEG4_Decode_COMPONENT, OMX_StateExecuting, VIDDEC_MEMUSAGE, NULL);
   3108                 }
   3109                 else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) {
   3110                     eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_StateSet, OMX_H263_Decode_COMPONENT, OMX_StateExecuting, VIDDEC_MEMUSAGE, NULL);
   3111                 }
   3112                 else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG2) {
   3113                     eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_StateSet, OMX_MPEG2_Decode_COMPONENT, OMX_StateExecuting, VIDDEC_MEMUSAGE, NULL);
   3114                 }
   3115                 else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV) {
   3116                     eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_StateSet, OMX_WMV_Decode_COMPONENT, OMX_StateExecuting, VIDDEC_MEMUSAGE, NULL);
   3117                 }
   3118 #ifdef VIDDEC_SPARK_CODE
   3119                 else if (VIDDEC_SPARKCHECK) {
   3120                     eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_StateSet, OMX_MPEG4_Decode_COMPONENT, OMX_StateExecuting, VIDDEC_MEMUSAGE, NULL);
   3121                 }
   3122 #endif
   3123                 else {
   3124                     eError = OMX_ErrorUnsupportedSetting;
   3125                     pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3126                                                            pComponentPrivate->pHandle->pApplicationPrivate,
   3127                                                            OMX_EventError,
   3128                                                            OMX_ErrorUnsupportedSetting,
   3129                                                            OMX_TI_ErrorMinor,
   3130                                                            "RM SendCommand OMX_ErrorUnsupportedSetting Error");
   3131                     OMX_ERROR4(pComponentPrivate->dbg, "OMX_ErrorUnsupportedSetting 0x%x\n",eError);
   3132                     goto EXIT;
   3133                 }
   3134                 if (eError != OMX_ErrorNone) {
   3135                     pComponentPrivate->eState = OMX_StateLoaded;
   3136                      pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3137                                                             pComponentPrivate->pHandle->pApplicationPrivate,
   3138                                                             OMX_EventError,
   3139                                                             OMX_ErrorInsufficientResources,
   3140                                                             OMX_TI_ErrorMajor,
   3141                                                             "RM SendCommand Error");
   3142                      OMX_PRMGR4(pComponentPrivate->dbg, "OMX_ErrorUnsupportedSetting 0x%x\n",eError);
   3143                      break;
   3144                 }
   3145             }
   3146 #endif
   3147 #endif
   3148 
   3149                 eError = OMX_ErrorNone;
   3150                 pComponentPrivate->bIsPaused = 0;
   3151                 pComponentPrivate->iEndofInputSent = 0;
   3152                 pComponentPrivate->eState = OMX_StateExecuting;
   3153                 /* Decrement reference count with signal enabled */
   3154                 if(RemoveStateTransition(pComponentPrivate, OMX_TRUE) != OMX_ErrorNone) {
   3155                       return OMX_ErrorUndefined;
   3156                 }
   3157                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3158                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   3159                                                        OMX_EventCmdComplete,
   3160                                                        OMX_CommandStateSet,
   3161                                                        pComponentPrivate->eState,
   3162                                                        NULL);
   3163                 OMX_PRSTATE2(pComponentPrivate->dbg, "Transition to OMX_StateExecuting\n");
   3164             }
   3165             else {
   3166                 eError = OMX_ErrorIncorrectStateTransition;
   3167                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3168                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   3169                                                        OMX_EventError,
   3170                                                        OMX_ErrorIncorrectStateTransition,
   3171                                                        OMX_TI_ErrorMinor,
   3172                                                        "Incorrect State Transition");
   3173                  OMX_PRSTATE4(pComponentPrivate->dbg, "OMX_ErrorIncorrectStateTransition 0x%x\n",eError);
   3174             }
   3175             break;
   3176         case OMX_StateLoaded:
   3177             OMX_PRSTATE2(pComponentPrivate->dbg, "Transitioning to OMX_StateLoaded C 0x%x N 0x%lx\n",pComponentPrivate->eState, nParam1);
   3178             if (pComponentPrivate->eState == OMX_StateLoaded) {
   3179                 eError = OMX_ErrorSameState;
   3180                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3181                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   3182                                                        OMX_EventError,
   3183                                                        OMX_ErrorSameState,
   3184                                                        OMX_TI_ErrorMinor,
   3185                                                        "Same State");
   3186                  OMX_PRSTATE4(pComponentPrivate->dbg, "OMX_ErrorSameState 0x%x\n",eError);
   3187             }
   3188             else if (pComponentPrivate->eState == OMX_StateIdle) {
   3189 #ifdef __PERF_INSTRUMENTATION__
   3190                 PERF_Boundary(pComponentPrivate->pPERFcomp,
   3191                               PERF_BoundaryStart | PERF_BoundaryCleanup);
   3192 #endif
   3193                 OMX_VidDec_Return(pComponentPrivate);
   3194                 pComponentPrivate->eIdleToLoad = OMX_StateLoaded;
   3195                 if(pComponentPrivate->eFirstBuffer.pFirstBufferSaved){
   3196                     free(pComponentPrivate->eFirstBuffer.pFirstBufferSaved);
   3197                     pComponentPrivate->eFirstBuffer.pFirstBufferSaved = NULL;
   3198                     pComponentPrivate->eFirstBuffer.bSaveFirstBuffer = OMX_FALSE;
   3199                     pComponentPrivate->eFirstBuffer.nFilledLen = 0;
   3200                 }
   3201 #ifdef RESOURCE_MANAGER_ENABLED
   3202                 if(pComponentPrivate->eRMProxyState == VidDec_RMPROXY_State_Registered){
   3203                         OMX_PRMGR2(pComponentPrivate->dbg, "memory usage 4 %d : %d bytes\n",(unsigned int)pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0],(unsigned int)VIDDEC_MEMUSAGE);
   3204                     if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
   3205                             eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_FreeResource, OMX_H264_Decode_COMPONENT, 0, VIDDEC_MEMUSAGE, NULL);
   3206                         if (eError != OMX_ErrorNone) {
   3207                              OMX_PRMGR4(pComponentPrivate->dbg, "Error returned from destroy ResourceManagerProxy thread\n");
   3208                         }
   3209                     }
   3210                     else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV) {
   3211                         eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_FreeResource, OMX_WMV_Decode_COMPONENT, 0, VIDDEC_MEMUSAGE, NULL);
   3212                         if (eError != OMX_ErrorNone) {
   3213                              OMX_PRMGR4(pComponentPrivate->dbg, "Error returned from destroy ResourceManagerProxy thread\n");
   3214                         }
   3215                     }
   3216                     else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4) {
   3217                         eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_FreeResource, OMX_MPEG4_Decode_COMPONENT, 0, VIDDEC_MEMUSAGE, NULL);
   3218                         if (eError != OMX_ErrorNone) {
   3219                              OMX_PRMGR4(pComponentPrivate->dbg, "Error returned from destroy ResourceManagerProxy thread\n");
   3220                         }
   3221                     }
   3222                     else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) {
   3223                         eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_FreeResource, OMX_H263_Decode_COMPONENT, 0, VIDDEC_MEMUSAGE, NULL);
   3224                         if (eError != OMX_ErrorNone) {
   3225                              OMX_PRMGR4(pComponentPrivate->dbg, "Error returned from destroy ResourceManagerProxy thread\n");
   3226                         }
   3227                     }
   3228                     else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG2) {
   3229                         eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_FreeResource, OMX_MPEG2_Decode_COMPONENT, 0, VIDDEC_MEMUSAGE, NULL);
   3230                         if (eError != OMX_ErrorNone) {
   3231                              OMX_PRMGR4(pComponentPrivate->dbg, "Error returned from destroy ResourceManagerProxy thread\n");
   3232                         }
   3233                     }
   3234 #ifdef VIDDEC_SPARK_CODE
   3235                     else if (VIDDEC_SPARKCHECK) {
   3236                         eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_FreeResource, OMX_MPEG4_Decode_COMPONENT, 0, VIDDEC_MEMUSAGE, NULL);
   3237                         if (eError != OMX_ErrorNone) {
   3238                              OMX_PRMGR4(pComponentPrivate->dbg, "Error returned from destroy ResourceManagerProxy thread\n");
   3239                         }
   3240                     }
   3241 #endif
   3242                     else {
   3243                         eError = OMX_ErrorUnsupportedSetting;
   3244                         goto EXIT;
   3245                     }
   3246                     pComponentPrivate->eRMProxyState = VidDec_RMPROXY_State_Load;
   3247                 }
   3248 #endif
   3249                 if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   3250                     pComponentPrivate->pLCML != NULL){
   3251                     OMX_PRDSP2(pComponentPrivate->dbg, "LCML_ControlCodec called EMMCodecControlDestroy 0x%p\n",pLcmlHandle);
   3252                     pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
   3253                     eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, EMMCodecControlDestroy, NULL);
   3254                     if (eError != OMX_ErrorNone) {
   3255                         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3256                                                                pComponentPrivate->pHandle->pApplicationPrivate,
   3257                                                                OMX_EventError,
   3258                                                                OMX_ErrorHardware,
   3259                                                                OMX_TI_ErrorSevere,
   3260                                                                NULL);
   3261                         OMX_PRDSP4(pComponentPrivate->dbg, "OMX_ErrorHardware 0x%x\n",eError);
   3262                         break;
   3263                     }
   3264                     pComponentPrivate->eLCMLState = VidDec_LCML_State_Destroy;
   3265                     OMX_PRDSP2(pComponentPrivate->dbg, "LCML_ControlCodec called EMMCodecControlDestroy 0x%p\n",pLcmlHandle);
   3266                 }
   3267 
   3268                 OMX_PRDSP2(pComponentPrivate->dbg, "Closing LCML lib 0x%p\n",pComponentPrivate->pModLCML);
   3269 
   3270 #ifndef UNDER_CE
   3271                 if(pComponentPrivate->pModLCML != NULL){
   3272                     dlclose(pComponentPrivate->pModLCML);
   3273                     pComponentPrivate->pModLCML = NULL;
   3274                     pComponentPrivate->pLCML = NULL;
   3275                 }
   3276 #else
   3277                 if(pComponentPrivate->pModLCML != NULL){
   3278                     FreeLibrary(pComponentPrivate->pModLCML);
   3279                     pComponentPrivate->pModLCML = NULL;
   3280                     pComponentPrivate->pLCML = NULL;
   3281                 }
   3282 #endif
   3283             pComponentPrivate->eLCMLState = VidDec_LCML_State_Unload;
   3284 
   3285                OMX_PRDSP1(pComponentPrivate->dbg, "Closed LCML lib 0x%p\n",pComponentPrivate->pModLCML);
   3286                OMX_PRBUFFER2(pComponentPrivate->dbg, "Waiting for unpopulate ports IN 0x%x OUT 0x%x\n",pPortDefIn->bEnabled,pPortDefOut->bEnabled);
   3287                OMX_PRBUFFER1(pComponentPrivate->dbg, "Tunneling 0x%p\n",(pComponentPrivate->pCompPort[1]->hTunnelComponent));
   3288                if ((pPortDefIn->bEnabled == OMX_TRUE && pPortDefOut->bEnabled == OMX_TRUE) ||
   3289                 (pPortDefIn->bEnabled == OMX_TRUE && pComponentPrivate->pCompPort[1]->hTunnelComponent != NULL)) {
   3290 #ifdef UNDER_CE
   3291                     while(1) {
   3292                         if(!pPortDefIn->bPopulated && !pPortDefOut->bPopulated) {
   3293                             OMX_PRBUFFER2(pComponentPrivate->dbg, "Standalone unpopulated ports IN 0x%x OUT 0x%x\n",pPortDefIn->bEnabled,pPortDefOut->bEnabled);
   3294                             eError = OMX_ErrorNone;
   3295                             pComponentPrivate->bIsPaused = 0;
   3296                             pComponentPrivate->eState = OMX_StateLoaded;
   3297                             /* Decrement reference count with signal enabled */
   3298                             if(RemoveStateTransition(pComponentPrivate, OMX_TRUE) != OMX_ErrorNone) {
   3299                                 return OMX_ErrorUndefined;
   3300                             }
   3301                             pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3302                                                                    pComponentPrivate->pHandle->pApplicationPrivate,
   3303                                                                    OMX_EventCmdComplete,
   3304                                                                    OMX_CommandStateSet,
   3305                                                                    pComponentPrivate->eState,
   3306                                                                    NULL);
   3307                             OMX_PRSTATE2(pComponentPrivate->dbg, "Transition to OMX_StateLoaded\n");
   3308                             VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_VARS);
   3309                             pComponentPrivate->eIdleToLoad = OMX_StateInvalid;
   3310                             break;
   3311                         }
   3312                         else if(!pPortDefIn->bPopulated && (pComponentPrivate->pCompPort[1]->hTunnelComponent != NULL)) {
   3313                             OMX_PRBUFFER2(pComponentPrivate->dbg, "Tunneling unpopulated ports IN 0x%x TUNNEL 0x%x\n",
   3314                                 pPortDefIn->bEnabled,pComponentPrivate->pCompPort[1]->hTunnelComponent);
   3315                             eError = OMX_ErrorNone;
   3316                             pComponentPrivate->bIsPaused = 0;
   3317                             pComponentPrivate->eState = OMX_StateLoaded;
   3318                             /* Decrement reference count with signal enabled */
   3319                             if(RemoveStateTransition(pComponentPrivate, OMX_TRUE) != OMX_ErrorNone) {
   3320                                 return OMX_ErrorUndefined;
   3321                             }
   3322                             pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3323                                                                    pComponentPrivate->pHandle->pApplicationPrivate,
   3324                                                                    OMX_EventCmdComplete,
   3325                                                                    OMX_CommandStateSet,
   3326                                                                    pComponentPrivate->eState,
   3327                                                                    NULL);
   3328                             OMX_PRSTATE2(pComponentPrivate->dbg, "Transition to OMX_StateLoaded\n");
   3329                             VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_VARS);
   3330                             pComponentPrivate->eIdleToLoad = OMX_StateInvalid;
   3331                             break;
   3332                         }
   3333                         VIDDEC_WAIT_CODE();
   3334                     }
   3335 #else
   3336                     if(pComponentPrivate->pCompPort[1]->hTunnelComponent != NULL) {
   3337                         if((!(pComponentPrivate->eState == OMX_StateLoaded) && pComponentPrivate->pInPortDef->bPopulated) ||
   3338                             pComponentPrivate->sInSemaphore.bSignaled) {
   3339                             VIDDEC_PTHREAD_SEMAPHORE_WAIT(pComponentPrivate->sInSemaphore);
   3340                         }
   3341                         OMX_PRBUFFER2(pComponentPrivate->dbg, "Tunneling unpopulated ports IN 0x%x TUNNEL 0x%p\n",
   3342                             pPortDefIn->bEnabled,pComponentPrivate->pCompPort[1]->hTunnelComponent);
   3343                         eError = OMX_ErrorNone;
   3344                         pComponentPrivate->bIsPaused = 0;
   3345                         pComponentPrivate->eState = OMX_StateLoaded;
   3346                         /* Decrement reference count with signal enabled */
   3347                         if(RemoveStateTransition(pComponentPrivate, OMX_TRUE) != OMX_ErrorNone) {
   3348                             return OMX_ErrorUndefined;
   3349                         }
   3350                         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3351                                                                pComponentPrivate->pHandle->pApplicationPrivate,
   3352                                                                OMX_EventCmdComplete,
   3353                                                                OMX_CommandStateSet,
   3354                                                                pComponentPrivate->eState,
   3355                                                                NULL);
   3356                         OMX_PRSTATE2(pComponentPrivate->dbg, "Transition to OMX_StateLoaded\n");
   3357                         VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_VARS);
   3358                         pComponentPrivate->eIdleToLoad = OMX_StateInvalid;
   3359                     }
   3360                     else {
   3361                         if((!(pComponentPrivate->eState == OMX_StateLoaded) && pComponentPrivate->pInPortDef->bPopulated) ||
   3362                             pComponentPrivate->sInSemaphore.bSignaled) {
   3363                             VIDDEC_PTHREAD_SEMAPHORE_WAIT(pComponentPrivate->sInSemaphore);
   3364                         }
   3365                         if((!(pComponentPrivate->eState == OMX_StateLoaded) && pComponentPrivate->pOutPortDef->bPopulated) ||
   3366                             pComponentPrivate->sOutSemaphore.bSignaled) {
   3367                             VIDDEC_PTHREAD_SEMAPHORE_WAIT(pComponentPrivate->sOutSemaphore);
   3368                         }
   3369                         OMX_PRBUFFER2(pComponentPrivate->dbg, "Standalone unpopulated ports IN 0x%x OUT 0x%x\n",pPortDefIn->bEnabled,pPortDefOut->bEnabled);
   3370                         eError = OMX_ErrorNone;
   3371                         pComponentPrivate->bIsPaused = 0;
   3372                         pComponentPrivate->eState = OMX_StateLoaded;
   3373                         /* Decrement reference count with signal enabled */
   3374                         if(RemoveStateTransition(pComponentPrivate, OMX_TRUE) != OMX_ErrorNone) {
   3375                             return OMX_ErrorUndefined;
   3376                         }
   3377                         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3378                                                                pComponentPrivate->pHandle->pApplicationPrivate,
   3379                                                                OMX_EventCmdComplete,
   3380                                                                OMX_CommandStateSet,
   3381                                                                pComponentPrivate->eState,
   3382                                                                NULL);
   3383                         OMX_PRSTATE2(pComponentPrivate->dbg, "Transition to OMX_StateLoaded\n");
   3384                         VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_VARS);
   3385                         pComponentPrivate->eIdleToLoad = OMX_StateInvalid;
   3386 
   3387                     }
   3388 
   3389 
   3390 #endif
   3391 #ifdef __PERF_INSTRUMENTATION__
   3392                     PERF_Boundary(pComponentPrivate->pPERFcomp,
   3393                                   PERF_BoundaryComplete | PERF_BoundaryCleanup);
   3394 #endif
   3395 
   3396                 }
   3397 #ifndef UNDER_CE
   3398                 else {
   3399                     if(pComponentPrivate->pCompPort[1]->hTunnelComponent != NULL) {
   3400                         if(pComponentPrivate->sInSemaphore.bSignaled){
   3401                             VIDDEC_PTHREAD_SEMAPHORE_WAIT(pComponentPrivate->sInSemaphore);
   3402                         }
   3403                     }
   3404                     else {
   3405                         if(pComponentPrivate->sInSemaphore.bSignaled){
   3406                             VIDDEC_PTHREAD_SEMAPHORE_WAIT(pComponentPrivate->sInSemaphore);
   3407                         }
   3408                         if(pComponentPrivate->sOutSemaphore.bSignaled){
   3409                             VIDDEC_PTHREAD_SEMAPHORE_WAIT(pComponentPrivate->sOutSemaphore);
   3410                         }
   3411                     }
   3412                     pComponentPrivate->eState = OMX_StateLoaded;
   3413                     pComponentPrivate->bIsPaused = 0;
   3414                     /* Decrement reference count with signal enabled */
   3415                     if(RemoveStateTransition(pComponentPrivate, OMX_TRUE) != OMX_ErrorNone) {
   3416                         return OMX_ErrorUndefined;
   3417                     }
   3418                     pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3419                                                            pComponentPrivate->pHandle->pApplicationPrivate,
   3420                                                            OMX_EventCmdComplete,
   3421                                                            OMX_CommandStateSet,
   3422                                                            pComponentPrivate->eState,
   3423                                                            NULL);
   3424                     pComponentPrivate->eIdleToLoad = OMX_StateInvalid;
   3425                     VIDDEC_Load_Defaults(pComponentPrivate, VIDDEC_INIT_VARS);
   3426                     OMX_PRSTATE2(pComponentPrivate->dbg, "Transition to OMX_StateLoaded\n");
   3427                     break;
   3428                 }
   3429 #endif
   3430             }
   3431             else if (pComponentPrivate->eState == OMX_StateWaitForResources) {
   3432                 pComponentPrivate->eState = OMX_StateLoaded;
   3433                 pComponentPrivate->bIsPaused = 0;
   3434                 /* Decrement reference count with signal enabled */
   3435                 if(RemoveStateTransition(pComponentPrivate, OMX_TRUE) != OMX_ErrorNone) {
   3436                     return OMX_ErrorUndefined;
   3437                 }
   3438                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3439                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   3440                                                        OMX_EventCmdComplete,
   3441                                                        OMX_CommandStateSet,
   3442                                                        pComponentPrivate->eState,
   3443                                                        NULL);
   3444                 OMX_PRSTATE2(pComponentPrivate->dbg, "Transition to OMX_StateLoaded\n");
   3445                 break;
   3446             }
   3447             else {
   3448                 eError = OMX_ErrorIncorrectStateTransition;
   3449                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3450                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   3451                                                        OMX_EventError,
   3452                                                        OMX_ErrorIncorrectStateTransition,
   3453                                                        OMX_TI_ErrorMinor,
   3454                                                        NULL);
   3455                 OMX_PRSTATE2(pComponentPrivate->dbg, "Incorrect State Transition 0x%x\n",eError);
   3456             }
   3457             break;
   3458         case OMX_StatePause:
   3459             OMX_VidDec_Return(pComponentPrivate);
   3460             OMX_PRSTATE2(pComponentPrivate->dbg, "Transitioning to OMX_StatePause C 0x%x N 0x%lx\n",pComponentPrivate->eState, nParam1);
   3461             if (pComponentPrivate->eState == OMX_StatePause) {
   3462                 eError = OMX_ErrorSameState;
   3463                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3464                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   3465                                                        OMX_EventError,
   3466                                                        OMX_ErrorSameState,
   3467                                                        OMX_TI_ErrorMinor,
   3468                                                        NULL);
   3469                 OMX_PRSTATE4(pComponentPrivate->dbg, "Same State 0x%x\n",eError);
   3470                 break;
   3471             }
   3472             else if (pComponentPrivate->eState == OMX_StateExecuting) {
   3473 #ifdef __PERF_INSTRUMENTATION__
   3474                 pComponentPrivate->lcml_nCntOpReceived = 0;
   3475                 PERF_Boundary(pComponentPrivate->pPERFcomp,
   3476                               PERF_BoundaryComplete | PERF_BoundarySteadyState);
   3477 #endif
   3478 
   3479                 VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->sMutex);
   3480                 pComponentPrivate->bIsPaused = 1;
   3481                 OMX_VidDec_Return(pComponentPrivate);
   3482                 if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   3483                     pComponentPrivate->eLCMLState != VidDec_LCML_State_Destroy &&
   3484                     pComponentPrivate->pLCML != NULL &&
   3485                     pComponentPrivate->bLCMLHalted != OMX_TRUE){
   3486                     pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
   3487                     OMX_PRDSP2(pComponentPrivate->dbg, "LCML_ControlCodec called EMMCodecControlPause 0x%p\n",pLcmlHandle);
   3488                     eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, EMMCodecControlPause, NULL);
   3489                     if (eError != OMX_ErrorNone) {
   3490                         eError = OMX_ErrorHardware;
   3491                         OMX_PRDSP4(pComponentPrivate->dbg, "Error during EMMCodecControlPause...\n");
   3492                         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3493                                                                pComponentPrivate->pHandle->pApplicationPrivate,
   3494                                                                OMX_EventError,
   3495                                                                eError,
   3496                                                                OMX_TI_ErrorSevere,
   3497                                                                NULL);
   3498                         VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   3499                         break;
   3500                     }
   3501                     eError = OMX_ErrorNone;
   3502                     VIDDEC_PTHREAD_MUTEX_WAIT(pComponentPrivate->sMutex);
   3503                     VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   3504                 }
   3505                 pComponentPrivate->eLCMLState = VidDec_LCML_State_Pause;
   3506                 OMX_VidDec_Return(pComponentPrivate);
   3507                 pComponentPrivate->eLCMLState = VidDec_LCML_State_Pause;
   3508                 eError = OMX_ErrorNone;
   3509                 pComponentPrivate->bIsPaused = 1;
   3510                 pComponentPrivate->eState = OMX_StatePause;
   3511                 /* Decrement reference count with signal enabled */
   3512                 if(RemoveStateTransition(pComponentPrivate, OMX_TRUE) != OMX_ErrorNone) {
   3513                     return OMX_ErrorUndefined;
   3514                 }
   3515                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3516                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   3517                                                        OMX_EventCmdComplete,
   3518                                                        OMX_CommandStateSet,
   3519                                                        pComponentPrivate->eState,
   3520                                                        NULL);
   3521 
   3522                 break;
   3523             }
   3524             else if (pComponentPrivate->eState == OMX_StateIdle) {
   3525                 pComponentPrivate->bIsPaused = 1;
   3526                 if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   3527                     pComponentPrivate->eLCMLState != VidDec_LCML_State_Destroy &&
   3528                     pComponentPrivate->pLCML != NULL &&
   3529                     pComponentPrivate->bLCMLHalted != OMX_TRUE){
   3530                     VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->sMutex);
   3531                     pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
   3532                     OMX_PRDSP2(pComponentPrivate->dbg, "LCML_ControlCodec called EMMCodecControlPause 0x%p\n",pLcmlHandle);
   3533                     eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, EMMCodecControlPause, NULL);
   3534                     if (eError != OMX_ErrorNone) {
   3535                         OMX_PRDSP4(pComponentPrivate->dbg, "During EMMCodecControlPause...\n");
   3536                         eError = OMX_ErrorHardware;
   3537                         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3538                                                                pComponentPrivate->pHandle->pApplicationPrivate,
   3539                                                                OMX_EventError,
   3540                                                                eError,
   3541                                                                OMX_TI_ErrorSevere,
   3542                                                                NULL);
   3543                         VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   3544                         break;
   3545                     }
   3546                     eError = OMX_ErrorNone;
   3547                     VIDDEC_PTHREAD_MUTEX_WAIT(pComponentPrivate->sMutex);
   3548                     VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   3549                 }
   3550                 pComponentPrivate->eLCMLState = VidDec_LCML_State_Pause;
   3551                 eError = OMX_ErrorNone;
   3552                 pComponentPrivate->bIsPaused = 1;
   3553                 pComponentPrivate->eState = OMX_StatePause;
   3554                 /* Decrement reference count with signal enabled */
   3555                 if(RemoveStateTransition(pComponentPrivate, OMX_TRUE) != OMX_ErrorNone) {
   3556                     return OMX_ErrorUndefined;
   3557                 }
   3558                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3559                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   3560                                                        OMX_EventCmdComplete,
   3561                                                        OMX_CommandStateSet,
   3562                                                        pComponentPrivate->eState,
   3563                                                        NULL);
   3564                 OMX_PRSTATE2(pComponentPrivate->dbg, "Transition to OMX_StatePause\n");
   3565             }
   3566             else {
   3567                 eError = OMX_ErrorIncorrectStateTransition;
   3568                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3569                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   3570                                                        OMX_EventError,
   3571                                                        OMX_ErrorIncorrectStateTransition,
   3572                                                        OMX_TI_ErrorMinor,
   3573                                                        "Incorrect State Transition");
   3574                 OMX_PRSTATE4(pComponentPrivate->dbg, "Incorrect State Transition\n");
   3575             }
   3576             break;
   3577         case OMX_StateInvalid:
   3578             OMX_PRINT1(pComponentPrivate->dbg, "Transitioning to OMX_StateInvalid C 0x%x N 0x%lx\n",pComponentPrivate->eState, nParam1);
   3579             if (pComponentPrivate->eState == OMX_StateInvalid) {
   3580                 eError = OMX_ErrorSameState;
   3581                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3582                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   3583                                                        OMX_EventError,
   3584                                                        OMX_ErrorSameState,
   3585                                                        OMX_TI_ErrorCritical,
   3586                                                        "Same State");
   3587                 OMX_PRSTATE4(pComponentPrivate->dbg, "Same State...\n");
   3588                 break;
   3589             }
   3590             else if (pComponentPrivate->eState == OMX_StateIdle || pComponentPrivate->eState == OMX_StateExecuting) {
   3591                 pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
   3592                 if (pComponentPrivate->eState == OMX_StateExecuting) {
   3593                     if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   3594                         pComponentPrivate->eLCMLState != VidDec_LCML_State_Destroy &&
   3595                         pComponentPrivate->pLCML != NULL &&
   3596                         pComponentPrivate->bLCMLHalted != OMX_TRUE) {
   3597                         VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->sMutex);
   3598                         OMX_PRDSP2(pComponentPrivate->dbg, "LCML_ControlCodec called MMCodecControlStop 0x%x\n",eError);
   3599                         eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, MMCodecControlStop, NULL);
   3600                         if (eError != OMX_ErrorNone) {
   3601                             OMX_PRDSP4(pComponentPrivate->dbg, "Occurred in Codec Stop...\n");
   3602                             eError = OMX_ErrorHardware;
   3603                             pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3604                                                                    pComponentPrivate->pHandle->pApplicationPrivate,
   3605                                                                    OMX_EventError,
   3606                                                                    eError,
   3607                                                                    OMX_TI_ErrorCritical,
   3608                                                                    NULL);
   3609                             VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   3610                             break;
   3611                         }
   3612                         VIDDEC_PTHREAD_MUTEX_WAIT(pComponentPrivate->sMutex);
   3613                         VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   3614                     }
   3615 
   3616                     pComponentPrivate->eLCMLState = VidDec_LCML_State_Stop;
   3617                 }
   3618                 if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   3619                     pComponentPrivate->pLCML != NULL){
   3620                     eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, EMMCodecControlDestroy, NULL);
   3621                     OMX_PRDSP2(pComponentPrivate->dbg, "LCML_ControlCodec called EMMCodecControlDestroy 0x%p\n",pLcmlHandle);
   3622                     if (eError != OMX_ErrorNone) {
   3623                         OMX_PRDSP4(pComponentPrivate->dbg, "Occurred in Codec Destroy...\n");
   3624                         eError = OMX_ErrorHardware;
   3625                         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3626                                                                pComponentPrivate->pHandle->pApplicationPrivate,
   3627                                                                OMX_EventError,
   3628                                                                eError,
   3629                                                                OMX_TI_ErrorCritical,
   3630                                                                NULL);
   3631                         OMX_PRSTATE4(pComponentPrivate->dbg, "Incorrect State Transition 0x%x\n", eError);
   3632                         break;
   3633                     }
   3634                 }
   3635 
   3636                 pComponentPrivate->eLCMLState = VidDec_LCML_State_Destroy;
   3637                 if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload) {
   3638 #ifndef UNDER_CE
   3639                     if(pComponentPrivate->pModLCML != NULL){
   3640                         dlclose(pComponentPrivate->pModLCML);
   3641                         pComponentPrivate->pModLCML = NULL;
   3642                         pComponentPrivate->pLCML = NULL;
   3643                         pComponentPrivate->eLCMLState = VidDec_LCML_State_Unload;
   3644                     }
   3645 #else
   3646                     if(pComponentPrivate->pModLCML != NULL){
   3647                         FreeLibrary(pComponentPrivate->pModLCML);
   3648                         pComponentPrivate->pModLCML = NULL;
   3649                         pComponentPrivate->pLCML = NULL;
   3650                         pComponentPrivate->eLCMLState = VidDec_LCML_State_Unload;
   3651                     }
   3652 #endif
   3653                 }
   3654                 for (iCount = 0; iCount < MAX_PRIVATE_BUFFERS; iCount++) {
   3655                     if(pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT]->pBufferPrivate[iCount]->bAllocByComponent == OMX_TRUE){
   3656                         if(pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT]->pBufferPrivate[iCount]->pBufferHdr != NULL) {
   3657                             OMX_BUFFERHEADERTYPE* pBuffHead = NULL;
   3658                             pBuffHead = pComponentPrivate->pCompPort[VIDDEC_INPUT_PORT]->pBufferPrivate[iCount]->pBufferHdr;
   3659                             OMX_MEMFREE_STRUCT_DSPALIGN(pBuffHead->pBuffer,OMX_U8);
   3660                         }
   3661                     }
   3662                 }
   3663 
   3664                 for (iCount = 0; iCount < MAX_PRIVATE_BUFFERS; iCount++) {
   3665                     if(pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[iCount]->bAllocByComponent == OMX_TRUE){
   3666                         if(pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[iCount]->pBufferHdr != NULL) {
   3667                             OMX_BUFFERHEADERTYPE* pBuffHead = NULL;
   3668                             pBuffHead = pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[iCount]->pBufferHdr;
   3669                             OMX_MEMFREE_STRUCT_DSPALIGN(pBuffHead->pBuffer,OMX_U8);
   3670                         }
   3671                     }
   3672                 }
   3673 #ifdef RESOURCE_MANAGER_ENABLED
   3674                 if(pComponentPrivate->eRMProxyState == VidDec_RMPROXY_State_Registered){
   3675                     OMX_PRMGR2(pComponentPrivate->dbg, "memory usage 4 %d : %d bytes\n",(unsigned int)pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel0],(unsigned int)VIDDEC_MEMUSAGE);
   3676                     if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
   3677                         eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_FreeResource, OMX_H264_Decode_COMPONENT, 0, VIDDEC_MEMUSAGE, NULL);
   3678                         if (eError != OMX_ErrorNone) {
   3679                              OMX_PRMGR4(pComponentPrivate->dbg, "Error returned from destroy ResourceManagerProxy thread\n");
   3680                         }
   3681                     }
   3682                     else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV) {
   3683                         eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_FreeResource, OMX_WMV_Decode_COMPONENT, 0, VIDDEC_MEMUSAGE, NULL);
   3684                         if (eError != OMX_ErrorNone) {
   3685                              OMX_PRMGR4(pComponentPrivate->dbg, "Error returned from destroy ResourceManagerProxy thread\n");
   3686                         }
   3687                     }
   3688                     else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4) {
   3689                         eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_FreeResource, OMX_MPEG4_Decode_COMPONENT, 0, VIDDEC_MEMUSAGE, NULL);
   3690                         if (eError != OMX_ErrorNone) {
   3691                              OMX_PRMGR4(pComponentPrivate->dbg, "Error returned from destroy ResourceManagerProxy thread\n");
   3692                         }
   3693                     }
   3694                     else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) {
   3695                         eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_FreeResource, OMX_H263_Decode_COMPONENT, 0, VIDDEC_MEMUSAGE, NULL);
   3696                         if (eError != OMX_ErrorNone) {
   3697                              OMX_PRMGR4(pComponentPrivate->dbg, "Error returned from destroy ResourceManagerProxy thread\n");
   3698                         }
   3699                     }
   3700                     else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG2) {
   3701                         eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_FreeResource, OMX_MPEG2_Decode_COMPONENT, 0, VIDDEC_MEMUSAGE, NULL);
   3702                         if (eError != OMX_ErrorNone) {
   3703                              OMX_PRMGR4(pComponentPrivate->dbg, "Error returned from destroy ResourceManagerProxy thread\n");
   3704                         }
   3705                     }
   3706 #ifdef VIDDEC_SPARK_CODE
   3707                     else if (VIDDEC_SPARKCHECK) {
   3708                         eError = RMProxy_NewSendCommand(pComponentPrivate->pHandle, RMProxy_FreeResource, OMX_MPEG4_Decode_COMPONENT, 0, VIDDEC_MEMUSAGE, NULL);
   3709                         if (eError != OMX_ErrorNone) {
   3710                              OMX_PRMGR4(pComponentPrivate->dbg, "Error returned from destroy ResourceManagerProxy thread\n");
   3711                         }
   3712                     }
   3713 #endif
   3714                     else {
   3715                         eError = OMX_ErrorUnsupportedSetting;
   3716                         goto EXIT;
   3717                     }
   3718                     pComponentPrivate->eRMProxyState = VidDec_RMPROXY_State_Load;
   3719                 }
   3720                 if(pComponentPrivate->eRMProxyState != VidDec_RMPROXY_State_Unload){
   3721                     eError = RMProxy_DeinitalizeEx(OMX_COMPONENTTYPE_VIDEO);
   3722                     if (eError != OMX_ErrorNone) {
   3723                         OMX_PRMGR4(pComponentPrivate->dbg, "Error returned from destroy ResourceManagerProxy thread\n");
   3724                     }
   3725                     pComponentPrivate->eRMProxyState = VidDec_RMPROXY_State_Unload;
   3726                 }
   3727 #endif
   3728                 eError = OMX_ErrorInvalidState;
   3729                 pComponentPrivate->eState = OMX_StateInvalid;
   3730                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3731                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   3732                                                        OMX_EventError,
   3733                                                        OMX_ErrorInvalidState,
   3734                                                        OMX_TI_ErrorCritical,
   3735                                                        "Invalid State");
   3736                 OMX_PRSTATE4(pComponentPrivate->dbg, "Incorrect State Transition 0x%x\n", eError);
   3737                 break;
   3738             }
   3739             else{
   3740                 eError = OMX_ErrorIncorrectStateTransition;
   3741                 pComponentPrivate->eState = OMX_StateInvalid;
   3742                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3743                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   3744                                                        OMX_EventError,
   3745                                                        OMX_ErrorInvalidState,
   3746                                                        OMX_TI_ErrorCritical,
   3747                                                        "Incorrect State Transition");
   3748                 OMX_PRSTATE4(pComponentPrivate->dbg, "Incorrect State Transition 0x%x\n", eError);
   3749                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3750                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   3751                                                        OMX_EventCmdComplete,
   3752                                                        OMX_CommandStateSet,
   3753                                                        pComponentPrivate->eState,
   3754                                                        NULL);
   3755 
   3756             }
   3757             break;
   3758         case OMX_StateWaitForResources:
   3759             OMX_PRSTATE2(pComponentPrivate->dbg, "Transitioning to OMX_StateWaitForResources C 0x%x N 0x%lx\n",pComponentPrivate->eState, nParam1);
   3760             if (pComponentPrivate->eState == OMX_StateWaitForResources) {
   3761                 eError = OMX_ErrorSameState;
   3762                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3763                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   3764                                                        OMX_EventError,
   3765                                                        OMX_ErrorSameState,
   3766                                                        OMX_TI_ErrorMinor,
   3767                                                        NULL);
   3768                 OMX_PRSTATE4(pComponentPrivate->dbg, "Same State 0x%x\n", eError);
   3769             }
   3770             else if (pComponentPrivate->eState == OMX_StateLoaded) {
   3771                 /*add code to wait for resources*/
   3772                 eError = OMX_ErrorNone;
   3773                 pComponentPrivate->bIsPaused = 0;
   3774                 pComponentPrivate->eState = OMX_StateWaitForResources;
   3775                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3776                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   3777                                                        OMX_EventCmdComplete,
   3778                                                        OMX_CommandStateSet,
   3779                                                        pComponentPrivate->eState,
   3780                                                        NULL);
   3781             }
   3782             else {
   3783                 eError = OMX_ErrorIncorrectStateTransition;
   3784                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3785                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   3786                                                        OMX_EventError,
   3787                                                        OMX_ErrorIncorrectStateTransition,
   3788                                                        OMX_TI_ErrorMinor,
   3789                                                        NULL);
   3790                 OMX_PRSTATE4(pComponentPrivate->dbg, "Incorrect State Transition 0x%x\n", eError);
   3791             }
   3792 
   3793             break;
   3794 
   3795         case OMX_StateMax:
   3796             OMX_PRSTATE2(pComponentPrivate->dbg, "Transitioning to OMX_StateMax C 0x%x N 0x%lx\n",pComponentPrivate->eState, nParam1);
   3797             eError = OMX_ErrorIncorrectStateTransition;
   3798             pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3799                                                    pComponentPrivate->pHandle->pApplicationPrivate,
   3800                                                    OMX_EventError,
   3801                                                    OMX_ErrorIncorrectStateTransition,
   3802                                                    OMX_TI_ErrorMinor,
   3803                                                    NULL);
   3804             OMX_PRSTATE4(pComponentPrivate->dbg, "Incorrect State Transition 0x%x\n", eError);
   3805             break;
   3806         default:
   3807             OMX_PRSTATE2(pComponentPrivate->dbg, "Transitioning to default C 0x%x N 0x%lx\n",pComponentPrivate->eState, nParam1);
   3808             eError = OMX_ErrorIncorrectStateTransition;
   3809             pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   3810                                                    pComponentPrivate->pHandle->pApplicationPrivate,
   3811                                                    OMX_EventError,
   3812                                                    OMX_ErrorIncorrectStateTransition,
   3813                                                    OMX_TI_ErrorMinor,
   3814                                                    NULL);
   3815             OMX_PRSTATE4(pComponentPrivate->dbg, "Incorrect State Transition 0x%x\n", eError);
   3816             break;
   3817     } /* End of Switch */
   3818 
   3819 
   3820 
   3821 EXIT:
   3822     OMX_PRINT1(pComponentPrivate->dbg, "---EXITING(0x%x)\n",eError);
   3823     return eError;
   3824 }
   3825 
   3826 /******************************************************************************/
   3827 /**
   3828   *  Sets free output buffers
   3829   **/
   3830 /******************************************************************************/
   3831 
   3832 OMX_ERRORTYPE VIDDEC_HandleFreeOutputBufferFromApp(VIDDEC_COMPONENT_PRIVATE *pComponentPrivate)
   3833 {
   3834     OMX_ERRORTYPE eError = OMX_ErrorNone;
   3835     OMX_BUFFERHEADERTYPE* pBuffHead;
   3836     OMX_U32 size_out_buf;
   3837     int ret;
   3838     LCML_DSP_INTERFACE* pLcmlHandle;
   3839     VIDDEC_BUFFER_PRIVATE* pBufferPrivate = NULL;
   3840     OMX_PRBUFFER1(pComponentPrivate->dbg, "+++ENTERING\n");
   3841     OMX_PRBUFFER1(pComponentPrivate->dbg, "pComponentPrivate 0x%p\n", pComponentPrivate);
   3842     size_out_buf = (OMX_U32)pComponentPrivate->pOutPortDef->nBufferSize;
   3843     pLcmlHandle = (LCML_DSP_INTERFACE*)(pComponentPrivate->pLCML);
   3844     ret = read(pComponentPrivate->free_outBuf_Q[0], &pBuffHead, sizeof(pBuffHead));
   3845 
   3846 
   3847     if (ret == -1) {
   3848         OMX_PRCOMM4(pComponentPrivate->dbg, "Error while reading from the pipe\n");
   3849         eError = OMX_ErrorHardware;
   3850         goto EXIT;
   3851     }
   3852 
   3853     eError = DecrementCount (&(pComponentPrivate->nCountOutputBFromApp), &(pComponentPrivate->mutexOutputBFromApp));
   3854     if (eError != OMX_ErrorNone) {
   3855         return eError;
   3856     }
   3857     OMX_PRBUFFER1(pComponentPrivate->dbg, "pBuffHead 0x%p eExecuteToIdle 0x%x\n", pBuffHead, pComponentPrivate->eExecuteToIdle);
   3858     if(pBuffHead->pOutputPortPrivate != NULL) {
   3859         pBufferPrivate = (VIDDEC_BUFFER_PRIVATE* )pBuffHead->pOutputPortPrivate;
   3860         if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   3861             pComponentPrivate->eLCMLState != VidDec_LCML_State_Destroy &&
   3862             pComponentPrivate->pLCML != NULL) {
   3863 #ifdef KHRONOS_1_1
   3864             if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 ||
   3865                  pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) {
   3866                 MP4VD_GPP_SN_UALGOutputParams* pUalgOutParams = NULL;
   3867                 pUalgOutParams = (MP4VD_GPP_SN_UALGOutputParams *)pBufferPrivate->pUalgParam;
   3868                 if (pComponentPrivate->eMBErrorReport.bEnabled) {
   3869                     pUalgOutParams->lMbErrorBufFlag = 1;
   3870                 }
   3871                 else {
   3872                     pUalgOutParams->lMbErrorBufFlag = 0;
   3873                 }
   3874             }
   3875             if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
   3876                 H264VDEC_UALGOutputParam* pUalgOutParams = NULL;
   3877                 pUalgOutParams = (H264VDEC_UALGOutputParam *)pBufferPrivate->pUalgParam;
   3878                 if (pComponentPrivate->eMBErrorReport.bEnabled) {
   3879                     pUalgOutParams->lMBErrStatFlag = 1;
   3880                 }
   3881                 else {
   3882                     pUalgOutParams->lMBErrStatFlag = 0;
   3883                 }
   3884              }
   3885 #endif
   3886             pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_DSP;
   3887             OMX_PRBUFFER1(pComponentPrivate->dbg, "eBufferOwner 0x%x\n", pBufferPrivate->eBufferOwner);
   3888 
   3889 #ifdef __PERF_INSTRUMENTATION__
   3890                 PERF_SendingFrame(pComponentPrivate->pPERFcomp,
   3891                                   pBuffHead->pBuffer,
   3892                                   pBuffHead->nFilledLen,
   3893                                   PERF_ModuleCommonLayer);
   3894 #endif
   3895 
   3896             OMX_PRDSP1(pComponentPrivate->dbg, "LCML_QueueBuffer(OUTPUT)\n");
   3897             eError = LCML_QueueBuffer(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
   3898                                       EMMCodecOutputBufferMapBufLen,
   3899                                       pBuffHead->pBuffer,
   3900                                       pBuffHead->nAllocLen,
   3901                                       pBuffHead->nFilledLen,
   3902                                       (OMX_U8*)(pBufferPrivate->pUalgParam),
   3903                                       (OMX_S32)pBufferPrivate->nUalgParamSize,
   3904                                       (OMX_U8*)pBuffHead);
   3905             if (eError != OMX_ErrorNone){
   3906                 OMX_PRDSP4(pComponentPrivate->dbg, "LCML_QueueBuffer 0x%x\n", eError);
   3907                 eError = OMX_ErrorHardware;
   3908                 goto EXIT;
   3909             }
   3910         }
   3911         else {
   3912             eError = OMX_ErrorHardware;
   3913             goto EXIT;
   3914         }
   3915     }
   3916     else {
   3917         OMX_PRBUFFER2(pComponentPrivate->dbg, "null element *************n\n");
   3918     }
   3919 
   3920 EXIT:
   3921     OMX_PRBUFFER1(pComponentPrivate->dbg, "---EXITING(0x%x)\n",eError);
   3922     return eError;
   3923 }
   3924 
   3925 #ifdef VIDDEC_ACTIVATEPARSER
   3926 OMX_S32 GET_NUM_BIT_REQ(OMX_U32 num)
   3927 {
   3928     OMX_S32 i;
   3929     for ( i = 31; i >= 0; i--)
   3930     {
   3931         if (num & (0x1 << i) ) break;
   3932     }
   3933     return (i+1);
   3934 }
   3935 #endif
   3936 
   3937 #ifdef VIDDEC_ACTIVATEPARSER
   3938 /*  ==========================================================================*/
   3939 /*  func    VIDDEC_ParseVideo_MPEG2                                        */
   3940 /*                                                                            */
   3941 /*  desc                                                                      */
   3942 /*  ==========================================================================*/
   3943 OMX_ERRORTYPE VIDDEC_ParseVideo_MPEG2( OMX_S32* nWidth, OMX_S32* nHeight, OMX_BUFFERHEADERTYPE *pBuffHead)
   3944 {
   3945     OMX_ERRORTYPE eError = OMX_ErrorUndefined;
   3946     OMX_U32    nTempValue = 0;
   3947     /*OMX_U8*    pTempValue = 0;*/
   3948     /*OMX_U8*    pTempSize = 0;*/
   3949     /*OMX_U32    nProfile = 0;*/
   3950     /*OMX_U32    nLevel = 0;*/
   3951     OMX_U32    nBitPosition = 0;
   3952     OMX_U8*    pHeaderStream = (OMX_U8*)pBuffHead->pBuffer;
   3953     OMX_BOOL   nStartFlag = OMX_FALSE;
   3954     OMX_U32    nInBytePosition = 0;
   3955     OMX_U32    nTotalInBytes = 0;
   3956     OMX_U32    nNalUnitType = 0;
   3957 
   3958     nTotalInBytes = pBuffHead->nFilledLen;
   3959 
   3960     do{
   3961         for (; (!nStartFlag) && (nInBytePosition < nTotalInBytes - 3); ) {
   3962            if (VIDDEC_GetBits(&nBitPosition, 24, pHeaderStream, OMX_FALSE) != 0x000001) {
   3963                 nBitPosition += 8;
   3964                 nInBytePosition++;
   3965            }
   3966            else {
   3967                nStartFlag = OMX_TRUE;
   3968                nBitPosition += 24;
   3969                nInBytePosition += 3;
   3970            }
   3971         }
   3972         if (!nStartFlag) {
   3973             eError = OMX_ErrorStreamCorrupt;
   3974             goto EXIT;
   3975         }
   3976         nNalUnitType = VIDDEC_GetBits(&nBitPosition, 8, pHeaderStream, OMX_TRUE);
   3977         nInBytePosition++;
   3978         if (nNalUnitType != 0xB3) {
   3979             nStartFlag = OMX_FALSE;
   3980         }
   3981     }while (nNalUnitType != 0xB3);
   3982 
   3983     if (nNalUnitType == 0xB3) {
   3984         nTempValue = VIDDEC_GetBits(&nBitPosition, 12, pHeaderStream, OMX_TRUE);
   3985         (*nWidth) = (nTempValue);
   3986         nTempValue = VIDDEC_GetBits(&nBitPosition, 12, pHeaderStream, OMX_TRUE);
   3987         (*nHeight) = (nTempValue);
   3988         eError = OMX_ErrorNone;
   3989     }
   3990 
   3991 EXIT:
   3992     return eError;
   3993 }
   3994 #endif
   3995 
   3996 #ifdef VIDDEC_ACTIVATEPARSER
   3997 /*  ==========================================================================*/
   3998 /*  func    VIDDEC_ParseVideo_WMV9_VC1                                        */
   3999 /*                                                                            */
   4000 /*  desc                                                                      */
   4001 /*  ==========================================================================*/
   4002 OMX_ERRORTYPE VIDDEC_ParseVideo_WMV9_VC1( OMX_S32* nWidth, OMX_S32* nHeight, OMX_BUFFERHEADERTYPE *pBuffHead)
   4003 {
   4004     OMX_ERRORTYPE eError = OMX_ErrorUndefined;
   4005     OMX_U32    nTempValue = 0;
   4006     /*OMX_U8*    pTempValue = 0;*/
   4007     /*OMX_U8*    pTempSize = 0;*/
   4008     OMX_U32    nProfile = 0;
   4009     OMX_U32    nLevel = 0;
   4010     OMX_U32    nBitPosition = 0;
   4011     OMX_U8*    pHeaderStream = (OMX_U8*)pBuffHead->pBuffer;
   4012     OMX_BOOL   nStartFlag = OMX_FALSE;
   4013     OMX_U32    nInBytePosition = 0;
   4014     OMX_U32    nTotalInBytes = 0;
   4015     OMX_U32    nNalUnitType = 0;
   4016 
   4017     nTotalInBytes = pBuffHead->nFilledLen;
   4018 
   4019     do{
   4020         for (; (!nStartFlag) && (nInBytePosition < nTotalInBytes - 3); ) {
   4021            if (VIDDEC_GetBits(&nBitPosition, 24, pHeaderStream, OMX_FALSE) != 0x000001) {
   4022                 nBitPosition += 8;
   4023                 nInBytePosition++;
   4024            }
   4025            else {
   4026                nStartFlag = OMX_TRUE;
   4027                nBitPosition += 24;
   4028                nInBytePosition += 3;
   4029            }
   4030         }
   4031         if (!nStartFlag) {
   4032             eError = OMX_ErrorStreamCorrupt;
   4033             goto EXIT;
   4034         }
   4035         nNalUnitType = VIDDEC_GetBits(&nBitPosition, 8, pHeaderStream, OMX_TRUE);
   4036         nInBytePosition++;
   4037         if (nNalUnitType != 0x0f && nNalUnitType != 0x0e) {
   4038             nStartFlag = OMX_FALSE;
   4039         }
   4040     }while (nNalUnitType != 0x0f && nNalUnitType != 0x0e);
   4041 
   4042     if (nNalUnitType == 0x0f || nNalUnitType == 0x0e) {
   4043         nProfile = VIDDEC_GetBits(&nBitPosition, 2, pHeaderStream, OMX_TRUE);
   4044         nLevel = VIDDEC_GetBits(&nBitPosition, 3, pHeaderStream, OMX_TRUE);
   4045         nTempValue = VIDDEC_GetBits(&nBitPosition, 11, pHeaderStream, OMX_TRUE);
   4046         nTempValue = VIDDEC_GetBits(&nBitPosition, 12, pHeaderStream, OMX_TRUE);
   4047         (*nWidth) = (nTempValue * 2) + 2;
   4048         nTempValue = VIDDEC_GetBits(&nBitPosition, 12, pHeaderStream, OMX_TRUE);
   4049         (*nHeight) = (nTempValue * 2) + 2;
   4050         eError = OMX_ErrorNone;
   4051     }
   4052 
   4053 EXIT:
   4054     return eError;
   4055 }
   4056 #endif
   4057 
   4058 #ifdef VIDDEC_ACTIVATEPARSER
   4059 /*  ==========================================================================*/
   4060 /*  func    VIDDEC_ParseVideo_WMV9_RCV                                        */
   4061 /*                                                                            */
   4062 /*  desc                                                                      */
   4063 /*  ==========================================================================*/
   4064 OMX_ERRORTYPE VIDDEC_ParseVideo_WMV9_RCV( OMX_S32* nWidth, OMX_S32* nHeight, OMX_BUFFERHEADERTYPE *pBuffHead)
   4065 {
   4066     OMX_ERRORTYPE eError = OMX_ErrorUndefined;
   4067     OMX_U32    nTempValue = 0;
   4068     OMX_U8*    pTempValue = 0;
   4069     /*OMX_U8*    pTempSize = 0;*/
   4070     OMX_U32    Profile = 0;
   4071     /*OMX_U32    i = 0;*/
   4072     OMX_U32    nBitPosition = 0;
   4073     OMX_U8*    pHeaderStream = (OMX_U8*)pBuffHead->pBuffer;
   4074 
   4075     if (pBuffHead->nFilledLen >= 20) {
   4076         nTempValue = VIDDEC_GetBits(&nBitPosition, 32, pHeaderStream, OMX_TRUE);
   4077         nTempValue = VIDDEC_GetBits(&nBitPosition, 32, pHeaderStream, OMX_TRUE);
   4078         Profile = VIDDEC_GetBits(&nBitPosition, 4, pHeaderStream, OMX_TRUE);
   4079         nTempValue = VIDDEC_GetBits(&nBitPosition, 28, pHeaderStream, OMX_TRUE);
   4080 
   4081         pTempValue = (OMX_U8*)&nTempValue;
   4082         pTempValue[0] = VIDDEC_GetBits(&nBitPosition, 8, pHeaderStream, OMX_TRUE);
   4083         pTempValue[1] = VIDDEC_GetBits(&nBitPosition, 8, pHeaderStream, OMX_TRUE);
   4084         pTempValue[2] = VIDDEC_GetBits(&nBitPosition, 8, pHeaderStream, OMX_TRUE);
   4085         pTempValue[3] = VIDDEC_GetBits(&nBitPosition, 8, pHeaderStream, OMX_TRUE);
   4086         (*nHeight) = nTempValue;
   4087 
   4088         pTempValue[0] = VIDDEC_GetBits(&nBitPosition, 8, pHeaderStream, OMX_TRUE);
   4089         pTempValue[1] = VIDDEC_GetBits(&nBitPosition, 8, pHeaderStream, OMX_TRUE);
   4090         pTempValue[2] = VIDDEC_GetBits(&nBitPosition, 8, pHeaderStream, OMX_TRUE);
   4091         pTempValue[3] = VIDDEC_GetBits(&nBitPosition, 8, pHeaderStream, OMX_TRUE);
   4092         (*nWidth) = nTempValue;
   4093         eError = OMX_ErrorNone;
   4094     }
   4095     else {
   4096         (*nWidth) = 0;
   4097         (*nHeight) = 0;
   4098         eError = OMX_ErrorUndefined;
   4099     }
   4100 
   4101     return eError;
   4102 }
   4103 #endif
   4104 
   4105 #ifdef VIDDEC_ACTIVATEPARSER
   4106 /*  ==========================================================================*/
   4107 /*  func    VIDDEC_ParseVideo_MPEG4                                             */
   4108 /*                                                                            */
   4109 /*  desc                                                                      */
   4110 /*  ==========================================================================*/
   4111 OMX_ERRORTYPE VIDDEC_ParseVideo_MPEG4( OMX_S32* nWidth, OMX_S32* nHeight, OMX_BUFFERHEADERTYPE *pBuffHead)
   4112 {
   4113     OMX_ERRORTYPE eError = OMX_ErrorUndefined;
   4114     OMX_U32    nSartCode = 0;
   4115     OMX_U32    nBitPosition = 0;
   4116     OMX_BOOL   bHeaderParseCompleted = OMX_FALSE;
   4117     OMX_BOOL   bFillHeaderInfo = OMX_FALSE;
   4118     OMX_U8* pHeaderStream = (OMX_U8*)pBuffHead->pBuffer;
   4119 
   4120     /*OMX_U32 nTotalInBytes = pBuffHead->nFilledLen;*/
   4121     VIDDEC_MPEG4_ParserParam MPEG4_Param;
   4122     VIDDEC_MPEG4UncompressedVideoFormat iOutputFormat = {0};
   4123     VIDDEC_MPEG4_ParserParam* sMPEG4_Param = &MPEG4_Param;
   4124     VIDDEC_VideoPictureHeader sPictHeaderDummy;
   4125     VIDDEC_MPEG4VisualVOLHeader sVolHeaderDummy;
   4126     VIDDEC_VideoPictureHeader* pPictHeaderPtr = &sPictHeaderDummy;
   4127     VIDDEC_MPEG4VisualVOLHeader* sVolHeaderPtr = &sVolHeaderDummy;
   4128 
   4129     pPictHeaderPtr->cnOptional = (OMX_U8*)malloc( sizeof(VIDDEC_MPEG4VisualVOLHeader));
   4130     while (!bHeaderParseCompleted)
   4131     {
   4132         nSartCode = VIDDEC_GetBits(&nBitPosition, 32, pHeaderStream, OMX_TRUE);
   4133         if (nSartCode == 0x1B0)
   4134         {
   4135             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 4);
   4136             pPictHeaderPtr->nProfile = VIDDEC_GetBits(&nBitPosition, 4, pHeaderStream, OMX_TRUE);
   4137             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 4);
   4138             pPictHeaderPtr->nLevel = VIDDEC_GetBits(&nBitPosition, 4, pHeaderStream, OMX_TRUE);
   4139         }
   4140         else if (nSartCode == 0x1B5)
   4141         {
   4142             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4143             sMPEG4_Param->nIsVisualObjectIdentifier = VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);
   4144             if (sMPEG4_Param->nIsVisualObjectIdentifier)
   4145             {
   4146                 OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 7);
   4147                 (void)VIDDEC_GetBits(&nBitPosition, 7, pHeaderStream, OMX_TRUE); /* DISCARD THIS INFO (7 bits)*/
   4148             }
   4149             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 4);
   4150             sMPEG4_Param->nVisualObjectType = VIDDEC_GetBits(&nBitPosition, 4, pHeaderStream, OMX_TRUE);
   4151             if (sMPEG4_Param->nVisualObjectType== 1|| sMPEG4_Param->nVisualObjectType== 2)
   4152             {
   4153                 OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4154                 sMPEG4_Param->nVideoSignalType = VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);
   4155                 if (sMPEG4_Param->nVideoSignalType)
   4156                 {
   4157                     OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 3);
   4158                     sMPEG4_Param->nVideoFormat = VIDDEC_GetBits(&nBitPosition, 3, pHeaderStream, OMX_TRUE);
   4159                     OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4160                     sMPEG4_Param->nVideoRange = VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);
   4161                     OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4162                     sMPEG4_Param->nColorDescription = VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);
   4163                     if (sMPEG4_Param->nColorDescription)
   4164                     {
   4165                         /*Discard this info*/
   4166                         OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 24);
   4167                         (void)VIDDEC_GetBits(&nBitPosition, 24, pHeaderStream, OMX_TRUE);
   4168                     }
   4169                 }
   4170             }
   4171             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4172             sMPEG4_Param->NBitZero = VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);
   4173             while ((nBitPosition%8)!= 0) {
   4174                 OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4175                 (void)VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);/*discard align bits*/
   4176             }
   4177         }
   4178         else if ((nSartCode >= 0x100)&&(nSartCode <= 0x11F))
   4179         {
   4180             /*Do nothing*/
   4181             /*    OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 8);
   4182                   (void)VIDDEC_GetBits(&nBitPosition, 8, pHeaderStream, OMX_TRUE);*/
   4183         }
   4184         else if (nSartCode == 0x1B3) /*GOV*/
   4185         {
   4186             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 20);
   4187             (void)VIDDEC_GetBits(&nBitPosition, 20, pHeaderStream, OMX_TRUE);
   4188             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4189             sMPEG4_Param->NBitZero = VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);
   4190             while ((nBitPosition%8)!= 0){
   4191                 OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4192                 (void)VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);/*discard align bits*/
   4193             }
   4194         }
   4195         else if (nSartCode == 0x1B2) /*user data*/
   4196         {
   4197             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 24);
   4198             while (VIDDEC_GetBits(&nBitPosition, 24, pHeaderStream, OMX_TRUE)!= 0x1)
   4199                 nBitPosition-=16;        /*discard only 8 bits and try againg until*/
   4200                                         /*the next start code is found*/
   4201             nBitPosition -=24;            /* prepare to read the entire start code*/
   4202         /*    OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4203             sMPEG4_Param->NBitZero = VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);
   4204             PRINT("sMPEG4_Param->NBitZero = %d", sMPEG4_Param->NBitZero);
   4205             while ((nBitPosition%8)!= 0) {
   4206                 OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4207                 (void)VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);*//*discard align bits*/
   4208             /*}*/
   4209         }
   4210         else if ((nSartCode >= 0x120)&&(nSartCode <= 0x12F))
   4211         {
   4212             sVolHeaderPtr->nVideoObjectLayerId = nSartCode&0x0000000f;
   4213             sVolHeaderPtr->bShortVideoHeader = 0;
   4214             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4215             pPictHeaderPtr->bIsRandomAccessible = VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);    /*1 bit*/
   4216             sVolHeaderPtr->bRandomAccessibleVOL = pPictHeaderPtr->bIsRandomAccessible;
   4217             if (pPictHeaderPtr->bIsRandomAccessible)
   4218             {
   4219                 /* it seems this never happens*/
   4220             }
   4221             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 8);
   4222             sMPEG4_Param->nVideoObjectTypeIndication = VIDDEC_GetBits(&nBitPosition, 8, pHeaderStream, OMX_TRUE);    /* 8 bits*/
   4223             sVolHeaderPtr->nVideoObjectTypeIndication = sMPEG4_Param->nVideoObjectTypeIndication;
   4224             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4225             sMPEG4_Param->nIsVisualObjectLayerIdentifier = VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);/*1 bit*/
   4226             sVolHeaderPtr->nVideoObjectLayerId = sMPEG4_Param->nIsVisualObjectLayerIdentifier;
   4227             sMPEG4_Param->nLayerVerId = 0;
   4228             if (sMPEG4_Param->nIsVisualObjectLayerIdentifier)
   4229             {
   4230                 OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 4);
   4231                 sMPEG4_Param->nLayerVerId = VIDDEC_GetBits(&nBitPosition, 4, pHeaderStream, OMX_TRUE);                        /*4 bits*/
   4232                 sVolHeaderPtr->nVideoObjectLayerVerId = sMPEG4_Param->nLayerVerId;
   4233                 OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 3);
   4234                 sMPEG4_Param->nLayerPriority = VIDDEC_GetBits(&nBitPosition, 3, pHeaderStream, OMX_TRUE);            /*3 bits*/
   4235                 sVolHeaderPtr->nVideoObjectLayerPriority = sMPEG4_Param->nLayerPriority;
   4236             }
   4237 
   4238             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 4);
   4239             sMPEG4_Param->nAspectRadio = VIDDEC_GetBits(&nBitPosition, 4, pHeaderStream, OMX_TRUE);                    /*4 bits*/
   4240             if (sMPEG4_Param->nAspectRadio == 0xf)
   4241             {
   4242                 OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 8);
   4243                 sMPEG4_Param->nParWidth = VIDDEC_GetBits(&nBitPosition, 8, pHeaderStream, OMX_TRUE);                    /*8 bits*/
   4244                 sVolHeaderPtr->nAspectRatioNum = sMPEG4_Param->nParWidth;
   4245                 OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 8);
   4246                 sMPEG4_Param->nParHeight = VIDDEC_GetBits(&nBitPosition, 8, pHeaderStream, OMX_TRUE);                /*8 bits*/
   4247                 sVolHeaderPtr->nAspectRatioDenom = sMPEG4_Param->nParHeight;
   4248             }
   4249             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4250             sMPEG4_Param->nControlParameters = VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);            /*1 bit*/
   4251             if ( sMPEG4_Param->nControlParameters )
   4252             {
   4253                 OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 2);
   4254                 sMPEG4_Param->nChromaFormat = VIDDEC_GetBits(&nBitPosition, 2, pHeaderStream, OMX_TRUE);                /*2 bits*/
   4255                 OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4256                 sMPEG4_Param->nLowDelay = VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);                    /*1 bit*/
   4257                 OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4258                 sMPEG4_Param->nVbvParameters = VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);            /*1 bit*/
   4259                 if (sMPEG4_Param->nVbvParameters)
   4260                 {
   4261                     OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 15);
   4262                     sMPEG4_Param->nBitRate = VIDDEC_GetBits(&nBitPosition, 15, pHeaderStream, OMX_TRUE)<<15;                /*15 bit*/
   4263                     OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4264                     (void)VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);                        /*1 bit*/
   4265                     OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 15);
   4266                     sMPEG4_Param->nBitRate |= VIDDEC_GetBits(&nBitPosition, 15, pHeaderStream, OMX_TRUE);                    /*15 bit*/
   4267                     sVolHeaderPtr->sVbvParams.nBitRate = sMPEG4_Param->nBitRate;
   4268                     OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4269                     (void)VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);
   4270                     OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 15);
   4271                     sMPEG4_Param->nFirstHalfVbvBufferSize = VIDDEC_GetBits(&nBitPosition, 15, pHeaderStream, OMX_TRUE);
   4272                     OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4273                     (void)VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);
   4274                     OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 3);
   4275                     sMPEG4_Param->nLatterHalfVbvBufferSize = VIDDEC_GetBits(&nBitPosition, 3, pHeaderStream, OMX_TRUE);
   4276                     sVolHeaderPtr->sVbvParams.nVbvBufferSize =
   4277                         (((sMPEG4_Param->nFirstHalfVbvBufferSize) << 3) + sMPEG4_Param->nLatterHalfVbvBufferSize) * 2048;
   4278                     OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 11);
   4279                     sMPEG4_Param->nFirstHalfVbvOccupancy = VIDDEC_GetBits(&nBitPosition, 11, pHeaderStream, OMX_TRUE);
   4280                     OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4281                     (void)VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);
   4282                     OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 15);
   4283                     sMPEG4_Param->nLatterHalfVbvOccupancy = VIDDEC_GetBits(&nBitPosition, 15, pHeaderStream, OMX_TRUE);
   4284                     sVolHeaderPtr->sVbvParams.nVbvOccupancy =
   4285                         (((sMPEG4_Param->nFirstHalfVbvOccupancy) << 15) + sMPEG4_Param->nLatterHalfVbvOccupancy) * 2048;
   4286                     OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4287                     (void)VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);
   4288 
   4289                     /*OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 48);
   4290                     (void)VIDDEC_GetBits(&nBitPosition, 48, pHeaderStream, OMX_TRUE);*/
   4291                 }
   4292                 else
   4293                 {
   4294                     sMPEG4_Param->nBitRate = 0;
   4295                 }
   4296             }
   4297             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 2);
   4298             sMPEG4_Param->nLayerShape = VIDDEC_GetBits(&nBitPosition, 2, pHeaderStream, OMX_TRUE);                    /*2 bits*/
   4299             /*skip one marker_bit*/
   4300             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4301             (void)VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);                                /*1 bit*/
   4302             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 16);
   4303             sMPEG4_Param->nTimeIncrementResolution = VIDDEC_GetBits(&nBitPosition, 16, pHeaderStream, OMX_TRUE);        /*16 bits*/
   4304             sVolHeaderPtr->nVOPTimeIncrementResolution = sMPEG4_Param->nTimeIncrementResolution;
   4305             /*skip one market bit*/
   4306             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4307             (void)VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);                                /*1 bit*/
   4308             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4309             sMPEG4_Param->nFnXedVopRate = VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);                    /*1 bit*/
   4310             sVolHeaderPtr->bnFnXedVopRate = sMPEG4_Param->nFnXedVopRate;
   4311             if (sMPEG4_Param->nFnXedVopRate)
   4312             {
   4313                 sMPEG4_Param->nNum_bits = GET_NUM_BIT_REQ (sMPEG4_Param->nTimeIncrementResolution);
   4314                 OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, sMPEG4_Param->nNum_bits);
   4315                 sVolHeaderPtr->nFnXedVOPTimeIncrement = VIDDEC_GetBits (&nBitPosition, sMPEG4_Param->nNum_bits, pHeaderStream, OMX_TRUE);
   4316             }
   4317             /*skip one market bit*/
   4318             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4319             (void)VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);                                /*1 bit*/
   4320             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 13);
   4321             (*nWidth) = VIDDEC_GetBits(&nBitPosition, 13, pHeaderStream, OMX_TRUE);                        /*13 bits*/
   4322             /*skip one market bit*/
   4323             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4324             (void)VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);                                /*1 bit*/
   4325             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 13);
   4326             (*nHeight) = VIDDEC_GetBits(&nBitPosition, 13, pHeaderStream, OMX_TRUE);                        /*13 bits*/
   4327 
   4328             /*skip one market bit*/
   4329             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4330             (void)VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);                                /*1 bit*/
   4331             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4332             sMPEG4_Param->nInterlaced = VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);                    /*1 bit*/
   4333             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4334             sMPEG4_Param->nObmc = VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);                            /*1 bit*/
   4335             if (sMPEG4_Param->nLayerVerId)
   4336             {
   4337                 OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4338                 sMPEG4_Param->NSpriteNotSupported = VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);        /*1 bit*/
   4339                 if (sMPEG4_Param->NSpriteNotSupported)
   4340                 {
   4341                 }
   4342             }
   4343             else
   4344             {
   4345                 OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 2);
   4346                 sMPEG4_Param->NSpriteNotSupported = VIDDEC_GetBits(&nBitPosition, 2, pHeaderStream, OMX_TRUE);        /*2 bits*/
   4347                 if (sMPEG4_Param->NSpriteNotSupported)
   4348                 {
   4349                 }
   4350             }
   4351             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4352             sMPEG4_Param->nNot8Bit = VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);                        /*1 bits*/
   4353             sMPEG4_Param->nQuantPrecision = 5;
   4354             sMPEG4_Param->nBitsPerPnXel = 8;
   4355             if (sMPEG4_Param->nNot8Bit)
   4356             {
   4357                 OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 4);
   4358                 sMPEG4_Param->nQuantPrecision = VIDDEC_GetBits(&nBitPosition,4, pHeaderStream, OMX_TRUE);                    /* 4 bits*/
   4359                 OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 4);
   4360             sMPEG4_Param->nBitsPerPnXel = VIDDEC_GetBits(&nBitPosition,4, pHeaderStream, OMX_TRUE);                    /* 4 bits*/
   4361             }
   4362             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4363             sMPEG4_Param->nIsInverseQuantMethodFirst = VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);    /*1 bits*/
   4364             if (sMPEG4_Param->nLayerVerId !=1)
   4365             {
   4366                 /*does not support quater sample*/
   4367                 /*kip one market bit*/
   4368                 OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4369                 (void)VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);                            /*1 bit*/
   4370             }
   4371             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4372             sMPEG4_Param->nComplexityEstimationDisable = VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);    /*1 bit*/
   4373             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4374             sMPEG4_Param->nIsResyncMarkerDisabled = VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);        /*1 bit*/
   4375             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4376             sMPEG4_Param->nIsDataPartitioned = VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);            /*1 bit*/
   4377             sVolHeaderPtr->bDataPartitioning = sMPEG4_Param->nIsDataPartitioned;
   4378             if (sMPEG4_Param->nIsDataPartitioned)
   4379             {
   4380                 OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4381                 sMPEG4_Param->nRvlc = VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);                        /*1 bit*/
   4382                 sVolHeaderPtr->bReversibleVLC = sMPEG4_Param->nRvlc;
   4383                 if (sMPEG4_Param->nRvlc)
   4384                 {
   4385                 }
   4386             }
   4387             if (sMPEG4_Param->nLayerVerId !=1)
   4388             {
   4389                 OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 2);
   4390                 (void)VIDDEC_GetBits(&nBitPosition, 2, pHeaderStream, OMX_TRUE);                            /*2 bit*/
   4391             }
   4392             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 1);
   4393             sMPEG4_Param->nScalability = VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);                    /*1 bit*/
   4394             /*pPictHeaderPtr->sSizeInMemory.nWidth              = (*nWidth);
   4395             pPictHeaderPtr->sSizeInMemory.nHeight             = (*nHeight);
   4396             pPictHeaderPtr->sDisplayedRect                    = TRect(TSize((*nWidth),(*nHeight)));*/
   4397             if (iOutputFormat.iYuvFormat.iPattern == 0x00000001)
   4398                 pPictHeaderPtr->nPostDecoderBufferSize    = (*nHeight) * (*nWidth) * 3 / 2;    /*YUV 420 Planar*/
   4399             else if (iOutputFormat.iYuvFormat.iPattern == 0x00000008)
   4400                 pPictHeaderPtr->nPostDecoderBufferSize    = (*nHeight) * (*nWidth) * 2;    /*YUV 422 Interleaved*/
   4401             pPictHeaderPtr->nOptions |= 0x00000008;
   4402             if(bFillHeaderInfo)
   4403             {
   4404                 ;
   4405             }
   4406             bHeaderParseCompleted = OMX_TRUE;
   4407             eError = OMX_ErrorNone;
   4408         }
   4409         else if ( (nSartCode&0xfffffc00) == 0x00008000 )
   4410         {
   4411             sVolHeaderPtr->bShortVideoHeader = 1;
   4412             /* discard 3 bits for split_screen_indicator, document_camera_indicator*/
   4413             /* and full_picture_freeze_release*/
   4414             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 3);
   4415             (void)VIDDEC_GetBits(&nBitPosition, 3, pHeaderStream, OMX_TRUE);
   4416             OMX_PARSER_CHECKLIMIT(nTotalInBytes, nBitPosition, 3);
   4417             sMPEG4_Param->nSourceFormat = VIDDEC_GetBits(&nBitPosition, 3, pHeaderStream, OMX_TRUE);
   4418             if (sMPEG4_Param->nSourceFormat == 0x1)
   4419             {
   4420                 (*nWidth) = 128;
   4421                 (*nHeight) = 96;
   4422             }
   4423             else if (sMPEG4_Param->nSourceFormat == 0x2)
   4424             {
   4425                 (*nWidth) = 176;
   4426                 (*nHeight) = 144;
   4427             }
   4428             else if (sMPEG4_Param->nSourceFormat == 0x3)
   4429             {
   4430                 (*nWidth) = 352;
   4431                 (*nHeight) = 288;
   4432             }
   4433             else if (sMPEG4_Param->nSourceFormat == 0x4)
   4434             {
   4435                 (*nWidth) = 704;
   4436                 (*nHeight) = 576;
   4437             }
   4438             else if (sMPEG4_Param->nSourceFormat == 0x5)
   4439             {
   4440                 (*nWidth) = 1408;
   4441                 (*nHeight) = 1152;
   4442             }
   4443             else if (sMPEG4_Param->nSourceFormat == 0x7)
   4444             {
   4445                 sMPEG4_Param->nUFEP = VIDDEC_GetBits(&nBitPosition, 3, pHeaderStream, OMX_TRUE);
   4446                 if(sMPEG4_Param->nUFEP == 1) {
   4447                     sMPEG4_Param->nSourceFormat = VIDDEC_GetBits(&nBitPosition, 3, pHeaderStream, OMX_TRUE);
   4448                     if (sMPEG4_Param->nSourceFormat == 0x1)
   4449                     {
   4450                         (*nWidth) = 128;
   4451                         (*nHeight) = 96;
   4452                     }
   4453                     else if (sMPEG4_Param->nSourceFormat == 0x2)
   4454                     {
   4455                         (*nWidth) = 176;
   4456                         (*nHeight) = 144;
   4457                     }
   4458                     else if (sMPEG4_Param->nSourceFormat == 0x3)
   4459                     {
   4460                         (*nWidth) = 352;
   4461                         (*nHeight) = 288;
   4462                     }
   4463                     else if (sMPEG4_Param->nSourceFormat == 0x4)
   4464                     {
   4465 
   4466                         (*nWidth) = 704;
   4467                         (*nHeight) = 576;
   4468                     }
   4469                     else if (sMPEG4_Param->nSourceFormat == 0x5)
   4470                     {
   4471                         (*nWidth) = 1408;
   4472                         (*nHeight) = 1152;
   4473                     }
   4474                     else if (sMPEG4_Param->nSourceFormat == 0x6)
   4475                     {
   4476                         (void)VIDDEC_GetBits(&nBitPosition, 24, pHeaderStream, OMX_TRUE);
   4477                         sMPEG4_Param->nCPM = VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);
   4478                         if(sMPEG4_Param->nCPM)
   4479                             (void)VIDDEC_GetBits(&nBitPosition, 2, pHeaderStream, OMX_TRUE);
   4480 
   4481                         (void)VIDDEC_GetBits(&nBitPosition, 4, pHeaderStream, OMX_TRUE);
   4482 
   4483                         sMPEG4_Param->nPWI = VIDDEC_GetBits(&nBitPosition, 9, pHeaderStream, OMX_TRUE);
   4484                         (*nWidth) = (sMPEG4_Param->nPWI + 1)*4;
   4485 
   4486                         (void)VIDDEC_GetBits(&nBitPosition, 1, pHeaderStream, OMX_TRUE);
   4487 
   4488                         sMPEG4_Param->nPHI = VIDDEC_GetBits(&nBitPosition, 9, pHeaderStream, OMX_TRUE);
   4489                         (*nHeight) = sMPEG4_Param->nPHI*4;
   4490 
   4491                     }
   4492                     else if (sMPEG4_Param->nSourceFormat == 0x7)
   4493                     {
   4494                         sMPEG4_Param->nSourceFormat = VIDDEC_GetBits(&nBitPosition, 3, pHeaderStream, OMX_TRUE);
   4495                         (*nWidth) = 1408;
   4496                         (*nHeight) = 1152;
   4497                     }
   4498                     else
   4499                     {
   4500                         eError = OMX_ErrorUnsupportedSetting;
   4501                         goto EXIT;
   4502                     }
   4503                 }
   4504             }
   4505             else
   4506             {
   4507                 eError = OMX_ErrorUnsupportedSetting;
   4508                 goto EXIT;
   4509             }
   4510             bHeaderParseCompleted = OMX_TRUE;
   4511             eError = OMX_ErrorNone;
   4512         }
   4513         else
   4514         {
   4515             eError = OMX_ErrorUnsupportedSetting;
   4516             goto EXIT;
   4517         }
   4518     }
   4519 EXIT:
   4520     if(pPictHeaderPtr->cnOptional != NULL)
   4521     {
   4522             free( pPictHeaderPtr->cnOptional);
   4523             pPictHeaderPtr->cnOptional = NULL;
   4524     }
   4525     return eError;
   4526 }
   4527 #endif
   4528 
   4529 #ifdef VIDDEC_ACTIVATEPARSER
   4530 /*  ==========================================================================*/
   4531 /*  func    VIDDEC_ScanConfigBufferAVC                                            */
   4532 /*                                                                            */
   4533 /*  desc    Use to scan buffer for certain patter. Used to know if ConfigBuffers are together                             */
   4534 /*  ==========================================================================*/
   4535 static OMX_U32 VIDDEC_ScanConfigBufferAVC(OMX_BUFFERHEADERTYPE* pBuffHead,  OMX_U32 pattern){
   4536     OMX_U32 nBitPosition = 0;
   4537     OMX_U32 nInBytePosition = 0;
   4538     OMX_U32 nPatternCounter = 0;
   4539     OMX_U32 nTotalInBytes = pBuffHead->nFilledLen;
   4540     OMX_U8* nBitStream = (OMX_U8*)pBuffHead->pBuffer;
   4541 
   4542     while (nInBytePosition < nTotalInBytes - 3){
   4543          if (VIDDEC_GetBits(&nBitPosition, 24, nBitStream, OMX_FALSE) != pattern) {
   4544               nBitPosition += 8;
   4545               nInBytePosition++;
   4546          }
   4547          else {
   4548              /*Pattern found; add count*/
   4549              nPatternCounter++;
   4550              nBitPosition += 24;
   4551              nInBytePosition += 3;
   4552          }
   4553     }
   4554     return nPatternCounter;
   4555 }
   4556 
   4557 /*  ==========================================================================*/
   4558 /*  func    VIDDEC_ParseVideo_H264                                             */
   4559 /*                                                                            */
   4560 /*  desc                                                                      */
   4561 /*  ==========================================================================*/
   4562 OMX_ERRORTYPE VIDDEC_ParseVideo_H264(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate,
   4563                                      OMX_BUFFERHEADERTYPE* pBuffHead,OMX_S32* nWidth,
   4564                                      OMX_S32* nHeight, OMX_S32* nCropWidth,
   4565                                      OMX_S32* nCropHeight, OMX_U32 nType)
   4566 {
   4567     OMX_ERRORTYPE eError = OMX_ErrorBadParameter;
   4568     OMX_S32 i = 0;
   4569     VIDDEC_AVC_ParserParam* sParserParam = NULL;
   4570     /*OMX_S32 nRetVal = 0;*/
   4571     OMX_BOOL nStartFlag = OMX_FALSE;
   4572     OMX_U32 nBitPosition = 0;
   4573     OMX_U32 nRbspPosition = 0;
   4574     OMX_U32 nTotalInBytes = 0;
   4575     OMX_U32 nInBytePosition = 0;
   4576     OMX_U32 nInPositionTemp = 0;
   4577     OMX_U32 nNumOfBytesInRbsp = 0;
   4578     OMX_S32 nNumBytesInNALunit = 0;
   4579     OMX_U8* nBitStream = 0;
   4580     OMX_U32 nNalUnitType = 0;
   4581     OMX_U8* nRbspByte = NULL;
   4582 
   4583     OMX_U8 *pDataBuf;
   4584 
   4585     /* counter used for fragmentation of Config Buffer Code */
   4586    static OMX_U32 nConfigBufferCounter;
   4587 
   4588     nTotalInBytes = pBuffHead->nFilledLen;
   4589     nBitStream = (OMX_U8*)pBuffHead->pBuffer;/* + (OMX_U8*)pBuffHead->nOffset;*/
   4590     nRbspByte = (OMX_U8*)malloc(nTotalInBytes);
   4591     if (!nRbspByte) {
   4592         eError =  OMX_ErrorInsufficientResources;
   4593         goto EXIT;
   4594     }
   4595     memset(nRbspByte, 0x0, nTotalInBytes);
   4596     sParserParam = (VIDDEC_AVC_ParserParam *)malloc(sizeof(VIDDEC_AVC_ParserParam));
   4597     if (!sParserParam) {
   4598         eError =  OMX_ErrorInsufficientResources;
   4599         goto EXIT;
   4600     }
   4601 
   4602     if (nType == 0) {
   4603         /* Start of Handle fragmentation of Config Buffer  Code*/
   4604         /*Scan for 2 "0x000001", requiered on buffer to parser properly*/
   4605         nConfigBufferCounter += VIDDEC_ScanConfigBufferAVC(pBuffHead, 0x000001);
   4606         if(nConfigBufferCounter < 2){ /*If less of 2 we need to store the data internally to later assembly the complete ConfigBuffer*/
   4607             /*Set flag to False, the Config Buffer is not complete */
   4608             OMX_PRINT2(pComponentPrivate->dbg, "Setting bConfigBufferCompleteAVC = OMX_FALSE");
   4609             pComponentPrivate->bConfigBufferCompleteAVC = OMX_FALSE;
   4610             /* Malloc Buffer if is not created yet, use Port  buffer size*/
   4611             if(pComponentPrivate->pInternalConfigBufferAVC == NULL){
   4612                 pComponentPrivate->pInternalConfigBufferAVC = malloc(pComponentPrivate->pInPortDef->nBufferSize);
   4613                 if(pComponentPrivate->pInternalConfigBufferAVC == NULL){
   4614                     eError = OMX_ErrorInsufficientResources;
   4615                     goto EXIT;
   4616                 }
   4617             }
   4618             /* Check if memcpy is safe*/
   4619             if(pComponentPrivate->pInPortDef->nBufferSize >= pComponentPrivate->nInternalConfigBufferFilledAVC + pBuffHead->nFilledLen){
   4620                 /*Append current buffer data to Internal Config Buffer */
   4621                 if(memcpy((OMX_U8*)(pComponentPrivate->pInternalConfigBufferAVC + pComponentPrivate->nInternalConfigBufferFilledAVC),
   4622                         pBuffHead->pBuffer,
   4623                         pBuffHead->nFilledLen) == NULL) {
   4624                           eError = OMX_ErrorInsufficientResources;
   4625                           goto EXIT;
   4626                 }
   4627             }
   4628             else{
   4629                 eError =OMX_ErrorInsufficientResources;
   4630                 goto EXIT;
   4631             }
   4632             /*Update Filled length of Internal Buffer*/
   4633             pComponentPrivate->nInternalConfigBufferFilledAVC += pBuffHead->nFilledLen;
   4634             /* Exit with out error*/
   4635             eError = OMX_ErrorNone;
   4636             goto EXIT;
   4637         }
   4638         else{  /* We have all the requiered data*/
   4639              OMX_PRINT2(pComponentPrivate->dbg, "Setting bConfigBufferCompleteAVC = OMX_TRUE");
   4640              pComponentPrivate->bConfigBufferCompleteAVC = OMX_TRUE;
   4641              /* If we have already Config data of previous buffer, we assembly the final ConfigBuffer*/
   4642              if(pComponentPrivate->pInternalConfigBufferAVC != NULL){
   4643                   /*Check if memcpy is safe*/
   4644                  if(pComponentPrivate->pInPortDef->nBufferSize >=
   4645                      pComponentPrivate->nInternalConfigBufferFilledAVC + pBuffHead->nFilledLen){
   4646                      /*The current data of the Buffer has to be placed at the end of buffer*/
   4647                      if(memcpy((OMX_U8*)(pBuffHead->pBuffer + pComponentPrivate->nInternalConfigBufferFilledAVC),
   4648                          pBuffHead->pBuffer,
   4649                          pBuffHead->nFilledLen) == NULL){
   4650                            eError = OMX_ErrorInsufficientResources;
   4651                            goto EXIT;
   4652                     }
   4653                      /*The data internally stored has to be put at the begining of the buffer*/
   4654                      if(memcpy(pBuffHead->pBuffer,
   4655                          pComponentPrivate->pInternalConfigBufferAVC,
   4656                          pComponentPrivate->nInternalConfigBufferFilledAVC) == NULL){
   4657                            eError = OMX_ErrorInsufficientResources;
   4658                            goto EXIT;
   4659                      }
   4660                 }
   4661                 else{
   4662                     eError = OMX_ErrorInsufficientResources;
   4663                     goto EXIT;
   4664                  }
   4665 
   4666                  /*Update filled length of current buffer */
   4667                  pBuffHead->nFilledLen = pComponentPrivate->nInternalConfigBufferFilledAVC + pBuffHead->nFilledLen;
   4668                  /*Free Internal Buffer used to temporarly hold the data*/
   4669                  if (pComponentPrivate->pInternalConfigBufferAVC != NULL)
   4670                      free(pComponentPrivate->pInternalConfigBufferAVC);
   4671                  /* Reset Internal Variables*/
   4672                  pComponentPrivate->pInternalConfigBufferAVC = NULL;
   4673                  pComponentPrivate->nInternalConfigBufferFilledAVC = 0;
   4674                  nConfigBufferCounter = 0;
   4675                  /* Update Buffer Variables before parsing */
   4676                  nTotalInBytes = pBuffHead->nFilledLen;
   4677                  if ( nRbspByte != NULL )
   4678                      free(nRbspByte);
   4679                  nRbspByte = (OMX_U8*)malloc(nTotalInBytes);
   4680                  if(nRbspByte == NULL){
   4681                      eError = OMX_ErrorInsufficientResources;
   4682                      goto EXIT;
   4683                  }
   4684                  memset(nRbspByte, 0x0, nTotalInBytes);
   4685                  /*Buffer ready to be parse =) */
   4686             }
   4687         }
   4688          /* End of Handle fragmentation Config Buffer Code*/
   4689 
   4690         do{
   4691             for (; (!nStartFlag) && (nInBytePosition < nTotalInBytes - 3); )
   4692             {
   4693                if (VIDDEC_GetBits(&nBitPosition, 24, nBitStream, OMX_FALSE) != 0x000001)
   4694                {
   4695                     nBitPosition += 8;
   4696                     nInBytePosition++;
   4697                }
   4698                else
   4699                {
   4700                    /*Start Code found*/
   4701                    nStartFlag = OMX_TRUE;
   4702                    nBitPosition += 24;
   4703                    nInBytePosition += 3;
   4704                }
   4705             }
   4706             nStartFlag = OMX_FALSE;
   4707             /* offset to NumBytesInNALunit*/
   4708             nNumBytesInNALunit = nInBytePosition;
   4709             sParserParam->nBitPosTemp = nBitPosition;
   4710               for (;(!nStartFlag)&&(nNumBytesInNALunit < nTotalInBytes-3); )
   4711             {
   4712                 if (VIDDEC_GetBits(&sParserParam->nBitPosTemp, 24, nBitStream, OMX_FALSE) != 0x000001)
   4713                 /*find start code*/
   4714                 {
   4715                     sParserParam->nBitPosTemp += 8;
   4716                     nNumBytesInNALunit++;
   4717                 }
   4718                 else
   4719                 {
   4720                    /*Start Code found*/
   4721                     nStartFlag = OMX_TRUE;
   4722                     sParserParam->nBitPosTemp += 24;
   4723                     nNumBytesInNALunit += 3;
   4724                 }
   4725             }
   4726 
   4727             if (!nStartFlag)
   4728             {
   4729                 eError = OMX_ErrorStreamCorrupt;
   4730                 goto EXIT;
   4731             }
   4732             /* forbidden_zero_bit */
   4733             sParserParam->nForbiddenZeroBit = VIDDEC_GetBits(&nBitPosition, 1, nBitStream, OMX_TRUE);
   4734             /* nal_ref_idc */
   4735             sParserParam->nNalRefIdc = VIDDEC_GetBits(&nBitPosition, 2, nBitStream, OMX_TRUE);
   4736             /* nal_unit_type */
   4737             nNalUnitType = VIDDEC_GetBits(&nBitPosition, 5, nBitStream, OMX_TRUE);
   4738             nInBytePosition++;
   4739 
   4740             /* This code is to ensure we will get parameter info */
   4741             if (nNalUnitType != 7)
   4742             {
   4743                 OMX_PRINT2(pComponentPrivate->dbg, "nal_unit_type does not specify parameter information need to look for next startcode\n");
   4744                 nStartFlag = OMX_FALSE;
   4745             }
   4746         }while (nNalUnitType != 7);
   4747     }
   4748     else {
   4749          pDataBuf = (OMX_U8*)nBitStream;
   4750          do {
   4751         /* iOMXComponentUsesNALStartCodes is set to OMX_FALSE on opencore */
   4752 #ifndef ANDROID
   4753             if (pComponentPrivate->H264BitStreamFormat == 1) {
   4754                 if (pComponentPrivate->bIsNALBigEndian) {
   4755                     nNumBytesInNALunit = (OMX_U32)pDataBuf[nInBytePosition];
   4756                 }
   4757                 else {
   4758                     nNumBytesInNALunit = (OMX_U32)pDataBuf[nInBytePosition];
   4759                 }
   4760             }
   4761             else if (pComponentPrivate->H264BitStreamFormat == 2) {
   4762                 if (pComponentPrivate>bIsNALBigEndian) {
   4763                     nNumBytesInNALunit = (OMX_U32)pDataBuf[nInBytePosition] << 8 | pDataBuf[nInBytePosition+1];
   4764                 }
   4765                 else {
   4766                     nNumBytesInNALunit = (OMX_U32)pDataBuf[nInBytePosition] << 0 | pDataBuf[nInBytePosition+1] << 8 ;
   4767                 }
   4768             }
   4769             else if (pComponentPrivate->H264BitStreamFormat == 4){
   4770                 if (pComponentPrivate->bIsNALBigEndian) {
   4771                     nNumBytesInNALunit = (OMX_U32)pDataBuf[nInBytePosition]<<24 | pDataBuf[nInBytePosition+1] << 16 | pDataBuf[nInBytePosition+2] << 8 | pDataBuf[nInBytePosition+3];
   4772                 }
   4773                 else {
   4774                     nNumBytesInNALunit = (OMX_U32)pDataBuf[nInBytePosition]<<0 | pDataBuf[nInBytePosition+1] << 8 | pDataBuf[nInBytePosition+2] << 16 | pDataBuf[nInBytePosition+3]<<24;
   4775                 }
   4776             }
   4777             else {
   4778                 eError = OMX_ErrorBadParameter;
   4779                 goto EXIT;
   4780             }
   4781 #endif
   4782             nBitPosition = (nInPositionTemp + nType) * 8;
   4783             nInBytePosition = nInPositionTemp + nType;
   4784             nInPositionTemp += nNumBytesInNALunit + nType;
   4785             if (nInBytePosition > nTotalInBytes) {
   4786                 eError = OMX_ErrorBadParameter;
   4787                 goto EXIT;
   4788             }
   4789             /* forbidden_zero_bit */
   4790             sParserParam->nForbiddenZeroBit = VIDDEC_GetBits(&nBitPosition, 1, nBitStream, OMX_TRUE);
   4791             /* nal_ref_idc */
   4792             sParserParam->nNalRefIdc = VIDDEC_GetBits(&nBitPosition, 2, nBitStream, OMX_TRUE);
   4793             /* nal_unit_type */
   4794             nNalUnitType = VIDDEC_GetBits(&nBitPosition, 5, nBitStream, OMX_TRUE);
   4795             nInBytePosition++;
   4796             /* This code is to ensure we will get parameter info */
   4797             if (nNalUnitType != 7) {
   4798                 /*nBitPosition += (nNumBytesInNALunit - 1) * 8;
   4799                 nInBytePosition += (nNumBytesInNALunit - 1);*/
   4800                 nBitPosition = (nInPositionTemp) * 8;
   4801                 nInBytePosition = (nInPositionTemp);
   4802 
   4803             }
   4804         } while (nNalUnitType != 7);
   4805         nNumBytesInNALunit += 8 + nInBytePosition;/*sum to keep the code flow*/
   4806                                 /*the buffer must had enough space to enter this number*/
   4807     }
   4808     for (i=0; nInBytePosition < nNumBytesInNALunit - 3; )
   4809     {
   4810 
   4811         if (((nInBytePosition + 2) < nNumBytesInNALunit - 3)&&
   4812             (VIDDEC_GetBits(&nBitPosition, 24, nBitStream, OMX_FALSE) == 0x000003))
   4813         {
   4814             OMX_PRINT2(pComponentPrivate->dbg, "discard emulation prev byte\n");
   4815             nRbspByte[i++] = nBitStream[nInBytePosition++];
   4816             nRbspByte[i++] = nBitStream[nInBytePosition++];
   4817             nNumOfBytesInRbsp += 2;
   4818             /* discard emulation prev byte */
   4819             nInBytePosition++;
   4820             nBitPosition += 24;
   4821         }
   4822         else
   4823         {
   4824             nRbspByte[i++] = nBitStream[nInBytePosition++];
   4825             nNumOfBytesInRbsp++;
   4826             nBitPosition += 8;
   4827         }
   4828     }
   4829 
   4830 
   4831     /*Parse RBSP sequence*/
   4832     /*///////////////////*/
   4833     /*  profile_idc u(8) */
   4834     sParserParam->nProfileIdc = VIDDEC_GetBits(&nRbspPosition, 8, nRbspByte, OMX_TRUE);
   4835     /* constraint_set0_flag u(1)*/
   4836     sParserParam->nConstraintSet0Flag = VIDDEC_GetBits(&nRbspPosition, 1, nRbspByte, OMX_TRUE);
   4837     /* constraint_set1_flag u(1)*/
   4838     sParserParam->nConstraintSet1Flag = VIDDEC_GetBits(&nRbspPosition, 1, nRbspByte, OMX_TRUE);
   4839     /* constraint_set2_flag u(1)*/
   4840     sParserParam->nConstraintSet2Flag = VIDDEC_GetBits(&nRbspPosition, 1, nRbspByte, OMX_TRUE);
   4841     /* reserved_zero_5bits u(5)*/
   4842     sParserParam->nReservedZero5bits = VIDDEC_GetBits(&nRbspPosition, 5, nRbspByte, OMX_TRUE);
   4843     /* level_idc*/
   4844     sParserParam->nLevelIdc = VIDDEC_GetBits(&nRbspPosition, 8, nRbspByte, OMX_TRUE);
   4845     sParserParam->nSeqParameterSetId = VIDDEC_UVLC_dec(&nRbspPosition, nRbspByte);
   4846     sParserParam->nLog2MaxFrameNumMinus4 = VIDDEC_UVLC_dec(&nRbspPosition, nRbspByte);
   4847     sParserParam->nPicOrderCntType = VIDDEC_UVLC_dec(&nRbspPosition, nRbspByte);
   4848 
   4849     if ( sParserParam->nPicOrderCntType == 0 )
   4850     {
   4851         sParserParam->nLog2MaxPicOrderCntLsbMinus4 = VIDDEC_UVLC_dec(&nRbspPosition, nRbspByte);
   4852     }
   4853     else if( sParserParam->nPicOrderCntType == 1 )
   4854     {
   4855         /* delta_pic_order_always_zero_flag*/
   4856         VIDDEC_GetBits(&nRbspPosition, 1, nRbspByte, OMX_TRUE);
   4857         sParserParam->nOffsetForNonRefPic = VIDDEC_UVLC_dec(&nRbspPosition, nRbspByte);
   4858         if (sParserParam->nOffsetForNonRefPic > 1)
   4859               sParserParam->nOffsetForNonRefPic = sParserParam->nOffsetForNonRefPic & 0x1 ?
   4860                                                 sParserParam->nOffsetForNonRefPic >> 1 :
   4861                                               -(sParserParam->nOffsetForNonRefPic >> 1);
   4862         sParserParam->nOffsetForTopToBottomField = VIDDEC_UVLC_dec(&nRbspPosition, nRbspByte);
   4863         sParserParam->nNumRefFramesInPicOrderCntCycle = VIDDEC_UVLC_dec(&nRbspPosition, nRbspByte);
   4864         for(i = 0; i < sParserParam->nNumRefFramesInPicOrderCntCycle; i++ )
   4865             VIDDEC_UVLC_dec(&nRbspPosition, nRbspByte); /*offset_for_ref_frame[i]*/
   4866     }
   4867 
   4868     sParserParam->nNumRefFrames = VIDDEC_UVLC_dec(&nRbspPosition, nRbspByte);
   4869     sParserParam->nGapsInFrameNumValueAllowedFlag = VIDDEC_GetBits(&nRbspPosition, 1, nRbspByte, OMX_TRUE);
   4870     sParserParam->nPicWidthInMbsMinus1 = VIDDEC_UVLC_dec(&nRbspPosition, nRbspByte);
   4871     (*nWidth) = (sParserParam->nPicWidthInMbsMinus1 + 1) * 16;
   4872     sParserParam->nPicHeightInMapUnitsMinus1 = VIDDEC_UVLC_dec(&nRbspPosition, nRbspByte);
   4873     (*nHeight) = (sParserParam->nPicHeightInMapUnitsMinus1 + 1) * 16;
   4874     /* Checking for cropping in picture saze */
   4875     /* getting frame_mbs_only_flag */
   4876     sParserParam->nFrameMbsOnlyFlag = VIDDEC_GetBits(&nRbspPosition, 1, nRbspByte, OMX_TRUE);
   4877     if (!sParserParam->nFrameMbsOnlyFlag)
   4878     {
   4879         sParserParam->nMBAdaptiveFrameFieldFlag = VIDDEC_GetBits(&nRbspPosition, 1, nRbspByte, OMX_TRUE);
   4880     }
   4881     /*getting direct_8x8_inference_flag and frame_cropping_flag*/
   4882     sParserParam->nDirect8x8InferenceFlag = VIDDEC_GetBits(&nRbspPosition, 1, nRbspByte, OMX_TRUE);
   4883     sParserParam->nFrameCroppingFlag = VIDDEC_GetBits(&nRbspPosition, 1, nRbspByte, OMX_TRUE);
   4884     /*getting the crop values if exist*/
   4885     if (sParserParam->nFrameCroppingFlag)
   4886     {
   4887         sParserParam->nFrameCropLeftOffset = VIDDEC_UVLC_dec(&nRbspPosition, nRbspByte);
   4888         sParserParam->nFrameCropRightOffset = VIDDEC_UVLC_dec(&nRbspPosition, nRbspByte);
   4889         sParserParam->nFrameCropTopOffset = VIDDEC_UVLC_dec(&nRbspPosition, nRbspByte);
   4890         sParserParam->nFrameCropBottomOffset = VIDDEC_UVLC_dec(&nRbspPosition, nRbspByte);
   4891         /* Update framesize taking into account the cropping values */
   4892         (*nCropWidth) = (2 * sParserParam->nFrameCropLeftOffset + 2 * sParserParam->nFrameCropRightOffset);
   4893         (*nCropHeight) = (2 * sParserParam->nFrameCropTopOffset + 2 * sParserParam->nFrameCropBottomOffset);
   4894     }
   4895     eError = OMX_ErrorNone;
   4896 
   4897 EXIT:
   4898     if (nRbspByte)
   4899         free( nRbspByte);
   4900     if (sParserParam)
   4901         free( sParserParam);
   4902     return eError;
   4903 }
   4904 #endif
   4905 
   4906 #ifdef VIDDEC_ACTIVATEPARSER
   4907 /*  =========================================================================*/
   4908 /*  func    GetBits                                                          */
   4909 /*                                                                           */
   4910 /*  desc    Gets aBits number of bits from position aPosition of one buffer  */
   4911 /*            and returns the value in a TUint value.                        */
   4912 /*  =========================================================================*/
   4913 OMX_U32 VIDDEC_GetBits(OMX_U32* nPosition, OMX_U8 nBits, OMX_U8* pBuffer, OMX_BOOL bIcreasePosition)
   4914 {
   4915     OMX_U32 nOutput;
   4916     OMX_U32 nNumBitsRead = 0;
   4917     OMX_U32 nBytePosition = 0;
   4918     OMX_U8  nBitPosition =  0;
   4919     nBytePosition = *nPosition / 8;
   4920     nBitPosition =  *nPosition % 8;
   4921 
   4922     if (bIcreasePosition)
   4923         *nPosition += nBits;
   4924     nOutput = ((OMX_U32)pBuffer[nBytePosition] << (24+nBitPosition) );
   4925     nNumBitsRead = nNumBitsRead + (8 - nBitPosition);
   4926     if (nNumBitsRead < nBits)
   4927     {
   4928         nOutput = nOutput | ( pBuffer[nBytePosition + 1] << (16+nBitPosition));
   4929         nNumBitsRead = nNumBitsRead + 8;
   4930     }
   4931     if (nNumBitsRead < nBits)
   4932     {
   4933         nOutput = nOutput | ( pBuffer[nBytePosition + 2] << (8+nBitPosition));
   4934         nNumBitsRead = nNumBitsRead + 8;
   4935     }
   4936     if (nNumBitsRead < nBits)
   4937     {
   4938         nOutput = nOutput | ( pBuffer[nBytePosition + 3] << (nBitPosition));
   4939         nNumBitsRead = nNumBitsRead + 8;
   4940     }
   4941     nOutput = nOutput >> (32 - nBits) ;
   4942     return nOutput;
   4943 }
   4944 
   4945 
   4946 OMX_S32 VIDDEC_UVLC_dec(OMX_U32 *nPosition, OMX_U8* pBuffer)
   4947 {
   4948 
   4949     OMX_U32 nBytePosition = (*nPosition) / 8;
   4950     OMX_U8 cBitPosition =  (*nPosition) % 8;
   4951     OMX_U32 nLen = 1;
   4952     OMX_U32 nCtrBit = 0;
   4953     OMX_U32 nVal = 1;
   4954     OMX_S32 nInfoBit=0;
   4955 
   4956     nCtrBit = pBuffer[nBytePosition] & (0x1 << (7-cBitPosition));
   4957     while (nCtrBit==0)
   4958     {
   4959         nLen++;
   4960         cBitPosition++;
   4961         (*nPosition)++;
   4962         if (!(cBitPosition%8))
   4963         {
   4964             cBitPosition=0;
   4965             nBytePosition++;
   4966         }
   4967         nCtrBit = pBuffer[nBytePosition] & (0x1<<(7-cBitPosition));
   4968     }
   4969     for(nInfoBit=0; (nInfoBit<(nLen-1)); nInfoBit++)
   4970     {
   4971         cBitPosition++;
   4972         (*nPosition)++;
   4973 
   4974         if (!(cBitPosition%8))
   4975         {
   4976             cBitPosition=0;
   4977             nBytePosition++;
   4978         }
   4979         nVal=(nVal << 1);
   4980         if(pBuffer[nBytePosition] & (0x01 << (7 - cBitPosition)))
   4981             nVal |= 1;
   4982     }
   4983     (*nPosition)++;
   4984     nVal -= 1;
   4985     return nVal;
   4986 }
   4987 #endif
   4988 
   4989 #ifdef VIDDEC_ACTIVATEPARSER
   4990 /* ========================================================================== */
   4991 /**
   4992   *  Parse the input buffer to get the correct width and height
   4993   **/
   4994 /* ========================================================================== */
   4995 OMX_ERRORTYPE VIDDEC_ParseHeader(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate, OMX_BUFFERHEADERTYPE *pBuffHead)
   4996 {
   4997     OMX_ERRORTYPE eError = OMX_ErrorNone;
   4998     OMX_S32 nWidth = 0;
   4999     OMX_S32 nHeight = 0;
   5000     OMX_S32 nPadWidth = 0;
   5001     OMX_S32 nPadHeight = 0;
   5002     OMX_S32 nCropWidth = 0;
   5003     OMX_S32 nCropHeight = 0;
   5004     OMX_S32 nCroppedWidth = 0;
   5005     OMX_S32 nCroppedHeight = 0;
   5006 
   5007     OMX_U32 nOutMinBufferSize = 0;
   5008     OMX_BOOL bInPortSettingsChanged = OMX_FALSE;
   5009     OMX_BOOL bOutPortSettingsChanged = OMX_FALSE;
   5010     OMX_U32 nOutPortActualAllocLen = 0;
   5011 
   5012     OMX_PRINT1(pComponentPrivate->dbg, "IN\n");
   5013     if(!pComponentPrivate) {
   5014         goto EXIT;
   5015     }
   5016 
   5017     bInPortSettingsChanged = pComponentPrivate->bInPortSettingsChanged;
   5018     bOutPortSettingsChanged = pComponentPrivate->bOutPortSettingsChanged;
   5019     /*Get output port allocated buffer size*/
   5020     nOutPortActualAllocLen =  pComponentPrivate->pCompPort[VIDDEC_OUTPUT_PORT]->pBufferPrivate[0]->pBufferHdr->nAllocLen;
   5021 
   5022     OMX_PRINT1(pComponentPrivate->dbg, "pBuffHead %x, Original resolution IN %dx%d : OUT %dx%d\n",
   5023             (unsigned int)pBuffHead,
   5024             (unsigned int)pComponentPrivate->pInPortDef->format.video.nFrameWidth,
   5025             (unsigned int)pComponentPrivate->pInPortDef->format.video.nFrameHeight,
   5026             (unsigned int)pComponentPrivate->pOutPortDef->format.video.nFrameWidth,
   5027             (unsigned int)pComponentPrivate->pOutPortDef->format.video.nFrameHeight);
   5028 
   5029 
   5030         if( pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
   5031             eError = VIDDEC_ParseVideo_H264( pComponentPrivate, pBuffHead, &nWidth, &nHeight,
   5032                 &nCropWidth, &nCropHeight, pComponentPrivate->H264BitStreamFormat);
   5033 
   5034             /* Start Code to handle fragmentation of ConfigBuffer for AVC*/
   5035             if(pComponentPrivate->bConfigBufferCompleteAVC == OMX_FALSE &&
   5036                 pComponentPrivate->ProcessMode == 0 && pComponentPrivate->H264BitStreamFormat == 0){
   5037                 /* We have received some part of the config Buffer.
   5038                  * Send EmptyThisBuffer of the buffer we have just received to Client
   5039                  */
   5040                 VIDDEC_EmptyBufferDone(pComponentPrivate, pBuffHead);
   5041                 /* Exit with out error to avoid sending again EmptyBufferDone in upper function*/
   5042                 eError = OMX_ErrorNone;
   5043                 goto EXIT;
   5044             }
   5045             /*End Code to handle fragmentation of ConfigBuffer for AVC*/
   5046         }
   5047         else if( pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4  ||
   5048                 pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) {
   5049             VIDDEC_ParseVideo_MPEG4( &nWidth, &nHeight, pBuffHead);
   5050             /* Work around force reconfiguration */
   5051             bOutPortSettingsChanged = OMX_TRUE;
   5052         }
   5053         else if( pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG2) {
   5054             VIDDEC_ParseVideo_MPEG2( &nWidth, &nHeight, pBuffHead);
   5055         }
   5056         else if( pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV) {
   5057             if (pComponentPrivate->nWMVFileType == VIDDEC_WMV_ELEMSTREAM) {
   5058                 eError = VIDDEC_ParseVideo_WMV9_VC1( &nWidth, &nHeight, pBuffHead);
   5059             }
   5060             else {
   5061                 eError = VIDDEC_ParseVideo_WMV9_RCV( &nWidth, &nHeight, pBuffHead);
   5062             }
   5063         }
   5064 
   5065         nPadWidth = nWidth;
   5066         nPadHeight = nHeight;
   5067         if((nPadWidth%16) != 0){
   5068             nPadWidth += 16-(nPadWidth%16);
   5069         }
   5070         if((nPadHeight%16) != 0){
   5071             nPadHeight += 16-(nPadHeight%16);
   5072         }
   5073 
   5074         /*TODO: Test Croped MPEG4*/
   5075 
   5076         if(pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 ||
   5077             pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263){
   5078             if(nPadWidth == 864){
   5079                 nPadWidth = 854;
   5080             }
   5081             if(nPadHeight == 864){
   5082                 nPadHeight = 864;
   5083             }
   5084         }
   5085 
   5086         /*TODO: Get minimum INPUT buffer size & verify if the actual size is enough*/
   5087         /*Verify correct values in the initial setup*/
   5088 
   5089         /*Verify if actual width & height parameters are correct*/
   5090         if (pComponentPrivate->pInPortDef->format.video.nFrameWidth != nWidth ||
   5091             pComponentPrivate->pInPortDef->format.video.nFrameHeight != nHeight) {
   5092             if((nWidth >= 1500) || (nHeight >= 1500)){
   5093                 pComponentPrivate->pInPortDef->format.video.nFrameHeight = 576;
   5094                 pComponentPrivate->pInPortDef->format.video.nFrameWidth = 720;
   5095                 eError = OMX_ErrorBadParameter;
   5096                 goto EXIT;
   5097             }
   5098             else if(((nWidth < 16) || (nHeight < 16))){
   5099                 pComponentPrivate->pInPortDef->format.video.nFrameHeight = 576;
   5100                 pComponentPrivate->pInPortDef->format.video.nFrameWidth = 720;
   5101                 eError = OMX_ErrorBadParameter;
   5102                 goto EXIT;
   5103             }
   5104             pComponentPrivate->pInPortDef->format.video.nFrameWidth = nPadWidth;
   5105             pComponentPrivate->pInPortDef->format.video.nFrameHeight = nPadHeight;
   5106 #ifdef ANDROID
   5107             /*Force reload the component to configure create face args (SN)*/
   5108             bOutPortSettingsChanged = OMX_TRUE;
   5109             OMX_PRINT1(pComponentPrivate->dbg, "Input port setting change, Force reload component !!!!!!\n");
   5110 #else
   5111             /*OpenCORE doesn't support dynamic input port configuration*/
   5112             bInPortSettingsChanged = OMX_TRUE;
   5113 #endif
   5114         }
   5115 
   5116         if(pComponentPrivate->pInPortDef->format.video.eCompressionFormat != OMX_VIDEO_CodingAVC &&
   5117             pComponentPrivate->pInPortDef->format.video.eCompressionFormat != OMX_VIDEO_CodingMPEG4 &&
   5118             pComponentPrivate->pInPortDef->format.video.eCompressionFormat != OMX_VIDEO_CodingH263){
   5119             if(pComponentPrivate->pOutPortDef->format.video.nFrameWidth != nWidth ||
   5120                 pComponentPrivate->pOutPortDef->format.video.nFrameHeight != nHeight) {
   5121 
   5122                 pComponentPrivate->pOutPortDef->format.video.nFrameWidth = nPadWidth;
   5123                 pComponentPrivate->pOutPortDef->format.video.nFrameHeight = nPadHeight;
   5124                 bOutPortSettingsChanged = OMX_TRUE;
   5125                 OMX_PRINT1(pComponentPrivate->dbg, "Resolution: default new: %dx%d\n", nPadWidth, nPadHeight);
   5126             }
   5127         }
   5128         else if(pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 ||
   5129                 pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263){
   5130             if(pComponentPrivate->pOutPortDef->format.video.nFrameWidth != nWidth ||
   5131                 pComponentPrivate->pOutPortDef->format.video.nFrameHeight != nHeight) {
   5132 
   5133                 pComponentPrivate->pOutPortDef->format.video.nFrameWidth = nWidth;
   5134                 pComponentPrivate->pOutPortDef->format.video.nFrameHeight = nHeight;
   5135                 bOutPortSettingsChanged = OMX_TRUE;
   5136                 OMX_PRINT1(pComponentPrivate->dbg, "Resolution: new MPEG4: %dx%d\n", nWidth, nHeight);
   5137             }
   5138         }
   5139         else{ /*OMX_VIDEO_CodingAVC*/
   5140             /* nCroppedWidth & nCroppedHeight indicate the resultant o/p resolution */
   5141             if((nWidth%16) != 0){
   5142                 nWidth += 16-(nWidth%16);
   5143             }
   5144             if((nHeight%16) != 0){
   5145                 nHeight += 16-(nHeight%16);
   5146             }
   5147             nCroppedWidth = nWidth - nCropWidth;
   5148             nCroppedHeight = nHeight - nCropHeight;
   5149             if(pComponentPrivate->pOutPortDef->format.video.nFrameWidth != nCroppedWidth ||
   5150                 pComponentPrivate->pOutPortDef->format.video.nFrameHeight != nCroppedHeight) {
   5151 
   5152                 pComponentPrivate->pOutPortDef->format.video.nFrameWidth = nCroppedWidth;
   5153                 pComponentPrivate->pOutPortDef->format.video.nFrameHeight = nCroppedHeight;
   5154                 bOutPortSettingsChanged = OMX_TRUE;
   5155                 OMX_PRINT1(pComponentPrivate->dbg, "Resolution: AVC new: %dx%d \n", nCroppedWidth, nCroppedHeight);
   5156             }
   5157         }
   5158 
   5159         /*Get minimum OUTPUT buffer size,
   5160          * verify if the actual allocated size is the same as require by display driver*/
   5161         nOutMinBufferSize = pComponentPrivate->pOutPortDef->format.video.nFrameWidth *
   5162                             pComponentPrivate->pOutPortDef->format.video.nFrameHeight *
   5163                             ((pComponentPrivate->pOutPortFormat->eColorFormat == VIDDEC_COLORFORMAT420) ? VIDDEC_FACTORFORMAT420 : VIDDEC_FACTORFORMAT422);
   5164 
   5165         if(nOutPortActualAllocLen != nOutMinBufferSize){
   5166             pComponentPrivate->pOutPortDef->nBufferSize = nOutMinBufferSize;
   5167             bOutPortSettingsChanged = OMX_TRUE;
   5168             OMX_PRINT1(pComponentPrivate->dbg, "NEW output BUFFSIZE:0x%x \n", nOutMinBufferSize);
   5169         }
   5170 
   5171 
   5172         OMX_PRINT1(pComponentPrivate->dbg, "pBuffHead %x, Resolution after parser: IN %dx%d : OUT %dx%d\n",
   5173                 (unsigned int)pBuffHead,
   5174                 (unsigned int)pComponentPrivate->pInPortDef->format.video.nFrameWidth,
   5175                 (unsigned int)pComponentPrivate->pInPortDef->format.video.nFrameHeight,
   5176                 (unsigned int)pComponentPrivate->pOutPortDef->format.video.nFrameWidth,
   5177                 (unsigned int)pComponentPrivate->pOutPortDef->format.video.nFrameHeight);
   5178 
   5179         pComponentPrivate->bInPortSettingsChanged |= bInPortSettingsChanged;
   5180         pComponentPrivate->bOutPortSettingsChanged |= bOutPortSettingsChanged;
   5181 
   5182         if(bOutPortSettingsChanged || bInPortSettingsChanged){
   5183             OMX_PRINT1(pComponentPrivate->dbg, "bDynamicConfigurationInProgress = OMX_TRUE\n");
   5184             pComponentPrivate->bDynamicConfigurationInProgress = OMX_TRUE;
   5185 
   5186             if(bOutPortSettingsChanged && bInPortSettingsChanged){
   5187                 OMX_PRBUFFER2(pComponentPrivate->dbg, "sending OMX_EventPortSettingsChanged to both ports\n");
   5188 
   5189 
   5190 #ifdef ANDROID
   5191                 /*We must send first INPUT port callback*/
   5192                 VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->sDynConfigMutex);
   5193 #endif
   5194 
   5195                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   5196                                                     pComponentPrivate->pHandle->pApplicationPrivate,
   5197                                                     OMX_EventPortSettingsChanged,
   5198                                                     VIDDEC_INPUT_PORT,
   5199                                                     0,
   5200                                                     NULL);
   5201                 VIDDEC_WAIT_CODE();
   5202                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   5203                                                     pComponentPrivate->pHandle->pApplicationPrivate,
   5204                                                     OMX_EventPortSettingsChanged,
   5205                                                     VIDDEC_OUTPUT_PORT,
   5206                                                     0,
   5207                                                     NULL);
   5208 
   5209 #ifdef ANDROID
   5210                 VIDDEC_PTHREAD_MUTEX_WAIT(pComponentPrivate->sDynConfigMutex);
   5211 #endif
   5212                 eError = OMX_ErrorBadParameter;
   5213                 goto EXIT;
   5214             }
   5215             else {
   5216                 OMX_PRBUFFER2(pComponentPrivate->dbg, "sending OMX_EventPortSettingsChanged SINGLE port\n");
   5217                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   5218                                                 pComponentPrivate->pHandle->pApplicationPrivate,
   5219                                                 OMX_EventPortSettingsChanged,
   5220                                                 bOutPortSettingsChanged ? VIDDEC_OUTPUT_PORT : VIDDEC_INPUT_PORT,
   5221                                                 0,
   5222                                                 NULL);
   5223                 eError = OMX_ErrorBadParameter;
   5224                 goto EXIT;
   5225             }
   5226         }
   5227         else {
   5228             eError = OMX_ErrorNone;
   5229         }
   5230 EXIT:
   5231     if (pComponentPrivate)
   5232         OMX_PRINT1(pComponentPrivate->dbg, "OUT\n");
   5233     return eError;
   5234 }
   5235 #endif
   5236 
   5237 /* ========================================================================== */
   5238 /**
   5239   *  Handle Data Buff function from application
   5240   **/
   5241 /* ========================================================================== */
   5242 
   5243 OMX_ERRORTYPE VIDDEC_HandleDataBuf_FromApp(VIDDEC_COMPONENT_PRIVATE *pComponentPrivate)
   5244 {
   5245     OMX_ERRORTYPE eError = OMX_ErrorNone;
   5246     OMX_BUFFERHEADERTYPE* pBuffHead = NULL;
   5247     VIDDEC_BUFFER_PRIVATE* pBufferPrivate = NULL;
   5248     OMX_U32 inpBufSize;
   5249     int ret = 0;
   5250     OMX_U32 size_dsp;
   5251     OMX_U8* pCSD = NULL;
   5252     OMX_U8* pData = NULL;
   5253     OMX_U32 nValue = 0;
   5254     OMX_U32 nWidth = 0;
   5255     OMX_U32 nHeight = 0;
   5256     OMX_U32 nActualCompression = 0;
   5257     OMX_U32 nSize_CSD = 0;
   5258 
   5259     void* pUalgInpParams = NULL;
   5260     LCML_DSP_INTERFACE* pLcmlHandle;
   5261     OMX_PRBUFFER1(pComponentPrivate->dbg, "+++ENTERING\n");
   5262     OMX_PRBUFFER1(pComponentPrivate->dbg, "pComponentPrivate 0x%p iEndofInputSent 0x%x\n", pComponentPrivate, pComponentPrivate->iEndofInputSent);
   5263     inpBufSize = pComponentPrivate->pInPortDef->nBufferSize;
   5264     pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
   5265     ret = read(pComponentPrivate->filled_inpBuf_Q[0], &(pBuffHead), sizeof(pBuffHead));
   5266     if (ret == -1) {
   5267         OMX_PRCOMM4(pComponentPrivate->dbg, "Error while reading from the pipe\n");
   5268         eError = OMX_ErrorHardware;
   5269         goto EXIT;
   5270     }
   5271     eError = DecrementCount (&(pComponentPrivate->nCountInputBFromApp), &(pComponentPrivate->mutexInputBFromApp));
   5272     if (eError != OMX_ErrorNone) {
   5273         return eError;
   5274     }
   5275     if( pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV &&
   5276             pComponentPrivate->ProcessMode == 0 &&
   5277             pBuffHead->nFilledLen != 0) {
   5278 
   5279         if (pComponentPrivate->bFirstHeader == OMX_FALSE) {
   5280             if (pBuffHead->nFlags & OMX_BUFFERFLAG_CODECCONFIG) {
   5281 #ifdef VIDDEC_HANDLE_FULL_STRM_PROP_OBJ
   5282                 pData = pBuffHead->pBuffer + 15; /*Position to Width & Height*/
   5283 
   5284                 VIDDEC_LoadDWORD(nValue, pData);
   5285                 nWidth = nValue;
   5286                 VIDDEC_LoadDWORD(nValue, pData);
   5287                 nHeight = nValue;
   5288 
   5289                 if((nWidth != (OMX_U32)pComponentPrivate->pOutPortDef->format.video.nFrameWidth) ||
   5290                         (nHeight != (OMX_U32)pComponentPrivate->pOutPortDef->format.video.nFrameHeight)){
   5291                     pComponentPrivate->pOutPortDef->format.video.nFrameWidth = nWidth;
   5292                     pComponentPrivate->pOutPortDef->format.video.nFrameHeight = nHeight;
   5293                     pComponentPrivate->bOutPortSettingsChanged = OMX_TRUE;
   5294                 }
   5295 
   5296                 pData += 4; /*Position to compression type*/
   5297                 VIDDEC_LoadDWORD(nValue, pData);
   5298                 nActualCompression = nValue;
   5299 
   5300                 /*If incorrect re-load SN with the proper nWMVFileType*/
   5301                 OMX_PRINT2(pComponentPrivate->dbg, "Compressions: WMV1=%lu, WMV2=%lu, WMV3=%lu, WVC1=%lu. Actual=%lu\n",
   5302                         FOURCC_WMV1, FOURCC_WMV2, FOURCC_WMV3, FOURCC_WVC1, nActualCompression);
   5303                 if(pComponentPrivate->nWMVFileType == VIDDEC_WMV_RCVSTREAM && nActualCompression == FOURCC_WVC1){
   5304                     pComponentPrivate->nWMVFileType = VIDDEC_WMV_ELEMSTREAM;
   5305                 }
   5306 
   5307                 eError = VIDDEC_Set_SN_StreamType(pComponentPrivate);
   5308                 if(eError != OMX_ErrorNone){
   5309                     goto EXIT;
   5310                 }
   5311 
   5312                 /*Seting pCSD to proper position*/
   5313                 pCSD = pBuffHead->pBuffer;
   5314                 pCSD += CSD_POSITION;
   5315                 nSize_CSD = pBuffHead->nFilledLen - CSD_POSITION;
   5316 #else
   5317                 pCSD = pBuffHead->pBuffer;
   5318                 nSize_CSD = pBuffHead->nFilledLen;
   5319 #endif
   5320             }
   5321             if (pComponentPrivate->nWMVFileType == VIDDEC_WMV_RCVSTREAM) {
   5322                     if(pComponentPrivate->pUalgParams == NULL) {
   5323                         OMX_U8* pTemp = NULL;
   5324                         OMX_MALLOC_STRUCT_SIZED(pComponentPrivate->pUalgParams, WMV9DEC_UALGInputParam,
   5325                                 sizeof(WMV9DEC_UALGInputParam) + VIDDEC_PADDING_FULL,
   5326                                 pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel1]);
   5327                         pTemp = (OMX_U8*)(pComponentPrivate->pUalgParams);
   5328                         pTemp += VIDDEC_PADDING_HALF;
   5329                         pComponentPrivate->pUalgParams = (OMX_PTR*)pTemp;
   5330                     }
   5331                     pBuffHead->nFlags  &= ~(OMX_BUFFERFLAG_CODECCONFIG);
   5332                     if (pComponentPrivate->bIsNALBigEndian) {
   5333                         pComponentPrivate->pBufferRCV.sStructRCV.nStructData = (OMX_U32)pCSD[0] << 24 |
   5334                                                                                         pCSD[1] << 16 |
   5335                                                                                         pCSD[2] << 8  |
   5336                                                                                         pCSD[3];
   5337                     }
   5338                     else {
   5339                         pComponentPrivate->pBufferRCV.sStructRCV.nStructData = (OMX_U32)pCSD[0] << 0  |
   5340                                                                                         pCSD[1] << 8  |
   5341                                                                                         pCSD[2] << 16 |
   5342                                                                                         pCSD[3] << 24;
   5343                     }
   5344                     size_dsp = sizeof(WMV9DEC_UALGInputParam);
   5345                     ((WMV9DEC_UALGInputParam*)pComponentPrivate->pUalgParams)->lBuffCount = ++pComponentPrivate->frameCounter;
   5346                     pUalgInpParams = pComponentPrivate->pUalgParams;
   5347                     /* Only WMV need to send EMMCodecInputBufferMapBufLen buffers */
   5348                     eError = LCML_QueueBuffer(((LCML_DSP_INTERFACE*)
   5349                                                 pLcmlHandle)->pCodecinterfacehandle,
   5350                                                 EMMCodecInputBufferMapBufLen,
   5351                                                 (OMX_U8*)&pComponentPrivate->pBufferRCV.pBuffer,
   5352                                                 sizeof(VIDDEC_WMV_RCV_struct),
   5353                                                 sizeof(VIDDEC_WMV_RCV_struct),
   5354                                                 (OMX_U8 *)pUalgInpParams,
   5355                                                 size_dsp,
   5356                                                 (OMX_U8*)&pComponentPrivate->pBufferTemp);
   5357                     OMX_PRBUFFER1(pComponentPrivate->dbg, "Returning First Input Buffer to test application\n");
   5358                     pBufferPrivate = (VIDDEC_BUFFER_PRIVATE* )pBuffHead->pInputPortPrivate;
   5359                     pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_CLIENT;
   5360                     OMX_PRBUFFER1(pComponentPrivate->dbg, "eBufferOwner 0x%x\n", pBufferPrivate->eBufferOwner);
   5361             #ifdef __PERF_INSTRUMENTATION__
   5362                     PERF_SendingFrame(pComponentPrivate->pPERFcomp,
   5363                                       pBuffHead->pBuffer,
   5364                                       pBuffHead->nFilledLen,
   5365                                       PERF_ModuleHLMM);
   5366             #endif
   5367                     VIDDEC_EmptyBufferDone(pComponentPrivate, pBuffHead);
   5368                     pComponentPrivate->bFirstHeader = OMX_TRUE;
   5369                     goto EXIT;
   5370             }
   5371             else { /* VC1 Advance profile */
   5372 #ifdef VIDDEC_WMVPOINTERFIXED
   5373                 if (pComponentPrivate->pCodecData == NULL ||
   5374                     !(pBuffHead->pBuffer[0] == 0 &&
   5375                     pBuffHead->pBuffer[1] == 0 &&
   5376                     pBuffHead->pBuffer[2] == 1)) {
   5377 #else
   5378                 if (pBuffHead->nOffset != 0) {
   5379 #endif
   5380                     if (pBuffHead->nFlags & OMX_BUFFERFLAG_CODECCONFIG) {
   5381                         pBuffHead->nFlags  &= ~(OMX_BUFFERFLAG_CODECCONFIG);
   5382                         if (pComponentPrivate->pCodecData != NULL) {
   5383                             free(pComponentPrivate->pCodecData);
   5384                             pComponentPrivate->pCodecData = NULL;
   5385                         }
   5386                         /* Save Codec Specific Data */
   5387                         pComponentPrivate->pCodecData = malloc (pBuffHead->nFilledLen);
   5388 #ifdef VIDDEC_WMVPOINTERFIXED
   5389                         memcpy (pComponentPrivate->pCodecData, pBuffHead->pBuffer, pBuffHead->nFilledLen);
   5390 #else
   5391                         memcpy (pComponentPrivate->pCodecData, pBuffHead->pBuffer + pBuffHead->nOffset, pBuffHead->nFilledLen);
   5392 #endif
   5393                         pComponentPrivate->nCodecDataSize = pBuffHead->nFilledLen;
   5394                         if(pComponentPrivate->nCodecDataSize > VIDDEC_WMV_BUFFER_OFFSET){
   5395                             OMX_ERROR4(pComponentPrivate->dbg, "Insufficient space in buffer pbuffer %p - nCodecDataSize %u\n",
   5396                                 (void *)pBuffHead->pBuffer,pComponentPrivate->nCodecDataSize);
   5397                             eError = OMX_ErrorStreamCorrupt;
   5398                             goto EXIT;
   5399                         }
   5400 #ifdef VIDDEC_ACTIVATEPARSER
   5401                         eError = VIDDEC_ParseHeader( pComponentPrivate, pBuffHead);
   5402 #endif
   5403                         OMX_PRBUFFER1(pComponentPrivate->dbg, "Returning First Input Buffer to test application %x\n",eError);
   5404                         pBufferPrivate = (VIDDEC_BUFFER_PRIVATE* )pBuffHead->pInputPortPrivate;
   5405                         pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_CLIENT;
   5406                         OMX_PRBUFFER1(pComponentPrivate->dbg, "eBufferOwner 0x%x\n", pBufferPrivate->eBufferOwner);
   5407                 #ifdef __PERF_INSTRUMENTATION__
   5408                         PERF_SendingFrame(pComponentPrivate->pPERFcomp,
   5409                                           pBuffHead->pBuffer,
   5410                                           pBuffHead->nFilledLen,
   5411                                           PERF_ModuleHLMM);
   5412                 #endif
   5413 #ifdef VIDDEC_WMVPOINTERFIXED
   5414                         OMX_PRBUFFER1(pComponentPrivate->dbg, "restoring buffer pointer 0x%p >> pBuffer 0x%p\n",
   5415                             pBufferPrivate->pTempBuffer, pBuffHead->pBuffer);
   5416                         pBuffHead->pBuffer = pBufferPrivate->pTempBuffer;
   5417 #else
   5418                         pBuffHead->nOffset = VIDDEC_WMV_BUFFER_OFFSET;
   5419 #endif
   5420                         VIDDEC_EmptyBufferDone(pComponentPrivate, pBuffHead);
   5421                         return OMX_ErrorNone;
   5422                    }
   5423                    else {
   5424                         /* VC-1: First data buffer received, add configuration data to it*/
   5425                         pComponentPrivate->bFirstHeader = OMX_TRUE;
   5426                         OMX_WMV_INSERT_CODEC_DATA(pBuffHead, pComponentPrivate);
   5427                         eError = OMX_ErrorNone;
   5428                     }
   5429                 }
   5430                 else {
   5431                     /*if no config flag is set just parse buffer and set flag first buffer*/
   5432                     /*this is ejecuted by the first buffer regular buffer*/
   5433                     if (pComponentPrivate->bFirstHeader == OMX_FALSE) {
   5434                         pComponentPrivate->bFirstHeader = OMX_TRUE;
   5435                         eError = VIDDEC_ParseHeader(pComponentPrivate, pBuffHead);
   5436                         if(eError != OMX_ErrorNone) {
   5437                                 OMX_PRBUFFER1(pComponentPrivate->dbg, "Returning First Input Buffer to test application\n");
   5438                                 pComponentPrivate->bFirstHeader = OMX_TRUE;
   5439                                 pBufferPrivate = (VIDDEC_BUFFER_PRIVATE* )pBuffHead->pInputPortPrivate;
   5440                                 pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_CLIENT;
   5441                                 OMX_PRBUFFER1(pComponentPrivate->dbg, "eBufferOwner 0x%x\n", pBufferPrivate->eBufferOwner);
   5442                         #ifdef __PERF_INSTRUMENTATION__
   5443                                 PERF_SendingFrame(pComponentPrivate->pPERFcomp,
   5444                                                   pBuffHead->pBuffer,
   5445                                                   pBuffHead->nFilledLen,
   5446                                                   PERF_ModuleHLMM);
   5447                         #endif
   5448 #ifdef VIDDEC_WMVPOINTERFIXED
   5449                                 OMX_PRBUFFER1(pComponentPrivate->dbg, "restoring buffer pointer 0x%p >> pBuffer 0x%p\n",
   5450                                     pBufferPrivate->pTempBuffer, pBuffHead->pBuffer);
   5451                                 pBuffHead->pBuffer = pBufferPrivate->pTempBuffer;
   5452 #else
   5453                                 pBuffHead->nOffset = VIDDEC_WMV_BUFFER_OFFSET;
   5454 #endif
   5455                             VIDDEC_EmptyBufferDone(pComponentPrivate, pBuffHead);
   5456                             eError = OMX_ErrorNone;
   5457                             goto EXIT;
   5458                         }
   5459                         else {
   5460                             eError = OMX_ErrorNone;
   5461                         }
   5462                     }
   5463                 }
   5464             }
   5465         }/*codec data is stored one time and repeated for each Config buffer*/
   5466         else if (pComponentPrivate->nWMVFileType == VIDDEC_WMV_ELEMSTREAM) {
   5467 #ifdef VIDDEC_WMVPOINTERFIXED
   5468                 if (!(pBuffHead->pBuffer[0] == 0 &&
   5469                     pBuffHead->pBuffer[1] == 0 &&
   5470                     pBuffHead->pBuffer[2] == 1)) {
   5471 #else
   5472                 if (pBuffHead->nOffset != 0) {
   5473 #endif
   5474                 OMX_S32 nDifference = 0;
   5475                 OMX_U8* pTempBuffer = NULL;
   5476 #ifdef VIDDEC_WMVPOINTERFIXED
   5477                 pTempBuffer = pBuffHead->pBuffer;
   5478 #else
   5479                 pTempBuffer = pBuffHead->pBuffer + pBuffHead->nOffset;
   5480 #endif
   5481 #ifdef VIDDEC_WMVPOINTERFIXED
   5482                 nDifference = pBuffHead->pBuffer - pTempBuffer;
   5483 #else
   5484                 nDifference = pTempBuffer - pBuffHead->pBuffer;
   5485 #endif
   5486                 if (nDifference < 0) {
   5487                     OMX_ERROR4(pComponentPrivate->dbg, "Insufficient space in buffer pbuffer %p - nOffset %lx\n",
   5488                         pBuffHead->pBuffer, pBuffHead->nOffset);
   5489                     eError = OMX_ErrorStreamCorrupt;
   5490                     goto EXIT;
   5491                 }
   5492                 (*(--pTempBuffer)) = 0x0d;
   5493                 (*(--pTempBuffer)) = 0x01;
   5494                 (*(--pTempBuffer)) = 0x00;
   5495                 (*(--pTempBuffer)) = 0x00;
   5496                 pBuffHead->nFilledLen += 4;
   5497 #ifdef VIDDEC_WMVPOINTERFIXED
   5498                 pBuffHead->pBuffer = pTempBuffer;
   5499                 pBuffHead->nOffset = 0;
   5500 #else
   5501                 pBuffHead->nOffset = pTempBuffer - pBuffHead->pBuffer;
   5502 #endif
   5503                 OMX_PRBUFFER1(pComponentPrivate->dbg, "pTempBuffer %p - pBuffHead->pBuffer %p - pBuffHead->nOffset %lx\n",
   5504                     pTempBuffer,pBuffHead->pBuffer,pBuffHead->nOffset);
   5505                 eError = OMX_ErrorNone;
   5506             }
   5507             else {
   5508                 OMX_PRBUFFER1(pComponentPrivate->dbg, "incorrect path %lu\n",pBuffHead->nOffset);
   5509                 /*if no config flag is set just parse buffer and set flag first buffer*/
   5510                 /*this is ejecuted by the first buffer regular buffer*/
   5511                 if (pComponentPrivate->bFirstHeader == OMX_FALSE) {
   5512                     pComponentPrivate->bFirstHeader = OMX_TRUE;
   5513                     eError = VIDDEC_ParseHeader(pComponentPrivate, pBuffHead);
   5514                     if(eError != OMX_ErrorNone) {
   5515                             OMX_PRBUFFER1(pComponentPrivate->dbg, "Returning First Input Buffer to test application\n");
   5516                             pComponentPrivate->bFirstHeader = OMX_TRUE;
   5517                             pBufferPrivate = (VIDDEC_BUFFER_PRIVATE* )pBuffHead->pInputPortPrivate;
   5518                             pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_CLIENT;
   5519                             OMX_PRBUFFER1(pComponentPrivate->dbg, "eBufferOwner 0x%x\n", pBufferPrivate->eBufferOwner);
   5520                     #ifdef __PERF_INSTRUMENTATION__
   5521                             PERF_SendingFrame(pComponentPrivate->pPERFcomp,
   5522                                               pBuffHead->pBuffer,
   5523                                               pBuffHead->nFilledLen,
   5524                                               PERF_ModuleHLMM);
   5525                     #endif
   5526 #ifdef VIDDEC_WMVPOINTERFIXED
   5527                             OMX_PRBUFFER1(pComponentPrivate->dbg, "restoring buffer pointer 0x%p >> pBuffer 0x%p\n",
   5528                                 pBufferPrivate->pTempBuffer, pBuffHead->pBuffer);
   5529                             pBuffHead->pBuffer = pBufferPrivate->pTempBuffer;
   5530 #else
   5531                             pBuffHead->nOffset = VIDDEC_WMV_BUFFER_OFFSET;
   5532 #endif
   5533                         VIDDEC_EmptyBufferDone(pComponentPrivate, pBuffHead);
   5534                         eError = OMX_ErrorNone;
   5535                         goto EXIT;
   5536                     }
   5537                     else {
   5538                         eError = OMX_ErrorNone;
   5539                     }
   5540                 }
   5541             }
   5542         }
   5543     }
   5544 #ifdef VIDDEC_ACTIVATEPARSER
   5545     if((((pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) ||
   5546             pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 ||
   5547             pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG2 ||
   5548             pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) ||
   5549             (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV &&
   5550              pComponentPrivate->ProcessMode == 1)) &&
   5551             pComponentPrivate->bParserEnabled &&
   5552             pComponentPrivate->bFirstHeader == OMX_FALSE) {
   5553         pComponentPrivate->bFirstHeader = OMX_TRUE;
   5554         /* If VIDDEC_ParseHeader() does not return OMX_ErrorNone, then
   5555         * reconfiguration is required.
   5556         * eError is set to OMX_ErrorNone after saving the buffer, which will
   5557         * be used later by the reconfiguration logic.
   5558         */
   5559         eError = VIDDEC_ParseHeader( pComponentPrivate, pBuffHead);
   5560 
   5561         /* The MPEG4 & H.263 algorithm expects both the configuration buffer
   5562         * and the first data buffer to be in the same frame - this logic only
   5563         * applies when in frame mode and when the framework sends the config data
   5564         * separately. The same situation is handled elsewhere for H.264 & WMV
   5565         * decoding.
   5566         */
   5567         if(eError != OMX_ErrorNone ||
   5568             ((pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 ||
   5569             pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) &&
   5570             pComponentPrivate->ProcessMode == 0)) {
   5571             if (pBuffHead != NULL) {
   5572 
   5573 #ifdef ANDROID
   5574                 OMX_PRINT1(pComponentPrivate->dbg,"save 1st ccd buffer - pBuffhead->nFilledLen = %d\n", pBuffHead->nFilledLen);
   5575                 eError = VIDDEC_SaveBuffer(pComponentPrivate, pBuffHead);
   5576                 if(eError != OMX_ErrorNone){
   5577                     goto EXIT;
   5578                 }
   5579                 /* only if NAL-bitstream format in frame mode */
   5580                 if (pComponentPrivate->ProcessMode == 0 && pComponentPrivate->H264BitStreamFormat > 0) {
   5581                     pComponentPrivate->aCCDsize[pComponentPrivate->nCCDcnt++] = pBuffHead->nFilledLen;
   5582                 }
   5583 #endif
   5584 
   5585                 pBufferPrivate = (VIDDEC_BUFFER_PRIVATE* )pBuffHead->pInputPortPrivate;
   5586                 pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_CLIENT;
   5587                 OMX_PRBUFFER1(pComponentPrivate->dbg, "eBufferOwner 0x%x\n", pBufferPrivate->eBufferOwner);
   5588         #ifdef __PERF_INSTRUMENTATION__
   5589                 PERF_SendingFrame(pComponentPrivate->pPERFcomp,
   5590                                   pBuffHead->pBuffer,
   5591                                   pBuffHead->nFilledLen,
   5592                                   PERF_ModuleHLMM);
   5593         #endif
   5594 
   5595                 VIDDEC_EmptyBufferDone(pComponentPrivate, pBuffHead);
   5596             }
   5597             eError = OMX_ErrorNone;
   5598             goto EXIT;
   5599         }
   5600         else {
   5601             /* We have received only one part of the Config Buffer, we need to wait for more buffers. ONLY FOR AVC*/
   5602             if(pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC &&
   5603                 pComponentPrivate->bConfigBufferCompleteAVC == FALSE){
   5604                 /* Set bFirstHeader flag to false so next buffer enters to ParseHeade again*/
   5605                 pComponentPrivate->bFirstHeader = OMX_FALSE;
   5606                 OMX_PRINT1(pComponentPrivate->dbg, "AVC: bConfigBufferCompleateAVC == FALSE!");
   5607                 goto EXIT;
   5608             }
   5609             eError = OMX_ErrorNone;
   5610         }
   5611     }
   5612 #endif
   5613 
   5614 
   5615     if (pComponentPrivate->nInCmdMarkBufIndex != pComponentPrivate->nOutCmdMarkBufIndex) {
   5616         pComponentPrivate->arrMarkBufIndex[pComponentPrivate->nInMarkBufIndex].hMarkTargetComponent = pComponentPrivate->arrCmdMarkBufIndex[pComponentPrivate->nOutCmdMarkBufIndex].hMarkTargetComponent;
   5617         pComponentPrivate->arrMarkBufIndex[pComponentPrivate->nInMarkBufIndex].pMarkData = pComponentPrivate->arrCmdMarkBufIndex[pComponentPrivate->nOutCmdMarkBufIndex].pMarkData;
   5618         pComponentPrivate->nOutCmdMarkBufIndex++;
   5619         pComponentPrivate->nOutCmdMarkBufIndex %= VIDDEC_MAX_QUEUE_SIZE;
   5620         pComponentPrivate->nInMarkBufIndex++;
   5621         pComponentPrivate->nInMarkBufIndex %= VIDDEC_MAX_QUEUE_SIZE;
   5622     }
   5623     else {
   5624         pComponentPrivate->arrMarkBufIndex[pComponentPrivate->nInMarkBufIndex].hMarkTargetComponent = pBuffHead->hMarkTargetComponent;
   5625         pComponentPrivate->arrMarkBufIndex[pComponentPrivate->nInMarkBufIndex].pMarkData = pBuffHead->pMarkData;
   5626         pComponentPrivate->nInMarkBufIndex++;
   5627         pComponentPrivate->nInMarkBufIndex  %= VIDDEC_MAX_QUEUE_SIZE;
   5628     }
   5629 
   5630     OMX_PRBUFFER1(pComponentPrivate->dbg, "pBuffHead 0x%p eExecuteToIdle 0x%x\n", pBuffHead,pComponentPrivate->eExecuteToIdle);
   5631     OMX_PRBUFFER1(pComponentPrivate->dbg, "nFilledLen 0x%lx nFlags 0x%lx\n", pBuffHead->nFilledLen,pBuffHead->nFlags);
   5632     pBufferPrivate = (VIDDEC_BUFFER_PRIVATE* )pBuffHead->pInputPortPrivate;
   5633 
   5634     if(pBuffHead->nFlags & OMX_BUFFERFLAG_EOS){
   5635         OMX_PRBUFFER2(pComponentPrivate->dbg, "End of Input EOS, nFlags=0x%x nFilledLen 0x%lx\n", pBuffHead->nFlags, pBuffHead->nFilledLen);
   5636         if(pBuffHead->nFilledLen != 0) { /*TODO: Validate this lagic*/
   5637             if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
   5638                 pUalgInpParams = (OMX_PTR)pBufferPrivate->pUalgParam;
   5639                 if ((pBuffHead->nFlags & OMX_BUFFERFLAG_EOS) == 0) {
   5640                     ((H264VDEC_UALGInputParam *)pUalgInpParams)->lBuffCount = ++pComponentPrivate->frameCounter;
   5641 
   5642                 /* prepare buffer and input parameter if H264BitStreamFormat = 1 */
   5643                 /*     the orignial buffer is: NAL1_Len NAL1 NAL2_Len NAL2...*/
   5644                 /*     we need to pack the data buffer as: NAL1 NAL2 NAL3..*/
   5645                 /*     and put the length info to the parameter array*/
   5646                     if (pComponentPrivate->H264BitStreamFormat) {
   5647                         OMX_U32 nal_len, i;
   5648                         OMX_U8 *pDataBuf;
   5649                         OMX_U32 length_pos = 0;
   5650                         OMX_U32 data_pos = 0;
   5651                         OMX_U32 buf_len;
   5652                         H264VDEC_UALGInputParam *pParam;
   5653 
   5654                         buf_len = pBuffHead->nFilledLen;
   5655                         pDataBuf = pBuffHead->pBuffer;
   5656                         pParam = (H264VDEC_UALGInputParam *)pUalgInpParams;
   5657                         pParam->ulNumOfNALU = 0;
   5658                         while (pBuffHead->nFilledLen > length_pos+pComponentPrivate->H264BitStreamFormat) {
   5659                             if (pComponentPrivate->H264BitStreamFormat == 1)
   5660                                 if (pComponentPrivate->bIsNALBigEndian) {
   5661                                     nal_len = (OMX_U32)pDataBuf[length_pos];
   5662                                 }
   5663                                 else {
   5664                                     nal_len = (OMX_U32)pDataBuf[length_pos];
   5665                                 }
   5666                             else if (pComponentPrivate->H264BitStreamFormat == 2)
   5667                                 if (pComponentPrivate->bIsNALBigEndian) {
   5668                                     nal_len = (OMX_U32)pDataBuf[length_pos] << 8 | pDataBuf[length_pos+1];
   5669                                 }
   5670                                 else {
   5671                                     nal_len = (OMX_U32)pDataBuf[length_pos] << 0 | pDataBuf[length_pos+1] << 8 ;
   5672                                 }
   5673                             else if (pComponentPrivate->H264BitStreamFormat == 4){
   5674                                 if (pComponentPrivate->bIsNALBigEndian) {
   5675                                     nal_len = (OMX_U32)pDataBuf[length_pos]<<24 | pDataBuf[length_pos+1] << 16 | pDataBuf[length_pos+2] << 8 | pDataBuf[length_pos+3];
   5676                                 }
   5677                                 else {
   5678                                     nal_len = (OMX_U32)pDataBuf[length_pos]<<0 | pDataBuf[length_pos+1] << 8 | pDataBuf[length_pos+2] << 16 | pDataBuf[length_pos+3]<<24;
   5679                                 }
   5680                             }
   5681                             else {
   5682                                 eError = OMX_ErrorBadParameter;
   5683                                 goto EXIT;
   5684                             }
   5685                             length_pos += pComponentPrivate->H264BitStreamFormat;
   5686                             if (nal_len > buf_len - length_pos) {
   5687                                 eError = OMX_ErrorBadParameter;
   5688                                 goto EXIT;
   5689                             }
   5690                             /* move the memory*/
   5691                             for (i=0; i<nal_len; i++)
   5692                                 pDataBuf[data_pos+i] = pDataBuf[length_pos+i];
   5693                             data_pos += nal_len;
   5694                             length_pos += nal_len;
   5695                             /* save the size*/
   5696                             pParam->pNALUSizeArray[pParam->ulNumOfNALU++] = nal_len;
   5697                         }
   5698                         /* update with the new data size*/
   5699                         pBuffHead->nFilledLen = data_pos;
   5700                     }
   5701                 }
   5702                 size_dsp = sizeof(H264VDEC_UALGInputParam);
   5703             }
   5704             else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV) {
   5705                 pUalgInpParams = (OMX_PTR)pBufferPrivate->pUalgParam;
   5706                 if ((pBuffHead->nFlags & OMX_BUFFERFLAG_EOS) == 0) {
   5707                     ((WMV9DEC_UALGInputParam*)pUalgInpParams)->lBuffCount = ++pComponentPrivate->frameCounter;
   5708                 }
   5709                 size_dsp = sizeof(WMV9DEC_UALGInputParam);
   5710             }
   5711             else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 ||
   5712                      pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) {
   5713                 pUalgInpParams = (OMX_PTR)pBufferPrivate->pUalgParam;
   5714                 if ((pBuffHead->nFlags & OMX_BUFFERFLAG_EOS) == 0) {
   5715                     ((MP4VD_GPP_SN_UALGInputParams*)pUalgInpParams)->nBuffCount = ++pComponentPrivate->frameCounter;
   5716                     ((MP4VD_GPP_SN_UALGInputParams*)pUalgInpParams)->uRingIOBlocksize = 0;
   5717                     ((MP4VD_GPP_SN_UALGInputParams*)pUalgInpParams)->nPerformMode = 2;
   5718                 }
   5719                 size_dsp = sizeof(MP4VD_GPP_SN_UALGInputParams);
   5720             }
   5721             else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG2) {
   5722                 pUalgInpParams = (OMX_PTR)pBufferPrivate->pUalgParam;
   5723                 if ((pBuffHead->nFlags & OMX_BUFFERFLAG_EOS) == 0) {
   5724                     ((MP2VDEC_UALGInputParam*)pUalgInpParams)->lBuffCount = ++pComponentPrivate->frameCounter;
   5725                 }
   5726                 size_dsp = sizeof(MP2VDEC_UALGInputParam);
   5727             }
   5728 #ifdef VIDDEC_SPARK_CODE
   5729             else if (VIDDEC_SPARKCHECK) {
   5730                 pUalgInpParams = (OMX_PTR)pBufferPrivate->pUalgParam;
   5731                 if ((pBuffHead->nFlags & OMX_BUFFERFLAG_EOS) == 0) {
   5732                     ((SPARKVD_GPP_SN_UALGInputParams*)pUalgInpParams)->lBuffCount = ++pComponentPrivate->frameCounter;
   5733                 }
   5734                 ((SPARKVD_GPP_SN_UALGInputParams*)pUalgInpParams)->nIsSparkInput = 1;
   5735                 size_dsp = sizeof(SPARKVD_GPP_SN_UALGInputParams);
   5736             }
   5737 #endif
   5738             else {
   5739                 eError = OMX_ErrorUnsupportedSetting;
   5740                 OMX_PRBUFFER4(pComponentPrivate->dbg, "VIDDEC_HandleDataBuf_FromApp 0x%x\n", eError);
   5741                 goto EXIT;
   5742             }
   5743 
   5744             if (pComponentPrivate->ProcessMode == 0) {
   5745                 OMX_U8 ucIndex = 0;
   5746                 OMX_PTR pBufferFlags = NULL;
   5747                 ucIndex = VIDDEC_CircBuf_GetHead(pComponentPrivate,
   5748                                                  VIDDEC_CBUFFER_TIMESTAMP,
   5749                                                  VIDDEC_INPUT_PORT);
   5750                 pComponentPrivate->aBufferFlags[ucIndex].nTimeStamp = pBuffHead->nTimeStamp;
   5751                 pComponentPrivate->aBufferFlags[ucIndex].nTickCount = pBuffHead->nTickCount;
   5752                 pBuffHead->nFlags &= ~OMX_BUFFERFLAG_EOS;
   5753                 pComponentPrivate->aBufferFlags[ucIndex].nFlags = pBuffHead->nFlags;
   5754                 pBufferFlags = &pComponentPrivate->aBufferFlags[ucIndex];
   5755                 VIDDEC_CircBuf_Add(pComponentPrivate,
   5756                                    VIDDEC_CBUFFER_TIMESTAMP,
   5757                                    VIDDEC_INPUT_PORT,
   5758                                    pBufferFlags);
   5759             }
   5760             else {
   5761                 pComponentPrivate->arrBufIndex[pComponentPrivate->nInBufIndex] = pBuffHead->nTimeStamp;
   5762                 pComponentPrivate->nInBufIndex++;
   5763                 pComponentPrivate->nInBufIndex %= VIDDEC_MAX_QUEUE_SIZE;
   5764             }
   5765             OMX_PRBUFFER1(pComponentPrivate->dbg, "pBuffHead->nTimeStamp %lld\n", pBuffHead->nTimeStamp);
   5766 
   5767 #ifdef __PERF_INSTRUMENTATION__
   5768             PERF_SendingFrame(pComponentPrivate->pPERFcomp,
   5769                               pBuffHead->pBuffer,
   5770                               pBuffHead->nFilledLen,
   5771                               PERF_ModuleCommonLayer);
   5772 #endif
   5773 
   5774             if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   5775                 pComponentPrivate->eLCMLState != VidDec_LCML_State_Destroy &&
   5776                 pComponentPrivate->pLCML != NULL){
   5777                 pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_DSP;
   5778                 pBuffHead->nFlags = 0;
   5779 
   5780 #ifdef __PERF_INSTRUMENTATION__
   5781                     PERF_SendingFrame(pComponentPrivate->pPERFcomp,
   5782                                       pBuffHead->pBuffer,
   5783                                       pBuffHead->nFilledLen,
   5784                                       PERF_ModuleHLMM);
   5785 #endif
   5786 
   5787                 if(pComponentPrivate->bDynamicConfigurationInProgress){
   5788                     pBufferPrivate = (VIDDEC_BUFFER_PRIVATE* )pBuffHead->pInputPortPrivate;
   5789                     pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_CLIENT;
   5790                     OMX_PRBUFFER1(pComponentPrivate->dbg, "eBufferOwner 0x%x\n", pBufferPrivate->eBufferOwner);
   5791 
   5792                     OMX_PRBUFFER2(pComponentPrivate->dbg, "Sending buffer back to client pBuffer=%p\n", pBuffHead->pBuffer);
   5793                     VIDDEC_EmptyBufferDone(pComponentPrivate, pBuffHead);
   5794                     goto EXIT;
   5795                 }
   5796 
   5797                 OMX_PRDSP1(pComponentPrivate->dbg, "Sending EOS Filled eBufferOwner 0x%x\n", pBufferPrivate->eBufferOwner);
   5798                 OMX_PRDSP2(pComponentPrivate->dbg, "LCML_QueueBuffer(INPUT)\n");
   5799                 eError = LCML_QueueBuffer(((LCML_DSP_INTERFACE*)
   5800                                             pLcmlHandle)->pCodecinterfacehandle,
   5801                                             ((pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV) ? EMMCodecInputBufferMapBufLen : EMMCodecInputBuffer),
   5802                                             &pBuffHead->pBuffer[pBuffHead->nOffset],/*WMV_VC1_CHANGES*/
   5803                                             pBuffHead->nAllocLen,
   5804                                             pBuffHead->nFilledLen,
   5805                                             (OMX_U8 *)pUalgInpParams,
   5806                                             size_dsp,
   5807                                             (OMX_U8 *)pBuffHead);
   5808                 if (eError != OMX_ErrorNone){
   5809                     OMX_PRDSP4(pComponentPrivate->dbg, "LCML_QueueBuffer(INPUT):OMX_BUFFERFLAG_EOS, Error 0x%x\n", eError);
   5810                     eError = OMX_ErrorHardware;
   5811                     goto EXIT;
   5812                 }
   5813             }
   5814             else {
   5815                 eError = OMX_ErrorHardware;
   5816                 goto EXIT;
   5817             }
   5818         }
   5819         else {
   5820             pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_COMPONENT;
   5821             OMX_PRBUFFER1(pComponentPrivate->dbg, "eBufferOwner 0x%x\n", pBufferPrivate->eBufferOwner);
   5822             eError = IncrementCount (&(pComponentPrivate->nCountInputBFromDsp), &(pComponentPrivate->mutexInputBFromDSP));
   5823             if (eError != OMX_ErrorNone) {
   5824                 return eError;
   5825             }
   5826             ret = write(pComponentPrivate->free_inpBuf_Q[1], &pBuffHead, sizeof(pBuffHead));
   5827             if(ret == -1){
   5828                 OMX_PRCOMM4(pComponentPrivate->dbg, "writing to the input pipe %x (%d)\n", OMX_ErrorInsufficientResources,ret);
   5829                 pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_DSP;
   5830                 DecrementCount (&(pComponentPrivate->nCountInputBFromDsp), &(pComponentPrivate->mutexInputBFromDSP));
   5831                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   5832                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   5833                                                        OMX_EventError,
   5834                                                        OMX_ErrorInsufficientResources,
   5835                                                        OMX_TI_ErrorSevere,
   5836                                                        "Error writing to the output pipe");
   5837             }
   5838         }
   5839 
   5840         if(pComponentPrivate->iEndofInputSent == 0){
   5841             //pComponentPrivate->iEndofInputSent = 1;
   5842             OMX_PRBUFFER1(pComponentPrivate->dbg, "Sending EOS Empty eBufferOwner 0x%x\n", pBufferPrivate->eBufferOwner);
   5843             if(pComponentPrivate->eFirstBuffer.bSaveFirstBuffer == OMX_FALSE){
   5844                 OMX_MEMFREE_STRUCT_DSPALIGN(pComponentPrivate->pUalgParams,OMX_PTR);
   5845             }
   5846 
   5847             if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
   5848                 if(pComponentPrivate->pUalgParams == NULL){
   5849                     OMX_U8* pTemp = NULL;
   5850                     OMX_MALLOC_STRUCT_SIZED(pComponentPrivate->pUalgParams,
   5851                             H264VDEC_UALGInputParam,
   5852                             sizeof(H264VDEC_UALGInputParam) + VIDDEC_PADDING_FULL,
   5853                             pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel1]);
   5854                     pTemp = (OMX_U8*)(pComponentPrivate->pUalgParams);
   5855                     pTemp += VIDDEC_PADDING_HALF;
   5856                     pComponentPrivate->pUalgParams = (OMX_PTR*)pTemp;
   5857                 }
   5858                 size_dsp = sizeof(H264VDEC_UALGInputParam);
   5859                 ((H264VDEC_UALGInputParam *)pComponentPrivate->pUalgParams)->lBuffCount = -1;
   5860                 OMX_PRBUFFER1(pComponentPrivate->dbg, "lBuffCount 0x%lx\n",
   5861                     ((H264VDEC_UALGInputParam *)pComponentPrivate->pUalgParams)->lBuffCount);
   5862             }
   5863             else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV) {
   5864                 if(pComponentPrivate->pUalgParams == NULL){
   5865                     OMX_U8* pTemp = NULL;
   5866                     OMX_MALLOC_STRUCT_SIZED(pComponentPrivate->pUalgParams,
   5867                             WMV9DEC_UALGInputParam,
   5868                             sizeof(WMV9DEC_UALGInputParam) + VIDDEC_PADDING_FULL,
   5869                             pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel1]);
   5870                     pTemp = (OMX_U8*)(pComponentPrivate->pUalgParams);
   5871                     pTemp += VIDDEC_PADDING_HALF;
   5872                     pComponentPrivate->pUalgParams = (OMX_PTR*)pTemp;
   5873                 }
   5874                 size_dsp = sizeof(WMV9DEC_UALGInputParam);
   5875                 ((WMV9DEC_UALGInputParam*)pComponentPrivate->pUalgParams)->lBuffCount = -1;
   5876                 OMX_PRBUFFER1(pComponentPrivate->dbg, "lBuffCount 0x%lx\n",
   5877                     ((WMV9DEC_UALGInputParam*)pComponentPrivate->pUalgParams)->lBuffCount);
   5878             }
   5879             else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 ||
   5880                      pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) {
   5881                 if(pComponentPrivate->pUalgParams == NULL){
   5882                     OMX_U8* pTemp = NULL;
   5883                     OMX_MALLOC_STRUCT_SIZED(pComponentPrivate->pUalgParams,
   5884                             MP4VD_GPP_SN_UALGInputParams,
   5885                             sizeof(MP4VD_GPP_SN_UALGInputParams) + VIDDEC_PADDING_FULL,
   5886                             pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel1]);
   5887                     pTemp = (OMX_U8*)(pComponentPrivate->pUalgParams);
   5888                     pTemp += VIDDEC_PADDING_HALF;
   5889                     pComponentPrivate->pUalgParams = (OMX_PTR*)pTemp;
   5890                 }
   5891                 size_dsp = sizeof(MP4VD_GPP_SN_UALGInputParams);
   5892                 ((MP4VD_GPP_SN_UALGInputParams*)pComponentPrivate->pUalgParams)->nBuffCount = -1;
   5893                 ((MP4VD_GPP_SN_UALGInputParams*)pComponentPrivate->pUalgParams)->uRingIOBlocksize = 0;
   5894                 /* If EOS is sent, set nPerformMode to 0 (this handle thumbnail case)*/
   5895                 ((MP4VD_GPP_SN_UALGInputParams*)pComponentPrivate->pUalgParams)->nPerformMode = 0;
   5896                 OMX_PRBUFFER1(pComponentPrivate->dbg, "lBuffCount 0x%lx\n",
   5897                     ((MP4VD_GPP_SN_UALGInputParams*)pComponentPrivate->pUalgParams)->nBuffCount);
   5898             }
   5899             else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG2) {
   5900                 if(pComponentPrivate->pUalgParams == NULL){
   5901                     OMX_U8* pTemp = NULL;
   5902                     OMX_MALLOC_STRUCT_SIZED(pComponentPrivate->pUalgParams,
   5903                             MP2VDEC_UALGInputParam,
   5904                             sizeof(MP2VDEC_UALGInputParam) + VIDDEC_PADDING_FULL,
   5905                             pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel1]);
   5906                     pTemp = (OMX_U8*)(pComponentPrivate->pUalgParams);
   5907                     pTemp += VIDDEC_PADDING_HALF;
   5908                     pComponentPrivate->pUalgParams = (OMX_PTR*)pTemp;
   5909                 }
   5910                 size_dsp = sizeof(MP2VDEC_UALGInputParam);
   5911                 ((MP2VDEC_UALGInputParam*)pComponentPrivate->pUalgParams)->lBuffCount = -1;
   5912                 OMX_PRBUFFER1(pComponentPrivate->dbg, "lBuffCount 0x%lx\n",
   5913                     ((MP2VDEC_UALGInputParam*)pComponentPrivate->pUalgParams)->lBuffCount);
   5914             }
   5915 #ifdef VIDDEC_SPARK_CODE
   5916             else if (VIDDEC_SPARKCHECK) {
   5917                 if(pComponentPrivate->pUalgParams == NULL){
   5918                     OMX_U8* pTemp = NULL;
   5919                     OMX_MALLOC_STRUCT_SIZED(pComponentPrivate->pUalgParams,
   5920                             SPARKVD_GPP_SN_UALGInputParams,
   5921                             sizeof(SPARKVD_GPP_SN_UALGInputParams) + VIDDEC_PADDING_FULL,
   5922                             pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel1]);
   5923                     pTemp = (OMX_U8*)(pComponentPrivate->pUalgParams);
   5924                     pTemp += VIDDEC_PADDING_HALF;
   5925                     pComponentPrivate->pUalgParams = (OMX_PTR*)pTemp;
   5926                 }
   5927                 size_dsp = sizeof(SPARKVD_GPP_SN_UALGInputParams);
   5928                 ((SPARKVD_GPP_SN_UALGInputParams*)pComponentPrivate->pUalgParams)->lBuffCount = -1;
   5929                 ((SPARKVD_GPP_SN_UALGInputParams*)pComponentPrivate->pUalgParams)->nIsSparkInput = 1;
   5930                 OMX_PRBUFFER1(pComponentPrivate->dbg, "lBuffCount 0x%lx\n",
   5931                     ((SPARKVD_GPP_SN_UALGInputParams*)pComponentPrivate->pUalgParams)->lBuffCount);
   5932             }
   5933 #endif
   5934             else {
   5935                 eError = OMX_ErrorUnsupportedSetting;
   5936                 goto EXIT;
   5937             }
   5938 
   5939 #ifdef __PERF_INSTRUMENTATION__
   5940             PERF_SendingFrame(pComponentPrivate->pPERFcomp,
   5941                               NULL, 0,
   5942                               PERF_ModuleCommonLayer);
   5943 #endif
   5944             if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   5945                 pComponentPrivate->eLCMLState != VidDec_LCML_State_Destroy &&
   5946                 pComponentPrivate->pLCML != NULL){
   5947                 pComponentPrivate->pTempBuffHead.nFlags = 0;
   5948                 //pComponentPrivate->pTempBuffHead.nFlags |= OMX_BUFFERFLAG_EOS;
   5949                 pComponentPrivate->pTempBuffHead.nFilledLen = 0;
   5950                 pComponentPrivate->pTempBuffHead.pBuffer = NULL;
   5951 
   5952 #ifdef __PERF_INSTRUMENTATION__
   5953                 PERF_SendingFrame(pComponentPrivate->pPERFcomp,
   5954                                   pBuffHead->pBuffer,
   5955                                   pBuffHead->nFilledLen,
   5956                                   PERF_ModuleHLMM);
   5957 #endif
   5958 
   5959                 if(pComponentPrivate->bDynamicConfigurationInProgress){
   5960                     pBufferPrivate = (VIDDEC_BUFFER_PRIVATE* )pBuffHead->pInputPortPrivate;
   5961                     pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_CLIENT;
   5962                     OMX_PRBUFFER1(pComponentPrivate->dbg, "eBufferOwner 0x%x\n", pBufferPrivate->eBufferOwner);
   5963                     OMX_PRBUFFER2(pComponentPrivate->dbg, "Sending buffer back to client pBuffer=%p\n", pBuffHead->pBuffer);
   5964                     VIDDEC_EmptyBufferDone(pComponentPrivate, pBuffHead);
   5965                     goto EXIT;
   5966                 }
   5967 
   5968                 OMX_PRDSP2(pComponentPrivate->dbg, "LCML_QueueBuffer(INPUT)\n");
   5969 
   5970                 /* Verify if first buffer as been stored.
   5971                  * Handle case were only one frame is decoded */
   5972                 if(pComponentPrivate->eFirstBuffer.bSaveFirstBuffer){
   5973                     if (pBuffHead->nFlags & OMX_BUFFERFLAG_EOS){
   5974                         pComponentPrivate->firstBufferEos = OMX_TRUE;
   5975                     }
   5976                     eError = VIDDEC_CopyBuffer(pComponentPrivate, pBuffHead);
   5977                     if (eError != OMX_ErrorNone) {
   5978                         OMX_PRDSP4(pComponentPrivate->dbg, "VIDDEC_HandleDataBuf_FromApp: VIDDEC_CopyBuffer()= 0x%x\n", eError);
   5979                         if (eError == OMX_ErrorInsufficientResources) {
   5980                             goto EXIT;
   5981                         }
   5982                     }
   5983                     pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_DSP;
   5984                     eError = LCML_QueueBuffer(((LCML_DSP_INTERFACE*)
   5985                                                 pLcmlHandle)->pCodecinterfacehandle,
   5986                                                 ((pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV) ? EMMCodecInputBufferMapBufLen : EMMCodecInputBuffer),
   5987                                                 &pBuffHead->pBuffer[pBuffHead->nOffset],/*WMV_VC1_CHANGES*/
   5988                                                 pBuffHead->nAllocLen,
   5989                                                 pBuffHead->nFilledLen,
   5990                                                 (OMX_U8 *)pComponentPrivate->pUalgParams,
   5991                                                 size_dsp,
   5992                                                 (OMX_U8 *)pBuffHead);
   5993                     if (eError != OMX_ErrorNone){
   5994                         OMX_PRDSP4(pComponentPrivate->dbg, "LCML_QueueBuffer EOS (0x%x)\n",eError);
   5995                         eError = OMX_ErrorHardware;
   5996                         goto EXIT;
   5997                     }
   5998                 }
   5999                 else{
   6000                     eError = LCML_QueueBuffer(pLcmlHandle->pCodecinterfacehandle,
   6001                                                   ((pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV) ? EMMCodecInputBufferMapBufLen : EMMCodecInputBuffer),
   6002                                                   NULL,
   6003                                                   0,
   6004                                                   0,
   6005                                                   (OMX_U8 *)pComponentPrivate->pUalgParams,
   6006                                                   size_dsp,
   6007                                                   (OMX_PTR)&pComponentPrivate->pTempBuffHead);
   6008                 }
   6009                 if (eError != OMX_ErrorNone){
   6010                     OMX_PRDSP4(pComponentPrivate->dbg, "LCML_QueueBuffer 1 (0x%x)\n",eError);
   6011                     eError = OMX_ErrorHardware;
   6012                     goto EXIT;
   6013                 }
   6014             }
   6015             else {
   6016                 eError = OMX_ErrorHardware;
   6017                 goto EXIT;
   6018             }
   6019         }
   6020     }
   6021     else {
   6022         pComponentPrivate->iEndofInputSent = 0;
   6023         if(pBuffHead->nFilledLen != 0) {
   6024             if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
   6025                 pUalgInpParams = pBufferPrivate->pUalgParam;
   6026                 if ((pBuffHead->nFlags & OMX_BUFFERFLAG_EOS) == 0) {
   6027                     ((H264VDEC_UALGInputParam *)pUalgInpParams)->lBuffCount = ++pComponentPrivate->frameCounter;
   6028                     if (pComponentPrivate->H264BitStreamFormat) {
   6029                         H264VDEC_UALGInputParam *pParam;
   6030 #ifndef ANDROID
   6031                         OMX_U32 nal_len, i;
   6032                         OMX_U8 *pDataBuf;
   6033                         OMX_U32 length_pos = 0;
   6034                         OMX_U32 data_pos = 0;
   6035                         OMX_U32 buf_len;
   6036 
   6037                         buf_len = pBuffHead->nFilledLen;
   6038                         pDataBuf = pBuffHead->pBuffer;
   6039                         pParam = (H264VDEC_UALGInputParam *)pUalgInpParams;
   6040                         pParam->ulNumOfNALU = 0;
   6041                         while (pBuffHead->nFilledLen > length_pos+pComponentPrivate->H264BitStreamFormat) {
   6042                             if (pComponentPrivate->H264BitStreamFormat == 1)
   6043                                 if (pComponentPrivate->bIsNALBigEndian) {
   6044                                     nal_len = (OMX_U32)pDataBuf[length_pos];
   6045                                 }
   6046                                 else {
   6047                                     nal_len = (OMX_U32)pDataBuf[length_pos];
   6048                                 }
   6049                             else if (pComponentPrivate->H264BitStreamFormat == 2)
   6050                                 if (pComponentPrivate->bIsNALBigEndian) {
   6051                                     nal_len = (OMX_U32)pDataBuf[length_pos] << 8 | pDataBuf[length_pos+1];
   6052                                 }
   6053                                 else {
   6054                                     nal_len = (OMX_U32)pDataBuf[length_pos] << 0 | pDataBuf[length_pos+1] << 8 ;
   6055                                 }
   6056                             else if (pComponentPrivate->H264BitStreamFormat == 4){
   6057                                 if (pComponentPrivate->bIsNALBigEndian) {
   6058                                     nal_len = (OMX_U32)pDataBuf[length_pos]<<24 | pDataBuf[length_pos+1] << 16 | pDataBuf[length_pos+2] << 8 | pDataBuf[length_pos+3];
   6059                                 }
   6060                                 else {
   6061                                     nal_len = (OMX_U32)pDataBuf[length_pos]<<0 | pDataBuf[length_pos+1] << 8 | pDataBuf[length_pos+2] << 16 | pDataBuf[length_pos+3]<<24;
   6062                                 }
   6063                             }
   6064                             else {
   6065                                 eError = OMX_ErrorBadParameter;
   6066                                 goto EXIT;
   6067                             }
   6068                             length_pos += pComponentPrivate->H264BitStreamFormat;
   6069                             if (nal_len > buf_len - length_pos) {
   6070                                 eError = OMX_ErrorBadParameter;
   6071                                 goto EXIT;
   6072                             }
   6073                             /* move the memory*/
   6074                             for (i=0; i<nal_len; i++)
   6075                                 pDataBuf[data_pos+i] = pDataBuf[length_pos+i];
   6076                             data_pos += nal_len;
   6077                             length_pos += nal_len;
   6078                             /* save the size*/
   6079                             pParam->pNALUSizeArray[pParam->ulNumOfNALU++] = nal_len;
   6080                         }
   6081                         /* update with the new data size*/
   6082                         pBuffHead->nFilledLen = data_pos;
   6083 #else
   6084                         pParam = (H264VDEC_UALGInputParam *)pUalgInpParams;
   6085                         pParam->ulNumOfNALU = 0;
   6086 
   6087                         if (pBuffHead->nFlags >= OMX_BUFFERFLAG_CODECCONFIG) {
   6088                             OMX_PRINT1(pComponentPrivate->dbg,"nFlags = %x\n", pBuffHead->nFlags);
   6089                             OMX_PRINT1(pComponentPrivate->dbg,"copy previous codec config data to current ccd buffer\n");
   6090                             eError = VIDDEC_CopyBuffer(pComponentPrivate, pBuffHead);
   6091 
   6092                             OMX_PRINT1(pComponentPrivate->dbg,"save current ccd buff - nFilledLen = %d\n", pBuffHead->nFilledLen);
   6093                             eError = VIDDEC_SaveBuffer(pComponentPrivate, pBuffHead);
   6094                             pComponentPrivate->aCCDsize[pComponentPrivate->nCCDcnt++] = pBuffHead->nFilledLen;
   6095 
   6096                             OMX_PRINT1(pComponentPrivate->dbg,"send ccd buffer back to client\n");
   6097                             pBufferPrivate = (VIDDEC_BUFFER_PRIVATE* )pBuffHead->pInputPortPrivate;
   6098                             pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_CLIENT;
   6099                             VIDDEC_EmptyBufferDone(pComponentPrivate, pBuffHead);
   6100                             goto EXIT;
   6101                         }
   6102                         else {
   6103                             H264VDEC_UALGInputParam *pParam;
   6104                             OMX_U32 len     = 0; /* offset+filledlen+padding */
   6105                             OMX_U32 off     = 0; /* offset */
   6106                             OMX_U32 fl      = 0; /* filledlen */
   6107                             OMX_U32 rem     = 0; /* modulus */
   6108                             OMX_U32 pad     = 0; /* padding */
   6109                             OMX_U32 numnalu = 0; /* number of nal units */
   6110                             OMX_U32 sp      = 0; /* starting position of 4 byte nDataSize */
   6111                             OMX_U32 nalusize[256] = {0}; /* array to store nal sizes */
   6112                             OMX_U32 i       = 0;
   6113                             OMX_U32 j       = 0;
   6114                             OMX_U32 t1      = 0;
   6115                             OMX_U32 t2      = 0;
   6116 
   6117                             /* This is how pBuffer is arranged when
   6118                              * iOMXComponentUsesFullAVCFrames is set
   6119                              * to true
   6120                              */
   6121 
   6122                             /* offset,
   6123                              * NALU1, NALU2, ...
   6124                              * padding,
   6125                              * nSize,
   6126                              * nVersion,
   6127                              * nPortIndex,
   6128                              * eType,
   6129                              * nDataSize,
   6130                              * NAL1Len, NAL2Len, ...
   6131                              */
   6132 
   6133                             pParam = (H264VDEC_UALGInputParam *)pUalgInpParams;
   6134                             pParam->ulNumOfNALU = 0;
   6135                             off = pBuffHead->nOffset;
   6136                             fl  = pBuffHead->nFilledLen;
   6137                             rem = (off + fl) % 4;
   6138                             if (rem > 0) {
   6139                                 pad = 4 - rem;
   6140                             }
   6141 
   6142                             len = off + fl + pad;
   6143                             OMX_PRINT1(pComponentPrivate->dbg,"nFlags = %x\n", pBuffHead->nFlags);
   6144                             OMX_PRINT1(pComponentPrivate->dbg,"off=%d,fl=%d,rem=%d,pad=%d,len=%d\n", off, fl, rem, pad, len);
   6145 
   6146                             /* print the OMX_ExtraDataNALSizeArry marker */
   6147                             OMX_PRINT1(pComponentPrivate->dbg,"extradata marker -> 0x %x %x %x %x\n",
   6148                                                             pBuffHead->pBuffer[len+15],
   6149                                                             pBuffHead->pBuffer[len+14],
   6150                                                             pBuffHead->pBuffer[len+13],
   6151                                                             pBuffHead->pBuffer[len+12]);
   6152 
   6153                             /* store number of numnalu */
   6154                             ((OMX_U8*)(&numnalu))[3] = pBuffHead->pBuffer[len+19];
   6155                             ((OMX_U8*)(&numnalu))[2] = pBuffHead->pBuffer[len+18];
   6156                             ((OMX_U8*)(&numnalu))[1] = pBuffHead->pBuffer[len+17];
   6157                             ((OMX_U8*)(&numnalu))[0] = pBuffHead->pBuffer[len+16];
   6158                             numnalu /= 4;
   6159 
   6160                             /* print the numnalu */
   6161                             OMX_PRINT1(pComponentPrivate->dbg,"numnalu -> 0x %x %x %x %x\n", ((OMX_U8*)(&numnalu))[3]
   6162                                                         , ((OMX_U8*)(&numnalu))[2]
   6163                                                         , ((OMX_U8*)(&numnalu))[1]
   6164                                                         , ((OMX_U8*)(&numnalu))[0]);
   6165 
   6166                             /* print the nDataSize */
   6167                             OMX_PRINT1(pComponentPrivate->dbg,"nDataSize -> 0x %x %x %x %x\n", pBuffHead->pBuffer[len+19]
   6168                                                         , pBuffHead->pBuffer[len+18]
   6169                                                         , pBuffHead->pBuffer[len+17]
   6170                                                         , pBuffHead->pBuffer[len+16]);
   6171                             /* print the first NALU len */
   6172                             OMX_PRINT1(pComponentPrivate->dbg,"first NALU len -> 0x %x %x %x %x\n", pBuffHead->pBuffer[len+23]
   6173                                                         , pBuffHead->pBuffer[len+22]
   6174                                                         , pBuffHead->pBuffer[len+21]
   6175                                                         , pBuffHead->pBuffer[len+20]);
   6176                             pParam->ulNumOfNALU = 0;
   6177 
   6178                             /* starting position of nalu sizes */
   6179                             sp = t1 = len+20;
   6180                             t2 = i;
   6181 
   6182                             OMX_PRINT1(pComponentPrivate->dbg,"numnalu = %d", numnalu);
   6183 
   6184                             while (i<(t2+numnalu)) {
   6185                                 j=0;
   6186                                 while (sp<(t1+4)) {
   6187                                     ((OMX_U8*)(&nalusize[i]))[j] = pBuffHead->pBuffer[sp];
   6188                                     sp++;
   6189                                     j++;
   6190                                 }
   6191                                 t1 = sp;
   6192                                 i++;
   6193                             }
   6194                             OMX_PRINT1(pComponentPrivate->dbg,"confirm ulNumOfNALU = %d\n", i);
   6195 
   6196                             if (pComponentPrivate->bCopiedCCDBuffer == OMX_FALSE){
   6197                                 pComponentPrivate->bCopiedCCDBuffer = OMX_TRUE;
   6198                                 OMX_PRINT1(pComponentPrivate->dbg,"copy saved ccd buffer to data buffer\n");
   6199                                 eError = VIDDEC_CopyBuffer(pComponentPrivate, pBuffHead);
   6200 
   6201                                 i=0;
   6202                                 /* tally number of ccd nalus and add sizes to nalu array */
   6203                                 while (i < pComponentPrivate->nCCDcnt) {
   6204                                     if (i == 0) {
   6205                                         pParam->pNALUSizeArray[i] = pComponentPrivate->aCCDsize[i];
   6206                                     }
   6207                                     else {
   6208                                         pParam->pNALUSizeArray[i] = pComponentPrivate->aCCDsize[i] -
   6209                                                                     pComponentPrivate->aCCDsize[i-1];
   6210                                     }
   6211                                     pParam->ulNumOfNALU++;
   6212                                     OMX_PRINT1(pComponentPrivate->dbg,"aCCDsize[%d] = %d\n", i, pParam->pNALUSizeArray[i]);
   6213                                     i++;
   6214                                 }
   6215 
   6216                                 /* adjust the filled length to account for the ccd nalus */
   6217                                 pBuffHead->nFilledLen = fl + pComponentPrivate->aCCDsize[i-1];
   6218 
   6219                                 OMX_PRINT1(pComponentPrivate->dbg,"new nFilledLen=%d; old fl=%d + aCCDsize=%d\n", pBuffHead->nFilledLen
   6220                                                                        , fl
   6221                                                                        , pComponentPrivate->aCCDsize[i-1]);
   6222                                 t1 = i;
   6223                                 j=0;
   6224 
   6225                                 /* now, add the data nalu sizes to the array,
   6226                                  * which already contain the ccd nalu sizes */
   6227                                 for(;i<t1+numnalu;i++) {
   6228                                     pParam->pNALUSizeArray[i] = nalusize[j];
   6229                                     j++;
   6230                                 }
   6231                                 pParam->ulNumOfNALU = i+numnalu;
   6232 
   6233                                 for(j=0;j<i;j++) {
   6234                                     OMX_PRINT1(pComponentPrivate->dbg,"pParm->pNALUSizeArray[%d] = %d\n",j,pParam->pNALUSizeArray[j]);
   6235                                 }
   6236                             }
   6237                             else {
   6238                                 /* add the data nalu sizes to the array.
   6239                                  * we should not have any ccd sizes in here */
   6240                                 for(j=0;j<i;j++) {
   6241                                     pParam->pNALUSizeArray[j] = nalusize[j];
   6242                                     OMX_PRINT1(pComponentPrivate->dbg,"pParm->pNALUSizeArray[%d] = %d\n",j,pParam->pNALUSizeArray[j]);
   6243                                 }
   6244                                 pParam->ulNumOfNALU = i;
   6245                             }
   6246                         }/* end else */
   6247 #endif
   6248                     }/* end bitstrm fmt */
   6249                 }/* end nFlags & EOS */
   6250                 size_dsp = sizeof(H264VDEC_UALGInputParam);
   6251             }/* end if AVC */
   6252             else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV) {
   6253                 pUalgInpParams = pBufferPrivate->pUalgParam;
   6254                 if ((pBuffHead->nFlags & OMX_BUFFERFLAG_EOS) == 0) {
   6255                     ((WMV9DEC_UALGInputParam*)pUalgInpParams)->lBuffCount = ++pComponentPrivate->frameCounter;
   6256                 }
   6257                 size_dsp = sizeof(WMV9DEC_UALGInputParam);
   6258             }
   6259             else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 ||
   6260                      pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) {
   6261                 pUalgInpParams = pBufferPrivate->pUalgParam;
   6262                 ((MP4VD_GPP_SN_UALGInputParams*)pUalgInpParams)->uRingIOBlocksize = 0;
   6263                 ((MP4VD_GPP_SN_UALGInputParams*)pUalgInpParams)->nPerformMode = 2;
   6264 
   6265                if ((pBuffHead->nFlags & OMX_BUFFERFLAG_EOS) == 0) {
   6266                     ((MP4VD_GPP_SN_UALGInputParams*)pUalgInpParams)->nBuffCount = ++pComponentPrivate->frameCounter;
   6267                 }
   6268                 size_dsp = sizeof(MP4VD_GPP_SN_UALGInputParams);
   6269             }
   6270             else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG2) {
   6271                 pUalgInpParams = pBufferPrivate->pUalgParam;
   6272                 if ((pBuffHead->nFlags & OMX_BUFFERFLAG_EOS) == 0) {
   6273                     ((MP2VDEC_UALGInputParam*)pUalgInpParams)->lBuffCount = ++pComponentPrivate->frameCounter;
   6274                 }
   6275                 size_dsp = sizeof(MP2VDEC_UALGInputParam);
   6276             }
   6277 #ifdef VIDDEC_SPARK_CODE
   6278             else if (VIDDEC_SPARKCHECK) {
   6279                 pUalgInpParams = pBufferPrivate->pUalgParam;
   6280                 if ((pBuffHead->nFlags & OMX_BUFFERFLAG_EOS) == 0) {
   6281                     ((SPARKVD_GPP_SN_UALGInputParams*)pUalgInpParams)->lBuffCount = ++pComponentPrivate->frameCounter;
   6282                 }
   6283                 ((SPARKVD_GPP_SN_UALGInputParams*)pUalgInpParams)->nIsSparkInput = 1;
   6284                 size_dsp = sizeof(SPARKVD_GPP_SN_UALGInputParams);
   6285             }
   6286 #endif
   6287             else {
   6288                 eError = OMX_ErrorUnsupportedSetting;
   6289                 OMX_PRBUFFER4(pComponentPrivate->dbg, "VIDDEC_HandleDataBuf_FromApp 0x%x\n", eError);
   6290                 goto EXIT;
   6291             }
   6292             /* Store time stamp information */
   6293             if (pComponentPrivate->ProcessMode == 0) {
   6294                 OMX_U8 ucIndex = 0;
   6295                 OMX_PTR pBufferFlags = NULL;
   6296 		if ((pBuffHead->nFlags & OMX_BUFFERFLAG_CODECCONFIG) == 0 ) {	//tag if not equal to OMX_BUFFERFLAG_CODECCONFIG
   6297                     ucIndex = VIDDEC_CircBuf_GetHead(pComponentPrivate,
   6298                                                  VIDDEC_CBUFFER_TIMESTAMP,
   6299                                                  VIDDEC_INPUT_PORT);
   6300                     pComponentPrivate->aBufferFlags[ucIndex].nTimeStamp = pBuffHead->nTimeStamp;
   6301                     pBuffHead->nFlags &= ~OMX_BUFFERFLAG_EOS;
   6302                     pComponentPrivate->aBufferFlags[ucIndex].nFlags = pBuffHead->nFlags;
   6303                     pComponentPrivate->aBufferFlags[ucIndex].nTickCount = pBuffHead->nTickCount;
   6304                     pBufferFlags = &pComponentPrivate->aBufferFlags[ucIndex];
   6305                     VIDDEC_CircBuf_Add(pComponentPrivate,
   6306                                    VIDDEC_CBUFFER_TIMESTAMP,
   6307                                    VIDDEC_INPUT_PORT,
   6308                                    pBufferFlags);
   6309                 }
   6310             }
   6311             else {
   6312                 pComponentPrivate->arrBufIndex[pComponentPrivate->nInBufIndex] = pBuffHead->nTimeStamp;
   6313                 pComponentPrivate->nInBufIndex++;
   6314                 pComponentPrivate->nInBufIndex %= VIDDEC_MAX_QUEUE_SIZE;
   6315             }
   6316             OMX_PRBUFFER1(pComponentPrivate->dbg, "pBuffHead->nTimeStamp %lld\n", pBuffHead->nTimeStamp);
   6317             OMX_PRBUFFER1(pComponentPrivate->dbg, "pBuffHead->nOffset %lu\n", pBuffHead->nOffset);
   6318     #ifdef __PERF_INSTRUMENTATION__
   6319             PERF_SendingFrame(pComponentPrivate->pPERFcomp,
   6320                               pBuffHead->pBuffer,
   6321                               pBuffHead->nFilledLen,
   6322                               PERF_ModuleCommonLayer);
   6323     #endif
   6324             if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   6325                 pComponentPrivate->eLCMLState != VidDec_LCML_State_Destroy &&
   6326                 pComponentPrivate->pLCML != NULL){
   6327                 pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_DSP;
   6328                 OMX_PRBUFFER1(pComponentPrivate->dbg, "pBuffHead->nFilledLen %lu\n", pBuffHead->nFilledLen);
   6329                 OMX_PRBUFFER1(pComponentPrivate->dbg, "Sending Filled eBufferOwner 0x%x f%x\n", pBufferPrivate->eBufferOwner, pComponentPrivate->frameCounter);
   6330 
   6331 
   6332 #ifdef __PERF_INSTRUMENTATION__
   6333                     PERF_SendingFrame(pComponentPrivate->pPERFcomp,
   6334                                       pBuffHead->pBuffer,
   6335                                       pBuffHead->nFilledLen,
   6336                                       PERF_ModuleHLMM);
   6337 #endif
   6338 
   6339                 if(pComponentPrivate->bDynamicConfigurationInProgress){
   6340                     pBufferPrivate = (VIDDEC_BUFFER_PRIVATE* )pBuffHead->pInputPortPrivate;
   6341                     pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_CLIENT;
   6342                     OMX_PRBUFFER1(pComponentPrivate->dbg, "eBufferOwner 0x%x\n", pBufferPrivate->eBufferOwner);
   6343 
   6344                     OMX_PRBUFFER2(pComponentPrivate->dbg, "Sending buffer back to client pBuffer=%p\n", pBuffHead->pBuffer);
   6345                     VIDDEC_EmptyBufferDone(pComponentPrivate, pBuffHead);
   6346                     goto EXIT;
   6347                 }
   6348 #ifdef ANDROID
   6349 
   6350                     if(pComponentPrivate->eFirstBuffer.bSaveFirstBuffer == OMX_TRUE){
   6351                         if(pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV &&
   6352                                 pComponentPrivate->nWMVFileType == VIDDEC_WMV_RCVSTREAM){
   6353                             ((WMV9DEC_UALGInputParam*)pComponentPrivate->pUalgParams)->lBuffCount = ++pComponentPrivate->frameCounter;
   6354                             eError = LCML_QueueBuffer(((LCML_DSP_INTERFACE*)
   6355                                                         pLcmlHandle)->pCodecinterfacehandle,
   6356                                                         EMMCodecInputBufferMapBufLen,
   6357                                                         (OMX_U8*)&pComponentPrivate->pBufferRCV.pBuffer,
   6358                                                         sizeof(VIDDEC_WMV_RCV_struct),
   6359                                                         sizeof(VIDDEC_WMV_RCV_struct),
   6360                                                         (OMX_U8 *)pUalgInpParams,
   6361                                                         sizeof(WMV9DEC_UALGInputParam),
   6362                                                         (OMX_U8*)&pComponentPrivate->pBufferTemp);
   6363                         }
   6364                         else {
   6365                             eError = VIDDEC_CopyBuffer(pComponentPrivate, pBuffHead);
   6366                             if (eError != OMX_ErrorNone) {
   6367                                 OMX_PRDSP4(pComponentPrivate->dbg, "VIDDEC_HandleDataBuf_FromApp: VIDDEC_CopyBuffer()= 0x%x\n", eError);
   6368                                 if (eError == OMX_ErrorInsufficientResources) {
   6369                                     goto EXIT;
   6370                                 }
   6371                             }
   6372                         }
   6373                     }
   6374 #endif
   6375 
   6376                 OMX_PRDSP2(pComponentPrivate->dbg, "LCML_QueueBuffer(INPUT), nFilledLen=0x%x nFlags=0x%x", pBuffHead->nFilledLen, pBuffHead->nFlags);
   6377                 pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_DSP;
   6378                 eError = LCML_QueueBuffer(((LCML_DSP_INTERFACE*)
   6379                                             pLcmlHandle)->pCodecinterfacehandle,
   6380                                             ((pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV) ? EMMCodecInputBufferMapBufLen : EMMCodecInputBuffer), /*Only WMV need to send map buffers */
   6381                                             &pBuffHead->pBuffer[pBuffHead->nOffset],/*WMV_VC1_CHANGES*/
   6382                                             pBuffHead->nAllocLen,
   6383                                             pBuffHead->nFilledLen,
   6384                                             (OMX_U8 *)pUalgInpParams,
   6385                                             size_dsp,
   6386                                             (OMX_U8 *)pBuffHead);
   6387                 if (eError != OMX_ErrorNone){
   6388                     OMX_PRDSP4(pComponentPrivate->dbg, "LCML_QueueBuffer 2 (0x%x)\n",eError);
   6389                     eError = OMX_ErrorHardware;
   6390                     goto EXIT;
   6391                 }
   6392             }
   6393             else {
   6394                 eError = OMX_ErrorHardware;
   6395                 goto EXIT;
   6396             }
   6397         }
   6398         else {
   6399             pBuffHead->nFilledLen = 0;
   6400             pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_COMPONENT;
   6401             OMX_PRBUFFER1(pComponentPrivate->dbg, "eBufferOwner 0x%x\n", pBufferPrivate->eBufferOwner);
   6402             eError = IncrementCount (&(pComponentPrivate->nCountInputBFromDsp), &(pComponentPrivate->mutexInputBFromDSP));
   6403             if (eError != OMX_ErrorNone) {
   6404                 return eError;
   6405             }
   6406             ret = write(pComponentPrivate->free_inpBuf_Q[1], &pBuffHead, sizeof(pBuffHead));
   6407             if(ret == -1){
   6408                 OMX_PRCOMM4(pComponentPrivate->dbg, "writing to the input pipe %x (%d)\n", OMX_ErrorInsufficientResources,ret);
   6409                 pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_DSP;
   6410                 DecrementCount (&(pComponentPrivate->nCountInputBFromDsp), &(pComponentPrivate->mutexInputBFromDSP));
   6411                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   6412                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   6413                                                        OMX_EventError,
   6414                                                        OMX_ErrorInsufficientResources,
   6415                                                        OMX_TI_ErrorSevere,
   6416                                                        "Error writing to the output pipe");
   6417             }
   6418         }
   6419     }
   6420 EXIT:
   6421     OMX_PRBUFFER1(pComponentPrivate->dbg, "---EXITING(0x%x)\n",eError);
   6422     return eError;
   6423 }
   6424 
   6425 /* ========================================================================== */
   6426 /**
   6427   *  Handle Data Buff function from DSP
   6428   **/
   6429 /* ========================================================================== */
   6430 
   6431 OMX_ERRORTYPE VIDDEC_HandleDataBuf_FromDsp(VIDDEC_COMPONENT_PRIVATE *pComponentPrivate)
   6432 {
   6433     OMX_ERRORTYPE eError = OMX_ErrorNone;
   6434     OMX_ERRORTYPE eExtendedError = OMX_ErrorNone;
   6435     OMX_BUFFERHEADERTYPE* pBuffHead;
   6436     VIDDEC_BUFFER_PRIVATE* pBufferPrivate = NULL;
   6437     int ret;
   6438 
   6439     OMX_PRBUFFER1(pComponentPrivate->dbg, "+++ENTERING\n");
   6440     OMX_PRBUFFER1(pComponentPrivate->dbg, "pComponentPrivate 0x%p\n", (int*)pComponentPrivate);
   6441     ret = read(pComponentPrivate->filled_outBuf_Q[0], &pBuffHead, sizeof(pBuffHead));
   6442     if (ret == -1) {
   6443         OMX_PRDSP4(pComponentPrivate->dbg, "Error while reading from dsp out pipe\n");
   6444         eError = OMX_ErrorHardware;
   6445         goto EXIT;
   6446     }
   6447     eError = DecrementCount (&(pComponentPrivate->nCountOutputBFromDsp), &(pComponentPrivate->mutexOutputBFromDSP));
   6448     if (eError != OMX_ErrorNone) {
   6449         return eError;
   6450     }
   6451     OMX_PRBUFFER1(pComponentPrivate->dbg, "BufferSize fromDSP %lu \n",pBuffHead->nAllocLen);
   6452     OMX_PRBUFFER1(pComponentPrivate->dbg, "AllocLen: 0x%x, FilledLen: 0x%x\n", pBuffHead->nAllocLen, pBuffHead->nFilledLen);
   6453     OMX_PRSTATE1(pComponentPrivate->dbg, "pBuffHead 0x%p eExecuteToIdle 0x%x\n", pBuffHead,pComponentPrivate->eExecuteToIdle);
   6454     if (pComponentPrivate->eState == OMX_StateLoaded || pComponentPrivate->eState == OMX_StateIdle) {
   6455         eError = OMX_ErrorNone;
   6456         goto EXIT;
   6457     }
   6458     OMX_PRBUFFER1(pComponentPrivate->dbg, "BufferSize fromDSP %lu \n",pBuffHead->nAllocLen);
   6459     OMX_PRBUFFER1(pComponentPrivate->dbg, "AllocLen: 0x%x, FilledLen: 0x%x\n", pBuffHead->nAllocLen, pBuffHead->nFilledLen);
   6460     OMX_PRSTATE1(pComponentPrivate->dbg, "pBuffHead 0x%p eExecuteToIdle 0x%x\n", pBuffHead,pComponentPrivate->eExecuteToIdle);
   6461     if(pBuffHead != NULL) {
   6462         OMX_S32 nErrorCode = 0;
   6463         OMX_S32 nInternalErrorCode = 0;
   6464         OMX_U32 ulDisplayID = 0;
   6465         pBufferPrivate = (VIDDEC_BUFFER_PRIVATE* )pBuffHead->pOutputPortPrivate;
   6466         pBuffHead->nFlags &= ~(OMX_BUFFERFLAG_SYNCFRAME);
   6467         pBuffHead->nFlags &= ~(VIDDEC_BUFFERFLAG_FRAMETYPE_MASK);
   6468         pBuffHead->nFlags &= ~(VIDDEC_BUFFERFLAG_EXTENDERROR_MASK);
   6469 
   6470         if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
   6471             H264VDEC_UALGOutputParam* pUalgOutParams = NULL;
   6472             pUalgOutParams = (H264VDEC_UALGOutputParam *)pBufferPrivate->pUalgParam;
   6473             nErrorCode = (pUalgOutParams->iErrorCode);
   6474             ulDisplayID = pUalgOutParams->ulDisplayID;
   6475             if(pUalgOutParams->ulDecodedFrameType == VIDDEC_I_FRAME) {
   6476                 pBuffHead->nFlags |= OMX_BUFFERFLAG_SYNCFRAME;
   6477                 pBuffHead->nFlags |= VIDDEC_BUFFERFLAG_FRAMETYPE_I_FRAME;
   6478             }
   6479             else if(pUalgOutParams->ulDecodedFrameType == VIDDEC_P_FRAME){
   6480                 pBuffHead->nFlags |= VIDDEC_BUFFERFLAG_FRAMETYPE_P_FRAME;
   6481             }
   6482             else if(pUalgOutParams->ulDecodedFrameType == VIDDEC_B_FRAME){
   6483                 pBuffHead->nFlags |= VIDDEC_BUFFERFLAG_FRAMETYPE_B_FRAME;
   6484             }
   6485             else {
   6486                 pBuffHead->nFlags |= VIDDEC_BUFFERFLAG_FRAMETYPE_IDR_FRAME;
   6487             }
   6488             /*VIDDEC_ISFLAGSET*/
   6489         }
   6490         else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV) {
   6491             WMV9DEC_UALGOutputParam* pUalgOutParams = NULL;
   6492             pUalgOutParams = (WMV9DEC_UALGOutputParam *)pBufferPrivate->pUalgParam;
   6493             nErrorCode = (pUalgOutParams->iErrorCode);
   6494             ulDisplayID = pUalgOutParams->ulDisplayID;
   6495             if(pUalgOutParams->ulDecodedFrameType == VIDDEC_I_FRAME) {
   6496                 pBuffHead->nFlags |= OMX_BUFFERFLAG_SYNCFRAME;
   6497                 pBuffHead->nFlags |= VIDDEC_BUFFERFLAG_FRAMETYPE_I_FRAME;
   6498             }
   6499             else if(pUalgOutParams->ulDecodedFrameType == VIDDEC_P_FRAME){
   6500                 pBuffHead->nFlags |= VIDDEC_BUFFERFLAG_FRAMETYPE_P_FRAME;
   6501             }
   6502             else if(pUalgOutParams->ulDecodedFrameType == VIDDEC_B_FRAME){
   6503                 pBuffHead->nFlags |= VIDDEC_BUFFERFLAG_FRAMETYPE_B_FRAME;
   6504             }
   6505             else {
   6506                 pBuffHead->nFlags |= VIDDEC_BUFFERFLAG_FRAMETYPE_IDR_FRAME;
   6507             }
   6508         }
   6509         else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 ||
   6510                      pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) {
   6511             MP4VD_GPP_SN_UALGOutputParams* pUalgOutParams = NULL;
   6512             pUalgOutParams = (MP4VD_GPP_SN_UALGOutputParams *)pBufferPrivate->pUalgParam;
   6513             nErrorCode = (pUalgOutParams->iErrorCode);
   6514             ulDisplayID = pUalgOutParams->ulDisplayID;
   6515             if(pUalgOutParams->ulDecodedFrameType == VIDDEC_I_FRAME) {
   6516                 pBuffHead->nFlags |= OMX_BUFFERFLAG_SYNCFRAME;
   6517                 pBuffHead->nFlags |= VIDDEC_BUFFERFLAG_FRAMETYPE_I_FRAME;
   6518             }
   6519             else if(pUalgOutParams->ulDecodedFrameType == VIDDEC_P_FRAME){
   6520                 pBuffHead->nFlags |= VIDDEC_BUFFERFLAG_FRAMETYPE_P_FRAME;
   6521             }
   6522             else if(pUalgOutParams->ulDecodedFrameType == VIDDEC_B_FRAME){
   6523                 pBuffHead->nFlags |= VIDDEC_BUFFERFLAG_FRAMETYPE_B_FRAME;
   6524             }
   6525             else {
   6526                 pBuffHead->nFlags |= VIDDEC_BUFFERFLAG_FRAMETYPE_IDR_FRAME;
   6527             }
   6528         }
   6529         else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG2) {
   6530             MP2VDEC_UALGOutputParam* pUalgOutParams = NULL;
   6531             pUalgOutParams = (MP2VDEC_UALGOutputParam *)pBufferPrivate->pUalgParam;
   6532             nErrorCode = (pUalgOutParams->lErrorCode);
   6533             ulDisplayID = pUalgOutParams->ulDisplayID;
   6534             if(pUalgOutParams->ulDecodedFrameType == VIDDEC_I_FRAME) {
   6535                 pBuffHead->nFlags |= OMX_BUFFERFLAG_SYNCFRAME;
   6536                 pBuffHead->nFlags |= VIDDEC_BUFFERFLAG_FRAMETYPE_I_FRAME;
   6537             }
   6538             else if(pUalgOutParams->ulDecodedFrameType == VIDDEC_P_FRAME){
   6539                 pBuffHead->nFlags |= VIDDEC_BUFFERFLAG_FRAMETYPE_P_FRAME;
   6540             }
   6541             else if(pUalgOutParams->ulDecodedFrameType == VIDDEC_B_FRAME){
   6542                 pBuffHead->nFlags |= VIDDEC_BUFFERFLAG_FRAMETYPE_B_FRAME;
   6543             }
   6544             else {
   6545                 pBuffHead->nFlags |= VIDDEC_BUFFERFLAG_FRAMETYPE_IDR_FRAME;
   6546             }
   6547         }
   6548 #ifdef VIDDEC_SPARK_CODE
   6549         else if (VIDDEC_SPARKCHECK) {
   6550             SPARKVD_GPP_SN_UALGOutputParams* pUalgOutParams = NULL;
   6551             pUalgOutParams = (SPARKVD_GPP_SN_UALGOutputParams *)pBufferPrivate->pUalgParam;
   6552             nErrorCode = (pUalgOutParams->iErrorCode);
   6553             ulDisplayID = pUalgOutParams->ulDisplayID;
   6554             if(pUalgOutParams->ulDecodedFrameType == VIDDEC_I_FRAME) {
   6555                 pBuffHead->nFlags |= OMX_BUFFERFLAG_SYNCFRAME;
   6556                 pBuffHead->nFlags |= VIDDEC_BUFFERFLAG_FRAMETYPE_I_FRAME;
   6557             }
   6558             else if(pUalgOutParams->ulDecodedFrameType == VIDDEC_P_FRAME){
   6559                 pBuffHead->nFlags |= VIDDEC_BUFFERFLAG_FRAMETYPE_P_FRAME;
   6560             }
   6561             else if(pUalgOutParams->ulDecodedFrameType == VIDDEC_B_FRAME){
   6562                 pBuffHead->nFlags |= VIDDEC_BUFFERFLAG_FRAMETYPE_B_FRAME;
   6563             }
   6564             else {
   6565                 pBuffHead->nFlags |= VIDDEC_BUFFERFLAG_FRAMETYPE_IDR_FRAME;
   6566             }
   6567         }
   6568 #endif
   6569         else {
   6570             eError = OMX_ErrorUnsupportedSetting;
   6571             goto EXIT;
   6572         }
   6573         pBuffHead->nFlags |= (nErrorCode<<12);
   6574         /*OMX_ERROR4(pComponentPrivate->dbg, "nErrorCode %x nFlags %x\n", (int *)nErrorCode, (int *)pBuffHead->nFlags);*/
   6575         if((nErrorCode & 0xff) != 0){/*OMX_BUFFERFLAG_DATACORRUPT*/
   6576             nInternalErrorCode = ((nErrorCode & VIDDEC_BUFFERFLAG_EXTENDERROR_DIRTY)>>12);
   6577             if(VIDDEC_ISFLAGSET(nErrorCode,VIDDEC_XDM_FATALERROR)){
   6578                 eExtendedError = OMX_ErrorStreamCorrupt;
   6579                 pBuffHead->nFlags |= OMX_BUFFERFLAG_DATACORRUPT;
   6580                 pBuffHead->nFilledLen = 0;
   6581                 OMX_PRDSP4(pComponentPrivate->dbg, "Not Recoverable Error Detected in Buffer in buffer %p %lu(int# %lx/%lu) OMX_ErrorStreamCorrupt\n",
   6582                         pBuffHead, ulDisplayID, (nErrorCode & VIDDEC_BUFFERFLAG_EXTENDERROR_DIRTY), pBuffHead->nFilledLen);
   6583             }
   6584             if(VIDDEC_ISFLAGSET(nErrorCode,VIDDEC_XDM_APPLIEDCONCEALMENT)){
   6585                 pBuffHead->nFlags |= OMX_BUFFERFLAG_DATACORRUPT;
   6586                 OMX_PRDSP4(pComponentPrivate->dbg, "Applied Concealment in buffer %p %lu(int# %lx/%lu)\n",
   6587                         pBuffHead, ulDisplayID, nInternalErrorCode, pBuffHead->nFilledLen);
   6588             }
   6589             if(VIDDEC_ISFLAGSET(nErrorCode,VIDDEC_XDM_INSUFFICIENTDATA)){
   6590                 pBuffHead->nFlags |= OMX_BUFFERFLAG_DATACORRUPT;
   6591                 pBuffHead->nFilledLen = 0;
   6592                 OMX_PRDSP4(pComponentPrivate->dbg, "Insufficient Data in buffer %p %lu(int# %lx/%lu)\n",
   6593                         pBuffHead, ulDisplayID, nInternalErrorCode, pBuffHead->nFilledLen);
   6594             }
   6595             if(VIDDEC_ISFLAGSET(nErrorCode,VIDDEC_XDM_CORRUPTEDDATA)){
   6596                 pBuffHead->nFlags |= OMX_BUFFERFLAG_DATACORRUPT;
   6597                 pBuffHead->nFilledLen = 0;
   6598                 OMX_PRDSP4(pComponentPrivate->dbg, "Corrupted Data in buffer %p %lu(int# %lx/%lu)\n",
   6599                         pBuffHead, ulDisplayID, nInternalErrorCode, pBuffHead->nFilledLen);
   6600             }
   6601             if(VIDDEC_ISFLAGSET(nErrorCode,VIDDEC_XDM_CORRUPTEDHEADER)){
   6602                 pBuffHead->nFlags |= OMX_BUFFERFLAG_DATACORRUPT;
   6603                 pBuffHead->nFilledLen = 0;
   6604                 OMX_PRDSP4(pComponentPrivate->dbg, "Corrupted Header in buffer %p %lu(int# %lx/%lu)\n",
   6605                         pBuffHead, ulDisplayID, nInternalErrorCode, pBuffHead->nFilledLen);
   6606             }
   6607             if(VIDDEC_ISFLAGSET(nErrorCode,VIDDEC_XDM_UNSUPPORTEDINPUT)){
   6608                 pBuffHead->nFlags |= OMX_BUFFERFLAG_DATACORRUPT;
   6609                 pBuffHead->nFilledLen = 0;
   6610                 OMX_PRDSP4(pComponentPrivate->dbg, "Unsupported Input in buffer %p %lu(int# %lx/%lu)\n",
   6611                         pBuffHead, ulDisplayID, nInternalErrorCode, pBuffHead->nFilledLen);
   6612             }
   6613             if(VIDDEC_ISFLAGSET(nErrorCode,VIDDEC_XDM_UNSUPPORTEDPARAM)){
   6614                 pBuffHead->nFlags |= OMX_BUFFERFLAG_DATACORRUPT;
   6615                 pBuffHead->nFilledLen = 0;
   6616                 OMX_PRDSP4(pComponentPrivate->dbg, "Unsupported Parameter in buffer %p %lu(int# %lx/%lu)\n",
   6617                         pBuffHead, ulDisplayID, nInternalErrorCode, pBuffHead->nFilledLen);
   6618             }
   6619         }
   6620 #ifdef KHRONOS_1_1
   6621         if (pComponentPrivate->eMBErrorReport.bEnabled) {/* && pBuffHead->nFilledLen != 0*/
   6622             OMX_U8* ErrMapFrom = NULL;
   6623             OMX_U8* ErrMapTo = NULL;
   6624             /*OMX_U32 nlooping = 0;*/
   6625             OMX_U32 nErrMapSize = 0;
   6626             if (pComponentPrivate->MPEG4Codec_IsTI &&
   6627                 (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 ||
   6628                  pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263)) {
   6629                 MP4VD_GPP_SN_UALGOutputParams* pUalgOutParams = NULL;
   6630                 pUalgOutParams = (MP4VD_GPP_SN_UALGOutputParams *)pBufferPrivate->pUalgParam;
   6631                 ErrMapFrom = pUalgOutParams->usMbErrorBuf;
   6632                 /*todo add code to use ualg_array*/
   6633                 nErrMapSize = pComponentPrivate->pOutPortDef->format.video.nFrameWidth *
   6634                               pComponentPrivate->pOutPortDef->format.video.nFrameHeight / 256;
   6635                 ErrMapTo = pComponentPrivate->eMBErrorMapType[pComponentPrivate->cMBErrorIndexIn].ErrMap;
   6636                 pComponentPrivate->eMBErrorMapType[pComponentPrivate->cMBErrorIndexIn].nErrMapSize = nErrMapSize;
   6637                 memcpy(ErrMapTo, ErrMapFrom, nErrMapSize);
   6638                 pComponentPrivate->cMBErrorIndexIn++;
   6639                 pComponentPrivate->cMBErrorIndexIn %= pComponentPrivate->pOutPortDef->nBufferCountActual;
   6640             }
   6641             if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
   6642                 H264VDEC_UALGOutputParam* pUalgOutParams = NULL;
   6643                 pUalgOutParams = (H264VDEC_UALGOutputParam *)pBufferPrivate->pUalgParam;
   6644                 ErrMapFrom = pUalgOutParams->pMBErrStatOutBuf;
   6645                 /*todo add code to use ualg_array*/
   6646                 nErrMapSize = pComponentPrivate->pOutPortDef->format.video.nFrameWidth *
   6647                               pComponentPrivate->pOutPortDef->format.video.nFrameHeight / 256;
   6648                 ErrMapTo = pComponentPrivate->eMBErrorMapType[pComponentPrivate->cMBErrorIndexIn].ErrMap;
   6649                 pComponentPrivate->eMBErrorMapType[pComponentPrivate->cMBErrorIndexIn].nErrMapSize = nErrMapSize;
   6650                 memcpy(ErrMapTo, ErrMapFrom, nErrMapSize);
   6651                 pComponentPrivate->cMBErrorIndexIn++;
   6652                 pComponentPrivate->cMBErrorIndexIn %= pComponentPrivate->pOutPortDef->nBufferCountActual;
   6653             }
   6654         }
   6655 #endif
   6656         if (pComponentPrivate->pCompPort[1]->hTunnelComponent != NULL) {
   6657             if(pComponentPrivate->bFirstBuffer) {
   6658                 OMX_PRBUFFER2(pComponentPrivate->dbg, "**** Setting OMX_BUFFERFLAG_STARTTIME\n");
   6659                 pBuffHead->nFlags |= OMX_BUFFERFLAG_STARTTIME;
   6660                 pComponentPrivate->bFirstBuffer = 0;
   6661             }
   6662             else {
   6663                 pBuffHead->nFlags &= ~(OMX_BUFFERFLAG_STARTTIME);
   6664             }
   6665             if(pBuffHead != NULL){
   6666                 if((pBuffHead->nFlags & OMX_BUFFERFLAG_DECODEONLY) == 0) {
   6667                     pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_TUNNELEDCOMP;
   6668                     OMX_PRBUFFER1(pComponentPrivate->dbg, "tunnel eBufferOwner 0x%x\n", pBufferPrivate->eBufferOwner);
   6669     #ifdef __PERF_INSTRUMENTATION__
   6670                     PERF_SendingFrame(pComponentPrivate->pPERFcomp,
   6671                                       pBuffHead->pBuffer,
   6672                                       pBuffHead->nFilledLen,
   6673                                       PERF_ModuleLLMM);
   6674     #endif
   6675                     OMX_PRDSP2(pComponentPrivate->dbg, "VIDDEC_HandleDataBuf_FromDsp %x   %x\n",(int)pBuffHead->nFlags,(int)pBuffHead->nFilledLen);
   6676                     VIDDEC_Propagate_Mark(pComponentPrivate, pBuffHead);
   6677                     eError = OMX_EmptyThisBuffer(pComponentPrivate->pCompPort[1]->hTunnelComponent, pBuffHead);
   6678                 }
   6679                 else {
   6680                     ret = write(pComponentPrivate->free_outBuf_Q[1],&pBuffHead,sizeof(pBuffHead));
   6681                     if (ret == -1) {
   6682                         OMX_PRDSP4(pComponentPrivate->dbg, "Error while writing to out pipe to client\n");
   6683                         eError = OMX_ErrorHardware;
   6684                         return eError;
   6685                     }
   6686                     eError = IncrementCount (&(pComponentPrivate->nCountOutputBFromApp), &(pComponentPrivate->mutexOutputBFromApp));
   6687                     if (eError != OMX_ErrorNone) {
   6688                         return eError;
   6689                     }
   6690                 }
   6691             }
   6692         }
   6693         else {
   6694             if(pBuffHead != NULL) {
   6695                 if (pComponentPrivate->firstBufferEos){
   6696                     pComponentPrivate->firstBufferEos = OMX_FALSE;
   6697                     pBuffHead->nFlags |= OMX_BUFFERFLAG_EOS;
   6698                     pBuffHead->nFilledLen = 0;
   6699                 }
   6700     #ifdef __PERF_INSTRUMENTATION__
   6701                 PERF_SendingFrame(pComponentPrivate->pPERFcomp,
   6702                                   pBuffHead->pBuffer,
   6703                                   pBuffHead->nFilledLen,
   6704                                   PERF_ModuleHLMM);
   6705     #endif
   6706 
   6707                 VIDDEC_Propagate_Mark(pComponentPrivate, pBuffHead);
   6708                 pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_CLIENT;
   6709                 OMX_PRBUFFER1(pComponentPrivate->dbg, "standalone buffer eBufferOwner 0x%x  --  %lx\n", pBufferPrivate->eBufferOwner,pBuffHead->nFlags);
   6710                 VIDDEC_FillBufferDone(pComponentPrivate, pBuffHead);
   6711             }
   6712         }
   6713     }
   6714 
   6715 EXIT:
   6716     if(eExtendedError != OMX_ErrorNone) {
   6717         eError = eExtendedError;
   6718     }
   6719     OMX_PRBUFFER1(pComponentPrivate->dbg, "---EXITING(0x%x)\n",eError);
   6720     return eError;
   6721 }
   6722 
   6723 /* ========================================================================== */
   6724 /**
   6725   *  Handle Free Data Buff
   6726   **/
   6727 /* ========================================================================== */
   6728 
   6729 OMX_ERRORTYPE VIDDEC_HandleFreeDataBuf( VIDDEC_COMPONENT_PRIVATE *pComponentPrivate )
   6730 {
   6731     OMX_ERRORTYPE eError = OMX_ErrorNone;
   6732     OMX_BUFFERHEADERTYPE* pBuffHead;
   6733     VIDDEC_BUFFER_PRIVATE* pBufferPrivate = NULL;
   6734     int ret;
   6735     int inputbufsize = (int)pComponentPrivate->pInPortDef->nBufferSize;
   6736 
   6737     OMX_PRBUFFER1(pComponentPrivate->dbg, "+++ENTERING\n");
   6738     OMX_PRBUFFER1(pComponentPrivate->dbg, "pComponentPrivate 0x%p\n", (int*)pComponentPrivate);
   6739     ret = read(pComponentPrivate->free_inpBuf_Q[0], &pBuffHead, sizeof(pBuffHead));
   6740     if (ret == -1) {
   6741         OMX_PRCOMM4(pComponentPrivate->dbg, "Error while reading from the free Q\n");
   6742         eError = OMX_ErrorHardware;
   6743         goto EXIT;
   6744     }
   6745     eError = DecrementCount (&(pComponentPrivate->nCountInputBFromDsp), &(pComponentPrivate->mutexInputBFromDSP));
   6746     if (eError != OMX_ErrorNone) {
   6747         return eError;
   6748     }
   6749     OMX_PRSTATE1(pComponentPrivate->dbg, "pBuffHead 0x%p eExecuteToIdle 0x%x\n", pBuffHead,pComponentPrivate->eExecuteToIdle);
   6750     if (pComponentPrivate->eState == OMX_StateLoaded || pComponentPrivate->eState == OMX_StateIdle) {
   6751         eError = OMX_ErrorNone;
   6752         goto EXIT;
   6753     }
   6754     OMX_PRSTATE1(pComponentPrivate->dbg, "pBuffHead 0x%p eExecuteToIdle 0x%x\n", pBuffHead,pComponentPrivate->eExecuteToIdle);
   6755     if (pBuffHead != NULL) {
   6756         pBufferPrivate = (VIDDEC_BUFFER_PRIVATE* )pBuffHead->pInputPortPrivate;
   6757         pBuffHead->nAllocLen = inputbufsize;
   6758         pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_CLIENT;
   6759         OMX_PRBUFFER1(pComponentPrivate->dbg, "eBufferOwner 0x%x\n", pBufferPrivate->eBufferOwner);
   6760 #ifdef __PERF_INSTRUMENTATION__
   6761         PERF_SendingFrame(pComponentPrivate->pPERFcomp,
   6762                           pBuffHead->pBuffer,
   6763                           pBuffHead->nFilledLen,
   6764                           PERF_ModuleHLMM);
   6765 #endif
   6766 
   6767         VIDDEC_EmptyBufferDone(pComponentPrivate, pBuffHead);
   6768     }
   6769     OMX_PRBUFFER1(pComponentPrivate->dbg, "---EXITING(0x%x) \n",eError);
   6770 EXIT:
   6771     return eError;
   6772 }
   6773 
   6774 /*-------------------------------------------------------------------*/
   6775 /**
   6776   *  Function to fill DSP structures via LCML
   6777   *
   6778   *
   6779   *
   6780   * @retval OMX_NoError              Success, ready to roll
   6781   *
   6782   **/
   6783 /*-------------------------------------------------------------------*/
   6784 OMX_ERRORTYPE VIDDEC_InitDSP_WMVDec(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate)
   6785 {
   6786     OMX_ERRORTYPE eError = OMX_ErrorNone;
   6787     LCML_DSP_INTERFACE *pLcmlHandle = NULL;
   6788     LCML_DSP *lcml_dsp = NULL;
   6789     OMX_U32 nInpBuff = MAX_PRIVATE_IN_BUFFERS;
   6790     OMX_U32 nInpBuffSize = 0;
   6791     OMX_U32 nOutBuff = MAX_PRIVATE_OUT_BUFFERS;
   6792     OMX_U32 nOutBuffSize = 0;
   6793     WMV9DEC_SNCreatePhArg* pCreatePhaseArgs = NULL;
   6794     LCML_CALLBACKTYPE cb;
   6795 
   6796     OMX_PRDSP1(pComponentPrivate->dbg, "+++ENTERING\n");
   6797     nInpBuff = pComponentPrivate->pInPortDef->nBufferCountActual;
   6798     nOutBuff = pComponentPrivate->pOutPortDef->nBufferCountActual;
   6799 
   6800     /* Back it up for further use in this function */
   6801     nInpBuffSize = pComponentPrivate->pInPortDef->nBufferSize;
   6802     nOutBuffSize = pComponentPrivate->pOutPortDef->nBufferSize;
   6803 
   6804     pLcmlHandle = (LCML_DSP_INTERFACE *)pComponentPrivate->pLCML;
   6805     lcml_dsp = (((LCML_DSP_INTERFACE*)pLcmlHandle)->dspCodec);
   6806 
   6807     lcml_dsp->DeviceInfo.TypeofDevice = 0;
   6808     lcml_dsp->DeviceInfo.DspStream    = NULL;
   6809 
   6810     lcml_dsp->In_BufInfo.nBuffers     = nInpBuff;
   6811     lcml_dsp->In_BufInfo.nSize        = nInpBuffSize;
   6812     lcml_dsp->In_BufInfo.DataTrMethod = DMM_METHOD;
   6813 
   6814     lcml_dsp->Out_BufInfo.nBuffers     = nOutBuff;
   6815     lcml_dsp->Out_BufInfo.nSize        = nOutBuffSize;
   6816     lcml_dsp->Out_BufInfo.DataTrMethod = DMM_METHOD;
   6817 
   6818     lcml_dsp->NodeInfo.nNumOfDLLs = OMX_WMVDEC_NUM_DLLS;
   6819     lcml_dsp->NodeInfo.AllUUIDs[0].uuid = (struct DSP_UUID *)&WMVDSOCKET_TI_UUID;
   6820     strcpy ((char*)(lcml_dsp->NodeInfo.AllUUIDs[0].DllName),(char*)WMV_DEC_NODE_DLL);
   6821     lcml_dsp->NodeInfo.AllUUIDs[0].eDllType = DLL_NODEOBJECT;
   6822 
   6823     lcml_dsp->NodeInfo.AllUUIDs[1].uuid = (struct DSP_UUID *)&WMVDSOCKET_TI_UUID;
   6824     strcpy ((char*)lcml_dsp->NodeInfo.AllUUIDs[1].DllName,(char*)WMV_DEC_NODE_DLL);
   6825     lcml_dsp->NodeInfo.AllUUIDs[1].eDllType = DLL_DEPENDENT;
   6826 
   6827     lcml_dsp->NodeInfo.AllUUIDs[2].uuid = (struct DSP_UUID *)&USN_UUID;
   6828     strcpy ((char*)lcml_dsp->NodeInfo.AllUUIDs[2].DllName,(char*)USN_DLL);
   6829     lcml_dsp->NodeInfo.AllUUIDs[2].eDllType = DLL_DEPENDENT;
   6830 
   6831     lcml_dsp->NodeInfo.AllUUIDs[3].uuid = (struct DSP_UUID *)&RINGIO_TI_UUID;
   6832     strcpy ((char*)lcml_dsp->NodeInfo.AllUUIDs[3].DllName,(char*)RINGIO_NODE_DLL);
   6833     lcml_dsp->NodeInfo.AllUUIDs[3].eDllType = DLL_DEPENDENT;
   6834 
   6835     lcml_dsp->NodeInfo.AllUUIDs[4].uuid = (struct DSP_UUID *)&CONVERSIONS_UUID;
   6836     strcpy ((char*)lcml_dsp->NodeInfo.AllUUIDs[4].DllName,(char*)CONVERSIONS_DLL);
   6837     lcml_dsp->NodeInfo.AllUUIDs[4].eDllType = DLL_DEPENDENT;
   6838 
   6839 
   6840     lcml_dsp->SegID     = 0;
   6841     lcml_dsp->Timeout   = -1;
   6842     lcml_dsp->Alignment = 0;
   6843     lcml_dsp->Priority  = 5;
   6844 
   6845     if(pComponentPrivate->ProcessMode == 0){
   6846         if(pComponentPrivate->wmvProfile == VIDDEC_WMV_PROFILEMAX)
   6847         {
   6848             if ((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth > 640) ||
   6849                 (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight > 480)) {
   6850                 lcml_dsp->ProfileID = 4;
   6851             }
   6852             else if (((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth <= 640) &&
   6853                 (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth > 352)) ||
   6854                 ((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight <= 480) &&
   6855                 (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight > 288))) {
   6856                 lcml_dsp->ProfileID = 2;
   6857             }
   6858             else if (((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth <= 352) &&
   6859                 (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth > 176)) ||
   6860                 ((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight <= 288) &&
   6861                 (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight > 144))) {
   6862                 lcml_dsp->ProfileID = 1;
   6863             }
   6864             else if (((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth <= 176) &&
   6865                 (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth >= 16)) ||
   6866                 ((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight <= 144) &&
   6867                 (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight >= 16))) {
   6868                 lcml_dsp->ProfileID = 0;
   6869             }
   6870             else {
   6871                 eError = OMX_ErrorUnsupportedSetting;
   6872                 goto EXIT;
   6873             }
   6874         }
   6875         else
   6876         {
   6877             switch(pComponentPrivate->wmvProfile)
   6878             {
   6879             case VIDDEC_WMV_PROFILE0:
   6880                 lcml_dsp->ProfileID = VIDDEC_WMV_PROFILE_ID0;
   6881                 break;
   6882             case VIDDEC_WMV_PROFILE1:
   6883                 lcml_dsp->ProfileID = VIDDEC_WMV_PROFILE_ID1;
   6884                 break;
   6885             case VIDDEC_WMV_PROFILE2:
   6886                 lcml_dsp->ProfileID = VIDDEC_WMV_PROFILE_ID2;
   6887                 break;
   6888             default:
   6889                 {
   6890                     eError = OMX_ErrorBadParameter;
   6891                     goto EXIT;
   6892                 }
   6893             }
   6894         }
   6895     } else if(pComponentPrivate->ProcessMode == 1)
   6896     {
   6897         switch(pComponentPrivate->wmvProfile)
   6898         {
   6899         case VIDDEC_WMV_PROFILE3:
   6900             lcml_dsp->ProfileID = VIDDEC_WMV_PROFILE_ID3;
   6901             break;
   6902         case VIDDEC_WMV_PROFILE4:
   6903             lcml_dsp->ProfileID = VIDDEC_WMV_PROFILE_ID4;
   6904             break;
   6905         case VIDDEC_WMV_PROFILE5:
   6906             lcml_dsp->ProfileID = VIDDEC_WMV_PROFILE_ID5;
   6907             break;
   6908         case VIDDEC_WMV_PROFILE6:
   6909             lcml_dsp->ProfileID = VIDDEC_WMV_PROFILE_ID6;
   6910             break;
   6911         case VIDDEC_WMV_PROFILE7:
   6912             lcml_dsp->ProfileID = VIDDEC_WMV_PROFILE_ID7;
   6913             break;
   6914         case VIDDEC_WMV_PROFILE8:
   6915             lcml_dsp->ProfileID = VIDDEC_WMV_PROFILE_ID8;
   6916             break;
   6917         case VIDDEC_WMV_PROFILEMAX:
   6918             lcml_dsp->ProfileID = VIDDEC_WMV_PROFILE_ID8;
   6919             break;
   6920         default:
   6921             eError = OMX_ErrorBadParameter;
   6922             goto EXIT;
   6923         }
   6924     }
   6925     else
   6926     {
   6927         eError = OMX_ErrorUnsupportedSetting;
   6928         goto EXIT;
   6929     }
   6930 
   6931     OMX_MALLOC_STRUCT(pCreatePhaseArgs, WMV9DEC_SNCreatePhArg,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel4]);
   6932     if (pCreatePhaseArgs == NULL) {
   6933         eError = OMX_ErrorInsufficientResources;
   6934         goto EXIT;
   6935     }
   6936     pCreatePhaseArgs->unNumOfStreams            = 2;
   6937     pCreatePhaseArgs->unInputStreamID           = 0;
   6938     pCreatePhaseArgs->unInputBufferType         = 0;
   6939     pCreatePhaseArgs->unInputNumBufsPerStream   = (OMX_U16)nInpBuff;
   6940     pCreatePhaseArgs->unOutputStreamID          = 1;
   6941     pCreatePhaseArgs->unOutputBufferType        = 0;
   6942     pCreatePhaseArgs->unOutputNumBufsPerStream  = (OMX_U16)nOutBuff;
   6943     pCreatePhaseArgs->ulMaxWidth                = (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth);
   6944     pCreatePhaseArgs->ulMaxHeight               = (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight);
   6945 
   6946     if (pComponentPrivate->nWMVFileType != VIDDEC_WMV_ELEMSTREAM) {
   6947         pComponentPrivate->pBufferRCV.sStructRCV.nVertSize = (OMX_U32)(pComponentPrivate->pInPortDef->format.video.nFrameHeight);
   6948         pComponentPrivate->pBufferRCV.sStructRCV.nHorizSize = (OMX_U32)(pComponentPrivate->pInPortDef->format.video.nFrameWidth);
   6949     }
   6950 
   6951     if (pComponentPrivate->pOutPortDef->format.video.eColorFormat == VIDDEC_COLORFORMAT422) {
   6952         pCreatePhaseArgs->ulYUVFormat           = WMV9VIDDEC_YUVFORMAT_INTERLEAVED422;
   6953     }
   6954     else if (pComponentPrivate->pOutPortDef->format.video.eColorFormat == VIDDEC_COLORFORMAT420) {
   6955         pCreatePhaseArgs->ulYUVFormat           = WMV9VIDDEC_YUVFORMAT_PLANAR420;
   6956     }
   6957     else
   6958     {
   6959         OMX_PRDSP4(pComponentPrivate->dbg, "Incorrect Color format %x\n",pComponentPrivate->pOutPortDef->format.video.eColorFormat);
   6960         eError = OMX_ErrorUnsupportedSetting;
   6961         goto EXIT;
   6962     }
   6963 
   6964     pCreatePhaseArgs->ulMaxFrameRate            = 0;
   6965     pCreatePhaseArgs->ulMaxBitRate              = 0;
   6966     pCreatePhaseArgs->ulDataEndianness          = 1;
   6967     pCreatePhaseArgs->ulProfile                 = -1;
   6968     pCreatePhaseArgs->ulMaxLevel                = -1;
   6969     pCreatePhaseArgs->ulProcessMode             = pComponentPrivate->ProcessMode;
   6970     pCreatePhaseArgs->lPreRollBufConfig         = 0;
   6971     pCreatePhaseArgs->bCopiedCCDBuffer          = 0;
   6972 
   6973     if (pComponentPrivate->nWMVFileType == VIDDEC_WMV_ELEMSTREAM) {
   6974         pCreatePhaseArgs->usIsElementaryStream = VIDDEC_SN_WMV_ELEMSTREAM;
   6975     }
   6976     else {
   6977         pCreatePhaseArgs->usIsElementaryStream = VIDDEC_SN_WMV_RCVSTREAM;
   6978     }
   6979 
   6980     pCreatePhaseArgs->endArgs                   = END_OF_CR_PHASE_ARGS;
   6981 
   6982     lcml_dsp->pCrPhArgs = (OMX_U16 *) pCreatePhaseArgs;
   6983     cb.LCML_Callback = (void *) VIDDEC_LCML_Callback;
   6984 
   6985     if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   6986         pComponentPrivate->pLCML != NULL){
   6987         eError = LCML_InitMMCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, NULL, &pLcmlHandle, NULL, &cb);
   6988         if (eError != OMX_ErrorNone) {
   6989             OMX_PRDSP4(pComponentPrivate->dbg, "LCML_InitMMCodec Failed!...%x\n",eError);
   6990             eError = OMX_ErrorHardware;
   6991             goto EXIT;
   6992         }
   6993     }
   6994     else {
   6995         eError = OMX_ErrorHardware;
   6996         goto EXIT;
   6997     }
   6998 EXIT:
   6999     if ( pCreatePhaseArgs != NULL )
   7000         free(pCreatePhaseArgs);
   7001     pCreatePhaseArgs = NULL;
   7002 
   7003     OMX_PRDSP1(pComponentPrivate->dbg, "---EXITING(0x%x)\n",eError);
   7004     return eError;
   7005 }
   7006 
   7007 
   7008 
   7009 /*-------------------------------------------------------------------*/
   7010 /**
   7011   *  Function to fill DSP structures via LCML
   7012   *
   7013   *
   7014   *
   7015   * @retval OMX_NoError              Success, ready to roll
   7016   *
   7017   **/
   7018 /*-------------------------------------------------------------------*/
   7019 
   7020 OMX_ERRORTYPE VIDDEC_InitDSP_H264Dec(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate)
   7021 {
   7022     OMX_ERRORTYPE eError = OMX_ErrorNone;
   7023     LCML_DSP_INTERFACE *pLcmlHandle = NULL;
   7024     LCML_DSP *lcml_dsp = NULL;
   7025     OMX_U32 nInpBuff = MAX_PRIVATE_IN_BUFFERS;
   7026     OMX_U32 nInpBuffSize = 0;
   7027     OMX_U32 nOutBuff = MAX_PRIVATE_OUT_BUFFERS;
   7028     OMX_U32 nOutBuffSize = 0;
   7029     H264VDEC_SNCreatePhArg* pCreatePhaseArgs = NULL;
   7030     LCML_CALLBACKTYPE cb;
   7031     OMX_U32 nFrameWidth = 0;
   7032     OMX_U32 nFrameHeight = 0;
   7033 
   7034     OMX_PRDSP1(pComponentPrivate->dbg, "+++ENTERING\n");
   7035 
   7036     /* Get number of input and output buffers */
   7037     nInpBuff = pComponentPrivate->pInPortDef->nBufferCountActual;
   7038     nOutBuff = pComponentPrivate->pOutPortDef->nBufferCountActual;
   7039 
   7040     /* Back it up for further use in this function */
   7041     nInpBuffSize = pComponentPrivate->pInPortDef->nBufferSize;
   7042     nOutBuffSize = pComponentPrivate->pOutPortDef->nBufferSize;
   7043 
   7044     pLcmlHandle = (LCML_DSP_INTERFACE *)pComponentPrivate->pLCML;
   7045     lcml_dsp = (((LCML_DSP_INTERFACE*)pLcmlHandle)->dspCodec);
   7046 
   7047     lcml_dsp->DeviceInfo.TypeofDevice = 0;
   7048     lcml_dsp->DeviceInfo.DspStream    = NULL;
   7049 
   7050     lcml_dsp->In_BufInfo.nBuffers     = nInpBuff;
   7051     lcml_dsp->In_BufInfo.nSize        = nInpBuffSize;
   7052     lcml_dsp->In_BufInfo.DataTrMethod = DMM_METHOD;
   7053 
   7054     lcml_dsp->Out_BufInfo.nBuffers     = nOutBuff;
   7055     lcml_dsp->Out_BufInfo.nSize        = nOutBuffSize;
   7056     lcml_dsp->Out_BufInfo.DataTrMethod = DMM_METHOD;
   7057 
   7058     lcml_dsp->NodeInfo.nNumOfDLLs = OMX_H264DEC_NUM_DLLS;
   7059     lcml_dsp->NodeInfo.AllUUIDs[0].uuid = (struct DSP_UUID *)&H264VDSOCKET_TI_UUID;
   7060     strcpy ((char*)lcml_dsp->NodeInfo.AllUUIDs[0].DllName,(char*)H264_DEC_NODE_DLL);
   7061     lcml_dsp->NodeInfo.AllUUIDs[0].eDllType = DLL_NODEOBJECT;
   7062 
   7063     lcml_dsp->NodeInfo.AllUUIDs[1].uuid = (struct DSP_UUID *)&H264VDSOCKET_TI_UUID;
   7064     strcpy ((char*)lcml_dsp->NodeInfo.AllUUIDs[1].DllName,(char*)H264_DEC_NODE_DLL);
   7065     lcml_dsp->NodeInfo.AllUUIDs[1].eDllType = DLL_DEPENDENT;
   7066 
   7067     lcml_dsp->NodeInfo.AllUUIDs[2].uuid = (struct DSP_UUID *)&USN_UUID;
   7068     strcpy ((char*)lcml_dsp->NodeInfo.AllUUIDs[2].DllName,(char*)USN_DLL);
   7069     lcml_dsp->NodeInfo.AllUUIDs[2].eDllType = DLL_DEPENDENT;
   7070 
   7071     lcml_dsp->NodeInfo.AllUUIDs[3].uuid = (struct DSP_UUID *)&RINGIO_TI_UUID;
   7072     strcpy ((char*)lcml_dsp->NodeInfo.AllUUIDs[3].DllName,(char*)RINGIO_NODE_DLL);
   7073     lcml_dsp->NodeInfo.AllUUIDs[3].eDllType = DLL_DEPENDENT;
   7074 
   7075     lcml_dsp->NodeInfo.AllUUIDs[4].uuid = (struct DSP_UUID *)&CONVERSIONS_UUID;
   7076     strcpy ((char*)lcml_dsp->NodeInfo.AllUUIDs[4].DllName,(char*)CONVERSIONS_DLL);
   7077     lcml_dsp->NodeInfo.AllUUIDs[4].eDllType = DLL_DEPENDENT;
   7078 
   7079     lcml_dsp->SegID     = 0;
   7080     lcml_dsp->Timeout   = -1;
   7081     lcml_dsp->Alignment = 0;
   7082     lcml_dsp->Priority  = 5;
   7083 
   7084    if(pComponentPrivate->ProcessMode == 0){
   7085         if ((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth > 352) ||
   7086             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight > 288)) {
   7087             lcml_dsp->ProfileID = 3;
   7088         }
   7089         else if (((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth <= 352) &&
   7090             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth > 176)) ||
   7091             ((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight <= 288) &&
   7092             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight > 144))) {
   7093             lcml_dsp->ProfileID = 2;
   7094         }
   7095         else if (((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth <= 176) &&
   7096             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth >= 16)) ||
   7097             ((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight <= 144) &&
   7098             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight >= 16))) {
   7099             lcml_dsp->ProfileID = 1;
   7100         }
   7101         else {
   7102             eError = OMX_ErrorUnsupportedSetting;
   7103             goto EXIT;
   7104         }
   7105    }
   7106    else if(pComponentPrivate->ProcessMode == 1) {
   7107         /*OMX_VIDEO_AVCLevelMax*/
   7108         switch(pComponentPrivate->pH264->eLevel) {
   7109             case OMX_VIDEO_AVCLevel1:
   7110                 lcml_dsp->ProfileID = 8;
   7111                 break;
   7112             case OMX_VIDEO_AVCLevel1b:
   7113                 lcml_dsp->ProfileID = 9;
   7114                 break;
   7115             case OMX_VIDEO_AVCLevel11:
   7116                 lcml_dsp->ProfileID = 10;
   7117                 break;
   7118             case OMX_VIDEO_AVCLevel12:
   7119                 lcml_dsp->ProfileID = 11;
   7120                 break;
   7121             case OMX_VIDEO_AVCLevel13:
   7122             case OMX_VIDEO_AVCLevel2:
   7123                 lcml_dsp->ProfileID = 12;
   7124                 break;
   7125             case OMX_VIDEO_AVCLevel21:
   7126             case OMX_VIDEO_AVCLevel22:
   7127                 lcml_dsp->ProfileID = 13;
   7128                 break;
   7129             default:
   7130                 lcml_dsp->ProfileID = 14;
   7131                 break;
   7132         }
   7133    }
   7134    /*add code to error*/
   7135     OMX_PRDSP1(pComponentPrivate->dbg, "lcml_dsp->ProfileID = %lu\n", lcml_dsp->ProfileID);
   7136     OMX_MALLOC_STRUCT(pCreatePhaseArgs, H264VDEC_SNCreatePhArg,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel4]);
   7137     if (pCreatePhaseArgs == NULL) {
   7138         eError = OMX_ErrorInsufficientResources;
   7139         goto EXIT;
   7140     }
   7141 
   7142     nFrameWidth = pComponentPrivate->pInPortDef->format.video.nFrameWidth;
   7143     nFrameHeight = pComponentPrivate->pInPortDef->format.video.nFrameHeight;
   7144     if (nFrameWidth & 0xF) nFrameWidth = (nFrameWidth & 0xFFF0) + 0x10;
   7145     if (nFrameHeight & 0xF) nFrameHeight = (nFrameHeight & 0xFFF0) + 0x10;
   7146 
   7147     pCreatePhaseArgs->unNumOfStreams            = 2;
   7148     pCreatePhaseArgs->unInputStreamID           = 0;
   7149     pCreatePhaseArgs->unInputBufferType         = 0;
   7150     pCreatePhaseArgs->unInputNumBufsPerStream   = (OMX_U16)nInpBuff;
   7151     pCreatePhaseArgs->unOutputStreamID          = 1;
   7152     pCreatePhaseArgs->unOutputBufferType        = 0;
   7153     pCreatePhaseArgs->unOutputNumBufsPerStream  = (OMX_U16)nOutBuff;
   7154     pCreatePhaseArgs->ulMaxWidth                = nFrameWidth;
   7155     pCreatePhaseArgs->ulMaxHeight               = nFrameHeight;
   7156 
   7157 
   7158     if (pComponentPrivate->pOutPortDef->format.video.eColorFormat == VIDDEC_COLORFORMAT422) {
   7159         pCreatePhaseArgs->ulYUVFormat           = H264VIDDEC_YUVFORMAT_INTERLEAVED422;
   7160     }
   7161     else if (pComponentPrivate->pOutPortDef->format.video.eColorFormat == VIDDEC_COLORFORMAT420) {
   7162         pCreatePhaseArgs->ulYUVFormat           = H264VIDDEC_YUVFORMAT_PLANAR420;
   7163     }
   7164     else
   7165     {
   7166         OMX_PRDSP4(pComponentPrivate->dbg, "Incorrect Color format %x\n",pComponentPrivate->pOutPortDef->format.video.eColorFormat);
   7167         eError = OMX_ErrorUnsupportedSetting;
   7168         goto EXIT;
   7169     }
   7170 
   7171     pCreatePhaseArgs->ulMaxFrameRate            = 0;
   7172     pCreatePhaseArgs->ulMaxBitRate              = 0;
   7173     pCreatePhaseArgs->ulDataEndianness          = 1;
   7174     pCreatePhaseArgs->ulProfile                 = 0;
   7175     pCreatePhaseArgs->ulMaxLevel            = -1;
   7176     pCreatePhaseArgs->ulProcessMode             = pComponentPrivate->ProcessMode;
   7177     pCreatePhaseArgs->lPreRollBufConfig         = 0;
   7178     pCreatePhaseArgs->ulBitStreamFormat         = (pComponentPrivate->H264BitStreamFormat>0?1:0);
   7179 
   7180     pCreatePhaseArgs->ulDisplayWidth = 0;
   7181     pCreatePhaseArgs->endArgs                   = END_OF_CR_PHASE_ARGS;
   7182 
   7183     memcpy (pComponentPrivate->arr, pCreatePhaseArgs, sizeof(H264VDEC_SNCreatePhArg));
   7184     lcml_dsp->pCrPhArgs = pComponentPrivate->arr;
   7185     cb.LCML_Callback = (void *) VIDDEC_LCML_Callback;
   7186 
   7187     if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   7188         pComponentPrivate->pLCML != NULL){
   7189         eError = LCML_InitMMCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, NULL, &pLcmlHandle, NULL, &cb);
   7190         if (eError != OMX_ErrorNone) {
   7191             OMX_PRDSP4(pComponentPrivate->dbg, "LCML_InitMMCodec Failed!...%x\n",eError);
   7192             eError = OMX_ErrorHardware;
   7193             goto EXIT;
   7194         }
   7195     }
   7196     else {
   7197         eError = OMX_ErrorHardware;
   7198         goto EXIT;
   7199     }
   7200 EXIT:
   7201     if (pCreatePhaseArgs) {
   7202         free(pCreatePhaseArgs);
   7203         pCreatePhaseArgs = NULL;
   7204     }
   7205     OMX_PRDSP1(pComponentPrivate->dbg, "---EXITING(0x%x)\n",eError);
   7206     return eError;
   7207 }
   7208 
   7209 /*-------------------------------------------------------------------*/
   7210 /**
   7211   *  Function to fill DSP structures via LCML
   7212   *
   7213   *
   7214   *
   7215   * @retval OMX_NoError              Success, ready to roll
   7216   *
   7217   **/
   7218 /*-------------------------------------------------------------------*/
   7219 
   7220 OMX_ERRORTYPE VIDDEC_InitDSP_Mpeg4Dec(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate)
   7221 {
   7222     OMX_ERRORTYPE eError = OMX_ErrorNone;
   7223     LCML_DSP_INTERFACE *pLcmlHandle = NULL;
   7224     LCML_DSP *lcml_dsp = NULL;
   7225     OMX_U32 nInpBuff = MAX_PRIVATE_IN_BUFFERS;
   7226     OMX_U32 nInpBuffSize = 0;
   7227     OMX_U32 nOutBuff = MAX_PRIVATE_OUT_BUFFERS;
   7228     OMX_U32 nOutBuffSize = 0;
   7229     MP4VD_GPP_SN_Obj_CreatePhase* pCreatePhaseArgs = NULL;
   7230     LCML_CALLBACKTYPE cb;
   7231 
   7232     OMX_PRDSP1(pComponentPrivate->dbg, "+++ENTERING\n");
   7233     /* Get number of input and output buffers */
   7234     nInpBuff = pComponentPrivate->pInPortDef->nBufferCountActual;
   7235     nOutBuff = pComponentPrivate->pOutPortDef->nBufferCountActual;
   7236 
   7237     /* Back it up for further use in this function */
   7238     nInpBuffSize = pComponentPrivate->pInPortDef->nBufferSize;
   7239     nOutBuffSize = pComponentPrivate->pOutPortDef->nBufferSize;
   7240 
   7241     pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
   7242     lcml_dsp = (((LCML_DSP_INTERFACE*)pLcmlHandle)->dspCodec);
   7243 
   7244     lcml_dsp->DeviceInfo.TypeofDevice = 0;
   7245     lcml_dsp->DeviceInfo.DspStream    = NULL;
   7246 
   7247     lcml_dsp->In_BufInfo.nBuffers      = nInpBuff;
   7248     lcml_dsp->In_BufInfo.nSize         = nInpBuffSize;
   7249     lcml_dsp->In_BufInfo.DataTrMethod  = DMM_METHOD;
   7250 
   7251     lcml_dsp->Out_BufInfo.nBuffers     = nOutBuff;
   7252     lcml_dsp->Out_BufInfo.nSize        = nOutBuffSize;
   7253     lcml_dsp->Out_BufInfo.DataTrMethod = DMM_METHOD;
   7254 
   7255     lcml_dsp->NodeInfo.nNumOfDLLs       = OMX_MP4DEC_NUM_DLLS;
   7256     OMX_U32 nFrameWidth = pComponentPrivate->pOutPortDef->format.video.nFrameWidth;
   7257     OMX_U32 nFrameHeight = pComponentPrivate->pOutPortDef->format.video.nFrameHeight;
   7258 
   7259     nFrameWidth = (nFrameWidth + 0x0f) & ~0x0f;
   7260     nFrameHeight = (nFrameHeight + 0x0f) & ~0x0f;
   7261     if (nFrameWidth * nFrameHeight > 880 * 720)
   7262     {
   7263         lcml_dsp->NodeInfo.AllUUIDs[0].uuid = (struct DSP_UUID *)&MP4D720PSOCKET_TI_UUID;
   7264         strcpy ((char*)lcml_dsp->NodeInfo.AllUUIDs[0].DllName,(char*)MP4720P_DEC_NODE_DLL);
   7265         lcml_dsp->NodeInfo.AllUUIDs[0].eDllType = DLL_NODEOBJECT;
   7266 
   7267         lcml_dsp->NodeInfo.AllUUIDs[1].uuid = (struct DSP_UUID *)&MP4D720PSOCKET_TI_UUID;
   7268         strcpy ((char*)lcml_dsp->NodeInfo.AllUUIDs[1].DllName,(char*)MP4720P_DEC_NODE_DLL);
   7269         lcml_dsp->NodeInfo.AllUUIDs[1].eDllType = DLL_DEPENDENT;
   7270 
   7271         pComponentPrivate->eMBErrorReport.bEnabled = FALSE;
   7272         pComponentPrivate->MPEG4Codec_IsTI = FALSE;
   7273     }
   7274     else
   7275     {
   7276     lcml_dsp->NodeInfo.AllUUIDs[0].uuid = (struct DSP_UUID *)&MP4DSOCKET_TI_UUID;
   7277     strcpy ((char*)lcml_dsp->NodeInfo.AllUUIDs[0].DllName,(char*)MP4_DEC_NODE_DLL);
   7278     lcml_dsp->NodeInfo.AllUUIDs[0].eDllType = DLL_NODEOBJECT;
   7279 
   7280     lcml_dsp->NodeInfo.AllUUIDs[1].uuid = (struct DSP_UUID *)&MP4DSOCKET_TI_UUID;
   7281     strcpy ((char*)lcml_dsp->NodeInfo.AllUUIDs[1].DllName,(char*)MP4_DEC_NODE_DLL);
   7282     lcml_dsp->NodeInfo.AllUUIDs[1].eDllType = DLL_DEPENDENT;
   7283         pComponentPrivate->MPEG4Codec_IsTI = TRUE;
   7284     }
   7285 
   7286     lcml_dsp->NodeInfo.AllUUIDs[2].uuid = (struct DSP_UUID *)&RINGIO_TI_UUID;
   7287     strcpy ((char*)lcml_dsp->NodeInfo.AllUUIDs[2].DllName,(char*)RINGIO_NODE_DLL);
   7288     lcml_dsp->NodeInfo.AllUUIDs[2].eDllType = DLL_DEPENDENT;
   7289 
   7290     lcml_dsp->NodeInfo.AllUUIDs[3].uuid = (struct DSP_UUID *)&USN_UUID;
   7291     strcpy ((char*)lcml_dsp->NodeInfo.AllUUIDs[3].DllName,(char*)USN_DLL);
   7292     lcml_dsp->NodeInfo.AllUUIDs[3].eDllType = DLL_DEPENDENT;
   7293 
   7294     lcml_dsp->NodeInfo.AllUUIDs[4].uuid = (struct DSP_UUID *)&CONVERSIONS_UUID;
   7295     strcpy ((char*)lcml_dsp->NodeInfo.AllUUIDs[4].DllName,(char*)CONVERSIONS_DLL);
   7296     lcml_dsp->NodeInfo.AllUUIDs[4].eDllType = DLL_DEPENDENT;
   7297 
   7298     lcml_dsp->SegID     = 0;
   7299     lcml_dsp->Timeout   = -1;
   7300     lcml_dsp->Alignment = 0;
   7301     lcml_dsp->Priority  = 5;
   7302 
   7303     if (nFrameWidth * nFrameHeight > 640 * 480) {
   7304         lcml_dsp->ProfileID = 4;
   7305     }
   7306     else if (nFrameWidth * nFrameHeight > 352 * 288) {
   7307         lcml_dsp->ProfileID = 3;
   7308     }
   7309     else if (nFrameWidth * nFrameHeight > 176 * 144) {
   7310         lcml_dsp->ProfileID = 2;
   7311     }
   7312     else if (nFrameWidth * nFrameHeight >= 16 * 16) {
   7313         lcml_dsp->ProfileID = 1;
   7314     }
   7315     else {
   7316         eError = OMX_ErrorUnsupportedSetting;
   7317         goto EXIT;
   7318     }
   7319 
   7320     OMX_MALLOC_STRUCT(pCreatePhaseArgs, MP4VD_GPP_SN_Obj_CreatePhase,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel4]);
   7321     if (pCreatePhaseArgs == NULL) {
   7322         eError = OMX_ErrorInsufficientResources;
   7323         goto EXIT;
   7324     }
   7325     pCreatePhaseArgs->unNumOfStreams            = 2;
   7326     pCreatePhaseArgs->unInputStreamID           = 0;
   7327     pCreatePhaseArgs->unInputBufferType         = 0;
   7328     pCreatePhaseArgs->unlInputNumBufsPerStream  = (OMX_U16)(pComponentPrivate->pInPortDef->nBufferCountActual);
   7329     pCreatePhaseArgs->unOutputStreamID          = 1;
   7330     pCreatePhaseArgs->unOutputBufferType        = 0;
   7331     pCreatePhaseArgs->unOutputNumBufsPerStream  = (OMX_U16)(pComponentPrivate->pOutPortDef->nBufferCountActual);
   7332 
   7333     /* ulMaxWidth and ulMaxHeight needs to be multiples of 16. */
   7334     nFrameWidth = pComponentPrivate->pInPortDef->format.video.nFrameWidth;
   7335     nFrameHeight = pComponentPrivate->pInPortDef->format.video.nFrameHeight;
   7336     if (nFrameWidth & 0xF) nFrameWidth = (nFrameWidth & 0xFFF0) + 0x10;
   7337     if (nFrameHeight & 0xF) nFrameHeight = (nFrameHeight & 0xFFF0) + 0x10;
   7338 
   7339     pCreatePhaseArgs->ulMaxWidth                = (OMX_U16)(nFrameWidth);
   7340     pCreatePhaseArgs->ulMaxHeight               = (OMX_U16)(nFrameHeight);
   7341 
   7342     if (pComponentPrivate->pOutPortDef->format.video.eColorFormat == VIDDEC_COLORFORMAT422) {
   7343         pCreatePhaseArgs->ulYUVFormat           = MP4VIDDEC_YUVFORMAT_INTERLEAVED422;
   7344     }
   7345     else if (pComponentPrivate->pOutPortDef->format.video.eColorFormat == VIDDEC_COLORFORMAT420) {
   7346         pCreatePhaseArgs->ulYUVFormat           = MP4VIDDEC_YUVFORMAT_PLANAR420;
   7347     }
   7348     else
   7349     {
   7350         OMX_PRDSP4(pComponentPrivate->dbg, "Incorrect Color format %x\n",pComponentPrivate->pOutPortDef->format.video.eColorFormat);
   7351         OMX_PRDSP1(pComponentPrivate->dbg, "lcml_dsp->ProfileID = %lu\n", lcml_dsp->ProfileID);
   7352         eError = OMX_ErrorUnsupportedSetting;
   7353         goto EXIT;
   7354     }
   7355 
   7356     OMX_PRBUFFER1(pComponentPrivate->dbg, "pCreatePhaseArgs->ulMaxWidth %lu  pCreatePhaseArgs->ulMaxHeight %lu\n",
   7357         pCreatePhaseArgs->ulMaxWidth,pCreatePhaseArgs->ulMaxHeight);
   7358 
   7359     pCreatePhaseArgs->ulMaxFrameRate            = VIDDEC_MAX_FRAMERATE;
   7360     pCreatePhaseArgs->ulMaxBitRate              = VIDDEC_MAX_BITRATE;
   7361     pCreatePhaseArgs->ulDataEndianness          = 1;
   7362     if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4){
   7363         pCreatePhaseArgs->ulProfile                 = 0;
   7364     }
   7365     else {
   7366         pCreatePhaseArgs->ulProfile                 = 8;
   7367     }
   7368     pCreatePhaseArgs->ulMaxLevel                = -1;
   7369     pCreatePhaseArgs->ulProcessMode             = pComponentPrivate->ProcessMode;
   7370     pCreatePhaseArgs->ulPreRollBufConfig        = 0;
   7371     pCreatePhaseArgs->ulDisplayWidth = 0;
   7372     pCreatePhaseArgs->endArgs                   = END_OF_CR_PHASE_ARGS;
   7373 
   7374     memcpy(pComponentPrivate->arr, pCreatePhaseArgs, sizeof(MP4VD_GPP_SN_Obj_CreatePhase));
   7375     lcml_dsp->pCrPhArgs = pComponentPrivate->arr;
   7376     cb.LCML_Callback = (void*) VIDDEC_LCML_Callback;
   7377 
   7378     if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   7379         pComponentPrivate->pLCML != NULL){
   7380         pComponentPrivate->eLCMLState = VidDec_LCML_State_Init;
   7381 
   7382         eError = LCML_InitMMCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, NULL, &pLcmlHandle, NULL, &cb);
   7383         if (eError != OMX_ErrorNone) {
   7384             OMX_PRDSP4(pComponentPrivate->dbg, "LCML_InitMMCodec Failed!...%x\n",eError);
   7385             eError = OMX_ErrorHardware;
   7386             goto EXIT;
   7387         }
   7388     }
   7389     else {
   7390         eError = OMX_ErrorHardware;
   7391         goto EXIT;
   7392     }
   7393 EXIT:
   7394     if (pCreatePhaseArgs) {
   7395         free(pCreatePhaseArgs);
   7396         pCreatePhaseArgs = NULL;
   7397     }
   7398     OMX_PRDSP1(pComponentPrivate->dbg, "---EXITING(0x%x)\n",eError);
   7399     return eError;
   7400 }
   7401 
   7402 
   7403 /*-------------------------------------------------------------------*/
   7404 /**
   7405   *  Function to fill DSP structures via LCML
   7406   *
   7407   *
   7408   *
   7409   * @retval OMX_NoError              Success, ready to roll
   7410   *
   7411   **/
   7412 /*-------------------------------------------------------------------*/
   7413 
   7414 OMX_ERRORTYPE VIDDEC_InitDSP_Mpeg2Dec(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate)
   7415 {
   7416     OMX_ERRORTYPE eError = OMX_ErrorNone;
   7417     LCML_DSP_INTERFACE *pLcmlHandle = NULL;
   7418     LCML_DSP *lcml_dsp = NULL;
   7419     OMX_U32 nInpBuff = MAX_PRIVATE_IN_BUFFERS;
   7420     OMX_U32 nInpBuffSize = 0;
   7421     OMX_U32 nOutBuff = MAX_PRIVATE_OUT_BUFFERS;
   7422     OMX_U32 nOutBuffSize = 0;
   7423     MP2VDEC_SNCreatePhArg* pCreatePhaseArgs = NULL;
   7424     LCML_CALLBACKTYPE cb;
   7425 
   7426     OMX_PRDSP1(pComponentPrivate->dbg, "+++ENTERING\n");
   7427     /* Get number of input and output buffers */
   7428     nInpBuff = pComponentPrivate->pInPortDef->nBufferCountActual;
   7429     nOutBuff = pComponentPrivate->pOutPortDef->nBufferCountActual;
   7430 
   7431     /* Back it up for further use in this function */
   7432     nInpBuffSize = pComponentPrivate->pInPortDef->nBufferSize;
   7433     nOutBuffSize = pComponentPrivate->pOutPortDef->nBufferSize;
   7434 
   7435     pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
   7436     lcml_dsp = (((LCML_DSP_INTERFACE*)pLcmlHandle)->dspCodec);
   7437 
   7438     lcml_dsp->DeviceInfo.TypeofDevice = 0;
   7439     lcml_dsp->DeviceInfo.DspStream    = NULL;
   7440 
   7441     lcml_dsp->In_BufInfo.nBuffers      = nInpBuff;
   7442     lcml_dsp->In_BufInfo.nSize         = nInpBuffSize;
   7443     lcml_dsp->In_BufInfo.DataTrMethod  = DMM_METHOD;
   7444 
   7445     lcml_dsp->Out_BufInfo.nBuffers     = nOutBuff;
   7446     lcml_dsp->Out_BufInfo.nSize        = nOutBuffSize;
   7447     lcml_dsp->Out_BufInfo.DataTrMethod = DMM_METHOD;
   7448 
   7449     lcml_dsp->NodeInfo.nNumOfDLLs       = OMX_MP2DEC_NUM_DLLS;
   7450     lcml_dsp->NodeInfo.AllUUIDs[0].uuid = (struct DSP_UUID *)&MP2DSOCKET_TI_UUID;
   7451     strcpy ((char*)lcml_dsp->NodeInfo.AllUUIDs[0].DllName,(char*)MP2_DEC_NODE_DLL);
   7452     lcml_dsp->NodeInfo.AllUUIDs[0].eDllType = DLL_NODEOBJECT;
   7453 
   7454     lcml_dsp->NodeInfo.AllUUIDs[1].uuid = (struct DSP_UUID *)&MP2DSOCKET_TI_UUID;
   7455     strcpy ((char*)lcml_dsp->NodeInfo.AllUUIDs[1].DllName,(char*)MP2_DEC_NODE_DLL);
   7456     lcml_dsp->NodeInfo.AllUUIDs[1].eDllType = DLL_DEPENDENT;
   7457 
   7458     lcml_dsp->NodeInfo.AllUUIDs[2].uuid = (struct DSP_UUID *)&RINGIO_TI_UUID;
   7459     strcpy ((char*)lcml_dsp->NodeInfo.AllUUIDs[2].DllName,(char*)RINGIO_NODE_DLL);
   7460     lcml_dsp->NodeInfo.AllUUIDs[2].eDllType = DLL_DEPENDENT;
   7461 
   7462     lcml_dsp->NodeInfo.AllUUIDs[3].uuid = (struct DSP_UUID *)&USN_UUID;
   7463     strcpy ((char*)lcml_dsp->NodeInfo.AllUUIDs[3].DllName,(char*)USN_DLL);
   7464     lcml_dsp->NodeInfo.AllUUIDs[3].eDllType = DLL_DEPENDENT;
   7465 
   7466     lcml_dsp->SegID     = 0;
   7467     lcml_dsp->Timeout   = -1;
   7468     lcml_dsp->Alignment = 0;
   7469     lcml_dsp->Priority  = 5;
   7470 
   7471     if(pComponentPrivate->ProcessMode == 0){
   7472         if ((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth > 352) ||
   7473             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight > 288)) {
   7474             lcml_dsp->ProfileID = 3;
   7475         }
   7476         else if (((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth <= 352) &&
   7477             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth > 176)) ||
   7478             ((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight <= 288) &&
   7479             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight > 144))) {
   7480             lcml_dsp->ProfileID = 2;
   7481         }
   7482         else if (((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth <= 176) &&
   7483             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth >= 16)) ||
   7484             ((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight <= 144) &&
   7485             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight >= 16))) {
   7486             lcml_dsp->ProfileID = 1;
   7487         }
   7488         else {
   7489             eError = OMX_ErrorUnsupportedSetting;
   7490             goto EXIT;
   7491         }
   7492     }
   7493     else if(pComponentPrivate->ProcessMode == 1) {
   7494         if ((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth > 352) ||
   7495             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight > 288)) {
   7496             lcml_dsp->ProfileID = 3;
   7497         }
   7498         else if (((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth <= 352) &&
   7499             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth > 176)) ||
   7500             ((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight <= 288) &&
   7501             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight > 144))) {
   7502             lcml_dsp->ProfileID = 2;
   7503         }
   7504         else if (((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth <= 176) &&
   7505             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth >= 16)) ||
   7506             ((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight <= 144) &&
   7507             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight >= 16))) {
   7508             lcml_dsp->ProfileID = 1;
   7509         }
   7510         else {
   7511             eError = OMX_ErrorUnsupportedSetting;
   7512             goto EXIT;
   7513         }
   7514     }
   7515 
   7516     OMX_MALLOC_STRUCT(pCreatePhaseArgs, MP2VDEC_SNCreatePhArg,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel4]);
   7517     if (pCreatePhaseArgs == NULL) {
   7518         eError = OMX_ErrorInsufficientResources;
   7519         goto EXIT;
   7520     }
   7521     pCreatePhaseArgs->unNumOfStreams            = 2;
   7522     pCreatePhaseArgs->unInputStreamID           = 0;
   7523     pCreatePhaseArgs->unInputBufferType         = 0;
   7524     pCreatePhaseArgs->unInputNumBufsPerStream  = (OMX_U16)(pComponentPrivate->pInPortDef->nBufferCountActual);
   7525     pCreatePhaseArgs->unOutputStreamID          = 1;
   7526     pCreatePhaseArgs->unOutputBufferType        = 0;
   7527     pCreatePhaseArgs->unOutputNumBufsPerStream  = (OMX_U16)(pComponentPrivate->pOutPortDef->nBufferCountActual);
   7528     pCreatePhaseArgs->ulMaxWidth                = (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth);
   7529     pCreatePhaseArgs->ulMaxHeight               = (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight);
   7530 
   7531     if (pComponentPrivate->pOutPortDef->format.video.eColorFormat == VIDDEC_COLORFORMAT422) {
   7532         pCreatePhaseArgs->ulYUVFormat           = MP2VIDDEC_YUVFORMAT_INTERLEAVED422;
   7533     }
   7534     else if (pComponentPrivate->pOutPortDef->format.video.eColorFormat == VIDDEC_COLORFORMAT420) {
   7535         pCreatePhaseArgs->ulYUVFormat           = MP2VIDDEC_YUVFORMAT_PLANAR420;
   7536     }
   7537     else
   7538     {
   7539         OMX_PRDSP4(pComponentPrivate->dbg, "Incorrect Color format %x\n",pComponentPrivate->pOutPortDef->format.video.eColorFormat);
   7540         eError = OMX_ErrorUnsupportedSetting;
   7541         goto EXIT;
   7542     }
   7543 
   7544     pCreatePhaseArgs->ulMaxFrameRate            = 0;
   7545     pCreatePhaseArgs->ulMaxBitRate              = -1;
   7546     pCreatePhaseArgs->ulDataEndianness          = 1;
   7547     pCreatePhaseArgs->ulProfile                 = 0;
   7548     pCreatePhaseArgs->lMaxLevel                = -1;
   7549     pCreatePhaseArgs->ulProcessMode             = pComponentPrivate->ProcessMode;
   7550     pCreatePhaseArgs->lPreRollBufConfig        = 0;
   7551     pCreatePhaseArgs->ulDisplayWidth = 0;
   7552     pCreatePhaseArgs->endArgs                   = END_OF_CR_PHASE_ARGS;
   7553 
   7554 
   7555     memcpy(pComponentPrivate->arr, pCreatePhaseArgs, sizeof(MP2VDEC_SNCreatePhArg));
   7556     lcml_dsp->pCrPhArgs = pComponentPrivate->arr;
   7557     cb.LCML_Callback = (void*) VIDDEC_LCML_Callback;
   7558 
   7559     if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   7560         pComponentPrivate->pLCML != NULL){
   7561         eError = LCML_InitMMCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, NULL, &pLcmlHandle, NULL, &cb);
   7562         if (eError != OMX_ErrorNone) {
   7563             OMX_PRDSP4(pComponentPrivate->dbg, "LCML_InitMMCodec Failed!...%x\n",eError);
   7564             eError = OMX_ErrorHardware;
   7565             goto EXIT;
   7566         }
   7567     }
   7568     else {
   7569         eError = OMX_ErrorHardware;
   7570         goto EXIT;
   7571     }
   7572 EXIT:
   7573     if (pCreatePhaseArgs) {
   7574         free(pCreatePhaseArgs);
   7575         pCreatePhaseArgs = NULL;
   7576     }
   7577     OMX_PRDSP1(pComponentPrivate->dbg, "---EXITING(0x%x)\n",eError);
   7578     return eError;
   7579 }
   7580 
   7581 /*-------------------------------------------------------------------*/
   7582 /**
   7583   *  Function to fill DSP structures via LCML
   7584   *
   7585   *
   7586   *
   7587   * @retval OMX_NoError              Success, ready to roll
   7588   *
   7589   **/
   7590 /*-------------------------------------------------------------------*/
   7591 
   7592 OMX_ERRORTYPE VIDDEC_InitDSP_SparkDec(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate)
   7593 {
   7594     OMX_ERRORTYPE eError = OMX_ErrorNone;
   7595     LCML_DSP_INTERFACE *pLcmlHandle = NULL;
   7596     LCML_DSP *lcml_dsp = NULL;
   7597     OMX_U32 nInpBuff = MAX_PRIVATE_IN_BUFFERS;
   7598     OMX_U32 nInpBuffSize = 0;
   7599     OMX_U32 nOutBuff = MAX_PRIVATE_OUT_BUFFERS;
   7600     OMX_U32 nOutBuffSize = 0;
   7601     SPARKVD_GPP_SN_Obj_CreatePhase* pCreatePhaseArgs = NULL;
   7602     LCML_CALLBACKTYPE cb;
   7603 
   7604     OMX_PRDSP1(pComponentPrivate->dbg, "+++ENTERING\n");
   7605     /* Get number of input and output buffers */
   7606     nInpBuff = pComponentPrivate->pInPortDef->nBufferCountActual;
   7607     nOutBuff = pComponentPrivate->pOutPortDef->nBufferCountActual;
   7608 
   7609     /* Back it up for further use in this function */
   7610     nInpBuffSize = pComponentPrivate->pInPortDef->nBufferSize;
   7611     nOutBuffSize = pComponentPrivate->pOutPortDef->nBufferSize;
   7612 
   7613     pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
   7614     lcml_dsp = (((LCML_DSP_INTERFACE*)pLcmlHandle)->dspCodec);
   7615 
   7616     lcml_dsp->DeviceInfo.TypeofDevice = 0;
   7617     lcml_dsp->DeviceInfo.DspStream    = NULL;
   7618 
   7619     lcml_dsp->In_BufInfo.nBuffers      = nInpBuff;
   7620     lcml_dsp->In_BufInfo.nSize         = nInpBuffSize;
   7621     lcml_dsp->In_BufInfo.DataTrMethod  = DMM_METHOD;
   7622 
   7623     lcml_dsp->Out_BufInfo.nBuffers     = nOutBuff;
   7624     lcml_dsp->Out_BufInfo.nSize        = nOutBuffSize;
   7625     lcml_dsp->Out_BufInfo.DataTrMethod = DMM_METHOD;
   7626 
   7627     lcml_dsp->NodeInfo.nNumOfDLLs       = OMX_SPARKDEC_NUM_DLLS;
   7628     lcml_dsp->NodeInfo.AllUUIDs[0].uuid = (struct DSP_UUID *)&SPARKDSOCKET_TI_UUID;
   7629     strcpy ((char*)lcml_dsp->NodeInfo.AllUUIDs[0].DllName,(char*)SPARK_DEC_NODE_DLL);
   7630     lcml_dsp->NodeInfo.AllUUIDs[0].eDllType = DLL_NODEOBJECT;
   7631 
   7632     lcml_dsp->NodeInfo.AllUUIDs[1].uuid = (struct DSP_UUID *)&SPARKDSOCKET_TI_UUID;
   7633     strcpy ((char*)lcml_dsp->NodeInfo.AllUUIDs[1].DllName,(char*)SPARK_DEC_NODE_DLL);
   7634     lcml_dsp->NodeInfo.AllUUIDs[1].eDllType = DLL_DEPENDENT;
   7635 
   7636     lcml_dsp->NodeInfo.AllUUIDs[2].uuid = (struct DSP_UUID *)&RINGIO_TI_UUID;
   7637     strcpy ((char*)lcml_dsp->NodeInfo.AllUUIDs[2].DllName,(char*)RINGIO_NODE_DLL);
   7638     lcml_dsp->NodeInfo.AllUUIDs[2].eDllType = DLL_DEPENDENT;
   7639 
   7640     lcml_dsp->NodeInfo.AllUUIDs[3].uuid = (struct DSP_UUID *)&USN_UUID;
   7641     strcpy ((char*)lcml_dsp->NodeInfo.AllUUIDs[3].DllName,(char*)USN_DLL);
   7642     lcml_dsp->NodeInfo.AllUUIDs[3].eDllType = DLL_DEPENDENT;
   7643 
   7644     lcml_dsp->NodeInfo.AllUUIDs[4].uuid = (struct DSP_UUID *)&CONVERSIONS_UUID;
   7645     strcpy ((char*)lcml_dsp->NodeInfo.AllUUIDs[4].DllName,(char*)CONVERSIONS_DLL);
   7646     lcml_dsp->NodeInfo.AllUUIDs[4].eDllType = DLL_DEPENDENT;
   7647 
   7648     lcml_dsp->SegID     = 0;
   7649     lcml_dsp->Timeout   = -1;
   7650     lcml_dsp->Alignment = 0;
   7651     lcml_dsp->Priority  = 5;
   7652 
   7653 
   7654     if(pComponentPrivate->ProcessMode == 0){
   7655         if ((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth > 640) ||
   7656             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight > 480)) {
   7657             lcml_dsp->ProfileID = 4;
   7658         }
   7659         else if (((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth <= 640) &&
   7660             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth > 352)) ||
   7661             ((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight <= 480) &&
   7662             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight > 288))) {
   7663             lcml_dsp->ProfileID = 3;
   7664         }
   7665         else if (((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth <= 352) &&
   7666             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth > 176)) ||
   7667             ((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight <= 288) &&
   7668             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight > 144))) {
   7669             lcml_dsp->ProfileID = 2;
   7670         }
   7671         else if (((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth <= 176) &&
   7672             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth >= 16)) ||
   7673             ((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight <= 144) &&
   7674             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight >= 16))) {
   7675             lcml_dsp->ProfileID = 1;
   7676         }
   7677         else {
   7678             eError = OMX_ErrorUnsupportedSetting;
   7679             goto EXIT;
   7680         }
   7681     }
   7682     else if(pComponentPrivate->ProcessMode == 1) {
   7683         if ((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth > 640) ||
   7684             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight > 480)) {
   7685             lcml_dsp->ProfileID = 4;
   7686         }
   7687         else if (((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth <= 640) &&
   7688             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth > 352)) ||
   7689             ((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight <= 480) &&
   7690             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight > 288))) {
   7691             lcml_dsp->ProfileID = 3;
   7692         }
   7693         else if (((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth <= 352) &&
   7694             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth > 176)) ||
   7695             ((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight <= 288) &&
   7696             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight > 144))) {
   7697             lcml_dsp->ProfileID = 2;
   7698         }
   7699         else if (((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth <= 176) &&
   7700             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth >= 16)) ||
   7701             ((OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight <= 144) &&
   7702             (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight >= 16))) {
   7703             lcml_dsp->ProfileID = 1;
   7704         }
   7705         else {
   7706             eError = OMX_ErrorUnsupportedSetting;
   7707             goto EXIT;
   7708         }
   7709     }
   7710 
   7711     OMX_MALLOC_STRUCT(pCreatePhaseArgs, SPARKVD_GPP_SN_Obj_CreatePhase,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel4]);
   7712     if (pCreatePhaseArgs == NULL) {
   7713         eError = OMX_ErrorInsufficientResources;
   7714         goto EXIT;
   7715     }
   7716     pCreatePhaseArgs->unNumOfStreams            = 2;
   7717     pCreatePhaseArgs->unInputStreamID           = 0;
   7718     pCreatePhaseArgs->unInputBufferType         = 0;
   7719     pCreatePhaseArgs->unlInputNumBufsPerStream  = (OMX_U16)(pComponentPrivate->pInPortDef->nBufferCountActual);
   7720     pCreatePhaseArgs->unOutputStreamID          = 1;
   7721     pCreatePhaseArgs->unOutputBufferType        = 0;
   7722     pCreatePhaseArgs->unOutputNumBufsPerStream  = (OMX_U16)(pComponentPrivate->pOutPortDef->nBufferCountActual);
   7723     pCreatePhaseArgs->ulMaxWidth                = (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameWidth);
   7724     pCreatePhaseArgs->ulMaxHeight               = (OMX_U16)(pComponentPrivate->pInPortDef->format.video.nFrameHeight);
   7725 
   7726     if (pComponentPrivate->pOutPortDef->format.video.eColorFormat == VIDDEC_COLORFORMAT422) {
   7727         pCreatePhaseArgs->ulYUVFormat           = SPARKVIDDEC_YUVFORMAT_INTERLEAVED422;
   7728     }
   7729     else if (pComponentPrivate->pOutPortDef->format.video.eColorFormat == VIDDEC_COLORFORMAT420) {
   7730         pCreatePhaseArgs->ulYUVFormat           = SPARKVIDDEC_YUVFORMAT_PLANAR420;
   7731     }
   7732     else
   7733     {
   7734         OMX_PRDSP4(pComponentPrivate->dbg, "Incorrect Color format %x\n",pComponentPrivate->pOutPortDef->format.video.eColorFormat);
   7735         eError = OMX_ErrorUnsupportedSetting;
   7736         goto EXIT;
   7737     }
   7738 
   7739     pCreatePhaseArgs->ulMaxFrameRate            = 0;
   7740     pCreatePhaseArgs->ulMaxBitRate              = -1;
   7741     pCreatePhaseArgs->ulDataEndianness          = 1;
   7742     pCreatePhaseArgs->ulProfile                 = 0;
   7743     pCreatePhaseArgs->ulMaxLevel                = -1;
   7744     pCreatePhaseArgs->ulProcessMode             = pComponentPrivate->ProcessMode;
   7745     pCreatePhaseArgs->ulPreRollBufConfig        = 0;
   7746     pCreatePhaseArgs->endArgs                   = END_OF_CR_PHASE_ARGS;
   7747 
   7748     memcpy(pComponentPrivate->arr, pCreatePhaseArgs, sizeof(SPARKVD_GPP_SN_Obj_CreatePhase));
   7749     lcml_dsp->pCrPhArgs = pComponentPrivate->arr;
   7750     cb.LCML_Callback = (void*) VIDDEC_LCML_Callback;
   7751 
   7752     if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   7753         pComponentPrivate->pLCML != NULL){
   7754         eError = LCML_InitMMCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, NULL, &pLcmlHandle, NULL, &cb);
   7755         if (eError != OMX_ErrorNone) {
   7756             OMX_PRDSP4(pComponentPrivate->dbg, "LCML_InitMMCodec Failed!...%x\n",eError);
   7757             eError = OMX_ErrorHardware;
   7758             goto EXIT;
   7759         }
   7760     }
   7761     else {
   7762         eError = OMX_ErrorHardware;
   7763         goto EXIT;
   7764     }
   7765 EXIT:
   7766     if (pCreatePhaseArgs) {
   7767         free(pCreatePhaseArgs);
   7768         pCreatePhaseArgs = NULL;
   7769     }
   7770     OMX_PRDSP1(pComponentPrivate->dbg, "---EXITING(0x%x)\n",eError);
   7771     return eError;
   7772 }
   7773 
   7774 /* ========================================================================== */
   7775 /**
   7776   *  VIDDEC_Handle_InvalidState() Function called for a non recoverable error
   7777   *
   7778   * @param pComponentPrivate         This is the pointer to the private structure
   7779   *
   7780   * @retval OMX_NoError              Success, ready to roll
   7781   *         OMX_ErrorHardware        If OMX_StateInvalid is the actual state
   7782  **/
   7783 /* ========================================================================== */
   7784 OMX_ERRORTYPE VIDDEC_Handle_InvalidState (VIDDEC_COMPONENT_PRIVATE* pComponentPrivate)
   7785 {
   7786     OMX_ERRORTYPE eError = OMX_ErrorNone;
   7787 
   7788     OMX_PRSTATE1(pComponentPrivate->dbg, "+++ENTERING\n");
   7789     OMX_PRSTATE2(pComponentPrivate->dbg, "pComponentPrivate 0x%p\n", (int*)pComponentPrivate);
   7790 
   7791     if(pComponentPrivate->eState != OMX_StateInvalid) {
   7792         pComponentPrivate->eState = OMX_StateInvalid;
   7793         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   7794                                                pComponentPrivate->pHandle->pApplicationPrivate,
   7795                                                OMX_EventError,
   7796                                                OMX_ErrorInvalidState,
   7797                                                OMX_TI_ErrorCritical,
   7798                                                "Transitioning to Invalid State");
   7799         eError = OMX_ErrorNone;
   7800     }
   7801     else {
   7802         eError = OMX_ErrorHardware;
   7803     }
   7804     OMX_PRSTATE1(pComponentPrivate->dbg, "---EXITING(0x%x)\n",eError);
   7805     return eError;
   7806 }
   7807 
   7808 
   7809 /* ========================================================================== */
   7810 /**
   7811   *  VIDDEC_PROPAGATE_MARK() Function called for propagate mark from input buffers to output buffers
   7812   *
   7813   * @param pComponentPrivate         This is the pointer to the private structure
   7814   * @param pBuffHead                       This is the pointer to the output buffer
   7815   *
   7816   * @retval OMX_NoError              Success
   7817   *         OMX_ErrorUnsupportedSetting        If CompressionFormat has not a valid value
   7818  **/
   7819 /* ========================================================================== */
   7820 OMX_ERRORTYPE VIDDEC_Propagate_Mark(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate, OMX_BUFFERHEADERTYPE *pBuffHead)
   7821 {
   7822     OMX_ERRORTYPE eError = OMX_ErrorNone;
   7823 
   7824     if (pBuffHead->nFilledLen != 0) {
   7825         pBuffHead->hMarkTargetComponent = pComponentPrivate->arrMarkBufIndex[pComponentPrivate->nInMarkBufIndex].hMarkTargetComponent;
   7826         pBuffHead->pMarkData = pComponentPrivate->arrMarkBufIndex[pComponentPrivate->nInMarkBufIndex].pMarkData;
   7827         pComponentPrivate->nOutMarkBufIndex++;
   7828         pComponentPrivate->nOutMarkBufIndex %= VIDDEC_MAX_QUEUE_SIZE;
   7829         eError = OMX_ErrorNone;
   7830     }
   7831     if(pBuffHead->hMarkTargetComponent == pComponentPrivate->pHandle)
   7832     {
   7833         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   7834                         pComponentPrivate->pHandle->pApplicationPrivate,
   7835                         OMX_EventMark,
   7836                         0,
   7837                         0,
   7838                         pBuffHead->pMarkData);
   7839     }
   7840 
   7841     return eError;
   7842 }
   7843 
   7844 
   7845 
   7846 /* ========================================================================== */
   7847 /**
   7848   *  Callback() function will be called LCML component to write the msg
   7849   *
   7850   * @param msgBuffer                 This buffer will be returned by the LCML
   7851   *
   7852   * @retval OMX_NoError              Success, ready to roll
   7853   *         OMX_Error_BadParameter   The input parameter pointer is null
   7854  **/
   7855 /* ========================================================================== */
   7856 
   7857 OMX_ERRORTYPE VIDDEC_LCML_Callback (TUsnCodecEvent event,void * argsCb [10])
   7858 {
   7859     VIDDEC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
   7860     OMX_ERRORTYPE eError = OMX_ErrorNone;
   7861     VIDDEC_BUFFER_PRIVATE* pBufferPrivate = NULL;
   7862     OMX_S32 nRetVal = 0;
   7863 
   7864     pComponentPrivate = (VIDDEC_COMPONENT_PRIVATE*)((LCML_DSP_INTERFACE*)argsCb[6])->pComponentPrivate;
   7865 
   7866 #if 0
   7867     switch(event) {
   7868         case EMMCodecDspError:
   7869             OMX_PRDSP2(pComponentPrivate->dbg, "[LCML CALLBACK EVENT]  EMMCodecDspError (int)argsCb [0] %x (int)argsCb [4] %x (int)argsCb [5] %x\n",(int)argsCb [0],(int)argsCb [4],(int)argsCb [5]);
   7870             break;
   7871 
   7872         case EMMCodecInternalError:
   7873             OMX_PRDSP2(pComponentPrivate->dbg, "[LCML CALLBACK EVENT]  EMMCodecInternalError\n");
   7874             break;
   7875 
   7876         case EMMCodecInitError:
   7877             OMX_PRDSP2(pComponentPrivate->dbg, "[LCML CALLBACK EVENT]  EMMCodecInitError\n");
   7878             break;
   7879 
   7880         case EMMCodecDspMessageRecieved:
   7881             OMX_PRDSP1(pComponentPrivate->dbg, "[LCML CALLBACK EVENT]  EMMCodecDspMessageRecieved\n");
   7882             break;
   7883         case EMMCodecBufferProcessed:
   7884             OMX_PRDSP0(pComponentPrivate->dbg, "[LCML CALLBACK EVENT]  EMMCodecBufferProcessed %x\n",(int)argsCb [0]);
   7885             break;
   7886         case EMMCodecProcessingStarted:
   7887             OMX_PRDSP1(pComponentPrivate->dbg, "[LCML CALLBACK EVENT]  EMMCodecProcessingStarted\n");
   7888             break;
   7889 
   7890         case EMMCodecProcessingPaused:
   7891             OMX_PRDSP1(pComponentPrivate->dbg, "[LCML CALLBACK EVENT]  EMMCodecProcessingPaused\n");
   7892             break;
   7893 
   7894         case EMMCodecProcessingStoped:
   7895             OMX_PRDSP1(pComponentPrivate->dbg, "[LCML CALLBACK EVENT]  EMMCodecProcessingStoped\n");
   7896             break;
   7897 
   7898         case EMMCodecProcessingEof:
   7899             OMX_PRDSP1(pComponentPrivate->dbg, "[LCML CALLBACK EVENT]  EMMCodecProcessingEof\n");
   7900             break;
   7901         case EMMCodecBufferNotProcessed:
   7902             OMX_PRDSP2(pComponentPrivate->dbg, "[LCML CALLBACK EVENT]  EMMCodecBufferNotProcessed %x\n",(int)argsCb [0]);
   7903             break;
   7904         case EMMCodecAlgCtrlAck:
   7905             OMX_PRDSP1(pComponentPrivate->dbg, "[LCML CALLBACK EVENT]  EMMCodecAlgCtrlAck\n");
   7906             break;
   7907 
   7908         case EMMCodecStrmCtrlAck:
   7909             OMX_PRDSP1(pComponentPrivate->dbg, "[LCML CALLBACK EVENT]  EMMCodecStrmCtrlAck\n");
   7910             break;
   7911     }
   7912 #endif
   7913 
   7914     OMX_PRDSP0(pComponentPrivate->dbg, "+++ENTERING\n");
   7915     OMX_PRDSP0(pComponentPrivate->dbg, "pComponentPrivate 0x%p 0x%x\n", (int*)pComponentPrivate,event);
   7916 
   7917     if(pComponentPrivate->pCompPort[0] == NULL){
   7918         OMX_PRDSP4(pComponentPrivate->dbg, "*****************************error in lcmlcalback******************************\n");
   7919         goto EXIT;
   7920     }
   7921     if (event == EMMCodecProcessingPaused) {
   7922         VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->sMutex);
   7923         VIDDEC_PTHREAD_MUTEX_SIGNAL(pComponentPrivate->sMutex);
   7924         VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   7925         pComponentPrivate->bTransPause = 1;
   7926     }
   7927     else if (event == EMMCodecAlgCtrlAck) {
   7928         VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->sMutex);
   7929         VIDDEC_PTHREAD_MUTEX_SIGNAL(pComponentPrivate->sMutex);
   7930         VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   7931         pComponentPrivate->bTransPause = 1;
   7932     }
   7933     else if (event == EMMCodecProcessingStoped) {
   7934         VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->sMutex);
   7935         VIDDEC_PTHREAD_MUTEX_SIGNAL(pComponentPrivate->sMutex);
   7936         VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   7937         pComponentPrivate->bTransPause = 1;
   7938         pComponentPrivate->bIsPaused = 0;
   7939     }
   7940     else if (event == EMMCodecProcessingStarted) {
   7941         VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->sMutex);
   7942         VIDDEC_PTHREAD_MUTEX_SIGNAL(pComponentPrivate->sMutex);
   7943         VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   7944         pComponentPrivate->bTransPause = 1;
   7945         pComponentPrivate->bIsPaused = 0;
   7946     }
   7947     else if (event == EMMCodecBufferProcessed) {
   7948         OMX_PRDSP2(pComponentPrivate->dbg, "EMMCodecBufferProcessed 0x%lx\n", (OMX_U32)argsCb [0]);
   7949         if ((OMX_U32)argsCb [0] == EMMCodecOuputBuffer) {
   7950             OMX_PRBUFFER1(pComponentPrivate->dbg, "EMMCodecOuputBuffer\n");
   7951             OMX_BUFFERHEADERTYPE* pBuffHead = NULL;
   7952             VIDDEC_BUFFER_PRIVATE* pBuffPriv = NULL;
   7953             OMX_U8* pBuffer;
   7954 
   7955         if (pComponentPrivate->eState != OMX_StateLoaded && pComponentPrivate->eState != OMX_StateIdle) {
   7956             pBuffHead = (OMX_BUFFERHEADERTYPE*)argsCb[7];
   7957             if(pBuffHead != NULL)
   7958             {
   7959                 OMX_PRBUFFER1(pComponentPrivate->dbg, "pBuffHead Output 0x%p pBuffer 0x%p\n", pBuffHead, argsCb[1]);
   7960                 pBuffPriv = (VIDDEC_BUFFER_PRIVATE*)pBuffHead->pOutputPortPrivate;
   7961                 if (pBuffPriv != NULL) {
   7962                     if(pBuffPriv->eBufferOwner != VIDDEC_BUFFER_WITH_CLIENT)
   7963                     {
   7964 #ifdef __PERF_INSTRUMENTATION__
   7965                         pComponentPrivate->lcml_nCntOpReceived++;
   7966                         if (pComponentPrivate->lcml_nCntOpReceived == 4) {
   7967                             PERF_Boundary(pComponentPrivate->pPERFcomp,
   7968                                           PERF_BoundaryStart | PERF_BoundarySteadyState);
   7969                         }
   7970 #endif
   7971                         pBuffer = (OMX_U8*)argsCb[1];
   7972                         /* Retrieve time stamp information */
   7973                         if (pComponentPrivate->ProcessMode == 0) {
   7974                             OMX_PTR pBufferFlags;
   7975                             VIDDEC_CircBuf_Remove(pComponentPrivate,
   7976                                                VIDDEC_CBUFFER_TIMESTAMP,
   7977                                                VIDDEC_INPUT_PORT,
   7978                                                &pBufferFlags);
   7979                             if(pBufferFlags != NULL){
   7980                                 pBuffHead->nTimeStamp = (OMX_TICKS)((VIDDEC_CBUFFER_BUFFERFLAGS*)pBufferFlags)->nTimeStamp;
   7981                                 /*pBuffHead->nFlags = 0;
   7982                                 pBuffHead->nFlags = (OMX_U32)((VIDDEC_CBUFFER_BUFFERFLAGS*)pBufferFlags)->nFlags;*/
   7983                                 pBuffHead->nFlags |= (((OMX_U32)((VIDDEC_CBUFFER_BUFFERFLAGS*)pBufferFlags)->nFlags) & OMX_BUFFERFLAG_DECODEONLY);
   7984                                 pBuffHead->nTickCount = (OMX_U32)((VIDDEC_CBUFFER_BUFFERFLAGS*)pBufferFlags)->nTickCount;
   7985                             }
   7986                             else {
   7987                                 pBuffHead->nTimeStamp = 0;
   7988                                 pBuffHead->nTickCount = 0;
   7989                             }
   7990                         }
   7991                         else {
   7992                             if (pBuffHead->nFilledLen != 0){
   7993                                 pBuffHead->nTimeStamp = (OMX_TICKS)pComponentPrivate->arrBufIndex[pComponentPrivate->nOutBufIndex];
   7994                                 pComponentPrivate->nOutBufIndex++;
   7995                                 pComponentPrivate->nOutBufIndex %= VIDDEC_MAX_QUEUE_SIZE;
   7996                             }
   7997                         }
   7998                         OMX_PRBUFFER1(pComponentPrivate->dbg, "pBuffHead->nTimeStamp %lld\n", pBuffHead->nTimeStamp);
   7999                         if(pBuffHead != NULL){
   8000                             /*if (pComponentPrivate->pCompPort[1]->hTunnelComponent != NULL) {
   8001                                 pBuffHead->nFilledLen = (OMX_S32)argsCb[2];
   8002                             }
   8003                             else {*/
   8004                                 pBuffHead->nFilledLen = (OMX_S32)argsCb[8];
   8005                             /*}*/
   8006                             OMX_PRBUFFER1(pComponentPrivate->dbg, "pBuffHead->nFilledLen %lu\n", pBuffHead->nFilledLen);
   8007                             eError = IncrementCount (&(pComponentPrivate->nCountOutputBFromDsp), &(pComponentPrivate->mutexOutputBFromDSP));
   8008                             if (eError != OMX_ErrorNone) {
   8009                                 return eError;
   8010                             }
   8011                             pBufferPrivate = (VIDDEC_BUFFER_PRIVATE* )pBuffHead->pOutputPortPrivate;
   8012                             pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_COMPONENT;
   8013                             OMX_PRBUFFER1(pComponentPrivate->dbg, "eBufferOwner 0x%x\n", pBufferPrivate->eBufferOwner);
   8014 #ifdef __PERF_INSTRUMENTATION__
   8015                             PERF_ReceivedFrame(pComponentPrivate->pPERFcomp,
   8016                                                pBuffHead->pBuffer,
   8017                                                pBuffHead->nFilledLen,
   8018                                                PERF_ModuleCommonLayer);
   8019 #endif
   8020 
   8021                             nRetVal = write(pComponentPrivate->filled_outBuf_Q[1],&pBuffHead,sizeof(pBuffHead));
   8022                             if(nRetVal == -1){
   8023                                 DecrementCount (&(pComponentPrivate->nCountOutputBFromDsp), &(pComponentPrivate->mutexOutputBFromDSP));
   8024                                 pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_DSP;
   8025                                 OMX_PRCOMM4(pComponentPrivate->dbg, "writing to the input pipe %x (%ld)\n", OMX_ErrorInsufficientResources,nRetVal);
   8026                                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   8027                                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   8028                                                                        OMX_EventError,
   8029                                                                        OMX_ErrorInsufficientResources,
   8030                                                                        OMX_TI_ErrorSevere,
   8031                                                                        "Error writing to the output pipe");
   8032                             }
   8033                         }
   8034                     }
   8035                     else {
   8036                         OMX_PRDSP1(pComponentPrivate->dbg, "buffer dropped lcml out process pBuffHead %p owner %d\n",pBuffHead,pBuffPriv->eBufferOwner);
   8037                     }
   8038                 }
   8039             }
   8040         }
   8041         }
   8042         if ((OMX_U32)argsCb [0] == EMMCodecInputBuffer ||
   8043                 ((OMX_U32)argsCb [0] == EMMCodecInputBufferMapBufLen)) {
   8044             OMX_PRBUFFER1(pComponentPrivate->dbg, "EMMCodecInputBuffer\n");
   8045             OMX_BUFFERHEADERTYPE* pBuffHead = NULL;
   8046             VIDDEC_BUFFER_PRIVATE* pBuffPriv = NULL;
   8047             OMX_U8* pBuffer;
   8048             if (pComponentPrivate->eState != OMX_StateLoaded && pComponentPrivate->eState != OMX_StateIdle) {
   8049             pBuffHead = (OMX_BUFFERHEADERTYPE*)argsCb[7];
   8050             if(pBuffHead != NULL)
   8051             {
   8052                 pBuffPriv = (VIDDEC_BUFFER_PRIVATE*)pBuffHead->pInputPortPrivate;
   8053                 if (pBuffPriv == NULL ) {
   8054                     goto EXIT;
   8055                 }
   8056                 else {
   8057                     if(pBuffPriv->eBufferOwner != VIDDEC_BUFFER_WITH_CLIENT)
   8058                     {
   8059                         OMX_PRBUFFER1(pComponentPrivate->dbg, "pBuffHead Input 0x%p pBuffer 0x%p\n", pBuffHead, argsCb[1]);
   8060                         pBuffer = (OMX_U8*)argsCb[1];
   8061                         if(pBuffer != NULL){
   8062                             eError = IncrementCount (&(pComponentPrivate->nCountInputBFromDsp), &(pComponentPrivate->mutexInputBFromDSP));
   8063                             if (eError != OMX_ErrorNone) {
   8064                                 return eError;
   8065                             }
   8066                             pBufferPrivate = (VIDDEC_BUFFER_PRIVATE* )pBuffHead->pInputPortPrivate;
   8067                             pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_COMPONENT;
   8068                             OMX_PRBUFFER1(pComponentPrivate->dbg, "eBufferOwner 0x%x\n", pBufferPrivate->eBufferOwner);
   8069     #ifdef __PERF_INSTRUMENTATION__
   8070                             PERF_ReceivedFrame(pComponentPrivate->pPERFcomp,
   8071                                                PREF(pBuffHead,pBuffer),
   8072                                                PREF(pBuffHead,nFilledLen),
   8073                                                PERF_ModuleCommonLayer);
   8074     #endif
   8075                             pBuffHead->nFilledLen = 0;
   8076                             if (pComponentPrivate->nWMVFileType == VIDDEC_WMV_ELEMSTREAM &&
   8077                                 pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV &&
   8078                                 pComponentPrivate->ProcessMode == 0) {
   8079                                 /* vc-1 fix */
   8080 #ifdef VIDDEC_WMVPOINTERFIXED
   8081                                 OMX_PRBUFFER1(pComponentPrivate->dbg, "restoring buffer pointer 0x%p >> pBuffer 0x%p\n",
   8082                                     pBufferPrivate->pTempBuffer, pBuffHead->pBuffer);
   8083                                 pBuffHead->pBuffer = pBufferPrivate->pTempBuffer;
   8084 #else
   8085                                 pBuffHead->nOffset = VIDDEC_WMV_BUFFER_OFFSET;
   8086 #endif
   8087                             }
   8088                             nRetVal = write(pComponentPrivate->free_inpBuf_Q[1], &pBuffHead, sizeof(pBuffHead));
   8089                             if(nRetVal == -1){
   8090                                 OMX_PRCOMM4(pComponentPrivate->dbg, "writing to the input pipe %x (%lu)\n", OMX_ErrorInsufficientResources,nRetVal);
   8091                                 DecrementCount (&(pComponentPrivate->nCountInputBFromDsp), &(pComponentPrivate->mutexInputBFromDSP));
   8092                                 pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_DSP;
   8093                                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   8094                                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   8095                                                                        OMX_EventError,
   8096                                                                        OMX_ErrorInsufficientResources,
   8097                                                                        OMX_TI_ErrorSevere,
   8098                                                                        "Error writing to the output pipe");
   8099                             }
   8100                         }
   8101                     }
   8102                     else {
   8103                         OMX_PRDSP1(pComponentPrivate->dbg, "buffer dropped lcml in notprocess pBuffHead %p owner %d\n",pBuffHead,pBuffPriv->eBufferOwner);
   8104                     }
   8105                 }
   8106             }
   8107         }
   8108       }
   8109     }
   8110     /************************************************************************************************/
   8111     else if (event == EMMCodecBufferNotProcessed) {
   8112         OMX_PRDSP2(pComponentPrivate->dbg, "EMMCodecBufferNotProcessed\n");
   8113         if ((OMX_U32)argsCb [0] == EMMCodecOuputBuffer) {
   8114             OMX_BUFFERHEADERTYPE* pBuffHead = NULL;
   8115             VIDDEC_BUFFER_PRIVATE* pBuffPriv = NULL;
   8116             OMX_U8* pBuffer;
   8117 
   8118         if (pComponentPrivate->eState != OMX_StateLoaded && pComponentPrivate->eState != OMX_StateIdle) {
   8119             pBuffHead = (OMX_BUFFERHEADERTYPE*)argsCb[7];
   8120             if(pBuffHead != NULL)
   8121             {
   8122                 pBuffPriv = (VIDDEC_BUFFER_PRIVATE*)pBuffHead->pOutputPortPrivate;
   8123                 if (pBuffPriv != NULL) {
   8124                     if(pBuffPriv->eBufferOwner != VIDDEC_BUFFER_WITH_CLIENT)
   8125                     {
   8126 #ifdef __PERF_INSTRUMENTATION__
   8127                         pComponentPrivate->lcml_nCntOpReceived++;
   8128                         if (pComponentPrivate->lcml_nCntOpReceived == 4) {
   8129                             PERF_Boundary(pComponentPrivate->pPERFcomp,
   8130                                           PERF_BoundaryStart | PERF_BoundarySteadyState);
   8131                         }
   8132 #endif
   8133                         pBuffer = (OMX_U8*)argsCb[1];
   8134                         /* Retrieve time stamp information */
   8135                         if (pComponentPrivate->ProcessMode == 0) {
   8136                             OMX_PTR pBufferFlags;
   8137                             VIDDEC_CircBuf_Remove(pComponentPrivate,
   8138                                                VIDDEC_CBUFFER_TIMESTAMP,
   8139                                                VIDDEC_INPUT_PORT,
   8140                                                &pBufferFlags);
   8141                             if(pBufferFlags != NULL){
   8142                                 pBuffHead->nTimeStamp = (OMX_TICKS)((VIDDEC_CBUFFER_BUFFERFLAGS*)pBufferFlags)->nTimeStamp;
   8143                                 /*pBuffHead->nFlags = 0;
   8144                                 pBuffHead->nFlags = (OMX_U32)((VIDDEC_CBUFFER_BUFFERFLAGS*)pBufferFlags)->nFlags;*/
   8145                                 pBuffHead->nFlags |= (((OMX_U32)((VIDDEC_CBUFFER_BUFFERFLAGS*)pBufferFlags)->nFlags) & OMX_BUFFERFLAG_DECODEONLY);
   8146                                 pBuffHead->nTickCount = (OMX_U32)((VIDDEC_CBUFFER_BUFFERFLAGS*)pBufferFlags)->nTickCount;
   8147                             }
   8148                             else {
   8149                                 pBuffHead->nTimeStamp = 0;
   8150                                 pBuffHead->nTickCount = 0;
   8151                             }
   8152                         }
   8153                         else {
   8154                             if (pBuffHead->nFilledLen != 0){
   8155                                 pBuffHead->nTimeStamp = (OMX_TICKS)pComponentPrivate->arrBufIndex[pComponentPrivate->nOutBufIndex];
   8156                                 pComponentPrivate->nOutBufIndex++;
   8157                                 pComponentPrivate->nOutBufIndex %= VIDDEC_MAX_QUEUE_SIZE;
   8158                             }
   8159                         }
   8160                         OMX_PRBUFFER1(pComponentPrivate->dbg, "pBuffHead->nTimeStamp %lld\n", pBuffHead->nTimeStamp);
   8161                         if(pBuffHead != NULL){
   8162                             /*if (pComponentPrivate->pCompPort[1]->hTunnelComponent != NULL) {
   8163                                 pBuffHead->nFilledLen = (OMX_S32)argsCb[2];
   8164                             }
   8165                             else {*/
   8166                                 pBuffHead->nFilledLen = (OMX_S32)argsCb[8];
   8167                             /*}*/
   8168                             OMX_PRBUFFER1(pComponentPrivate->dbg, "pBuffHead->nFilledLen %lu\n", pBuffHead->nFilledLen);
   8169                             eError = IncrementCount (&(pComponentPrivate->nCountOutputBFromDsp), &(pComponentPrivate->mutexOutputBFromDSP));
   8170                             if (eError != OMX_ErrorNone) {
   8171                                 return eError;
   8172                             }
   8173                             pBufferPrivate = (VIDDEC_BUFFER_PRIVATE* )pBuffHead->pOutputPortPrivate;
   8174                             pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_COMPONENT;
   8175                             OMX_PRBUFFER1(pComponentPrivate->dbg, "eBufferOwner 0x%x\n", pBufferPrivate->eBufferOwner);
   8176 #ifdef __PERF_INSTRUMENTATION__
   8177                             PERF_ReceivedFrame(pComponentPrivate->pPERFcomp,
   8178                                                pBuffHead->pBuffer,
   8179                                                pBuffHead->nFilledLen,
   8180                                                PERF_ModuleCommonLayer);
   8181 #endif
   8182 
   8183                             nRetVal = write(pComponentPrivate->filled_outBuf_Q[1],&pBuffHead,sizeof(pBuffHead));
   8184                             if(nRetVal == -1){
   8185                                 DecrementCount (&(pComponentPrivate->nCountOutputBFromDsp), &(pComponentPrivate->mutexOutputBFromDSP));
   8186                                 pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_DSP;
   8187                                 OMX_PRCOMM4(pComponentPrivate->dbg, "writing to the input pipe %x (%lu)\n", OMX_ErrorInsufficientResources,nRetVal);
   8188                                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   8189                                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   8190                                                                        OMX_EventError,
   8191                                                                        OMX_ErrorInsufficientResources,
   8192                                                                        OMX_TI_ErrorSevere,
   8193                                                                        "Error writing to the output pipe");
   8194                             }
   8195                         }
   8196                     }
   8197                     else {
   8198                         OMX_PRDSP1(pComponentPrivate->dbg, "buffer dropped lcml out process pBuffHead %p owner %d\n",pBuffHead,pBuffPriv->eBufferOwner);
   8199                     }
   8200                 }
   8201             }
   8202         }
   8203         }
   8204         if ((OMX_U32)argsCb [0] == EMMCodecInputBuffer ||
   8205                 ((OMX_U32)argsCb [0] == EMMCodecInputBufferMapBufLen)) {
   8206             OMX_BUFFERHEADERTYPE* pBuffHead = NULL;
   8207             VIDDEC_BUFFER_PRIVATE* pBuffPriv = NULL;
   8208             OMX_U8* pBuffer;
   8209             if (pComponentPrivate->eState != OMX_StateLoaded && pComponentPrivate->eState != OMX_StateIdle) {
   8210             pBuffHead = (OMX_BUFFERHEADERTYPE*)argsCb[7];
   8211             if(pBuffHead != NULL)
   8212             {
   8213                 pBuffPriv = (VIDDEC_BUFFER_PRIVATE*)pBuffHead->pInputPortPrivate;
   8214                 if (pBuffPriv == NULL ) {
   8215                     goto EXIT;
   8216                 }
   8217                 else {
   8218                     if(pBuffPriv->eBufferOwner != VIDDEC_BUFFER_WITH_CLIENT)
   8219                     {
   8220                         OMX_PRBUFFER1(pComponentPrivate->dbg, "pBuffHead Input 0x%p pBuffer 0x%p\n", pBuffHead, argsCb[1]);
   8221                         pBuffer = (OMX_U8*)argsCb[1];
   8222                         if(pBuffer != NULL){
   8223                             eError = IncrementCount (&(pComponentPrivate->nCountInputBFromDsp), &(pComponentPrivate->mutexInputBFromDSP));
   8224                             if (eError != OMX_ErrorNone) {
   8225                                 return eError;
   8226                             }
   8227                             pBufferPrivate = (VIDDEC_BUFFER_PRIVATE* )pBuffHead->pInputPortPrivate;
   8228                             pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_COMPONENT;
   8229                             OMX_PRBUFFER1(pComponentPrivate->dbg, "eBufferOwner 0x%x\n", pBufferPrivate->eBufferOwner);
   8230     #ifdef __PERF_INSTRUMENTATION__
   8231                             PERF_ReceivedFrame(pComponentPrivate->pPERFcomp,
   8232                                                PREF(pBuffHead,pBuffer),
   8233                                                PREF(pBuffHead,nFilledLen),
   8234                                                PERF_ModuleCommonLayer);
   8235     #endif
   8236                             pBuffHead->nFilledLen = 0;
   8237                             if (pComponentPrivate->nWMVFileType == VIDDEC_WMV_ELEMSTREAM &&
   8238                                 pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV &&
   8239                                 pComponentPrivate->ProcessMode == 0) {
   8240                                 /* vc-1 fix */
   8241 #ifdef VIDDEC_WMVPOINTERFIXED
   8242                                 OMX_PRBUFFER1(pComponentPrivate->dbg, "restoring buffer pointer 0x%p >> pBuffer 0x%p\n",
   8243                                     pBufferPrivate->pTempBuffer, pBuffHead->pBuffer);
   8244                                 pBuffHead->pBuffer = pBufferPrivate->pTempBuffer;
   8245 #else
   8246                                 pBuffHead->nOffset = VIDDEC_WMV_BUFFER_OFFSET;
   8247 #endif
   8248                             }
   8249                             nRetVal = write(pComponentPrivate->free_inpBuf_Q[1], &pBuffHead, sizeof(pBuffHead));
   8250                             if(nRetVal == -1){
   8251                                 OMX_PRCOMM4(pComponentPrivate->dbg, "writing to the input pipe %x (%lu)\n", OMX_ErrorInsufficientResources,nRetVal);
   8252                                 DecrementCount (&(pComponentPrivate->nCountInputBFromDsp), &(pComponentPrivate->mutexInputBFromDSP));
   8253                                 pBufferPrivate->eBufferOwner = VIDDEC_BUFFER_WITH_DSP;
   8254                                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   8255                                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   8256                                                                        OMX_EventError,
   8257                                                                        OMX_ErrorInsufficientResources,
   8258                                                                        OMX_TI_ErrorSevere,
   8259                                                                        "Error writing to the output pipe");
   8260                             }
   8261                         }
   8262                     }
   8263                     else {
   8264                         OMX_PRDSP1(pComponentPrivate->dbg, "buffer dropped lcml in notprocess pBuffHead %p owner %d\n",pBuffHead,pBuffPriv->eBufferOwner);
   8265                     }
   8266                 }
   8267             }
   8268             }
   8269         }
   8270     }
   8271     /************************************************************************************************/
   8272     else if (event == EMMCodecDspError) {
   8273         OMX_PRDSP2(pComponentPrivate->dbg, "EMMCodecDspError\n");
   8274         if((argsCb[4] == (void *)NULL) && (argsCb[5] == (void*)NULL)) {
   8275             OMX_PRDSP4(pComponentPrivate->dbg, "DSP MMU_Fault\n");
   8276             pComponentPrivate->bLCMLHalted = OMX_TRUE;
   8277             pComponentPrivate->pHandle->SendCommand( pComponentPrivate->pHandle, OMX_CommandStateSet, -2, 0);
   8278         }
   8279         if((int)argsCb[5] == IUALG_ERR_NOT_SUPPORTED)
   8280         {
   8281            OMX_PRDSP4(pComponentPrivate->dbg, "Algorithm error. Parameter not supported\n");
   8282            OMX_PRDSP2(pComponentPrivate->dbg, "argsCb5 = %p\n",argsCb[5]);
   8283            OMX_PRDSP2(pComponentPrivate->dbg, "LCML_Callback: IUALG_ERR_NOT_SUPPORTED\n");
   8284            pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   8285                                        pComponentPrivate->pHandle->pApplicationPrivate,
   8286                                        OMX_EventError,
   8287                                        OMX_ErrorInsufficientResources,
   8288                                        OMX_TI_ErrorCritical,
   8289                                        "Error from the DSP");
   8290                 goto EXIT;
   8291         }
   8292         if ((int)argsCb [0] == USN_DSPMSG_EVENT) {
   8293             if ((int)argsCb [4] == USN_ERR_WARNING) {
   8294                 if ((int)argsCb [5] == IUALG_WARN_PLAYCOMPLETED) {
   8295                     OMX_PRDSP2(pComponentPrivate->dbg, "Received PLAYCOMPLETED\n");
   8296                 }
   8297                 else {
   8298                     OMX_PRDSP4(pComponentPrivate->dbg, "Error from the DSP: argsCb[5]=%d.\n", (int)argsCb [5]);
   8299                     pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   8300                                            pComponentPrivate->pHandle->pApplicationPrivate,
   8301                                            OMX_EventError,
   8302                                            OMX_ErrorHardware,
   8303                                            OMX_TI_ErrorCritical,
   8304                                            "Error from the DSP");
   8305                 }
   8306             }
   8307             else {
   8308                 OMX_PRDSP4(pComponentPrivate->dbg, "Error from the DSP: argsCb[4]=%d.\n", (int)argsCb [4]);
   8309                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   8310                                            pComponentPrivate->pHandle->pApplicationPrivate,
   8311                                            OMX_EventError,
   8312                                            OMX_ErrorHardware,
   8313                                            OMX_TI_ErrorCritical,
   8314                                            "Error from the DSP");
   8315                 goto EXIT;
   8316             }
   8317         }
   8318         else {
   8319             OMX_PRDSP4(pComponentPrivate->dbg, "LCML Halted: argsCb[0]=%d.\n", (int)argsCb [0]);
   8320             pComponentPrivate->bLCMLHalted = OMX_TRUE;
   8321             pComponentPrivate->pHandle->SendCommand( pComponentPrivate->pHandle, OMX_CommandStateSet, -2, 0);
   8322 
   8323         }
   8324     }
   8325     else if (event == EMMCodecInternalError || event == EMMCodecInitError) {
   8326         OMX_PRDSP4(pComponentPrivate->dbg, "EMMCodecInternalError || EMMCodecInitError\n");
   8327         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   8328                                                pComponentPrivate->pHandle->pApplicationPrivate,
   8329                                                OMX_EventError,
   8330                                                OMX_ErrorHardware,
   8331                                                OMX_TI_ErrorCritical,
   8332                                                "Error from the DSP");
   8333     }
   8334     else if (event == EMMCodecStrmCtrlAck) {
   8335         if ((int)argsCb [0] == USN_ERR_NONE) {
   8336             OMX_PRDSP2(pComponentPrivate->dbg, "EMMCodecStrmCtrlAck\n");
   8337             VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->sMutex);
   8338             VIDDEC_PTHREAD_MUTEX_SIGNAL(pComponentPrivate->sMutex);
   8339             VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   8340         } else {
   8341             OMX_PRDSP4(pComponentPrivate->dbg, "EMMCodecStrmCtrlAck: argsCb[0]=%d\n", (int)argsCb [0]);
   8342         }
   8343     } else {
   8344         OMX_PRDSP4(pComponentPrivate->dbg, "Unknown event: %d\n", event);
   8345     }
   8346 
   8347 EXIT:
   8348     OMX_PRDSP0(pComponentPrivate->dbg, "---EXITING(0x%x)\n",eError);
   8349     return eError;
   8350 }
   8351 
   8352 #ifdef RESOURCE_MANAGER_ENABLED
   8353 void VIDDEC_ResourceManagerCallback(RMPROXY_COMMANDDATATYPE cbData)
   8354 {
   8355 
   8356     /*OMX_COMMANDTYPE Cmd = OMX_CommandStateSet;
   8357     OMX_U32 state ;
   8358     OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)cbData.hComponent;*/
   8359     VIDDEC_COMPONENT_PRIVATE *pCompPrivate = NULL;
   8360     pCompPrivate = NULL;
   8361 }
   8362 #endif
   8363 
   8364 #ifdef ANDROID
   8365 /* ========================================================================== */
   8366 /**
   8367   *  VIDDEC_SaveBuffer() function will be use to copy a buffer at private space, to be used later by VIDDEC_CopyBuffer()
   8368   *
   8369   * @param
   8370   *     pComponentPrivate            Component private structure
   8371   *     pBuffHead                    Header of the buffer to be store
   8372   *
   8373   * @retval OMX_ErrorNone              Success, ready to roll
   8374   *         OMX_ErrorInsufficientResources   Not enough memory to save first buffer
   8375  **/
   8376 /* ========================================================================== */
   8377 
   8378 OMX_ERRORTYPE VIDDEC_SaveBuffer(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate,
   8379                                      OMX_BUFFERHEADERTYPE* pBuffHead)
   8380 {
   8381     OMX_ERRORTYPE eError = OMX_ErrorNone;
   8382     OMX_PRINT1(pComponentPrivate->dbg, "IN\n");
   8383     pComponentPrivate->eFirstBuffer.bSaveFirstBuffer = OMX_TRUE;
   8384 
   8385     OMX_MALLOC_STRUCT_SIZED(pComponentPrivate->eFirstBuffer.pFirstBufferSaved, OMX_U8, pBuffHead->nFilledLen, NULL);
   8386     memcpy(pComponentPrivate->eFirstBuffer.pFirstBufferSaved, pBuffHead->pBuffer, pBuffHead->nFilledLen);
   8387 
   8388     pComponentPrivate->eFirstBuffer.nFilledLen = pBuffHead->nFilledLen;
   8389 
   8390 EXIT:
   8391     OMX_PRINT1(pComponentPrivate->dbg, "OUT\n");
   8392     return eError;
   8393 }
   8394 
   8395 
   8396 
   8397 /* ========================================================================== */
   8398 /**
   8399   *  VIDDEC_CopyBuffer() function will insert an the begining of pBuffer the buffer stored using VIDDEC_SaveBuffer()
   8400   *     and update nFilledLen of the buffer header
   8401   *
   8402   * @param
   8403   *     pComponentPrivate            Component private structure
   8404   *     pBuffHead                    Header of the buffer to be store
   8405   *
   8406   * @retval OMX_ErrorNone              Success, ready to roll
   8407   *         OMX_ErrorUndefined       No buffer to be copy.
   8408   *         OMX_ErrorInsufficientResources   Not enough memory to save buffer
   8409  **/
   8410 /* ========================================================================== */
   8411 
   8412 OMX_ERRORTYPE VIDDEC_CopyBuffer(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate,
   8413                                      OMX_BUFFERHEADERTYPE* pBuffHead)
   8414 {
   8415     OMX_PRINT1(pComponentPrivate->dbg, "IN\n");
   8416     OMX_ERRORTYPE eError = OMX_ErrorNone;
   8417     if (pComponentPrivate->eFirstBuffer.bSaveFirstBuffer == OMX_FALSE) {
   8418         eError = OMX_ErrorUndefined;
   8419         goto EXIT;
   8420     }
   8421     OMX_PRINT1(pComponentPrivate->dbg, "pBuffer=%p\n", pBuffHead->pBuffer);
   8422     OMX_PTR pTemp = NULL;
   8423     pComponentPrivate->eFirstBuffer.bSaveFirstBuffer = OMX_FALSE;
   8424 
   8425     /* only if NAL-bitstream format in frame mode */
   8426     if (
   8427         ((pComponentPrivate->ProcessMode == 0 && pComponentPrivate->H264BitStreamFormat > 0)
   8428      || (pBuffHead->nFilledLen > pComponentPrivate->eFirstBuffer.nFilledLen))
   8429      && (pBuffHead->nAllocLen >= pComponentPrivate->eFirstBuffer.nFilledLen + pBuffHead->nFilledLen)
   8430        ) {
   8431         OMX_MALLOC_STRUCT_SIZED(pTemp, OMX_U8, pBuffHead->nFilledLen, NULL);
   8432         memcpy(pTemp, pBuffHead->pBuffer, pBuffHead->nFilledLen); /*copy somewere actual buffer*/
   8433         memcpy(pBuffHead->pBuffer, pComponentPrivate->eFirstBuffer.pFirstBufferSaved, pComponentPrivate->eFirstBuffer.nFilledLen); /*copy first buffer to the beganing of pBuffer.*/
   8434         memcpy((OMX_U8 *)pBuffHead->pBuffer+pComponentPrivate->eFirstBuffer.nFilledLen, pTemp, pBuffHead->nFilledLen); /* copy back actual buffer after first buffer*/
   8435         pBuffHead->nFilledLen += pComponentPrivate->eFirstBuffer.nFilledLen; /*Add first buffer size*/
   8436 
   8437         free(pTemp);
   8438         free(pComponentPrivate->eFirstBuffer.pFirstBufferSaved);
   8439         pComponentPrivate->eFirstBuffer.pFirstBufferSaved = NULL;
   8440     }
   8441         /*The first buffer has more information than the second, so the first buffer will be send to codec*/
   8442         /*We are loosing the second fame. TODO: Fix this*/
   8443         else if (pBuffHead->nAllocLen >= pComponentPrivate->eFirstBuffer.nFilledLen){
   8444             /*copy first buffer data to the actual buffer*/
   8445             memcpy(pBuffHead->pBuffer, pComponentPrivate->eFirstBuffer.pFirstBufferSaved, pComponentPrivate->eFirstBuffer.nFilledLen); /*copy first buffer*/
   8446             pBuffHead->nFilledLen = pComponentPrivate->eFirstBuffer.nFilledLen; /*Update buffer size*/
   8447             free(pComponentPrivate->eFirstBuffer.pFirstBufferSaved);
   8448             pComponentPrivate->eFirstBuffer.pFirstBufferSaved = NULL;
   8449         } else {
   8450             LOGE("Not enough memory in the buffer to concatenate the 2 frames, loosing first frame\n");
   8451         }
   8452 EXIT:
   8453     OMX_PRINT1(pComponentPrivate->dbg, "OUT\n");
   8454     return eError;
   8455 }
   8456 #endif
   8457 
   8458 
   8459 /* ========================================================================== */
   8460 /**
   8461   *  VIDDEC_LoadCodec() function will get LCML resource and start the codec.
   8462   *
   8463   * @param
   8464   *     pComponentPrivate            Component private structure
   8465   *
   8466   * @retval OMX_ErrorNone              Success, ready to roll
   8467   *         OMX_ErrorUndefined
   8468   *         OMX_ErrorInsufficientResources   Not enough memory
   8469  **/
   8470 /* ========================================================================== */
   8471 
   8472 OMX_ERRORTYPE VIDDEC_LoadCodec(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate)
   8473 {
   8474     OMX_ERRORTYPE eError = OMX_ErrorUndefined;
   8475     OMX_U32 message[4];
   8476     LCML_DSP_INTERFACE *pLcmlHandle = NULL;
   8477     OMX_HANDLETYPE hLCML = NULL;
   8478     void* p = NULL;
   8479 #ifdef UNDER_CE
   8480    typedef OMX_ERRORTYPE (*LPFNDLLFUNC1)(OMX_HANDLETYPE);
   8481    HINSTANCE hDLL;
   8482    LPFNDLLFUNC1 fpGetHandle1;
   8483 #else
   8484    VIDDEC_fpo fpGetHandle;
   8485    char* error;
   8486 #endif
   8487 
   8488 #ifndef UNDER_CE
   8489     pComponentPrivate->pModLCML = dlopen("libLCML.so", RTLD_LAZY);
   8490     if (!pComponentPrivate->pModLCML) {
   8491         OMX_PRDSP4(pComponentPrivate->dbg, "OMX_ErrorBadParameter\n");
   8492         fputs(dlerror(), stderr);
   8493         eError = OMX_ErrorBadParameter;
   8494         goto EXIT;
   8495     }
   8496     fpGetHandle = dlsym(pComponentPrivate->pModLCML, "GetHandle");
   8497     if ((error = dlerror()) != NULL) {
   8498         OMX_PRDSP4(pComponentPrivate->dbg, "OMX_ErrorBadParameter\n");
   8499         fputs(error, stderr);
   8500         dlclose(pComponentPrivate->pModLCML);
   8501         pComponentPrivate->pModLCML = NULL;
   8502         eError = OMX_ErrorBadParameter;
   8503         goto EXIT;
   8504     }
   8505     eError = (*fpGetHandle)(&hLCML);
   8506     if (eError != OMX_ErrorNone) {
   8507         OMX_PRDSP4(pComponentPrivate->dbg, "OMX_ErrorBadParameter\n");
   8508         dlclose(pComponentPrivate->pModLCML);
   8509         pComponentPrivate->pModLCML = NULL;
   8510         eError = OMX_ErrorBadParameter;
   8511         goto EXIT;
   8512     }
   8513 
   8514 #endif
   8515 
   8516     pComponentPrivate->eLCMLState = VidDec_LCML_State_Load;
   8517     OMX_PRDSP2(pComponentPrivate->dbg, "LCML Handler 0x%p\n",hLCML);
   8518     /*(LCML_DSP_INTERFACE*)pComponentPrivate->pLCML = (LCML_DSP_INTERFACE*)hLCML;*/
   8519     pComponentPrivate->pLCML = (LCML_DSP_INTERFACE*)hLCML;
   8520     pComponentPrivate->pLCML->pComponentPrivate = pComponentPrivate;
   8521 
   8522 
   8523 #ifdef __PERF_INSTRUMENTATION__
   8524     pComponentPrivate->lcml_nCntOpReceived = 0;
   8525 #endif
   8526     eError = OMX_ErrorNone;
   8527 #ifndef UNDER_CE
   8528     pComponentPrivate->bLCMLOut = OMX_TRUE;
   8529 #endif
   8530     if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
   8531         eError = VIDDEC_InitDSP_H264Dec(pComponentPrivate);
   8532     }
   8533     else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4 ||
   8534              pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) {
   8535         eError = VIDDEC_InitDSP_Mpeg4Dec(pComponentPrivate);
   8536     }
   8537     else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG2) {
   8538         eError = VIDDEC_InitDSP_Mpeg2Dec(pComponentPrivate);
   8539     }
   8540     else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingWMV) {
   8541         eError = VIDDEC_InitDSP_WMVDec(pComponentPrivate);
   8542     }
   8543 #ifdef VIDDEC_SPARK_CODE
   8544     else if (VIDDEC_SPARKCHECK) {
   8545         eError = VIDDEC_InitDSP_SparkDec(pComponentPrivate);
   8546     }
   8547 #endif
   8548     else {
   8549         OMX_PRDSP4(pComponentPrivate->dbg, "OMX_ErrorUnsupportedSetting\n");
   8550         eError = OMX_ErrorUnsupportedSetting;
   8551         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   8552                                                pComponentPrivate->pHandle->pApplicationPrivate,
   8553                                                OMX_EventError,
   8554                                                OMX_ErrorUnsupportedSetting,
   8555                                                OMX_TI_ErrorMinor,
   8556                                                "DSP Initialization");
   8557         goto EXIT;
   8558     }
   8559     if (eError != OMX_ErrorNone){
   8560         OMX_PRDSP4(pComponentPrivate->dbg, "LCML Error %x\n", pComponentPrivate->eState);
   8561         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   8562                                                pComponentPrivate->pHandle->pApplicationPrivate,
   8563                                                OMX_EventError,
   8564                                                eError,
   8565                                                OMX_TI_ErrorSevere,
   8566                                                "DSP Initialization");
   8567         goto EXIT;
   8568     }
   8569     #ifndef UNDER_CE
   8570     pComponentPrivate->bLCMLOut = OMX_FALSE;
   8571 #endif
   8572     pComponentPrivate->bLCMLHalted = OMX_FALSE;
   8573     pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
   8574     pComponentPrivate->eLCMLState = VidDec_LCML_State_Init;
   8575 
   8576     OMX_PRDSP2(pComponentPrivate->dbg, "OUTPUT width=%lu height=%lu\n", pComponentPrivate->pOutPortDef->format.video.nFrameWidth, pComponentPrivate->pOutPortDef->format.video.nFrameHeight);
   8577     OMX_PRDSP2(pComponentPrivate->dbg, "INPUT width=%lu height=%lu\n", pComponentPrivate->pInPortDef->format.video.nFrameWidth, pComponentPrivate->pInPortDef->format.video.nFrameHeight);
   8578 
   8579     /*Enable EOS propagation at USN*/
   8580     if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   8581         pComponentPrivate->eLCMLState != VidDec_LCML_State_Destroy &&
   8582         pComponentPrivate->pLCML != NULL &&
   8583         pComponentPrivate->bLCMLHalted != OMX_TRUE){
   8584         OMX_PRDSP2(pComponentPrivate->dbg, "LCML_ControlCodec called EMMCodecControlUsnEos 0x%p\n",pLcmlHandle);
   8585         eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,EMMCodecControlUsnEos, NULL);
   8586         if (eError != OMX_ErrorNone) {
   8587             OMX_PRDSP4(pComponentPrivate->dbg, "error in EMMCodecControlUsnEos %x\n",eError);
   8588             eError = OMX_ErrorHardware;
   8589             pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   8590                                                    pComponentPrivate->pHandle->pApplicationPrivate,
   8591                                                    OMX_EventError,
   8592                                                    OMX_ErrorHardware,
   8593                                                    OMX_TI_ErrorSevere,
   8594                                                    "LCML_ControlCodec EMMCodecControlUsnEos function");
   8595             OMX_PRDSP4(pComponentPrivate->dbg, "OMX_ErrorHardware 0x%x\n",eError);
   8596             goto EXIT;
   8597         }
   8598     }
   8599 
   8600     if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat != OMX_VIDEO_CodingWMV) {
   8601         if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
   8602             message[1] = 4;
   8603         }
   8604         else {
   8605             message[1] = 100;
   8606         }
   8607         message[0] = 0x400;
   8608         message[2] = 0;
   8609         p = (void*)&message;
   8610         VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->sMutex);
   8611         OMX_PRDSP2(pComponentPrivate->dbg, "LCML_ControlCodec called EMMCodecControlSendDspMessage 0x%p\n",pLcmlHandle);
   8612         eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,EMMCodecControlSendDspMessage, (void *)p);
   8613         if (eError != OMX_ErrorNone) {
   8614             OMX_PRDSP4(pComponentPrivate->dbg, "error in EMMCodecControlSendDspMessage %x\n",eError);
   8615             eError = OMX_ErrorHardware;
   8616             pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   8617                                                    pComponentPrivate->pHandle->pApplicationPrivate,
   8618                                                    OMX_EventError,
   8619                                                    OMX_ErrorHardware,
   8620                                                    OMX_TI_ErrorSevere,
   8621                                                    "LCML_ControlCodec function");
   8622             OMX_PRDSP4(pComponentPrivate->dbg, "OMX_ErrorHardware 0x%x\n",eError);
   8623             VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   8624             goto EXIT;
   8625         }
   8626         VIDDEC_PTHREAD_MUTEX_WAIT(pComponentPrivate->sMutex);
   8627         VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   8628     }
   8629 
   8630     pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
   8631     pComponentPrivate->bIsPaused = 0;
   8632     pComponentPrivate->bFirstBuffer = 1;
   8633 
   8634         OMX_PRDSP2(pComponentPrivate->dbg, "LCML_ControlCodec called EMMCodecControlStart 0x%p\n",pLcmlHandle);
   8635         eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,EMMCodecControlStart,NULL);
   8636         if (eError != OMX_ErrorNone) {
   8637             eError = OMX_ErrorHardware;
   8638             pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   8639                                                    pComponentPrivate->pHandle->pApplicationPrivate,
   8640                                                    OMX_EventError,
   8641                                                    OMX_ErrorHardware,
   8642                                                    OMX_TI_ErrorSevere,
   8643                                                    "LCML_ControlCodec Start");
   8644             goto EXIT;
   8645             OMX_PRDSP4(pComponentPrivate->dbg, "Occurred in Codec Start... 0x%x\n",eError);
   8646             }
   8647     pComponentPrivate->eLCMLState = VidDec_LCML_State_Start;
   8648 
   8649     if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC &&
   8650         pComponentPrivate->eState == OMX_StateIdle) {
   8651         H264_Iualg_Cmd_SetStatus* pDynParams = NULL;
   8652         char* pTmp = NULL;
   8653         OMX_U32 cmdValues[3] = {0, 0, 0};
   8654 
   8655         OMX_PRDSP2(pComponentPrivate->dbg, "Initializing DSP for h264 eCompressionFormat 0x%x\n",
   8656         pComponentPrivate->pInPortDef->format.video.eCompressionFormat);
   8657         OMX_MALLOC_STRUCT_SIZED(pDynParams, H264_Iualg_Cmd_SetStatus, sizeof(H264_Iualg_Cmd_SetStatus) + VIDDEC_PADDING_FULL,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel4]);
   8658         if (pDynParams == NULL) {
   8659            OMX_TRACE4(pComponentPrivate->dbg, "Error: Malloc failed\n");
   8660            eError = OMX_ErrorInsufficientResources;
   8661            goto EXIT;
   8662        }
   8663         memset(pDynParams, 0, sizeof(H264_Iualg_Cmd_SetStatus) + VIDDEC_PADDING_FULL);
   8664         pTmp = (char*)pDynParams;
   8665         pTmp += VIDDEC_PADDING_HALF;
   8666         pDynParams = (H264_Iualg_Cmd_SetStatus*)pTmp;
   8667 #ifdef VIDDEC_SN_R8_14
   8668         pDynParams->size = sizeof(H264_Iualg_Cmd_SetStatus);
   8669 #endif
   8670         pDynParams->ulDecodeHeader = 1;
   8671         pDynParams->ulDisplayWidth = 0;
   8672         pDynParams->ulFrameSkipMode = 0;
   8673         pDynParams->ulPPType = 0;
   8674 
   8675         cmdValues[0] = IUALG_CMD_SETSTATUS;
   8676         cmdValues[1] = (OMX_U32)(pDynParams);
   8677         cmdValues[2] = sizeof(H264_Iualg_Cmd_SetStatus);
   8678 
   8679         p = (void*)&cmdValues;
   8680         if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   8681             pComponentPrivate->eLCMLState != VidDec_LCML_State_Destroy &&
   8682             pComponentPrivate->pLCML != NULL &&
   8683             pComponentPrivate->bLCMLHalted != OMX_TRUE){
   8684             VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->sMutex);
   8685             eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
   8686                                        EMMCodecControlAlgCtrl,
   8687                                        (void*)p);
   8688             if (eError != OMX_ErrorNone) {
   8689                 eError = OMX_ErrorHardware;
   8690                 VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   8691                 OMX_MEMFREE_STRUCT_DSPALIGN(pDynParams,H264_Iualg_Cmd_SetStatus);
   8692                 goto EXIT;
   8693             }
   8694             VIDDEC_PTHREAD_MUTEX_WAIT(pComponentPrivate->sMutex);
   8695             VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   8696         }
   8697         OMX_MEMFREE_STRUCT_DSPALIGN(pDynParams,H264_Iualg_Cmd_SetStatus);
   8698 
   8699         if (eError != OMX_ErrorNone) {
   8700             OMX_PRDSP4(pComponentPrivate->dbg, "Codec AlgCtrl 0x%x\n",eError);
   8701             goto EXIT;
   8702         }
   8703     }
   8704     else if (pComponentPrivate->pInPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG2 &&
   8705         pComponentPrivate->eState == OMX_StateIdle) {
   8706         MP2VDEC_UALGDynamicParams* pDynParams = NULL;
   8707         char* pTmp = NULL;
   8708         OMX_U32 cmdValues[3] = {0, 0, 0};
   8709 
   8710         OMX_PRDSP2(pComponentPrivate->dbg, "Initializing DSP for wmv9 eCompressionFormat 0x%x\n",
   8711             pComponentPrivate->pInPortDef->format.video.eCompressionFormat);
   8712         OMX_MALLOC_STRUCT_SIZED(pDynParams, MP2VDEC_UALGDynamicParams, sizeof(MP2VDEC_UALGDynamicParams) + VIDDEC_PADDING_FULL,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel4]);
   8713         memset(pDynParams, 0, sizeof(MP2VDEC_UALGDynamicParams) + VIDDEC_PADDING_FULL);
   8714         pTmp = (char*)pDynParams;
   8715         pTmp += VIDDEC_PADDING_HALF;
   8716         pDynParams = (MP2VDEC_UALGDynamicParams*)pTmp;
   8717 
   8718 #ifdef VIDDEC_SN_R8_14
   8719         pDynParams->size = sizeof(MP2VDEC_UALGDynamicParams);
   8720 #endif
   8721         if (pComponentPrivate->nDisplayWidth > 0) {
   8722             if (pComponentPrivate->pInPortDef->format.video.nFrameWidth > pComponentPrivate->nDisplayWidth) {
   8723                 pComponentPrivate->nDisplayWidth = pComponentPrivate->pInPortDef->format.video.nFrameWidth;
   8724             }
   8725             pDynParams->ulDisplayWidth = (((pComponentPrivate->nDisplayWidth + 15) >> 4) << 4);
   8726             if (pComponentPrivate->nDisplayWidth != pDynParams->ulDisplayWidth ) {
   8727                 pComponentPrivate->nDisplayWidth = pDynParams->ulDisplayWidth;
   8728                 OMX_PRDSP2(pComponentPrivate->dbg, "warning Display Width adjusted to %lu\n",pDynParams->ulDisplayWidth);
   8729             }
   8730         }
   8731         else if (pComponentPrivate->pCompPort[1]->hTunnelComponent != NULL){
   8732             if (pComponentPrivate->pInPortDef->format.video.nFrameWidth > pComponentPrivate->nDisplayWidth) {
   8733                 pComponentPrivate->nDisplayWidth = pComponentPrivate->pInPortDef->format.video.nFrameWidth;
   8734             }
   8735             pDynParams->ulDisplayWidth = (((pComponentPrivate->nDisplayWidth + 15) >> 4) << 4);
   8736             if (pComponentPrivate->nDisplayWidth != pDynParams->ulDisplayWidth ) {
   8737                 pComponentPrivate->nDisplayWidth = pDynParams->ulDisplayWidth;
   8738                 OMX_PRDSP2(pComponentPrivate->dbg, "warning Display Width adjusted to %lu\n",pDynParams->ulDisplayWidth);
   8739             }
   8740         }
   8741         else {
   8742             pDynParams->ulDisplayWidth = 0;
   8743         }
   8744         pDynParams->ulDecodeHeader = 0;
   8745         pDynParams->ulFrameSkipMode = 0;
   8746         pDynParams->ulPPType = 0;
   8747         pDynParams->ulPpNone = 0;
   8748         if (pComponentPrivate->pOutPortDef->format.video.eColorFormat == VIDDEC_COLORFORMAT422) {
   8749             pDynParams->ulDyna_chroma_format = MP2VIDDEC_YUVFORMAT_INTERLEAVED422;
   8750         }
   8751         else {
   8752             pDynParams->ulDyna_chroma_format = MP2VIDDEC_YUVFORMAT_PLANAR420;
   8753         }
   8754 
   8755         cmdValues[0] = IUALG_CMD_SETSTATUS;
   8756         cmdValues[1] = (OMX_U32)(pDynParams);
   8757         cmdValues[2] = sizeof(MP2VDEC_UALGDynamicParams);
   8758 
   8759         pComponentPrivate->bTransPause = 0;
   8760         p = (void*)&cmdValues;
   8761         if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   8762             pComponentPrivate->eLCMLState != VidDec_LCML_State_Destroy &&
   8763             pComponentPrivate->pLCML != NULL &&
   8764             pComponentPrivate->bLCMLHalted != OMX_TRUE){
   8765             eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
   8766                                        EMMCodecControlAlgCtrl,
   8767                                        (void*)p);
   8768              if(eError != OMX_ErrorNone){
   8769                 eError = OMX_ErrorHardware;
   8770                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   8771                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   8772                                                        OMX_EventError,
   8773                                                        eError,
   8774                                                        0x0,
   8775                                                        "LCML_ControlCodec function");
   8776                 OMX_MEMFREE_STRUCT_DSPALIGN(pDynParams,MP2VDEC_UALGDynamicParams);
   8777                 goto EXIT;
   8778             }
   8779             while(1) {
   8780                 if(pComponentPrivate->bTransPause != 0) {
   8781                      pComponentPrivate->bTransPause = 0;
   8782                      break;
   8783                 }
   8784                 VIDDEC_WAIT_CODE();
   8785             }
   8786         }
   8787 
   8788         OMX_MEMFREE_STRUCT_DSPALIGN(pDynParams,MP2VDEC_UALGDynamicParams);
   8789 
   8790         if (eError != OMX_ErrorNone) {
   8791             OMX_PRDSP4(pComponentPrivate->dbg, "Codec AlgCtrl 0x%x\n",eError);
   8792             goto EXIT;
   8793         }
   8794     }
   8795 #ifdef VIDDEC_SPARK_CODE
   8796     else if (VIDDEC_SPARKCHECK) {
   8797         if(pComponentPrivate->eState == OMX_StateIdle) {
   8798             SPARKVDEC_UALGDynamicParams* pDynParams = NULL;
   8799             char* pTmp = NULL;
   8800             OMX_U32 cmdValues[3] = {0, 0, 0};
   8801 
   8802             OMX_PRDSP2(pComponentPrivate->dbg, "Initializing DSP for mpeg4 and h263 eCompressionFormat 0x%x\n",
   8803             pComponentPrivate->pInPortDef->format.video.eCompressionFormat);
   8804             OMX_MALLOC_STRUCT_SIZED(pDynParams, SPARKVDEC_UALGDynamicParams, sizeof(SPARKVDEC_UALGDynamicParams) + VIDDEC_PADDING_FULL,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel4]);
   8805             if (pDynParams == NULL) {
   8806                OMX_TRACE4(pComponentPrivate->dbg, "Error: Malloc failed\n");
   8807                eError = OMX_ErrorInsufficientResources;
   8808                goto EXIT;
   8809             }
   8810             memset(pDynParams, 0, sizeof(SPARKVDEC_UALGDynamicParams) + VIDDEC_PADDING_FULL);
   8811             pTmp = (char*)pDynParams;
   8812             pTmp += VIDDEC_PADDING_HALF;
   8813             pDynParams = (SPARKVDEC_UALGDynamicParams*)pTmp;
   8814 #ifdef VIDDEC_SN_R8_14
   8815             pDynParams->size = sizeof(SPARKVDEC_UALGDynamicParams);
   8816 #endif
   8817             pDynParams->ulDecodeHeader = 0;
   8818             pDynParams->ulDisplayWidth = 0;
   8819             pDynParams->ulFrameSkipMode = 0;
   8820             pDynParams->ulPPType = 0;
   8821 
   8822             cmdValues[0] = IUALG_CMD_SETSTATUS;
   8823             cmdValues[1] = (OMX_U32)(pDynParams);
   8824             cmdValues[2] = sizeof(SPARKVDEC_UALGDynamicParams);
   8825 
   8826             /*pComponentPrivate->bTransPause = 0;*//*flag to wait for the generated event*/
   8827             VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->sMutex);
   8828             p = (void*)&cmdValues;
   8829             if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   8830                 pComponentPrivate->eLCMLState != VidDec_LCML_State_Destroy &&
   8831                 pComponentPrivate->pLCML != NULL &&
   8832                 pComponentPrivate->bLCMLHalted != OMX_TRUE){
   8833                 eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
   8834                                            EMMCodecControlAlgCtrl,
   8835                                            (void*)p);
   8836                 if (eError != OMX_ErrorNone) {
   8837                     VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   8838                     eError = OMX_ErrorHardware;
   8839                     OMX_MEMFREE_STRUCT_DSPALIGN (pDynParams,SPARKVDEC_UALGDynamicParams);
   8840                     goto EXIT;
   8841                 }
   8842                 VIDDEC_PTHREAD_MUTEX_WAIT(pComponentPrivate->sMutex);
   8843                 VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   8844             }
   8845 
   8846             OMX_MEMFREE_STRUCT_DSPALIGN(pDynParams,SPARKVDEC_UALGDynamicParams);
   8847 
   8848             if (eError != OMX_ErrorNone) {
   8849                 OMX_PRDSP4(pComponentPrivate->dbg, "Codec AlgCtrl 0x%x\n",eError);
   8850                 goto EXIT;
   8851             }
   8852         }
   8853     }
   8854 #endif
   8855     else {
   8856         eError = VIDDEC_SetMpeg4_Parameters(pComponentPrivate);
   8857         if (eError != OMX_ErrorNone){
   8858             goto EXIT;
   8859         }
   8860     }
   8861 
   8862     eError = OMX_ErrorNone;
   8863 
   8864 EXIT:
   8865     return eError;
   8866 }
   8867 
   8868 
   8869 
   8870 /* ========================================================================== */
   8871 /**
   8872   *  VIDDEC_UnloadCodec() function will stop & destroy the codec. LCML resource is also been freed.
   8873   *
   8874   * @param
   8875   *     pComponentPrivate            Component private structure
   8876   *
   8877   * @retval OMX_NoError              Success, ready to roll
   8878   *         OMX_ErrorUndefined
   8879   *         OMX_ErrorInsufficientResources   Not enough memory
   8880  **/
   8881 /* ========================================================================== */
   8882 
   8883 OMX_ERRORTYPE VIDDEC_UnloadCodec(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate)
   8884 {
   8885     OMX_ERRORTYPE eError = OMX_ErrorUndefined;
   8886     LCML_DSP_INTERFACE *pLcmlHandle = NULL;
   8887     OMX_PRDSP1(pComponentPrivate->dbg, "+++ENTERING\n");
   8888     if (!(pComponentPrivate->eState == OMX_StateLoaded) &&
   8889         !(pComponentPrivate->eState == OMX_StateWaitForResources)) {
   8890         pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
   8891         if (pComponentPrivate->eState == OMX_StateExecuting) {
   8892             if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   8893                 pComponentPrivate->eLCMLState != VidDec_LCML_State_Destroy &&
   8894                 pComponentPrivate->pLCML != NULL &&
   8895                 pComponentPrivate->bLCMLHalted != OMX_TRUE) {
   8896     VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->sMutex);
   8897     OMX_PRDSP1(pComponentPrivate->dbg, "LCML_ControlCodec called MMCodecControlStop 0x%x\n",eError);
   8898     eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, MMCodecControlStop, NULL);
   8899     if (eError != OMX_ErrorNone) {
   8900         OMX_PRDSP4(pComponentPrivate->dbg, "Occurred in Codec Stop...\n");
   8901         eError = OMX_ErrorHardware;
   8902         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   8903                                                pComponentPrivate->pHandle->pApplicationPrivate,
   8904                                                OMX_EventError,
   8905                                                eError,
   8906                                                OMX_TI_ErrorCritical,
   8907                                                NULL);
   8908         VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   8909         goto EXIT;
   8910     }
   8911 
   8912     VIDDEC_PTHREAD_MUTEX_WAIT(pComponentPrivate->sMutex);
   8913     VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   8914             }
   8915             pComponentPrivate->eLCMLState = VidDec_LCML_State_Stop;
   8916         }
   8917         if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   8918             pComponentPrivate->pLCML != NULL){
   8919     eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, EMMCodecControlDestroy, NULL);
   8920 
   8921     OMX_PRDSP2(pComponentPrivate->dbg, "LCML_ControlCodec called EMMCodecControlDestroy 0x%p\n",pLcmlHandle);
   8922     if (eError != OMX_ErrorNone) {
   8923         OMX_PRDSP4(pComponentPrivate->dbg, "Occurred in Codec Destroy...\n");
   8924         eError = OMX_ErrorHardware;
   8925         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   8926                                                pComponentPrivate->pHandle->pApplicationPrivate,
   8927                                                OMX_EventError,
   8928                                                eError,
   8929                                                OMX_TI_ErrorCritical,
   8930                                                NULL);
   8931         OMX_ERROR4(pComponentPrivate->dbg, "Incorrect State Transition 0x%x\n", eError);
   8932         goto EXIT;
   8933         }
   8934     }
   8935     pComponentPrivate->eLCMLState = VidDec_LCML_State_Destroy;
   8936     OMX_PRDSP1(pComponentPrivate->dbg, "LCML_ControlCodec called EMMCodecControlDestroy 0x%p\n",pLcmlHandle);
   8937 
   8938 #ifndef UNDER_CE
   8939         if(pComponentPrivate->pModLCML != NULL){
   8940             dlclose(pComponentPrivate->pModLCML);
   8941             pComponentPrivate->pModLCML = NULL;
   8942             pComponentPrivate->pLCML = NULL;
   8943             pComponentPrivate->eLCMLState = VidDec_LCML_State_Unload;
   8944         }
   8945 #else
   8946         if(pComponentPrivate->pModLCML != NULL){
   8947             FreeLibrary(pComponentPrivate->pModLCML);
   8948             pComponentPrivate->pModLCML = NULL;
   8949             pComponentPrivate->pLCML = NULL;
   8950             pComponentPrivate->eLCMLState = VidDec_LCML_State_Unload;
   8951         }
   8952 #endif
   8953 
   8954         pComponentPrivate->bLCMLHalted = OMX_TRUE;
   8955     }
   8956     eError = OMX_ErrorNone;
   8957 EXIT:
   8958     return eError;
   8959 }
   8960 
   8961 
   8962 
   8963 /* ========================================================================== */
   8964 /**
   8965   *  VIDDEC_Set_SN_StreamType() Set stream type using dynamic parameters at the SN.
   8966   *
   8967   * @param
   8968   *     pComponentPrivate            Component private structure
   8969   *
   8970   * @retval OMX_NoError              Success, ready to roll
   8971   *         OMX_ErrorUndefined
   8972   *         OMX_ErrorInsufficientResources   Not enough memory
   8973  **/
   8974 /* ========================================================================== */
   8975 
   8976 OMX_ERRORTYPE VIDDEC_Set_SN_StreamType(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate)
   8977 {
   8978 
   8979         WMV9DEC_UALGDynamicParams* pDynParams = NULL;
   8980         LCML_DSP_INTERFACE* pLcmlHandle;
   8981         char* pTmp = NULL;
   8982         OMX_U32 cmdValues[3] = {0, 0, 0};
   8983         void* p = NULL;
   8984         OMX_ERRORTYPE eError = OMX_ErrorUndefined;
   8985 
   8986         OMX_PRDSP1(pComponentPrivate->dbg, "Initializing DSP for wmv9 eCompressionFormat 0x%x\n",
   8987             pComponentPrivate->pInPortDef->format.video.eCompressionFormat);
   8988 
   8989         pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
   8990         OMX_MALLOC_STRUCT_SIZED(pDynParams, WMV9DEC_UALGDynamicParams, sizeof(WMV9DEC_UALGDynamicParams) + VIDDEC_PADDING_FULL,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel4]);
   8991         if (pDynParams == NULL) {
   8992            OMX_TRACE4(pComponentPrivate->dbg, "Error: Malloc failed\n");
   8993            eError = OMX_ErrorInsufficientResources;
   8994            goto EXIT;
   8995         }
   8996         memset(pDynParams, 0, sizeof(WMV9DEC_UALGDynamicParams) + VIDDEC_PADDING_FULL);
   8997         pTmp = (char*)pDynParams;
   8998         pTmp += VIDDEC_PADDING_HALF;
   8999         pDynParams = (WMV9DEC_UALGDynamicParams*)pTmp;
   9000 
   9001         pDynParams->size = sizeof(WMV9DEC_UALGDynamicParams);
   9002         pDynParams->ulDecodeHeader = 0;
   9003         pDynParams->ulDisplayWidth = 0;
   9004         pDynParams->ulFrameSkipMode = 0;
   9005         pDynParams->ulPPType = 0;
   9006 
   9007         if (pComponentPrivate->nWMVFileType == VIDDEC_WMV_ELEMSTREAM) {
   9008             pDynParams->usIsElementaryStream = VIDDEC_SN_WMV_ELEMSTREAM;
   9009         }
   9010         else {
   9011             pDynParams->usIsElementaryStream = VIDDEC_SN_WMV_RCVSTREAM;
   9012         }
   9013 
   9014         cmdValues[0] = IUALG_CMD_SETSTATUS; /* add #define IUALG_CMD_SETSTATUS 3 */
   9015         cmdValues[1] = (OMX_U32)(pDynParams);
   9016         cmdValues[2] = sizeof(WMV9DEC_UALGDynamicParams);
   9017 
   9018         p = (void*)&cmdValues;
   9019         if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   9020             pComponentPrivate->eLCMLState != VidDec_LCML_State_Destroy &&
   9021             pComponentPrivate->pLCML != NULL &&
   9022             pComponentPrivate->bLCMLHalted != OMX_TRUE){
   9023             VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->sMutex);
   9024             OMX_PRDSP1(pComponentPrivate->dbg, "Sending Control coded command EMMCodecControlAlgCtrl\n");
   9025             eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
   9026                                        EMMCodecControlAlgCtrl,
   9027                                        (void*)p);
   9028              if(eError != OMX_ErrorNone){
   9029                 eError = OMX_ErrorHardware;
   9030                 pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
   9031                                                        pComponentPrivate->pHandle->pApplicationPrivate,
   9032                                                        OMX_EventError,
   9033                                                        eError,
   9034                                                        OMX_TI_ErrorSevere,
   9035                                                        "LCML_ControlCodec function");
   9036                 VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   9037                 OMX_MEMFREE_STRUCT_DSPALIGN(pDynParams,WMV9DEC_UALGDynamicParams);
   9038                 goto EXIT;
   9039             }
   9040             VIDDEC_PTHREAD_MUTEX_WAIT(pComponentPrivate->sMutex);
   9041             VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   9042             /*This flag is set to TRUE in the LCML callback from EMMCodecControlAlgCtrl
   9043              * this is not the case were we need it*/
   9044             pComponentPrivate->bTransPause = OMX_FALSE;
   9045         }
   9046 
   9047         OMX_MEMFREE_STRUCT_DSPALIGN(pDynParams,WMV9DEC_UALGDynamicParams);
   9048         if (eError != OMX_ErrorNone) {
   9049             OMX_PRDSP4(pComponentPrivate->dbg, "Codec AlgCtrl 0x%x\n",eError);
   9050         }
   9051 
   9052 EXIT:
   9053     return eError;
   9054 }
   9055 
   9056 
   9057 
   9058 /* ========================================================================== */
   9059 /**
   9060  *  VIDDEC_SetMpeg4_Parameters() Enable Deblocking filter
   9061  *
   9062  * @param
   9063  *     pComponentPrivate            Component private structure
   9064  *
   9065  * @retval OMX_NoError              Success, ready to roll
   9066  *         OMX_ErrorUndefined
   9067  *         OMX_ErrorInsufficientResources   Not enough memory
   9068  **/
   9069 /* ========================================================================== */
   9070 
   9071 OMX_ERRORTYPE VIDDEC_SetMpeg4_Parameters(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate)
   9072 {
   9073     MP4VDEC_UALGDynamicParams* pDynParams = NULL;
   9074     LCML_DSP_INTERFACE* pLcmlHandle = NULL;
   9075     char* pTmp = NULL;
   9076     OMX_U32 cmdValues[3] = {0, 0, 0};
   9077     void* p = NULL;
   9078     char value[PROPERTY_VALUE_MAX];
   9079     static int mDisableDeblockingIfD1 = 0;
   9080     OMX_BOOL bDisDeblocking = OMX_FALSE;
   9081     OMX_ERRORTYPE eError = OMX_ErrorUndefined;
   9082 
   9083     property_get("deblocking.video.disableIfD1", value, "0");
   9084     mDisableDeblockingIfD1 = atoi(value);
   9085     LOGD_IF(mDisableDeblockingIfD1, "Disabling deblocking if D1 resolution");
   9086 
   9087     OMX_PRDSP2(pComponentPrivate->dbg,"Initializing DSP for mpeg4 and h263 eCompressionFormat 0x%x\n",
   9088     pComponentPrivate->pInPortDef->format.video.eCompressionFormat);
   9089     pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
   9090     OMX_MALLOC_STRUCT_SIZED(pDynParams, MP4VDEC_UALGDynamicParams, sizeof(MP4VDEC_UALGDynamicParams) + VIDDEC_PADDING_FULL,pComponentPrivate->nMemUsage[VIDDDEC_Enum_MemLevel4]);
   9091     if (pDynParams == NULL) {
   9092        OMX_TRACE4(pComponentPrivate->dbg, "Error: Malloc failed\n");
   9093        eError = OMX_ErrorInsufficientResources;
   9094        goto EXIT;
   9095     }
   9096     memset(pDynParams, 0, sizeof(MP4VDEC_UALGDynamicParams) + VIDDEC_PADDING_FULL);
   9097     pTmp = (char*)pDynParams;
   9098     pTmp += VIDDEC_PADDING_HALF;
   9099     pDynParams = (MP4VDEC_UALGDynamicParams*)pTmp;
   9100 #ifdef VIDDEC_SN_R8_14
   9101     pDynParams->size = sizeof(MP4VDEC_UALGDynamicParams);
   9102 #endif
   9103     pDynParams->ulDecodeHeader = 0;
   9104     pDynParams->ulDisplayWidth = 0;
   9105     pDynParams->ulFrameSkipMode = 0;
   9106     pDynParams->useHighPrecIdctQp1 = 0;
   9107 
   9108 
   9109     if(mDisableDeblockingIfD1){
   9110         /* Disable if resolution higher than D1 NTSC (720x480) */
   9111         if(pComponentPrivate->pOutPortDef->format.video.nFrameWidth > 480 ||
   9112                 pComponentPrivate->pOutPortDef->format.video.nFrameHeight > 480){
   9113            bDisDeblocking = OMX_TRUE;
   9114            LOGD("D1 or higher resolution: Disable Deblocking!!");
   9115         }
   9116     }
   9117 
   9118     if(pComponentPrivate->pDeblockingParamType->bDeblocking && bDisDeblocking == OMX_FALSE){
   9119         pDynParams->ulPPType = 1; /* Enable deblocking filter*/
   9120     }
   9121     else{
   9122         pDynParams->ulPPType = 0; /* Disable */
   9123     }
   9124 
   9125     cmdValues[0] = IUALG_CMD_SETSTATUS;
   9126     cmdValues[1] = (OMX_U32)(pDynParams);
   9127     cmdValues[2] = sizeof(MP4VDEC_UALGDynamicParams);
   9128 
   9129     p = (void*)&cmdValues;
   9130     if(pComponentPrivate->eLCMLState != VidDec_LCML_State_Unload &&
   9131         pComponentPrivate->eLCMLState != VidDec_LCML_State_Destroy &&
   9132         pComponentPrivate->pLCML != NULL &&
   9133         pComponentPrivate->bLCMLHalted != OMX_TRUE){
   9134 
   9135         VIDDEC_PTHREAD_MUTEX_LOCK(pComponentPrivate->sMutex);
   9136         eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
   9137                                    EMMCodecControlAlgCtrl,
   9138                                    (void*)p);
   9139         if (eError != OMX_ErrorNone) {
   9140             eError = OMX_ErrorHardware;
   9141             VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   9142             OMX_MEMFREE_STRUCT_DSPALIGN(pDynParams,MP4VDEC_UALGDynamicParams);
   9143             goto EXIT;
   9144         }
   9145         VIDDEC_PTHREAD_MUTEX_WAIT(pComponentPrivate->sMutex);
   9146         VIDDEC_PTHREAD_MUTEX_UNLOCK(pComponentPrivate->sMutex);
   9147         /*This flag is set to TRUE in the LCML callback from EMMCodecControlAlgCtrl
   9148          * this is not the case were we need it*/
   9149         pComponentPrivate->bTransPause = OMX_FALSE;
   9150     }
   9151 
   9152     OMX_MEMFREE_STRUCT_DSPALIGN(pDynParams,MP4VDEC_UALGDynamicParams);
   9153 
   9154     if (eError != OMX_ErrorNone) {
   9155         OMX_PRDSP4(pComponentPrivate->dbg, "Codec AlgCtrl 0x%x\n",eError);
   9156         goto EXIT;
   9157     }
   9158 
   9159 EXIT:
   9160     return eError;
   9161 }
   9162 
   9163 OMX_ERRORTYPE AddStateTransition(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate) {
   9164 
   9165     OMX_ERRORTYPE eError = OMX_ErrorNone;
   9166 
   9167     if(pthread_mutex_lock(&pComponentPrivate->mutexStateChangeRequest)) {
   9168        return OMX_ErrorUndefined;
   9169     }
   9170 
   9171     /* Increment state change request reference count */
   9172     pComponentPrivate->nPendingStateChangeRequests++;
   9173 
   9174     if(pthread_mutex_unlock(&pComponentPrivate->mutexStateChangeRequest)) {
   9175        return OMX_ErrorUndefined;
   9176     }
   9177 
   9178     return eError;
   9179 }
   9180 
   9181 OMX_ERRORTYPE RemoveStateTransition(VIDDEC_COMPONENT_PRIVATE* pComponentPrivate, OMX_BOOL bEnableSignal) {
   9182     OMX_ERRORTYPE eError = OMX_ErrorNone;
   9183 
   9184      /* Decrement state change request reference count*/
   9185     if(pthread_mutex_lock(&pComponentPrivate->mutexStateChangeRequest)) {
   9186        return OMX_ErrorUndefined;
   9187     }
   9188 
   9189     pComponentPrivate->nPendingStateChangeRequests--;
   9190 
   9191     /* If there are no more pending requests, signal the thread waiting on this*/
   9192     if(!pComponentPrivate->nPendingStateChangeRequests && bEnableSignal) {
   9193        pthread_cond_signal(&(pComponentPrivate->StateChangeCondition));
   9194     }
   9195 
   9196     if(pthread_mutex_unlock(&pComponentPrivate->mutexStateChangeRequest)) {
   9197        return OMX_ErrorUndefined;
   9198     }
   9199 
   9200     return eError;
   9201 }
   9202 
   9203 OMX_ERRORTYPE IncrementCount (OMX_U8 * pCounter, pthread_mutex_t *pMutex) {
   9204     OMX_ERRORTYPE eError = OMX_ErrorNone;
   9205     if(pthread_mutex_lock(pMutex)) {
   9206        return OMX_ErrorUndefined;
   9207     }
   9208     (*pCounter)++;
   9209     if(pthread_mutex_unlock(pMutex)) {
   9210        return OMX_ErrorUndefined;
   9211     }
   9212     return eError;
   9213 }
   9214 
   9215 OMX_ERRORTYPE DecrementCount (OMX_U8 * pCounter, pthread_mutex_t *pMutex) {
   9216     OMX_ERRORTYPE eError = OMX_ErrorNone;
   9217     if(pthread_mutex_lock(pMutex)) {
   9218        return OMX_ErrorUndefined;
   9219     }
   9220     (*pCounter)--;
   9221     if(pthread_mutex_unlock(pMutex)) {
   9222        return OMX_ErrorUndefined;
   9223     }
   9224     return eError;
   9225 }
   9226 
   9227