1
2 /*
3 * Copyright 2001-2008 Texas Instruments - http://www.ti.com/
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17 #ifdef UNDER_CE
18 #include <windows.h>
19 #include <oaf_osal.h>
20 #else
21 #include <unistd.h>
22 #include <sys/ioctl.h>
23 #include <sys/select.h>
24 #include <fcntl.h>
25 #include <errno.h>
26 #include <linux/vt.h>
27 #include <signal.h>
28 #include <sys/stat.h>
29 #include <sys/time.h>
30 #include <time.h>
31 #endif
32
33 #include <stdlib.h>
34 #include <string.h>
35 #include <stdio.h>
36 #include <pthread.h>
37 #include <OMX_Index.h>
38 #include <OMX_Types.h>
39 #include <OMX_Core.h>
40 #include <OMX_Audio.h>
41 #include <OMX_VPP.h>
42 #include <OMX_IVCommon.h>
43 #include <OMX_Component.h>
44 #include "VPPTest.h"
45 #include <signal.h>
46
47 /* DSP recovery includes */
48 #include <qosregistry.h>
49 #include <qosti.h>
50 #include <dbapi.h>
51 #include <DSPManager.h>
52 #include <DSPProcessor.h>
53 #include <DSPProcessor_OEM.h>
54
55 #define KHRONOS_1_2
56
57
58 #ifdef UNDER_CE
59 #define sleep Sleep
60 #define APP_DPRINT printf
61 #else
62 /*#define APP_DEBUG*/
63
64 #ifdef APP_DEBUG
65 #define APP_DPRINT(...) fprintf(stderr,__VA_ARGS__)
66 #else
67 #define APP_DPRINT(...)
68 #endif
69 #endif //#ifdef UNDER_CE
70
71 #ifdef UNDER_CE
72 int fill_data (OMX_BUFFERHEADERTYPE *pBuf, HANDLE fIn);
73 #else
74 int fill_data (OMX_BUFFERHEADERTYPE *pBuf, FILE *fIn);
75 #endif
76
77 #define DEFAULT_WIDTH (176)
78 #define DEFAULT_HEIGHT (144)
79
80
81 typedef struct _OMX_VPPCustomTYPE
82 {
83 OMX_INDEXTYPE VPPCustomSetZoomFactor;
84 OMX_INDEXTYPE VPPCustomSetZoomLimit;
85 OMX_INDEXTYPE VPPCustomSetZoomSpeed;
86 OMX_INDEXTYPE VPPCustomSetZoomXoffsetFromCenter16;
87 OMX_INDEXTYPE VPPCustomSetZoomYoffsetFromCenter16;
88 OMX_INDEXTYPE VPPCustomSetFrostedGlassOvly;
89 OMX_INDEXTYPE VPPCustomSetColorRange;
90 OMX_INDEXTYPE VPP_CustomRGB4ColorFormat;
91 } OMX_VPPCustomTYPE;
92
93 typedef struct EVENT_PRIVATE {
94 OMX_EVENTTYPE eEvent;
95 OMX_U32 nData1;
96 OMX_U32 nData2;
97 OMX_PTR pAppData;
98 OMX_PTR eInfo;
99 } EVENT_PRIVATE;
100 static OMX_ERRORTYPE VPP_SetZoom(OMX_HANDLETYPE pHandle, int speed, int factor, int limit, int xoff, int yoff);
101 static OMX_ERRORTYPE VPP_SetContrast(OMX_HANDLETYPE pHandle, int Contrast);
102 static OMX_ERRORTYPE VPP_FrostedGlassEffect(OMX_HANDLETYPE pHandle, int IsOverlay);
103 static OMX_ERRORTYPE VPP_SetCrop(OMX_HANDLETYPE pHandle, int XStart, int XSize, int YStart, int YSize);
104 static OMX_ERRORTYPE VPP_SetMirroring(OMX_HANDLETYPE pHandle, int IsRGBOutput);
105 static OMX_ERRORTYPE VPP_SetRotationAngle(OMX_HANDLETYPE pHandle, int IsRGBOutput,int Angle);
106 static OMX_ERRORTYPE VPP_SetDithering(OMX_HANDLETYPE pHandle, int IsRGBOutput);
107 static OMX_ERRORTYPE VPP_SetColorRange(OMX_HANDLETYPE pHandle, int nColorRange);
108 OMX_BOOL VPP_Test_Check_Frames(int YUVRGB, int inFrames, int OvlyFrames,int outRGBFrames,int outYUVFrames);
109
110 #ifdef DSP_MMU_FAULT_HANDLING
111 int LoadBaseImage();
112 #endif
113
114 #ifdef UNDER_CE
115 OMX_STRING strAmrDecoder = "OMX.TI.IMAGE.VGPOP";
116 #else
117 OMX_STRING strAmrDecoder = "OMX.TI.VPP";
118 #endif
119
120 int IpBuf_Pipe[2];
121 int OvlyBuf_Pipe[2];
122 int OpRGBBuf_Pipe[2];
123 int OpYUVBuf_Pipe[2];
124 int Event_Pipe[2];
125 int nRGBFillBufferDones=0;
126 int nYUVFillBufferDones=0;
127 int nInputEmptyBufferDones=0;
128 int nOvlyEmptyBufferDones=0;
129
130 /* Error flag */
131 OMX_BOOL bError = OMX_FALSE;
132
133 #ifndef UNDER_CE
134 struct timeval base;
135 struct timeval newer;
136 /*struct timezone tz;*/
137 #endif //#ifndef UNDER_CE
138
139
140 static COMPONENT_PORTINDEX_DEF MyVppPortDef;
141 static OMX_VPPCustomTYPE MyVPPCustomDef;
142
143 static long int nTotalTime = 0;
144
145
146 /* safe routine to get the maximum of 2 integers */
maxint(int a,int b)147 int maxint(int a, int b)
148 {
149 return (a>b) ? a : b;
150 }
151
152 /* This method will wait for the component to get to the state
153 * specified by the DesiredState input. */
WaitForState(OMX_HANDLETYPE * pHandle,OMX_STATETYPE DesiredState)154 static OMX_ERRORTYPE WaitForState(OMX_HANDLETYPE* pHandle, OMX_STATETYPE DesiredState)
155 {
156 OMX_STATETYPE CurState = OMX_StateInvalid;
157 OMX_ERRORTYPE eError = OMX_ErrorNone;
158 int nCnt = 0;
159 OMX_COMPONENTTYPE *pComponent = (OMX_COMPONENTTYPE *)pHandle;
160
161 eError = pComponent->GetState(pHandle, &CurState);
162 while( (eError == OMX_ErrorNone) &&
163 (CurState != DesiredState) && (CurState != OMX_StateInvalid)) {
164 sched_yield();
165 if ( nCnt++ >= 0xFFFFFFFE ) {
166 fprintf(stderr, "VPPTEST:: Press CTL-C to continue\n");
167 }
168 eError = pComponent->GetState(pHandle, &CurState);
169 }
170
171 if (CurState == OMX_StateInvalid && DesiredState != OMX_StateInvalid){
172 eError = OMX_ErrorInvalidState;
173 }
174 return eError;
175 }
176
EventHandler(OMX_HANDLETYPE hComponent,OMX_PTR pAppData,OMX_EVENTTYPE eEvent,OMX_U32 nData1,OMX_U32 nData2,OMX_STRING eInfo)177 void EventHandler(OMX_HANDLETYPE hComponent,OMX_PTR pAppData, OMX_EVENTTYPE eEvent,
178 OMX_U32 nData1,OMX_U32 nData2, OMX_STRING eInfo)
179 {
180
181 OMX_ERRORTYPE eError = OMX_ErrorNone;
182 EVENT_PRIVATE MyEvent;
183
184 MyEvent.eEvent = eEvent;
185 MyEvent.nData1 = nData1;
186 MyEvent.nData2 = nData2;
187 MyEvent.pAppData = pAppData;
188
189 switch (eEvent) {
190 case OMX_EventCmdComplete:
191 APP_DPRINT ("%d :: App: Component State Changed To %d\n", __LINE__,state);
192
193 break;
194 case OMX_EventError:
195 if(nData1 == OMX_ErrorHardware){
196 printf("%d: App: ErrorNotofication Came: \
197 \nComponent Name : %d : Error Num %lx: String :%s\n",
198 __LINE__,*((int *)(pAppData)), nData1, eInfo);
199 eError = OMX_SendCommand(hComponent, OMX_CommandStateSet, OMX_StateInvalid, NULL);
200 if(eError != OMX_ErrorNone) {
201 printf ("Error from SendCommand-Invalid State function\n");
202 }
203 }
204 else{
205 printf("%d: App: ErrorNotofication Came: \
206 \nComponent Name : %d : Error Num %lx: String :%s\n",
207 __LINE__,*((int *)(pAppData)), nData1, eInfo);
208 }
209
210 break;
211 case OMX_EventMax:
212 break;
213 case OMX_EventMark:
214 break;
215 default:
216 break;
217 }
218
219 write(Event_Pipe[1], &MyEvent, sizeof(EVENT_PRIVATE));
220
221 }
222
223 #ifndef UNDER_CE
GetProfiletime()224 long GetProfiletime()
225 {
226 long int nFrameTime = 0;
227 /*struct timeval older;*/
228 int nStatus ;
229 base.tv_sec = newer.tv_sec;
230 base.tv_usec = newer.tv_usec;
231 nStatus = gettimeofday(&newer, NULL);
232 /*printf("base.tv_sec = %ld, base.tv_usec %ld\n", base.tv_sec, base.tv_usec);*/
233 nFrameTime = (newer.tv_sec-base.tv_sec) * 1000000 + (newer.tv_usec-base.tv_usec);
234 nTotalTime = nTotalTime + nFrameTime;
235 return nFrameTime;
236
237 }
238 #endif /*#ifndef UNDER_CE*/
239
FillBufferDone(OMX_HANDLETYPE hComponent,OMX_PTR ptr,OMX_BUFFERHEADERTYPE * pBuffer)240 void FillBufferDone (OMX_HANDLETYPE hComponent, OMX_PTR ptr, OMX_BUFFERHEADERTYPE* pBuffer)
241 {
242
243 /*PROFILE POINT*/
244
245 #ifndef UNDER_CE
246 long int pftime = 0;
247 pftime = GetProfiletime();
248 APP_DPRINT("total time for frame %d \n", nTotalTime);
249 APP_DPRINT("total time for each frame %d \n",pftime);
250 #endif
251
252 if(pBuffer->nOutputPortIndex==MyVppPortDef.rgboutput_port){
253 write(OpRGBBuf_Pipe[1], &pBuffer, sizeof(pBuffer));
254 nRGBFillBufferDones++;
255 }
256 else if(pBuffer->nOutputPortIndex==MyVppPortDef.yuvoutput_port){
257 write(OpYUVBuf_Pipe[1], &pBuffer, sizeof(pBuffer));
258 nYUVFillBufferDones++;
259 }
260 else{
261 printf("VPPTEST:: Incorrect Output Port Index\n");
262 }
263
264
265 }
266
267
EmptyBufferDone(OMX_HANDLETYPE hComponent,OMX_PTR ptr,OMX_BUFFERHEADERTYPE * pBuffer)268 void EmptyBufferDone(OMX_HANDLETYPE hComponent, OMX_PTR ptr, OMX_BUFFERHEADERTYPE* pBuffer)
269 {
270 if(pBuffer->nInputPortIndex == MyVppPortDef.input_port){
271 write(IpBuf_Pipe[1], &pBuffer, sizeof(pBuffer));
272 nInputEmptyBufferDones++;
273 }
274 else if(pBuffer->nInputPortIndex == MyVppPortDef.overlay_port){
275 write(OvlyBuf_Pipe[1], &pBuffer,sizeof(pBuffer));
276 nOvlyEmptyBufferDones++;
277 }
278 else{
279 printf("VPPTEST:: Incorrect Input Port Index\n");
280 }
281 }
282
283
GetComponentPortDef(OMX_HANDLETYPE pHandleVPP,COMPONENT_PORTINDEX_DEF * pVppPortDef)284 static OMX_ERRORTYPE GetComponentPortDef(OMX_HANDLETYPE pHandleVPP, COMPONENT_PORTINDEX_DEF *pVppPortDef)
285 {
286 OMX_PORT_PARAM_TYPE *pTempPortType = NULL;
287 OMX_ERRORTYPE eError = OMX_ErrorNone;
288 OMX_PARAM_PORTDEFINITIONTYPE *pTempVidPortDef = NULL;
289 int i;
290 OMX_BOOL found_input = OMX_FALSE;
291
292 pTempPortType = calloc(1, sizeof(OMX_PORT_PARAM_TYPE));
293 if (!pTempPortType){
294 eError = OMX_ErrorInsufficientResources;
295 goto EXIT;
296 }
297
298 eError = OMX_GetParameter(pHandleVPP, OMX_IndexParamVideoInit, pTempPortType);
299 if (eError != OMX_ErrorNone) {
300 printf("VPPTEST:: Error at %d\n",__LINE__);
301 eError = OMX_ErrorBadParameter;
302 goto EXIT;
303 }
304
305 APP_DPRINT("VPP_JPEG_DISPLAY:: ports of VPP %lu, start port %lu\n", pTempPortType->nPorts, pTempPortType->nStartPortNumber);
306
307 pTempVidPortDef = calloc (1,sizeof (OMX_PARAM_PORTDEFINITIONTYPE));
308 if (!pTempVidPortDef){
309 eError = OMX_ErrorInsufficientResources;
310 goto EXIT;
311 }
312
313 found_input = OMX_FALSE;
314 for (i = pTempPortType->nStartPortNumber; i < pTempPortType->nPorts; i ++){
315 pTempVidPortDef->nPortIndex = i;
316 eError = OMX_GetParameter (pHandleVPP, OMX_IndexParamPortDefinition, pTempVidPortDef);
317 if ( eError != OMX_ErrorNone ){
318 printf("VPPTEST:: Error at %d\n",__LINE__);
319 eError = OMX_ErrorBadParameter;
320 goto EXIT;
321 }
322
323 if ((pTempVidPortDef->eDir == OMX_DirInput) &&(found_input == OMX_FALSE)){
324 /* found input */
325 pVppPortDef->input_port= i;
326 found_input = OMX_TRUE;
327 continue;
328 }
329 if ((pTempVidPortDef->eDir == OMX_DirInput) && (found_input == OMX_TRUE)){
330 /* found ovelay port */
331 pVppPortDef->overlay_port = i;
332 continue;
333 }
334 if ((pTempVidPortDef->eDir == OMX_DirOutput) &&
335 (pTempVidPortDef->format.video.eColorFormat == OMX_COLOR_Format16bitRGB565)){
336 /* found RGB output */
337 pVppPortDef->rgboutput_port = i;
338 continue;
339 }
340 if ((pTempVidPortDef->eDir == OMX_DirOutput) &&
341 ((pTempVidPortDef->format.video.eColorFormat == OMX_COLOR_FormatYCbYCr)||
342 (pTempVidPortDef->format.video.eColorFormat == OMX_COLOR_FormatCbYCrY))){
343 /* found YUV output */
344 pVppPortDef->yuvoutput_port = i;
345 continue;
346 }
347 }
348
349 APP_DPRINT("VPPTEST:: input port is %d\n", pVppPortDef->input_port);
350 APP_DPRINT("VPPTEST:: overlay port is %d\n", pVppPortDef->overlay_port);
351 APP_DPRINT("VPPTEST:: RGB output port is %d\n", pVppPortDef->rgboutput_port);
352 APP_DPRINT("VPPTEST:: YUV output port is %d\n", pVppPortDef->yuvoutput_port);
353
354 EXIT:
355 if (pTempPortType){
356 free(pTempPortType);
357 pTempPortType = NULL;
358 }
359
360 if (pTempVidPortDef){
361 free(pTempVidPortDef);
362 pTempVidPortDef = NULL;
363 }
364 return eError;
365 }
366
367
368
GetVPPCustomDef(OMX_HANDLETYPE pHandleVPP)369 static OMX_ERRORTYPE GetVPPCustomDef(OMX_HANDLETYPE pHandleVPP)
370 {
371 OMX_ERRORTYPE eError = OMX_ErrorNone;
372
373 eError = OMX_GetExtensionIndex(pHandleVPP, "OMX.TI.VPP.Param.ZoomFactor", &(MyVPPCustomDef.VPPCustomSetZoomFactor));
374 if(eError != OMX_ErrorNone) {
375 fprintf (stderr,"VPPTEST:: Error in OMX_GetExtensionIndex function\n");
376 goto EXIT;
377 }
378 APP_DPRINT("OMX.TI.VPP.Param.ZoomFactor is %x\n", MyVPPCustomDef.VPPCustomSetZoomFactor);
379
380 eError = OMX_GetExtensionIndex(pHandleVPP, "OMX.TI.VPP.Param.ZoomLimit", &(MyVPPCustomDef.VPPCustomSetZoomLimit));
381 if(eError != OMX_ErrorNone) {
382 fprintf (stderr,"VPPTEST:: Error in OMX_GetExtensionIndex function\n");
383 goto EXIT;
384 }
385 APP_DPRINT("OMX.TI.VPP.Param.ZoomLimit is %x\n", MyVPPCustomDef.VPPCustomSetZoomLimit);
386
387 eError = OMX_GetExtensionIndex(pHandleVPP, "OMX.TI.VPP.Param.ZoomSpeed", &(MyVPPCustomDef.VPPCustomSetZoomSpeed));
388 if(eError != OMX_ErrorNone) {
389 fprintf (stderr,"Error in OMX_GetExtensionIndex function\n");
390 goto EXIT;
391 }
392 APP_DPRINT("OMX.TI.VPP.Param.ZoomSpeed is %x\n", MyVPPCustomDef.VPPCustomSetZoomSpeed);
393
394 eError = OMX_GetExtensionIndex(pHandleVPP, "OMX.TI.VPP.Param.ZoomXoffsetFromCenter16", &(MyVPPCustomDef.VPPCustomSetZoomXoffsetFromCenter16));
395 if(eError != OMX_ErrorNone) {
396 fprintf (stderr,"VPPTEST:: Error in OMX_GetExtensionIndex function\n");
397 goto EXIT;
398 }
399 APP_DPRINT("OMX.TI.VPP.Param.ZoomXoffsetFromCenter16 is %x\n", MyVPPCustomDef.VPPCustomSetZoomXoffsetFromCenter16);
400
401 eError = OMX_GetExtensionIndex(pHandleVPP, "OMX.TI.VPP.Param.ZoomYoffsetFromCenter16", &(MyVPPCustomDef.VPPCustomSetZoomYoffsetFromCenter16));
402 if(eError != OMX_ErrorNone) {
403 fprintf (stderr,"Error in OMX_GetExtensionIndex function\n");
404 goto EXIT;
405 }
406 APP_DPRINT("OMX.TI.VPP.Param.ZoomYoffsetFromCenter16 is %x\n", MyVPPCustomDef.VPPCustomSetZoomYoffsetFromCenter16);
407
408 eError = OMX_GetExtensionIndex(pHandleVPP, "OMX.TI.VPP.Param.FrostedGlassOvly", &(MyVPPCustomDef.VPPCustomSetFrostedGlassOvly));
409 if(eError != OMX_ErrorNone) {
410 fprintf (stderr,"VPPTEST:: Error in OMX_GetExtensionIndex function\n");
411 goto EXIT;
412 }
413 APP_DPRINT("OMX.TI.VPP.Param.FrostedGlassOvly is %x\n", (MyVPPCustomDef.VPPCustomSetFrostedGlassOvly));
414
415
416 eError = OMX_GetExtensionIndex(pHandleVPP, "OMX.TI.VPP.Param.VideoColorRange", &(MyVPPCustomDef.VPPCustomSetColorRange));
417 if(eError != OMX_ErrorNone) {
418 fprintf (stderr,"VPPTEST:: Error in OMX_GetExtensionIndex function\n");
419 goto EXIT;
420 }
421 APP_DPRINT("OMX.TI.VPP.Param.FrostedGlassOvly is %x\n", (MyVPPCustomDef.VPPCustomSetColorRange));
422
423 eError = OMX_GetExtensionIndex(pHandleVPP, "OMX.TI.VPP.Param.RGB4ColorFormat", &(MyVPPCustomDef.VPP_CustomRGB4ColorFormat));
424 if(eError != OMX_ErrorNone) {
425 fprintf (stderr,"VPPTEST:: Error in OMX_GetExtensionIndex function\n");
426 goto EXIT;
427 }
428 APP_DPRINT("OMX.TI.VPP.Param.ZoomFactor is %x\n", MyVPPCustomDef.VPP_CustomRGB4ColorFormat);
429
430 EXIT:
431 return eError;
432
433 }
434
435
436
437 #ifdef UNDER_CE
_tmain(int argc,TCHAR ** argv)438 int _tmain(int argc, TCHAR **argv)
439 #else
440 int main(int argc, char* argv[])
441 #endif
442 {
443 OMX_ERRORTYPE error = OMX_ErrorNone;
444 OMX_CALLBACKTYPE AmrCaBa = {(void *)EventHandler,
445 (void*) EmptyBufferDone,
446 (void*)FillBufferDone};
447 OMX_HANDLETYPE pHandle;
448 OMX_U32 AppData = 100;
449 OMX_PARAM_PORTDEFINITIONTYPE* pCompPrivateStruct = NULL;
450 OMX_BUFFERHEADERTYPE* InputBufHeader[MAX_VPP_BUFFERS];
451 OMX_BUFFERHEADERTYPE* OvlyBufHeader[MAX_VPP_BUFFERS];
452 OMX_BUFFERHEADERTYPE* OutRGBBufHeader[MAX_VPP_BUFFERS];
453 OMX_BUFFERHEADERTYPE* OutYUVBufHeader[MAX_VPP_BUFFERS];
454
455 OMX_COMPONENTTYPE *pComponent;
456 OMX_STATETYPE state;
457 int retval;
458 #ifdef UNDER_CE
459 TCHAR* szInFile = NULL;
460 TCHAR* szOutFile = NULL;
461 HANDLE fIn = NULL;
462 HANDLE fOut = NULL;
463 HANDLE fYuvOut = NULL;
464 HANDLE fInOvelay = NULL;
465 TCHAR stringRGB[30];
466 TCHAR stringYUV[30];
467 TCHAR overlaystring[30];
468 DWORD dwWritten;
469 #else
470 char* szInFile = NULL;
471 char* szOutFile = NULL;
472 FILE* fIn = NULL;
473 FILE* fOut = NULL;
474 FILE* fYuvOut = NULL;
475 FILE* fInOvelay = NULL;
476 char stringRGB[30];
477 char stringYUV[30];
478 char overlaystring[30];
479 #endif
480 OMX_U16 inputwidth=0;
481 OMX_U16 inputheight=0;
482 OMX_U16 outputwidth=0;
483 OMX_U16 outputheight=0;
484 OMX_U16 inputcolor;
485 OMX_U16 rgboutputcolor;
486 OMX_U16 yuvoutputcolor;
487 int Isoverlay;
488 int IsYUVRGB;
489 int bitrate=0;
490 int iCurrentFrameIn = 0;
491 int iCurrentOvlyFrameIn=0;
492 int iCurrentRGBFrameOut = 0;
493 int iCurrentYUVFrameOut = 0;
494 int DEINIT_FLAG = 0;
495 int nTypeofAllocation;
496 int feature_param[4]={0,0,0,0}; /*Initialize array*/
497 int feature; /*Feature selected, only scaling, zoom, contrast, frosted glass effect, cropping, mirror and rotation*/
498 OMX_COLOR_FORMATTYPE nColor; /*Used to pass Color Format for input and output ports*/
499 fd_set rfds;
500 int fdmax;
501 OMX_U8 *pInBuffer = NULL;
502 OMX_U8 *pYUVBuffer = NULL;
503 OMX_U8 *pRGBBuffer = NULL;
504 int nRead = 0;
505 int done = 0;
506 int frmCount = 0;
507 int nCounter =0;
508 int count_stop_restart=0; /* Executing-->Idle-->Executing*/
509 int count_stop_load=0; /* Loaded-->Idle-->Executing-->Idle-->Loaded */
510 int max_count_stop_restart=0;
511 int max_count_stop_load=0;
512 OMX_BUFFERHEADERTYPE* pBuffer = NULL; /*To Hold Input Buffers*/
513 OMX_BUFFERHEADERTYPE* pBuf = NULL; /*To Hold Output Buffers*/
514 OMX_PARAM_PORTDEFINITIONTYPE *portinput;
515 int nFillThisBufferYUV=0;
516 int nFillThisBufferRGB=0;
517 int nTimeouts =0;
518 int bPauseResume=OMX_FALSE;
519 int bStopRestart=OMX_FALSE;
520 int bStopNotFree=OMX_FALSE;
521 int bStopExit=OMX_FALSE;
522 int MAX_VPP_BUFFERS_IN_USE = MAX_VPP_BUFFERS;
523 sigset_t set;
524
525 /* validate command line args */
526 if(argc < 13) {
527 #ifdef UNDER_CE
528 printf("usage: %S <input.yuv><file_desc><Inp. Width><Inp. Height><Inp. color><0:no overlay/1:overlay><Out. Width><Out Height><yuv color><rgb color><0 :Internal 1 :external allocation><Feature [0-8]>\n",
529 argv[0]);
530 printf("./VPPTest_common patterns/qciftest.yuv qcif_qqcif 176 144 1 0 88 72 1 2 0 0\n");
531 #else
532 printf("usage: %s <input.yuv><file_desc><Inp. Width><Inp. Height><Inp. color><0:no overlay/1:overlay><Out. Width><Out Height><yuv color><rgb color><0 :Internal 1 :external allocation><Feature [0-8]>\n",
533 argv[0]);
534 printf("./VPPTest_common patterns/qciftest.yuv qcif_qqcif 176 144 1 0 88 72 1 2 0 0\n");
535 #endif
536 return -1;
537 }
538
539 szInFile = argv[1];
540 szOutFile = argv[2];
541 #ifdef UNDER_CE
542 inputwidth=_wtoi(argv[3]);
543 inputheight=_wtoi(argv[4]);
544 inputcolor=_wtoi(argv[5]);
545 Isoverlay = _wtoi(argv[6]);
546 outputwidth=_wtoi(argv[7]);
547 outputheight=_wtoi(argv[8]);
548 yuvoutputcolor= _wtoi(argv[9]);
549 rgboutputcolor = _wtoi(argv[10]);
550 nTypeofAllocation = _wtoi(argv[11]);
551 feature= (_wtoi(argv[12])& (0x00FF); /*Use only lower byte*/
552 bPauseResume = (_wtoi(argv[12]) & (0x0100); /*Bit 8 is PauseResumeFlag*/
553 bStopRestart = (_wtoi(argv[12]) & (0x0200); /*Bit 9 is StopRestart Flag*/
554 bStopNotFree = (_wtoi(argv[12]) & (0x0400); /*Bit 10 is Stop without freeing component Flag*/
555 bStopExit = (_wtoi(argv[12]) & (0x0800); /*Bit 11 is Stop without finishing the procesed image*/
556
557 #else
558 inputwidth=atoi(argv[3]);
559 inputheight=atoi(argv[4]);
560 inputcolor=atoi(argv[5]);
561 Isoverlay =atoi(argv[6]);
562 outputwidth=atoi(argv[7]);
563 outputheight=atoi(argv[8]);
564 yuvoutputcolor= atoi(argv[9]);
565 rgboutputcolor = atoi(argv[10]);
566 nTypeofAllocation = atoi(argv[11]);
567 feature=atoi(argv[12]) & (0x00FF); /*Use only lower byte*/
568 bPauseResume = atoi(argv[12]) & (0x0100); /*Bit 8 is PauseResumeFlag*/
569 bStopRestart = atoi(argv[12]) & (0x0200); /*Bit 9 is StopRestart Flag*/
570 bStopNotFree = atoi(argv[12]) & (0x0400); /*Bit 10 is Stop without freeing component Flag*/
571 bStopExit = atoi(argv[12]) & (0x0800); /*Bit 11 is Stop without finishing the procesed image*/
572 #endif
573
574 /* 1600 x 1200 is only a rough guess */
575 if ((inputwidth * inputheight) >= (1600 * 1200))
576 {
577 MAX_VPP_BUFFERS_IN_USE = 1;
578 }
579
580 if(yuvoutputcolor == 0 && rgboutputcolor ==0)
581 {
582 printf("VPPTEST:: At least one output is required\n");
583 printf("VPPTEST:: Selecting YUV420 as default.\n");
584 yuvoutputcolor=1;
585 }
586 if(yuvoutputcolor && rgboutputcolor) /*Simultaneous output*/
587 {
588 IsYUVRGB=2;
589 }
590 else if(yuvoutputcolor) /*Only YUV output*/
591 {
592 IsYUVRGB=0;
593 }
594 else
595 {
596 IsYUVRGB=1; /*Only RGB output*/
597 }
598
599 /* Assign Parameters according to feature selected*/
600 switch (feature) /*Assign feature selected feature parameters*/
601 {
602 case 0 : /*Only Scaling Needed */
603 {
604 if(argc>13)
605 {
606 printf("VPPTEST:: Only Scaling Selected, ignoring Extra parameters\n");
607 }
608
609 break;
610 }
611
612 case 1: /*On Demand Zoom */
613 case 2: /*Dynamic Zoom */
614 {
615 if(argc < 15){
616 #ifdef UNDER_CE
617 printf("usage: %S <input.yuv> <output desc> <Inp. width> <Inp. Height> <0:no overlay/1:overlay> <outputwidth> <outputheight> <0:YUV/1:RGB/2:BOTH> <0 :Internal 1 :external allocation>\
618 <Feature 1= On Demand/2=Dynamic> <On Demand Zoom/Dynamic Zoom> <Zoom Factor/Zoom Speed> <Zoom Limit>\n",argv[0]);
619 #else
620 printf("usage: %s <input.yuv> <output desc> <Inp. width> <Inp. Height> <0:no overlay/1:overlay> <outputwidth> <outputheight> <0:YUV/1:RGB/2:BOTH> <0 :Internal 1 :external allocation>\
621 <Feature 1= On Demand/2=Dynamic> <On Demand Zoom/Dynamic Zoom> <Zoom Factor/Zoom Speed> <Zoom Limit>\n",argv[0]);
622 #endif
623 return -1;
624 }
625 else{
626 #ifdef UNDER_CE
627 feature_param[0] = _wtoi(argv[13]); /*Zoom Factor or Zoom Speed*/
628 feature_param[1] = _wtoi(argv[14]); /*Zoom Limit */
629 #else
630 feature_param[0] = atoi(argv[13]); /*Zoom Factor or Zoom Speed*/
631 feature_param[1] = atoi(argv[14]); /*Zoom Limit */
632 #endif
633 }
634 if(argc>15){
635 printf("On Demand Zoom Selected, Ignoring Extra parameters\n");
636 }
637
638 break;
639 }
640 case 3: /*Zoom Offset*/
641 {
642 if(argc<17){
643 #ifdef UNDER_CE
644 printf("usage: %S <input.yuv> <output.rgb> <inputwidth> <inputheight> <0:no overlay/1:overlay> <outputwidth> <outputheight> <0:YUV/1:RGB/2:BOTH> <0 :Internal 1 :external allocation>\
645 <Feature 3=Zoom Offset> <Zoom Factor> <Zoom Limit> <X Offset> <Y Offset>\n",argv[0]);
646 #else
647 printf("usage: %s <input.yuv> <output.rgb> <inputwidth> <inputheight> <0:no overlay/1:overlay> <outputwidth> <outputheight> <0:YUV/1:RGB/2:BOTH> <0 :Internal 1 :external allocation>\
648 <Feature 3=Zoom Offset> <Zoom Factor> <Zoom Limit> <X Offset> <Y Offset>\n",argv[0]);
649 #endif
650 return -1;
651 }
652 else{
653 #ifdef UNDER_CE
654 feature_param[0] = _wtoi(argv[13]); /*Zoom Factor*/
655 feature_param[1] = _wtoi(argv[14]); /*Zoom Limit*/
656 feature_param[2] = _wtoi(argv[15]); /*X Offset*/
657 feature_param[3] = _wtoi(argv[16]); /*Y Offset*/
658 #else
659 feature_param[0] = atoi(argv[13]); /*Zoom Factor*/
660 feature_param[1] = atoi(argv[14]); /*Zoom Limit*/
661 feature_param[2] = atoi(argv[15]); /*X Offset*/
662 feature_param[3] = atoi(argv[16]); /*Y Offset*/
663 #endif
664 }
665 if(argc>17){
666 printf("VPPTEST:: Zoom Offset Selected, Ignoring Extra parameters\n");
667 }
668
669 break;
670 }
671
672 case 4 : /* Contrast */
673 {
674 if(argc<14)
675 {
676 #ifdef UNDER_CE
677 printf("usage: %S <input.yuv> <output.rgb> <width> <height> <0:no overlay/1:overlay> <outputwidth> <outputheight> <0:YUV/1:RGB/2:BOTH> <0 :Internal 1 :external allocation>\
678 <Feature 4=Contrast> <Contrast Value [-100 100]>\n",argv[0]);
679 #else
680 printf("usage: %s <input.yuv> <output.rgb> <width> <height> <0:no overlay/1:overlay> <outputwidth> <outputheight> <0:YUV/1:RGB/2:BOTH> <0 :Internal 1 :external allocation>\
681 <Feature 4=Contrast> <Contrast Value [-100 100]>\n",argv[0]);
682 #endif
683 return -1;
684 }
685 else{
686 #ifdef UNDER_CE
687 feature_param[0] = _wtoi(argv[13]);
688 #else
689 feature_param[0]=atoi(argv[13]);
690 #endif
691 }
692 if(argc>14){
693 printf("VPPTEST:: Contrast Selected, Ignoring extra parameters\n");
694 }
695
696 break;
697 }
698
699 case 5 : /*Frosted Glass effect */
700 {
701 if(Isoverlay ==0){
702 printf("VPPTEST:: Overlay is needed for Frosted Glass effect\n");
703 return -1;
704 }
705
706 break;
707 }
708
709 case 6 : /*Cropping*/
710 {
711 if(argc<17){
712 #ifdef UNDER_CE
713 printf("usage: %S <input.yuv> <output.rgb> <width> <height> <0:no overlay/1:overlay> <outputwidth> <outputheight> <0:YUV/1:RGB/2:BOTH> <0 :Internal 1 :external allocation>\
714 <Feature 6=Cropping> <Left Coord> <Width> <Top coord> <Height>\n",argv[0]);
715 #else
716 printf("usage: %s <input.yuv> <output.rgb> <width> <height> <0:no overlay/1:overlay> <outputwidth> <outputheight> <0:YUV/1:RGB/2:BOTH> <0 :Internal 1 :external allocation>\
717 <Feature 6=Cropping> <Left Coord> <Width> <Top Coord> <Height>\n",argv[0]);
718 #endif
719 return -1;
720 }
721 else{
722 #ifdef UNDER_CE
723 feature_param[0] = _wtoi(argv[13]); /*Left Pixel*/
724 feature_param[1] = _wtoi(argv[14]); /*Width*/
725 feature_param[2] = _wtoi(argv[15]); /*Top Pixel*/
726 feature_param[3] = _wtoi(argv[16]); /*Height*/
727 #else
728 feature_param[0] = atoi(argv[13]); /*Left Pixel*/
729 feature_param[1] = atoi(argv[14]); /*Width*/
730 feature_param[2] = atoi(argv[15]); /*Top Pixel*/
731 feature_param[3] = atoi(argv[16]); /*Height*/
732 #endif
733 }
734 if(argc>17){
735 printf("VPPTEST:: Cropping Selected, Ignoring Extra parameters\n");
736 }
737
738 break;
739 }
740
741 case 7 : /* Mirroring */
742 {
743 if(!IsYUVRGB){
744 printf("VPPTEST:: Mirrored Image is only possible for RGB output\n");
745 return -1;
746 }
747 break;
748 }
749
750 case 8: /*Rotation*/
751 {
752 if(argc<14){
753 printf("usage: %s <input.yuv> <output descriptor> <Inp. width> <Inp. height> <Inp. Color> <0:no overlay/1:overlay> <outputwidth> <outputheight> <YUV output format> <RGB format> <0 :Internal 1 :external allocation>\
754 <Feature 8=Rotation> <Rotation Angle = 0,90,180,270>\n",argv[0]);
755 return -1;
756 }
757 else{
758 #ifdef UNDER_CE
759 feature_param[0]=_wtoi(argv[13]);
760 #else
761 feature_param[0]=atoi(argv[13]);
762 #endif
763 }
764
765 break;
766 }
767 case 9 : /* Dithering */
768 {
769 if(!IsYUVRGB){
770 printf("VPPTEST:: Dithering is only possible for RGB output\n");
771 return -1;
772 }
773 break;
774 }
775 case 10: /*Video Color Range Conversion*/
776 {
777
778 #ifdef UNDER_CE
779 feature_param[0]=_wtoi(argv[13]);
780 #else
781 feature_param[0]=atoi(argv[13]);
782 #endif
783 break;
784
785 }
786
787
788 default :
789 {
790 #ifdef UNDER_CE
791 printf("Not a Valid Option on Selected Feature\n");
792 printf("usage: %S <Num><input.yuv> <output.rgb> <width> <height> <0:no overlay/1:overlay> <outputwidth> <outputheight> <0:YUV/1:RGB/2:BOTH> <0 :Internal 1 :external allocation>\
793 <Feature [0:9]> <...>\n",argv[0]);
794 #else
795 printf("Not a Valid Option on Selected Feature\n");
796 printf("usage: %s <Num><input.yuv> <output.rgb> <width> <height> <0:no overlay/1:overlay> <outputwidth> <outputheight> <0:YUV/1:RGB/2:BOTH> <0 :Internal 1 :external allocation>\
797 <Feature [0:9]> <...>\n",argv[0]);
798 #endif
799 return -1;
800 break;
801 }
802 } /*End switch*/
803
804
805 printf("Test Core 1.8 - " __DATE__ ":" __TIME__ "\n");
806 printf("------------------------------------------------\n");
807 /*Buffer flow can happen here*/
808 if(Isoverlay){
809 #ifdef UNDER_CE
810 wsprintf(overlaystring,L"play_qCIF.raw");
811 printf("Overlay file: %S\n",overlaystring);
812 #else
813
814 sprintf(overlaystring,"/omx/patterns/play_qCIF.raw");
815 printf("Overlay file: %s\n",overlaystring);
816 #endif
817 }
818
819
820 #ifndef UNDER_CE
821 /* check to see that the input file exists */
822 struct stat sb = {0};
823 int status = stat(argv[1], &sb);
824 if( status != 0 ){
825 fprintf(stderr, "Cannot find file %s. (%u)\n", argv[1], errno);
826 goto EXIT;
827 }
828 #endif
829
830 /* Create a pipe used to queue data from the callback. */
831 retval = pipe(IpBuf_Pipe);
832 if(retval != 0){
833 fprintf(stderr, "Error:Fill Data Pipe failed to open\n");
834 goto EXIT;
835 }
836 /* Create a pipe used to queue data from the callback. */
837 retval = pipe(OvlyBuf_Pipe);
838 if(retval != 0){
839 fprintf(stderr, "Error:Fill Data Pipe failed to open\n");
840 goto EXIT;
841 }
842
843 retval = pipe(OpRGBBuf_Pipe);
844 if(retval != 0){
845 fprintf(stderr, "Error:Empty Data Pipe failed to open\n");
846 goto EXIT;
847 }
848 retval = pipe(OpYUVBuf_Pipe);
849 if(retval != 0){
850 fprintf(stderr, "Error:Empty Data Pipe failed to open\n");
851 goto EXIT;
852 }
853 /* Create a pipe used to handle events from the callback. */
854 retval = pipe(Event_Pipe);
855 if(retval != 0){
856 fprintf(stderr, "Error:Fill Data Pipe failed to open\n");
857 goto EXIT;
858 }
859
860 /* save off the "max" of the handles for the selct statement */
861 fdmax = maxint(IpBuf_Pipe[0], OvlyBuf_Pipe[0]);
862 fdmax = maxint(fdmax, OpRGBBuf_Pipe[0]);
863 fdmax = maxint(fdmax, OpYUVBuf_Pipe[0]);
864 fdmax = maxint(fdmax, Event_Pipe[0]);
865
866 #ifdef DSP_MMU_FAULT_HANDLING
867 /* LOAD BASE IMAGE FIRST TIME */
868 LoadBaseImage();
869 #endif
870
871 error = TIOMX_Init();
872 if(error != OMX_ErrorNone) {
873 printf("%d :: Error returned by TIOMX_init()\n",__LINE__);
874 goto EXIT;
875 }
876
877 /********************************************************************************************************/
878 /* Load the VPP Component */
879 error = TIOMX_GetHandle(&pHandle,strAmrDecoder,&AppData, &AmrCaBa);
880 if( (error != OMX_ErrorNone) || (pHandle == NULL) ){
881 fprintf (stderr,"Error in Get Handle function\n");
882 goto EXIT;
883 }
884 if(bStopNotFree){
885 max_count_stop_load=20;
886 }
887 else{
888 max_count_stop_load=1;
889 }
890 /********************************Component is loaded here, we can loop after this point****************************************/
891 for(count_stop_load=0; count_stop_load<max_count_stop_load; count_stop_load++)
892 {
893 error = GetComponentPortDef(pHandle, &MyVppPortDef);
894 if (error != OMX_ErrorNone){
895 fprintf (stderr,"Error in Get Handle function\n");
896 goto EXIT;
897 }
898
899 error = GetVPPCustomDef(pHandle);
900 if(error != OMX_ErrorNone)
901 {
902 fprintf (stderr,"Error in Get Handle function\n");
903 goto EXIT;
904 }
905
906 printf("VPPTEST:: Input Height: %d, Input Width %d\n",inputheight, inputwidth);
907
908 /*Select Input Format and Buffer Size accordingly*/
909 switch(inputcolor)
910 {
911 case 0: /*YUV 420 Planar*/
912 nColor = OMX_COLOR_FormatYUV420PackedPlanar;
913 printf("VPPTEST:: Input YUV420\n");
914 break;
915 case 1: /*YUV 422 Interleaved (little-endian)*/
916 nColor = OMX_COLOR_FormatCbYCrY/*OMX_COLOR_FormatYCbYCr*/;
917 printf("VPPTEST:: Input YUV422 Interleaved (little-endian)\n");
918 break;
919 case 2: /*YUV 422 Interleaved (big-endian)*/
920 nColor = OMX_COLOR_FormatYCbYCr/*OMX_COLOR_FormatYCrYCb*/;
921 printf("VPPTEST:: Input YUV422 Interleaved (big-endian)\n");
922 break;
923 case 3: /*RGB24 8:8:8*/
924 nColor = OMX_COLOR_Format24bitRGB888;
925 printf("VPPTEST:: Input RGB24\n");
926 break;
927 case 4 : /*RGB16 5:6:5*/
928 nColor = OMX_COLOR_Format16bitRGB565;
929 printf("VPPTEST:: Input RGB16\n");
930 break;
931 case 5 : /*RGB12 5:6:5*/
932 nColor = OMX_COLOR_Format12bitRGB444;
933 printf("VPPTEST:: Input RGB12\n");
934 break;
935 case 6 : /*RGB8 3:3:2*/
936 nColor = OMX_COLOR_Format8bitRGB332;
937 printf("VPPTEST:: Input RGB8\n");
938 break;
939 case 7 : /*RGB4 Look-Up-Table*/
940 nColor = MyVPPCustomDef.VPP_CustomRGB4ColorFormat;
941 printf("VPPTEST:: Input RGB4\n");
942 break;
943 case 8 : /*GRAY8 */
944 nColor = OMX_COLOR_FormatL8;
945 printf("VPPTEST:: Input GRAY8\n");
946 break;
947 case 9 : /* GRAY4 */
948 nColor = OMX_COLOR_FormatL4;
949 printf("VPPTEST:: Input GRAY4\n");
950 break;
951 case 10: /* GRAY2 */
952 nColor = OMX_COLOR_FormatL2;
953 printf("VPPTEST:: Input GRAY2\n");
954 break;
955 case 11 : /* Monochrome */
956 nColor = OMX_COLOR_FormatMonochrome;
957 printf("VPPTEST:: Input Monochrome\n");
958 break;
959 default:
960 printf("VPPTEST:: Not a valid option for Input Format\n");
961 goto EXIT;
962 break;
963 }
964
965
966 printf("VPPTEST:: %d : GetHandle Done..........\n",__LINE__);
967
968 pCompPrivateStruct = malloc (sizeof (OMX_PARAM_PORTDEFINITIONTYPE));
969 if(!pCompPrivateStruct){
970 printf("VPPTEST:: eError = OMX_ErrorInsufficientResources");
971 error = OMX_ErrorInsufficientResources;
972 goto EXIT;
973 }
974
975 pCompPrivateStruct->nSize = sizeof (OMX_PARAM_PORTDEFINITIONTYPE);
976 pCompPrivateStruct->nVersion.s.nVersionMajor = 0x1;
977 pCompPrivateStruct->nVersion.s.nVersionMinor = 0x0;
978 pCompPrivateStruct->nVersion.s.nRevision = 0x0;
979 pCompPrivateStruct->nVersion.s.nStep = 0x0;
980 pCompPrivateStruct->nPortIndex = MyVppPortDef.input_port;
981 pCompPrivateStruct->eDir = OMX_DirInput;
982 pCompPrivateStruct->nBufferCountMin = 1;
983 pCompPrivateStruct->nBufferCountActual = MAX_VPP_BUFFERS_IN_USE;
984 pCompPrivateStruct->bEnabled = OMX_TRUE;
985 pCompPrivateStruct->bPopulated = OMX_FALSE;
986 pCompPrivateStruct->eDomain = OMX_PortDomainVideo;
987 pCompPrivateStruct->format.video.nFrameHeight = inputheight;
988 pCompPrivateStruct->format.video.nFrameWidth = inputwidth;
989 pCompPrivateStruct->format.video.eColorFormat = nColor;
990 pCompPrivateStruct->format.video.nBitrate = bitrate;
991
992 //Send input port config
993 error = OMX_SetParameter (pHandle,OMX_IndexParamPortDefinition,
994 pCompPrivateStruct);
995 if (error != OMX_ErrorNone) {
996 goto EXIT;
997 }
998
999 if(Isoverlay){ /* At the moment, only qcif overlay frame is supported*/
1000 error = OMX_GetParameter (pHandle,OMX_IndexParamPortDefinition, pCompPrivateStruct);
1001 if(error != OMX_ErrorNone){
1002 goto EXIT;
1003 }
1004 pCompPrivateStruct->nPortIndex = MyVppPortDef.overlay_port;
1005 pCompPrivateStruct->eDir = OMX_DirInput;
1006 pCompPrivateStruct->nBufferCountActual = MAX_VPP_BUFFERS_IN_USE;
1007 pCompPrivateStruct->format.video.nFrameHeight = DEFAULT_HEIGHT;
1008 pCompPrivateStruct->format.video.nFrameWidth = DEFAULT_WIDTH;
1009 pCompPrivateStruct->format.video.eColorFormat = OMX_COLOR_Format24bitRGB888;//OMX_COLOR_FormatYCbYCr
1010 error = OMX_SetParameter (pHandle,OMX_IndexParamPortDefinition, pCompPrivateStruct);
1011 if (error != OMX_ErrorNone){
1012 goto EXIT;
1013 }
1014 printf("VPPTEST:: Overlay Enabled\n");
1015
1016 }
1017 else {
1018 OMX_SendCommand(pHandle, OMX_CommandPortDisable, MyVppPortDef.overlay_port, NULL);
1019 }
1020
1021 /**************************** FOR OUTPUT PORTS ***************************/
1022 printf("VPPTEST:: Output height: %d, Output Width: %d\n",outputheight, outputwidth);
1023
1024 if(IsYUVRGB){ /*Select output Format and Buffer Size accordingly*/
1025 switch (rgboutputcolor) {
1026 case 1: /*RGB24 8:8:8*/
1027 nColor = OMX_COLOR_Format24bitRGB888; /* changed from BGR*/
1028 printf("VPPTEST:: %d::Output RGB24\n",__LINE__);
1029 break;
1030 case 2: /*RGB16 5:6:5*/
1031 nColor =OMX_COLOR_Format16bitRGB565;
1032 printf("VPPTEST:: Output RGB16\n");
1033 break;
1034 case 3:/*RGB12 4:4:4*/
1035 nColor=OMX_COLOR_Format12bitRGB444;
1036 printf("VPPTEST:: Output RGB12\n");
1037 break;
1038 case 4:/*RGB8 3:3:2*/
1039 nColor = OMX_COLOR_Format8bitRGB332;
1040 printf("VPPTEST:: Output RGB8\n");
1041 break;
1042 case 5: /*RGB4*/
1043 nColor = MyVPPCustomDef.VPP_CustomRGB4ColorFormat;
1044 printf("VPPTEST:: Output RGB4\n");
1045 break;
1046 case 6: /*GRAY8 */
1047 nColor=OMX_COLOR_FormatL8;
1048 printf("VPPTEST:: Output GRAY8\n");
1049 break;
1050 case 7:/*GRAY4*/
1051 nColor = OMX_COLOR_FormatL4;
1052 printf("VPPTEST:: Output GRAY4\n");
1053 break;
1054 case 8: /*GRAY2*/
1055 nColor = OMX_COLOR_FormatL2;
1056 printf("VPPTEST:: Output GRAY2\n");
1057 break;
1058 case 9: /*Monochrome*/
1059 nColor = OMX_COLOR_FormatMonochrome;
1060 printf("VPPTEST:: Output Monochrome\n");
1061 break;
1062 case 10: /*RGB32*/
1063 nColor = OMX_COLOR_Format32bitARGB8888;
1064 printf("VPPTEST:: Output RGB32\n");
1065 break;
1066 default:
1067 nColor =OMX_COLOR_Format16bitRGB565;
1068 printf("VPPTEST:: Not a valid option, default to RGB16\n");
1069 break;
1070 }
1071 }
1072
1073 /*Send output port config for RGB port*/
1074
1075 if(IsYUVRGB){
1076 printf("VPPTEST:: configuring RGB port \n");
1077 error = OMX_GetParameter (pHandle,OMX_IndexParamPortDefinition,
1078 pCompPrivateStruct);
1079 if (error != OMX_ErrorNone) {
1080 goto EXIT;
1081 }
1082 pCompPrivateStruct->nPortIndex = MyVppPortDef.rgboutput_port;
1083 pCompPrivateStruct->eDir = OMX_DirOutput;
1084 pCompPrivateStruct->nBufferCountActual = MAX_VPP_BUFFERS_IN_USE;
1085 pCompPrivateStruct->format.video.nFrameHeight = outputheight;
1086 pCompPrivateStruct->format.video.nFrameWidth = outputwidth;
1087 pCompPrivateStruct->format.video.eColorFormat = nColor ;/*OMX_COLOR_FormatUnused */
1088 error = OMX_SetParameter (pHandle,OMX_IndexParamPortDefinition,
1089 pCompPrivateStruct);
1090 if (error != OMX_ErrorNone) {
1091 goto EXIT;
1092 }
1093 printf("VPPTEST:: RGB port has been configured\n");
1094 }
1095
1096 else{
1097 OMX_SendCommand(pHandle, OMX_CommandPortDisable, MyVppPortDef.rgboutput_port, NULL);
1098 }
1099
1100 /*Send output port config for YUV port*/
1101 if(IsYUVRGB ==0 || IsYUVRGB ==2){
1102 switch (yuvoutputcolor)
1103 {
1104 case 1:
1105 nColor=OMX_COLOR_FormatYUV420PackedPlanar;
1106 printf("VPPTEST:: Output YUV420 Planar\n");
1107 break;
1108 case 2:
1109 nColor=OMX_COLOR_FormatYCbYCr; /*YUV422 (YUYV)*/
1110 printf("VPPTEST:: Output YUV422 YUYV\n");
1111 break;
1112 case 3:
1113 nColor=OMX_COLOR_FormatCbYCrY; /*YUV422 (UYVY)*/
1114 printf("VPPTEST:: Output YUV422 UYVY\n");
1115 break;
1116 default:
1117 printf("VPPTEST:: Not a valid option, default to YUV420 planar\n");
1118 nColor=OMX_COLOR_FormatYUV420PackedPlanar;
1119 break;
1120 }
1121
1122 error = OMX_GetParameter (pHandle,OMX_IndexParamPortDefinition,
1123 pCompPrivateStruct);
1124 if (error != OMX_ErrorNone) {
1125 goto EXIT;
1126 }
1127 pCompPrivateStruct->nPortIndex = MyVppPortDef.yuvoutput_port;
1128 pCompPrivateStruct->eDir = OMX_DirOutput;
1129 pCompPrivateStruct->nBufferCountActual = MAX_VPP_BUFFERS_IN_USE;
1130 pCompPrivateStruct->format.video.nFrameHeight = outputheight;
1131 pCompPrivateStruct->format.video.nFrameWidth = outputwidth;
1132 pCompPrivateStruct->format.video.eColorFormat = nColor;
1133
1134 APP_DPRINT("VPPTEST:: Configuring YUV output port\n");
1135 error = OMX_SetParameter (pHandle,OMX_IndexParamPortDefinition,
1136 pCompPrivateStruct);
1137 if (error != OMX_ErrorNone) {
1138 goto EXIT;
1139 }
1140 printf("VPPTEST:: YUV output port has been configured\n");
1141 }
1142 else{
1143 OMX_SendCommand(pHandle, OMX_CommandPortDisable, MyVppPortDef.yuvoutput_port, NULL);
1144 }
1145
1146 APP_DPRINT ("Basic Function:: Sending OMX_StateIdle Command\n");
1147
1148
1149 printf("VPPTEST:: Num buffers %d\n", MAX_VPP_BUFFERS_IN_USE);
1150
1151 /*Input Buffer Allocation*/
1152 pCompPrivateStruct->nPortIndex = MyVppPortDef.input_port;
1153 error = OMX_GetParameter (pHandle, OMX_IndexParamPortDefinition, pCompPrivateStruct);
1154 if (error != OMX_ErrorNone) {
1155 goto EXIT;
1156 }
1157
1158 if(nTypeofAllocation ==0){
1159 for(nCounter=0; nCounter<MAX_VPP_BUFFERS_IN_USE; nCounter++){ /*MultiBuffer*/
1160 error = OMX_AllocateBuffer(pHandle, &InputBufHeader[nCounter], MyVppPortDef.input_port, (void *)NULL, pCompPrivateStruct->nBufferSize);
1161 if(error != OMX_ErrorNone) {
1162 printf("VPPTEST:: VPPTEST:: OMX_AllocateBuffer failed !!\n");
1163 goto EXIT;
1164 }
1165 }
1166 }
1167 else{
1168 pInBuffer = malloc(pCompPrivateStruct->nBufferSize +256);
1169 if(pInBuffer == NULL){
1170 error = OMX_ErrorInsufficientResources;
1171 goto EXIT;
1172 }
1173 pInBuffer += 128;
1174 for(nCounter=0; nCounter<MAX_VPP_BUFFERS_IN_USE; nCounter++){ /*MultiBuffer*/
1175 error = OMX_UseBuffer(pHandle, &InputBufHeader[nCounter],
1176 MyVppPortDef.input_port,
1177 (void *)NULL,
1178 pCompPrivateStruct->nBufferSize,
1179 pInBuffer);
1180 if(error != OMX_ErrorNone) {
1181 printf("VPPTEST:: OMX_UseBuffer failed !!\n");
1182 goto EXIT;
1183 }
1184 }
1185 }
1186
1187 /*Overlay Buffer Allocation*/
1188 pCompPrivateStruct->nPortIndex = MyVppPortDef.overlay_port;
1189 error = OMX_GetParameter (pHandle, OMX_IndexParamPortDefinition, pCompPrivateStruct);
1190 if (error != OMX_ErrorNone) {
1191 goto EXIT;
1192 }
1193
1194 if(Isoverlay){
1195 for(nCounter=0; nCounter<MAX_VPP_BUFFERS_IN_USE; nCounter++){ /*MultiBuffer*/
1196 error = OMX_AllocateBuffer(pHandle, &OvlyBufHeader[nCounter],
1197 MyVppPortDef.overlay_port,
1198 (void *)NULL,
1199 pCompPrivateStruct->nBufferSize);
1200 if(error != OMX_ErrorNone) {
1201 printf("VPPTEST:: OMX_AllocateBuffer failed !!\n");
1202 goto EXIT;
1203 }
1204 }
1205 }
1206
1207 /*RGB Buffer Allocation*/
1208 pCompPrivateStruct->nPortIndex = MyVppPortDef.rgboutput_port;
1209 error = OMX_GetParameter (pHandle, OMX_IndexParamPortDefinition, pCompPrivateStruct);
1210 if (error != OMX_ErrorNone) {
1211 goto EXIT;
1212 }
1213
1214 if(IsYUVRGB){
1215 if(nTypeofAllocation == 0){
1216 for(nCounter=0; nCounter<MAX_VPP_BUFFERS_IN_USE; nCounter++){ /*MultiBuffer*/
1217 error = OMX_AllocateBuffer(pHandle, &OutRGBBufHeader[nCounter],
1218 MyVppPortDef.rgboutput_port,
1219 (void *)NULL,
1220 pCompPrivateStruct->nBufferSize);
1221 if(error != OMX_ErrorNone) {
1222 printf("VPPTEST:: OMX_AllocateBuffer failed !!\n");
1223 goto EXIT;
1224 }
1225 }
1226 }
1227 else{
1228 pRGBBuffer = malloc(pCompPrivateStruct->nBufferSize + 256);
1229 if(pRGBBuffer == NULL){
1230 error = OMX_ErrorInsufficientResources;
1231 goto EXIT;
1232 }
1233 pRGBBuffer += 128;
1234 for(nCounter = 0; nCounter<MAX_VPP_BUFFERS_IN_USE; nCounter++){ /*MultiBuffer*/
1235 error = OMX_UseBuffer(pHandle, &OutRGBBufHeader[nCounter],
1236 MyVppPortDef.rgboutput_port,
1237 (void *)NULL,
1238 pCompPrivateStruct->nBufferSize,
1239 pRGBBuffer);
1240 if(error != OMX_ErrorNone){
1241 printf("VPPTEST:: OMX_UseBuffer failed !!\n");
1242 goto EXIT;
1243 }
1244 }
1245 }
1246 }
1247
1248 /*YUV Buffer Allocation*/
1249 pCompPrivateStruct->nPortIndex = MyVppPortDef.yuvoutput_port;
1250 error = OMX_GetParameter (pHandle, OMX_IndexParamPortDefinition, pCompPrivateStruct);
1251 if (error != OMX_ErrorNone) {
1252 goto EXIT;
1253 }
1254
1255 if(IsYUVRGB ==0 || IsYUVRGB ==2){
1256 if(nTypeofAllocation ==0){
1257 for(nCounter=0; nCounter<MAX_VPP_BUFFERS_IN_USE; nCounter++){ /*MultiBuffer*/
1258 error = OMX_AllocateBuffer(pHandle, &OutYUVBufHeader[nCounter],
1259 MyVppPortDef.yuvoutput_port,
1260 (void *)NULL,
1261 pCompPrivateStruct->nBufferSize);
1262 if(error != OMX_ErrorNone) {
1263 printf("VPPTEST:: OMX_AllocateBuffer failed !!\n");
1264 goto EXIT;
1265 }
1266 }
1267 }
1268 else{
1269 pYUVBuffer = malloc(pCompPrivateStruct->nBufferSize +256);
1270 if(pYUVBuffer == NULL){
1271 error = OMX_ErrorInsufficientResources;
1272 goto EXIT;
1273 }
1274 pYUVBuffer += 128;
1275 for(nCounter=0; nCounter<MAX_VPP_BUFFERS_IN_USE; nCounter++){ /*MultiBuffer*/
1276 error = OMX_UseBuffer(pHandle, &OutYUVBufHeader[nCounter],
1277 MyVppPortDef.yuvoutput_port,
1278 (void *)NULL,
1279 pCompPrivateStruct->nBufferSize,
1280 pYUVBuffer);
1281 if(error != OMX_ErrorNone) {
1282 printf("VPPTEST:: OMX_UseBuffer failed !!\n");
1283 goto EXIT;
1284 }
1285 }
1286 }
1287 }
1288
1289 error = OMX_SendCommand(pHandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
1290 if(error != OMX_ErrorNone){
1291 fprintf (stderr,"VPPTEST:: Error from SendCommand-Idle(Init) State function\n");
1292 goto EXIT;
1293 }
1294 printf("VPPTEST:: Sending component to Idle State\n");
1295 /* Wait for startup to complete */
1296 error = WaitForState(pHandle, OMX_StateIdle);
1297 if(error != OMX_ErrorNone) {
1298 fprintf(stderr, "VPPTEST:: Error: VPP->WaitForState reports an error %X\n", error);
1299 goto EXIT;
1300 }
1301 state = OMX_StateIdle;
1302 APP_DPRINT("Component is in Idle State\n");
1303
1304 /*******HERE THE COMPONENT IS ALREADY IN IDLE STATE AND BUFFERS HAVE BEEN ALLOCATED********/
1305 if(bStopRestart) {
1306 max_count_stop_restart=20;
1307 }
1308 else{
1309 max_count_stop_restart=1;
1310 }
1311
1312 for(count_stop_restart=0; count_stop_restart<max_count_stop_restart; count_stop_restart++) /*Executing-->Idle-->Executing*/
1313 {
1314 sched_yield();
1315 iCurrentFrameIn = 0;
1316 iCurrentOvlyFrameIn=0;
1317 iCurrentRGBFrameOut = 0;
1318 iCurrentYUVFrameOut = 0;
1319 nFillThisBufferYUV=0;
1320 nFillThisBufferRGB=0;
1321 /***********************************OPEN THE NEEDED FILES****************************************************/
1322 #ifdef UNDER_CE
1323 fIn = CreateFile(argv[1], GENERIC_READ, 0,
1324 NULL,OPEN_EXISTING, 0, NULL);
1325 if (INVALID_HANDLE_VALUE == fIn){
1326 APP_DPRINT("Error: failed to open the file %S for readonly" \
1327 "access\n", argv[1]);
1328 goto EXIT;
1329 }
1330
1331 if(IsYUVRGB){
1332 wsprintf(stringRGB, L"%s.raw",szOutFile);
1333
1334 fOut = CreateFile(stringRGB, GENERIC_WRITE, 0,
1335 NULL,CREATE_ALWAYS, 0, NULL);
1336 if (INVALID_HANDLE_VALUE == fOut){
1337 APP_DPRINT("Error: failed to create the output file %s\n",
1338 stringRGB);
1339 goto EXIT;
1340 }
1341 }
1342
1343 if(IsYUVRGB ==0 || IsYUVRGB ==2){
1344 wsprintf(stringYUV, L"%s.yuv",szOutFile);
1345
1346 fYuvOut = CreateFile(stringYUV, GENERIC_WRITE, 0,
1347 NULL,CREATE_ALWAYS, 0, NULL);
1348 if( fYuvOut == INVALID_HANDLE_VALUE ){
1349 APP_DPRINT("Error: failed to create the output file %s\n",
1350 stringYUV);
1351 goto EXIT;
1352 }
1353 }
1354 #else
1355
1356 /* Open the file of data to be rendered. */
1357 fIn = fopen(argv[1], "r");
1358 if( fIn == NULL ){
1359 fprintf(stderr, "VPPTEST:: %d::Error: failed to open the file %s for readonly access\n",__LINE__,argv[1]);
1360 goto EXIT;
1361 }
1362
1363 if(IsYUVRGB ){
1364
1365 sprintf(stringRGB, "%s.raw",szOutFile);
1366
1367 fOut = fopen(stringRGB, "w");
1368 if( fOut == NULL ){
1369 fprintf(stderr,
1370 "Error: failed to create the output file %s\n",
1371 argv[2]);
1372 goto EXIT;
1373 }
1374 }
1375 if(IsYUVRGB ==0 || IsYUVRGB ==2){
1376 sprintf(stringYUV, "%s.yuv",szOutFile);
1377 fYuvOut = fopen(stringYUV, "w");
1378 if(fYuvOut == NULL){
1379 fprintf(stderr,
1380 "Error: failed to create the output file %s\n",
1381 stringYUV);
1382 goto EXIT;
1383 }
1384 }
1385 #endif
1386
1387
1388
1389 /**** ALL THE Configurables Features of VPP will happen here (Zoom, Contrast, Cropping, etc.*/
1390 APP_DPRINT("Configurating features...\n");
1391 if(Isoverlay){
1392 /*This should be enable in case of overlay */
1393 OMX_CONFIG_COLORKEYTYPE *color = malloc(sizeof(OMX_CONFIG_COLORKEYTYPE));
1394 if(color == NULL){
1395 error = OMX_ErrorInsufficientResources;
1396 goto EXIT;
1397 }
1398 /*OMX_U8 colorKey[] = {0,250,5,3}; ARGB*/
1399 OMX_U8 colorKey[] = {0,3,5,250}; /*ARGB*/
1400 color->nARGBMask = (int)colorKey;
1401 error = OMX_SetConfig (pHandle,OMX_IndexConfigCommonColorKey,
1402 color);
1403 free(color);
1404 if (error != OMX_ErrorNone) {
1405 error = OMX_ErrorBadParameter;
1406 goto EXIT;
1407 }
1408 }
1409 error=OMX_ErrorNone;
1410 switch(feature)
1411 {
1412 case 0: /*Only Scaling Selected*/
1413 break; /*No need to configure any other feature*/
1414 case 1: /*On Demand Zoom*/
1415 {
1416 error = VPP_SetZoom(pHandle, 0,feature_param[0], feature_param[1],0,0);
1417 printf("VPPTEST:: Selected On Demand Zoom feature\n");
1418 break;
1419 }
1420 case 2: /*Dynamic Zoom*/
1421 error = VPP_SetZoom(pHandle,feature_param[0],1024,feature_param[1],0,0);
1422 printf("VPPTEST:: Selected Dynamic Zoom Feature\n");
1423 break;
1424
1425 case 3: /*Zoom Offset*/
1426 {
1427 /* error = VPP_SetZoom(pHandle,feature,feature_param);*/
1428 error = VPP_SetZoom(pHandle,0, feature_param[0], feature_param[1],feature_param[2],feature_param[3]);
1429 printf("VPPTEST:: Selected Zoom Offset Feature\n");
1430 /*VPP_SetZoom(OMX_HANDLETYPE pHandle, int speed, int factor, int limit, int xoff, int yoff);*/
1431 break;
1432 }
1433 case 4: /*Contrast*/
1434 {
1435 error = VPP_SetContrast(pHandle, feature_param[0]);
1436 printf("VPPTEST:: Selected Contrast (Video Gain) Feature\n");
1437 break;
1438 }
1439 case 5: /*Frosted Glass Overlay Effect*/
1440 {
1441 error = VPP_FrostedGlassEffect(pHandle, Isoverlay);
1442 printf("VPPTEST:: Selected Frosted Glass Overlay Effect\n");
1443 break;
1444 }
1445 case 6: /*Cropping*/
1446 {
1447 error = VPP_SetCrop(pHandle, feature_param[0], feature_param[1], feature_param[2], feature_param[3]);
1448 printf("VPPTEST:: Selected cropping Feature\n");
1449 break;
1450 }
1451 case 7: /*Mirroring*/
1452 {
1453 error = VPP_SetMirroring(pHandle,IsYUVRGB);
1454 printf("VPPTEST:: Selected Mirroring Feature\n");
1455 break;
1456 }
1457 case 8 : /*RotationAngle*/
1458 {
1459 error = VPP_SetRotationAngle(pHandle, IsYUVRGB,feature_param[0]);
1460 printf("VPPTEST:: Selected Rotation Feature\n");
1461 break;
1462 }
1463 case 9: /*Dithering*/
1464 {
1465 error = VPP_SetDithering(pHandle,IsYUVRGB);
1466 printf("VPPTEST:: Selected Dithering Feature\n");
1467 break;
1468
1469 }
1470
1471 case 10: /*Color Range Conversion*/
1472 {
1473 error=VPP_SetColorRange(pHandle,feature_param[0]);
1474 printf("VPPTEST:: Selected Color Range\n");
1475 break;
1476 }
1477
1478
1479 default:
1480 { error = OMX_ErrorBadParameter;
1481 printf("VPPTEST:: Not a valid Option on Feature Selection\n");
1482 break;
1483 }
1484 }
1485
1486 if (error != OMX_ErrorNone)
1487 {
1488 error = OMX_ErrorBadParameter;
1489 goto EXIT;
1490 }
1491
1492 APP_DPRINT ("Basic Function:: Sending OMX_StateExecuting Command\n");
1493 error = OMX_SendCommand(pHandle,OMX_CommandStateSet, OMX_StateExecuting, NULL);
1494 if(error != OMX_ErrorNone) {
1495 fprintf (stderr,"VPPTEST:: Error from SendCommand-Executing State function\n");
1496 goto EXIT;
1497 }
1498 pComponent = (OMX_COMPONENTTYPE *)pHandle;
1499
1500
1501 error = WaitForState(pHandle, OMX_StateExecuting);
1502 if(error != OMX_ErrorNone) {
1503 fprintf(stderr, "VPPTEST:: Error: VPP->WaitForState reports an error %X\n", error);
1504 goto EXIT;
1505 }
1506 printf("VPPTEST:: Component is now in Executing state\n");
1507 state = OMX_StateExecuting;
1508
1509 if(Isoverlay){
1510 fInOvelay = fopen(overlaystring, "r");
1511 if (!fInOvelay)
1512 {
1513 fprintf(stderr, "Error: failed to open the file %s for readonly access\n", overlaystring);
1514 goto EXIT;
1515 }
1516 }
1517 #ifndef UNDER_CE
1518 /*PROFILE POINT */
1519 gettimeofday(&base, NULL);
1520 newer.tv_sec = base.tv_sec;
1521 newer.tv_usec = base.tv_usec;
1522 APP_DPRINT("sec: %ld, usec: %ld\n", base.tv_sec, base.tv_usec);
1523 /*profiletime = GetProfiletime());*/
1524 #endif
1525 for(nCounter=0; nCounter<MAX_VPP_BUFFERS_IN_USE; nCounter++){ /*MultiBuffer*/
1526 /*Send Input Buffers to the Component */
1527 /*Provided that at least one frame will be read*/
1528 nRead = fill_data (InputBufHeader[nCounter],fIn);
1529 if(nRead == 0){
1530 APP_DPRINT("There is no data on input file\n");
1531 break; /*If there is no data send no more buffers to the component*/
1532 /*Exit for loop*/
1533 }
1534 else{
1535 ++iCurrentFrameIn;
1536 error = OMX_EmptyThisBuffer(pHandle, InputBufHeader[nCounter]); /*INPUT port*/
1537 if (error != OMX_ErrorNone) {
1538 printf ("VPPTEST:: Error from OMX_EmptyThisBuffer function 0x%X\n",error);
1539 goto EXIT;
1540 }
1541 }
1542
1543 if(Isoverlay) /*OVERLAY PORT*/{
1544 #ifdef UNDER_CE
1545 fInOvelay = CreateFile(overlaystring, GENERIC_READ, 0,
1546 NULL,OPEN_EXISTING, 0, NULL);
1547 if(fInOvelay == INVALID_HANDLE_VALUE){
1548 APP_DPRINT("Error: failed to open the file %s for readonly\
1549 access\n", fInOvelay);
1550 goto EXIT;
1551 }
1552 #else
1553 fseek(fInOvelay, 0L, SEEK_SET);
1554 nRead = fill_data (OvlyBufHeader[nCounter],fInOvelay);
1555 if (nRead < (DEFAULT_WIDTH * DEFAULT_HEIGHT)* 3){
1556 printf("VPPTEST:: Error in fread for overlay, not enough data\n");
1557 }
1558 ++iCurrentOvlyFrameIn;
1559 error = OMX_EmptyThisBuffer(pHandle, OvlyBufHeader[nCounter]); /*OVERLAY port*/
1560 if (error != OMX_ErrorNone) {
1561 printf ("VPPTEST:: Error from OMX_EmptyThisBuffer function 0x%X\n",error);
1562 goto EXIT;
1563 }
1564 }
1565 #endif
1566 if(IsYUVRGB){ /*Send RGB output buffers to component*/
1567 OutRGBBufHeader[nCounter]->nFilledLen=0;
1568 error = OMX_FillThisBuffer(pHandle,OutRGBBufHeader[nCounter]);
1569 if (error != OMX_ErrorNone){
1570 printf ("VPPTEST:: Error from OMX_FillThisBuffer function 0x%X\n",error);
1571 goto EXIT;
1572 }
1573 nFillThisBufferRGB++;
1574 }
1575 if(IsYUVRGB==0 || IsYUVRGB ==2){ /*Send YUV output buffers to component*/
1576 OutYUVBufHeader[nCounter]->nFilledLen=0;
1577 error = OMX_FillThisBuffer(pHandle,OutYUVBufHeader[nCounter]);
1578 if (error != OMX_ErrorNone) {
1579 printf ("VPPTEST:: Error from OMX_FillThisBuffer function 0x%X\n",error);
1580 goto EXIT;
1581 }
1582 nFillThisBufferYUV++;
1583 }
1584 } /*end of for*/
1585
1586 /**************************************************************************/
1587
1588 nRead = 0;
1589 done = 0;
1590 frmCount = 0;
1591 OMX_STATETYPE MyState;
1592
1593 MyState = OMX_StateExecuting;
1594 DEINIT_FLAG = OMX_FALSE;
1595 while ((error == OMX_ErrorNone ) && (MyState != OMX_StateIdle)) {
1596 FD_ZERO(&rfds);
1597 FD_SET(IpBuf_Pipe[0], &rfds);
1598 FD_SET(OvlyBuf_Pipe[0],&rfds);
1599 FD_SET(OpRGBBuf_Pipe[0], &rfds);
1600 FD_SET(OpYUVBuf_Pipe[0],&rfds);
1601 FD_SET(Event_Pipe[0],&rfds);
1602 sigemptyset(&set) ;
1603 sigaddset(&set, SIGALRM);
1604
1605 retval = pselect(fdmax+1, &rfds, NULL, NULL, NULL,&set);
1606 if(retval == -1) {
1607 #ifndef UNDER_CE
1608 perror("select()");
1609 #endif
1610 fprintf (stderr, "VPPTEST:: : Error \n");
1611 break;
1612 }
1613
1614 if(retval == 0) {
1615 APP_DPRINT("\n\n\n%d ::!!!!!!! App Timeout !!!!!!!!!!! \n",__LINE__);
1616 APP_DPRINT("%d :: ---------------------------------------\n\n\n",__LINE__);
1617 if(++nTimeouts>5){
1618 APP_DPRINT("VPPTEST:: No more data from Component\n");
1619 APP_DPRINT("VPPTEST:: Inputs=%d, Ovlys=%d, OutRGBs=%d,OutYUVs=%d\n",
1620 iCurrentFrameIn, iCurrentOvlyFrameIn,
1621 iCurrentRGBFrameOut,iCurrentYUVFrameOut);
1622 error = OMX_SendCommand(pHandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
1623 if(error != OMX_ErrorNone) {
1624 fprintf (stderr,"VPPTEST:: Error from SendCommand-Idle(Init) State function\n");
1625 goto EXIT;
1626 }
1627 error = WaitForState(pHandle, OMX_StateIdle);
1628 if(error != OMX_ErrorNone) {
1629 printf("VPPTEST:: Error: hVPP->WaitForState has timed out %X", error);
1630 goto EXIT;
1631 }
1632 APP_DPRINT("VPP has been set in Idle State now\n");
1633 APP_DPRINT("Error on %s-->%s\n",szInFile,szOutFile);
1634 MyState = OMX_StateIdle;
1635 }
1636 }
1637 /**
1638 * If FD_ISSET then there is data available in the pipe.
1639 * Read it and get the buffer data out.
1640 * Then re-fill the buffer and send it back.
1641 **/
1642 if ( FD_ISSET(Event_Pipe[0], &rfds)) {
1643 EVENT_PRIVATE EventPrivate;
1644 read(Event_Pipe[0], &EventPrivate, sizeof(EVENT_PRIVATE));
1645 switch(EventPrivate.eEvent) {
1646 case OMX_EventError:
1647 DEINIT_FLAG = OMX_TRUE;
1648 bError = OMX_TRUE;
1649 printf("APP:: Waiting for OMX_StateInvalid... \n");
1650 WaitForState(pHandle, OMX_StateInvalid);
1651 printf("APP:: At Invalid state.\n");
1652 goto EXIT;
1653 break;
1654
1655 case OMX_EventBufferFlag:
1656 printf("APP:: Unloading component...\n");
1657 break;
1658
1659 default:
1660 break;
1661 }
1662 }
1663
1664 if(bPauseResume && !(iCurrentFrameIn%20)){
1665 printf("VPPTEST:: Pausing the component at %d Frames\n",iCurrentFrameIn);
1666 error=OMX_SendCommand(pHandle,OMX_CommandStateSet,OMX_StatePause,NULL);
1667 if(error!=OMX_ErrorNone){
1668 fprintf(stderr,"VPPTEST:: Error from SendCommand-Pause State Function\n");
1669 goto EXIT;
1670 }
1671 error = WaitForState(pHandle,OMX_StatePause);
1672 if(error !=OMX_ErrorNone){
1673 printf("VPPTEST:: Error: hVPP->WaitForState has timed out %X", error);
1674 goto EXIT;
1675 }
1676 printf("VPPTEST:: Sleeping the component for 2 seconds in Pause\n");
1677 sleep(2);
1678 error = OMX_SendCommand(pHandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
1679 if(error != OMX_ErrorNone) {
1680 fprintf (stderr,"Error from SendCommand-Executing State function\n");
1681 goto EXIT;
1682 }
1683 error = WaitForState(pHandle, OMX_StateExecuting);
1684 if(error != OMX_ErrorNone) {
1685 printf("VPPTEST:: Error: hVPP->WaitForState has timed out %X", error);
1686 goto EXIT;
1687 }
1688 printf("VPPTEST:: Component is Executing again\n");
1689
1690 }
1691
1692 if(bStopExit && !(iCurrentFrameIn%43)){ /*Stopping to get an output file of 40 frames jesa*/
1693 printf("VPPTEST:: Stopping at output YUV frame %d and exiting\n", iCurrentYUVFrameOut);
1694 if( FD_ISSET(IpBuf_Pipe[0], &rfds) ) {
1695 read(IpBuf_Pipe[0], &pBuffer, sizeof(pBuffer));
1696 }
1697 if( FD_ISSET(OvlyBuf_Pipe[0], &rfds) ) {
1698 read(OvlyBuf_Pipe[0], &pBuffer, sizeof(pBuffer));
1699 }
1700 if( FD_ISSET(OpRGBBuf_Pipe[0], &rfds) ) {
1701 read(OpRGBBuf_Pipe[0], &pBuffer, sizeof(pBuffer));
1702 }
1703 if( FD_ISSET(OpYUVBuf_Pipe[0], &rfds) ) {
1704 read(OpYUVBuf_Pipe[0], &pBuffer, sizeof(pBuffer));
1705 }
1706 fprintf(stderr, "VPPTEST:: Shutting down ---------- \n");
1707 APP_DPRINT("Number of Processed Frames: Input=%d, Overlay=%d, RGB=%d, YUV=%d\n",
1708 iCurrentFrameIn,iCurrentOvlyFrameIn,iCurrentRGBFrameOut,iCurrentYUVFrameOut);
1709 APP_DPRINT("Number of frames received: Input=%d, Overlay=%d, RGB=%d, YUV=%d\n",
1710 nInputEmptyBufferDones, nOvlyEmptyBufferDones, nRGBFillBufferDones, nYUVFillBufferDones);
1711 APP_DPRINT("Number of sent Buffers: Input=%d, Overlay=%d, RGB=%d, YUV=%d\n",
1712 iCurrentFrameIn,iCurrentOvlyFrameIn, nFillThisBufferRGB, nFillThisBufferYUV);
1713 DEINIT_FLAG = 1;
1714 }
1715
1716 if( FD_ISSET(IpBuf_Pipe[0], &rfds) ) {
1717 read(IpBuf_Pipe[0], &pBuffer, sizeof(pBuffer));
1718 portinput = pBuffer->pInputPortPrivate;
1719 APP_DPRINT("%d ::App: Read from IpBuf_Pipe InBufHeader %p\n",
1720 __LINE__,pBuffer);
1721 frmCount++;
1722
1723 if (!done) {
1724
1725 APP_DPRINT("%d ::reading INPUT DATA file \n",
1726 __LINE__);
1727 /*If buffer corresponds to Input Port*/
1728 nRead = fill_data (pBuffer,fIn);
1729 APP_DPRINT(" ::reading INPUT DATA file pBuffer->nAllocLen %d read=%d\n",
1730 pBuffer->nAllocLen,nRead);
1731 if((nRead < pBuffer->nAllocLen) && (done == 0)){
1732 fprintf(stderr, "VPPTEST:: Shutting down ---------- \n");
1733 APP_DPRINT("Number of Processed Frames: Input=%d, Overlay=%d, RGB=%d, YUV=%d\n",
1734 iCurrentFrameIn,iCurrentOvlyFrameIn,iCurrentRGBFrameOut,iCurrentYUVFrameOut);
1735 APP_DPRINT("Number of frames received: Input=%d, Overlay=%d, RGB=%d, YUV=%d\n",
1736 nInputEmptyBufferDones, nOvlyEmptyBufferDones, nRGBFillBufferDones, nYUVFillBufferDones);
1737 APP_DPRINT("Number of sent Buffers: Input=%d, Overlay=%d, RGB=%d, YUV=%d\n",
1738 iCurrentFrameIn,iCurrentOvlyFrameIn, nFillThisBufferRGB, nFillThisBufferYUV);
1739 done = 1;
1740 DEINIT_FLAG = 1;
1741 pBuffer->nFlags = OMX_BUFFERFLAG_EOS;
1742 }
1743 else{
1744 ++iCurrentFrameIn;
1745 pBuffer->nFilledLen = nRead;
1746 pComponent->EmptyThisBuffer(pHandle,pBuffer);
1747 APP_DPRINT("%d :: App: Sent Filled Input Buffer to Comp\n",__LINE__);
1748 }
1749 }
1750 }
1751
1752 if(FD_ISSET(OvlyBuf_Pipe[0],&rfds) ){
1753 APP_DPRINT("%d ::reading OVERLAY DATA file \n",
1754 __LINE__);
1755 /*Read and process Overlay Pipe, only if Input Pipe has been processed already*/
1756 if(iCurrentOvlyFrameIn<iCurrentFrameIn){
1757 read(OvlyBuf_Pipe[0], &pBuffer, sizeof(pBuffer));
1758 #ifdef UNDER_CE
1759 fInOvelay = CreateFile(overlaystring, GENERIC_READ, 0,
1760 NULL,OPEN_EXISTING, 0, NULL);
1761 if( fInOvelay == INVALID_HANDLE_VALUE ){
1762 APP_DPRINT("Error: failed to open the file %s for readonly\
1763 access\n", fInOvelay);
1764 goto EXIT;
1765 }
1766 #else
1767 fseek(fInOvelay, 0L, SEEK_SET);
1768 nRead = fill_data(pBuffer,fInOvelay);
1769 if (nRead < (DEFAULT_WIDTH * DEFAULT_HEIGHT)* 3){
1770 printf("VPPTEST:: Error in fread for overlay, not enough data\n");
1771 }
1772 #endif
1773
1774 #ifdef UNDER_CE
1775 CloseHandle(fInOvelay);
1776 #else
1777
1778 #endif
1779 ++iCurrentOvlyFrameIn;
1780 pBuffer->nFilledLen = nRead;
1781 pComponent->EmptyThisBuffer(pHandle,pBuffer);
1782 APP_DPRINT("%d :: App: Sent Filled Overlay Buffer to Comp\n",__LINE__);
1783 }/*end if(iCurrentOvlyFrameIn<iCurrentFrameIn)*/
1784 } /*end if(FD_ISSET(OvlyBuf_Pipe[0],&rfds) */
1785
1786 if(FD_ISSET(OpRGBBuf_Pipe[0], &rfds) ) {
1787 /*Only read and process RGB Output pipe if Input Pipe
1788 has been processed first*/
1789 if(iCurrentRGBFrameOut<iCurrentFrameIn){
1790 read(OpRGBBuf_Pipe[0], &pBuf, sizeof(pBuf));
1791 APP_DPRINT("%d ::App: Read from OpBuf_Pipe OutBufHeader %p\n", __LINE__,pBuf);
1792 ++iCurrentRGBFrameOut;
1793 if (pBuf->nAllocLen != pBuf->nFilledLen ) {
1794 if(pBuf->nFilledLen==0) printf("* WARNING: Frame has been lost (pBuf->nFilledLen is 0)\n");
1795 APP_DPRINT("%d : WARNING: Different Size, %ld\n",__LINE__, pBuf->nFilledLen);
1796 }
1797 else{
1798 #ifdef UNDER_CE
1799 WriteFile(fOut, pBuf->pBuffer, pBuf->nFilledLen, &dwWritten, NULL);
1800 #else
1801 fwrite(pBuf->pBuffer, 1, pBuf->nFilledLen, fOut);
1802 #endif
1803
1804 /*Send the same number of Output buffers than Input buffers*/
1805 if(nFillThisBufferRGB<iCurrentFrameIn){
1806 pComponent->FillThisBuffer(pHandle,pBuf);
1807 nFillThisBufferRGB++;
1808 }
1809 }
1810 }/*end if((iCurrentRGBFrameOut<iCurrentFrameIn)*/
1811 } /*end of FD_ISSET(OpRGBBuf_Pipe[0], &rfds)*/
1812
1813 if(FD_ISSET(OpYUVBuf_Pipe[0], &rfds) ) {
1814 /*Read and Process Output YUV Pipe, only if Input Pipe has
1815 been read and processed first */
1816 if(iCurrentYUVFrameOut < iCurrentFrameIn){
1817 read(OpYUVBuf_Pipe[0], &pBuf, sizeof(pBuf));
1818 APP_DPRINT("%d ::App: Read from OpYUVBuf_Pipe OutBufHeader %p\n", __LINE__,pBuf);
1819 ++iCurrentYUVFrameOut;
1820 if (pBuf->nAllocLen != pBuf->nFilledLen ) {
1821 if(pBuf->nFilledLen==0) printf("* WARNING: Frame has been lost (pBuf->nFilledLen is 0)\n");
1822 APP_DPRINT("%d : WARNING: Different Size, %ld\n",__LINE__, pBuf->nFilledLen);
1823 }
1824 else{
1825
1826 #ifdef UNDER_CE
1827 WriteFile(fOut, pBuf->pBuffer, pBuf->nFilledLen, &dwWritten, NULL);
1828 #else
1829 fwrite(pBuf->pBuffer, 1, pBuf->nFilledLen, fYuvOut);
1830 #endif
1831
1832 /*Send the same number of output buffers than input buffers
1833 to the component*/
1834 if(nFillThisBufferYUV<iCurrentFrameIn){
1835 pComponent->FillThisBuffer(pHandle,pBuf);
1836 nFillThisBufferYUV++;
1837 }
1838 }
1839
1840 }/*end if(iCurrentYUVFrameOut < iCurrentFrameIn)*/
1841 APP_DPRINT("%d :: App: %ld bytes are being written\n",__LINE__,(pBuf->nFilledLen/4));
1842
1843 }/*end if (FD_ISSET(OpYUVBuf_Pipe[0], &rfds)*/
1844
1845 if (DEINIT_FLAG &&
1846 ((iCurrentFrameIn == iCurrentRGBFrameOut) ||
1847 (iCurrentFrameIn == iCurrentYUVFrameOut) ||
1848 (bStopExit)
1849 )){
1850 APP_DPRINT("Read full file!!!\n");
1851 done = 1;
1852 error = OMX_SendCommand(pHandle,OMX_CommandStateSet, OMX_StateIdle, NULL);
1853 if(error != OMX_ErrorNone) {
1854 fprintf (stderr,"Error from SendCommand-Idle(Stop) State function\n");
1855 goto EXIT;
1856 }
1857 APP_DPRINT("Waiting for OMX_StateIdle... \n");
1858 error = WaitForState(pHandle, OMX_StateIdle);
1859 if(error != OMX_ErrorNone) {
1860 APP_DPRINT("Error: VPP->WaitForState has timed out %X",
1861 error);
1862 goto EXIT;
1863 }
1864 }/*end of if DEINIT_FLAG*/
1865
1866
1867 if(done == 1) {
1868 error = pComponent->GetState(pHandle, &state);
1869 if(error != OMX_ErrorNone) {
1870 fprintf(stderr, "Warning: VPP->GetState has returned status %X\n", error);
1871 goto EXIT;
1872 }
1873 }
1874 OMX_GetState(pHandle, &MyState);
1875
1876 }
1877 APP_DPRINT("VPPTESTDEBUG::Exiting While loop, closing all the file handles\n");
1878 APP_DPRINT("Number of Processed Frames: Input=%d, Overlay=%d, RGB=%d, YUV=%d\n",
1879 iCurrentFrameIn,iCurrentOvlyFrameIn,iCurrentRGBFrameOut,iCurrentYUVFrameOut);
1880 printf("VPPTEST:: Component is now in Idle State\n");
1881 #ifdef UNDER_CE
1882 CloseHandle(fIn);
1883 if(IsYUVRGB )
1884 CloseHandle(fOut);
1885 if(IsYUVRGB ==0 || IsYUVRGB ==2)
1886 CloseHandle(fYuvOut);
1887 #else
1888 fclose(fIn);
1889 if(IsYUVRGB)
1890 fclose(fOut);
1891 if (Isoverlay)
1892 fclose(fInOvelay);
1893 if(IsYUVRGB ==0 || IsYUVRGB ==2)
1894 fclose(fYuvOut);
1895 #endif
1896 if(MyState == OMX_StateInvalid){
1897 break; /*to exit the Executing-->Idle-->Executing cicle*/
1898 }
1899 } /* Executing-->Idle-->Executing*/
1900
1901 /***************************************************************************************************/
1902 APP_DPRINT("Total processing time = %ld\n", nTotalTime);
1903
1904 OMX_STATETYPE MyState;
1905 OMX_GetState(pHandle, &MyState);
1906
1907 if(MyState != OMX_StateInvalid){
1908 APP_DPRINT ("%d :: App: State Of Component Is Idle Now\n",__LINE__);
1909 APP_DPRINT("Sending the StateLoaded Command\n");
1910 error = OMX_SendCommand(pHandle,OMX_CommandStateSet, OMX_StateLoaded, NULL);
1911 if(error != OMX_ErrorNone) {
1912 fprintf (stderr,"Error from SendCommand-Idle State function\n");
1913 goto EXIT;
1914 }
1915 /*Disable the ports before freeing the buffers*/
1916
1917 error = OMX_SendCommand(pHandle,OMX_CommandPortDisable, MyVppPortDef.input_port, NULL);
1918 if(error != OMX_ErrorNone){
1919 APP_DPRINT("VPPTEST:: %d::Error from SendCommand-->PortDisable\n",__LINE__);
1920 goto EXIT;
1921 }
1922 if(Isoverlay){
1923 error = OMX_SendCommand(pHandle,OMX_CommandPortDisable, MyVppPortDef.overlay_port, NULL);
1924 if(error != OMX_ErrorNone){
1925 APP_DPRINT("VPPTEST:: %d::Error from SendCommand-->PortDisable\n",__LINE__);
1926 goto EXIT;
1927 }
1928 }
1929 if(IsYUVRGB){
1930 error = OMX_SendCommand(pHandle,OMX_CommandPortDisable,MyVppPortDef.rgboutput_port, NULL);
1931 if(error != OMX_ErrorNone){
1932 APP_DPRINT("VPPTEST:: %d::Error from SendCommand-->PortDisable\n",__LINE__);
1933 goto EXIT;
1934 }
1935 }
1936 if(IsYUVRGB==0 || IsYUVRGB==2){
1937 error = OMX_SendCommand(pHandle,OMX_CommandPortDisable,MyVppPortDef.yuvoutput_port, NULL);
1938 if(error != OMX_ErrorNone){
1939 APP_DPRINT("VPPTEST:: %d::Error from SendCommand-->PortDisable\n",__LINE__);
1940 goto EXIT;
1941 }
1942 }
1943 }
1944 if(nTypeofAllocation == 1){
1945 if(pInBuffer){
1946 free (pInBuffer);
1947 pInBuffer = NULL;
1948 }
1949 if(pYUVBuffer){
1950 free(pYUVBuffer);
1951 pYUVBuffer = NULL;
1952 }
1953 if(pRGBBuffer){
1954 free(pRGBBuffer);
1955 pYUVBuffer = NULL;
1956 }
1957 }
1958 for(nCounter=0; nCounter<MAX_VPP_BUFFERS_IN_USE; nCounter++){ /* MultiBuffer*/
1959 error = OMX_FreeBuffer(pHandle, MyVppPortDef.input_port, InputBufHeader[nCounter]) ;
1960 if(error != OMX_ErrorNone) {
1961 printf("VPPTEST:: free buffer failed !!\n");
1962 goto EXIT;
1963 }
1964
1965 if(Isoverlay){
1966 error = OMX_FreeBuffer(pHandle, MyVppPortDef.overlay_port, OvlyBufHeader[nCounter]);
1967 if(error != OMX_ErrorNone) {
1968 printf("VPPTEST:: OMX_FreeBuffer failed !!\n");
1969 goto EXIT;
1970 }
1971 }
1972
1973 if(IsYUVRGB)
1974 {
1975 error = OMX_FreeBuffer(pHandle, MyVppPortDef.rgboutput_port, OutRGBBufHeader[nCounter]);
1976 if(error != OMX_ErrorNone) {
1977 printf("VPPTEST:: OMX_FreeBuffer failed !!\n");
1978 goto EXIT;
1979 }
1980 }
1981
1982 if(IsYUVRGB ==0 || IsYUVRGB ==2){
1983 error = OMX_FreeBuffer(pHandle, MyVppPortDef.yuvoutput_port, OutYUVBufHeader[nCounter]);
1984 if(error != OMX_ErrorNone) {
1985 printf("VPPTEST:: OMX_FreeBuffer failed !!\n");
1986 goto EXIT;
1987 }
1988 }
1989 }//end of for loop
1990
1991 /* Wait for startup to complete */
1992 error = WaitForState(pHandle, OMX_StateLoaded);
1993 if((error != OMX_ErrorNone) && (error != OMX_ErrorInvalidState)){
1994 fprintf(stderr, "Error: VPP->WaitForState reports an error %X\n", error);
1995 goto EXIT;
1996 }
1997 free(pCompPrivateStruct); /*Free all m(allocated) resources to avoid memory leaks*/
1998
1999 printf ("VPPTEST:: App: State Of Component Is Loaded Now\n");
2000
2001 if(MyState == OMX_StateInvalid){
2002 break; /*to exit for (count_stop_load ...) */
2003 }
2004
2005 } /*end for(count_stop_load=0; count_stop_load<2; count_stop_load++)*/
2006
2007 EXIT:
2008
2009 printf ("VPPTEST:: Free the Component handle\n");
2010 error = TIOMX_FreeHandle(pHandle);
2011 if( (error != OMX_ErrorNone)) {
2012 fprintf (stderr,"Error in Free Handle function\n");
2013 goto EXIT;
2014 }
2015 fprintf (stderr,"Free Handle returned Successfully \n");
2016
2017 #ifdef DSP_MMU_FAULT_HANDLING
2018 if(bError) {
2019 LoadBaseImage();
2020 }
2021 #endif
2022
2023
2024 /* De-Initialize OMX Core */
2025 error = TIOMX_Deinit();
2026 if (error != OMX_ErrorNone) {
2027 printf("VPPTEST:: Failed to de-init OMX Core!\n");
2028 goto EXIT;
2029 }
2030
2031 if(error != OMX_ErrorNone){
2032 if(pCompPrivateStruct){
2033 free(pCompPrivateStruct);
2034 pCompPrivateStruct = NULL;
2035 }
2036 if(pInBuffer){
2037 pInBuffer -= 128;
2038 free(pInBuffer);
2039 pInBuffer = NULL;
2040 }
2041 if(pRGBBuffer){
2042 pRGBBuffer -= 128;
2043 free(pRGBBuffer);
2044 pRGBBuffer = NULL;
2045 }
2046 if(pYUVBuffer){
2047 pYUVBuffer -= 128;
2048 free(pYUVBuffer);
2049 pYUVBuffer = NULL;
2050 }
2051 }
2052 return error;
2053 }
2054
2055
2056
2057 #ifndef UNDER_CE
2058 int fill_data (OMX_BUFFERHEADERTYPE *pBuf, FILE *fIn)
2059 #else
2060 int fill_data (OMX_BUFFERHEADERTYPE *pBuf, HANDLE fIn)
2061 #endif
2062 {
2063 int nRead;
2064 static int totalRead = 0;
2065 OMX_U8 *pTmp = NULL;
2066 pTmp = pBuf->pBuffer;
2067 APP_DPRINT(" :: ------------- before File Read -------------- %p\n",pBuf);
2068 APP_DPRINT(" :: ------------- before File Read -------------- %d\n",pBuf->nAllocLen);
2069 APP_DPRINT(" :: ------------- before File Read -------------- %p\n",pBuf->pBuffer);
2070 #ifndef UNDER_CE
2071 nRead = fread(pBuf->pBuffer, 1, pBuf->nAllocLen, fIn);
2072 #else
2073 ReadFile(fIn, pBuf->pBuffer, pBuf->nAllocLen, &nRead, NULL);
2074 #endif
2075 APP_DPRINT("\n%d :: ------------- App File Read --------------\n",__LINE__);
2076 APP_DPRINT ("App: Read %d bytes from file\n", nRead);
2077 APP_DPRINT ("App: pBuf->nAllocLen = %ld\n",pBuf->nAllocLen);
2078 APP_DPRINT("%d :: ------------- App File Read --------------\n\n",__LINE__);
2079
2080 pBuf->nFilledLen = nRead;
2081 totalRead += nRead;
2082 return nRead;
2083 }
2084
2085
2086
2087 static OMX_ERRORTYPE VPP_SetZoom(OMX_HANDLETYPE pHandle, int speed, int factor, int limit, int xoff, int yoff)
2088 {
2089 int nZoomSpeed = speed;
2090 int nZoomFactor = factor<<10;
2091 int nZoomLimit = limit<<10;
2092 int nXoff = xoff<<4;
2093 int nYoff=yoff<<4;
2094
2095 OMX_ERRORTYPE error = OMX_ErrorNone;
2096
2097 error = OMX_SetConfig (pHandle, MyVPPCustomDef.VPPCustomSetZoomFactor, &nZoomFactor);
2098 if(error != OMX_ErrorNone){
2099 fprintf(stderr,"Error configuring Zoom Factor\n");
2100 return error;
2101 }
2102 error = OMX_SetConfig (pHandle,MyVPPCustomDef.VPPCustomSetZoomSpeed,&nZoomSpeed);
2103 if(error != OMX_ErrorNone){
2104 fprintf(stderr,"Error configuring Zoom Factor\n");
2105 return error;
2106 }
2107
2108 error = OMX_SetConfig (pHandle,MyVPPCustomDef.VPPCustomSetZoomLimit,&nZoomLimit);
2109 if(error != OMX_ErrorNone){
2110 fprintf(stderr,"Error configuring Zoom Limit/n");
2111 return error;
2112 }
2113 error = OMX_SetConfig(pHandle,MyVPPCustomDef.VPPCustomSetZoomXoffsetFromCenter16,&nXoff);
2114 if(error != OMX_ErrorNone){
2115 fprintf(stderr,"Error Configuring Horizontal Zoom Offset\n.");
2116 return error;
2117 }
2118 error = OMX_SetConfig(pHandle,MyVPPCustomDef.VPPCustomSetZoomYoffsetFromCenter16,&nYoff);
2119 if(error != OMX_ErrorNone){
2120 fprintf(stderr,"Error Configuring Vertical Zoom Offset");
2121 return error;
2122 }
2123
2124 return error;
2125 }
2126
2127
2128
2129 static OMX_ERRORTYPE VPP_SetContrast(OMX_HANDLETYPE pHandle, int Contrast)
2130 {
2131 OMX_ERRORTYPE error = OMX_ErrorNone;
2132 OMX_CONFIG_CONTRASTTYPE *pConfigNewContrast = malloc(sizeof(OMX_CONFIG_CONTRASTTYPE));
2133 if(pConfigNewContrast == NULL){
2134 error = OMX_ErrorInsufficientResources;
2135 goto EXIT;
2136 }
2137 memset(pConfigNewContrast,0,sizeof(OMX_CONFIG_CONTRASTTYPE));
2138 pConfigNewContrast->nContrast = Contrast;
2139 error=OMX_SetConfig(pHandle,OMX_IndexConfigCommonContrast,pConfigNewContrast);
2140 if(error != OMX_ErrorNone){
2141 printf("VPPTEST:: VPPTest Error at %d\n",__LINE__);
2142 error = OMX_ErrorBadParameter;
2143 goto EXIT;
2144 }
2145
2146 EXIT:
2147 if ( error != OMX_ErrorNone){
2148 if(pConfigNewContrast){
2149 free(pConfigNewContrast);
2150 pConfigNewContrast = NULL;
2151 }
2152 }
2153 return error;
2154 }
2155
2156
2157
2158 static OMX_ERRORTYPE VPP_FrostedGlassEffect(OMX_HANDLETYPE pHandle, int IsOverlay)
2159 {
2160 OMX_ERRORTYPE error = OMX_ErrorNone;
2161
2162 if(IsOverlay){
2163 int FrostedGlassEffect=1;
2164 error=OMX_SetConfig(pHandle,MyVPPCustomDef.VPPCustomSetFrostedGlassOvly,&FrostedGlassEffect);
2165 if(error != OMX_ErrorNone){
2166 printf("VPPTEST:: VPPTest Error at %d\n",__LINE__);
2167 error = OMX_ErrorBadParameter;
2168 return error;
2169 }
2170 }
2171 else{
2172 printf("VPPTEST:: Frosted Glass Effect is only upon overlayed images.\n");
2173 error=OMX_ErrorBadParameter;
2174 }
2175 return error;
2176 }
2177
2178
2179
2180 static OMX_ERRORTYPE VPP_SetCrop(OMX_HANDLETYPE pHandle, int XStart, int XSize, int YStart, int YSize)
2181 {
2182 OMX_ERRORTYPE error = OMX_ErrorNone;
2183 OMX_CONFIG_RECTTYPE *pConfigNewCropWindow = malloc (sizeof(OMX_CONFIG_RECTTYPE));
2184 if(pConfigNewCropWindow == NULL){
2185 error = OMX_ErrorInsufficientResources;
2186 goto EXIT;
2187 }
2188 memset(pConfigNewCropWindow, 0, sizeof(OMX_CONFIG_RECTTYPE));
2189 pConfigNewCropWindow->nLeft = XStart;
2190 pConfigNewCropWindow->nTop = YStart;
2191 pConfigNewCropWindow->nWidth = XSize;
2192 pConfigNewCropWindow->nHeight = YSize;
2193 error = OMX_SetConfig (pHandle, OMX_IndexConfigCommonInputCrop, pConfigNewCropWindow);
2194 if (error != OMX_ErrorNone) {
2195 printf("VPPTest Error at %d\n",__LINE__);
2196 error = OMX_ErrorBadParameter;
2197 goto EXIT;
2198 }
2199
2200 EXIT:
2201 if(error != OMX_ErrorNone){
2202 free(pConfigNewCropWindow);
2203 pConfigNewCropWindow = NULL;
2204 }
2205 return error;
2206 }
2207
2208 static OMX_ERRORTYPE VPP_SetMirroring(OMX_HANDLETYPE pHandle, int IsRGBOutput)
2209 {
2210 OMX_ERRORTYPE error = OMX_ErrorNone;
2211 OMX_CONFIG_MIRRORTYPE * pConfigNewMirror = NULL;
2212 if(IsRGBOutput){
2213 pConfigNewMirror = malloc(sizeof(OMX_CONFIG_MIRRORTYPE));
2214 if(pConfigNewMirror == NULL){
2215 error = OMX_ErrorInsufficientResources;
2216 goto EXIT;
2217 }
2218 memset(pConfigNewMirror,0,sizeof(OMX_CONFIG_MIRRORTYPE));
2219 pConfigNewMirror->nPortIndex = MyVppPortDef.rgboutput_port;
2220 pConfigNewMirror->eMirror = OMX_MirrorHorizontal;
2221 error=OMX_SetConfig(pHandle,OMX_IndexConfigCommonMirror,pConfigNewMirror);
2222 if(error != OMX_ErrorNone){
2223 printf("VPPTest Error at %d\n",__LINE__);
2224 error = OMX_ErrorBadParameter;
2225 goto EXIT;
2226 }
2227 }
2228 else{
2229 printf("VPPTEST:: Need to use RGB as Output, Mirror Setting unchanged.\n");
2230 error=OMX_ErrorBadParameter;
2231 goto EXIT;
2232 }
2233 EXIT:
2234
2235 if(pConfigNewMirror){
2236 free(pConfigNewMirror);
2237 pConfigNewMirror = NULL;
2238 }
2239 return error;
2240 }
2241
2242 static OMX_ERRORTYPE VPP_SetRotationAngle(OMX_HANDLETYPE pHandle, int IsRGBOutput,int Angle)
2243 {
2244 OMX_ERRORTYPE error = OMX_ErrorNone;
2245 OMX_CONFIG_ROTATIONTYPE *pConfigNewRotation = malloc(sizeof(OMX_CONFIG_ROTATIONTYPE));
2246 if(pConfigNewRotation == NULL){
2247 error = OMX_ErrorInsufficientResources;
2248 goto EXIT;
2249 }
2250 memset(pConfigNewRotation,0,sizeof(OMX_CONFIG_ROTATIONTYPE));
2251 if(Angle == 0 || Angle == 90 || Angle ==180 || Angle ==270){
2252 pConfigNewRotation->nRotation = Angle;
2253 }
2254 else{
2255 printf("VPPTEST:: Not a valid Rotation Angle, Working with Default Rotation Angle\n");
2256 goto EXIT;
2257 }
2258
2259 switch(IsRGBOutput){
2260 case 0: /*YUV output only*/
2261 pConfigNewRotation->nPortIndex = MyVppPortDef.yuvoutput_port;
2262 error=OMX_SetConfig(pHandle,OMX_IndexConfigCommonRotate,pConfigNewRotation);
2263 if(error != OMX_ErrorNone){
2264 printf("VPPTest Error at %d\n",__LINE__);
2265 error = OMX_ErrorBadParameter;
2266 goto EXIT;
2267 }
2268 break;
2269 case 1: /*RGB output only*/
2270 pConfigNewRotation->nPortIndex = MyVppPortDef.rgboutput_port;
2271 error=OMX_SetConfig(pHandle,OMX_IndexConfigCommonRotate,pConfigNewRotation);
2272 if(error != OMX_ErrorNone){
2273 printf("VPPTest Error at %d\n",__LINE__);
2274 error = OMX_ErrorBadParameter;
2275 goto EXIT;
2276 }
2277 case 2: /*Simultaneous outputs*/
2278 pConfigNewRotation->nPortIndex = MyVppPortDef.rgboutput_port;
2279 error=OMX_SetConfig(pHandle,OMX_IndexConfigCommonRotate,pConfigNewRotation);
2280 if(error != OMX_ErrorNone){
2281 printf("VPPTest Error at %d\n",__LINE__);
2282 error = OMX_ErrorBadParameter;
2283 goto EXIT;
2284 }
2285 pConfigNewRotation->nPortIndex = MyVppPortDef.yuvoutput_port;
2286 error=OMX_SetConfig(pHandle,OMX_IndexConfigCommonRotate,pConfigNewRotation);
2287 if(error != OMX_ErrorNone){
2288 printf("VPPTest Error at %d\n",__LINE__);
2289 error = OMX_ErrorBadParameter;
2290 goto EXIT;
2291 }
2292 break;
2293 default:
2294 break;
2295 }
2296 EXIT:
2297 if(pConfigNewRotation){
2298 free(pConfigNewRotation);
2299 pConfigNewRotation = NULL;
2300 }
2301 return error;
2302
2303 }
2304
2305
2306
2307 static OMX_ERRORTYPE VPP_SetDithering(OMX_HANDLETYPE pHandle, int IsRGBOutput)
2308 {
2309 OMX_ERRORTYPE error = OMX_ErrorNone;
2310 OMX_CONFIG_DITHERTYPE * pConfigNewDither = NULL;
2311
2312 if(IsRGBOutput){
2313 pConfigNewDither = malloc(sizeof(OMX_CONFIG_DITHERTYPE));
2314 if(pConfigNewDither == NULL){
2315 error = OMX_ErrorInsufficientResources;
2316 goto EXIT;
2317 }
2318 memset(pConfigNewDither,0,sizeof(OMX_CONFIG_DITHERTYPE));
2319 pConfigNewDither->nPortIndex = MyVppPortDef.rgboutput_port;
2320 pConfigNewDither->eDither = OMX_DitherErrorDiffusion;
2321 error=OMX_SetConfig(pHandle,OMX_IndexConfigCommonDithering,pConfigNewDither);
2322 if(error != OMX_ErrorNone){
2323 printf("VPPTest Error at %d\n",__LINE__);
2324 error = OMX_ErrorBadParameter;
2325 goto EXIT;
2326 }
2327 }
2328 else{
2329 printf("VPPTEST:: Need to use RGB as Output, Dithering not possible.\n");
2330 error=OMX_ErrorBadParameter;
2331 goto EXIT;
2332 }
2333
2334 EXIT:
2335
2336 if(pConfigNewDither){
2337 free(pConfigNewDither);
2338 pConfigNewDither = NULL;
2339 }
2340 return error;
2341 }
2342
2343 static OMX_ERRORTYPE VPP_SetColorRange(OMX_HANDLETYPE pHandle, int nColorRange)
2344 {
2345 OMX_ERRORTYPE error = OMX_ErrorNone;
2346
2347 if(nColorRange<0 || nColorRange>3){
2348 printf("VPPTEST:: Not a valid option in Color Range Conversion\n");
2349 error = OMX_ErrorBadParameter;
2350 return error;
2351 }
2352
2353 error=OMX_SetConfig(pHandle, MyVPPCustomDef.VPPCustomSetColorRange, &nColorRange);
2354 if(error != OMX_ErrorNone){
2355 printf("VPPTest Error at %d\n",__LINE__);
2356 error = OMX_ErrorBadParameter;
2357 return error;
2358 }
2359
2360
2361 return error;
2362 }
2363
2364 OMX_BOOL VPP_Test_Check_Frames(int YUVRGB, int inFrames, int OvlyFrames,int outRGBFrames,int outYUVFrames)
2365 {
2366 if(YUVRGB==0){
2367 if(outYUVFrames < (inFrames-1) || outYUVFrames < (OvlyFrames-1))
2368 {
2369 return OMX_TRUE;
2370 }
2371 else{
2372 return OMX_FALSE;
2373 }
2374 }
2375 else if(YUVRGB==1){
2376 if(outRGBFrames < (inFrames-1) || outRGBFrames < (OvlyFrames-1)){
2377 return OMX_TRUE;
2378 }
2379 else{
2380 return OMX_FALSE;
2381 }
2382 }
2383 else{
2384 if( (outRGBFrames < (inFrames-1) || outRGBFrames < (OvlyFrames-1)) ||
2385 (outYUVFrames < (inFrames-1) || outYUVFrames < (OvlyFrames-1))){
2386 return OMX_TRUE;
2387 }
2388 else{
2389 return OMX_FALSE;
2390 }
2391 }
2392 }
2393
2394 #ifdef DSP_MMU_FAULT_HANDLING
2395
2396 int LoadBaseImage() {
2397 unsigned int uProcId = 0; /* default proc ID is 0. */
2398 unsigned int index = 0;
2399
2400 struct DSP_PROCESSORINFO dspInfo;
2401 DSP_HPROCESSOR hProc;
2402 DSP_STATUS status = DSP_SOK;
2403 unsigned int numProcs;
2404 char* argv[2];
2405
2406 argv[0] = "/lib/dsp/baseimage.dof";
2407
2408 status = (DBAPI)DspManager_Open(0, NULL);
2409 if (DSP_FAILED(status)) {
2410 printf("DSPManager_Open failed \n");
2411 return -1;
2412 }
2413 while (DSP_SUCCEEDED(DSPManager_EnumProcessorInfo(index,&dspInfo,
2414 (unsigned int)sizeof(struct DSP_PROCESSORINFO),&numProcs))) {
2415 if ((dspInfo.uProcessorType == DSPTYPE_55) ||
2416 (dspInfo.uProcessorType == DSPTYPE_64)) {
2417 uProcId = index;
2418 status = DSP_SOK;
2419 break;
2420 }
2421 index++;
2422 }
2423 status = DSPProcessor_Attach(uProcId, NULL, &hProc);
2424 if (DSP_SUCCEEDED(status)) {
2425 status = DSPProcessor_Stop(hProc);
2426 if (DSP_SUCCEEDED(status)) {
2427 status = DSPProcessor_Load(hProc,1,(const char **)argv,NULL);
2428 if (DSP_SUCCEEDED(status)) {
2429 status = DSPProcessor_Start(hProc);
2430 if (DSP_SUCCEEDED(status)) {
2431 }
2432 else {
2433 }
2434 }
2435 else {
2436 }
2437 DSPProcessor_Detach(hProc);
2438 }
2439 else {
2440 }
2441 }
2442 else {
2443 }
2444 fprintf(stderr,"Baseimage Loaded\n");
2445
2446 return 0;
2447 }
2448 #endif
2449
2450
2451