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_G726Dec_Utils.c
30 *
31 * This file implements various utilitiy functions for various activities
32 * like handling command from application, callback from LCML etc.
33 *
34 * @path  $(CSLPATH)\OMAPSW_MPU\linux\audio\src\openmax_il\g726_dec\src
35 *
36 * @rev  1.0
37 */
38/* ----------------------------------------------------------------------------
39 *!
40 *! Revision History
41 *! ===================================
42 *! 21-sept-2006 bk: updated some 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 *! This is newest file
46 * =========================================================================== */
47/* ------compilation control switches -------------------------*/
48/****************************************************************
49 *  INCLUDE FILES
50 ****************************************************************/
51/* ----- system and platform files ----------------------------*/
52
53#ifdef UNDER_CE
54#include <windows.h>
55#include <oaf_osal.h>
56#include <omx_core.h>
57#include <stdlib.h>
58#else
59#include <unistd.h>
60#include <sys/types.h>
61#include <sys/stat.h>
62#include <dlfcn.h>
63#include <malloc.h>
64#include <memory.h>
65#include <fcntl.h>
66#endif
67
68#include <pthread.h>
69#include <dbapi.h>
70#include <string.h>
71#include <stdio.h>
72
73/*------- Program Header Files -----------------------------------------------*/
74#include "LCML_DspCodec.h"
75#include "OMX_G726Dec_Utils.h"
76#include "g726decsocket_ti.h"
77
78#ifdef RESOURCE_MANAGER_ENABLED
79#include <ResourceManagerProxyAPI.h>
80#endif
81
82
83#ifdef UNDER_CE
84#define HASHINGENABLE 1
85#endif
86
87#ifndef UNDER_CE
88#define G726DEC_DPRINT_ON(...)  fprintf(stdout, "%s %d::  ",__FUNCTION__, __LINE__); \
89    fprintf(stdout, __VA_ARGS__);                                       \
90    fprintf(stdout, "\n");
91#endif
92
93/* ================================================================================= * */
94/**
95 * @fn G726DEC_Fill_LCMLInitParams() fills the LCML initialization structure.
96 *
97 * @param pHandle This is component handle allocated by the OMX core.
98 *
99 * @param plcml_Init This structure is filled and sent to LCML.
100 *
101 * @pre          None
102 *
103 * @post         None
104 *
105 *  @return      OMX_ErrorNone = Successful Inirialization of the LCML struct.
106 *               OMX_ErrorInsufficientResources = Not enough memory
107 *
108 *  @see         None
109 */
110/* ================================================================================ * */
111OMX_ERRORTYPE G726DEC_Fill_LCMLInitParams(OMX_HANDLETYPE pComponent,
112                                          LCML_DSP *plcml_Init, OMX_U16 arr[])
113{
114    OMX_ERRORTYPE eError = OMX_ErrorNone;
115    OMX_U32 nIpBuf = 0,nIpBufSize = 0,nOpBuf = 0,nOpBufSize = 0;
116    OMX_U32 i = 0;
117    OMX_BUFFERHEADERTYPE *pTemp = NULL;
118    OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)pComponent;
119    G726DEC_COMPONENT_PRIVATE *pComponentPrivate =
120        (G726DEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
121    G726D_LCML_BUFHEADERTYPE *pTemp_lcml = NULL;
122    OMX_U32 size_lcml = 0;
123    /*int inputPortFlag=0,outputPortFlag=0;*/
124    LCML_STRMATTR *strmAttr = NULL;
125    OMX_U8 *ptemp = NULL;
126
127    G726DEC_DPRINT(":: Entered Fill_LCMLInitParams");
128
129    G726DEC_DPRINT("%d :: OMX_StateLoaded [G726D_INPUT_PORT]->bPopulated  %d \n",
130                   __LINE__,pComponentPrivate->pPortDef[G726D_INPUT_PORT]->bPopulated);
131    G726DEC_DPRINT("%d :: OMX_StateLoaded [G726D_INPUT_PORT]->bEnabled    %d \n",
132                   __LINE__,pComponentPrivate->pPortDef[G726D_INPUT_PORT]->bEnabled);
133    G726DEC_DPRINT("%d :: OMX_StateLoaded [G726D_OUTPUT_PORT]->bPopulated %d \n",
134                   __LINE__,pComponentPrivate->pPortDef[G726D_OUTPUT_PORT]->bPopulated);
135    G726DEC_DPRINT("%d :: OMX_StateLoaded [G726D_OUTPUT_PORT]->bEnabled   %d \n",
136                   __LINE__,pComponentPrivate->pPortDef[G726D_OUTPUT_PORT]->bEnabled);
137
138    pComponentPrivate->strmAttr = NULL;
139
140    nIpBuf = pComponentPrivate->pInputBufferList->numBuffers;
141    pComponentPrivate->nRuntimeInputBuffers = nIpBuf;
142    nOpBuf = pComponentPrivate->pOutputBufferList->numBuffers;
143    pComponentPrivate->nRuntimeOutputBuffers = nOpBuf;
144    nIpBufSize = pComponentPrivate->pPortDef[G726D_INPUT_PORT]->nBufferSize;
145    nOpBufSize = pComponentPrivate->pPortDef[G726D_OUTPUT_PORT]->nBufferSize;
146
147    G726DEC_BUFPRINT("Input Buffer Count = %ld\n",nIpBuf);
148    G726DEC_BUFPRINT("Input Buffer Size = %ld\n",nIpBufSize);
149    G726DEC_BUFPRINT("LCML::Output Buffer Count = %ld\n",nOpBuf);
150    G726DEC_BUFPRINT("Output Buffer Size = %ld\n",nOpBufSize);
151
152    plcml_Init->In_BufInfo.nBuffers = nIpBuf;
153    plcml_Init->In_BufInfo.nSize = nIpBufSize;
154    plcml_Init->In_BufInfo.DataTrMethod = DMM_METHOD;
155    plcml_Init->Out_BufInfo.nBuffers = nOpBuf;
156    plcml_Init->Out_BufInfo.nSize = nOpBufSize;
157    plcml_Init->Out_BufInfo.DataTrMethod = DMM_METHOD;
158
159    G726D_OMX_MALLOC_SIZE(pComponentPrivate->pParams,(sizeof(G726D_USN_AudioCodecParams) + 256),
160                          G726D_USN_AudioCodecParams);
161    ptemp = (OMX_U8*)pComponentPrivate->pParams;
162    ptemp += 128;
163    pComponentPrivate->pParams = (G726D_USN_AudioCodecParams*)ptemp;
164
165
166    plcml_Init->NodeInfo.nNumOfDLLs = 3;
167
168    memset(plcml_Init->NodeInfo.AllUUIDs[0].DllName,0,
169           sizeof(plcml_Init->NodeInfo.AllUUIDs[0].DllName));
170    memset(plcml_Init->NodeInfo.AllUUIDs[1].DllName,0,
171           sizeof(plcml_Init->NodeInfo.AllUUIDs[1].DllName));
172    memset(plcml_Init->NodeInfo.AllUUIDs[2].DllName,0,
173           sizeof(plcml_Init->NodeInfo.AllUUIDs[1].DllName));
174    memset(plcml_Init->NodeInfo.AllUUIDs[0].DllName,0,
175           sizeof(plcml_Init->DeviceInfo.AllUUIDs[1].DllName));
176
177    plcml_Init->NodeInfo.AllUUIDs[0].uuid = &G726DECSOCKET_TI_UUID;
178    strcpy ((char*)plcml_Init->NodeInfo.AllUUIDs[0].DllName, G726DEC_DLL_NAME);
179    plcml_Init->NodeInfo.AllUUIDs[0].eDllType = DLL_NODEOBJECT;
180
181    plcml_Init->NodeInfo.AllUUIDs[1].uuid = &G726DECSOCKET_TI_UUID;
182    strcpy ((char*)plcml_Init->NodeInfo.AllUUIDs[1].DllName, G726DEC_DLL_NAME);
183    plcml_Init->NodeInfo.AllUUIDs[1].eDllType = DLL_DEPENDENT;
184
185    plcml_Init->NodeInfo.AllUUIDs[2].uuid = &USN_TI_UUID;
186    strcpy ((char*)plcml_Init->NodeInfo.AllUUIDs[2].DllName, USN_DLL_NAME);
187    plcml_Init->NodeInfo.AllUUIDs[2].eDllType = DLL_DEPENDENT;
188
189    plcml_Init->SegID = OMX_G726DEC_DEFAULT_SEGMENT;
190    plcml_Init->Timeout = OMX_G726DEC_SN_TIMEOUT;
191    plcml_Init->Alignment = 0;
192    plcml_Init->Priority = OMX_G726DEC_SN_PRIORITY;
193    plcml_Init->ProfileID = 0;
194
195
196
197    G726DEC_BUFPRINT("DLL name0 = %s\n",plcml_Init->NodeInfo.AllUUIDs[0].DllName);
198    G726DEC_BUFPRINT("DLL name1 = %s\n",plcml_Init->NodeInfo.AllUUIDs[1].DllName);
199    G726DEC_BUFPRINT("DLL name2 = %s\n",plcml_Init->NodeInfo.AllUUIDs[2].DllName);
200
201    if(pComponentPrivate->dasfmode == 1) {
202#ifndef DSP_RENDERING_ON
203        G726D_OMX_ERROR_EXIT(eError, OMX_ErrorInsufficientResources,
204                             "Flag DSP_RENDERING_ON Must Be Defined To Use Rendering");
205#else
206        G726D_OMX_MALLOC(strmAttr,LCML_STRMATTR);
207        pComponentPrivate->strmAttr = strmAttr;
208        G726DEC_DPRINT(":: G726 DECODER IS RUNNING UNDER DASF MODE \n");
209        strmAttr->uSegid = OMX_G726DEC_DEFAULT_SEGMENT;
210        strmAttr->uAlignment = 0;
211        strmAttr->uTimeout = OMX_G726DEC_SN_TIMEOUT;
212        strmAttr->uBufsize = nOpBufSize;
213        strmAttr->uNumBufs = 2;  /*G726D_NUM_OUTPUT_BUFFERS;*/
214        strmAttr->lMode = STRMMODE_PROCCOPY;
215        plcml_Init->DeviceInfo.TypeofDevice = 1;
216        plcml_Init->DeviceInfo.TypeofRender = 0;
217        plcml_Init->DeviceInfo.AllUUIDs[0].uuid = &DCTN_TI_UUID;
218        plcml_Init->DeviceInfo.DspStream = strmAttr;
219#endif
220    } else {
221        plcml_Init->DeviceInfo.TypeofDevice = 0;
222    }
223    if (pComponentPrivate->dasfmode == 0){
224        G726DEC_DPRINT(":: FILE MODE CREATE PHASE PARAMETERS\n");
225        arr[0] = 2;
226        arr[1] = 0;
227        arr[2] = 0;
228        if(pComponentPrivate->pInputBufferList->numBuffers == 0) {
229            arr[3] = G726D_NUM_INPUT_BUFFERS;
230        } else {
231            arr[3] = (OMX_U16) nIpBuf;
232        }
233        arr[4] = 1;
234        arr[5] = 0;
235        if(pComponentPrivate->pOutputBufferList->numBuffers == 0) {
236            arr[6] = G726D_NUM_OUTPUT_BUFFERS;
237        } else {
238            arr[6] = (OMX_U16) nOpBuf;
239        }
240    } else {
241        G726DEC_DPRINT(":: DASF MODE CREATE PHASE PARAMETERS\n");
242        arr[0] = 2;
243        arr[1] = 0;
244        arr[2] = 0;
245
246        if(pComponentPrivate->pInputBufferList->numBuffers == 0) {
247            arr[3] = G726D_NUM_INPUT_BUFFERS;
248        } else {
249            arr[3] = (OMX_U16) nIpBuf;
250        }
251        arr[4] = 1;
252        arr[5] = 2;
253        arr[6] = 2;
254    }
255    /* TO DO: dynamically adjust arr[7] arr[8] for bit rate and packing mode */
256    if (pComponentPrivate->G726Params->eG726Mode == OMX_AUDIO_G726Mode16){
257        G726DEC_DPRINT("setting bit rate = 0\n");
258        arr[7] = 0;
259    }
260    else if (pComponentPrivate->G726Params->eG726Mode == OMX_AUDIO_G726Mode24){
261        G726DEC_DPRINT("setting bit rate = 1\n");
262        arr[7] = 1;
263    }
264    else if (pComponentPrivate->G726Params->eG726Mode == OMX_AUDIO_G726Mode32){
265        G726DEC_DPRINT("setting bit rate = 2\n");
266        arr[7] = 2;
267    }
268    else if (pComponentPrivate->G726Params->eG726Mode == OMX_AUDIO_G726Mode40){
269        G726DEC_DPRINT("setting bit rate = 3\n");
270        arr[7] = 3;
271    }
272    arr[8] = pComponentPrivate->packingType; /* 0 = linear, 1 = rtp packing */
273    G726DEC_DPRINT("Using arr[8] = %d packing type\n", arr[8]);
274    arr[9] = END_OF_CR_PHASE_ARGS;
275    plcml_Init->pCrPhArgs = arr;
276    G726DEC_DPRINT(":: bufAlloced = %d\n",pComponentPrivate->bufAlloced);
277    size_lcml = nIpBuf * sizeof(G726D_LCML_BUFHEADERTYPE);
278    G726D_OMX_MALLOC_SIZE(pTemp_lcml,size_lcml,G726D_LCML_BUFHEADERTYPE);
279    pComponentPrivate->pLcmlBufHeader[G726D_INPUT_PORT] = pTemp_lcml;
280
281    for (i=0; i<nIpBuf; i++) {
282
283        pTemp = pComponentPrivate->pInputBufferList->pBufHdr[i];
284
285        pTemp->nSize = sizeof(OMX_BUFFERHEADERTYPE);
286        G726DEC_DPRINT("IP: pTemp->nSize = %ld\n",pTemp->nSize);
287
288        /*pTemp->nAllocLen = nIpBufSize;*/
289        pTemp->nFilledLen = nIpBufSize;
290        pTemp->nVersion.s.nVersionMajor = G726DEC_MAJOR_VER;
291        pTemp->nVersion.s.nVersionMinor = G726DEC_MINOR_VER;
292
293        pTemp->pPlatformPrivate = pHandle->pComponentPrivate;
294        pTemp->nTickCount = DONT_CARE;
295
296        pTemp_lcml->pBufHdr = pTemp;
297        pTemp_lcml->eDir = OMX_DirInput;
298        pTemp_lcml->pOtherParams[i] = NULL;
299
300        G726D_OMX_MALLOC(pTemp_lcml->pFrameParam,G726DEC_UAlgInBufParamStruct);
301
302
303
304        pTemp->nFlags = NORMAL_BUFFER;
305        ((G726DEC_COMPONENT_PRIVATE *) pTemp->pPlatformPrivate)->pHandle = pHandle;
306
307        G726DEC_DPRINT("::Comp: InBuffHeader[%ld] = %p\n", i, pTemp);
308        G726DEC_DPRINT("::Comp:  >>>> InputBuffHeader[%ld]->pBuffer = %p\n", i, pTemp->pBuffer);
309        G726DEC_DPRINT("::Comp: Ip : pTemp_lcml[%ld] = %p\n", i, pTemp_lcml);
310        pTemp_lcml++;
311    }
312
313    size_lcml = nOpBuf * sizeof(G726D_LCML_BUFHEADERTYPE);
314    G726D_OMX_MALLOC_SIZE(pTemp_lcml,size_lcml,G726D_LCML_BUFHEADERTYPE);
315
316    pComponentPrivate->pLcmlBufHeader[G726D_OUTPUT_PORT] = pTemp_lcml;
317
318    for (i=0; i<nOpBuf; i++) {
319        pTemp = pComponentPrivate->pOutputBufferList->pBufHdr[i];
320        pTemp->nSize = sizeof(OMX_BUFFERHEADERTYPE);
321        pTemp->nAllocLen = nOpBufSize;
322        pTemp->nVersion.s.nVersionMajor = G726DEC_MAJOR_VER;
323        pTemp->nVersion.s.nVersionMinor = G726DEC_MINOR_VER;
324        pTemp->pPlatformPrivate = pHandle->pComponentPrivate;
325        pTemp->nTickCount = DONT_CARE;
326
327        pTemp_lcml->pBufHdr = pTemp;
328        pTemp_lcml->eDir = OMX_DirOutput;
329        pTemp_lcml->pOtherParams[i] = NULL;
330
331        pTemp->nFlags = NORMAL_BUFFER;
332        ((G726DEC_COMPONENT_PRIVATE *)pTemp->pPlatformPrivate)->pHandle = pHandle;
333        G726DEC_DPRINT("::Comp:  >>>>>>>>>>>>> OutBuffHeader[%ld] = %p\n", i, pTemp);
334        G726DEC_DPRINT("::Comp:  >>>> OutBuffHeader[%ld]->pBuffer = %p\n", i, pTemp->pBuffer);
335        G726DEC_DPRINT("::Comp: Op : pTemp_lcml[%ld] = %p\n", i, pTemp_lcml);
336        pTemp_lcml++;
337    }
338
339    pComponentPrivate->bPortDefsAllocated = 1;
340    pComponentPrivate->bInitParamsInitialized = 1;
341
342 EXIT:
343    if(eError == OMX_ErrorInsufficientResources || eError == OMX_ErrorBadParameter){
344        G726D_OMX_FREE(strmAttr);
345        G726D_OMX_FREE(pTemp_lcml);
346    }
347    G726DEC_DPRINT("Exiting G726DEC_Fill_LCMLInitParams\n");
348    return eError;
349}
350
351/* ================================================================================= * */
352/**
353 * @fn G726Dec_StartCompThread() starts the component thread. This is internal
354 * function of the component.
355 *
356 * @param pHandle This is component handle allocated by the OMX core.
357 *
358 * @pre          None
359 *
360 * @post         None
361 *
362 *  @return      OMX_ErrorNone = Successful Inirialization of the component\n
363 *               OMX_ErrorInsufficientResources = Not enough memory
364 *
365 *  @see         None
366 */
367/* ================================================================================ * */
368OMX_ERRORTYPE G726Dec_StartCompThread(OMX_HANDLETYPE pComponent)
369{
370    OMX_ERRORTYPE eError = OMX_ErrorNone;
371    OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)pComponent;
372    G726DEC_COMPONENT_PRIVATE *pComponentPrivate =
373        (G726DEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
374    int nRet = 0;
375#ifdef UNDER_CE
376    pthread_attr_t attr;
377    memset(&attr, 0, sizeof(attr));
378    attr.__inheritsched = PTHREAD_EXPLICIT_SCHED;
379    attr.__schedparam.__sched_priority = OMX_AUDIO_DECODER_THREAD_PRIORITY;
380#endif
381
382    G726DEC_DPRINT (":: Enetering  G726Dec_StartCompThread()\n");
383
384    pComponentPrivate->lcml_nOpBuf = 0;
385    pComponentPrivate->lcml_nIpBuf = 0;
386    pComponentPrivate->app_nBuf = 0;
387    pComponentPrivate->num_Op_Issued = 0;
388    pComponentPrivate->num_Sent_Ip_Buff = 0;
389    pComponentPrivate->num_Reclaimed_Op_Buff = 0;
390    pComponentPrivate->bIsEOFSent = 0;
391
392    nRet = pipe (pComponentPrivate->dataPipe);
393    if (0 != nRet) {
394        G726D_OMX_ERROR_EXIT(eError, OMX_ErrorInsufficientResources,
395                             "Pipe Creation Failed");
396    }
397
398    nRet = pipe (pComponentPrivate->cmdPipe);
399    if (0 != nRet) {
400        G726D_OMX_ERROR_EXIT(eError, OMX_ErrorInsufficientResources,
401                             "Pipe Creation Failed");
402    }
403
404    nRet = pipe (pComponentPrivate->cmdDataPipe);
405    if (0 != nRet) {
406        G726D_OMX_ERROR_EXIT(eError, OMX_ErrorInsufficientResources,
407                             "Pipe Creation Failed");
408    }
409
410#ifdef UNDER_CE
411    nRet = pthread_create (&(pComponentPrivate->ComponentThread), &attr,
412                           G726DEC_ComponentThread, pComponentPrivate);
413#else
414    nRet = pthread_create (&(pComponentPrivate->ComponentThread), NULL,
415                           G726DEC_ComponentThread, pComponentPrivate);
416#endif
417    if ((0 != nRet) || (!pComponentPrivate->ComponentThread)) {
418        G726D_OMX_ERROR_EXIT(eError, OMX_ErrorInsufficientResources,
419                             "Thread Creation Failed");
420    }
421
422    pComponentPrivate->bCompThreadStarted = 1;
423    G726DEC_DPRINT (":: Exiting from G726Dec_StartCompThread()\n");
424
425 EXIT:
426    return eError;
427}
428
429
430/* ================================================================================= * */
431/**
432 * @fn G726DEC_FreeCompResources() function frees the component resources.
433 *
434 * @param pComponent This is the component handle.
435 *
436 * @pre          None
437 *
438 * @post         None
439 *
440 *  @return      OMX_ErrorNone = Successful Inirialization of the component\n
441 *               OMX_ErrorHardware = Hardware error has occured.
442 *
443 *  @see         None
444 */
445/* ================================================================================ * */
446OMX_ERRORTYPE G726DEC_FreeCompResources(OMX_HANDLETYPE pComponent)
447{
448    OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)pComponent;
449    G726DEC_COMPONENT_PRIVATE *pComponentPrivate = (G726DEC_COMPONENT_PRIVATE *)
450        pHandle->pComponentPrivate;
451    OMX_ERRORTYPE eError = OMX_ErrorNone;
452    OMX_U32 nIpBuf=0, nOpBuf=0;
453    int nRet=0;
454
455    G726DEC_DPRINT (":: G726Dec_FreeCompResources\n");
456
457    G726DEC_DPRINT(":::pComponentPrivate->bPortDefsAllocated = %ld\n",
458                   pComponentPrivate->bPortDefsAllocated);
459    if (pComponentPrivate->bPortDefsAllocated) {
460        nIpBuf = pComponentPrivate->pInputBufferList->numBuffers;
461        nOpBuf = pComponentPrivate->pOutputBufferList->numBuffers;
462    }
463    G726DEC_DPRINT(":: Closing pipess.....\n");
464
465    nRet = close (pComponentPrivate->dataPipe[0]);
466    if (0 != nRet && OMX_ErrorNone == eError) {
467        eError = OMX_ErrorHardware;
468    }
469
470    nRet = close (pComponentPrivate->dataPipe[1]);
471    if (0 != nRet && OMX_ErrorNone == eError) {
472        eError = OMX_ErrorHardware;
473    }
474
475    nRet = close (pComponentPrivate->cmdPipe[0]);
476    if (0 != nRet && OMX_ErrorNone == eError) {
477        eError = OMX_ErrorHardware;
478    }
479
480    nRet = close (pComponentPrivate->cmdPipe[1]);
481    if (0 != nRet && OMX_ErrorNone == eError) {
482        eError = OMX_ErrorHardware;
483    }
484
485    nRet = close (pComponentPrivate->cmdDataPipe[0]);
486    if (0 != nRet && OMX_ErrorNone == eError) {
487        eError = OMX_ErrorHardware;
488    }
489
490    nRet = close (pComponentPrivate->cmdDataPipe[1]);
491    if (0 != nRet && OMX_ErrorNone == eError) {
492        eError = OMX_ErrorHardware;
493    }
494
495    if (pComponentPrivate->bPortDefsAllocated) {
496        G726D_OMX_FREE(pComponentPrivate->pPortDef[G726D_INPUT_PORT]);
497        G726D_OMX_FREE(pComponentPrivate->pPortDef[G726D_OUTPUT_PORT]);
498        G726D_OMX_FREE(pComponentPrivate->G726Params);
499        G726D_OMX_FREE(pComponentPrivate->PcmParams);
500        G726D_OMX_FREE(pComponentPrivate->pCompPort[G726D_INPUT_PORT]->pPortFormat);
501        G726D_OMX_FREE(pComponentPrivate->pCompPort[G726D_OUTPUT_PORT]->pPortFormat);
502        G726D_OMX_FREE(pComponentPrivate->pCompPort[G726D_INPUT_PORT]);
503        G726D_OMX_FREE(pComponentPrivate->pCompPort[G726D_OUTPUT_PORT]);
504        G726D_OMX_FREE(pComponentPrivate->sPortParam);
505        G726D_OMX_FREE(pComponentPrivate->pPriorityMgmt);
506        G726D_OMX_FREE(pComponentPrivate->pInputBufferList);
507        G726D_OMX_FREE(pComponentPrivate->pOutputBufferList);
508        G726D_OMX_FREE(pComponentPrivate->componentRole);
509    }
510
511    pComponentPrivate->bPortDefsAllocated = 0;
512
513#ifndef UNDER_CE
514    G726DEC_DPRINT("\n\n FreeCompResources: Destroying mutexes.\n\n");
515    pthread_mutex_destroy(&pComponentPrivate->InLoaded_mutex);
516    pthread_cond_destroy(&pComponentPrivate->InLoaded_threshold);
517
518    pthread_mutex_destroy(&pComponentPrivate->InIdle_mutex);
519    pthread_cond_destroy(&pComponentPrivate->InIdle_threshold);
520
521    pthread_mutex_destroy(&pComponentPrivate->AlloBuf_mutex);
522    pthread_cond_destroy(&pComponentPrivate->AlloBuf_threshold);
523#else
524    OMX_DestroyEvent(&(pComponentPrivate->InLoaded_event));
525    OMX_DestroyEvent(&(pComponentPrivate->InIdle_event));
526    OMX_DestroyEvent(&(pComponentPrivate->AlloBuf_event));
527#endif
528
529    return eError;
530}
531
532/* ================================================================================= * */
533/**
534 * @fn G726DEC_HandleCommand() function handles the command sent by the application.
535 * All the state transitions, except from nothing to loaded state, of the
536 * component are done by this function.
537 *
538 * @param pComponentPrivate  This is component's private date structure.
539 *
540 * @pre          None
541 *
542 * @post         None
543 *
544 *  @return      OMX_ErrorNone = Successful processing.
545 *               OMX_ErrorInsufficientResources = Not enough memory
546 *               OMX_ErrorHardware = Hardware error has occured lile LCML failed
547 *               to do any said operartion.
548 *
549 *  @see         None
550 */
551/* ================================================================================ * */
552OMX_U32 G726DEC_HandleCommand (G726DEC_COMPONENT_PRIVATE *pComponentPrivate)
553{
554    OMX_U32 i = 0,ret = 0;
555    OMX_ERRORTYPE eError = OMX_ErrorNone;
556    char *pArgs = "damedesuStr";
557    OMX_COMPONENTTYPE *pHandle =
558        (OMX_COMPONENTTYPE *) pComponentPrivate->pHandle;
559    OMX_COMMANDTYPE command;
560    OMX_STATETYPE commandedState = OMX_StateInvalid;
561    OMX_U32 commandData = 0;
562    OMX_HANDLETYPE pLcmlHandle = pComponentPrivate->pLcmlHandle;
563    OMX_U16 arr[10] = {0};
564
565#ifdef RESOURCE_MANAGER_ENABLED
566    OMX_ERRORTYPE rm_error = OMX_ErrorNone;
567#endif
568    G726DEC_DPRINT (":: >>> Entering HandleCommand Function\n");
569
570    ret = read (pComponentPrivate->cmdPipe[0], &command, sizeof (command));
571    if(ret == -1){
572        G726DEC_DPRINT ("%d :: Error in Reading from the Data pipe\n", __LINE__);
573        eError = OMX_ErrorHardware;
574        goto EXIT;
575    }
576    ret = read (pComponentPrivate->cmdDataPipe[0], &commandData, sizeof (commandData));
577    if(ret == -1){
578        G726DEC_DPRINT ("%d :: Error in Reading from the Data pipe\n", __LINE__);
579        eError = OMX_ErrorHardware;
580        goto EXIT;
581    }
582    G726DEC_DPRINT("---------------------------------------------\n");
583    G726DEC_DPRINT(":: command = %d\n",command);
584    G726DEC_DPRINT(":: commandData = %ld\n",commandData);
585    G726DEC_DPRINT("---------------------------------------------\n");
586
587    if (command == OMX_CommandStateSet) {
588        commandedState = (OMX_STATETYPE)commandData;
589        if (pComponentPrivate->curState == commandedState) {
590            pComponentPrivate->cbInfo.EventHandler (pHandle, pHandle->pApplicationPrivate,
591                                                    OMX_EventError, OMX_ErrorSameState,0,
592                                                    NULL);
593            G726DEC_DPRINT(":: Error: Same State Given by Application\n");
594        } else {
595            switch(commandedState) {
596            case OMX_StateIdle:
597                G726DEC_DPRINT(": HandleCommand: Cmd Idle \n");
598                if (pComponentPrivate->curState == OMX_StateLoaded || pComponentPrivate->curState == OMX_StateWaitForResources) {
599                    LCML_CALLBACKTYPE cb;
600                    LCML_DSP *pLcmlDsp = NULL;
601                    char *p = "damedesuStr";
602                    int inputPortFlag=0,outputPortFlag=0;
603
604                    if (pComponentPrivate->dasfmode == 1) {
605                        pComponentPrivate->pPortDef[G726D_OUTPUT_PORT]->bEnabled= FALSE;
606                        pComponentPrivate->pPortDef[G726D_OUTPUT_PORT]->bPopulated= FALSE;
607                        if(pComponentPrivate->streamID == 0) {
608                            G726DEC_DPRINT("**************************************\n");
609                            G726DEC_DPRINT(":: Error = OMX_ErrorInsufficientResources\n");
610                            G726DEC_DPRINT("**************************************\n");
611                            eError = OMX_ErrorInsufficientResources;
612                            pComponentPrivate->curState = OMX_StateInvalid;
613                            pComponentPrivate->cbInfo.EventHandler(pHandle,
614                                                                   pHandle->pApplicationPrivate,
615                                                                   OMX_EventError, OMX_ErrorInvalidState,
616                                                                   0,
617                                                                   NULL);
618                            goto EXIT;
619                        }
620                    }
621
622                    G726DEC_DPRINT("%d :: OMX_StateLoaded [G726D_INPUT_PORT]->bPopulated  %d \n",
623                                   __LINE__,pComponentPrivate->pPortDef[G726D_INPUT_PORT]->bPopulated);
624                    G726DEC_DPRINT("%d :: OMX_StateLoaded [G726D_INPUT_PORT]->bEnabled    %d \n",
625                                   __LINE__,pComponentPrivate->pPortDef[G726D_INPUT_PORT]->bEnabled);
626                    G726DEC_DPRINT("%d :: OMX_StateLoaded [G726D_OUTPUT_PORT]->bPopulated %d \n",
627                                   __LINE__,pComponentPrivate->pPortDef[G726D_OUTPUT_PORT]->bPopulated);
628                    G726DEC_DPRINT("%d :: OMX_StateLoaded [G726D_OUTPUT_PORT]->bEnabled   %d \n",
629                                   __LINE__,pComponentPrivate->pPortDef[G726D_OUTPUT_PORT]->bEnabled);
630
631                    if (pComponentPrivate->pPortDef[G726D_INPUT_PORT]->bPopulated &&
632                        pComponentPrivate->pPortDef[G726D_INPUT_PORT]->bEnabled)  {
633                        inputPortFlag = 1;
634                    }
635                    if (!pComponentPrivate->pPortDef[G726D_INPUT_PORT]->bPopulated &&
636                        !pComponentPrivate->pPortDef[G726D_INPUT_PORT]->bEnabled) {
637                        inputPortFlag = 1;
638                    }
639                    if (pComponentPrivate->pPortDef[G726D_OUTPUT_PORT]->bPopulated &&
640                        pComponentPrivate->pPortDef[G726D_OUTPUT_PORT]->bEnabled) {
641                        outputPortFlag = 1;
642                    }
643                    if (!pComponentPrivate->pPortDef[G726D_OUTPUT_PORT]->bPopulated &&
644                        !pComponentPrivate->pPortDef[G726D_OUTPUT_PORT]->bEnabled) {
645                        outputPortFlag = 1;
646                    }
647                    if (!(inputPortFlag && outputPortFlag)) {
648                        pComponentPrivate->InLoaded_readytoidle = 1;
649#ifndef UNDER_CE
650                        pthread_mutex_lock(&pComponentPrivate->InLoaded_mutex);
651                        pthread_cond_wait(&pComponentPrivate->InLoaded_threshold,
652                                          &pComponentPrivate->InLoaded_mutex);
653                        pthread_mutex_unlock(&pComponentPrivate->InLoaded_mutex);
654#else
655                        OMX_WaitForEvent(&(pComponentPrivate->InLoaded_event));
656#endif
657                    }
658
659                    pLcmlHandle = (OMX_HANDLETYPE) G726DEC_GetLCMLHandle(pComponentPrivate);
660                    if (pLcmlHandle == NULL) {
661                        G726DEC_EPRINT(":: LCML Handle is NULL........exiting..\n");
662                        pComponentPrivate->curState = OMX_StateInvalid;
663                        pComponentPrivate->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
664                                                               OMX_EventError, OMX_ErrorInvalidState,
665                                                               0, NULL);
666                        goto EXIT;
667                    }
668
669                    pLcmlDsp = (((LCML_DSP_INTERFACE*)pLcmlHandle)->dspCodec);
670                    eError = G726DEC_Fill_LCMLInitParams(pHandle, pLcmlDsp, arr);
671                    if(eError != OMX_ErrorNone) {
672                        G726DEC_EPRINT(":: Error returned from Fill_LCMLInitParams()\n");
673                        pComponentPrivate->curState = OMX_StateInvalid;
674                        pComponentPrivate->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
675                                                               OMX_EventError, OMX_ErrorInvalidState,
676                                                               0, NULL);
677                        goto EXIT;
678                    }
679
680                    pComponentPrivate->pLcmlHandle = (LCML_DSP_INTERFACE *)pLcmlHandle;
681                    cb.LCML_Callback = (void *) G726DEC_LCML_Callback;
682
683#ifndef UNDER_CE
684
685                    eError = LCML_InitMMCodecEx(((LCML_DSP_INTERFACE *)pLcmlHandle)->pCodecinterfacehandle,
686                                                p,&pLcmlHandle,(void *)p,
687                                                &cb,(OMX_STRING)pComponentPrivate->sDeviceString);
688                    if (eError != OMX_ErrorNone){
689                        G726DEC_EPRINT("%d :: Error : InitMMCodec failed...>>>>>> \n",__LINE__);
690                        goto EXIT;
691                    }
692
693#else
694
695                    eError = LCML_InitMMCodec(((LCML_DSP_INTERFACE *)pLcmlHandle)->pCodecinterfacehandle,
696                                              p,&pLcmlHandle,(void *)p,&cb);
697
698                    if (eError != OMX_ErrorNone){
699                        G726DEC_EPRINT("%d :: Error : InitMMCodec failed...>>>>>> \n",__LINE__);
700                        goto EXIT;
701                    }
702#endif
703
704#ifdef HASHINGENABLE
705                    /* Enable the Hashing Code */
706                    eError = LCML_SetHashingState(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
707                                                  OMX_TRUE);
708                    if (eError != OMX_ErrorNone) {
709                        G726DEC_EPRINT("Failed to set Mapping State\n");
710                        goto EXIT;
711                    }
712#endif
713
714#ifdef RESOURCE_MANAGER_ENABLED
715                    /* need check the resource with RM */
716                    pComponentPrivate->rmproxyCallback.RMPROXY_Callback = (void *) G726DEC_ResourceManagerCallback;
717                    if (pComponentPrivate->curState != OMX_StateWaitForResources) {
718                        rm_error = RMProxy_NewSendCommand(pHandle, RMProxy_RequestResource, OMX_PCM_Decoder_COMPONENT, G726DEC_CPU , 3456,&
719                                                          (pComponentPrivate->rmproxyCallback));
720                        if(rm_error == OMX_ErrorNone) {
721                            /* resource is available */
722                            pComponentPrivate->curState = OMX_StateIdle;
723                            rm_error = RMProxy_NewSendCommand(pHandle, RMProxy_StateSet, OMX_NBAMR_Decoder_COMPONENT, OMX_StateIdle, 3456,NULL);
724                        }
725                        else if(rm_error == OMX_ErrorInsufficientResources) {
726                            /* resource is not available, need set state to OMX_StateWaitForResources */
727                            pComponentPrivate->curState = OMX_StateWaitForResources;
728                            pComponentPrivate->cbInfo.EventHandler(pHandle,
729                                                                   pHandle->pApplicationPrivate,
730                                                                   OMX_EventCmdComplete,
731                                                                   OMX_CommandStateSet,
732                                                                   pComponentPrivate->curState,
733                                                                   NULL);
734                            G726DEC_EPRINT("%d :: OMX_AmrDec_Utils.c :: AMRDEC: Error - insufficient resources\n", __LINE__);
735                        }
736                    }
737                    else {
738                        rm_error = RMProxy_NewSendCommand(pHandle, RMProxy_StateSet, OMX_NBAMR_Decoder_COMPONENT, OMX_StateIdle, 3456,NULL);
739                    }
740                    pComponentPrivate->curState = OMX_StateIdle;
741
742                    pComponentPrivate->cbInfo.EventHandler(
743                                                           pHandle,
744                                                           pHandle->pApplicationPrivate,
745                                                           OMX_EventCmdComplete, OMX_CommandStateSet,pComponentPrivate->curState, NULL);
746
747#else
748                    G726DEC_DPRINT(":: Control Came Here\n");
749                    G726DEC_STATEPRINT("****************** Component State Set to Idle\n\n");
750                    pComponentPrivate->curState = OMX_StateIdle;
751                    pComponentPrivate->cbInfo.EventHandler(pHandle,
752                                                           pHandle->pApplicationPrivate,
753                                                           OMX_EventCmdComplete,
754                                                           OMX_CommandStateSet,
755                                                           pComponentPrivate->curState,
756                                                           NULL);
757#endif
758
759                    G726DEC_DPRINT("G726DEC: State has been Set to Idle\n");
760
761                } else if (pComponentPrivate->curState == OMX_StateExecuting) {
762#ifdef HASHINGENABLE
763                    /*Hashing Change*/
764                    pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLcmlHandle;
765                    /* clear out any mappings that might have accumulated */
766                    eError = LCML_FlushHashes(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle);
767                    if (eError != OMX_ErrorNone) {
768                        G726DEC_EPRINT("Error occurred in Codec mapping flush!\n");
769                        break;
770                    }
771#endif
772                    pComponentPrivate->bDspStoppedWhileExecuting = OMX_TRUE;
773                    G726DEC_DPRINT(":: In HandleCommand: Stopping the codec\n");
774                    eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
775                                               MMCodecControlStop,(void *)pArgs);
776                    if(eError != OMX_ErrorNone) {
777                        G726DEC_EPRINT(": Error Occurred in Codec Stop..\n");
778                        pComponentPrivate->curState = OMX_StateInvalid;
779                        pComponentPrivate->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
780                                                               OMX_EventError, OMX_ErrorInvalidState,0, NULL);
781                        goto EXIT;
782                    }
783                } else if(pComponentPrivate->curState == OMX_StatePause) {
784                    char *pArgs = "damedesuStr";
785#ifdef HASHINGENABLE
786                    /*Hashing Change*/
787                    pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLcmlHandle;
788                    /* clear out any mappings that might have accumulated */
789                    eError = LCML_FlushHashes(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle);
790                    if (eError != OMX_ErrorNone) {
791                        G726DEC_EPRINT("Error occurred in Codec mapping flush!\n");
792                        break;
793                    }
794#endif
795                    G726DEC_DPRINT(":: Comp: Stop Command Received\n");
796                    G726DEC_DPRINT(": G726DECUTILS::About to call LCML_ControlCodec\n");
797                    eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
798                                               MMCodecControlStop,(void *)pArgs);
799                    if(eError != OMX_ErrorNone) {
800                        G726DEC_EPRINT(": Error Occurred in Codec Stop..\n");
801                        pComponentPrivate->curState = OMX_StateInvalid;
802                        pComponentPrivate->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
803                                                               OMX_EventError, OMX_ErrorInvalidState,0, NULL);
804                        goto EXIT;
805                    }
806                    G726DEC_STATEPRINT("****************** Component State Set to Idle\n\n");
807                    pComponentPrivate->curState = OMX_StateIdle;
808#ifdef RESOURCE_MANAGER_ENABLED
809                    rm_error = RMProxy_NewSendCommand(pHandle, RMProxy_StateSet, OMX_PCM_Decoder_COMPONENT, OMX_StateIdle, 3456,NULL);
810#endif
811                    G726DEC_DPRINT ("%d :: The component is stopped\n",__LINE__);
812                    pComponentPrivate->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
813                                                           OMX_EventCmdComplete, OMX_CommandStateSet,
814                                                           pComponentPrivate->curState, NULL);
815                } else {
816                    G726DEC_DPRINT(": Comp: Sending ErrorNotification: Invalid State\n");
817                    pComponentPrivate->cbInfo.EventHandler(pHandle,
818                                                           pHandle->pApplicationPrivate,
819                                                           OMX_EventError,
820                                                           OMX_ErrorIncorrectStateTransition, 0,
821                                                           "Invalid State Error");
822                }
823                break;
824
825            case OMX_StateExecuting:
826                G726DEC_DPRINT(": HandleCommand: Cmd Executing \n");
827                if (pComponentPrivate->curState == OMX_StateIdle) {
828                    char *pArgs = "damedesuStr";
829                    if(pComponentPrivate->dasfmode == 1) {
830                        OMX_U32 pValues[4];
831                        pComponentPrivate->pParams->unUUID = pComponentPrivate->streamID;
832                        pComponentPrivate->pParams->ulSamplingFreq =
833                            pComponentPrivate->PcmParams->nSamplingRate;
834                        pComponentPrivate->pParams->unAudioFormat = 1; /*MONO stream */
835
836                        G726DEC_DPRINT("::pComponentPrivate->pParams->unAudioFormat = %d\n",
837                                       pComponentPrivate->pParams->unAudioFormat);
838                        G726DEC_DPRINT("::pComponentPrivate->pParams->ulSamplingFreq = %ld\n",
839                                       pComponentPrivate->pParams->ulSamplingFreq);
840                        G726DEC_DPRINT("::pComponentPrivate->pParams->unUUID = %ld\n",
841                                       pComponentPrivate->pParams->unUUID);
842
843                        pValues[0] = USN_STRMCMD_SETCODECPARAMS;
844                        pValues[1] = (OMX_U32)pComponentPrivate->pParams;
845                        pValues[2] = sizeof(G726D_USN_AudioCodecParams);
846
847                        eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
848                                                   EMMCodecControlStrmCtrl,(void *)pValues);
849                        if(eError != OMX_ErrorNone) {
850                            G726DEC_EPRINT(": Error Occurred in Codec StreamControl..\n");
851                            pComponentPrivate->curState = OMX_StateInvalid;
852                            pComponentPrivate->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
853                                                                   OMX_EventError, OMX_ErrorInvalidState,0, NULL);
854                            goto EXIT;
855                        }
856                    }
857
858                    pComponentPrivate->bDspStoppedWhileExecuting = OMX_FALSE;
859                    eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
860                                               EMMCodecControlStart,(void *)pArgs);
861                    if(eError != OMX_ErrorNone) {
862                        G726DEC_EPRINT("Error Occurred in Codec Start..\n");
863                        pComponentPrivate->curState = OMX_StateInvalid;
864                        pComponentPrivate->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
865                                                               OMX_EventError, OMX_ErrorInvalidState,0, NULL);
866                        goto EXIT;
867                    }
868                } else if (pComponentPrivate->curState == OMX_StatePause) {
869                    char *pArgs = "damedesuStr";
870                    G726DEC_DPRINT(": Comp: Resume Command Came from App\n");
871                    G726DEC_DPRINT(": G726DECUTILS::About to call LCML_ControlCodec\n");
872                    eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
873                                               EMMCodecControlStart,(void *)pArgs);
874                    if (eError != OMX_ErrorNone) {
875                        G726DEC_EPRINT ("Error While Resuming the codec\n");
876                        pComponentPrivate->curState = OMX_StateInvalid;
877                        pComponentPrivate->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
878                                                               OMX_EventError, OMX_ErrorInvalidState,0, NULL);
879                        goto EXIT;
880                    }
881
882                    for (i=0; i < pComponentPrivate->nNumInputBufPending; i++) {
883                        if (pComponentPrivate->pInputBufHdrPending[i] != NULL) {
884                            G726D_LCML_BUFHEADERTYPE *pLcmlHdr;
885                            G726DEC_GetCorresponding_LCMLHeader(pComponentPrivate,
886                                                                pComponentPrivate->pInputBufHdrPending[i]->pBuffer,
887                                                                OMX_DirInput, &pLcmlHdr);
888                            G726DEC_SetPending(pComponentPrivate,pComponentPrivate->pInputBufHdrPending[i],OMX_DirInput,
889                                               __LINE__);
890                            eError = LCML_QueueBuffer(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
891                                                      EMMCodecInputBuffer,
892                                                      pComponentPrivate->pInputBufHdrPending[i]->pBuffer,
893                                                      pComponentPrivate->pInputBufHdrPending[i]->nAllocLen,
894                                                      pComponentPrivate->pInputBufHdrPending[i]->nFilledLen,
895                                                      (OMX_U8 *) pLcmlHdr->pFrameParam,
896                                                      sizeof(G726DEC_UAlgInBufParamStruct),
897                                                      NULL);
898                        }
899                    }
900                    pComponentPrivate->nNumInputBufPending = 0;
901
902                    for (i=0; i < pComponentPrivate->nNumOutputBufPending; i++) {
903                        if (pComponentPrivate->pOutputBufHdrPending[i] != NULL) {
904                            G726D_LCML_BUFHEADERTYPE *pLcmlHdr;
905                            G726DEC_GetCorresponding_LCMLHeader(pComponentPrivate,
906                                                                pComponentPrivate->pOutputBufHdrPending[i]->pBuffer,
907                                                                OMX_DirOutput, &pLcmlHdr);
908                            if (!G726DEC_IsPending(pComponentPrivate, pComponentPrivate->pOutputBufHdrPending[i],
909                                                   OMX_DirOutput)) {
910                                G726DEC_SetPending(pComponentPrivate,pComponentPrivate->pOutputBufHdrPending[i],
911                                                   OMX_DirOutput,__LINE__);
912                                eError = LCML_QueueBuffer(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
913                                                          EMMCodecOuputBuffer,
914                                                          pComponentPrivate->pOutputBufHdrPending[i]->pBuffer,
915                                                          pComponentPrivate->pOutputBufHdrPending[i]->nAllocLen,
916                                                          pComponentPrivate->pOutputBufHdrPending[i]->nFilledLen,
917                                                          NULL,
918                                                          0,
919                                                          NULL);
920                            }
921                        }
922                    }
923                    pComponentPrivate->nNumOutputBufPending = 0;
924                }else {
925                    pComponentPrivate->cbInfo.EventHandler (pHandle, pHandle->pApplicationPrivate,
926                                                            OMX_EventError, OMX_ErrorIncorrectStateTransition, 0,
927                                                            "Invalid State");
928                    G726DEC_DPRINT(":: Error: Invalid State Given by \
929                       Application\n");
930                    goto EXIT;
931                }
932
933                G726DEC_STATEPRINT("****************** Component State Set to Executing\n\n");
934                pComponentPrivate->curState = OMX_StateExecuting;
935#ifdef RESOURCE_MANAGER_ENABLED
936                rm_error = RMProxy_NewSendCommand(pHandle, RMProxy_StateSet, OMX_PCM_Decoder_COMPONENT, OMX_StateExecuting, 3456,NULL);
937#endif
938                pComponentPrivate->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
939                                                       OMX_EventCmdComplete,
940                                                       OMX_CommandStateSet, pComponentPrivate->curState, NULL);
941                break;
942
943            case OMX_StateLoaded:
944                G726DEC_DPRINT(": HandleCommand: Cmd Loaded\n");
945                if (pComponentPrivate->curState == OMX_StateWaitForResources ){
946                    G726DEC_STATEPRINT("***************** Component State Set to Loaded\n\n");
947                    pComponentPrivate->curState = OMX_StateLoaded;
948                    pComponentPrivate->cbInfo.EventHandler (pHandle, pHandle->pApplicationPrivate,
949                                                            OMX_EventCmdComplete, OMX_CommandStateSet,
950                                                            pComponentPrivate->curState,
951                                                            NULL);
952                    G726DEC_DPRINT(":: Tansitioning from WaitFor to Loaded\n");
953                    break;
954                }
955                if (pComponentPrivate->curState != OMX_StateIdle) {
956                    pComponentPrivate->cbInfo.EventHandler (pHandle, pHandle->pApplicationPrivate,
957                                                            OMX_EventError, OMX_ErrorIncorrectStateTransition, 0,
958                                                            "Invalid State");
959                    G726DEC_DPRINT(":: Error: Invalid State Given by \
960                       Application\n");
961                    goto EXIT;
962                }
963
964                G726DEC_DPRINT("Current State = %d\n",pComponentPrivate->curState);
965                G726DEC_DPRINT("pComponentPrivate->pInputBufferList->numBuffers = %ld\n",
966                               pComponentPrivate->pInputBufferList->numBuffers);
967                G726DEC_DPRINT("pComponentPrivate->pOutputBufferList->numBuffers = %ld\n",
968                               pComponentPrivate->pOutputBufferList->numBuffers);
969
970                G726DEC_DPRINT(":: Loaded State - in while(1) loop: ip : %ld : op: %ld\n",
971                               pComponentPrivate->pInputBufferList->numBuffers,
972                               pComponentPrivate->pOutputBufferList->numBuffers);
973                if (pComponentPrivate->pInputBufferList->numBuffers ||
974                    pComponentPrivate->pOutputBufferList->numBuffers) {
975                    pComponentPrivate->InIdle_goingtoloaded = 1;
976#ifndef UNDER_CE
977                    pthread_mutex_lock(&pComponentPrivate->InIdle_mutex);
978                    pthread_cond_wait(&pComponentPrivate->InIdle_threshold,
979                                      &pComponentPrivate->InIdle_mutex);
980                    pthread_mutex_unlock(&pComponentPrivate->InIdle_mutex);
981
982#else
983                    OMX_WaitForEvent(&(pComponentPrivate->InIdle_event));
984#endif
985                    pComponentPrivate->bLoadedCommandPending = OMX_FALSE;
986                }
987                /* Now Deinitialize the component No error should be returned from
988                 * this function. It should clean the system as much as possible */
989                eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
990                                           EMMCodecControlDestroy,(void *)pArgs);
991                pComponentPrivate->bInitParamsInitialized = 0;
992                eError = EXIT_COMPONENT_THRD;
993                break;
994
995            case OMX_StatePause:
996                G726DEC_DPRINT("Cmd Pause: Cur State = %d\n", pComponentPrivate->curState);
997
998                if ((pComponentPrivate->curState != OMX_StateExecuting) &&
999                    (pComponentPrivate->curState != OMX_StateIdle)) {
1000                    pComponentPrivate->cbInfo.EventHandler (pHandle, pHandle->pApplicationPrivate,
1001                                                            OMX_EventError, OMX_ErrorIncorrectStateTransition, 0,
1002                                                            "Invalid State");
1003                    G726DEC_DPRINT(":: Error: Invalid State Given by \
1004                       Application\n");
1005                    goto EXIT;
1006                }
1007
1008                G726DEC_DPRINT(": G726DECUTILS::About to call LCML_ControlCodec\n");
1009                eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1010                                           EMMCodecControlPause,(void *)pArgs);
1011
1012                if (eError != OMX_ErrorNone) {
1013                    G726DEC_EPRINT(": Error: in Pausing the codec\n");
1014                    pComponentPrivate->curState = OMX_StateInvalid;
1015                    pComponentPrivate->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
1016                                                           OMX_EventError, OMX_ErrorInvalidState,0, NULL);
1017                    goto EXIT;
1018                }
1019                G726DEC_DPRINT(":: Component: Codec Is Paused\n");
1020
1021                G726DEC_STATEPRINT("****************** Component State Set to Pause\n\n");
1022                pComponentPrivate->curState = OMX_StatePause;
1023                pComponentPrivate->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
1024                                                       OMX_EventCmdComplete, OMX_CommandStateSet,
1025                                                       pComponentPrivate->curState, NULL);
1026                break;
1027
1028            case OMX_StateWaitForResources:
1029                G726DEC_DPRINT(": HandleCommand: Cmd : OMX_StateWaitForResources\n");
1030                if (pComponentPrivate->curState == OMX_StateLoaded) {
1031#ifdef RESOURCE_MANAGER_ENABLED
1032                    rm_error = RMProxy_NewSendCommand(pHandle, RMProxy_StateSet, OMX_PCM_Decoder_COMPONENT, OMX_StateWaitForResources, 3456,NULL);
1033#endif
1034                    pComponentPrivate->curState = OMX_StateWaitForResources;
1035                    G726DEC_DPRINT(": Transitioning from Loaded to OMX_StateWaitForResources\n");
1036                    pComponentPrivate->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
1037                                                           OMX_EventCmdComplete,
1038                                                           OMX_CommandStateSet,pComponentPrivate->curState, NULL);
1039                } else {
1040                    pComponentPrivate->cbInfo.EventHandler(
1041                                                           pHandle, pHandle->pApplicationPrivate,
1042                                                           OMX_EventError, OMX_ErrorIncorrectStateTransition,0, NULL);
1043                }
1044                break;
1045
1046            case OMX_StateInvalid:
1047                G726DEC_DPRINT(": HandleCommand: Cmd OMX_StateInvalid:\n");
1048                pComponentPrivate->curState = OMX_StateInvalid;
1049
1050                pComponentPrivate->cbInfo.EventHandler(
1051                                                       pHandle, pHandle->pApplicationPrivate,
1052                                                       OMX_EventError, OMX_ErrorInvalidState,0, NULL);
1053                break;
1054
1055            case OMX_StateMax:
1056                G726DEC_DPRINT(": HandleCommand: Cmd OMX_StateMax::\n");
1057                break;
1058            } /* End of Switch */
1059        }
1060    }
1061    else if (command == OMX_CommandMarkBuffer) {
1062        G726DEC_DPRINT("command OMX_CommandMarkBuffer received\n");
1063        if(!pComponentPrivate->pMarkBuf){
1064            G726DEC_DPRINT("command OMX_CommandMarkBuffer received \n");
1065            pComponentPrivate->pMarkBuf = (OMX_MARKTYPE *)(commandData);
1066        }
1067    }
1068    else if (command == OMX_CommandPortDisable) {
1069        if (!pComponentPrivate->bDisableCommandPending) {
1070            if(commandData == 0x0){
1071                /* disable port */
1072                for (i=0; i < pComponentPrivate->pInputBufferList->numBuffers; i++) {
1073                    if (G726DEC_IsPending(pComponentPrivate,pComponentPrivate->pInputBufferList->pBufHdr[i],
1074                                          OMX_DirInput)) {
1075                        /* Real solution is flush buffers from DSP.  Until we have the ability to do that
1076                           we just call EmptyBufferDone() on any pending buffers */
1077                        pComponentPrivate->cbInfo.EmptyBufferDone (pComponentPrivate->pHandle,
1078                                                                   pComponentPrivate->pHandle->pApplicationPrivate,
1079                                                                   pComponentPrivate->pInputBufferList->pBufHdr[i]);
1080                        pComponentPrivate->nEmptyBufferDoneCount++;
1081                    }
1082                }
1083                pComponentPrivate->pPortDef[G726D_INPUT_PORT]->bEnabled = OMX_FALSE;
1084            }
1085            if(commandData == -1){
1086                pComponentPrivate->pPortDef[G726D_INPUT_PORT]->bEnabled = OMX_FALSE;
1087            }
1088            if(commandData == 0x1 || commandData == -1){
1089                char *pArgs = "damedesuStr";
1090                pComponentPrivate->pPortDef[G726D_OUTPUT_PORT]->bEnabled = OMX_FALSE;
1091                if (pComponentPrivate->curState == OMX_StateExecuting) {
1092                    pComponentPrivate->bNoIdleOnStop = OMX_TRUE;
1093                    eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1094                                               MMCodecControlStop,(void *)pArgs);
1095                }
1096            }
1097        }
1098        G726DEC_DPRINT("commandData = %ld\n",commandData);
1099        G726DEC_DPRINT("pComponentPrivate->pPortDef[G726D_INPUT_PORT]->bPopulated = %d\n",
1100                       pComponentPrivate->pPortDef[G726D_INPUT_PORT]->bPopulated);
1101        G726DEC_DPRINT("pComponentPrivate->pPortDef[G726D_OUTPUT_PORT]->bPopulated = %d\n",
1102                       pComponentPrivate->pPortDef[G726D_OUTPUT_PORT]->bPopulated);
1103        if(commandData == 0x0) {
1104            if(!pComponentPrivate->pPortDef[G726D_INPUT_PORT]->bPopulated){
1105                /* return cmdcomplete event if input unpopulated */
1106                pComponentPrivate->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
1107                                                       OMX_EventCmdComplete, OMX_CommandPortDisable,
1108                                                       G726D_INPUT_PORT, NULL);
1109                pComponentPrivate->bDisableCommandPending = 0;
1110            }
1111            else{
1112                pComponentPrivate->bDisableCommandPending = 1;
1113                pComponentPrivate->bDisableCommandParam = commandData;
1114            }
1115        }
1116        if(commandData == 0x1) {
1117            if (!pComponentPrivate->pPortDef[G726D_OUTPUT_PORT]->bPopulated){
1118                /* return cmdcomplete event if output unpopulated */
1119                pComponentPrivate->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
1120                                                       OMX_EventCmdComplete, OMX_CommandPortDisable,
1121                                                       G726D_OUTPUT_PORT, NULL);
1122                pComponentPrivate->bDisableCommandPending = 0;
1123            }
1124            else {
1125                pComponentPrivate->bDisableCommandPending = 1;
1126                pComponentPrivate->bDisableCommandParam = commandData;
1127            }
1128        }
1129        if(commandData == -1) {
1130            if (!pComponentPrivate->pPortDef[G726D_INPUT_PORT]->bPopulated &&
1131                !pComponentPrivate->pPortDef[G726D_OUTPUT_PORT]->bPopulated){
1132                /* return cmdcomplete event if inout & output unpopulated */
1133                pComponentPrivate->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
1134                                                       OMX_EventCmdComplete, OMX_CommandPortDisable,
1135                                                       G726D_INPUT_PORT, NULL);
1136                pComponentPrivate->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
1137                                                       OMX_EventCmdComplete, OMX_CommandPortDisable,
1138                                                       G726D_OUTPUT_PORT, NULL);
1139                pComponentPrivate->bDisableCommandPending = 0;
1140            }
1141            else {
1142                pComponentPrivate->bDisableCommandPending = 1;
1143                pComponentPrivate->bDisableCommandParam = commandData;
1144            }
1145#ifndef UNDER_CE
1146            sched_yield();
1147#else
1148            Sleep(0);
1149#endif
1150        }
1151    }
1152    else if (command == OMX_CommandPortEnable) {
1153        if(commandData == 0x0 || commandData == -1){
1154            /* enable in port */
1155            G726DEC_DPRINT("setting input port to enabled\n");
1156            pComponentPrivate->pPortDef[G726D_INPUT_PORT]->bEnabled = OMX_TRUE;
1157            G726DEC_DPRINT("pComponentPrivate->pPortDef[G726D_INPUT_PORT]->bEnabled = %d\n",
1158                           pComponentPrivate->pPortDef[G726D_INPUT_PORT]->bEnabled);
1159
1160            if(pComponentPrivate->AlloBuf_waitingsignal){
1161                pComponentPrivate->AlloBuf_waitingsignal = 0;
1162#ifndef UNDER_CE
1163                pthread_mutex_lock(&pComponentPrivate->AlloBuf_mutex);
1164                pthread_cond_signal(&pComponentPrivate->AlloBuf_threshold);
1165                pthread_mutex_unlock(&pComponentPrivate->AlloBuf_mutex);
1166#else
1167                OMX_SignalEvent(&(pComponentPrivate->AlloBuf_event));
1168#endif
1169            }
1170        }
1171        if(commandData == 0x1 || commandData == -1){
1172            char *pArgs = "damedesuStr";
1173            /* enable out port */
1174            G726DEC_DPRINT("setting output port to enabled\n");
1175            pComponentPrivate->pPortDef[G726D_OUTPUT_PORT]->bEnabled = OMX_TRUE;
1176            if(pComponentPrivate->AlloBuf_waitingsignal){
1177                pComponentPrivate->AlloBuf_waitingsignal = 0;
1178#ifndef UNDER_CE
1179                pthread_mutex_lock(&pComponentPrivate->AlloBuf_mutex);
1180                pthread_cond_signal(&pComponentPrivate->AlloBuf_threshold);
1181                pthread_mutex_unlock(&pComponentPrivate->AlloBuf_mutex);
1182#else
1183                OMX_SignalEvent(&(pComponentPrivate->AlloBuf_event));
1184#endif
1185            }
1186            if(pComponentPrivate->curState == OMX_StateExecuting){
1187                pComponentPrivate->bDspStoppedWhileExecuting = OMX_FALSE;
1188                eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1189                                           EMMCodecControlStart,(void *)pArgs);
1190            }
1191            G726DEC_DPRINT("pComponentPrivate->pPortDef[G726D_OUTPUT_PORT]->bEnabled = %d\n",
1192                           pComponentPrivate->pPortDef[G726D_OUTPUT_PORT]->bEnabled);
1193        }
1194        while (1) {
1195            G726DEC_DPRINT("commandData = %ld\n",commandData);
1196            G726DEC_DPRINT("pComponentPrivate->curState = %d\n",pComponentPrivate->curState);
1197            G726DEC_DPRINT("pComponentPrivate->pPortDef[G726D_INPUT_PORT]->bPopulated = %d\n",
1198                           pComponentPrivate->pPortDef[G726D_INPUT_PORT]->bPopulated);
1199
1200            if(commandData == 0x0 && (pComponentPrivate->curState == OMX_StateLoaded ||
1201                                      pComponentPrivate->pPortDef[G726D_INPUT_PORT]->bPopulated)){
1202
1203                pComponentPrivate->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
1204                                                       OMX_EventCmdComplete,
1205                                                       OMX_CommandPortEnable,G726D_INPUT_PORT,
1206                                                       NULL);
1207                break;
1208            }
1209            else if(commandData == 0x1 && (pComponentPrivate->curState == OMX_StateLoaded ||
1210                                           pComponentPrivate->pPortDef[G726D_OUTPUT_PORT]->bPopulated)){
1211
1212                pComponentPrivate->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
1213                                                       OMX_EventCmdComplete,
1214                                                       OMX_CommandPortEnable,G726D_OUTPUT_PORT,
1215                                                       NULL);
1216                break;
1217            }
1218            else if(commandData == -1 && (pComponentPrivate->curState == OMX_StateLoaded ||
1219                                          (pComponentPrivate->pPortDef[G726D_INPUT_PORT]->bPopulated &&
1220                                           pComponentPrivate->pPortDef[G726D_OUTPUT_PORT]->bPopulated))) {
1221
1222                pComponentPrivate->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
1223                                                       OMX_EventCmdComplete, OMX_CommandPortEnable,
1224                                                       G726D_INPUT_PORT,
1225                                                       NULL);
1226
1227                pComponentPrivate->cbInfo.EventHandler(pHandle, pHandle->pApplicationPrivate,
1228                                                       OMX_EventCmdComplete, OMX_CommandPortEnable,
1229                                                       G726D_OUTPUT_PORT,
1230                                                       NULL);
1231                G726DECFill_LCMLInitParamsEx(pComponentPrivate->pHandle);
1232                break;
1233            }
1234#ifndef UNDER_CE
1235            sched_yield();
1236#else
1237            Sleep(0);
1238#endif
1239        }
1240    }
1241    else if (command == OMX_CommandFlush) {
1242        OMX_U32 aParam[3] = {0};
1243        if(commandData == 0x0 || commandData == -1) {
1244            if (pComponentPrivate->nUnhandledEmptyThisBuffers == 0)  {
1245                pComponentPrivate->bFlushInputPortCommandPending = OMX_FALSE;
1246                aParam[0] = USN_STRMCMD_FLUSH;
1247                aParam[1] = 0x0;
1248                aParam[2] = 0x0;
1249
1250                G726DEC_DPRINT("Flushing input port\n");
1251                eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1252                                           EMMCodecControlStrmCtrl, (void*)aParam);
1253
1254                if (eError != OMX_ErrorNone) {
1255                    goto EXIT;
1256                }
1257            }else {
1258                pComponentPrivate->bFlushInputPortCommandPending = OMX_TRUE;
1259            }
1260        }
1261        if(commandData == 0x1 || commandData == -1){
1262            if (pComponentPrivate->nUnhandledFillThisBuffers == 0)  {
1263                pComponentPrivate->bFlushOutputPortCommandPending = OMX_FALSE;
1264                aParam[0] = USN_STRMCMD_FLUSH;
1265                aParam[1] = 0x1;
1266                aParam[2] = 0x0;
1267
1268                G726DEC_DPRINT("Flushing output port\n");
1269                eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1270                                           EMMCodecControlStrmCtrl, (void*)aParam);
1271                if (eError != OMX_ErrorNone) {
1272                    goto EXIT;
1273                }
1274            } else {
1275                pComponentPrivate->bFlushOutputPortCommandPending = OMX_TRUE;
1276            }
1277        }
1278    }
1279 EXIT:
1280    G726DEC_DPRINT (":: Exiting HandleCommand Function\n");
1281    return eError;
1282}
1283
1284
1285
1286/* ================================================================================= * */
1287/**
1288 * @fn G726DEC_HandleDataBuf_FromApp() function handles the input and output buffers
1289 * that come from the application. It is not direct function wich gets called by
1290 * the application rather, it gets called eventually.
1291 *
1292 * @param *pBufHeader This is the buffer header that needs to be processed.
1293 *
1294 * @param *pComponentPrivate  This is component's private date structure.
1295 *
1296 * @pre          None
1297 *
1298 * @post         None
1299 *
1300 *  @return      OMX_ErrorNone = Successful processing.
1301 *               OMX_ErrorInsufficientResources = Not enough memory
1302 *               OMX_ErrorHardware = Hardware error has occured lile LCML failed
1303 *               to do any said operartion.
1304 *
1305 *  @see         None
1306 */
1307/* ================================================================================ * */
1308OMX_ERRORTYPE G726DEC_HandleDataBuf_FromApp(OMX_BUFFERHEADERTYPE* pBufHeader,
1309                                            G726DEC_COMPONENT_PRIVATE *pComponentPrivate)
1310{
1311    OMX_ERRORTYPE eError = OMX_ErrorNone;
1312    OMX_DIRTYPE eDir;
1313    LCML_DSP_INTERFACE * phandle = NULL;
1314
1315    G726DEC_DPRINT (":: Entering HandleDataBuf_FromApp Function\n");
1316    G726DEC_DPRINT (":: pBufHeader->pMarkData = %p\n",pBufHeader->pMarkData);
1317
1318    pBufHeader->pPlatformPrivate  = pComponentPrivate;
1319    eError = G726DEC_GetBufferDirection(pBufHeader, &eDir);
1320    G726DEC_DPRINT (":: HandleDataBuf_FromApp Function\n");
1321    if (eError != OMX_ErrorNone) {
1322        G726DEC_EPRINT (":: The pBufHeader is not found in the list\n");
1323        goto EXIT;
1324    }
1325
1326    if (eDir == OMX_DirInput) {
1327        LCML_DSP_INTERFACE *pLcmlHandle = (LCML_DSP_INTERFACE *)pComponentPrivate->pLcmlHandle;
1328        G726D_LCML_BUFHEADERTYPE *pLcmlHdr;
1329        pComponentPrivate->nUnhandledEmptyThisBuffers--;
1330        eError = G726DEC_GetCorresponding_LCMLHeader(pComponentPrivate,
1331                                                     pBufHeader->pBuffer, OMX_DirInput, &pLcmlHdr);
1332        if (eError != OMX_ErrorNone) {
1333            G726DEC_EPRINT(":: Error: Invalid Buffer Came ...\n");
1334            goto EXIT;
1335        }
1336
1337
1338        if (pBufHeader->nFilledLen > 0 || pBufHeader->nFlags == OMX_BUFFERFLAG_EOS) {
1339            pComponentPrivate->bBypassDSP = 0;
1340            G726DEC_DPRINT (":: HandleDataBuf_FromApp Function\n");
1341            G726DEC_DPRINT (":::Calling LCML_QueueBuffer\n");
1342            pLcmlHdr->pFrameParam->bLastBuffer = 0;
1343            if(pBufHeader->nFlags == OMX_BUFFERFLAG_EOS) {
1344                pLcmlHdr->pFrameParam->bLastBuffer = 1;
1345                pComponentPrivate->bIsEOFSent = 1;
1346                pBufHeader->nFlags = 0;
1347            }
1348
1349            G726DEC_DPRINT ("Comp:: Sending Filled Input buffer = %p, %p\
1350 to LCML\n",pBufHeader,pBufHeader->pBuffer);
1351
1352            /* Store time stamp information */
1353            pComponentPrivate->arrTimestamp[pComponentPrivate->IpBufindex] = pBufHeader->nTimeStamp;
1354            pComponentPrivate->arrTickCount[pComponentPrivate->IpBufindex] = pBufHeader->nTickCount;
1355            pComponentPrivate->IpBufindex++;
1356            pComponentPrivate->IpBufindex %= pComponentPrivate->pPortDef[OMX_DirInput]->nBufferCountActual;
1357
1358            if (pComponentPrivate->curState == OMX_StateExecuting) {
1359                if (!G726DEC_IsPending(pComponentPrivate,pBufHeader,OMX_DirInput)) {
1360                    if(!pComponentPrivate->bDspStoppedWhileExecuting) {
1361                        G726DEC_SetPending(pComponentPrivate,pBufHeader,OMX_DirInput,__LINE__);
1362
1363
1364                        eError = LCML_QueueBuffer(pLcmlHandle->pCodecinterfacehandle,
1365                                                  EMMCodecInputBuffer,
1366                                                  pBufHeader->pBuffer,
1367                                                  pBufHeader->nAllocLen,
1368                                                  pBufHeader->nFilledLen,
1369                                                  (OMX_U8 *) pLcmlHdr->pFrameParam,
1370                                                  sizeof(G726DEC_UAlgInBufParamStruct),
1371                                                  pBufHeader->pBuffer);
1372
1373                        if (eError != OMX_ErrorNone) {
1374                            G726DEC_EPRINT ("::Comp: SetBuff: IP: Error Occurred\n");
1375                            eError = OMX_ErrorHardware;
1376                            goto EXIT;
1377                        }
1378
1379                        pComponentPrivate->lcml_nCntIp++;
1380                        pComponentPrivate->lcml_nIpBuf++;
1381                        pComponentPrivate->num_Sent_Ip_Buff++;
1382                        G726DEC_DPRINT ("Sending Input buffer to Codec\n");
1383                    }
1384                    else {
1385                        G726DEC_DPRINT("Calling EmptyBufferDone from line %d\n",__LINE__);
1386                        pComponentPrivate->cbInfo.EmptyBufferDone (pComponentPrivate->pHandle,
1387                                                                   pComponentPrivate->pHandle->pApplicationPrivate,
1388                                                                   pBufHeader );
1389                    }
1390
1391                }
1392            } else if (pComponentPrivate->curState == OMX_StatePause) {
1393                pComponentPrivate->pInputBufHdrPending[pComponentPrivate->nNumInputBufPending++] = pBufHeader;
1394            }
1395        } else {
1396            pComponentPrivate->bBypassDSP = 1;
1397            G726DEC_DPRINT ("Forcing EmptyBufferDone\n");
1398            if(pComponentPrivate->dasfmode == 0) {
1399                pComponentPrivate->cbInfo.EmptyBufferDone (pComponentPrivate->pHandle,
1400                                                           pComponentPrivate->pHandle->pApplicationPrivate,
1401                                                           pComponentPrivate->pInputBufferList->pBufHdr[0]);
1402                pComponentPrivate->nEmptyBufferDoneCount++;
1403            }
1404        }
1405        if(pBufHeader->pMarkData){
1406            G726DEC_DPRINT (":Detected pBufHeader->pMarkData\n");
1407            pComponentPrivate->pMarkData = pBufHeader->pMarkData;
1408            pComponentPrivate->hMarkTargetComponent = pBufHeader->hMarkTargetComponent;
1409            pComponentPrivate->pOutputBufferList->pBufHdr[0]->pMarkData = pBufHeader->pMarkData;
1410            pComponentPrivate->pOutputBufferList->pBufHdr[0]->hMarkTargetComponent = pBufHeader->hMarkTargetComponent;
1411            if(pBufHeader->hMarkTargetComponent == pComponentPrivate->pHandle && pBufHeader->pMarkData){
1412                pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
1413                                                       pComponentPrivate->pHandle->pApplicationPrivate,
1414                                                       OMX_EventMark,
1415                                                       0,
1416                                                       0,
1417                                                       pBufHeader->pMarkData);
1418            }
1419        }
1420        if (pComponentPrivate->bFlushInputPortCommandPending) {
1421            OMX_SendCommand(pComponentPrivate->pHandle,OMX_CommandFlush,0,NULL);
1422        }
1423    }
1424    else if (eDir == OMX_DirOutput) {
1425        LCML_DSP_INTERFACE *pLcmlHandle = (LCML_DSP_INTERFACE *)pComponentPrivate->pLcmlHandle;
1426        G726D_LCML_BUFHEADERTYPE *pLcmlHdr;
1427        pComponentPrivate->nUnhandledFillThisBuffers--;
1428        G726DEC_DPRINT(": pComponentPrivate->lcml_nOpBuf = %ld\n",
1429                       pComponentPrivate->lcml_nOpBuf);
1430        G726DEC_DPRINT(": pComponentPrivate->lcml_nIpBuf = %ld\n",
1431                       pComponentPrivate->lcml_nIpBuf);
1432
1433        eError = G726DEC_GetCorresponding_LCMLHeader(pComponentPrivate,pBufHeader->pBuffer, OMX_DirOutput, &pLcmlHdr);
1434        phandle = (LCML_DSP_INTERFACE *)(((LCML_CODEC_INTERFACE *)pLcmlHandle->pCodecinterfacehandle)->pCodec);
1435
1436        if (eError != OMX_ErrorNone) {
1437            G726DEC_EPRINT(":: Error: Invalid Buffer Came ...\n");
1438            goto EXIT;
1439        }
1440
1441
1442
1443        G726DEC_DPRINT (":::Calling LCML_QueueBuffer\n");
1444        if (pComponentPrivate->bBypassDSP == 0) {
1445            G726DEC_DPRINT ("Comp:: Sending Emptied Output buffer=%p to LCML\n",pBufHeader);
1446            if (pComponentPrivate->curState == OMX_StateExecuting) {
1447                G726DEC_DPRINT ("Comp:: in G726DEC UTILS pLcmlHandle->pCodecinterfacehandle= %p\n",
1448                                pLcmlHandle->pCodecinterfacehandle);
1449                G726DEC_DPRINT ("Comp:: in G726DEC UTILS pBufHeader->pBuffer = %p\n",pBufHeader->pBuffer);
1450                G726DEC_DPRINT ("Comp:: in G726DEC UTILS pBufHeader->nAllocLen = %ld\n",pBufHeader->nAllocLen);
1451                if (!G726DEC_IsPending(pComponentPrivate,pBufHeader,OMX_DirOutput) &&
1452                    (pComponentPrivate->numPendingBuffers < pComponentPrivate->pOutputBufferList->numBuffers))  {
1453                    G726DEC_SetPending(pComponentPrivate,pBufHeader,OMX_DirOutput,__LINE__);
1454                    G726DEC_DPRINT("pComponentPrivate->bDspStoppedWhileExecuting = %d\n", pComponentPrivate->bDspStoppedWhileExecuting);
1455                    if(!pComponentPrivate->bDspStoppedWhileExecuting){
1456                        eError = LCML_QueueBuffer(pLcmlHandle->pCodecinterfacehandle,
1457                                                  EMMCodecOuputBuffer,
1458                                                  pBufHeader->pBuffer,
1459                                                  pBufHeader->nAllocLen,
1460                                                  pBufHeader->nFilledLen,
1461                                                  NULL,
1462                                                  0,
1463                                                  pBufHeader->pBuffer);
1464
1465                        if (eError != OMX_ErrorNone ) {
1466                            G726DEC_EPRINT (":: Comp:: SetBuff OP: Error Occurred\n");
1467                            eError = OMX_ErrorHardware;
1468                            goto EXIT;
1469                        }
1470                        pComponentPrivate->lcml_nCntOp++;
1471                        pComponentPrivate->lcml_nOpBuf++;
1472                        pComponentPrivate->num_Op_Issued++;
1473                        G726DEC_DPRINT ("Comp:: in G726DEC UTILS \n");
1474                    }
1475                }
1476            } else {
1477                pComponentPrivate->pOutputBufHdrPending[pComponentPrivate->nNumOutputBufPending++] = pBufHeader;
1478            }
1479        }
1480        if (pComponentPrivate->bFlushOutputPortCommandPending) {
1481            OMX_SendCommand( pComponentPrivate->pHandle, OMX_CommandFlush, 1, NULL);
1482        }
1483    } /* end of OMX_DirOutput if struct */
1484    else {
1485        G726DEC_DPRINT(": BufferHeader %p, Buffer %p Unknown ..........\n",pBufHeader, pBufHeader->pBuffer);
1486        eError = OMX_ErrorBadParameter;
1487    }
1488 EXIT:
1489    G726DEC_DPRINT(": Exiting from  HandleDataBuf_FromApp: %x \n",eError);
1490    if(eError == OMX_ErrorBadParameter) {
1491        G726DEC_DPRINT(": Error = OMX_ErrorBadParameter\n");
1492    }
1493    return eError;
1494}
1495
1496
1497/* ================================================================================= * */
1498/**
1499 * @fn G726DEC_GetBufferDirection() function determines whether it is input buffer or
1500 * output buffer.
1501 *
1502 * @param *pBufHeader This is pointer to buffer header whose direction needs to
1503 *                    be determined.
1504 *
1505 * @param *eDir  This is output argument which stores the direction of buffer.
1506 *
1507 * @pre          None
1508 *
1509 * @post         None
1510 *
1511 *  @return      OMX_ErrorNone = Successful processing.
1512 *               OMX_ErrorBadParameter = In case of invalid buffer
1513 *
1514 *  @see         None
1515 */
1516/* ================================================================================ * */
1517
1518OMX_ERRORTYPE G726DEC_GetBufferDirection(OMX_BUFFERHEADERTYPE *pBufHeader,
1519                                         OMX_DIRTYPE *eDir)
1520{
1521    OMX_ERRORTYPE eError = OMX_ErrorNone;
1522    G726DEC_COMPONENT_PRIVATE *pComponentPrivate = pBufHeader->pPlatformPrivate;
1523    OMX_U32 nBuf = pComponentPrivate->pInputBufferList->numBuffers;
1524    OMX_BUFFERHEADERTYPE *pBuf = NULL;
1525    int flag = 1;
1526    OMX_U32 i=0;
1527
1528    G726DEC_DPRINT (":: Entering GetBufferDirection Function\n");
1529    for(i=0; i<nBuf; i++) {
1530        pBuf = pComponentPrivate->pInputBufferList->pBufHdr[i];
1531        if(pBufHeader == pBuf) {
1532            *eDir = OMX_DirInput;
1533            G726DEC_DPRINT (":: Buffer %p is INPUT BUFFER\n", pBufHeader);
1534            flag = 0;
1535            goto EXIT;
1536        }
1537    }
1538
1539    nBuf = pComponentPrivate->pOutputBufferList->numBuffers;
1540
1541    for(i=0; i<nBuf; i++) {
1542        pBuf = pComponentPrivate->pOutputBufferList->pBufHdr[i];
1543        if(pBufHeader == pBuf) {
1544            *eDir = OMX_DirOutput;
1545            G726DEC_DPRINT (":: Buffer %p is OUTPUT BUFFER\n", pBufHeader);
1546            flag = 0;
1547            goto EXIT;
1548        }
1549    }
1550
1551    if (flag == 1) {
1552        G726D_OMX_ERROR_EXIT(eError, OMX_ErrorBadParameter,
1553                             "Buffer Not Found in List : OMX_ErrorBadParameter");
1554    }
1555 EXIT:
1556    G726DEC_DPRINT (":: Exiting GetBufferDirection Function\n");
1557    return eError;
1558}
1559
1560
1561/* ================================================================================= * */
1562/**
1563 * @fn G726DEC_LCML_Callback() function is callback which is called by LCML whenever
1564 * there is an even generated for the component.
1565 *
1566 * @param event  This is event that was generated.
1567 *
1568 * @param arg    This has other needed arguments supplied by LCML like handles
1569 *               etc.
1570 *
1571 * @pre          None
1572 *
1573 * @post         None
1574 *
1575 *  @return      OMX_ErrorNone = Successful processing.
1576 *               OMX_ErrorInsufficientResources = Not enough memory
1577 *
1578 *  @see         None
1579 */
1580/* ================================================================================ * */
1581OMX_ERRORTYPE G726DEC_LCML_Callback (TUsnCodecEvent event,void * args [10])
1582{
1583    OMX_ERRORTYPE eError = OMX_ErrorNone;
1584    OMX_U8 *pBuffer = args[1];
1585    OMX_U32 i = 0;
1586    G726D_LCML_BUFHEADERTYPE *pLcmlHdr = NULL;
1587    OMX_COMPONENTTYPE *pHandle = NULL;
1588    LCML_DSP_INTERFACE *pLcmlHandle = NULL;
1589    G726DEC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
1590#ifdef RESOURCE_MANAGER_ENABLED
1591    OMX_ERRORTYPE rm_error = OMX_ErrorNone;
1592#endif
1593
1594    pComponentPrivate = (G726DEC_COMPONENT_PRIVATE*)
1595        ((LCML_DSP_INTERFACE*)args[6])->pComponentPrivate;
1596    G726DEC_DPRINT("Component private handle: pComponentPrivate = %p\n",pComponentPrivate);
1597
1598    G726DEC_DPRINT (":: Entering the LCML_Callback() : event = %d\n",event);
1599    switch(event) {
1600
1601    case EMMCodecDspError:
1602        G726DEC_DPRINT("[LCML CALLBACK EVENT]  EMMCodecDspError >>>>>>>>>>\n");
1603        break;
1604
1605    case EMMCodecInternalError:
1606        G726DEC_DPRINT("[LCML CALLBACK EVENT]  EMMCodecInternalError >>>>>>>>>> \n");
1607        break;
1608
1609    case EMMCodecInitError:
1610        G726DEC_DPRINT("[LCML CALLBACK EVENT]  EMMCodecInitError>>>>>>>>>> \n");
1611        break;
1612
1613    case EMMCodecDspMessageRecieved:
1614        G726DEC_DPRINT("[LCML CALLBACK EVENT]  EMMCodecDspMessageRecieved>>>>>>>>>> \n");
1615        break;
1616
1617    case EMMCodecBufferProcessed:
1618        G726DEC_DPRINT("[LCML CALLBACK EVENT]  EMMCodecBufferProcessed>>>>>>>>>> \n");
1619        break;
1620
1621    case EMMCodecProcessingStarted:
1622        G726DEC_DPRINT("[LCML CALLBACK EVENT]  EMMCodecProcessingStarted>>>>>>>>>> \n");
1623        break;
1624
1625    case EMMCodecProcessingPaused:
1626        G726DEC_DPRINT("[LCML CALLBACK EVENT]  EMMCodecProcessingPaused>>>>>>>>>> \n");
1627        break;
1628
1629    case EMMCodecProcessingStoped:
1630        G726DEC_DPRINT("[LCML CALLBACK EVENT]  EMMCodecProcessingStoped>>>>>>>>>> \n");
1631        break;
1632
1633    case EMMCodecProcessingEof:
1634        G726DEC_DPRINT("[LCML CALLBACK EVENT]  EMMCodecProcessingEof>>>>>>>>>> \n");
1635        break;
1636
1637    case EMMCodecBufferNotProcessed:
1638        G726DEC_DPRINT("[LCML CALLBACK EVENT]  EMMCodecBufferNotProcessed>>>>>>>>>> \n");
1639        break;
1640
1641    case EMMCodecAlgCtrlAck:
1642        G726DEC_DPRINT("[LCML CALLBACK EVENT]  EMMCodecAlgCtrlAck>>>>>>>>>> \n");
1643        break;
1644
1645    case EMMCodecStrmCtrlAck:
1646        G726DEC_DPRINT("[LCML CALLBACK EVENT]  EMMCodecStrmCtrlAck>>>>>>>>>> \n");
1647        break;
1648    }
1649    if(event == EMMCodecBufferProcessed){
1650        G726DEC_DPRINT(":: --------- EMMCodecBufferProcessed Here\n");
1651        if( args[0] == (void *)EMMCodecInputBuffer) {
1652            G726DEC_DPRINT (" :: Inside the LCML_Callback EMMCodecInputBuffer\n");
1653            G726DEC_DPRINT(":: Input: pBufferr = %p\n", pBuffer);
1654
1655            eError = G726DEC_GetCorresponding_LCMLHeader(pComponentPrivate,pBuffer, OMX_DirInput, &pLcmlHdr);
1656            G726DEC_DPRINT(":: Input: pLcmlHeader = %p\n", pLcmlHdr);
1657            G726DEC_DPRINT(":: Input: pLcmlHdr->eDir = %d\n", pLcmlHdr->eDir);
1658            G726DEC_DPRINT(":: Input: *pLcmlHdr->eDir = %d\n", pLcmlHdr->eDir);
1659            G726DEC_DPRINT(":: Input: Filled Len = %ld\n", pLcmlHdr->pBufHdr->nFilledLen);
1660
1661            if((int)args[5] == IUALG_WARN_PLAYCOMPLETED)
1662                G726DEC_DPRINT("IUALG_WARN_PLAYCOMPLETED is sent from EMMCodecBufferProcessed event\n");
1663            if (eError != OMX_ErrorNone) {
1664                G726DEC_EPRINT(":: Error: Invalid Buffer Came ...\n");
1665                goto EXIT;
1666            }
1667            G726DEC_DPRINT(":: Input: pLcmlHeader = %p\n", pLcmlHdr);
1668
1669            pComponentPrivate->lcml_nCntIpRes++;
1670
1671            G726DEC_ClearPending(pComponentPrivate,pLcmlHdr->pBufHdr,OMX_DirInput,__LINE__);
1672            /*ret = write (pComponentPrivate->lcml_Pipe[1], &pLcmlHdr, sizeof(pLcmlHdr)); */
1673            G726DEC_DPRINT(": Component Sending Empty Input buffer%p to App\n",pLcmlHdr->pBufHdr->pBuffer);
1674            pLcmlHdr->pBufHdr->nFlags |= OMX_BUFFERFLAG_EOS;
1675            pComponentPrivate->cbInfo.EmptyBufferDone (pComponentPrivate->pHandle,
1676                                                       pComponentPrivate->pHandle->pApplicationPrivate,
1677                                                       pLcmlHdr->pBufHdr );
1678            pComponentPrivate->nEmptyBufferDoneCount++;
1679            pComponentPrivate->lcml_nIpBuf--;
1680            pComponentPrivate->app_nBuf++;
1681            /***************************************/
1682
1683        } else if (args[0] == (void *)EMMCodecOuputBuffer) {
1684            G726DEC_DPRINT (" :: Inside the LCML_Callback EMMCodecOuputBuffer\n");
1685            G726DEC_DPRINT(":: Output: pBuffer = %p\n", pBuffer);
1686            if (!G726DEC_IsValid(pComponentPrivate,pBuffer,OMX_DirOutput)) {
1687                /* If the buffer we get back from the DSP is not valid call FillBufferDone
1688                   on a valid buffer */
1689                pComponentPrivate->cbInfo.FillBufferDone (pComponentPrivate->pHandle,
1690                                                          pComponentPrivate->pHandle->pApplicationPrivate,
1691                                                          pComponentPrivate->pOutputBufferList->pBufHdr[pComponentPrivate->nInvalidFrameCount++]);
1692                pComponentPrivate->nOutStandingFillDones--;
1693                pComponentPrivate->numPendingBuffers--;
1694            }
1695            else {
1696                pComponentPrivate->nOutStandingFillDones++;
1697                eError = G726DEC_GetCorresponding_LCMLHeader(pComponentPrivate,pBuffer, OMX_DirOutput, &pLcmlHdr);
1698                if (eError != OMX_ErrorNone) {
1699                    G726DEC_EPRINT(":: Error: Invalid Buffer Came ...\n");
1700                    goto EXIT;
1701                }
1702                pLcmlHdr->pBufHdr->nFilledLen = (int)args[8];
1703                G726DEC_DPRINT(":: Output: pLcmlHeader = %p\n", pLcmlHdr);
1704                G726DEC_DPRINT(":: Output: pLcmlHdr->eDir = %d\n", pLcmlHdr->eDir);
1705                G726DEC_DPRINT(":: Output: Filled Len = %ld\n", pLcmlHdr->pBufHdr->nFilledLen);
1706                pComponentPrivate->lcml_nCntOpReceived++;
1707                G726DEC_ClearPending(pComponentPrivate,pLcmlHdr->pBufHdr,OMX_DirOutput,__LINE__);
1708                /*ret = write (pComponentPrivate->lcml_Pipe[1], &pLcmlHdr, sizeof(pLcmlHdr));*/
1709                G726DEC_DPRINT ("Sending Output buffer to Applcation\n");
1710                if (pComponentPrivate->bIsEOFSent){
1711                    G726DEC_DPRINT ("Adding EOS flag to the output buffer\n");
1712                    pLcmlHdr->pBufHdr->nFlags |= OMX_BUFFERFLAG_EOS;
1713                    pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
1714                                                           pComponentPrivate->pHandle->pApplicationPrivate,
1715                                                           OMX_EventBufferFlag,
1716                                                           pLcmlHdr->pBufHdr->nOutputPortIndex,
1717                                                           pLcmlHdr->pBufHdr->nFlags, NULL);
1718                    pComponentPrivate->bIsEOFSent = 0;
1719                }
1720                if (pComponentPrivate->pMarkData) {
1721                    G726DEC_DPRINT ("pComponentPrivate->pMarkData set\n");
1722                    pLcmlHdr->pBufHdr->pMarkData = pComponentPrivate->pMarkData;
1723                    pLcmlHdr->pBufHdr->hMarkTargetComponent = pComponentPrivate->hMarkTargetComponent;
1724                }
1725                pComponentPrivate->num_Reclaimed_Op_Buff++;
1726                G726DEC_DPRINT(": Component Sending Filled Output buffer%p to App\n",pLcmlHdr->pBufHdr);
1727                G726DEC_DPRINT("pLcmlHdr->pBufHdr = 0x%p\n",pLcmlHdr->pBufHdr);
1728                if (pComponentPrivate->curState != OMX_StatePause) {
1729                    /* Copying time stamp information to output buffer */
1730                    pLcmlHdr->pBufHdr->nTimeStamp = pComponentPrivate->arrTimestamp[pComponentPrivate->OpBufindex];
1731                    pLcmlHdr->pBufHdr->nTickCount = pComponentPrivate->arrTickCount[pComponentPrivate->OpBufindex];
1732                    pComponentPrivate->OpBufindex++;
1733                    pComponentPrivate->OpBufindex %= pComponentPrivate->pPortDef[OMX_DirInput]->nBufferCountActual;
1734
1735                    pComponentPrivate->cbInfo.FillBufferDone (pComponentPrivate->pHandle,
1736                                                              pComponentPrivate->pHandle->pApplicationPrivate,
1737                                                              pLcmlHdr->pBufHdr);
1738                    pComponentPrivate->nOutStandingFillDones--;
1739                    pComponentPrivate->lcml_nOpBuf--;
1740                    pComponentPrivate->app_nBuf++;
1741                    pComponentPrivate->nFillBufferDoneCount++;
1742                }
1743                /**********************************************/
1744            }
1745        }
1746    } else if(event == EMMCodecProcessingStoped) {
1747        if (!pComponentPrivate->bNoIdleOnStop) {
1748            pComponentPrivate->curState = OMX_StateIdle;
1749#ifdef RESOURCE_MANAGER_ENABLED
1750            rm_error = RMProxy_NewSendCommand(pHandle, RMProxy_StateSet, OMX_PCM_Decoder_COMPONENT, OMX_StateIdle, 3456,NULL);
1751#endif
1752            pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle, pComponentPrivate->pHandle->pApplicationPrivate,
1753                                                   OMX_EventCmdComplete, OMX_CommandStateSet,
1754                                                   pComponentPrivate->curState, NULL);
1755            G726DEC_DPRINT ("%d :: The component is stopped\n",__LINE__);
1756        }
1757        else {
1758            pComponentPrivate->bIdleCommandPending = OMX_TRUE;
1759            pComponentPrivate->bDspStoppedWhileExecuting = OMX_TRUE;
1760            pComponentPrivate->bNoIdleOnStop= OMX_FALSE;
1761        }
1762        for (i=0; i < pComponentPrivate->pInputBufferList->numBuffers; i++) {
1763            G726DEC_ClearPending(pComponentPrivate, pComponentPrivate->pInputBufferList->pBufHdr[i], OMX_DirInput, __LINE__);
1764        }
1765        for (i=0; i < pComponentPrivate->pOutputBufferList->numBuffers; i++) {
1766            G726DEC_ClearPending(pComponentPrivate, pComponentPrivate->pOutputBufferList->pBufHdr[i], OMX_DirOutput, __LINE__);
1767        }
1768
1769    } else if(event == EMMCodecAlgCtrlAck) {
1770        G726DEC_DPRINT ("GOT MESSAGE USN_DSPACK_ALGCTRL \n");
1771    } else if (event == EMMCodecDspError) {
1772        G726DEC_DPRINT(":: commandedState  = %p\n",args[0]);
1773        G726DEC_DPRINT(":: arg4 = %p\n",args[4]);
1774        G726DEC_DPRINT(":: arg5 = %p\n",args[5]);
1775        G726DEC_DPRINT(":: --------- EMMCodecDspError Here\n");
1776        if(((int)args[4] == USN_ERR_WARNING) && ((int)args[5] == IUALG_WARN_PLAYCOMPLETED)) {
1777            /* add callback to application to indicate SN/USN has completed playing of current set of date */
1778
1779            pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
1780                                                   pComponentPrivate->pHandle->pApplicationPrivate,
1781                                                   OMX_EventBufferFlag,
1782                                                   (OMX_U32)NULL,
1783                                                   OMX_BUFFERFLAG_EOS,
1784                                                   NULL);
1785        }
1786        if((int)args[5] == IUALG_WARN_CONCEALED) {
1787            G726DEC_DPRINT( "Algorithm issued a warning. But can continue" );
1788            G726DEC_DPRINT("%d :: arg5 = %p\n",__LINE__,args[5]);
1789        }
1790
1791        if((int)args[5] == IUALG_ERR_GENERAL) {
1792            G726DEC_DPRINT( "Algorithm error. Cannot continue" );
1793            G726DEC_DPRINT("%d :: arg5 = %p\n",__LINE__,args[5]);
1794            G726DEC_DPRINT("%d :: LCML_Callback: IUALG_ERR_GENERAL\n",__LINE__);
1795            pHandle = pComponentPrivate->pHandle;
1796            pLcmlHandle = (LCML_DSP_INTERFACE *)pComponentPrivate->pLcmlHandle;
1797        }
1798
1799        if( (int)args[5] == IUALG_ERR_DATA_CORRUPT ){
1800            char *pArgs = "damedesuStr";
1801            G726DEC_DPRINT("%d :: arg5 = %p\n",__LINE__,args[5]);
1802            G726DEC_DPRINT("%d :: LCML_Callback: IUALG_ERR_DATA_CORRUPT\n",__LINE__);
1803            pHandle = pComponentPrivate->pHandle;
1804            pLcmlHandle = (LCML_DSP_INTERFACE *)pComponentPrivate->pLcmlHandle;
1805
1806            eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1807                                       MMCodecControlStop,(void *)pArgs);
1808            if(eError != OMX_ErrorNone) {
1809                G726DEC_EPRINT("%d: Error Occurred in Codec Stop..\n",
1810                               __LINE__);
1811                goto EXIT;
1812            }
1813            G726DEC_DPRINT("%d :: G726DEC: Codec has been Stopped here\n",__LINE__);
1814            pComponentPrivate->curState = OMX_StateIdle;
1815#ifdef RESOURCE_MANAGER_ENABLED
1816            rm_error = RMProxy_NewSendCommand(pHandle, RMProxy_StateSet, OMX_PCM_Decoder_COMPONENT, OMX_StateIdle, 3456,NULL);
1817#endif
1818            pComponentPrivate->cbInfo.EventHandler(
1819                                                   pHandle, pHandle->pApplicationPrivate,
1820                                                   OMX_EventCmdComplete, OMX_ErrorNone,0, NULL);
1821
1822        }
1823
1824        if( (int)args[5] == IUALG_WARN_OVERFLOW ){
1825            G726DEC_DPRINT( "Algorithm error. Overflow" );
1826        }
1827        if( (int)args[5] == IUALG_WARN_UNDERFLOW ){
1828            G726DEC_DPRINT( "Algorithm error. Underflow" );
1829        }
1830    } else if (event == EMMCodecStrmCtrlAck) {
1831        G726DEC_DPRINT(":: GOT MESSAGE USN_DSPACK_STRMCTRL ----\n");
1832        {
1833            pHandle = pComponentPrivate->pHandle;
1834            if ( args[2] == (void *)EMMCodecInputBuffer) {
1835                if (args[0] == (void *)USN_ERR_NONE ) {
1836                    G726DEC_DPRINT("Flushing input port %d\n",__LINE__);
1837                    for (i=0; i < pComponentPrivate->nNumInputBufPending; i++) {
1838                        pComponentPrivate->cbInfo.EmptyBufferDone (pComponentPrivate->pHandle,
1839                                                                   pComponentPrivate->pHandle->pApplicationPrivate,
1840                                                                   pComponentPrivate->pInputBufHdrPending[i]);
1841                        pComponentPrivate->pInputBufHdrPending[i] = NULL;
1842                    }
1843                    pComponentPrivate->nNumInputBufPending=0;
1844                    pComponentPrivate->cbInfo.EventHandler(pHandle,
1845                                                           pHandle->pApplicationPrivate,
1846                                                           OMX_EventCmdComplete,
1847                                                           OMX_CommandFlush,G726D_INPUT_PORT, NULL);
1848                } else {
1849                    G726DEC_DPRINT ("LCML reported error while flushing input port\n");
1850                    goto EXIT;
1851                }
1852            }
1853            else if ( args[2] == (void *)EMMCodecOuputBuffer) {
1854                if (args[0] == (void *)USN_ERR_NONE ) {
1855                    G726DEC_DPRINT("Flushing output port %d\n",__LINE__);
1856                    for (i=0; i < pComponentPrivate->nNumOutputBufPending; i++) {
1857                        pComponentPrivate->cbInfo.FillBufferDone (pComponentPrivate->pHandle,
1858                                                                  pComponentPrivate->pHandle->pApplicationPrivate,
1859                                                                  pComponentPrivate->pOutputBufHdrPending[i]
1860                                                                  );
1861                        pComponentPrivate->nOutStandingFillDones--;
1862                        pComponentPrivate->pOutputBufHdrPending[i] = NULL;
1863                    }
1864                    pComponentPrivate->nNumOutputBufPending=0;
1865                    pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
1866                                                           pComponentPrivate->pHandle->pApplicationPrivate,
1867                                                           OMX_EventCmdComplete,
1868                                                           OMX_CommandFlush,G726D_OUTPUT_PORT,
1869                                                           NULL);
1870                } else {
1871                    G726DEC_DPRINT ("LCML reported error while flushing output port\n");
1872                    goto EXIT;
1873                }
1874            }
1875        }
1876    }
1877
1878 EXIT:
1879    G726DEC_DPRINT (":: Exiting the LCML_Callback() \n");
1880    return eError;
1881}
1882
1883
1884/* ================================================================================= * */
1885/**
1886 * @fn G726DEC_GetCorresponding_LCMLHeader() function gets the corresponding LCML
1887 * header from the actual data buffer for required processing.
1888 *
1889 * @param *pBuffer This is the data buffer pointer.
1890 *
1891 * @param eDir   This is direction of buffer. Input/Output.
1892 *
1893 * @param *G726D_LCML_BUFHEADERTYPE  This is pointer to LCML Buffer Header.
1894 *
1895 * @pre          None
1896 *
1897 * @post         None
1898 *
1899 *  @return      OMX_ErrorNone = Successful Inirialization of the component\n
1900 *               OMX_ErrorHardware = Hardware error has occured.
1901 *
1902 *  @see         None
1903 */
1904/* ================================================================================ * */
1905OMX_ERRORTYPE G726DEC_GetCorresponding_LCMLHeader(G726DEC_COMPONENT_PRIVATE *pComponentPrivate,
1906                                                  OMX_U8 *pBuffer,
1907                                                  OMX_DIRTYPE eDir,
1908                                                  G726D_LCML_BUFHEADERTYPE **ppLcmlHdr)
1909{
1910    OMX_ERRORTYPE eError = OMX_ErrorNone;
1911    G726D_LCML_BUFHEADERTYPE *pLcmlBufHeader = NULL;
1912    int nIpBuf=0, nOpBuf=0, i=0;
1913
1914    G726DEC_DPRINT (":: Entering the G726DEC_GetCorresponding_LCMLHeader()\n");
1915    G726DEC_DPRINT (":: eDir = %d\n",eDir);
1916
1917    while (!pComponentPrivate->bInitParamsInitialized) {
1918#ifndef UNDER_CE
1919        sched_yield();
1920#else
1921        Sleep(0);
1922#endif
1923    }
1924
1925    if(eDir == OMX_DirInput) {
1926        G726DEC_DPRINT (":: In GetCorresponding_LCMLHeader()\n");
1927
1928        nIpBuf = pComponentPrivate->pInputBufferList->numBuffers;
1929
1930        pLcmlBufHeader = pComponentPrivate->pLcmlBufHeader[G726D_INPUT_PORT];
1931
1932        for(i=0; i<nIpBuf; i++) {
1933            G726DEC_DPRINT("pBuffer = %p\n",pBuffer);
1934            G726DEC_DPRINT("pLcmlBufHeader->pBufHdr->pBuffer = %p\n",pLcmlBufHeader->pBufHdr->pBuffer);
1935            if(pBuffer == pLcmlBufHeader->pBufHdr->pBuffer) {
1936                *ppLcmlHdr = pLcmlBufHeader;
1937                G726DEC_DPRINT("::Corresponding LCML Header Found\n");
1938                goto EXIT;
1939            }
1940            pLcmlBufHeader++;
1941        }
1942    } else if (eDir == OMX_DirOutput) {
1943        i = 0;
1944        nOpBuf = pComponentPrivate->pOutputBufferList->numBuffers;
1945
1946        pLcmlBufHeader = pComponentPrivate->pLcmlBufHeader[G726D_OUTPUT_PORT];
1947        G726DEC_DPRINT (":: nOpBuf = %d\n",nOpBuf);
1948
1949        for(i=0; i<nOpBuf; i++) {
1950            G726DEC_DPRINT("pBuffer = %p\n",pBuffer);
1951            G726DEC_DPRINT("pLcmlBufHeader->pBufHdr->pBuffer = %p\n",pLcmlBufHeader->pBufHdr->pBuffer);
1952            if(pBuffer == pLcmlBufHeader->pBufHdr->pBuffer) {
1953                *ppLcmlHdr = pLcmlBufHeader;
1954                G726DEC_DPRINT("::Corresponding LCML Header Found\n");
1955                goto EXIT;
1956            }
1957            pLcmlBufHeader++;
1958        }
1959    } else {
1960        G726DEC_DPRINT(":: Invalid Buffer Type :: exiting...\n");
1961    }
1962
1963 EXIT:
1964    G726DEC_DPRINT (":: Exiting the GetCorresponding_LCMLHeader() \n");
1965    return eError;
1966}
1967
1968
1969/** ========================================================================
1970 *  OMX_DmmMap () method is used to allocate the memory using DMM.
1971 *
1972 *  @param ProcHandle -  Component identification number
1973 *  @param size  - Buffer header address, that needs to be sent to codec
1974 *  @param pArmPtr - Message used to send the buffer to codec
1975 *  @param pDmmBuf - buffer id
1976 *
1977 *  @retval OMX_ErrorNone  - Success
1978 *          OMX_ErrorHardware  -  Hardware Error
1979 ** ==========================================================================*/
1980OMX_ERRORTYPE OMX_DmmMap(DSP_HPROCESSOR ProcHandle,
1981                         int size,
1982                         void* pArmPtr,
1983                         DMM_BUFFER_OBJ* pDmmBuf)
1984{
1985    OMX_ERRORTYPE eError = OMX_ErrorUndefined;
1986    DSP_STATUS status = DSP_SOK;
1987    int nSizeReserved = 0;
1988
1989    if(pDmmBuf == NULL)
1990    {
1991        G726DEC_DPRINT("pBuf is NULL\n");
1992        eError = OMX_ErrorBadParameter;
1993        goto EXIT;
1994    }
1995
1996    if(pArmPtr == NULL)
1997    {
1998        G726DEC_DPRINT("pBuf is NULL\n");
1999        eError = OMX_ErrorBadParameter;
2000        goto EXIT;
2001    }
2002
2003    /* Allocate */
2004    pDmmBuf->pAllocated = pArmPtr;
2005
2006    /* Reserve */
2007    nSizeReserved = ROUND_TO_PAGESIZE(size) + 2*DMM_PAGE_SIZE ;
2008    status = DSPProcessor_ReserveMemory(ProcHandle, nSizeReserved, &(pDmmBuf->pReserved));
2009    G726DEC_DPRINT("\nOMX Reserve DSP: %p\n",pDmmBuf->pReserved);
2010
2011    if(DSP_FAILED(status))
2012    {
2013        G726DEC_EPRINT("DSPProcessor_ReserveMemory() failed - error 0x%x", (int)status);
2014        eError = OMX_ErrorHardware;
2015        goto EXIT;
2016    }
2017    pDmmBuf->nSize = size;
2018    G726DEC_DPRINT(" DMM MAP Reserved: %p, size 0x%x (%d)\n", pDmmBuf->pReserved,nSizeReserved,nSizeReserved);
2019
2020    /* Map */
2021    status = DSPProcessor_Map(ProcHandle,
2022                              pDmmBuf->pAllocated,/* Arm addres of data to Map on DSP*/
2023                              size , /* size to Map on DSP*/
2024                              pDmmBuf->pReserved, /* reserved space */
2025                              &(pDmmBuf->pMapped), /* returned map pointer */
2026                              0); /* final param is reserved.  set to zero. */
2027    if(DSP_FAILED(status))
2028    {
2029        G726DEC_EPRINT("DSPProcessor_Map() failed - error 0x%x", (int)status);
2030        eError = OMX_ErrorHardware;
2031        goto EXIT;
2032    }
2033    G726DEC_DPRINT("DMM Mapped: %p, size 0x%x (%d)\n",pDmmBuf->pMapped, size,size);
2034
2035    /* Issue an initial memory flush to ensure cache coherency */
2036    status = DSPProcessor_FlushMemory(ProcHandle, pDmmBuf->pAllocated, size, 0);
2037    if(DSP_FAILED(status))
2038    {
2039        G726DEC_EPRINT("Unable to flush mapped buffer: error 0x%x",(int)status);
2040        goto EXIT;
2041    }
2042    eError = OMX_ErrorNone;
2043
2044 EXIT:
2045    return eError;
2046}
2047
2048/** ========================================================================
2049 *  OMX_DmmUnMap () method is used to de-allocate the memory using DMM.
2050 *
2051 *  @param ProcHandle -  Component identification number
2052 *  @param pMapPtr  - Map address
2053 *  @param pResPtr - reserve adress
2054 *
2055 *  @retval OMX_ErrorNone  - Success
2056 *          OMX_ErrorHardware  -  Hardware Error
2057 ** ==========================================================================*/
2058OMX_ERRORTYPE OMX_DmmUnMap(DSP_HPROCESSOR ProcHandle, void* pMapPtr, void* pResPtr)
2059{
2060    DSP_STATUS status = DSP_SOK;
2061    OMX_ERRORTYPE eError = OMX_ErrorNone;
2062    G726DEC_DPRINT("\nOMX UnReserve DSP: %p\n",pResPtr);
2063
2064    if(pMapPtr == NULL)
2065    {
2066        G726DEC_DPRINT("pMapPtr is NULL\n");
2067        eError = OMX_ErrorBadParameter;
2068        goto EXIT;
2069    }
2070    if(pResPtr == NULL)
2071    {
2072        G726DEC_DPRINT("pResPtr is NULL\n");
2073        eError = OMX_ErrorBadParameter;
2074        goto EXIT;
2075    }
2076    status = DSPProcessor_UnMap(ProcHandle,pMapPtr);
2077    if(DSP_FAILED(status))
2078    {
2079        G726DEC_EPRINT("DSPProcessor_UnMap() failed - error 0x%x",(int)status);
2080    }
2081
2082    G726DEC_DPRINT("unreserving  structure =0x%p\n",pResPtr );
2083    status = DSPProcessor_UnReserveMemory(ProcHandle,pResPtr);
2084    if(DSP_FAILED(status))
2085    {
2086        G726DEC_EPRINT("DSPProcessor_UnReserveMemory() failed - error 0x%x", (int)status);
2087    }
2088
2089 EXIT:
2090    return eError;
2091}
2092
2093/* ================================================================================= * */
2094/**
2095 * @fn G726DEC_GetLCMLHandle() function gets the LCML handle and interacts with LCML
2096 * by using this LCML Handle.
2097 *
2098 * @param *pBufHeader This is the buffer header that needs to be processed.
2099 *
2100 * @param *pComponentPrivate  This is component's private date structure.
2101 *
2102 * @pre          None
2103 *
2104 * @post         None
2105 *
2106 *  @return      OMX_HANDLETYPE = Successful loading of LCML library.
2107 *               OMX_ErrorHardware = Hardware error has occured.
2108 *
2109 *  @see         None
2110 */
2111/* ================================================================================ * */
2112#ifndef UNDER_CE
2113OMX_HANDLETYPE G726DEC_GetLCMLHandle(G726DEC_COMPONENT_PRIVATE *pComponentPrivate)
2114{
2115    /* This must be taken care by WinCE */
2116    OMX_HANDLETYPE pHandle = NULL;
2117    OMX_ERRORTYPE eError = OMX_ErrorNone;
2118    void *handle = NULL;
2119    OMX_ERRORTYPE (*fpGetHandle)(OMX_HANDLETYPE);
2120    char *error = NULL;
2121
2122    handle = dlopen("libLCML.so", RTLD_LAZY);
2123    if (!handle) {
2124        fputs(dlerror(), stderr);
2125        goto EXIT;
2126    }
2127
2128    fpGetHandle = dlsym (handle, "GetHandle");
2129    if ((error = dlerror()) != NULL) {
2130        fputs(error, stderr);
2131        goto EXIT;
2132    }
2133    eError = (*fpGetHandle)(&pHandle);
2134    if(eError != OMX_ErrorNone) {
2135        eError = OMX_ErrorUndefined;
2136        G726DEC_EPRINT("eError != OMX_ErrorNone...\n");
2137        pHandle = NULL;
2138        goto EXIT;
2139    }
2140
2141    ((LCML_DSP_INTERFACE*)pHandle)->pComponentPrivate = pComponentPrivate;
2142 EXIT:
2143    return pHandle;
2144}
2145#else
2146/* WINDOWS Explicit dll load procedure */
2147OMX_HANDLETYPE G726DEC_GetLCMLHandle(G726DEC_COMPONENT_PRIVATE *pComponentPrivate)
2148{
2149    typedef OMX_ERRORTYPE (*LPFNDLLFUNC1)(OMX_HANDLETYPE);
2150    OMX_HANDLETYPE pHandle = NULL;
2151    OMX_ERRORTYPE eError = OMX_ErrorNone;
2152    HINSTANCE hDLL;               /* Handle to DLL */
2153    LPFNDLLFUNC1 fpGetHandle1;
2154
2155    hDLL = LoadLibraryEx(TEXT("OAF_BML.dll"), NULL,0);
2156    if (hDLL == NULL)
2157    {
2158        /*fputs(dlerror(), stderr); */
2159        G726DEC_DPRINT("BML Load Failed!!!\n");
2160        return pHandle;
2161    }
2162
2163    fpGetHandle1 = (LPFNDLLFUNC1)GetProcAddress(hDLL,TEXT("GetHandle"));
2164    if (!fpGetHandle1)
2165    {
2166        /* handle the error */
2167        FreeLibrary(hDLL);
2168        return pHandle;
2169    }
2170
2171    /* call the function */
2172    eError = fpGetHandle1(&pHandle);
2173    if(eError != OMX_ErrorNone) {
2174        eError = OMX_ErrorUndefined;
2175        G726DEC_EPRINT("eError != OMX_ErrorNone...\n");
2176        pHandle = NULL;
2177        return pHandle;
2178    }
2179    ((LCML_DSP_INTERFACE*)pHandle)->pComponentPrivate = pComponentPrivate;
2180    return pHandle;
2181}
2182#endif
2183
2184void G726DEC_CleanupInitParams(OMX_HANDLETYPE pComponent)
2185{
2186    OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)pComponent;
2187    G726DEC_COMPONENT_PRIVATE *pComponentPrivate = (G726DEC_COMPONENT_PRIVATE *)
2188        pHandle->pComponentPrivate;
2189    G726D_LCML_BUFHEADERTYPE *pTemp_lcml = NULL;
2190    OMX_U32 nIpBuf = pComponentPrivate->nRuntimeInputBuffers;
2191    OMX_U32 i=0;
2192    OMX_U8 *ptemp = NULL;
2193
2194    G726DEC_DPRINT (":: G726DEC_CleanupInitParams()\n");
2195    G726DEC_MEMPRINT(":: Freeing:  pComponentPrivate->strmAttr = %p\n", pComponentPrivate->strmAttr);
2196
2197    G726D_OMX_FREE(pComponentPrivate->strmAttr);
2198    /*pComponentPrivate->strmAttr = NULL;*/
2199
2200    /*if (pComponentPrivate->dasfmode == 1) {*/
2201    G726DEC_MEMPRINT(":: Freeing: pComponentPrivate->pParams = %p\n",pComponentPrivate->pParams);
2202    ptemp = (OMX_U8*)pComponentPrivate->pParams;
2203    if(ptemp != NULL){
2204        ptemp -= 128;
2205    }
2206    pComponentPrivate->pParams = (G726D_USN_AudioCodecParams *)ptemp;
2207    G726D_OMX_FREE(pComponentPrivate->pParams);
2208    /*}*/
2209
2210    pTemp_lcml = pComponentPrivate->pLcmlBufHeader[G726D_INPUT_PORT];
2211    for(i=0; i<nIpBuf; i++) {
2212        G726DEC_MEMPRINT(":: Freeing: pTemp_lcml->pFrameParam = %p\n",pTemp_lcml->pFrameParam);
2213        if(pTemp_lcml->pFrameParam!=NULL){
2214            G726D_OMX_FREE(pTemp_lcml->pFrameParam);
2215        }
2216        pTemp_lcml++;
2217    }
2218
2219    G726DEC_MEMPRINT(":: Freeing pComponentPrivate->pLcmlBufHeader[G726D_INPUT_PORT] = %p\n",
2220                     pComponentPrivate->pLcmlBufHeader[G726D_INPUT_PORT]);
2221    G726D_OMX_FREE(pComponentPrivate->pLcmlBufHeader[G726D_INPUT_PORT]);
2222
2223
2224    pTemp_lcml = pComponentPrivate->pLcmlBufHeader[G726D_OUTPUT_PORT];
2225
2226    G726DEC_MEMPRINT(":: Freeing: pComponentPrivate->pLcmlBufHeader[G726D_OUTPUT_PORT] = %p\n",
2227                     pComponentPrivate->pLcmlBufHeader[G726D_OUTPUT_PORT]);
2228    G726D_OMX_FREE(pComponentPrivate->pLcmlBufHeader[G726D_OUTPUT_PORT]);
2229    G726DEC_DPRINT ("Exiting Successfully G726DEC_CleanupInitParams()\n");
2230}
2231/* ========================================================================== */
2232/**
2233 * @G726DEC_SetPending() This function marks the buffer as pending when it is sent
2234 * to DSP/
2235 *
2236 * @param pComponentPrivate This is component's private date area.
2237 *
2238 * @param pBufHdr This is poiter to OMX Buffer header whose buffer is sent to DSP
2239 *
2240 * @param eDir This is direction of buffer i.e. input or output.
2241 *
2242 * @pre None
2243 *
2244 * @post None
2245 *
2246 * @return none
2247 */
2248/* ========================================================================== */
2249void G726DEC_SetPending(G726DEC_COMPONENT_PRIVATE *pComponentPrivate, OMX_BUFFERHEADERTYPE *pBufHdr, OMX_DIRTYPE eDir, OMX_U32 lineNumber)
2250{
2251    OMX_U16 i = 0;
2252
2253    G726DEC_DPRINT("Called G726DEC_SetPending\n");
2254    G726DEC_DPRINT("eDir = %d\n",eDir);
2255
2256    if (eDir == OMX_DirInput) {
2257        for (i=0; i < pComponentPrivate->pInputBufferList->numBuffers; i++) {
2258            if (pBufHdr == pComponentPrivate->pInputBufferList->pBufHdr[i]) {
2259                pComponentPrivate->pInputBufferList->bBufferPending[i] = 1;
2260                G726DEC_DPRINT("*******************INPUT BUFFER %d IS PENDING Line %ld******************************\n",i,lineNumber);
2261            }
2262        }
2263    }
2264    else {
2265        for (i=0; i < pComponentPrivate->pOutputBufferList->numBuffers; i++) {
2266            if (pBufHdr == pComponentPrivate->pOutputBufferList->pBufHdr[i]) {
2267                pComponentPrivate->pOutputBufferList->bBufferPending[i] = 1;
2268                G726DEC_DPRINT("*******************OUTPUT BUFFER %d IS PENDING Line %ld******************************\n",i,lineNumber);
2269            }
2270        }
2271    }
2272}
2273
2274/* ========================================================================== */
2275/**
2276 * @G726DEC_ClearPending() This function clears the buffer status from pending
2277 * when it is received back from DSP.
2278 *
2279 * @param pComponentPrivate This is component's private date area.
2280 *
2281 * @param pBufHdr This is poiter to OMX Buffer header that is received from
2282 * DSP/LCML.
2283 *
2284 * @param eDir This is direction of buffer i.e. input or output.
2285 *
2286 * @pre None
2287 *
2288 * @post None
2289 *
2290 * @return none
2291 */
2292/* ========================================================================== */
2293
2294void G726DEC_ClearPending(G726DEC_COMPONENT_PRIVATE *pComponentPrivate, OMX_BUFFERHEADERTYPE *pBufHdr, OMX_DIRTYPE eDir, OMX_U32 lineNumber)
2295{
2296    OMX_U16 i = 0;
2297    G726DEC_DPRINT("!!!             Entering ClearPending!! eDir = %d\n\n", eDir);
2298    if (eDir == OMX_DirInput) {
2299        for (i=0; i < pComponentPrivate->pInputBufferList->numBuffers; i++) {
2300            if (pBufHdr == pComponentPrivate->pInputBufferList->pBufHdr[i]) {
2301                pComponentPrivate->pInputBufferList->bBufferPending[i] = 0;
2302                G726DEC_DPRINT("*******************INPUT BUFFER %d IS RECLAIMED Line %ld******************************\n",i,lineNumber);
2303            }
2304        }
2305    }
2306    else {
2307        for (i=0; i < pComponentPrivate->pOutputBufferList->numBuffers; i++) {
2308            if (pBufHdr == pComponentPrivate->pOutputBufferList->pBufHdr[i]) {
2309                pComponentPrivate->pOutputBufferList->bBufferPending[i] = 0;
2310                G726DEC_DPRINT("*******************OUTPUT BUFFER %d IS RECLAIMED Line %ld******************************\n",i,lineNumber);
2311            }
2312        }
2313    }
2314}
2315
2316/* ========================================================================== */
2317/**
2318 * @G726DEC_IsPending() This function checks whether or not a buffer is pending.
2319 *
2320 * @param pComponentPrivate This is component's private date area.
2321 *
2322 * @param pBufHdr This is poiter to OMX Buffer header of interest.
2323 *
2324 * @param eDir This is direction of buffer i.e. input or output.
2325 *
2326 * @pre None
2327 *
2328 * @post None
2329 *
2330 * @return none
2331 */
2332/* ========================================================================== */
2333
2334OMX_U32 G726DEC_IsPending(G726DEC_COMPONENT_PRIVATE *pComponentPrivate, OMX_BUFFERHEADERTYPE *pBufHdr, OMX_DIRTYPE eDir)
2335{
2336    OMX_U16 i = 0;
2337
2338    if (eDir == OMX_DirInput) {
2339        for (i=0; i < pComponentPrivate->pInputBufferList->numBuffers; i++) {
2340            if (pBufHdr == pComponentPrivate->pInputBufferList->pBufHdr[i]) {
2341                return pComponentPrivate->pInputBufferList->bBufferPending[i];
2342            }
2343        }
2344    }
2345    else {
2346        for (i=0; i < pComponentPrivate->pOutputBufferList->numBuffers; i++) {
2347            if (pBufHdr == pComponentPrivate->pOutputBufferList->pBufHdr[i]) {
2348                return pComponentPrivate->pOutputBufferList->bBufferPending[i];
2349            }
2350        }
2351    }
2352    return -1;
2353}
2354
2355
2356/* ========================================================================== */
2357/**
2358 * @G726DEC_IsValid() This function identifies whether or not buffer recieved from
2359 * LCML is valid. It searches in the list of input/output buffers to do this.
2360 *
2361 * @param pComponentPrivate This is component's private date area.
2362 *
2363 * @param pBufHdr This is poiter to OMX Buffer header of interest.
2364 *
2365 * @param eDir This is direction of buffer i.e. input or output.
2366 *
2367 * @pre None
2368 *
2369 * @post None
2370 *
2371 * @return status of the buffer.
2372 */
2373/* ========================================================================== */
2374
2375OMX_U32 G726DEC_IsValid(G726DEC_COMPONENT_PRIVATE *pComponentPrivate, OMX_U8 *pBuffer, OMX_DIRTYPE eDir)
2376{
2377    OMX_U16 i = 0;
2378    OMX_U32 found=0;
2379
2380    if (eDir == OMX_DirInput) {
2381        for (i=0; i < pComponentPrivate->pInputBufferList->numBuffers; i++) {
2382            if (pBuffer == pComponentPrivate->pInputBufferList->pBufHdr[i]->pBuffer) {
2383                found = 1;
2384            }
2385        }
2386    }
2387    else {
2388        for (i=0; i < pComponentPrivate->pOutputBufferList->numBuffers; i++) {
2389            if (pBuffer == pComponentPrivate->pOutputBufferList->pBufHdr[i]->pBuffer) {
2390                found = 1;
2391            }
2392        }
2393    }
2394    return found;
2395}
2396
2397/* ========================================================================== */
2398/**
2399 * @G726DECFill_LCMLInitParamsEx() This function initializes the init parameter of
2400 * the LCML structure when a port is enabled and component is in idle state.
2401 *
2402 * @param pComponent This is component handle.
2403 *
2404 * @pre None
2405 *
2406 * @post None
2407 *
2408 * @return appropriate OMX Error.
2409 */
2410/* ========================================================================== */
2411
2412OMX_ERRORTYPE G726DECFill_LCMLInitParamsEx(OMX_HANDLETYPE pComponent)
2413
2414{
2415    OMX_ERRORTYPE eError = OMX_ErrorNone;
2416    OMX_U32 nIpBuf = 0,nIpBufSize = 0,nOpBuf = 0,nOpBufSize = 0;
2417    OMX_U32 i = 0;
2418    OMX_BUFFERHEADERTYPE *pTemp = NULL;
2419    OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)pComponent;
2420    G726DEC_COMPONENT_PRIVATE *pComponentPrivate =
2421        (G726DEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
2422    G726D_LCML_BUFHEADERTYPE *pTemp_lcml = NULL;
2423    OMX_U32 size_lcml = 0;
2424    OMX_U8 *ptr = NULL;
2425
2426
2427    G726DEC_DPRINT(":: Entered Fill_LCMLInitParams");
2428
2429
2430    nIpBuf = pComponentPrivate->pInputBufferList->numBuffers;
2431    nOpBuf = pComponentPrivate->pPortDef[G726D_OUTPUT_PORT]->nBufferCountActual;                   /* pComponentPrivate->pOutputBufferList->numBuffers; */
2432    nIpBufSize = pComponentPrivate->pPortDef[G726D_INPUT_PORT]->nBufferSize;
2433    nOpBufSize = pComponentPrivate->pPortDef[G726D_OUTPUT_PORT]->nBufferSize;
2434
2435
2436    G726DEC_BUFPRINT("Input Buffer Count = %ld\n",nIpBuf);
2437    G726DEC_BUFPRINT("Input Buffer Size = %ld\n",nIpBufSize);
2438    G726DEC_BUFPRINT("Output Buffer Count = %ld\n",nOpBuf);
2439    G726DEC_BUFPRINT("Output Buffer Size = %ld\n",nOpBufSize);
2440
2441
2442
2443    G726DEC_DPRINT(":: bufAlloced = %d\n",pComponentPrivate->bufAlloced);
2444    size_lcml = nIpBuf * sizeof(G726D_LCML_BUFHEADERTYPE);
2445
2446    G726D_OMX_MALLOC_SIZE(ptr,size_lcml,OMX_U8);
2447    pTemp_lcml = (G726D_LCML_BUFHEADERTYPE *)ptr;
2448
2449    pComponentPrivate->pLcmlBufHeader[G726D_INPUT_PORT] = pTemp_lcml;
2450
2451    for (i=0; i<nIpBuf; i++) {
2452        if(pComponentPrivate->bufAlloced == 0) {
2453            G726D_OMX_MALLOC(pTemp, OMX_BUFFERHEADERTYPE);
2454        } else {
2455            G726DEC_DPRINT(":: IpBufferHeader %p is already there\n",
2456                           pComponentPrivate->pInputBufferList->pBufHdr[i]);
2457            pTemp = pComponentPrivate->pInputBufferList->pBufHdr[i];
2458        }
2459
2460        pTemp->nSize = sizeof(OMX_BUFFERHEADERTYPE);
2461
2462        pTemp->nAllocLen = nIpBufSize;
2463        pTemp->nFilledLen = nIpBufSize;
2464        pTemp->nVersion.s.nVersionMajor = G726DEC_MAJOR_VER;
2465        pTemp->nVersion.s.nVersionMinor = G726DEC_MINOR_VER;
2466
2467        pTemp->pPlatformPrivate = pHandle->pComponentPrivate;
2468        pTemp->nTickCount = DONT_CARE;
2469
2470        if (pComponentPrivate->bufAlloced == 0) {
2471            G726D_OMX_MALLOC_SIZE(pTemp->pBuffer,(nIpBufSize+256),OMX_U8);
2472            pTemp->pBuffer = pTemp->pBuffer + 128;
2473        } else {
2474            G726DEC_DPRINT(":: IpBuffer %p is already there\n",pTemp->pBuffer);
2475        }
2476
2477        if (pTemp->pBuffer == NULL) {
2478            G726DEC_EPRINT(":: Malloc Failed...\n");
2479            goto EXIT;
2480        }
2481
2482        pTemp_lcml->pBufHdr = pTemp;
2483        pTemp_lcml->eDir = OMX_DirInput;
2484        pTemp_lcml->pOtherParams[i] = NULL;
2485
2486        G726D_OMX_MALLOC(pTemp_lcml->pFrameParam, G726DEC_UAlgInBufParamStruct);
2487        pTemp_lcml->pFrameParam->bLastBuffer = 0;
2488
2489        pTemp->nFlags = NORMAL_BUFFER;
2490        ((G726DEC_COMPONENT_PRIVATE *) pTemp->pPlatformPrivate)->pHandle = pHandle;
2491
2492        G726DEC_DPRINT("::Comp: InBuffHeader[%ld] = %p\n", i, pTemp);
2493        G726DEC_DPRINT("::Comp:  >>>> InputBuffHeader[%ld]->pBuffer = %p\n", i, pTemp->pBuffer);
2494        G726DEC_DPRINT("::Comp: Ip : pTemp_lcml[%ld] = %p\n", i, pTemp_lcml);
2495
2496        pTemp_lcml++;
2497    }
2498
2499    size_lcml = nOpBuf * sizeof(G726D_LCML_BUFHEADERTYPE);
2500
2501    G726D_OMX_MALLOC_SIZE(pTemp_lcml,size_lcml,G726D_LCML_BUFHEADERTYPE);
2502    pComponentPrivate->pLcmlBufHeader[G726D_OUTPUT_PORT] = pTemp_lcml;
2503
2504    for (i=0; i<nOpBuf; i++) {
2505        if(pComponentPrivate->bufAlloced == 0) {
2506            G726D_OMX_MALLOC(pTemp, OMX_BUFFERHEADERTYPE);
2507        } else {
2508            G726DEC_DPRINT(":: OpBufferHeader %p is already there\n",
2509                           pComponentPrivate->pOutputBufferList->pBufHdr[i]);
2510            pTemp = pComponentPrivate->pOutputBufferList->pBufHdr[i];
2511        }
2512
2513        pTemp->nSize = sizeof(OMX_BUFFERHEADERTYPE);
2514
2515        pTemp->nAllocLen = nOpBufSize;
2516        pTemp->nFilledLen = nOpBufSize;
2517        pTemp->nVersion.s.nVersionMajor = G726DEC_MAJOR_VER;
2518        pTemp->nVersion.s.nVersionMinor = G726DEC_MINOR_VER;
2519
2520        pTemp->pPlatformPrivate = pHandle->pComponentPrivate;
2521        pTemp->nTickCount = DONT_CARE;
2522
2523        if (pComponentPrivate->bufAlloced == 0) {
2524            G726D_OMX_MALLOC_SIZE(pTemp->pBuffer,(nOpBufSize+256),OMX_U8);
2525            pTemp->pBuffer += 128;
2526            G726DEC_DPRINT("%d:: OpBuffer %p is already there\n",__LINE__,pTemp->pBuffer);
2527        } else {
2528            G726DEC_DPRINT(":: OpBuffer %p is already there\n",pTemp->pBuffer);
2529        }
2530
2531        pTemp_lcml->pBufHdr = pTemp;
2532        pTemp_lcml->eDir = OMX_DirOutput;
2533        pTemp_lcml->pOtherParams[i] = NULL;
2534
2535
2536        pTemp->nFlags = NORMAL_BUFFER;
2537        ((G726DEC_COMPONENT_PRIVATE *)pTemp->pPlatformPrivate)->pHandle = pHandle;
2538        G726DEC_DPRINT("::Comp:  >>>>>>>>>>>>> OutBuffHeader[%ld] = %p\n", i, pTemp);
2539        G726DEC_DPRINT("::Comp:  >>>> OutBuffHeader[%ld]->pBuffer = %p\n", i, pTemp->pBuffer);
2540        G726DEC_DPRINT("::Comp: Op : pTemp_lcml[%ld] = %p\n", i, pTemp_lcml);
2541        pTemp_lcml++;
2542    }
2543    pComponentPrivate->bPortDefsAllocated = 1;
2544
2545    G726DEC_DPRINT(":: Exiting Fill_LCMLInitParams");
2546
2547    pComponentPrivate->bInitParamsInitialized = 1;
2548
2549 EXIT:
2550    return eError;
2551}
2552
2553#ifdef RESOURCE_MANAGER_ENABLED
2554/***********************************
2555 *  Callback to the RM                                       *
2556 ***********************************/
2557void G726DEC_ResourceManagerCallback(RMPROXY_COMMANDDATATYPE cbData)
2558{
2559    OMX_COMMANDTYPE Cmd = OMX_CommandStateSet;
2560    OMX_STATETYPE state = OMX_StateIdle;
2561    OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)cbData.hComponent;
2562    G726DEC_COMPONENT_PRIVATE *pCompPrivate = NULL;
2563
2564    pCompPrivate = (G726DEC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
2565
2566    if (*(cbData.RM_Error) == OMX_RmProxyCallback_ResourcesPreempted){
2567        if (pCompPrivate->curState == OMX_StateExecuting ||
2568            pCompPrivate->curState == OMX_StatePause) {
2569
2570            write (pCompPrivate->cmdPipe[1], &Cmd, sizeof(Cmd));
2571            write (pCompPrivate->cmdDataPipe[1], &state ,sizeof(OMX_U32));
2572
2573            pCompPrivate->bPreempted = 1;
2574        }
2575    }
2576    else if (*(cbData.RM_Error) == OMX_RmProxyCallback_ResourcesAcquired){
2577        pCompPrivate->cbInfo.EventHandler ( pHandle,
2578                                            pHandle->pApplicationPrivate,
2579                                            OMX_EventResourcesAcquired,
2580                                            0, 0, NULL);
2581    }
2582}
2583#endif
2584