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_JpegEncoder.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 #ifdef UNDER_CE
54 #include <windows.h>
55 #include <oaf_osal.h>
56 #include <omx_core.h>
57 #else
58 #include <unistd.h>
59 #include <sys/time.h>
60 #include <sys/types.h>
61 #include <sys/ioctl.h>
62 #include <sys/select.h>
63 #include <errno.h>
64 #include <pthread.h>
65 #endif
66
67 #include <string.h>
68 #include <fcntl.h>
69 #include <stdlib.h>
70 #include <stdio.h>
71 #include <dbapi.h>
72
73
74 /*------- Program Header Files ----------------------------------------*/
75
76 #include "OMX_JpegEnc_Utils.h"
77 #include "OMX_JpegEnc_CustomCmd.h"
78
79 #ifdef RESOURCE_MANAGER_ENABLED
80 #include <ResourceManagerProxyAPI.h>
81 #endif
82 /*----------------------Global-----------------------------------*/
83 OMX_STRING cJPEGencName = "OMX.TI.JPEG.encoder";
84 /*--------function prototypes ---------------------------------*/
85 static OMX_ERRORTYPE JPEGENC_SetCallbacks (OMX_HANDLETYPE hComp,
86 OMX_CALLBACKTYPE* pCallBacks,
87 OMX_PTR pAppData);
88
89 static OMX_ERRORTYPE JPEGENC_GetComponentVersion (OMX_HANDLETYPE hComp,
90 OMX_STRING pComponentName,
91 OMX_VERSIONTYPE* pComponentVersion,
92 OMX_VERSIONTYPE* pSpecVersion,
93 OMX_UUIDTYPE* pComponentUUID);
94
95 static OMX_ERRORTYPE JPEGENC_SendCommand (OMX_HANDLETYPE hComponent,
96 OMX_COMMANDTYPE Cmd,
97 OMX_U32 nParam,
98 OMX_PTR pCmdData);
99
100 static OMX_ERRORTYPE JPEGENC_GetParameter (OMX_IN OMX_HANDLETYPE hComponent,
101 OMX_IN OMX_INDEXTYPE nParamIndex,
102 OMX_INOUT OMX_PTR ComponentParameterStructure);
103
104 static OMX_ERRORTYPE JPEGENC_SetParameter (OMX_HANDLETYPE hComp,
105 OMX_INDEXTYPE nParamIndex,
106 OMX_PTR ComponentParameterStructure);
107
108 static OMX_ERRORTYPE JPEGENC_GetConfig (OMX_HANDLETYPE hComp,
109 OMX_INDEXTYPE nConfigIndex,
110 OMX_PTR ComponentConfigStructure);
111
112 static OMX_ERRORTYPE JPEGENC_SetConfig (OMX_HANDLETYPE hComp,
113 OMX_INDEXTYPE nConfigIndex,
114 OMX_PTR ComponentConfigStructure);
115
116 static OMX_ERRORTYPE JPEGENC_EmptyThisBuffer (OMX_HANDLETYPE hComp,
117 OMX_BUFFERHEADERTYPE* pBuffer);
118
119 static OMX_ERRORTYPE JPEGENC_FillThisBuffer (OMX_HANDLETYPE hComp,
120 OMX_BUFFERHEADERTYPE* pBuffer);
121
122 static OMX_ERRORTYPE JPEGENC_GetState (OMX_HANDLETYPE hComp,
123 OMX_STATETYPE* pState);
124
125 static OMX_ERRORTYPE JPEGENC_ComponentTunnelRequest(OMX_IN OMX_HANDLETYPE hComp,
126 OMX_IN OMX_U32 nPort,
127 OMX_IN OMX_HANDLETYPE hTunneledComp,
128 OMX_IN OMX_U32 nTunneledPort,
129 OMX_INOUT OMX_TUNNELSETUPTYPE* pTunnelSetup);
130
131
132 static OMX_ERRORTYPE JPEGENC_VerifyTunnelConnection(JPEG_PORT_TYPE*pPort,
133 OMX_HANDLETYPE hTunneledComp,
134 OMX_PARAM_PORTDEFINITIONTYPE* pPortDef,
135 struct OMX_TI_Debug *dbg);
136
137 static OMX_ERRORTYPE JPEGENC_UseBuffer(OMX_IN OMX_HANDLETYPE hComponent,
138 OMX_INOUT OMX_BUFFERHEADERTYPE** ppBufferHdr,
139 OMX_IN OMX_U32 nPortIndex,
140 OMX_IN OMX_PTR pAppPrivate,
141 OMX_IN OMX_U32 nSizeBytes,
142 OMX_IN OMX_U8* pBuffer);
143
144 static OMX_ERRORTYPE JPEGENC_FreeBuffer(OMX_IN OMX_HANDLETYPE hComponent,
145 OMX_IN OMX_U32 nPortIndex,
146 OMX_IN OMX_BUFFERHEADERTYPE* pBuffer);
147
148 static OMX_ERRORTYPE JPEGENC_ComponentDeInit(OMX_HANDLETYPE pHandle);
149
150 static OMX_ERRORTYPE JPEGENC_AllocateBuffer(OMX_IN OMX_HANDLETYPE hComponent,
151 OMX_INOUT OMX_BUFFERHEADERTYPE** pBuffer,
152 OMX_IN OMX_U32 nPortIndex,
153 OMX_IN OMX_PTR pAppPrivate,
154 OMX_IN OMX_U32 nSizeBytes);
155
156 static void JPEGENC_InitBufferFlagTrack(JPEGENC_COMPONENT_PRIVATE *pComponentPrivate, OMX_U32 nPortIndex);
157
158 #ifdef KHRONOS_1_1
159 static OMX_ERRORTYPE ComponentRoleEnum(
160 OMX_IN OMX_HANDLETYPE hComponent,
161 OMX_OUT OMX_U8 *cRole,
162 OMX_IN OMX_U32 nIndex);
163 #endif
164
165 static OMX_ERRORTYPE JPEGENC_GetExtensionIndex(OMX_IN OMX_HANDLETYPE hComponent,
166 OMX_IN OMX_STRING cParameterName,
167 OMX_OUT OMX_INDEXTYPE* pIndexType);
168
169
170 /*-------- Function Implementations ---------------------------------*/
171
172
JPEGENC_FreeBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_BUFFERHEADERTYPE * pBuffer)173 static OMX_ERRORTYPE JPEGENC_FreeBuffer(OMX_IN OMX_HANDLETYPE hComponent,
174 OMX_IN OMX_U32 nPortIndex,
175 OMX_IN OMX_BUFFERHEADERTYPE* pBuffer)
176 {
177 OMX_COMPONENTTYPE *pHandle = NULL;
178 JPEGENC_COMPONENT_PRIVATE *pComponentPrivate = NULL;
179 OMX_PARAM_PORTDEFINITIONTYPE* pPortDef = NULL;
180 JPEGENC_BUFFER_PRIVATE* pBuffPrivate = NULL;
181 JPEG_PORT_TYPE* pCompPort = NULL;
182 OMX_ERRORTYPE eError = OMX_ErrorNone;
183 char* pTemp = NULL;
184
185 OMX_CHECK_PARAM(hComponent);
186 OMX_CHECK_PARAM(pBuffer);
187
188 pHandle = (OMX_COMPONENTTYPE *) hComponent;
189 pComponentPrivate = (JPEGENC_COMPONENT_PRIVATE *) pHandle->pComponentPrivate;
190 pCompPort = pComponentPrivate->pCompPort[nPortIndex];
191
192 OMX_PRINT1(pComponentPrivate->dbg, "JPEGENC_FreeBuffer %p at port %d\n", pBuffer, (int)nPortIndex);
193
194 #ifdef __PERF_INSTRUMENTATION__
195 /* never frees buffer */
196 PERF_SendingFrame(pComponentPrivate->pPERF,
197 pBuffer->pBuffer,
198 pBuffer->nFilledLen,
199 PERF_ModuleMax);
200 #endif
201
202 pPortDef = pComponentPrivate->pCompPort[nPortIndex]->pPortDef;
203
204 if ( nPortIndex == pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortFormat->nPortIndex ) {
205 pBuffPrivate = pBuffer->pInputPortPrivate;
206 }
207 else if ( nPortIndex == pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortFormat->nPortIndex ) {
208 pBuffPrivate = pBuffer->pOutputPortPrivate;
209 }
210 else {
211 eError = OMX_ErrorBadPortIndex;
212 goto PRINT_EXIT;
213 }
214
215 if (pBuffPrivate->bAllocByComponent == OMX_TRUE) {
216 if (pBuffer->pBuffer) {
217 pTemp = (char*)pBuffer->pBuffer;
218 pTemp -= 128;
219 OMX_FREE(pTemp);
220 pBuffer->pBuffer = NULL;
221 }
222 }
223
224 OMX_FREE(pBuffer);
225
226 if ( pPortDef->bEnabled &&
227 ((pComponentPrivate->nCurState == OMX_StateIdle && pComponentPrivate->nToState != OMX_StateLoaded) ||
228 pComponentPrivate->nCurState == OMX_StateExecuting ||
229 pComponentPrivate->nCurState == OMX_StatePause) ) {
230 pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
231 pComponentPrivate->pHandle->pApplicationPrivate,
232 OMX_EventError,
233 OMX_ErrorPortUnpopulated,
234 OMX_TI_ErrorMinor,
235 "Port Unpopulated");
236 }
237
238 pCompPort->nBuffCount--;
239 OMX_PRBUFFER2(pComponentPrivate->dbg, "JPEGE: bPopulated %d\n", pComponentPrivate->pCompPort[nPortIndex]->pPortDef->bPopulated);
240 if (pCompPort->nBuffCount == 0) {
241 pComponentPrivate->pCompPort[nPortIndex]->pPortDef->bPopulated = OMX_FALSE;
242
243 pthread_mutex_lock(&pComponentPrivate->jpege_mutex_app);
244 pthread_cond_signal(&pComponentPrivate->unpopulate_cond);
245 pthread_mutex_unlock(&pComponentPrivate->jpege_mutex_app);
246
247 JPEGENC_InitBufferFlagTrack(pComponentPrivate, nPortIndex);
248 }
249
250 if ((!pPortDef->bEnabled) &&
251 (!pComponentPrivate->pCompPort[nPortIndex]->pPortDef->bPopulated)) {
252 if ((nPortIndex == 0) && (!pComponentPrivate->bInportDisableIncomplete)) {
253 pComponentPrivate->bInportDisableIncomplete = OMX_TRUE;
254 pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
255 pComponentPrivate->pHandle->pApplicationPrivate,
256 OMX_EventCmdComplete,
257 OMX_CommandPortDisable,
258 JPEGENC_INP_PORT,
259 NULL);
260 }
261 if ((nPortIndex == 1) && (!pComponentPrivate->bOutportDisableIncomplete)) {
262 pComponentPrivate->bOutportDisableIncomplete = OMX_TRUE;
263 pComponentPrivate->cbInfo.EventHandler (pComponentPrivate->pHandle,
264 pComponentPrivate->pHandle->pApplicationPrivate,
265 OMX_EventCmdComplete,
266 OMX_CommandPortDisable,
267 JPEGENC_OUT_PORT,
268 NULL);
269 }
270 }
271
272 PRINT_EXIT:
273 OMX_PRINT1(pComponentPrivate->dbg, "Exit from FreeBuffer\n");
274 EXIT:
275 return eError;
276 }
277
JPEGENC_UseBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_INOUT OMX_BUFFERHEADERTYPE ** ppBufferHdr,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_PTR pAppPrivate,OMX_IN OMX_U32 nSizeBytes,OMX_IN OMX_U8 * pBuffer)278 OMX_ERRORTYPE JPEGENC_UseBuffer(OMX_IN OMX_HANDLETYPE hComponent,
279 OMX_INOUT OMX_BUFFERHEADERTYPE** ppBufferHdr,
280 OMX_IN OMX_U32 nPortIndex,
281 OMX_IN OMX_PTR pAppPrivate,
282 OMX_IN OMX_U32 nSizeBytes,
283 OMX_IN OMX_U8* pBuffer)
284
285 {
286 OMX_COMPONENTTYPE *pHandle = NULL;
287 JPEGENC_COMPONENT_PRIVATE *pComponentPrivate = NULL;
288 OMX_PARAM_PORTDEFINITIONTYPE* pPortDef = NULL;
289 OMX_ERRORTYPE eError = OMX_ErrorNone;
290 OMX_HANDLETYPE hTunnelComponent = NULL;
291 OMX_U32 nBufferCount = -1;
292 OMX_BUFFERHEADERTYPE *pBuffHeader = NULL;
293 int nInpIndex;
294 int nOutIndex;
295
296
297 OMX_CHECK_PARAM(hComponent);
298 OMX_CHECK_PARAM(ppBufferHdr);
299 OMX_CHECK_PARAM(pBuffer);
300
301 if (nPortIndex != 0 && nPortIndex != 1) {
302 eError = OMX_ErrorBadParameter;
303 goto EXIT;
304 }
305
306 pHandle = (OMX_COMPONENTTYPE *)hComponent;
307 pComponentPrivate = (JPEGENC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
308 hTunnelComponent = pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->hTunnelComponent;
309 pPortDef = pComponentPrivate->pCompPort[nPortIndex]->pPortDef;
310 nBufferCount = pComponentPrivate->pCompPort[nPortIndex]->nBuffCount;
311
312 #ifdef __PERF_INSTRUMENTATION__
313 PERF_ReceivedFrame(pComponentPrivate->pPERF,
314 pBuffer,
315 nSizeBytes,
316 PERF_ModuleLLMM);
317 #endif
318
319 pPortDef = pComponentPrivate->pCompPort[nPortIndex]->pPortDef;
320
321
322 nInpIndex = pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortFormat->nPortIndex;
323 nOutIndex = pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortFormat->nPortIndex;
324
325 if ( (int)nPortIndex == nInpIndex ) {
326 OMX_MALLOC(pBuffHeader, sizeof(OMX_BUFFERHEADERTYPE));
327 OMX_CONF_INIT_STRUCT(pBuffHeader, OMX_BUFFERHEADERTYPE);
328 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pBufferPrivate[nBufferCount]->pBufferHdr = pBuffHeader;
329 *ppBufferHdr = pBuffHeader;
330 }
331 else if ( (int)nPortIndex == nOutIndex ) {
332 OMX_MALLOC(pBuffHeader, sizeof(OMX_BUFFERHEADERTYPE));
333 OMX_CONF_INIT_STRUCT(pBuffHeader, OMX_BUFFERHEADERTYPE);
334 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pBufferPrivate[nBufferCount]->pBufferHdr = pBuffHeader;
335 *ppBufferHdr = pBuffHeader;
336 }
337 else {
338 eError = OMX_ErrorBadPortIndex;
339 goto EXIT;
340 }
341
342 /* set relevant fields */
343 (*ppBufferHdr)->nSize = sizeof(OMX_BUFFERHEADERTYPE);
344 (*ppBufferHdr)->nVersion = pPortDef->nVersion;
345 (*ppBufferHdr)->pBuffer = pBuffer;
346 (*ppBufferHdr)->nAllocLen = nSizeBytes;
347 (*ppBufferHdr)->pAppPrivate = pAppPrivate;
348 pComponentPrivate->pCompPort[nPortIndex]->pBufferPrivate[nBufferCount]->bAllocByComponent = OMX_FALSE;
349
350 /* set direction dependent fields */
351 if (hTunnelComponent != NULL) {
352
353 if ( pPortDef->eDir == OMX_DirInput ) {
354 (*ppBufferHdr)->nInputPortIndex = nPortIndex;
355 (*ppBufferHdr)->nOutputPortIndex = pComponentPrivate->pCompPort[nPortIndex]->nTunnelPort;
356 /* pComponentPrivate->pCompPort[nPortIndex]->pBufferPrivate[nBufferCount]->pBufferHdr = (*ppBufferHdr); */
357
358 }
359 else {
360 (*ppBufferHdr)->nOutputPortIndex = nPortIndex;
361 (*ppBufferHdr)->nInputPortIndex = pComponentPrivate->pCompPort[nPortIndex]->nTunnelPort;
362 /* pComponentPrivate->pCompPort[nPortIndex]->pBufferPrivate[nBufferCount]->pBufferHdr = (*ppBufferHdr); */
363 }
364 }
365 else {
366 if (nPortIndex == JPEGENC_INP_PORT) {
367 pBuffHeader->nInputPortIndex = JPEGENC_INP_PORT;
368 pBuffHeader->nOutputPortIndex = OMX_NOPORT;
369 }
370 else {
371 pBuffHeader->nInputPortIndex = OMX_NOPORT;
372 pBuffHeader->nOutputPortIndex = JPEGENC_OUT_PORT;
373 }
374 }
375 if (nPortIndex == JPEGENC_INP_PORT) {
376 pBuffHeader->pInputPortPrivate = pComponentPrivate->pCompPort[nPortIndex]->pBufferPrivate[nBufferCount];
377 }
378 else {
379 pBuffHeader->pOutputPortPrivate = pComponentPrivate->pCompPort[nPortIndex]->pBufferPrivate[nBufferCount];
380 }
381
382 if (pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->hTunnelComponent != NULL) {
383 pComponentPrivate->pCompPort[nPortIndex]->pBufferPrivate[nBufferCount]->eBufferOwner = JPEGENC_BUFFER_TUNNEL_COMPONENT;
384 }
385 else {
386 pComponentPrivate->pCompPort[nPortIndex]->pBufferPrivate[nBufferCount]->eBufferOwner = JPEGENC_BUFFER_CLIENT;
387 }
388
389 if ( nPortIndex == pComponentPrivate->pCompPort[nPortIndex]->pPortFormat->nPortIndex ) {
390 pComponentPrivate->pCompPort[nPortIndex]->nBuffCount++;
391 if (pComponentPrivate->pCompPort[nPortIndex]->nBuffCount == pPortDef->nBufferCountActual) {
392 pPortDef->bPopulated = OMX_TRUE;
393
394 pthread_mutex_lock(&pComponentPrivate->jpege_mutex_app);
395 pthread_cond_signal(&pComponentPrivate->populate_cond);
396 pthread_mutex_unlock(&pComponentPrivate->jpege_mutex_app);
397
398 JPEGENC_InitBufferFlagTrack(pComponentPrivate, nPortIndex);
399 }
400 }
401
402 EXIT:
403 return eError;
404
405 }
406 /*-------------------------------------------------------------------*/
407 /**
408 * OMX_ComponentInit() Set the all the function pointers of component
409 *
410 * This method will update the component function pointer to the handle
411 *
412 * @param hComp handle for this instance of the component
413 *
414 * @retval OMX_NoError Success, ready to roll
415 * OMX_ErrorInsufficientResources If the malloc fails
416 **/
417 /*-------------------------------------------------------------------*/
OMX_ComponentInit(OMX_HANDLETYPE hComponent)418 OMX_ERRORTYPE OMX_ComponentInit (OMX_HANDLETYPE hComponent)
419 {
420 OMX_COMPONENTTYPE *pHandle = NULL;
421 OMX_ERRORTYPE eError = OMX_ErrorNone;
422 JPEGENC_COMPONENT_PRIVATE *pComponentPrivate = NULL;
423 OMX_U8 i = 0;
424
425 /* Allocate memory for component's private data area */
426 OMX_CHECK_PARAM(hComponent);
427
428
429 LinkedList_Create(&AllocList);
430
431 pHandle = (OMX_COMPONENTTYPE *)hComponent;
432 OMX_MALLOC(pHandle->pComponentPrivate, sizeof(JPEGENC_COMPONENT_PRIVATE));
433
434 pComponentPrivate = (JPEGENC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
435
436 /* get default settings for debug */
437 OMX_DBG_INIT(pComponentPrivate->dbg, "OMX_DBG_JPGENC");
438 /* Allocate memory for component's private data area */
439 OMX_PRINT1(pComponentPrivate->dbg, "in jpeg-enc OMX_ComponentInit\n");
440
441 #ifdef __PERF_INSTRUMENTATION__
442 pComponentPrivate->pPERF = PERF_Create(PERF_FOURCC('J','P','E',' '),
443 PERF_ModuleLLMM | PERF_ModuleImageEncode);
444 pComponentPrivate->pPERFcomp = NULL;
445 #endif
446
447 /**Assigning address of Component Structure point to place holder inside comp
448 nentprivate structure
449 */
450 ((JPEGENC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate)->pHandle = pHandle;
451
452 pComponentPrivate->nCurState = OMX_StateLoaded;
453
454 pHandle->SetCallbacks = JPEGENC_SetCallbacks;
455 pHandle->GetComponentVersion = JPEGENC_GetComponentVersion;
456 pHandle->SendCommand = JPEGENC_SendCommand;
457 pHandle->GetParameter = JPEGENC_GetParameter;
458 pHandle->SetParameter = JPEGENC_SetParameter;
459 pHandle->GetConfig = JPEGENC_GetConfig;
460 pHandle->SetConfig = JPEGENC_SetConfig;
461 pHandle->GetState = JPEGENC_GetState;
462 pHandle->EmptyThisBuffer = JPEGENC_EmptyThisBuffer;
463 pHandle->FillThisBuffer = JPEGENC_FillThisBuffer;
464 pHandle->ComponentTunnelRequest = JPEGENC_ComponentTunnelRequest;
465 pHandle->ComponentDeInit = JPEGENC_ComponentDeInit;
466 pHandle->UseBuffer = JPEGENC_UseBuffer ;
467 pHandle->FreeBuffer = JPEGENC_FreeBuffer;
468 pHandle->AllocateBuffer = JPEGENC_AllocateBuffer;
469 pHandle->GetExtensionIndex = JPEGENC_GetExtensionIndex;
470 #ifdef KHRONOS_1_1
471 pHandle->ComponentRoleEnum = ComponentRoleEnum;
472 #endif
473 OMX_PRINT2(pComponentPrivate->dbg, "Inside Component Init JPEG encoder\n");
474 pComponentPrivate->ComponentVersion.s.nVersionMajor = 0x01;
475 pComponentPrivate->ComponentVersion.s.nVersionMinor = 0x00;
476 pComponentPrivate->ComponentVersion.s.nRevision = 0x00;
477 pComponentPrivate->ComponentVersion.s.nStep = 0x00;
478 OMX_MALLOC(pComponentPrivate->cComponentName, COMP_MAX_NAMESIZE+1);
479 strncpy(pComponentPrivate->cComponentName, cJPEGencName, COMP_MAX_NAMESIZE);
480
481 /* Allocate memory for component data structures */
482 OMX_MALLOC(pComponentPrivate->pPortParamType, sizeof(OMX_PORT_PARAM_TYPE));
483 OMX_MALLOC(pComponentPrivate->pPortParamTypeAudio, sizeof(OMX_PORT_PARAM_TYPE));
484 OMX_MALLOC(pComponentPrivate->pPortParamTypeVideo, sizeof(OMX_PORT_PARAM_TYPE));
485 OMX_MALLOC(pComponentPrivate->pPortParamTypeOthers, sizeof(OMX_PORT_PARAM_TYPE));
486 OMX_MALLOC(pComponentPrivate->pCompPort[JPEGENC_INP_PORT], sizeof(JPEG_PORT_TYPE));
487 OMX_MALLOC(pComponentPrivate->pCompPort[JPEGENC_OUT_PORT], sizeof(JPEG_PORT_TYPE));
488 OMX_MALLOC(pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
489 OMX_MALLOC(pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
490 OMX_MALLOC(pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortFormat, sizeof(OMX_IMAGE_PARAM_PORTFORMATTYPE));
491 OMX_MALLOC(pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortFormat, sizeof(OMX_IMAGE_PARAM_PORTFORMATTYPE));
492 OMX_MALLOC(pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pParamBufSupplier, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE));
493 OMX_MALLOC(pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pParamBufSupplier, sizeof(OMX_PARAM_BUFFERSUPPLIERTYPE));
494 OMX_MALLOC(pComponentPrivate->pPriorityMgmt, sizeof(OMX_PRIORITYMGMTTYPE));
495 OMX_MALLOC(pComponentPrivate->pQualityfactor, sizeof(OMX_IMAGE_PARAM_QFACTORTYPE));
496 OMX_MALLOC(pComponentPrivate->pCrop, sizeof(OMX_CONFIG_RECTTYPE));
497 OMX_MALLOC(pComponentPrivate->pCustomLumaQuantTable, sizeof(OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE));
498 OMX_MALLOC(pComponentPrivate->pCustomChromaQuantTable, sizeof(OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE));
499 OMX_MALLOC(pComponentPrivate->pHuffmanTable, sizeof(JPEGENC_CUSTOM_HUFFMANTTABLETYPE));
500 for (i = 0;i<NUM_OF_BUFFERSJPEG;i++) {
501 OMX_MALLOC(pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pBufferPrivate[i], sizeof(JPEGENC_BUFFER_PRIVATE));
502 }
503
504 for (i = 0;i<NUM_OF_BUFFERSJPEG;i++) {
505 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pBufferPrivate[i]->pBufferHdr = NULL;
506 }
507
508 for (i = 0;i<NUM_OF_BUFFERSJPEG;i++) {
509 OMX_MALLOC(pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pBufferPrivate[i], sizeof(JPEGENC_BUFFER_PRIVATE));
510 }
511
512 for (i = 0;i<NUM_OF_BUFFERSJPEG;i++) {
513 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pBufferPrivate[i]->pBufferHdr = NULL;
514 }
515
516 pComponentPrivate->nFlags = 0;
517 pComponentPrivate->isLCMLActive = 0;
518 pComponentPrivate->nCommentFlag = 0;
519 /* pComponentPrivate->nThumbnailFlag = 0; */
520 pComponentPrivate->pMarkData = NULL;
521 pComponentPrivate->hMarkTargetComponent = NULL;
522 pComponentPrivate->pString_Comment = NULL;
523 pComponentPrivate->nDRI_Interval = 0;
524 pComponentPrivate->bSetHuffmanTable = OMX_FALSE;
525 pComponentPrivate->bSetLumaQuantizationTable = OMX_FALSE;
526 pComponentPrivate->bSetChromaQuantizationTable = OMX_FALSE;
527 pComponentPrivate->bConvert420pTo422i = OMX_FALSE;
528 #ifdef __JPEG_OMX_PPLIB_ENABLED__
529 pComponentPrivate->bPPLibEnable = OMX_TRUE;
530 #else
531 pComponentPrivate->bPPLibEnable = OMX_FALSE;
532 #endif
533
534 pComponentPrivate->InParams.pInParams = NULL;
535 pComponentPrivate->InParams.size = 0;
536 pComponentPrivate->bPreempted = OMX_FALSE;
537
538 #ifdef __JPEG_OMX_PPLIB_ENABLED__
539 pComponentPrivate->pOutParams = NULL;
540 #endif
541
542
543 OMX_MALLOC(pComponentPrivate->pDynParams, sizeof(IDMJPGE_TIGEM_DynamicParams)+256);
544 if (!pComponentPrivate->pDynParams) {
545 eError = OMX_ErrorInsufficientResources;
546 goto EXIT;
547 }
548
549 eError = SetJpegEncInParams(pComponentPrivate);
550
551 #ifdef KHRONOS_1_1
552 strcpy((char *)pComponentPrivate->componentRole.cRole, "image_encoder.jpeg");
553 #endif
554
555 /* Set pPortParamType defaults */
556 OMX_CONF_INIT_STRUCT(pComponentPrivate->pPortParamType, OMX_PORT_PARAM_TYPE);
557 pComponentPrivate->pPortParamType->nPorts = NUM_OF_PORTS;
558 pComponentPrivate->pPortParamType->nStartPortNumber = 0;
559
560 OMX_CONF_INIT_STRUCT(pComponentPrivate->pPortParamTypeAudio, OMX_PORT_PARAM_TYPE);
561 pComponentPrivate->pPortParamTypeAudio->nPorts = 0;
562 pComponentPrivate->pPortParamTypeAudio->nStartPortNumber = -1;
563
564 OMX_CONF_INIT_STRUCT(pComponentPrivate->pPortParamTypeVideo, OMX_PORT_PARAM_TYPE);
565 pComponentPrivate->pPortParamTypeVideo->nPorts = 0;
566 pComponentPrivate->pPortParamTypeVideo->nStartPortNumber = -1;
567
568 OMX_CONF_INIT_STRUCT(pComponentPrivate->pPortParamTypeOthers, OMX_PORT_PARAM_TYPE);
569 pComponentPrivate->pPortParamTypeOthers->nPorts = 0;
570 pComponentPrivate->pPortParamTypeOthers->nStartPortNumber = -1;
571
572 /*Set Quality factor structure */
573 /* OMX_CONF_INIT_STRUCT(pComponentPrivate->pQualityfactor, OMX_IMAGE_PARAM_QFACTORTYPE);*/
574
575 /* Set pInPortDef defaults */
576 OMX_CONF_INIT_STRUCT(pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef, OMX_PARAM_PORTDEFINITIONTYPE);
577 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->nPortIndex = JPEGENC_INP_PORT;
578 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->eDir = OMX_DirInput;
579 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->nBufferCountActual = NUM_OF_BUFFERSJPEG;
580 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->nBufferCountMin = 1;
581 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->nBufferSize = 460800; /* 50688; */
582 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->bEnabled = OMX_TRUE;
583 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->bPopulated = OMX_FALSE;
584 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->eDomain = OMX_PortDomainImage;
585
586 pComponentPrivate->isLCMLActive = 0;
587 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->format.image.cMIMEType = "JPEGENC";
588 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->format.image.pNativeRender = NULL;
589 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->format.image.nFrameWidth = 640; /* 176; */
590 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->format.image.nFrameHeight = 480; /* 144; */
591 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->format.image.nStride = -1;
592 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->format.image.nSliceHeight = -1;
593 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->format.image.bFlagErrorConcealment = OMX_FALSE;
594 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->format.image.eCompressionFormat = OMX_IMAGE_CodingUnused; /* OMX_IMAGE_CodingJPEG; */
595 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->format.image.eColorFormat = OMX_COLOR_FormatYUV420PackedPlanar; /* OMX_COLOR_FormatCbYCrY; */
596
597
598 /* Set pOutPortDef defaults */
599 OMX_CONF_INIT_STRUCT(pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef, OMX_PARAM_PORTDEFINITIONTYPE);
600 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef->nPortIndex = JPEGENC_OUT_PORT;
601 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef->eDir = OMX_DirOutput;
602 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef->nBufferCountMin = 1;
603 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef->nBufferCountActual = NUM_OF_BUFFERSJPEG;
604 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef->nBufferSize = 460800; /* 50688; */
605 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef->bEnabled = OMX_TRUE;
606 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef->bPopulated = OMX_FALSE;
607 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef->eDomain = OMX_PortDomainImage;
608 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef->format.image.cMIMEType = "JPEGENC";
609 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef->format.image.pNativeRender = NULL;
610 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef->format.image.nFrameWidth = 640; /* 176; */
611 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef->format.image.nFrameHeight = 480; /* 144; */
612 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef->format.image.nStride = -1;
613 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef->format.image.nSliceHeight = -1;
614 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef->format.image.bFlagErrorConcealment = OMX_FALSE;
615 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef->format.image.eCompressionFormat = OMX_IMAGE_CodingJPEG; /* OMX_IMAGE_CodingUnused; */
616 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef->format.image.eColorFormat = OMX_COLOR_FormatUnused; /* OMX_COLOR_FormatCbYCrY; */
617
618
619 OMX_CONF_INIT_STRUCT(pComponentPrivate->pCustomLumaQuantTable, OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE);
620 pComponentPrivate->pCustomLumaQuantTable->nPortIndex = JPEGENC_OUT_PORT;
621 pComponentPrivate->pCustomLumaQuantTable->eQuantizationTable = OMX_IMAGE_QuantizationTableLuma;
622
623 OMX_CONF_INIT_STRUCT(pComponentPrivate->pCustomChromaQuantTable, OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE);
624 pComponentPrivate->pCustomChromaQuantTable->nPortIndex = JPEGENC_OUT_PORT;
625 pComponentPrivate->pCustomChromaQuantTable->eQuantizationTable = OMX_IMAGE_QuantizationTableChroma;
626
627 OMX_CONF_INIT_STRUCT(pComponentPrivate->pHuffmanTable, JPEGENC_CUSTOM_HUFFMANTTABLETYPE);
628 pComponentPrivate->pHuffmanTable->nPortIndex = JPEGENC_OUT_PORT;
629
630 /* Set pInPortFormat defaults */
631 OMX_CONF_INIT_STRUCT(pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortFormat, OMX_IMAGE_PARAM_PORTFORMATTYPE);
632 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortFormat->nPortIndex = JPEGENC_INP_PORT;
633 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortFormat->nIndex = 0x0;
634 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortFormat->eCompressionFormat = OMX_IMAGE_CodingUnused; /* OMX_IMAGE_CodingJPEG; */
635 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortFormat->eColorFormat = OMX_COLOR_FormatYUV420PackedPlanar; /* OMX_COLOR_FormatCbYCrY; */
636
637 /* Set pOutPortFormat defaults */
638 OMX_CONF_INIT_STRUCT(pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortFormat, OMX_IMAGE_PARAM_PORTFORMATTYPE);
639 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortFormat->nPortIndex = JPEGENC_OUT_PORT;
640 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortFormat->nIndex = 0x0;
641 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortFormat->eCompressionFormat = OMX_IMAGE_CodingJPEG; /* OMX_IMAGE_CodingUnused; */
642 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortFormat->eColorFormat = OMX_COLOR_FormatUnused; /* OMX_COLOR_FormatCbYCrY; */
643
644 /* Set pPriorityMgmt defaults */
645 OMX_CONF_INIT_STRUCT(pComponentPrivate->pPriorityMgmt, OMX_PRIORITYMGMTTYPE);
646 pComponentPrivate->pPriorityMgmt->nGroupPriority = -1;
647 pComponentPrivate->pPriorityMgmt->nGroupID = -1;
648
649 OMX_CONF_INIT_STRUCT(pComponentPrivate->pCrop, OMX_CONFIG_RECTTYPE);
650 OMX_CONF_INIT_STRUCT(pComponentPrivate->pQualityfactor, OMX_IMAGE_PARAM_QFACTORTYPE);
651 pComponentPrivate->pQualityfactor->nPortIndex = 1;
652 pComponentPrivate->pQualityfactor->nQFactor = 100;
653
654 pComponentPrivate->sAPP0.bMarkerEnabled = OMX_FALSE;
655 pComponentPrivate->sAPP1.bMarkerEnabled = OMX_FALSE;
656 pComponentPrivate->sAPP5.bMarkerEnabled = OMX_FALSE;
657 pComponentPrivate->sAPP13.bMarkerEnabled = OMX_FALSE;
658
659 pComponentPrivate->sAPP0.pMarkerBuffer = NULL;
660 pComponentPrivate->sAPP1.pMarkerBuffer = NULL;
661 pComponentPrivate->sAPP5.pMarkerBuffer = NULL;
662 pComponentPrivate->sAPP13.pMarkerBuffer = NULL;
663
664 OMX_CONF_INIT_STRUCT(pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pParamBufSupplier, OMX_PARAM_BUFFERSUPPLIERTYPE);
665 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pParamBufSupplier->nPortIndex = JPEGENC_INP_PORT;
666 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pParamBufSupplier->eBufferSupplier = 0x0;
667
668 /* Set pOutBufSupplier defaults */
669 OMX_CONF_INIT_STRUCT(pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pParamBufSupplier, OMX_PARAM_BUFFERSUPPLIERTYPE);
670 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pParamBufSupplier->nPortIndex = JPEGENC_OUT_PORT;
671 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pParamBufSupplier->eBufferSupplier = 0x0;
672
673
674
675 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pBufSupplier= OMX_BufferSupplyOutput;
676 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->hTunnelComponent = NULL;
677 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->nBuffCount = 0;
678
679
680 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->hTunnelComponent = NULL;
681 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->nBuffCount = 0;
682
683 pthread_mutex_init(&pComponentPrivate->jpege_mutex, NULL);
684 pthread_cond_init(&pComponentPrivate->stop_cond, NULL);
685 pthread_cond_init(&pComponentPrivate->flush_cond, NULL);
686 /* pthread_cond_init(&pComponentPrivate->control_cond, NULL); */
687
688 pthread_mutex_init(&pComponentPrivate->jpege_mutex_app, NULL);
689 pthread_cond_init(&pComponentPrivate->populate_cond, NULL);
690 pthread_cond_init(&pComponentPrivate->unpopulate_cond, NULL);
691
692 if(pthread_mutex_init(&pComponentPrivate->mutexStateChangeRequest, NULL)) {
693 return OMX_ErrorUndefined;
694 }
695
696 if(pthread_cond_init (&pComponentPrivate->StateChangeCondition, NULL)) {
697 return OMX_ErrorUndefined;
698 }
699 pComponentPrivate->nPendingStateChangeRequests = 0;
700
701 #ifdef RESOURCE_MANAGER_ENABLED
702 /* load the ResourceManagerProxy thread */
703 eError = RMProxy_NewInitalizeEx(OMX_COMPONENTTYPE_IMAGE);
704 if ( eError != OMX_ErrorNone ) {
705 OMX_PRMGR4(pComponentPrivate->dbg, "Error returned from loading ResourceManagerProxy thread\n");
706 goto EXIT;
707 }
708
709 #endif
710 eError = JPEGEnc_Start_ComponentThread(pHandle);
711 if (eError) {
712 OMX_PRINT4(pComponentPrivate->dbg, "Error while initializing thread\n");
713 goto EXIT;
714 }
715
716 OMX_PRBUFFER2(pComponentPrivate->dbg, "JPEG-ENC: actual buffer %d\n", (int)(pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->nBufferCountActual));
717 EXIT:
718 if(eError != OMX_ErrorNone){
719 /* LinkedList_DisplayAll (&AllocList); */
720 OMX_FREEALL();
721 LinkedList_Destroy(&AllocList);
722 }
723 return eError;
724 }
725
726
727 /*-------------------------------------------------------------------*/
728 /**
729 * JPEGENC_SetCallbacks() Sets application callbacks to the component
730 *
731 * This method will update application callbacks
732 * the application.
733 *
734 * @param pComponent handle for this instance of the component
735 * @param pCallBacks application callbacks
736 * @param pAppData pointer to application Data
737 *
738 * @retval OMX_NoError Success, ready to roll
739 * OMX_Error_BadParameter The input parameter pointer is null
740 **/
741 /*-------------------------------------------------------------------*/
JPEGENC_SetCallbacks(OMX_HANDLETYPE pComponent,OMX_CALLBACKTYPE * pCallBacks,OMX_PTR pAppData)742 static OMX_ERRORTYPE JPEGENC_SetCallbacks (OMX_HANDLETYPE pComponent,
743 OMX_CALLBACKTYPE* pCallBacks,
744 OMX_PTR pAppData)
745 {
746 OMX_ERRORTYPE eError = OMX_ErrorNone;
747 OMX_COMPONENTTYPE *pHandle = NULL;
748 JPEGENC_COMPONENT_PRIVATE *pComponentPrivate = NULL;
749
750 OMX_CHECK_PARAM(pComponent);
751 OMX_CHECK_PARAM(pCallBacks);
752
753 pHandle = (OMX_COMPONENTTYPE*)pComponent;
754 pComponentPrivate = (JPEGENC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
755
756 /*Copy the callbacks of the application to the component private */
757 memcpy (&(pComponentPrivate->cbInfo), pCallBacks, sizeof(OMX_CALLBACKTYPE));
758 OMX_MEMCPY_CHECK(&(pComponentPrivate->cbInfo));
759
760 /*Copy the application private data to component memory */
761 pHandle->pApplicationPrivate = pAppData;
762 pComponentPrivate->nCurState = OMX_StateLoaded;
763
764 EXIT:
765 return eError;
766 }
767
768
769 /*-------------------------------------------------------------------*/
770 /**
771 * JPEGENC_GetComponentVersion() Sets application callbacks to the component
772 *
773 * This method will get the component Version.
774 *
775 * @param hComp handle for this instance of the component
776 * @param pComponentName application callbacks
777 * @param pComponentVersion
778 * @param pSpecVersion
779 * @param pComponentUUID
780 *
781 * @retval OMX_NoError Success, ready to roll
782 * OMX_Error_BadParameter The input parameter pointer is null
783 **/
784 /*-------------------------------------------------------------------*/
JPEGENC_GetComponentVersion(OMX_HANDLETYPE hComp,OMX_STRING szComponentName,OMX_VERSIONTYPE * pComponentVersion,OMX_VERSIONTYPE * pSpecVersion,OMX_UUIDTYPE * pComponentUUID)785 static OMX_ERRORTYPE JPEGENC_GetComponentVersion (OMX_HANDLETYPE hComp,
786 OMX_STRING szComponentName,
787 OMX_VERSIONTYPE* pComponentVersion,
788 OMX_VERSIONTYPE* pSpecVersion,
789 OMX_UUIDTYPE* pComponentUUID)
790 {
791 OMX_ERRORTYPE eError = OMX_ErrorNone;
792 OMX_COMPONENTTYPE * pHandle = NULL;
793 JPEGENC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
794 OMX_U8 *pTemp = NULL;
795 if (!hComp || !szComponentName || !pComponentVersion || !pSpecVersion || !pComponentUUID) {
796 eError = OMX_ErrorBadParameter;
797 goto EXIT;
798 }
799 pHandle = (OMX_COMPONENTTYPE*)hComp;
800 if (!pHandle->pComponentPrivate) {
801 eError = OMX_ErrorBadParameter;
802 goto EXIT;
803 }
804 pComponentPrivate = (JPEGENC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate;
805
806 strncpy(szComponentName, pComponentPrivate->cComponentName, COMP_MAX_NAMESIZE);
807 pTemp = memcpy(pComponentVersion, &(pComponentPrivate->ComponentVersion.s), sizeof(pComponentPrivate->ComponentVersion.s));
808 if(pTemp == NULL){
809 eError = OMX_ErrorUndefined;
810 goto EXIT;
811 }
812 pTemp = memcpy(pSpecVersion, &(pComponentPrivate->SpecVersion.s), sizeof(pComponentPrivate->SpecVersion.s));
813 if(pTemp == NULL){
814 eError = OMX_ErrorUndefined;
815 goto EXIT;
816 }
817 EXIT:
818 return eError;
819 }
820
821 /*-------------------------------------------------------------------*/
822 /**
823 * JPEGENC_SendCommand() Send commands to the
824 *
825 * This method will update application callbacks
826 * the application.
827 *
828 * @param phandle handle for this instance of the component
829 * @param Cmd OMX Command usually OMX_CommandStateSet
830 * @param nParam
831 *
832 * @retval OMX_NoError Success, ready to roll
833 * OMX_Error_BadParameter The input parameter pointer is null
834 **/
835 /*-------------------------------------------------------------------*/
JPEGENC_SendCommand(OMX_HANDLETYPE hComponent,OMX_COMMANDTYPE Cmd,OMX_U32 nParam,OMX_PTR pCmdData)836 static OMX_ERRORTYPE JPEGENC_SendCommand (
837 OMX_HANDLETYPE hComponent,
838 OMX_COMMANDTYPE Cmd,
839 OMX_U32 nParam,
840 OMX_PTR pCmdData
841 )
842 {
843 OMX_ERRORTYPE eError = OMX_ErrorNone;
844 OMX_COMPONENTTYPE *pHandle = NULL;
845 JPEGENC_COMPONENT_PRIVATE *pCompPrivate = NULL;
846 OMX_PARAM_PORTDEFINITIONTYPE *pPortDefIn = NULL;
847 OMX_PARAM_PORTDEFINITIONTYPE *pPortDefOut = NULL;
848 OMX_MARKTYPE *pMarkType = NULL;
849 OMX_COMMANDTYPE eCmd = -1;
850 int nRet = 0;
851
852 OMX_CHECK_PARAM(hComponent);
853
854 pHandle = (OMX_COMPONENTTYPE *)hComponent;
855 pCompPrivate = (JPEGENC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
856 pPortDefIn = pCompPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef;
857 pPortDefOut = pCompPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef;
858
859 OMX_PRINT2(pCompPrivate->dbg, "Print nParam = %d\n", (int)nParam);
860
861 if ( pCompPrivate->nCurState == OMX_StateInvalid ) {
862 eError = OMX_ErrorInvalidState;
863 goto EXIT;
864 }
865
866 switch ( Cmd ) {
867 case OMX_CommandStateSet:
868 /* Add a pending transition */
869 if(AddStateTransition(pCompPrivate) != OMX_ErrorNone) {
870 return OMX_ErrorUndefined;
871 }
872 eCmd = SetState;
873 pCompPrivate->nToState = nParam;
874 break;
875 case OMX_CommandFlush:
876 if ((nParam != 0) && (nParam != 1) && ((int)nParam != -1)) {
877 eError = OMX_ErrorBadPortIndex;
878 goto EXIT;
879 }
880 eCmd = Flush;
881 break;
882 case OMX_CommandPortDisable:
883 if (nParam == JPEGENC_INP_PORT || (int)nParam == -1) {
884 pPortDefIn->bEnabled = OMX_FALSE;
885 pCompPrivate->bInportDisableIncomplete = OMX_FALSE;
886 }
887 if (nParam == JPEGENC_OUT_PORT || (int)nParam == -1) {
888 pPortDefOut->bEnabled = OMX_FALSE;
889 pCompPrivate->bOutportDisableIncomplete = OMX_FALSE;
890 }
891 if ((nParam != JPEGENC_INP_PORT) && (nParam != JPEGENC_OUT_PORT) && ((int)nParam != -1))
892 {
893 eError = OMX_ErrorBadParameter;
894 goto EXIT;
895 }
896
897 if (!pPortDefIn->bPopulated) {
898 pCompPrivate->bInportDisableIncomplete = OMX_TRUE;
899 pCompPrivate->cbInfo.EventHandler (pCompPrivate->pHandle,
900 pCompPrivate->pHandle->pApplicationPrivate,
901 OMX_EventCmdComplete,
902 OMX_CommandPortDisable,
903 JPEGENC_INP_PORT,
904 NULL);
905 }
906
907 if (!pPortDefOut->bPopulated) {
908 pCompPrivate->bOutportDisableIncomplete = OMX_TRUE;
909 pCompPrivate->cbInfo.EventHandler (pCompPrivate->pHandle,
910 pCompPrivate->pHandle->pApplicationPrivate,
911 OMX_EventCmdComplete,
912 OMX_CommandPortDisable,
913 JPEGENC_OUT_PORT,
914 NULL);
915 }
916 eCmd = OMX_CommandPortDisable;
917 break;
918
919 case OMX_CommandPortEnable:
920 if (nParam == JPEGENC_INP_PORT || (int)nParam == -1) {
921 pPortDefIn->bEnabled = OMX_TRUE;
922 }
923 if (nParam == JPEGENC_OUT_PORT || (int)nParam == -1) {
924 pPortDefOut->bEnabled = OMX_TRUE;
925 }
926 if ((nParam != JPEGENC_INP_PORT) && (nParam != JPEGENC_OUT_PORT) && ((int)nParam != -1)) {
927 eError = OMX_ErrorBadParameter;
928 goto EXIT;
929 }
930 eCmd = OMX_CommandPortEnable;
931 break;
932
933 case OMX_CommandMarkBuffer:
934 if ((nParam != JPEGENC_OUT_PORT) && (nParam != JPEGENC_INP_PORT)) {
935 eError = OMX_ErrorBadPortIndex;
936 goto EXIT;
937 }
938 pMarkType = (OMX_MARKTYPE *)pCmdData;
939 pCompPrivate->pMarkData = pMarkType->pMarkData;
940 pCompPrivate->hMarkTargetComponent = pMarkType->hMarkTargetComponent;
941 pCompPrivate->nMarkPort = nParam;
942 OMX_PRBUFFER2(pCompPrivate->dbg, "IN SendCommand, port %d mark %p\n", pCompPrivate->nMarkPort, pCompPrivate->pMarkData);
943 goto EXIT;
944 break;
945 default:
946 break;
947
948 }
949
950 nRet = write(pCompPrivate->nCmdPipe[1], &eCmd, sizeof(eCmd));
951 if (nRet == -1) {
952 if(RemoveStateTransition(pCompPrivate, OMX_FALSE) != OMX_ErrorNone) {
953 return OMX_ErrorUndefined;
954 }
955 return OMX_ErrorUndefined;
956 }
957
958 #ifdef __PERF_INSTRUMENTATION__
959 PERF_SendingCommand(pCompPrivate->pPERF,
960 Cmd,
961 (Cmd == OMX_CommandMarkBuffer) ? (OMX_U32) pCmdData : nParam,
962 PERF_ModuleComponent);
963 #endif
964
965
966 nRet = write(pCompPrivate->nCmdDataPipe[1], &nParam, sizeof(nParam));
967 if (nRet == -1) {
968 if(RemoveStateTransition(pCompPrivate, OMX_FALSE) != OMX_ErrorNone) {
969 return OMX_ErrorUndefined;
970 }
971 return OMX_ErrorUndefined;
972 }
973
974 EXIT:
975
976 return eError;
977 }
978
979
980 /*-------------------------------------------------------------------*/
981 /**
982 * JPEGENC_GetParameter() Gets Parameters from the Component
983 *
984 * This method will update parameters from the component to the app.
985 *
986 * @param hComp handle for this instance of the component
987 * @param nParamIndex Component Index Port
988 * @param ComponentParameterStructure Component Parameter Structure
989 *
990 * @retval OMX_NoError Success, ready to roll
991 * OMX_Error_BadParameter The input parameter pointer is null
992 **/
993 /*-------------------------------------------------------------------*/
JPEGENC_GetParameter(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_INDEXTYPE nParamIndex,OMX_INOUT OMX_PTR pComponentParameterStructure)994 static OMX_ERRORTYPE JPEGENC_GetParameter (OMX_IN OMX_HANDLETYPE hComponent,
995 OMX_IN OMX_INDEXTYPE nParamIndex,
996 OMX_INOUT OMX_PTR pComponentParameterStructure)
997 {
998 OMX_COMPONENTTYPE *pComp = NULL;
999 JPEGENC_COMPONENT_PRIVATE *pComponentPrivate = NULL;
1000 OMX_ERRORTYPE eError = OMX_ErrorNone;
1001 JPEG_PORT_TYPE *pInpPortType = NULL;
1002 JPEG_PORT_TYPE *pOutPortType = NULL;
1003
1004 OMX_CHECK_PARAM(hComponent);
1005 OMX_CHECK_PARAM(pComponentParameterStructure);
1006
1007 pComp = (OMX_COMPONENTTYPE *)hComponent;
1008 pComponentPrivate = (JPEGENC_COMPONENT_PRIVATE*)pComp->pComponentPrivate;
1009 OMX_PRINT1(pComponentPrivate->dbg, "Entering function\n");
1010
1011 if ( pComponentPrivate->nCurState == OMX_StateInvalid ) {
1012 eError = OMX_ErrorInvalidState;
1013 goto PRINT_EXIT;
1014 }
1015 pInpPortType = pComponentPrivate->pCompPort[JPEGENC_INP_PORT];
1016 pOutPortType = pComponentPrivate->pCompPort[JPEGENC_OUT_PORT];
1017
1018 switch ( nParamIndex ) {
1019 case OMX_IndexParamImageInit:
1020 memcpy(pComponentParameterStructure, pComponentPrivate->pPortParamType, sizeof(OMX_PORT_PARAM_TYPE));
1021 OMX_MEMCPY_CHECK(pComponentParameterStructure);
1022 break;
1023 case OMX_IndexParamAudioInit:
1024 memcpy(pComponentParameterStructure, pComponentPrivate->pPortParamTypeAudio, sizeof(OMX_PORT_PARAM_TYPE));
1025 OMX_MEMCPY_CHECK(pComponentParameterStructure);
1026 break;
1027 case OMX_IndexParamVideoInit:
1028 memcpy(pComponentParameterStructure, pComponentPrivate->pPortParamTypeVideo, sizeof(OMX_PORT_PARAM_TYPE));
1029 OMX_MEMCPY_CHECK(pComponentParameterStructure);
1030 break;
1031 case OMX_IndexParamOtherInit:
1032 memcpy(pComponentParameterStructure, pComponentPrivate->pPortParamTypeOthers, sizeof(OMX_PORT_PARAM_TYPE));
1033 OMX_MEMCPY_CHECK(pComponentParameterStructure);
1034 break;
1035 case OMX_IndexParamPortDefinition:
1036 {
1037 OMX_PARAM_PORTDEFINITIONTYPE *pParamPortDef = NULL;
1038
1039 pParamPortDef = (OMX_PARAM_PORTDEFINITIONTYPE *)pComponentParameterStructure;
1040 OMX_PRINT2(pComponentPrivate->dbg, "index is %d (%d) (%d)\n",
1041 (int)(pParamPortDef->nPortIndex),
1042 (int)(pInpPortType->pPortDef->nPortIndex),
1043 (int)(pOutPortType->pPortDef->nPortIndex));
1044 if (pParamPortDef->nPortIndex == pInpPortType->pPortDef->nPortIndex)
1045 {
1046 OMX_PRBUFFER2(pComponentPrivate->dbg, "nBufferCountActual %d (0) \n", (int)(pInpPortType->pPortDef->nBufferCountActual));
1047 /* pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->bPopulated = OMX_FALSE; */
1048 memcpy(pComponentParameterStructure, pInpPortType->pPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1049 OMX_MEMCPY_CHECK(pComponentParameterStructure);
1050 } else if (pParamPortDef->nPortIndex == pOutPortType->pPortDef->nPortIndex)
1051 {
1052 OMX_PRBUFFER2(pComponentPrivate->dbg, "nBufferCountActual %d (1)\n", (int)(pOutPortType->pPortDef->nBufferCountActual));
1053 /* pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef->bPopulated = OMX_FALSE; */
1054 memcpy(pComponentParameterStructure, pOutPortType->pPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1055 OMX_MEMCPY_CHECK(pComponentParameterStructure);
1056 } else {
1057 eError = OMX_ErrorBadPortIndex;
1058 }
1059 }
1060 break;
1061
1062 case OMX_IndexParamImagePortFormat:
1063 {
1064 OMX_IMAGE_PARAM_PORTFORMATTYPE *pParamImagePortFormat = NULL;
1065
1066 pParamImagePortFormat = (OMX_IMAGE_PARAM_PORTFORMATTYPE *)pComponentParameterStructure;
1067 if ( pParamImagePortFormat->nPortIndex == pInpPortType->pPortFormat->nPortIndex )
1068 {
1069 if (pParamImagePortFormat->nIndex > pInpPortType->pPortFormat->nIndex ) {
1070 eError = OMX_ErrorNoMore;
1071 } else {
1072 memcpy(pComponentParameterStructure, pInpPortType->pPortFormat, sizeof(OMX_IMAGE_PARAM_PORTFORMATTYPE));
1073 OMX_MEMCPY_CHECK(pComponentParameterStructure);
1074 }
1075 } else if (pParamImagePortFormat->nPortIndex == pOutPortType->pPortFormat->nPortIndex )
1076 {
1077 if ( pParamImagePortFormat->nIndex > pOutPortType->pPortFormat->nIndex ) {
1078 eError = OMX_ErrorNoMore;
1079 } else {
1080 memcpy(pComponentParameterStructure, pOutPortType->pPortFormat, sizeof(OMX_IMAGE_PARAM_PORTFORMATTYPE));
1081 OMX_MEMCPY_CHECK(pComponentParameterStructure);
1082 }
1083 } else {
1084 eError = OMX_ErrorBadPortIndex;
1085 }
1086 }
1087 break;
1088
1089 case OMX_IndexParamPriorityMgmt:
1090 memcpy(pComponentParameterStructure, pComponentPrivate->pPriorityMgmt, sizeof(OMX_PRIORITYMGMTTYPE));
1091 OMX_MEMCPY_CHECK(pComponentParameterStructure);
1092 break;
1093
1094 case OMX_IndexParamCompBufferSupplier:
1095 {
1096 OMX_PARAM_BUFFERSUPPLIERTYPE *pBuffSupplierParam = (OMX_PARAM_BUFFERSUPPLIERTYPE *)pComponentParameterStructure;
1097
1098 if ( pBuffSupplierParam->nPortIndex == pOutPortType->pPortDef->nPortIndex)
1099 {
1100 pBuffSupplierParam->eBufferSupplier = pOutPortType->pParamBufSupplier->eBufferSupplier;
1101 } else if ( pBuffSupplierParam->nPortIndex == pInpPortType->pPortDef->nPortIndex )
1102 {
1103 pBuffSupplierParam->eBufferSupplier = pInpPortType->pParamBufSupplier->eBufferSupplier;
1104 } else
1105 {
1106 eError = OMX_ErrorBadPortIndex;
1107 break;
1108 }
1109 }
1110 break;
1111 case OMX_IndexParamQuantizationTable:
1112 {
1113 OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE *pQuantTable = (OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE *)pComponentParameterStructure;
1114 if (pQuantTable->eQuantizationTable == OMX_IMAGE_QuantizationTableLuma) {
1115 memcpy(pQuantTable, pComponentPrivate->pCustomLumaQuantTable, sizeof(OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE));
1116 }
1117 else if (pQuantTable->eQuantizationTable == OMX_IMAGE_QuantizationTableChroma) {
1118 memcpy(pQuantTable, pComponentPrivate->pCustomChromaQuantTable, sizeof(OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE));
1119 }
1120 else { /* wrong eQuantizationTable, return error */
1121 eError = OMX_ErrorBadParameter;
1122 }
1123 break;
1124 }
1125 case OMX_IndexCustomHuffmanTable:
1126 {
1127 JPEGENC_CUSTOM_HUFFMANTTABLETYPE *pHuffmanTable = (JPEGENC_CUSTOM_HUFFMANTTABLETYPE *)pComponentParameterStructure;
1128 memcpy(pHuffmanTable, pComponentPrivate->pHuffmanTable, sizeof(JPEGENC_CUSTOM_HUFFMANTTABLETYPE));
1129 break;
1130 }
1131 default:
1132 eError = OMX_ErrorUnsupportedIndex;
1133 break;
1134 }
1135 PRINT_EXIT:
1136 OMX_PRINT1(pComponentPrivate->dbg, "Exit function eError = %x\n", eError);
1137 EXIT:
1138 return eError;
1139
1140 }
1141
1142
1143 /*-------------------------------------------------------------------*/
1144 /**
1145 * JPEGENC_SetParameter() Gets the parameters sent by the Application and sets it to the component.
1146 *
1147 * This method will update component parameters .
1148 *
1149 *
1150 * @param hComp handle for this instance of the component
1151 * @param nParamIndex Component Params Index Port
1152 * @param ComponentParameterStructure Component Parameter Structure
1153 *
1154 * @retval OMX_NoError Success, ready to roll
1155 * OMX_Error_BadParameter The input parameter pointer is null
1156 **/
1157 /*-------------------------------------------------------------------*/
JPEGENC_SetParameter(OMX_HANDLETYPE hComponent,OMX_INDEXTYPE nParamIndex,OMX_PTR pCompParam)1158 static OMX_ERRORTYPE JPEGENC_SetParameter (OMX_HANDLETYPE hComponent,
1159 OMX_INDEXTYPE nParamIndex,
1160 OMX_PTR pCompParam)
1161 {
1162 OMX_COMPONENTTYPE * pHandle = NULL;
1163 JPEGENC_COMPONENT_PRIVATE * pComponentPrivate = NULL;
1164 OMX_ERRORTYPE eError = OMX_ErrorNone;
1165 JPEG_PORT_TYPE *pInpPortType = NULL;
1166 JPEG_PORT_TYPE *pOutPortType = NULL;
1167 #ifdef KHRONOS_1_1
1168 OMX_PARAM_COMPONENTROLETYPE *pRole;
1169 #endif
1170
1171 OMX_CHECK_PARAM(hComponent);
1172 OMX_CHECK_PARAM(pCompParam);
1173
1174 pHandle= (OMX_COMPONENTTYPE*)hComponent;
1175 pComponentPrivate = pHandle->pComponentPrivate;
1176
1177 if ( pComponentPrivate->nCurState != OMX_StateLoaded ) {
1178 eError = OMX_ErrorIncorrectStateOperation;
1179 goto EXIT;
1180 }
1181
1182 pInpPortType = pComponentPrivate->pCompPort[JPEGENC_INP_PORT];
1183 pOutPortType = pComponentPrivate->pCompPort[JPEGENC_OUT_PORT];
1184 OMX_CHECK_PARAM(pInpPortType);
1185 OMX_CHECK_PARAM(pOutPortType);
1186
1187 switch ( nParamIndex ) {
1188 case OMX_IndexParamImagePortFormat:
1189 {
1190 OMX_IMAGE_PARAM_PORTFORMATTYPE* pComponentParam = (OMX_IMAGE_PARAM_PORTFORMATTYPE *)pCompParam;
1191 OMX_MEMCPY_CHECK(pInpPortType->pPortFormat);
1192 OMX_MEMCPY_CHECK(pOutPortType->pPortFormat);
1193 if ( pComponentParam->nPortIndex == pInpPortType->pPortFormat->nPortIndex )
1194 {
1195 memcpy(pInpPortType->pPortFormat, pComponentParam, sizeof(OMX_IMAGE_PARAM_PORTFORMATTYPE));
1196 }
1197 else if ( pComponentParam->nPortIndex == pOutPortType->pPortFormat->nPortIndex ) {
1198 memcpy(pOutPortType->pPortFormat, pComponentParam, sizeof(OMX_IMAGE_PARAM_PORTFORMATTYPE));
1199 }
1200 else {
1201 eError = OMX_ErrorBadPortIndex;
1202 }
1203 break;
1204 }
1205 case OMX_IndexParamImageInit:
1206 {
1207 OMX_MEMCPY_CHECK(pComponentPrivate->pPortParamType);
1208 memcpy(pComponentPrivate->pPortParamType, (OMX_PORT_PARAM_TYPE*)pCompParam, sizeof(OMX_PORT_PARAM_TYPE));
1209 break;
1210 }
1211 case OMX_IndexParamPortDefinition:
1212 {
1213 OMX_PARAM_PORTDEFINITIONTYPE* pComponentParam = (OMX_PARAM_PORTDEFINITIONTYPE *)pCompParam;
1214 OMX_MEMCPY_CHECK(pInpPortType->pPortDef);
1215 OMX_MEMCPY_CHECK(pOutPortType->pPortDef);
1216 if ( pComponentParam->nPortIndex == pInpPortType->pPortDef->nPortIndex ) {
1217 memcpy(pInpPortType->pPortDef, pComponentParam, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1218 }
1219 else if ( pComponentParam->nPortIndex == pOutPortType->pPortDef->nPortIndex ) {
1220 memcpy(pOutPortType->pPortDef, pComponentParam, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1221 }
1222 else {
1223 eError = OMX_ErrorBadPortIndex;
1224 }
1225 break;
1226 }
1227 case OMX_IndexParamPriorityMgmt:
1228 {
1229 OMX_MEMCPY_CHECK(pComponentPrivate->pPriorityMgmt);
1230 memcpy(pComponentPrivate->pPriorityMgmt, (OMX_PRIORITYMGMTTYPE*)pCompParam, sizeof(OMX_PRIORITYMGMTTYPE));
1231 break;
1232 }
1233 case OMX_IndexParamQFactor:
1234 {
1235 OMX_MEMCPY_CHECK(pComponentPrivate->pQualityfactor);
1236 memcpy(pComponentPrivate->pQualityfactor, (OMX_IMAGE_PARAM_QFACTORTYPE*)pCompParam, sizeof(OMX_IMAGE_PARAM_QFACTORTYPE));
1237 break;
1238 }
1239 case OMX_IndexParamCompBufferSupplier:
1240 {
1241 OMX_PARAM_BUFFERSUPPLIERTYPE *pBuffSupplierParam = (OMX_PARAM_BUFFERSUPPLIERTYPE *)pCompParam;
1242
1243 if ( pBuffSupplierParam->nPortIndex == 1 /*pOutPortType->pBuffSupplierParam->nPortIndex */) {
1244 /* Copy parameters to input port buffer supplier type */
1245 pOutPortType->pBufSupplier = pBuffSupplierParam->eBufferSupplier;
1246 }
1247 else if ( pBuffSupplierParam->nPortIndex == 0 /* pInpPortType->pBuffSupplierParam->nPortIndex */ ) {
1248 pInpPortType->pBufSupplier = pBuffSupplierParam->eBufferSupplier;
1249 }
1250 else {
1251 eError = OMX_ErrorBadPortIndex;
1252 break;
1253 }
1254 break;
1255 }
1256 #ifdef KHRONOS_1_1
1257 case OMX_IndexParamStandardComponentRole:
1258 if (pCompParam) {
1259 pRole = (OMX_PARAM_COMPONENTROLETYPE *)pCompParam;
1260 memcpy(&(pComponentPrivate->componentRole), (void *)pRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
1261 } else {
1262 eError = OMX_ErrorBadParameter;
1263 }
1264 break;
1265 #endif
1266 case OMX_IndexParamQuantizationTable:
1267 {
1268 OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE *pQuantTable = (OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE *)pCompParam;
1269 if (pQuantTable->eQuantizationTable == OMX_IMAGE_QuantizationTableLuma) {
1270 memcpy(pComponentPrivate->pCustomLumaQuantTable, pQuantTable, sizeof(OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE));
1271 pComponentPrivate->bSetLumaQuantizationTable = OMX_TRUE;
1272 eError = SetJpegEncInParams(pComponentPrivate);
1273 }
1274 else if (pQuantTable->eQuantizationTable == OMX_IMAGE_QuantizationTableChroma) {
1275 memcpy(pComponentPrivate->pCustomChromaQuantTable, pQuantTable, sizeof(OMX_IMAGE_PARAM_QUANTIZATIONTABLETYPE));
1276 pComponentPrivate->bSetChromaQuantizationTable = OMX_TRUE;
1277 eError = SetJpegEncInParams(pComponentPrivate);
1278 }
1279 else { /* wrong eQuantizationTable, return error */
1280 eError = OMX_ErrorBadParameter;
1281 }
1282 break;
1283 }
1284 case OMX_IndexCustomHuffmanTable:
1285 {
1286 JPEGENC_CUSTOM_HUFFMANTTABLETYPE *pHuffmanTable = (JPEGENC_CUSTOM_HUFFMANTTABLETYPE *)pCompParam;
1287 if (pHuffmanTable->nPortIndex == pOutPortType->pPortDef->nPortIndex) {
1288 memcpy(pComponentPrivate->pHuffmanTable, pHuffmanTable, sizeof(JPEGENC_CUSTOM_HUFFMANTTABLETYPE));
1289 pComponentPrivate->bSetHuffmanTable = OMX_TRUE;
1290 eError = SetJpegEncInParams(pComponentPrivate);
1291 } else { /* wrong nPortIndex, return error */
1292 eError = OMX_ErrorBadPortIndex;
1293 }
1294 break;
1295 }
1296 break; default:
1297 eError = OMX_ErrorUnsupportedIndex;
1298 break;
1299 }
1300
1301 EXIT:
1302 return eError;
1303 }
1304
1305
1306 /*-------------------------------------------------------------------*/
1307 /**
1308 * JPEGENC_GetConfig() Gets Configuration from the Component
1309 *
1310 * This method will update component config structure .(NOT IMPLEMENTED)
1311 *
1312 * @param hComp handle for this instance of the component
1313 * @param nConfigIndex Component Config Index Port
1314 * @param ComponentConfigStructure Component Config Structure
1315 *
1316 * @retval OMX_NoError Success, ready to roll
1317 * OMX_Error_BadParameter The input parameter pointer is null
1318 **/
1319 /*-------------------------------------------------------------------*/
JPEGENC_GetConfig(OMX_HANDLETYPE hComp,OMX_INDEXTYPE nConfigIndex,OMX_PTR ComponentConfigStructure)1320 static OMX_ERRORTYPE JPEGENC_GetConfig (OMX_HANDLETYPE hComp,
1321 OMX_INDEXTYPE nConfigIndex,
1322 OMX_PTR ComponentConfigStructure)
1323 {
1324 OMX_ERRORTYPE eError = OMX_ErrorNone;
1325 OMX_COMPONENTTYPE *pHandle = (OMX_COMPONENTTYPE*)hComp;
1326 OMX_CHECK_PARAM(hComp);
1327
1328 JPEGENC_COMPONENT_PRIVATE *pComponentPrivate = pHandle->pComponentPrivate;
1329
1330 OMX_PRINT1(pComponentPrivate->dbg, "Inside JPEGENC_GetConfig function\n");
1331 switch ( nConfigIndex ) {
1332 case OMX_IndexCustomDebug:
1333 OMX_DBG_GETCONFIG(pComponentPrivate->dbg, ComponentConfigStructure);
1334 break;
1335 default:
1336 eError = OMX_ErrorUnsupportedIndex;
1337 break;
1338 }
1339 EXIT:
1340 return eError;
1341 }
1342
1343
1344 /*-------------------------------------------------------------------*/
1345 /**
1346 * JPEGENC_SetConfig() Gets Configuration structure to the component.
1347 *
1348 * This method will update application callbacks
1349 * the application.
1350 *
1351 * @param pComp handle for this instance of the component
1352 * @param pCallBacks application callbacks
1353 * @param ptr
1354 *
1355 * @retval OMX_NoError Success, ready to roll
1356 * OMX_Error_BadParameter The input parameter pointer is null
1357 **/
1358 /*-------------------------------------------------------------------*/
1359
JPEGENC_SetConfig(OMX_HANDLETYPE hComp,OMX_INDEXTYPE nConfigIndex,OMX_PTR ComponentConfigStructure)1360 static OMX_ERRORTYPE JPEGENC_SetConfig (OMX_HANDLETYPE hComp,
1361 OMX_INDEXTYPE nConfigIndex,
1362 OMX_PTR ComponentConfigStructure)
1363 {
1364 OMX_ERRORTYPE eError = OMX_ErrorNone;
1365 OMX_COMPONENTTYPE* pHandle = NULL;
1366 JPEGENC_COMPONENT_PRIVATE *pComponentPrivate = NULL;
1367
1368 OMX_CHECK_PARAM(hComp);
1369
1370 pHandle = (OMX_COMPONENTTYPE *)hComp;
1371
1372 pComponentPrivate = (JPEGENC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
1373 switch ( nConfigIndex ) {
1374 case OMX_IndexCustomCommentFlag :
1375 {
1376 int *nComment = (int*)ComponentConfigStructure;
1377 if ( nComment == NULL ) {
1378 eError = OMX_ErrorBadParameter;
1379 goto EXIT;
1380 }
1381 ((JPEGENC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate)->nCommentFlag = *nComment;
1382
1383
1384 break;
1385 }
1386
1387 case OMX_IndexCustomAPP0:
1388 {
1389 JPEG_APPTHUMB_MARKER *pMarkerInfo = (JPEG_APPTHUMB_MARKER *) ComponentConfigStructure;
1390
1391 if (pComponentPrivate->sAPP0.pMarkerBuffer != NULL) {
1392 OMX_FREE(pComponentPrivate->sAPP0.pMarkerBuffer);
1393 }
1394
1395 memcpy (&pComponentPrivate->sAPP0, pMarkerInfo, sizeof(JPEG_APPTHUMB_MARKER));
1396 OMX_MEMCPY_CHECK(&pComponentPrivate->sAPP0);
1397 if (pMarkerInfo->pMarkerBuffer != NULL) {
1398 OMX_MALLOC(pComponentPrivate->sAPP0.pMarkerBuffer, pMarkerInfo->nMarkerSize);
1399 memcpy (pComponentPrivate->sAPP0.pMarkerBuffer, pMarkerInfo->pMarkerBuffer, pMarkerInfo->nMarkerSize);
1400 OMX_MEMCPY_CHECK(pComponentPrivate->sAPP0.pMarkerBuffer);
1401 }
1402
1403 eError = SetJpegEncInParams(pComponentPrivate);
1404 break;
1405 }
1406
1407 case OMX_IndexCustomAPP1:
1408 {
1409 JPEG_APPTHUMB_MARKER *pMarkerInfo = (JPEG_APPTHUMB_MARKER *) ComponentConfigStructure;
1410
1411 if (pComponentPrivate->sAPP1.pMarkerBuffer != NULL) {
1412 OMX_FREE(pComponentPrivate->sAPP1.pMarkerBuffer);
1413 }
1414
1415 memcpy (&pComponentPrivate->sAPP1, pMarkerInfo, sizeof(JPEG_APPTHUMB_MARKER));
1416 OMX_MEMCPY_CHECK(&pComponentPrivate->sAPP1);
1417 if (pMarkerInfo->pMarkerBuffer != NULL) {
1418 OMX_MALLOC(pComponentPrivate->sAPP1.pMarkerBuffer, pMarkerInfo->nMarkerSize);
1419 memcpy (pComponentPrivate->sAPP1.pMarkerBuffer, pMarkerInfo->pMarkerBuffer, pMarkerInfo->nMarkerSize);
1420 OMX_MEMCPY_CHECK(pComponentPrivate->sAPP1.pMarkerBuffer);
1421 }
1422
1423 eError = SetJpegEncInParams(pComponentPrivate);
1424 break;
1425 }
1426
1427 case OMX_IndexCustomAPP5:
1428 {
1429 JPEG_APPTHUMB_MARKER *pMarkerInfo = (JPEG_APPTHUMB_MARKER *) ComponentConfigStructure;
1430
1431 if (pComponentPrivate->sAPP5.pMarkerBuffer != NULL) {
1432 OMX_FREE(pComponentPrivate->sAPP5.pMarkerBuffer);
1433 }
1434
1435 memcpy (&pComponentPrivate->sAPP5, pMarkerInfo, sizeof(JPEG_APPTHUMB_MARKER));
1436 OMX_MEMCPY_CHECK(&pComponentPrivate->sAPP5);
1437 if (pMarkerInfo->pMarkerBuffer != NULL) {
1438 OMX_MALLOC(pComponentPrivate->sAPP5.pMarkerBuffer, pMarkerInfo->nMarkerSize);
1439 memcpy (pComponentPrivate->sAPP5.pMarkerBuffer, pMarkerInfo->pMarkerBuffer, pMarkerInfo->nMarkerSize);
1440 OMX_MEMCPY_CHECK(pComponentPrivate->sAPP5.pMarkerBuffer);
1441 }
1442 eError = SetJpegEncInParams(pComponentPrivate);
1443 break;
1444 }
1445
1446 case OMX_IndexCustomAPP13:
1447 {
1448 JPEG_APP13_MARKER *pMarkerInfo = (JPEG_APP13_MARKER *) ComponentConfigStructure;
1449 if (pComponentPrivate->sAPP13.pMarkerBuffer != NULL) {
1450 OMX_FREE(pComponentPrivate->sAPP13.pMarkerBuffer);
1451 }
1452
1453 memcpy (&pComponentPrivate->sAPP13, pMarkerInfo, sizeof(JPEG_APP13_MARKER));
1454 OMX_MEMCPY_CHECK(&pComponentPrivate->sAPP13);
1455 if (pMarkerInfo->pMarkerBuffer != NULL) {
1456 OMX_MALLOC(pComponentPrivate->sAPP13.pMarkerBuffer, pMarkerInfo->nMarkerSize);
1457 memcpy (pComponentPrivate->sAPP13.pMarkerBuffer, pMarkerInfo->pMarkerBuffer, pMarkerInfo->nMarkerSize);
1458 OMX_MEMCPY_CHECK(pComponentPrivate->sAPP13.pMarkerBuffer);
1459 }
1460
1461 eError = SetJpegEncInParams(pComponentPrivate);
1462 break;
1463 }
1464
1465 case OMX_IndexCustomDRI:
1466 pComponentPrivate->nDRI_Interval = *(OMX_U8 *)ComponentConfigStructure;
1467 break;
1468
1469 case OMX_IndexCustomCommentString :
1470 {
1471 if(((JPEGENC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate)->pString_Comment == NULL){
1472 OMX_MALLOC(((JPEGENC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate)->pString_Comment , 256);
1473 }
1474 strncpy((char *)((JPEGENC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate)->pString_Comment, (char *)ComponentConfigStructure, 255);
1475 eError = SetJpegEncInParams(pComponentPrivate);
1476 break;
1477 }
1478 case OMX_IndexCustomInputFrameWidth:
1479 {
1480 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefIn = NULL;
1481 int *nWidth= (int*)ComponentConfigStructure;
1482
1483 pPortDefIn = ((JPEGENC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate)->pCompPort[JPEGENC_INP_PORT]->pPortDef;
1484 OMX_PRINT1(pComponentPrivate->dbg, "INIT nFrameHeight = %d\n", (int)(pPortDefIn->format.image.nFrameHeight));
1485 OMX_PRINT1(pComponentPrivate->dbg, "INIT nFrameWidth = %d\n", (int)(pPortDefIn->format.image.nFrameWidth));
1486 pPortDefIn->format.image.nFrameWidth = *nWidth;
1487 OMX_PRINT1(pComponentPrivate->dbg, "nFrameWidth = %d\n", (int)(pPortDefIn->format.image.nFrameWidth));
1488 #if 0
1489 eError = SendDynamicParam(pComponentPrivate);
1490 if (eError != OMX_ErrorNone ) {
1491 OMX_PRDSP4(pComponentPrivate->dbg, "SETSTATUS failed... %x\n", eError);
1492 goto EXIT;
1493 }
1494 #endif
1495 break;
1496 }
1497 case OMX_IndexCustomInputFrameHeight:
1498 {
1499 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefIn = NULL;
1500 int *nHeight = (int*)ComponentConfigStructure;
1501
1502 pPortDefIn = ((JPEGENC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate)->pCompPort[JPEGENC_INP_PORT]->pPortDef;
1503 pPortDefIn->format.image.nFrameHeight = *nHeight;
1504 OMX_PRINT1(pComponentPrivate->dbg, "nFrameHeight = %d\n", (int)(pPortDefIn->format.image.nFrameHeight));
1505 #if 0
1506 eError = SendDynamicParam(pComponentPrivate);
1507 if (eError != OMX_ErrorNone ) {
1508 OMX_PRDSP4(pComponentPrivate->dbg, "SETSTATUS failed... %x\n", eError);
1509 goto EXIT;
1510 }
1511 #endif
1512 break;
1513 }
1514 case OMX_IndexCustomQFactor:
1515 {
1516 OMX_MEMCPY_CHECK(pComponentPrivate->pQualityfactor);
1517 memcpy(pComponentPrivate->pQualityfactor, (OMX_IMAGE_PARAM_QFACTORTYPE*)ComponentConfigStructure, sizeof(OMX_IMAGE_PARAM_QFACTORTYPE));
1518 break;
1519 }
1520 case OMX_IndexConfigCommonInputCrop :
1521 {
1522 OMX_CONFIG_RECTTYPE *crop = (OMX_CONFIG_RECTTYPE*)ComponentConfigStructure;
1523 if ((crop->nTop != 0) || (crop->nLeft != 0))
1524 {
1525 eError = OMX_ErrorBadParameter;
1526 }
1527 else{
1528 pComponentPrivate->pCrop->nWidth = crop->nWidth;
1529 pComponentPrivate->pCrop->nHeight = crop->nHeight;
1530 }
1531 break;
1532 }
1533 case OMX_IndexCustomDebug:
1534 OMX_DBG_SETCONFIG(pComponentPrivate->dbg, ComponentConfigStructure);
1535 break;
1536
1537 case OMX_IndexCustomColorFormatConvertion_420pTo422i :
1538 {
1539 pComponentPrivate->bConvert420pTo422i = *((OMX_BOOL*)ComponentConfigStructure);
1540 break;
1541 }
1542
1543 case OMX_IndexCustomPPLibEnable :
1544 {
1545 #ifdef __JPEG_OMX_PPLIB_ENABLED__
1546 pComponentPrivate->bPPLibEnable = *((OMX_BOOL*)ComponentConfigStructure);
1547 #endif
1548 break;
1549 }
1550
1551 default:
1552 eError = OMX_ErrorUnsupportedIndex;
1553 break;
1554 }
1555
1556 if (pComponentPrivate->nCurState == OMX_StateExecuting || pComponentPrivate->nCurState == OMX_StatePause) {
1557 eError = SendDynamicParam(pComponentPrivate);
1558 if (eError != OMX_ErrorNone ) {
1559 OMX_PRDSP4(pComponentPrivate->dbg, "SETSTATUS failed... %x\n", eError);
1560 goto EXIT;
1561 }
1562 }
1563
1564 OMX_PRINT1(pComponentPrivate->dbg, "Inside JPEGENC_SetConfig function\n");
1565 EXIT:
1566 return eError;
1567 }
1568
1569
1570 /*-------------------------------------------------------------------*/
1571 /**
1572 * JPEGENC_GetState() Gets OMX Component State
1573 *
1574 * This method will return OMX Component State
1575 *
1576 * @param pComponent handle for this instance of the component
1577 * @param pState State type
1578 *
1579 *
1580 * @retval OMX_NoError Success, ready to roll
1581 * OMX_Error_BadParameter The input parameter pointer is null
1582 **/
1583 /*-------------------------------------------------------------------*/
JPEGENC_GetState(OMX_HANDLETYPE hComponent,OMX_STATETYPE * pState)1584 static OMX_ERRORTYPE JPEGENC_GetState (OMX_HANDLETYPE hComponent, OMX_STATETYPE* pState)
1585 {
1586 OMX_ERRORTYPE eError = OMX_ErrorNone;
1587 OMX_COMPONENTTYPE* pHandle = NULL;
1588 JPEGENC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
1589 struct timespec abs_time = {0,0};
1590 int nPendingStateChangeRequests = 0;
1591 int ret = 0;
1592 /* Set to sufficiently high value */
1593 int mutex_timeout = 3;
1594
1595 if(hComponent == NULL || pState == NULL) {
1596 return OMX_ErrorBadParameter;
1597 }
1598
1599
1600 pHandle = (OMX_COMPONENTTYPE*)hComponent;
1601 pComponentPrivate = (JPEGENC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate;
1602
1603 /* Retrieve current state */
1604 if (pHandle && pHandle->pComponentPrivate) {
1605 /* Check for any pending state transition requests */
1606 if(pthread_mutex_lock(&pComponentPrivate->mutexStateChangeRequest)) {
1607 return OMX_ErrorUndefined;
1608 }
1609 nPendingStateChangeRequests = pComponentPrivate->nPendingStateChangeRequests;
1610 if(!nPendingStateChangeRequests) {
1611 if(pthread_mutex_unlock(&pComponentPrivate->mutexStateChangeRequest)) {
1612 return OMX_ErrorUndefined;
1613 }
1614
1615 /* No pending state transitions */
1616 *pState = ((JPEGENC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate)->nCurState;
1617 eError = OMX_ErrorNone;
1618 }
1619 else {
1620 /* Wait for component to complete state transition */
1621 clock_gettime(CLOCK_REALTIME, &abs_time);
1622 abs_time.tv_sec += mutex_timeout;
1623 abs_time.tv_nsec = 0;
1624 ret = pthread_cond_timedwait(&(pComponentPrivate->StateChangeCondition), &(pComponentPrivate->mutexStateChangeRequest), &abs_time);
1625 if (!ret) {
1626 /* Component has completed state transitions*/
1627 *pState = ((JPEGENC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate)->nCurState;
1628 if(pthread_mutex_unlock(&pComponentPrivate->mutexStateChangeRequest)) {
1629 return OMX_ErrorUndefined;
1630 }
1631 eError = OMX_ErrorNone;
1632 }
1633 else if(ret == ETIMEDOUT) {
1634 /* Unlock mutex in case of timeout */
1635 pthread_mutex_unlock(&pComponentPrivate->mutexStateChangeRequest);
1636 return OMX_ErrorTimeout;
1637 }
1638 }
1639 }
1640 else {
1641 eError = OMX_ErrorInvalidComponent;
1642 *pState = OMX_StateInvalid;
1643 }
1644 return eError;
1645 }
1646
1647
1648 /*-------------------------------------------------------------------*/
1649 /**
1650 * JPEGENC_EmptyThisBuffer() Send Input Buffers
1651 *
1652 * The application uses this macro to send the input buffers filled with data to the input port of the component
1653 *
1654 * @param pComponent handle for this instance of the component
1655 * @param nPortIndex PortIndex
1656 * @param pBuffHead Pointer to data filled
1657 *
1658 * @retval OMX_NoError Success, ready to roll
1659 * OMX_Error_BadParameter The input parameter pointer is null
1660 * OMX_ErrorInvalidState Called in a invalid state
1661 * OMX_ErrorHardware Error in Writing to the Data pipe
1662 **/
1663 /*-------------------------------------------------------------------*/
JPEGENC_EmptyThisBuffer(OMX_HANDLETYPE pComponent,OMX_BUFFERHEADERTYPE * pBuffHead)1664 static OMX_ERRORTYPE JPEGENC_EmptyThisBuffer (OMX_HANDLETYPE pComponent,
1665 OMX_BUFFERHEADERTYPE* pBuffHead)
1666 {
1667 OMX_ERRORTYPE eError = OMX_ErrorNone;
1668 OMX_COMPONENTTYPE *pHandle = NULL;
1669 JPEGENC_COMPONENT_PRIVATE *pComponentPrivate = NULL;
1670 JPEGENC_BUFFER_PRIVATE *pBuffPrivate = NULL;
1671 OMX_HANDLETYPE hTunnelComponent;
1672 int i;
1673 int ret;
1674
1675 OMX_CHECK_PARAM(pComponent);
1676 OMX_CHECK_PARAM(pBuffHead);
1677
1678 pHandle = (OMX_COMPONENTTYPE *)pComponent;
1679 pComponentPrivate = (JPEGENC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
1680 OMX_PRBUFFER1(pComponentPrivate->dbg, "inside JPEGENC_EmptyThisBuffer\n");
1681 hTunnelComponent = pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->hTunnelComponent;
1682 pBuffPrivate = pBuffHead->pInputPortPrivate;
1683
1684 if ( pComponentPrivate->nCurState != OMX_StateExecuting &&
1685 pComponentPrivate->nCurState != OMX_StatePause &&
1686 pComponentPrivate->nCurState != OMX_StateIdle) {
1687 eError= OMX_ErrorIncorrectStateOperation;
1688 goto EXIT;
1689 }
1690
1691 if ( pBuffHead == NULL ) {
1692 eError = OMX_ErrorBadParameter;
1693 goto EXIT;
1694 }
1695 if ( pBuffHead->nSize != sizeof(OMX_BUFFERHEADERTYPE) ) {
1696 eError = OMX_ErrorBadParameter;
1697 OMX_PRBUFFER4(pComponentPrivate->dbg, "JPEG-ENC: buffer header size is not correct\n");
1698 goto EXIT;
1699 }
1700
1701 if (!pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->bEnabled) {
1702 eError = OMX_ErrorIncorrectStateOperation;
1703 goto EXIT;
1704 }
1705
1706 if ( (pBuffHead->nVersion.s.nVersionMajor != 0x1) ||
1707 (pBuffHead->nVersion.s.nVersionMinor != 0x0) ||
1708 (pBuffHead->nVersion.s.nRevision != 0x0) ||
1709 (pBuffHead->nVersion.s.nStep != 0x0) ) {
1710
1711 eError= OMX_ErrorVersionMismatch;
1712 goto EXIT;
1713 }
1714
1715 if (pBuffHead->nInputPortIndex != 0x0) {
1716 eError = OMX_ErrorBadPortIndex;
1717 goto EXIT;
1718 }
1719
1720 #ifdef __PERF_INSTRUMENTATION__
1721 PERF_ReceivedFrame(pComponentPrivate->pPERF,
1722 pBuffHead->pBuffer,
1723 pBuffHead->nFilledLen,
1724 PERF_ModuleHLMM);
1725 #endif
1726
1727 OMX_PRBUFFER1(pComponentPrivate->dbg, "pBuffHead->nAllocLen = %lu\n", pBuffHead->nAllocLen);
1728 OMX_PRBUFFER1(pComponentPrivate->dbg, "pBuffHead->nFilledLen = %lu\n", pBuffHead->nFilledLen);
1729
1730 pComponentPrivate->nInPortIn ++;
1731
1732 OMX_PRBUFFER2(pComponentPrivate->dbg, "EmptyThisBuffer nInPortIn %lu\n", pComponentPrivate->nInPortIn);
1733
1734 if (pBuffHead->nFlags == OMX_BUFFERFLAG_EOS) {
1735 OMX_PRBUFFER2(pComponentPrivate->dbg, "END OF STREAM DETECTED\n");
1736 pComponentPrivate->nFlags = OMX_BUFFERFLAG_EOS;
1737 /* pBuffHead->nFlags = 0; */
1738 OMX_PRBUFFER2(pComponentPrivate->dbg, "record EOS flag on buffer ID %lu\n", pComponentPrivate->nInPortIn);
1739 for (i = 0; i < (int)(pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->nBufferCountActual); i ++) {
1740 if (pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->sBufferFlagTrack[i].buffer_id == 0xFFFFFFFF)
1741 {
1742 OMX_PRBUFFER2(pComponentPrivate->dbg, "record buffer id in array %d\n", i);
1743 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->sBufferFlagTrack[i].flag = pBuffHead->nFlags;
1744 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->sBufferFlagTrack[i].buffer_id =
1745 pComponentPrivate->nInPortIn;
1746 break;
1747 }
1748 }
1749 }
1750
1751 /* mark the first buffer from input port after receiving mark buffer command */
1752 if (pComponentPrivate->nMarkPort == JPEGENC_INP_PORT) {
1753 if (pComponentPrivate->pMarkData) {
1754 OMX_PRBUFFER2(pComponentPrivate->dbg, "get mark buffer command, mark buffer %p\n", pBuffHead);
1755 pBuffHead->pMarkData = pComponentPrivate->pMarkData;
1756 pBuffHead->hMarkTargetComponent = pComponentPrivate->hMarkTargetComponent;
1757 pComponentPrivate->pMarkData = NULL;
1758 pComponentPrivate->hMarkTargetComponent = NULL;
1759 }
1760 }
1761
1762 /* if a buffer from input port is marked, record this port # in the buffer queue */
1763 if (pBuffHead->pMarkData) {
1764 for (i = 0; i < (int)(pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->nBufferCountActual); i ++) {
1765 if (pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->sBufferMarkTrack[i].buffer_id == 0xFFFFFFFF)
1766 {
1767 JPEGENC_BUFFERMARK_TRACK *pMarkTrack;
1768 pMarkTrack = &(pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->sBufferMarkTrack[i]);
1769 pMarkTrack->buffer_id = pComponentPrivate->nInPortIn;
1770 pMarkTrack->pMarkData = pBuffHead->pMarkData;
1771 pMarkTrack->hMarkTargetComponent = pBuffHead->hMarkTargetComponent;
1772 OMX_PRBUFFER2(pComponentPrivate->dbg, "mark buffer at ID %lu\n", pComponentPrivate->nInPortIn);
1773 break;
1774 }
1775 }
1776 }
1777
1778 #if 0
1779 eError = SendDynamicParam(pComponentPrivate);
1780 if (eError != OMX_ErrorNone ) {
1781 JOMX_PRDSP4(pComponentPrivate->dbg, "SETSTATUS failed... %x\n", eError);
1782 goto EXIT;
1783 }
1784 #endif
1785
1786 pBuffPrivate->eBufferOwner = JPEGENC_BUFFER_COMPONENT_IN;
1787 pBuffPrivate->bReadFromPipe = OMX_FALSE;
1788
1789 OMX_PRBUFFER1(pComponentPrivate->dbg, "buffer summary (get filled input buffer) %lu %lu %lu %lu (%p)\n",
1790 pComponentPrivate->nInPortIn,
1791 pComponentPrivate->nInPortOut,
1792 pComponentPrivate->nOutPortIn,
1793 pComponentPrivate->nOutPortOut, pBuffHead);
1794
1795 /*Writing the component buffer corresponding to input buffer to infill_q */
1796 OMX_PRCOMM2(pComponentPrivate->dbg, "EmptyThisBuffer: write to the queue %p \n", pBuffHead);
1797
1798 ret = write (pComponentPrivate->filled_inpBuf_Q[1], &(pBuffHead),sizeof(pBuffHead));
1799
1800 if ( ret == -1 ) {
1801 OMX_PRCOMM4(pComponentPrivate->dbg, "Error in Writing to the Data pipe\n");
1802 eError = OMX_ErrorHardware;
1803 goto EXIT;
1804 }
1805
1806 EXIT:
1807 return eError;
1808 }
1809
1810
1811 /*-------------------------------------------------------------------*/
1812 /**
1813 * JPEGENC_FillThisBuffer() Empty an output Buffer
1814 *
1815 * The component uses this to request the application to
1816 * empty an output buffer which contains the decoded data..
1817 * @param pComponent handle for this instance of the component
1818 * @param pCallBacks application callbacks
1819 * @param ptr
1820 *
1821 * @retval OMX_NoError Success, ready to roll
1822 * OMX_Error_BadParameter The input parameter pointer is null
1823 **/
1824 /*-------------------------------------------------------------------*/
JPEGENC_FillThisBuffer(OMX_HANDLETYPE pComponent,OMX_BUFFERHEADERTYPE * pBuffHead)1825 static OMX_ERRORTYPE JPEGENC_FillThisBuffer (OMX_HANDLETYPE pComponent,
1826 OMX_BUFFERHEADERTYPE* pBuffHead)
1827 {
1828 OMX_ERRORTYPE eError = OMX_ErrorNone;
1829 int err = 0;
1830 OMX_COMPONENTTYPE *pHandle = NULL;
1831 JPEGENC_BUFFER_PRIVATE* pBuffPrivate = NULL;
1832 JPEGENC_COMPONENT_PRIVATE *pComponentPrivate = NULL;
1833
1834 OMX_CHECK_PARAM(pComponent);
1835 OMX_CHECK_PARAM(pBuffHead);
1836
1837 pHandle = (OMX_COMPONENTTYPE *)pComponent;
1838 pComponentPrivate = (JPEGENC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
1839 pBuffPrivate = pBuffHead->pOutputPortPrivate;
1840
1841 OMX_PRINT1(pComponentPrivate->dbg, "Inside JPEGENC_FillThisBuffer function (%p) (state %d -> %d)\n", pBuffHead, pComponentPrivate->nCurState, pComponentPrivate->nToState);
1842
1843 if ( pComponentPrivate->nCurState != OMX_StateExecuting &&
1844 pComponentPrivate->nCurState != OMX_StatePause &&
1845 pComponentPrivate->nCurState != OMX_StateIdle) {
1846 eError= OMX_ErrorIncorrectStateOperation;
1847 goto EXIT;
1848 }
1849
1850 if ( pBuffHead->nSize != sizeof(OMX_BUFFERHEADERTYPE) ) {
1851 eError = OMX_ErrorBadParameter;
1852 OMX_PRBUFFER4(pComponentPrivate->dbg, "JPEG-ENC: buffer header size is not correct\n");
1853 goto EXIT;
1854 }
1855
1856 if (!pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pPortDef->bEnabled) {
1857 eError = OMX_ErrorIncorrectStateOperation;
1858 goto EXIT;
1859 }
1860
1861 if ( (pBuffHead->nVersion.s.nVersionMajor != 0x1) ||
1862 (pBuffHead->nVersion.s.nVersionMinor != 0x0) ||
1863 (pBuffHead->nVersion.s.nRevision != 0x0) ||
1864 (pBuffHead->nVersion.s.nStep != 0x0) ) {
1865
1866 eError= OMX_ErrorVersionMismatch;
1867 goto EXIT;
1868 }
1869
1870 if (pBuffHead->nOutputPortIndex != 0x1) {
1871 eError = OMX_ErrorBadPortIndex;
1872 goto EXIT;
1873 }
1874
1875 pBuffHead->nFilledLen = 0;
1876 #ifdef __PERF_INSTRUMENTATION__
1877 PERF_ReceivedFrame(pComponentPrivate->pPERF,
1878 pBuffHead->pBuffer,
1879 0,
1880 PERF_ModuleHLMM);
1881 #endif
1882
1883 pBuffPrivate->eBufferOwner = JPEGENC_BUFFER_COMPONENT_IN;
1884 pBuffPrivate->bReadFromPipe = OMX_FALSE;
1885
1886
1887 pComponentPrivate->nOutPortIn ++;
1888
1889 OMX_PRBUFFER2(pComponentPrivate->dbg, "FillThisBuffer nOutPortIn %lu\n", pComponentPrivate->nOutPortIn);
1890
1891 OMX_PRBUFFER1(pComponentPrivate->dbg, "buffer summary (get empty output buffer) %lu %lu %lu %lu\n",
1892 pComponentPrivate->nInPortIn,
1893 pComponentPrivate->nInPortOut,
1894 pComponentPrivate->nOutPortIn,
1895 pComponentPrivate->nOutPortOut);
1896
1897 /* writing the component structure corresponding to output buffer */
1898 OMX_PRCOMM2(pComponentPrivate->dbg, "FillThisBuffer: write to the queue %p \n", pBuffHead);
1899 err = write (pComponentPrivate->free_outBuf_Q[1], &(pBuffHead), sizeof (pBuffHead));
1900 if (err == -1) {
1901 eError = OMX_ErrorInsufficientResources;
1902 goto EXIT;
1903 }
1904 OMX_PRINT1(pComponentPrivate->dbg, "Error is %x\n",eError);
1905 EXIT:
1906 return eError;
1907 }
1908
1909
1910 /*-------------------------------------------------------------------*/
1911 /**
1912 * OMX_ComponentDeinit() Deinitialize Component
1913 *
1914 * This method will clean all resources in the component (NOT IMPLEMENTED)
1915 *
1916 * @param pHandle handle for this instance of the component
1917 *
1918 * @retval OMX_NoError Success, ready to roll
1919 * OMX_Error_BadParameter The input parameter pointer is null
1920 **/
1921 /*-------------------------------------------------------------------*/
1922
JPEGENC_ComponentDeInit(OMX_HANDLETYPE hComponent)1923 static OMX_ERRORTYPE JPEGENC_ComponentDeInit(OMX_HANDLETYPE hComponent)
1924 {
1925 OMX_ERRORTYPE eError = OMX_ErrorNone;
1926 OMX_COMPONENTTYPE *pHandle = NULL;
1927 JPEGENC_COMPONENT_PRIVATE *pComponentPrivate = NULL;
1928 struct OMX_TI_Debug dbg;
1929 OMX_DBG_INIT_BASE(dbg);
1930 OMX_CHECK_PARAM(hComponent);
1931 pHandle = (OMX_COMPONENTTYPE *)hComponent;
1932 pComponentPrivate = (JPEGENC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
1933 memcpy(&dbg, &(pComponentPrivate->dbg), sizeof(dbg));
1934 pthread_mutex_destroy(&pComponentPrivate->mutexStateChangeRequest);
1935 pthread_cond_destroy(&pComponentPrivate->StateChangeCondition);
1936 JPEGEnc_Free_ComponentResources(pComponentPrivate);
1937
1938 #ifdef RESOURCE_MANAGER_ENABLED
1939 eError = RMProxy_NewSendCommand(pHandle, RMProxy_FreeResource, OMX_JPEG_Encoder_COMPONENT, 0, 3456, NULL);
1940 if (eError != OMX_ErrorNone) {
1941 OMX_PRMGR4(dbg, "Cannot Free RMProxy Resources\n");
1942 }
1943
1944 eError = RMProxy_DeinitalizeEx(OMX_COMPONENTTYPE_IMAGE);
1945 if ( eError != OMX_ErrorNone ) {
1946 OMX_PRMGR4(dbg, "Error returned from destroy ResourceManagerProxy thread\n");
1947 }
1948
1949 #endif
1950
1951 EXIT:
1952 #if 0
1953 #ifdef __PERF_INSTRUMENTATION__
1954 PERF_Boundary(pComponentPrivate->pPERF,
1955 PERF_BoundaryComplete | PERF_BoundaryCleanup);
1956 PERF_Done(pComponentPrivate->pPERF);
1957 #endif
1958 #endif
1959 OMX_DBG_CLOSE(dbg);
1960 return eError;
1961 }
1962
1963
1964
1965 /*-------------------------------------------------------------------*/
1966 /**
1967 * JPEGENC_VerifyTunnelConnection()
1968 *
1969 *
1970 *
1971 *
1972 * @param
1973 * @param
1974 * @param
1975 *
1976 * @retval OMX_NoError Success, ready to roll
1977 * OMX_Error_BadParameter The input parameter pointer is null
1978 **/
1979 /*-------------------------------------------------------------------*/
1980 /* TODO: Component Name */
1981
JPEGENC_VerifyTunnelConnection(JPEG_PORT_TYPE * pPort,OMX_HANDLETYPE hTunneledComp,OMX_PARAM_PORTDEFINITIONTYPE * pPortDef,struct OMX_TI_Debug * dbg)1982 OMX_ERRORTYPE JPEGENC_VerifyTunnelConnection (JPEG_PORT_TYPE *pPort,
1983 OMX_HANDLETYPE hTunneledComp,
1984 OMX_PARAM_PORTDEFINITIONTYPE* pPortDef,
1985 struct OMX_TI_Debug *dbg)
1986 {
1987 OMX_PARAM_PORTDEFINITIONTYPE sPortDef;
1988 OMX_ERRORTYPE eError = OMX_ErrorNone;
1989 /*sPortDef.format.image.eCompressionFormat = OMX_IMAGE_CodingJPEG;*/
1990
1991 OMX_PRINT1(*dbg, "Inside JPEG JPEGENC_VerifyTunnelConnection..\n");
1992 sPortDef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
1993 sPortDef.nVersion.s.nVersionMajor = 0x1;
1994 sPortDef.nVersion.s.nVersionMinor = 0x0;
1995 sPortDef.nPortIndex = pPort->nTunnelPort;
1996
1997 eError = OMX_GetParameter(hTunneledComp, OMX_IndexParamPortDefinition, &sPortDef);
1998 if (eError != OMX_ErrorNone) {
1999 OMX_ERROR4(*dbg, "error 1\n");
2000 return eError;
2001 }
2002
2003 switch(pPort->pPortDef->eDomain) {
2004 case OMX_PortDomainOther:
2005 if (sPortDef.format.other.eFormat!= pPortDef->format.other.eFormat) {
2006 pPort->hTunnelComponent = 0;
2007 pPort->nTunnelPort = 0;
2008 return OMX_ErrorPortsNotCompatible;
2009 }
2010 break;
2011 case OMX_PortDomainAudio:
2012 if (sPortDef.format.audio.eEncoding != pPortDef->format.audio.eEncoding) {
2013 pPort->hTunnelComponent = 0;
2014 pPort->nTunnelPort = 0;
2015 return OMX_ErrorPortsNotCompatible;
2016 }
2017 break;
2018 case OMX_PortDomainVideo:
2019 if (sPortDef.format.video.eCompressionFormat != pPortDef->format.video.eCompressionFormat) {
2020 pPort->hTunnelComponent = 0;
2021 pPort->nTunnelPort = 0;
2022 return OMX_ErrorPortsNotCompatible;
2023 }
2024 break;
2025 case OMX_PortDomainImage:
2026 if (sPortDef.format.image.eCompressionFormat != pPortDef->format.image.eCompressionFormat) {
2027 pPort->hTunnelComponent = 0;
2028 pPort->nTunnelPort = 0;
2029 return OMX_ErrorPortsNotCompatible;
2030 }
2031 break;
2032 default:
2033 pPort->hTunnelComponent = 0;
2034 pPort->nTunnelPort = 0;
2035 return OMX_ErrorPortsNotCompatible; /* Our current port is not set up correctly */
2036 }
2037 return eError;
2038 }
2039
2040 /*-------------------------------------------------------------------*/
2041 /**
2042 * JPEGENC_ComponentTunnelRequest() Sets application callbacks to the component
2043 *
2044 * This method will update application callbacks
2045 * the application.
2046 *
2047 * @param hComp handle for this instance of the component
2048 * @param nPortInput
2049 * @param hTunneledComp
2050 * @param nTunneledPort
2051 * @param eDir
2052 * @param pCallbacks
2053 *
2054 * @retval OMX_NoError Success, ready to roll
2055 * OMX_Error_BadParameter The input parameter pointer is null
2056 *
2057 static OMX_ERRORTYPE JPEGENC_ComponentTunnelRequest (OMX_HANDLETYPE hComp,
2058 OMX_U32 nPortInput,
2059 OMX_HANDLETYPE hTunneledComp,
2060 OMX_U32 nTunneledPort,
2061 OMX_DIRTYPE eDir,
2062 OMX_CALLBACKTYPE* pCallbacks)
2063
2064 -------------------------------------------------------------------*/
2065
JPEGENC_ComponentTunnelRequest(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_U32 nPort,OMX_IN OMX_HANDLETYPE hTunneledComp,OMX_IN OMX_U32 nTunneledPort,OMX_INOUT OMX_TUNNELSETUPTYPE * pTunnelSetup)2066 OMX_ERRORTYPE JPEGENC_ComponentTunnelRequest(OMX_IN OMX_HANDLETYPE hComponent,
2067 OMX_IN OMX_U32 nPort,
2068 OMX_IN OMX_HANDLETYPE hTunneledComp,
2069 OMX_IN OMX_U32 nTunneledPort,
2070 OMX_INOUT OMX_TUNNELSETUPTYPE* pTunnelSetup)
2071 {
2072 OMX_ERRORTYPE eError = OMX_ErrorNone;
2073 OMX_COMPONENTTYPE *pHandle = NULL;
2074 JPEGENC_COMPONENT_PRIVATE *pComponentPrivate = NULL;
2075 OMX_PARAM_BUFFERSUPPLIERTYPE sBufferSupplier;
2076 JPEG_PORT_TYPE *pPortType = NULL;
2077
2078 OMX_CHECK_PARAM(hComponent);
2079
2080
2081 pHandle = (OMX_COMPONENTTYPE *)hComponent;
2082 pComponentPrivate = (JPEGENC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate;
2083 pPortType = pComponentPrivate->pCompPort[nPort];
2084
2085 OMX_PRBUFFER2(pComponentPrivate->dbg, "nPort = %d nTunneledPort = %d\n",(int)nPort, (int)nTunneledPort);
2086
2087 if (pTunnelSetup == NULL || hTunneledComp == 0)
2088 {
2089 /* cancel previous tunnel */
2090 pPortType->hTunnelComponent = 0;
2091 pPortType->nTunnelPort = 0;
2092 pPortType->pBufSupplier = OMX_BufferSupplyUnspecified;
2093 goto EXIT;
2094 }
2095
2096 if (pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->eDir != OMX_DirInput &&
2097 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef->eDir != OMX_DirOutput) {
2098 return OMX_ErrorBadParameter;
2099 }
2100
2101 /* Check if the other component is developed by TI */
2102 if(IsTIOMXComponent(hTunneledComp) != OMX_TRUE)
2103 {
2104 eError = OMX_ErrorTunnelingUnsupported;
2105 goto EXIT;
2106 }
2107
2108 pPortType->hTunnelComponent = hTunneledComp;
2109 pPortType->nTunnelPort = nTunneledPort;
2110 OMX_PRCOMM2(pComponentPrivate->dbg, "PP comp = %x, tunneled comp = %x\n",(int)hComponent, (int)pPortType->hTunnelComponent);
2111
2112 if (pPortType->pPortDef->eDir == OMX_DirOutput) {
2113 /* Component is the output (source of data) */
2114 pTunnelSetup->eSupplier = pPortType->pBufSupplier;
2115 }
2116 else {
2117 /* Component is the input (sink of data) */
2118 eError = JPEGENC_VerifyTunnelConnection(pPortType,
2119 hTunneledComp,
2120 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pPortDef, &(pComponentPrivate->dbg));
2121 if (OMX_ErrorNone != eError) {
2122 OMX_PRCOMM4(pComponentPrivate->dbg, "PP JPEGENC_VerifyTunnelConnection inside JPEGfailed\n");
2123 /* Invalid connection formats. Return eError */
2124 return OMX_ErrorPortsNotCompatible;
2125 }
2126
2127 /* If specified obey output port's preferences. Otherwise choose output */
2128 pPortType->pBufSupplier = pTunnelSetup->eSupplier;
2129 if (OMX_BufferSupplyUnspecified == pPortType->pBufSupplier) {
2130 pPortType->pBufSupplier = pTunnelSetup->eSupplier = OMX_BufferSupplyOutput;
2131 }
2132
2133 /* Tell the output port who the supplier is */
2134 sBufferSupplier.nSize = sizeof(sBufferSupplier);
2135 sBufferSupplier.nVersion.s.nVersionMajor = 0x1;
2136 sBufferSupplier.nVersion.s.nVersionMinor = 0x0;
2137 sBufferSupplier.nPortIndex = nTunneledPort;
2138 sBufferSupplier.eBufferSupplier = pPortType->pBufSupplier;
2139 eError = OMX_SetParameter(hTunneledComp, OMX_IndexParamCompBufferSupplier, &sBufferSupplier);
2140
2141 eError = OMX_GetParameter(hTunneledComp, OMX_IndexParamCompBufferSupplier, &sBufferSupplier);
2142 if (sBufferSupplier.eBufferSupplier != pPortType->pBufSupplier) {
2143 OMX_PRCOMM4(pComponentPrivate->dbg, "- JPEGENC_SetParameter: OMX_IndexParamCompBufferSupplier failed to change setting\n" );
2144 return OMX_ErrorUndefined;
2145 }
2146 }
2147
2148 EXIT:
2149 return eError;
2150 }
2151
2152
2153
2154 /*-------------------------------------------------------------------*/
2155 /**
2156 * JPEGENC_AllocateBuffer()
2157 *
2158 *
2159 *
2160 *
2161 * @param
2162 * @param
2163 * @param
2164 *
2165 * @retval OMX_NoError Success, ready to roll
2166 * OMX_Error_BadParameter The input parameter pointer is null
2167 **/
2168 /*-------------------------------------------------------------------*/
JPEGENC_AllocateBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_INOUT OMX_BUFFERHEADERTYPE ** ppBuffHead,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_PTR pAppPrivate,OMX_IN OMX_U32 nSizeBytes)2169 OMX_ERRORTYPE JPEGENC_AllocateBuffer(OMX_IN OMX_HANDLETYPE hComponent,
2170 OMX_INOUT OMX_BUFFERHEADERTYPE** ppBuffHead,
2171 OMX_IN OMX_U32 nPortIndex,
2172 OMX_IN OMX_PTR pAppPrivate,
2173 OMX_IN OMX_U32 nSizeBytes)
2174 {
2175 OMX_COMPONENTTYPE *pHandle = NULL;
2176 JPEGENC_COMPONENT_PRIVATE *pComponentPrivate = NULL;
2177 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = NULL;
2178 OMX_BUFFERHEADERTYPE *pBufferHdr = NULL;
2179 OMX_U32 nBufferCount = -1;
2180 OMX_ERRORTYPE eError = OMX_ErrorNone;
2181 OMX_U8* pTemp = NULL;
2182
2183 pHandle = (OMX_COMPONENTTYPE *) hComponent;
2184 pComponentPrivate = (JPEGENC_COMPONENT_PRIVATE *)pHandle->pComponentPrivate;
2185 pPortDef = pComponentPrivate->pCompPort[nPortIndex]->pPortDef;
2186 nBufferCount = pComponentPrivate->pCompPort[nPortIndex]->nBuffCount;
2187
2188 if (nBufferCount >= pPortDef->nBufferCountActual) {
2189 eError = OMX_ErrorInsufficientResources;
2190 OMX_PRBUFFER4(pComponentPrivate->dbg, " try to allocate more buffers that the port supports\n");
2191 goto EXIT;
2192 }
2193
2194 if(nPortIndex == JPEGENC_INP_PORT) {
2195 OMX_MALLOC(pBufferHdr, sizeof(OMX_BUFFERHEADERTYPE));
2196 OMX_PRBUFFER2(pComponentPrivate->dbg, "Allocate Buffer Input pBufferPrivate = %p\n",pBufferHdr);
2197
2198 OMX_CONF_INIT_STRUCT(pBufferHdr, OMX_BUFFERHEADERTYPE);
2199 pBufferHdr->nOutputPortIndex = OMX_NOPORT;
2200 pBufferHdr->nInputPortIndex = nPortIndex;
2201 pBufferHdr->nSize = sizeof(OMX_BUFFERHEADERTYPE);
2202 pBufferHdr->nVersion = pPortDef->nVersion;
2203 pBufferHdr->pAppPrivate = pAppPrivate;
2204 pBufferHdr->nAllocLen = nSizeBytes;
2205 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pBufferPrivate[nBufferCount]->bAllocByComponent = OMX_TRUE;
2206 pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->pBufferPrivate[nBufferCount]->pBufferHdr = pBufferHdr;
2207 *ppBuffHead = pBufferHdr;
2208 }
2209 else if(nPortIndex == JPEGENC_OUT_PORT) {
2210 OMX_MALLOC(pBufferHdr, sizeof(OMX_BUFFERHEADERTYPE));
2211 OMX_PRBUFFER2(pComponentPrivate->dbg, "Allocate Buffer Output pBufferPrivate[0] = %p\n", pBufferHdr);
2212 OMX_CONF_INIT_STRUCT(pBufferHdr, OMX_BUFFERHEADERTYPE);
2213 pBufferHdr->nInputPortIndex = OMX_NOPORT;
2214 pBufferHdr->nOutputPortIndex = nPortIndex;
2215 pBufferHdr->nSize = sizeof(OMX_BUFFERHEADERTYPE);
2216 pBufferHdr->nVersion = pPortDef->nVersion;
2217 pBufferHdr->pAppPrivate = pAppPrivate;
2218 pBufferHdr->nAllocLen = nSizeBytes;
2219 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pBufferPrivate[nBufferCount]->bAllocByComponent = OMX_TRUE;
2220 pComponentPrivate->pCompPort[JPEGENC_OUT_PORT]->pBufferPrivate[nBufferCount]->pBufferHdr = pBufferHdr;
2221 *ppBuffHead = pBufferHdr;
2222 }
2223 else {
2224 eError = OMX_ErrorBadPortIndex;
2225 goto EXIT;
2226 }
2227
2228 OMX_MALLOC(pBufferHdr->pBuffer, nSizeBytes+256);
2229
2230 #ifdef __PERF_INSTRUMENTATION__
2231 PERF_ReceivedFrame(pComponentPrivate->pPERF,
2232 pBufferHdr->pBuffer,
2233 pBufferHdr->nFilledLen,
2234 PERF_ModuleMemory);
2235 #endif
2236
2237 if (!pBufferHdr->pBuffer) {
2238 OMX_TRACE4(pComponentPrivate->dbg, "Error: Malloc failed\n");
2239 eError = OMX_ErrorInsufficientResources;
2240 goto EXIT;
2241 }
2242
2243
2244 pTemp = (OMX_U8 *)(pBufferHdr->pBuffer);
2245 pTemp += 128;
2246 pBufferHdr->pBuffer = pTemp;
2247 OMX_PRBUFFER2(pComponentPrivate->dbg, "Allocate Buffer Input pBufferPrivate[0]-pBuffer = %p\n",pBufferHdr->pBuffer);
2248
2249
2250 if (nPortIndex == JPEGENC_INP_PORT) {
2251 pBufferHdr->pInputPortPrivate = pComponentPrivate->pCompPort[nPortIndex]->pBufferPrivate[nBufferCount];
2252 }
2253 else {
2254 pBufferHdr->pOutputPortPrivate = pComponentPrivate->pCompPort[nPortIndex]->pBufferPrivate[nBufferCount];
2255 }
2256
2257 /** The following 6 lines need to be changed **/
2258 if (pComponentPrivate->pCompPort[JPEGENC_INP_PORT]->hTunnelComponent != NULL) {
2259 pComponentPrivate->pCompPort[nPortIndex]->pBufferPrivate[nBufferCount]->eBufferOwner = JPEGENC_BUFFER_TUNNEL_COMPONENT;
2260 }
2261 else {
2262 pComponentPrivate->pCompPort[nPortIndex]->pBufferPrivate[nBufferCount]->eBufferOwner = JPEGENC_BUFFER_CLIENT;
2263 }
2264
2265
2266 pComponentPrivate->pCompPort[nPortIndex]->nBuffCount++;
2267 OMX_PRBUFFER2(pComponentPrivate->dbg, "JPEG-ENC: actual %d ask %lu\n",
2268 pComponentPrivate->pCompPort[nPortIndex]->nBuffCount,
2269 pPortDef->nBufferCountActual);
2270
2271 if (pComponentPrivate->pCompPort[nPortIndex]->nBuffCount == pPortDef->nBufferCountActual) {
2272 pPortDef->bPopulated = OMX_TRUE;
2273
2274 pthread_mutex_lock(&pComponentPrivate->jpege_mutex_app);
2275 pthread_cond_signal(&pComponentPrivate->populate_cond);
2276 pthread_mutex_unlock(&pComponentPrivate->jpege_mutex_app);
2277
2278 JPEGENC_InitBufferFlagTrack(pComponentPrivate, nPortIndex);
2279 OMX_PRBUFFER2(pComponentPrivate->dbg, " Port [%d] Populated!\n", (int)(nPortIndex));
2280 }
2281
2282 EXIT:
2283 OMX_PRINT1(pComponentPrivate->dbg, "Exiting pHandle = %d\n", (int)pHandle);
2284 return eError;
2285 }
2286
2287
JPEGENC_InitBufferFlagTrack(JPEGENC_COMPONENT_PRIVATE * pComponentPrivate,OMX_U32 nPortIndex)2288 static void JPEGENC_InitBufferFlagTrack(
2289 JPEGENC_COMPONENT_PRIVATE *pComponentPrivate,
2290 OMX_U32 nPortIndex)
2291
2292 {
2293 JPEG_PORT_TYPE *pPortType = NULL;
2294 int i;
2295
2296 pPortType = pComponentPrivate->pCompPort[nPortIndex];
2297
2298 /* assume pPortType->pPortDef->nBufferCountActual <= NUM_OF_BUFFERSJPEG */
2299 for (i = 0; i < (int)(pPortType->pPortDef->nBufferCountActual); i ++) {
2300 pPortType->sBufferFlagTrack[i].flag = 0;
2301 pPortType->sBufferFlagTrack[i].buffer_id = 0xFFFFFFFF;
2302 pPortType->sBufferMarkTrack[i].buffer_id = 0xFFFFFFFF;
2303 pPortType->sBufferMarkTrack[i].pMarkData = NULL;
2304 }
2305 }
2306
2307 #ifdef KHRONOS_1_1
2308
ComponentRoleEnum(OMX_IN OMX_HANDLETYPE hComponent,OMX_OUT OMX_U8 * cRole,OMX_IN OMX_U32 nIndex)2309 static OMX_ERRORTYPE ComponentRoleEnum(
2310 OMX_IN OMX_HANDLETYPE hComponent,
2311 OMX_OUT OMX_U8 *cRole,
2312 OMX_IN OMX_U32 nIndex)
2313 {
2314 JPEGENC_COMPONENT_PRIVATE *pComponentPrivate;
2315
2316 OMX_ERRORTYPE eError = OMX_ErrorNone;
2317 pComponentPrivate = (JPEGENC_COMPONENT_PRIVATE *)(((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate);
2318
2319 if(nIndex == 0){
2320 /* memcpy(cRole, &(pComponentPrivate->componentRole.cRole), sizeof(OMX_U8) * OMX_MAX_STRINGNAME_SIZE - 1); */
2321 strncpy((char *)cRole, (char *)pComponentPrivate->componentRole.cRole, sizeof(OMX_U8) * OMX_MAX_STRINGNAME_SIZE - 1);
2322 }
2323 else {
2324 eError = OMX_ErrorNoMore;
2325 }
2326
2327 return eError;
2328 };
2329 #endif
2330
2331
2332 /*-------------------------------------------------------------------*/
2333 /**
2334 * JPEGENC_GetExtensionIndex()
2335 *
2336 * Return the index corresponding to the string.
2337 *
2338 * @retval OMX_ErrorNone Successful operation.
2339 * OMX_ErrorUnsupportedIndex If no index corresponding to the string is found
2340 **/
2341 /*-------------------------------------------------------------------*/
JPEGENC_GetExtensionIndex(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_STRING cParameterName,OMX_OUT OMX_INDEXTYPE * pIndexType)2342 OMX_ERRORTYPE JPEGENC_GetExtensionIndex(OMX_IN OMX_HANDLETYPE hComponent, OMX_IN OMX_STRING cParameterName, OMX_OUT OMX_INDEXTYPE* pIndexType)
2343 {
2344 OMX_U16 nIndex;
2345 OMX_ERRORTYPE eError = OMX_ErrorUndefined;
2346 JPEGENC_CUSTOM_PARAM_DEFINITION sJpegEncCustomParams[] = {
2347 {"OMX.TI.JPEG.encoder.Config.HuffmanTable", OMX_IndexCustomHuffmanTable},
2348 {"OMX.TI.JPEG.encoder.Config.CommentFlag", OMX_IndexCustomCommentFlag},
2349 {"OMX.TI.JPEG.encoder.Config.CommentString", OMX_IndexCustomCommentString},
2350 {"OMX.TI.JPEG.encoder.Config.InputFrameWidth", OMX_IndexCustomInputFrameWidth},
2351 {"OMX.TI.JPEG.encoder.Config.InputFrameHeight", OMX_IndexCustomInputFrameHeight},
2352 {"OMX.TI.JPEG.encoder.Config.APP0", OMX_IndexCustomAPP0},
2353 {"OMX.TI.JPEG.encoder.Config.APP1", OMX_IndexCustomAPP1},
2354 {"OMX.TI.JPEG.encoder.Config.APP5", OMX_IndexCustomAPP5},
2355 {"OMX.TI.JPEG.encoder.Config.APP13", OMX_IndexCustomAPP13},
2356 {"OMX.TI.JPEG.encoder.Config.QFactor", OMX_IndexCustomQFactor},
2357 {"OMX.TI.JPEG.encoder.Config.DRI", OMX_IndexCustomDRI},
2358 {"OMX.TI.JPEG.encoder.Config.Debug", OMX_IndexCustomDebug},
2359 {"OMX.TI.JPEG.encoder.Config.ColorFormatConvertion_420pTo422i", OMX_IndexCustomColorFormatConvertion_420pTo422i},
2360 {"OMX.TI.JPEG.encoder.Config.PPLibEnable", OMX_IndexCustomPPLibEnable},
2361 {"",0x0}
2362 };
2363
2364 /* Check parameter validity */
2365 OMX_CHECK_PARAM(hComponent);
2366 OMX_CHECK_PARAM(pIndexType);
2367 *pIndexType = OMX_IndexMax;
2368
2369 const OMX_U32 nExtensions = sizeof(sJpegEncCustomParams)/sizeof(JPEGENC_CUSTOM_PARAM_DEFINITION);
2370 for (nIndex = 0; nIndex < nExtensions; ++nIndex) {
2371 if (!strcmp((const char*)cParameterName, (const char*)(&(sJpegEncCustomParams[nIndex].cCustomParamName)))){
2372 *pIndexType = sJpegEncCustomParams[nIndex].nCustomParamIndex;
2373 eError = OMX_ErrorNone;
2374 break;
2375 }
2376 }
2377
2378 if(*pIndexType == OMX_IndexMax){
2379 eError = OMX_ErrorUnsupportedIndex;
2380 }
2381
2382 EXIT:
2383 return eError;
2384 }
2385
2386
2387
2388
