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_JpegEnc_Utils.c
30*
31* This file implements OMX Component for JPEG encoder that
32* is fully compliant with the OMX specification 1.5.
33*
34* @path  $(CSLPATH)\src
35*
36* @rev  0.1
37*/
38/* -------------------------------------------------------------------------------- */
39/* ================================================================================
40*!
41*! Revision History
42*! ===================================
43*!
44*! 22-May-2006 mf: Revisions appear in reverse chronological order;
45*! that is, newest first.  The date format is dd-Mon-yyyy.
46* ================================================================================= */
47
48/****************************************************************
49*  INCLUDE FILES
50****************************************************************/
51
52/* ----- System and Platform Files ----------------------------*/
53
54#ifdef UNDER_CE
55#include <windows.h>
56#include <oaf_osal.h>
57#include <omx_core.h>
58#else
59#include <unistd.h>
60#include <sys/types.h>
61#include <malloc.h>
62#include <memory.h>
63#include <sys/time.h>
64#include <sys/types.h>
65#include <sys/stat.h>
66#endif
67
68#include <dbapi.h>
69#include <string.h>
70#include <stdio.h>
71#include <stdlib.h>
72#include <fcntl.h>
73
74
75#include <OMX_Types.h>
76#include <OMX_Component.h>
77#include <OMX_Core.h>
78#include <OMX_Index.h>
79#include <OMX_Image.h>
80#include <OMX_Audio.h>
81#include <OMX_Video.h>
82#include <OMX_IVCommon.h>
83#include <OMX_Other.h>
84
85#include <usn.h>
86
87/*------- Program Header Files ----------------------------------------*/
88
89#include "OMX_JpegEnc_Utils.h"
90#include "OMX_JpegEnc_CustomCmd.h"
91
92#ifdef RESOURCE_MANAGER_ENABLED
93    #include <ResourceManagerProxyAPI.h>
94#endif
95
96#define JPEGENC_TIMEOUT 0xFFFFFFFE
97
98static OMX_ERRORTYPE HandleJpegEncInternalFlush(JPEGENC_COMPONENT_PRIVATE *pComponentPrivate, OMX_U32 nParam1);
99
100#ifdef RESOURCE_MANAGER_ENABLED
101void ResourceManagerCallback(RMPROXY_COMMANDDATATYPE cbData);
102#endif
103
104#ifdef UNDER_CE
105void sleep(DWORD Duration)
106{
107    Sleep(Duration);
108}
109#endif
110
111/*--------function prototypes ---------------------------------*/
112OMX_ERRORTYPE JpegEncLCML_Callback (TUsnCodecEvent event,
113                                    void * args [10]);
114
115/*-------- Function Implementations ---------------------------------*/
116OMX_ERRORTYPE GetJpegEncLCMLHandle(OMX_HANDLETYPE pComponent)
117{
118    OMX_ERRORTYPE eError = OMX_ErrorNone;
119#ifndef UNDER_CE
120    OMX_HANDLETYPE LCML_pHandle;
121
122    OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)pComponent;
123    JPEGENC_COMPONENT_PRIVATE *pComponentPrivate = (JPEGENC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
124    fpo fpGetHandle ;
125    void *handle = NULL;
126    char *error =NULL;
127
128    OMX_PRDSP1(pComponentPrivate->dbg, "Inside GetLCMLHandle function\n");
129
130    handle = dlopen("libLCML.so", RTLD_LAZY);
131    if ( !handle ) {
132        if ( (error = (char *)dlerror()) != NULL ) {
133            fputs(error, stderr);
134        }
135        eError = OMX_ErrorComponentNotFound;
136        goto EXIT;
137    }
138
139    fpGetHandle = dlsym (handle, "GetHandle");
140    if ( (error = (char *)dlerror()) != NULL ) {
141        fputs(error, stderr);
142        eError = OMX_ErrorInvalidComponent;
143        goto EXIT;
144    }
145
146    /*  calling gethandle and passing phandle to b filled   */
147    if ( fpGetHandle != NULL ) {
148        eError = (*fpGetHandle)(&LCML_pHandle);
149    }
150    else  {
151        eError = OMX_ErrorInvalidComponent;
152        goto EXIT;
153    }
154
155    if ( eError != OMX_ErrorNone ) {
156        eError = OMX_ErrorUndefined;
157        OMX_PRDSP4(pComponentPrivate->dbg, "eError != OMX_ErrorNone...\n");
158        goto EXIT;
159    }
160
161    OMX_PRDSP2(pComponentPrivate->dbg, "Received LCML Handle\n");
162
163    pComponentPrivate->pDllHandle = handle;
164    pComponentPrivate->pLCML = (void *)LCML_pHandle;
165    pComponentPrivate->pLCML->pComponentPrivate = (JPEGENC_COMPONENT_PRIVATE *)pComponentPrivate;
166#else
167    typedef OMX_ERRORTYPE (*LPFNDLLFUNC1)(OMX_HANDLETYPE);
168    LPFNDLLFUNC1 fpGetHandle1;
169    OMX_HANDLETYPE LCML_pHandle = NULL;
170    OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)pComponent;
171    JPEGENC_COMPONENT_PRIVATE *pComponentPrivate = (JPEGENC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
172    HINSTANCE hDLL;
173
174    hDLL = LoadLibraryEx(TEXT("OAF_BML.dll"), NULL, 0);
175    if (hDLL == NULL)
176    {
177        eError = OMX_ErrorComponentNotFound;
178        goto EXIT;
179    }
180
181    fpGetHandle1 = (LPFNDLLFUNC1)GetProcAddress(hDLL,TEXT("GetHandle"));
182    if (!fpGetHandle1)
183    {
184
185        FreeLibrary(hDLL);
186        eError = OMX_ErrorComponentNotFound;
187        goto EXIT;
188    }
189
190
191    eError = fpGetHandle1(&LCML_pHandle);
192    if(eError != OMX_ErrorNone) {
193
194        eError = OMX_ErrorUndefined;
195        LCML_pHandle = NULL;
196          goto EXIT;
197    }
198
199    (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML = (LCML_DSP_INTERFACE *)LCML_pHandle;
200    pComponentPrivate->pLCML->pComponentPrivate = (JPEGENC_COMPONENT_PRIVATE *)pComponentPrivate;
201
202#endif
203    OMX_PRINT1(pComponentPrivate->dbg, "Exit\n");
204    EXIT:
205    return eError;
206}
207
208
209/*-----------------------------------------------------------------------------*/
210/**
211  * Disable Port()
212  *
213  * Called by component thread, handles commands sent by the app.
214  *
215  * @param
216  *
217  * @retval OMX_ErrorNone                  success, ready to roll
218  *
219  **/
220/*-----------------------------------------------------------------------------*/
221OMX_ERRORTYPE JpegEncDisablePort (JPEGENC_COMPONENT_PRIVATE* pComponentPrivate, OMX_U32 nParam1)
222{
223    OMX_ERRORTYPE eError = OMX_ErrorNone;
224    OMX_CHECK_PARAM(pComponentPrivate);
225
226    OMX_PRINT1(pComponentPrivate->dbg, "Inside DisablePort function\n");
227
228    OMX_PRBUFFER1(pComponentPrivate->dbg, "Inside disable port (%lu) %lu %lu %lu %lu\n",
229            nParam1,
230            pComponentPrivate->nInPortIn,
231            pComponentPrivate->nInPortOut,
232            pComponentPrivate->nOutPortIn,
233            pComponentPrivate->nOutPortOut);
234
235   if (pComponentPrivate->nCurState == OMX_StateExecuting || pComponentPrivate->nCurState == OMX_StatePause) {
236	if ((nParam1 == JPEGENC_INP_PORT) || (nParam1 == JPEGENC_OUT_PORT) || ((int)nParam1 == -1)) {
237           eError = HandleJpegEncInternalFlush(pComponentPrivate, nParam1);
238       }
239   }
240
241    OMX_PRINT1(pComponentPrivate->dbg, "Exit form JPEGEnc Disable Port eError is = %x\n",eError);
242EXIT:
243    return eError;
244}
245
246
247
248/*-----------------------------------------------------------------------------*/
249/**
250  * Enable Port()
251  *
252  * Called by component thread, handles commands sent by the app.
253  *
254  * @param
255  *
256  * @retval OMX_ErrorNone                  success, ready to roll
257  *
258  **/
259/*-----------------------------------------------------------------------------*/
260
261OMX_ERRORTYPE JpegEncEnablePort (JPEGENC_COMPONENT_PRIVATE* pComponentPrivate, OMX_U32 nParam1)
262{
263    OMX_ERRORTYPE eError = OMX_ErrorNone;
264    OMX_CHECK_PARAM(pComponentPrivate);
265
266    OMX_PRINT1(pComponentPrivate->dbg, "Inside EnablePort function\n");
267
268
269    if (nParam1 == 0) {
270        if (pComponentPrivate->nCurState != OMX_StateLoaded) {
271        pthread_mutex_lock(&pComponentPrivate->jpege_mutex_app);
272        while (!pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->bPopulated) {
273            OMX_PRBUFFER0(pComponentPrivate->dbg, "%d in cond wait\n", __LINE__);
274            pthread_cond_wait(&pComponentPrivate->populate_cond, &pComponentPrivate->jpege_mutex_app);
275        }
276        }
277        pthread_mutex_unlock(&pComponentPrivate->jpege_mutex_app);
278        pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
279                                                pComponentPrivate->pHandle->pApplicationPrivate,
280                                                OMX_EventCmdComplete,
281                                                OMX_CommandPortEnable,
282                                                JPEGENC_INP_PORT,
283                                                NULL);
284    } else if (nParam1 == 1) {
285        if (pComponentPrivate->nCurState != OMX_StateLoaded) {
286        pthread_mutex_lock(&pComponentPrivate->jpege_mutex_app);
287        while (!pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef->bPopulated) {
288            OMX_PRBUFFER0(pComponentPrivate->dbg, "%d in cond wait\n", __LINE__);
289            pthread_cond_wait(&pComponentPrivate->populate_cond, &pComponentPrivate->jpege_mutex_app);
290        }
291        }
292        pthread_mutex_unlock(&pComponentPrivate->jpege_mutex_app);
293        pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
294                                                pComponentPrivate->pHandle->pApplicationPrivate,
295                                                OMX_EventCmdComplete,
296                                                OMX_CommandPortEnable,
297                                                JPEGENC_OUT_PORT,
298                                                NULL);
299    } else if ((int)nParam1 == -1) {
300        if (pComponentPrivate->nCurState != OMX_StateLoaded) {
301        pthread_mutex_lock(&pComponentPrivate->jpege_mutex_app);
302        while ((!pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->bPopulated) ||
303               (!pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef->bPopulated)) {
304            OMX_PRBUFFER0(pComponentPrivate->dbg, "%d in cond wait\n", __LINE__);
305            pthread_cond_wait(&pComponentPrivate->populate_cond, &pComponentPrivate->jpege_mutex_app);
306        }
307        pthread_mutex_unlock(&pComponentPrivate->jpege_mutex_app);
308        }
309        pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
310                                                pComponentPrivate->pHandle->pApplicationPrivate,
311                                                OMX_EventCmdComplete,
312                                                OMX_CommandPortEnable,
313                                                JPEGENC_INP_PORT,
314                                                NULL);
315
316        pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
317                                                pComponentPrivate->pHandle->pApplicationPrivate,
318                                                OMX_EventCmdComplete,
319                                                OMX_CommandPortEnable,
320                                                JPEGENC_OUT_PORT,
321                                                NULL);
322    }
323EXIT:
324    return eError;
325}
326
327
328
329/*-------------------------------------------------------------------*/
330/**
331  *  JPEGEnc_Start_ComponentThread() Starts Component Thread
332  *
333  *  Creates data pipes, commmand pipes and initializes Component thread
334  *
335  * @param pComponent    handle for this instance of the component
336  *
337  * @retval OMX_NoError              Success, ready to roll
338  * @retval OMX_ErrorInsufficientResources    Insiffucient Resources
339  *
340  **/
341/*-------------------------------------------------------------------*/
342OMX_ERRORTYPE JPEGEnc_Start_ComponentThread(OMX_HANDLETYPE pComponent)
343{
344    OMX_ERRORTYPE eError = OMX_ErrorNone;
345    OMX_COMPONENTTYPE *pHandle = NULL;
346    JPEGENC_COMPONENT_PRIVATE *pComponentPrivate = NULL;
347
348
349    OMX_CHECK_PARAM(pComponent);
350    pHandle = (OMX_COMPONENTTYPE *)pComponent;
351    pComponentPrivate = (JPEGENC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
352    OMX_PRINT1(pComponentPrivate->dbg, "Inside JPEGEnc_Start_ComponentThread function\n");
353
354    /* create the pipe used to maintain free output buffers*/
355    eError = pipe (pComponentPrivate->free_outBuf_Q);
356    if ( eError ) {
357        eError = OMX_ErrorInsufficientResources;
358        goto EXIT;
359    }
360
361    /* create the pipe used to maintain filled input buffers*/
362    eError = pipe (pComponentPrivate->filled_inpBuf_Q);
363    if ( eError ) {
364        eError = OMX_ErrorInsufficientResources;
365        goto EXIT;
366    }
367
368    /* create the pipe used to send commands to the thread */
369    eError = pipe (pComponentPrivate->nCmdPipe);
370    if ( eError ) {
371        eError = OMX_ErrorInsufficientResources;
372        goto EXIT;
373    }
374
375    /* create the pipe used to send commands to the thread */
376    eError = pipe (pComponentPrivate->nCmdDataPipe);
377    if ( eError ) {
378        eError = OMX_ErrorInsufficientResources;
379        goto EXIT;
380    }
381
382    /*  No buffers have been sent to dsp    */
383    pComponentPrivate->nNum_dspBuf = 0;
384
385    /* Create the Component Thread */
386    eError = pthread_create (&(pComponentPrivate->ComponentThread), NULL,
387                             OMX_JpegEnc_Thread, pComponent);
388
389
390    if ( eError || !pComponentPrivate->ComponentThread ) {
391        eError = OMX_ErrorInsufficientResources;
392        goto EXIT;
393    }
394
395#ifdef __PERF_INSTRUMENTATION__
396        PERF_ThreadCreated(pComponentPrivate->pPERF,
397                           pComponentPrivate->ComponentThread,
398                           PERF_FOURCC('J','P','E','T'));
399
400#endif
401
402    EXIT:
403    return eError;
404}
405
406
407
408/* -------------------------------------------------------------------------- */
409/**
410* @JPEGEnc_Free_ComponentResources() This function is called by the component during
411* de-init to close component thread, Command pipe, data pipe & LCML pipe.
412*
413* @param pComponent  handle for this instance of the component
414*
415* @pre
416*
417* @post
418*
419* @return none
420*/
421/* -------------------------------------------------------------------------- */
422OMX_ERRORTYPE JPEGEnc_Free_ComponentResources(JPEGENC_COMPONENT_PRIVATE *pComponentPrivate)
423{
424    OMX_ERRORTYPE eError = OMX_ErrorNone;
425    OMX_ERRORTYPE threadError = OMX_ErrorNone;
426    OMX_ERRORTYPE err = OMX_ErrorNone;
427    int pipeError = 0;
428    int pthreadError = 0;
429    OMX_COMMANDTYPE eCmd = OMX_CustomCommandStopThread;
430    OMX_U32 nParam = 0;
431    struct OMX_TI_Debug dbg;
432
433    OMX_DBG_INIT_BASE(dbg);
434    OMX_CHECK_PARAM(pComponentPrivate);
435
436#ifdef __PERF_INSTRUMENTATION__
437        PERF_Boundary(pComponentPrivate->pPERF,
438                      PERF_BoundaryStart | PERF_BoundaryCleanup);
439#endif
440
441    if ( pComponentPrivate->pLCML != NULL && pComponentPrivate->isLCMLActive) {
442    	LCML_ControlCodec(((LCML_DSP_INTERFACE*)pComponentPrivate->pLCML)->pCodecinterfacehandle,EMMCodecControlDestroy,NULL);
443    	dlclose(pComponentPrivate->pDllHandle);
444    	pComponentPrivate->pLCML = NULL;
445    	pComponentPrivate->isLCMLActive = 0;
446    }
447
448    pipeError = write(pComponentPrivate->nCmdPipe[1], &eCmd, sizeof(eCmd));
449    if (pipeError == -1) {
450        eError = OMX_ErrorHardware;
451        OMX_PRCOMM4(dbg, "Error while writing to nCmdPipe\n");
452    }
453
454    pipeError = write(pComponentPrivate->nCmdDataPipe[1], &nParam, sizeof(nParam));
455    if (pipeError == -1) {
456        eError = OMX_ErrorHardware;
457        OMX_PRCOMM4(dbg, "Error while writing to nCmdPipe\n");
458    }
459
460    pthreadError = pthread_join (pComponentPrivate->ComponentThread,
461                                 (void*)&threadError);
462    if ( 0 != pthreadError ) {
463        eError = OMX_ErrorHardware;
464        OMX_TRACE4(dbg, "Error while closing Component Thread\n");
465    }
466
467    if ( OMX_ErrorNone != threadError && OMX_ErrorNone != eError ) {
468        eError = OMX_ErrorInsufficientResources;
469        OMX_TRACE4(dbg, "Error while closing Component Thread\n");
470    }
471
472    /*  close the data pipe handles */
473
474    err = close (pComponentPrivate->free_outBuf_Q[0]);
475    if ( 0 != err && OMX_ErrorNone == eError ) {
476        eError = OMX_ErrorHardware;
477        OMX_PRCOMM4(dbg, "Error while closing data pipe\n");
478    }
479
480    err = close (pComponentPrivate->filled_inpBuf_Q[0]);
481    if ( 0 != err && OMX_ErrorNone == eError ) {
482        eError = OMX_ErrorHardware;
483        OMX_PRCOMM4(dbg, "Error while closing data pipe\n");
484    }
485
486    err = close (pComponentPrivate->free_outBuf_Q[1]);
487    if ( 0 != err && OMX_ErrorNone == eError ) {
488        eError = OMX_ErrorHardware;
489        OMX_PRCOMM4(dbg, "Error while closing data pipe\n");
490    }
491
492    err = close (pComponentPrivate->filled_inpBuf_Q[1]);
493    if ( 0 != err && OMX_ErrorNone == eError ) {
494        eError = OMX_ErrorHardware;
495        OMX_PRCOMM4(dbg, "Error while closing data pipe\n");
496    }
497
498    /*  close the command pipe handles  */
499    err = close (pComponentPrivate->nCmdPipe[0]);
500    if ( 0 != err && OMX_ErrorNone == eError ) {
501        eError = OMX_ErrorHardware;
502        OMX_PRCOMM4(dbg, "Error while closing cmd pipe\n");
503    }
504
505    err = close (pComponentPrivate->nCmdPipe[1]);
506    if ( 0 != err && OMX_ErrorNone == eError ) {
507        eError = OMX_ErrorHardware;
508        OMX_PRCOMM4(dbg, "Error while closing cmd pipe\n");
509    }
510
511    /*  close the command data pipe handles */
512    err = close (pComponentPrivate->nCmdDataPipe[0]);
513    if ( 0 != err && OMX_ErrorNone == eError ) {
514        eError = OMX_ErrorHardware;
515        OMX_PRCOMM4(dbg, "Error while closing cmd pipe\n");
516    }
517
518    err = close (pComponentPrivate->nCmdDataPipe[1]);
519    if ( 0 != err && OMX_ErrorNone == eError ) {
520        eError = OMX_ErrorHardware;
521        OMX_PRCOMM4(dbg, "Error while closing cmd pipe\n");
522    }
523
524    pthread_mutex_destroy(&pComponentPrivate->jpege_mutex);
525    pthread_cond_destroy(&pComponentPrivate->stop_cond);
526    pthread_cond_destroy(&pComponentPrivate->flush_cond);
527    /* pthread_cond_destroy(&pComponentPrivate->control_cond); */
528
529    pthread_mutex_destroy(&pComponentPrivate->jpege_mutex_app);
530    pthread_cond_destroy(&pComponentPrivate->populate_cond);
531    pthread_cond_destroy(&pComponentPrivate->unpopulate_cond);
532#ifdef __PERF_INSTRUMENTATION__
533    PERF_Boundary(pComponentPrivate->pPERF,
534    		PERF_BoundaryComplete | PERF_BoundaryCleanup);
535    PERF_Done(pComponentPrivate->pPERF);
536#endif
537
538    /* LinkedList_DisplayAll (&AllocList); */
539    OMX_FREEALL();
540    LinkedList_Destroy(&AllocList);
541
542EXIT:
543    OMX_PRINT1(dbg, "Exiting JPEG FreeComponentresources\n");
544    return eError;
545}
546
547OMX_ERRORTYPE Fill_JpegEncLCMLInitParams(LCML_DSP *lcml_dsp, OMX_U16 arr[], OMX_HANDLETYPE pComponent)
548{
549    OMX_ERRORTYPE eError = OMX_ErrorNone;
550    OMX_COMPONENTTYPE *pHandle = NULL;
551    JPEGENC_COMPONENT_PRIVATE *pComponentPrivate = NULL;
552    OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = NULL;
553    OMX_PARAM_PORTDEFINITIONTYPE* pPortDefIn = NULL;
554    int outbufsize = 0;
555
556    OMX_U16 *ptCreateString = (OMX_U16*)arr;
557    OMX_U32 *ptCreateStringPPLIB = (OMX_U32*)arr;
558
559    OMX_CHECK_PARAM(pComponent);
560    pHandle = (OMX_COMPONENTTYPE *)pComponent;
561    pComponentPrivate = (JPEGENC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
562    OMX_PRINT1(pComponentPrivate->dbg, "Initialize Params\n");
563    pPortDefIn = pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef;
564    pPortDefOut = pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef;
565    outbufsize = pPortDefOut->nBufferSize;
566
567    lcml_dsp->In_BufInfo.nBuffers = NUM_OF_BUFFERSJPEG;
568    lcml_dsp->In_BufInfo.nSize = pPortDefIn->nBufferSize;
569    lcml_dsp->In_BufInfo.DataTrMethod = DMM_METHOD;
570
571    lcml_dsp->Out_BufInfo.nBuffers = NUM_OF_BUFFERSJPEG;
572    lcml_dsp->Out_BufInfo.nSize = outbufsize;
573    lcml_dsp->Out_BufInfo.DataTrMethod = DMM_METHOD;
574
575    lcml_dsp->NodeInfo.nNumOfDLLs = OMX_JPEGENC_NUM_DLLS;
576    lcml_dsp->NodeInfo.AllUUIDs[0].uuid = (struct DSP_UUID * )&JPEGESOCKET_TI_UUID;
577    strcpy ((char *)lcml_dsp->NodeInfo.AllUUIDs[0].DllName,JPEG_ENC_NODE_DLL);
578    lcml_dsp->NodeInfo.AllUUIDs[0].eDllType = DLL_NODEOBJECT;
579
580    lcml_dsp->NodeInfo.AllUUIDs[1].uuid = (struct DSP_UUID * )&JPEGESOCKET_TI_UUID;
581    strcpy ((char *)lcml_dsp->NodeInfo.AllUUIDs[1].DllName,JPEG_ENC_NODE_DLL);
582    lcml_dsp->NodeInfo.AllUUIDs[1].eDllType = DLL_DEPENDENT;
583
584    lcml_dsp->NodeInfo.AllUUIDs[2].uuid =(struct DSP_UUID * ) &USN_UUID;
585    strcpy ((char *)lcml_dsp->NodeInfo.AllUUIDs[2].DllName,USN_DLL);
586    lcml_dsp->NodeInfo.AllUUIDs[2].eDllType = DLL_DEPENDENT;
587
588    lcml_dsp->NodeInfo.AllUUIDs[3].uuid =(struct DSP_UUID * ) &CONVERSIONS_UUID;
589    strcpy ((char *)lcml_dsp->NodeInfo.AllUUIDs[3].DllName,CONVERSIONS_DLL);
590    lcml_dsp->NodeInfo.AllUUIDs[3].eDllType = DLL_DEPENDENT;
591
592#ifdef __JPEG_OMX_PPLIB_ENABLED__
593    lcml_dsp->NodeInfo.AllUUIDs[4].uuid =(struct DSP_UUID * ) &PPLIB_UUID;
594    strcpy ((char *)lcml_dsp->NodeInfo.AllUUIDs[4].DllName,PPLIB_DLL);
595    lcml_dsp->NodeInfo.AllUUIDs[4].eDllType = DLL_DEPENDENT;
596#endif
597    lcml_dsp->SegID = 0;
598    lcml_dsp->Timeout = -1;
599    lcml_dsp->Alignment = 0;
600    lcml_dsp->Priority = 5;
601
602#ifdef __JPEG_OMX_PPLIB_ENABLED__
603      if ((pPortDefIn->format.image.nFrameHeight * pPortDefIn->format.image.nFrameWidth) <= (352*288)) {
604          lcml_dsp->ProfileID = 2 ;
605      }
606      else if ((pPortDefIn->format.image.nFrameHeight * pPortDefIn->format.image.nFrameWidth) <= (640*480)) {
607          lcml_dsp->ProfileID = 2 +1 ; // temporary fix meanwhile SN confirms is there's any problem with VGA profile ID
608      }
609      else if ((pPortDefIn->format.image.nFrameHeight * pPortDefIn->format.image.nFrameWidth) <= (720*576)) {
610          lcml_dsp->ProfileID = 3 ;
611      }
612      else if ((pPortDefIn->format.image.nFrameHeight * pPortDefIn->format.image.nFrameWidth) <= (1*1024*1024)) {
613          lcml_dsp->ProfileID = 4 ;
614      }
615      else if ((pPortDefIn->format.image.nFrameHeight * pPortDefIn->format.image.nFrameWidth) <= (2*1024*1024)) {
616          lcml_dsp->ProfileID = 5 ;
617      }
618      else if ((pPortDefIn->format.image.nFrameHeight * pPortDefIn->format.image.nFrameWidth) <= (3*1024*1024)) {
619          lcml_dsp->ProfileID = 6 ;
620      }
621      else if ((pPortDefIn->format.image.nFrameHeight * pPortDefIn->format.image.nFrameWidth) <= (4*1024*1024)) {
622          lcml_dsp->ProfileID = 7 ;
623      }
624      else if ((pPortDefIn->format.image.nFrameHeight * pPortDefIn->format.image.nFrameWidth) <= (5*1024*1024)) {
625          lcml_dsp->ProfileID = 8 ;
626      }
627      else if ((pPortDefIn->format.image.nFrameHeight * pPortDefIn->format.image.nFrameWidth) <= (6*1024*1024)) {
628          lcml_dsp->ProfileID = 9 ;
629      }
630      else {
631          lcml_dsp->ProfileID = 10;
632      }
633#else
634    /* according to JPEG Enc SN Interface guide */
635    /* if PPLib is not enabled than  use profile 1 by default */
636    lcml_dsp->ProfileID = 2;
637#endif
638
639    /* CrPhArgs for JpegEnc */
640    ptCreateString[0] = JPGENC_SNTEST_STRMCNT;
641    ptCreateString[1] = JPGENC_SNTEST_INSTRMID; /* Stream ID   */
642    ptCreateString[2] = 0;                      /* Stream based input stream   */
643    ptCreateString[3] = JPGENC_SNTEST_INBUFCNT; /* Number of buffers on input stream   */
644    ptCreateString[4] = JPGENC_SNTEST_OUTSTRMID;/* Stream ID   */
645    ptCreateString[5] = 0;                      /* Stream based input stream   */
646    ptCreateString[6] = JPGENC_SNTEST_OUTBUFCNT;/* Number of buffers on input stream   */
647    ptCreateString[7] = (pPortDefOut->format.image.nFrameWidth > 0) ? pPortDefOut->format.image.nFrameWidth : JPGENC_SNTEST_MAX_WIDTH;
648    ptCreateString[8] = (pPortDefOut->format.image.nFrameHeight > 0) ? pPortDefOut->format.image.nFrameHeight : JPGENC_SNTEST_MAX_HEIGHT;
649
650    /*
651    if ( pPortDefIn->format.image.eColorFormat == OMX_COLOR_FormatYUV420PackedPlanar ) {
652        arr[9] = 1;
653    } else if ( pPortDefIn->format.image.eColorFormat ==  OMX_COLOR_FormatCbYCrY ) {
654        arr[9] = 4;
655    }  else {
656        arr[9] = 4;
657    }
658    */
659    ptCreateString[9] = 1;
660
661    ptCreateString[10] = 512; /* Maximum Horizontal Size of the Thumbnail for App0 marker */
662    ptCreateString[11] = 384; /* Maximum Vertical Size of the Thumbnail for App0 marker */
663    ptCreateString[12] = 512; /* Maximum Horizontal Size of the Thumbnail for App1 marker */
664    ptCreateString[13] = 384; /* Maximum Vertical Size of the Thumbnail for App1 marker */
665    ptCreateString[14] = 512; /* Maximum Horizontal Size of the Thumbnail for App13 marker */
666    ptCreateString[15] = 384; /* Maximum Vertical Size of the Thumbnail for App13 marker */
667    ptCreateString[16] = 0; /* Number of scans is always 0 */
668
669/*
670this option supportsonly up to 3 mega pixels
671	if (pPortDefIn->format.image.eColorFormat == OMX_COLOR_FormatYUV420PackedPlanar)
672    {
673    	ptCreateString[16] = 1;
674    }
675*/
676
677    ptCreateString[17] = 0;
678    if ( pPortDefIn->format.image.eColorFormat == OMX_COLOR_Format32bitARGB8888){
679    	ptCreateString[17] = 1; //Convert flag
680    }
681
682	/*Do an internal conversion from YUV420P to YUV422I and encode so that
683	this JPEG would be viewable using the TI JPEG decoder*/
684	else if (pComponentPrivate->bConvert420pTo422i ){
685		if (pPortDefIn->format.image.eColorFormat == OMX_COLOR_FormatYUV420PackedPlanar ){
686			ptCreateString[17] = 10;
687			if(pComponentPrivate->bPPLibEnable)
688			{
689				/* memory requirement for having both conversion and pplib is much larger */
690				lcml_dsp->ProfileID +=3;
691			}
692		}
693		else{
694			OMX_PRMGR4(pComponentPrivate->dbg, "Error invalid ColorFormat for YUVConvertion\n");
695			eError=-1;
696			goto EXIT;
697		}
698	}
699
700    ptCreateString[18] = 512; /* Maximum Horizontal Size of the Thumbnail for App5 marker */
701    ptCreateString[19] = 384; /* Maximum Vertical Size of the Thumbnail for App5 marker */
702
703#ifdef __JPEG_OMX_PPLIB_ENABLED__
704
705    //size
706    ptCreateStringPPLIB[10] = JPEGENC_PPLIB_CREATEPARAM_SIZE;
707
708    //SlibVersion
709    ptCreateStringPPLIB[11] = 0x00000100;
710
711    //MaxInWidth
712    ptCreateStringPPLIB[12] = pPortDefIn->format.image.nFrameWidth;
713
714    //MaxOutWidth
715    ptCreateStringPPLIB[13] = pPortDefIn->format.image.nFrameWidth;
716    //Input Format => 0:RGB24, 1:RGB16, 2:RGB12, 3:RGB8, 4:RGB4, 5:YUV422ILE, 6:YUV422IBE,
717    //                7:422_IN_UY_WS, 8:422_IN_YU_WS, 9:YUV420P, 10:GRAY8, 11:GRAY4, 12:GRAY2_IN, 13:GRAY1
718    if (pPortDefIn->format.image.eColorFormat ==  OMX_COLOR_FormatCbYCrY
719        ||  pPortDefIn->format.image.eColorFormat == OMX_COLOR_Format32bitARGB8888
720        ||  pPortDefIn->format.image.eColorFormat == OMX_COLOR_FormatYCbYCr
721        ||  ptCreateString[17] == 10)
722    {
723        ptCreateStringPPLIB[14] = 5;
724    }
725    else if (pPortDefIn->format.image.eColorFormat ==  OMX_COLOR_FormatYUV420PackedPlanar)
726    {
727        ptCreateStringPPLIB[14] = 9;
728    }
729    else if (pPortDefIn->format.image.eColorFormat ==  OMX_COLOR_Format16bitRGB565)
730    {
731        ptCreateStringPPLIB[14] = 1;
732    }
733    else{
734        ptCreateStringPPLIB[14] = 9;
735    }
736
737    //YuvOutputFormat
738    // --> 0 = OFF, 1 = YUV420, 2 = YUV422ILE, 3 = YUV422IBE
739    if (pPortDefIn->format.image.eColorFormat ==  OMX_COLOR_FormatYUV420PackedPlanar
740        && ptCreateString[17] != 10)
741    {
742        ptCreateStringPPLIB[15] = 1;
743    }
744    else
745    {
746        ptCreateStringPPLIB[15] = 2;
747    }
748
749    //RGBOuputFormat
750    // --> 0 = OFF, 1 = RGB4, 2 = RGB8, 3 = RGB12, 4 = RGB16, 5 = RGB24, 6 = RGB32,
751    //     7 = GRAY8, 8 = GRAY4, 9 = GRAY2, 10 = GRAY1
752    ptCreateStringPPLIB[16] = 0;
753
754    if(pComponentPrivate->bPPLibEnable)
755    {
756        ptCreateString[34] = END_OF_CR_PHASE_ARGS;
757    }else
758    {
759        ptCreateString[20] = END_OF_CR_PHASE_ARGS;
760    }
761#else
762    ptCreateString[20] = END_OF_CR_PHASE_ARGS;
763#endif
764    lcml_dsp->pCrPhArgs = ptCreateString;
765    EXIT:
766    return eError;
767}
768
769
770static OMX_ERRORTYPE HandleJpegEncInternalFlush(JPEGENC_COMPONENT_PRIVATE *pComponentPrivate, OMX_U32 nParam1)
771{
772    OMX_ERRORTYPE eError = OMX_ErrorNone;
773    OMX_U32 aParam[4];
774    LCML_DSP_INTERFACE *pLcmlHandle = NULL;
775
776    OMX_CHECK_PARAM(pComponentPrivate);
777
778    if ( nParam1 == 0x0 ||
779         (int)nParam1 == -1 ) {
780
781        pComponentPrivate->bFlushComplete = OMX_FALSE;
782        aParam[0] = USN_STRMCMD_FLUSH;
783        aParam[1] = 0;
784        aParam[2] = 0;
785        pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
786        eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,EMMCodecControlStrmCtrl, (void*)aParam);
787        if (eError != OMX_ErrorNone) {
788            goto PRINT_EXIT;
789        }
790
791        pthread_mutex_lock(&pComponentPrivate->jpege_mutex);
792        while (pComponentPrivate->bFlushComplete == OMX_FALSE) {
793            OMX_PRBUFFER0(pComponentPrivate->dbg, "%d in cond wait\n", __LINE__);
794            pthread_cond_wait(&pComponentPrivate->flush_cond, &pComponentPrivate->jpege_mutex);
795        }
796        pthread_mutex_unlock(&pComponentPrivate->jpege_mutex);
797
798        pComponentPrivate->bFlushComplete = OMX_FALSE;
799    }
800    if ( nParam1 == 0x1 ||
801	 (int)nParam1 == -1 ) {
802
803        pComponentPrivate->bFlushComplete = OMX_FALSE;
804        aParam[0] = USN_STRMCMD_FLUSH;
805        aParam[1] = 1;
806        aParam[2] = 0;
807        pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
808        eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,EMMCodecControlStrmCtrl, (void*)aParam);
809        if (eError != OMX_ErrorNone) {
810            goto PRINT_EXIT;
811        }
812
813        pthread_mutex_lock(&pComponentPrivate->jpege_mutex);
814        while (pComponentPrivate->bFlushComplete == OMX_FALSE) {
815            OMX_PRBUFFER0(pComponentPrivate->dbg, "%d in cond wait\n", __LINE__);
816            pthread_cond_wait(&pComponentPrivate->flush_cond, &pComponentPrivate->jpege_mutex);
817        }
818        pthread_mutex_unlock(&pComponentPrivate->jpege_mutex);
819        pComponentPrivate->bFlushComplete = OMX_FALSE;
820
821        pComponentPrivate->bFlushComplete = OMX_FALSE;
822    }
823
824    PRINT_EXIT:
825        OMX_PRINT1(pComponentPrivate->dbg, "Exiting HandleCommand FLush Function JEPG Encoder\n");
826    EXIT:
827    return eError;
828
829}
830
831
832OMX_ERRORTYPE HandleJpegEncCommandFlush(JPEGENC_COMPONENT_PRIVATE *pComponentPrivate, OMX_U32 nParam1)
833{
834    OMX_ERRORTYPE eError = OMX_ErrorNone;
835    OMX_U32 aParam[4];
836    LCML_DSP_INTERFACE *pLcmlHandle = NULL;
837
838    OMX_CHECK_PARAM(pComponentPrivate);
839
840    if ( nParam1 == 0x0 ||
841         (int)nParam1 == -1 ) {
842
843        pComponentPrivate->bFlushComplete = OMX_FALSE;
844
845        aParam[0] = USN_STRMCMD_FLUSH;
846        aParam[1] = 0;
847        aParam[2] = 0;
848        pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
849        eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,EMMCodecControlStrmCtrl, (void*)aParam);
850        if (eError != OMX_ErrorNone) {
851            goto PRINT_EXIT;
852        }
853       OMX_PRDSP2(pComponentPrivate->dbg, "sent EMMCodecControlStrmCtrl command\n");
854
855        pthread_mutex_lock(&pComponentPrivate->jpege_mutex);
856        while (pComponentPrivate->bFlushComplete == OMX_FALSE) {
857            OMX_PRBUFFER0(pComponentPrivate->dbg, "%d in cond wait\n", __LINE__);
858            pthread_cond_wait(&pComponentPrivate->flush_cond, &pComponentPrivate->jpege_mutex);
859        }
860        pthread_mutex_unlock(&pComponentPrivate->jpege_mutex);
861
862        pComponentPrivate->bFlushComplete = OMX_FALSE;
863
864        while (pComponentPrivate->nInPortIn > pComponentPrivate->nInPortOut) {
865
866            OMX_BUFFERHEADERTYPE* pBuffHead = NULL;
867            JPEGENC_BUFFER_PRIVATE* pBuffPrivate = NULL;
868            int ret;
869
870            ret = read(pComponentPrivate->filled_inpBuf_Q[0], &(pBuffHead), sizeof(pBuffHead));
871            if ( ret == -1 ) {
872                OMX_PRCOMM4(pComponentPrivate->dbg, "Error while reading from the pipe\n");
873            }
874
875            if (pBuffHead != NULL) {
876                pBuffPrivate = pBuffHead->pInputPortPrivate;
877            }
878
879            pComponentPrivate->nInPortOut ++;
880            pBuffPrivate->eBufferOwner = JPEGENC_BUFFER_CLIENT;
881            OMX_PRBUFFER1(pComponentPrivate->dbg, "buffer summary (return empty output buffer) %lu %lu %lu %lu\n",
882                    pComponentPrivate->nInPortIn,
883                    pComponentPrivate->nInPortOut,
884                    pComponentPrivate->nOutPortIn,
885                    pComponentPrivate->nOutPortOut);
886            OMX_PRBUFFER1(pComponentPrivate->dbg, "before EmptyBufferDone\n");
887            pComponentPrivate->cbInfo.EmptyBufferDone(
888                           pComponentPrivate->pHandle,
889                           pComponentPrivate->pHandle->pApplicationPrivate,
890                           pBuffHead);
891             OMX_PRBUFFER1(pComponentPrivate->dbg, "after EmptyBufferDone\n");
892        }
893#if 0
894        for ( i=0; i < pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->nBufferCountActual; i++ ) {
895
896#ifdef __PERF_INSTRUMENTATION__
897            PERF_SendingFrame(pComponentPrivate->pPERFcomp,
898                              PREF(pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pBufferPrivate[i]->pBufferHdr,pBuffer),
899                              0,
900                              PERF_ModuleHLMM);
901#endif
902          pBuffPrivate = (JPEGENC_BUFFER_PRIVATE*) pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pBufferPrivate[i]->pBufferHdr->pInputPortPrivate;
903          OMX_PRBUFFER2(pComponentPrivate->dbg, "flush input port. buffer owner (%d) %d\n", i, pBuffPrivate->eBufferOwner);
904        }
905#endif
906
907        OMX_PRBUFFER1(pComponentPrivate->dbg, "buffer summary (flush input) %lu %lu %lu %lu\n",
908                    pComponentPrivate->nInPortIn,
909                    pComponentPrivate->nInPortOut,
910                    pComponentPrivate->nOutPortIn,
911                    pComponentPrivate->nOutPortOut);
912
913        /* returned all input buffers */
914        pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
915                                      pComponentPrivate->pHandle->pApplicationPrivate,
916                      OMX_EventCmdComplete,
917                                      OMX_CommandFlush,
918                                      JPEGENC_INP_PORT,
919                                      NULL);
920
921    }
922    if ( nParam1 == 0x1 ||
923         (int)nParam1 == -1 ) {
924
925        pComponentPrivate->bFlushComplete = OMX_FALSE;
926
927        aParam[0] = USN_STRMCMD_FLUSH;
928        aParam[1] = 1;
929        aParam[2] = 0;
930        pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
931        eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,EMMCodecControlStrmCtrl, (void*)aParam);
932        if (eError != OMX_ErrorNone) {
933            goto PRINT_EXIT;
934        }
935        OMX_PRDSP2(pComponentPrivate->dbg, "(1) sent EMMCodecControlStrmCtrl command\n");
936
937        pthread_mutex_lock(&pComponentPrivate->jpege_mutex);
938        while (pComponentPrivate->bFlushComplete == OMX_FALSE) {
939            OMX_PRBUFFER0(pComponentPrivate->dbg, "%d in cond wait\n", __LINE__);
940            pthread_cond_wait(&pComponentPrivate->flush_cond, &pComponentPrivate->jpege_mutex);
941        }
942        pthread_mutex_unlock(&pComponentPrivate->jpege_mutex);
943        pComponentPrivate->bFlushComplete = OMX_FALSE;
944
945        /* return all output buffers */
946
947#if 0
948        for ( i=0; i < pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef->nBufferCountActual ; i++ ) {
949            OMX_PRBUFFER1(pComponentPrivate->dbg, "BEFORE  FillBufferDone in OMX_CommandFlush\n");
950
951#ifdef __PERF_INSTRUMENTATION__
952                        PERF_SendingFrame(pComponentPrivate->pPERFcomp,
953                                          PREF(pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pBufferPrivate[i]->pBufferHdr,pBuffer),
954                                          PREF(pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pBufferPrivate[i]->pBufferHdr,nFilledLen),
955                                          PERF_ModuleHLMM);
956#endif
957          pBuffPrivate = (JPEGENC_BUFFER_PRIVATE*) pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pBufferPrivate[i]->pBufferHdr->pOutputPortPrivate;
958          OMX_PRBUFFER2(pComponentPrivate->dbg, "flush output port. buffer owner (%d) %d\n", i, pBuffPrivate->eBufferOwner);
959
960          OMX_PRBUFFER1(pComponentPrivate->dbg, "in flush 1: buffer %d owner %d\n", i, pBuffPrivate->eBufferOwner);
961          if (pBuffPrivate->eBufferOwner == JPEGENC_BUFFER_COMPONENT_IN) {
962                  OMX_PRBUFFER1(pComponentPrivate->dbg, "return output buffer %p from free_in_pipe (flush)\n",
963                     pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pBufferPrivate[i]->pBufferHdr);
964                  pComponentPrivate->nOutPortOut ++;
965                  pBuffPrivate->eBufferOwner = JPEGENC_BUFFER_CLIENT;
966                  pComponentPrivate->cbInfo.FillBufferDone (pComponentPrivate->pHandle,
967                                   pComponentPrivate->pHandle->pApplicationPrivate,
968                                   pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pBufferPrivate[i]->pBufferHdr);
969          }
970
971        }
972#endif
973        while (pComponentPrivate->nOutPortIn > pComponentPrivate->nOutPortOut) {
974            OMX_BUFFERHEADERTYPE* pBuffHead = NULL;
975            JPEGENC_BUFFER_PRIVATE* pBuffPrivate = NULL;
976            int ret;
977
978            OMX_PRBUFFER1(pComponentPrivate->dbg, "in while loop %lu %lu )\n", pComponentPrivate->nOutPortIn, pComponentPrivate->nOutPortOut);
979            ret = read(pComponentPrivate->free_outBuf_Q[0], &pBuffHead, sizeof(pBuffHead));
980            if ( ret == -1 ) {
981                OMX_PRCOMM4(pComponentPrivate->dbg, "Error while reading from the pipe\n");
982                goto PRINT_EXIT;
983            }
984            OMX_PRCOMM1(pComponentPrivate->dbg, "after read\n");
985            if (pBuffHead != NULL) {
986               pBuffPrivate = pBuffHead->pOutputPortPrivate;
987            }
988
989            pComponentPrivate->nOutPortOut ++;
990            pBuffPrivate->eBufferOwner = JPEGENC_BUFFER_CLIENT;
991            OMX_PRBUFFER1(pComponentPrivate->dbg, "buffer summary (return empty output buffer) %lu %lu %lu %lu\n",
992                    pComponentPrivate->nInPortIn,
993                    pComponentPrivate->nInPortOut,
994                    pComponentPrivate->nOutPortIn,
995                    pComponentPrivate->nOutPortOut);
996             OMX_PRBUFFER1(pComponentPrivate->dbg, "before FillBufferDone\n");
997             pComponentPrivate->cbInfo.FillBufferDone(pComponentPrivate->pHandle,
998                    pComponentPrivate->pHandle->pApplicationPrivate,
999                    pBuffHead);
1000             OMX_PRBUFFER1(pComponentPrivate->dbg, "after FillBufferDone\n");
1001        }
1002
1003        OMX_PRBUFFER1(pComponentPrivate->dbg, "buffer summary (flush input) %lu %lu %lu %lu\n",
1004                    pComponentPrivate->nInPortIn,
1005                    pComponentPrivate->nInPortOut,
1006                    pComponentPrivate->nOutPortIn,
1007                    pComponentPrivate->nOutPortOut);
1008
1009        pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
1010                                               pComponentPrivate->pHandle->pApplicationPrivate,
1011                                               OMX_EventCmdComplete,
1012                                               OMX_CommandFlush,
1013                                               JPEGENC_OUT_PORT,
1014                                               NULL);
1015    }
1016
1017    PRINT_EXIT:
1018        OMX_PRINT1(pComponentPrivate->dbg, "Exiting HandleCommand FLush Function JEPG Encoder\n");
1019    EXIT:
1020    return eError;
1021
1022}
1023
1024OMX_ERRORTYPE SendDynamicParam(JPEGENC_COMPONENT_PRIVATE *pComponentPrivate)
1025{
1026    OMX_ERRORTYPE eError = OMX_ErrorNone;
1027    IDMJPGE_TIGEM_DynamicParams* pTmpDynParams;
1028    OMX_HANDLETYPE pLcmlHandle = NULL;
1029    char* pTmp = NULL;
1030    OMX_U32 cmdValues[3] = {0, 0, 0};
1031    IIMGENC_DynamicParams ptParam;
1032    OMX_PARAM_PORTDEFINITIONTYPE* pPortDefIn = NULL;
1033    OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = NULL;
1034
1035    OMX_CHECK_PARAM(pComponentPrivate);
1036
1037    pPortDefIn = pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef;
1038    pPortDefOut = pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef;
1039
1040    ptParam.nNumAU = 0; /*  XDM_DEFAULT */
1041    //ptParam.nSize   =   sizeof(IIMGENC_DynamicParams);
1042    ptParam.nSize   =   sizeof(IDMJPGE_TIGEM_DynamicParams) ;
1043
1044    if ( pPortDefIn->format.image.eColorFormat == OMX_COLOR_FormatYUV420PackedPlanar ) {
1045        ptParam.nInputChromaFormat = 1;
1046    }
1047    else if ( pPortDefIn->format.image.eColorFormat ==  OMX_COLOR_FormatCbYCrY
1048    		|| pPortDefIn->format.image.eColorFormat == OMX_COLOR_Format32bitARGB8888
1049            || pPortDefIn->format.image.eColorFormat == OMX_COLOR_Format16bitRGB565) {
1050        ptParam.nInputChromaFormat = 4;
1051    }
1052	else if ( pPortDefIn->format.image.eColorFormat == OMX_COLOR_FormatYCbYCr) {
1053		ptParam.nInputChromaFormat = 9;
1054	}
1055    else {
1056        ptParam.nInputChromaFormat = 1;
1057    }
1058
1059    if (pComponentPrivate->pCrop->nWidth == 0)
1060    {
1061        ptParam.nInputWidth     = pPortDefIn->format.image.nFrameWidth;
1062    }
1063    else
1064    {
1065        ptParam.nInputWidth     = pComponentPrivate->pCrop->nWidth;
1066    }
1067
1068    if (pComponentPrivate->pCrop->nHeight == 0)
1069    {
1070        ptParam.nInputHeight     = pPortDefIn->format.image.nFrameHeight;
1071    }
1072    else
1073    {
1074        ptParam.nInputHeight     = pComponentPrivate->pCrop->nHeight;
1075    }
1076
1077    ptParam.nCaptureWidth   =  pPortDefIn->format.image.nFrameWidth;
1078    ptParam.nGenerateHeader =   0; /*XDM_ENCODE_AU*/
1079    ptParam.qValue          =   pComponentPrivate->pQualityfactor->nQFactor;
1080
1081    OMX_PRDSP1(pComponentPrivate->dbg, "ptParam.qValue %lu\n", ptParam.qValue);
1082
1083
1084    pTmp = (char*)pComponentPrivate->pDynParams;
1085    pTmp += 128;
1086    pTmpDynParams = (IDMJPGE_TIGEM_DynamicParams*)pTmp;
1087
1088    pTmpDynParams->params         = ptParam;
1089    pTmpDynParams->captureHeight = pPortDefIn->format.image.nFrameHeight;
1090    pTmpDynParams->DRI_Interval  = pComponentPrivate->nDRI_Interval;
1091    pTmpDynParams->huffmanTable = NULL;
1092    pTmpDynParams->quantTable     = NULL;
1093
1094    cmdValues[0] = IUALG_CMD_SETSTATUS;
1095    cmdValues[1] = (OMX_U32)(pTmpDynParams);
1096    cmdValues[2] = sizeof(IDMJPGE_TIGEM_DynamicParams) + 128;
1097
1098    pComponentPrivate->bAckFromSetStatus = 0;
1099    pLcmlHandle =(LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
1100    eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
1101                                               EMMCodecControlAlgCtrl,
1102                                               (void*)&cmdValues);
1103
1104EXIT:
1105    return eError;
1106}
1107
1108#ifdef __JPEG_OMX_PPLIB_ENABLED__
1109OMX_ERRORTYPE SendDynamicPPLibParam(JPEGENC_COMPONENT_PRIVATE *pComponentPrivate,OMX_U32 *ptInputParam)
1110{
1111    OMX_ERRORTYPE eError = OMX_ErrorNone;
1112    OMX_PARAM_PORTDEFINITIONTYPE* pPortDefIn = NULL;
1113    OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = NULL;
1114
1115    OMX_CHECK_PARAM(pComponentPrivate);
1116    pPortDefIn = pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef;
1117    pPortDefOut = pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef;
1118
1119    // PPLIB hardcoded params
1120    OMX_U32 ulOutPitch = 0;
1121    OMX_U32 ulPPLIBVideoGain=64;
1122    OMX_U32 ulPPLIBEnableCropping=0;
1123    OMX_U32 ulPPLIBXstart=0;
1124    OMX_U32 ulPPLIBYstart=0;
1125    OMX_U32 ulPPLIBXsize=0;
1126    OMX_U32 ulPPLIBYsize=0;
1127    OMX_U32 ulPPLIBEnableZoom=0;
1128    OMX_U32 ulPPLIBZoomFactor=0;
1129    OMX_U32 ulPPLIBZoomLimit=0;
1130    OMX_U32 ulPPLIBZoomSpeed=0;
1131    OMX_U32 ulPPLIBLightChroma=0;
1132    OMX_U32 ulPPLIBLockedRatio=1;
1133    OMX_U32 ulPPLIBMirroring=0;
1134    OMX_U32 ulPPLIBRGBrotation=0;
1135    OMX_U32 ulPPLIBYUVRotation=0;
1136    OMX_U32 ulPPLIBIORange=1;
1137    OMX_U32 ulPPLIBDithering=0;
1138
1139    OMX_U32 cOffset = 0;
1140
1141    /* PPLIB_RunTimeParams */
1142    // LgUns size; // size of structure
1143
1144    ptInputParam[0] = JPEGENC_PPLIB_DYNPARM_SIZE; // 252 bytes
1145
1146    // LgUns ulInWidth; // picture buffer width
1147
1148    ptInputParam[1] = pPortDefIn->format.image.nFrameWidth;
1149
1150    // LgUns ulInHeight; // picture buffer height
1151
1152    ptInputParam[2] = pPortDefIn->format.image.nFrameHeight;
1153
1154    // LgUns FrameEnabled[0] (enable instance 1 of VGPOP)
1155
1156    ptInputParam[3] = 1;
1157
1158    // LgUns FrameEnabled[1] (enable instance 2 of VGPOP - not used now)
1159
1160    ptInputParam[4] = 0;
1161
1162    // LgUns EnalbeYUVOutput[0]
1163
1164    ptInputParam[5] = 1;
1165
1166    // LgUns FrameEnabled[1]
1167
1168    ptInputParam[6] = 0;
1169
1170    // LgUns EnalbeRGBOutput[0]
1171
1172    ptInputParam[7] = 0;
1173
1174    // LgUns EnalbeRGBOutput[1]
1175
1176    ptInputParam[8] = 0;
1177
1178    // LgUns FrameInputStartYOffset[0]
1179
1180    ptInputParam[9] = 0;
1181
1182    // LgUns FrameInputStartYOffset[1]
1183
1184    ptInputParam[10] = 0;
1185
1186     cOffset = (pPortDefIn->format.image.nFrameWidth * pPortDefIn->format.image.nFrameHeight);
1187
1188    // LgUns FrameInputStartCOffset[0]
1189
1190    ptInputParam[11] = cOffset;
1191
1192    // LgUns FrameInputStartCOffset[1]
1193
1194    ptInputParam[12] = cOffset;
1195
1196    // LgUns FrameOutputStartYOffset[0]
1197
1198    ptInputParam[13] = 0;
1199
1200    // LgUns FrameOutputStartYOffset[1]
1201
1202    ptInputParam[14] = 0;
1203
1204    if (ulOutPitch > 0) {
1205        if (ulPPLIBYUVRotation == 0 || ulPPLIBYUVRotation == 180) {
1206            cOffset = (pPortDefIn->format.image.nFrameHeight * ulOutPitch);
1207        }
1208        else {
1209            cOffset = (pPortDefIn->format.image.nFrameWidth * ulOutPitch);
1210        }
1211    }
1212    else {
1213        cOffset = (pPortDefIn->format.image.nFrameHeight * pPortDefIn->format.image.nFrameWidth);
1214    }
1215
1216    // LgUns FrameOutputStartCOffset[0]
1217    ptInputParam[15] = cOffset;
1218
1219    // LgUns FrameOutputStartCOffset[1]
1220    ptInputParam[16] = cOffset;
1221
1222    // LgUns FrameOutputRGBOffset[0]
1223    ptInputParam[17] = 0;
1224
1225    // LgUns FrameOutputRGBOffset[1]
1226    ptInputParam[18] = 0;
1227
1228    // LgUns ulOutHeight[0]; // picture buffer height
1229    ptInputParam[19] = pPortDefIn->format.image.nFrameHeight;
1230
1231    // LgUns ulOutHeight[1]; // picture buffer height
1232    ptInputParam[20] = 0;
1233
1234    // LgUns ulOutWidth[0]; // picture buffer width
1235    ptInputParam[21] = pPortDefIn->format.image.nFrameWidth;
1236
1237    // LgUns ulOutWidth[1]; // picture buffer width
1238    ptInputParam[22] = 0;
1239
1240    //Contrast (same as Video Gain)
1241    ptInputParam[23] = ulPPLIBVideoGain;
1242
1243    //Contrast (same as Video Gain)
1244    ptInputParam[24] = ulPPLIBVideoGain;
1245
1246    if (ulPPLIBEnableCropping == 1) {
1247        // Cropping
1248        // LgUns ulInXstart[0]; // Hin active start
1249        ptInputParam[25] = ulPPLIBXstart;
1250
1251        // Cropping
1252        // LgUns ulInXstart[1]; // Hin active start
1253        ptInputParam[26] = 0;
1254
1255        //LgUns ulInYstart[0]; // Vin active start
1256        ptInputParam[27] = ulPPLIBYstart;
1257
1258        //LgUns ulInYstart[1]; // Vin active start
1259        ptInputParam[28] = 0;
1260
1261        // LgUns ulInXsize[0]; // Hin active width
1262        ptInputParam[29] = ulPPLIBXsize;
1263
1264        // LgUns ulInXsize[1]; // Hin active width
1265        ptInputParam[30] = 0;
1266
1267        // LgUns ulInYsize; // Vin active height
1268        ptInputParam[31] = ulPPLIBYsize;
1269
1270        // LgUns ulInYsize; // Vin active height
1271        ptInputParam[32] = 0;
1272    }
1273    else {
1274        // Cropping
1275        // LgUns ulInXstart; // Hin active start
1276        ptInputParam[25] = 0;
1277
1278        // Cropping
1279        // LgUns ulInXstart[1]; // Hin active start
1280        ptInputParam[26] = 0;
1281
1282        //LgUns ulInYstart; // Vin active start
1283        ptInputParam[27] = 0;
1284
1285        //LgUns ulInYstart[1]; // Vin active start
1286        ptInputParam[28] = 0;
1287
1288        // LgUns ulInXsize; // Hin active width
1289        ptInputParam[29] = 0;
1290
1291        // LgUns ulInXsize[1]; // Hin active width
1292        ptInputParam[30] = 0;
1293
1294        // LgUns ulInYsize; // Vin active height
1295        ptInputParam[31] = 0;
1296
1297        // LgUns ulInYsize; // Vin active height
1298        ptInputParam[32] = 0;
1299    }
1300
1301    if (ulPPLIBEnableZoom) {
1302        //Zoom
1303        //LgUns ulZoomFactor; // zooming ratio (/1024)
1304        ptInputParam[33] = ulPPLIBZoomFactor;
1305
1306        //Zoom
1307        //LgUns ulZoomFactor; // zooming ratio (/1024)
1308        ptInputParam[34] = 1024;
1309
1310        // LgUns ulZoomLimit; // zooming ratio limit (/1024)
1311        ptInputParam[35] = ulPPLIBZoomLimit;
1312
1313        // LgUns ulZoomLimit; // zooming ratio limit (/1024)
1314        ptInputParam[36] = 1024;
1315
1316        // LgInt slZoomSpeed; // speed of ratio change
1317        ptInputParam[37] = ulPPLIBZoomSpeed;
1318
1319        // LgInt slZoomSpeed; // speed of ratio change
1320        ptInputParam[38] = 0;
1321    }
1322    else {
1323        //Zoom
1324        //LgUns ulZoomFactor; // zooming ratio (/1024)
1325        ptInputParam[33] = 1024;
1326
1327        //Zoom
1328        //LgUns ulZoomFactor; // zooming ratio (/1024)
1329        ptInputParam[34] = 1024;
1330
1331        // LgUns ulZoomLimit; // zooming ratio limit (/1024)
1332        ptInputParam[35] = 1024;
1333
1334        // LgUns ulZoomLimit; // zooming ratio limit (/1024)
1335        ptInputParam[36] = 1024;
1336
1337        // LgInt slZoomSpeed; // speed of ratio change
1338        ptInputParam[37] = 0;
1339
1340        // LgInt slZoomSpeed; // speed of ratio change
1341        ptInputParam[38] = 0;
1342    }
1343
1344    // LgUns bLightChroma[0]; // Light chrominance process
1345    ptInputParam[39] = ulPPLIBLightChroma;
1346
1347    // LgUns bLightChroma[1]; // Light chrominance process
1348    ptInputParam[40] = ulPPLIBLightChroma;
1349
1350    //Aspect Ration Locked/unlocked
1351    // LgUns bLockedRatio; // keep H/V ratio
1352    ptInputParam[41] = ulPPLIBLockedRatio;
1353
1354    //Aspect Ration Locked/unlocked
1355    // LgUns bLockedRatio; // keep H/V ratio
1356    ptInputParam[42] = ulPPLIBLockedRatio;
1357
1358    //Mirroring and Rotation
1359    // LgUns bMirror; // to mirror the picture
1360    ptInputParam[43] = ulPPLIBMirroring;
1361
1362    //Mirroring and Rotation
1363    // LgUns bMirror; // to mirror the picture
1364    ptInputParam[44] = ulPPLIBMirroring;
1365
1366    // LgUns eRGBrotation; // 0, 90, 180, 270 deg.
1367    ptInputParam[45] = ulPPLIBRGBrotation;
1368
1369    // LgUns eRGBrotation; // 0, 90, 180, 270 deg.
1370    ptInputParam[46] = ulPPLIBRGBrotation;
1371
1372    // LgUns eYUVrotation; // 0, 90, 180, 270 deg.
1373    ptInputParam[47] = ulPPLIBYUVRotation;
1374
1375    // LgUns eYUVrotation; // 0, 90, 180, 270 deg.
1376    ptInputParam[48] = ulPPLIBYUVRotation;
1377
1378    // IO Range and Dithering
1379    // LgUns eIORange; // Input/Output video range
1380    // 0 = VGPOP_IN_16_235_OUT_16_235 (limi range to limi range),
1381    // 1 = VGPOP_IN_00_255_OUT_00_255 (full range to full range),
1382    // 2 = VGPOP_IN_00_255_OUT_16_235 (full range to limi range),
1383    // 3 = VGPOP_IN_16_235_OUT_00_255 (limi range to full range)
1384    ptInputParam[49] = ulPPLIBIORange;
1385
1386    // IO Range and Dithering
1387    // LgUns eIORange; // Input/Output video range
1388    // 0 = VGPOP_IN_16_235_OUT_16_235 (limi range to limi range),
1389    // 1 = VGPOP_IN_00_255_OUT_00_255 (full range to full range),
1390    // 2 = VGPOP_IN_00_255_OUT_16_235 (full range to limi range),
1391    // 3 = VGPOP_IN_16_235_OUT_00_255 (limi range to full range)
1392    ptInputParam[50] = ulPPLIBIORange;
1393
1394    // LgUns bDithering; // ON Enables the dithering
1395    ptInputParam[51] = ulPPLIBDithering;
1396
1397    // LgUns bDithering; // ON Enables the dithering
1398    ptInputParam[52] = ulPPLIBDithering;
1399
1400    // LgUns ulFrameOutputPitch; // ON Enables the dithering
1401    ptInputParam[53] = ulOutPitch;
1402
1403    // LgUns bDithering; // ON Enables the dithering
1404    ptInputParam[54] = ulOutPitch;
1405
1406    // LgUns ulAlphaRGB;
1407    ptInputParam[55] = 0;
1408
1409    // LgUns ulAlphaRGB;
1410    ptInputParam[56] = 0;
1411
1412    // LgUns ulIsFrameGenerated[0]
1413    ptInputParam[57] = 0;
1414
1415    // LgUns ulIsFrameGenerated[1]
1416    ptInputParam[58] = 0;
1417
1418    // LgUns ulYUVFrameSize[0]
1419    ptInputParam[59] = 0;
1420
1421    // LgUns ulYUVFrameSize[1]
1422    ptInputParam[60] = 0;
1423
1424    // LgUns ulRGBFrameSize[0]
1425    ptInputParam[61] = 0;
1426
1427    // LgUns ulRGBFrameSize[1]
1428    ptInputParam[62] = 0;
1429
1430EXIT:
1431    return eError;
1432}
1433#endif
1434
1435/*-------------------------------------------------------------------*/
1436/**
1437  *  HandleCommand() Handle State type commands
1438  *
1439  *  Depending on the State Command received it executes the corresponding code.
1440  *
1441  * @param phandle    handle for this instance of the component
1442  *
1443  * @retval OMX_NoError              Success, ready to roll
1444  * @retval OMX_ErrorInsufficientResources    Insiffucient Resources
1445  * @retval OMX_ErrorInvalidState    Invalid State Change
1446  *
1447  **/
1448/*-------------------------------------------------------------------*/
1449OMX_ERRORTYPE HandleJpegEncCommand (JPEGENC_COMPONENT_PRIVATE *pComponentPrivate, OMX_U32 nParam1)
1450{
1451
1452    OMX_ERRORTYPE eError = OMX_ErrorNone;
1453    OMX_COMPONENTTYPE *pHandle = NULL;
1454    OMX_PARAM_PORTDEFINITIONTYPE* pPortDefIn = NULL;
1455    OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = NULL;
1456    OMX_HANDLETYPE pLcmlHandle = NULL;
1457    LCML_DSP *lcml_dsp;
1458    OMX_U16 arr[100];
1459    LCML_CALLBACKTYPE cb;
1460#ifdef RESOURCE_MANAGER_ENABLED
1461    OMX_U32 lImageResolution = 0;
1462    OMX_U8 nMHzRM = 0;
1463#endif
1464
1465
1466
1467    OMX_CHECK_PARAM(pComponentPrivate);
1468    OMX_PRINT1(pComponentPrivate->dbg, "JPEGEnc Handlecommand\n");
1469    pHandle = (OMX_COMPONENTTYPE *) pComponentPrivate->pHandle;
1470    pPortDefIn = pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef;
1471    pPortDefOut = pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef;
1472
1473    switch ( (OMX_STATETYPE)(nParam1) ) {
1474    case OMX_StateIdle:
1475        OMX_PRSTATE2(pComponentPrivate->dbg, "HandleCommand: Cmd OMX_StateIdle\n");
1476        OMX_PRSTATE1(pComponentPrivate->dbg, "CHP 1 pComponentPrivate->nCurState  = %d\n",pComponentPrivate->nCurState );
1477        OMX_PRSTATE1(pComponentPrivate->dbg, "In idle in %lu out %lu\n", pComponentPrivate->nInPortIn, pComponentPrivate->nOutPortOut);
1478
1479        if ( pComponentPrivate->nCurState == OMX_StateIdle ) {
1480            pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
1481                                                   pComponentPrivate->pHandle->pApplicationPrivate,
1482                                                   OMX_EventError,
1483                                                   OMX_ErrorSameState,
1484                                                   OMX_TI_ErrorMinor,
1485                                                   NULL);
1486            break;
1487        }
1488        else if ( pComponentPrivate->nCurState == OMX_StateLoaded ||
1489                  pComponentPrivate->nCurState == OMX_StateWaitForResources) {
1490
1491                      OMX_PRSTATE2(pComponentPrivate->dbg, "state tranc from loaded to idle\n");
1492#ifdef __PERF_INSTRUMENTATION__
1493                  PERF_Boundary(pComponentPrivate->pPERFcomp,
1494                                PERF_BoundaryStart | PERF_BoundarySetup);
1495#endif
1496
1497#ifdef RESOURCE_MANAGER_ENABLED /* Resource Manager Proxy Calls */
1498            pComponentPrivate->rmproxyCallback.RMPROXY_Callback = (void *)ResourceManagerCallback;
1499            lImageResolution = pPortDefIn->format.image.nFrameWidth * pPortDefIn->format.image.nFrameHeight;
1500            OMX_GET_RM_VALUE(lImageResolution, nMHzRM, pComponentPrivate->dbg);
1501            OMX_PRMGR2(pComponentPrivate->dbg, "Value sent to RM = %d\n", nMHzRM);
1502            if (pComponentPrivate->nCurState != OMX_StateWaitForResources) {
1503
1504                eError = RMProxy_NewSendCommand(pHandle, RMProxy_RequestResource, OMX_JPEG_Encoder_COMPONENT, nMHzRM, 3456, &(pComponentPrivate->rmproxyCallback));
1505
1506                if (eError != OMX_ErrorNone) {
1507                    /* resource is not available, need set state to OMX_StateWaitForResources*/
1508                    OMX_PRMGR4(pComponentPrivate->dbg, "Resource is not available\n");
1509
1510                    pComponentPrivate->cbInfo.EventHandler(pHandle,
1511                                                           pHandle->pApplicationPrivate,
1512                                                           OMX_EventError,
1513                                                           OMX_ErrorInsufficientResources,
1514                                                           OMX_TI_ErrorSevere,
1515                                                           NULL);
1516                    eError = OMX_ErrorNone;
1517                    break;
1518                }
1519            }
1520#endif
1521
1522            if ( pPortDefIn->bEnabled == OMX_TRUE && pPortDefOut->bEnabled == OMX_TRUE ) {
1523                pthread_mutex_lock(&pComponentPrivate->jpege_mutex_app);
1524                while ( (!pPortDefIn->bPopulated) || (!pPortDefOut->bPopulated)) {
1525                    OMX_PRBUFFER0(pComponentPrivate->dbg, "%d in cond wait\n", __LINE__);
1526                    pthread_cond_wait(&pComponentPrivate->populate_cond, &pComponentPrivate->jpege_mutex_app);
1527                }
1528                pthread_mutex_unlock(&pComponentPrivate->jpege_mutex_app);
1529            }
1530
1531            eError =  GetJpegEncLCMLHandle(pHandle);
1532
1533            if ( eError != OMX_ErrorNone ) {
1534                OMX_PRDSP4(pComponentPrivate->dbg, "GetLCMLHandle failed...\n");
1535                goto EXIT;
1536            }
1537            pLcmlHandle =(LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
1538            lcml_dsp = (((LCML_DSP_INTERFACE*)pLcmlHandle)->dspCodec);
1539            Fill_JpegEncLCMLInitParams(lcml_dsp,arr, pHandle);
1540            cb.LCML_Callback = (void *) JpegEncLCML_Callback;
1541            OMX_PRDSP2(pComponentPrivate->dbg, "Start LCML_InitMMCodec JPEG Phase in JPEG.....\n");
1542
1543            /*  calling initMMCodec to init codec with details filled earlier   */
1544            eError = LCML_InitMMCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle, NULL, &pLcmlHandle, NULL, &cb);
1545            if ( eError != OMX_ErrorNone ) {
1546                OMX_PRDSP4(pComponentPrivate->dbg, "InitMMCodec failed...  %x\n", eError);
1547                printf("Error : InitMMCodec failed...>>>>>>");
1548                pComponentPrivate->cbInfo.EventHandler(pHandle,
1549                                                       pHandle->pApplicationPrivate,
1550                                                       OMX_EventError,
1551                                                       OMX_ErrorHardware,
1552                                                       OMX_TI_ErrorSevere,
1553                                                       NULL);
1554                goto EXIT;
1555            }
1556            pComponentPrivate->isLCMLActive = 1;
1557            OMX_PRDSP2(pComponentPrivate->dbg, "End LCML_InitMMCodec Phase\n");
1558
1559
1560            pComponentPrivate->bFlushComplete = OMX_FALSE;
1561            OMX_PRSTATE2(pComponentPrivate->dbg, "State has been Set to Idle\n");
1562            pComponentPrivate->nCurState = OMX_StateIdle;
1563
1564            /* Decrement reference count with signal enabled */
1565            if(RemoveStateTransition(pComponentPrivate, 1) != OMX_ErrorNone) {
1566                   return OMX_ErrorUndefined;
1567            }
1568
1569            pComponentPrivate->nInPortIn   = pComponentPrivate->nInPortOut   = 0;
1570            pComponentPrivate->nOutPortIn = pComponentPrivate->nOutPortOut = 0;
1571
1572
1573#ifdef RESOURCE_MANAGER_ENABLED
1574            eError= RMProxy_NewSendCommand(pHandle, RMProxy_StateSet, OMX_JPEG_Encoder_COMPONENT, OMX_StateIdle,  3456, NULL);
1575            if (eError != OMX_ErrorNone) {
1576                OMX_PRMGR4(pComponentPrivate->dbg, "Resources not available Loaded ->Idle\n");
1577
1578                pComponentPrivate->cbInfo.EventHandler(pHandle,
1579                                                       pHandle->pApplicationPrivate,
1580                                                       OMX_EventError,
1581                                                       OMX_ErrorInsufficientResources,
1582                                                       OMX_TI_ErrorSevere,
1583                                                       NULL);
1584                break;
1585            }
1586#endif
1587
1588#ifdef __PERF_INSTRUMENTATION__
1589            PERF_Boundary(pComponentPrivate->pPERFcomp,
1590                          PERF_BoundaryComplete | PERF_BoundarySetup);
1591#endif
1592
1593            pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
1594                              pComponentPrivate->pHandle->pApplicationPrivate,
1595                          OMX_EventCmdComplete,
1596                          OMX_CommandStateSet,
1597                          pComponentPrivate->nCurState,
1598                          NULL);
1599            break;
1600
1601        }
1602        else if ( pComponentPrivate->nCurState == OMX_StateExecuting ||
1603                  pComponentPrivate->nCurState == OMX_StatePause ) {
1604#ifdef __PERF_INSTRUMENTATION__
1605            PERF_Boundary(pComponentPrivate->pPERFcomp,
1606                          PERF_BoundaryComplete | PERF_BoundarySteadyState);
1607#endif
1608
1609          pLcmlHandle =(LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
1610          pComponentPrivate->bDSPStopAck = OMX_FALSE;
1611          OMX_PRDSP2(pComponentPrivate->dbg, "bDSPStopAck is %d\n", pComponentPrivate->bDSPStopAck);
1612          eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,MMCodecControlStop,NULL);
1613          pComponentPrivate->nApp_nBuf= 1;
1614         /* HandleJpegEncCommandFlush(pComponentPrivate, -1); */
1615          /*
1616          if ( pComponentPrivate->isLCMLActive ==1 ) {
1617              LCML_ControlCodec(((LCML_DSP_INTERFACE*)pComponentPrivate->pLCML)->pCodecinterfacehandle,EMMCodecControlDestroy,NULL);
1618              dlclose(pComponentPrivate->pDllHandle);
1619              pComponentPrivate->isLCMLActive = 0;
1620          }
1621          */
1622
1623#ifdef RESOURCE_MANAGER_ENABLED
1624
1625        eError= RMProxy_NewSendCommand(pHandle, RMProxy_StateSet, OMX_JPEG_Encoder_COMPONENT, OMX_StateIdle, 3456, NULL);
1626        if (eError != OMX_ErrorNone) {
1627	        OMX_PRMGR4(pComponentPrivate->dbg, "Resources not available Executing ->Idle\n");
1628            pComponentPrivate->nCurState = OMX_StateWaitForResources;
1629            pComponentPrivate->cbInfo.EventHandler(pHandle,
1630                                                   pHandle->pApplicationPrivate,
1631                                                   OMX_EventCmdComplete,
1632                                                   OMX_CommandStateSet,
1633                                                   pComponentPrivate->nCurState,
1634                                                   NULL);
1635            break;
1636        }
1637#endif
1638          pComponentPrivate->ExeToIdleFlag |= JPEGE_BUFFERBACK;
1639
1640        OMX_PRBUFFER2(pComponentPrivate->dbg, "JPEG enc: before stop lock\n");
1641        pthread_mutex_lock(&pComponentPrivate->jpege_mutex);
1642        /*
1643        while ((pComponentPrivate->ExeToIdleFlag & 0x3) != JPEGE_IDLEREADY) {
1644            OMX_PRBUFFER0(pComponentPrivate->dbg, "%d in cond wait\n", __LINE__);
1645            pthread_cond_wait(&pComponentPrivate->stop_cond, &pComponentPrivate->jpege_mutex);
1646        }
1647        */
1648        while (pComponentPrivate->bDSPStopAck == OMX_FALSE) {
1649            OMX_PRBUFFER0(pComponentPrivate->dbg, "%d in cond wait\n", __LINE__);
1650            pthread_cond_wait(&pComponentPrivate->stop_cond, &pComponentPrivate->jpege_mutex);
1651        }
1652        pthread_mutex_unlock(&pComponentPrivate->jpege_mutex);
1653
1654        OMX_PRBUFFER2(pComponentPrivate->dbg, "JPEG enc:got STOP ack from DSP\n");
1655
1656        int i;
1657        for (i = 0; i < (int)(pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->nBufferCountActual); i ++) {
1658            JPEGENC_BUFFER_PRIVATE    *pBuffPrivate = NULL;
1659            OMX_BUFFERHEADERTYPE* pBuffHead = NULL;
1660
1661            pBuffHead = pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pBufferPrivate[i]->pBufferHdr;
1662            pBuffPrivate = pBuffHead->pInputPortPrivate;
1663
1664            OMX_PRBUFFER1(pComponentPrivate->dbg, "JPEG enc:: owner %d \n", pBuffPrivate->eBufferOwner);
1665            if (pBuffPrivate->eBufferOwner != JPEGENC_BUFFER_CLIENT) {
1666                if (pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pBufSupplier != OMX_BufferSupplyInput) {
1667                    if(pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->hTunnelComponent == NULL){
1668                        OMX_PRBUFFER2(pComponentPrivate->dbg, "Sending buffer to app\n");
1669                        OMX_PRDSP2(pComponentPrivate->dbg, "Handle error from DSP/bridge\n");
1670                        pComponentPrivate->nInPortOut ++;
1671                        pBuffPrivate->eBufferOwner = JPEGENC_BUFFER_CLIENT;
1672                        pComponentPrivate->cbInfo.EmptyBufferDone(
1673                                   pComponentPrivate->pHandle,
1674                                   pComponentPrivate->pHandle->pApplicationPrivate,
1675                                   pBuffHead);
1676                }
1677                else{
1678                    OMX_PRBUFFER2(pComponentPrivate->dbg, "JPEG enc:: Sending beffer to tunnel, pHandle=%p\n", pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->hTunnelComponent);
1679                    pBuffHead->nFilledLen = 0;
1680                    pBuffPrivate->eBufferOwner = JPEGENC_BUFFER_CLIENT;
1681                    eError = OMX_FillThisBuffer(pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->hTunnelComponent,
1682                                                pBuffHead);
1683                }
1684            }
1685        }
1686    }
1687
1688        OMX_PRBUFFER2(pComponentPrivate->dbg, "returned all input buffers\n");
1689
1690        for (i = 0; i < (int)(pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef->nBufferCountActual); i ++) {
1691            JPEGENC_BUFFER_PRIVATE    *pBuffPrivate = NULL;
1692            OMX_BUFFERHEADERTYPE* pBuffHead = NULL;
1693
1694            pBuffHead = pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pBufferPrivate[i]->pBufferHdr;
1695            pBuffPrivate = pBuffHead->pOutputPortPrivate;
1696
1697            OMX_PRBUFFER1(pComponentPrivate->dbg, "buffer %p owner %d \n", pBuffHead, pBuffPrivate->eBufferOwner);
1698            if (pBuffPrivate->eBufferOwner != JPEGENC_BUFFER_CLIENT) {
1699                if (pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pBufSupplier != OMX_BufferSupplyOutput) {
1700                    if(pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->hTunnelComponent == NULL){
1701                        OMX_PRBUFFER2(pComponentPrivate->dbg, "JPEG enc:: Sending OUTPUT buffer to app\n");
1702                        OMX_PRDSP2(pComponentPrivate->dbg, "Handle error from DSP/bridge\n");
1703                        pComponentPrivate->nOutPortOut ++;
1704                        pBuffPrivate->eBufferOwner = JPEGENC_BUFFER_CLIENT;
1705                        pComponentPrivate->cbInfo.FillBufferDone(
1706                                   pComponentPrivate->pHandle,
1707                                   pComponentPrivate->pHandle->pApplicationPrivate,
1708                                   pBuffHead);
1709                    }
1710                    else{
1711                        OMX_PRBUFFER2(pComponentPrivate->dbg, "JPEG enc:: Sending OUTPUT buffer to Tunnel component\n");
1712                        pBuffPrivate->eBufferOwner = JPEGENC_BUFFER_CLIENT;
1713                    eError = OMX_EmptyThisBuffer(pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->hTunnelComponent,
1714                                                pBuffHead);
1715                    }
1716                }
1717            }
1718        }
1719        OMX_PRBUFFER2(pComponentPrivate->dbg, "returned all output buffers\n");
1720
1721         pComponentPrivate->nCurState = OMX_StateIdle;
1722
1723         /* Decrement reference count with signal enabled */
1724         if(RemoveStateTransition(pComponentPrivate, 1) != OMX_ErrorNone) {
1725              return OMX_ErrorUndefined;
1726         }
1727
1728         pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
1729               pComponentPrivate->pHandle->pApplicationPrivate,
1730               OMX_EventCmdComplete,
1731               OMX_CommandStateSet,
1732               pComponentPrivate->nCurState,
1733               NULL);
1734             pComponentPrivate->ExeToIdleFlag = 0;
1735    }
1736        else {
1737         OMX_PRSTATE4(pComponentPrivate->dbg, "Error: Invalid State Given by Application\n");
1738         pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
1739                                                    pComponentPrivate->pHandle->pApplicationPrivate,
1740                            OMX_EventError,
1741                                                    OMX_ErrorIncorrectStateTransition,
1742                                                    OMX_TI_ErrorMinor,
1743                                                    "Invalid State");
1744        }
1745    break;
1746
1747    case OMX_StateExecuting:
1748
1749        OMX_PRSTATE2(pComponentPrivate->dbg, "HandleCommand: Cmd OMX_StateExecuting \n");
1750        OMX_PRBUFFER2(pComponentPrivate->dbg, "In exec in %lu out %lu\n", pComponentPrivate->nInPortIn, pComponentPrivate->nOutPortOut);
1751        if ( pComponentPrivate->nCurState == OMX_StateExecuting ) {
1752            pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
1753                                                   pComponentPrivate->pHandle->pApplicationPrivate,
1754                                                   OMX_EventError,
1755                                                   OMX_ErrorSameState,
1756                                                   OMX_TI_ErrorMinor,
1757                                                   NULL);
1758        }
1759        else if ( pComponentPrivate->nCurState == OMX_StateIdle || pComponentPrivate->nCurState == OMX_StatePause ) {
1760
1761#ifdef __PERF_INSTRUMENTATION__
1762            PERF_Boundary(pComponentPrivate->pPERFcomp,
1763                          PERF_BoundaryStart | PERF_BoundarySteadyState);
1764#endif
1765
1766#if 1
1767        eError = SendDynamicParam(pComponentPrivate);
1768            if (eError != OMX_ErrorNone ) {
1769                OMX_PRDSP4(pComponentPrivate->dbg, "SETSTATUS failed...  %x\n", eError);
1770                goto EXIT;
1771        }
1772#endif
1773
1774
1775
1776
1777        OMX_PRDSP2(pComponentPrivate->dbg, "after SendDynamicParam\n");
1778        pLcmlHandle =(LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
1779        eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,EMMCodecControlStart,NULL);
1780
1781#ifdef RESOURCE_MANAGER_ENABLED
1782
1783    eError= RMProxy_NewSendCommand(pHandle, RMProxy_StateSet, OMX_JPEG_Encoder_COMPONENT, OMX_StateExecuting, 3456, NULL);
1784    if (eError != OMX_ErrorNone) {
1785        OMX_PRMGR4(pComponentPrivate->dbg, "Resources not available\n");
1786        pComponentPrivate->nCurState = OMX_StateWaitForResources;
1787        pComponentPrivate->cbInfo.EventHandler(pHandle,
1788                                               pHandle->pApplicationPrivate,
1789                                               OMX_EventCmdComplete,
1790                                               OMX_CommandStateSet,
1791                                               pComponentPrivate->nCurState,
1792                                               NULL);
1793        break;
1794        }
1795#endif
1796
1797        pComponentPrivate->nCurState = OMX_StateExecuting;
1798        OMX_PRSTATE2(pComponentPrivate->dbg, "State has been set to Executing\n");
1799#ifdef __PERF_INSTRUMENTATION__
1800            PERF_Boundary(pComponentPrivate->pPERFcomp,
1801                          PERF_BoundarySteadyState| PERF_BoundaryComplete);
1802#endif
1803
1804         /* Decrement reference count with signal enabled */
1805         if(RemoveStateTransition(pComponentPrivate, 1) != OMX_ErrorNone) {
1806               return OMX_ErrorUndefined;
1807         }
1808
1809        pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
1810                                               pComponentPrivate->pHandle->pApplicationPrivate,
1811                                               OMX_EventCmdComplete,
1812                                               OMX_CommandStateSet,
1813                                               pComponentPrivate->nCurState,
1814                                               NULL);
1815        } else {
1816            pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
1817                                                   pComponentPrivate->pHandle->pApplicationPrivate,
1818                                                   OMX_EventError,
1819                                                   OMX_ErrorIncorrectStateTransition,
1820                                                   OMX_TI_ErrorMinor,
1821                                                   NULL);
1822        }
1823        break;
1824
1825    case OMX_StatePause:
1826        OMX_PRSTATE2(pComponentPrivate->dbg, "HandleCommand: Cmd OMX_StatePause\n");
1827
1828        pComponentPrivate->nToState = OMX_StatePause;
1829#ifdef __PERF_INSTRUMENTATION__
1830                PERF_Boundary(pComponentPrivate->pPERFcomp,
1831                              PERF_BoundaryComplete | PERF_BoundarySteadyState);
1832#endif
1833
1834        if ( pComponentPrivate->nCurState == OMX_StatePause ) {
1835            pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,pComponentPrivate->pHandle->pApplicationPrivate,
1836                                                   OMX_EventError, OMX_ErrorSameState, OMX_TI_ErrorMinor , NULL);
1837        } else if ( pComponentPrivate->nCurState == OMX_StateExecuting || pComponentPrivate->nCurState == OMX_StateIdle ) {
1838
1839            pLcmlHandle =(LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
1840            eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,EMMCodecControlPause,NULL);
1841            if ( eError != OMX_ErrorNone ) {
1842                OMX_PRDSP4(pComponentPrivate->dbg, "Error during EMMCodecControlPause. Error: %d.\n", eError );
1843                goto EXIT;
1844            }
1845            /*
1846            pComponentPrivate->nCurState = OMX_StatePause; */
1847            /* Decrement reference count with signal enabled */
1848            if(RemoveStateTransition(pComponentPrivate, 1) != OMX_ErrorNone) {
1849                   return OMX_ErrorUndefined;
1850           }
1851            pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,pComponentPrivate->pHandle->pApplicationPrivate,
1852                                                   OMX_EventCmdComplete, OMX_CommandStateSet, pComponentPrivate->nCurState, NULL);
1853        } else {
1854            pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,pComponentPrivate->pHandle->pApplicationPrivate,
1855                                                   OMX_EventError, OMX_ErrorIncorrectStateTransition, OMX_TI_ErrorMinor , NULL);
1856            OMX_PRSTATE4(pComponentPrivate->dbg, "Error: Invalid State Given by Application\n");
1857        }
1858        break;
1859
1860
1861    case OMX_StateInvalid:
1862        OMX_PRSTATE2(pComponentPrivate->dbg, "HandleCommand: Cmd OMX_StateInvalid::\n");
1863        if ( pComponentPrivate->nCurState == OMX_StateInvalid ) {
1864            pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle, pComponentPrivate->pHandle->pApplicationPrivate,
1865                                                   OMX_EventError, OMX_ErrorSameState, OMX_TI_ErrorMinor , NULL);
1866        }
1867        if ( pComponentPrivate->nCurState != OMX_StateLoaded ) {
1868            OMX_PRBUFFER2(pComponentPrivate->dbg, "HandleJpegEncInternalFlush \n");
1869            eError = HandleJpegEncInternalFlush(pComponentPrivate, nParam1);
1870            }
1871
1872            pComponentPrivate->nCurState = OMX_StateInvalid;
1873
1874            if(pComponentPrivate->nToState == OMX_StateInvalid){ /*if the IL client call directly send to invalid state*/
1875                pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
1876                                       pComponentPrivate->pHandle->pApplicationPrivate,
1877                                       OMX_EventCmdComplete,
1878                                       OMX_CommandStateSet,
1879                                       pComponentPrivate->nCurState,
1880                                       NULL);
1881            }
1882            else{ /*When the component go to invalid state by it self*/
1883                pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
1884                                       pComponentPrivate->pHandle->pApplicationPrivate,
1885                                       OMX_EventError,
1886                                       OMX_ErrorInvalidState,
1887                                       OMX_TI_ErrorSevere,
1888                                       NULL);
1889            }
1890        break;
1891
1892    case OMX_StateLoaded:
1893        if ( pComponentPrivate->nCurState == OMX_StateLoaded ) {
1894            pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
1895                                                   pComponentPrivate->pHandle->pApplicationPrivate,
1896                                                   OMX_EventError,
1897                                                   OMX_ErrorSameState,
1898                                                   OMX_TI_ErrorMinor ,
1899                                                   NULL);
1900
1901        } else if ( pComponentPrivate->nCurState == OMX_StateIdle ||
1902                    pComponentPrivate->nCurState == OMX_StateWaitForResources ) {
1903            /* Ports have to be unpopulated before transition completes */
1904            OMX_PRSTATE2(pComponentPrivate->dbg, "from idle to loaded\n");
1905
1906            pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
1907            if ( pComponentPrivate->pLCML != NULL && pComponentPrivate->isLCMLActive) {
1908                pLcmlHandle =(LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
1909                OMX_PRDSP2(pComponentPrivate->dbg, "try to close library again %p\n", pComponentPrivate->pLCML);
1910                LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,EMMCodecControlDestroy,NULL);
1911                OMX_PRDSP2(pComponentPrivate->dbg, "after close library again %p\n", pComponentPrivate->pLCML);
1912                pComponentPrivate->pLCML = NULL;
1913                dlclose(pComponentPrivate->pDllHandle);
1914                pComponentPrivate->isLCMLActive = 0;
1915
1916            }
1917            OMX_PRDSP2(pComponentPrivate->dbg, "after release LCML\n");
1918#ifdef __PERF_INSTRUMENTATION__
1919            PERF_Boundary(pComponentPrivate->pPERFcomp,
1920                          PERF_BoundaryStart | PERF_BoundaryCleanup);
1921#endif
1922
1923#ifdef UNDER_CE
1924            nTimeout=0x0;
1925
1926                while ( 1 )
1927                {
1928                    if ( (pPortDefOut->bPopulated == OMX_FALSE) )
1929                    {
1930                        OMX_PRDSP2(pComponentPrivate->dbg, "Thread Sending Cmd EMMCodecControlDestroy\n");
1931
1932
1933                        break;
1934                    } else if ( nTimeout++ > JPEGENC_TIMEOUT )
1935
1936                    {
1937                        OMX_PRBUFFER4(pComponentPrivate->dbg, "Timeout ...\n");
1938                        pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
1939                                       pComponentPrivate->pHandle->pApplicationPrivate,
1940                                       OMX_EventError,
1941                                       OMX_ErrorPortUnresponsiveDuringAllocation,
1942                                       OMX_TI_ErrorMajor,
1943                                       "Not response Port -Loaded");
1944                        OMX_PRBUFFER4(pComponentPrivate->dbg, "Not all ports are unpopulated!\n");
1945                        break;
1946                    }
1947                    /* Sleep for a while, so the application thread can allocate buffers */
1948            sched_yield();
1949            }
1950#else
1951
1952            pthread_mutex_lock(&pComponentPrivate->jpege_mutex_app);
1953            while ( pPortDefIn->bPopulated || pPortDefOut->bPopulated) {
1954                OMX_PRBUFFER0(pComponentPrivate->dbg, "%d in cond wait\n", __LINE__);
1955                pthread_cond_wait(&pComponentPrivate->unpopulate_cond, &pComponentPrivate->jpege_mutex_app);
1956            }
1957            pthread_mutex_unlock(&pComponentPrivate->jpege_mutex_app);
1958#endif
1959
1960#ifdef __PERF_INSTRUMENTATION__
1961                        PERF_Boundary(pComponentPrivate->pPERFcomp,
1962                                      PERF_BoundaryComplete | PERF_BoundaryCleanup);
1963#endif
1964
1965#ifdef RESOURCE_MANAGER_ENABLED
1966            if (pComponentPrivate->nCurState != OMX_StateWaitForResources) {
1967                eError= RMProxy_NewSendCommand(pHandle,  RMProxy_FreeResource, OMX_JPEG_Encoder_COMPONENT, 0, 3456, NULL);
1968                if (eError != OMX_ErrorNone) {
1969                    OMX_PRMGR4(pComponentPrivate->dbg, "Cannot Free Resources\n");
1970                    pComponentPrivate->cbInfo.EventHandler(pHandle,
1971                                                           pHandle->pApplicationPrivate,
1972                                                           OMX_EventError,
1973                                                           OMX_ErrorUndefined,
1974                                                           OMX_TI_ErrorMajor,
1975                                                           NULL);
1976                    break;
1977                }
1978            }
1979#endif
1980
1981            pComponentPrivate->nCurState = OMX_StateLoaded;
1982
1983            if ((pComponentPrivate->nCurState == OMX_StateIdle) &&
1984                 (pComponentPrivate->bPreempted == 1 )){
1985
1986                pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
1987                                                       pComponentPrivate->pHandle->pApplicationPrivate,
1988                                                       OMX_EventError,
1989                                                       OMX_ErrorResourcesLost,
1990                                                       OMX_TI_ErrorSevere,
1991                                                       NULL);
1992                pComponentPrivate->bPreempted = 0;
1993
1994            }
1995            else {
1996                /* Decrement reference count with signal enabled */
1997                if(RemoveStateTransition(pComponentPrivate, 1) != OMX_ErrorNone) {
1998                  return OMX_ErrorUndefined;
1999                }
2000                pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
2001                                                       pComponentPrivate->pHandle->pApplicationPrivate,
2002                                                       OMX_EventCmdComplete,
2003                                                       OMX_CommandStateSet,
2004                                                       OMX_StateLoaded,
2005                                                       NULL);
2006            }
2007
2008        }
2009        else {
2010
2011            pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
2012                                                   pComponentPrivate->pHandle->pApplicationPrivate,
2013                                                   OMX_EventError,
2014                                                   OMX_ErrorIncorrectStateTransition,
2015                                                   OMX_TI_ErrorMinor,
2016                                                   NULL);
2017        }
2018        break;
2019
2020    case OMX_StateWaitForResources:
2021        if ( pComponentPrivate->nCurState == OMX_StateWaitForResources ) {
2022            pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
2023                                                                            pComponentPrivate->pHandle->pApplicationPrivate,
2024                                                                            OMX_EventError,
2025                                                                            OMX_ErrorSameState,
2026                                                                            OMX_TI_ErrorMinor,
2027                                                                            NULL);
2028        } else if ( pComponentPrivate->nCurState == OMX_StateLoaded ) {
2029
2030#ifdef RESOURCE_MANAGER_ENABLED
2031            eError= RMProxy_NewSendCommand(pHandle, RMProxy_StateSet, OMX_JPEG_Encoder_COMPONENT, OMX_StateWaitForResources, 3456, NULL);
2032            if (eError != OMX_ErrorNone) {
2033                OMX_PRMGR4(pComponentPrivate->dbg, "RMProxy_NewSendCommand(OMX_StateWaitForResources) failed\n");
2034                pComponentPrivate->cbInfo.EventHandler(pHandle,
2035                                                       pHandle->pApplicationPrivate,
2036                                                       OMX_EventError,
2037                                                       OMX_ErrorUndefined,
2038                                                       OMX_TI_ErrorSevere,
2039                                                       NULL);
2040                break;
2041            }
2042#endif
2043
2044            pComponentPrivate->nCurState = OMX_StateWaitForResources;
2045            pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
2046                                                                            pComponentPrivate->pHandle->pApplicationPrivate,
2047                                                                            OMX_EventCmdComplete,
2048                                                                            OMX_CommandStateSet,
2049                                                                            pComponentPrivate->nCurState,
2050                                                                            NULL);
2051        } else {
2052            pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
2053                                                                            pComponentPrivate->pHandle->pApplicationPrivate,
2054                                                                            OMX_EventError,
2055                                                                            OMX_ErrorIncorrectStateTransition,
2056                                                                            OMX_TI_ErrorMinor,
2057                                                                            NULL);
2058        }
2059        break;
2060
2061    case OMX_StateMax:
2062        OMX_PRSTATE2(pComponentPrivate->dbg, "HandleCommand: Cmd OMX_StateMax::\n");
2063        break;
2064    } /* End of Switch */
2065
2066
2067    EXIT:
2068    return eError;
2069}
2070
2071
2072OMX_ERRORTYPE HandleJpegEncFreeOutputBufferFromApp(JPEGENC_COMPONENT_PRIVATE *pComponentPrivate )
2073{
2074
2075    OMX_ERRORTYPE eError = OMX_ErrorNone;
2076    OMX_BUFFERHEADERTYPE* pBuffHead = NULL;
2077    /* IUALG_Buf *ptParam = NULL; */
2078    OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = NULL;
2079    LCML_DSP_INTERFACE* pLcmlHandle = NULL;
2080    JPEGENC_BUFFER_PRIVATE* pBuffPrivate = NULL;
2081    int ret;
2082
2083    OMX_PRINT1(pComponentPrivate->dbg, "Inside HandleFreeOutputBufferFromApp function\n");
2084
2085    pLcmlHandle = (LCML_DSP_INTERFACE *)(pComponentPrivate->pLCML);
2086    pPortDefOut = pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef;
2087
2088    ret = read(pComponentPrivate->free_outBuf_Q[0], &pBuffHead, sizeof(pBuffHead));
2089    if ( ret == -1 ) {
2090        OMX_PRCOMM4(pComponentPrivate->dbg, "Error while reading from the pipe\n");
2091        goto EXIT;
2092    }
2093
2094    if (pBuffHead != NULL) {
2095        pBuffPrivate = pBuffHead->pOutputPortPrivate;
2096    } else {
2097        OMX_PRBUFFER4(pComponentPrivate->dbg, "Error while reading pBuffHead from the pipe\n");
2098        goto EXIT;
2099    }
2100
2101    if (pComponentPrivate->nCurState != OMX_StatePause || pComponentPrivate->nToState != OMX_StatePause) {
2102
2103   if ((pComponentPrivate->nCurState != OMX_StateExecuting ) ||
2104       (pComponentPrivate->nToState == OMX_StateIdle) ||
2105         (pPortDefOut->bEnabled == OMX_FALSE)) {
2106         if (pBuffPrivate->eBufferOwner != JPEGENC_BUFFER_CLIENT) {
2107            pBuffPrivate->eBufferOwner = JPEGENC_BUFFER_CLIENT;
2108            pComponentPrivate->nOutPortOut ++;
2109            OMX_PRBUFFER1(pComponentPrivate->dbg, "buffer summary (return empty output buffer) %lu %lu %lu %lu\n",
2110                    pComponentPrivate->nInPortIn,
2111                    pComponentPrivate->nInPortOut,
2112                    pComponentPrivate->nOutPortIn,
2113                    pComponentPrivate->nOutPortOut);
2114            OMX_PRBUFFER2(pComponentPrivate->dbg, "FillBufferDone (incorrect state %d) %p\n", pComponentPrivate->nCurState, pBuffHead);
2115            pComponentPrivate->cbInfo.FillBufferDone(pComponentPrivate->pHandle,
2116                    pComponentPrivate->pHandle->pApplicationPrivate,
2117                    pBuffHead);
2118         }
2119        goto EXIT;
2120    }
2121    }
2122
2123    OMX_PRBUFFER1(pComponentPrivate->dbg, "buffer summary (HandleJpegEncFreeOutputBufferFromApp) %lu %lu %lu %lu\n",
2124                    pComponentPrivate->nInPortIn,
2125                    pComponentPrivate->nInPortOut,
2126                    pComponentPrivate->nOutPortIn,
2127                    pComponentPrivate->nOutPortOut);
2128
2129#ifdef __PERF_INSTRUMENTATION__
2130    PERF_SendingFrame(pComponentPrivate->pPERFcomp,
2131                      pBuffHead->pBuffer,
2132                      0,
2133                      PERF_ModuleCommonLayer);
2134#endif
2135
2136    /* ptParam =  (IUALG_Buf *)pBuffPrivate->pUALGParams; */
2137    pBuffPrivate->eBufferOwner = JPEGENC_BUFFER_DSP;
2138
2139#ifdef __JPEG_OMX_PPLIB_ENABLED__
2140    if (pComponentPrivate->pOutParams != NULL)
2141    {
2142        pComponentPrivate->pOutParams = (OMX_U8*)pComponentPrivate->pOutParams - PADDING_128_BYTE;
2143	OMX_FREE(pComponentPrivate->pOutParams);
2144    }
2145    OMX_MALLOC(pComponentPrivate->pOutParams,sizeof(PPLIB_UALGRunTimeParam_t) + PADDING_256_BYTE);
2146    pComponentPrivate->pOutParams = (OMX_U8*)pComponentPrivate->pOutParams + PADDING_128_BYTE;
2147
2148    if (pComponentPrivate->pOutParams != NULL)
2149    {
2150    }
2151    else
2152    {
2153        goto EXIT;
2154    }
2155
2156    eError = SendDynamicPPLibParam(pComponentPrivate,pComponentPrivate->pOutParams);
2157       if (eError != OMX_ErrorNone ) {
2158           goto EXIT;
2159       }
2160
2161
2162       eError = LCML_QueueBuffer(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
2163                                 EMMCodecOuputBuffer,
2164                                 pBuffHead->pBuffer,
2165                                 pPortDefOut->nBufferSize,
2166                                 0,
2167                                 (OMX_U8 *)pComponentPrivate->pOutParams,
2168                                 sizeof(PPLIB_UALGRunTimeParam_t),
2169                                 (OMX_U8 *)  pBuffHead);
2170
2171#else
2172    eError = LCML_QueueBuffer(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
2173                              EMMCodecOuputBuffer,
2174                              pBuffHead->pBuffer,
2175                              pPortDefOut->nBufferSize,
2176                              0,
2177                              NULL,
2178                              0,
2179                              (OMX_U8 *)  pBuffHead);
2180#endif
2181
2182    OMX_PRINT1(pComponentPrivate->dbg, "Error is %x\n",eError);
2183
2184    EXIT:
2185    return eError;
2186}
2187
2188OMX_U32 CalculateParamsSize (JPEGENC_COMPONENT_PRIVATE *pComponentPrivate) {
2189
2190    OMX_U32 i = 0;
2191
2192    i+= 4; /* 4 bytes for the size of the whole array */
2193
2194    /* Set Custom Quantization Table */
2195    if (pComponentPrivate->bSetLumaQuantizationTable && pComponentPrivate->bSetChromaQuantizationTable) {
2196        i+=4;  /* 4 bytes for the Quantization table TAG */
2197        i+=4;  /* 4 bytes for the size of this TAG */
2198        i+=256; /* 256 bytes for the Quantization table data*/
2199    }
2200
2201    /* Set Custom Huffman Table */
2202    if (pComponentPrivate->bSetHuffmanTable) {
2203        i+=4;  /* 4 bytes for the Huffman table TAG */
2204        i+=4;  /* 4 bytes for the size of this TAG */
2205        if (sizeof(JPEGENC_CUSTOM_HUFFMAN_TABLE) % 4) {
2206            i += (sizeof(JPEGENC_CUSTOM_HUFFMAN_TABLE) + (4 - (sizeof(JPEGENC_CUSTOM_HUFFMAN_TABLE) % 4)));
2207        }
2208        else {
2209            i += sizeof(JPEGENC_CUSTOM_HUFFMAN_TABLE);
2210        }
2211    }
2212
2213    /* handle APP0 marker (JFIF)*/
2214    if(pComponentPrivate->sAPP0.bMarkerEnabled) {
2215        i+=4;  /* 4 bytes for the Number of buffers TAG */
2216        i+=4;  /* 4 bytes for the size of this TAG */
2217        i+=4;  /* 4 bytes for the actual number of buffers (just 1 buffer) */
2218        i+=4;  /* 4 bytes for the buffer0  TAG */
2219
2220        /* if thumbnail is set, or if explicity specified by application, set the marker from algo, otherwise set it from application */
2221        if ((pComponentPrivate->sAPP0.nThumbnailWidth > 0 && pComponentPrivate->sAPP0.nThumbnailHeight > 0)
2222        || pComponentPrivate->sAPP0.nMarkerSize <= 0) {
2223            i+=4;   /* 4 bytes for the size of this TAG */
2224            i+=4;   /* 4 bytes for the actual data of this TAG */
2225        }
2226        else {
2227            i+=4;   /* 4 bytes for the size of this TAG */
2228            i += (pComponentPrivate->sAPP0.nMarkerSize/4)*4;  /* x bytes for the actual buffer data for this TAG */
2229            if (pComponentPrivate->sAPP0.nMarkerSize % 4) {
2230                i +=4;  /* 4 extra bytes if the size is not divisible by 4*/
2231            }
2232        }
2233        /* if thumbnail is set, configure it accordingly */
2234        if (pComponentPrivate->sAPP0.nThumbnailWidth > 0 && pComponentPrivate->sAPP0.nThumbnailHeight > 0) {
2235            i+=4;  /* 4 bytes for the THUMB INDEX TAG */
2236            i+=4;  /* 4 bytes for the size of this TAG */
2237            i+=4;  /* 4 bytes for the actual data for this TAG */
2238
2239            i+=4;  /* 4 bytes for the THUMB W TAG */
2240            i+=4;  /* 4 bytes for the size of this TAG */
2241            i+=4;  /* 4 bytes for the actual data for this TAG (width value) */
2242
2243            i+=4;  /* 4 bytes for the THUMB H TAG */
2244            i+=4;  /* 4 bytes for the size of this TAG */
2245            i+=4;  /* 4 bytes for the actual data for this TAG (height value) */
2246        }
2247    }
2248
2249    /* handle APP1 marker (EXIF)*/
2250    if (pComponentPrivate->sAPP1.bMarkerEnabled) {
2251        i+=4;  /* 4 bytes for the Number of buffers TAG */
2252        i+=4;  /* 4 bytes for the size of this TAG */
2253        i+=4;  /* 4 bytes for the actual number of buffers (just 1 buffer) */
2254        i+=4;  /* 4 bytes for the buffer0  TAG */
2255
2256    	/* if explicity specified by application, set the marker from algo, otherwise set it from application */
2257    	if (pComponentPrivate->sAPP1.nMarkerSize <= 0) {
2258            i+=4;   /* 4 bytes for the size of this TAG */
2259            i+=4;   /* 4 bytes for the actual data of this TAG */
2260            i+=4;   /* 4 bytes for the actual data of this TAG */
2261    	}
2262    	else {
2263    	    i+=4;   /* 4 bytes for the size of this TAG */
2264                i += (pComponentPrivate->sAPP1.nMarkerSize/4)*4;  /* x bytes for the actual buffer data for this TAG */
2265                if (pComponentPrivate->sAPP1.nMarkerSize % 4) {
2266                    i +=4;  /* 4 extra bytes if the size is not divisible by 4*/
2267                }
2268    	}
2269
2270    	/* if thumbnail is set, configure it accordingly */
2271    	if (pComponentPrivate->sAPP1.nThumbnailWidth > 0 && pComponentPrivate->sAPP1.nThumbnailHeight > 0) {
2272            i+=4;  /* 4 bytes for the THUMB INDEX TAG */
2273            i+=4;  /* 4 bytes for the size of this TAG */
2274            i+=4;  /* 4 bytes for the actual data for this TAG */
2275
2276            i+=4;  /* 4 bytes for the THUMB W TAG */
2277            i+=4;  /* 4 bytes for the size of this TAG */
2278            i+=4;  /* 4 bytes for the actual data for this TAG (width value) */
2279
2280            i+=4;  /* 4 bytes for the THUMB H TAG */
2281            i+=4;  /* 4 bytes for the size of this TAG */
2282            i+=4;  /* 4 bytes for the actual data for this TAG (height value) */
2283    	}
2284    }
2285
2286
2287    /* handle APP5 marker */
2288    if (pComponentPrivate->sAPP5.bMarkerEnabled) {
2289        i+=4;  /* 4 bytes for the Number of buffers TAG */
2290        i+=4;  /* 4 bytes for the size of this TAG */
2291        i+=4;  /* 4 bytes for the actual number of buffers (just 1 buffer) */
2292        i+=4;  /* 4 bytes for the buffer0  TAG */
2293
2294    	/* if explicity specified by application, set the marker from algo, otherwise set it from application */
2295    	if (pComponentPrivate->sAPP5.nMarkerSize <= 0) {
2296            i+=4;   /* 4 bytes for the size of this TAG */
2297            i+=4;   /* 4 bytes for the actual data of this TAG */
2298            i+=4;   /* 4 bytes for the actual data of this TAG */
2299    	}
2300    	else {
2301    	    i+=4;   /* 4 bytes for the size of this TAG */
2302                i += (pComponentPrivate->sAPP5.nMarkerSize/4)*4;  /* x bytes for the actual buffer data for this TAG */
2303                if (pComponentPrivate->sAPP5.nMarkerSize % 4) {
2304                    i +=4;  /* 4 extra bytes if the size is not divisible by 4*/
2305                }
2306    	}
2307
2308    	/* if thumbnail is set, configure it accordingly */
2309    	if (pComponentPrivate->sAPP5.nThumbnailWidth > 0 && pComponentPrivate->sAPP5.nThumbnailHeight > 0) {
2310            i+=4;  /* 4 bytes for the THUMB INDEX TAG */
2311            i+=4;  /* 4 bytes for the size of this TAG */
2312            i+=4;  /* 4 bytes for the actual data for this TAG */
2313
2314            i+=4;  /* 4 bytes for the THUMB W TAG */
2315            i+=4;  /* 4 bytes for the size of this TAG */
2316            i+=4;  /* 4 bytes for the actual data for this TAG (width value) */
2317
2318            i+=4;  /* 4 bytes for the THUMB H TAG */
2319            i+=4;  /* 4 bytes for the size of this TAG */
2320            i+=4;  /* 4 bytes for the actual data for this TAG (height value) */
2321    	}
2322    }
2323    /* handle APP13 marker */
2324    if (pComponentPrivate->sAPP13.bMarkerEnabled) {
2325        i+=4;  /* 4 bytes for the Number of buffers TAG */
2326        i+=4;  /* 4 bytes for the size of this TAG */
2327        i+=4;  /* 4 bytes for the actual number of buffers (just 1 buffer) */
2328        i+=4;  /* 4 bytes for the buffer0  TAG */
2329
2330    	/* if explicity specified by application, set the marker from algo, otherwise set it from application */
2331    	if (pComponentPrivate->sAPP13.nMarkerSize <= 0) {
2332            i+=4;   /* 4 bytes for the size of this TAG */
2333            i+=4;   /* 4 bytes for the actual data of this TAG */
2334            i+=4;   /* 4 bytes for the actual data of this TAG */
2335    	}
2336    	else {
2337            i+=4;   /* 4 bytes for the size of this TAG */
2338            i += (pComponentPrivate->sAPP13.nMarkerSize/4)*4;  /* x bytes for the actual buffer data for this TAG */
2339            if (pComponentPrivate->sAPP13.nMarkerSize % 4) {
2340                i +=4;  /* 4 extra bytes if the size is not divisible by 4*/
2341            }
2342    	}
2343    }
2344
2345    /* comment flag needed */
2346    i+=4;   /* 4 bytes for the size of this TAG */
2347
2348    /* handle CommentFlag */
2349    if (pComponentPrivate->nCommentFlag == 1 && pComponentPrivate->pString_Comment) {
2350        i+=4;  /* 4 bytes for the Comment TAG */
2351        i+=4;  /* 4 bytes for the size of this TAG */
2352            /* comment string upper limit is 256 bytes */
2353            i+=256;
2354    }
2355    else {
2356        i+=4;  /* 4 bytes for the Comment TAG */
2357        i+=4;  /* 4 bytes for the size of this TAG */
2358    }
2359
2360    return i;
2361}
2362
2363static OMX_ERRORTYPE SetJpegEncInPortParams(JPEGENC_COMPONENT_PRIVATE *pComponentPrivate, OMX_U32* new_params)
2364{
2365    OMX_ERRORTYPE eError = OMX_ErrorNone;
2366    int i = 1;
2367
2368    /* Set Custom Quantization Table */
2369    if (pComponentPrivate->bSetLumaQuantizationTable && pComponentPrivate->bSetChromaQuantizationTable) {
2370        new_params[i++] = DYNPARAMS_QUANTTABLE;
2371        new_params[i++] = 256; /* 2 tables * 64 entries * 2(16bit entries) */
2372        OMX_U16 *temp = (OMX_U16 *)&new_params[i];
2373        int j, k;
2374        for (j = 0; j < 64; j++) {
2375            temp[j] = pComponentPrivate->pCustomLumaQuantTable->nQuantizationMatrix[j];
2376        }
2377        for (k = 0; k < 64; k++, j++) {
2378            temp[j] = pComponentPrivate->pCustomChromaQuantTable->nQuantizationMatrix[k];
2379        }
2380        i += 64; /* 256 / 4 */
2381    }
2382
2383    /* Set Custom Huffman Table */
2384    if (pComponentPrivate->bSetHuffmanTable) {
2385        new_params[i++] = DYNPARAMS_HUFFMANTABLE;
2386        new_params[i++] = sizeof(JPEGENC_CUSTOM_HUFFMAN_TABLE); /* 2572 % 4 = 0 */
2387
2388        memcpy((OMX_U8 *)(&new_params[i]), &(pComponentPrivate->pHuffmanTable->sHuffmanTable), sizeof(JPEGENC_CUSTOM_HUFFMAN_TABLE));
2389        if (sizeof(JPEGENC_CUSTOM_HUFFMAN_TABLE) % 4) {
2390            i += (sizeof(JPEGENC_CUSTOM_HUFFMAN_TABLE) + (4 - (sizeof(JPEGENC_CUSTOM_HUFFMAN_TABLE) % 4)))/4 ;
2391        }
2392        else {
2393           i += sizeof(JPEGENC_CUSTOM_HUFFMAN_TABLE)/4;
2394        }
2395    }
2396
2397    /* handle APP0 marker (JFIF)*/
2398    if(pComponentPrivate->sAPP0.bMarkerEnabled) {
2399        new_params[i++] = APP0_NUMBUF;
2400        new_params[i++] = 4;
2401        new_params[i++] = 1;
2402
2403        /* set default APP0 BUFFER */
2404        new_params[i++] = APP0_BUFFER;
2405
2406        /* if thumbnail is set, or if explicity specified by application, set the marker from algo, otherwise set it from application */
2407        if ((pComponentPrivate->sAPP0.nThumbnailWidth > 0 && pComponentPrivate->sAPP0.nThumbnailHeight > 0)
2408        	|| pComponentPrivate->sAPP0.nMarkerSize <= 0) {
2409            new_params[i++] = 4;
2410            new_params[i++] = 0;
2411        }
2412        else {
2413            new_params[i++] = pComponentPrivate->sAPP0.nMarkerSize;
2414            memcpy(new_params + i, pComponentPrivate->sAPP0.pMarkerBuffer, pComponentPrivate->sAPP0.nMarkerSize);
2415            i += pComponentPrivate->sAPP0.nMarkerSize / 4;
2416            if (pComponentPrivate->sAPP0.nMarkerSize % 4) {
2417            	i ++;
2418            }
2419        }
2420
2421        /* if thumbnail is set, configure it accordingly */
2422        if (pComponentPrivate->sAPP0.nThumbnailWidth > 0 && pComponentPrivate->sAPP0.nThumbnailHeight > 0) {
2423            new_params[i++] = APP0_THUMB_INDEX;
2424            new_params[i++] = 4;
2425            new_params[i++] = 1;
2426
2427            new_params[i++] = APP0_THUMB_W;
2428            new_params[i++] = 4;
2429            new_params[i++] = pComponentPrivate->sAPP0.nThumbnailWidth;
2430
2431            new_params[i++] = APP0_THUMB_H;
2432            new_params[i++] = 4;
2433            new_params[i++] = pComponentPrivate->sAPP0.nThumbnailHeight;
2434        }
2435    }
2436
2437    /* handle APP1 marker (EXIF)*/
2438    if(pComponentPrivate->sAPP1.bMarkerEnabled) {
2439        new_params[i++] = APP1_NUMBUF;
2440        new_params[i++] = 4;
2441        new_params[i++] = 1;
2442
2443        /* set default APP1 BUFFER */
2444        new_params[i++] = APP1_BUFFER;
2445
2446        /* if explicity specified by application, set the marker from algo, otherwise set it from application */
2447        if (pComponentPrivate->sAPP1.nMarkerSize <= 0) {
2448            new_params[i++] = 8;
2449            new_params[i++] = 0;
2450            new_params[i++] = 'F' | 'F' << 8 | 'F' << 16 | 'F' << 24;
2451        }
2452        else {
2453            new_params[i++] = pComponentPrivate->sAPP1.nMarkerSize;
2454            memcpy(new_params + i, pComponentPrivate->sAPP1.pMarkerBuffer, pComponentPrivate->sAPP1.nMarkerSize);
2455            i += pComponentPrivate->sAPP1.nMarkerSize / 4;
2456            if (pComponentPrivate->sAPP1.nMarkerSize % 4) {
2457            	i ++;
2458            }
2459        }
2460
2461        /* if thumbnail is set, configure it accordingly */
2462        if (pComponentPrivate->sAPP1.nThumbnailWidth > 0 && pComponentPrivate->sAPP1.nThumbnailHeight > 0) {
2463            new_params[i++] = APP1_THUMB_INDEX;
2464            new_params[i++] = 4;
2465            new_params[i++] = 1;
2466
2467            new_params[i++] = APP1_THUMB_W;
2468            new_params[i++] = 4;
2469            new_params[i++] = pComponentPrivate->sAPP1.nThumbnailWidth;
2470
2471            new_params[i++] = APP1_THUMB_H;
2472            new_params[i++] = 4;
2473            new_params[i++] = pComponentPrivate->sAPP1.nThumbnailHeight;
2474        }
2475    }
2476
2477
2478    /* handle APP5 marker */
2479    if(pComponentPrivate->sAPP5.bMarkerEnabled) {
2480        new_params[i++] = APP5_NUMBUF;
2481        new_params[i++] = 4;
2482        new_params[i++] = 1;
2483
2484        /* set default APP5 BUFFER */
2485        new_params[i++] = APP5_BUFFER;
2486
2487        /* if explicity specified by application, set the marker from algo, otherwise set it from application */
2488        if (pComponentPrivate->sAPP5.nMarkerSize <= 0) {
2489            new_params[i++] = 8;
2490            new_params[i++] = 0;
2491            new_params[i++] = 'F' | 'F' << 8 | 'F' << 16 | 'F' << 24;
2492        }
2493        else {
2494            new_params[i++] = pComponentPrivate->sAPP5.nMarkerSize;
2495            memcpy(new_params + i, pComponentPrivate->sAPP5.pMarkerBuffer, pComponentPrivate->sAPP5.nMarkerSize);
2496            i += pComponentPrivate->sAPP5.nMarkerSize / 4;
2497            if (pComponentPrivate->sAPP5.nMarkerSize % 4) {
2498            	i ++;
2499            }
2500        }
2501
2502        /* if thumbnail is set, configure it accordingly */
2503        if (pComponentPrivate->sAPP5.nThumbnailWidth > 0 && pComponentPrivate->sAPP5.nThumbnailHeight > 0) {
2504            new_params[i++] = APP5_THUMB_INDEX;
2505            new_params[i++] = 4;
2506            new_params[i++] = 1;
2507
2508            new_params[i++] = APP5_THUMB_W;
2509            new_params[i++] = 4;
2510            new_params[i++] = pComponentPrivate->sAPP5.nThumbnailWidth;
2511
2512            new_params[i++] = APP5_THUMB_H;
2513            new_params[i++] = 4;
2514            new_params[i++] = pComponentPrivate->sAPP5.nThumbnailHeight;
2515        }
2516    }
2517
2518
2519    /* handle APP13 marker */
2520    if(pComponentPrivate->sAPP13.bMarkerEnabled) {
2521        new_params[i++] = APP13_NUMBUF;
2522        new_params[i++] = 4;
2523        new_params[i++] = 1;
2524
2525        /* set default APP13 BUFFER */
2526        new_params[i++] = APP13_BUFFER;
2527
2528        /* if explicity specified by application, set the marker from algo, otherwise set it from application */
2529        if (pComponentPrivate->sAPP13.nMarkerSize <= 0) {
2530            new_params[i++] = 8;
2531            new_params[i++] = 0;
2532            new_params[i++] = 'F' | 'F' << 8 | 'F' << 16 | 'F' << 24;
2533        }
2534        else {
2535            new_params[i++] = pComponentPrivate->sAPP13.nMarkerSize;
2536            memcpy(new_params + i, pComponentPrivate->sAPP13.pMarkerBuffer, pComponentPrivate->sAPP13.nMarkerSize);
2537            i += pComponentPrivate->sAPP13.nMarkerSize / 4;
2538            if (pComponentPrivate->sAPP13.nMarkerSize % 4) {
2539            	i ++;
2540            }
2541        }
2542    }
2543
2544    new_params[i++] = COMMENT_BUFFER;
2545
2546    /* handle CommentFlag */
2547    if (pComponentPrivate->nCommentFlag == 1 && pComponentPrivate->pString_Comment) {
2548        new_params[i++] = strlen((char *)pComponentPrivate->pString_Comment)  + 4 ;
2549        new_params[i++] = 0;
2550        strncpy((char *)(new_params+i), (char *)pComponentPrivate->pString_Comment, 255);
2551    }
2552    else {
2553        new_params[i++] = 4;
2554        new_params[i++] = 0;
2555    }
2556
2557    /* now that we know the final size of the buffer, we can set it accordingly */
2558    new_params[0] = i * sizeof(OMX_U32);
2559
2560/*
2561    printf("=========DUMP of new_params array=============\n");
2562    int j;
2563    for (j=0; j< i*4; j++) {
2564    printf("new_params[%d] = 0x%x\n", j, *(((unsigned char *)new_params)+j));
2565    }
2566    printf("================================\n");
2567*/
2568    return eError;
2569}
2570
2571OMX_ERRORTYPE SetJpegEncInParams(JPEGENC_COMPONENT_PRIVATE *pComponentPrivate)
2572{
2573    OMX_ERRORTYPE eError = OMX_ErrorNone;
2574    OMX_U8 *p = NULL;
2575    OMX_U32 params_size;
2576
2577    if (pComponentPrivate->InParams.pInParams) {
2578        p = (OMX_U8 *)pComponentPrivate->InParams.pInParams;
2579        p -= 128;
2580        OMX_FREE(p);
2581        pComponentPrivate->InParams.pInParams = NULL;
2582    }
2583
2584   /*alloc enough memory for params array*/
2585    params_size = CalculateParamsSize(pComponentPrivate);
2586    OMX_MALLOC(p, params_size + 256);
2587    p += 128;
2588    pComponentPrivate->InParams.pInParams = (OMX_U32 *)p;
2589    p = NULL;
2590    eError = SetJpegEncInPortParams(pComponentPrivate, pComponentPrivate->InParams.pInParams);
2591
2592EXIT:
2593    return eError;
2594}
2595
2596OMX_ERRORTYPE HandleJpegEncDataBuf_FromApp(JPEGENC_COMPONENT_PRIVATE *pComponentPrivate )
2597{
2598    OMX_ERRORTYPE eError = OMX_ErrorNone;
2599    OMX_BUFFERHEADERTYPE* pBuffHead = NULL;
2600    LCML_DSP_INTERFACE* pLcmlHandle = NULL;
2601    OMX_PARAM_PORTDEFINITIONTYPE* pPortDefIn = NULL;
2602    OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = NULL;
2603    JPEGENC_BUFFER_PRIVATE* pBuffPrivate = NULL;
2604    int ret;
2605
2606    OMX_CHECK_PARAM(pComponentPrivate);
2607
2608    pLcmlHandle = (LCML_DSP_INTERFACE*)pComponentPrivate->pLCML;
2609    pPortDefIn = pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef;
2610    pPortDefOut = pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef;
2611
2612    OMX_PRINT1(pComponentPrivate->dbg, "Inside HandleDataBuf_FromApp function\n");
2613    ret = read(pComponentPrivate->filled_inpBuf_Q[0], &(pBuffHead), sizeof(pBuffHead));
2614    if ( ret == -1 ) {
2615        OMX_PRCOMM4(pComponentPrivate->dbg, "Error while reading from the pipe\n");
2616    }
2617
2618    if (pBuffHead != NULL) {
2619        pBuffPrivate = pBuffHead->pInputPortPrivate;
2620    } else {
2621        eError = OMX_ErrorInsufficientResources;
2622          goto EXIT;
2623        }
2624
2625   if (pBuffPrivate->eBufferOwner == JPEGENC_BUFFER_CLIENT) {
2626        /* already returned to client */
2627        OMX_PRBUFFER4(pComponentPrivate->dbg, "this buffer %p already returned to client\n", pBuffHead);
2628        goto EXIT;
2629    }
2630
2631   if ((pComponentPrivate->nCurState != OMX_StateExecuting) ||
2632       (pComponentPrivate->nToState == OMX_StateIdle) ||
2633        (pPortDefIn->bEnabled == OMX_FALSE)) {
2634            if (pBuffPrivate->eBufferOwner != JPEGENC_BUFFER_CLIENT) {
2635                pComponentPrivate->nInPortOut ++;
2636                pBuffPrivate->eBufferOwner = JPEGENC_BUFFER_CLIENT;
2637                OMX_PRBUFFER1(pComponentPrivate->dbg, "buffer summary (return empty input buffer) %lu %lu %lu %lu\n",
2638                    pComponentPrivate->nInPortIn,
2639                    pComponentPrivate->nInPortOut,
2640                    pComponentPrivate->nOutPortIn,
2641                    pComponentPrivate->nOutPortOut);
2642                pComponentPrivate->cbInfo.EmptyBufferDone(
2643                           pComponentPrivate->pHandle,
2644                           pComponentPrivate->pHandle->pApplicationPrivate,
2645                           pBuffHead);
2646             }
2647             goto EXIT;
2648    }
2649
2650    OMX_PRBUFFER1(pComponentPrivate->dbg, "buffer summary (HandleJpegEncDataBuf_FromApp) %lu %lu %lu %lu\n",
2651                    pComponentPrivate->nInPortIn,
2652                    pComponentPrivate->nInPortOut,
2653                    pComponentPrivate->nOutPortIn,
2654                    pComponentPrivate->nOutPortOut);
2655
2656#ifdef __PERF_INSTRUMENTATION__
2657    PERF_SendingFrame(pComponentPrivate->pPERFcomp,
2658                      pBuffHead->pBuffer,
2659                      pBuffHead->nFilledLen,
2660                      PERF_ModuleCommonLayer);
2661#endif
2662
2663    if ((pBuffHead->nFlags == OMX_BUFFERFLAG_EOS) && (pBuffHead->nAllocLen == 0)) {
2664            OMX_PRBUFFER2(pComponentPrivate->dbg, "BufferFlag Set!!\n");
2665            pComponentPrivate->nFlags = OMX_BUFFERFLAG_EOS;
2666        pBuffHead->nFlags = 0;
2667    }
2668#if 0
2669    eError = SendDynamicParam(pComponentPrivate);
2670    if (eError != OMX_ErrorNone ) {
2671            OMX_PRDSP4(pComponentPrivate->dbg, "SETSTATUS failed...  %x\n", eError);
2672            goto EXIT;
2673    }
2674#endif
2675
2676    OMX_PRBUFFER1(pComponentPrivate->dbg, "pBuffHead->nAllocLen = %d\n",(int)pBuffHead->nAllocLen);
2677    OMX_PRBUFFER1(pComponentPrivate->dbg, "pBuffHead->pBuffer = %p\n",pBuffHead->pBuffer);
2678    OMX_PRBUFFER1(pComponentPrivate->dbg, "pBuffHead->nFilledLen = %d\n",(int)pBuffHead->nFilledLen);
2679    OMX_PRBUFFER1(pComponentPrivate->dbg, "pBuffHead = %p\n",pBuffHead);
2680
2681    pBuffPrivate->eBufferOwner = JPEGENC_BUFFER_DSP;
2682
2683    OMX_PRDSP2(pComponentPrivate->dbg, "Input: before queue buffer %p\n", pBuffHead);
2684        eError = LCML_QueueBuffer(
2685                                  pLcmlHandle->pCodecinterfacehandle,
2686                                  EMMCodecInputBuffer,
2687                                  pBuffHead->pBuffer,
2688                                  pPortDefIn->nBufferSize,
2689                                  pBuffHead->nFilledLen,
2690                                  (OMX_U8 *) pComponentPrivate->InParams.pInParams,
2691                                  pComponentPrivate->InParams.pInParams[0],
2692                                  (OMX_U8 *)pBuffHead);
2693
2694    OMX_PRDSP2(pComponentPrivate->dbg, "Input: after queue buffer %p\n", pBuffHead);
2695
2696    if ( eError ) {
2697        eError = OMX_ErrorInsufficientResources;
2698        OMX_PRDSP4(pComponentPrivate->dbg, "OMX_ErrorInsufficientResources\n");
2699        goto EXIT;
2700    }
2701    OMX_PRINT1(pComponentPrivate->dbg, "Error is %x\n",eError);
2702    EXIT:
2703
2704    return eError;
2705}
2706
2707
2708OMX_ERRORTYPE HandleJpegEncDataBuf_FromDsp(JPEGENC_COMPONENT_PRIVATE *pComponentPrivate, OMX_BUFFERHEADERTYPE* pBuffHead)
2709{
2710
2711    OMX_ERRORTYPE eError                 = OMX_ErrorNone;
2712    OMX_BUFFERHEADERTYPE* pInpBuf        = NULL;
2713    JPEGENC_BUFFER_PRIVATE* pBuffPrivate = NULL;
2714
2715    OMX_CHECK_PARAM(pComponentPrivate);
2716
2717    pInpBuf = pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pBufferPrivate[0]->pBufferHdr;
2718
2719    pBuffPrivate = pBuffHead->pOutputPortPrivate;
2720
2721        if (pBuffPrivate->eBufferOwner == JPEGENC_BUFFER_CLIENT) {
2722           OMX_PRBUFFER2(pComponentPrivate->dbg, "buffer %p already at the client side\n", pBuffHead);
2723           pComponentPrivate->nOutPortOut --;
2724           OMX_PRBUFFER1(pComponentPrivate->dbg, "buffer summary (FromDsp escape return output buffer) %lu %lu %lu %lu\n",
2725                                        pComponentPrivate->nInPortIn,
2726                                        pComponentPrivate->nInPortOut,
2727                                        pComponentPrivate->nOutPortIn,
2728                                        pComponentPrivate->nOutPortOut);
2729
2730           goto EXIT;
2731        }
2732
2733#ifdef __PERF_INSTRUMENTATION__
2734        PERF_SendingFrame(pComponentPrivate->pPERFcomp,
2735                          pBuffHead->pBuffer,
2736                          pBuffHead->nFilledLen,
2737                          PERF_ModuleHLMM);
2738#endif
2739    pBuffPrivate->eBufferOwner = JPEGENC_BUFFER_CLIENT;
2740
2741        if (pBuffHead->pMarkData) {
2742           OMX_PRBUFFER2(pComponentPrivate->dbg, "get Mark buffer %p %p %p\n", pBuffHead->pMarkData, pBuffHead->hMarkTargetComponent, pComponentPrivate->pHandle);
2743        }
2744
2745        if (pBuffHead->pMarkData && pBuffHead->hMarkTargetComponent == pComponentPrivate->pHandle) {
2746           OMX_PRBUFFER2(pComponentPrivate->dbg, "send OMX_MarkEvent\n");
2747           pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
2748                                                pComponentPrivate->pHandle->pApplicationPrivate,
2749                                                OMX_EventMark,
2750                                                JPEGENC_OUT_PORT,
2751                                                0,
2752                                                pBuffHead->pMarkData);
2753        }
2754
2755    OMX_PRBUFFER1(pComponentPrivate->dbg, "buffer summary (return empty output buffer) %lu %lu %lu %lu\n",
2756                    pComponentPrivate->nInPortIn,
2757                    pComponentPrivate->nInPortOut,
2758                    pComponentPrivate->nOutPortIn,
2759                    pComponentPrivate->nOutPortOut);
2760    OMX_PRBUFFER1(pComponentPrivate->dbg, "Output: before fillbufferdone %p\n", pBuffHead);
2761        pComponentPrivate->cbInfo.FillBufferDone(pComponentPrivate->pHandle,
2762                        pComponentPrivate->pHandle->pApplicationPrivate,
2763                        pBuffHead);
2764
2765    if ( pComponentPrivate->nFlags & OMX_BUFFERFLAG_EOS )   {
2766
2767        pBuffHead->nFlags |= OMX_BUFFERFLAG_EOS;
2768        pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
2769                                                pComponentPrivate->pHandle->pApplicationPrivate,
2770                                                OMX_EventBufferFlag,
2771                                                JPEGENC_OUT_PORT,
2772                                                OMX_BUFFERFLAG_EOS,
2773                                                NULL);
2774
2775        pComponentPrivate->nFlags = 0;
2776    }
2777
2778    EXIT:
2779    return eError;
2780}
2781
2782
2783
2784OMX_ERRORTYPE HandleJpegEncFreeDataBuf( JPEGENC_COMPONENT_PRIVATE *pComponentPrivate, OMX_BUFFERHEADERTYPE* pBuffHead )
2785{
2786    OMX_ERRORTYPE eError = OMX_ErrorNone;
2787    OMX_PARAM_PORTDEFINITIONTYPE* pPortDefIn = NULL;
2788    JPEGENC_BUFFER_PRIVATE* pBuffPrivate = NULL;
2789    OMX_HANDLETYPE hTunnelComponent = pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->hTunnelComponent;
2790
2791    OMX_CHECK_PARAM(pComponentPrivate);
2792    OMX_PRINT1(pComponentPrivate->dbg, "Inside HandleFreeDataBuf function \n");
2793    pPortDefIn = pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef;
2794
2795    /* pBuffHead->nAllocLen = pPortDefIn->nBufferSize; */
2796    pBuffPrivate = pBuffHead->pInputPortPrivate;
2797
2798    OMX_PRCOMM2(pComponentPrivate->dbg, "hTunnelComponent = %p\n" ,hTunnelComponent );
2799    OMX_PRINT1(pComponentPrivate->dbg, "pComponentPrivate->pHandle = %p\n",pComponentPrivate->pHandle);
2800
2801    if (pBuffPrivate->eBufferOwner == JPEGENC_BUFFER_CLIENT) {
2802        OMX_PRBUFFER2(pComponentPrivate->dbg, "buffer %p already at the client side\n", pBuffHead);
2803        pComponentPrivate->nInPortOut --;
2804        OMX_PRBUFFER1(pComponentPrivate->dbg, "buffer summary (FromDsp escape return input buffer) %lu %lu %lu %lu\n",
2805                                        pComponentPrivate->nInPortIn,
2806                                        pComponentPrivate->nInPortOut,
2807                                        pComponentPrivate->nOutPortIn,
2808                                        pComponentPrivate->nOutPortOut);
2809
2810           goto EXIT;
2811    }
2812
2813    if(hTunnelComponent != NULL)
2814    {
2815
2816#ifdef __PERF_INSTRUMENTATION__
2817            PERF_SendingFrame(pComponentPrivate->pPERFcomp,
2818                              pBuffHead->pBuffer,
2819                              0,
2820                              PERF_ModuleLLMM);
2821#endif
2822    pBuffPrivate->eBufferOwner = JPEGENC_BUFFER_TUNNEL_COMPONENT;
2823        eError = OMX_FillThisBuffer(hTunnelComponent, pBuffHead);
2824
2825    }
2826    else {
2827
2828#ifdef __PERF_INSTRUMENTATION__
2829            PERF_SendingFrame(pComponentPrivate->pPERFcomp,
2830                              pBuffHead->pBuffer,
2831                              0,
2832                              PERF_ModuleHLMM);
2833#endif
2834        pBuffPrivate->eBufferOwner = JPEGENC_BUFFER_CLIENT;
2835        OMX_PRBUFFER2(pComponentPrivate->dbg, "before emptybufferdone in HandleJpegEncFreeDataBuf %p\n", pBuffHead);
2836        pComponentPrivate->cbInfo.EmptyBufferDone(
2837                 pComponentPrivate->pHandle,
2838                 pComponentPrivate->pHandle->pApplicationPrivate,
2839                 pBuffHead);
2840    }
2841
2842    EXIT:
2843    return eError;
2844
2845}
2846
2847
2848/* -------------------------------------------------------------------*/
2849/**
2850  *  Callback() function will be called LCML component to write the msg
2851  *
2852  * @param msgBuffer                 This buffer will be returned by the LCML
2853  *
2854  * @retval OMX_NoError              Success, ready to roll
2855  *         OMX_Error_BadParameter   The input parameter pointer is null
2856 **/
2857/*-------------------------------------------------------------------*/
2858OMX_ERRORTYPE JpegEncLCML_Callback (TUsnCodecEvent event,void * argsCb [10])
2859{
2860    OMX_ERRORTYPE eError = OMX_ErrorNone;
2861    JPEGENC_BUFFER_PRIVATE *pBuffPrivate = NULL;
2862    JPEG_PORT_TYPE *pPortType = NULL;
2863    int i;
2864
2865    JPEGENC_COMPONENT_PRIVATE *pComponentPrivate = NULL;
2866    OMX_COMPONENTTYPE *pHandle = NULL;
2867
2868    if ( ((LCML_DSP_INTERFACE*)argsCb[6] ) != NULL ) {
2869        pComponentPrivate = (JPEGENC_COMPONENT_PRIVATE*)((LCML_DSP_INTERFACE*)argsCb[6])->pComponentPrivate;
2870        OMX_CHECK_PARAM(pComponentPrivate);
2871
2872        pHandle = (OMX_COMPONENTTYPE *)pComponentPrivate->pHandle;
2873    }
2874    else {
2875        OMXDBG_PRINT(stderr, DSP, 5, 0, "wrong in LCML callback, exit\n");
2876	 goto EXIT;
2877    }
2878    OMX_PRDSP0(pComponentPrivate->dbg, "Event = %d\n", event);
2879
2880    if ( event == EMMCodecBufferProcessed ) {
2881    if ( (int)argsCb [0] == EMMCodecOuputBuffer ) {
2882        OMX_BUFFERHEADERTYPE* pBuffHead = (OMX_BUFFERHEADERTYPE*)argsCb[7];
2883        pBuffPrivate = pBuffHead->pOutputPortPrivate;
2884
2885        pComponentPrivate->nOutPortOut ++;
2886#ifdef __PERF_INSTRUMENTATION__
2887        PERF_ReceivedFrame(pComponentPrivate->pPERFcomp,
2888                           PREF(pBuffHead,pBuffer),
2889                           PREF(pBuffHead,nFilledLen),
2890                           PERF_ModuleCommonLayer);
2891#endif
2892        OMX_PRDSP1(pComponentPrivate->dbg, "argsCb[8] is %d\n", (int)(argsCb[8]));
2893        pBuffHead->nFilledLen = (OMX_U32) argsCb[8];
2894
2895        OMX_PRBUFFER1(pComponentPrivate->dbg, "buffer summary (LCML for output buffer %p) %lu %lu %lu %lu\n", pBuffHead,
2896                    pComponentPrivate->nInPortIn,
2897                    pComponentPrivate->nInPortOut,
2898                    pComponentPrivate->nOutPortIn,
2899                    pComponentPrivate->nOutPortOut);
2900
2901        pPortType = pComponentPrivate->pCompPort[JPEGENC_INP_PORT];
2902        for (i = 0; i < (int)(pPortType->pPortDef->nBufferCountActual); i ++) {
2903            if (pComponentPrivate->nOutPortOut > 10) {
2904                OMX_PRBUFFER1(pComponentPrivate->dbg, "pPortType->sBufferFlagTrack[i].buffer_id %lu\n", pPortType->sBufferFlagTrack[i].buffer_id);
2905            }
2906            if (pPortType->sBufferFlagTrack[i].buffer_id == pComponentPrivate->nOutPortOut) {
2907                OMX_PRBUFFER1(pComponentPrivate->dbg, "output buffer %lu has flag %lx\n",
2908                           pPortType->sBufferFlagTrack[i].buffer_id,
2909                           pPortType->sBufferFlagTrack[i].flag);
2910                pBuffHead->nFlags = pPortType->sBufferFlagTrack[i].flag;
2911                pPortType->sBufferFlagTrack[i].flag = 0;
2912                pPortType->sBufferFlagTrack[i].buffer_id = 0xFFFFFFFF;
2913                break;
2914            }
2915        }
2916        for (i = 0; i < (int)(pPortType->pPortDef->nBufferCountActual); i ++) {
2917            if (pPortType->sBufferMarkTrack[i].buffer_id == pComponentPrivate->nInPortOut) {
2918                OMX_PRBUFFER1(pComponentPrivate->dbg, "buffer ID %lu has mark (output port)\n", pPortType->sBufferMarkTrack[i].buffer_id);
2919                pBuffHead->pMarkData = pPortType->sBufferMarkTrack[i].pMarkData;
2920                pBuffHead->hMarkTargetComponent = pPortType->sBufferMarkTrack[i].hMarkTargetComponent;
2921                pPortType->sBufferMarkTrack[i].buffer_id = 0xFFFFFFFF;
2922                break;
2923            }
2924        }
2925
2926        OMX_PRDSP2(pComponentPrivate->dbg, "EMMCodec Args -> %x, %p\n", (int)argsCb[1] , (void *)(argsCb[5]));
2927        if (pBuffPrivate->eBufferOwner != JPEGENC_BUFFER_CLIENT) {
2928            OMX_PRBUFFER2(pComponentPrivate->dbg, "return output buffer %p from LCML_Callback (%d)\n",
2929                           pBuffHead,
2930                           pBuffPrivate->eBufferOwner);
2931            pBuffPrivate->eBufferOwner = JPEGENC_BUFFER_COMPONENT_OUT;
2932            OMX_PRBUFFER2(pComponentPrivate->dbg, "LCML_Callback - Filled (output) Data from DSP %p\n", pBuffHead);
2933            eError = HandleJpegEncDataBuf_FromDsp(pComponentPrivate, pBuffHead);
2934        }
2935    }
2936
2937    if ((int) argsCb [0] == EMMCodecInputBuffer ) {
2938        OMX_BUFFERHEADERTYPE* pBuffHead = (OMX_BUFFERHEADERTYPE*)argsCb[7];
2939        pBuffPrivate = pBuffHead->pInputPortPrivate;
2940
2941       pComponentPrivate->nInPortOut ++;
2942        OMX_PRBUFFER2(pComponentPrivate->dbg, "buffer summary (LCML for InputBuffer %p) %lu %lu %lu %lu\n", pBuffHead,
2943                    pComponentPrivate->nInPortIn,
2944                    pComponentPrivate->nInPortOut,
2945                    pComponentPrivate->nOutPortIn,
2946                    pComponentPrivate->nOutPortOut);
2947#ifdef __PERF_INSTRUMENTATION__
2948	PERF_ReceivedFrame(pComponentPrivate->pPERFcomp,
2949			   PREF(pBuffHead,pBuffer),
2950			   0,
2951			   PERF_ModuleCommonLayer);
2952#endif
2953	OMX_PRDSP2(pComponentPrivate->dbg, "EMMCodec Args -> %x, %p\n", (int)argsCb[1] , (void *)(argsCb[5]));
2954        if (pBuffPrivate->eBufferOwner != JPEGENC_BUFFER_CLIENT) {
2955            OMX_PRBUFFER2(pComponentPrivate->dbg, "return input buffer %p from LCML_Callback (%d)\n",
2956                           pBuffHead,
2957                           pBuffPrivate->eBufferOwner);
2958            pBuffPrivate->eBufferOwner = JPEGENC_BUFFER_COMPONENT_OUT;
2959            OMX_PRBUFFER2(pComponentPrivate->dbg, "LCML_Callback - Emptied (input) Data from DSP %p\n", pBuffHead);
2960            eError = HandleJpegEncFreeDataBuf(pComponentPrivate, pBuffHead);
2961        }
2962    }
2963    goto PRINT_EXIT;
2964    } /* end     if ( event == EMMCodecBufferProcessed ) */
2965
2966    if ( event == EMMCodecProcessingStoped ) {
2967        OMX_PRDSP2(pComponentPrivate->dbg, "Entering To EMMCodecProcessingStoped \n");
2968        OMX_PRBUFFER1(pComponentPrivate->dbg, "buffer summary (Stopped) %lu %lu %lu %lu\n",
2969                    pComponentPrivate->nInPortIn,
2970                    pComponentPrivate->nInPortOut,
2971                    pComponentPrivate->nOutPortIn,
2972                    pComponentPrivate->nOutPortOut);
2973        pComponentPrivate->bDSPStopAck = OMX_TRUE;
2974        OMX_PRSTATE2(pComponentPrivate->dbg, "to state is %d\n", pComponentPrivate->nToState);
2975
2976
2977        /* if (pComponentPrivate->nToState == OMX_StateIdle) { */
2978            pComponentPrivate->ExeToIdleFlag |= JPEGE_DSPSTOP;
2979        /* } */
2980
2981        OMX_TRACE1(pComponentPrivate->dbg, "before stop signal\n");
2982
2983        pthread_mutex_lock(&pComponentPrivate->jpege_mutex);
2984        pthread_cond_signal(&pComponentPrivate->stop_cond);
2985        pthread_mutex_unlock(&pComponentPrivate->jpege_mutex);
2986
2987        OMX_TRACE1(pComponentPrivate->dbg, "after stop signal\n");
2988
2989        goto PRINT_EXIT;
2990    }
2991
2992    if ( event == EMMCodecDspError ) {
2993
2994       OMX_PRDSP4(pComponentPrivate->dbg, "in EMMCodecDspError EMMCodec Args -> %x, %x\n", (int)argsCb[4] , (int)argsCb[5]);
2995        if ((int)argsCb[4] == USN_ERR_PROCESS && (int)argsCb[5] == IUALG_ERR_INSUFF_BUFFER) {
2996            OMX_PRDSP4(pComponentPrivate->dbg,
2997                    "DSP Error. The allocated output buffer length is insufficient");
2998           pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
2999                                     pComponentPrivate->pHandle->pApplicationPrivate,
3000                                     OMX_EventError,
3001                                     OMX_ErrorInsufficientResources,
3002                                     OMX_TI_ErrorCritical,
3003                                     "The allocated output buffer length is insufficient");
3004           goto PRINT_EXIT;
3005       }
3006       if ((int)argsCb[4] != 0x1 || (int)argsCb[5] != 0x500) {
3007		   if ((int)argsCb[5] == JPEGENC_THUMBNAIL_ABSENT_WARNING) {
3008	           OMX_PRDSP4(pComponentPrivate->dbg, "Thumbnail is not generated as it \
3009	                   exceeds 64K spec size limit for the given thumbnail resolution and yuv data\n");
3010	           pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
3011	                                     pComponentPrivate->pHandle->pApplicationPrivate,
3012	                                     OMX_EventError,
3013	                                     OMX_ErrorUndefined,
3014	                                     OMX_TI_ErrorMinor,
3015	                                     "Thumbnail not generated as it exceeds 64K size limit set by spec");
3016		       goto EXIT;
3017		   }
3018           pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
3019                                     pComponentPrivate->pHandle->pApplicationPrivate,
3020                                     OMX_EventError,
3021                                     OMX_ErrorHardware,
3022                                     OMX_TI_ErrorCritical,
3023                                     NULL);
3024
3025            pComponentPrivate->nCurState = OMX_StateInvalid;
3026            pComponentPrivate->cbInfo.EventHandler(pHandle,
3027                                                   pHandle->pApplicationPrivate,
3028                                                   OMX_EventError,
3029                                                   OMX_ErrorInvalidState,
3030                                                   OMX_TI_ErrorCritical,
3031                                                   "DSP Hardware Error");
3032           goto PRINT_EXIT;
3033       }
3034#ifdef DSP_MMU_FAULT_HANDLING
3035        /* Cheking for MMU_fault */
3036        if((argsCb[4] == (void *)NULL) && (argsCb[5] == (void*)NULL)) {
3037            //JPEGENC_DPRINT("DSP MMU_Fault");
3038            pComponentPrivate->nCurState = OMX_StateInvalid;
3039            pComponentPrivate->cbInfo.EventHandler(pHandle,
3040                                                   pHandle->pApplicationPrivate,
3041                                                   OMX_EventError,
3042                                                   OMX_ErrorInvalidState,
3043                                                   OMX_TI_ErrorCritical,
3044                                                   "DSP MMU FAULT");
3045        }
3046#endif
3047    }
3048    if (event == EMMCodecInternalError) {
3049        eError = OMX_ErrorHardware;
3050        OMX_PRDSP4(pComponentPrivate->dbg, "JPEG-E: EMMCodecInternalError\n");
3051        pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
3052                                               pComponentPrivate->pHandle->pApplicationPrivate,
3053                                               OMX_EventError,
3054                                               OMX_ErrorHardware,
3055                                               OMX_TI_ErrorCritical,
3056                                               NULL);
3057        goto PRINT_EXIT;
3058    }
3059    if ( event == EMMCodecProcessingPaused ) {
3060        OMX_PRDSP2(pComponentPrivate->dbg, "ENTERING TO EMMCodecProcessingPaused JPEG Encoder\n");
3061        if (pComponentPrivate != NULL) {
3062            pComponentPrivate->bDSPStopAck = OMX_TRUE;
3063            pComponentPrivate->nCurState = OMX_StatePause;
3064            /* Decrement reference count with signal enabled */
3065            if(RemoveStateTransition(pComponentPrivate, 1) != OMX_ErrorNone) {
3066                  return OMX_ErrorUndefined;
3067            }
3068            pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,pComponentPrivate->pHandle->pApplicationPrivate,
3069                                                   OMX_EventCmdComplete, OMX_CommandStateSet, pComponentPrivate->nCurState, NULL);
3070        }
3071    }
3072    if (event == EMMCodecStrmCtrlAck) {
3073        OMX_PRDSP2(pComponentPrivate->dbg, "EMMCodecStrmCtrlAck\n");
3074        if ((int)argsCb [0] == USN_ERR_NONE) {
3075            OMX_PRDSP2(pComponentPrivate->dbg, "Callback: no error\n");
3076            pComponentPrivate->bFlushComplete = OMX_TRUE;
3077            pthread_mutex_lock(&pComponentPrivate->jpege_mutex);
3078            pthread_cond_signal(&pComponentPrivate->flush_cond);
3079            pthread_mutex_unlock(&pComponentPrivate->jpege_mutex);
3080        }
3081    }
3082    if (event == EMMCodecAlgCtrlAck) {
3083        OMX_PRDSP2(pComponentPrivate->dbg, "jpeg-enc: EMMCodecAlgCtrlAck\n");
3084        pComponentPrivate->bAckFromSetStatus = 1;
3085        /*
3086        pthread_mutex_lock(&pComponentPrivate->jpege_mutex);
3087        pthread_cond_signal(&pComponentPrivate->control_cond);
3088        pthread_mutex_unlock(&pComponentPrivate->jpege_mutex);
3089        */
3090    }
3091PRINT_EXIT:
3092    OMX_PRDSP1(pComponentPrivate->dbg, "Exiting the LCML_Callback function\n");
3093EXIT:
3094    return eError;
3095}
3096/*-------------------------------------------------------------------*/
3097/**
3098  * IsTIOMXComponent()
3099  *
3100  * Check if the component is TI component.
3101  *
3102  * @param hTunneledComp Component Tunnel Pipe
3103  *
3104  * @retval OMX_TRUE   Input is a TI component.
3105  *         OMX_FALSE  Input is a not a TI component.
3106  *
3107  **/
3108/*-------------------------------------------------------------------*/
3109OMX_BOOL IsTIOMXComponent(OMX_HANDLETYPE hComp)
3110{
3111    OMX_ERRORTYPE eError = OMX_ErrorNone;
3112    OMX_STRING pTunnelcComponentName = NULL;
3113    OMX_VERSIONTYPE* pTunnelComponentVersion = NULL;
3114    OMX_VERSIONTYPE* pSpecVersion = NULL;
3115    OMX_UUIDTYPE* pComponentUUID = NULL;
3116    char *pSubstring = NULL;
3117    OMX_BOOL bResult = OMX_TRUE;
3118
3119    OMX_MALLOC(pTunnelcComponentName, 128);
3120    OMX_MALLOC(pTunnelComponentVersion, sizeof(OMX_VERSIONTYPE));
3121    OMX_MALLOC(pSpecVersion, sizeof(OMX_VERSIONTYPE));
3122    OMX_MALLOC(pComponentUUID, sizeof(OMX_UUIDTYPE));
3123
3124    eError = OMX_GetComponentVersion (hComp, pTunnelcComponentName, pTunnelComponentVersion, pSpecVersion, pComponentUUID);
3125
3126    /* Check if tunneled component is a TI component */
3127    pSubstring = strstr(pTunnelcComponentName, "OMX.TI.");
3128    if(pSubstring == NULL) {
3129        bResult = OMX_FALSE;
3130    }
3131
3132EXIT:
3133    OMX_FREE(pTunnelcComponentName);
3134    OMX_FREE(pTunnelComponentVersion);
3135    OMX_FREE(pSpecVersion);
3136    OMX_FREE(pComponentUUID);
3137    return bResult;
3138} /* End of IsTIOMXComponent */
3139
3140#ifdef RESOURCE_MANAGER_ENABLED
3141/* ========================================================================== */
3142/**
3143 *  ResourceManagerCallback() - handle callbacks from Resource Manager
3144 * @param cbData    Resource Manager Command Data Structure
3145 * @return: void
3146  **/
3147/* ========================================================================== */
3148
3149void ResourceManagerCallback(RMPROXY_COMMANDDATATYPE cbData)
3150{
3151    OMX_COMMANDTYPE Cmd = OMX_CommandStateSet;
3152    OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE *)cbData.hComponent;
3153    JPEGENC_COMPONENT_PRIVATE *pComponentPrivate = NULL;
3154    OMX_ERRORTYPE RM_Error = *(cbData.RM_Error);
3155
3156    pComponentPrivate = (JPEGENC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
3157    OMX_PRINT1(pComponentPrivate->dbg, "RM_Error = %x\n", RM_Error);
3158
3159    if (RM_Error == OMX_RmProxyCallback_ResourcesPreempted) {
3160
3161        pComponentPrivate->bPreempted = 1;
3162
3163        if (pComponentPrivate->nCurState == OMX_StateExecuting ||
3164            pComponentPrivate->nCurState == OMX_StatePause) {
3165
3166            pComponentPrivate->cbInfo.EventHandler(pComponentPrivate->pHandle,
3167                                                   pComponentPrivate->pHandle->pApplicationPrivate,
3168                                                   OMX_EventError,
3169                                                   OMX_ErrorResourcesPreempted,
3170                                                   OMX_TI_ErrorSevere,
3171                                                   NULL);
3172
3173            pComponentPrivate->nToState = OMX_StateIdle;
3174            OMX_PRSTATE2(pComponentPrivate->dbg, "Component Preempted. Going to IDLE State.\n");
3175        }
3176        else if (pComponentPrivate->nCurState == OMX_StateIdle){
3177            pComponentPrivate->nToState = OMX_StateLoaded;
3178            OMX_PRSTATE2(pComponentPrivate->dbg, "Component Preempted. Going to LOADED State.\n");
3179        }
3180
3181#ifdef __PERF_INSTRUMENTATION__
3182        PERF_SendingCommand(pComponentPrivate->pPERF, Cmd, pComponentPrivate->nToState, PERF_ModuleComponent);
3183#endif
3184
3185        write (pComponentPrivate->nCmdPipe[1], &Cmd, sizeof(Cmd));
3186        write (pComponentPrivate->nCmdDataPipe[1], &(pComponentPrivate->nToState) ,sizeof(OMX_U32));
3187
3188    }
3189    else if (RM_Error == OMX_RmProxyCallback_ResourcesAcquired ){
3190
3191        if (pComponentPrivate->nCurState == OMX_StateWaitForResources) /* Wait for Resource Response */
3192        {
3193            pComponentPrivate->cbInfo.EventHandler (
3194                            pHandle, pHandle->pApplicationPrivate,
3195                            OMX_EventResourcesAcquired, 0,0,
3196                            NULL);
3197
3198            pComponentPrivate->nToState = OMX_StateIdle;
3199
3200#ifdef __PERF_INSTRUMENTATION__
3201            PERF_SendingCommand(pComponentPrivate->pPERF, Cmd, pComponentPrivate->nToState, PERF_ModuleComponent);
3202#endif
3203
3204            write (pComponentPrivate->nCmdPipe[1], &Cmd, sizeof(Cmd));
3205            write (pComponentPrivate->nCmdDataPipe[1], &(pComponentPrivate->nToState) ,sizeof(OMX_U32));
3206            OMX_PRMGR2(pComponentPrivate->dbg, "OMX_RmProxyCallback_ResourcesAcquired.\n");
3207        }
3208	}
3209	else if (RM_Error == OMX_RmProxyCallback_FatalError){
3210
3211		/* Deinitialize the component...no error should be returned from
3212		 * this function. It should clean the system as much as possible */
3213		if ( pComponentPrivate->pLCML != NULL && pComponentPrivate->isLCMLActive) {
3214                	LCML_ControlCodec(((LCML_DSP_INTERFACE*)pComponentPrivate->pLCML)->pCodecinterfacehandle, EMMCodecControlDestroy, NULL);
3215                     	dlclose(pComponentPrivate->pDllHandle);
3216                	pComponentPrivate->pLCML = NULL;
3217                	pComponentPrivate->isLCMLActive = 0;
3218		}
3219
3220		pComponentPrivate->nCurState = OMX_StateInvalid;
3221		pComponentPrivate->cbInfo.EventHandler(pHandle,
3222											   pHandle->pApplicationPrivate,
3223											   OMX_EventError,
3224											   OMX_ErrorInvalidState,
3225											   OMX_TI_ErrorSevere,
3226											   NULL);
3227	}
3228}
3229#endif
3230
3231void LinkedList_Create(LinkedList *LinkedList) {
3232    LinkedList->pRoot = NULL;
3233    pthread_mutex_init(&LinkedList->lock, NULL);
3234}
3235
3236void LinkedList_AddElement(LinkedList *LinkedList, void *pValue) {
3237    /* create new node and fill the value */
3238    Node *pNewNode = (Node *)malloc(sizeof(Node));
3239    if ( pNewNode != NULL ) {
3240        pNewNode->pValue = (void *)pValue;
3241        /*printf("LinkedList:::: Pointer=%p has been added.\n", pNewNode->pValue); */
3242        /* add new node on the root to implement quick FIFO */
3243        /* modify new node pointers */
3244
3245        pthread_mutex_lock(&LinkedList->lock);
3246        if(LinkedList->pRoot == NULL) {
3247            pNewNode->pNextNode = NULL;
3248        }
3249        else {
3250             pNewNode->pNextNode = LinkedList->pRoot;
3251        }
3252        /*modify root */
3253        LinkedList->pRoot = pNewNode;
3254        pthread_mutex_unlock(&LinkedList->lock);
3255    }
3256    else {
3257         ALOGE("Linked list memory allocation failed.\n" );
3258    }
3259}
3260
3261void LinkedList_FreeElement(LinkedList *LinkedList, void *pValue) {
3262    pthread_mutex_lock(&LinkedList->lock);
3263    Node *pNode = LinkedList->pRoot;
3264    Node *pPastNode = NULL;
3265    while (pNode != NULL) {
3266        if (pNode->pValue == pValue) {
3267            Node *pTempNode = pNode->pNextNode;
3268            if(pPastNode == NULL) {
3269                LinkedList->pRoot = pTempNode;
3270            }
3271            else {
3272                pPastNode->pNextNode = pTempNode;
3273            }
3274            /*printf("LinkedList:::: Pointer=%p has been freed\n", pNode->pValue); */
3275            free(pNode->pValue);
3276            pNode->pValue = NULL;
3277            free(pNode);
3278            pNode = NULL;
3279            break;
3280        }
3281        pPastNode = pNode;
3282        pNode = pNode->pNextNode;
3283    }
3284    pthread_mutex_unlock(&LinkedList->lock);
3285}
3286
3287void LinkedList_FreeAll(LinkedList *LinkedList) {
3288    Node *pTempNode;
3289    int nodes = 0;
3290    pthread_mutex_lock(&LinkedList->lock);
3291    while (LinkedList->pRoot != NULL) {
3292        pTempNode = LinkedList->pRoot->pNextNode;
3293        /*printf("LinkedList:::: Pointer=%p has been freed\n", LinkedList->pRoot->pValue); */
3294        if(LinkedList->pRoot->pValue != NULL) {
3295		free(LinkedList->pRoot->pValue);
3296		LinkedList->pRoot->pValue = NULL;
3297	}
3298        free(LinkedList->pRoot);
3299        LinkedList->pRoot = pTempNode;
3300        nodes++;
3301    }
3302    pthread_mutex_unlock(&LinkedList->lock);
3303    /*printf("==================No. of deleted nodes: %d=======================================\n\n", nodes); */
3304}
3305
3306void LinkedList_DisplayAll(LinkedList *LinkedList) {
3307    Node *pNode = LinkedList->pRoot;
3308    int nodes = 0;
3309    printf("\n================== Displaying contents of linked list=%p=====================\n", LinkedList);
3310    printf("root->\n");
3311    while (pNode != NULL) {
3312        printf("[Value=%p, NextNode=%p]->\n", pNode->pValue, pNode->pNextNode);
3313        pNode = pNode->pNextNode;
3314        nodes++;
3315    }
3316    printf("==================No. of existing nodes: %d=======================================\n\n", nodes);
3317}
3318
3319void LinkedList_Destroy(LinkedList *LinkedList) {
3320    pthread_mutex_destroy(&LinkedList->lock);
3321}
3322
3323OMX_ERRORTYPE AddStateTransition(JPEGENC_COMPONENT_PRIVATE* pComponentPrivate) {
3324
3325    OMX_ERRORTYPE eError = OMX_ErrorNone;
3326
3327    if(pthread_mutex_lock(&pComponentPrivate->mutexStateChangeRequest)) {
3328       return OMX_ErrorUndefined;
3329    }
3330
3331    /* Increment state change request reference count */
3332    pComponentPrivate->nPendingStateChangeRequests++;
3333
3334    if(pthread_mutex_unlock(&pComponentPrivate->mutexStateChangeRequest)) {
3335       return OMX_ErrorUndefined;
3336    }
3337
3338    return eError;
3339}
3340
3341OMX_ERRORTYPE RemoveStateTransition(JPEGENC_COMPONENT_PRIVATE* pComponentPrivate, OMX_BOOL bEnableSignal) {
3342    OMX_ERRORTYPE eError = OMX_ErrorNone;
3343
3344     /* Decrement state change request reference count*/
3345    if(pthread_mutex_lock(&pComponentPrivate->mutexStateChangeRequest)) {
3346       return OMX_ErrorUndefined;
3347    }
3348
3349    pComponentPrivate->nPendingStateChangeRequests--;
3350
3351    /* If there are no more pending requests, signal the thread waiting on this*/
3352    if(!pComponentPrivate->nPendingStateChangeRequests && bEnableSignal) {
3353       pthread_cond_signal(&(pComponentPrivate->StateChangeCondition));
3354    }
3355
3356    if(pthread_mutex_unlock(&pComponentPrivate->mutexStateChangeRequest)) {
3357       return OMX_ErrorUndefined;
3358    }
3359
3360    return eError;
3361}
3362