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_AmrEnc_Utils.c
30*
31* This file implements NBAMR Encoder Component Specific APIs and its functionality
32* that is fully compliant with the Khronos OpenMAX (TM) 1.0 Specification
33*
34* @path  $(CSLPATH)\OMAPSW_MPU\linux\audio\src\openmax_il\nbamr_enc\src
35*
36* @rev  1.0
37*/
38/* ----------------------------------------------------------------------------
39*!
40*! Revision History
41*! ===================================
42*! 21-sept-2006 bk: updated review findings for alpha release
43*! 24-Aug-2006 bk: Khronos OpenMAX (TM) 1.0 Conformance tests some more
44*! 18-July-2006 bk: Khronos OpenMAX (TM) 1.0 Conformance tests validated for few cases
45*! 21-Jun-2006 bk: Khronos OpenMAX (TM) 1.0 migration done
46*! 22-May-2006 bk: DASF recording quality improved
47*! 19-Apr-2006 bk: DASF recording speed issue resloved
48*! 23-Feb-2006 bk: DASF functionality added
49*! 18-Jan-2006 bk: Repated recording issue fixed and LCML changes taken care
50*! 14-Dec-2005 bk: Initial Version
51*! 16-Nov-2005 bk: Initial Version
52*! 23-Sept-2005 bk: Initial Version
53*! 10-Sept-2005 bk: Initial Version
54*! 10-Sept-2005 bk:
55*! This is newest file
56* =========================================================================== */
57
58/* ------compilation control switches -------------------------*/
59/****************************************************************
60*  INCLUDE FILES
61****************************************************************/
62/* ----- system and platform files ----------------------------*/
63#ifdef UNDER_CE
64#include <windows.h>
65#include <oaf_osal.h>
66#include <omx_core.h>
67#else
68#include <wchar.h>
69#include <unistd.h>
70#include <sys/types.h>
71#include <sys/wait.h>
72#include <sys/types.h>
73#include <sys/stat.h>
74#include <dlfcn.h>
75#include <malloc.h>
76#include <memory.h>
77#include <fcntl.h>
78#include <errno.h>
79#endif
80
81#include <dbapi.h>
82#include <string.h>
83#include <stdio.h>
84#include <stdlib.h>
85/*-------program files ----------------------------------------*/
86#include "OMX_AmrEnc_Utils.h"
87#include "amrencsocket_ti.h"
88#include <encode_common_ti.h>
89#include "OMX_AmrEnc_ComponentThread.h"
90#include "usn.h"
91#include "LCML_DspCodec.h"
92
93#ifdef RESOURCE_MANAGER_ENABLED
94    #include <ResourceManagerProxyAPI.h>
95#endif
96
97/* ========================================================================== */
98/**
99* @NBAMRENC_FillLCMLInitParams () This function is used by the component thread to
100* fill the all of its initialization parameters, buffer deatils  etc
101* to LCML structure,
102*
103* @param pComponent  handle for this instance of the component
104* @param plcml_Init  pointer to LCML structure to be filled
105*
106* @pre
107*
108* @post
109*
110* @return none
111*/
112/* ========================================================================== */
113
114OMX_ERRORTYPE NBAMRENC_FillLCMLInitParams(OMX_HANDLETYPE pComponent,
115                                  LCML_DSP *plcml_Init, OMX_U16 arr[])
116{
117    OMX_ERRORTYPE eError = OMX_ErrorNone;
118    OMX_U32 nIpBuf,nIpBufSize,nOpBuf,nOpBufSize;
119    OMX_BUFFERHEADERTYPE *pTemp;
120    LCML_DSP_INTERFACE *pHandle = (LCML_DSP_INTERFACE *)pComponent;
121    AMRENC_COMPONENT_PRIVATE *pComponentPrivate = pHandle->pComponentPrivate;
122    NBAMRENC_LCML_BUFHEADERTYPE *pTemp_lcml = NULL;
123    OMX_U16 i;
124    OMX_U32 size_lcml;
125    OMX_PRINT1(pComponentPrivate->dbg, "%d :: Entering NBAMRENC_FillLCMLInitParams\n",__LINE__);
126    nIpBuf = pComponentPrivate->pInputBufferList->numBuffers;
127    nIpBufSize = pComponentPrivate->pPortDef[NBAMRENC_INPUT_PORT]->nBufferSize;
128    pComponentPrivate->nRuntimeInputBuffers = nIpBuf;
129    nOpBuf = pComponentPrivate->pOutputBufferList->numBuffers;
130    nOpBufSize = pComponentPrivate->pPortDef[NBAMRENC_OUTPUT_PORT]->nBufferSize;
131    pComponentPrivate->nRuntimeOutputBuffers = nOpBuf;
132    OMX_PRBUFFER2(pComponentPrivate->dbg, "%d :: ------ Buffer Details -----------\n",__LINE__);
133    OMX_PRBUFFER2(pComponentPrivate->dbg, "%d :: Input  Buffer Count = %ld\n",__LINE__,nIpBuf);
134    OMX_PRBUFFER2(pComponentPrivate->dbg, "%d :: Input  Buffer Size = %ld\n",__LINE__,nIpBufSize);
135    OMX_PRBUFFER2(pComponentPrivate->dbg, "%d :: Output Buffer Count = %ld\n",__LINE__,nOpBuf);
136    OMX_PRBUFFER2(pComponentPrivate->dbg, "%d :: Output Buffer Size = %ld\n",__LINE__,nOpBufSize);
137    OMX_PRBUFFER2(pComponentPrivate->dbg, "%d :: ------ Buffer Details ------------\n",__LINE__);
138    /* Fill Input Buffers Info for LCML */
139    plcml_Init->In_BufInfo.nBuffers = nIpBuf;
140    plcml_Init->In_BufInfo.nSize = nIpBufSize;
141    plcml_Init->In_BufInfo.DataTrMethod = DMM_METHOD;
142
143    /* Fill Output Buffers Info for LCML */
144    plcml_Init->Out_BufInfo.nBuffers = nOpBuf;
145    plcml_Init->Out_BufInfo.nSize = nOpBufSize;
146    plcml_Init->Out_BufInfo.DataTrMethod = DMM_METHOD;
147
148    /*Copy the node information*/
149    plcml_Init->NodeInfo.nNumOfDLLs = 3;
150
151    plcml_Init->NodeInfo.AllUUIDs[0].uuid = &AMRENCSOCKET_TI_UUID;
152    strcpy ((char*)plcml_Init->NodeInfo.AllUUIDs[0].DllName,NBAMRENC_DLL_NAME);
153    plcml_Init->NodeInfo.AllUUIDs[0].eDllType = DLL_NODEOBJECT;
154
155    plcml_Init->NodeInfo.AllUUIDs[1].uuid = &AMRENCSOCKET_TI_UUID;
156    strcpy ((char*)plcml_Init->NodeInfo.AllUUIDs[1].DllName,NBAMRENC_DLL_NAME);
157    plcml_Init->NodeInfo.AllUUIDs[1].eDllType = DLL_DEPENDENT;
158
159    plcml_Init->NodeInfo.AllUUIDs[2].uuid = &USN_TI_UUID;
160    strcpy ((char*)plcml_Init->NodeInfo.AllUUIDs[2].DllName,NBAMRENC_USN_DLL_NAME);
161    plcml_Init->NodeInfo.AllUUIDs[2].eDllType = DLL_DEPENDENT;
162    plcml_Init->DeviceInfo.TypeofDevice = 0;
163
164    if(pComponentPrivate->dasfMode == 1) {
165        OMX_PRDSP2(pComponentPrivate->dbg, "%d :: Codec is configuring to DASF mode\n",__LINE__);
166        OMX_MALLOC_GENERIC(pComponentPrivate->strmAttr, LCML_STRMATTR);
167        pComponentPrivate->strmAttr->uSegid = NBAMRENC_DEFAULT_SEGMENT;
168        pComponentPrivate->strmAttr->uAlignment = 0;
169        pComponentPrivate->strmAttr->uTimeout = NBAMRENC_SN_TIMEOUT;
170        pComponentPrivate->strmAttr->uBufsize = NBAMRENC_INPUT_BUFFER_SIZE_DASF;
171        pComponentPrivate->strmAttr->uNumBufs = NBAMRENC_NUM_INPUT_BUFFERS_DASF;
172        pComponentPrivate->strmAttr->lMode = STRMMODE_PROCCOPY;
173        /* Device is Configuring to DASF Mode */
174        plcml_Init->DeviceInfo.TypeofDevice = 1;
175        /* Device is Configuring to Record Mode */
176        plcml_Init->DeviceInfo.TypeofRender = 1;
177
178        if(pComponentPrivate->acdnMode == 1) {
179            /* ACDN mode */
180            plcml_Init->DeviceInfo.AllUUIDs[0].uuid = &ACDN_TI_UUID;
181        }
182        else {
183            /* DASF/TeeDN mode */
184                if(pComponentPrivate->teeMode!= TEEMODE_NONE) {
185                    plcml_Init->DeviceInfo.AllUUIDs[0].uuid = &TEEDN_TI_UUID;
186                }
187                else {
188                    plcml_Init->DeviceInfo.AllUUIDs[0].uuid = &DCTN_TI_UUID;
189                }
190        }
191        plcml_Init->DeviceInfo.DspStream = pComponentPrivate->strmAttr;
192    }
193
194    /*copy the other information*/
195    plcml_Init->SegID = NBAMRENC_DEFAULT_SEGMENT;
196    plcml_Init->Timeout = NBAMRENC_SN_TIMEOUT;
197    plcml_Init->Alignment = 0;
198    plcml_Init->Priority = NBAMRENC_SN_PRIORITY;
199    plcml_Init->ProfileID = -1;
200
201    /* Setting Creat Phase Parameters here */
202    arr[0] = NBAMRENC_STREAM_COUNT;
203    arr[1] = NBAMRENC_INPUT_PORT;
204
205    if(pComponentPrivate->dasfMode == 1) {
206        arr[2] = NBAMRENC_INSTRM;
207        arr[3] = NBAMRENC_NUM_INPUT_BUFFERS_DASF;
208    }
209    else {
210        arr[2] = NBAMRENC_DMM;
211        if (pComponentPrivate->pInputBufferList->numBuffers) {
212            arr[3] = (OMX_U16) pComponentPrivate->pInputBufferList->numBuffers;
213        }
214        else {
215            arr[3] = 1;
216        }
217    }
218
219    arr[4] = NBAMRENC_OUTPUT_PORT;
220    arr[5] = NBAMRENC_DMM;
221    if (pComponentPrivate->pOutputBufferList->numBuffers) {
222        arr[6] = (OMX_U16) pComponentPrivate->pOutputBufferList->numBuffers;
223    }
224    else {
225        arr[6] = 1;
226    }
227
228    if (pComponentPrivate->efrMode == 1) {
229        OMX_PRDSP2(pComponentPrivate->dbg, "%d :: Codec is configuring to EFR mode\n",__LINE__);
230        arr[7] = NBAMRENC_EFR;
231    }
232    else {
233        OMX_PRDSP2(pComponentPrivate->dbg, "%d :: Codec is configuring to NBAMR mode\n",__LINE__);
234        arr[7] = NBAMRENC_NBAMR;
235    }
236
237    if(pComponentPrivate->frameMode == NBAMRENC_MIMEMODE ) {
238        OMX_PRDSP2(pComponentPrivate->dbg, "%d :: Codec is configuring MIME mode\n",__LINE__);
239        arr[8] = NBAMRENC_MIMEMODE;
240    }
241    else if(pComponentPrivate->frameMode == NBAMRENC_IF2 ){
242        OMX_PRDSP2(pComponentPrivate->dbg, "%d :: Codec is configuring IF2 mode\n",__LINE__);
243        arr[8] = NBAMRENC_IF2;
244        }
245    else {
246        OMX_PRDSP2(pComponentPrivate->dbg, "%d :: Codec is configuring FORMAT CONFORMANCE mode\n",__LINE__);
247        arr[8] = NBAMRENC_FORMATCONFORMANCE;
248    }
249    arr[9] = END_OF_CR_PHASE_ARGS;
250
251    plcml_Init->pCrPhArgs = arr;
252
253    /* Allocate memory for all input buffer headers..
254     * This memory pointer will be sent to LCML */
255    size_lcml = nIpBuf * sizeof(NBAMRENC_LCML_BUFHEADERTYPE);
256
257    OMX_MALLOC_SIZE(pTemp_lcml, size_lcml,NBAMRENC_LCML_BUFHEADERTYPE);
258
259    pComponentPrivate->pLcmlBufHeader[NBAMRENC_INPUT_PORT] = pTemp_lcml;
260    for (i=0; i<nIpBuf; i++) {
261        OMX_PRCOMM2(pComponentPrivate->dbg, "%d :: INPUT--------- Inside Ip Loop\n",__LINE__);
262        pTemp = pComponentPrivate->pInputBufferList->pBufHdr[i];
263        pTemp->nSize = sizeof(OMX_BUFFERHEADERTYPE);
264        pTemp->nFilledLen = nIpBufSize;
265        pTemp->nVersion.s.nVersionMajor = NBAMRENC_MAJOR_VER;
266        pTemp->nVersion.s.nVersionMinor = NBAMRENC_MINOR_VER;
267        pTemp->pPlatformPrivate = pHandle->pComponentPrivate;
268        pTemp->nTickCount = NBAMRENC_NOT_USED;
269        pTemp_lcml->buffer = pTemp;
270        OMX_PRBUFFER2(pComponentPrivate->dbg, "%d :: pTemp_lcml->buffer->pBuffer = %p \n",__LINE__,pTemp_lcml->buffer->pBuffer);
271        pTemp_lcml->eDir = OMX_DirInput;
272
273        OMX_MALLOC_SIZE_DSPALIGN(pTemp_lcml->pBufferParam, sizeof(NBAMRENC_ParamStruct),OMX_U8);
274
275        pTemp_lcml->pBufferParam->usNbFrames=0;
276        pTemp_lcml->pBufferParam->pParamElem=NULL;
277        pTemp_lcml->pFrameParam=NULL;
278
279        OMX_MALLOC_GENERIC(pTemp_lcml->pDmmBuf, DMM_BUFFER_OBJ);
280
281        /* This means, it is not a last buffer. This flag is to be modified by
282         * the application to indicate the last buffer */
283        pTemp->nFlags = NBAMRENC_NORMAL_BUFFER;
284        pTemp++;
285        pTemp_lcml++;
286    }
287
288    /* Allocate memory for all output buffer headers..
289     * This memory pointer will be sent to LCML */
290    size_lcml = nOpBuf * sizeof(NBAMRENC_LCML_BUFHEADERTYPE);
291
292    OMX_MALLOC_SIZE(pTemp_lcml, size_lcml,NBAMRENC_LCML_BUFHEADERTYPE);
293
294    pComponentPrivate->pLcmlBufHeader[NBAMRENC_OUTPUT_PORT] = pTemp_lcml;
295    for (i=0; i<nOpBuf; i++) {
296        OMX_PRCOMM2(pComponentPrivate->dbg, "%d :: OUTPUT--------- Inside Op Loop\n",__LINE__);
297        pTemp = pComponentPrivate->pOutputBufferList->pBufHdr[i];
298        pTemp->nSize = sizeof(OMX_BUFFERHEADERTYPE);
299        pTemp->nFilledLen = nOpBufSize;
300        pTemp->nVersion.s.nVersionMajor = NBAMRENC_MAJOR_VER;
301        pTemp->nVersion.s.nVersionMinor = NBAMRENC_MINOR_VER;
302        pComponentPrivate->nVersion = pTemp->nVersion.nVersion;
303        pTemp->pPlatformPrivate = pHandle->pComponentPrivate;
304        pTemp->nTickCount = NBAMRENC_NOT_USED;
305        pTemp_lcml->buffer = pTemp;
306        OMX_PRBUFFER2(pComponentPrivate->dbg, "%d :: pTemp_lcml->buffer->pBuffer = %p \n",__LINE__,pTemp_lcml->buffer->pBuffer);
307        pTemp_lcml->eDir = OMX_DirOutput;
308
309        OMX_MALLOC_SIZE_DSPALIGN(pTemp_lcml->pBufferParam,
310                                sizeof(NBAMRENC_ParamStruct),
311                                NBAMRENC_ParamStruct);
312
313        pTemp_lcml->pBufferParam->usNbFrames=0;
314        pTemp_lcml->pBufferParam->pParamElem=NULL;
315        pTemp_lcml->pFrameParam=NULL;
316
317        OMX_MALLOC_GENERIC(pTemp_lcml->pDmmBuf, DMM_BUFFER_OBJ);
318
319        pTemp->nFlags = NBAMRENC_NORMAL_BUFFER;
320        pTemp++;
321        pTemp_lcml++;
322    }
323#ifdef __PERF_INSTRUMENTATION__
324        pComponentPrivate->nLcml_nCntIp = 0;
325        pComponentPrivate->nLcml_nCntOpReceived = 0;
326#endif
327
328    pComponentPrivate->bInitParamsInitialized = 1;
329EXIT:
330    OMX_PRINT1(pComponentPrivate->dbg, "%d :: Exiting NBAMRENC_FillLCMLInitParams\n",__LINE__);
331    OMX_PRINT1(pComponentPrivate->dbg, "%d :: Returning = 0x%x\n",__LINE__,eError);
332    return eError;
333}
334
335/* ========================================================================== */
336/**
337* @NBAMRENC_StartComponentThread() This function is called by the component to create
338* the component thread, command pipes, data pipes and LCML Pipes.
339*
340* @param pComponent  handle for this instance of the component
341*
342* @pre
343*
344* @post
345*
346* @return none
347*/
348/* ========================================================================== */
349
350OMX_ERRORTYPE NBAMRENC_StartComponentThread(OMX_HANDLETYPE pComponent)
351{
352    OMX_ERRORTYPE eError = OMX_ErrorNone;
353    OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)pComponent;
354    AMRENC_COMPONENT_PRIVATE *pComponentPrivate =
355                        (AMRENC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
356#ifdef UNDER_CE
357    pthread_attr_t attr;
358    memset(&attr, 0, sizeof(attr));
359    attr.__inheritsched = PTHREAD_EXPLICIT_SCHED;
360    attr.__schedparam.__sched_priority = OMX_AUDIO_ENCODER_THREAD_PRIORITY;
361#endif
362
363    OMX_PRINT1(pComponentPrivate->dbg, "%d :: Entering  NBAMRENC_StartComponentThread\n", __LINE__);
364    /* Initialize all the variables*/
365    pComponentPrivate->bIsStopping = 0;
366    pComponentPrivate->bIsThreadstop = 0;
367    pComponentPrivate->lcml_nOpBuf = 0;
368    pComponentPrivate->lcml_nIpBuf = 0;
369    pComponentPrivate->app_nBuf = 0;
370    pComponentPrivate->num_Op_Issued = 0;
371
372
373    /* create the pipe used to send buffers to the thread */
374    eError = pipe (pComponentPrivate->cmdDataPipe);
375    if (eError) {
376       eError = OMX_ErrorInsufficientResources;
377       OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error while creating cmdDataPipe\n",__LINE__);
378       goto EXIT;
379    }
380    /* create the pipe used to send buffers to the thread */
381    eError = pipe (pComponentPrivate->dataPipe);
382    if (eError) {
383       eError = OMX_ErrorInsufficientResources;
384       OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error while creating dataPipe\n",__LINE__);
385       goto EXIT;
386    }
387
388    /* create the pipe used to send commands to the thread */
389    eError = pipe (pComponentPrivate->cmdPipe);
390    if (eError) {
391       eError = OMX_ErrorInsufficientResources;
392       OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error while creating cmdPipe\n",__LINE__);
393       goto EXIT;
394    }
395
396    /* Create the Component Thread */
397#ifdef UNDER_CE
398    eError = pthread_create (&(pComponentPrivate->ComponentThread), &attr, NBAMRENC_CompThread, pComponentPrivate);
399#else
400    eError = pthread_create (&(pComponentPrivate->ComponentThread), NULL, NBAMRENC_CompThread, pComponentPrivate);
401#endif
402    if (eError || !pComponentPrivate->ComponentThread) {
403       eError = OMX_ErrorInsufficientResources;
404       goto EXIT;
405    }
406
407    pComponentPrivate->bCompThreadStarted = 1;
408EXIT:
409    OMX_PRINT1(pComponentPrivate->dbg, "%d :: Exiting NBAMRENC_StartComponentThread\n", __LINE__);
410    OMX_PRINT1(pComponentPrivate->dbg, "%d :: Returning = 0x%x\n",__LINE__,eError);
411    return eError;
412}
413
414/* ========================================================================== */
415/**
416* @NBAMRENC_FreeCompResources() This function is called by the component during
417* de-init , to newfree Command pipe, data pipe & LCML pipe.
418*
419* @param pComponent  handle for this instance of the component
420*
421* @pre
422*
423* @post
424*
425* @return none
426*/
427/* ========================================================================== */
428
429OMX_ERRORTYPE NBAMRENC_FreeCompResources(OMX_HANDLETYPE pComponent)
430{
431    OMX_ERRORTYPE eError = OMX_ErrorNone;
432    OMX_ERRORTYPE err = OMX_ErrorNone;
433    OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)pComponent;
434    AMRENC_COMPONENT_PRIVATE *pComponentPrivate = (AMRENC_COMPONENT_PRIVATE *)
435                                                     pHandle->pComponentPrivate;
436
437    OMX_PRINT1(pComponentPrivate->dbg, "%d :: Entering NBAMRENC_FreeCompResources\n",__LINE__);
438
439    if (pComponentPrivate->bCompThreadStarted) {
440        OMX_NBCLOSE_PIPE(pComponentPrivate->dataPipe[0],err);
441        OMX_NBCLOSE_PIPE(pComponentPrivate->dataPipe[1],err);
442        OMX_NBCLOSE_PIPE(pComponentPrivate->cmdPipe[0],err);
443        OMX_NBCLOSE_PIPE(pComponentPrivate->cmdPipe[1],err);
444        OMX_NBCLOSE_PIPE(pComponentPrivate->cmdDataPipe[0],err);
445        OMX_NBCLOSE_PIPE(pComponentPrivate->cmdDataPipe[1],err);
446    }
447
448    OMX_MEMFREE_STRUCT_DSPALIGN(pComponentPrivate->pAlgParam, NBAMRENC_TALGCtrl);
449    OMX_MEMFREE_STRUCT_DSPALIGN(pComponentPrivate->pAlgParamDTX, NBAMRENC_TALGCtrlDTX);
450    OMX_MEMFREE_STRUCT_DSPALIGN(pComponentPrivate->pParams, NBAMRENC_AudioCodecParams);
451
452    OMX_MEMFREE_STRUCT(pComponentPrivate->pPortDef[NBAMRENC_INPUT_PORT]);
453    OMX_MEMFREE_STRUCT(pComponentPrivate->pPortDef[NBAMRENC_OUTPUT_PORT]);
454    OMX_MEMFREE_STRUCT(pComponentPrivate->pcmParams);
455    OMX_MEMFREE_STRUCT(pComponentPrivate->amrParams);
456
457    OMX_MEMFREE_STRUCT(pComponentPrivate->pCompPort[NBAMRENC_INPUT_PORT]->pPortFormat);
458    OMX_MEMFREE_STRUCT(pComponentPrivate->pCompPort[NBAMRENC_OUTPUT_PORT]->pPortFormat);
459    OMX_MEMFREE_STRUCT(pComponentPrivate->pCompPort[NBAMRENC_INPUT_PORT]);
460    OMX_MEMFREE_STRUCT(pComponentPrivate->pCompPort[NBAMRENC_OUTPUT_PORT]);
461
462    OMX_MEMFREE_STRUCT(pComponentPrivate->sPortParam);
463    OMX_MEMFREE_STRUCT(pComponentPrivate->sPriorityMgmt);
464    OMX_MEMFREE_STRUCT(pComponentPrivate->pInputBufferList);
465    OMX_MEMFREE_STRUCT(pComponentPrivate->pOutputBufferList);
466
467EXIT:
468    OMX_PRINT1(pComponentPrivate->dbg, "%d :: Exiting NBAMRENC_FreeCompResources()\n",__LINE__);
469    OMX_PRINT1(pComponentPrivate->dbg, "%d :: Returning = 0x%x\n",__LINE__,eError);
470    return eError;
471}
472
473/* ========================================================================== */
474/**
475* @NBAMRENC_CleanupInitParams() This function is called by the component during
476* de-init to newfree structues that are been allocated at intialization stage
477*
478* @param pComponent  handle for this instance of the component
479*
480* @pre
481*
482* @post
483*
484* @return none
485*/
486/* ========================================================================== */
487
488OMX_ERRORTYPE NBAMRENC_CleanupInitParams(OMX_HANDLETYPE pComponent)
489{
490    OMX_ERRORTYPE eError = OMX_ErrorNone;
491    OMX_U32 nIpBuf = 0;
492    OMX_U32 nOpBuf = 0;
493    OMX_U16 i = 0;
494    NBAMRENC_LCML_BUFHEADERTYPE *pTemp_lcml;
495
496    LCML_DSP_INTERFACE *pLcmlHandle;
497    LCML_DSP_INTERFACE *pLcmlHandleAux;
498
499    OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)pComponent;
500    AMRENC_COMPONENT_PRIVATE *pComponentPrivate = (AMRENC_COMPONENT_PRIVATE *)
501                                                     pHandle->pComponentPrivate;
502    OMX_PRINT1(pComponentPrivate->dbg, "%d :: Entering NBAMRENC_CleanupInitParams()\n", __LINE__);
503
504    if(pComponentPrivate->dasfMode == 1) {
505
506        OMX_MEMFREE_STRUCT(pComponentPrivate->strmAttr);
507    }
508
509    OMX_MEMFREE_STRUCT_DSPALIGN(pComponentPrivate->pAlgParam, NBAMRENC_TALGCtrl);
510    OMX_MEMFREE_STRUCT_DSPALIGN(pComponentPrivate->pAlgParamDTX, NBAMRENC_TALGCtrlDTX);
511
512    pComponentPrivate->nHoldLength = 0;
513    OMX_MEMFREE_STRUCT(pComponentPrivate->pHoldBuffer);
514    OMX_MEMFREE_STRUCT(pComponentPrivate->pHoldBuffer2);
515    OMX_MEMFREE_STRUCT(pComponentPrivate->iHoldBuffer);
516    OMX_MEMFREE_STRUCT(pComponentPrivate->iMMFDataLastBuffer);
517
518    pTemp_lcml = pComponentPrivate->pLcmlBufHeader[NBAMRENC_INPUT_PORT];
519    nIpBuf = pComponentPrivate->nRuntimeInputBuffers;
520
521    for(i=0; i<nIpBuf; i++) {
522        if(pTemp_lcml->pFrameParam!=NULL){
523              pLcmlHandle = (LCML_DSP_INTERFACE *)pComponentPrivate->pLcmlHandle;
524              pLcmlHandleAux = (LCML_DSP_INTERFACE *)(((LCML_CODEC_INTERFACE *)pLcmlHandle->pCodecinterfacehandle)->pCodec);
525              OMX_DmmUnMap(pLcmlHandleAux->dspCodec->hProc,
526                               (void*)pTemp_lcml->pBufferParam->pParamElem,
527                               pTemp_lcml->pDmmBuf->pReserved, pComponentPrivate->dbg);
528
529              OMX_MEMFREE_STRUCT_DSPALIGN(pTemp_lcml->pFrameParam, NBAMRENC_FrameStruct);
530        }
531
532    OMX_MEMFREE_STRUCT_DSPALIGN(pTemp_lcml->pBufferParam, NBAMRENC_ParamStruct);
533    OMX_MEMFREE_STRUCT(pTemp_lcml->pDmmBuf);
534    pTemp_lcml++;
535    }
536
537    pTemp_lcml = pComponentPrivate->pLcmlBufHeader[NBAMRENC_OUTPUT_PORT];
538    nOpBuf = pComponentPrivate->nRuntimeOutputBuffers;
539
540    for(i=0; i<nOpBuf; i++) {
541        if(pTemp_lcml->pFrameParam!=NULL){
542              pLcmlHandle = (LCML_DSP_INTERFACE *)pComponentPrivate->pLcmlHandle;
543              pLcmlHandleAux = (LCML_DSP_INTERFACE *)(((LCML_CODEC_INTERFACE *)pLcmlHandle->pCodecinterfacehandle)->pCodec);
544#ifndef UNDER_CE
545            OMX_DmmUnMap(pLcmlHandleAux->dspCodec->hProc,
546                              (void*)pTemp_lcml->pBufferParam->pParamElem,
547                               pTemp_lcml->pDmmBuf->pReserved, pComponentPrivate->dbg);
548#endif
549
550            OMX_MEMFREE_STRUCT_DSPALIGN(pTemp_lcml->pFrameParam, NBAMRENC_FrameStruct);
551        }
552
553    OMX_MEMFREE_STRUCT_DSPALIGN(pTemp_lcml->pBufferParam, NBAMRENC_ParamStruct);
554    OMX_MEMFREE_STRUCT(pTemp_lcml->pDmmBuf);
555    pTemp_lcml++;
556    }
557
558
559    OMX_MEMFREE_STRUCT(pComponentPrivate->pLcmlBufHeader[NBAMRENC_INPUT_PORT]);
560    OMX_MEMFREE_STRUCT(pComponentPrivate->pLcmlBufHeader[NBAMRENC_OUTPUT_PORT]);
561
562    OMX_PRINT1(pComponentPrivate->dbg, "%d :: Exiting NBAMRENC_CleanupInitParams()\n",__LINE__);
563    OMX_PRINT1(pComponentPrivate->dbg, "%d :: Returning = 0x%x\n",__LINE__,eError);
564    return eError;
565}
566
567/* ========================================================================== */
568/**
569* @NBAMRENC_StopComponentThread() This function is called by the component during
570* de-init to close component thread.
571*
572* @param pComponent  handle for this instance of the component
573*
574* @pre
575*
576* @post
577*
578* @return none
579*/
580/* ========================================================================== */
581
582OMX_ERRORTYPE NBAMRENC_StopComponentThread(OMX_HANDLETYPE pComponent)
583{
584    OMX_ERRORTYPE eError = OMX_ErrorNone;
585    OMX_ERRORTYPE threadError = OMX_ErrorNone;
586    int pthreadError = 0;
587    OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)pComponent;
588    AMRENC_COMPONENT_PRIVATE *pComponentPrivate = (AMRENC_COMPONENT_PRIVATE *)
589                                                     pHandle->pComponentPrivate;
590    OMX_PRINT1(pComponentPrivate->dbg, "%d :: Entering NBAMRENC_StopComponentThread\n",__LINE__);
591    pComponentPrivate->bIsThreadstop = 1;
592    write (pComponentPrivate->cmdPipe[1], &pComponentPrivate->bIsThreadstop, sizeof(OMX_U16));
593    OMX_PRINT2(pComponentPrivate->dbg, "%d :: About to call pthread_join\n",__LINE__);
594    pthreadError = pthread_join (pComponentPrivate->ComponentThread,
595                                 (void*)&threadError);
596    if (0 != pthreadError) {
597        eError = OMX_ErrorHardware;
598        OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error closing ComponentThread - pthreadError = %d\n",__LINE__,pthreadError);
599        goto EXIT;
600    }
601    if (OMX_ErrorNone != threadError && OMX_ErrorNone != eError) {
602        eError = OMX_ErrorInsufficientResources;
603        OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error while closing Component Thread\n",__LINE__);
604        goto EXIT;
605    }
606EXIT:
607   OMX_PRINT1(pComponentPrivate->dbg, "%d :: Exiting NBAMRENC_StopComponentThread\n",__LINE__);
608   OMX_PRINT1(pComponentPrivate->dbg, "%d :: Returning = 0x%x\n",__LINE__,eError);
609   return eError;
610}
611
612
613/* ========================================================================== */
614/**
615* @NBAMRENC_HandleCommand() This function is called by the component when ever it
616* receives the command from the application
617*
618* @param pComponentPrivate  Component private data
619*
620* @pre
621*
622* @post
623*
624* @return none
625*/
626/* ========================================================================== */
627
628OMX_U32 NBAMRENC_HandleCommand (AMRENC_COMPONENT_PRIVATE *pComponentPrivate)
629{
630    OMX_ERRORTYPE eError = OMX_ErrorNone;
631    OMX_COMMANDTYPE command;
632    OMX_STATETYPE commandedState;
633    OMX_HANDLETYPE pLcmlHandle;
634#ifdef RESOURCE_MANAGER_ENABLED
635    OMX_ERRORTYPE rm_error;
636#endif
637    LCML_CALLBACKTYPE cb;
638    LCML_DSP *pLcmlDsp;
639    OMX_U32 cmdValues[4];
640    OMX_U32 pValues[4];
641    OMX_U32 commandData;
642    OMX_U16 arr[100];
643    char *pArgs = "damedesuStr";
644    char *p = "hello";
645    OMX_U16 i = 0;
646    OMX_U32 ret = 0;
647    OMX_U8 inputPortFlag=0,outputPortFlag=0;
648    NBAMRENC_LCML_BUFHEADERTYPE *pLcmlHdr = NULL;
649#ifdef DSP_RENDERING_ON
650#if 0
651   AM_COMMANDDATATYPE cmd_data;
652#endif
653#endif
654    OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *) pComponentPrivate->pHandle;
655    pLcmlHandle = pComponentPrivate->pLcmlHandle;
656
657    OMX_PRINT1(pComponentPrivate->dbg, "%d :: Entering NBAMRENCHandleCommand Function \n",__LINE__);
658    OMX_PRSTATE2(pComponentPrivate->dbg, "%d :: pComponentPrivate->curState = %d\n",__LINE__,pComponentPrivate->curState);
659    ret = read(pComponentPrivate->cmdPipe[0], &command, sizeof (command));
660    if (ret == -1) {
661        OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error in Reading from the Data pipe\n", __LINE__);
662        eError = OMX_ErrorHardware;
663        goto EXIT;
664    }
665    ret = read(pComponentPrivate->cmdDataPipe[0], &commandData, sizeof (commandData));
666    if (ret == -1) {
667        OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error in Reading from the Data pipe\n", __LINE__);
668        eError = OMX_ErrorHardware;
669        goto EXIT;
670    }
671
672#ifdef __PERF_INSTRUMENTATION__
673    PERF_ReceivedCommand(pComponentPrivate->pPERFcomp,
674                        command,
675                        commandData,
676                        PERF_ModuleLLMM);
677#endif
678    if (command == OMX_CommandStateSet) {
679        commandedState = (OMX_STATETYPE)commandData;
680        switch(commandedState) {
681        case OMX_StateIdle:
682            OMX_PRSTATE2(pComponentPrivate->dbg, "%d :: NBAMRENC_HandleCommand :: OMX_StateIdle \n",__LINE__);
683            OMX_PRSTATE1(pComponentPrivate->dbg, "%d :: pComponentPrivate->curState = %d\n",__LINE__,pComponentPrivate->curState);
684            if (pComponentPrivate->curState == commandedState){
685                pComponentPrivate->cbInfo.EventHandler ( pHandle,
686                                                         pHandle->pApplicationPrivate,
687                                                         OMX_EventError,
688                                                         OMX_ErrorSameState,
689                                                         OMX_TI_ErrorMinor,
690                                                         NULL);
691                OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error: Same State Given by Application\n",__LINE__);
692            }
693            else if (pComponentPrivate->curState == OMX_StateLoaded) {
694#ifdef __PERF_INSTRUMENTATION__
695            PERF_Boundary(pComponentPrivate->pPERFcomp,PERF_BoundaryStart | PERF_BoundarySetup);
696#endif
697
698                 if(pComponentPrivate->dasfMode == 1) {
699                     if(pComponentPrivate->streamID == 0)
700                     {
701                         OMX_ERROR4(pComponentPrivate->dbg, "**************************************\n");
702                         OMX_ERROR4(pComponentPrivate->dbg, ":: Error = OMX_ErrorInsufficientResources\n");
703                         OMX_ERROR4(pComponentPrivate->dbg, "**************************************\n");
704                         eError = OMX_ErrorInsufficientResources;
705                         pComponentPrivate->curState = OMX_StateInvalid;
706                         pComponentPrivate->cbInfo.EventHandler(pHandle,
707                                                                pHandle->pApplicationPrivate,
708                                                                OMX_EventError,
709                                                                OMX_ErrorInvalidState,
710                                                                OMX_TI_ErrorMajor,
711                                                                "No Stream ID Available");
712                         goto EXIT;
713                     }
714                 }
715
716                 if (pComponentPrivate->pPortDef[NBAMRENC_INPUT_PORT]->bPopulated &&  pComponentPrivate->pPortDef[NBAMRENC_INPUT_PORT]->bEnabled)  {
717                                     inputPortFlag = 1;
718                 }
719                 if (pComponentPrivate->pPortDef[NBAMRENC_OUTPUT_PORT]->bPopulated && pComponentPrivate->pPortDef[NBAMRENC_OUTPUT_PORT]->bEnabled) {
720                                     outputPortFlag = 1;
721                 }
722
723                if (!pComponentPrivate->pPortDef[NBAMRENC_INPUT_PORT]->bPopulated && !pComponentPrivate->pPortDef[NBAMRENC_INPUT_PORT]->bEnabled) {
724                    inputPortFlag = 1;
725                }
726
727                if (!pComponentPrivate->pPortDef[NBAMRENC_OUTPUT_PORT]->bPopulated && !pComponentPrivate->pPortDef[NBAMRENC_OUTPUT_PORT]->bEnabled) {
728                    outputPortFlag = 1;
729                }
730
731                if((pComponentPrivate->dasfMode && !outputPortFlag) ||
732               (!pComponentPrivate->dasfMode && (!inputPortFlag || !outputPortFlag)))
733                 {
734                         /* Sleep for a while, so the application thread can allocate buffers */
735                         OMX_PRSTATE1(pComponentPrivate->dbg, "%d :: Sleeping...\n",__LINE__);
736                         pComponentPrivate->InLoaded_readytoidle = 1;
737#ifndef UNDER_CE
738                         pthread_mutex_lock(&pComponentPrivate->InLoaded_mutex);
739                         pthread_cond_wait(&pComponentPrivate->InLoaded_threshold, &pComponentPrivate->InLoaded_mutex);
740                         pthread_mutex_unlock(&pComponentPrivate->InLoaded_mutex);
741#else
742                         OMX_WaitForEvent(&(pComponentPrivate->InLoaded_event));
743#endif
744                 }
745
746                cb.LCML_Callback = (void *) NBAMRENC_LCMLCallback;
747                pLcmlHandle = (OMX_HANDLETYPE) NBAMRENC_GetLCMLHandle(pComponentPrivate);
748
749                if (pLcmlHandle == NULL) {
750                    OMX_ERROR4(pComponentPrivate->dbg, "%d :: LCML Handle is NULL........exiting..\n",__LINE__);
751                    goto EXIT;
752                }
753
754
755                /* Got handle of dsp via phandle filling information about DSP Specific things */
756                pLcmlDsp = (((LCML_DSP_INTERFACE*)pLcmlHandle)->dspCodec);
757                eError = NBAMRENC_FillLCMLInitParams(pHandle, pLcmlDsp, arr);
758                if(eError != OMX_ErrorNone) {
759                    OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error from NBAMRENCFill_LCMLInitParams()\n",__LINE__);
760                    goto EXIT;
761                }
762
763
764                pComponentPrivate->pLcmlHandle = (LCML_DSP_INTERFACE *)pLcmlHandle;
765                cb.LCML_Callback = (void *) NBAMRENC_LCMLCallback;
766
767#ifndef UNDER_CE
768                eError = LCML_InitMMCodecEx(((LCML_DSP_INTERFACE *)pLcmlHandle)->pCodecinterfacehandle,
769                                          p,&pLcmlHandle,(void *)p,&cb, (OMX_STRING)pComponentPrivate->sDeviceString);
770
771#else
772                eError = LCML_InitMMCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
773                                                                    p,&pLcmlHandle, (void *)p, &cb);
774#endif
775
776                if(eError != OMX_ErrorNone) {
777                    OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error returned from LCML_Init()\n",__LINE__);
778                    /* send an event to client */
779                    /* client should unload the component if the codec is not able to load */
780                    eError = OMX_ErrorInvalidState;
781                    pComponentPrivate->cbInfo.EventHandler (pHandle,
782                                                pHandle->pApplicationPrivate,
783                                                OMX_EventError,
784                                                eError,
785                                                OMX_TI_ErrorSevere,
786                                                NULL);
787                    goto EXIT;
788                }
789
790#ifdef RESOURCE_MANAGER_ENABLED
791                /* Need check the resource with RM */
792                pComponentPrivate->rmproxyCallback.RMPROXY_Callback = (void *) NBAMRENC_ResourceManagerCallback;
793
794                if (pComponentPrivate->curState != OMX_StateWaitForResources){
795
796                    rm_error = RMProxy_NewSendCommand(pHandle,
797                                                        RMProxy_RequestResource,
798                                                        OMX_NBAMR_Encoder_COMPONENT, NBAMRENC_CPU_LOAD,
799                                                        3456, &(pComponentPrivate->rmproxyCallback));
800
801                    if(rm_error == OMX_ErrorNone) {
802                        /* resource is available */
803#ifdef __PERF_INSTRUMENTATION__
804                        PERF_Boundary(pComponentPrivate->pPERFcomp,PERF_BoundaryComplete | PERF_BoundarySetup);
805#endif
806                        pComponentPrivate->curState = OMX_StateIdle;
807
808                       /* Decrement reference count with signal enabled */
809                        if(RemoveStateTransition(pComponentPrivate, OMX_TRUE) != OMX_ErrorNone) {
810                            return OMX_ErrorUndefined;
811                        }
812
813                        pComponentPrivate->cbInfo.EventHandler(pHandle,
814                                pHandle->pApplicationPrivate,
815                                OMX_EventCmdComplete,
816                                OMX_CommandStateSet,
817                                pComponentPrivate->curState,
818                                NULL);
819
820                        rm_error = RMProxy_NewSendCommand(pHandle, RMProxy_StateSet, OMX_NBAMR_Encoder_COMPONENT, OMX_StateIdle, 3456, NULL);
821                    }
822                    else if(rm_error == OMX_ErrorInsufficientResources) {
823                        /* resource is not available, need set state to OMX_StateWaitForResources */
824                        pComponentPrivate->curState = OMX_StateWaitForResources;
825                        pComponentPrivate->cbInfo.EventHandler( pHandle,
826                                                                pHandle->pApplicationPrivate,
827                                                                OMX_EventCmdComplete,
828                                                                OMX_CommandStateSet,
829                                                                pComponentPrivate->curState,
830                                                                NULL);
831                        OMX_ERROR4(pComponentPrivate->dbg, "%d :: Comp: OMX_ErrorInsufficientResources\n", __LINE__);
832                    }
833            }
834            else {
835                    pComponentPrivate->curState = OMX_StateIdle;
836
837                    /* Decrement reference count with signal enabled */
838                    if(RemoveStateTransition(pComponentPrivate, OMX_TRUE) != OMX_ErrorNone) {
839                          return OMX_ErrorUndefined;
840                    }
841
842                    pComponentPrivate->cbInfo.EventHandler(pHandle,
843                                                            pHandle->pApplicationPrivate,
844                                                            OMX_EventCmdComplete,
845                                                            OMX_CommandStateSet,
846                                                            pComponentPrivate->curState,
847                                                            NULL);
848
849                rm_error = RMProxy_NewSendCommand(pHandle,
850                                                       RMProxy_StateSet,
851                                                       OMX_NBAMR_Encoder_COMPONENT,
852                                                       OMX_StateIdle,
853                                                       3456,
854                                                       NULL);
855
856            }
857#else
858                pComponentPrivate->curState = OMX_StateIdle;
859
860                /* Decrement reference count with signal enabled */
861                if(RemoveStateTransition(pComponentPrivate, OMX_TRUE) != OMX_ErrorNone) {
862                      return OMX_ErrorUndefined;
863                }
864
865                pComponentPrivate->cbInfo.EventHandler( pHandle,
866                                                        pHandle->pApplicationPrivate,
867                                                        OMX_EventCmdComplete,
868                                                        OMX_CommandStateSet,
869                                                        pComponentPrivate->curState,
870                                                        NULL);
871
872#endif
873
874            }
875            else if (pComponentPrivate->curState == OMX_StateExecuting) {
876                OMX_PRSTATE1(pComponentPrivate->dbg, "%d :: Setting Component to OMX_StateIdle\n",__LINE__);
877                OMX_PRINT2(pComponentPrivate->dbg, "%d :: AMRENC: About to Call MMCodecControlStop\n", __LINE__);
878#ifdef __PERF_INSTRUMENTATION__
879                    PERF_Boundary(pComponentPrivate->pPERFcomp,PERF_BoundaryComplete | PERF_BoundarySteadyState);
880#endif
881                pComponentPrivate->bIsStopping = 1;
882
883                if (pComponentPrivate->codecStop_waitingsignal == 0){
884                    pthread_mutex_lock(&pComponentPrivate->codecStop_mutex);
885                }
886                eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
887                                                                    MMCodecControlStop,(void *)pArgs);
888
889                if (pComponentPrivate->codecStop_waitingsignal == 0){
890                    pthread_cond_wait(&pComponentPrivate->codecStop_threshold, &pComponentPrivate->codecStop_mutex);
891                    pComponentPrivate->codecStop_waitingsignal = 0;
892                    pthread_mutex_unlock(&pComponentPrivate->codecStop_mutex);
893                }
894
895                OMX_MEMFREE_STRUCT_DSPALIGN(pComponentPrivate->pAlgParam, NBAMRENC_TALGCtrl);
896                OMX_MEMFREE_STRUCT_DSPALIGN(pComponentPrivate->pAlgParamDTX, NBAMRENC_TALGCtrlDTX);
897
898                pComponentPrivate->nOutStandingFillDones = 0;
899                                pComponentPrivate->nOutStandingEmptyDones = 0;
900
901                OMX_MEMFREE_STRUCT_DSPALIGN(pComponentPrivate->pParams, NBAMRENC_AudioCodecParams);
902
903                if(eError != OMX_ErrorNone) {
904                    OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error from LCML_ControlCodec MMCodecControlStop..\n",__LINE__);
905                    goto EXIT;
906                }
907            }
908            else if(pComponentPrivate->curState == OMX_StatePause) {
909
910                pComponentPrivate->curState = OMX_StateIdle;
911#ifdef __PERF_INSTRUMENTATION__
912                    PERF_Boundary(pComponentPrivate->pPERFcomp,PERF_BoundaryComplete | PERF_BoundarySteadyState);
913#endif
914#ifdef RESOURCE_MANAGER_ENABLED
915                rm_error = RMProxy_NewSendCommand(pHandle, RMProxy_StateSet, OMX_NBAMR_Encoder_COMPONENT, OMX_StateIdle, 3456, NULL);
916
917#endif
918                OMX_PRSTATE2(pComponentPrivate->dbg, "%d :: The component is stopped\n",__LINE__);
919
920                /* Decrement reference count with signal enabled */
921                if(RemoveStateTransition(pComponentPrivate, OMX_TRUE) != OMX_ErrorNone) {
922                      return OMX_ErrorUndefined;
923                }
924
925                pComponentPrivate->cbInfo.EventHandler ( pHandle,
926                                                         pHandle->pApplicationPrivate,
927                                                         OMX_EventCmdComplete,
928                                                         OMX_CommandStateSet,
929                                                         pComponentPrivate->curState,
930                                                         NULL);
931            } else {    /* This means, it is invalid state from application */
932                pComponentPrivate->cbInfo.EventHandler( pHandle,
933                                                        pHandle->pApplicationPrivate,
934                                                        OMX_EventError,
935                                                        OMX_ErrorIncorrectStateTransition,
936                                                        OMX_TI_ErrorMinor,
937                                                        "Invalid State");
938                OMX_ERROR4(pComponentPrivate->dbg, "%d :: Comp: OMX_ErrorIncorrectStateTransition\n",__LINE__);
939            }
940            break;
941
942        case OMX_StateExecuting:
943            OMX_PRSTATE2(pComponentPrivate->dbg, "%d :: NBAMRENC_HandleCommand :: OMX_StateExecuting \n",__LINE__);
944            if (pComponentPrivate->curState == commandedState){
945                pComponentPrivate->cbInfo.EventHandler ( pHandle,
946                                                         pHandle->pApplicationPrivate,
947                                                         OMX_EventError,
948                                                         OMX_ErrorSameState,
949                                                         OMX_TI_ErrorMinor,
950                                                         "Invalid State");
951                OMX_ERROR4(pComponentPrivate->dbg, "%d :: Comp: OMX_ErrorSameState Given by Comp\n",__LINE__);
952                break;
953            }
954            else if (pComponentPrivate->curState == OMX_StateIdle) {
955                /* Sending commands to DSP via LCML_ControlCodec third argument
956                is not used for time being */
957                pComponentPrivate->nNumInputBufPending = 0;
958                pComponentPrivate->nNumOutputBufPending = 0;
959                pComponentPrivate->nNumOfFramesSent=0;
960                pComponentPrivate->nEmptyBufferDoneCount = 0;
961                pComponentPrivate->nEmptyThisBufferCount =0;
962
963                OMX_MALLOC_SIZE_DSPALIGN(pComponentPrivate->pAlgParam, sizeof(NBAMRENC_TALGCtrl),OMX_U8);
964                OMX_MALLOC_SIZE_DSPALIGN(pComponentPrivate->pAlgParamDTX, sizeof(NBAMRENC_TALGCtrlDTX),OMX_U8);
965
966                pComponentPrivate->pAlgParam->iBitrate = pComponentPrivate->amrParams->eAMRBandMode;
967
968#ifdef NBAMR_DTX_VAD_MODE_SUPPORT_ENABLED
969                if (pComponentPrivate->amrParams->eAMRDTXMode == OMX_AUDIO_AMRDTXModeOnAuto) {
970                    pComponentPrivate->pAlgParamDTX->iVADFlag = OMX_TRUE;
971                }
972                else {
973                    pComponentPrivate->pAlgParamDTX->iVADFlag = OMX_FALSE;
974                }
975#else
976                pComponentPrivate->pAlgParamDTX->iVADFlag = OMX_FALSE;
977#endif
978                pComponentPrivate->pAlgParam->iSize = sizeof (NBAMRENC_TALGCtrl);
979                pComponentPrivate->pAlgParamDTX->iSize = sizeof (NBAMRENC_TALGCtrlDTX);
980                OMX_PRINT2(pComponentPrivate->dbg, "%d :: pAlgParam->iBitrate = %d\n",__LINE__,pComponentPrivate->pAlgParam->iBitrate);
981                OMX_PRINT2(pComponentPrivate->dbg, "%d :: pAlgParamDTX->iVADFlag  = %d\n",__LINE__,pComponentPrivate->pAlgParamDTX->iVADFlag);
982
983                cmdValues[0] = ALGCMD_BITRATE;                  /*setting the bit-rate*/
984                cmdValues[1] = (OMX_U32)pComponentPrivate->pAlgParam;
985                cmdValues[2] = sizeof (NBAMRENC_TALGCtrl);
986                p = (void *)&cmdValues;
987                OMX_PRCOMM1(pComponentPrivate->dbg, "%d :: EMMCodecControlAlgCtrl-1 Sending...\n",__LINE__);
988                /* Sending ALGCTRL MESSAGE DTX to DSP via LCML_ControlCodec*/
989                eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
990                                                EMMCodecControlAlgCtrl, (void *)p);
991                if (eError != OMX_ErrorNone) {
992                    OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error from LCML_ControlCodec EMMCodecControlAlgCtrl-1 failed = %x\n",__LINE__,eError);
993                    goto EXIT;
994                }
995                cmdValues[0] = ALGCMD_DTX;                  /*setting DTX mode*/
996                cmdValues[1] = (OMX_U32)pComponentPrivate->pAlgParamDTX;
997                cmdValues[2] = sizeof (NBAMRENC_TALGCtrlDTX);
998                p = (void *)&cmdValues;
999                OMX_PRCOMM1(pComponentPrivate->dbg, "%d :: EMMCodecControlAlgCtrl-2 Sending...\n",__LINE__);
1000                /* Sending ALGCTRL MESSAGE BITRATE to DSP via LCML_ControlCodec*/
1001                eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1002                                                EMMCodecControlAlgCtrl, (void *)p);
1003                if (eError != OMX_ErrorNone) {
1004                    OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error from LCML_ControlCodec EMMCodecControlAlgCtrl-2 failed = %x\n",__LINE__,eError);
1005                    goto EXIT;
1006                }
1007                if(pComponentPrivate->dasfMode == 1) {
1008                    OMX_PRDSP2(pComponentPrivate->dbg, "%d :: ---- Comp: DASF Functionality is ON ---\n",__LINE__);
1009
1010                    OMX_MALLOC_SIZE_DSPALIGN(pComponentPrivate->pParams, sizeof(NBAMRENC_AudioCodecParams),OMX_U8);
1011
1012                    pComponentPrivate->pParams->iAudioFormat = 1;
1013                    pComponentPrivate->pParams->iStrmId = pComponentPrivate->streamID;
1014                    pComponentPrivate->pParams->iSamplingRate = NBAMRENC_SAMPLING_FREQUENCY;
1015                    pValues[0] = USN_STRMCMD_SETCODECPARAMS;
1016                    pValues[1] = (OMX_U32)pComponentPrivate->pParams;
1017                    pValues[2] = sizeof(NBAMRENC_AudioCodecParams);
1018                    /* Sending STRMCTRL MESSAGE to DSP via LCML_ControlCodec*/
1019                    eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1020                                                              EMMCodecControlStrmCtrl,(void *)pValues);
1021                    if(eError != OMX_ErrorNone) {
1022                       OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error from LCML_ControlCodec EMMCodecControlStrmCtrl = %x\n",__LINE__,eError);
1023                       goto EXIT;
1024                    }
1025                }
1026                /* Sending START MESSAGE to DSP via LCML_ControlCodec*/
1027                eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1028                                                EMMCodecControlStart, (void *)p);
1029                if(eError != OMX_ErrorNone) {
1030                    OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error from LCML_ControlCodec EMMCodecControlStart = %x\n",__LINE__,eError);
1031                    goto EXIT;
1032                }
1033
1034            } else if (pComponentPrivate->curState == OMX_StatePause) {
1035                eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1036                                                EMMCodecControlStart, (void *)p);
1037                if (eError != OMX_ErrorNone) {
1038                    OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error While Resuming the codec = %x\n",__LINE__,eError);
1039                    goto EXIT;
1040                }
1041
1042                for (i=0; i < pComponentPrivate->nNumInputBufPending; i++) {
1043                    if (pComponentPrivate->pInputBufHdrPending[i]) {
1044                        NBAMRENC_GetCorrespondingLCMLHeader(pComponentPrivate, pComponentPrivate->pInputBufHdrPending[i]->pBuffer, OMX_DirInput, &pLcmlHdr);
1045                        NBAMRENC_SetPending(pComponentPrivate,pComponentPrivate->pInputBufHdrPending[i],OMX_DirInput,__LINE__);
1046
1047                        eError = LCML_QueueBuffer(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1048                                                    EMMCodecInputBuffer,
1049                                                    pComponentPrivate->pInputBufHdrPending[i]->pBuffer,
1050                                                    pComponentPrivate->pInputBufHdrPending[i]->nAllocLen,
1051                                                    pComponentPrivate->pInputBufHdrPending[i]->nFilledLen,
1052                                                    (OMX_U8 *) pLcmlHdr->pBufferParam,
1053                                                    sizeof(NBAMRENC_ParamStruct),
1054                                                    NULL);
1055                    }
1056                }
1057                pComponentPrivate->nNumInputBufPending = 0;
1058
1059                for (i=0; i < pComponentPrivate->nNumOutputBufPending; i++) {
1060                    if (pComponentPrivate->pOutputBufHdrPending[i]) {
1061                        NBAMRENC_GetCorrespondingLCMLHeader(pComponentPrivate,pComponentPrivate->pOutputBufHdrPending[i]->pBuffer, OMX_DirOutput, &pLcmlHdr);
1062                        NBAMRENC_SetPending(pComponentPrivate,pComponentPrivate->pOutputBufHdrPending[i],OMX_DirOutput,__LINE__);
1063                        eError = LCML_QueueBuffer(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1064                                                    EMMCodecOuputBuffer,
1065                                                    pComponentPrivate->pOutputBufHdrPending[i]->pBuffer,
1066                                                    pComponentPrivate->pOutputBufHdrPending[i]->nAllocLen,
1067                                                    pComponentPrivate->pOutputBufHdrPending[i]->nFilledLen,
1068                                                    (OMX_U8 *) pLcmlHdr->pBufferParam,
1069                                                    sizeof(NBAMRENC_ParamStruct),
1070                                                    NULL);
1071                    }
1072                }
1073                pComponentPrivate->nNumOutputBufPending = 0;
1074            } else {
1075                pComponentPrivate->cbInfo.EventHandler( pHandle,
1076                                                        pHandle->pApplicationPrivate,
1077                                                        OMX_EventError,
1078                                                        OMX_ErrorIncorrectStateTransition,
1079                                                        OMX_TI_ErrorMinor,
1080                                                        "Incorrect State Transition");
1081                OMX_ERROR4(pComponentPrivate->dbg, "%d :: Comp: OMX_ErrorIncorrectStateTransition Given by Comp\n",__LINE__);
1082                goto EXIT;
1083
1084            }
1085#ifdef RESOURCE_MANAGER_ENABLED
1086             rm_error = RMProxy_NewSendCommand(pHandle, RMProxy_StateSet, OMX_NBAMR_Encoder_COMPONENT, OMX_StateExecuting, 3456, NULL);
1087#endif
1088            pComponentPrivate->curState = OMX_StateExecuting;
1089#ifdef __PERF_INSTRUMENTATION__
1090            PERF_Boundary(pComponentPrivate->pPERFcomp,PERF_BoundaryStart | PERF_BoundarySteadyState);
1091#endif
1092
1093            /* Decrement reference count with signal enabled */
1094            if(RemoveStateTransition(pComponentPrivate, OMX_TRUE) != OMX_ErrorNone) {
1095                  return OMX_ErrorUndefined;
1096            }
1097
1098            pComponentPrivate->cbInfo.EventHandler( pHandle,
1099                                                    pHandle->pApplicationPrivate,
1100                                                    OMX_EventCmdComplete,
1101                                                    OMX_CommandStateSet,
1102                                                    pComponentPrivate->curState,
1103                                                    NULL);
1104            OMX_PRSTATE2(pComponentPrivate->dbg, "%d :: Comp: OMX_CommandStateSet Given by Comp\n",__LINE__);
1105            break;
1106
1107        case OMX_StateLoaded:
1108            OMX_PRDSP2(pComponentPrivate->dbg, "%d :: NBAMRENC_HandleCommand :: OMX_StateLoaded\n",__LINE__);
1109            if (pComponentPrivate->curState == commandedState){
1110                pComponentPrivate->cbInfo.EventHandler ( pHandle,
1111                                                         pHandle->pApplicationPrivate,
1112                                                         OMX_EventError,
1113                                                         OMX_ErrorSameState,
1114                                                         OMX_TI_ErrorMinor,
1115                                                         "Same State");
1116                OMX_ERROR4(pComponentPrivate->dbg, "%d :: Comp: OMX_ErrorSameState Given by Comp\n",__LINE__);
1117                break;
1118             }
1119            if (pComponentPrivate->curState == OMX_StateWaitForResources){
1120                OMX_PRCOMM1(pComponentPrivate->dbg, "%d :: NBAMRENC_HandleCommand :: OMX_StateWaitForResources\n",__LINE__);
1121#ifdef __PERF_INSTRUMENTATION__
1122                PERF_Boundary(pComponentPrivate->pPERFcomp,PERF_BoundaryStart | PERF_BoundaryCleanup);
1123#endif
1124                pComponentPrivate->curState = OMX_StateLoaded;
1125#ifdef __PERF_INSTRUMENTATION__
1126                PERF_Boundary(pComponentPrivate->pPERFcomp,PERF_BoundaryComplete | PERF_BoundaryCleanup);
1127#endif
1128                pComponentPrivate->curState = OMX_StateLoaded;
1129
1130                /* Decrement reference count with signal enabled */
1131                if(RemoveStateTransition(pComponentPrivate, OMX_TRUE) != OMX_ErrorNone) {
1132                    return OMX_ErrorUndefined;
1133                }
1134                pComponentPrivate->cbInfo.EventHandler ( pHandle,
1135                                                         pHandle->pApplicationPrivate,
1136                                                         OMX_EventCmdComplete,
1137                                                         OMX_CommandStateSet,
1138                                                         pComponentPrivate->curState,
1139                                                         NULL);
1140                OMX_PRINT2(pComponentPrivate->dbg, "%d :: Comp: OMX_CommandStateSet Given by Comp\n",__LINE__);
1141                break;
1142            }
1143            if (pComponentPrivate->curState != OMX_StateIdle &&
1144                pComponentPrivate->curState != OMX_StateWaitForResources) {
1145                OMX_PRSTATE2(pComponentPrivate->dbg, "%d :: NBAMRENC_HandleCommand :: OMX_StateIdle && OMX_StateWaitForResources\n",__LINE__);
1146                pComponentPrivate->cbInfo.EventHandler ( pHandle,
1147                                                         pHandle->pApplicationPrivate,
1148                                                         OMX_EventError,
1149                                                         OMX_ErrorIncorrectStateTransition,
1150                                                         OMX_TI_ErrorMinor,
1151                                                         "Incorrect State Transition");
1152                OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error: OMX_ErrorIncorrectStateTransition Given by Comp\n",__LINE__);
1153                goto EXIT;
1154            }
1155#ifdef __PERF_INSTRUMENTATION__
1156            PERF_Boundary(pComponentPrivate->pPERFcomp,PERF_BoundaryStart | PERF_BoundaryCleanup);
1157#endif
1158            OMX_PRBUFFER2(pComponentPrivate->dbg, "%d :: NBAMRENC_HandleCommand - evaluating if all buffers are free\n",__LINE__);
1159
1160            if (pComponentPrivate->pInputBufferList->numBuffers ||
1161                pComponentPrivate->pOutputBufferList->numBuffers) {
1162
1163                pthread_mutex_lock(&pComponentPrivate->InIdle_mutex);
1164                pComponentPrivate->InIdle_goingtoloaded = 1;
1165                pthread_cond_wait(&pComponentPrivate->InIdle_threshold, &pComponentPrivate->InIdle_mutex);
1166                pthread_mutex_unlock(&pComponentPrivate->ToLoaded_mutex);
1167            }
1168
1169            /* Now Deinitialize the component No error should be returned from
1170            * this function. It should clean the system as much as possible */
1171            NBAMRENC_CleanupInitParams(pComponentPrivate->pHandle);
1172            eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1173                                        EMMCodecControlDestroy, (void *)p);
1174            if (eError != OMX_ErrorNone) {
1175                OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error: LCML_ControlCodec EMMCodecControlDestroy = %x\n",__LINE__, eError);
1176                goto EXIT;
1177            }
1178
1179            /*Closing LCML Lib*/
1180            if (pComponentPrivate->ptrLibLCML != NULL)
1181            {
1182                OMX_PRDSP2(pComponentPrivate->dbg, "%d OMX_AmrEncoder.c Closing LCML library\n",__LINE__);
1183                dlclose( pComponentPrivate->ptrLibLCML);
1184                pComponentPrivate->ptrLibLCML = NULL;
1185            }
1186
1187
1188#ifdef __PERF_INSTRUMENTATION__
1189            PERF_SendingCommand(pComponentPrivate->pPERF, -1, 0, PERF_ModuleComponent);
1190#endif
1191            eError = NBAMRENC_EXIT_COMPONENT_THRD;
1192            pComponentPrivate->bInitParamsInitialized = 0;
1193            pComponentPrivate->bLoadedCommandPending = OMX_FALSE;
1194            pComponentPrivate->bLoadedWaitingFreeBuffers = OMX_FALSE;
1195            break;
1196
1197        case OMX_StatePause:
1198            OMX_PRSTATE2(pComponentPrivate->dbg, "%d :: NBAMRENC_HandleCommand :: OMX_StatePause\n",__LINE__);
1199            if (pComponentPrivate->curState == commandedState){
1200                pComponentPrivate->cbInfo.EventHandler ( pHandle,
1201                                                         pHandle->pApplicationPrivate,
1202                                                         OMX_EventError,
1203                                                         OMX_ErrorSameState,
1204                                                         OMX_TI_ErrorMinor,
1205                                                         "Same State");
1206                OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error: OMX_ErrorSameState Given by Comp\n",__LINE__);
1207                break;
1208            }
1209            if (pComponentPrivate->curState != OMX_StateExecuting &&
1210                pComponentPrivate->curState != OMX_StateIdle) {
1211                pComponentPrivate->cbInfo.EventHandler ( pHandle,
1212                                                         pHandle->pApplicationPrivate,
1213                                                         OMX_EventError,
1214                                                         OMX_ErrorIncorrectStateTransition,
1215                                                         OMX_TI_ErrorMinor,
1216                                                         "Incorrect State Transition");
1217                OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error: OMX_ErrorIncorrectStateTransition Given by Comp\n",__LINE__);
1218                goto EXIT;
1219            }
1220#ifdef __PERF_INSTRUMENTATION__
1221                PERF_Boundary(pComponentPrivate->pPERFcomp,PERF_BoundaryComplete | PERF_BoundarySteadyState);
1222#endif
1223            eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1224                                        EMMCodecControlPause, (void *)p);
1225            if (eError != OMX_ErrorNone) {
1226                OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error: LCML_ControlCodec EMMCodecControlPause = %x\n",__LINE__,eError);
1227                goto EXIT;
1228            }
1229            OMX_PRSTATE1(pComponentPrivate->dbg, "%d :: Comp: OMX_CommandStateSet Given by Comp\n",__LINE__);
1230            break;
1231
1232        case OMX_StateWaitForResources:
1233            if (pComponentPrivate->curState == commandedState) {
1234                pComponentPrivate->cbInfo.EventHandler ( pHandle,
1235                                                         pHandle->pApplicationPrivate,
1236                                                         OMX_EventError,
1237                                                         OMX_ErrorSameState,
1238                                                         OMX_TI_ErrorMinor,
1239                                                         "Same State");
1240                OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error: OMX_ErrorSameState Given by Comp\n",__LINE__);
1241            } else if (pComponentPrivate->curState == OMX_StateLoaded) {
1242
1243#ifdef RESOURCE_MANAGER_ENABLED
1244            rm_error = RMProxy_NewSendCommand(pHandle, RMProxy_StateSet, OMX_NBAMR_Encoder_COMPONENT, OMX_StateWaitForResources, 3456, NULL);
1245#endif
1246
1247                pComponentPrivate->curState = OMX_StateWaitForResources;
1248                pComponentPrivate->cbInfo.EventHandler( pHandle,
1249                                                        pHandle->pApplicationPrivate,
1250                                                        OMX_EventCmdComplete,
1251                                                        OMX_CommandStateSet,
1252                                                        pComponentPrivate->curState,
1253                                                        NULL);
1254                OMX_PRINT2(pComponentPrivate->dbg, "%d :: Comp: OMX_CommandStateSet Given by Comp\n",__LINE__);
1255            } else {
1256                pComponentPrivate->cbInfo.EventHandler( pHandle,
1257                                                        pHandle->pApplicationPrivate,
1258                                                        OMX_EventError,
1259                                                        OMX_ErrorIncorrectStateTransition,
1260                                                        OMX_TI_ErrorMinor,
1261                                                        "Incorrect State Transition");
1262                OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error: OMX_ErrorIncorrectStateTransition Given by Comp\n",__LINE__);
1263            }
1264            break;
1265
1266        case OMX_StateInvalid:
1267            if (pComponentPrivate->curState == commandedState) {
1268                pComponentPrivate->cbInfo.EventHandler ( pHandle,
1269                                                         pHandle->pApplicationPrivate,
1270                                                         OMX_EventError,
1271                                                         OMX_ErrorSameState,
1272                                                         OMX_TI_ErrorSevere,
1273                                                         "Same State");
1274                OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error: OMX_ErrorSameState Given by Comp\n",__LINE__);
1275            }
1276            else {
1277                OMX_PRSTATE2(pComponentPrivate->dbg, "%d: HandleCommand: Cmd OMX_StateInvalid:\n",__LINE__);
1278                if (pComponentPrivate->curState != OMX_StateWaitForResources &&
1279                    pComponentPrivate->curState != OMX_StateInvalid &&
1280                    pComponentPrivate->curState != OMX_StateLoaded) {
1281
1282                    eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1283                                                EMMCodecControlDestroy, (void *)pArgs);
1284                }
1285                pComponentPrivate->curState = OMX_StateInvalid;
1286                pComponentPrivate->cbInfo.EventHandler( pHandle,
1287                                                    pHandle->pApplicationPrivate,
1288                                                    OMX_EventError,
1289                                                    OMX_ErrorInvalidState,
1290                                                    OMX_TI_ErrorSevere,
1291                                                    "Incorrect State Transition");
1292
1293                OMX_ERROR4(pComponentPrivate->dbg, "%d :: Comp: OMX_ErrorInvalidState Given by Comp\n",__LINE__);
1294                NBAMRENC_CleanupInitParams(pHandle);
1295            }
1296            break;
1297
1298        case OMX_StateMax:
1299            OMX_PRSTATE2(pComponentPrivate->dbg, "%d :: NBAMRENC_HandleCommand :: Cmd OMX_StateMax\n",__LINE__);
1300            break;
1301        } /* End of Switch */
1302    } else if (command == OMX_CommandMarkBuffer) {
1303        OMX_PRSTATE2(pComponentPrivate->dbg, "%d :: command OMX_CommandMarkBuffer received\n",__LINE__);
1304        if(!pComponentPrivate->pMarkBuf){
1305            /* TODO Need to handle multiple marks */
1306            pComponentPrivate->pMarkBuf = (OMX_MARKTYPE *)(commandData);
1307        }
1308    } else if (command == OMX_CommandPortDisable) {
1309        if (!pComponentPrivate->bDisableCommandPending) {
1310            OMX_PRINT2(pComponentPrivate->dbg, "I'm here Line %d\n",__LINE__);
1311            if(commandData == 0x0 || commandData == -1){
1312                pComponentPrivate->pPortDef[NBAMRENC_INPUT_PORT]->bEnabled = OMX_FALSE;
1313            }
1314            if(commandData == 0x1 || commandData == -1){
1315                char *pArgs = "damedesuStr";
1316
1317                pComponentPrivate->pPortDef[NBAMRENC_OUTPUT_PORT]->bEnabled = OMX_FALSE;
1318                if (pComponentPrivate->curState == OMX_StateExecuting) {
1319                    pComponentPrivate->bNoIdleOnStop = OMX_TRUE;
1320                    pComponentPrivate->bIsStopping = 1;
1321                    if (pComponentPrivate->codecStop_waitingsignal == 0){
1322                        pthread_mutex_lock(&pComponentPrivate->codecStop_mutex);
1323                    }
1324                    eError = LCML_ControlCodec(
1325                                  ((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1326                                  MMCodecControlStop,(void *)pArgs);
1327                    if (pComponentPrivate->codecStop_waitingsignal == 0){
1328                        pthread_cond_wait(&pComponentPrivate->codecStop_threshold, &pComponentPrivate->codecStop_mutex);
1329                        pComponentPrivate->codecStop_waitingsignal = 0;
1330                        pthread_mutex_unlock(&pComponentPrivate->codecStop_mutex);
1331                    }
1332
1333                }
1334            }
1335        }
1336
1337        OMX_PRCOMM2(pComponentPrivate->dbg, "commandData = %d\n",(int)commandData);
1338        OMX_PRCOMM2(pComponentPrivate->dbg, "pComponentPrivate->pPortDef[NBAMRENC_INPUT_PORT]->bPopulated = %d\n",pComponentPrivate->pPortDef[NBAMRENC_INPUT_PORT]->bPopulated);
1339        OMX_PRCOMM2(pComponentPrivate->dbg, "pComponentPrivate->pPortDef[NBAMRENC_OUTPUT_PORT]->bPopulated = %d\n",pComponentPrivate->pPortDef[NBAMRENC_OUTPUT_PORT]->bPopulated);
1340
1341        if(commandData == 0x0) {
1342            if(!pComponentPrivate->pPortDef[NBAMRENC_INPUT_PORT]->bPopulated){
1343                /* return cmdcomplete event if input unpopulated */
1344                pComponentPrivate->cbInfo.EventHandler(
1345                     pHandle, pHandle->pApplicationPrivate,
1346                     OMX_EventCmdComplete, OMX_CommandPortDisable,NBAMRENC_INPUT_PORT, NULL);
1347                pComponentPrivate->bDisableCommandPending = 0;
1348            }
1349            else{
1350                pComponentPrivate->bDisableCommandPending = 1;
1351                pComponentPrivate->bDisableCommandParam = commandData;
1352            }
1353        }
1354
1355        if(commandData == 0x1) {
1356            if (!pComponentPrivate->pPortDef[NBAMRENC_OUTPUT_PORT]->bPopulated){
1357                /* return cmdcomplete event if output unpopulated */
1358                pComponentPrivate->cbInfo.EventHandler(
1359                    pHandle, pHandle->pApplicationPrivate,
1360                    OMX_EventCmdComplete, OMX_CommandPortDisable,NBAMRENC_OUTPUT_PORT, NULL);
1361                pComponentPrivate->bDisableCommandPending = 0;
1362            }
1363            else {
1364                pComponentPrivate->bDisableCommandPending = 1;
1365                pComponentPrivate->bDisableCommandParam = commandData;
1366            }
1367        }
1368
1369        if(commandData == -1) {
1370            if (!pComponentPrivate->pPortDef[NBAMRENC_INPUT_PORT]->bPopulated &&
1371                !pComponentPrivate->pPortDef[NBAMRENC_OUTPUT_PORT]->bPopulated){
1372
1373                /* return cmdcomplete event if inout & output unpopulated */
1374                pComponentPrivate->cbInfo.EventHandler(
1375                     pHandle, pHandle->pApplicationPrivate,
1376                     OMX_EventCmdComplete, OMX_CommandPortDisable,NBAMRENC_INPUT_PORT, NULL);
1377
1378                pComponentPrivate->cbInfo.EventHandler(
1379                     pHandle, pHandle->pApplicationPrivate,
1380                     OMX_EventCmdComplete, OMX_CommandPortDisable,NBAMRENC_OUTPUT_PORT, NULL);
1381                pComponentPrivate->bDisableCommandPending = 0;
1382            }
1383            else {
1384                pComponentPrivate->bDisableCommandPending = 1;
1385                pComponentPrivate->bDisableCommandParam = commandData;
1386            }
1387        }
1388#ifndef UNDER_CE
1389        sched_yield();
1390#endif
1391    }
1392    else if (command == OMX_CommandPortEnable) {
1393        if(!pComponentPrivate->bEnableCommandPending) {
1394            if(commandData == 0x0 || commandData == -1){
1395                /* enable in port */
1396                OMX_PRCOMM2(pComponentPrivate->dbg, "setting input port to enabled\n");
1397                pComponentPrivate->pPortDef[NBAMRENC_INPUT_PORT]->bEnabled = OMX_TRUE;
1398                if(pComponentPrivate->AlloBuf_waitingsignal)
1399                {
1400                     pComponentPrivate->AlloBuf_waitingsignal = 0;
1401
1402                }
1403                OMX_PRCOMM2(pComponentPrivate->dbg, "pComponentPrivate->pPortDef[NBAMRENC_INPUT_PORT]->bEnabled = %d\n",pComponentPrivate->pPortDef[NBAMRENC_INPUT_PORT]->bEnabled);
1404            }
1405            if(commandData == 0x1 || commandData == -1){
1406                char *pArgs = "damedesuStr";
1407                /* enable out port */
1408                if(pComponentPrivate->AlloBuf_waitingsignal)
1409                {
1410                     pComponentPrivate->AlloBuf_waitingsignal = 0;
1411#ifndef UNDER_CE
1412                     pthread_mutex_lock(&pComponentPrivate->AlloBuf_mutex);
1413                     pthread_cond_signal(&pComponentPrivate->AlloBuf_threshold);
1414                     pthread_mutex_unlock(&pComponentPrivate->AlloBuf_mutex);
1415#else
1416                     OMX_SignalEvent(&(pComponentPrivate->AlloBuf_event));
1417#endif
1418                }
1419                if (pComponentPrivate->curState == OMX_StateExecuting) {
1420                    pComponentPrivate->bDspStoppedWhileExecuting = OMX_FALSE;
1421                    eError = LCML_ControlCodec(
1422                                          ((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1423                                          EMMCodecControlStart,(void *)pArgs);
1424                }
1425                OMX_PRCOMM2(pComponentPrivate->dbg, "setting output port to enabled\n");
1426                pComponentPrivate->pPortDef[NBAMRENC_OUTPUT_PORT]->bEnabled = OMX_TRUE;
1427                OMX_PRCOMM2(pComponentPrivate->dbg, "pComponentPrivate->pPortDef[NBAMRENC_OUTPUT_PORT]->bEnabled = %d\n",pComponentPrivate->pPortDef[NBAMRENC_OUTPUT_PORT]->bEnabled);
1428            }
1429        }
1430          if(commandData == 0x0 ){
1431                if (pComponentPrivate->curState == OMX_StateLoaded || pComponentPrivate->pPortDef[NBAMRENC_INPUT_PORT]->bPopulated){
1432                pComponentPrivate->cbInfo.EventHandler(
1433                     pHandle, pHandle->pApplicationPrivate,
1434                     OMX_EventCmdComplete, OMX_CommandPortEnable,NBAMRENC_INPUT_PORT, NULL);
1435                     pComponentPrivate->bEnableCommandPending = 0;
1436                    }
1437                else{
1438                    pComponentPrivate->bEnableCommandPending = 1;
1439                    pComponentPrivate->bEnableCommandParam = commandData;
1440                }
1441              }
1442            else if(commandData == 0x1){
1443                if (pComponentPrivate->curState == OMX_StateLoaded || pComponentPrivate->pPortDef[NBAMRENC_OUTPUT_PORT]->bPopulated){
1444                pComponentPrivate->cbInfo.EventHandler(
1445                     pHandle, pHandle->pApplicationPrivate,
1446                     OMX_EventCmdComplete, OMX_CommandPortEnable,NBAMRENC_OUTPUT_PORT, NULL);
1447                     pComponentPrivate->bEnableCommandPending = 0;
1448                }
1449                else{
1450                     pComponentPrivate->bEnableCommandPending = 1;
1451                     pComponentPrivate->bEnableCommandParam = commandData;
1452                }
1453            }
1454            else if(commandData == -1){
1455                if(pComponentPrivate->curState == OMX_StateLoaded || (pComponentPrivate->pPortDef[NBAMRENC_INPUT_PORT]->bPopulated
1456                    && pComponentPrivate->pPortDef[NBAMRENC_OUTPUT_PORT]->bPopulated)){
1457                    pComponentPrivate->cbInfo.EventHandler(
1458                     pHandle, pHandle->pApplicationPrivate,
1459                     OMX_EventCmdComplete, OMX_CommandPortEnable,NBAMRENC_INPUT_PORT, NULL);
1460
1461                    pComponentPrivate->cbInfo.EventHandler(
1462                     pHandle, pHandle->pApplicationPrivate,
1463                     OMX_EventCmdComplete, OMX_CommandPortEnable,NBAMRENC_OUTPUT_PORT, NULL);
1464
1465                    pComponentPrivate->bEnableCommandPending = 0;
1466                    NBAMRENC_FillLCMLInitParamsEx(pComponentPrivate->pHandle);
1467                }
1468                else {
1469                    pComponentPrivate->bEnableCommandPending = 1;
1470                    pComponentPrivate->bEnableCommandParam = commandData;
1471                }
1472            }
1473#ifndef UNDER_CE
1474                    pthread_mutex_lock(&pComponentPrivate->AlloBuf_mutex);
1475                    pthread_cond_signal(&pComponentPrivate->AlloBuf_threshold);
1476                    pthread_mutex_unlock(&pComponentPrivate->AlloBuf_mutex);
1477#else
1478                    OMX_SignalEvent(&(pComponentPrivate->AlloBuf_event));
1479#endif
1480
1481    } else if (command == OMX_CommandFlush) {
1482          if(commandData == 0x0 || commandData == -1){/*input*/
1483                    OMX_PRCOMM2(pComponentPrivate->dbg, "Flushing input port %d\n",__LINE__);
1484                    for (i=0; i < NBAMRENC_MAX_NUM_OF_BUFS; i++) {
1485                        pComponentPrivate->pInputBufHdrPending[i] = NULL;
1486                    }
1487                    pComponentPrivate->nNumInputBufPending=0;
1488
1489            for (i=0; i < pComponentPrivate->pInputBufferList->numBuffers; i++) {
1490
1491
1492#ifdef __PERF_INSTRUMENTATION__
1493                            PERF_SendingFrame(pComponentPrivate->pPERFcomp,
1494                                              pComponentPrivate->pInputBufferList->pBufHdr[i]->pBuffer,
1495                                              0,
1496                                              PERF_ModuleHLMM);
1497#endif
1498                       pComponentPrivate->cbInfo.EmptyBufferDone (
1499                                       pComponentPrivate->pHandle,
1500                                       pComponentPrivate->pHandle->pApplicationPrivate,
1501                                       pComponentPrivate->pInputBufferList->pBufHdr[i]
1502                                       );
1503                    pComponentPrivate->nEmptyBufferDoneCount++;
1504                    pComponentPrivate->nOutStandingEmptyDones--;
1505
1506                    }
1507                    pComponentPrivate->cbInfo.EventHandler(
1508                         pHandle, pHandle->pApplicationPrivate,
1509                         OMX_EventCmdComplete, OMX_CommandFlush,NBAMRENC_INPUT_PORT, NULL);
1510          }
1511
1512          if(commandData == 0x1 || commandData == -1){/*output*/
1513                     for (i=0; i < NBAMRENC_MAX_NUM_OF_BUFS; i++) {
1514                        pComponentPrivate->pOutputBufHdrPending[i] = NULL;
1515                    }
1516                    pComponentPrivate->nNumOutputBufPending=0;
1517
1518                    for (i=0; i < pComponentPrivate->pOutputBufferList->numBuffers; i++) {
1519#ifdef __PERF_INSTRUMENTATION__
1520                    PERF_SendingFrame(pComponentPrivate->pPERFcomp,
1521                                      pComponentPrivate->pOutputBufferList->pBufHdr[i]->pBuffer,
1522                                      pComponentPrivate->pOutputBufferList->pBufHdr[i]->nFilledLen,
1523                                      PERF_ModuleHLMM);
1524#endif
1525                       pComponentPrivate->cbInfo.FillBufferDone (
1526                                       pComponentPrivate->pHandle,
1527                                       pComponentPrivate->pHandle->pApplicationPrivate,
1528                                       pComponentPrivate->pOutputBufferList->pBufHdr[i]
1529                                       );
1530                        pComponentPrivate->nFillBufferDoneCount++;
1531                        pComponentPrivate->nOutStandingFillDones--;
1532
1533                    }
1534                     pComponentPrivate->cbInfo.EventHandler(
1535                             pHandle, pHandle->pApplicationPrivate,
1536                             OMX_EventCmdComplete, OMX_CommandFlush,NBAMRENC_OUTPUT_PORT, NULL);
1537          }
1538    }
1539
1540EXIT:
1541    OMX_PRINT1(pComponentPrivate->dbg, "%d :: Exiting NBAMRENC_HandleCommand Function\n",__LINE__);
1542    OMX_PRINT1(pComponentPrivate->dbg, "%d :: Returning = 0x%x\n",__LINE__,eError);
1543    if (eError != OMX_ErrorNone && eError != NBAMRENC_EXIT_COMPONENT_THRD) {
1544        pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
1545                                               pComponentPrivate->pHandle->pApplicationPrivate,
1546                                               OMX_EventError,
1547                                               eError,
1548                                               OMX_TI_ErrorSevere,
1549                                               NULL);
1550    }
1551    return eError;
1552}
1553
1554/* ========================================================================== */
1555/**
1556* @NBAMRENC_HandleDataBufFromApp() This function is called by the component when ever it
1557* receives the buffer from the application
1558*
1559* @param pComponentPrivate  Component private data
1560* @param pBufHeader Buffer from the application
1561*
1562* @pre
1563*
1564* @post
1565*
1566* @return none
1567*/
1568/* ========================================================================== */
1569OMX_ERRORTYPE NBAMRENC_HandleDataBufFromApp(OMX_BUFFERHEADERTYPE* pBufHeader,
1570                                    AMRENC_COMPONENT_PRIVATE *pComponentPrivate)
1571{
1572    OMX_ERRORTYPE eError = OMX_ErrorNone;
1573    OMX_DIRTYPE eDir;
1574    NBAMRENC_LCML_BUFHEADERTYPE *pLcmlHdr = NULL;
1575    LCML_DSP_INTERFACE *pLcmlHandle = (LCML_DSP_INTERFACE *)
1576                                              pComponentPrivate->pLcmlHandle;
1577    OMX_U32 frameLength, remainingBytes;
1578    OMX_U8* pExtraData = NULL;
1579    OMX_U8 nFrames=0,i;
1580    LCML_DSP_INTERFACE * phandle = NULL;
1581
1582    OMX_PRINT1(pComponentPrivate->dbg, "%d :: Entering NBAMRENC_HandleDataBufFromApp Function\n",__LINE__);
1583    /*Find the direction of the received buffer from buffer list */
1584        eError = NBAMRENC_GetBufferDirection(pBufHeader, &eDir);
1585        if (eError != OMX_ErrorNone) {
1586                OMX_ERROR4(pComponentPrivate->dbg, "%d :: The pBufHeader is not found in the list\n", __LINE__);
1587                goto EXIT;
1588        }
1589
1590    if (eDir == OMX_DirInput) {
1591                pComponentPrivate->nEmptyThisBufferCount++;
1592                pComponentPrivate->nUnhandledEmptyThisBuffers--;
1593                if  (pBufHeader->nFilledLen > 0) {
1594                        if (pComponentPrivate->nHoldLength == 0) {
1595                                frameLength = NBAMRENC_INPUT_FRAME_SIZE;
1596                                nFrames = (OMX_U8)(pBufHeader->nFilledLen / frameLength);
1597                                if ( nFrames>=1 ) { /*At least there is 1 frame in the buffer*/
1598                                        pComponentPrivate->nHoldLength = pBufHeader->nFilledLen - frameLength*nFrames;
1599                                        if (pComponentPrivate->nHoldLength > 0) {/* something need to be hold in pHoldBuffer */
1600                                                if (pComponentPrivate->pHoldBuffer == NULL) {
1601                                                   OMX_MALLOC_SIZE(pComponentPrivate->pHoldBuffer, NBAMRENC_INPUT_FRAME_SIZE,OMX_U8);
1602                                                }
1603
1604                                                /* Copy the extra data into pHoldBuffer. Size will be nHoldLength. */
1605                                                pExtraData = pBufHeader->pBuffer + frameLength*nFrames;
1606
1607                        if(pComponentPrivate->nHoldLength <= NBAMRENC_INPUT_FRAME_SIZE) {
1608                            memcpy(pComponentPrivate->pHoldBuffer, pExtraData,  pComponentPrivate->nHoldLength);
1609                        }
1610                        else {
1611                            OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error: pHoldLenght is bigger than the input frame size\n", __LINE__);
1612                                    goto EXIT;
1613                        }
1614
1615                                                pBufHeader->nFilledLen-=pComponentPrivate->nHoldLength;
1616                                        }
1617                                }
1618                                else {
1619                                        if( !pComponentPrivate->InBuf_Eos_alreadysent ){
1620                                                /* received buffer with less than 1 AMR frame length. Save the data in pHoldBuffer.*/
1621                                                pComponentPrivate->nHoldLength = pBufHeader->nFilledLen;
1622                                                /* save the data into pHoldBuffer */
1623                                                if (pComponentPrivate->pHoldBuffer == NULL) {
1624                                                    OMX_MALLOC_SIZE(pComponentPrivate->pHoldBuffer, NBAMRENC_INPUT_FRAME_SIZE,OMX_U8);
1625                                                }
1626
1627                                                if(pComponentPrivate->nHoldLength <= NBAMRENC_INPUT_FRAME_SIZE) {
1628                                                    memcpy(pComponentPrivate->pHoldBuffer, pBufHeader->pBuffer, pComponentPrivate->nHoldLength);
1629                                                }
1630                                                else {
1631                                                    OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error: pHoldLenght is bigger than the input frame size\n", __LINE__);
1632                                                    goto EXIT;
1633                                                }
1634                                        }
1635                                        /* since not enough data, we shouldn't send anything to SN, but instead request to EmptyBufferDone again.*/
1636                                        if (pComponentPrivate->curState != OMX_StatePause ) {
1637                                                OMX_PRBUFFER2(pComponentPrivate->dbg, "%d :: Calling EmptyBufferDone\n",__LINE__);
1638
1639#ifdef __PERF_INSTRUMENTATION__
1640                            PERF_SendingFrame(pComponentPrivate->pPERFcomp,
1641                                              pBufHeader->pBuffer,
1642                                              0,
1643                                              PERF_ModuleHLMM);
1644#endif
1645
1646                                              pComponentPrivate->cbInfo.EmptyBufferDone( pComponentPrivate->pHandle,
1647                                                                                                                pComponentPrivate->pHandle->pApplicationPrivate,
1648                                                                                                                pBufHeader);
1649                                              pComponentPrivate->nEmptyBufferDoneCount++;
1650
1651                                        }
1652                                        else {
1653                                                pComponentPrivate->pInputBufHdrPending[pComponentPrivate->nNumInputBufPending++] = pBufHeader;
1654                                        }
1655
1656                                        pComponentPrivate->ProcessingInputBuf--;
1657                                        goto EXIT;
1658
1659                                }
1660                        }
1661                        else {
1662                                if((pComponentPrivate->nHoldLength+pBufHeader->nFilledLen) > pBufHeader->nAllocLen){
1663                                        /*means that a second Acumulator must be used to insert holdbuffer to pbuffer and save remaining bytes
1664                                                     into hold buffer*/
1665                                        remainingBytes = pComponentPrivate->nHoldLength+pBufHeader->nFilledLen-pBufHeader->nAllocLen;
1666                                        if (pComponentPrivate->pHoldBuffer2 == NULL) {
1667                                                        OMX_MALLOC_SIZE(pComponentPrivate->pHoldBuffer2, NBAMRENC_INPUT_FRAME_SIZE,OMX_U8);
1668                                        }
1669                                        pExtraData = (pBufHeader->pBuffer)+(pBufHeader->nFilledLen-remainingBytes);
1670                                        memcpy(pComponentPrivate->pHoldBuffer2,pExtraData,remainingBytes);
1671                                        pBufHeader->nFilledLen-=remainingBytes;
1672                                        memmove(pBufHeader->pBuffer+ pComponentPrivate->nHoldLength,pBufHeader->pBuffer,pBufHeader->nFilledLen);
1673                                        memcpy(pBufHeader->pBuffer,pComponentPrivate->pHoldBuffer,pComponentPrivate->nHoldLength);
1674                                        pBufHeader->nFilledLen+=pComponentPrivate->nHoldLength;
1675                                        memcpy(pComponentPrivate->pHoldBuffer, pComponentPrivate->pHoldBuffer2, remainingBytes);
1676                                        pComponentPrivate->nHoldLength=remainingBytes;
1677                                }
1678                                else{
1679                                        memmove(pBufHeader->pBuffer+pComponentPrivate->nHoldLength, pBufHeader->pBuffer, pBufHeader->nFilledLen);
1680                                        memcpy(pBufHeader->pBuffer,pComponentPrivate->pHoldBuffer, pComponentPrivate->nHoldLength);
1681                                        pBufHeader->nFilledLen+=pComponentPrivate->nHoldLength;
1682                                        pComponentPrivate->nHoldLength=0;
1683                                }
1684                                frameLength = NBAMRENC_INPUT_FRAME_SIZE;
1685                                nFrames = (OMX_U8)(pBufHeader->nFilledLen / frameLength);
1686                                pComponentPrivate->nHoldLength = pBufHeader->nFilledLen - frameLength*nFrames;
1687                                pExtraData = pBufHeader->pBuffer + pBufHeader->nFilledLen-pComponentPrivate->nHoldLength;
1688                                memcpy(pComponentPrivate->pHoldBuffer, pExtraData,  pComponentPrivate->nHoldLength);
1689                                pBufHeader->nFilledLen-=pComponentPrivate->nHoldLength;
1690                                if(nFrames < 1 ){
1691                                        if (pComponentPrivate->curState != OMX_StatePause ) {
1692                                                OMX_PRBUFFER2(pComponentPrivate->dbg, "line %d:: Calling EmptyBufferDone\n",__LINE__);
1693
1694#ifdef __PERF_INSTRUMENTATION__
1695                                                        PERF_SendingFrame(pComponentPrivate->pPERFcomp,
1696                                                                        pBufHeader->pBuffer,
1697                                                                        0,
1698                                                                        PERF_ModuleHLMM);
1699#endif
1700
1701                                                pComponentPrivate->cbInfo.EmptyBufferDone( pComponentPrivate->pHandle,
1702                                                                                                                pComponentPrivate->pHandle->pApplicationPrivate,
1703                                                                                                                pBufHeader);
1704                                                pComponentPrivate->nEmptyBufferDoneCount++;
1705
1706                                        }
1707                                        else {
1708                                                pComponentPrivate->pInputBufHdrPending[pComponentPrivate->nNumInputBufPending++] = pBufHeader;
1709                                        }
1710                                        goto EXIT;
1711                                }
1712                        }
1713                }else{
1714                        if((pBufHeader->nFlags&OMX_BUFFERFLAG_EOS) != OMX_BUFFERFLAG_EOS){
1715                            if (pComponentPrivate->dasfMode == 0 && !pBufHeader->pMarkData) {
1716#ifdef __PERF_INSTRUMENTATION__
1717                                PERF_SendingFrame(pComponentPrivate->pPERFcomp,
1718                                              pComponentPrivate->pInputBufferList->pBufHdr[0]->pBuffer,
1719                                              0,
1720                                              PERF_ModuleHLMM);
1721#endif
1722
1723                                pComponentPrivate->cbInfo.EmptyBufferDone( pComponentPrivate->pHandle,
1724                                                                                pComponentPrivate->pHandle->pApplicationPrivate,
1725                                                                                pComponentPrivate->pInputBufferList->pBufHdr[0]);
1726                                pComponentPrivate->nEmptyBufferDoneCount++;
1727                                pComponentPrivate->ProcessingInputBuf--;
1728
1729                                }
1730                        }
1731                        else{
1732               frameLength = NBAMRENC_INPUT_FRAME_SIZE;
1733                            nFrames=1;
1734                            }
1735                }
1736                if(nFrames >= 1){
1737                eError = NBAMRENC_GetCorrespondingLCMLHeader(pComponentPrivate,pBufHeader->pBuffer, OMX_DirInput, &pLcmlHdr);
1738                if (eError != OMX_ErrorNone) {
1739                        OMX_ERROR4(pComponentPrivate->dbg, "%d :: Error: Invalid Buffer Came ...\n",__LINE__);
1740                        goto EXIT;
1741                }
1742
1743#ifdef __PERF_INSTRUMENTATION__
1744    /*For Steady State Instumentation*/
1745    PERF_SendingFrame(pComponentPrivate->pPERFcomp,
1746                      PREF(pBufHeader,pBuffer),
1747                      pComponentPrivate->pPortDef[OMX_DirInput]->nBufferSize,
1748                      PERF_ModuleCommonLayer);
1749#endif
1750
1751/*---------------------------------------------------------------*/
1752
1753                pComponentPrivate->nNumOfFramesSent = nFrames;
1754
1755                phandle = (LCML_DSP_INTERFACE *)(((LCML_CODEC_INTERFACE *)pLcmlHandle->pCodecinterfacehandle)->pCodec);
1756
1757                if( (pLcmlHdr->pBufferParam->usNbFrames < nFrames) && (pLcmlHdr->pFrameParam!=NULL) ){
1758                        OMX_MEMFREE_STRUCT_DSPALIGN(pLcmlHdr->pFrameParam, NBAMRENC_FrameStruct);
1759                        OMX_DmmUnMap(phandle->dspCodec->hProc, /*Unmap DSP memory used*/
1760                                   (void*)pLcmlHdr->pBufferParam->pParamElem,
1761                                   pLcmlHdr->pDmmBuf->pReserved, pComponentPrivate->dbg);
1762                        pLcmlHdr->pBufferParam->pParamElem = NULL;
1763                }
1764
1765                if(pLcmlHdr->pFrameParam==NULL ){
1766                        OMX_MALLOC_SIZE_DSPALIGN(pLcmlHdr->pFrameParam, (sizeof(NBAMRENC_FrameStruct)*nFrames),OMX_U8);
1767                        eError = OMX_DmmMap(phandle->dspCodec->hProc,
1768                                        nFrames*sizeof(NBAMRENC_FrameStruct),
1769                                        (void*)pLcmlHdr->pFrameParam,
1770                                        (pLcmlHdr->pDmmBuf), pComponentPrivate->dbg);
1771                        if (eError != OMX_ErrorNone){
1772                                OMX_ERROR4(pComponentPrivate->dbg, "OMX_DmmMap ERRROR!!!!\n\n");
1773                                goto EXIT;
1774                        }
1775                        pLcmlHdr->pBufferParam->pParamElem = (NBAMRENC_FrameStruct *)pLcmlHdr->pDmmBuf->pMapped; /*DSP Address*/
1776                }
1777
1778                for(i=0;i<nFrames;i++){
1779                        (pLcmlHdr->pFrameParam+i)->usLastFrame = 0;
1780                }
1781
1782                if((pBufHeader->nFlags & OMX_BUFFERFLAG_EOS)  == OMX_BUFFERFLAG_EOS) {
1783                        (pLcmlHdr->pFrameParam+(nFrames-1))->usLastFrame = OMX_BUFFERFLAG_EOS;
1784                        pComponentPrivate->InBuf_Eos_alreadysent = 1; /*TRUE*/
1785                        if(pComponentPrivate->dasfMode == 0) {
1786                               if(!pBufHeader->nFilledLen){
1787                                     pComponentPrivate->pOutputBufferList->pBufHdr[0]->nFlags |= OMX_BUFFERFLAG_EOS;
1788                               }
1789                                pComponentPrivate->cbInfo.EventHandler( pComponentPrivate->pHandle,
1790                                                                                        pComponentPrivate->pHandle->pApplicationPrivate,
1791                                                                                        OMX_EventBufferFlag,
1792                                                                                        pComponentPrivate->pOutputBufferList->pBufHdr[0]->nOutputPortIndex,
1793                                                                                        pComponentPrivate->pOutputBufferList->pBufHdr[0]->nFlags, NULL);
1794                        }
1795                        pBufHeader->nFlags = 0;
1796                }
1797                pLcmlHdr->pBufferParam->usNbFrames = nFrames;
1798/*---------------------------------------------------------------*/
1799            /* Store time stamp information */
1800                /*pComponentPrivate->arrBufIndex[pComponentPrivate->IpBufindex] = pBufHeader->nTimeStamp;*/
1801                if (!pComponentPrivate->bFirstInputBufReceived) {
1802                    /* Reset TimeStamp when first input buffer received */
1803                    pComponentPrivate->TimeStamp = 0;
1804                    /* First Input buffer received */
1805                    pComponentPrivate->bFirstInputBufReceived = OMX_TRUE;
1806                }
1807            /* Store nTickCount information */
1808                        pComponentPrivate->arrTickCount[pComponentPrivate->IpBufindex] = pBufHeader->nTickCount;
1809                        pComponentPrivate->IpBufindex++;
1810                        pComponentPrivate->IpBufindex %= pComponentPrivate->pPortDef[OMX_DirOutput]->nBufferCountActual;
1811
1812                        if (pComponentPrivate->curState == OMX_StateExecuting) {
1813                                if(!pComponentPrivate->bDspStoppedWhileExecuting)
1814                                {
1815                                        if (!NBAMRENC_IsPending(pComponentPrivate,pBufHeader,OMX_DirInput)) {
1816                                                NBAMRENC_SetPending(pComponentPrivate,pBufHeader,OMX_DirInput,__LINE__);
1817/*              if (pLcmlHdr->buffer->nFilledLen != 0)
1818                    fwrite(pLcmlHdr->buffer->pBuffer, 1, pLcmlHdr->buffer->nFilledLen, fOut);
1819*/
1820                /* fflush(fOut); */
1821
1822/*
1823                fclose(fOut);
1824*/
1825
1826                                                eError = LCML_QueueBuffer( pLcmlHandle->pCodecinterfacehandle,
1827                                                                                                EMMCodecInputBuffer,
1828                                                                                                (OMX_U8 *)pBufHeader->pBuffer,
1829                                                                                                pBufHeader->nAllocLen,
1830                                                                                                pBufHeader->nFilledLen,
1831                                                                                                (OMX_U8 *) pLcmlHdr->pBufferParam,
1832                                                                                                sizeof(NBAMRENC_ParamStruct),
1833                                                                                                NULL);
1834                                                if (eError != OMX_ErrorNone) {
1835                                                        eError = OMX_ErrorHardware;
1836                                                        goto EXIT;
1837                                                }
1838                                                pComponentPrivate->lcml_nIpBuf++;
1839                                        }
1840                                    }
1841                        }
1842                        else if(pComponentPrivate->curState == OMX_StatePause){
1843                                pComponentPrivate->pInputBufHdrPending[pComponentPrivate->nNumInputBufPending++] = pBufHeader;
1844                        }
1845                        pComponentPrivate->ProcessingInputBuf--;
1846          }
1847/******************************************************************************/
1848        if(pBufHeader->pMarkData){
1849                if(pComponentPrivate->pOutputBufferList->pBufHdr[0]!=NULL) {
1850                       /* copy mark to output buffer header */
1851                       pComponentPrivate->pOutputBufferList->pBufHdr[0]->pMarkData = pBufHeader->pMarkData;
1852                       pComponentPrivate->pOutputBufferList->pBufHdr[0]->hMarkTargetComponent = pBufHeader->hMarkTargetComponent;
1853                }
1854                /* trigger event handler if we are supposed to */
1855                if(pBufHeader->hMarkTargetComponent == pComponentPrivate->pHandle && pBufHeader->pMarkData){
1856                        pComponentPrivate->cbInfo.EventHandler( pComponentPrivate->pHandle,
1857                                                                                        pComponentPrivate->pHandle->pApplicationPrivate,
1858                                                                                        OMX_EventMark,
1859                                                                                        0,
1860                                                                                        0,
1861                                                                                        pBufHeader->pMarkData);
1862                }
1863                if (pComponentPrivate->curState != OMX_StatePause && !NBAMRENC_IsPending(pComponentPrivate,pBufHeader,OMX_DirInput)) {
1864                    OMX_PRBUFFER2(pComponentPrivate->dbg, "line %d:: Calling EmptyBufferDone\n",__LINE__);
1865
1866#ifdef __PERF_INSTRUMENTATION__
1867                            PERF_SendingFrame(pComponentPrivate->pPERFcomp,
1868                                            pBufHeader->pBuffer,
1869                                            0,
1870                                            PERF_ModuleHLMM);
1871#endif
1872
1873                    pComponentPrivate->cbInfo.EmptyBufferDone( pComponentPrivate->pHandle,
1874                                                                                    pComponentPrivate->pHandle->pApplicationPrivate,
1875                                                                                    pBufHeader);
1876                    pComponentPrivate->nEmptyBufferDoneCount++;
1877
1878                }
1879        }
1880
1881        if (pComponentPrivate->bFlushInputPortCommandPending) {
1882                OMX_SendCommand(pComponentPrivate->pHandle,OMX_CommandFlush,0,NULL);
1883            }
1884
1885    } else if (eDir == OMX_DirOutput) {
1886                /* Make sure that output buffer is issued to output stream only when
1887                * there is an outstanding input buffer already issued on input stream
1888                */
1889
1890/***--------------------------------------****/
1891     pComponentPrivate->nUnhandledFillThisBuffers--;
1892     nFrames = pComponentPrivate->nNumOfFramesSent;
1893     if(nFrames == 0)
1894           nFrames = 1;
1895
1896     eError = NBAMRENC_GetCorrespondingLCMLHeader(pComponentPrivate,pBufHeader->pBuffer, OMX_DirOutput, &pLcmlHdr);
1897
1898     phandle = (LCML_DSP_INTERFACE *)(((LCML_CODEC_INTERFACE *)pLcmlHandle->pCodecinterfacehandle)->pCodec);
1899
1900     if( (pLcmlHdr->pBufferParam->usNbFrames < nFrames) && (pLcmlHdr->pFrameParam!=NULL) ){
1901                   OMX_MEMFREE_STRUCT_DSPALIGN(pLcmlHdr->pFrameParam, NBAMRENC_FrameStruct);
1902#ifndef UNDER_CE
1903                   OMX_DmmUnMap(phandle->dspCodec->hProc,
1904                                   (void*)pLcmlHdr->pBufferParam->pParamElem,
1905                                   pLcmlHdr->pDmmBuf->pReserved, pComponentPrivate->dbg);
1906#endif
1907
1908                   pLcmlHdr->pBufferParam->pParamElem = NULL;
1909         }
1910
1911     if(pLcmlHdr->pFrameParam==NULL ){
1912                   OMX_MALLOC_SIZE_DSPALIGN(pLcmlHdr->pFrameParam, (sizeof(NBAMRENC_FrameStruct)*nFrames ),OMX_U8);
1913#ifndef UNDER_CE
1914                   eError = OMX_DmmMap(phandle->dspCodec->hProc,
1915                                       nFrames*sizeof(NBAMRENC_FrameStruct),
1916                                       (void*)pLcmlHdr->pFrameParam,
1917                                       (pLcmlHdr->pDmmBuf), pComponentPrivate->dbg);
1918
1919                   if (eError != OMX_ErrorNone)
1920                   {
1921                               OMX_ERROR4(pComponentPrivate->dbg, "OMX_DmmMap ERRROR!!!!\n");
1922                               goto EXIT;
1923                   }
1924                   pLcmlHdr->pBufferParam->pParamElem = (NBAMRENC_FrameStruct *)pLcmlHdr->pDmmBuf->pMapped; /*DSP Address*/
1925#endif
1926         }
1927
1928     pLcmlHdr->pBufferParam->usNbFrames = nFrames;
1929
1930                        if (pComponentPrivate->curState == OMX_StateExecuting) {
1931                                if (!NBAMRENC_IsPending(pComponentPrivate,pBufHeader,OMX_DirOutput)) {
1932                                                NBAMRENC_SetPending(pComponentPrivate,pBufHeader,OMX_DirOutput,__LINE__);
1933                                                eError = LCML_QueueBuffer( pLcmlHandle->pCodecinterfacehandle,
1934                                                                                                EMMCodecOuputBuffer,
1935                                                                                                (OMX_U8 *)pBufHeader->pBuffer,
1936                                                                                                NBAMRENC_OUTPUT_FRAME_SIZE * nFrames,
1937                                                                                                0,
1938                                                                                                (OMX_U8 *) pLcmlHdr->pBufferParam,
1939                                                                                                sizeof(NBAMRENC_ParamStruct),
1940                                                                                                NULL);
1941                                                OMX_PRBUFFER1(pComponentPrivate->dbg, "After QueueBuffer Line %d\n",__LINE__);
1942                                                if (eError != OMX_ErrorNone ) {
1943                                                        OMX_ERROR4(pComponentPrivate->dbg, "%d :: Issuing DSP OP: Error Occurred\n",__LINE__);
1944                                                        eError = OMX_ErrorHardware;
1945                                                        goto EXIT;
1946                                                }
1947                                                pComponentPrivate->lcml_nOpBuf++;
1948                                                pComponentPrivate->num_Op_Issued++;
1949                                        }
1950                                }
1951                        else  if (pComponentPrivate->curState == OMX_StatePause){
1952                                pComponentPrivate->pOutputBufHdrPending[pComponentPrivate->nNumOutputBufPending++] = pBufHeader;
1953                        }
1954                        pComponentPrivate->ProcessingOutputBuf--;
1955
1956                        if (pComponentPrivate->bFlushOutputPortCommandPending) {
1957                                  OMX_SendCommand( pComponentPrivate->pHandle,
1958                                  OMX_CommandFlush,
1959                                  1,NULL);
1960        }
1961
1962    }
1963    else {
1964        eError = OMX_ErrorBadParameter;
1965    }
1966
1967EXIT:
1968    OMX_PRINT1(pComponentPrivate->dbg, "%d :: Exiting from  NBAMRENC_HandleDataBufFromApp \n",__LINE__);
1969    OMX_PRINT1(pComponentPrivate->dbg, "%d :: Returning error %d\n",__LINE__,eError);
1970
1971    return eError;
1972}
1973
1974/*-------------------------------------------------------------------*/
1975/**
1976* NBAMRENC_GetBufferDirection () This function is used by the component
1977* to get the direction of the buffer
1978* @param eDir pointer will be updated with buffer direction
1979* @param pBufHeader pointer to the buffer to be requested to be filled
1980*
1981* @retval none
1982**/
1983/*-------------------------------------------------------------------*/
1984
1985OMX_ERRORTYPE NBAMRENC_GetBufferDirection(OMX_BUFFERHEADERTYPE *pBufHeader,
1986                                                         OMX_DIRTYPE *eDir)
1987{
1988    OMX_ERRORTYPE eError = OMX_ErrorNone;
1989    AMRENC_COMPONENT_PRIVATE *pComponentPrivate = pBufHeader->pPlatformPrivate;
1990    OMX_U32 nBuf = 0;
1991    OMX_BUFFERHEADERTYPE *pBuf = NULL;
1992    OMX_U16 flag = 1,i = 0;
1993    OMX_PRINT1(pComponentPrivate->dbg, "%d :: Entering NBAMRENC_GetBufferDirection Function\n",__LINE__);
1994    /*Search this buffer in input buffers list */
1995    nBuf = pComponentPrivate->pInputBufferList->numBuffers;
1996    for(i=0; i<nBuf; i++) {
1997        pBuf = pComponentPrivate->pInputBufferList->pBufHdr[i];
1998        if(pBufHeader == pBuf) {
1999            *eDir = OMX_DirInput;
2000            OMX_PRBUFFER2(pComponentPrivate->dbg, "%d :: pBufHeader = %p is INPUT BUFFER pBuf = %p\n",__LINE__,pBufHeader,pBuf);
2001            flag = 0;
2002            goto EXIT;
2003        }
2004    }
2005    /*Search this buffer in output buffers list */
2006    nBuf = pComponentPrivate->pOutputBufferList->numBuffers;
2007    for(i=0; i<nBuf; i++) {
2008        pBuf = pComponentPrivate->pOutputBufferList->pBufHdr[i];
2009        if(pBufHeader == pBuf) {
2010            *eDir = OMX_DirOutput;
2011            OMX_PRBUFFER2(pComponentPrivate->dbg, "%d :: pBufHeader = %p is OUTPUT BUFFER pBuf = %p\n",__LINE__,pBufHeader,pBuf);
2012            flag = 0;
2013            goto EXIT;
2014        }
2015    }
2016
2017    if (flag == 1) {
2018        OMX_ERROR4(pComponentPrivate->dbg, "%d :: Buffer %p is Not Found in the List\n",__LINE__, pBufHeader);
2019        eError = OMX_ErrorUndefined;
2020        goto EXIT;
2021    }
2022EXIT:
2023    OMX_PRINT1(pComponentPrivate->dbg, "%d :: Exiting NBAMRENC_GetBufferDirection Function\n",__LINE__);
2024    OMX_PRINT1(pComponentPrivate->dbg, "%d :: Returning = 0x%x\n",__LINE__,eError);
2025    return eError;
2026}
2027
2028/* -------------------------------------------------------------------*/
2029/**
2030  * NBAMRENC_GetCorrespondingLCMLHeader() function will be called by LCML_Callback
2031  * component to write the msg
2032  * @param *pBuffer,          Event which gives to details about USN status
2033  * @param NBAMRENC_LCML_BUFHEADERTYPE **ppLcmlHdr
2034  * @param  OMX_DIRTYPE eDir this gives direction of the buffer
2035  * @retval OMX_NoError              Success, ready to roll
2036  *         OMX_Error_BadParameter   The input parameter pointer is null
2037 **/
2038/* -------------------------------------------------------------------*/
2039OMX_ERRORTYPE NBAMRENC_GetCorrespondingLCMLHeader(AMRENC_COMPONENT_PRIVATE *pComponentPrivate,
2040                                                  OMX_U8 *pBuffer,
2041                                                  OMX_DIRTYPE eDir,
2042                                                  NBAMRENC_LCML_BUFHEADERTYPE **ppLcmlHdr)
2043{
2044    OMX_ERRORTYPE eError = OMX_ErrorNone;
2045    NBAMRENC_LCML_BUFHEADERTYPE *pLcmlBufHeader;
2046    OMX_S16 nIpBuf;
2047    OMX_S16 nOpBuf;
2048    OMX_S16 i;
2049
2050    AMRENC_COMPONENT_PRIVATE *pComponentPrivate_CC;
2051
2052    pComponentPrivate_CC = (AMRENC_COMPONENT_PRIVATE*) pComponentPrivate;
2053    nIpBuf = pComponentPrivate_CC->pInputBufferList->numBuffers;
2054    nOpBuf = pComponentPrivate_CC->pOutputBufferList->numBuffers;
2055
2056    OMX_PRINT1(pComponentPrivate_CC->dbg, "%d :: Entering NBAMRENC_GetCorrespondingLCMLHeader..\n",__LINE__);
2057    while (!pComponentPrivate_CC->bInitParamsInitialized) {
2058        OMX_PRSTATE2(pComponentPrivate_CC->dbg, "%d :: Waiting for init to complete........\n",__LINE__);
2059#ifndef UNDER_CE
2060        sched_yield();
2061#else
2062        Sleep(1);
2063#endif
2064    }
2065    if(eDir == OMX_DirInput) {
2066        OMX_PRINT2(pComponentPrivate_CC->dbg, "%d :: Entering NBAMRENC_GetCorrespondingLCMLHeader..\n",__LINE__);
2067        pLcmlBufHeader = pComponentPrivate_CC->pLcmlBufHeader[NBAMRENC_INPUT_PORT];
2068        for(i = 0; i < nIpBuf; i++) {
2069            OMX_PRBUFFER2(pComponentPrivate_CC->dbg, "%d :: pBuffer = %p\n",__LINE__,pBuffer);
2070            OMX_PRBUFFER2(pComponentPrivate_CC->dbg, "%d :: pLcmlBufHeader->buffer->pBuffer = %p\n",__LINE__,pLcmlBufHeader->buffer->pBuffer);
2071            if(pBuffer == pLcmlBufHeader->buffer->pBuffer) {
2072                *ppLcmlHdr = pLcmlBufHeader;
2073                 OMX_PRDSP2(pComponentPrivate_CC->dbg, "%d :: Corresponding Input LCML Header Found = %p\n",__LINE__,pLcmlBufHeader);
2074                 eError = OMX_ErrorNone;
2075                 goto EXIT;
2076            }
2077            pLcmlBufHeader++;
2078        }
2079    } else if (eDir == OMX_DirOutput) {
2080        OMX_PRINT1(pComponentPrivate_CC->dbg, "%d :: Entering NBAMRENC_GetCorrespondingLCMLHeader..\n",__LINE__);
2081        pLcmlBufHeader = pComponentPrivate_CC->pLcmlBufHeader[NBAMRENC_OUTPUT_PORT];
2082        for(i = 0; i < nOpBuf; i++) {
2083            OMX_PRBUFFER2(pComponentPrivate_CC->dbg, "%d :: pBuffer = %p\n",__LINE__,pBuffer);
2084            OMX_PRBUFFER2(pComponentPrivate_CC->dbg, "%d :: pLcmlBufHeader->buffer->pBuffer = %p\n",__LINE__,pLcmlBufHeader->buffer->pBuffer);
2085            if(pBuffer == pLcmlBufHeader->buffer->pBuffer) {
2086                *ppLcmlHdr = pLcmlBufHeader;
2087                 OMX_PRDSP2(pComponentPrivate_CC->dbg, "%d :: Corresponding Output LCML Header Found = %p\n",__LINE__,pLcmlBufHeader);
2088                 eError = OMX_ErrorNone;
2089                 goto EXIT;
2090            }
2091            pLcmlBufHeader++;
2092        }
2093    } else {
2094      OMX_ERROR4(pComponentPrivate_CC->dbg, "%d :: Invalid Buffer Type :: exiting...\n",__LINE__);
2095      eError = OMX_ErrorUndefined;
2096    }
2097
2098EXIT:
2099    OMX_PRINT1(pComponentPrivate_CC->dbg, "%d :: Exiting NBAMRENC_GetCorrespondingLCMLHeader..\n",__LINE__);
2100    OMX_PRINT1(pComponentPrivate_CC->dbg, "%d :: Returning = 0x%x\n",__LINE__,eError);
2101    return eError;
2102}
2103
2104/* -------------------------------------------------------------------*/
2105/**
2106  *  NBAMRENC_LCMLCallback() will be called LCML component to write the msg
2107  *
2108  * @param event                 Event which gives to details about USN status
2109  * @param void * args        //    args [0] //bufType;
2110                              //    args [1] //arm address fpr buffer
2111                              //    args [2] //BufferSize;
2112                              //    args [3]  //arm address for param
2113                              //    args [4] //ParamSize;
2114                              //    args [6] //LCML Handle
2115  * @retval OMX_NoError              Success, ready to roll
2116  *         OMX_Error_BadParameter   The input parameter pointer is null
2117 **/
2118/*-------------------------------------------------------------------*/
2119
2120OMX_ERRORTYPE NBAMRENC_LCMLCallback (TUsnCodecEvent event,void * args[10])
2121{
2122    OMX_ERRORTYPE eError = OMX_ErrorNone;
2123    OMX_U8 *pBuffer = args[1];
2124    NBAMRENC_LCML_BUFHEADERTYPE *pLcmlHdr;
2125    OMX_U16 i,index,frameLength, length;
2126    OMX_COMPONENTTYPE *pHandle;
2127    LCML_DSP_INTERFACE *pLcmlHandle;
2128    OMX_U8 nFrames;
2129    OMX_U32 buffer_duration = 0;
2130
2131    NBAMRENC_BUFDATA* OutputFrames = NULL;
2132
2133    AMRENC_COMPONENT_PRIVATE* pComponentPrivate_CC = NULL;
2134    pComponentPrivate_CC = (AMRENC_COMPONENT_PRIVATE*)((LCML_DSP_INTERFACE*)args[6])->pComponentPrivate;
2135    pHandle = pComponentPrivate_CC->pHandle;
2136
2137
2138#ifdef AMRENC_DEBUG
2139    switch(event) {
2140
2141        case EMMCodecDspError:
2142            OMX_PRDSP2(pComponentPrivate_CC->dbg, "[LCML CALLBACK EVENT]  EMMCodecDspError\n");
2143            break;
2144
2145        case EMMCodecInternalError:
2146            OMX_ERROR4(pComponentPrivate_CC->dbg, "[LCML CALLBACK EVENT]  EMMCodecInternalError\n");
2147            break;
2148
2149        case EMMCodecInitError:
2150            OMX_ERROR4(pComponentPrivate_CC->dbg, "[LCML CALLBACK EVENT]  EMMCodecInitError\n");
2151            break;
2152
2153        case EMMCodecDspMessageRecieved:
2154            OMX_PRDSP2(pComponentPrivate_CC->dbg, "[LCML CALLBACK EVENT]  EMMCodecDspMessageRecieved\n");
2155            break;
2156
2157        case EMMCodecBufferProcessed:
2158            OMX_PRDSP2(pComponentPrivate_CC->dbg, "[LCML CALLBACK EVENT]  EMMCodecBufferProcessed\n");
2159            break;
2160
2161        case EMMCodecProcessingStarted:
2162            OMX_PRDSP2(pComponentPrivate_CC->dbg, "[LCML CALLBACK EVENT]  EMMCodecProcessingStarted\n");
2163            break;
2164
2165        case EMMCodecProcessingPaused:
2166            OMX_PRDSP2(pComponentPrivate_CC->dbg, "[LCML CALLBACK EVENT]  EMMCodecProcessingPaused\n");
2167            break;
2168
2169        case EMMCodecProcessingStoped:
2170            OMX_PRDSP2(pComponentPrivate_CC->dbg, "[LCML CALLBACK EVENT]  EMMCodecProcessingStoped\n");
2171            break;
2172
2173        case EMMCodecProcessingEof:
2174            OMX_PRDSP2(pComponentPrivate_CC->dbg, "[LCML CALLBACK EVENT]  EMMCodecProcessingEof\n");
2175            break;
2176
2177        case EMMCodecBufferNotProcessed:
2178            OMX_PRDSP2(pComponentPrivate_CC->dbg, "[LCML CALLBACK EVENT]  EMMCodecBufferNotProcessed\n");
2179            break;
2180
2181        case EMMCodecAlgCtrlAck:
2182            OMX_PRDSP2(pComponentPrivate_CC->dbg, "[LCML CALLBACK EVENT]  EMMCodecAlgCtrlAck\n");
2183            break;
2184
2185        case EMMCodecStrmCtrlAck:
2186            OMX_PRDSP2(pComponentPrivate_CC->dbg, "[LCML CALLBACK EVENT]  EMMCodecStrmCtrlAck\n");
2187            break;
2188    }
2189#endif
2190
2191    if(event == EMMCodecBufferProcessed)
2192    {
2193
2194        if((OMX_U32)args[0] == EMMCodecInputBuffer) {
2195                OMX_PRBUFFER1(pComponentPrivate_CC->dbg, "%d :: INPUT: pBuffer = %p\n",__LINE__, pBuffer);
2196            eError = NBAMRENC_GetCorrespondingLCMLHeader(pComponentPrivate_CC,pBuffer, OMX_DirInput, &pLcmlHdr);
2197            if (eError != OMX_ErrorNone) {
2198                OMX_ERROR4(pComponentPrivate_CC->dbg, "%d :: Error: Invalid Buffer Came ...\n",__LINE__);
2199                goto EXIT;
2200            }
2201#ifdef __PERF_INSTRUMENTATION__
2202            PERF_ReceivedFrame(pComponentPrivate_CC->pPERFcomp,
2203                               PREF(pLcmlHdr->buffer,pBuffer),
2204                               0,
2205                               PERF_ModuleCommonLayer);
2206#endif
2207
2208            NBAMRENC_ClearPending(pComponentPrivate_CC,pLcmlHdr->buffer,OMX_DirInput,__LINE__);
2209
2210#ifdef __PERF_INSTRUMENTATION__
2211                                PERF_SendingFrame(pComponentPrivate_CC->pPERFcomp,
2212                                              pLcmlHdr->buffer->pBuffer,
2213                                              0,
2214                                              PERF_ModuleHLMM);
2215#endif
2216                pComponentPrivate_CC->cbInfo.EmptyBufferDone( pHandle,
2217                                                           pHandle->pApplicationPrivate,
2218                                                           pLcmlHdr->buffer);
2219                pComponentPrivate_CC->nEmptyBufferDoneCount++;
2220                pComponentPrivate_CC->nOutStandingEmptyDones--;
2221                pComponentPrivate_CC->lcml_nIpBuf--;
2222                pComponentPrivate_CC->app_nBuf++;
2223
2224        pComponentPrivate_CC->nOutStandingEmptyDones++;
2225
2226        } else if((OMX_U32)args[0] == EMMCodecOuputBuffer) {
2227
2228            if (!NBAMRENC_IsValid(pComponentPrivate_CC,pBuffer,OMX_DirOutput)) {
2229
2230                for (i=0; i < pComponentPrivate_CC->pOutputBufferList->numBuffers; i++) {
2231#ifdef __PERF_INSTRUMENTATION__
2232                PERF_SendingFrame(pComponentPrivate_CC->pPERFcomp,
2233                                  pComponentPrivate_CC->pOutputBufferList->pBufHdr[i]->pBuffer,
2234                                  pComponentPrivate_CC->pOutputBufferList->pBufHdr[i]->nFilledLen,
2235                                  PERF_ModuleHLMM);
2236#endif
2237                    pComponentPrivate_CC->cbInfo.FillBufferDone (pComponentPrivate_CC->pHandle,
2238                                                          pComponentPrivate_CC->pHandle->pApplicationPrivate,
2239                                                          pComponentPrivate_CC->pOutputBufferList->pBufHdr[i++]
2240                                                          );
2241                }
2242            } else {
2243
2244            OMX_PRBUFFER2(pComponentPrivate_CC->dbg, "%d :: OUTPUT: pBuffer = %p\n",__LINE__, pBuffer);
2245
2246            pComponentPrivate_CC->nOutStandingFillDones++;
2247
2248            eError = NBAMRENC_GetCorrespondingLCMLHeader(pComponentPrivate_CC, pBuffer, OMX_DirOutput, &pLcmlHdr);
2249            if (eError != OMX_ErrorNone) {
2250                OMX_ERROR4(pComponentPrivate_CC->dbg, "%d :: Error: Invalid Buffer Came ...\n",__LINE__);
2251                goto EXIT;
2252            }
2253
2254            OMX_PRBUFFER2(pComponentPrivate_CC->dbg, "%d :: Output: pLcmlHdr->buffer->pBuffer = %p\n",__LINE__, pLcmlHdr->buffer->pBuffer);
2255            pLcmlHdr->buffer->nFilledLen = (OMX_U32)args[8];
2256            OMX_PRBUFFER1(pComponentPrivate_CC->dbg, "%d :: Output: pBuffer = %ld\n",__LINE__, pLcmlHdr->buffer->nFilledLen);
2257#if 0
2258            pLcmlHdr->buffer->nFilledLen = 32;
2259            OMX_PRBUFFER1(pComponentPrivate_CC->dbg, "%d :: Output: ::RESET:: pBuffer->nFilledLen = %ld\n",__LINE__, pLcmlHdr->buffer->nFilledLen);
2260#endif
2261
2262#ifdef __PERF_INSTRUMENTATION__
2263            PERF_ReceivedFrame(pComponentPrivate_CC->pPERFcomp,
2264                               PREF(pLcmlHdr->buffer,pBuffer),
2265                               PREF(pLcmlHdr->buffer,nFilledLen),
2266                               PERF_ModuleCommonLayer);
2267
2268            pComponentPrivate_CC->nLcml_nCntOpReceived++;
2269
2270            if ((pComponentPrivate_CC->nLcml_nCntIp >= 1) && (pComponentPrivate_CC->nLcml_nCntOpReceived == 1)) {
2271                PERF_Boundary(pComponentPrivate_CC->pPERFcomp,
2272                              PERF_BoundaryStart | PERF_BoundarySteadyState);
2273            }
2274#endif
2275
2276                NBAMRENC_ClearPending(pComponentPrivate_CC,pLcmlHdr->buffer,OMX_DirOutput,__LINE__);
2277
2278                pComponentPrivate_CC->LastOutbuf = pLcmlHdr->buffer;
2279                if(!pLcmlHdr->pBufferParam->usNbFrames){
2280                        pLcmlHdr->pBufferParam->usNbFrames++;
2281                }
2282                if((pComponentPrivate_CC->frameMode == NBAMRENC_MIMEMODE)&&(pLcmlHdr->buffer->nFilledLen)) {
2283                       nFrames = (OMX_U8)( pLcmlHdr->buffer->nFilledLen / NBAMRENC_OUTPUT_BUFFER_SIZE_MIME);
2284                       frameLength=0;
2285                       length=0;
2286                       for(i=0;i<nFrames;i++){
2287                             index = (pLcmlHdr->buffer->pBuffer[i*NBAMRENC_OUTPUT_BUFFER_SIZE_MIME] >> 3) & 0x0F;
2288                             if(pLcmlHdr->buffer->nFilledLen == 0)
2289                                  length = 0;
2290                             else
2291                                  length = (OMX_U16)pComponentPrivate_CC->amrMimeBytes[index];
2292                             if (i){
2293                                   memmove( pLcmlHdr->buffer->pBuffer + frameLength,
2294                                            pLcmlHdr->buffer->pBuffer + (i * NBAMRENC_OUTPUT_BUFFER_SIZE_MIME),
2295                                            length);
2296                             }
2297                             frameLength += length;
2298                        }
2299                        pLcmlHdr->buffer->nFilledLen= frameLength;
2300                }
2301                 else if((pComponentPrivate_CC->frameMode == NBAMRENC_IF2)&&(pLcmlHdr->buffer->nFilledLen)) {
2302                       nFrames = (OMX_U8)( pLcmlHdr->buffer->nFilledLen / NBAMRENC_OUTPUT_BUFFER_SIZE_IF2);
2303                       frameLength=0;
2304                       length=0;
2305                       for(i=0;i<nFrames;i++){
2306                             index = (pLcmlHdr->buffer->pBuffer[i*NBAMRENC_OUTPUT_BUFFER_SIZE_IF2]) & 0x0F;
2307                             if(pLcmlHdr->buffer->nFilledLen == 0)
2308                                  length = 0;
2309                             else
2310                                  length = (OMX_U16)pComponentPrivate_CC->amrIf2Bytes[index];
2311                             if (i){
2312                                   memmove( pLcmlHdr->buffer->pBuffer + frameLength,
2313                                            pLcmlHdr->buffer->pBuffer + (i * NBAMRENC_OUTPUT_BUFFER_SIZE_IF2),
2314                                            length);
2315                             }
2316                             frameLength += length;
2317                        }
2318                        pLcmlHdr->buffer->nFilledLen= frameLength;
2319                } else{
2320                        if ((pComponentPrivate_CC->efrMode == 1)&&(pLcmlHdr->buffer->nFilledLen)){
2321                           nFrames = pLcmlHdr->buffer->nFilledLen/NBAMRENC_OUTPUT_BUFFER_SIZE_EFR;
2322                            }
2323                        else
2324                           nFrames = pLcmlHdr->buffer->nFilledLen/NBAMRENC_OUTPUT_FRAME_SIZE;
2325                      }
2326
2327                OutputFrames = pLcmlHdr->buffer->pOutputPortPrivate;
2328                OutputFrames->nFrames = nFrames;
2329
2330
2331                if( !pComponentPrivate_CC->dasfMode){
2332                        /* Copying time stamp information to output buffer */
2333                        /*pLcmlHdr->buffer->nTimeStamp = (OMX_TICKS)pComponentPrivate_CC->arrBufIndex[pComponentPrivate_CC->OpBufindex];*/
2334                        pLcmlHdr->buffer->nTimeStamp = pComponentPrivate_CC->TimeStamp;
2335                        buffer_duration = (160*nFrames*1000000) /
2336                          (pComponentPrivate_CC->pcmParams->nSamplingRate*pComponentPrivate_CC->pcmParams->nChannels) ;
2337                        /* Update time stamp information */
2338                        pComponentPrivate_CC->TimeStamp += (OMX_TICKS)buffer_duration;
2339                        /* Copying nTickCount information to output buffer */
2340                        pLcmlHdr->buffer->nTickCount = pComponentPrivate_CC->arrTickCount[pComponentPrivate_CC->OpBufindex];
2341                        pComponentPrivate_CC->OpBufindex++;
2342                        pComponentPrivate_CC->OpBufindex %= pComponentPrivate_CC->pPortDef[OMX_DirOutput]->nBufferCountActual;
2343                }
2344
2345#ifdef __PERF_INSTRUMENTATION__
2346                PERF_SendingBuffer(pComponentPrivate_CC->pPERFcomp,
2347                                    pLcmlHdr->buffer->pBuffer,
2348                                    pLcmlHdr->buffer->nFilledLen,
2349                                    PERF_ModuleHLMM);
2350#endif
2351                /* Non Multi Frame Mode has been tested here */
2352
2353                pComponentPrivate_CC->nFillBufferDoneCount++;
2354                pComponentPrivate_CC->nOutStandingFillDones--;
2355                pComponentPrivate_CC->lcml_nOpBuf--;
2356                pComponentPrivate_CC->app_nBuf++;
2357
2358                pComponentPrivate_CC->cbInfo.FillBufferDone( pHandle,
2359                                            pHandle->pApplicationPrivate,
2360                                            pLcmlHdr->buffer);
2361
2362                OMX_PRBUFFER2(pComponentPrivate_CC->dbg, "%d :: Incrementing app_nBuf = %ld\n",__LINE__,pComponentPrivate_CC->app_nBuf);
2363            }
2364        }
2365        }
2366    else if (event == EMMCodecStrmCtrlAck) {
2367        OMX_PRDSP2(pComponentPrivate_CC->dbg, "%d :: GOT MESSAGE USN_DSPACK_STRMCTRL \n",__LINE__);
2368        if (args[1] == (void *)USN_STRMCMD_FLUSH) {
2369            pHandle = pComponentPrivate_CC->pHandle;
2370            if ( args[2] == (void *)EMMCodecInputBuffer) {
2371                if (args[0] == (void *)USN_ERR_NONE ) {
2372                    OMX_PRCOMM1(pComponentPrivate_CC->dbg, "Flushing input port %d\n",__LINE__);
2373
2374                    for (i=0; i < pComponentPrivate_CC->nNumInputBufPending; i++) {
2375
2376#ifdef __PERF_INSTRUMENTATION__
2377                            PERF_SendingFrame(pComponentPrivate_CC->pPERFcomp,
2378                                              pComponentPrivate_CC->pInputBufferList->pBufHdr[i]->pBuffer,
2379                                              0,
2380                                              PERF_ModuleHLMM);
2381#endif
2382
2383                        pComponentPrivate_CC->cbInfo.EmptyBufferDone (
2384                                       pHandle,
2385                                       pHandle->pApplicationPrivate,
2386                                       pComponentPrivate_CC->pInputBufHdrPending[i]
2387                                       );
2388                    pComponentPrivate_CC->nEmptyBufferDoneCount++;
2389                    pComponentPrivate_CC->nOutStandingEmptyDones--;
2390
2391                    }
2392                    pComponentPrivate_CC->nNumInputBufPending=0;
2393                    pComponentPrivate_CC->cbInfo.EventHandler(
2394                         pHandle, pHandle->pApplicationPrivate,
2395                         OMX_EventCmdComplete, OMX_CommandFlush,NBAMRENC_INPUT_PORT, NULL);
2396                } else {
2397                     OMX_ERROR4(pComponentPrivate_CC->dbg, "LCML reported error while flushing input port\n");
2398                     goto EXIT;
2399                }
2400            }
2401            else if ( args[2] == (void *)EMMCodecOuputBuffer) {
2402                if (args[0] == (void *)USN_ERR_NONE ) {
2403                    OMX_PRCOMM1(pComponentPrivate_CC->dbg, "Flushing output port %d\n",__LINE__);
2404
2405                    for (i=0; i < pComponentPrivate_CC->nNumOutputBufPending; i++) {
2406#ifdef __PERF_INSTRUMENTATION__
2407                    PERF_SendingFrame(pComponentPrivate_CC->pPERFcomp,
2408                                      pComponentPrivate_CC->pOutputBufferList->pBufHdr[i]->pBuffer,
2409                                      pComponentPrivate_CC->pOutputBufferList->pBufHdr[i]->nFilledLen,
2410                                      PERF_ModuleHLMM);
2411#endif
2412                        pComponentPrivate_CC->cbInfo.FillBufferDone (
2413                                       pHandle,
2414                                       pHandle->pApplicationPrivate,
2415                                       pComponentPrivate_CC->pOutputBufHdrPending[i]
2416                                       );
2417                    pComponentPrivate_CC->nFillBufferDoneCount++;
2418                    pComponentPrivate_CC->nOutStandingFillDones--;
2419
2420                    }
2421                    pComponentPrivate_CC->nNumOutputBufPending=0;
2422                    pComponentPrivate_CC->cbInfo.EventHandler(
2423                             pHandle, pHandle->pApplicationPrivate,
2424                             OMX_EventCmdComplete, OMX_CommandFlush,NBAMRENC_OUTPUT_PORT, NULL);
2425                } else {
2426                    OMX_ERROR4(pComponentPrivate_CC->dbg, "LCML reported error while flushing output port\n");
2427                    goto EXIT;
2428                }
2429            }
2430        }
2431    }
2432    else if(event == EMMCodecProcessingStoped) {
2433
2434        pthread_mutex_lock(&pComponentPrivate_CC->codecStop_mutex);
2435        if(pComponentPrivate_CC->codecStop_waitingsignal == 0){
2436            pComponentPrivate_CC->codecStop_waitingsignal = 1;
2437            pthread_cond_signal(&pComponentPrivate_CC->codecStop_threshold);
2438            OMX_PRINT2(pComponentPrivate_CC->dbg, "stop ack. received. stop waiting for sending disable command completed\n");
2439        }
2440        pthread_mutex_unlock(&pComponentPrivate_CC->codecStop_mutex);
2441
2442        OMX_PRDSP2(pComponentPrivate_CC->dbg, "%d :: GOT MESSAGE USN_DSPACK_STOP \n",__LINE__);
2443
2444        for (i=0; i < pComponentPrivate_CC->pInputBufferList->numBuffers; i++) {
2445
2446            if (pComponentPrivate_CC->pInputBufferList->bBufferPending[i]) {
2447
2448#ifdef __PERF_INSTRUMENTATION__
2449                            PERF_SendingFrame(pComponentPrivate_CC->pPERFcomp,
2450                                              pComponentPrivate_CC->pInputBufferList->pBufHdr[i]->pBuffer,
2451                                              0,
2452                                              PERF_ModuleHLMM);
2453#endif
2454
2455                   pComponentPrivate_CC->cbInfo.EmptyBufferDone (
2456                                       pComponentPrivate_CC->pHandle,
2457                                       pComponentPrivate_CC->pHandle->pApplicationPrivate,
2458                                       pComponentPrivate_CC->pInputBufferList->pBufHdr[i]
2459                                       );
2460                   pComponentPrivate_CC->nEmptyBufferDoneCount++;
2461                   pComponentPrivate_CC->nOutStandingEmptyDones--;
2462                   NBAMRENC_ClearPending(pComponentPrivate_CC, pComponentPrivate_CC->pInputBufferList->pBufHdr[i], OMX_DirInput,__LINE__);
2463            }
2464        }
2465
2466        for (i=0; i < pComponentPrivate_CC->pOutputBufferList->numBuffers; i++) {
2467            if (pComponentPrivate_CC->pOutputBufferList->bBufferPending[i]) {
2468#ifdef __PERF_INSTRUMENTATION__
2469                    PERF_SendingFrame(pComponentPrivate_CC->pPERFcomp,
2470                                      pComponentPrivate_CC->pOutputBufferList->pBufHdr[i]->pBuffer,
2471                                      pComponentPrivate_CC->pOutputBufferList->pBufHdr[i]->nFilledLen,
2472                                      PERF_ModuleHLMM);
2473#endif
2474                pComponentPrivate_CC->cbInfo.FillBufferDone (
2475                                       pComponentPrivate_CC->pHandle,
2476                                       pComponentPrivate_CC->pHandle->pApplicationPrivate,
2477                                       pComponentPrivate_CC->pOutputBufferList->pBufHdr[i]
2478                                       );
2479                pComponentPrivate_CC->nFillBufferDoneCount++;
2480                pComponentPrivate_CC->nOutStandingFillDones--;
2481
2482                NBAMRENC_ClearPending(pComponentPrivate_CC, pComponentPrivate_CC->pOutputBufferList->pBufHdr[i], OMX_DirOutput,__LINE__);
2483            }
2484        }
2485
2486        if (!pComponentPrivate_CC->bNoIdleOnStop) {
2487
2488            pComponentPrivate_CC->nNumOutputBufPending=0;
2489
2490            pComponentPrivate_CC->ProcessingInputBuf=0;
2491            pComponentPrivate_CC->ProcessingOutputBuf=0;
2492
2493            pComponentPrivate_CC->nHoldLength = 0;
2494            pComponentPrivate_CC->InBuf_Eos_alreadysent = 0;
2495
2496            OMX_MEMFREE_STRUCT(pComponentPrivate_CC->pHoldBuffer);
2497            OMX_MEMFREE_STRUCT(pComponentPrivate_CC->iMMFDataLastBuffer);
2498
2499            pComponentPrivate_CC->curState = OMX_StateIdle;
2500#ifdef RESOURCE_MANAGER_ENABLED
2501            eError = RMProxy_NewSendCommand(pHandle, RMProxy_StateSet, OMX_NBAMR_Encoder_COMPONENT, OMX_StateIdle, 3456, NULL);
2502#endif
2503
2504            if (pComponentPrivate_CC->bPreempted == 0) {
2505                /* Decrement reference count with signal enabled */
2506                if(RemoveStateTransition(pComponentPrivate_CC, OMX_TRUE) != OMX_ErrorNone) {
2507                   return OMX_ErrorUndefined;
2508                }
2509
2510                pComponentPrivate_CC->cbInfo.EventHandler(pComponentPrivate_CC->pHandle,
2511                                                        pComponentPrivate_CC->pHandle->pApplicationPrivate,
2512                                                        OMX_EventCmdComplete,
2513                                                        OMX_CommandStateSet,
2514                                                        pComponentPrivate_CC->curState,
2515                                                        NULL);
2516            }
2517            else{
2518                                pComponentPrivate_CC->cbInfo.EventHandler(pComponentPrivate_CC->pHandle,
2519                                                        pComponentPrivate_CC->pHandle->pApplicationPrivate,
2520                                                        OMX_EventError,
2521                                                        OMX_ErrorResourcesPreempted,
2522                                                        OMX_TI_ErrorSevere,
2523                                                        NULL);
2524            }
2525
2526
2527        }
2528        else {
2529            pComponentPrivate_CC->bNoIdleOnStop= OMX_FALSE;
2530            pComponentPrivate_CC->bDspStoppedWhileExecuting = OMX_TRUE;
2531        }
2532    }
2533    else if(event == EMMCodecDspMessageRecieved) {
2534        OMX_PRSTATE1(pComponentPrivate_CC->dbg, "%d :: commandedState  = %ld\n",__LINE__,(OMX_U32)args[0]);
2535        OMX_PRINT2(pComponentPrivate_CC->dbg, "%d :: arg1 = %ld\n",__LINE__,(OMX_U32)args[1]);
2536        OMX_PRINT2(pComponentPrivate_CC->dbg, "%d :: arg2 = %ld\n",__LINE__,(OMX_U32)args[2]);
2537
2538        if(0x0500 == (OMX_U32)args[2]) {
2539            OMX_PRDSP2(pComponentPrivate_CC->dbg, "%d :: EMMCodecDspMessageRecieved\n",__LINE__);
2540        }
2541    }
2542    else if(event == EMMCodecAlgCtrlAck) {
2543        OMX_PRINT2(pComponentPrivate_CC->dbg, "%d :: GOT MESSAGE USN_DSPACK_ALGCTRL \n",__LINE__);
2544    }
2545        else if (event == EMMCodecDspError) {
2546            switch ( (OMX_U32) args [4])
2547            {
2548            /* USN_ERR_NONE,: Indicates that no error encountered during execution of the command and the command execution completed succesfully.
2549             * USN_ERR_WARNING,: Indicates that process function returned a warning. The exact warning is returned in Arg2 of this message.
2550             * USN_ERR_PROCESS,: Indicates that process function returned a error type. The exact error type is returnd in Arg2 of this message.
2551             * USN_ERR_PAUSE,: Indicates that execution of pause resulted in error.
2552             * USN_ERR_STOP,: Indicates that execution of stop resulted in error.
2553             * USN_ERR_ALGCTRL,: Indicates that execution of alg control resulted in error.
2554             * USN_ERR_STRMCTRL,: Indiactes the execution of STRM control command, resulted in error.
2555             * USN_ERR_UNKNOWN_MSG,: Indicates that USN received an unknown command. */
2556
2557#ifdef _ERROR_PROPAGATION__
2558                case USN_ERR_PAUSE:
2559                case USN_ERR_STOP:
2560                case USN_ERR_ALGCTRL:
2561                case USN_ERR_STRMCTRL:
2562                case USN_ERR_UNKNOWN_MSG:
2563                {
2564                    pComponentPrivate_CC->bIsInvalidState=OMX_TRUE;
2565                    pComponentPrivate_CC->curState = OMX_StateInvalid;
2566                    pHandle = pComponentPrivate_CC->pHandle;
2567                    pComponentPrivate_CC->cbInfo.EventHandler(pHandle,
2568                            pHandle->pApplicationPrivate,
2569                            OMX_EventError,
2570                            OMX_ErrorInvalidState,
2571                            OMX_TI_ErrorSevere,
2572                            NULL);
2573                }
2574                    break;
2575#endif
2576
2577                case USN_ERR_WARNING:
2578                case USN_ERR_PROCESS:
2579                    NBAMRENC_HandleUSNError (pComponentPrivate_CC, (OMX_U32)args[5]);
2580                    break;
2581                default:
2582                    break;
2583            }
2584        }
2585        else if (event == EMMCodecProcessingPaused) {
2586            pComponentPrivate_CC->nUnhandledEmptyThisBuffers = 0;
2587            pComponentPrivate_CC->nUnhandledFillThisBuffers = 0;
2588            pComponentPrivate_CC->curState = OMX_StatePause;
2589
2590            /* Decrement reference count with signal enabled */
2591            if(RemoveStateTransition(pComponentPrivate_CC, OMX_TRUE) != OMX_ErrorNone) {
2592                   return OMX_ErrorUndefined;
2593            }
2594            pComponentPrivate_CC->cbInfo.EventHandler( pComponentPrivate_CC->pHandle,
2595                                                    pComponentPrivate_CC->pHandle->pApplicationPrivate,
2596                                                    OMX_EventCmdComplete,
2597                                                    OMX_CommandStateSet,
2598                                                    pComponentPrivate_CC->curState,
2599                                                    NULL);
2600        }
2601#ifdef _ERROR_PROPAGATION__
2602        else if (event ==EMMCodecInitError){
2603             /* Cheking for MMU_fault */
2604             if(((int)args[4] == USN_ERR_UNKNOWN_MSG) && (args[5] == (void*)NULL)) {
2605                    pComponentPrivate_CC->bIsInvalidState=OMX_TRUE;
2606                    pComponentPrivate_CC->curState = OMX_StateInvalid;
2607                    pHandle = pComponentPrivate_CC->pHandle;
2608                    pComponentPrivate_CC->cbInfo.EventHandler(pHandle,
2609                                   pHandle->pApplicationPrivate,
2610                                   OMX_EventError,
2611                                   OMX_ErrorInvalidState,
2612                                   OMX_TI_ErrorSevere,
2613                                   NULL);
2614        }
2615    }
2616    else if (event ==EMMCodecInternalError){
2617        /* Cheking for MMU_fault */
2618        if(((int)args[4] == USN_ERR_UNKNOWN_MSG) && (args[5] == (void*)NULL)) {
2619            OMX_ERROR4(pComponentPrivate_CC->dbg, "%d :: UTIL: MMU_Fault \n",__LINE__);
2620            pComponentPrivate_CC->bIsInvalidState=OMX_TRUE;
2621            pComponentPrivate_CC->curState = OMX_StateInvalid;
2622            pHandle = pComponentPrivate_CC->pHandle;
2623            pComponentPrivate_CC->cbInfo.EventHandler(pHandle,
2624                                   pHandle->pApplicationPrivate,
2625                                   OMX_EventError,
2626                                   OMX_ErrorInvalidState,
2627                                   OMX_TI_ErrorSevere,
2628                                   NULL);
2629        }
2630
2631    }
2632#endif
2633EXIT:
2634    if (pComponentPrivate_CC != NULL) {
2635	OMX_PRINT1(pComponentPrivate_CC->dbg, "%d :: Exiting the NBAMRENC_LCMLCallback Function\n", __LINE__);
2636	OMX_PRINT1(pComponentPrivate_CC->dbg, "%d :: Returning = 0x%x\n", __LINE__, eError);
2637    }
2638
2639    return eError;
2640}
2641
2642/* ================================================================================= */
2643/**
2644  *  NBAMRENC_GetLCMLHandle()
2645  *
2646  * @retval OMX_HANDLETYPE
2647  */
2648/* ================================================================================= */
2649#ifndef UNDER_CE
2650OMX_HANDLETYPE NBAMRENC_GetLCMLHandle(AMRENC_COMPONENT_PRIVATE *pComponentPrivate)
2651{
2652    OMX_ERRORTYPE eError = OMX_ErrorNone;
2653    OMX_ERRORTYPE (*fpGetHandle)(OMX_HANDLETYPE);
2654    OMX_HANDLETYPE pHandle = NULL;
2655    void *handle;
2656    char *error;
2657    AMRENC_COMPONENT_PRIVATE* pComponentPrivate_CC = NULL;
2658
2659    OMX_PRINT1 (pComponentPrivate->dbg, "%d :: Entering NBAMRENC_GetLCMLHandle..\n",__LINE__);
2660    handle = dlopen("libLCML.so", RTLD_LAZY);
2661    if (!handle) {
2662        fputs(dlerror(), stderr);
2663        goto EXIT;
2664    }
2665    fpGetHandle = dlsym (handle, "GetHandle");
2666    if ((error = dlerror()) != NULL) {
2667        fputs(error, stderr);
2668        goto EXIT;
2669    }
2670    eError = (*fpGetHandle)(&pHandle);
2671    if(eError != OMX_ErrorNone) {
2672        eError = OMX_ErrorUndefined;
2673        OMXDBG_PRINT(stderr, ERROR, 4, 0, "%d :: OMX_ErrorUndefined...\n",__LINE__);
2674        pHandle = NULL;
2675        goto EXIT;
2676    }
2677    pComponentPrivate_CC = (AMRENC_COMPONENT_PRIVATE*)pComponentPrivate;
2678    ((LCML_DSP_INTERFACE*)pHandle)->pComponentPrivate = pComponentPrivate;
2679
2680    pComponentPrivate->ptrLibLCML=handle;           /* saving LCML lib pointer  */
2681
2682EXIT:
2683    OMX_PRINT1(pComponentPrivate_CC->dbg, "%d :: Exiting NBAMRENC_GetLCMLHandle..\n",__LINE__);
2684    OMX_PRINT1(pComponentPrivate_CC->dbg, "%d :: Returning = 0x%x\n",__LINE__,eError);
2685    return pHandle;
2686}
2687
2688#else
2689/*WINDOWS Explicit dll load procedure*/
2690OMX_HANDLETYPE NBAMRENC_GetLCMLHandle(AMRENC_COMPONENT_PRIVATE *pComponentPrivate)
2691{
2692    typedef OMX_ERRORTYPE (*LPFNDLLFUNC1)(OMX_HANDLETYPE);
2693    OMX_HANDLETYPE pHandle = NULL;
2694    OMX_ERRORTYPE eError;
2695    LPFNDLLFUNC1 fpGetHandle1;
2696
2697
2698    if (!fpGetHandle1) {
2699      // handle the error
2700      return pHandle;
2701    }
2702    // call the function
2703    eError = fpGetHandle1(&pHandle);
2704    if(eError != OMX_ErrorNone) {
2705        eError = OMX_ErrorUndefined;
2706        OMXDBG_PRINT(stderr, ERROR, 4, 0, "eError != OMX_ErrorNone...\n");
2707        pHandle = NULL;
2708        return pHandle;
2709    }
2710
2711    ((LCML_DSP_INTERFACE*)pHandle)->pComponentPrivate = pComponentPrivate;
2712    return pHandle;
2713}
2714#endif
2715
2716/* ================================================================================= */
2717/**
2718* @fn NBAMRENC_SetPending() description for NBAMRENC_SetPending
2719NBAMRENC_SetPending().
2720This component is called when a buffer is queued to the LCML
2721* @param pComponent  handle for this instance of the component
2722*
2723* @pre
2724*
2725* @post
2726*
2727* @return OMX_ERRORTYPE
2728*/
2729/* ================================================================================ */
2730void NBAMRENC_SetPending(AMRENC_COMPONENT_PRIVATE *pComponentPrivate,
2731                         OMX_BUFFERHEADERTYPE *pBufHdr, OMX_DIRTYPE eDir, OMX_U32 lineNumber)
2732{
2733    OMX_U16 i;
2734
2735    if (eDir == OMX_DirInput) {
2736        for (i=0; i < pComponentPrivate->pInputBufferList->numBuffers; i++) {
2737            if (pBufHdr == pComponentPrivate->pInputBufferList->pBufHdr[i]) {
2738                pComponentPrivate->pInputBufferList->bBufferPending[i] = 1;
2739                OMX_PRBUFFER2(pComponentPrivate->dbg, "****INPUT BUFFER %d IS PENDING Line %ld******\n",i,lineNumber);
2740            }
2741        }
2742    }
2743    else {
2744        for (i=0; i < pComponentPrivate->pOutputBufferList->numBuffers; i++) {
2745            if (pBufHdr == pComponentPrivate->pOutputBufferList->pBufHdr[i]) {
2746                pComponentPrivate->pOutputBufferList->bBufferPending[i] = 1;
2747                OMX_PRBUFFER2(pComponentPrivate->dbg, "****OUTPUT BUFFER %d IS PENDING Line %ld*****\n",i,lineNumber);
2748            }
2749        }
2750    }
2751}
2752/* ================================================================================= */
2753/**
2754* @fn NBAMRENC_ClearPending() description for NBAMRENC_ClearPending
2755NBAMRENC_ClearPending().
2756This component is called when a buffer is returned from the LCML
2757* @param pComponent  handle for this instance of the component
2758*
2759* @pre
2760*
2761* @post
2762*
2763* @return OMX_ERRORTYPE
2764*/
2765/* ================================================================================ */
2766void NBAMRENC_ClearPending(AMRENC_COMPONENT_PRIVATE *pComponentPrivate,
2767                           OMX_BUFFERHEADERTYPE *pBufHdr, OMX_DIRTYPE eDir, OMX_U32 lineNumber)
2768{
2769    OMX_U16 i;
2770
2771    if (eDir == OMX_DirInput) {
2772        for (i=0; i < pComponentPrivate->pInputBufferList->numBuffers; i++) {
2773            if (pBufHdr == pComponentPrivate->pInputBufferList->pBufHdr[i]) {
2774                pComponentPrivate->pInputBufferList->bBufferPending[i] = 0;
2775                OMX_PRBUFFER2(pComponentPrivate->dbg, "****INPUT BUFFER %d IS RECLAIMED Line %ld*****\n",i,lineNumber);
2776            }
2777        }
2778    }
2779    else {
2780        for (i=0; i < pComponentPrivate->pOutputBufferList->numBuffers; i++) {
2781            if (pBufHdr == pComponentPrivate->pOutputBufferList->pBufHdr[i]) {
2782                pComponentPrivate->pOutputBufferList->bBufferPending[i] = 0;
2783                OMX_PRBUFFER2(pComponentPrivate->dbg, "****OUTPUT BUFFER %d IS RECLAIMED Line %ld*****\n",i,lineNumber);
2784            }
2785        }
2786    }
2787}
2788/* ================================================================================= */
2789/**
2790* @fn NBAMRENC_IsPending() description for NBAMRENC_IsPending
2791NBAMRENC_IsPending().
2792This method returns the pending status to the buffer
2793* @param pComponent  handle for this instance of the component
2794*
2795* @pre
2796*
2797* @post
2798*
2799* @return OMX_ERRORTYPE
2800*/
2801/* ================================================================================ */
2802OMX_U32 NBAMRENC_IsPending(AMRENC_COMPONENT_PRIVATE *pComponentPrivate,
2803                           OMX_BUFFERHEADERTYPE *pBufHdr, OMX_DIRTYPE eDir)
2804{
2805    OMX_U16 i;
2806
2807    if (eDir == OMX_DirInput) {
2808        for (i=0; i < pComponentPrivate->pInputBufferList->numBuffers; i++) {
2809            if (pBufHdr == pComponentPrivate->pInputBufferList->pBufHdr[i]) {
2810                return pComponentPrivate->pInputBufferList->bBufferPending[i];
2811            }
2812        }
2813    }
2814    else {
2815        for (i=0; i < pComponentPrivate->pOutputBufferList->numBuffers; i++) {
2816            OMX_PRBUFFER2(pComponentPrivate->dbg, "pBufHdr = %p\n",pBufHdr);
2817            OMX_PRBUFFER2(pComponentPrivate->dbg, "pOutputBufferList->pBufHdr[i] = %p\n",pComponentPrivate->pOutputBufferList->pBufHdr[i]);
2818            if (pBufHdr == pComponentPrivate->pOutputBufferList->pBufHdr[i]) {
2819                OMX_PRBUFFER2(pComponentPrivate->dbg, "returning %lx\n",pComponentPrivate->pOutputBufferList->bBufferPending[i]);
2820                return pComponentPrivate->pOutputBufferList->bBufferPending[i];
2821            }
2822        }
2823    }
2824    return -1;
2825}
2826/* ================================================================================= */
2827/**
2828* @fn NBAMRENC_IsValid() description for NBAMRENC_IsValid
2829NBAMRENC_IsValid().
2830This method checks to see if a buffer returned from the LCML is valid.
2831* @param pComponent  handle for this instance of the component
2832*
2833* @pre
2834*
2835* @post
2836*
2837* @return OMX_ERRORTYPE
2838*/
2839/* ================================================================================ */
2840OMX_U32 NBAMRENC_IsValid(AMRENC_COMPONENT_PRIVATE *pComponentPrivate,
2841                         OMX_U8 *pBuffer, OMX_DIRTYPE eDir)
2842{
2843    OMX_U16 i;
2844    int found=0;
2845
2846    if (eDir == OMX_DirInput) {
2847        for (i=0; i < pComponentPrivate->pInputBufferList->numBuffers; i++) {
2848            if (pBuffer == pComponentPrivate->pInputBufferList->pBufHdr[i]->pBuffer) {
2849                found = 1;
2850            }
2851        }
2852    }
2853    else {
2854        for (i=0; i < pComponentPrivate->pOutputBufferList->numBuffers; i++) {
2855            if (pBuffer == pComponentPrivate->pOutputBufferList->pBufHdr[i]->pBuffer) {
2856                found = 1;
2857            }
2858        }
2859    }
2860    return found;
2861}
2862/* ========================================================================== */
2863/**
2864* @NBAMRENC_FillLCMLInitParamsEx() This function is used by the component thread to
2865* fill the all of its initialization parameters, buffer deatils  etc
2866* to LCML structure,
2867*
2868* @param pComponent  handle for this instance of the component
2869* @param plcml_Init  pointer to LCML structure to be filled
2870*
2871* @pre
2872*
2873* @post
2874*
2875* @return none
2876*/
2877/* ========================================================================== */
2878OMX_ERRORTYPE NBAMRENC_FillLCMLInitParamsEx(OMX_HANDLETYPE pComponent)
2879{
2880    OMX_ERRORTYPE eError = OMX_ErrorNone;
2881    OMX_U32 nIpBuf,nIpBufSize,nOpBuf,nOpBufSize;
2882    OMX_BUFFERHEADERTYPE *pTemp;
2883    LCML_DSP_INTERFACE *pHandle = (LCML_DSP_INTERFACE *)pComponent;
2884    AMRENC_COMPONENT_PRIVATE *pComponentPrivate = pHandle->pComponentPrivate;
2885    NBAMRENC_LCML_BUFHEADERTYPE *pTemp_lcml = NULL;
2886    OMX_U16 i;
2887    OMX_U32 size_lcml;
2888    OMX_PRINT1(pComponentPrivate->dbg, "%d :: NBAMRENC_FillLCMLInitParamsEx\n",__LINE__);
2889    nIpBuf = pComponentPrivate->pInputBufferList->numBuffers;
2890    nIpBufSize = pComponentPrivate->pPortDef[NBAMRENC_INPUT_PORT]->nBufferSize;
2891    nOpBuf = pComponentPrivate->pOutputBufferList->numBuffers;
2892    nOpBufSize = pComponentPrivate->pPortDef[NBAMRENC_OUTPUT_PORT]->nBufferSize;
2893    OMX_PRBUFFER1(pComponentPrivate->dbg, "%d :: ------ Buffer Details -----------\n",__LINE__);
2894    OMX_PRBUFFER1(pComponentPrivate->dbg, "%d :: Input  Buffer Count = %ld\n",__LINE__,nIpBuf);
2895    OMX_PRBUFFER1(pComponentPrivate->dbg, "%d :: Input  Buffer Size = %ld\n",__LINE__,nIpBufSize);
2896    OMX_PRBUFFER1(pComponentPrivate->dbg, "%d :: Output Buffer Count = %ld\n",__LINE__,nOpBuf);
2897    OMX_PRBUFFER1(pComponentPrivate->dbg, "%d :: Output Buffer Size = %ld\n",__LINE__,nOpBufSize);
2898    OMX_PRBUFFER1(pComponentPrivate->dbg, "%d :: ------ Buffer Details ------------\n",__LINE__);
2899    /* Allocate memory for all input buffer headers..
2900     * This memory pointer will be sent to LCML */
2901    size_lcml = nIpBuf * sizeof(NBAMRENC_LCML_BUFHEADERTYPE);
2902    OMX_MALLOC_SIZE(pTemp_lcml, size_lcml,NBAMRENC_LCML_BUFHEADERTYPE);
2903
2904    pComponentPrivate->pLcmlBufHeader[NBAMRENC_INPUT_PORT] = pTemp_lcml;
2905    for (i=0; i<nIpBuf; i++) {
2906        OMX_PRCOMM1(pComponentPrivate->dbg, "%d :: INPUT--------- Inside Ip Loop\n",__LINE__);
2907        pTemp = pComponentPrivate->pInputBufferList->pBufHdr[i];
2908        pTemp->nSize = sizeof(OMX_BUFFERHEADERTYPE);
2909        pTemp->nFilledLen = nIpBufSize;
2910        pTemp->nVersion.s.nVersionMajor = NBAMRENC_MAJOR_VER;
2911        pTemp->nVersion.s.nVersionMinor = NBAMRENC_MINOR_VER;
2912        pTemp->pPlatformPrivate = pHandle->pComponentPrivate;
2913        pTemp->nTickCount = NBAMRENC_NOT_USED;
2914        pTemp_lcml->buffer = pTemp;
2915        OMX_PRBUFFER2(pComponentPrivate->dbg, "%d :: pTemp_lcml->buffer->pBuffer = %p \n",__LINE__,pTemp_lcml->buffer->pBuffer);
2916        pTemp_lcml->eDir = OMX_DirInput;
2917
2918        OMX_MALLOC_SIZE_DSPALIGN(pTemp_lcml->pBufferParam, sizeof(NBAMRENC_ParamStruct), OMX_U8);
2919        pTemp_lcml->pBufferParam->usNbFrames=0;
2920        pTemp_lcml->pBufferParam->pParamElem=NULL;
2921        pTemp_lcml->pFrameParam=NULL;
2922        OMX_MALLOC_GENERIC(pTemp_lcml->pDmmBuf, DMM_BUFFER_OBJ);
2923
2924        pTemp->nFlags = NBAMRENC_NORMAL_BUFFER;
2925        pTemp++;
2926        pTemp_lcml++;
2927    }
2928
2929    /* Allocate memory for all output buffer headers..
2930     * This memory pointer will be sent to LCML */
2931    size_lcml = nOpBuf * sizeof(NBAMRENC_LCML_BUFHEADERTYPE);
2932    OMX_MALLOC_SIZE(pTemp_lcml, size_lcml,NBAMRENC_LCML_BUFHEADERTYPE);
2933
2934    pComponentPrivate->pLcmlBufHeader[NBAMRENC_OUTPUT_PORT] = pTemp_lcml;
2935    for (i=0; i<nOpBuf; i++) {
2936        OMX_PRCOMM1(pComponentPrivate->dbg, "%d :: OUTPUT--------- Inside Op Loop\n",__LINE__);
2937        pTemp = pComponentPrivate->pOutputBufferList->pBufHdr[i];
2938        pTemp->nSize = sizeof(OMX_BUFFERHEADERTYPE);
2939         pTemp->nFilledLen = nOpBufSize;
2940        pTemp->nVersion.s.nVersionMajor = NBAMRENC_MAJOR_VER;
2941        pTemp->nVersion.s.nVersionMinor = NBAMRENC_MINOR_VER;
2942        pComponentPrivate->nVersion = pTemp->nVersion.nVersion;
2943        pTemp->pPlatformPrivate = pHandle->pComponentPrivate;
2944        pTemp->nTickCount = NBAMRENC_NOT_USED;
2945        pTemp_lcml->buffer = pTemp;
2946        OMX_PRBUFFER1(pComponentPrivate->dbg, "%d :: pTemp_lcml->buffer->pBuffer = %p \n",__LINE__,pTemp_lcml->buffer->pBuffer);
2947        pTemp_lcml->eDir = OMX_DirOutput;
2948
2949        OMX_MALLOC_SIZE_DSPALIGN(pTemp_lcml->pBufferParam,
2950                                sizeof(NBAMRENC_ParamStruct),
2951                                NBAMRENC_ParamStruct);
2952        pTemp_lcml->pBufferParam->usNbFrames=0;
2953        pTemp_lcml->pBufferParam->pParamElem=NULL;
2954        pTemp_lcml->pFrameParam=NULL;
2955        OMX_MALLOC_GENERIC(pTemp_lcml->pDmmBuf, DMM_BUFFER_OBJ);
2956
2957        pTemp->nFlags = NBAMRENC_NORMAL_BUFFER;
2958        pTemp++;
2959        pTemp_lcml++;
2960    }
2961
2962    pComponentPrivate->bInitParamsInitialized = 1;
2963EXIT:
2964    OMX_PRINT1(pComponentPrivate->dbg, "%d :: Exiting NBAMRENC_FillLCMLInitParamsEx\n",__LINE__);
2965    OMX_PRINT1(pComponentPrivate->dbg, "%d :: Returning = 0x%x\n",__LINE__,eError);
2966    return eError;
2967}
2968
2969/** ========================================================================
2970*  OMX_DmmMap () method is used to allocate the memory using DMM.
2971*
2972*  @param ProcHandle -  Component identification number
2973*  @param size  - Buffer header address, that needs to be sent to codec
2974*  @param pArmPtr - Message used to send the buffer to codec
2975*  @param pDmmBuf - buffer id
2976*
2977*  @retval OMX_ErrorNone  - Success
2978*          OMX_ErrorHardware  -  Hardware Error
2979** ==========================================================================*/
2980OMX_ERRORTYPE OMX_DmmMap(DSP_HPROCESSOR ProcHandle,
2981                     int size,
2982                     void* pArmPtr,
2983                     DMM_BUFFER_OBJ* pDmmBuf,
2984                     struct OMX_TI_Debug dbg)
2985{
2986    OMX_ERRORTYPE eError = OMX_ErrorUndefined;
2987    DSP_STATUS status;
2988    int nSizeReserved = 0;
2989
2990    if(pDmmBuf == NULL)
2991    {
2992        OMX_ERROR4 (dbg, "pBuf is NULL\n");
2993        eError = OMX_ErrorBadParameter;
2994        goto EXIT;
2995    }
2996
2997    if(pArmPtr == NULL)
2998    {
2999        OMX_ERROR4 (dbg, "pBuf is NULL\n");
3000        eError = OMX_ErrorBadParameter;
3001        goto EXIT;
3002    }
3003    if(ProcHandle == NULL)
3004    {
3005        OMX_ERROR4 (dbg, "pProcHandle is NULL\n");
3006        eError = OMX_ErrorBadParameter;
3007        goto EXIT;
3008    }
3009
3010    /* Allocate */
3011    pDmmBuf->pAllocated = pArmPtr;
3012
3013    /* Reserve */
3014    nSizeReserved = ROUND_TO_PAGESIZE(size) + 2*DMM_PAGE_SIZE ;
3015
3016
3017    status = DSPProcessor_ReserveMemory(ProcHandle, nSizeReserved, &(pDmmBuf->pReserved));
3018
3019    if(DSP_FAILED(status))
3020    {
3021        OMX_ERROR4 (dbg,  "DSPProcessor_ReserveMemory() failed - error 0x%x", (int)status);
3022        eError = OMX_ErrorHardware;
3023        goto EXIT;
3024    }
3025    pDmmBuf->nSize = size;
3026    OMX_PRBUFFER2 (dbg, " DMM MAP Reserved: %p, size 0x%x (%d)\n", pDmmBuf->pReserved,nSizeReserved,nSizeReserved);
3027
3028    /* Map */
3029    status = DSPProcessor_Map(ProcHandle,
3030                              pDmmBuf->pAllocated,/* Arm addres of data to Map on DSP*/
3031                              size , /* size to Map on DSP*/
3032                              pDmmBuf->pReserved, /* reserved space */
3033                              &(pDmmBuf->pMapped), /* returned map pointer */
3034                              0); /* final param is reserved.  set to zero. */
3035    if(DSP_FAILED(status))
3036    {
3037        OMX_ERROR4 (dbg, "DSPProcessor_Map() failed - error 0x%x", (int)status);
3038        eError = OMX_ErrorHardware;
3039        goto EXIT;
3040    }
3041    OMX_PRBUFFER2 (dbg, "DMM Mapped: %p, size 0x%x (%d)\n",pDmmBuf->pMapped, size,size);
3042
3043    /* Issue an initial memory flush to ensure cache coherency */
3044    status = DSPProcessor_FlushMemory(ProcHandle, pDmmBuf->pAllocated, size, 0);
3045    if(DSP_FAILED(status))
3046    {
3047        OMX_ERROR4 (dbg, "Unable to flush mapped buffer: error 0x%x",(int)status);
3048        goto EXIT;
3049    }
3050    eError = OMX_ErrorNone;
3051
3052EXIT:
3053   return eError;
3054}
3055
3056/** ========================================================================
3057*  OMX_DmmUnMap () method is used to de-allocate the memory using DMM.
3058*
3059*  @param ProcHandle -  Component identification number
3060*  @param pMapPtr  - Map address
3061*  @param pResPtr - reserve adress
3062*
3063*  @retval OMX_ErrorNone  - Success
3064*          OMX_ErrorHardware  -  Hardware Error
3065** ==========================================================================*/
3066OMX_ERRORTYPE OMX_DmmUnMap(DSP_HPROCESSOR ProcHandle, void* pMapPtr, void* pResPtr, struct OMX_TI_Debug dbg)
3067{
3068    DSP_STATUS status = DSP_SOK;
3069    OMX_ERRORTYPE eError = OMX_ErrorNone;
3070    if(pMapPtr == NULL)
3071    {
3072        OMX_ERROR4(dbg, "pMapPtr is NULL\n");
3073        eError = OMX_ErrorBadParameter;
3074        goto EXIT;
3075    }
3076    if(pResPtr == NULL)
3077    {
3078        OMX_ERROR4(dbg, "pResPtr is NULL\n");
3079        OMXDBG_PRINT(stderr, ERROR, 4, 0, "pResPtr is NULL\n");
3080        eError = OMX_ErrorBadParameter;
3081        goto EXIT;
3082    }
3083    if(ProcHandle == NULL)
3084    {
3085        OMX_ERROR4 (dbg, "--ProcHandle is NULL\n");
3086        eError = OMX_ErrorBadParameter;
3087        goto EXIT;
3088    }
3089
3090    status = DSPProcessor_UnMap(ProcHandle,pMapPtr);
3091    if(DSP_FAILED(status))
3092    {
3093        OMX_ERROR4 (dbg, "DSPProcessor_UnMap() failed - error 0x%x",(int)status);
3094    }
3095
3096    OMX_PRSTATE2 (dbg, "unreserving  structure =0x%p\n",pResPtr);
3097    status = DSPProcessor_UnReserveMemory(ProcHandle,pResPtr);
3098    if(DSP_FAILED(status))
3099    {
3100        OMX_ERROR4 (dbg, "DSPProcessor_UnReserveMemory() failed - error 0x%x", (int)status);
3101    }
3102
3103EXIT:
3104    return eError;
3105}
3106
3107
3108#ifdef RESOURCE_MANAGER_ENABLED
3109void NBAMRENC_ResourceManagerCallback(RMPROXY_COMMANDDATATYPE cbData)
3110{
3111    OMX_COMMANDTYPE Cmd = OMX_CommandStateSet;
3112    OMX_STATETYPE state = OMX_StateIdle;
3113    OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)cbData.hComponent;
3114    AMRENC_COMPONENT_PRIVATE *pCompPrivate = NULL;
3115
3116    pCompPrivate = (AMRENC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
3117
3118    if (*(cbData.RM_Error) == OMX_RmProxyCallback_ResourcesPreempted) {
3119        if (pCompPrivate->curState == OMX_StateExecuting ||
3120            pCompPrivate->curState == OMX_StatePause) {
3121            write (pCompPrivate->cmdPipe[1], &Cmd, sizeof(Cmd));
3122            write (pCompPrivate->cmdDataPipe[1], &state ,sizeof(OMX_U32));
3123
3124            pCompPrivate->bPreempted = 1;
3125        }
3126    }
3127    else if (*(cbData.RM_Error) == OMX_RmProxyCallback_ResourcesAcquired){
3128        pCompPrivate->cbInfo.EventHandler (
3129                            pHandle, pHandle->pApplicationPrivate,
3130                            OMX_EventResourcesAcquired, 0,0,
3131                            NULL);
3132
3133    }
3134}
3135#endif
3136
3137void NBAMRENC_HandleUSNError (AMRENC_COMPONENT_PRIVATE *pComponentPrivate, OMX_U32 arg)
3138{
3139    OMX_COMPONENTTYPE *pHandle = NULL;
3140    OMX_U8 pending_buffers = OMX_FALSE;
3141    OMX_U32 i;
3142    switch (arg)
3143    {
3144        case IUALG_WARN_CONCEALED:
3145        case IUALG_WARN_UNDERFLOW:
3146        case IUALG_WARN_OVERFLOW:
3147        case IUALG_WARN_ENDOFDATA:
3148            /* all of these are informative messages, Algo can recover, no need to notify the
3149             * IL Client at this stage of the implementation */
3150            break;
3151
3152        case IUALG_WARN_PLAYCOMPLETED:
3153        {
3154            pHandle = pComponentPrivate->pHandle;
3155            OMX_PRDSP2(pComponentPrivate->dbg, "%d :: GOT MESSAGE IUALG_WARN_PLAYCOMPLETED\n",__LINE__);
3156            OMX_PRINT2(pComponentPrivate->dbg, "IUALG_WARN_PLAYCOMPLETED Received\n");
3157            if(pComponentPrivate->LastOutbuf!=NULL){
3158                pComponentPrivate->LastOutbuf->nFlags |= OMX_BUFFERFLAG_EOS;
3159            }
3160            pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
3161                            pComponentPrivate->pHandle->pApplicationPrivate,
3162                            OMX_EventBufferFlag,
3163                            (OMX_U32)NULL,
3164                            OMX_BUFFERFLAG_EOS,
3165                            NULL);
3166        }
3167            break;
3168
3169#ifdef _ERROR_PROPAGATION__
3170        case IUALG_ERR_BAD_HANDLE:
3171        case IUALG_ERR_DATA_CORRUPT:
3172        case IUALG_ERR_NOT_SUPPORTED:
3173        case IUALG_ERR_ARGUMENT:
3174        case IUALG_ERR_NOT_READY:
3175        case IUALG_ERR_GENERAL:
3176        {
3177        /* all of these are fatal messages, Algo can not recover
3178                 * hence return an error */
3179                pComponentPrivate->bIsInvalidState=OMX_TRUE;
3180                pComponentPrivate->curState = OMX_StateInvalid;
3181                pHandle = pComponentPrivate->pHandle;
3182                pComponentPrivate->cbInfo.EventHandler(pHandle,
3183                        pHandle->pApplicationPrivate,
3184                        OMX_EventError,
3185                        OMX_ErrorInvalidState,
3186                        OMX_TI_ErrorSevere,
3187                        NULL);
3188            }
3189            break;
3190#endif
3191        default:
3192            break;
3193    }
3194}
3195OMX_ERRORTYPE AddStateTransition(AMRENC_COMPONENT_PRIVATE *pComponentPrivate) {
3196    OMX_ERRORTYPE eError = OMX_ErrorNone;
3197
3198    if(pthread_mutex_lock(&pComponentPrivate->mutexStateChangeRequest)) {
3199       return OMX_ErrorUndefined;
3200    }
3201    /* Increment state change request reference count */
3202    pComponentPrivate->nPendingStateChangeRequests++;
3203    LOGI("addstatetranstion: %ld @ %d", pComponentPrivate->nPendingStateChangeRequests, pComponentPrivate->curState);
3204
3205    if(pthread_mutex_unlock(&pComponentPrivate->mutexStateChangeRequest)) {
3206       return OMX_ErrorUndefined;
3207    }
3208    return eError;
3209}
3210
3211OMX_ERRORTYPE RemoveStateTransition(AMRENC_COMPONENT_PRIVATE *pComponentPrivate, OMX_BOOL bEnableSignal) {
3212    OMX_ERRORTYPE eError = OMX_ErrorNone;
3213
3214     /* Decrement state change request reference count*/
3215    if(pthread_mutex_lock(&pComponentPrivate->mutexStateChangeRequest)) {
3216       return OMX_ErrorUndefined;
3217    }
3218    pComponentPrivate->nPendingStateChangeRequests--;
3219
3220    LOGI("removestatetransition: %ld @ %d", pComponentPrivate->nPendingStateChangeRequests, pComponentPrivate->curState);
3221    /* If there are no more pending requests, signal the thread waiting on this*/
3222    if(!pComponentPrivate->nPendingStateChangeRequests && bEnableSignal) {
3223       pthread_cond_signal(&(pComponentPrivate->StateChangeCondition));
3224    }
3225    if(pthread_mutex_unlock(&pComponentPrivate->mutexStateChangeRequest)) {
3226       return OMX_ErrorUndefined;
3227    }
3228
3229    return eError;
3230}
3231
3232