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/* ====================================================================
18*             Texas Instruments OMAP(TM) Platform Software
19* (c) Copyright Texas Instruments, Incorporated. All Rights Reserved.
20*
21* Use of this software is controlled by the terms and conditions found
22* in the license agreement under which this software has been supplied.
23* ==================================================================== */
24#ifdef UNDER_CE
25#include <windows.h>
26#else
27#include <sys/stat.h>
28#include <sys/time.h>
29#endif
30#include <stdio.h>
31#include <stdlib.h>
32#include <stdarg.h>
33#include <string.h>
34#include <sched.h>
35#include <unistd.h>
36#include <sys/types.h>
37#include <sys/select.h>
38#include <time.h>
39#include <OMX_Component.h>
40#include "JPEGTest.h"
41
42/* DSP recovery includes */
43#include <qosregistry.h>
44#include <qosti.h>
45#include <dbapi.h>
46#include <DSPManager.h>
47#include <DSPProcessor.h>
48#include <DSPProcessor_OEM.h>
49
50#ifdef UNDER_CE
51#define PRINT printf
52#else
53/*#define OMX_DEB*/
54#ifdef OMX_DEB
55#define PRINT(str,args...) fprintf(stdout,"[%s] %s():%d: *** "str"",__FILE__,__FUNCTION__,__LINE__,##args)
56#else
57#define PRINT(str, args...)
58#endif
59#endif
60
61typedef unsigned char uchar;
62/**
63 * Pipe used to communicate back to the main thread from the component thread;
64**/
65
66int IpBuf_Pipe[2];
67int OpBuf_Pipe[2];
68int Event_Pipe[2];
69struct timeval tim;
70int DEINIT_FLAG = 0;
71int bPreempted=0;
72
73
74/* safe routine to get the maximum of 2 integers */
75
76inline int maxint(int a, int b)
77{
78    return(a>b) ? a : b;
79}
80
81
82 /*Define prototypes*/
83
84#ifdef DSP_MMU_FAULT_HANDLING
85int LoadBaseImage();
86#endif
87
88 static OMX_ERRORTYPE WaitForEvent_JPEG(OMX_HANDLETYPE* pHandle,
89                                  OMX_EVENTTYPE DesiredEvent,
90                                  OMX_U32 data,
91                                  OMX_STATETYPE DesiredState);
92
93
94static int Get16m(const void * Short)
95{
96    return(((uchar *)Short)[0] << 8) | ((uchar *)Short)[1];
97}
98
99void  FixFrameSize ( IMAGE_INFO* imageinfo)
100{
101
102    int nWidth=imageinfo->nWidth, nHeight=imageinfo->nHeight;
103
104    /*round up if nWidth is not multiple of 32*/
105    ( (nWidth%32 ) !=0 ) ?  nWidth=32 * (  (  nWidth/32 ) + 1 )  : nWidth;
106    PRINT("411 file new nWidth %d \n", nWidth);
107
108    /*round up if nHeight is not multiple of 16*/
109    ( (nHeight%16) !=0 ) ?  nHeight=16 * (  (  nHeight/16 ) + 1 )  : nHeight;
110    PRINT("new nHeight %d \n", nHeight);
111
112    imageinfo->nWidth = nWidth;
113    imageinfo->nHeight = nHeight;
114}
115
116
117int GetYUVformat(uchar * Data)
118{
119    unsigned char Nf;
120    int j;
121     int temp_index;
122     int temp;
123     int image_format;
124    short           H[4],V[4];
125
126     Nf = Data[7];
127
128
129    for (j = 0; j < Nf; j++)
130    {
131       temp_index = j * 3 + 7 + 2;
132        /*---------------------------------------------------------*/
133       /* H[j]: upper 4 bits of a byte, horizontal sampling fator.                  */
134       /* V[j]: lower 4 bits of a byte, vertical sampling factor.                    */
135       /*---------------------------------------------------------*/
136         H[j] = (0x0f & (Data[temp_index] >> 4));
137         V[j] = (0x0f & Data[temp_index]);
138    }
139
140    /*------------------------------------------------------------------*/
141    /* Set grayscale flag, namely if image is gray then set it to 1,    */
142    /* else set it to 0.                                                */
143    /*------------------------------------------------------------------*/
144    image_format = -1;
145
146
147    if (Nf == 1){
148      image_format = OMX_COLOR_FormatL8;
149    }
150
151
152    if (Nf == 3)
153    {
154       temp = (V[0]*H[0])/(V[1]*H[1]) ;
155
156      if (temp == 4 && H[0] == 2)
157        image_format = OMX_COLOR_FormatYUV420PackedPlanar;
158
159      if (temp == 4 && H[0] == 4)
160        image_format = OMX_COLOR_FormatYUV411Planar;
161
162      if (temp == 2)
163        image_format = OMX_COLOR_FormatCbYCrY; /* YUV422 interleaved, little endian */
164
165      if (temp == 1)
166        image_format = OMX_COLOR_FormatYUV444Interleaved;
167    }
168
169    return (image_format);
170
171}
172
173/*--------------------------------------------------------------------------
174* Parse the marker stream until SOS or EOI is seen;
175* ------------------------------------------------------------------------*/
176
177#ifdef UNDER_CE
178int ReadJpegSections (HANDLE infile,
179                      IMAGE_INFO* imageinfo)
180#else
181int ReadJpegSections (FILE * infile,
182                      IMAGE_INFO* imageinfo)
183#endif
184{
185    int a = 0;
186    long lSize = 0;
187#ifdef UNDER_CE
188    int got = 0;
189    int b = 0;
190    lSize = GetFileSize(infile, NULL );
191    SetFilePointer(infile, 0, NULL, FILE_BEGIN);
192#else
193    fseek (infile , 0 , SEEK_END);
194    lSize = ftell (infile);
195    rewind (infile);
196#endif
197
198    PRINT ("Size is %d \n", (int)lSize);
199    imageinfo->nProgressive = 0; /*Default value is non progressive*/
200
201
202#ifdef UNDER_CE
203    ReadFile(infile, &a, 1, &got, NULL);
204#else
205    a = fgetc(infile);
206#endif
207
208#ifdef UNDER_CE
209    ReadFile(infile, &b, 1, &got, NULL);
210    if ( a != 0xff || b != M_SOI )  {
211#else
212    if ( a != 0xff || fgetc(infile) != M_SOI )  {
213#endif
214        return 0;
215    }
216    for ( ;; )  {
217        int itemlen = 0;
218        int marker = 0;
219        int ll = 0,lh = 0, got = 0;
220        uchar * Data = NULL;
221
222        for ( a=0;a<7;a++ ) {
223#ifdef UNDER_CE
224            ReadFile(infile, &marker, 1, &got, NULL);
225#else
226            marker = fgetc(infile);
227#endif
228            PRINT("MARKER IS %x\n",marker);
229
230            if ( marker != 0xff )   {
231                break;
232            }
233            if ( a >= 6 )   {
234                PRINT("too many padding bytes\n");
235                if ( Data != NULL ) {
236                    free(Data);
237                    Data=NULL;
238                }
239                return 0;
240            }
241        }
242        if ( marker == 0xff )   {
243            /* 0xff is legal padding, but if we get that many, something's wrong.*/
244            PRINT("too many padding bytes!");
245        }
246
247        /* Read the length of the section.*/
248#ifdef UNDER_CE
249        ReadFile(infile, &lh, 1, &got, NULL);
250        ReadFile(infile, &ll, 1, &got, NULL);
251#else
252        lh = fgetc(infile);
253        ll = fgetc(infile);
254#endif
255
256        itemlen = (lh << 8) | ll;
257
258        if ( itemlen < 2 )  {
259            PRINT("invalid marker");
260        }
261
262        Data = (uchar *)malloc(itemlen);
263        if ( Data == NULL ) {
264            PRINT("Could not allocate memory");
265        }
266
267        /* Store first two pre-read bytes. */
268        Data[0] = (uchar)lh;
269        Data[1] = (uchar)ll;
270
271#ifdef UNDER_CE
272        ReadFile(infile, Data+2, itemlen-2, &got, NULL);
273#else
274        got = fread(Data+2, 1, itemlen-2, infile); /* Read the whole section.*/
275#endif
276        if ( got != itemlen-2 ) {
277            PRINT("Premature end of file?");
278        }
279
280        PRINT("Jpeg section marker 0x%02x size %d\n",marker, itemlen);
281        switch ( marker )   {
282
283        case M_SOS:
284            if ( Data != NULL ) {
285                free(Data);
286                Data=NULL;
287            }
288
289            return lSize;
290
291        case M_EOI:
292            PRINT("No image in jpeg!\n");
293            if ( Data != NULL ) {
294                free(Data);
295                Data=NULL;
296            }
297            return 0;
298
299        case M_COM: /* Comment section  */
300
301            break;
302
303        case M_JFIF:
304
305            break;
306
307        case M_EXIF:
308
309            break;
310
311        case M_SOF2:
312            PRINT("nProgressive IMAGE!\n");
313            imageinfo->nProgressive=1;
314
315        case M_SOF0:
316        case M_SOF1:
317        case M_SOF3:
318        case M_SOF5:
319        case M_SOF6:
320        case M_SOF7:
321        case M_SOF9:
322        case M_SOF10:
323        case M_SOF11:
324        case M_SOF13:
325        case M_SOF14:
326        case M_SOF15:
327
328            imageinfo->nHeight = Get16m(Data+3);
329            imageinfo->nWidth = Get16m(Data+5);
330            imageinfo->format = GetYUVformat(Data);
331            switch (imageinfo->format) {
332            case OMX_COLOR_FormatYUV420PackedPlanar:
333                printf("APP:: Image chroma format is OMX_COLOR_FormatYUV420PackedPlanar\n");
334                break;
335            case OMX_COLOR_FormatYUV411Planar:
336                printf("APP:: Image chroma format is OMX_COLOR_FormatYUV411Planar\n");
337                break;
338            case OMX_COLOR_FormatCbYCrY:
339                printf("APP:: Image chroma format is OMX_COLOR_FormatYUV422Interleaved\n");
340                break;
341            case OMX_COLOR_FormatYUV444Interleaved:
342                 printf("APP:: Image chroma format is OMX_COLOR_FormatYUV444Interleaved\n");
343                 break;
344            case OMX_COLOR_FormatL8:
345                printf("APP:: Image chroma format is OMX_COLOR_FormatL8 \n");
346                break;
347            default:
348                 printf("APP:: Cannot find Image chroma format \n");
349                 imageinfo->format = OMX_COLOR_FormatUnused;
350                 break;
351            }
352            printf("APP:: Image Width x Height = %u * %u\n", Get16m(Data+5), Get16m(Data+3)  );
353            /*
354            PRINT("JPEG image is %uw * %uh,\n", Get16m(Data+3), Get16m(Data+5)  );
355
356            if ( *(Data+9)==0x41 )  {
357                PRINT("THIS IS A YUV 411 ENCODED IMAGE \n" );
358                imageinfo->format= 1;
359            }
360            */
361
362            if ( Data != NULL ) {
363                free(Data);
364                Data=NULL;
365            }
366            break;
367        default:
368            /* Skip any other sections.*/
369            break;
370        }
371
372        if ( Data != NULL ) {
373            free(Data);
374            Data=NULL;
375        }
376    }
377
378
379    return 0;
380}
381
382
383
384OMX_ERRORTYPE EventHandler(OMX_HANDLETYPE hComponent,
385                                               OMX_PTR pAppData,
386                                               OMX_EVENTTYPE eEvent,
387                                    OMX_U32 nData1,
388                                               OMX_U32 data2,
389                                               OMX_PTR pEventData)
390{
391    JPEGD_EVENTPRIVATE MyEvent;
392
393    MyEvent.eEvent = eEvent;
394    MyEvent.nData1 = nData1;
395    MyEvent.nData2 = data2;
396    MyEvent.pAppData = pAppData;
397    MyEvent.pEventInfo = pEventData;
398
399    PRINT("eEvent = %x, nData1 = %x\n\n", eEvent, (unsigned int)nData1);
400
401    switch ( eEvent ) {
402        case OMX_EventCmdComplete:
403            PRINT ("Component State Changed To %ld\n", data2);
404            break;
405
406        case OMX_EventError:
407            if ( nData1 != OMX_ErrorNone ){
408                printf ("APP:: ErrorNotification received: Error Num %x,\tSeverity = %ld\n", (unsigned int)nData1, data2);
409                if ((nData1 == OMX_ErrorHardware) || (nData1 == OMX_ErrorInsufficientResources)){
410                    printf("\nAPP:: OMX_ErrorHardware. Deinitialization of the component....\n\n");
411                    break;
412                }
413                else if(nData1 == OMX_ErrorResourcesPreempted) {
414                    bPreempted = 1;
415                    PRINT("APP:: OMX_ErrorResourcesPreempted !\n\n");
416                }
417                else if(nData1 == OMX_ErrorInvalidState){
418                    return OMX_ErrorNone;
419                }
420                else if(nData1 == OMX_ErrorTimeout){
421                    return OMX_ErrorNone;
422                }
423                else {
424                    DEINIT_FLAG = 1;
425                }
426            }
427            break;
428
429        case OMX_EventResourcesAcquired:
430            bPreempted = 0;
431            break;
432        case OMX_EventBufferFlag:
433            printf("APP:: OMX_EventBufferFlag received\n");
434            break;
435        case OMX_EventPortSettingsChanged:
436        case OMX_EventMax:
437        case OMX_EventMark:
438            break;
439
440        default:
441            break;
442    }
443
444    write(Event_Pipe[1], &MyEvent, sizeof(JPEGD_EVENTPRIVATE));
445
446    return OMX_ErrorNone;
447}
448
449
450
451void FillBufferDone (OMX_HANDLETYPE hComponent,
452                     OMX_PTR ptr,
453                     OMX_BUFFERHEADERTYPE* pBuffHead)
454{
455    PRINT("OutBufHeader %p, pBuffer = %p\n", pBuffHead, pBuffHead->pBuffer);
456    write(OpBuf_Pipe[1], &pBuffHead, sizeof(pBuffHead));
457    /*	if (eError == -1) {
458       PRINT ("Error while writing in OpBuf_pipe from app\n");
459
460    }*/
461
462}
463
464
465
466
467void EmptyBufferDone(OMX_HANDLETYPE hComponent,
468                     OMX_PTR ptr,
469                     OMX_BUFFERHEADERTYPE* pBuffer)
470{
471    write(IpBuf_Pipe[1], &pBuffer, sizeof(pBuffer));
472    /*	if (eError == -1) {
473    	PRINT ("Error while writing in IpBuf_pipe from EmptyBufferDone\n");
474    }*/
475}
476
477
478
479#ifdef UNDER_CE
480int fill_data (OMX_BUFFERHEADERTYPE *pBuf,
481               HANDLE fIn, long lBuffUsed)
482#else
483int fill_data (OMX_BUFFERHEADERTYPE *pBuf,
484               FILE *fIn, int lBuffUsed)
485#endif
486{
487    int nRead;
488
489    PRINT(" checking buf address %x\n", (unsigned int)pBuf->pBuffer);
490
491#ifdef UNDER_CE
492    lSize = GetFileSize(fIn, NULL );
493    SetFilePointer(fIn, 0, NULL, FILE_BEGIN);
494#else
495    //fseek (fIn , 0 , SEEK_END);
496    //lSize = ftell (fIn);
497    //rewind (fIn);
498#endif
499
500#ifdef UNDER_CE
501    ReadFile(fIn, pBuf->pBuffer, lBuffUsed, &nRead, NULL);
502#else
503    nRead = fread(pBuf->pBuffer,1, lBuffUsed, fIn);
504#endif
505
506    PRINT ("printing lsize %d \n", (int) lBuffUsed);
507    PRINT( "Read %d bytes from file\n", nRead);
508
509    pBuf->nFilledLen = nRead;
510    return nRead;
511}
512/* This method will wait for the component to get to the event
513 * specified by the DesiredEvent input. */
514static OMX_ERRORTYPE WaitForEvent_JPEG(OMX_HANDLETYPE* pHandle,
515                                  OMX_EVENTTYPE DesiredEvent,
516                                  OMX_U32 nFDmax,
517                                  OMX_STATETYPE DesiredState)
518{
519    OMX_ERRORTYPE error = OMX_ErrorNone;
520    OMX_STATETYPE CurrentState;
521    OMX_COMPONENTTYPE *pComponent = (OMX_COMPONENTTYPE *)pHandle;
522    int nRetval;
523    sigset_t set;
524
525    while(1) {
526
527        error = pComponent->GetState(pHandle, &CurrentState);
528        if(error || CurrentState == DesiredState) {
529            break;
530        }
531
532        fd_set rfds;
533        FD_ZERO(&rfds);
534        FD_SET(Event_Pipe[0], &rfds);
535        sigemptyset(&set);
536        sigaddset(&set,SIGALRM);
537
538        nRetval = pselect(nFDmax+1, &rfds, NULL, NULL, NULL, &set);
539
540        if ( nRetval == -1 ) {
541#ifndef UNDER_CE
542            perror("select()");
543#endif
544            fprintf (stderr, " : Error \n");
545            break;
546        }
547
548        if ( nRetval == 0 ) {
549            PRINT("Waiting: Desired Event = %x, Desired State = %x \n",DesiredEvent, DesiredState);
550        }
551
552        if ( FD_ISSET(Event_Pipe[0], &rfds)) {
553
554            JPEGD_EVENTPRIVATE EventPrivate;
555            read(Event_Pipe[0], &EventPrivate, sizeof(JPEGD_EVENTPRIVATE));
556
557            if (EventPrivate.eEvent == DesiredEvent &&
558                EventPrivate.nData1 == OMX_CommandStateSet &&
559                EventPrivate.nData2 == DesiredState) {
560                PRINT("OMX_EventCmdComplete :: nData2 = %x\n", (unsigned int)EventPrivate.nData2);
561                break;
562            }
563            else if (EventPrivate.eEvent == OMX_EventError &&
564                EventPrivate.nData1 == OMX_ErrorInsufficientResources &&
565                DesiredState == OMX_StateIdle) {
566                printf("\n\n Received OMX_EventError: Error = 0x%x,\tSeverity = %ld\n\n", (unsigned int)EventPrivate.nData1, EventPrivate.nData2);
567                error = OMX_ErrorInsufficientResources;
568                break;
569            }
570            else if (EventPrivate.eEvent == OMX_EventError &&
571                EventPrivate.nData1 == OMX_ErrorResourcesLost &&
572                DesiredState == OMX_StateLoaded) {
573                printf("\n\n Received OMX_EventError: Error = 0x%x,\tSeverity = %ld\n\n", (unsigned int)EventPrivate.nData1, EventPrivate.nData2);
574                break;
575            }
576        }
577
578    }
579
580    PRINT("Exit from Wait For Event function JPEGD\n");
581    return error;
582}
583
584
585
586#ifdef UNDER_CE
587int _tmain(int argc, TCHAR **argv)
588#else
589int main(int argc, char** argv)
590#endif
591{
592
593    OMX_HANDLETYPE pHandle = NULL;
594    OMX_U32 AppData = 100;
595    OMX_CALLBACKTYPE JPEGCaBa = {   (void *)EventHandler,
596                                                            (void*) EmptyBufferDone,
597                                                            (void*)FillBufferDone};
598
599    OMX_ERRORTYPE eError = OMX_ErrorNone;
600    OMX_BOOL bError = OMX_FALSE;
601    int nRetval;
602    int nWidth;
603    int nHeight;
604    /*int nFramesent= 0;*/
605    long lBuffused;
606    int nOutformat;
607    int nResizeMode;
608    int nIndex1;
609    int nIndex2;
610    OMX_U32 nMCURow = 0;
611    OMX_U32 nXOrg = 0;         /*Sectional decoding: X origin*/
612    OMX_U32 nYOrg = 0;         /*Sectional decoding: Y origin*/
613    OMX_U32 nXLength = 0;      /*Sectional decoding: X lenght*/
614    OMX_U32 nYLength = 0;    /*Sectional decoding: Y lenght*/
615    OMX_U32 i = 0;      /*Temporary counter*/
616
617    IMAGE_INFO* imageinfo = NULL;
618    OMX_PORT_PARAM_TYPE* pPortParamType = NULL;
619    OMX_PARAM_PORTDEFINITIONTYPE* pParamPortDef = NULL;
620    OMX_PARAM_PORTDEFINITIONTYPE* pInPortDef = NULL;
621    OMX_PARAM_PORTDEFINITIONTYPE* pOutPortDef = NULL;
622    OMX_CONFIG_SCALEFACTORTYPE* pScaleFactor = NULL;
623    OMX_PORT_PARAM_TYPE* pPortType = NULL;
624    OMX_CUSTOM_IMAGE_DECODE_SECTION* pSectionDecode = NULL;
625    OMX_CUSTOM_IMAGE_DECODE_SUBREGION* pSubRegionDecode = NULL;
626	OMX_CUSTOM_RESOLUTION *pMaxResolution = NULL;
627
628#ifdef UNDER_CE
629    TCHAR* szInFile = NULL;
630    TCHAR* szOutFile = NULL;
631    HANDLE fIn = NULL;
632    HANDLE fOut = NULL;
633    DWORD dwWritten;
634#else
635    char* szInFile = NULL;
636    char* szOutFile = NULL;
637    FILE* fIn = NULL;
638    FILE* fOut = NULL;
639#endif
640
641    int nFramesDecoded = 0;
642    double t1 = 0;
643    double t2 = 0;
644    /*int nCountstarted = 0;*/
645    OMX_S32 nPostProcCompId = 200;
646    /*int nDone = 0;*/
647    int nExternal= 0;
648    OMX_U8 * pTemp;
649    OMX_BUFFERHEADERTYPE* pInBuffHead[NUM_OF_BUFFERS];
650    OMX_BUFFERHEADERTYPE* pOutBuffHead[NUM_OF_BUFFERS];
651    OMX_U8* pInBuffer = NULL;
652    OMX_U8* pOutBuffer = NULL;
653    int nFdmax;
654    int nRead;
655    OMX_INDEXTYPE nCustomIndex = OMX_IndexMax;
656    OMX_U16 nBufferHdrSend = 0;
657    OMX_U16 nSampleFactor = 32;
658    OMX_U8 nNUM_OF_DECODING_BUFFERS = 1;
659    sigset_t set;
660    OMX_BOOL bWaitForLoaded = OMX_FALSE;
661    int  nMaxFrames = 1;
662    OMX_BUFFERHEADERTYPE* pInBufferHdr;
663    struct timeval tv1, tv2;
664
665    /* validate command line args */
666    if ( (argc < 5) || ((argc > 7) && (argc < 11)) ||(argc > 11)) {
667#ifdef UNDER_CE
668        printf("usage: %S <input.jpg> <output.yuv> <nOutformat-1:420 4:422 9:RGB16 10: RGB24 11:RGB32 12:BGR32> <nResizeMode> <nRepeat> <nSections> <nXOrigin> <nYOrigin> <nXLenght> <nYLenght>\n",
669        argv[0]);
670#else
671        printf("usage: %s <input.jpg> <output.yuv> <nOutformat-1:Original(default)  4:422 9:RGB16 10: RGB24 11:RGB32 12:BGR32> <nResizeMode> <nRepeat> <nSections> <nXOrigin> <nYOrigin> <nXLenght> <nYLenght>\n",
672        argv[0]);
673#endif
674        printf("nResizeMode 100:No Rescaling\nnResizeMode 50:Rescale to 50 percent of original size \n");
675        printf("nResizeMode 25:Rescale to 25 percent of original size\nnResizeMode 12:Rescale to 12.5 percent of original size\n\n");
676        printf("Example ./JpegTestCommon patterns/shrek.jpg shrek.yuv 1 50 \n");
677        printf("Input: 720x480. Output: YUV420, 360x240\n\n");
678        printf("nRepeat: It is an optional parameter. Range is 0 to 100. Repeatedly encode the same frame 'nRepeat+1' times");
679        printf("Example ./JpegTestCommon patterns/shrek.jpg shrek.yuv 1 50 0\n");
680        printf("Example ./JpegTestCommon patterns/shrek.jpg shrek.yuv 1 50 9\n");
681        printf("Output: YUV420, 360x240\n\n");
682        printf("<nSections> It's an optional parameter. Values: 0, 1, 2, ...\n");
683        printf("Example ./JpegTestCommon patterns/shrek.jpg shrek.yuv 4 50 0 1\n");
684        printf("Output: YUV422, 360x240\n\n");
685        printf("SubRegion decode:\n");
686        printf("<nXOrigin> <nYOrigin> <nXLenght> <nYLenght>\n");
687        printf("Example ./JpegTestCommon patterns/shrek.jpg shrek.yuv 1 100 0 0 192 48 288 256\n");
688        printf("Output: YUV420, 288x256\n\n");
689        return -1;
690    }
691
692
693    szInFile = argv[1];
694    szOutFile = argv[2];
695#ifdef UNDER_CE
696    nOutformat = _wtoi(argv[3]);
697    nResizeMode = _wtoi(argv[4]);
698#else
699    nOutformat = atoi(argv[3]);
700    nResizeMode = atoi(argv[4]);
701#endif
702
703    if (argc >= 6){
704        nMaxFrames = atoi(argv[5]) + 1;
705    }
706
707    if(argc >= 7){
708        nMCURow = atoi(argv[6]);
709        if(nOutformat >= 9){
710            printf("\nAPP: WARNING Sectional decoding is not supported for RGB color formats\n\n");
711            nMCURow = 0;
712        }
713        if(nMCURow){
714            nNUM_OF_DECODING_BUFFERS = NUM_OF_BUFFERS;
715        }
716        else{
717            nNUM_OF_DECODING_BUFFERS = 1;
718        }
719    }
720
721    if(argc > 7){
722        nXOrg = atoi(argv[7]);
723        nYOrg = atoi(argv[8]);
724        nXLength = atoi(argv[9]);
725        nYLength = atoi(argv[10]);
726    }
727
728    imageinfo = (IMAGE_INFO *)malloc (sizeof (IMAGE_INFO ) );
729    pPortParamType = (OMX_PORT_PARAM_TYPE*)malloc(sizeof(OMX_PORT_PARAM_TYPE));
730    pParamPortDef = (OMX_PARAM_PORTDEFINITIONTYPE*)malloc(sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
731    pInPortDef = (OMX_PARAM_PORTDEFINITIONTYPE*)malloc(sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
732    pOutPortDef = (OMX_PARAM_PORTDEFINITIONTYPE*)malloc(sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
733    pScaleFactor = (OMX_CONFIG_SCALEFACTORTYPE*)malloc(sizeof(OMX_CONFIG_SCALEFACTORTYPE));
734    pPortType = (OMX_PORT_PARAM_TYPE*)malloc(sizeof(OMX_PORT_PARAM_TYPE));
735    pSectionDecode = (OMX_CUSTOM_IMAGE_DECODE_SECTION*)malloc(sizeof(OMX_CUSTOM_IMAGE_DECODE_SECTION));
736    pSubRegionDecode = (OMX_CUSTOM_IMAGE_DECODE_SUBREGION*)malloc(sizeof(OMX_CUSTOM_IMAGE_DECODE_SUBREGION));
737	pMaxResolution = (OMX_CUSTOM_RESOLUTION *)malloc(sizeof(OMX_CUSTOM_RESOLUTION ));
738
739
740    printf("\n------------------------------------------------\n");
741    printf("OMX JPEG Decoder Test App built on " __DATE__ ":" __TIME__ "\n");
742    printf("------------------------------------------------\n");
743    printf("\nAPP:: Output File Name is %s \n", szOutFile);
744
745    /* Create a pipe used to queue data from the callback. */
746    nRetval = pipe(IpBuf_Pipe);
747    PRINT("Pipe InBuf_Pipe just created\n");
748    if ( nRetval != 0 )	{
749        fprintf(stderr, "Error:Fill Data Pipe failed to open\n");
750        goto EXIT;
751    }
752
753    PRINT("Pipe OpBuf_Pipe just created\n");
754    nRetval = pipe(OpBuf_Pipe);
755    if ( nRetval != 0 ) {
756        fprintf(stderr, "Error:Empty Data Pipe failed to open\n");
757        goto EXIT;
758    }
759
760    PRINT("Pipe Event_Pipe just created\n");
761    nRetval = pipe(Event_Pipe);
762    if ( nRetval != 0 ) {
763        fprintf(stderr, "Error:Empty Data Pipe failed to open\n");
764        goto EXIT;
765    }
766
767    /* save off the "max" of the handles for the selct statement */
768    nFdmax = maxint(IpBuf_Pipe[0], OpBuf_Pipe[0]);
769    nFdmax = maxint(Event_Pipe[0], nFdmax);
770
771#ifdef DSP_MMU_FAULT_HANDLING
772    /* LOAD BASE IMAGE FIRST TIME */
773    LoadBaseImage();
774#endif
775
776    eError = TIOMX_Init();
777    if ( eError != OMX_ErrorNone ) {
778        PRINT("%d :: Error returned by TIOMX_Init()\n",__LINE__);
779        goto EXIT;
780    }
781
782    /*--------------------------------------------------------------------------------
783    *
784    * Open the file of data to be rendered.  Since this is a just sample
785    * application, the data is "rendered" to a test mixer.  So, the test
786    * file better contain data that can be printed to the terminal w/o
787    * problems or you will not be a happy [JPEGTest.c] fill_data():473: *** Read 997386 bytes from file
788    **/
789    PRINT("Opening input & output file\n");
790#ifdef UNDER_CE
791    fOut = CreateFile(szOutFile, GENERIC_WRITE, 0,
792    NULL,CREATE_ALWAYS, 0, NULL);
793    if (INVALID_HANDLE_VALUE == fOut)
794    {
795        PRINT("Error:  failed to create the output file %S\n",
796        szOutFile);
797        goto EXIT;
798    }
799
800    fIn = CreateFile(szInFile, GENERIC_READ, 0,
801    NULL,OPEN_EXISTING, 0, NULL);
802    if (INVALID_HANDLE_VALUE == fIn) {
803        PRINT("Error:  failed to open the file %s for readonly\n" \
804        "access\n", szInFile);
805        goto EXIT;
806    }
807
808#else
809
810    fIn = fopen(szInFile, "r");
811    if ( fIn == NULL ) {
812        printf("\nError: failed to open the file <%s> for reading\n",
813        szInFile);
814        goto EXIT;
815    }
816    PRINT("APP:: File %s opened \n" , szInFile);
817#endif
818
819    lBuffused = ReadJpegSections(fIn , imageinfo);
820
821    if (lBuffused == 0) {
822        printf("The file size is 0. Maybe the format of the file is not correct\n");
823        goto EXIT;
824    }
825
826    /* Load the JPEGDecoder Component */
827
828    PRINT("Calling TIOMX_GetHandle\n");
829    eError = TIOMX_GetHandle(&pHandle,StrJpegDecoder, (void *)&AppData, &JPEGCaBa);
830    if ( (eError != OMX_ErrorNone) ||  (pHandle == NULL) ) {
831        fprintf (stderr,"Error in Get Handle function\n");
832        goto EXIT;
833    }
834
835    eError = OMX_GetParameter(pHandle, OMX_IndexParamImageInit, pPortType);
836    if ( eError != OMX_ErrorNone ) {
837        goto EXIT;
838    }
839
840
841    nIndex1 = pPortType->nStartPortNumber;
842    nIndex2 = nIndex1 + 1;
843    nHeight = imageinfo->nHeight;
844    nWidth = imageinfo->nWidth;
845
846    FixFrameSize(imageinfo);
847
848    pScaleFactor->xWidth = (int)nResizeMode;
849    pScaleFactor->xHeight = (int)nResizeMode;
850
851    eError = OMX_SetConfig (pHandle, OMX_IndexConfigCommonScale, pScaleFactor);
852    if ( eError != OMX_ErrorNone ) {
853        goto EXIT;
854    }
855
856    eError = OMX_GetParameter (pHandle, OMX_IndexParamPortDefinition, pInPortDef);
857    if ( eError != OMX_ErrorNone ) {
858        eError = OMX_ErrorBadParameter;
859        goto EXIT;
860    }
861
862    if (pInPortDef->eDir == nIndex1 ) {
863        pInPortDef->nPortIndex = nIndex1;
864    }
865    else {
866        pInPortDef->nPortIndex = nIndex2;
867    }
868
869    /* Set the component's OMX_PARAM_PORTDEFINITIONTYPE structure (input) */
870    /**********************************************************************/
871
872    pInPortDef->nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
873    pInPortDef->nVersion.s.nVersionMajor = 0x1;
874    pInPortDef->nVersion.s.nVersionMinor = 0x0;
875    pInPortDef->nVersion.s.nRevision = 0x0;
876    pInPortDef->nVersion.s.nStep = 0x0;
877    pInPortDef->nPortIndex = 0x0;
878    pInPortDef->eDir = OMX_DirInput;
879    pInPortDef->nBufferCountActual =1;
880    pInPortDef->nBufferCountMin = 1;
881    pInPortDef->bEnabled = OMX_TRUE;
882    pInPortDef->bPopulated = OMX_FALSE;
883    pInPortDef->eDomain = OMX_PortDomainImage;
884    pInPortDef->format.image.cMIMEType = "JPEGDEC";
885    pInPortDef->format.image.pNativeRender = NULL;
886    pInPortDef->format.image.nFrameWidth = imageinfo->nWidth;
887    pInPortDef->format.image.nFrameHeight = imageinfo->nHeight;
888    pInPortDef->format.image.nStride = -1;
889    pInPortDef->format.image.nSliceHeight = -1;
890    pInPortDef->format.image.bFlagErrorConcealment = OMX_FALSE;
891    pInPortDef->format.image.eColorFormat =OMX_COLOR_FormatCbYCrY ;
892    pInPortDef->format.image.eCompressionFormat = OMX_IMAGE_CodingJPEG;
893    pInPortDef->nBufferSize = lBuffused;
894
895
896    if (imageinfo->format == OMX_COLOR_FormatYCbYCr ||
897        imageinfo->format == OMX_COLOR_FormatYUV444Interleaved ||
898        imageinfo->format == OMX_COLOR_FormatUnused) {
899        pInPortDef->format.image.eColorFormat = OMX_COLOR_FormatCbYCrY;
900    }
901    else {
902        pInPortDef->format.image.eColorFormat = OMX_COLOR_FormatYUV420PackedPlanar;
903    }
904
905    PRINT("Calling OMX_SetParameter\n");
906
907	/* Set max width & height value*/
908    eError = OMX_GetExtensionIndex(pHandle, "OMX.TI.JPEG.decoder.Param.SetMaxResolution", (OMX_INDEXTYPE*)&nCustomIndex);
909    if ( eError != OMX_ErrorNone ) {
910        printf ("JPEGDec test:: %d:error= %x\n", __LINE__, eError);
911        goto EXIT;
912    }
913
914	pMaxResolution->nWidth = imageinfo->nWidth;
915	pMaxResolution->nHeight = imageinfo->nHeight;
916
917	eError = OMX_SetParameter (pHandle, nCustomIndex, pMaxResolution);
918    if ( eError != OMX_ErrorNone ) {
919        printf ("JPEGDec test:: %d:error= %x\n", __LINE__, eError);
920        goto EXIT;
921    }
922
923    eError = OMX_SetParameter (pHandle, OMX_IndexParamPortDefinition, pInPortDef);
924    if ( eError != OMX_ErrorNone ) {
925        eError = OMX_ErrorBadParameter;
926        goto EXIT;
927    }
928
929    memset(pOutPortDef, 0x0, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
930    eError = OMX_GetParameter (pHandle, OMX_IndexParamPortDefinition, pOutPortDef);
931    if ( eError != OMX_ErrorNone ) {
932        eError = OMX_ErrorBadParameter;
933        goto EXIT;
934    }
935
936    if (pOutPortDef->eDir == nIndex1 ) {
937        pOutPortDef->nPortIndex = nIndex1;
938    }
939    else {
940        pOutPortDef->nPortIndex = nIndex2;
941    }
942
943    /*****************************************************************/
944    /* Set the component's OMX_PARAM_PORTDEFINITIONTYPE structure (Output) */
945    /**********************************************************************/
946    pOutPortDef->nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
947    pOutPortDef->nVersion.s.nVersionMajor = 0x1;
948    pOutPortDef->nVersion.s.nVersionMinor = 0x0;
949    pOutPortDef->nVersion.s.nRevision = 0x0;
950    pOutPortDef->nVersion.s.nStep = 0x0;
951    pOutPortDef->nPortIndex = 0x1;
952    pOutPortDef->eDir = OMX_DirOutput;
953    pOutPortDef->nBufferCountActual = nNUM_OF_DECODING_BUFFERS;
954    pOutPortDef->nBufferCountMin = 1;
955    pOutPortDef->bEnabled = OMX_TRUE;
956    pOutPortDef->bPopulated = OMX_FALSE;
957    pOutPortDef->eDomain = OMX_PortDomainImage;
958
959    /* OMX_IMAGE_PORTDEFINITION values for Output port */
960    pOutPortDef->format.image.cMIMEType = "JPEGDEC";
961    pOutPortDef->format.image.pNativeRender = NULL;
962    pOutPortDef->format.image.nFrameWidth = imageinfo->nWidth;
963    pOutPortDef->format.image.nFrameHeight = imageinfo->nHeight;
964    pOutPortDef->format.image.nStride = -1;
965    pOutPortDef->format.image.nSliceHeight = -1;
966    pOutPortDef->format.image.bFlagErrorConcealment = OMX_FALSE;
967    pOutPortDef->format.image.eCompressionFormat = OMX_IMAGE_CodingUnused;
968
969    PRINT("nWidth and nHeight = %d and %d\n",nWidth,nHeight);
970    if ( nOutformat == 4 ) {
971        pOutPortDef->format.image.eColorFormat = OMX_COLOR_FormatCbYCrY;
972    }
973    else if (nOutformat == 9) {
974        pOutPortDef->format.image.eColorFormat = OMX_COLOR_Format16bitRGB565;
975        PRINT("color format is %d\n", pOutPortDef->format.image.eColorFormat);
976    }
977    else if (nOutformat == 10) {
978        pOutPortDef->format.image.eColorFormat = OMX_COLOR_Format24bitRGB888;
979    }
980    else if (nOutformat == 11) {
981        pOutPortDef->format.image.eColorFormat = OMX_COLOR_Format32bitARGB8888;
982    }
983    else if (nOutformat == 12) {
984        pOutPortDef->format.image.eColorFormat = OMX_COLOR_Format32bitBGRA8888;
985    }
986    else { /*Set DEFAULT (original) color format*/
987        pOutPortDef->format.image.eColorFormat = imageinfo->format; /*Setting input original format */
988
989        if(imageinfo->format == OMX_COLOR_Format16bitRGB565 ||
990                imageinfo->format == OMX_COLOR_Format24bitRGB888 ||
991                imageinfo->format == OMX_COLOR_Format32bitARGB8888 ||
992                imageinfo->format == OMX_COLOR_Format32bitBGRA8888 ||
993                imageinfo->format == OMX_COLOR_FormatL8){
994            for(i = 0; i < strlen(szOutFile); i++){
995                if(szOutFile[i]=='.'){
996                    if(szOutFile[i+1]=='y'){
997                        szOutFile[i+1]='r';
998                        szOutFile[i+2]='a';
999                        szOutFile[i+3]='w';
1000                        szOutFile[i+4]='\0';
1001                        printf("\n\nAPP::--WARNING:\nIncorrect output file extension. Changing output file name extension--\n");
1002                        printf("APP:: New file name: %s\n\n\n", szOutFile);
1003                        break;
1004                    }
1005                    break;
1006                }
1007            }
1008        }
1009    }
1010
1011    fOut = fopen(szOutFile, "w");
1012    if ( fOut == NULL ) {
1013        printf("\nError: failed to open the file <%s> for writing", szOutFile);
1014        goto EXIT;
1015    }
1016
1017    if(nResizeMode == 800){
1018        nWidth *= 8;
1019        nHeight *= 8;
1020    }
1021    else if(nResizeMode == 400){
1022        nWidth *= 4;
1023        nHeight *= 4;
1024    }
1025    else if(nResizeMode == 200){
1026        nWidth *= 2;
1027        nHeight *= 2;
1028    }
1029    else if (nResizeMode == 50) {
1030        nWidth /= 2;
1031        nHeight /= 2;
1032    } else if (nResizeMode == 25) {
1033        nWidth /= 4;
1034        nHeight /= 4;
1035    } else if (nResizeMode == 12) {
1036        nWidth /= 4;
1037        nHeight /= 4;
1038    }
1039
1040    if(nMCURow == 0){ /*Full frame decoding*/
1041        if ( nOutformat == 1 ) { /* Buffer size depends on the Original color format*/
1042            if (imageinfo->format == OMX_COLOR_FormatYUV420PackedPlanar ||
1043                imageinfo->format == OMX_COLOR_FormatYUV411Planar) {
1044                pOutPortDef->nBufferSize = ( int )((( nWidth * nHeight) *3 ) /2);
1045                }
1046            else if (imageinfo->format == OMX_COLOR_FormatCbYCrY) {
1047                pOutPortDef->nBufferSize =  ( int ) ((nWidth * nHeight) *2);
1048            }
1049            else if (imageinfo->format == OMX_COLOR_FormatYUV444Interleaved) {
1050                    pOutPortDef->nBufferSize =  ( int ) ((nWidth * nHeight) *3);
1051            }
1052            else {
1053                pOutPortDef->nBufferSize = ( int ) (nWidth * nHeight) * 2;
1054            }
1055        }
1056        else if (nOutformat == 4 || nOutformat == 9) {        /* OMX_COLOR_FormatCbYCrY & OMX_COLOR_Format16bitRGB565*/
1057            pOutPortDef->nBufferSize =  (int)((nWidth * nHeight) * 2);
1058        }
1059        else if (nOutformat == 10) { /* OMX_COLOR_Format24bitRGB888 */
1060           pOutPortDef->nBufferSize = (int) ((nWidth * nHeight) * 3);
1061        }
1062        else if (nOutformat == 11 || nOutformat == 12) { /* OMX_COLOR_Format32bitARGB8888 & OMX_COLOR_Format32bitBGRA8888*/
1063           pOutPortDef->nBufferSize = (int) ((nWidth * nHeight) * 4);
1064        }
1065        else {
1066            eError = OMX_ErrorBadParameter;
1067            goto EXIT;
1068        }
1069    }
1070    else{ /*Slice Decoding*/
1071        switch(imageinfo->format){
1072            case OMX_COLOR_FormatYUV420PackedPlanar:
1073                nSampleFactor = 16;
1074                break;
1075            case OMX_COLOR_FormatYUV411Planar:
1076            case OMX_COLOR_FormatCbYCrY:
1077            case OMX_COLOR_FormatYUV444Interleaved:
1078                nSampleFactor = 8;
1079                break;
1080            default:
1081                nSampleFactor = 8;
1082                break;
1083        }
1084
1085
1086        if(nResizeMode == 12){ /* setting to 13 instead of 12.5 */
1087            nResizeMode = 13;
1088        }
1089
1090        if ( nOutformat == 1 ) { /* Buffer size depends on the Original color format*/
1091            if (imageinfo->format == OMX_COLOR_FormatYUV420PackedPlanar ||
1092                    imageinfo->format == OMX_COLOR_FormatYUV411Planar) {
1093                pOutPortDef->nBufferSize = (OMX_U32)(((nWidth*3)/2)*(nSampleFactor*nMCURow*nResizeMode)/100);
1094
1095            }
1096            else if (imageinfo->format == OMX_COLOR_FormatCbYCrY){
1097                    pOutPortDef->nBufferSize =  (OMX_U32) ( (nWidth * 2) * (nSampleFactor * nMCURow*nResizeMode)/100);
1098            }
1099            else if (imageinfo->format == OMX_COLOR_FormatYUV444Interleaved) {
1100                pOutPortDef->nBufferSize =  (OMX_U32) ( (nWidth * 3) * (nSampleFactor * nMCURow*nResizeMode)/100);
1101            }
1102            else{
1103                pOutPortDef->nBufferSize =  (OMX_U32) ( (nWidth) * (nSampleFactor * nMCURow*nResizeMode)/100);
1104            }
1105        }
1106        else if(nOutformat == 4){ /*YUV422 ILE */
1107            pOutPortDef->nBufferSize = (OMX_U32)((nWidth * 2) * (nSampleFactor * nMCURow * nResizeMode)/100);
1108        }
1109    }
1110
1111    printf("APP:: Output buffer size is %ld\n", pOutPortDef->nBufferSize);
1112    printf("APP:: Output color format is ");
1113    if (nOutformat == 4){
1114        printf("OMX_COLOR_FormatCbYCrY (YUV422ILE)\n");
1115    }
1116    else if (nOutformat == 9){
1117        printf("OMX_COLOR_Format16bitRGB565 (RGB16)\n");
1118    }
1119    else if (nOutformat == 10){
1120        printf("OMX_COLOR_Format24bitRGB888 (BGR24)\n");
1121    }
1122    else if (nOutformat == 11){
1123        printf("OMX_COLOR_Format32bitARGB8888 (ARGB32)\n");
1124	}
1125    else if (nOutformat == 12){
1126        printf("OMX_COLOR_Format32bitBGRA8888 (BGRA32)\n");
1127    }
1128    else{
1129         if (imageinfo->format == OMX_COLOR_FormatYUV420PackedPlanar){
1130            printf("OMX_COLOR_FormatYUV420PackedPlanar\n");
1131         }
1132         else if (imageinfo->format == OMX_COLOR_FormatYUV411Planar) {
1133            printf("OMX_COLOR_FormatYUV411Planar\n");
1134        }
1135        else if (imageinfo->format == OMX_COLOR_FormatCbYCrY){
1136                printf("OMX_COLOR_FormatCbYCrY (YUV422ILE)\n");
1137        }
1138        else if (imageinfo->format == OMX_COLOR_FormatYUV444Interleaved) {
1139            printf("OMX_COLOR_FormatYUV444Interleaved\n");
1140        }
1141        else if (imageinfo->format == OMX_COLOR_FormatL8){
1142            printf("OMX_COLOR_FormatL8 (Gray 8)\n");
1143        }
1144        else{
1145            printf("Unknow format\n");
1146        }
1147    }
1148
1149    eError = OMX_SetParameter (pHandle, OMX_IndexParamPortDefinition, pOutPortDef);
1150    if ( eError != OMX_ErrorNone ) {
1151        eError = OMX_ErrorBadParameter;
1152        goto EXIT;
1153    }
1154
1155    eError = OMX_GetExtensionIndex(pHandle, "OMX.TI.JPEG.decoder.Config.ProgressiveFactor", (OMX_INDEXTYPE*)&nCustomIndex);
1156    if ( eError != OMX_ErrorNone ) {
1157        printf ("JPEGDec test:: %d:error= %x\n", __LINE__, eError);
1158        goto EXIT;
1159    }
1160    eError = OMX_SetConfig (pHandle, nCustomIndex, &(imageinfo->nProgressive));
1161    if ( eError != OMX_ErrorNone ) {
1162        printf ("JPEGDec test:: %d:error= %x\n", __LINE__, eError);
1163        goto EXIT;
1164    }
1165
1166    eError = OMX_GetExtensionIndex(pHandle, "OMX.TI.JPEG.decoder.Config.OutputColorFormat", (OMX_INDEXTYPE*)&nCustomIndex);
1167    if ( eError != OMX_ErrorNone ) {
1168        printf ("JPEGDec test:: %d:error= %x\n", __LINE__, eError);
1169        goto EXIT;
1170    }
1171
1172    eError = OMX_SetConfig (pHandle, nCustomIndex, &(pOutPortDef->format.image.eColorFormat));
1173    if ( eError != OMX_ErrorNone ) {
1174        printf ("JPEGDec test:: %d:error= %x\n", __LINE__, eError);
1175        goto EXIT;
1176    }
1177
1178    if(nMCURow){
1179        eError = OMX_GetExtensionIndex(pHandle, "OMX.TI.JPEG.decoder.Param.SectionDecode", (OMX_INDEXTYPE*)&nCustomIndex);
1180        if ( eError != OMX_ErrorNone ) {
1181            printf ("JPEGDec test:: %d:error= %x\n", __LINE__, eError);
1182            goto EXIT;
1183        }
1184        eError = OMX_GetParameter(pHandle, nCustomIndex, pSectionDecode);
1185        if ( eError != OMX_ErrorNone ) {
1186            printf ("JPEGDec test:: %d:error= %x\n", __LINE__, eError);
1187            goto EXIT;
1188        }
1189        pSectionDecode->nMCURow = nMCURow; /*number of slices*/
1190        pSectionDecode->bSectionsInput = OMX_FALSE; /*Should be false at input port. Unsupported slice dec at input port at the moment*/
1191        pSectionDecode->bSectionsOutput = OMX_TRUE; /*Should be true if slice at output port*/
1192        eError = OMX_SetParameter(pHandle, nCustomIndex, pSectionDecode);
1193        if ( eError != OMX_ErrorNone ) {
1194            printf ("JPEGDec test:: %d:error= %x\n", __LINE__, eError);
1195            goto EXIT;
1196        }
1197    }
1198
1199    if(nXOrg || nYOrg || nXLength || nYLength){
1200        eError = OMX_GetExtensionIndex(pHandle, "OMX.TI.JPEG.decoder.Param.SubRegionDecode", (OMX_INDEXTYPE*)&nCustomIndex);
1201        if ( eError != OMX_ErrorNone ) {
1202            printf ("JPEGDec test:: %d:error= %x\n", __LINE__, eError);
1203            goto EXIT;
1204        }
1205
1206        eError = OMX_GetParameter(pHandle, nCustomIndex, pSubRegionDecode);
1207        if ( eError != OMX_ErrorNone ) {
1208            printf ("JPEGDec test:: %d:error= %x\n", __LINE__, eError);
1209            goto EXIT;
1210        }
1211
1212        pSubRegionDecode->nXOrg = nXOrg;
1213        pSubRegionDecode->nYOrg = nYOrg;
1214        pSubRegionDecode->nXLength = nXLength;
1215        pSubRegionDecode->nYLength = nYLength;
1216        eError = OMX_SetParameter(pHandle, nCustomIndex, pSubRegionDecode);
1217        if ( eError != OMX_ErrorNone ) {
1218            printf ("JPEGDec test:: %d:error= %x\n", __LINE__, eError);
1219            goto EXIT;
1220        }
1221        PRINT("pSubRegionDecode set\n");
1222    }
1223
1224    /********* EXTERNAL BUFFER ****************/
1225
1226    if ( nExternal == 1 ) {
1227        pTemp=(OMX_U8*)malloc(pInPortDef->nBufferSize+256);
1228        pTemp+=128;
1229        pInBuffer = pTemp;
1230        pTemp=(OMX_U8*)malloc(pOutPortDef->nBufferSize+256);
1231        pTemp+=128;
1232        pOutBuffer = pTemp;
1233
1234        eError = OMX_UseBuffer(pHandle, &pInBuffHead[0], nIndex1, pInBuffHead, pInPortDef->nBufferSize, pInBuffer);
1235        for(nBufferHdrSend = 0; (nBufferHdrSend < nNUM_OF_DECODING_BUFFERS); nBufferHdrSend++){
1236            eError = OMX_UseBuffer(pHandle, &pOutBuffHead[nBufferHdrSend], nIndex2 , pOutBuffHead, pOutPortDef->nBufferSize, pOutBuffer);
1237        }
1238    }
1239    else {
1240
1241        OMX_AllocateBuffer(pHandle, &pInBuffHead[0], nIndex1, (void *)&nPostProcCompId, pInPortDef->nBufferSize);
1242
1243        for(nBufferHdrSend = 0; (nBufferHdrSend < nNUM_OF_DECODING_BUFFERS); nBufferHdrSend++){
1244            OMX_AllocateBuffer(pHandle, &pOutBuffHead[nBufferHdrSend], nIndex2, (void *)&nPostProcCompId, pOutPortDef->nBufferSize);
1245            PRINT("APP:: AllocateBuff Hdr = %p ; pBuffer = %p\n", pOutBuffHead[nBufferHdrSend], pOutBuffHead[nBufferHdrSend]->pBuffer);
1246       }
1247
1248    }
1249
1250    gettimeofday(&tv1, NULL);
1251    eError = OMX_SendCommand(pHandle, OMX_CommandStateSet, OMX_StateIdle ,NULL);
1252    if ( eError != OMX_ErrorNone ) {
1253        fprintf (stderr,"Error from SendCommand-Idle(Init) State function\n");
1254        goto EXIT;
1255    }
1256
1257    WaitForEvent_JPEG(pHandle, OMX_EventCmdComplete, nFdmax, OMX_StateIdle);
1258
1259    PRINT("Transitioned to IDLE State\n");
1260    /*PRINT("from loaded to idle: %ld %ld %ld %ld\n", tv1.tv_sec, tv1.tv_usec, tv2.tv_sec, tv2.tv_usec);*/
1261
1262    gettimeofday(&tv1, NULL);
1263    eError = OMX_SendCommand(pHandle,OMX_CommandStateSet, OMX_StateExecuting, NULL);
1264    if ( eError != OMX_ErrorNone ) {
1265        fprintf (stderr,"eError from SendCommand-Executing State function\n");
1266        goto EXIT;
1267    }
1268
1269    WaitForEvent_JPEG(pHandle, OMX_EventCmdComplete, nFdmax, OMX_StateExecuting);
1270    gettimeofday(&tv2, NULL);
1271
1272    PRINT("Transitioned to EXECUTE State\n");
1273    /*PRINT("from idle to exec: %ld %ld %ld %ld\n", tv1.tv_sec, tv1.tv_usec, tv2.tv_sec, tv2.tv_usec);*/
1274
1275    rewind(fIn);
1276    nRead = fill_data(pInBuffHead[0], fIn, lBuffused);
1277
1278#ifndef UNDER_CE
1279
1280    gettimeofday(&tim, NULL);
1281    t1=tim.tv_sec+(tim.tv_usec/1000000.0);
1282#endif
1283
1284    pInBuffHead[0]->nFilledLen = nRead;
1285    pInBuffHead[0]->nFlags = OMX_BUFFERFLAG_EOS;
1286
1287    OMX_EmptyThisBuffer(pHandle, pInBuffHead[0]);
1288    DEINIT_FLAG = 0;
1289
1290    if(nMCURow){
1291        for(nBufferHdrSend = 0; nBufferHdrSend < nNUM_OF_DECODING_BUFFERS; nBufferHdrSend++){
1292            OMX_FillThisBuffer(pHandle, pOutBuffHead[nBufferHdrSend]);
1293        }
1294    }
1295    else{
1296        OMX_FillThisBuffer(pHandle, pOutBuffHead[0]);
1297    }
1298
1299    /** Handle the component's requests for data until we run out of data.  Do this
1300    * in a way that will allow the UI to continue to run (if there is a UI, which
1301    * this sample application does NOT have)
1302    **/
1303
1304    PRINT("\n\n\n*******************************************\n\n\n");
1305
1306    while (DEINIT_FLAG == 0){
1307
1308        if (bPreempted){
1309            goto DEINIT2;
1310        }
1311
1312        fd_set rfds;
1313        FD_ZERO(&rfds);
1314
1315        FD_SET(IpBuf_Pipe[0], &rfds);
1316        FD_SET(OpBuf_Pipe[0], &rfds);
1317        FD_SET(Event_Pipe[0], &rfds);
1318
1319        sigemptyset(&set);
1320        sigaddset(&set,SIGALRM);
1321        nRetval = pselect(nFdmax+1, &rfds, NULL, NULL, NULL, &set);
1322        if ( nRetval == -1 ) {
1323#ifndef UNDER_CE
1324            perror("select()");
1325#endif
1326            fprintf (stderr, " : Error \n");
1327            break;
1328        }
1329
1330        /**
1331        * If FD_ISSET then there is data available in the pipe.
1332        * Read it and get the buffer data out.
1333        * Then re-fill the buffer and send it back.
1334        **/
1335        if ( FD_ISSET(Event_Pipe[0], &rfds)) {
1336
1337            JPEGD_EVENTPRIVATE EventPrivate;
1338            read(Event_Pipe[0], &EventPrivate, sizeof(JPEGD_EVENTPRIVATE));
1339            switch(EventPrivate.eEvent) {
1340
1341                case OMX_EventError:
1342                    DEINIT_FLAG = OMX_TRUE;
1343                    bError = OMX_TRUE;
1344                    printf("APP:: Waiting for OMX_StateInvalid... \n");
1345                    WaitForEvent_JPEG(pHandle, OMX_EventCmdComplete, nFdmax, OMX_StateInvalid);
1346                    printf("APP:: At Invalid state.\n");
1347                    goto EXIT;
1348                    break;
1349
1350                case OMX_EventBufferFlag:
1351                    printf("APP:: Unloading component...\n");
1352                    break;
1353
1354                default:
1355                    printf("APP:: Non-error event rise. Event -> 0x%x\n", EventPrivate.eEvent);
1356                    break;
1357            }
1358        }
1359
1360        if ( FD_ISSET(IpBuf_Pipe[0], &rfds)){
1361            read(IpBuf_Pipe[0], &pInBufferHdr, sizeof(pInBufferHdr));
1362
1363            if ( (!nMCURow) &&  (nFramesDecoded < nMaxFrames)){
1364                pInBuffHead[0]->nFilledLen = nRead;
1365                pInBuffHead[0]->nFlags = OMX_BUFFERFLAG_EOS;
1366                OMX_EmptyThisBuffer(pHandle, pInBufferHdr);
1367            }
1368        }
1369
1370        if ( FD_ISSET(OpBuf_Pipe[0], &rfds) ) {
1371            OMX_BUFFERHEADERTYPE* pBuf;
1372#ifndef UNDER_CE
1373            gettimeofday(&tim, NULL);
1374            t2=tim.tv_sec+(tim.tv_usec/1000000.0);
1375            /*	printf("\n%.6lf seconds elapsed\n", t2-t1);  */
1376#endif
1377            read(OpBuf_Pipe[0], &pBuf, sizeof(pBuf));
1378
1379            PRINT("%d ::App: Read from OpBuf_Pipe OutBufHeader %p, nFilledLen = %d\n", __LINE__, pBuf, (int)pBuf->nFilledLen);
1380
1381#ifdef UNDER_CE
1382            WriteFile(fOut, pBuf->pBuffer, pBuf->nFilledLen, &dwWritten, NULL);
1383#else
1384            fwrite(pBuf->pBuffer, 1, (int ) (int)pBuf->nFilledLen, fOut);
1385            fflush(fOut);
1386#endif
1387
1388            nFramesDecoded++;
1389            PRINT("\n\n\n*******************************************\n\n\n");
1390
1391            if (( (nMCURow) &&  (pBuf->nFlags && OMX_BUFFERFLAG_EOS)) ||
1392               ( (!nMCURow) &&  (nFramesDecoded >= nMaxFrames))){
1393                break;
1394            }
1395            PRINT("---------------------------- Output Buff FRAME %d ----------------------------\n", nFramesDecoded);
1396
1397            eError = OMX_FillThisBuffer(pHandle, pBuf);
1398            if ( eError != OMX_ErrorNone ) {
1399                printf ("Error from OMX_FillThisBuffer\n");
1400                goto EXIT;
1401            }
1402
1403            if (!nMCURow){
1404                rewind(fOut);
1405            }
1406        }
1407    }/***** End of While Loop *****/
1408
1409    if (bError == OMX_FALSE){
1410        PRINT("APP:: Sending back to Idle\n");
1411
1412        eError = OMX_SendCommand(pHandle,OMX_CommandStateSet, OMX_StateIdle, NULL);
1413        if ( eError != OMX_ErrorNone ) {
1414            fprintf (stderr,"Error from SendCommand-Idle(nStop) State function\n");
1415            goto EXIT;
1416        }
1417    }
1418DEINIT2:
1419
1420    if (bError == OMX_FALSE){
1421        WaitForEvent_JPEG(pHandle, OMX_EventCmdComplete, nFdmax, OMX_StateIdle);
1422
1423        eError = OMX_SendCommand(pHandle,OMX_CommandStateSet, OMX_StateLoaded, NULL);
1424        if ( eError != OMX_ErrorNone ) {
1425            fprintf (stderr,"Error from SendCommand-Idle State function\n");
1426            goto EXIT;
1427        }
1428
1429        bWaitForLoaded = OMX_TRUE;
1430    }
1431//DEINIT1:
1432
1433    eError = OMX_SendCommand(pHandle, OMX_CommandPortDisable, 0x0, NULL);
1434    if ( eError != OMX_ErrorNone ) {
1435        fprintf (stderr,"APP:: Error from SendCommand-PortDisable function. Input port.\n");
1436        goto EXIT;
1437    }
1438
1439    eError = OMX_SendCommand(pHandle, OMX_CommandPortDisable, 0x1, NULL);
1440    if ( eError != OMX_ErrorNone ) {
1441        fprintf (stderr,"APP:: Error from SendCommand-PortDisable function. Output port.\n");
1442        goto EXIT;
1443    }
1444
1445    /* Free buffers */
1446    if ( nExternal==1 )
1447    {
1448        pOutBuffer-=128;
1449        pInBuffer-=128;
1450        eError = OMX_FreeBuffer(pHandle, nIndex1, pInBuffHead[0]);
1451        for(nBufferHdrSend = 0; nBufferHdrSend < nNUM_OF_DECODING_BUFFERS; nBufferHdrSend++){
1452            eError = OMX_FreeBuffer(pHandle, nIndex2, pOutBuffHead[nBufferHdrSend]);
1453        }
1454
1455        free(pOutBuffer);
1456        free(pInBuffer);
1457
1458    }
1459    else {
1460        eError = OMX_FreeBuffer(pHandle, nIndex1, pInBuffHead[0]);
1461        for (nBufferHdrSend = 0; nBufferHdrSend < nNUM_OF_DECODING_BUFFERS; nBufferHdrSend ++) {
1462            eError = OMX_FreeBuffer(pHandle, nIndex2, pOutBuffHead[nBufferHdrSend]);
1463        }
1464    }
1465
1466    if (bWaitForLoaded && (bError == OMX_FALSE)){
1467        WaitForEvent_JPEG(pHandle, OMX_EventCmdComplete, nFdmax, OMX_StateLoaded);
1468    }
1469
1470EXIT:
1471    if (pPortParamType) {
1472        free(pPortParamType);
1473        pPortParamType = NULL;
1474    }
1475    if (pParamPortDef) {
1476        free(pParamPortDef);
1477        pParamPortDef = NULL;
1478    }
1479    if (pInPortDef) {
1480        free(pInPortDef);
1481        pInPortDef = NULL;
1482    }
1483    if (pOutPortDef) {
1484        free(pOutPortDef);
1485        pOutPortDef = NULL;
1486    }
1487    if (imageinfo) {
1488        free(imageinfo);
1489        imageinfo = NULL;
1490    }
1491    if (pScaleFactor) {
1492        free(pScaleFactor);
1493        pScaleFactor = NULL;
1494    }
1495    if (pPortType) {
1496        free(pPortType);
1497        pPortType = NULL;
1498    }
1499    if(pSectionDecode){
1500        free(pSectionDecode);
1501        pSectionDecode = NULL;
1502    }
1503    if(pSubRegionDecode){
1504        free(pSubRegionDecode);
1505        pSubRegionDecode = NULL;
1506    }
1507	if(pMaxResolution) {
1508		free(pMaxResolution);
1509		pMaxResolution = NULL;
1510	}
1511
1512    if ( fOut != NULL ) {
1513        PRINT("Closing Output File\n");
1514#ifdef UNDER_CE
1515        CloseHandle(fOut);
1516#else
1517        fclose(fOut);
1518#endif
1519    }
1520
1521    if ( fIn != NULL ) {
1522        PRINT("Closing Input File\n");
1523#ifdef UNDER_CE
1524        CloseHandle(fIn);
1525#else
1526        fclose(fIn);
1527#endif
1528    }
1529
1530    if (pHandle) {
1531        eError = TIOMX_FreeHandle(pHandle);
1532        if ( (eError != OMX_ErrorNone) )	{
1533            fprintf (stderr,"Error in Free Handle function\n");
1534        }
1535    }
1536
1537#ifdef DSP_MMU_FAULT_HANDLING
1538    if(bError) {
1539        LoadBaseImage();
1540    }
1541#endif
1542
1543    eError = TIOMX_Deinit();
1544    if ( eError != OMX_ErrorNone ) {
1545        PRINT("Error returned by OMX_Init()\n");
1546        goto EXIT;
1547    }
1548
1549    return eError;
1550}
1551
1552
1553#ifdef DSP_MMU_FAULT_HANDLING
1554
1555int LoadBaseImage() {
1556    unsigned int uProcId = 0;	/* default proc ID is 0. */
1557    unsigned int index = 0;
1558
1559    struct DSP_PROCESSORINFO dspInfo;
1560    DSP_HPROCESSOR hProc;
1561    DSP_STATUS status = DSP_SOK;
1562    unsigned int numProcs;
1563    char* argv[2];
1564
1565    argv[0] = "/lib/dsp/baseimage.dof";
1566
1567    status = (DBAPI)DspManager_Open(0, NULL);
1568    if (DSP_FAILED(status)) {
1569        printf("DSPManager_Open failed \n");
1570        return -1;
1571    }
1572    while (DSP_SUCCEEDED(DSPManager_EnumProcessorInfo(index,&dspInfo,
1573        (unsigned int)sizeof(struct DSP_PROCESSORINFO),&numProcs))) {
1574        if ((dspInfo.uProcessorType == DSPTYPE_55) ||
1575            (dspInfo.uProcessorType == DSPTYPE_64)) {
1576            uProcId = index;
1577            status = DSP_SOK;
1578            break;
1579        }
1580        index++;
1581    }
1582    status = DSPProcessor_Attach(uProcId, NULL, &hProc);
1583    if (DSP_SUCCEEDED(status)) {
1584        status = DSPProcessor_Stop(hProc);
1585        if (DSP_SUCCEEDED(status)) {
1586            status = DSPProcessor_Load(hProc,1,(const char **)argv,NULL);
1587            if (DSP_SUCCEEDED(status)) {
1588                status = DSPProcessor_Start(hProc);
1589                if (DSP_SUCCEEDED(status)) {
1590                }
1591                else {
1592                }
1593            }
1594			else {
1595            }
1596            DSPProcessor_Detach(hProc);
1597        }
1598        else {
1599        }
1600    }
1601    else {
1602    }
1603    fprintf(stderr,"Baseimage Loaded\n");
1604
1605    return 0;
1606}
1607#endif
1608
1609