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_VideoEncoder.c
30 *
31 * This file implements OMX Component for MPEG-4 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 *! 24-Jul-2005 mf: Revisions appear in reverse chronological order;
45 *! that is, newest first. The date format is dd-Mon-yyyy.
46 * ============================================================================*/
47
48 /* ------compilation control switches ----------------------------------------*/
49 /******************************************************************************
50 * INCLUDE FILES
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 <wchar.h>
59 #include <unistd.h>
60 #include <sys/time.h>
61 #include <sys/types.h>
62 #include <sys/ioctl.h>
63 #include <sys/select.h>
64 #include <errno.h>
65 #include <pthread.h>
66 #include <dlfcn.h>
67 #endif
68
69 #include <string.h>
70 #include <fcntl.h>
71 #include <stdlib.h>
72 #include <stdio.h>
73 #include <dbapi.h>
74
75 /*------- Program Header Files -----------------------------------------------*/
76 #include "OMX_VideoEnc_Utils.h"
77 #include "OMX_VideoEnc_DSP.h"
78 #include "OMX_VideoEnc_Thread.h"
79
80 #ifdef RESOURCE_MANAGER_ENABLED
81 #include <ResourceManagerProxyAPI.h>
82 #endif
83 #ifdef UNDER_CE
84 extern HINSTANCE g_hLcmlDllHandle;
85 #endif
86 /* H.263 Supported Levels & profiles */
87 VIDEO_PROFILE_LEVEL_TYPE SupportedH263ProfileLevels[] = {
88 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level10},
89 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level20},
90 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level30},
91 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level40},
92 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level45},
93 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level50},
94 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level60},
95 {OMX_VIDEO_H263ProfileBaseline, OMX_VIDEO_H263Level70},
96 {-1, -1}};
97
98 /* MPEG4 Supported Levels & profiles */
99 VIDEO_PROFILE_LEVEL_TYPE SupportedMPEG4ProfileLevels[] ={
100 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level0},
101 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level0b},
102 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level1},
103 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level2},
104 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level3},
105 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level4},
106 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level4a},
107 {OMX_VIDEO_MPEG4ProfileSimple, OMX_VIDEO_MPEG4Level5},
108 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level0},
109 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level0b},
110 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level1},
111 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level2},
112 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level3},
113 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level4},
114 {OMX_VIDEO_MPEG4ProfileAdvancedSimple, OMX_VIDEO_MPEG4Level5},
115 {-1,-1}};
116
117 /* AVC Supported Levels & profiles */
118 VIDEO_PROFILE_LEVEL_TYPE SupportedAVCProfileLevels[] ={
119 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel1},
120 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel1b},
121 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel11},
122 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel12},
123 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel13},
124 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel2},
125 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel21},
126 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel22},
127 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel3},
128 {OMX_VIDEO_AVCProfileBaseline, OMX_VIDEO_AVCLevel31},
129 {-1,-1}};
130 /******************************************************************************
131 * EXTERNAL REFERENCES NOTE : only use if not found in header file
132 *******************************************************************************/
133 /*--------data declarations --------------------------------------------------*/
134 /*--------function prototypes ------------------------------------------------*/
135
136 /******************************************************************************
137 * PUBLIC DECLARATIONS Defined here, used elsewhere
138 *******************************************************************************/
139 /*--------data declarations --------------------------------------------------*/
140 /*--------function prototypes ------------------------------------------------*/
141 #ifndef UNDER_CE
142 OMX_ERRORTYPE OMX_ComponentInit(OMX_HANDLETYPE hComp);
143 #else
144 #define OMX_EXPORT __declspec(dllexport)
145 OMX_EXPORT OMX_ERRORTYPE OMX_ComponentInit (OMX_HANDLETYPE hComp);
146 #endif
147
148 /******************************************************************************
149 * PRIVATE DECLARATIONS Defined here, used only here
150 *******************************************************************************/
151 /*--------data declarations --------------------------------------------------*/
152 #ifdef UNDER_CE
153 static pthread_t ComponentThread;
154 #endif
155 /*--------macro definitions --------------------------------------------------*/
156 #define OMX_CONVERT_STATE(_s_, _p_) \
157 if (_p_ == 0) { \
158 _s_ = "OMX_StateInvalid"; \
159 } \
160 else if (_p_ == 1) { \
161 _s_ = "OMX_StateLoaded"; \
162 } \
163 else if (_p_ == 2) { \
164 _s_ = "OMX_StateIdle"; \
165 } \
166 else if (_p_ == 3) { \
167 _s_ = "OMX_StateExecuting"; \
168 } \
169 else if (_p_ == 4) { \
170 _s_ = "OMX_StatePause"; \
171 } \
172 else if (_p_ == 5) { \
173 _s_ = "OMX_StateWaitForResources"; \
174 } \
175 else { \
176 _s_ = "UnsupportedCommand"; \
177 }
178
179 #define OMX_CONVERT_CMD(_s_, _p_) \
180 if (_p_ == 0) { \
181 _s_ = "OMX_CommandStateSet"; \
182 } \
183 else if (_p_ == 1) { \
184 _s_ = "OMX_CommandFlush"; \
185 } \
186 else if (_p_ == 2) { \
187 _s_ = "OMX_CommandPortDisable"; \
188 } \
189 else if (_p_ == 3) { \
190 _s_ = "OMX_CommandPortEnable"; \
191 } \
192 else if (_p_ == 4) { \
193 _s_ = "OMX_CommandMarkBuffer"; \
194 } \
195 else { \
196 _s_ = "UnsupportedCommand"; \
197 }
198
199 /*--------function prototypes ------------------------------------------------*/
200 static OMX_ERRORTYPE SetCallbacks (OMX_IN OMX_HANDLETYPE hComponent,
201 OMX_IN OMX_CALLBACKTYPE* pCallBacks,
202 OMX_IN OMX_PTR pAppData);
203
204 static OMX_ERRORTYPE GetComponentVersion (OMX_HANDLETYPE hComponent,
205 OMX_STRING szComponentName,
206 OMX_VERSIONTYPE* pComponentVersion,
207 OMX_VERSIONTYPE* pSpecVersion,
208 OMX_UUIDTYPE* pComponentUUID);
209
210 static OMX_ERRORTYPE SendCommand (OMX_IN OMX_HANDLETYPE hComponent,
211 OMX_IN OMX_COMMANDTYPE Cmd,
212 OMX_IN OMX_U32 nParam1,
213 OMX_IN OMX_PTR pCmdData);
214
215 static OMX_ERRORTYPE GetParameter (OMX_IN OMX_HANDLETYPE hComponent,
216 OMX_IN OMX_INDEXTYPE nParamIndex,
217 OMX_INOUT OMX_PTR CompParamStruct);
218
219 static OMX_ERRORTYPE SetParameter (OMX_IN OMX_HANDLETYPE hComponent,
220 OMX_IN OMX_INDEXTYPE nParamIndex,
221 OMX_IN OMX_PTR CompParamStruct);
222
223 static OMX_ERRORTYPE GetConfig (OMX_HANDLETYPE hComponent,
224 OMX_INDEXTYPE nConfigIndex,
225 OMX_PTR ComponentConfigStructure);
226
227 static OMX_ERRORTYPE SetConfig (OMX_HANDLETYPE hComponent,
228 OMX_INDEXTYPE nConfigIndex,
229 OMX_PTR ComponentConfigStructure);
230
231 static OMX_ERRORTYPE EmptyThisBuffer (OMX_IN OMX_HANDLETYPE hComponent,
232 OMX_IN OMX_BUFFERHEADERTYPE* pBuffer);
233
234 static OMX_ERRORTYPE FillThisBuffer (OMX_IN OMX_HANDLETYPE hComponent,
235 OMX_IN OMX_BUFFERHEADERTYPE* pBuffer);
236
237 static OMX_ERRORTYPE GetState (OMX_IN OMX_HANDLETYPE hComponent,
238 OMX_OUT OMX_STATETYPE* pState);
239
240 static OMX_ERRORTYPE ComponentTunnelRequest (OMX_IN OMX_HANDLETYPE hComponent,
241 OMX_IN OMX_U32 nPort,
242 OMX_IN OMX_HANDLETYPE hTunneledComp,
243 OMX_IN OMX_U32 nTunneledPort,
244 OMX_INOUT OMX_TUNNELSETUPTYPE* pTunnelSetup);
245
246 static OMX_ERRORTYPE UseBuffer (OMX_IN OMX_HANDLETYPE hComponent,
247 OMX_INOUT OMX_BUFFERHEADERTYPE** ppBufferHdr,
248 OMX_IN OMX_U32 nPortIndex,
249 OMX_IN OMX_PTR pAppPrivate,
250 OMX_IN OMX_U32 nSizeBytes,
251 OMX_IN OMX_U8* pBuffer);
252
253 static OMX_ERRORTYPE AllocateBuffer (OMX_IN OMX_HANDLETYPE hComponent,
254 OMX_INOUT OMX_BUFFERHEADERTYPE** pBuffer,
255 OMX_IN OMX_U32 nPortIndex,
256 OMX_IN OMX_PTR pAppPrivate,
257 OMX_IN OMX_U32 nSizeBytes);
258
259 static OMX_ERRORTYPE FreeBuffer (OMX_IN OMX_HANDLETYPE hComponent,
260 OMX_IN OMX_U32 nPortIndex,
261 OMX_IN OMX_BUFFERHEADERTYPE* pBuffer);
262
263 static OMX_ERRORTYPE ComponentDeInit (OMX_IN OMX_HANDLETYPE hComponent);
264
265 static OMX_ERRORTYPE VerifyTunnelConnection (VIDEOENC_PORT_TYPE* pPort,
266 OMX_HANDLETYPE hTunneledComp,
267 OMX_PARAM_PORTDEFINITIONTYPE* pPortDef,
268 struct OMX_TI_Debug *dbg);
269
270 static OMX_ERRORTYPE ExtensionIndex (OMX_IN OMX_HANDLETYPE hComponent,
271 OMX_IN OMX_STRING cParameterName,
272 OMX_OUT OMX_INDEXTYPE* pIndexType);
273
274 #ifdef __KHRONOS_CONF_1_1__
275 static OMX_ERRORTYPE ComponentRoleEnum(OMX_IN OMX_HANDLETYPE hComponent,
276 OMX_OUT OMX_U8 *cRole,
277 OMX_IN OMX_U32 nIndex);
278 #endif
279
280 void CalculateBufferSize(OMX_PARAM_PORTDEFINITIONTYPE* pCompPort, VIDENC_COMPONENT_PRIVATE* pCompPrivate);
281 OMX_ERRORTYPE IsResolutionPlayable (OMX_U32 width, OMX_U32 height);
282
283 static const int iQ16_Const = 1 << 16;
284 static const float fQ16_Const = (float)(1 << 16);
285
Q16Tof(int nQ16)286 static float Q16Tof(int nQ16)
287 {
288 return nQ16 / fQ16_Const;
289 }
290
fToQ16(float f)291 static int fToQ16(float f)
292 {
293 return(int)(f*fQ16_Const);
294 }
295
296 extern OMX_U32 VIDENC_STRUCT_H264DEFBITRATE [VIDENC_MAXBITRATES][2];
297 extern OMX_U32 VIDENC_STRUCT_MPEG4DEFBITRATE [VIDENC_MAXBITRATES][2];
298 extern OMX_U32 VIDENC_STRUCT_H263DEFBITRATE [VIDENC_MAXBITRATES][2];
299
300 /*----------------------------------------------------------------------------*/
301 /**
302 * OMX_ComponentInit() Set the all the function pointers of component
303 *
304 * This method will update the component function pointer to the handle
305 *
306 * @param hComp handle for this instance of the component
307 *
308 * @retval OMX_NoError Success, ready to roll
309 * OMX_ErrorInsufficientResources If the malloc fails
310 **/
311 /*----------------------------------------------------------------------------*/
312
313 #ifdef UNDER_CE
314 OMX_EXPORT
315 #endif
OMX_ComponentInit(OMX_HANDLETYPE hComponent)316 OMX_ERRORTYPE OMX_ComponentInit (OMX_HANDLETYPE hComponent)
317 {
318 OMX_COMPONENTTYPE* pHandle = NULL;
319 OMX_ERRORTYPE eError = OMX_ErrorNone;
320 VIDENC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
321 VIDEOENC_PORT_TYPE* pCompPortIn = NULL;
322 VIDEOENC_PORT_TYPE* pCompPortOut = NULL;
323 OMX_PARAM_PORTDEFINITIONTYPE* pPortDef = NULL;
324 OMX_VIDEO_PARAM_PORTFORMATTYPE* pPortFormat = NULL;
325 OMX_PRIORITYMGMTTYPE* pPriorityMgmt = NULL;
326 VIDENC_NODE* pMemoryListHead = NULL;
327 struct OMX_TI_Debug dbg;
328
329 OMX_S32 nError = 0;
330 OMX_U32 i = 0;
331 char* sDynamicFormat;
332 #ifdef UNDER_CE
333 pthread_attr_t attr;
334 memset(&attr, 0, sizeof(attr));
335 #endif
336
337
338 /* get default settings for debug */
339 OMX_DBG_INIT(dbg, "OMX_DBG_VIDENC");
340
341 /*dlopen("libLCML.so", RTLD_LAZY);*/
342 OMX_PRINT2(dbg, "Enter to ComponetInit\n");
343 if (!hComponent)
344 {
345 eError = OMX_ErrorBadParameter;
346 goto OMX_CONF_CMD_BAIL;
347 }
348 pHandle = (OMX_COMPONENTTYPE*)hComponent;
349 eError = OMX_VIDENC_ListCreate(&dbg, &pMemoryListHead);
350 OMX_CONF_BAIL_IF_ERROR(eError);
351
352 /* Allocate memory for component's private data area */
353 VIDENC_MALLOC(pHandle->pComponentPrivate,
354 sizeof(VIDENC_COMPONENT_PRIVATE),
355 VIDENC_COMPONENT_PRIVATE,
356 pMemoryListHead, dbg);
357
358 pComponentPrivate = (VIDENC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate;
359 pComponentPrivate->pMemoryListHead = pMemoryListHead;
360
361 pComponentPrivate->dbg = dbg;
362 pComponentPrivate->compressionFormats[0]=OMX_VIDEO_CodingAVC;
363 pComponentPrivate->compressionFormats[1]=OMX_VIDEO_CodingMPEG4;
364 pComponentPrivate->compressionFormats[2]=OMX_VIDEO_CodingH263;
365 pComponentPrivate->colorFormats[0]=OMX_COLOR_FormatYUV420Planar;
366 pComponentPrivate->colorFormats[1]=OMX_COLOR_FormatYCbYCr;
367 pComponentPrivate->colorFormats[2]=OMX_COLOR_FormatCbYCrY;
368
369 #ifdef __PERF_INSTRUMENTATION__
370 pComponentPrivate->pPERF = PERF_Create(PERF_FOURCC('V','E',' ',' '),
371 PERF_ModuleLLMM |
372 PERF_ModuleVideoEncode);
373 #endif
374
375 pComponentPrivate->bDeblockFilter = OMX_TRUE;
376 pComponentPrivate->nVBVSize = 120;
377 pComponentPrivate->bForceIFrame = OMX_FALSE;
378 pComponentPrivate->nIntraFrameInterval = 30;
379 pComponentPrivate->nQPI = 12;
380 pComponentPrivate->nAIRRate = 0;
381 pComponentPrivate->ucUnrestrictedMV = 0;
382 pComponentPrivate->bHideEvents = OMX_FALSE;
383 pComponentPrivate->bHandlingFatalError = OMX_FALSE;
384 pComponentPrivate->bUnresponsiveDsp = OMX_FALSE;
385 pComponentPrivate->bCodecLoaded = OMX_FALSE;
386 pComponentPrivate->cComponentName = "OMX.TI.Video.encoder";
387 pComponentPrivate->sps = NULL;
388 pComponentPrivate->spsLen = 0;
389
390 #ifdef __KHRONOS_CONF__
391 pComponentPrivate->bPassingIdleToLoaded = OMX_FALSE;
392 pComponentPrivate->bErrorLcmlHandle = OMX_FALSE;
393 #endif
394
395 /*Initialize Circular Buffer*/
396 OMX_CONF_CIRCULAR_BUFFER_INIT(pComponentPrivate);
397
398 /* ASO/FMO*/
399 pComponentPrivate->numSliceASO = 0;
400 for( i=0; i<MAXNUMSLCGPS;i++)
401 {
402 pComponentPrivate->asoSliceOrder[i] = 0;
403 }
404 pComponentPrivate->numSliceGroups = 0;
405 pComponentPrivate->sliceGroupMapType = 0;
406 pComponentPrivate->sliceGroupChangeDirectionFlag = 0;
407 pComponentPrivate->sliceGroupChangeRate = 0;
408 pComponentPrivate->sliceGroupChangeCycle = 0;
409 for( i=0; i<MAXNUMSLCGPS;i++)
410 {
411 pComponentPrivate->sliceGroupParams[i] = 0;
412 }
413
414 /*Assigning address of Component Structure point to place holder inside
415 component private structure
416 */
417 ((VIDENC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate)->pHandle = pHandle;
418
419 /* fill in function pointers */
420 pHandle->SetCallbacks = SetCallbacks;
421 pHandle->GetComponentVersion = GetComponentVersion;
422 pHandle->SendCommand = SendCommand;
423 pHandle->GetParameter = GetParameter;
424 pHandle->SetParameter = SetParameter;
425 pHandle->GetConfig = GetConfig;
426 pHandle->SetConfig = SetConfig;
427 pHandle->GetExtensionIndex = ExtensionIndex;
428 pHandle->GetState = GetState;
429 pHandle->ComponentTunnelRequest = ComponentTunnelRequest;
430 pHandle->UseBuffer = UseBuffer;
431 pHandle->AllocateBuffer = AllocateBuffer;
432 pHandle->FreeBuffer = FreeBuffer;
433 pHandle->EmptyThisBuffer = EmptyThisBuffer;
434 pHandle->FillThisBuffer = FillThisBuffer;
435 pHandle->ComponentDeInit = ComponentDeInit;
436 #ifdef __KHRONOS_CONF_1_1__
437 pHandle->ComponentRoleEnum = ComponentRoleEnum;
438
439 sDynamicFormat = getenv("FORMAT");
440 /*printf("\n ** FORMAT = %s\n\n", sDynamicFormat);*/
441 #if 1
442 if (sDynamicFormat != NULL)
443 {
444 if ( strcmp(sDynamicFormat, "MPEG4") == 0 )
445 {
446
447 strcpy((char *)pComponentPrivate->componentRole.cRole, "video_encoder.mpeg4");
448 }
449 else if (strcmp(sDynamicFormat, "H263") == 0 )
450 {
451 strcpy((char *)pComponentPrivate->componentRole.cRole, "video_encoder.h263");
452 }
453 else if (strcmp(sDynamicFormat, "H264") == 0 )
454 {
455 strcpy((char *)pComponentPrivate->componentRole.cRole, "video_encoder.avc");
456 }
457 }
458 else
459 {
460 strcpy((char *)pComponentPrivate->componentRole.cRole, "video_encoder.avc");
461 }
462 #else
463 strcpy((char *)pComponentPrivate->componentRole.cRole, "VideoEncode");
464 /* strcpy((char *)pComponentPrivate->componentRole.cRole, "video_encoder.mpeg4");*/
465 #endif
466 #endif
467
468 /* Allocate memory for component data structures */
469 VIDENC_MALLOC(pComponentPrivate->pPortParamType,
470 sizeof(OMX_PORT_PARAM_TYPE),
471 OMX_PORT_PARAM_TYPE,
472 pMemoryListHead, dbg);
473 #ifdef __KHRONOS_CONF_1_1__
474 VIDENC_MALLOC(pComponentPrivate->pPortAudioType,
475 sizeof(OMX_PORT_PARAM_TYPE),
476 OMX_PORT_PARAM_TYPE,
477 pMemoryListHead, dbg);
478 VIDENC_MALLOC(pComponentPrivate->pPortImageType,
479 sizeof(OMX_PORT_PARAM_TYPE),
480 OMX_PORT_PARAM_TYPE,
481 pMemoryListHead, dbg);
482 VIDENC_MALLOC(pComponentPrivate->pPortOtherType,
483 sizeof(OMX_PORT_PARAM_TYPE),
484 OMX_PORT_PARAM_TYPE,
485 pMemoryListHead, dbg);
486 #endif
487
488
489 VIDENC_MALLOC(pComponentPrivate->pCompPort[VIDENC_INPUT_PORT],
490 sizeof(VIDEOENC_PORT_TYPE),
491 VIDEOENC_PORT_TYPE,
492 pMemoryListHead, dbg);
493 VIDENC_MALLOC(pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT],
494 sizeof(VIDEOENC_PORT_TYPE),
495 VIDEOENC_PORT_TYPE,
496 pMemoryListHead, dbg);
497 VIDENC_MALLOC(pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->pPortDef,
498 sizeof(OMX_PARAM_PORTDEFINITIONTYPE),
499 OMX_PARAM_PORTDEFINITIONTYPE,
500 pMemoryListHead, dbg);
501 VIDENC_MALLOC(pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortDef,
502 sizeof(OMX_PARAM_PORTDEFINITIONTYPE),
503 OMX_PARAM_PORTDEFINITIONTYPE,
504 pMemoryListHead, dbg);
505 VIDENC_MALLOC(pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->pPortFormat,
506 sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE),
507 OMX_VIDEO_PARAM_PORTFORMATTYPE,
508 pMemoryListHead, dbg);
509 VIDENC_MALLOC(pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortFormat,
510 sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE),
511 OMX_VIDEO_PARAM_PORTFORMATTYPE,
512 pMemoryListHead, dbg);
513 #ifdef __KHRONOS_CONF_1_1__
514 VIDENC_MALLOC(pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->pProfileType,
515 sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE),
516 OMX_VIDEO_PARAM_PROFILELEVELTYPE,
517 pMemoryListHead, dbg);
518 VIDENC_MALLOC(pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pProfileType,
519 sizeof(OMX_VIDEO_PARAM_PROFILELEVELTYPE),
520 OMX_VIDEO_PARAM_PROFILELEVELTYPE,
521 pMemoryListHead, dbg);
522 VIDENC_MALLOC(pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->pBitRateTypeConfig,
523 sizeof(OMX_VIDEO_CONFIG_BITRATETYPE),
524 OMX_VIDEO_CONFIG_BITRATETYPE,
525 pMemoryListHead, dbg);
526 VIDENC_MALLOC(pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pBitRateTypeConfig,
527 sizeof(OMX_VIDEO_CONFIG_BITRATETYPE),
528 OMX_VIDEO_CONFIG_BITRATETYPE,
529 pMemoryListHead, dbg);
530 VIDENC_MALLOC(pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->pFrameRateConfig,
531 sizeof(OMX_CONFIG_FRAMERATETYPE),
532 OMX_CONFIG_FRAMERATETYPE,
533 pMemoryListHead, dbg);
534 VIDENC_MALLOC(pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pFrameRateConfig,
535 sizeof(OMX_CONFIG_FRAMERATETYPE),
536 OMX_CONFIG_FRAMERATETYPE,
537 pMemoryListHead, dbg);
538 VIDENC_MALLOC(pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pErrorCorrectionType,
539 sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE),
540 OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE,
541 pMemoryListHead, dbg);
542 VIDENC_MALLOC(pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pIntraRefreshType,
543 sizeof(OMX_VIDEO_PARAM_INTRAREFRESHTYPE),
544 OMX_VIDEO_PARAM_INTRAREFRESHTYPE,
545 pMemoryListHead, dbg);
546 #endif
547 VIDENC_MALLOC(pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->pBitRateType,
548 sizeof(OMX_VIDEO_PARAM_BITRATETYPE),
549 OMX_VIDEO_PARAM_BITRATETYPE,
550 pMemoryListHead, dbg);
551 VIDENC_MALLOC(pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pBitRateType,
552 sizeof(OMX_VIDEO_PARAM_BITRATETYPE),
553 OMX_VIDEO_PARAM_BITRATETYPE,
554 pMemoryListHead, dbg);
555 VIDENC_MALLOC(pComponentPrivate->pPriorityMgmt,
556 sizeof(OMX_PRIORITYMGMTTYPE),
557 OMX_PRIORITYMGMTTYPE,
558 pMemoryListHead, dbg);
559 VIDENC_MALLOC(pComponentPrivate->pH264,
560 sizeof(OMX_VIDEO_PARAM_AVCTYPE),
561 OMX_VIDEO_PARAM_AVCTYPE,
562 pMemoryListHead, dbg);
563 VIDENC_MALLOC(pComponentPrivate->pMpeg4,
564 sizeof(OMX_VIDEO_PARAM_MPEG4TYPE),
565 OMX_VIDEO_PARAM_MPEG4TYPE,
566 pMemoryListHead, dbg);
567 VIDENC_MALLOC(pComponentPrivate->pH263,
568 sizeof(OMX_VIDEO_PARAM_H263TYPE),
569 OMX_VIDEO_PARAM_H263TYPE,
570 pMemoryListHead, dbg);
571 VIDENC_MALLOC(pComponentPrivate->pVidParamBitrate,
572 sizeof(OMX_VIDEO_PARAM_BITRATETYPE),
573 OMX_VIDEO_PARAM_BITRATETYPE,
574 pMemoryListHead, dbg);
575 VIDENC_MALLOC(pComponentPrivate->pQuantization,
576 sizeof(OMX_VIDEO_PARAM_QUANTIZATIONTYPE),
577 OMX_VIDEO_PARAM_QUANTIZATIONTYPE,
578 pMemoryListHead, dbg);
579 VIDENC_MALLOC(pComponentPrivate->pH264IntraPeriod,
580 sizeof(OMX_VIDEO_CONFIG_AVCINTRAPERIOD),
581 OMX_VIDEO_CONFIG_AVCINTRAPERIOD,
582 pMemoryListHead, dbg);
583 VIDENC_MALLOC(pComponentPrivate->pMotionVector,
584 sizeof(OMX_VIDEO_PARAM_MOTIONVECTORTYPE),
585 OMX_VIDEO_PARAM_MOTIONVECTORTYPE,
586 pMemoryListHead, dbg);
587 VIDENC_MALLOC(pComponentPrivate->pCapabilityFlags,
588 sizeof(PV_OMXComponentCapabilityFlagsType),
589 PV_OMXComponentCapabilityFlagsType,
590 pMemoryListHead, dbg);
591
592 /* Set pPortParamType defaults */
593 OMX_CONF_INIT_STRUCT(pComponentPrivate->pPortParamType, OMX_PORT_PARAM_TYPE);
594 pComponentPrivate->pPortParamType->nPorts = VIDENC_NUM_OF_PORTS;
595 pComponentPrivate->pPortParamType->nStartPortNumber = VIDENC_INPUT_PORT;
596
597 #ifdef __KHRONOS_CONF_1_1__
598 OMX_CONF_INIT_STRUCT(pComponentPrivate->pPortAudioType, OMX_PORT_PARAM_TYPE);
599 pComponentPrivate->pPortAudioType->nPorts = 0;
600 pComponentPrivate->pPortAudioType->nStartPortNumber = -1;
601
602 OMX_CONF_INIT_STRUCT(pComponentPrivate->pPortImageType, OMX_PORT_PARAM_TYPE);
603 pComponentPrivate->pPortImageType->nPorts = 0;
604 pComponentPrivate->pPortImageType->nStartPortNumber = -1;
605
606 OMX_CONF_INIT_STRUCT(pComponentPrivate->pPortOtherType, OMX_PORT_PARAM_TYPE);
607 pComponentPrivate->pPortOtherType->nPorts = 0;
608 pComponentPrivate->pPortOtherType->nStartPortNumber = -1;
609
610 #endif
611
612 pCompPortIn = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT];
613
614 /* Set input port defaults */
615
616 pPortDef = pCompPortIn->pPortDef;
617 OMX_CONF_INIT_STRUCT(pPortDef, OMX_PARAM_PORTDEFINITIONTYPE);
618 pPortDef->nPortIndex = VIDENC_INPUT_PORT;
619 pPortDef->eDir = OMX_DirInput;
620 pPortDef->nBufferCountActual = VIDENC_NUM_OF_IN_BUFFERS;
621 pPortDef->nBufferCountMin = 1;
622 pPortDef->nBufferSize = 0; /* It is calculated below */
623 pPortDef->bEnabled = OMX_TRUE;
624 pPortDef->bPopulated = OMX_FALSE;
625 pPortDef->eDomain = OMX_PortDomainVideo;
626 pPortDef->format.video.cMIMEType = "yuv";
627 pPortDef->format.video.pNativeRender = NULL;
628 pPortDef->format.video.nFrameWidth = 176;
629 pPortDef->format.video.nFrameHeight = 144;
630 pPortDef->format.video.nStride = -1;
631 pPortDef->format.video.nSliceHeight = -1;
632 pPortDef->format.video.xFramerate = fToQ16(15.0);
633 pPortDef->format.video.bFlagErrorConcealment = OMX_FALSE;
634 pPortDef->format.video.eCompressionFormat = OMX_VIDEO_CodingUnused;
635 pPortDef->format.video.eColorFormat = OMX_COLOR_FormatYUV420Planar;
636
637 /* Set the default value of the run-time Target Frame Rate to the create-time Frame Rate */
638 pComponentPrivate->nTargetFrameRate = Q16Tof(pPortDef->format.video.xFramerate);
639
640 CalculateBufferSize(pPortDef, pComponentPrivate);
641 pComponentPrivate->nInBufferSize = 0;
642
643 for (i = 0; i < VIDENC_MAX_NUM_OF_IN_BUFFERS; i++)
644 {
645 VIDENC_MALLOC(pCompPortIn->pBufferPrivate[i],
646 sizeof(VIDENC_BUFFER_PRIVATE),
647 VIDENC_BUFFER_PRIVATE,
648 pMemoryListHead, dbg);
649 }
650 for (i = 0; i < VIDENC_MAX_NUM_OF_IN_BUFFERS; i++)
651 {
652 pCompPortIn->pBufferPrivate[i]->pBufferHdr = NULL;
653 }
654 pCompPortIn->nBufferCnt = 0;
655
656 /* Set output port defaults */
657 pCompPortOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT];
658 pPortDef = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortDef;
659 OMX_CONF_INIT_STRUCT(pPortDef, OMX_PARAM_PORTDEFINITIONTYPE);
660 pPortDef->nPortIndex = VIDENC_OUTPUT_PORT;
661 pPortDef->eDir = OMX_DirOutput;
662 pPortDef->nBufferCountActual = VIDENC_NUM_OF_OUT_BUFFERS;
663 pPortDef->nBufferCountMin = 1;
664 pPortDef->nBufferSize = 0; /* It is calculated below */
665 pPortDef->bEnabled = OMX_TRUE;
666 pPortDef->bPopulated = OMX_FALSE;
667 pPortDef->eDomain = OMX_PortDomainVideo;
668 pPortDef->format.video.cMIMEType = "264";
669 pPortDef->format.video.pNativeRender = NULL;
670 pPortDef->format.video.nFrameWidth = 176;
671 pPortDef->format.video.nFrameHeight = 144;
672 pPortDef->format.video.nStride = -1;
673 pPortDef->format.video.nSliceHeight = -1;
674 pPortDef->format.video.xFramerate = fToQ16(15.0);
675 pPortDef->format.video.bFlagErrorConcealment = OMX_FALSE;
676
677 if (sDynamicFormat != NULL)
678 {
679 if ( strcmp(sDynamicFormat, "MPEG4") == 0 )
680 {
681 pPortDef->format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
682 pPortDef->format.video.cMIMEType = "mp4";
683 pPortDef->format.video.nBitrate = VIDENC_STRUCT_MPEG4DEFBITRATE[0][1];
684 }
685 else if (strcmp(sDynamicFormat, "H263") == 0 )
686 {
687 pPortDef->format.video.eCompressionFormat = OMX_VIDEO_CodingH263;
688 pPortDef->format.video.cMIMEType = "mp4";
689 pPortDef->format.video.nBitrate = VIDENC_STRUCT_H263DEFBITRATE[0][1];
690 }
691 else if (strcmp(sDynamicFormat, "H264") == 0 )
692 {
693 pPortDef->format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
694 pPortDef->format.video.cMIMEType = "264";
695 pPortDef->format.video.nBitrate = VIDENC_STRUCT_H264DEFBITRATE[0][1];
696 }
697 }
698 else
699 {
700 pPortDef->format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
701 pPortDef->format.video.cMIMEType = "264";
702 pPortDef->format.video.nBitrate = VIDENC_STRUCT_H264DEFBITRATE[0][1];
703 }
704
705 pPortDef->format.video.eColorFormat = OMX_COLOR_FormatUnused;
706
707 CalculateBufferSize(pPortDef, pComponentPrivate);
708 pComponentPrivate->nOutBufferSize = 0;
709
710 for (i = 0; i < VIDENC_MAX_NUM_OF_OUT_BUFFERS; i++)
711 {
712 VIDENC_MALLOC(pCompPortOut->pBufferPrivate[i],
713 sizeof(VIDENC_BUFFER_PRIVATE),
714 VIDENC_BUFFER_PRIVATE,
715 pMemoryListHead, pComponentPrivate->dbg);
716 }
717 for (i = 0; i < VIDENC_MAX_NUM_OF_OUT_BUFFERS; i++)
718 {
719 pCompPortOut->pBufferPrivate[i]->pBufferHdr = NULL;
720 }
721 /*allocate MPEG4 metadata structure*/
722 for (i = 0; i < VIDENC_MAX_NUM_OF_OUT_BUFFERS; i++)
723 {
724 VIDENC_MALLOC(pCompPortOut->pBufferPrivate[i]->pMetaData,
725 sizeof(VIDENC_MPEG4_SEGMENTMODE_METADATA),
726 VIDENC_MPEG4_SEGMENTMODE_METADATA,
727 pMemoryListHead, pComponentPrivate->dbg);
728 }
729
730 /*segment mode defaults*/
731 pComponentPrivate->bMVDataEnable=OMX_FALSE;
732 pComponentPrivate->bResyncDataEnable=OMX_FALSE;
733 pCompPortOut->nBufferCnt = 0;
734
735 /* Set input port format defaults */
736 pPortFormat = pCompPortIn->pPortFormat;
737 OMX_CONF_INIT_STRUCT(pPortFormat, OMX_VIDEO_PARAM_PORTFORMATTYPE);
738 pPortFormat->nPortIndex = VIDENC_INPUT_PORT;
739 pPortFormat->nIndex = 0x0;
740 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingUnused;
741 pPortFormat->eColorFormat = OMX_COLOR_FormatYUV420Planar;
742
743 /* Set output port format defaults */
744 pPortFormat = pCompPortOut->pPortFormat;
745 OMX_CONF_INIT_STRUCT(pPortFormat, OMX_VIDEO_PARAM_PORTFORMATTYPE);
746 pPortFormat->nPortIndex = VIDENC_OUTPUT_PORT;
747 pPortFormat->nIndex = 0x0;
748
749 if (sDynamicFormat != NULL)
750 {
751 if ( strcmp(sDynamicFormat, "MPEG4") == 0 )
752 {
753 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingMPEG4;
754 }
755 else if (strcmp(sDynamicFormat, "H263") == 0 )
756 {
757 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingH263;
758 }
759 else if (strcmp(sDynamicFormat, "H264") == 0 )
760 {
761 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingAVC;
762 }
763 }
764 else
765 {
766 pPortFormat->eCompressionFormat = OMX_VIDEO_CodingAVC;
767 }
768
769 pPortFormat->eColorFormat = OMX_COLOR_FormatUnused;
770
771 /* Set pPriorityMgmt defaults */
772 pPriorityMgmt = pComponentPrivate->pPriorityMgmt;
773 OMX_CONF_INIT_STRUCT(pPriorityMgmt, OMX_PRIORITYMGMTTYPE);
774 pPriorityMgmt->nGroupPriority = -1;
775 pPriorityMgmt->nGroupID = -1;
776
777 /* Buffer supplier setting */
778 pCompPortIn->eSupplierSetting = OMX_BufferSupplyOutput;
779
780 /* Set pH264 defaults */
781 OMX_CONF_INIT_STRUCT(pComponentPrivate->pH264, OMX_VIDEO_PARAM_AVCTYPE);
782 pComponentPrivate->pH264->nPortIndex = VIDENC_OUTPUT_PORT;
783 pComponentPrivate->pH264->nSliceHeaderSpacing = 0;
784 pComponentPrivate->pH264->nPFrames = -1;
785 pComponentPrivate->pH264->nBFrames = -1;
786 pComponentPrivate->pH264->bUseHadamard = OMX_TRUE; /*OMX_FALSE*/
787 pComponentPrivate->pH264->nRefFrames = 1; /*-1; */
788 pComponentPrivate->pH264->nRefIdx10ActiveMinus1 = -1;
789 pComponentPrivate->pH264->nRefIdx11ActiveMinus1 = -1;
790 pComponentPrivate->pH264->bEnableUEP = OMX_FALSE;
791 pComponentPrivate->pH264->bEnableFMO = OMX_FALSE;
792 pComponentPrivate->pH264->bEnableASO = OMX_FALSE;
793 pComponentPrivate->pH264->bEnableRS = OMX_FALSE;
794 pComponentPrivate->pH264->eProfile = OMX_VIDEO_AVCProfileBaseline; /*0x01;*/
795 pComponentPrivate->pH264->eLevel = OMX_VIDEO_AVCLevel1; /*OMX_VIDEO_AVCLevel11;*/
796 pComponentPrivate->pH264->nAllowedPictureTypes = -1;
797 pComponentPrivate->pH264->bFrameMBsOnly = OMX_FALSE;
798 pComponentPrivate->pH264->bMBAFF = OMX_FALSE;
799 pComponentPrivate->pH264->bEntropyCodingCABAC = OMX_FALSE;
800 pComponentPrivate->pH264->bWeightedPPrediction = OMX_FALSE;
801 pComponentPrivate->pH264->nWeightedBipredicitonMode = -1;
802 pComponentPrivate->pH264->bconstIpred = OMX_FALSE;
803 pComponentPrivate->pH264->bDirect8x8Inference = OMX_FALSE;
804 pComponentPrivate->pH264->bDirectSpatialTemporal = OMX_FALSE;
805 pComponentPrivate->pH264->nCabacInitIdc = -1;
806 pComponentPrivate->pH264->eLoopFilterMode = 1;
807 /*other h264 defaults*/
808 pComponentPrivate->intra4x4EnableIdc = INTRA4x4_IPSLICES;
809 pComponentPrivate->maxMVperMB = 4;
810 pComponentPrivate->nEncodingPreset = 3;/*0:DEFAULT/ 1:HIGH QUALITY/ 2:HIGH SPEED/ 3:USER DEFINED*/
811 pComponentPrivate->AVCNALFormat = VIDENC_AVC_NAL_SLICE;/*VIDENC_AVC_NAL_UNIT;*/
812 /* Set pMpeg4 defaults */
813 OMX_CONF_INIT_STRUCT(pComponentPrivate->pMpeg4, OMX_VIDEO_PARAM_MPEG4TYPE);
814 pComponentPrivate->pMpeg4->nPortIndex = VIDENC_OUTPUT_PORT;
815 pComponentPrivate->pMpeg4->nSliceHeaderSpacing = 0;
816 pComponentPrivate->pMpeg4->bSVH = OMX_FALSE;
817 pComponentPrivate->pMpeg4->bGov = OMX_FALSE;
818 pComponentPrivate->pMpeg4->nPFrames = -1;
819 pComponentPrivate->pMpeg4->nBFrames = -1;
820 pComponentPrivate->pMpeg4->nIDCVLCThreshold = 0; /*-1*/
821 pComponentPrivate->pMpeg4->bACPred = OMX_TRUE;
822 pComponentPrivate->pMpeg4->nMaxPacketSize = -1;
823 pComponentPrivate->pMpeg4->nTimeIncRes = -1;
824 pComponentPrivate->pMpeg4->eProfile = OMX_VIDEO_MPEG4ProfileSimple;
825 #ifdef __KHRONOS_CONF_1_1__
826 pComponentPrivate->pMpeg4->eLevel = OMX_VIDEO_MPEG4Level1;
827 #else
828 pComponentPrivate->pMpeg4->eLevel = 0x0;
829 #endif
830 pComponentPrivate->pMpeg4->nAllowedPictureTypes = -1;
831 pComponentPrivate->pMpeg4->nHeaderExtension = 0;
832 pComponentPrivate->pMpeg4->bReversibleVLC = OMX_FALSE;
833
834 /* Set pH263 defaults */
835 OMX_CONF_INIT_STRUCT(pComponentPrivate->pH263, OMX_VIDEO_PARAM_H263TYPE);
836 pComponentPrivate->pH263->nPortIndex = VIDENC_OUTPUT_PORT;
837 pComponentPrivate->pH263->nPFrames = 0;
838 pComponentPrivate->pH263->nBFrames = 0;
839 pComponentPrivate->pH263->eProfile = OMX_VIDEO_H263ProfileBaseline;
840 pComponentPrivate->pH263->eLevel = OMX_VIDEO_H263Level10;
841 pComponentPrivate->pH263->bPLUSPTYPEAllowed = OMX_FALSE;
842 pComponentPrivate->pH263->nAllowedPictureTypes = 0;
843 pComponentPrivate->pH263->bForceRoundingTypeToZero = OMX_TRUE;
844 pComponentPrivate->pH263->nPictureHeaderRepetition = 0;
845 pComponentPrivate->pH263->nGOBHeaderInterval = 1;
846
847 /* Set pVidParamBitrate and intraRefreshType defaults */
848 OMX_CONF_INIT_STRUCT(pCompPortOut->pErrorCorrectionType, OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE);
849 OMX_CONF_INIT_STRUCT(pCompPortOut->pIntraRefreshType, OMX_VIDEO_PARAM_INTRAREFRESHTYPE);
850 pCompPortOut->pErrorCorrectionType->nPortIndex= VIDENC_OUTPUT_PORT;
851 pCompPortOut->pIntraRefreshType->nPortIndex= VIDENC_OUTPUT_PORT;
852 /*initDSP params*/
853 /*Error resilience tools used by MPEG4/H263 encoder*/
854 pCompPortOut->pErrorCorrectionType->bEnableHEC= OMX_TRUE;/*shouldn't be 0?*/
855 pCompPortOut->pErrorCorrectionType->bEnableResync = OMX_TRUE;/*shouldn't be 0?*/
856 pCompPortOut->pErrorCorrectionType->bEnableDataPartitioning= OMX_FALSE;
857 pCompPortOut->pErrorCorrectionType->bEnableRVLC= OMX_FALSE;
858 pCompPortOut->pErrorCorrectionType->nResynchMarkerSpacing = 1024;
859
860 pCompPortOut->pIntraRefreshType->nAirRef = 10;
861 /* Set pVidParamBitrate defaults */
862 OMX_CONF_INIT_STRUCT(pComponentPrivate->pVidParamBitrate, OMX_VIDEO_PARAM_BITRATETYPE);
863 pComponentPrivate->pVidParamBitrate->nPortIndex = VIDENC_OUTPUT_PORT;
864 pComponentPrivate->pVidParamBitrate->eControlRate = OMX_Video_ControlRateConstant;
865 pComponentPrivate->pVidParamBitrate->nTargetBitrate = 64000;
866 /**/
867 pComponentPrivate->nMIRRate=0;
868 /* Set pQuantization defaults */
869 OMX_CONF_INIT_STRUCT(pComponentPrivate->pQuantization, OMX_VIDEO_PARAM_QUANTIZATIONTYPE);
870 pComponentPrivate->pQuantization->nPortIndex = VIDENC_OUTPUT_PORT;
871 pComponentPrivate->pQuantization->nQpI = 12;
872 pComponentPrivate->pQuantization->nQpP = 0;
873 pComponentPrivate->pQuantization->nQpB = 0;
874
875 /* Set pMotionVector defaults */
876 OMX_CONF_INIT_STRUCT(pComponentPrivate->pMotionVector, OMX_VIDEO_PARAM_MOTIONVECTORTYPE);
877 pComponentPrivate->pMotionVector->nPortIndex = VIDENC_OUTPUT_PORT;
878 pComponentPrivate->pMotionVector->bFourMV = 1;
879 pComponentPrivate->pMotionVector->bUnrestrictedMVs = 0; /* unused */
880 pComponentPrivate->pMotionVector->eAccuracy = OMX_Video_MotionVectorQuarterPel;
881 pComponentPrivate->pMotionVector->sXSearchRange = pComponentPrivate->pMotionVector->sXSearchRange = 64;
882
883 /* Set pIntraPeriod defaults */
884 OMX_CONF_INIT_STRUCT(pComponentPrivate->pH264IntraPeriod, OMX_VIDEO_CONFIG_AVCINTRAPERIOD);
885 pComponentPrivate->pH264IntraPeriod->nPortIndex = VIDENC_OUTPUT_PORT;
886 pComponentPrivate->pH264IntraPeriod->nIDRPeriod = 0;
887 pComponentPrivate->pH264IntraPeriod->nPFrames = 30;
888
889 #ifdef __KHRONOS_CONF_1_1__
890 OMX_CONF_INIT_STRUCT(pCompPortIn->pProfileType, OMX_VIDEO_PARAM_PROFILELEVELTYPE);
891 pCompPortIn->pProfileType->nPortIndex = VIDENC_INPUT_PORT;
892 pCompPortIn->pProfileType->eLevel = OMX_VIDEO_AVCLevel1;
893 pCompPortIn->pProfileType->eProfile = OMX_VIDEO_AVCProfileBaseline;
894 pCompPortIn->pProfileType->nProfileIndex = 0;
895
896 OMX_CONF_INIT_STRUCT(pCompPortOut->pProfileType, OMX_VIDEO_PARAM_PROFILELEVELTYPE);
897 pCompPortOut->pProfileType->nPortIndex = VIDENC_OUTPUT_PORT;
898 pCompPortOut->pProfileType->eLevel = OMX_VIDEO_AVCLevel1;
899 pCompPortOut->pProfileType->eProfile = OMX_VIDEO_AVCProfileBaseline;
900 pCompPortOut->pProfileType->nProfileIndex = 0;
901 OMX_CONF_INIT_STRUCT(pCompPortIn->pFrameRateConfig, OMX_CONFIG_FRAMERATETYPE);
902 pCompPortIn->pFrameRateConfig->nPortIndex = VIDENC_INPUT_PORT;
903 pCompPortIn->pFrameRateConfig->xEncodeFramerate = 0;
904
905 OMX_CONF_INIT_STRUCT(pCompPortOut->pFrameRateConfig, OMX_CONFIG_FRAMERATETYPE);
906 pCompPortOut->pFrameRateConfig->nPortIndex = VIDENC_OUTPUT_PORT;
907 pCompPortOut->pFrameRateConfig->xEncodeFramerate = (15<<16);
908
909 OMX_CONF_INIT_STRUCT(pCompPortIn->pBitRateTypeConfig, OMX_VIDEO_CONFIG_BITRATETYPE);
910 pCompPortIn->pBitRateTypeConfig->nPortIndex = VIDENC_INPUT_PORT;
911 pCompPortIn->pBitRateTypeConfig->nEncodeBitrate = 0;
912
913 OMX_CONF_INIT_STRUCT(pCompPortOut->pBitRateTypeConfig, OMX_VIDEO_CONFIG_BITRATETYPE);
914 pCompPortOut->pBitRateTypeConfig->nPortIndex = VIDENC_OUTPUT_PORT;
915 if(pPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4)
916 {
917 pCompPortOut->pBitRateTypeConfig->nEncodeBitrate = VIDENC_STRUCT_MPEG4DEFBITRATE[0][1];
918 }
919 else if(pPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) {
920 pCompPortOut->pBitRateTypeConfig->nEncodeBitrate = VIDENC_STRUCT_H263DEFBITRATE[0][1];
921 }
922 else {
923 pCompPortOut->pBitRateTypeConfig->nEncodeBitrate = VIDENC_STRUCT_H264DEFBITRATE[0][1];
924 }
925
926 #endif
927 OMX_CONF_INIT_STRUCT(pCompPortIn->pBitRateType, OMX_VIDEO_PARAM_BITRATETYPE);
928 pCompPortIn->pBitRateType->nPortIndex = VIDENC_INPUT_PORT;
929 pCompPortIn->pBitRateType->eControlRate = OMX_Video_ControlRateDisable;
930 pCompPortIn->pBitRateType->nTargetBitrate = 0;
931
932 OMX_CONF_INIT_STRUCT(pCompPortOut->pBitRateType, OMX_VIDEO_PARAM_BITRATETYPE);
933 pCompPortOut->pBitRateType->nPortIndex = VIDENC_OUTPUT_PORT;
934 pCompPortOut->pBitRateType->eControlRate = OMX_Video_ControlRateConstant;
935 pCompPortOut->pBitRateType->nTargetBitrate = pCompPortOut->pBitRateTypeConfig->nEncodeBitrate;
936
937 /*set the capability Flags needed by Opencore*/
938 pComponentPrivate->pCapabilityFlags->iIsOMXComponentMultiThreaded=OMX_TRUE;
939 pComponentPrivate->pCapabilityFlags->iOMXComponentCanHandleIncompleteFrames=OMX_FALSE;
940 pComponentPrivate->pCapabilityFlags->iOMXComponentSupportsExternalInputBufferAlloc=OMX_FALSE;
941 pComponentPrivate->pCapabilityFlags->iOMXComponentSupportsExternalOutputBufferAlloc=OMX_FALSE;
942 pComponentPrivate->pCapabilityFlags->iOMXComponentSupportsMovableInputBuffers=OMX_TRUE;
943 pComponentPrivate->pCapabilityFlags->iOMXComponentSupportsPartialFrames=OMX_FALSE;
944 pComponentPrivate->pCapabilityFlags->iOMXComponentUsesFullAVCFrames=OMX_FALSE;
945 pComponentPrivate->pCapabilityFlags->iOMXComponentUsesNALStartCode=OMX_FALSE;
946 pComponentPrivate->nLastUpdateTime = 0;
947 pComponentPrivate->nFrameRateUpdateInterval = 60;
948 pComponentPrivate->nFrameCount = 0;
949 pComponentPrivate->nVideoTime = 0;
950 pComponentPrivate->EmptybufferdoneCount = 0;
951 pComponentPrivate->EmptythisbufferCount = 0;
952 pComponentPrivate->FillbufferdoneCount = 0;
953 pComponentPrivate->FillthisbufferCount = 0;
954 #ifndef UNDER_CE
955 /* Initialize Mutex for Buffer Tracking */
956 pthread_mutex_init(&(pComponentPrivate->mVideoEncodeBufferMutex), NULL);
957 #else
958 /* Add WinCE critical section API */
959 #endif
960
961 /* create the pipe used to maintain free input buffers*/
962 eError = pipe(pComponentPrivate->nFree_oPipe);
963 if (eError)
964 {
965 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorInsufficientResources);
966 }
967
968 /* create the pipe used to maintain input buffers*/
969 eError = pipe(pComponentPrivate->nFilled_iPipe);
970 if (eError)
971 {
972 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorInsufficientResources);
973 }
974
975 /* create the pipe used to send commands to the thread */
976 eError = pipe(pComponentPrivate->nCmdPipe);
977 if (eError)
978 {
979 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorInsufficientResources);
980 }
981
982 /* create the pipe used to send commands to the thread */
983 eError = pipe(pComponentPrivate->nCmdDataPipe);
984 if (eError)
985 {
986 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorInsufficientResources);
987 }
988
989 #ifdef RESOURCE_MANAGER_ENABLED
990 /* Initialize Resource Manager */
991 eError = RMProxy_NewInitalizeEx(OMX_COMPONENTTYPE_VIDEO);
992 if (eError != OMX_ErrorNone)
993 {
994 OMX_PRMGR4(dbg, "Error returned from loading ResourceManagerProxy thread...\n");
995 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorInsufficientResources);
996 }
997 #endif
998 /* Create the Component Thread */
999 #ifdef UNDER_CE
1000 attr.__inheritsched = PTHREAD_EXPLICIT_SCHED;
1001 attr.__schedparam.__sched_priority = OMX_VIDEO_ENCODER_THREAD_PRIORITY;
1002 nError = pthread_create(&ComponentThread, &attr, OMX_VIDENC_Thread, pComponentPrivate);
1003 #else
1004 nError = pthread_create(&pComponentPrivate->ComponentThread, NULL, OMX_VIDENC_Thread, pComponentPrivate);
1005 #endif
1006
1007
1008 #ifndef UNDER_CE
1009 if (nError == EAGAIN)
1010 {
1011 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorInsufficientResources);
1012 }
1013 #else
1014 if (nError || !(pComponentPrivate->ComponentThread))
1015 {
1016 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorInsufficientResources);
1017 }
1018 #endif
1019
1020 #ifdef __PERF_INSTRUMENTATION__
1021 PERF_ThreadCreated(pComponentPrivate->pPERF, pComponentPrivate->ComponentThread,
1022 PERF_FOURCC('V','E',' ','T'));
1023 #endif
1024 #ifndef UNDER_CE
1025 /*pthread_mutex_init(&pComponentPrivate->videoe_mutex_app, NULL);*/
1026 pthread_mutex_init(&pComponentPrivate->videoe_mutex, NULL);
1027 pthread_cond_init (&pComponentPrivate->populate_cond, NULL);
1028 pthread_mutex_init(&pComponentPrivate->videoe_mutex_app, NULL);
1029 pthread_cond_init (&pComponentPrivate->unpopulate_cond, NULL);
1030 pthread_cond_init (&pComponentPrivate->flush_cond, NULL);
1031 pthread_cond_init (&pComponentPrivate->stop_cond, NULL);
1032
1033 pthread_mutex_init(&bufferReturned_mutex, NULL);
1034 pthread_cond_init (&bufferReturned_condition, NULL);
1035 #else
1036 OMX_CreateEvent(&(pComponentPrivate->InLoaded_event));
1037 OMX_CreateEvent(&(pComponentPrivate->InIdle_event));
1038 #endif
1039
1040 if(pthread_mutex_init(&pComponentPrivate->mutexStateChangeRequest, NULL)) {
1041 return OMX_ErrorUndefined;
1042 }
1043
1044 if(pthread_cond_init (&pComponentPrivate->StateChangeCondition, NULL)) {
1045 return OMX_ErrorUndefined;
1046 }
1047 OMX_CONF_CMD_BAIL:
1048 OMX_PRINT2(dbg, "Component Init Exit\n");
1049 return eError;
1050 }
1051
1052 /*----------------------------------------------------------------------------*/
1053 /**
1054 * SetCallbacks() Sets application callbacks to the component
1055 *
1056 * This method will update application callbacks
1057 * the application.
1058 *
1059 * @param pComp handle for this instance of the component
1060 * @param pCallBacks application callbacks
1061 * @param ptr
1062 *
1063 * @retval OMX_NoError Success, ready to roll
1064 * OMX_Error_BadParameter The input parameter pointer is null
1065 **/
1066 /*----------------------------------------------------------------------------*/
1067
SetCallbacks(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_CALLBACKTYPE * pCallBacks,OMX_IN OMX_PTR pAppData)1068 static OMX_ERRORTYPE SetCallbacks (OMX_IN OMX_HANDLETYPE hComponent,
1069 OMX_IN OMX_CALLBACKTYPE* pCallBacks,
1070 OMX_IN OMX_PTR pAppData)
1071 {
1072 OMX_ERRORTYPE eError = OMX_ErrorNone;
1073 OMX_COMPONENTTYPE* pHandle = NULL;
1074 VIDENC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
1075 OMX_U32* pTmp = NULL;
1076
1077 pComponentPrivate = (VIDENC_COMPONENT_PRIVATE*)(((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate);
1078 OMX_CONF_CHECK_CMD(pComponentPrivate, 1, 1);
1079 OMX_DBG_CHECK_CMD(pComponentPrivate->dbg, pCallBacks, 1, 1);
1080
1081 /*Copy the callbacks of the application to the component private */
1082 pTmp = memcpy (&(pComponentPrivate->sCbData), pCallBacks, sizeof(OMX_CALLBACKTYPE));
1083 if (pTmp == NULL)
1084 {
1085 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined, pComponentPrivate->dbg,
1086 OMX_TRACE4, "Failed to copy callbacks.\n");
1087 }
1088
1089 /*copy the application private data to component memory*/
1090 pHandle = (OMX_COMPONENTTYPE*)hComponent;
1091 pHandle->pApplicationPrivate = pAppData;
1092 pComponentPrivate->eState = OMX_StateLoaded;
1093
1094 OMX_CONF_CMD_BAIL:
1095 return eError;
1096 }
1097
1098 /*----------------------------------------------------------------------------*/
1099 /**
1100 * GetComponentVersion() Sets application callbacks to the component
1101 *
1102 * This method will update application callbacks
1103 * the application.
1104 *
1105 * @param pComp handle for this instance of the component
1106 * @param pCallBacks application callbacks
1107 * @param ptr
1108 *
1109 * @retval OMX_NoError Success, ready to roll
1110 * OMX_Error_BadParameter The input parameter pointer is null
1111 **/
1112 /*----------------------------------------------------------------------------*/
1113
GetComponentVersion(OMX_HANDLETYPE hComp,OMX_STRING szComponentName,OMX_VERSIONTYPE * pComponentVersion,OMX_VERSIONTYPE * pSpecVersion,OMX_UUIDTYPE * pComponentUUID)1114 static OMX_ERRORTYPE GetComponentVersion (OMX_HANDLETYPE hComp,
1115 OMX_STRING szComponentName,
1116 OMX_VERSIONTYPE* pComponentVersion,
1117 OMX_VERSIONTYPE* pSpecVersion,
1118 OMX_UUIDTYPE* pComponentUUID)
1119 {
1120 OMX_ERRORTYPE eError = OMX_ErrorNone;
1121 OMX_COMPONENTTYPE* pHandle = NULL;
1122 VIDENC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
1123
1124 OMX_CONF_CHECK_CMD(hComp, ((OMX_COMPONENTTYPE *) hComp)->pComponentPrivate, 1);
1125 pHandle = (OMX_COMPONENTTYPE*)hComp;
1126 pComponentPrivate = (VIDENC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate;
1127
1128 OMX_DBG_CHECK_CMD(pComponentPrivate->dbg, szComponentName, pComponentVersion, pSpecVersion);
1129 OMX_DBG_CHECK_CMD(pComponentPrivate->dbg, pComponentUUID, 1, 1);
1130
1131 if (pComponentPrivate->eState == OMX_StateInvalid)
1132 {
1133 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorIncorrectStateOperation,
1134 pComponentPrivate->dbg, OMX_PRSTATE3,
1135 "Component is in invalid state.\n");
1136 }
1137
1138 strcpy(szComponentName, pComponentPrivate->cComponentName);
1139 memcpy(pComponentVersion,
1140 &(pComponentPrivate->ComponentVersion.s),
1141 sizeof(pComponentPrivate->ComponentVersion.s));
1142 memcpy(pSpecVersion,
1143 &(pComponentPrivate->SpecVersion.s),
1144 sizeof(pComponentPrivate->SpecVersion.s));
1145
1146 OMX_CONF_CMD_BAIL:
1147 return eError;
1148 }
1149
1150 /*----------------------------------------------------------------------------*/
1151 /**
1152 * SendCommand() Sets application callbacks to the component
1153 *
1154 * This method will update application callbacks
1155 * the application.
1156 *
1157 * @param pComp handle for this instance of the component
1158 * @param pCallBacks application callbacks
1159 * @param ptr
1160 *
1161 * @retval OMX_NoError Success, ready to roll
1162 * OMX_Error_BadParameter The input parameter pointer is null
1163 **/
1164 /*----------------------------------------------------------------------------*/
1165
SendCommand(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_COMMANDTYPE Cmd,OMX_IN OMX_U32 nParam1,OMX_IN OMX_PTR pCmdData)1166 static OMX_ERRORTYPE SendCommand (OMX_IN OMX_HANDLETYPE hComponent,
1167 OMX_IN OMX_COMMANDTYPE Cmd,
1168 OMX_IN OMX_U32 nParam1,
1169 OMX_IN OMX_PTR pCmdData)
1170 {
1171 OMX_ERRORTYPE eError = OMX_ErrorNone;
1172 int nRet = 0;
1173 VIDENC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
1174 char* szCommandType = NULL;
1175 char* szParam = NULL;
1176 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefIn = NULL;
1177 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = NULL;
1178 VIDENC_NODE* pMemoryListHead = NULL;
1179
1180 OMX_CONF_CHECK_CMD(hComponent, ((OMX_COMPONENTTYPE *) hComponent)->pComponentPrivate, 1);
1181
1182 pComponentPrivate = (VIDENC_COMPONENT_PRIVATE*)(((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate);
1183 if (Cmd == OMX_CommandMarkBuffer)
1184 {
1185 OMX_DBG_CHECK_CMD(pComponentPrivate->dbg, pCmdData, 1, 1);
1186 }
1187
1188 if (pComponentPrivate->eState == OMX_StateInvalid)
1189 {
1190 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorIncorrectStateOperation,
1191 pComponentPrivate->dbg, OMX_PRSTATE3,
1192 "Component is in invalid state.\n");
1193 }
1194
1195 pMemoryListHead = pComponentPrivate->pMemoryListHead;
1196
1197 #ifdef __PERF_INSTRUMENTATION__
1198 PERF_SendingCommand(pComponentPrivate->pPERF,
1199 Cmd,
1200 (Cmd == OMX_CommandMarkBuffer) ? ((OMX_U32) pCmdData) : nParam1,
1201 PERF_ModuleComponent);
1202 #endif
1203
1204 switch (Cmd)
1205 {
1206 case OMX_CommandStateSet:
1207 /* Add a pending transition */
1208 if(AddStateTransition(pComponentPrivate) != OMX_ErrorNone) {
1209 return OMX_ErrorUndefined;
1210 }
1211
1212 #ifdef __KHRONOS_CONF__
1213 if(nParam1 == OMX_StateLoaded &&
1214 pComponentPrivate->eState == OMX_StateIdle)
1215 {
1216 pComponentPrivate->bPassingIdleToLoaded = OMX_TRUE;
1217 }
1218 #endif
1219 OMX_PRCOMM2(pComponentPrivate->dbg, "Write to cmd pipe!\n");
1220 nRet = write(pComponentPrivate->nCmdPipe[1], &Cmd, sizeof(Cmd));
1221 if (nRet == -1) {
1222 /* Decrement reference count without generating any signal */
1223 if(RemoveStateTransition(pComponentPrivate, 0) != OMX_ErrorNone) {
1224 return OMX_ErrorUndefined;
1225 }
1226 }
1227 nRet = write(pComponentPrivate->nCmdDataPipe[1],
1228 &nParam1,
1229 sizeof(nParam1));
1230 if (nRet == -1) {
1231 /* Decrement reference count without generating any signal */
1232 if(RemoveStateTransition(pComponentPrivate, 0) != OMX_ErrorNone) {
1233 return OMX_ErrorUndefined;
1234 }
1235 }
1236 break;
1237 case OMX_CommandFlush:
1238 if (nParam1 > 1 && nParam1 != (OMX_U32)-1)
1239 {
1240 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorBadPortIndex,
1241 pComponentPrivate->dbg, OMX_PRBUFFER4,
1242 "Invalid flush nParam1 (%lu).\n", nParam1);
1243 }
1244 nRet = write(pComponentPrivate->nCmdPipe[1], &Cmd, sizeof(Cmd));
1245 if (nRet == -1)
1246 {
1247 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1248 pComponentPrivate->dbg, OMX_PRCOMM4,
1249 "Failed to write to cmd pipe.\n");
1250 }
1251 nRet = write(pComponentPrivate->nCmdDataPipe[1],
1252 &nParam1,
1253 sizeof(nParam1));
1254 if (nRet == -1)
1255 {
1256 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1257 pComponentPrivate->dbg, OMX_PRCOMM4,
1258 "Failed to write to cmd pipe.\n");
1259 }
1260 break;
1261 case OMX_CommandPortDisable:
1262
1263 pPortDefIn = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->pPortDef;
1264 pPortDefOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortDef;
1265
1266 if (nParam1 == VIDENC_INPUT_PORT ||
1267 nParam1 == VIDENC_OUTPUT_PORT ||
1268 nParam1 == (OMX_U32)-1)
1269 {
1270 if (nParam1 == VIDENC_INPUT_PORT || nParam1 == (OMX_U32)-1)
1271 {
1272
1273 pPortDefIn->bEnabled = OMX_FALSE;
1274 }
1275 if (nParam1 == VIDENC_OUTPUT_PORT || nParam1 == (OMX_U32)-1)
1276 {
1277
1278 pPortDefOut->bEnabled = OMX_FALSE;
1279 }
1280 }
1281 else
1282 {
1283 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorBadParameter,
1284 pComponentPrivate->dbg, OMX_PRBUFFER4,
1285 "Invalid port disable nParam1 (%lu).\n", nParam1);
1286 }
1287
1288 nRet = write(pComponentPrivate->nCmdPipe[1], &Cmd, sizeof(Cmd));
1289 if (nRet == -1)
1290 {
1291 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1292 pComponentPrivate->dbg, OMX_PRCOMM4,
1293 "Failed to write to cmd pipe.\n");
1294 }
1295 nRet = write(pComponentPrivate->nCmdDataPipe[1],
1296 &nParam1,
1297 sizeof(nParam1));
1298 if (nRet == -1)
1299 {
1300 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1301 pComponentPrivate->dbg, OMX_PRCOMM4,
1302 "Failed to write to cmd pipe.\n");
1303 }
1304 break;
1305 case OMX_CommandPortEnable:
1306 pPortDefIn = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->pPortDef;
1307 pPortDefOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortDef;
1308
1309 if (nParam1 == VIDENC_INPUT_PORT ||
1310 nParam1 == VIDENC_OUTPUT_PORT ||
1311 nParam1 == (OMX_U32)-1)
1312 {
1313 if (nParam1 == VIDENC_INPUT_PORT || nParam1 == (OMX_U32)-1)
1314 {
1315 pPortDefIn->bEnabled = OMX_TRUE;
1316 }
1317 if (nParam1 == VIDENC_OUTPUT_PORT || nParam1 == (OMX_U32)-1)
1318 {
1319 pPortDefOut->bEnabled = OMX_TRUE;
1320 }
1321 }
1322 else
1323 {
1324 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorBadParameter,
1325 pComponentPrivate->dbg, OMX_PRBUFFER4,
1326 "Invalid port enable nParam1 (%lu).\n", nParam1);
1327 }
1328
1329 nRet = write(pComponentPrivate->nCmdPipe[1], &Cmd, sizeof(Cmd));
1330 if (nRet == -1)
1331 {
1332 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1333 pComponentPrivate->dbg, OMX_PRCOMM4,
1334 "Failed to write to cmd pipe.\n");
1335 }
1336 nRet = write(pComponentPrivate->nCmdDataPipe[1],
1337 &nParam1,
1338 sizeof(nParam1));
1339 if (nRet == -1)
1340 {
1341 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1342 pComponentPrivate->dbg, OMX_PRCOMM4,
1343 "Failed to write to cmd pipe.\n");
1344 }
1345 break;
1346 case OMX_CommandMarkBuffer:
1347 if (nParam1 > 0)
1348 {
1349 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorBadPortIndex,
1350 pComponentPrivate->dbg, OMX_PRBUFFER4,
1351 "Invalid port number (%lu).\n", nParam1);
1352 }
1353 nRet = write(pComponentPrivate->nCmdPipe[1], &Cmd, sizeof(Cmd));
1354 if (nRet == -1)
1355 {
1356 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1357 pComponentPrivate->dbg, OMX_PRCOMM4,
1358 "Failed to write to cmd pipe.\n");
1359 }
1360 nRet = write(pComponentPrivate->nCmdDataPipe[1],
1361 &pCmdData,
1362 sizeof(pCmdData));
1363 if (nRet == -1)
1364 {
1365 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1366 pComponentPrivate->dbg, OMX_PRCOMM4,
1367 "Failed to write to cmd pipe.\n");
1368 }
1369 break;
1370 case OMX_CommandMax:
1371 break;
1372 default:
1373 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1374 pComponentPrivate->dbg, OMX_PRCOMM4,
1375 "Invalid command (%x).\n", Cmd);
1376 }
1377
1378 OMX_CONVERT_CMD(szCommandType, Cmd);
1379 if (Cmd == OMX_CommandStateSet)
1380 {
1381 OMX_CONVERT_STATE(szParam, nParam1);
1382 OMX_PRSTATE2(pComponentPrivate->dbg, "%s -> %s\n", szCommandType, szParam);
1383 }
1384
1385 OMX_CONF_CMD_BAIL:
1386 return eError;
1387 }
1388
1389 /*----------------------------------------------------------------------------*/
1390 /**
1391 * GetParameter() Sets application callbacks to the component
1392 *
1393 * This method will update application callbacks
1394 * the application.
1395 *
1396 * @param pComp handle for this instance of the component
1397 * @param pCallBacks application callbacks
1398 * @param ptr
1399 *
1400 * @retval OMX_NoError Success, ready to roll
1401 * OMX_Error_BadParameter The input parameter pointer is null
1402 **/
1403 /*----------------------------------------------------------------------------*/
1404
GetParameter(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_INDEXTYPE nParamIndex,OMX_INOUT OMX_PTR ComponentParameterStructure)1405 static OMX_ERRORTYPE GetParameter (OMX_IN OMX_HANDLETYPE hComponent,
1406 OMX_IN OMX_INDEXTYPE nParamIndex,
1407 OMX_INOUT OMX_PTR ComponentParameterStructure)
1408 {
1409 VIDENC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
1410 OMX_ERRORTYPE eError = OMX_ErrorNone;
1411 OMX_U32* pTmp = NULL;
1412 VIDEOENC_PORT_TYPE* pCompPortIn = NULL;
1413 VIDEOENC_PORT_TYPE* pCompPortOut = NULL;
1414
1415 OMX_CONF_CHECK_CMD(hComponent, ((OMX_COMPONENTTYPE *) hComponent)->pComponentPrivate, 1);
1416
1417 pComponentPrivate = (VIDENC_COMPONENT_PRIVATE*)(((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate);
1418 OMX_DBG_CHECK_CMD(pComponentPrivate->dbg, ComponentParameterStructure, 1, 1);
1419
1420 if (pComponentPrivate->eState == OMX_StateInvalid)
1421 {
1422 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorIncorrectStateOperation,
1423 pComponentPrivate->dbg, OMX_PRSTATE3,
1424 "Component is in invalid state.\n");
1425 }
1426
1427 pCompPortIn = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT];
1428 pCompPortOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT];
1429
1430 switch (nParamIndex)
1431 {
1432 case OMX_IndexParamVideoInit:
1433 pTmp = memcpy(ComponentParameterStructure,
1434 pComponentPrivate->pPortParamType,
1435 sizeof(OMX_PORT_PARAM_TYPE));
1436 if (pTmp == NULL)
1437 {
1438 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1439 pComponentPrivate->dbg, OMX_TRACE4,
1440 "Failed to copy parameter.\n");
1441 }
1442 break;
1443 #ifdef __KHRONOS_CONF_1_1__
1444
1445 case OMX_IndexParamImageInit:
1446 pTmp = memcpy(ComponentParameterStructure,
1447 pComponentPrivate->pPortImageType,
1448 sizeof(OMX_PORT_PARAM_TYPE));
1449 if (pTmp == NULL)
1450 {
1451 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1452 pComponentPrivate->dbg, OMX_TRACE4,
1453 "Failed to copy parameter.\n");
1454 }
1455 break;
1456
1457 case OMX_IndexParamAudioInit:
1458 pTmp = memcpy(ComponentParameterStructure,
1459 pComponentPrivate->pPortAudioType,
1460 sizeof(OMX_PORT_PARAM_TYPE));
1461 if (pTmp == NULL)
1462 {
1463 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1464 pComponentPrivate->dbg, OMX_TRACE4,
1465 "Failed to copy parameter.\n");
1466 }
1467 break;
1468
1469 case OMX_IndexParamOtherInit:
1470 pTmp = memcpy(ComponentParameterStructure,
1471 pComponentPrivate->pPortOtherType,
1472 sizeof(OMX_PORT_PARAM_TYPE));
1473 if (pTmp == NULL)
1474 {
1475 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1476 pComponentPrivate->dbg, OMX_TRACE4,
1477 "Failed to copy parameter.\n");
1478 }
1479 break;
1480
1481 #endif
1482
1483 case OMX_IndexParamPortDefinition:
1484 {
1485 OMX_PARAM_PORTDEFINITIONTYPE *pPortDef = (OMX_PARAM_PORTDEFINITIONTYPE*)(ComponentParameterStructure);
1486 if (pPortDef->nPortIndex == pCompPortIn->pPortDef->nPortIndex)
1487 {
1488 pTmp = memcpy(ComponentParameterStructure,
1489 pCompPortIn->pPortDef,
1490 sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1491 if (pTmp == NULL)
1492 {
1493 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1494 pComponentPrivate->dbg, OMX_TRACE4,
1495 "Failed to copy parameter.\n");
1496 }
1497 }
1498 else if (pPortDef->nPortIndex == pCompPortOut->pPortDef->nPortIndex)
1499 {
1500 pTmp = memcpy(ComponentParameterStructure,
1501 pCompPortOut->pPortDef,
1502 sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1503 if (pTmp == NULL)
1504 {
1505 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1506 pComponentPrivate->dbg, OMX_TRACE4,
1507 "Failed to copy parameter.\n");
1508 }
1509 }
1510 else
1511 {
1512 eError = OMX_ErrorBadPortIndex;
1513 }
1514 break;
1515 }
1516 case OMX_IndexParamVideoPortFormat:
1517 if (((OMX_VIDEO_PARAM_PORTFORMATTYPE*)(ComponentParameterStructure))->nPortIndex ==
1518 pCompPortIn->pPortFormat->nPortIndex)
1519 {
1520 if (((OMX_VIDEO_PARAM_PORTFORMATTYPE*)(ComponentParameterStructure))->nIndex < 3)
1521 {
1522 ((OMX_VIDEO_PARAM_PORTFORMATTYPE*)(ComponentParameterStructure))->eColorFormat =
1523 pComponentPrivate->colorFormats[((OMX_VIDEO_PARAM_PORTFORMATTYPE*)(ComponentParameterStructure))->nIndex];
1524 eError = OMX_ErrorNone;
1525 }
1526 else
1527 {
1528 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorNoMore,
1529 pComponentPrivate->dbg, OMX_TRACE4,
1530 "No such index.\n");
1531 }
1532 }
1533 else if (((OMX_VIDEO_PARAM_PORTFORMATTYPE*)(ComponentParameterStructure))->nPortIndex ==
1534 pCompPortOut->pPortFormat->nPortIndex)
1535 {
1536 if (((OMX_VIDEO_PARAM_PORTFORMATTYPE*)(ComponentParameterStructure))->nIndex < 3)
1537 {
1538 ((OMX_VIDEO_PARAM_PORTFORMATTYPE*)(ComponentParameterStructure))->eCompressionFormat =
1539 pComponentPrivate->compressionFormats[((OMX_VIDEO_PARAM_PORTFORMATTYPE*)(ComponentParameterStructure))->nIndex];
1540 eError = OMX_ErrorNone;
1541 }
1542 else
1543 {
1544 /*OMX_TRACE("OMX_IndexParamVideoPortFormat OMX_ErrorNoMore, no such index\n");*/
1545 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorNoMore);
1546 }
1547 }
1548 else
1549 {
1550 eError = OMX_ErrorBadPortIndex;
1551 }
1552 break;
1553 case OMX_IndexParamPriorityMgmt:
1554 pTmp = memcpy(ComponentParameterStructure,
1555 pComponentPrivate->pPriorityMgmt,
1556 sizeof(OMX_PRIORITYMGMTTYPE));
1557 if (pTmp == NULL)
1558 {
1559 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1560 pComponentPrivate->dbg, OMX_TRACE4,
1561 "Failed to copy parameter.\n");
1562 }
1563 break;
1564 case OMX_IndexParamVideoAvc:
1565 if (((OMX_VIDEO_PARAM_AVCTYPE*)(ComponentParameterStructure))->nPortIndex ==
1566 pComponentPrivate->pH264->nPortIndex)
1567 {
1568 pTmp = memcpy(ComponentParameterStructure,
1569 pComponentPrivate->pH264,
1570 sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1571 if (pTmp == NULL)
1572 {
1573 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1574 pComponentPrivate->dbg, OMX_TRACE4,
1575 "Failed to copy parameter.\n");
1576 }
1577 }
1578 else
1579 {
1580 eError = OMX_ErrorBadPortIndex;
1581 }
1582 break;
1583 case OMX_IndexParamVideoMpeg4:
1584 if (((OMX_VIDEO_PARAM_MPEG4TYPE*)(ComponentParameterStructure))->nPortIndex ==
1585 pComponentPrivate->pMpeg4->nPortIndex)
1586 {
1587 pTmp = memcpy(ComponentParameterStructure,
1588 pComponentPrivate->pMpeg4,
1589 sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1590 if (pTmp == NULL)
1591 {
1592 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1593 pComponentPrivate->dbg, OMX_TRACE4,
1594 "Failed to copy parameter.\n");
1595 }
1596 }
1597 else
1598 {
1599 eError = OMX_ErrorBadPortIndex;
1600 }
1601 break;
1602 case OMX_IndexParamCompBufferSupplier:
1603 {
1604 OMX_PARAM_BUFFERSUPPLIERTYPE* pBuffSupplierParam = (OMX_PARAM_BUFFERSUPPLIERTYPE*)ComponentParameterStructure;
1605 if (pBuffSupplierParam->nPortIndex == VIDENC_INPUT_PORT)
1606 {
1607 pBuffSupplierParam->eBufferSupplier = pCompPortIn->eSupplierSetting;
1608 }
1609 else if (pBuffSupplierParam->nPortIndex == VIDENC_OUTPUT_PORT)
1610 {
1611 pBuffSupplierParam->eBufferSupplier = pCompPortOut->eSupplierSetting;
1612 }
1613 else
1614 {
1615 eError = OMX_ErrorBadPortIndex;
1616 }
1617 break;
1618 }
1619
1620 case OMX_IndexParamVideoBitrate:
1621 if (((OMX_VIDEO_PARAM_BITRATETYPE*)(ComponentParameterStructure))->nPortIndex ==
1622 pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pBitRateType->nPortIndex)
1623 {
1624 pTmp = memcpy(ComponentParameterStructure,
1625 pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pBitRateType,
1626 sizeof(OMX_VIDEO_PARAM_BITRATETYPE));
1627 if (pTmp == NULL)
1628 {
1629 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1630 pComponentPrivate->dbg, OMX_TRACE4,
1631 "Failed to copy parameter.\n");
1632 }
1633 }
1634 else
1635 {
1636 eError = OMX_ErrorBadPortIndex;
1637 }
1638 break;
1639
1640 case OMX_IndexParamVideoH263:
1641 if (((OMX_VIDEO_PARAM_H263TYPE*)(ComponentParameterStructure))->nPortIndex ==
1642 pComponentPrivate->pH263->nPortIndex)
1643 {
1644 pTmp = memcpy(ComponentParameterStructure,
1645 pComponentPrivate->pH263,
1646 sizeof(OMX_VIDEO_PARAM_H263TYPE));
1647 if (pTmp == NULL)
1648 {
1649 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1650 pComponentPrivate->dbg, OMX_TRACE4,
1651 "Failed to copy parameter.\n");
1652 }
1653 }
1654 else
1655 {
1656 eError = OMX_ErrorBadPortIndex;
1657 }
1658 break;
1659 case OMX_IndexParamVideoQuantization:
1660 if (((OMX_VIDEO_PARAM_QUANTIZATIONTYPE*)(ComponentParameterStructure))->nPortIndex ==
1661 pComponentPrivate->pQuantization->nPortIndex)
1662 {
1663 pTmp = memcpy(ComponentParameterStructure,
1664 pComponentPrivate->pQuantization,
1665 sizeof(OMX_VIDEO_PARAM_QUANTIZATIONTYPE));
1666 if (pTmp == NULL)
1667 {
1668 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1669 pComponentPrivate->dbg, OMX_TRACE4,
1670 "Failed to copy parameter.\n");
1671 }
1672 }
1673 else
1674 {
1675 eError = OMX_ErrorBadPortIndex;
1676 }
1677 break;
1678
1679
1680 case OMX_IndexParamVideoProfileLevelQuerySupported:
1681 {
1682 VIDEO_PROFILE_LEVEL_TYPE* pProfileLevel = NULL;
1683 OMX_U32 nNumberOfProfiles = 0;
1684 OMX_VIDEO_PARAM_PROFILELEVELTYPE *pParamProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)ComponentParameterStructure;
1685 pParamProfileLevel->nPortIndex = pCompPortOut->pPortDef->nPortIndex;
1686 /* Choose table based on compression format */
1687 switch(pCompPortOut->pPortDef->format.video.eCompressionFormat)
1688 {
1689 case OMX_VIDEO_CodingH263:
1690 pProfileLevel = SupportedH263ProfileLevels;
1691 nNumberOfProfiles = sizeof(SupportedH263ProfileLevels) / sizeof (VIDEO_PROFILE_LEVEL_TYPE);
1692 break;
1693 case OMX_VIDEO_CodingMPEG4:
1694 pProfileLevel = SupportedMPEG4ProfileLevels;
1695 nNumberOfProfiles = sizeof(SupportedMPEG4ProfileLevels) / sizeof (VIDEO_PROFILE_LEVEL_TYPE);
1696 break;
1697 case OMX_VIDEO_CodingAVC:
1698 pProfileLevel = SupportedAVCProfileLevels;
1699 nNumberOfProfiles = sizeof(SupportedAVCProfileLevels) / sizeof (VIDEO_PROFILE_LEVEL_TYPE);
1700 break;
1701 default:
1702 eError = OMX_ErrorBadParameter;
1703 return eError;
1704 }
1705 if(pParamProfileLevel->nProfileIndex >= nNumberOfProfiles) {
1706 return OMX_ErrorBadParameter;
1707 }
1708 /* Point to table entry based on index */
1709 pProfileLevel += pParamProfileLevel->nProfileIndex;
1710
1711 /* -1 indicates end of table */
1712 if(pProfileLevel->nProfile != -1) {
1713 pParamProfileLevel->eProfile = pProfileLevel->nProfile;
1714 pParamProfileLevel->eLevel = pProfileLevel->nLevel;
1715 eError = OMX_ErrorNone;
1716 }
1717 else {
1718 eError = OMX_ErrorNoMore;
1719 }
1720 }
1721 break;
1722 case OMX_IndexParamVideoProfileLevelCurrent:
1723 {
1724 OMX_VIDEO_PARAM_PROFILELEVELTYPE *pParamProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *) ComponentParameterStructure;
1725 if (pCompPortOut->pPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
1726 pParamProfileLevel->eProfile = pComponentPrivate->pH264->eProfile;
1727 pParamProfileLevel->eLevel = pComponentPrivate->pH264->eLevel;
1728 }
1729 else if (pCompPortOut->pPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingMPEG4) {
1730 pParamProfileLevel->eProfile = pComponentPrivate->pMpeg4->eProfile;
1731 pParamProfileLevel->eLevel = pComponentPrivate->pMpeg4->eLevel;
1732
1733 }
1734 else if (pCompPortOut->pPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingH263) {
1735 pParamProfileLevel->eProfile = pComponentPrivate->pH263->eProfile;
1736 pParamProfileLevel->eLevel = pComponentPrivate->pH263->eLevel;
1737 }
1738 else {
1739 eError = OMX_ErrorBadParameter;
1740 }
1741
1742 }
1743 break;
1744
1745 case OMX_IndexParamVideoErrorCorrection:
1746 {
1747 if (((OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE*)(ComponentParameterStructure))->nPortIndex ==
1748 VIDENC_OUTPUT_PORT)
1749 {
1750 pTmp = memcpy(ComponentParameterStructure,
1751 pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pErrorCorrectionType,
1752 sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
1753 if (pTmp == NULL)
1754 {
1755 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1756 pComponentPrivate->dbg, OMX_TRACE4,
1757 "Failed to copy OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE parameter.\n");
1758 }
1759 }
1760 else
1761 {
1762 eError = OMX_ErrorBadPortIndex;
1763 }
1764 break;
1765 }
1766
1767 case VideoEncodeCustomParamIndexVBVSize:
1768 (*((OMX_U32*)ComponentParameterStructure)) = (OMX_U32)pComponentPrivate->nVBVSize;
1769 break;
1770 case VideoEncodeCustomParamIndexDeblockFilter:
1771 (*((OMX_BOOL*)ComponentParameterStructure)) = (OMX_BOOL)pComponentPrivate->bDeblockFilter;
1772 break;
1773 case VideoEncodeCustomParamIndexEncodingPreset:
1774 (*((unsigned int*)ComponentParameterStructure)) = (unsigned int)pComponentPrivate->nEncodingPreset;
1775 break;
1776 case VideoEncodeCustomConfigIndexUnrestrictedMV:
1777 (*((OMX_U8*)ComponentParameterStructure)) = (OMX_U8)pComponentPrivate->ucUnrestrictedMV;
1778 break;
1779 case VideoEncodeCustomParamIndexNALFormat:
1780 (*((unsigned int*)ComponentParameterStructure)) = (unsigned int)pComponentPrivate->AVCNALFormat;
1781 break;
1782 case PV_OMX_COMPONENT_CAPABILITY_TYPE_INDEX:
1783 pTmp = memcpy(ComponentParameterStructure,
1784 pComponentPrivate->pCapabilityFlags,
1785 sizeof(PV_OMXComponentCapabilityFlagsType));
1786 if (pTmp == NULL)
1787 {
1788 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorUndefined);
1789 }
1790 break;
1791 //not supported yet
1792 case OMX_IndexConfigCommonRotate:
1793 break;
1794 default:
1795 eError = OMX_ErrorUnsupportedIndex;
1796 break;
1797 }
1798 OMX_CONF_CMD_BAIL:
1799 return eError;
1800 }
1801
1802 /*----------------------------------------------------------------------------*/
1803 /**
1804 * SetParameter() Sets application callbacks to the component
1805 *
1806 * This method will update application callbacks
1807 * the application.
1808 *
1809 * @param pComp handle for this instance of the component
1810 * @param pCallBacks application callbacks
1811 * @param ptr
1812 *
1813 * @retval OMX_NoError Success, ready to roll
1814 * OMX_Error_BadParameter The input parameter pointer is null
1815 **/
1816 /*----------------------------------------------------------------------------*/
1817
SetParameter(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_INDEXTYPE nParamIndex,OMX_IN OMX_PTR pCompParam)1818 static OMX_ERRORTYPE SetParameter (OMX_IN OMX_HANDLETYPE hComponent,
1819 OMX_IN OMX_INDEXTYPE nParamIndex,
1820 OMX_IN OMX_PTR pCompParam)
1821 {
1822 VIDENC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
1823 OMX_ERRORTYPE eError = OMX_ErrorNone;
1824 OMX_U32* pTmp = NULL;
1825 VIDENC_NODE* pMemoryListHead = NULL;
1826 VIDEOENC_PORT_TYPE* pCompPortIn = NULL;
1827 VIDEOENC_PORT_TYPE* pCompPortOut = NULL;
1828
1829 #ifdef __KHRONOS_CONF_1_1__
1830 OMX_PARAM_COMPONENTROLETYPE *pRole = NULL;
1831 OMX_VIDEO_PARAM_PROFILELEVELTYPE* sProfileLevel;
1832 #endif
1833 OMX_CONF_CHECK_CMD(hComponent, ((OMX_COMPONENTTYPE *) hComponent)->pComponentPrivate, 1);
1834
1835 pComponentPrivate = (VIDENC_COMPONENT_PRIVATE*)(((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate);
1836 OMX_DBG_CHECK_CMD(pComponentPrivate->dbg, pCompParam, 1, 1);
1837
1838 pMemoryListHead = pComponentPrivate->pMemoryListHead;
1839 pCompPortIn = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT];
1840 pCompPortOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT];
1841
1842 if ((pComponentPrivate->eState != OMX_StateLoaded) &&
1843 (pComponentPrivate->eState != OMX_StateWaitForResources) &&
1844 (nParamIndex != OMX_IndexParamPortDefinition ||
1845 (pCompPortIn->pPortDef->bEnabled && pCompPortOut->pPortDef->bEnabled)))
1846 {
1847 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorIncorrectStateOperation,
1848 pComponentPrivate->dbg, OMX_PRSTATE3,
1849 "Call in an invalid state.\n");
1850 }
1851
1852 switch (nParamIndex)
1853 {
1854 case OMX_IndexParamVideoPortFormat:
1855 {
1856 OMX_VIDEO_PARAM_PORTFORMATTYPE* pComponentParam = (OMX_VIDEO_PARAM_PORTFORMATTYPE*)pCompParam;
1857 if (pComponentParam->nPortIndex == pCompPortIn->pPortFormat->nPortIndex)
1858 {
1859 pTmp = memcpy(pCompPortIn->pPortFormat,
1860 pComponentParam,
1861 sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
1862 if (pTmp == NULL)
1863 {
1864 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1865 pComponentPrivate->dbg, OMX_TRACE4,
1866 "Failed to copy parameter.\n");
1867 }
1868 }
1869 else if (pComponentParam->nPortIndex == pCompPortOut->pPortFormat->nPortIndex)
1870 {
1871 pTmp = memcpy(pCompPortOut->pPortFormat,
1872 pComponentParam,
1873 sizeof(OMX_VIDEO_PARAM_PORTFORMATTYPE));
1874 if (pTmp == NULL)
1875 {
1876 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1877 pComponentPrivate->dbg, OMX_TRACE4,
1878 "Failed to copy parameter.\n");
1879 }
1880 }
1881 else
1882 {
1883 eError = OMX_ErrorBadPortIndex;
1884 }
1885 break;
1886 }
1887 case OMX_IndexParamVideoInit:
1888 pTmp = memcpy(pComponentPrivate->pPortParamType,
1889 (OMX_PORT_PARAM_TYPE*)pCompParam,
1890 sizeof(OMX_PORT_PARAM_TYPE));
1891 if (pTmp == NULL)
1892 {
1893 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1894 pComponentPrivate->dbg, OMX_TRACE4,
1895 "Failed to copy parameter.\n");
1896 }
1897 break;
1898 case OMX_IndexParamPortDefinition:
1899 {
1900 OMX_PARAM_PORTDEFINITIONTYPE* pComponentParam = (OMX_PARAM_PORTDEFINITIONTYPE*)pCompParam;
1901 eError = IsResolutionPlayable(pCompPortIn->pPortDef->format.video.nFrameWidth, pCompPortIn->pPortDef->format.video.nFrameHeight);
1902 if (eError != OMX_ErrorNone)
1903 {
1904 /* OMX components co-existance, if resolution is 720p or higher let the 720p OMX
1905 * component to take care of them */
1906 return OMX_ErrorBadParameter;
1907 }
1908 if (pComponentParam->nPortIndex == pCompPortIn->pPortDef->nPortIndex)
1909 {
1910 pTmp = memcpy(pCompPortIn->pPortDef,
1911 pComponentParam,
1912 sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1913 if (pTmp == NULL)
1914 {
1915 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1916 pComponentPrivate->dbg, OMX_TRACE4,
1917 "Failed to copy parameter.\n");
1918 }
1919 CalculateBufferSize(pCompPortIn->pPortDef, pComponentPrivate);
1920 }
1921 else if (pComponentParam->nPortIndex == pCompPortOut->pPortDef->nPortIndex)
1922 {
1923 pTmp = memcpy(pCompPortOut->pPortDef,
1924 pComponentParam,
1925 sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1926 if (pTmp == NULL)
1927 {
1928 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1929 pComponentPrivate->dbg, OMX_TRACE4,
1930 "Failed to copy parameter.\n");
1931 }
1932 CalculateBufferSize(pCompPortOut->pPortDef, pComponentPrivate);
1933 if(!pCompPortOut->pPortDef->format.video.nBitrate)
1934 {
1935 pCompPortOut->pPortDef->format.video.nBitrate = OMX_VIDENC_GetDefaultBitRate(pComponentPrivate);
1936 }
1937 pCompPortOut->pBitRateTypeConfig->nEncodeBitrate =
1938 pCompPortOut->pBitRateType->nTargetBitrate =
1939 pCompPortOut->pPortDef->format.video.nBitrate;
1940 }
1941 else
1942 {
1943 eError = OMX_ErrorBadPortIndex;
1944 }
1945 break;
1946 }
1947 case OMX_IndexParamVideoAvc:
1948 {
1949 OMX_VIDEO_PARAM_AVCTYPE* pComponentParam = (OMX_VIDEO_PARAM_AVCTYPE*)pCompParam;
1950 if (pComponentParam->nPortIndex == pComponentPrivate->pH264->nPortIndex)
1951 {
1952 pTmp = memcpy(pComponentPrivate->pH264,
1953 pCompParam,
1954 sizeof(OMX_VIDEO_PARAM_AVCTYPE));
1955 if (pTmp == NULL)
1956 {
1957 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1958 pComponentPrivate->dbg, OMX_TRACE4,
1959 "Failed to copy parameter.\n");
1960 }
1961 CalculateBufferSize(pCompPortOut->pPortDef, pComponentPrivate);
1962 }
1963 else
1964 {
1965 eError = OMX_ErrorBadPortIndex;
1966 }
1967 break;
1968 }
1969 case OMX_IndexParamVideoMpeg4:
1970 {
1971 OMX_VIDEO_PARAM_MPEG4TYPE* pComponentParam = (OMX_VIDEO_PARAM_MPEG4TYPE*)pCompParam;
1972 if (pComponentParam->nPortIndex == pComponentPrivate->pMpeg4->nPortIndex)
1973 {
1974 pTmp = memcpy(pComponentPrivate->pMpeg4,
1975 pCompParam,
1976 sizeof(OMX_VIDEO_PARAM_MPEG4TYPE));
1977 if (pTmp == NULL)
1978 {
1979 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1980 pComponentPrivate->dbg, OMX_TRACE4,
1981 "Failed to copy parameter.\n");
1982 }
1983 }
1984 else
1985 {
1986 eError = OMX_ErrorBadPortIndex;
1987 }
1988 break;
1989 }
1990 case OMX_IndexParamPriorityMgmt:
1991 pTmp = memcpy(pComponentPrivate->pPriorityMgmt,
1992 (OMX_PRIORITYMGMTTYPE*)pCompParam,
1993 sizeof(OMX_PRIORITYMGMTTYPE));
1994 if (pTmp == NULL)
1995 {
1996 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
1997 pComponentPrivate->dbg, OMX_TRACE4,
1998 "Failed to copy parameter.\n");
1999 }
2000 break;
2001 case OMX_IndexParamCompBufferSupplier:
2002 {
2003 OMX_PARAM_BUFFERSUPPLIERTYPE* pBuffSupplierParam = (OMX_PARAM_BUFFERSUPPLIERTYPE*)pCompParam;
2004 if (pBuffSupplierParam->nPortIndex == VIDENC_INPUT_PORT)
2005 {
2006 pCompPortIn->eSupplierSetting = pBuffSupplierParam->eBufferSupplier;
2007 }
2008 else if (pBuffSupplierParam->nPortIndex == VIDENC_OUTPUT_PORT)
2009 {
2010 pCompPortOut->eSupplierSetting = pBuffSupplierParam->eBufferSupplier;
2011 }
2012 else
2013 {
2014 eError = OMX_ErrorBadPortIndex;
2015 }
2016 break;
2017 }
2018 case OMX_IndexParamVideoBitrate:
2019 {
2020 OMX_VIDEO_PARAM_BITRATETYPE* pComponentParam = (OMX_VIDEO_PARAM_BITRATETYPE*)pCompParam;
2021 if (pComponentParam->nPortIndex == pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pBitRateType->nPortIndex)
2022 {
2023 pTmp = memcpy(pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pBitRateType,
2024 pCompParam,
2025 sizeof(OMX_VIDEO_PARAM_BITRATETYPE));
2026 if (pTmp == NULL)
2027 {
2028 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
2029 pComponentPrivate->dbg, OMX_TRACE4,
2030 "Failed to copy parameter.\n");
2031 }
2032 if(!pCompPortOut->pBitRateType->nTargetBitrate)
2033 {
2034 pCompPortOut->pBitRateType->nTargetBitrate = OMX_VIDENC_GetDefaultBitRate(pComponentPrivate);
2035 }
2036 pCompPortOut->pPortDef->format.video.nBitrate =
2037 pCompPortOut->pBitRateTypeConfig->nEncodeBitrate =
2038 pCompPortOut->pBitRateType->nTargetBitrate;
2039 }
2040 else
2041 {
2042 eError = OMX_ErrorBadPortIndex;
2043 }
2044 break;
2045 }
2046 case OMX_IndexParamVideoErrorCorrection:
2047 {
2048 pTmp = memcpy(pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pErrorCorrectionType,
2049 pCompParam,
2050 sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
2051 if (pTmp == NULL)
2052 {
2053 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
2054 pComponentPrivate->dbg, OMX_TRACE4,
2055 "Failed to copy parameter.\n");
2056 }
2057 }
2058 break;
2059 case OMX_IndexParamVideoH263:
2060 {
2061 OMX_VIDEO_PARAM_H263TYPE* pComponentParam = (OMX_VIDEO_PARAM_H263TYPE*)pCompParam;
2062 if (pComponentParam->nPortIndex == pComponentPrivate->pH263->nPortIndex)
2063 {
2064 pTmp = memcpy(pComponentPrivate->pH263,
2065 pCompParam,
2066 sizeof(OMX_VIDEO_PARAM_H263TYPE));
2067 if (pTmp == NULL)
2068 {
2069 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
2070 pComponentPrivate->dbg, OMX_TRACE4,
2071 "Failed to copy parameter.\n");
2072 }
2073 }
2074 else
2075 {
2076 eError = OMX_ErrorBadPortIndex;
2077 }
2078 break;
2079 }
2080 case OMX_IndexParamVideoQuantization:
2081 {
2082 OMX_VIDEO_PARAM_QUANTIZATIONTYPE* pComponentParam = (OMX_VIDEO_PARAM_QUANTIZATIONTYPE*)pCompParam;
2083 if (pComponentParam->nPortIndex == pComponentPrivate->pQuantization->nPortIndex)
2084 {
2085 pTmp = memcpy(pComponentPrivate->pQuantization,
2086 pCompParam,
2087 sizeof(OMX_VIDEO_PARAM_QUANTIZATIONTYPE));
2088 if (pTmp == NULL)
2089 {
2090 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
2091 pComponentPrivate->dbg, OMX_TRACE4,
2092 "Failed to copy parameter.\n");
2093 }
2094 }
2095 else
2096 {
2097 eError = OMX_ErrorBadPortIndex;
2098 }
2099 break;
2100 }
2101 case VideoEncodeCustomParamIndexVBVSize:
2102 pComponentPrivate->nVBVSize = (OMX_U32)(*((OMX_U32*)pCompParam));
2103 break;
2104 case VideoEncodeCustomParamIndexDeblockFilter:
2105 pComponentPrivate->bDeblockFilter = (OMX_BOOL)(*((OMX_BOOL*)pCompParam));
2106 break;
2107
2108 #ifdef __KHRONOS_CONF_1_1__
2109 case OMX_IndexParamStandardComponentRole:
2110 if (pCompParam)
2111 {
2112 pRole = (OMX_PARAM_COMPONENTROLETYPE *)pCompParam;
2113 memcpy(&(pComponentPrivate->componentRole), (void *)pRole, sizeof(OMX_PARAM_COMPONENTROLETYPE));
2114 if (strcmp((char *)pRole->cRole,"video_encoder.mpeg4")==0)
2115 {
2116 pCompPortOut->pPortDef->format.video.eCompressionFormat = OMX_VIDEO_CodingMPEG4;
2117 pCompPortOut->pPortFormat->eCompressionFormat = OMX_VIDEO_CodingMPEG4;
2118 pCompPortOut->pPortDef->format.video.nBitrate = VIDENC_STRUCT_MPEG4DEFBITRATE[0][1];
2119 }
2120 else if (strcmp((char *)pRole->cRole,"video_encoder.h263")==0)
2121 {
2122 pCompPortOut->pPortDef->format.video.eCompressionFormat = OMX_VIDEO_CodingH263;
2123 pCompPortOut->pPortFormat->eCompressionFormat = OMX_VIDEO_CodingH263;
2124 pCompPortOut->pPortDef->format.video.nBitrate = VIDENC_STRUCT_H263DEFBITRATE[0][1];
2125 }
2126 else if (strcmp((char *)pRole->cRole,"video_encoder.avc")==0)
2127 {
2128 pCompPortOut->pPortDef->format.video.eCompressionFormat = OMX_VIDEO_CodingAVC;
2129 pCompPortOut->pPortFormat->eCompressionFormat= OMX_VIDEO_CodingAVC;
2130 pCompPortOut->pPortDef->format.video.nBitrate = VIDENC_STRUCT_H264DEFBITRATE[0][1];
2131 }
2132
2133 pCompPortOut->pPortFormat->eColorFormat = OMX_COLOR_FormatUnused;
2134 pCompPortOut->pPortDef->eDomain = OMX_PortDomainVideo;
2135 pCompPortOut->pPortDef->format.video.eColorFormat = OMX_COLOR_FormatUnused;
2136 pCompPortOut->pPortDef->format.video.nFrameWidth = 176;
2137 pCompPortOut->pPortDef->format.video.nFrameHeight = 144;
2138 pCompPortOut->pPortDef->format.video.xFramerate = fToQ16(15.0);
2139 }
2140 else
2141 {
2142 eError = OMX_ErrorBadParameter;
2143 }
2144 break;
2145
2146 case OMX_IndexParamVideoProfileLevelCurrent:
2147 {
2148 VIDEO_PROFILE_LEVEL_TYPE* pProfileLevel = NULL;
2149 OMX_VIDEO_PARAM_PROFILELEVELTYPE *pParamProfileLevel = (OMX_VIDEO_PARAM_PROFILELEVELTYPE *)pCompParam;
2150
2151 /* Choose table based on compression format */
2152 switch(pCompPortOut->pPortDef->format.video.eCompressionFormat)
2153
2154 {
2155 case OMX_VIDEO_CodingH263:
2156 pProfileLevel = &SupportedH263ProfileLevels;
2157 break;
2158 case OMX_VIDEO_CodingMPEG4:
2159 pProfileLevel = &SupportedMPEG4ProfileLevels;
2160 break;
2161 case OMX_VIDEO_CodingAVC:
2162 pProfileLevel = &SupportedAVCProfileLevels;
2163 break;
2164 default:
2165 eError = OMX_ErrorBadParameter;
2166 return eError;
2167 }
2168 /* Check validity of profile & level parameters */
2169 while((pProfileLevel->nProfile != (OMX_S32)pParamProfileLevel->eProfile) ||
2170 (pProfileLevel->nLevel != (OMX_S32)pParamProfileLevel->eLevel)) {
2171 pProfileLevel++;
2172 if(pProfileLevel->nProfile == -1) break;
2173 }
2174 if(pProfileLevel->nProfile != -1) {
2175 /* Update profile & level values in the compression format specific structure */
2176 switch(pCompPortOut->pPortDef->format.video.eCompressionFormat) {
2177 case OMX_VIDEO_CodingH263:
2178 pComponentPrivate->pH263->eProfile = pParamProfileLevel->eProfile;
2179 pComponentPrivate->pH263->eLevel = pParamProfileLevel->eLevel;
2180 break;
2181 case OMX_VIDEO_CodingMPEG4:
2182 pComponentPrivate->pMpeg4->eProfile = pParamProfileLevel->eProfile;
2183 pComponentPrivate->pMpeg4->eLevel = pParamProfileLevel->eLevel;
2184 break;
2185 case OMX_VIDEO_CodingAVC:
2186 pComponentPrivate->pH264->eProfile = pParamProfileLevel->eProfile;
2187 pComponentPrivate->pH264->eLevel = pParamProfileLevel->eLevel;
2188 default:
2189 eError = OMX_ErrorBadParameter;
2190 return eError;
2191 }
2192 eError = OMX_ErrorNone;
2193 }
2194 else {
2195 eError = OMX_ErrorBadParameter;
2196 }
2197 }
2198 break;
2199 #endif
2200 /*valid for H264 only*/
2201 case VideoEncodeCustomParamIndexEncodingPreset:
2202 pComponentPrivate->nEncodingPreset = (unsigned int)(*((unsigned int*)pCompParam));
2203 break;
2204 case VideoEncodeCustomConfigIndexUnrestrictedMV:
2205 pComponentPrivate->ucUnrestrictedMV = (OMX_U8)(*((OMX_U8*)pCompParam));
2206 break;
2207 case VideoEncodeCustomParamIndexNALFormat:
2208 pComponentPrivate->AVCNALFormat = (VIDENC_AVC_NAL_FORMAT)(*((unsigned int*)pCompParam));
2209 break;
2210 //not supported yet
2211 case OMX_IndexConfigCommonRotate:
2212 break;
2213
2214 default:
2215 eError = OMX_ErrorUnsupportedIndex;
2216 break;
2217 }
2218 OMX_CONF_CMD_BAIL:
2219 return eError;
2220 }
2221
2222 /*----------------------------------------------------------------------------*/
2223 /**
2224 * GetConfig() Sets application callbacks to the component
2225 *
2226 * This method will update application callbacks
2227 * the application.
2228 *
2229 * @param pComp handle for this instance of the component
2230 * @param pCallBacks application callbacks
2231 * @param ptr
2232 *
2233 * @retval OMX_NoError Success, ready to roll
2234 * OMX_Error_BadParameter The input parameter pointer is null
2235 **/
2236 /*----------------------------------------------------------------------------*/
2237
GetConfig(OMX_HANDLETYPE hComponent,OMX_INDEXTYPE nConfigIndex,OMX_PTR ComponentConfigStructure)2238 static OMX_ERRORTYPE GetConfig (OMX_HANDLETYPE hComponent,
2239 OMX_INDEXTYPE nConfigIndex,
2240 OMX_PTR ComponentConfigStructure)
2241 {
2242 VIDENC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
2243 OMX_ERRORTYPE eError = OMX_ErrorNone;
2244 VIDENC_NODE* pMemoryListHead = NULL;
2245 OMX_U32* pTmp = NULL;
2246
2247 OMX_CONF_CHECK_CMD(hComponent, ((OMX_COMPONENTTYPE *) hComponent)->pComponentPrivate, 1);
2248
2249 pComponentPrivate = (VIDENC_COMPONENT_PRIVATE*)(((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate);
2250 OMX_DBG_CHECK_CMD(pComponentPrivate->dbg, ComponentConfigStructure, 1, 1);
2251
2252 if (pComponentPrivate->eState == OMX_StateInvalid)
2253 {
2254 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorIncorrectStateOperation,
2255 pComponentPrivate->dbg, OMX_PRSTATE3,
2256 "Component is in invalid state.\n");
2257 }
2258
2259 pMemoryListHead = pComponentPrivate->pMemoryListHead;
2260
2261 switch (nConfigIndex)
2262 {
2263 case VideoEncodeCustomConfigIndexForceIFrame:
2264 (*((OMX_BOOL*)ComponentConfigStructure)) = (OMX_BOOL)pComponentPrivate->bForceIFrame;
2265 break;
2266 case VideoEncodeCustomConfigIndexIntraFrameInterval:
2267 (*((OMX_U32*)ComponentConfigStructure)) = (OMX_U32)pComponentPrivate->nIntraFrameInterval;
2268 break;
2269 case VideoEncodeCustomConfigIndexTargetFrameRate:
2270 (*((OMX_U32*)ComponentConfigStructure)) = (OMX_U32)pComponentPrivate->nTargetFrameRate;
2271 break;
2272 case VideoEncodeCustomConfigIndexQPI:
2273 (*((OMX_U32*)ComponentConfigStructure)) = (OMX_U32)pComponentPrivate->nQPI;
2274 break;
2275 case VideoEncodeCustomConfigIndexAIRRate:
2276 (*((OMX_U32*)ComponentConfigStructure)) = (OMX_U32)pComponentPrivate->nAIRRate;
2277 break;
2278 /*ASO/FMO*/
2279 case VideoEncodeCustomConfigIndexNumSliceASO:
2280 (*((OMX_U32*)ComponentConfigStructure)) = (OMX_U32)pComponentPrivate->numSliceASO;
2281 break;
2282 case VideoEncodeCustomConfigIndexAsoSliceOrder:
2283 (*((OMX_U32*)ComponentConfigStructure)) = (OMX_U32)pComponentPrivate->asoSliceOrder;
2284 break;
2285 case VideoEncodeCustomConfigIndexNumSliceGroups:
2286 (*((OMX_U32*)ComponentConfigStructure)) = (OMX_U32)pComponentPrivate->numSliceGroups;
2287 break;
2288 case VideoEncodeCustomConfigIndexSliceGroupMapType:
2289 (*((OMX_U32*)ComponentConfigStructure)) = (OMX_U32)pComponentPrivate->sliceGroupMapType;
2290 break;
2291 case VideoEncodeCustomConfigIndexSliceGroupChangeDirectionFlag:
2292 (*((OMX_U32*)ComponentConfigStructure)) = (OMX_U32)pComponentPrivate->sliceGroupChangeDirectionFlag;
2293 break;
2294 case VideoEncodeCustomConfigIndexSliceGroupChangeRate:
2295 (*((OMX_U32*)ComponentConfigStructure)) = (OMX_U32)pComponentPrivate->sliceGroupChangeRate;
2296 break;
2297 case VideoEncodeCustomConfigIndexSliceGroupChangeCycle:
2298 (*((OMX_U32*)ComponentConfigStructure)) = (OMX_U32)pComponentPrivate->sliceGroupChangeCycle;
2299 break;
2300 case VideoEncodeCustomConfigIndexSliceGroupParams:
2301 (*((OMX_U32*)ComponentConfigStructure)) = (OMX_U32)pComponentPrivate->sliceGroupParams;
2302 break;
2303
2304 #ifdef __KHRONOS_CONF_1_1__
2305 case OMX_IndexConfigVideoFramerate:
2306 {
2307
2308 pTmp = memcpy(ComponentConfigStructure,
2309 pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pFrameRateConfig,
2310 sizeof(OMX_CONFIG_FRAMERATETYPE));
2311 if (pTmp == NULL)
2312 {
2313 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
2314 pComponentPrivate->dbg, OMX_TRACE4,
2315 "Failed to copy config.\n");
2316 }
2317 }
2318 break;
2319 case OMX_IndexConfigVideoBitrate:
2320 {
2321 pTmp = memcpy(ComponentConfigStructure,
2322 pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pBitRateTypeConfig,
2323 sizeof(OMX_VIDEO_CONFIG_BITRATETYPE));
2324 if (pTmp == NULL)
2325 {
2326 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
2327 pComponentPrivate->dbg, OMX_TRACE4,
2328 "Failed to copy config.\n");
2329 }
2330 }
2331 break;
2332 #endif
2333 case OMX_IndexParamVideoMotionVector:
2334 {
2335 /* also get parameters in this structure that are tracked outside of it */
2336 pComponentPrivate->pMotionVector->bFourMV = pComponentPrivate->maxMVperMB >= 4;
2337 pComponentPrivate->pMotionVector->eAccuracy = OMX_Video_MotionVectorQuarterPel;
2338
2339 pTmp = memcpy(ComponentConfigStructure,
2340 pComponentPrivate->pMotionVector,
2341 sizeof(OMX_VIDEO_PARAM_MOTIONVECTORTYPE));
2342 if (pTmp == NULL)
2343 {
2344 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
2345 pComponentPrivate->dbg, OMX_TRACE4,
2346 "Failed to copy config.\n");
2347 }
2348 }
2349 case OMX_IndexConfigVideoAVCIntraPeriod:
2350 {
2351 /* also get parameters in this structure that are tracked outside of it */
2352 pComponentPrivate->pH264IntraPeriod->nPFrames = pComponentPrivate->nIntraFrameInterval;
2353 pComponentPrivate->pH264IntraPeriod->nIDRPeriod = 0;
2354
2355 pTmp = memcpy(ComponentConfigStructure,
2356 pComponentPrivate->pH264IntraPeriod,
2357 sizeof(OMX_VIDEO_CONFIG_AVCINTRAPERIOD));
2358 if (pTmp == NULL)
2359 {
2360 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
2361 pComponentPrivate->dbg, OMX_TRACE4,
2362 "Failed to copy structure OMX_VIDEO_CONFIG_AVCINTRAPERIOD.\n");
2363 }
2364 }
2365 case OMX_IndexParamVideoIntraRefresh:
2366 {
2367 pTmp = memcpy(ComponentConfigStructure,
2368 pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pIntraRefreshType,
2369 sizeof(OMX_VIDEO_PARAM_INTRAREFRESHTYPE));
2370 if (pTmp == NULL)
2371 {
2372 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
2373 pComponentPrivate->dbg, OMX_TRACE4,
2374 "Failed to copy structure OMX_VIDEO_PARAM_INTRAREFRESHTYPE.\n");
2375 }
2376 }
2377 break;
2378 case OMX_IndexParamVideoErrorCorrection:
2379 {
2380 if (((OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE*)(ComponentConfigStructure))->nPortIndex ==
2381 VIDENC_OUTPUT_PORT)
2382 {
2383 pTmp = memcpy(ComponentConfigStructure,
2384 pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pErrorCorrectionType,
2385 sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
2386 if (pTmp == NULL)
2387 {
2388 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorUndefined,
2389 pComponentPrivate->dbg, OMX_TRACE4,
2390 "Failed to copy structure OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE.\n");
2391 }
2392 }
2393 else
2394 {
2395 eError = OMX_ErrorBadPortIndex;
2396 }
2397 break;
2398 }
2399 case VideoEncodeCustomConfigIndexDebug:
2400 OMX_DBG_GETCONFIG(pComponentPrivate->dbg, ComponentConfigStructure);
2401 break;
2402 case VideoEncodeCustomConfigIndexMIRRate:
2403 (*((OMX_U32*)ComponentConfigStructure)) = (OMX_U32)pComponentPrivate->nMIRRate;
2404 break;
2405 case VideoEncodeCustomConfigIndexMVDataEnable:
2406 (*((OMX_BOOL*)ComponentConfigStructure)) = (OMX_BOOL)pComponentPrivate->bMVDataEnable;
2407 break;
2408 case VideoEncodeCustomConfigIndexResyncDataEnable:
2409 (*((OMX_BOOL*)ComponentConfigStructure)) = (OMX_BOOL)pComponentPrivate->bResyncDataEnable;
2410 break;
2411 case VideoEncodeCustomConfigIndexMaxMVperMB:
2412 (*((OMX_U32*)ComponentConfigStructure)) = (OMX_U32)pComponentPrivate->maxMVperMB;
2413 break;
2414 case VideoEncodeCustomConfigIndexIntra4x4EnableIdc:
2415 (*((IH264VENC_Intra4x4Params*)ComponentConfigStructure)) = (IH264VENC_Intra4x4Params)pComponentPrivate->intra4x4EnableIdc;
2416 break;
2417 default:
2418 eError = OMX_ErrorUnsupportedIndex;
2419 break;
2420 }
2421
2422 OMX_CONF_CMD_BAIL:
2423 return eError;
2424 }
2425
2426 /*----------------------------------------------------------------------------*/
2427 /**
2428 * SetConfig() Sets application callbacks to the component
2429 *
2430 * This method will update application callbacks
2431 * the application.
2432 *
2433 * @param pComp handle for this instance of the component
2434 * @param pCallBacks application callbacks
2435 * @param ptr
2436 *
2437 * @retval OMX_NoError Success, ready to roll
2438 * OMX_Error_BadParameter The input parameter pointer is null
2439 **/
2440 /*----------------------------------------------------------------------------*/
2441
SetConfig(OMX_HANDLETYPE hComponent,OMX_INDEXTYPE nConfigIndex,OMX_PTR ComponentConfigStructure)2442 static OMX_ERRORTYPE SetConfig (OMX_HANDLETYPE hComponent,
2443 OMX_INDEXTYPE nConfigIndex,
2444 OMX_PTR ComponentConfigStructure)
2445 {
2446 VIDENC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
2447 OMX_ERRORTYPE eError = OMX_ErrorNone;
2448 VIDENC_NODE* pMemoryListHead = NULL;
2449 OMX_U32 i;
2450
2451 OMX_CONF_CHECK_CMD(hComponent, ((OMX_COMPONENTTYPE *) hComponent)->pComponentPrivate, 1);
2452
2453 pComponentPrivate = (VIDENC_COMPONENT_PRIVATE*)(((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate);
2454 OMX_DBG_CHECK_CMD(pComponentPrivate->dbg, ComponentConfigStructure, 1, 1);
2455
2456 if (pComponentPrivate->eState == OMX_StateInvalid)
2457 {
2458 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorIncorrectStateOperation,
2459 pComponentPrivate->dbg, OMX_PRSTATE3,
2460 "Component is in invalid state.\n");
2461 }
2462
2463 pMemoryListHead = pComponentPrivate->pMemoryListHead;
2464
2465 switch (nConfigIndex)
2466 {
2467 case VideoEncodeCustomConfigIndexForceIFrame:
2468 pComponentPrivate->bForceIFrame = (OMX_BOOL)(*((OMX_BOOL*)ComponentConfigStructure));
2469 break;
2470 case VideoEncodeCustomConfigIndexIntraFrameInterval:
2471 pComponentPrivate->nIntraFrameInterval = (OMX_U32)(*((OMX_U32*)ComponentConfigStructure));
2472 break;
2473 case VideoEncodeCustomConfigIndexTargetFrameRate:
2474 pComponentPrivate->nTargetFrameRate = (OMX_U32)(*((OMX_U32*)ComponentConfigStructure));
2475 break;
2476 case VideoEncodeCustomConfigIndexQPI:
2477 pComponentPrivate->nQPI = (OMX_U32)(*((OMX_U32*)ComponentConfigStructure));
2478 break;
2479 case VideoEncodeCustomConfigIndexAIRRate:
2480 pComponentPrivate->nAIRRate = (OMX_U32)(*((OMX_U32*)ComponentConfigStructure));
2481 break;
2482 /*ASO/FMO*/
2483 case VideoEncodeCustomConfigIndexNumSliceASO:
2484 pComponentPrivate->numSliceASO = (OMX_U32)(*((OMX_U32*)ComponentConfigStructure));
2485 break;
2486 case VideoEncodeCustomConfigIndexAsoSliceOrder:
2487 for(i=0; i<MAXNUMSLCGPS;i++)
2488 {
2489 pComponentPrivate->asoSliceOrder[i] = (OMX_U32)(*((*((OMX_U32**)ComponentConfigStructure))+i));
2490 }
2491 break;
2492 case VideoEncodeCustomConfigIndexNumSliceGroups:
2493 pComponentPrivate->numSliceGroups = (OMX_U32)(*((OMX_U32*)ComponentConfigStructure));
2494 break;
2495 case VideoEncodeCustomConfigIndexSliceGroupMapType:
2496 pComponentPrivate->sliceGroupMapType = (OMX_U32)(*((OMX_U32*)ComponentConfigStructure));
2497 break;
2498 case VideoEncodeCustomConfigIndexSliceGroupChangeDirectionFlag:
2499 pComponentPrivate->sliceGroupChangeDirectionFlag = (OMX_U32)(*((OMX_U32*)ComponentConfigStructure));
2500 break;
2501 case VideoEncodeCustomConfigIndexSliceGroupChangeRate:
2502 pComponentPrivate->sliceGroupChangeRate = (OMX_U32)(*((OMX_U32*)ComponentConfigStructure));
2503 break;
2504 case VideoEncodeCustomConfigIndexSliceGroupChangeCycle:
2505 pComponentPrivate->sliceGroupChangeCycle = (OMX_U32)(*((OMX_U32*)ComponentConfigStructure));
2506 break;
2507 case VideoEncodeCustomConfigIndexSliceGroupParams:
2508 for(i=0; i<MAXNUMSLCGPS;i++)
2509 {
2510 pComponentPrivate->sliceGroupParams[i] = (OMX_U32)(*((*((OMX_U32**)ComponentConfigStructure))+i));
2511 }
2512 break;
2513 case OMX_IndexConfigVideoFramerate:
2514 {
2515 memcpy(pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pFrameRateConfig,
2516 ComponentConfigStructure,
2517 sizeof(OMX_CONFIG_FRAMERATETYPE));
2518 }
2519 break;
2520 case OMX_IndexConfigVideoBitrate:
2521 {
2522 memcpy(pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pBitRateTypeConfig,
2523 ComponentConfigStructure,
2524 sizeof(OMX_VIDEO_CONFIG_BITRATETYPE));
2525
2526 if(!pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pBitRateTypeConfig->nEncodeBitrate)
2527 {
2528 pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pBitRateTypeConfig->nEncodeBitrate = OMX_VIDENC_GetDefaultBitRate(pComponentPrivate);
2529 }
2530 pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortDef->format.video.nBitrate =
2531 pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pBitRateType->nTargetBitrate =
2532 pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pBitRateTypeConfig->nEncodeBitrate;
2533 }
2534 break;
2535 case OMX_IndexParamVideoErrorCorrection:
2536 {
2537 memcpy(pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pErrorCorrectionType,
2538 ComponentConfigStructure,
2539 sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE));
2540 }
2541 break;
2542 case OMX_IndexParamVideoIntraRefresh:
2543 {
2544 memcpy(pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pIntraRefreshType,
2545 ComponentConfigStructure,
2546 sizeof(OMX_VIDEO_PARAM_INTRAREFRESHTYPE));
2547 }
2548 break;
2549 case OMX_IndexParamVideoMotionVector:
2550 {
2551 memcpy(pComponentPrivate->pMotionVector,
2552 ComponentConfigStructure,
2553 sizeof(OMX_VIDEO_PARAM_MOTIONVECTORTYPE));
2554 /* also set parameters set by this structure that are tracked outside of it */
2555 pComponentPrivate->maxMVperMB = pComponentPrivate->pMotionVector->bFourMV ? 4 : 1;
2556
2557 /* quarter pixel accuracy must be always enabled */
2558 if (pComponentPrivate->pMotionVector->eAccuracy < OMX_Video_MotionVectorQuarterPel)
2559 eError = OMX_ErrorBadParameter;
2560 }
2561 break;
2562 case OMX_IndexConfigVideoAVCIntraPeriod:
2563 {
2564 memcpy(pComponentPrivate->pH264IntraPeriod,
2565 ComponentConfigStructure,
2566 sizeof(OMX_VIDEO_CONFIG_AVCINTRAPERIOD));
2567 /* also set parameters set by this structure that are tracked outside of it */
2568 pComponentPrivate->nIntraFrameInterval = pComponentPrivate->pH264IntraPeriod->nPFrames;
2569 }
2570 break;
2571 case VideoEncodeCustomConfigIndexDebug:
2572 OMX_DBG_SETCONFIG(pComponentPrivate->dbg, ComponentConfigStructure);
2573 break;
2574 case VideoEncodeCustomConfigIndexMIRRate:
2575 pComponentPrivate->nMIRRate = (OMX_U32)(*((OMX_U32*)ComponentConfigStructure));
2576 break;
2577 case VideoEncodeCustomConfigIndexMVDataEnable:
2578 pComponentPrivate->bMVDataEnable = (OMX_BOOL)(*((OMX_BOOL*)ComponentConfigStructure));
2579 break;
2580 case VideoEncodeCustomConfigIndexResyncDataEnable:
2581 pComponentPrivate->bResyncDataEnable = (OMX_BOOL)(*((OMX_BOOL*)ComponentConfigStructure));
2582 break;
2583 case VideoEncodeCustomConfigIndexMaxMVperMB:
2584 i = (OMX_U32)(*((OMX_U32*)ComponentConfigStructure));
2585 if (i==1 || i==4)
2586 pComponentPrivate->maxMVperMB=i;
2587 else
2588 eError = OMX_ErrorBadParameter;
2589 break;
2590 case VideoEncodeCustomConfigIndexIntra4x4EnableIdc:
2591 pComponentPrivate->intra4x4EnableIdc = (IH264VENC_Intra4x4Params)(*((IH264VENC_Intra4x4Params*)ComponentConfigStructure));
2592 break;
2593 default:
2594 eError = OMX_ErrorUnsupportedIndex;
2595 break;
2596 }
2597
2598 OMX_CONF_CMD_BAIL:
2599 return eError;
2600 }
2601
2602 /*----------------------------------------------------------------------------*/
2603 /**
2604 * ExtensionIndex()
2605 *
2606 *
2607 *
2608 *
2609 * @param pComponent handle for this instance of the component
2610 * @param pCallBacks application callbacks
2611 * @param ptr
2612 *
2613 * @retval OMX_NoError Success, ready to roll
2614 * OMX_Error_BadParameter The input parameter pointer is null
2615 **/
2616 /*----------------------------------------------------------------------------*/
2617
ExtensionIndex(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_STRING cParameterName,OMX_OUT OMX_INDEXTYPE * pIndexType)2618 static OMX_ERRORTYPE ExtensionIndex(OMX_IN OMX_HANDLETYPE hComponent,
2619 OMX_IN OMX_STRING cParameterName,
2620 OMX_OUT OMX_INDEXTYPE* pIndexType)
2621 {
2622 VIDENC_CUSTOM_DEFINITION sVideoEncodeCustomIndex[] =
2623 {
2624 {"OMX.TI.VideoEncode.Param.VBVSize", VideoEncodeCustomParamIndexVBVSize},
2625 {"OMX.TI.VideoEncode.Param.DeblockFilter", VideoEncodeCustomParamIndexDeblockFilter},
2626 {"OMX.TI.VideoEncode.Config.ForceIFrame", VideoEncodeCustomConfigIndexForceIFrame},
2627 {"OMX.TI.VideoEncode.Config.IntraFrameInterval", VideoEncodeCustomConfigIndexIntraFrameInterval},
2628 {"OMX.TI.VideoEncode.Config.TargetFrameRate", VideoEncodeCustomConfigIndexTargetFrameRate},
2629 {"OMX.TI.VideoEncode.Config.QPI", VideoEncodeCustomConfigIndexQPI},
2630 {"OMX.TI.VideoEncode.Config.AIRRate", VideoEncodeCustomConfigIndexAIRRate},
2631 {"OMX.TI.VideoEncode.Config.UnrestrictedMV", VideoEncodeCustomConfigIndexUnrestrictedMV},
2632
2633 /*Segment mode Metadata*/
2634 {"OMX.TI.VideoEncode.Config.MVDataEnable", VideoEncodeCustomConfigIndexMVDataEnable},
2635 {"OMX.TI.VideoEncode.Config.ResyncDataEnable", VideoEncodeCustomConfigIndexResyncDataEnable},
2636
2637 /*ASO*/
2638 {"OMX.TI.VideoEncode.Config.NumSliceASO", VideoEncodeCustomConfigIndexNumSliceASO},
2639 {"OMX.TI.VideoEncode.Config.AsoSliceOrder", VideoEncodeCustomConfigIndexAsoSliceOrder},
2640 /*FMO*/
2641 {"OMX.TI.VideoEncode.Config.NumSliceGroups", VideoEncodeCustomConfigIndexNumSliceGroups},
2642 {"OMX.TI.VideoEncode.Config.SliceGroupMapType", VideoEncodeCustomConfigIndexSliceGroupMapType},
2643 {"OMX.TI.VideoEncode.Config.SliceGroupChangeDirectionFlag", VideoEncodeCustomConfigIndexSliceGroupChangeDirectionFlag},
2644 {"OMX.TI.VideoEncode.Config.SliceGroupChangeRate", VideoEncodeCustomConfigIndexSliceGroupChangeRate},
2645 {"OMX.TI.VideoEncode.Config.SliceGroupChangeCycle", VideoEncodeCustomConfigIndexSliceGroupChangeCycle},
2646 {"OMX.TI.VideoEncode.Config.SliceGroupParams", VideoEncodeCustomConfigIndexSliceGroupParams},
2647 /**/
2648 {"OMX.TI.VideoEncode.Config.MIRRate", VideoEncodeCustomConfigIndexMIRRate},
2649 {"OMX.TI.VideoEncode.Config.MaxMVperMB", VideoEncodeCustomConfigIndexMaxMVperMB},
2650 {"OMX.TI.VideoEncode.Config.Intra4x4EnableIdc", VideoEncodeCustomConfigIndexIntra4x4EnableIdc},
2651 {"OMX.TI.VideoEncode.Config.EncodingPreset", VideoEncodeCustomParamIndexEncodingPreset},
2652 {"OMX.TI.VideoEncode.Config.NALFormat", VideoEncodeCustomParamIndexNALFormat},
2653 {"OMX.TI.VideoEncode.Debug", VideoEncodeCustomConfigIndexDebug}
2654 };
2655 OMX_ERRORTYPE eError = OMX_ErrorNone;
2656 int nIndex = 0;
2657 const int nNumberIndices = sizeof(sVideoEncodeCustomIndex)/sizeof(sVideoEncodeCustomIndex[0]);
2658
2659 if (!hComponent || !pIndexType)
2660 {
2661 eError = OMX_ErrorBadParameter;
2662 goto OMX_CONF_CMD_BAIL;
2663 }
2664
2665 for (nIndex = 0; nIndex < nNumberIndices; nIndex++)
2666 {
2667 if (!strcmp((const char*)cParameterName, (const char*)(&(sVideoEncodeCustomIndex[nIndex].cCustomName))))
2668 {
2669 *pIndexType = sVideoEncodeCustomIndex[nIndex].nCustomIndex;
2670 eError = OMX_ErrorNone;
2671 break;
2672 }
2673 }
2674
2675 OMX_CONF_CMD_BAIL:
2676 return eError;
2677 }
2678
2679 /*----------------------------------------------------------------------------*/
2680 /**
2681 * GetState() Sets application callbacks to the component
2682 *
2683 * This method will update application callbacks
2684 * the application.
2685 *
2686 * @param pComp handle for this instance of the component
2687 * @param pCallBacks application callbacks
2688 * @param ptr
2689 *
2690 * @retval OMX_NoError Success, ready to roll
2691 * OMX_Error_BadParameter The input parameter pointer is null
2692 **/
2693 /*----------------------------------------------------------------------------*/
2694
GetState(OMX_IN OMX_HANDLETYPE hComponent,OMX_OUT OMX_STATETYPE * pState)2695 static OMX_ERRORTYPE GetState (OMX_IN OMX_HANDLETYPE hComponent,
2696 OMX_OUT OMX_STATETYPE* pState)
2697 {
2698 OMX_ERRORTYPE eError = OMX_ErrorNone;
2699 OMX_COMPONENTTYPE* pHandle = NULL;
2700 VIDENC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
2701 struct timespec abs_time = {0,0};
2702 int nPendingStateChangeRequests = 0;
2703 int ret = 0;
2704 /* Set to sufficiently high value */
2705 int mutex_timeout = 3;
2706
2707 if(hComponent == NULL || pState == NULL) {
2708 return OMX_ErrorBadParameter;
2709 }
2710
2711 pHandle = (OMX_COMPONENTTYPE*)hComponent;
2712 pComponentPrivate = (VIDENC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate;
2713
2714 /* Retrieve current state */
2715 if (pHandle && pHandle->pComponentPrivate) {
2716 /* Check for any pending state transition requests */
2717 if(pthread_mutex_lock(&pComponentPrivate->mutexStateChangeRequest)) {
2718 return OMX_ErrorUndefined;
2719 }
2720 nPendingStateChangeRequests = pComponentPrivate->nPendingStateChangeRequests;
2721 if(!nPendingStateChangeRequests) {
2722 if(pthread_mutex_unlock(&pComponentPrivate->mutexStateChangeRequest)) {
2723 return OMX_ErrorUndefined;
2724 }
2725
2726 /* No pending state transitions */
2727 *pState = ((VIDENC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate)->eState;
2728 eError = OMX_ErrorNone;
2729 }
2730 else {
2731 /* Wait for component to complete state transition */
2732 clock_gettime(CLOCK_REALTIME, &abs_time);
2733 abs_time.tv_sec += mutex_timeout;
2734 abs_time.tv_nsec = 0;
2735 ret = pthread_cond_timedwait(&(pComponentPrivate->StateChangeCondition), &(pComponentPrivate->mutexStateChangeRequest), &abs_time);
2736 if (!ret) {
2737 /* Component has completed state transitions*/
2738 *pState = ((VIDENC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate)->eState;
2739 if(pthread_mutex_unlock(&pComponentPrivate->mutexStateChangeRequest)) {
2740 return OMX_ErrorUndefined;
2741 }
2742 eError = OMX_ErrorNone;
2743 }
2744 else if(ret == ETIMEDOUT) {
2745 /* Unlock mutex in case of timeout */
2746 OMX_ERROR4(pComponentPrivate->dbg, "GetState timed out\n");
2747 pthread_mutex_unlock(&pComponentPrivate->mutexStateChangeRequest);
2748 *pState = OMX_StateInvalid;
2749 return OMX_ErrorNone;
2750 }
2751 }
2752 }
2753 else {
2754 eError = OMX_ErrorInvalidComponent;
2755 *pState = OMX_StateInvalid;
2756 }
2757
2758 return eError;
2759 }
2760
2761 /*----------------------------------------------------------------------------*/
2762 /**
2763 * EmptyThisBuffer() Sets application callbacks to the component
2764 *
2765 * This method will update application callbacks
2766 * the application.
2767 *
2768 * @param pComp handle for this instance of the component
2769 * @param pCallBacks application callbacks
2770 * @param ptr
2771 *
2772 * @retval OMX_NoError Success, ready to roll
2773 * OMX_Error_BadParameter The input parameter pointer is null
2774 **/
2775 /*----------------------------------------------------------------------------*/
2776
EmptyThisBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_BUFFERHEADERTYPE * pBufHead)2777 static OMX_ERRORTYPE EmptyThisBuffer (OMX_IN OMX_HANDLETYPE hComponent,
2778 OMX_IN OMX_BUFFERHEADERTYPE* pBufHead)
2779 {
2780 OMX_ERRORTYPE eError = OMX_ErrorNone;
2781 VIDENC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
2782 int nRet = 0;
2783 OMX_HANDLETYPE hTunnelComponent = NULL;
2784 VIDENC_BUFFER_PRIVATE* pBufferPrivate = NULL;
2785 VIDENC_NODE* pMemoryListHead = NULL;
2786 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefIn = NULL;
2787
2788 OMX_CONF_CHECK_CMD(hComponent, ((OMX_COMPONENTTYPE *) hComponent)->pComponentPrivate, 1);
2789
2790 pComponentPrivate = (VIDENC_COMPONENT_PRIVATE*)(((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate);
2791 OMX_DBG_CHECK_CMD(pComponentPrivate->dbg, pBufHead, 1, 1);
2792
2793 hTunnelComponent = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->hTunnelComponent;
2794
2795 pComponentPrivate->pMarkData = pBufHead->pMarkData;
2796 pComponentPrivate->hMarkTargetComponent = pBufHead->hMarkTargetComponent;
2797 pPortDefIn = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->pPortDef;
2798 if (!(pPortDefIn->bEnabled))
2799 {
2800 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorIncorrectStateOperation,
2801 pComponentPrivate->dbg, OMX_PRBUFFER4,
2802 "Emptying buffer on disabled port.\n");
2803 }
2804
2805 if(!hTunnelComponent)
2806 {
2807 if (pBufHead->nInputPortIndex != 0x0 ||
2808 pBufHead->nOutputPortIndex != OMX_NOPORT)
2809 {
2810 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorBadPortIndex,
2811 pComponentPrivate->dbg, OMX_PRBUFFER4,
2812 "Emptying buffer on invalid port.\n");
2813 }
2814
2815 if (pComponentPrivate->eState != OMX_StateExecuting &&
2816 pComponentPrivate->eState != OMX_StatePause)
2817 {
2818 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorIncorrectStateOperation,
2819 pComponentPrivate->dbg, OMX_PRBUFFER4,
2820 "Emptying buffer in invalid state (%d).\n", pComponentPrivate->eState);
2821 }
2822 }
2823
2824 OMX_CONF_CHK_VERSION(pBufHead, OMX_BUFFERHEADERTYPE, eError);
2825 pMemoryListHead = pComponentPrivate->pMemoryListHead;
2826
2827
2828 #ifdef __PERF_INSTRUMENTATION__
2829 PERF_ReceivedFrame(pComponentPrivate->pPERF,
2830 pBufHead->pBuffer,
2831 pBufHead->nFilledLen,
2832 PERF_ModuleHLMM);
2833 #endif
2834
2835 #ifndef UNDER_CE
2836 if (pthread_mutex_lock(&(pComponentPrivate->mVideoEncodeBufferMutex)) != 0)
2837 {
2838 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorHardware,
2839 pComponentPrivate->dbg, OMX_TRACE4,
2840 "pthread_mutex_lock() failed.\n");
2841 }
2842 pBufferPrivate = pBufHead->pInputPortPrivate;
2843
2844
2845 pBufferPrivate->eBufferOwner = VIDENC_BUFFER_WITH_COMPONENT;
2846 pBufferPrivate->bReadFromPipe = OMX_FALSE;
2847 /* Check if frame rate needs to be updated */
2848 pComponentPrivate->nFrameCount++;
2849 pComponentPrivate->nVideoTime = pBufHead->nTimeStamp - pComponentPrivate->nLastUpdateTime;
2850
2851 if (pComponentPrivate->nFrameCount == pComponentPrivate->nFrameRateUpdateInterval) {
2852
2853 if(pComponentPrivate->nVideoTime <= 0) {
2854 /* Incorrect time stamps */
2855 return OMX_ErrorBadParameter;
2856 }
2857
2858 /* Timestamps are in micro seconds */
2859 pComponentPrivate->nTargetFrameRate = pComponentPrivate->nFrameCount * 1000000 / pComponentPrivate->nVideoTime;
2860
2861 if(pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortDef->format.video.eCompressionFormat == OMX_VIDEO_CodingAVC) {
2862 /* H.264 Socket Node expects frame rate to be multiplied by 1000 */
2863 pComponentPrivate->nTargetFrameRate *= 1000;
2864
2865 if((pComponentPrivate->nPrevTargetFrameRate) &&
2866 (pComponentPrivate->nTargetFrameRate == pComponentPrivate->nPrevTargetFrameRate)) {
2867 pComponentPrivate->bForceIFrame = OMX_TRUE;
2868 }
2869 else {
2870 pComponentPrivate->nPrevTargetFrameRate = pComponentPrivate->nTargetFrameRate;
2871 pComponentPrivate->bForceIFrame = OMX_FALSE;
2872 }
2873 }
2874 pComponentPrivate->nLastUpdateTime = pBufHead->nTimeStamp;
2875 pComponentPrivate->nFrameCount = 0;
2876 }
2877
2878 nRet = write(pComponentPrivate->nFilled_iPipe[1],
2879 &(pBufHead),
2880 sizeof(pBufHead));
2881 if (nRet == -1)
2882 {
2883 pthread_mutex_unlock(&(pComponentPrivate->mVideoEncodeBufferMutex));
2884 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorHardware,
2885 pComponentPrivate->dbg, OMX_PRBUFFER4,
2886 "failed to write to nFilled_iPipe.\n");
2887 } else {
2888 OMX_VIDENC_IncrementBufferCountByOne(&pComponentPrivate->EmptythisbufferCount);
2889 }
2890 if (pthread_mutex_unlock(&(pComponentPrivate->mVideoEncodeBufferMutex)) != 0)
2891 {
2892 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorHardware,
2893 pComponentPrivate->dbg, OMX_TRACE4,
2894 "pthread_mutex_unlock() failed.\n");
2895 }
2896 #else
2897 pBufferPrivate->eBufferOwner = VIDENC_BUFFER_WITH_COMPONENT;
2898 pBufferPrivate->bReadFromPipe = OMX_FALSE;
2899 nRet = write(pComponentPrivate->nFilled_iPipe[1],
2900 &(pBufHead),
2901 sizeof(pBufHead));
2902 if (nRet == -1)
2903 {
2904 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorHardware,
2905 pComponentPrivate->dbg, OMX_PRBUFFER4,
2906 "failed to write to nFilled_iPipe.\n");
2907 }
2908 #endif
2909
2910 OMX_CONF_CMD_BAIL:
2911 return eError;
2912 }
2913
2914 /*----------------------------------------------------------------------------*/
2915 /**
2916 * FillThisBuffer() Sets application callbacks to the component
2917 *
2918 * This method will update application callbacks
2919 * the application.
2920 *
2921 * @param pComp handle for this instance of the component
2922 * @param pCallBacks application callbacks
2923 * @param ptr
2924 *
2925 * @retval OMX_NoError Success, ready to roll
2926 * OMX_Error_BadParameter The input parameter pointer is null
2927 **/
2928 /*----------------------------------------------------------------------------*/
FillThisBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_BUFFERHEADERTYPE * pBufHead)2929 static OMX_ERRORTYPE FillThisBuffer (OMX_IN OMX_HANDLETYPE hComponent,
2930 OMX_IN OMX_BUFFERHEADERTYPE* pBufHead)
2931 {
2932 OMX_ERRORTYPE eError = OMX_ErrorNone;
2933 VIDENC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
2934 int nRet = 0;
2935 VIDENC_BUFFER_PRIVATE* pBufferPrivate = NULL;
2936 OMX_HANDLETYPE hTunnelComponent = NULL;
2937 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = NULL;
2938
2939 OMX_CONF_CHECK_CMD(hComponent, ((OMX_COMPONENTTYPE *) hComponent)->pComponentPrivate, 1);
2940
2941 pComponentPrivate = (VIDENC_COMPONENT_PRIVATE*)(((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate);
2942 OMX_DBG_CHECK_CMD(pComponentPrivate->dbg, pBufHead, 1, 1);
2943
2944
2945 hTunnelComponent = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->hTunnelComponent;
2946 pPortDefOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortDef;
2947 pBufHead->nFilledLen = 0;
2948 pBufferPrivate = (VIDENC_BUFFER_PRIVATE*)pBufHead->pOutputPortPrivate;
2949
2950 if (!(pPortDefOut->bEnabled))
2951 {
2952 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorIncorrectStateOperation,
2953 pComponentPrivate->dbg, OMX_PRBUFFER4,
2954 "Filling buffer on disabled port.\n");
2955 }
2956
2957 if(!hTunnelComponent)
2958 {
2959 if (pBufHead->nOutputPortIndex != 0x1 ||
2960 pBufHead->nInputPortIndex != OMX_NOPORT)
2961 {
2962 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorBadPortIndex,
2963 pComponentPrivate->dbg, OMX_PRBUFFER4,
2964 "Filling buffer on invalid port.\n");
2965 }
2966
2967 if (pComponentPrivate->eState != OMX_StateExecuting &&
2968 pComponentPrivate->eState != OMX_StatePause)
2969 {
2970 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorIncorrectStateOperation,
2971 pComponentPrivate->dbg, OMX_PRBUFFER4,
2972 "Filling buffer in invalid state (%d).\n", pComponentPrivate->eState);
2973 }
2974 }
2975 OMX_CONF_CHK_VERSION(pBufHead, OMX_BUFFERHEADERTYPE, eError);
2976 #ifdef __PERF_INSTRUMENTATION__
2977 PERF_ReceivedFrame(pComponentPrivate->pPERF,
2978 pBufHead->pBuffer,
2979 0,
2980 PERF_ModuleHLMM);
2981 #endif
2982
2983 if (pComponentPrivate->pMarkBuf)
2984 {
2985 pBufHead->hMarkTargetComponent = pComponentPrivate->pMarkBuf->hMarkTargetComponent;
2986 pBufHead->pMarkData = pComponentPrivate->pMarkBuf->pMarkData;
2987 pComponentPrivate->pMarkBuf = NULL;
2988 }
2989
2990 if (pComponentPrivate->pMarkData)
2991 {
2992 pBufHead->hMarkTargetComponent = pComponentPrivate->hMarkTargetComponent;
2993 pBufHead->pMarkData = pComponentPrivate->pMarkData;
2994 pComponentPrivate->pMarkData = NULL;
2995 }
2996
2997 #ifndef UNDER_CE
2998 if (pthread_mutex_lock(&(pComponentPrivate->mVideoEncodeBufferMutex)) != 0)
2999 {
3000 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorHardware,
3001 pComponentPrivate->dbg, OMX_TRACE4,
3002 "pthread_mutex_lock() failed.\n");
3003 }
3004
3005
3006 pBufferPrivate->eBufferOwner = VIDENC_BUFFER_WITH_COMPONENT;
3007 pBufferPrivate->bReadFromPipe = OMX_FALSE;
3008 nRet = write(pComponentPrivate->nFree_oPipe[1],
3009 &(pBufHead),
3010 sizeof (pBufHead));
3011 if (nRet == -1)
3012 {
3013 pthread_mutex_unlock(&(pComponentPrivate->mVideoEncodeBufferMutex));
3014 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorHardware,
3015 pComponentPrivate->dbg, OMX_PRBUFFER4,
3016 "failed to write to nFree_oPipe.\n");
3017 } else {
3018 OMX_VIDENC_IncrementBufferCountByOne(&pComponentPrivate->FillthisbufferCount);
3019 }
3020 if (pthread_mutex_unlock(&(pComponentPrivate->mVideoEncodeBufferMutex)) != 0)
3021 {
3022 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorHardware,
3023 pComponentPrivate->dbg, OMX_TRACE4,
3024 "pthread_mutex_unlock() failed.\n");
3025 }
3026 #else
3027
3028 pBufferPrivate->eBufferOwner = VIDENC_BUFFER_WITH_COMPONENT;
3029 pBufferPrivate->bReadFromPipe = OMX_FALSE;
3030 nRet = write(pComponentPrivate->nFree_oPipe[1],
3031 &(pBufHead),
3032 sizeof (pBufHead));
3033 if (nRet == -1)
3034 {
3035 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorHardware,
3036 pComponentPrivate->dbg, OMX_PRBUFFER4,
3037 "failed to write to nFree_oPipe.\n");
3038 }
3039 #endif
3040 OMX_CONF_CMD_BAIL:
3041 return eError;
3042 }
3043 /*----------------------------------------------------------------------------*/
3044 /**
3045 * OMX_ComponentDeInit() Sets application callbacks to the component
3046 *
3047 * This method will update application callbacks
3048 * the application.
3049 *
3050 * @param pComp handle for this instance of the component
3051 * @param pCallBacks application callbacks
3052 * @param ptr
3053 *
3054 * @retval OMX_NoError Success, ready to roll
3055 * OMX_Error_BadParameter The input parameter pointer is null
3056 **/
3057 /*----------------------------------------------------------------------------*/
3058
ComponentDeInit(OMX_IN OMX_HANDLETYPE hComponent)3059 static OMX_ERRORTYPE ComponentDeInit(OMX_IN OMX_HANDLETYPE hComponent)
3060 {
3061 OMX_ERRORTYPE eError = OMX_ErrorNone;
3062 VIDENC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
3063 LCML_DSP_INTERFACE* pLcmlHandle = NULL;
3064 VIDENC_NODE* pMemoryListHead = NULL;
3065 OMX_ERRORTYPE eErr = OMX_ErrorNone;
3066 OMX_S32 nRet = -1;
3067 OMX_S32 nStop = -1;
3068 OMX_U32 nTimeout = 0;
3069 struct OMX_TI_Debug dbg;
3070
3071 OMX_CONF_CHECK_CMD(hComponent, ((OMX_COMPONENTTYPE *) hComponent)->pComponentPrivate, 1);
3072 pComponentPrivate = (VIDENC_COMPONENT_PRIVATE*)(((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate);
3073
3074 dbg = pComponentPrivate->dbg;
3075
3076 pMemoryListHead=pComponentPrivate->pMemoryListHead;
3077
3078 #ifdef __PERF_INSTRUMENTATION__
3079 PERF_Boundary(pComponentPrivate->pPERF,
3080 PERF_BoundaryStart | PERF_BoundaryCleanup);
3081 #endif
3082 while(1)
3083 {
3084 if(!(pComponentPrivate->bHandlingFatalError))
3085 {
3086 if(!(pComponentPrivate->bErrorLcmlHandle) &&
3087 !(pComponentPrivate->bUnresponsiveDsp))
3088 { /* Add for ResourceExhaustionTest*/
3089 pLcmlHandle = pComponentPrivate->pLCML;
3090 if (pLcmlHandle != NULL)
3091 {
3092 if (pComponentPrivate->bCodecStarted == OMX_TRUE ||
3093 pComponentPrivate->bCodecLoaded == OMX_TRUE)
3094 {
3095 eError = LCML_ControlCodec(((LCML_DSP_INTERFACE*)pLcmlHandle)->pCodecinterfacehandle,
3096 EMMCodecControlDestroy,
3097 NULL);
3098 if (eError != OMX_ErrorNone)
3099 {
3100 OMX_PRDSP4(dbg, "error when requesting EMMCodecControlDestroy");
3101 eError = OMX_ErrorUndefined;
3102 }
3103
3104 #ifdef UNDER_CE
3105 FreeLibrary(g_hLcmlDllHandle);
3106 g_hLcmlDllHandle = NULL;
3107 #endif
3108 }
3109 }
3110 }
3111 break;
3112 }
3113 if(nTimeout++ > VIDENC_MAX_COMPONENT_TIMEOUT)
3114 {
3115 OMX_ERROR5(dbg, "TimeOut in HandlingFatalError!\n");
3116 break;
3117 }
3118 sched_yield();
3119 }
3120
3121
3122 /*Unload LCML */
3123 if(pComponentPrivate->pModLcml != NULL)
3124 {
3125 #ifndef UNDER_CE
3126 dlclose(pComponentPrivate->pModLcml);
3127 #else
3128 FreeLibrary(pComponentPrivate->pModLcml);
3129 #endif
3130 pComponentPrivate->pModLcml = NULL;
3131 pComponentPrivate->pLCML = NULL;
3132 }
3133
3134
3135 pComponentPrivate->bCodecStarted = OMX_FALSE;
3136
3137 nStop = -1;
3138 #ifdef __PERF_INSTRUMENTATION__
3139 PERF_SendingCommand(pComponentPrivate->pPERF, nStop, 0, PERF_ModuleComponent);
3140 #endif
3141 OMX_PRCOMM2(dbg, "eCmd: -1 Send\n");
3142 nRet = write(pComponentPrivate->nCmdPipe[1],
3143 &nStop,
3144 sizeof(OMX_COMMANDTYPE));
3145
3146 /*Join the component thread*/
3147 /*pthread_cancel(ComponentThread);*/
3148 #ifdef UNDER_CE
3149 eErr = pthread_join(ComponentThread, NULL);
3150 #else
3151 eErr = pthread_join(pComponentPrivate->ComponentThread, NULL);
3152 #endif
3153 if (eErr != 0)
3154 {
3155 eError = OMX_ErrorHardware;
3156 OMX_TRACE4(dbg, "Error pthread_join (%d).\n", eErr);
3157 }
3158
3159 /*close the data pipe handles*/
3160 eErr = close(pComponentPrivate->nFree_oPipe[0]);
3161 if (0 != eErr && OMX_ErrorNone == eError)
3162 {
3163 eError = OMX_ErrorHardware;
3164 OMX_PRBUFFER4(dbg, "Error while closing data pipe (%d).\n", eErr);
3165 }
3166
3167 eErr = close(pComponentPrivate->nFilled_iPipe[0]);
3168 if (0 != eErr && OMX_ErrorNone == eError)
3169 {
3170 eError = OMX_ErrorHardware;
3171 OMX_PRBUFFER4(dbg, "Error while closing data pipe (%d).\n", eErr);
3172 }
3173
3174 eErr = close(pComponentPrivate->nFree_oPipe[1]);
3175 if (0 != eErr && OMX_ErrorNone == eError)
3176 {
3177 eError = OMX_ErrorHardware;
3178 OMX_PRBUFFER4(dbg, "Error while closing data pipe (%d).\n", eErr);
3179 }
3180
3181 eErr = close(pComponentPrivate->nFilled_iPipe[1]);
3182 if (0 != eErr && OMX_ErrorNone == eError)
3183 {
3184 eError = OMX_ErrorHardware;
3185 OMX_PRBUFFER4(dbg, "Error while closing data pipe (%d).\n", eErr);
3186 }
3187
3188 /*Close the command pipe handles*/
3189 eErr = close(pComponentPrivate->nCmdPipe[0]);
3190 if (0 != eErr && OMX_ErrorNone == eError)
3191 {
3192 eError = OMX_ErrorHardware;
3193 OMX_PRCOMM4(dbg, "Error while closing data pipe (%d).\n", eErr);
3194 }
3195
3196 eErr = close(pComponentPrivate->nCmdPipe[1]);
3197 if (0 != eErr && OMX_ErrorNone == eError)
3198 {
3199 eError = OMX_ErrorHardware;
3200 OMX_PRCOMM4(dbg, "Error while closing data pipe (%d).\n", eErr);
3201 }
3202 /*Close the command data pipe handles*/
3203 eErr = close(pComponentPrivate->nCmdDataPipe[0]);
3204 if (0 != eErr && OMX_ErrorNone == eError)
3205 {
3206 eError = OMX_ErrorHardware;
3207 OMX_PRCOMM4(dbg, "Error while closing data pipe (%d).\n", eErr);
3208 }
3209
3210 eErr = close(pComponentPrivate->nCmdDataPipe[1]);
3211 if (0 != eErr && OMX_ErrorNone == eError)
3212 {
3213 eError = OMX_ErrorHardware;
3214 OMX_PRCOMM4(dbg, "Error while closing data pipe (%d).\n", eErr);
3215 }
3216
3217 OMX_PRINT2(dbg, "pipes closed...\n");
3218
3219 #ifndef UNDER_CE
3220 OMX_TRACE2(dbg, "destroy mVideoEncodeBufferMutex -> %p\n",
3221 &(pComponentPrivate->mVideoEncodeBufferMutex));
3222 /* Destroy Mutex for Buffer Tracking */
3223 nRet = pthread_mutex_destroy(&(pComponentPrivate->mVideoEncodeBufferMutex));
3224 while (nRet == EBUSY)
3225 {
3226 /* The mutex is busy. We need to unlock it, then destroy it. */
3227 OMX_TRACE2(dbg, "destroy status = EBUSY\n");
3228 pthread_mutex_unlock(&(pComponentPrivate->mVideoEncodeBufferMutex));
3229 nRet = pthread_mutex_destroy(&(pComponentPrivate->mVideoEncodeBufferMutex));
3230 }
3231 #else
3232 /* Add WinCE critical section API here... */
3233 #endif
3234 #ifndef UNDER_CE
3235 pthread_mutex_destroy(&pComponentPrivate->videoe_mutex);
3236 pthread_cond_destroy(&pComponentPrivate->populate_cond);
3237 pthread_mutex_destroy(&pComponentPrivate->videoe_mutex_app);
3238 pthread_cond_destroy(&pComponentPrivate->unpopulate_cond);
3239 pthread_cond_destroy(&pComponentPrivate->flush_cond);
3240 pthread_cond_destroy(&pComponentPrivate->stop_cond);
3241 pthread_mutex_destroy(&bufferReturned_mutex);
3242 pthread_cond_destroy(&bufferReturned_condition);
3243 #else
3244 OMX_DestroyEvent(&(pComponentPrivate->InLoaded_event));
3245 OMX_DestroyEvent(&(pComponentPrivate->InIdle_event));
3246 #endif
3247
3248 #ifdef RESOURCE_MANAGER_ENABLED
3249 /* Deinitialize Resource Manager */
3250 eError = RMProxy_DeinitalizeEx(OMX_COMPONENTTYPE_VIDEO);
3251 if (eError != OMX_ErrorNone)
3252 {
3253 OMX_PRMGR4(dbg, "Error returned from destroy ResourceManagerProxy thread\n");
3254 eError = OMX_ErrorUndefined;
3255 }
3256 #endif
3257
3258 #ifdef __PERF_INSTRUMENTATION__
3259 PERF_Boundary(pComponentPrivate->pPERF,
3260 PERF_BoundaryComplete | PERF_BoundaryCleanup);
3261 PERF_Done(pComponentPrivate->pPERF);
3262 #endif
3263
3264 pthread_mutex_destroy(&pComponentPrivate->mutexStateChangeRequest);
3265 pthread_cond_destroy(&pComponentPrivate->StateChangeCondition);
3266
3267 if (pComponentPrivate != NULL)
3268 {
3269 VIDENC_FREE(pComponentPrivate, pMemoryListHead, dbg);
3270 }
3271
3272 /* Free Resources */
3273 OMX_VIDENC_ListDestroy(&dbg, pMemoryListHead);
3274
3275 OMX_DBG_CLOSE(dbg);
3276
3277 OMX_CONF_CMD_BAIL:
3278 return eError;
3279 }
3280
3281 /*----------------------------------------------------------------------------*/
3282 /**
3283 * UseBuffer()
3284 *
3285 *
3286 *
3287 *
3288 * @param
3289 * @param
3290 * @param
3291 *
3292 * @retval OMX_NoError Success, ready to roll
3293 * OMX_Error_BadParameter The input parameter pointer is null
3294 **/
3295 /*----------------------------------------------------------------------------*/
3296
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)3297 OMX_ERRORTYPE UseBuffer(OMX_IN OMX_HANDLETYPE hComponent,
3298 OMX_INOUT OMX_BUFFERHEADERTYPE** ppBufferHdr,
3299 OMX_IN OMX_U32 nPortIndex,
3300 OMX_IN OMX_PTR pAppPrivate,
3301 OMX_IN OMX_U32 nSizeBytes,
3302 OMX_IN OMX_U8* pBuffer)
3303 {
3304 VIDENC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
3305 OMX_PARAM_PORTDEFINITIONTYPE* pPortDef = NULL;
3306 VIDEOENC_PORT_TYPE* pCompPort = NULL;
3307 VIDENC_BUFFER_PRIVATE* pBufferPrivate = NULL;
3308 OMX_U32 nBufferCnt = -1;
3309 OMX_ERRORTYPE eError = OMX_ErrorNone;
3310 OMX_HANDLETYPE hTunnelComponent = NULL;
3311 VIDENC_NODE* pMemoryListHead = NULL;
3312
3313 OMX_CONF_CHECK_CMD(hComponent, ((OMX_COMPONENTTYPE *) hComponent)->pComponentPrivate, 1);
3314
3315 pComponentPrivate = (VIDENC_COMPONENT_PRIVATE*)(((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate);
3316 OMX_DBG_CHECK_CMD(pComponentPrivate->dbg, ppBufferHdr, pBuffer, 1);
3317
3318 if (nPortIndex == VIDENC_INPUT_PORT)
3319 {
3320 pPortDef = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->pPortDef;
3321 }
3322 else if (nPortIndex == VIDENC_OUTPUT_PORT)
3323 {
3324 pPortDef = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortDef;
3325 }
3326 else
3327 {
3328 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorBadParameter,
3329 pComponentPrivate->dbg, OMX_PRBUFFER4,
3330 "Using buffer on invalid port index.\n");
3331 }
3332
3333 if (!pPortDef->bEnabled)
3334 {
3335 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorIncorrectStateOperation,
3336 pComponentPrivate->dbg, OMX_PRBUFFER4,
3337 "Using buffer on disabled port.\n");
3338 }
3339
3340 if (pPortDef->bPopulated)
3341 {
3342 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorBadParameter,
3343 pComponentPrivate->dbg, OMX_PRBUFFER4,
3344 "Allocating duplicate buffer\n");
3345 }
3346 if (nSizeBytes < pPortDef->nBufferSize)
3347 {
3348 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorBadParameter,
3349 pComponentPrivate->dbg, OMX_PRBUFFER4,
3350 "Allocating invalid size buffer: nBufferSize: %lu nSizeBytes: %lu\n", pPortDef->nBufferSize, nSizeBytes);
3351 }
3352
3353
3354 if (pComponentPrivate->eState == OMX_StateInvalid)
3355 {
3356 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorInvalidState,
3357 pComponentPrivate->dbg, OMX_PRBUFFER4,
3358 "Using buffer in invalid state.\n");
3359 }
3360
3361 pMemoryListHead=pComponentPrivate->pMemoryListHead;
3362
3363
3364 #ifdef __PERF_INSTRUMENTATION__
3365 PERF_ReceivedBuffer(pComponentPrivate->pPERF,
3366 pBuffer, nSizeBytes,
3367 PERF_ModuleHLMM);
3368 #endif
3369
3370 nBufferCnt = pComponentPrivate->pCompPort[nPortIndex]->nBufferCnt;
3371 hTunnelComponent = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->hTunnelComponent;
3372 pCompPort = pComponentPrivate->pCompPort[nPortIndex];
3373 pBufferPrivate = pCompPort->pBufferPrivate[nBufferCnt];
3374
3375 VIDENC_MALLOC(pBufferPrivate->pBufferHdr,
3376 sizeof(OMX_BUFFERHEADERTYPE),
3377 OMX_BUFFERHEADERTYPE, pMemoryListHead, pComponentPrivate->dbg);
3378
3379 pBufferPrivate->pBufferHdr->nSize = sizeof(OMX_BUFFERHEADERTYPE);
3380 pBufferPrivate->pBufferHdr->nVersion = pPortDef->nVersion;
3381 pBufferPrivate->pBufferHdr->pBuffer = pBuffer;
3382 pBufferPrivate->pBufferHdr->pAppPrivate = pAppPrivate;
3383 pBufferPrivate->pBufferHdr->nAllocLen = nSizeBytes;
3384
3385 if (hTunnelComponent != NULL)
3386 {
3387 /* set direction dependent fields */
3388 if (pPortDef->eDir == OMX_DirInput)
3389 {
3390 pBufferPrivate->pBufferHdr->nInputPortIndex = nPortIndex;
3391 pBufferPrivate->pBufferHdr->nOutputPortIndex = pCompPort->nTunnelPort;
3392 }
3393 else
3394 {
3395 pBufferPrivate->pBufferHdr->nInputPortIndex = pCompPort->nTunnelPort;
3396 pBufferPrivate->pBufferHdr->nOutputPortIndex = nPortIndex;
3397 }
3398 }
3399 else
3400 {
3401 if (nPortIndex == VIDENC_INPUT_PORT)
3402 {
3403 pBufferPrivate->pBufferHdr->nInputPortIndex = VIDENC_INPUT_PORT;
3404 pBufferPrivate->pBufferHdr->nOutputPortIndex = OMX_NOPORT;
3405 }
3406 else
3407 {
3408 pBufferPrivate->pBufferHdr->nInputPortIndex = OMX_NOPORT;
3409 pBufferPrivate->pBufferHdr->nOutputPortIndex = VIDENC_OUTPUT_PORT;
3410 }
3411 }
3412 *ppBufferHdr = pBufferPrivate->pBufferHdr;
3413 pBufferPrivate->pBufferHdr = pBufferPrivate->pBufferHdr;
3414
3415 if (nPortIndex == VIDENC_INPUT_PORT)
3416 {
3417 pBufferPrivate->pBufferHdr->pInputPortPrivate = pBufferPrivate;
3418 if(!pComponentPrivate->nInBufferSize || (pComponentPrivate->nInBufferSize > nSizeBytes)) {
3419 pComponentPrivate->nInBufferSize = nSizeBytes;
3420 }
3421 }
3422 else
3423 {
3424 pBufferPrivate->pBufferHdr->pOutputPortPrivate = pBufferPrivate;
3425 if(!pComponentPrivate->nOutBufferSize || (pComponentPrivate->nOutBufferSize > nSizeBytes)) {
3426 pComponentPrivate->nOutBufferSize = nSizeBytes;
3427 }
3428 }
3429 pBufferPrivate->bAllocByComponent = OMX_FALSE;
3430
3431 if (hTunnelComponent != NULL)
3432 {
3433 pBufferPrivate->eBufferOwner = VIDENC_BUFFER_WITH_TUNNELEDCOMP;
3434 }
3435 else
3436 {
3437 pBufferPrivate->eBufferOwner = VIDENC_BUFFER_WITH_CLIENT;
3438 }
3439
3440 eError = OMX_VIDENC_Allocate_DSPResources(pComponentPrivate, nPortIndex);
3441 OMX_DBG_BAIL_IF_ERROR(eError, pComponentPrivate->dbg, OMX_PRDSP4,
3442 "Failed to allocate DSP resources.\n");
3443
3444 OMX_CONF_CIRCULAR_BUFFER_ADD_NODE(pComponentPrivate,
3445 pComponentPrivate->sCircularBuffer);
3446 pCompPort->nBufferCnt++;
3447 if(pCompPort->nBufferCnt == pPortDef->nBufferCountActual)
3448 {
3449 #ifndef UNDER_CE
3450 pthread_mutex_lock(&pComponentPrivate->videoe_mutex_app);
3451 pPortDef->bPopulated = OMX_TRUE;
3452 pthread_cond_signal(&pComponentPrivate->populate_cond);
3453 pthread_mutex_unlock(&pComponentPrivate->videoe_mutex_app);
3454 #else
3455 pPortDef->bPopulated = OMX_TRUE;
3456 OMX_SignalEvent(&(pComponentPrivate->InLoaded_event));
3457 #endif
3458 }
3459 OMX_CONF_CMD_BAIL:
3460 return eError;
3461 }
3462
3463 /*----------------------------------------------------------------------------*/
3464 /**
3465 * FreeBuffer()
3466 *
3467 *
3468 *
3469 *
3470 * @param
3471 * @param
3472 * @param
3473 *
3474 * @retval OMX_NoError Success, ready to roll
3475 * OMX_Error_BadParameter The input parameter pointer is null
3476 **/
3477 /*----------------------------------------------------------------------------*/
3478
FreeBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_BUFFERHEADERTYPE * pBufHead)3479 OMX_ERRORTYPE FreeBuffer(OMX_IN OMX_HANDLETYPE hComponent,
3480 OMX_IN OMX_U32 nPortIndex,
3481 OMX_IN OMX_BUFFERHEADERTYPE* pBufHead)
3482 {
3483 OMX_ERRORTYPE eError = OMX_ErrorNone;
3484 OMX_COMPONENTTYPE* pHandle = NULL;
3485 VIDENC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
3486 char* pTemp = NULL;
3487 VIDEOENC_PORT_TYPE* pCompPort = NULL;
3488 OMX_PARAM_PORTDEFINITIONTYPE* pPortDef = NULL;
3489 OMX_PARAM_PORTDEFINITIONTYPE* pPortDefOut = NULL;
3490 OMX_VIDEO_CODINGTYPE eCompressionFormat = -1;
3491 OMX_U32 nBufferCnt = -1;
3492 OMX_U8 nCount = 0;
3493 VIDENC_BUFFER_PRIVATE* pBufferPrivate = NULL;
3494 VIDENC_NODE* pMemoryListHead = NULL;
3495
3496 OMX_CONF_CHECK_CMD(hComponent, ((OMX_COMPONENTTYPE *) hComponent)->pComponentPrivate, 1);
3497
3498 pComponentPrivate = (VIDENC_COMPONENT_PRIVATE*)(((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate);
3499 OMX_DBG_CHECK_CMD(pComponentPrivate->dbg, pBufHead, 1, 1);
3500 /*OMX_CONF_CHK_VERSION(pBufHead, OMX_BUFFERHEADERTYPE, eError); Makes CONF_FlushTest Fail*/
3501
3502 pHandle = (OMX_COMPONENTTYPE*)hComponent;
3503
3504 pMemoryListHead = pComponentPrivate->pMemoryListHead;
3505 pCompPort = pComponentPrivate->pCompPort[nPortIndex];
3506 pPortDefOut = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortDef;
3507 pPortDef = pComponentPrivate->pCompPort[nPortIndex]->pPortDef;
3508 nBufferCnt = pComponentPrivate->pCompPort[nPortIndex]->nBufferCnt;
3509
3510 eCompressionFormat = pPortDefOut->format.video.eCompressionFormat;
3511
3512 if (nPortIndex == VIDENC_INPUT_PORT)
3513 {
3514 pBufferPrivate = pBufHead->pInputPortPrivate;
3515 if (pBufferPrivate != NULL)
3516 {
3517 if (pBufferPrivate->pUalgParam != NULL)
3518 {
3519 pTemp = (char*)pBufferPrivate->pUalgParam;
3520 pTemp -= 128;
3521 if (eCompressionFormat == OMX_VIDEO_CodingAVC)
3522 {
3523 pBufferPrivate->pUalgParam = (H264VE_GPP_SN_UALGInputParams*)pTemp;
3524 }
3525 else if (eCompressionFormat == OMX_VIDEO_CodingMPEG4 ||
3526 eCompressionFormat ==OMX_VIDEO_CodingH263)
3527 {
3528 pBufferPrivate->pUalgParam = (MP4VE_GPP_SN_UALGInputParams*)pTemp;
3529 }
3530 }
3531 VIDENC_FREE(pBufferPrivate->pUalgParam, pMemoryListHead, pComponentPrivate->dbg);
3532 }
3533 }
3534 else if (nPortIndex == VIDENC_OUTPUT_PORT)
3535 {
3536 pBufferPrivate = pBufHead->pOutputPortPrivate;
3537 if (pBufferPrivate != NULL)
3538 {
3539 if (pBufferPrivate->pUalgParam != NULL)
3540 {
3541 pTemp = (char*)pBufferPrivate->pUalgParam;
3542 pTemp -= 128;
3543 if (eCompressionFormat == OMX_VIDEO_CodingAVC)
3544 {
3545 pBufferPrivate->pUalgParam = (H264VE_GPP_SN_UALGOutputParams*)pTemp;
3546 }
3547 else if (eCompressionFormat == OMX_VIDEO_CodingMPEG4 ||
3548 eCompressionFormat ==OMX_VIDEO_CodingH263)
3549 {
3550 pBufferPrivate->pUalgParam = (MP4VE_GPP_SN_UALGOutputParams*)pTemp;
3551 }
3552 }
3553 VIDENC_FREE(pBufferPrivate->pUalgParam, pMemoryListHead, pComponentPrivate->dbg);
3554 }
3555 }
3556 else
3557 {
3558 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorBadPortIndex,
3559 pComponentPrivate->dbg, OMX_PRBUFFER4,
3560 "Freeing buffer on invalid port index.\n");
3561 }
3562
3563 if (pPortDef->bEnabled && pComponentPrivate->eState != OMX_StateIdle && pComponentPrivate->eState != OMX_StateInvalid)
3564 {
3565 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorIncorrectStateOperation,
3566 pComponentPrivate->dbg, OMX_PRBUFFER4,
3567 "Freeing buffer in invalid state or on a disabled port.\n");
3568 }
3569 OMX_CONF_CHECK_CMD(pBufferPrivate, 1, 1);
3570
3571 #ifdef __PERF_INSTRUMENTATION__
3572 PERF_SendingBuffer(pComponentPrivate->pPERF,
3573 pBufHead->pBuffer, pBufHead->nAllocLen,
3574 (pBufferPrivate->bAllocByComponent == OMX_TRUE) ?
3575 PERF_ModuleMemory :
3576 PERF_ModuleHLMM);
3577 #endif
3578
3579 if (pBufferPrivate->bAllocByComponent == OMX_TRUE)
3580 {
3581 if (pBufHead->pBuffer != NULL)
3582 {
3583 pBufHead->pBuffer -= 128;
3584 pBufHead->pBuffer = (unsigned char*)pBufHead->pBuffer;
3585 VIDENC_FREE(pBufHead->pBuffer, pMemoryListHead, pComponentPrivate->dbg);
3586 }
3587 }
3588
3589 while (1)
3590 {
3591 if (pCompPort->pBufferPrivate[nCount]->pBufferHdr == pBufHead)
3592 {
3593 break;
3594 }
3595 nCount++;
3596 }
3597
3598 if (pBufHead != NULL)
3599 {
3600 VIDENC_FREE(pBufHead, pMemoryListHead, pComponentPrivate->dbg);
3601 }
3602
3603 OMX_CONF_CIRCULAR_BUFFER_DELETE_NODE(pComponentPrivate,
3604 pComponentPrivate->sCircularBuffer);
3605 pCompPort->nBufferCnt--;
3606 if (pCompPort->nBufferCnt == 0)
3607 {
3608
3609 #ifndef UNDER_CE
3610 pthread_mutex_lock(&pComponentPrivate->videoe_mutex_app);
3611 pPortDef->bPopulated = OMX_FALSE;
3612 pthread_cond_signal(&pComponentPrivate->unpopulate_cond);
3613 pthread_mutex_unlock(&pComponentPrivate->videoe_mutex_app);
3614 #else
3615 pPortDef->bPopulated = OMX_FALSE;
3616 OMX_SignalEvent(&(pComponentPrivate->InIdle_event));
3617 #endif
3618 }
3619
3620 if (pPortDef->bEnabled &&
3621 (pComponentPrivate->eState == OMX_StateIdle ||
3622 pComponentPrivate->eState == OMX_StateExecuting ||
3623 pComponentPrivate->eState == OMX_StatePause))
3624 {
3625 #ifdef __KHRONOS_CONF__
3626 if(!pComponentPrivate->bPassingIdleToLoaded)
3627 #endif
3628 OMX_VIDENC_EVENT_HANDLER(pComponentPrivate,
3629 OMX_EventError,
3630 OMX_ErrorPortUnpopulated,
3631 nPortIndex,
3632 NULL);
3633 }
3634 OMX_CONF_CMD_BAIL:
3635 return eError;
3636 }
3637
3638 /*----------------------------------------------------------------------------*/
3639 /**
3640 * AllocateBuffer()
3641 *
3642 *
3643 *
3644 *
3645 * @param
3646 * @param
3647 * @param
3648 *
3649 * @retval OMX_NoError Success, ready to roll
3650 * OMX_Error_BadParameter The input parameter pointer is null
3651 **/
3652 /*----------------------------------------------------------------------------*/
3653
AllocateBuffer(OMX_IN OMX_HANDLETYPE hComponent,OMX_INOUT OMX_BUFFERHEADERTYPE ** pBufHead,OMX_IN OMX_U32 nPortIndex,OMX_IN OMX_PTR pAppPrivate,OMX_IN OMX_U32 nSizeBytes)3654 OMX_ERRORTYPE AllocateBuffer(OMX_IN OMX_HANDLETYPE hComponent,
3655 OMX_INOUT OMX_BUFFERHEADERTYPE** pBufHead,
3656 OMX_IN OMX_U32 nPortIndex,
3657 OMX_IN OMX_PTR pAppPrivate,
3658 OMX_IN OMX_U32 nSizeBytes)
3659 {
3660 OMX_COMPONENTTYPE* pHandle = NULL;
3661 VIDENC_COMPONENT_PRIVATE* pComponentPrivate = NULL;
3662 OMX_PARAM_PORTDEFINITIONTYPE* pPortDef = NULL;
3663 VIDEOENC_PORT_TYPE* pCompPort = NULL;
3664 OMX_HANDLETYPE hTunnelComponent = NULL;
3665 VIDENC_BUFFER_PRIVATE* pBufferPrivate = NULL;
3666 OMX_U32 nBufferCnt = -1;
3667 OMX_ERRORTYPE eError = OMX_ErrorNone;
3668 VIDENC_NODE* pMemoryListHead = NULL;
3669
3670 OMX_CONF_CHECK_CMD(hComponent, ((OMX_COMPONENTTYPE *) hComponent)->pComponentPrivate, 1);
3671
3672 pComponentPrivate = (VIDENC_COMPONENT_PRIVATE*)(((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate);
3673 OMX_DBG_CHECK_CMD(pComponentPrivate->dbg, pBufHead, 1, 1);
3674
3675 pHandle = (OMX_COMPONENTTYPE*)hComponent;
3676
3677 if (nPortIndex == VIDENC_INPUT_PORT)
3678 {
3679 pPortDef = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->pPortDef;
3680 }
3681 else if (nPortIndex == VIDENC_OUTPUT_PORT)
3682 {
3683 pPortDef = pComponentPrivate->pCompPort[VIDENC_OUTPUT_PORT]->pPortDef;
3684 }
3685 else
3686 {
3687 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorBadParameter,
3688 pComponentPrivate->dbg, OMX_PRBUFFER4,
3689 "Allocating buffer on invalid port index.\n");
3690 }
3691 if (!pPortDef->bEnabled)
3692 {
3693 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorIncorrectStateOperation,
3694 pComponentPrivate->dbg, OMX_PRBUFFER4,
3695 "Allocating buffer on disabled port.\n");
3696 }
3697
3698 if (pPortDef->bPopulated)
3699 {
3700 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorBadParameter,
3701 pComponentPrivate->dbg, OMX_PRBUFFER4,
3702 "Allocating duplicate buffer\n");
3703 }
3704 if (nSizeBytes < pPortDef->nBufferSize)
3705 {
3706 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorBadParameter,
3707 pComponentPrivate->dbg, OMX_PRBUFFER4,
3708 "Allocating invalid size buffer: nBufferSize: %lu nSizeBytes: %lu\n", pPortDef->nBufferSize, nSizeBytes);
3709 }
3710
3711 pMemoryListHead = pComponentPrivate->pMemoryListHead;
3712 pCompPort = pComponentPrivate->pCompPort[nPortIndex];
3713 nBufferCnt = pComponentPrivate->pCompPort[nPortIndex]->nBufferCnt;
3714 hTunnelComponent = pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->hTunnelComponent;
3715 pBufferPrivate = pComponentPrivate->pCompPort[nPortIndex]->pBufferPrivate[nBufferCnt];
3716
3717 VIDENC_MALLOC(*pBufHead,
3718 sizeof(OMX_BUFFERHEADERTYPE),
3719 OMX_BUFFERHEADERTYPE,
3720 pMemoryListHead, pComponentPrivate->dbg);
3721
3722 if (nPortIndex == VIDENC_INPUT_PORT)
3723 {
3724 (*pBufHead)->nInputPortIndex = VIDENC_INPUT_PORT;
3725 (*pBufHead)->nOutputPortIndex = OMX_NOPORT;
3726 }
3727 else
3728 {
3729 (*pBufHead)->nInputPortIndex = OMX_NOPORT;
3730 (*pBufHead)->nOutputPortIndex = VIDENC_OUTPUT_PORT;
3731 }
3732
3733 VIDENC_MALLOC((*pBufHead)->pBuffer,
3734 nSizeBytes + 256,
3735 OMX_U8,
3736 pMemoryListHead, pComponentPrivate->dbg);
3737 ((*pBufHead)->pBuffer) += 128;
3738 ((*pBufHead)->pBuffer) = (unsigned char*)((*pBufHead)->pBuffer);
3739 (*pBufHead)->nSize = sizeof(OMX_BUFFERHEADERTYPE);
3740 (*pBufHead)->nVersion = pPortDef->nVersion;
3741 (*pBufHead)->pAppPrivate = pAppPrivate;
3742 (*pBufHead)->nAllocLen = nSizeBytes;
3743 pBufferPrivate->pBufferHdr = *pBufHead;
3744
3745 #ifdef __PERF_INSTRUMENTATION__
3746 PERF_ReceivedBuffer(pComponentPrivate->pPERF,
3747 (*pBufHead)->pBuffer, nSizeBytes,
3748 PERF_ModuleMemory);
3749 #endif
3750
3751 if (nPortIndex == VIDENC_INPUT_PORT)
3752 {
3753 pBufferPrivate->pBufferHdr->pInputPortPrivate = pBufferPrivate;
3754 if(!pComponentPrivate->nInBufferSize || (pComponentPrivate->nInBufferSize > nSizeBytes)) {
3755 pComponentPrivate->nInBufferSize = nSizeBytes;
3756 }
3757 }
3758 else
3759 {
3760 pBufferPrivate->pBufferHdr->pOutputPortPrivate = pBufferPrivate;
3761 if(!pComponentPrivate->nOutBufferSize || (pComponentPrivate->nOutBufferSize > nSizeBytes)) {
3762 pComponentPrivate->nOutBufferSize = nSizeBytes;
3763 }
3764 }
3765 pBufferPrivate->bAllocByComponent = OMX_TRUE;
3766
3767 if (hTunnelComponent != NULL)
3768 {
3769 pBufferPrivate->eBufferOwner = VIDENC_BUFFER_WITH_TUNNELEDCOMP;
3770 }
3771 else
3772 {
3773 pBufferPrivate->eBufferOwner = VIDENC_BUFFER_WITH_CLIENT;
3774 }
3775
3776 eError = OMX_VIDENC_Allocate_DSPResources(pComponentPrivate, nPortIndex);
3777 OMX_DBG_BAIL_IF_ERROR(eError, pComponentPrivate->dbg, OMX_PRDSP4,
3778 "Failed to allocate DSP resources.\n");
3779
3780 OMX_CONF_CIRCULAR_BUFFER_ADD_NODE(pComponentPrivate,
3781 pComponentPrivate->sCircularBuffer);
3782
3783 pCompPort->nBufferCnt++;
3784 if(pCompPort->nBufferCnt == pPortDef->nBufferCountActual)
3785 {
3786 #ifndef UNDER_CE
3787 pthread_mutex_lock(&pComponentPrivate->videoe_mutex_app);
3788 pPortDef->bPopulated = OMX_TRUE;
3789 pthread_cond_signal(&pComponentPrivate->populate_cond);
3790 pthread_mutex_unlock(&pComponentPrivate->videoe_mutex_app);
3791 #else
3792 pPortDef->bPopulated = OMX_TRUE;
3793 OMX_SignalEvent(&(pComponentPrivate->InLoaded_event));
3794 #endif
3795 }
3796
3797 OMX_CONF_CMD_BAIL:
3798 return eError;
3799 }
3800
3801
3802 /*----------------------------------------------------------------------------*/
3803 /**
3804 * VerifyTunnelConnection()
3805 *
3806 *
3807 *
3808 *
3809 * @param
3810 * @param
3811 * @param
3812 *
3813 * @retval OMX_NoError Success, ready to roll
3814 * OMX_Error_BadParameter The input parameter pointer is null
3815 **/
3816 /*----------------------------------------------------------------------------*/
3817
VerifyTunnelConnection(VIDEOENC_PORT_TYPE * pPort,OMX_HANDLETYPE hTunneledComp,OMX_PARAM_PORTDEFINITIONTYPE * pPortDef,struct OMX_TI_Debug * dbg)3818 OMX_ERRORTYPE VerifyTunnelConnection(VIDEOENC_PORT_TYPE* pPort,
3819 OMX_HANDLETYPE hTunneledComp,
3820 OMX_PARAM_PORTDEFINITIONTYPE* pPortDef,
3821 struct OMX_TI_Debug *dbg)
3822 {
3823 OMX_PARAM_PORTDEFINITIONTYPE sPortDef;
3824 OMX_ERRORTYPE eError = OMX_ErrorNone;
3825
3826 OMX_DBG_CHECK_CMD(*dbg, pPort, hTunneledComp, pPortDef);
3827
3828 sPortDef.nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
3829 sPortDef.nVersion.s.nVersionMajor = 0x1;
3830 sPortDef.nVersion.s.nVersionMinor = 0x0;
3831 sPortDef.nPortIndex = pPort->nTunnelPort;
3832
3833 eError = OMX_GetParameter(hTunneledComp,
3834 OMX_IndexParamPortDefinition,
3835 &sPortDef);
3836 if (eError != OMX_ErrorNone)
3837 {
3838 return eError;
3839 }
3840
3841 switch (pPortDef->eDomain)
3842 {
3843 case OMX_PortDomainOther:
3844 if (sPortDef.format.other.eFormat!= pPortDef->format.other.eFormat)
3845 {
3846 pPort->hTunnelComponent = 0;
3847 pPort->nTunnelPort = 0;
3848 return OMX_ErrorPortsNotCompatible;
3849 }
3850 break;
3851 case OMX_PortDomainAudio:
3852 if (sPortDef.format.audio.eEncoding != pPortDef->format.audio.eEncoding)
3853 {
3854 pPort->hTunnelComponent = 0;
3855 pPort->nTunnelPort = 0;
3856 return OMX_ErrorPortsNotCompatible;
3857 }
3858 break;
3859 case OMX_PortDomainVideo:
3860 if (sPortDef.format.video.eCompressionFormat != pPortDef->format.video.eCompressionFormat)
3861 {
3862 pPort->hTunnelComponent = 0;
3863 pPort->nTunnelPort = 0;
3864 return OMX_ErrorPortsNotCompatible;
3865 }
3866 break;
3867 case OMX_PortDomainImage:
3868 if (sPortDef.format.image.eCompressionFormat != pPortDef->format.image.eCompressionFormat)
3869 {
3870 pPort->hTunnelComponent = 0;
3871 pPort->nTunnelPort = 0;
3872 return OMX_ErrorPortsNotCompatible;
3873 }
3874 break;
3875 default:
3876 pPort->hTunnelComponent = 0;
3877 pPort->nTunnelPort = 0;
3878 return OMX_ErrorPortsNotCompatible;
3879 }
3880
3881 OMX_CONF_CMD_BAIL:
3882 return eError;
3883 }
3884
3885 /*-------------------------------------------------------------------*/
3886 /**
3887 * IsTIOMXComponent()
3888 * Check if the component is TI component.
3889 * @param hTunneledComp Component Tunnel Pipe
3890 * @retval OMX_TRUE Input is a TI component.
3891 * OMX_FALSE Input is a not a TI component.
3892 *
3893 **/
3894 /*-------------------------------------------------------------------*/
3895
IsTIOMXComponent(OMX_HANDLETYPE hComp,struct OMX_TI_Debug * dbg)3896 static OMX_BOOL IsTIOMXComponent(OMX_HANDLETYPE hComp, struct OMX_TI_Debug *dbg)
3897 {
3898
3899 OMX_ERRORTYPE eError = OMX_ErrorNone;
3900 OMX_STRING pTunnelcComponentName = NULL;
3901 OMX_VERSIONTYPE* pTunnelComponentVersion = NULL;
3902 OMX_VERSIONTYPE* pSpecVersion = NULL;
3903 OMX_UUIDTYPE* pComponentUUID = NULL;
3904 char *pSubstring = NULL;
3905 OMX_BOOL bResult = OMX_TRUE;
3906
3907 pTunnelcComponentName = malloc(128);
3908
3909 if (pTunnelcComponentName == NULL)
3910 {
3911 eError = OMX_ErrorInsufficientResources;
3912 OMX_TRACE4(*dbg, "Error in video encoder OMX_ErrorInsufficientResources %d\n",__LINE__);
3913 goto EXIT;
3914 }
3915
3916 pTunnelComponentVersion = malloc(sizeof(OMX_VERSIONTYPE));
3917 if (pTunnelComponentVersion == NULL)
3918 {
3919 OMX_TRACE4(*dbg, "Error in video encoder OMX_ErrorInsufficientResources %d\n",__LINE__);
3920 eError = OMX_ErrorInsufficientResources;
3921 goto EXIT;
3922 }
3923
3924 pSpecVersion = malloc(sizeof(OMX_VERSIONTYPE));
3925 if (pSpecVersion == NULL)
3926 {
3927 OMX_TRACE4(*dbg, "Error in video encoder OMX_ErrorInsufficientResources %d\n",__LINE__);
3928 eError = OMX_ErrorInsufficientResources;
3929 goto EXIT;
3930 }
3931
3932 pComponentUUID = malloc(sizeof(OMX_UUIDTYPE));
3933 if (pComponentUUID == NULL)
3934 {
3935 OMX_TRACE4(*dbg, "Error in video encoder OMX_ErrorInsufficientResources %d\n",__LINE__);
3936 eError = OMX_ErrorInsufficientResources;
3937 goto EXIT;
3938 }
3939
3940 eError = OMX_GetComponentVersion (hComp, pTunnelcComponentName, pTunnelComponentVersion, pSpecVersion, pComponentUUID);
3941
3942 /* Check if tunneled component is a TI component */
3943 pSubstring = strstr(pTunnelcComponentName, "OMX.TI.");
3944 if (pSubstring == NULL)
3945 {
3946 bResult = OMX_FALSE;
3947 }
3948
3949 EXIT:
3950 free(pTunnelcComponentName);
3951 free(pTunnelComponentVersion);
3952 free(pSpecVersion);
3953 free(pComponentUUID);
3954
3955 return bResult;
3956 } /* End of IsTIOMXComponent */
3957
3958
3959
3960
3961 /*----------------------------------------------------------------------------*/
3962 /**
3963 * ComponentTunnelRequest() Sets application callbacks to the component
3964 *
3965 * This method will update application callbacks
3966 * the application.
3967 *
3968 * @param pComp handle for this instance of the component
3969 * @param pCallBacks application callbacks
3970 * @param ptr
3971 *
3972 * @retval OMX_NoError Success, ready to roll
3973 * OMX_Error_BadParameter The input parameter pointer is null
3974 **/
3975 /*----------------------------------------------------------------------------*/
3976
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)3977 OMX_ERRORTYPE ComponentTunnelRequest(OMX_IN OMX_HANDLETYPE hComponent,
3978 OMX_IN OMX_U32 nPort,
3979 OMX_IN OMX_HANDLETYPE hTunneledComp,
3980 OMX_IN OMX_U32 nTunneledPort,
3981 OMX_INOUT OMX_TUNNELSETUPTYPE* pTunnelSetup)
3982 {
3983 OMX_ERRORTYPE eError = OMX_ErrorNone;
3984 OMX_COMPONENTTYPE* pHandle = (OMX_COMPONENTTYPE*)hComponent;
3985 VIDENC_COMPONENT_PRIVATE* pComponentPrivate = (VIDENC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate;
3986 OMX_PARAM_BUFFERSUPPLIERTYPE sBufferSupplier;
3987 VIDEOENC_PORT_TYPE* pPort = pComponentPrivate->pCompPort[nPort];
3988 if (pTunnelSetup == NULL || hTunneledComp == 0)
3989 {
3990 /* cancel previous tunnel */
3991 pPort->hTunnelComponent = 0;
3992 pPort->nTunnelPort = 0;
3993 pPort->eSupplierSetting = OMX_BufferSupplyUnspecified;
3994 }
3995 else
3996 {
3997 pHandle = (OMX_COMPONENTTYPE*)hComponent;
3998 if (!pHandle->pComponentPrivate)
3999 {
4000 OMX_CONF_SET_ERROR_BAIL(eError, OMX_ErrorBadParameter);
4001 }
4002 pComponentPrivate = (VIDENC_COMPONENT_PRIVATE*)pHandle->pComponentPrivate;
4003 pPort = pComponentPrivate->pCompPort[nPort];
4004
4005 if (pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->pPortDef->eDir != OMX_DirInput &&
4006 pComponentPrivate->pCompPort[VIDENC_INPUT_PORT]->pPortDef->eDir != OMX_DirOutput)
4007 {
4008 return OMX_ErrorBadParameter;
4009 }
4010
4011 /* Check if the other component is developed by TI */
4012 if (IsTIOMXComponent(hTunneledComp, &pComponentPrivate->dbg) != OMX_TRUE)
4013 {
4014 eError = OMX_ErrorTunnelingUnsupported;
4015 goto OMX_CONF_CMD_BAIL;
4016 }
4017 pPort->hTunnelComponent = hTunneledComp;
4018 pPort->nTunnelPort = nTunneledPort;
4019
4020 if (pPort->pPortDef->eDir == OMX_DirOutput)
4021 {
4022 /* Component is the output (source of data) */
4023 pTunnelSetup->eSupplier = pPort->eSupplierSetting;
4024 }
4025 else
4026 {
4027 /* Component is the input (sink of data) */
4028 eError = VerifyTunnelConnection(pPort,
4029 hTunneledComp,
4030 pPort->pPortDef,
4031 &pComponentPrivate->dbg);
4032 if(OMX_ErrorNone != eError)
4033 {
4034 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorPortsNotCompatible,
4035 pComponentPrivate->dbg, OMX_PRCOMM3,
4036 "VerifyTunnelConnection failed.\n");
4037 }
4038
4039 /* If specified obey output port's preferences. Otherwise choose output */
4040 pPort->eSupplierSetting = pTunnelSetup->eSupplier;
4041 if (OMX_BufferSupplyUnspecified == pPort->eSupplierSetting)
4042 {
4043 pPort->eSupplierSetting = pTunnelSetup->eSupplier = OMX_BufferSupplyOutput;
4044 }
4045
4046 /* Tell the output port who the supplier is */
4047 sBufferSupplier.nSize = sizeof(sBufferSupplier);
4048 sBufferSupplier.nVersion.s.nVersionMajor = 0x1;
4049 sBufferSupplier.nVersion.s.nVersionMinor = 0x0;
4050 sBufferSupplier.nPortIndex = nTunneledPort;
4051 sBufferSupplier.eBufferSupplier = pPort->eSupplierSetting;
4052
4053 eError = OMX_SetParameter(hTunneledComp,
4054 OMX_IndexParamCompBufferSupplier,
4055 &sBufferSupplier);
4056 eError = OMX_GetParameter(hTunneledComp,
4057 OMX_IndexParamCompBufferSupplier,
4058 &sBufferSupplier);
4059
4060 if (sBufferSupplier.eBufferSupplier != pPort->eSupplierSetting)
4061 {
4062 OMX_DBG_SET_ERROR_BAIL(eError, OMX_ErrorPortsNotCompatible,
4063 pComponentPrivate->dbg, OMX_PRCOMM3,
4064 "SetParameter: OMX_IndexParamCompBufferSupplier failed to change setting.\n");
4065 }
4066 }
4067 }
4068 OMX_CONF_CMD_BAIL:
4069 return eError;
4070 }
4071
4072 #ifdef __KHRONOS_CONF_1_1__
4073
4074 /*----------------------------------------------------------------------------*/
4075 /**
4076 * ComponentRoleEnum()
4077 *
4078 *
4079 * @param pComp handle for this instance of the component
4080 *
4081 * @retval OMX_NoError Success, ready to roll
4082 * OMX_Error_BadParameter The input parameter pointer is null
4083 **/
4084 /*----------------------------------------------------------------------------*/
ComponentRoleEnum(OMX_IN OMX_HANDLETYPE hComponent,OMX_OUT OMX_U8 * cRole,OMX_IN OMX_U32 nIndex)4085 static OMX_ERRORTYPE ComponentRoleEnum(OMX_IN OMX_HANDLETYPE hComponent,
4086 OMX_OUT OMX_U8 *cRole,
4087 OMX_IN OMX_U32 nIndex)
4088 {
4089 VIDENC_COMPONENT_PRIVATE *pComponentPrivate;
4090 OMX_ERRORTYPE eError = OMX_ErrorNone;
4091
4092 if (hComponent==NULL)
4093 {
4094 goto OMX_CONF_CMD_BAIL;
4095 eError= OMX_ErrorBadParameter;
4096 }
4097
4098 pComponentPrivate = (VIDENC_COMPONENT_PRIVATE*)(((OMX_COMPONENTTYPE*)hComponent)->pComponentPrivate);
4099
4100 if(nIndex == 0)
4101 {
4102 strncpy((char*)cRole, (char *)pComponentPrivate->componentRole.cRole, sizeof(OMX_U8) * OMX_MAX_STRINGNAME_SIZE - 1);
4103 }
4104 else
4105 {
4106 eError = OMX_ErrorNoMore;
4107 }
4108
4109 OMX_CONF_CMD_BAIL:
4110 return eError;
4111 };
4112 #endif
4113