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
98 static OMX_ERRORTYPE HandleJpegEncInternalFlush(JPEGENC_COMPONENT_PRIVATE *pComponentPrivate, OMX_U32 nParam1);
99
100 #ifdef RESOURCE_MANAGER_ENABLED
101 void ResourceManagerCallback(RMPROXY_COMMANDDATATYPE cbData);
102 #endif
103
104 #ifdef UNDER_CE
sleep(DWORD Duration)105 void sleep(DWORD Duration)
106 {
107 Sleep(Duration);
108 }
109 #endif
110
111 /*--------function prototypes ---------------------------------*/
112 OMX_ERRORTYPE JpegEncLCML_Callback (TUsnCodecEvent event,
113 void * args [10]);
114
115 /*-------- Function Implementations ---------------------------------*/
GetJpegEncLCMLHandle(OMX_HANDLETYPE pComponent)116 OMX_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 /*-----------------------------------------------------------------------------*/
JpegEncDisablePort(JPEGENC_COMPONENT_PRIVATE * pComponentPrivate,OMX_U32 nParam1)221 OMX_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);
242 EXIT:
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
JpegEncEnablePort(JPEGENC_COMPONENT_PRIVATE * pComponentPrivate,OMX_U32 nParam1)261 OMX_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 }
323 EXIT:
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 /*-------------------------------------------------------------------*/
JPEGEnc_Start_ComponentThread(OMX_HANDLETYPE pComponent)342 OMX_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 /* -------------------------------------------------------------------------- */
JPEGEnc_Free_ComponentResources(JPEGENC_COMPONENT_PRIVATE * pComponentPrivate)422 OMX_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
542 EXIT:
543 OMX_PRINT1(dbg, "Exiting JPEG FreeComponentresources\n");
544 return eError;
545 }
546
Fill_JpegEncLCMLInitParams(LCML_DSP * lcml_dsp,OMX_U16 arr[],OMX_HANDLETYPE pComponent)547 OMX_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 /*
670 this 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
HandleJpegEncInternalFlush(JPEGENC_COMPONENT_PRIVATE * pComponentPrivate,OMX_U32 nParam1)770 static 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
HandleJpegEncCommandFlush(JPEGENC_COMPONENT_PRIVATE * pComponentPrivate,OMX_U32 nParam1)832 OMX_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
SendDynamicParam(JPEGENC_COMPONENT_PRIVATE * pComponentPrivate)1024 OMX_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
1104 EXIT:
1105 return eError;
1106 }
1107
1108 #ifdef __JPEG_OMX_PPLIB_ENABLED__
SendDynamicPPLibParam(JPEGENC_COMPONENT_PRIVATE * pComponentPrivate,OMX_U32 * ptInputParam)1109 OMX_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
1430 EXIT:
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 /*-------------------------------------------------------------------*/
HandleJpegEncCommand(JPEGENC_COMPONENT_PRIVATE * pComponentPrivate,OMX_U32 nParam1)1449 OMX_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
HandleJpegEncFreeOutputBufferFromApp(JPEGENC_COMPONENT_PRIVATE * pComponentPrivate)2072 OMX_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
CalculateParamsSize(JPEGENC_COMPONENT_PRIVATE * pComponentPrivate)2188 OMX_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
SetJpegEncInPortParams(JPEGENC_COMPONENT_PRIVATE * pComponentPrivate,OMX_U32 * new_params)2363 static 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
SetJpegEncInParams(JPEGENC_COMPONENT_PRIVATE * pComponentPrivate)2571 OMX_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
2592 EXIT:
2593 return eError;
2594 }
2595
HandleJpegEncDataBuf_FromApp(JPEGENC_COMPONENT_PRIVATE * pComponentPrivate)2596 OMX_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
HandleJpegEncDataBuf_FromDsp(JPEGENC_COMPONENT_PRIVATE * pComponentPrivate,OMX_BUFFERHEADERTYPE * pBuffHead)2708 OMX_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
HandleJpegEncFreeDataBuf(JPEGENC_COMPONENT_PRIVATE * pComponentPrivate,OMX_BUFFERHEADERTYPE * pBuffHead)2784 OMX_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 /*-------------------------------------------------------------------*/
JpegEncLCML_Callback(TUsnCodecEvent event,void * argsCb[10])2858 OMX_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 }
3091 PRINT_EXIT:
3092 OMX_PRDSP1(pComponentPrivate->dbg, "Exiting the LCML_Callback function\n");
3093 EXIT:
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 /*-------------------------------------------------------------------*/
IsTIOMXComponent(OMX_HANDLETYPE hComp)3109 OMX_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
3132 EXIT:
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
ResourceManagerCallback(RMPROXY_COMMANDDATATYPE cbData)3149 void 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
LinkedList_Create(LinkedList * LinkedList)3231 void LinkedList_Create(LinkedList *LinkedList) {
3232 LinkedList->pRoot = NULL;
3233 pthread_mutex_init(&LinkedList->lock, NULL);
3234 }
3235
LinkedList_AddElement(LinkedList * LinkedList,void * pValue)3236 void 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
LinkedList_FreeElement(LinkedList * LinkedList,void * pValue)3261 void 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
LinkedList_FreeAll(LinkedList * LinkedList)3287 void 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
LinkedList_DisplayAll(LinkedList * LinkedList)3306 void 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
LinkedList_Destroy(LinkedList * LinkedList)3319 void LinkedList_Destroy(LinkedList *LinkedList) {
3320 pthread_mutex_destroy(&LinkedList->lock);
3321 }
3322
AddStateTransition(JPEGENC_COMPONENT_PRIVATE * pComponentPrivate)3323 OMX_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
RemoveStateTransition(JPEGENC_COMPONENT_PRIVATE * pComponentPrivate,OMX_BOOL bEnableSignal)3341 OMX_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