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/**
25* @file VideoEncTest.c
26*
27* This file implements OMX Component for MPEG-4 encoder that
28* is fully compliant with the OMX specification 1.5.
29*
30* @path  $(CSLPATH)\src
31*
32* @rev  0.1
33*/
34/* -------------------------------------------------------------------------- */
35/* =============================================================================
36*!
37*! Revision History
38*! ===================================
39*!
40*! 02-Feb-2006 mf: Revisions appear in reverse chronological order;
41*! that is, newest first.  The date format is dd-Mon-yyyy.
42* =========================================================================== */
43#define _XOPEN_SOURCE 600
44
45#include <signal.h>
46#include <stdio.h>
47#include <stdlib.h>
48#include <stdarg.h>
49#include <string.h>
50#include <sched.h>
51#include <unistd.h>
52#include <sys/types.h>
53#include <sys/select.h>
54#include <time.h>
55#include <OMX_Component.h>
56#include <getopt.h>
57#include <sys/types.h>
58
59#define DSP_MMU_FAULT_HANDLING
60
61#ifdef DSP_MMU_FAULT_HANDLING
62#include <dbapi.h>
63#include <DSPManager.h>
64#include <DSPProcessor.h>
65#include <DSPProcessor_OEM.h>
66#endif
67
68/* For debug printing
69   Add -DAPP_DEBUG to CFLAGS in test Makefile */
70#define KHRONOS_1_2
71#if VIDENCTEST_DEBUG
72    #define VIDENCTEST_MAX_TIME_OUTS 1000000
73    #define __VIDENCTEST_PRINT__
74    #define __VIDENCTEST_DPRINT__
75    #define __VIDENCTEST_MTRACE__
76#else
77    #define VIDENCTEST_MAX_TIME_OUTS 1000000
78#endif
79#define VIDENCTEST_UNUSED_ARG(arg) (void)(arg)
80#if 0
81    #define VIDENCTEST_COLOR
82    #define VIDENCTEST_PRINT_PARAMS
83#endif
84
85#define VIDENCTEST_USE_DEFAULT_VALUE (OMX_U32)-1
86#define VIDENCTEST_USE_DEFAULT_VALUE_UI (unsigned int)-1
87
88#define VIDENCTEST_MALLOC(_p_, _s_, _c_, _h_)                           \
89    _p_ = (_c_*)malloc(_s_);                                            \
90    if (_p_ == NULL) {                                                  \
91        VIDENCTEST_MTRACE("malloc() error.\n");                         \
92        eError = OMX_ErrorInsufficientResources;                        \
93    }                                                                   \
94    else {                                                              \
95        VIDENCTEST_MTRACE(": %d :malloc() -> %p\n", __LINE__, _p_);     \
96        memset((_p_), 0x0, _s_);                                        \
97        if ((_p_) == NULL) {                                            \
98            VIDENCTEST_MTRACE("memset() error.\n");                     \
99            eError = OMX_ErrorUndefined;                                \
100        }                                                               \
101        else{                                                           \
102            eError = VIDENCTEST_ListAdd(_h_, _p_);                      \
103            if (eError == OMX_ErrorInsufficientResources) {             \
104                VIDENCTEST_MTRACE("malloc() error.\n");                 \
105            }                                                           \
106        }                                                               \
107    }                                                                   \
108
109
110#define VIDENCTEST_FREE(_p_, _h_)                           \
111    VIDENCTEST_ListRemove(_h_, _p_);                        \
112    _p_ = NULL;                                             \
113
114#define VIDENCTEST_CHECK_ERROR(_e_, _s_)                    \
115    if (_e_ != OMX_ErrorNone){                              \
116        printf("\n------VIDENCTEST FATAL ERROR-------\n %x : %s \n", _e_, _s_);  \
117        VIDENCTEST_HandleError(pAppData, _e_);               \
118        goto EXIT;                                          \
119    }                                                       \
120
121#define VIDENCTEST_CHECK_EXIT(_e_, _s_)                     \
122    if (_e_ != OMX_ErrorNone){                              \
123        printf("\n------VIDENCTEST ERROR-------\n %x : %s \n", _e_, _s_);  \
124        goto EXIT;                                          \
125    }
126
127#if 1
128    #define CALC_TIME
129#endif
130
131#define MAX_UNRESPONSIVE_COUNT 50
132#define NUM_OF_IN_BUFFERS 4
133#define NUM_OF_OUT_BUFFERS 4
134#define MAX_NUM_OF_PORTS 16
135#define MAX_EVENTS 256
136/*
137 *  ANSI escape sequences for outputing text in various colors
138 */
139#ifdef APP_COLOR
140    #define DBG_TEXT_WHITE   "\x1b[1;37;40m"
141    #define DBG_TEXT_YELLOW  "\x1b[1;33;40m"
142    #define DBG_TEXT_MAGENTA "\x1b[1;35;40m"
143    #define DBG_TEXT_GREEN   "\x1b[1;32;40m"
144    #define DBG_TEXT_CYAN    "\x1b[1;36;40m"
145    #define DBG_TEXT_RED     "\x1b[1;31;40m"
146#else
147    #define DBG_TEXT_WHITE ""
148    #define DBG_TEXT_YELLOW ""
149    #define DBG_TEXT_MAGENTA ""
150    #define DBG_TEXT_GREEN ""
151    #define DBG_TEXT_CYAN ""
152    #define DBG_TEXT_RED ""
153#endif
154
155#define APP_CONVERT_STATE(_s_, _p_)        \
156    if (_p_ == 0) {                        \
157        _s_ = "OMX_StateInvalid";          \
158    }                                      \
159    else if (_p_ == 1) {                   \
160        _s_ = "OMX_StateLoaded";           \
161    }                                      \
162    else if (_p_ == 2) {                   \
163        _s_ = "OMX_StateIdle";             \
164    }                                      \
165    else if (_p_ == 3) {                   \
166        _s_ = "OMX_StateExecuting";        \
167    }                                      \
168    else if (_p_ == 4) {                   \
169        _s_ = "OMX_StatePause";            \
170    }                                      \
171    else if (_p_ == 5) {                   \
172        _s_ = "OMX_StateWaitForResources"; \
173    }                                      \
174    else {                                 \
175        _s_ = "UnsupportedCommand";        \
176    }
177
178
179/*static const int iQ16_Const = 1 << 16;*/
180static const float fQ16_Const = (float)(1 << 16);
181
182/*static float Q16Tof(int nQ16)
183{
184    return nQ16 / fQ16_Const;
185}*/
186
187static int fToQ16(float f)
188{
189    return (int)(f*fQ16_Const);
190}
191
192#ifdef DSP_MMU_FAULT_HANDLING
193static int bInvalid_state;
194int LoadBaseImage();
195#endif
196
197void VIDENCTEST_Log(const char *szFileName, int iLineNum, const char *szFunctionName, const char *strFormat, ...)
198{
199    va_list list;
200    VIDENCTEST_UNUSED_ARG(szFileName);
201    VIDENCTEST_UNUSED_ARG(iLineNum);
202    fprintf(stdout, "%s():", szFunctionName);
203    va_start(list, strFormat);
204    vfprintf(stdout, strFormat, list);
205    va_end(list);
206}
207
208#ifdef __VIDENCTEST_DPRINT__
209    #define VIDENCTEST_DPRINT(STR, ARG...) VIDENCTEST_Log(__FILE__, __LINE__, __FUNCTION__, STR, ##ARG)
210#else
211    #define VIDENCTEST_DPRINT(...)
212#endif
213
214#ifdef __VIDENCTEST_MTRACE__
215    #define VIDENCTEST_MTRACE(STR, ARG...) VIDENCTEST_Log(__FILE__, __LINE__, __FUNCTION__, STR, ##ARG)
216#else
217    #define VIDENCTEST_MTRACE(...)
218#endif
219
220#ifdef __VIDENCTEST_PRINT__
221    #define VIDENCTEST_PRINT(...) fprintf(stdout, __VA_ARGS__)
222#else
223    #define VIDENCTEST_PRINT(...)
224#endif
225
226OMX_STRING StrVideoEncoder= "OMX.TI.Video.encoder";
227
228typedef enum VIDEOENC_PORT_INDEX {
229    VIDENC_INPUT_PORT = 0x0,
230    VIDENC_OUTPUT_PORT
231} VIDEOENC_PORT_INDEX;
232
233typedef enum VIDENCTEST_STATE {
234    VIDENCTEST_StateLoaded = 0x0,
235    VIDENCTEST_StateUnLoad,
236    VIDENCTEST_StateReady,
237    VIDENCTEST_StateStarting,
238    VIDENCTEST_StateEncoding,
239    VIDENCTEST_StateStopping,
240    VIDENCTEST_StateConfirm,
241    VIDENCTEST_StateWaitEvent,
242    VIDENCTEST_StatePause,
243    VIDENCTEST_StateStop,
244    VIDENCTEST_StateError
245} VIDENCTEST_STATE;
246
247typedef enum VIDENCTEST_TEST_TYPE {
248    VIDENCTEST_FullRecord = 0x0,
249    VIDENCTEST_PartialRecord,
250    VIDENCTEST_PauseResume,
251    VIDENCTEST_StopRestart
252} VIDENCTEST_TEST_TYPE;
253
254typedef enum VIDENC_TEST_NAL_FORMAT {
255    VIDENC_TEST_NAL_UNIT = 0,
256    VIDENC_TEST_NAL_SLICE,
257    VIDENC_TEST_NAL_FRAME
258}VIDENC_TEST_NAL_FORMAT;
259
260#ifndef KHRONOS_1_2
261typedef enum OMX_EXTRADATATYPE {
262    OMX_ExtraDataNone = 0,
263    OMX_ExtraDataQuantization
264} OMX_EXTRADATATYPE;
265#endif
266
267typedef struct OMX_OTHER_EXTRADATATYPE_1_1_2 {
268    OMX_U32 nSize;
269    OMX_VERSIONTYPE nVersion;
270    OMX_U32 nPortIndex;
271    OMX_EXTRADATATYPE eType;
272    OMX_U32 nDataSize;
273    OMX_U8 data[1];
274} OMX_OTHER_EXTRADATATYPE_1_1_2;
275
276typedef struct APP_TIME{
277    time_t rawTime;
278    struct tm* pTimeInfo;
279    int nHrs;
280    int nMin;
281    int nSec;
282    OMX_BOOL bInitTime;
283    int nTotalTime;
284} APP_TIME;
285
286/* Structure used for the Memory List (Link-List)*/
287typedef struct VIDENCTEST_NODE {
288    OMX_PTR pData;
289    struct VIDENCTEST_NODE* pNext;
290}VIDENCTEST_NODE;
291
292typedef struct MYBUFFER_DATA{
293    time_t rawTime;
294    struct tm* pTimeInfo;
295} MYBUFFER_DATA;
296
297typedef struct MYDATATYPE {
298    OMX_HANDLETYPE pHandle;
299    char* szInFile;
300    char* szOutFile;
301    char* szOutFileNal;
302    int nWidth;
303    int nHeight;
304    OMX_U8 eColorFormat;
305    OMX_U32 nBitrate;
306    OMX_U8 nFramerate;
307    OMX_U8 eCompressionFormat;
308    OMX_U8 eLevel;
309    OMX_U32 nOutBuffSize;
310    OMX_STATETYPE eState;
311    OMX_PORT_PARAM_TYPE* pVideoInit;
312    OMX_PARAM_PORTDEFINITIONTYPE* pPortDef[MAX_NUM_OF_PORTS];
313    OMX_PARAM_PORTDEFINITIONTYPE* pInPortDef;
314    OMX_PARAM_PORTDEFINITIONTYPE* pOutPortDef;
315    OMX_VIDEO_PARAM_AVCTYPE* pH264;
316    OMX_VIDEO_AVCLEVELTYPE eLevelH264;
317    OMX_VIDEO_PARAM_H263TYPE* pH263;
318    OMX_VIDEO_H263LEVELTYPE eLevelH63;
319    OMX_VIDEO_PARAM_MPEG4TYPE* pMpeg4;
320    OMX_VIDEO_MPEG4LEVELTYPE eLevelMpeg4;
321    int IpBuf_Pipe[2];
322    int OpBuf_Pipe[2];
323    int eventPipe[2];
324    int fdmax;
325    FILE* fIn;
326    FILE* fOut;
327    FILE* fNalnd;
328    OMX_U32 nCurrentFrameIn;
329    OMX_U32 nCurrentFrameOut;
330    OMX_S32 nRetVal;
331    OMX_CALLBACKTYPE* pCb;
332    OMX_COMPONENTTYPE* pComponent;
333    OMX_BUFFERHEADERTYPE* pInBuff[NUM_OF_IN_BUFFERS];
334    OMX_BUFFERHEADERTYPE* pOutBuff[NUM_OF_OUT_BUFFERS];
335    OMX_U8* pIBuffer[NUM_OF_IN_BUFFERS];
336    OMX_U8* pOBuffer[NUM_OF_OUT_BUFFERS];
337    OMX_VIDEO_PARAM_BITRATETYPE* pVidParamBitrate;
338    OMX_VIDEO_CONTROLRATETYPE eControlRate;
339    OMX_VIDEO_PARAM_QUANTIZATIONTYPE* pQuantization;
340    OMX_U32 nQpI;
341    OMX_BOOL bAllocateIBuf;
342    OMX_BOOL bAllocateOBuf;
343    OMX_INDEXTYPE nVideoEncodeCustomParamIndex;
344    OMX_U32 nVBVSize;
345    OMX_BOOL bDeblockFilter;
346    OMX_BOOL bForceIFrame;
347    OMX_U32 nIntraFrameInterval;
348    OMX_U32 nGOBHeaderInterval;
349    OMX_U32 nTargetFrameRate;
350    OMX_U32 nAIRRate;
351    OMX_U32 nTargetBitRate;
352    OMX_U32 nStartPortNumber;
353    OMX_U32 nPorts;
354    OMX_U8 nInBufferCount;
355    OMX_U8 nOutBufferCount;
356    void* pEventArray[MAX_EVENTS];
357    OMX_U8 nEventCount;
358    OMX_BOOL bStop;
359    OMX_BOOL bExit;
360    OMX_U32 nSizeIn;
361    OMX_U32 nSizeOut;
362
363    OMX_U32 nReferenceFrame;
364    OMX_U32 nNumberOfTimesTodo;
365    OMX_U32 nNumberOfTimesDone;
366    OMX_U32 nUnresponsiveCount;
367    VIDENCTEST_NODE*  pMemoryListHead; /* Used in Memory List (Link-List) */
368    VIDENCTEST_STATE eCurrentState;
369    VIDENCTEST_TEST_TYPE eTypeOfTest;
370    OMX_U32 nMIRRate;
371    OMX_U32 nResynchMarkerSpacing;
372    unsigned int nEncodingPreset;
373    OMX_U8 nUnrestrictedMV;
374    OMX_U8 NalFormat;
375    OMX_U8 bLastOutBuffer;
376    OMX_U32  nQPIoF;
377} MYDATATYPE;
378
379typedef struct EVENT_PRIVATE {
380    OMX_EVENTTYPE eEvent;
381    OMX_U32 nData1;
382    OMX_U32 nData2;
383    MYDATATYPE* pAppData;
384    OMX_PTR pEventData;
385} EVENT_PRIVATE;
386
387/* safe routine to get the maximum of 2 integers */
388/* inline int maxint(int a, int b) */
389int maxint(int a, int b)
390{
391    return(a>b) ? a : b;
392}
393
394/*-----------------------------------------------------------------------------*/
395/**
396  * ListCreate()
397  *
398  * Creates the List Head of the Component Memory List.
399  *
400  * @param pListHead VIDENCTEST_NODE double pointer with the List Header of the Memory List.
401  *
402  * @retval OMX_ErrorNone
403  *               OMX_ErrorInsufficientResources if the malloc fails
404  *
405  **/
406/*-----------------------------------------------------------------------------*/
407OMX_ERRORTYPE VIDENCTEST_ListCreate(struct VIDENCTEST_NODE** pListHead)
408{
409    OMX_ERRORTYPE eError = OMX_ErrorNone;
410
411    *pListHead = (VIDENCTEST_NODE*)malloc(sizeof(VIDENCTEST_NODE)); /* need to malloc!!! */
412    if (*pListHead == NULL) {
413        VIDENCTEST_DPRINT("malloc() error.\n");
414        eError = OMX_ErrorInsufficientResources;
415        goto EXIT;
416    }
417
418    VIDENCTEST_DPRINT("Create MemoryListHeader[%p]\n", *pListHead);
419    memset(*pListHead, 0x0, sizeof(VIDENCTEST_NODE));
420
421EXIT:
422    return eError;
423}
424
425/*-----------------------------------------------------------------------------*/
426/**
427  * ListAdd()
428  *
429  * Add a new node to Component Memory List
430  *
431  * @param pListHead VIDENCTEST_NODE Points List Header of the Memory List.
432  *                pData OMX_PTR points to the new allocated data.
433  * @retval OMX_ErrorNone
434  *               OMX_ErrorInsufficientResources if the malloc fails
435  *
436  **/
437/*-----------------------------------------------------------------------------*/
438
439OMX_ERRORTYPE VIDENCTEST_ListAdd(struct VIDENCTEST_NODE* pListHead, OMX_PTR pData)
440{
441    OMX_ERRORTYPE eError = OMX_ErrorNone;
442    VIDENCTEST_NODE* pTmp = NULL;
443    VIDENCTEST_NODE* pNewNode = NULL;
444
445    pNewNode = (VIDENCTEST_NODE*)malloc(sizeof(VIDENCTEST_NODE)); /* need to malloc!!! */
446    if (pNewNode == NULL) {
447        VIDENCTEST_DPRINT("malloc() error.\n");
448        eError = OMX_ErrorInsufficientResources;
449        goto EXIT;
450    }
451
452    memset(pNewNode, 0x0, sizeof(VIDENCTEST_NODE));
453    pNewNode->pData = pData;
454    pNewNode->pNext = NULL;
455    VIDENCTEST_DPRINT("Add MemoryNode[%p] -> [%p]\n", pNewNode, pNewNode->pData);
456
457    pTmp = pListHead;
458
459    while (pTmp->pNext != NULL) {
460        pTmp = pTmp->pNext;
461    }
462    pTmp->pNext = pNewNode;
463
464EXIT:
465    return eError;
466}
467
468/*-----------------------------------------------------------------------------*/
469/**
470  * ListRemove()
471  *
472  * Called inside VIDENC_FREE Macro remove  node from Component Memory List and free the memory pointed by the node.
473  *
474  * @param pListHead VIDENCTEST_NODE Points List Header of the Memory List.
475  *                pData OMX_PTR points to the new allocated data.
476  * @retval OMX_ErrorNone
477  *
478  *
479  **/
480/*-----------------------------------------------------------------------------*/
481
482OMX_ERRORTYPE VIDENCTEST_ListRemove(struct VIDENCTEST_NODE* pListHead, OMX_PTR pData)
483{
484    OMX_ERRORTYPE eError = OMX_ErrorNone;
485    VIDENCTEST_NODE* pNode = NULL;
486    VIDENCTEST_NODE* pTmp = NULL;
487
488    pNode = pListHead;
489
490    while (pNode->pNext != NULL) {
491        if (pNode->pNext->pData == pData) {
492            pTmp = pNode->pNext;
493            pNode->pNext = pTmp->pNext;
494            VIDENCTEST_DPRINT("Remove MemoryNode[%p] -> [%p]\n", pTmp, pTmp->pData);
495            free(pTmp->pData);
496            free(pTmp);
497            pTmp = NULL;
498            break;
499            /* VIDENC_ListPrint2(pListHead); */
500        }
501        pNode = pNode->pNext;
502    }
503    return eError;
504}
505
506/*-----------------------------------------------------------------------------*/
507/**
508  * ListDestroy()
509  *
510  * Called inside OMX_ComponentDeInit()  Remove all nodes and free all the memory in the Component Memory List.
511  *
512  * @param pListHead VIDENCTEST_NODE Points List Header of the Memory List.
513  *
514  * @retval OMX_ErrorNone
515  *
516  *
517  **/
518/*-----------------------------------------------------------------------------*/
519
520OMX_ERRORTYPE VIDENCTEST_ListDestroy(struct VIDENCTEST_NODE* pListHead)
521{
522    OMX_ERRORTYPE eError = OMX_ErrorNone;
523    VIDENCTEST_NODE* pTmp = NULL;
524    VIDENCTEST_NODE* pNode = NULL;
525    pNode = pListHead;
526
527    while (pNode->pNext != NULL) {
528        pTmp = pNode->pNext;
529        if (pTmp->pData != NULL) {
530            VIDENCTEST_FREE(pTmp->pData, pListHead);
531        }
532        pNode->pNext = pTmp->pNext;
533        VIDENCTEST_FREE(pTmp, pListHead);
534    }
535
536    VIDENCTEST_DPRINT("Destroy MemoryListHeader[%p]\n", pListHead);
537    free(pListHead);
538    return eError;
539}
540
541/*-----------------------------------------------------------------------------*/
542/**
543  * EventHandler(  )
544  *
545  * Called inside OMX_ComponentDeInit()  Remove all nodes and free all the memory in the Component Memory List.
546  *
547  * @param pListHead VIDENCTEST_NODE Points List Header of the Memory List.
548  *
549  * @retval OMX_ErrorNone
550  *
551  *
552  **/
553/*-----------------------------------------------------------------------------*/
554void VIDENCTEST_EventHandler(OMX_HANDLETYPE hComponent, MYDATATYPE* pAppData, OMX_EVENTTYPE eEvent, OMX_U32 nData1, OMX_U32 nData2, OMX_PTR pEventData)
555{
556    EVENT_PRIVATE* pEventPrivate = NULL;
557    OMX_ERRORTYPE eError = OMX_ErrorNone;
558    OMX_HANDLETYPE pHandle;
559    VIDENCTEST_NODE* pListHead;
560
561    pHandle= pAppData->pHandle;
562    pListHead = pAppData->pMemoryListHead;
563    VIDENCTEST_UNUSED_ARG(hComponent);
564    VIDENCTEST_MALLOC(pEventPrivate, sizeof(EVENT_PRIVATE), EVENT_PRIVATE, pListHead);
565
566    /* TODO: Optimize using a linked list */
567    pAppData->pEventArray[pAppData->nEventCount] = pEventPrivate;
568    pAppData->nEventCount++;
569    if(eError != OMX_ErrorNone)
570        VIDENCTEST_DPRINT("Erro in function VIDENCTEST_EventHandler\n");
571    else{
572    pEventPrivate->pAppData = pAppData;
573    pEventPrivate->eEvent = eEvent;
574    pEventPrivate->nData1 = nData1;
575    pEventPrivate->nData2 = nData2;
576    pEventPrivate->pEventData = pEventData;
577
578    write(pAppData->eventPipe[1], &pEventPrivate, sizeof(pEventPrivate));
579    }
580}
581
582/*-----------------------------------------------------------------------------*/
583/**
584  * FillBufferDone()
585  *
586  * Callback function when output buffer is done fill with h.264/mpeg4/h.263 data
587  *
588  * @param
589  *
590  * @retval OMX_ErrorNone
591  *
592  *
593  **/
594/*-----------------------------------------------------------------------------*/
595void VIDENCTEST_FillBufferDone(OMX_HANDLETYPE hComponent, MYDATATYPE* pAppData, OMX_BUFFERHEADERTYPE* pBuffer)
596{
597    VIDENCTEST_UNUSED_ARG(hComponent);
598    VIDENCTEST_DPRINT("FillBufferDone :: %p \n", pBuffer);
599    write(pAppData->OpBuf_Pipe[1], &pBuffer, sizeof(pBuffer));
600}
601
602/*-----------------------------------------------------------------------------*/
603/**
604  * EmptyBufferDone()
605  *
606  * Callback function when and input buffer has been encoded. Returns an Empty Buffer.
607  *
608  * @param
609  *
610  * @retval OMX_ErrorNone
611  *
612  *
613  **/
614/*-----------------------------------------------------------------------------*/
615void VIDENCTEST_EmptyBufferDone(OMX_HANDLETYPE hComponent, MYDATATYPE* pAppData, OMX_BUFFERHEADERTYPE* pBuffer)
616{
617    VIDENCTEST_UNUSED_ARG(hComponent);
618    VIDENCTEST_DPRINT("EmptyBufferDone :: %p \n", pBuffer);
619    write(pAppData->IpBuf_Pipe[1], &pBuffer, sizeof(pBuffer));
620}
621
622/*-----------------------------------------------------------------------------*/
623/**
624  * fill_data()
625  *
626  * Fill buffer with data from the input file (YUV data 420/422 little endian/ 422 big endian).
627  *
628  * @param
629  *
630  * @retval OMX_ErrorNone
631  *
632  *
633  **/
634/*-----------------------------------------------------------------------------*/
635int VIDENCTEST_fill_data(OMX_BUFFERHEADERTYPE *pBuf, FILE *fIn, int buffersize)
636{
637    int nRead = -1;
638    int nError = 0;
639
640    /* Input video frame format: YUV422 interleaved (1) or YUV420 (0) */
641    nRead = fread(pBuf->pBuffer,1, buffersize, fIn);
642    if (nRead == -1) {
643        VIDENCTEST_DPRINT("Error Reading File!\n");
644    }
645    nError = ferror(fIn);
646    if (nError != 0) {
647        VIDENCTEST_DPRINT("ERROR: reading file\n");
648    }
649    nError = feof(fIn);
650    if (nError != 0 ) {
651        VIDENCTEST_DPRINT("EOS reached...\n");
652    }
653
654    pBuf->nFilledLen = nRead;
655    if (feof(fIn)) {
656        VIDENCTEST_DPRINT("Setting OMX_BUFFERFLAGE_EOS -> %p\n", pBuf);
657        pBuf->nFlags = OMX_BUFFERFLAG_EOS;
658    }
659    return nRead;
660}
661
662/*-----------------------------------------------------------------------------*/
663/**
664  * HandleError()
665  *
666  * Function call when an error ocurrs. The function un-load and free all the resource
667  * depending the eError recieved.
668  * @param pHandle Handle of MYDATATYPE structure
669  * @param eError Error ocurred.
670 *
671  * @retval OMX_ErrorNone
672  *
673  *
674  **/
675/*-----------------------------------------------------------------------------*/
676
677OMX_ERRORTYPE VIDENCTEST_HandleError(MYDATATYPE* pAppData, OMX_ERRORTYPE eError)
678{
679    OMX_ERRORTYPE eErrorHandleError = OMX_ErrorNone;
680    OMX_HANDLETYPE pHandle = pAppData->pHandle;
681    OMX_U32 nCounter;
682    VIDENCTEST_NODE* pListHead;
683    OMX_ERRORTYPE eErr = OMX_ErrorNone;
684
685    VIDENCTEST_DPRINT ("Enters to HandleError\n");
686    pListHead = pAppData->pMemoryListHead;
687
688    switch (pAppData->eCurrentState) {
689        case VIDENCTEST_StateReady:
690        case VIDENCTEST_StateStarting:
691        case VIDENCTEST_StateEncoding:
692        case VIDENCTEST_StateStopping:
693        case VIDENCTEST_StateConfirm:
694        case VIDENCTEST_StatePause:
695        case VIDENCTEST_StateStop:
696        case VIDENCTEST_StateWaitEvent:
697         VIDENCTEST_DPRINT ("Free buffers\n");
698            if (pAppData->bAllocateOBuf == OMX_TRUE) {
699                for (nCounter = 0; nCounter < NUM_OF_OUT_BUFFERS; nCounter++) {
700                    pAppData->pOBuffer[nCounter] -= 128;
701                    pAppData->pOBuffer[nCounter] = (unsigned char*)pAppData->pOBuffer[nCounter];
702                    VIDENCTEST_FREE(pAppData->pOBuffer[nCounter], pListHead);
703                    pAppData->pOBuffer[nCounter] = NULL;
704                }
705            }
706            for (nCounter = 0; nCounter < NUM_OF_OUT_BUFFERS; nCounter++) {
707                eError = OMX_FreeBuffer(pHandle, pAppData->pOutPortDef->nPortIndex, pAppData->pOutBuff[nCounter]);
708            }
709            if (pAppData->bAllocateIBuf == OMX_TRUE) {
710                for (nCounter = 0; nCounter < NUM_OF_IN_BUFFERS; nCounter++) {
711                    pAppData->pIBuffer[nCounter] -= 128;
712                    pAppData->pIBuffer[nCounter] = (unsigned char*)pAppData->pIBuffer[nCounter];
713                    VIDENCTEST_FREE(pAppData->pIBuffer[nCounter], pListHead);
714                    pAppData->pIBuffer[nCounter] = NULL;
715                }
716            }
717            for (nCounter = 0; nCounter < NUM_OF_IN_BUFFERS; nCounter++) {
718                eError = OMX_FreeBuffer(pHandle, pAppData->pInPortDef->nPortIndex, pAppData->pInBuff[nCounter]);
719            }
720        case VIDENCTEST_StateLoaded:
721            VIDENCTEST_DPRINT ("DeInit Component\n");
722            eErrorHandleError = TIOMX_FreeHandle(pHandle);
723            VIDENCTEST_CHECK_EXIT(eErrorHandleError, "Error at TIOMX_FreeHandle function");
724            eErrorHandleError = TIOMX_Deinit();
725            VIDENCTEST_CHECK_EXIT(eErrorHandleError, "Error at TIOMX_Deinit function");
726            fclose(pAppData->fIn);
727            fclose(pAppData->fOut);
728            if(pAppData->NalFormat == VIDENC_TEST_NAL_FRAME || pAppData->NalFormat == VIDENC_TEST_NAL_SLICE) {
729                fclose(pAppData->fNalnd);
730            }
731
732            eErr = close(pAppData->IpBuf_Pipe[0]);
733            if (0 != eErr && OMX_ErrorNone == eError) {
734                eError = OMX_ErrorHardware;
735                VIDENCTEST_DPRINT ("Error while closing data pipe\n");
736            }
737
738            eErr = close(pAppData->OpBuf_Pipe[0]);
739            if (0 != eErr && OMX_ErrorNone == eError) {
740                eError = OMX_ErrorHardware;
741                VIDENCTEST_DPRINT ("Error while closing data pipe\n");
742            }
743
744            eErr = close(pAppData->eventPipe[0]);
745            if (0 != eErr && OMX_ErrorNone == eError) {
746                eError = OMX_ErrorHardware;
747                VIDENCTEST_DPRINT ("Error while closing data pipe\n");
748            }
749
750            eErr = close(pAppData->IpBuf_Pipe[1]);
751            if (0 != eErr && OMX_ErrorNone == eError) {
752                eError = OMX_ErrorHardware;
753                VIDENCTEST_DPRINT ("Error while closing data pipe\n");
754            }
755
756            eErr = close(pAppData->OpBuf_Pipe[1]);
757            if (0 != eErr && OMX_ErrorNone == eError) {
758                eError = OMX_ErrorHardware;
759                VIDENCTEST_DPRINT ("Error while closing data pipe\n");
760            }
761
762            eErr = close(pAppData->eventPipe[1]);
763            if (0 != eErr && OMX_ErrorNone == eError) {
764                eError = OMX_ErrorHardware;
765                VIDENCTEST_DPRINT ("Error while closing data pipe\n");
766            }
767            pAppData->fIn = NULL;
768            pAppData->fOut = NULL;
769            pAppData->fNalnd = NULL;
770        case VIDENCTEST_StateUnLoad:
771            VIDENCTEST_DPRINT ("Free Resources\n");
772            VIDENCTEST_ListDestroy(pListHead);
773        default:
774            ;
775    }
776
777#ifdef DSP_MMU_FAULT_HANDLING
778    if(bInvalid_state == OMX_TRUE)
779    {
780        LoadBaseImage();
781    }
782#endif
783
784EXIT:
785    return eErrorHandleError;
786}
787
788/*-----------------------------------------------------------------------------*/
789/**
790  * SetH264Parameter()
791  *
792  * Initialize H264 Parameters.
793  *
794  * @param pAppData
795  *
796  * @retval OMX_ErrorNone
797  *
798  *
799  **/
800/*-----------------------------------------------------------------------------*/
801OMX_ERRORTYPE VIDENCTEST_SetH264Parameter(MYDATATYPE* pAppData)
802{
803    OMX_ERRORTYPE eError = OMX_ErrorNone;
804    OMX_HANDLETYPE pHandle = pAppData->pHandle;
805
806    /* Set the component's OMX_PARAM_PORTDEFINITIONTYPE structure (input) */
807    /**********************************************************************/
808    pAppData->pInPortDef->nBufferCountActual = NUM_OF_IN_BUFFERS;
809    pAppData->pInPortDef->nBufferCountMin = 1;
810    pAppData->pInPortDef->bEnabled = OMX_TRUE;
811    pAppData->pInPortDef->bPopulated = OMX_FALSE;
812    pAppData->pInPortDef->eDomain = OMX_PortDomainVideo;
813
814    /* OMX_VIDEO_PORTDEFINITION values for input port */
815    pAppData->pInPortDef->format.video.cMIMEType = "yuv";
816    pAppData->pInPortDef->format.video.pNativeRender = NULL;
817    pAppData->pInPortDef->format.video.nStride = -1;
818    pAppData->pInPortDef->format.video.nSliceHeight = -1;
819    pAppData->pInPortDef->format.video.xFramerate = fToQ16(pAppData->nFramerate);
820    pAppData->pInPortDef->format.video.bFlagErrorConcealment = OMX_FALSE;
821    pAppData->pInPortDef->format.video.eColorFormat = pAppData->eColorFormat;
822    pAppData->pInPortDef->format.video.nFrameWidth = pAppData->nWidth;
823    pAppData->pInPortDef->format.video.nFrameHeight = pAppData->nHeight;
824
825
826
827    eError = OMX_SetParameter(pHandle, OMX_IndexParamPortDefinition, pAppData->pInPortDef);
828    VIDENCTEST_CHECK_EXIT(eError, "Error at SetParameter");
829
830    /* To get nBufferSize */
831    eError = OMX_GetParameter(pHandle, OMX_IndexParamPortDefinition, pAppData->pInPortDef);
832    VIDENCTEST_CHECK_EXIT(eError, "Error at GetParameter");
833
834    pAppData->nSizeIn = pAppData->pInPortDef->nBufferSize;
835
836    /* Set the component's OMX_VIDEO_PARAM_AVCTYPE structure (output) */
837    /*************************************************************/
838    memset(pAppData->pH264, 0x0, sizeof(OMX_VIDEO_PARAM_AVCTYPE));
839    pAppData->pH264->nSize = sizeof(OMX_VIDEO_PARAM_AVCTYPE);
840    pAppData->pH264->nVersion.s.nVersionMajor = 0x1;
841    pAppData->pH264->nVersion.s.nVersionMinor = 0x0;
842    pAppData->pH264->nVersion.s.nRevision = 0x0;
843    pAppData->pH264->nVersion.s.nStep = 0x0;
844    pAppData->pH264->nPortIndex = VIDENC_OUTPUT_PORT;
845    pAppData->pH264->nSliceHeaderSpacing = 0;
846    pAppData->pH264->nPFrames = -1;
847    pAppData->pH264->nBFrames = -1;
848    pAppData->pH264->bUseHadamard = 0;
849    pAppData->pH264->nRefFrames = -1;
850    pAppData->pH264->nRefIdx10ActiveMinus1 = -1;
851    pAppData->pH264->nRefIdx11ActiveMinus1 = -1;
852    pAppData->pH264->bEnableUEP = OMX_FALSE;
853    pAppData->pH264->bEnableFMO = OMX_FALSE;
854    pAppData->pH264->bEnableASO = OMX_FALSE;
855    pAppData->pH264->bEnableRS = OMX_FALSE;
856    pAppData->pH264->eProfile = OMX_VIDEO_AVCProfileBaseline;
857    pAppData->pH264->nAllowedPictureTypes = -1;
858    pAppData->pH264->bFrameMBsOnly = OMX_FALSE;
859    pAppData->pH264->bMBAFF = OMX_FALSE;
860    pAppData->pH264->bEntropyCodingCABAC = OMX_FALSE;
861    pAppData->pH264->bWeightedPPrediction = OMX_FALSE;
862    pAppData->pH264->nWeightedBipredicitonMode = -1;
863    pAppData->pH264->bconstIpred = OMX_FALSE;
864    pAppData->pH264->bDirect8x8Inference = OMX_FALSE;
865    pAppData->pH264->bDirectSpatialTemporal = OMX_FALSE;
866    pAppData->pH264->nCabacInitIdc = -1;
867    pAppData->pH264->eLoopFilterMode = OMX_VIDEO_AVCLoopFilterDisable;
868    pAppData->pH264->eLevel = pAppData->eLevelH264;
869
870    eError = OMX_SetParameter (pHandle, OMX_IndexParamVideoAvc, pAppData->pH264);
871    VIDENCTEST_CHECK_EXIT(eError, "Error at SetParameter");
872
873    /* Set the component's OMX_PARAM_PORTDEFINITIONTYPE structure (output) */
874    /***********************************************************************/
875    /*memset(pAppData->pOutPortDef, 0x1, sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
876    pAppData->pOutPortDef->nSize = sizeof(OMX_PARAM_PORTDEFINITIONTYPE);
877    pAppData->pOutPortDef->nVersion.s.nVersionMajor = 0x1;
878    pAppData->pOutPortDef->nVersion.s.nVersionMinor = 0x0;
879    pAppData->pOutPortDef->nVersion.s.nRevision = 0x0;
880    pAppData->pOutPortDef->nVersion.s.nStep = 0x0;
881    pAppData->pOutPortDef->nPortIndex = VIDENC_OUTPUT_PORT;
882    pAppData->pOutPortDef->eDir = OMX_DirOutput;*/
883    pAppData->pOutPortDef->nBufferCountActual = NUM_OF_OUT_BUFFERS;
884    pAppData->pOutPortDef->nBufferCountMin = 1;
885    /*pAppData->pOutPortDef->nBufferSize = pAppData->nOutBuffSize;*/
886    pAppData->pOutPortDef->bEnabled = OMX_TRUE;
887    pAppData->pOutPortDef->bPopulated = OMX_FALSE;
888    pAppData->pOutPortDef->eDomain = OMX_PortDomainVideo;
889
890    /* OMX_VIDEO_PORTDEFINITION values for input port */
891    pAppData->pOutPortDef->format.video.cMIMEType = "264";
892    pAppData->pOutPortDef->format.video.pNativeRender = NULL;
893    pAppData->pOutPortDef->format.video.nFrameWidth = pAppData->nWidth;
894    pAppData->pOutPortDef->format.video.nFrameHeight = pAppData->nHeight;
895    pAppData->pOutPortDef->format.video.nStride = 0;
896    pAppData->pOutPortDef->format.video.nSliceHeight = 0;
897    pAppData->pOutPortDef->format.video.nBitrate = pAppData->nBitrate;
898    pAppData->pOutPortDef->format.video.xFramerate = 0;
899    pAppData->pOutPortDef->format.video.bFlagErrorConcealment = OMX_FALSE;
900    pAppData->pOutPortDef->format.video.eCompressionFormat = pAppData->eCompressionFormat;
901
902    eError = OMX_SetParameter (pHandle, OMX_IndexParamPortDefinition, pAppData->pOutPortDef);
903    VIDENCTEST_CHECK_EXIT(eError, "Error at SetParameter");
904
905    /* Retreive nBufferSize */
906    eError = OMX_GetParameter (pHandle, OMX_IndexParamPortDefinition, pAppData->pOutPortDef);
907    VIDENCTEST_CHECK_EXIT(eError, "Error at GetParameter");
908
909    pAppData->nSizeOut = pAppData->pOutPortDef->nBufferSize;
910
911    /* Set the component's OMX_VIDEO_PARAM_BITRATETYPE structure (output) */
912    /*************************************************************/
913    pAppData->pVidParamBitrate->nSize = sizeof(OMX_VIDEO_PARAM_BITRATETYPE);
914    pAppData->pVidParamBitrate->nVersion.s.nVersionMajor = 0x1;
915    pAppData->pVidParamBitrate->nVersion.s.nVersionMinor = 0x0;
916    pAppData->pVidParamBitrate->nVersion.s.nRevision = 0x0;
917    pAppData->pVidParamBitrate->nVersion.s.nStep = 0x0;
918    pAppData->pVidParamBitrate->nPortIndex = VIDENC_OUTPUT_PORT;
919    pAppData->pVidParamBitrate->eControlRate = pAppData->eControlRate;
920    pAppData->pVidParamBitrate->nTargetBitrate = pAppData->pOutPortDef->format.video.nBitrate;
921
922    /* TODO: need to convert what value DSP is expecting to equivalent OMX value */
923    eError = OMX_SetParameter (pHandle, OMX_IndexParamVideoBitrate, pAppData->pVidParamBitrate);
924    VIDENCTEST_CHECK_EXIT(eError, "Error at SetParameter");
925
926    /* Set the component's OMX_VIDEO_PARAM_QUANTIZATIONTYPE structure (output) */
927    /*************************************************************/
928    pAppData->pQuantization->nSize = sizeof(OMX_VIDEO_PARAM_QUANTIZATIONTYPE);
929    pAppData->pQuantization->nVersion.s.nVersionMajor = 0x1;
930    pAppData->pQuantization->nVersion.s.nVersionMinor = 0x0;
931    pAppData->pQuantization->nVersion.s.nRevision = 0x0;
932    pAppData->pQuantization->nVersion.s.nStep = 0x0;
933    pAppData->pQuantization->nPortIndex = VIDENC_OUTPUT_PORT;
934    pAppData->pQuantization->nQpI = pAppData->nQpI;
935
936    eError = OMX_SetParameter (pHandle, OMX_IndexParamVideoQuantization, pAppData->pQuantization);
937    VIDENCTEST_CHECK_EXIT(eError, "Error at SetParameter");
938
939    /* SR12020: Set H.264 encode Deblocking Filter using the custom OMX index */
940    eError = OMX_GetExtensionIndex(pHandle,"OMX.TI.VideoEncode.Param.DeblockFilter", (OMX_INDEXTYPE*)(&(pAppData->nVideoEncodeCustomParamIndex)));
941    VIDENCTEST_CHECK_EXIT(eError, "Error in OMX_GetExtensionIndex function");
942
943    eError = OMX_SetParameter(pHandle, pAppData->nVideoEncodeCustomParamIndex, &(pAppData->bDeblockFilter));
944    VIDENCTEST_CHECK_EXIT(eError, "Error at SetParameter");
945
946    if(pAppData->nEncodingPreset!=VIDENCTEST_USE_DEFAULT_VALUE_UI && pAppData->nEncodingPreset<=4){
947        printf("EncodingPreset %d selected\n", pAppData->nEncodingPreset);
948        eError = OMX_GetExtensionIndex(pHandle,"OMX.TI.VideoEncode.Config.EncodingPreset", (OMX_INDEXTYPE*)(&(pAppData->nVideoEncodeCustomParamIndex)));
949        VIDENCTEST_CHECK_EXIT(eError, "OMX_GetExtensionIndex function");
950        eError = OMX_SetParameter(pHandle, pAppData->nVideoEncodeCustomParamIndex, &(pAppData->nEncodingPreset));
951        VIDENCTEST_CHECK_EXIT(eError, "Error at SetConfig for nEncodingPreset");
952    }
953
954    if(pAppData->nUnrestrictedMV != (OMX_U8)VIDENCTEST_USE_DEFAULT_VALUE_UI){
955        printf("nUnrestrictedMV %d selected\n", pAppData->nUnrestrictedMV);
956        eError = OMX_GetExtensionIndex(pHandle,"OMX.TI.VideoEncode.Config.UnrestrictedMV", (OMX_INDEXTYPE*)(&(pAppData->nVideoEncodeCustomParamIndex)));
957        VIDENCTEST_CHECK_EXIT(eError, "OMX_GetExtensionIndex function");
958        eError = OMX_SetParameter(pHandle, pAppData->nVideoEncodeCustomParamIndex, &(pAppData->nUnrestrictedMV));
959        VIDENCTEST_CHECK_EXIT(eError, "Error at SetConfig for nUnrestrictedMV");
960    }
961
962    eError = OMX_GetExtensionIndex(pHandle,"OMX.TI.VideoEncode.Config.NALFormat", (OMX_INDEXTYPE*)(&(pAppData->nVideoEncodeCustomParamIndex)));
963    VIDENCTEST_CHECK_EXIT(eError, "OMX_GetExtensionIndex function");
964    eError = OMX_SetParameter(pHandle, pAppData->nVideoEncodeCustomParamIndex, &(pAppData->NalFormat));
965    VIDENCTEST_CHECK_EXIT(eError, "Error at SetConfig for NalFormat");
966
967EXIT:
968    return eError;
969}
970
971/*-----------------------------------------------------------------------------*/
972/**
973  * SetMpeg4Parameter()
974  *
975  * Intialize Mpeg4 structures.
976  *
977  * @param pAppData
978  *
979  * @retval OMX_ErrorNone
980  *
981  *
982  **/
983/*-----------------------------------------------------------------------------*/
984OMX_ERRORTYPE VIDENCTEST_SetMpeg4Parameter(MYDATATYPE* pAppData)
985{
986    OMX_ERRORTYPE eError = OMX_ErrorNone;
987    OMX_HANDLETYPE pHandle = pAppData->pHandle;
988
989    /* Set the component's OMX_PARAM_PORTDEFINITIONTYPE structure (input) */
990    /**********************************************************************/
991    pAppData->pInPortDef->nBufferCountActual = NUM_OF_IN_BUFFERS;
992    pAppData->pInPortDef->nBufferCountMin = 2;
993    pAppData->pInPortDef->bEnabled = OMX_TRUE;
994    pAppData->pInPortDef->bPopulated = OMX_FALSE;
995    pAppData->pInPortDef->eDomain = OMX_PortDomainVideo;
996
997    /* OMX_VIDEO_PORTDEFINITION values for input port */
998    pAppData->pInPortDef->format.video.cMIMEType = "yuv";
999    pAppData->pInPortDef->format.video.pNativeRender = NULL;
1000    pAppData->pInPortDef->format.video.nStride = -1;
1001    pAppData->pInPortDef->format.video.nSliceHeight = -1;
1002    pAppData->pInPortDef->format.video.xFramerate = fToQ16(pAppData->nFramerate);
1003    pAppData->pInPortDef->format.video.bFlagErrorConcealment = OMX_FALSE;
1004    pAppData->pInPortDef->format.video.eColorFormat = pAppData->eColorFormat;
1005    pAppData->pInPortDef->format.video.nFrameWidth = pAppData->nWidth;
1006    pAppData->pInPortDef->format.video.nFrameHeight = pAppData->nHeight;
1007
1008    eError = OMX_SetParameter (pHandle, OMX_IndexParamPortDefinition, pAppData->pInPortDef);
1009    VIDENCTEST_CHECK_EXIT(eError, "Error at SetParameter");
1010
1011    /* To get nBufferSize */
1012    eError = OMX_GetParameter(pHandle, OMX_IndexParamPortDefinition, pAppData->pInPortDef);
1013    VIDENCTEST_CHECK_EXIT(eError, "Error at GetParameter");
1014
1015    pAppData->nSizeIn = pAppData->pInPortDef->nBufferSize;
1016
1017    /* Set the component's OMX_PARAM_PORTDEFINITIONTYPE structure (output) */
1018    /*************************************************************/
1019    pAppData->pOutPortDef->nBufferCountActual = NUM_OF_OUT_BUFFERS;
1020    pAppData->pOutPortDef->nBufferCountMin = 1;
1021    pAppData->pOutPortDef->bEnabled = OMX_TRUE;
1022    pAppData->pOutPortDef->bPopulated = OMX_FALSE;
1023    pAppData->pOutPortDef->eDomain = OMX_PortDomainVideo;
1024
1025    /* OMX_VIDEO_PORTDEFINITION values for input port */
1026    pAppData->pOutPortDef->format.video.cMIMEType = "mp4";
1027    pAppData->pOutPortDef->format.video.pNativeRender = NULL;
1028    pAppData->pOutPortDef->format.video.nFrameWidth = pAppData->nWidth;
1029    pAppData->pOutPortDef->format.video.nFrameHeight = pAppData->nHeight;
1030    pAppData->pOutPortDef->format.video.nStride = 0;
1031    pAppData->pOutPortDef->format.video.nSliceHeight = 0;
1032    pAppData->pOutPortDef->format.video.nBitrate = pAppData->nBitrate;
1033    pAppData->pOutPortDef->format.video.xFramerate = 0;
1034    pAppData->pOutPortDef->format.video.bFlagErrorConcealment = OMX_FALSE;
1035    pAppData->pOutPortDef->format.video.eCompressionFormat = pAppData->eCompressionFormat;
1036
1037    eError = OMX_SetParameter (pHandle, OMX_IndexParamPortDefinition, pAppData->pOutPortDef);
1038    VIDENCTEST_CHECK_EXIT(eError, "Error at SetParameter");
1039
1040    /* Retreive nBufferSize */
1041    eError = OMX_GetParameter (pHandle, OMX_IndexParamPortDefinition, pAppData->pOutPortDef);
1042    VIDENCTEST_CHECK_EXIT(eError, "Error at GetParameter");
1043
1044    pAppData->nSizeOut = pAppData->pOutPortDef->nBufferSize;
1045
1046    /* Set the component's OMX_VIDEO_PARAM_BITRATETYPE structure (output) */
1047    /*************************************************************/
1048    pAppData->pVidParamBitrate->nSize = sizeof(OMX_VIDEO_PARAM_BITRATETYPE);
1049    pAppData->pVidParamBitrate->nVersion.s.nVersionMajor = 0x1;
1050    pAppData->pVidParamBitrate->nVersion.s.nVersionMinor = 0x0;
1051    pAppData->pVidParamBitrate->nVersion.s.nRevision = 0x0;
1052    pAppData->pVidParamBitrate->nVersion.s.nStep = 0x0;
1053    pAppData->pVidParamBitrate->nPortIndex = VIDENC_OUTPUT_PORT;
1054    pAppData->pVidParamBitrate->eControlRate = pAppData->eControlRate;
1055    pAppData->pVidParamBitrate->nTargetBitrate = pAppData->pOutPortDef->format.video.nBitrate;
1056
1057    /* TODO: need to convert what value DSP is expecting to equivalent OMX value */
1058
1059    eError = OMX_SetParameter (pHandle, OMX_IndexParamVideoBitrate, pAppData->pVidParamBitrate);
1060    VIDENCTEST_CHECK_EXIT(eError, "Error at SetParameter");
1061
1062    /* Set the component's OMX_VIDEO_PARAM_H263TYPE structure (output) */
1063    /*************************************************************/
1064    if (pAppData->eCompressionFormat == OMX_VIDEO_CodingH263) {
1065        pAppData->pH263->nSize = sizeof(OMX_VIDEO_PARAM_H263TYPE);
1066        pAppData->pH263->nVersion.s.nVersionMajor = 0x1;
1067        pAppData->pH263->nVersion.s.nVersionMinor = 0x0;
1068        pAppData->pH263->nVersion.s.nRevision = 0x0;
1069        pAppData->pH263->nVersion.s.nStep = 0x0;
1070        pAppData->pH263->nPortIndex = VIDENC_OUTPUT_PORT;
1071        pAppData->pH263->eLevel = pAppData->eLevelH63;
1072        pAppData->pH263->nGOBHeaderInterval = pAppData->nGOBHeaderInterval;
1073
1074        eError = OMX_SetParameter (pHandle, OMX_IndexParamVideoH263, pAppData->pH263);
1075        VIDENCTEST_CHECK_EXIT(eError, "Error at SetParameter");
1076    }
1077
1078    /* Set the component's OMX_VIDEO_PARAM_QUANTIZATIONTYPE structure (output) */
1079    /*************************************************************/
1080    pAppData->pQuantization->nSize = sizeof(OMX_VIDEO_PARAM_QUANTIZATIONTYPE);
1081    pAppData->pQuantization->nVersion.s.nVersionMajor = 0x1;
1082    pAppData->pQuantization->nVersion.s.nVersionMinor = 0x0;
1083    pAppData->pQuantization->nVersion.s.nRevision = 0x0;
1084    pAppData->pQuantization->nVersion.s.nStep = 0x0;
1085    pAppData->pQuantization->nPortIndex = VIDENC_OUTPUT_PORT;
1086    pAppData->pQuantization->nQpI = pAppData->nQpI;
1087
1088    eError = OMX_SetParameter (pHandle, OMX_IndexParamVideoQuantization, pAppData->pQuantization);
1089    VIDENCTEST_CHECK_EXIT(eError, "Error at SetParameter");
1090
1091    /* Set the component's OMX_VIDEO_PARAM_MPEG4TYPE structure (output) */
1092    /*************************************************************/
1093    if (pAppData->eCompressionFormat == OMX_VIDEO_CodingMPEG4) {
1094        pAppData->pMpeg4->nSize = sizeof(OMX_VIDEO_PARAM_MPEG4TYPE);
1095        pAppData->pMpeg4->nVersion.s.nVersionMajor = 0x1;
1096        pAppData->pMpeg4->nVersion.s.nVersionMinor = 0x0;
1097        pAppData->pMpeg4->nVersion.s.nRevision = 0x0;
1098        pAppData->pMpeg4->nVersion.s.nStep = 0x0;
1099        pAppData->pMpeg4->nPortIndex = VIDENC_OUTPUT_PORT;
1100        pAppData->pMpeg4->eLevel = pAppData->eLevelMpeg4;
1101
1102        eError = OMX_SetParameter (pHandle, OMX_IndexParamVideoMpeg4, pAppData->pMpeg4);
1103        VIDENCTEST_CHECK_EXIT(eError, "Error at SetParameter");
1104    }
1105
1106    /* SR10527: Set MPEG4/H263 encode VBV Size using the custom OMX index */
1107    eError = OMX_GetExtensionIndex(pHandle,"OMX.TI.VideoEncode.Param.VBVSize", (OMX_INDEXTYPE*)(&(pAppData->nVideoEncodeCustomParamIndex)));
1108    VIDENCTEST_CHECK_EXIT(eError, "OMX_GetExtensionIndex function");
1109
1110    eError = OMX_SetParameter(pHandle, pAppData->nVideoEncodeCustomParamIndex, &(pAppData->nVBVSize));
1111    VIDENCTEST_CHECK_EXIT(eError, "Error at SetParameter");
1112
1113    if(pAppData->nMIRRate != VIDENCTEST_USE_DEFAULT_VALUE){
1114        printf("MIRRate selected\n");
1115        eError = OMX_GetExtensionIndex(pHandle,"OMX.TI.VideoEncode.Config.MIRRate", (OMX_INDEXTYPE*)(&(pAppData->nVideoEncodeCustomParamIndex)));
1116        VIDENCTEST_CHECK_EXIT(eError, "OMX_GetExtensionIndex function");
1117        eError = OMX_SetConfig(pHandle, pAppData->nVideoEncodeCustomParamIndex, &(pAppData->nMIRRate));
1118        VIDENCTEST_CHECK_EXIT(eError, "Error at SetConfig for nMIRRate");
1119    }
1120
1121    if(pAppData->nResynchMarkerSpacing != VIDENCTEST_USE_DEFAULT_VALUE){
1122        printf("ResynchMarkerSpacing selected\n");
1123        OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE ErrorCorrectionType;
1124        ErrorCorrectionType.nSize = sizeof(OMX_VIDEO_PARAM_ERRORCORRECTIONTYPE);
1125        ErrorCorrectionType.nVersion.s.nVersionMajor = 0x1;
1126        ErrorCorrectionType.nVersion.s.nVersionMinor = 0x0;
1127        ErrorCorrectionType.nVersion.s.nRevision     = 0x0;
1128        ErrorCorrectionType.nVersion.s.nStep         = 0x0;
1129        ErrorCorrectionType.nPortIndex= VIDENC_OUTPUT_PORT;
1130        ErrorCorrectionType.bEnableHEC= OMX_TRUE;
1131        ErrorCorrectionType.bEnableResync = OMX_TRUE;
1132        ErrorCorrectionType.bEnableDataPartitioning= OMX_FALSE;
1133        ErrorCorrectionType.bEnableRVLC= OMX_FALSE;
1134        ErrorCorrectionType.nResynchMarkerSpacing = pAppData->nResynchMarkerSpacing;
1135
1136        eError = OMX_SetConfig(pHandle, OMX_IndexParamVideoErrorCorrection, &ErrorCorrectionType);
1137        VIDENCTEST_CHECK_EXIT(eError, "Error at SetConfig for ErrorCorrection");
1138    }
1139    if(pAppData->nUnrestrictedMV != (OMX_U8)VIDENCTEST_USE_DEFAULT_VALUE_UI){
1140        printf("nUnrestrictedMV %d selected\n", pAppData->nUnrestrictedMV);
1141        eError = OMX_GetExtensionIndex(pHandle,"OMX.TI.VideoEncode.Config.UnrestrictedMV", (OMX_INDEXTYPE*)(&(pAppData->nVideoEncodeCustomParamIndex)));
1142        VIDENCTEST_CHECK_EXIT(eError, "OMX_GetExtensionIndex function");
1143        eError = OMX_SetParameter(pHandle, pAppData->nVideoEncodeCustomParamIndex, &(pAppData->nUnrestrictedMV));
1144        VIDENCTEST_CHECK_EXIT(eError, "Error at SetConfig for nUnrestrictedMV");
1145    }
1146EXIT:
1147    return eError;
1148}
1149
1150/*-----------------------------------------------------------------------------*/
1151/**
1152  * AllocateResources()
1153  *
1154  * Allocate necesary resources.
1155  *
1156  * @param pAppData
1157  *
1158  * @retval OMX_ErrorNone
1159  *
1160  *
1161  **/
1162/*-----------------------------------------------------------------------------*/
1163OMX_ERRORTYPE VIDENCTEST_AllocateResources(MYDATATYPE* pAppData)
1164{
1165    OMX_ERRORTYPE eError = OMX_ErrorNone;
1166    int retval = 0;
1167    VIDENCTEST_NODE* pListHead;
1168
1169    pListHead = pAppData->pMemoryListHead;
1170
1171    VIDENCTEST_MALLOC(pAppData->pCb, sizeof(OMX_CALLBACKTYPE), OMX_CALLBACKTYPE, pListHead);
1172    VIDENCTEST_MALLOC(pAppData->pInPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE), OMX_PARAM_PORTDEFINITIONTYPE, pListHead);
1173    VIDENCTEST_MALLOC(pAppData->pOutPortDef, sizeof(OMX_PARAM_PORTDEFINITIONTYPE), OMX_PARAM_PORTDEFINITIONTYPE, pListHead);
1174
1175    if (pAppData->eCompressionFormat == OMX_VIDEO_CodingH263) {
1176        VIDENCTEST_MALLOC(pAppData->pVidParamBitrate, sizeof(OMX_VIDEO_PARAM_BITRATETYPE), OMX_VIDEO_PARAM_BITRATETYPE, pListHead);
1177        VIDENCTEST_MALLOC(pAppData->pH263, sizeof(OMX_VIDEO_PARAM_H263TYPE), OMX_VIDEO_PARAM_H263TYPE, pListHead);
1178    }
1179    else if (pAppData->eCompressionFormat == OMX_VIDEO_CodingMPEG4) {
1180        VIDENCTEST_MALLOC(pAppData->pVidParamBitrate, sizeof(OMX_VIDEO_PARAM_BITRATETYPE), OMX_VIDEO_PARAM_BITRATETYPE, pListHead);
1181        VIDENCTEST_MALLOC(pAppData->pMpeg4, sizeof(OMX_VIDEO_PARAM_MPEG4TYPE), OMX_VIDEO_PARAM_MPEG4TYPE, pListHead);
1182    }
1183    else if (pAppData->eCompressionFormat == OMX_VIDEO_CodingAVC) {
1184        VIDENCTEST_MALLOC(pAppData->pVidParamBitrate, sizeof(OMX_VIDEO_PARAM_BITRATETYPE), OMX_VIDEO_PARAM_BITRATETYPE, pListHead);
1185        VIDENCTEST_MALLOC(pAppData->pH264, sizeof(OMX_VIDEO_PARAM_AVCTYPE), OMX_VIDEO_PARAM_AVCTYPE, pListHead);
1186    }
1187    else {
1188        VIDENCTEST_DPRINT("Invalid compression format value.\n");
1189        eError = OMX_ErrorUnsupportedSetting;
1190        goto EXIT;
1191    }
1192    VIDENCTEST_MALLOC(pAppData->pQuantization, sizeof(OMX_VIDEO_PARAM_QUANTIZATIONTYPE), OMX_VIDEO_PARAM_QUANTIZATIONTYPE, pListHead);
1193
1194    /* Create a pipe used to queue data from the callback. */
1195    retval = pipe(pAppData->IpBuf_Pipe);
1196    if (retval != 0) {
1197        VIDENCTEST_DPRINT("Error: Fill Data Pipe failed to open\n");
1198        goto EXIT;
1199    }
1200    retval = pipe(pAppData->OpBuf_Pipe);
1201    if (retval != 0) {
1202        VIDENCTEST_DPRINT("Error: Empty Data Pipe failed to open\n");
1203        goto EXIT;
1204    }
1205    retval = pipe(pAppData->eventPipe);
1206    if (retval != 0) {
1207        VIDENCTEST_DPRINT("Error: Empty Data Pipe failed to open\n");
1208        goto EXIT;
1209    }
1210
1211EXIT:
1212    return eError;
1213}
1214
1215/*-----------------------------------------------------------------------------*/
1216/**
1217  * AllocateBuffers()
1218  *
1219  * Allocate necesary resources.
1220  *
1221  * @param pAppData
1222  *
1223  * @retval OMX_ErrorNone
1224  *
1225  *
1226  **/
1227/*-----------------------------------------------------------------------------*/
1228OMX_ERRORTYPE VIDENCTEST_AllocateBuffers(MYDATATYPE* pAppData)
1229{
1230    OMX_ERRORTYPE eError = OMX_ErrorNone;
1231    OMX_U8 nCounter = 0;
1232    VIDENCTEST_NODE* pListHead;
1233
1234    pListHead = pAppData->pMemoryListHead;
1235
1236    for (nCounter = 0; nCounter < NUM_OF_IN_BUFFERS; nCounter++) {
1237        if (pAppData->bAllocateIBuf == OMX_TRUE) {
1238            VIDENCTEST_MALLOC(pAppData->pIBuffer[nCounter], pAppData->nSizeIn + 256, OMX_U8, pListHead);
1239            pAppData->pIBuffer[nCounter] += 128;
1240            pAppData->pIBuffer[nCounter] = (unsigned char*)pAppData->pIBuffer[nCounter];
1241        }
1242    }
1243    for (nCounter = 0; nCounter < NUM_OF_OUT_BUFFERS; nCounter++) {
1244        if (pAppData->bAllocateOBuf == OMX_TRUE) {
1245            VIDENCTEST_MALLOC(pAppData->pOBuffer[nCounter], pAppData->nSizeOut + 256, OMX_U8, pListHead);
1246            pAppData->pOBuffer[nCounter] += 128;
1247            pAppData->pOBuffer[nCounter] = (unsigned char*)pAppData->pOBuffer[nCounter];
1248            }
1249    }
1250
1251    return eError;
1252}
1253
1254/*-----------------------------------------------------------------------------*/
1255/**
1256  * FreeResources()
1257  *
1258  * Free all allocated memory.
1259  *
1260  * @param pAppData
1261  *
1262  * @retval OMX_ErrorNone
1263  *
1264  *
1265  **/
1266/*-----------------------------------------------------------------------------*/
1267OMX_ERRORTYPE VIDENCTEST_FreeResources(MYDATATYPE* pAppData)
1268{
1269    OMX_ERRORTYPE eError = OMX_ErrorNone;
1270    OMX_U32 i = 0;
1271    VIDENCTEST_NODE* pListHead;
1272
1273    pListHead = pAppData->pMemoryListHead;
1274
1275    VIDENCTEST_FREE(pAppData->pCb, pListHead);
1276    VIDENCTEST_FREE(pAppData->pInPortDef, pListHead);
1277    VIDENCTEST_FREE(pAppData->pOutPortDef, pListHead);
1278
1279    if((pAppData->NalFormat == VIDENC_TEST_NAL_FRAME || pAppData->NalFormat == VIDENC_TEST_NAL_SLICE)
1280        && pAppData->szOutFileNal) {
1281        VIDENCTEST_FREE(pAppData->szOutFileNal, pListHead);
1282    }
1283
1284    if (pAppData->pH264 != NULL) {
1285        VIDENCTEST_FREE(pAppData->pH264, pListHead);
1286    }
1287
1288    VIDENCTEST_FREE(pAppData->pVidParamBitrate, pListHead);
1289
1290    if (pAppData->pH263 != NULL) {
1291        VIDENCTEST_FREE(pAppData->pH263, pListHead);
1292    }
1293
1294    VIDENCTEST_FREE(pAppData->pQuantization, pListHead);
1295
1296    if (pAppData->pMpeg4 != NULL) {
1297        VIDENCTEST_FREE(pAppData->pMpeg4, pListHead);
1298    }
1299
1300    for (i = 0; i < pAppData->nEventCount; i++) {
1301        VIDENCTEST_FREE(pAppData->pEventArray[i], pListHead);
1302    }
1303
1304    return eError;
1305}
1306
1307/*-----------------------------------------------------------------------------*/
1308/**
1309  * PrintCorrectArgs()
1310  *
1311  * Print the description of the input arguments. Also Prints a sample line.
1312  *
1313  * @param bPrintH264. IF set will print the H264 argument description.
1314  * @param bPrintMpeg4. If set will print the Mpeg4/H263  argument description.
1315  *
1316  * @retval OMX_ErrorNone
1317  *
1318  *
1319  **/
1320/*-----------------------------------------------------------------------------*/
1321OMX_ERRORTYPE VIDENCTEST_PrintCorrectArgs(OMX_BOOL bPrintH264, OMX_BOOL bPrintMpeg4)
1322{
1323    OMX_ERRORTYPE eError = OMX_ErrorNone;
1324
1325    if (bPrintMpeg4 == OMX_TRUE) {
1326        printf("MPEG4/H.263 Encode Usage: ./VideoEncTest <arg01> <arg02> <arg03> ...");
1327        printf("\narg01 : <input.yuv>");
1328        printf("\narg02 : <output.mp4>");
1329        printf("\narg03 : <width>");
1330        printf("\narg04 : <height>");
1331        printf("\narg05 : <19:420/25:422-BE/26:422-LE>");
1332        printf("\narg06 : <bitrate>");
1333        printf("\narg07 : <framerate>");
1334        printf("\narg08 : <3:H263/4:MPEG4/7:H264>");
1335        printf("\narg09 : <rateCtrl/1:var/2:const>");
1336        printf("\narg10 : <GOB> --H.263 only--");
1337        printf("\narg11 : <QPI>");
1338        printf("\narg12 : <level>");
1339        printf("\narg13 : <allocateBufFlag>");
1340        printf("\narg14 : <VBVsize>");
1341        printf("\narg15 : <0:full-rec/1:partial-rec->stop/2:rec->pause->resume/3:rec->stop->restart>");
1342        printf("\narg16 : <stop/pause frame/iteration> -- use zero if arg15 = 0:full-rec <or> use a valid frame # if arg15 = 1, 2, 3 --\n");
1343        printf("\narg17 : <Number of Repetitions of test>");
1344        printf("\nSample OMX MPEG4 Encode test:\n");
1345        printf("/omx/VideoEncTest /omx/patterns/carphone_qcif_420p_short.yuv /omx/patterns/carphone_qcif_420p_short.mp4 176 144 19 64000 15 4 1 0 12 0 1 120 0 0 1\n");
1346        printf("\nSample OMX H.263 Encode test:\n");
1347        printf("/omx/VideoEncTest /omx/patterns/carphone_qcif_420p_short.yuv /omx/patterns/carphone_qcif_420p_short.263 176 144 19 64000 15 3 2 0 12 10 1 120 0 0 1\n\n");
1348    }
1349    if (bPrintH264 == OMX_TRUE) {
1350        printf("H.264 Encode Usage: ./VideoEncTest <arg01> <arg02> <arg03> ...");
1351        printf("\narg01 :: <input.yuv>");
1352        printf("\narg02 :: <output.H264>");
1353        printf("\narg03 :: <width>");
1354        printf("\narg04 :: <height>");
1355        printf("\narg05 :: <19:420/25:422-BE/26:422-LE>");
1356        printf("\narg06 :: <bitrate>");
1357        printf("\narg07 :: <framerate>");
1358        printf("\narg08 :: <3:H263/4:MPEG4/7:H264>");
1359        printf("\narg09 :: <level>");
1360        printf("\narg10 :: <out_buff_size>");
1361        printf("\narg11 :: <allocateBufFlag>");
1362        printf("\narg12 :: <deblockFilter>");
1363        printf("\narg13 :: <rateCtrl/0:none/1:var/2:const>");
1364        printf("\narg14 :: <QPI> --set rate control to zero--");
1365        printf("\narg15 :: <0:full-rec/1:partial-rec->stop/2:rec->pause->resume/3:rec->stop->restart>");
1366        printf("\narg16 :: <stop/pause frame/iteration> -- use zero if arg15 = 0:full-rec <or> use a valid frame # if arg15 = 1, 2, 3 --\n");
1367        printf("\narg17 :: <Number of Repetitions of test>");
1368        printf("\nSample OMX H.264 Encode test:\n");
1369        printf("/omx/VideoEncTest /omx/patterns/carphone_qcif_420p_short.yuv /omx/patterns/carphone_qcif_420p_short.264 176 144 19 64000 15 7 10 26250 1 1 1 0 0 0 1\n\n");
1370    }
1371    return eError;
1372}
1373
1374/*-----------------------------------------------------------------------------*/
1375/**
1376  * Init()
1377  *
1378  *Initialize all the parameters for the VideoEncoder Structures
1379  *
1380  * @param  pAppData MYDATA handle
1381  *
1382  * @retval OMX_ErrorNone
1383  *
1384  *
1385  **/
1386/*-----------------------------------------------------------------------------*/
1387OMX_ERRORTYPE VIDENCTEST_PassToLoaded(MYDATATYPE* pAppData)
1388{
1389    OMX_ERRORTYPE eError = OMX_ErrorNone;
1390    OMX_HANDLETYPE pHandle;
1391    VIDENCTEST_NODE* pListHead;
1392    OMX_U32 i;
1393    OMX_CALLBACKTYPE sCb = {(void*)VIDENCTEST_EventHandler, (void*)VIDENCTEST_EmptyBufferDone, (void*)VIDENCTEST_FillBufferDone};
1394
1395    pListHead = pAppData->pMemoryListHead;
1396
1397    eError = VIDENCTEST_AllocateResources(pAppData);
1398
1399
1400    VIDENCTEST_CHECK_EXIT(eError, "Error at Allocation of Resources");
1401
1402    pAppData->fdmax = maxint(pAppData->IpBuf_Pipe[0], pAppData->eventPipe[0]);
1403
1404    pAppData->fdmax = maxint(pAppData->OpBuf_Pipe[0], pAppData->fdmax);
1405
1406
1407
1408    /* Initialize OMX Core */
1409
1410    eError = TIOMX_Init();
1411    VIDENCTEST_CHECK_EXIT(eError, "Error returned by TIOMX_Init()");
1412
1413    *pAppData->pCb = sCb;
1414    /* Get VideoEncoder Component Handle */
1415    eError = TIOMX_GetHandle(&pHandle, StrVideoEncoder, pAppData, pAppData->pCb);
1416    VIDENCTEST_CHECK_EXIT(eError, "Error returned by TIOMX_Init()");
1417    if (pHandle == NULL) {
1418        VIDENCTEST_DPRINT("Error GetHandle() return Null Pointer\n");
1419        eError = OMX_ErrorUndefined;
1420        goto EXIT;
1421    }
1422
1423    pAppData->pHandle = pHandle;
1424
1425    /* Get starting port number and the number of ports */
1426    VIDENCTEST_MALLOC(pAppData->pVideoInit, sizeof(OMX_PORT_PARAM_TYPE), OMX_PORT_PARAM_TYPE, pListHead);
1427
1428    eError = OMX_GetParameter(pHandle, OMX_IndexParamVideoInit, pAppData->pVideoInit);
1429    VIDENCTEST_CHECK_EXIT(eError, "Error returned from GetParameter()");
1430
1431    pAppData->nStartPortNumber = pAppData->pVideoInit->nStartPortNumber;
1432    pAppData->nPorts           = pAppData->pVideoInit->nPorts;
1433
1434    VIDENCTEST_FREE(pAppData->pVideoInit, pListHead);
1435
1436    /* TODO: Optimize - We should use a linked list instead of an array */
1437    for (i = pAppData->nStartPortNumber; i < pAppData->nPorts; i++) {
1438        VIDENCTEST_MALLOC(pAppData->pPortDef[i], sizeof(OMX_PARAM_PORTDEFINITIONTYPE), OMX_PARAM_PORTDEFINITIONTYPE, pListHead);
1439
1440        pAppData->pPortDef[i]->nPortIndex = i;
1441        eError = OMX_GetParameter(pHandle, OMX_IndexParamPortDefinition, pAppData->pPortDef[i]);
1442        VIDENCTEST_CHECK_EXIT(eError, "Error returned from GetParameter()");
1443
1444        if (pAppData->pPortDef[i]->eDir == OMX_DirInput) {
1445            memcpy(pAppData->pInPortDef, pAppData->pPortDef[i], sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1446        }
1447        else {
1448            memcpy(pAppData->pOutPortDef, pAppData->pPortDef[i], sizeof(OMX_PARAM_PORTDEFINITIONTYPE));
1449        }
1450        VIDENCTEST_FREE(pAppData->pPortDef[i], pListHead);
1451    }
1452
1453    switch (pAppData->eCompressionFormat) {
1454        case OMX_VIDEO_CodingH263:
1455            eError = VIDENCTEST_SetMpeg4Parameter(pAppData);
1456            VIDENCTEST_CHECK_EXIT(eError, "Error returned from SetMpeg4Parameter()");
1457            break;
1458        case OMX_VIDEO_CodingMPEG4:
1459            eError = VIDENCTEST_SetMpeg4Parameter(pAppData);
1460            VIDENCTEST_CHECK_EXIT(eError, "Error returned from SetMpeg4Parameter()");
1461            break;
1462        case OMX_VIDEO_CodingAVC:
1463            eError = VIDENCTEST_SetH264Parameter(pAppData);
1464            VIDENCTEST_CHECK_EXIT(eError, "Error returned from SetH264Parameter()");
1465            break;
1466        default:
1467            VIDENCTEST_DPRINT("Invalid compression format value.\n");
1468            eError = OMX_ErrorUnsupportedSetting;
1469            goto EXIT;
1470    }
1471
1472    VIDENCTEST_AllocateBuffers(pAppData);
1473    VIDENCTEST_CHECK_EXIT(eError, "Error at Allocation of Resources");
1474
1475    pAppData->eCurrentState = VIDENCTEST_StateLoaded;
1476
1477 EXIT:
1478    return eError;
1479
1480}
1481
1482/*-----------------------------------------------------------------------------*/
1483/**
1484  * PassToReady()
1485  *
1486  *Pass the Component to Idle and allocate the buffers
1487  *
1488  * @param  pAppData MYDATA handle
1489  *
1490  * @retval OMX_ErrorNone
1491  *
1492  *
1493  **/
1494/*-----------------------------------------------------------------------------*/
1495OMX_ERRORTYPE VIDENCTEST_PassToReady(MYDATATYPE* pAppData)
1496{
1497    OMX_ERRORTYPE eError = OMX_ErrorNone;
1498    OMX_HANDLETYPE pHandle;
1499    OMX_U32 nCounter;
1500
1501    pHandle = pAppData->pHandle;
1502
1503    eError = OMX_SendCommand(pHandle, OMX_CommandStateSet, OMX_StateIdle, NULL);
1504    VIDENCTEST_CHECK_EXIT(eError, "Error from SendCommand-Idle(Init) State function");
1505
1506    for (nCounter = 0; nCounter < NUM_OF_IN_BUFFERS; nCounter++) {
1507       if (pAppData->bAllocateIBuf == OMX_TRUE) {
1508            eError = OMX_UseBuffer(pHandle,
1509                                  &pAppData->pInBuff[nCounter],
1510                                  pAppData->pInPortDef->nPortIndex,
1511                                  pAppData,
1512                                  pAppData->pInPortDef->nBufferSize,
1513                                  pAppData->pIBuffer[nCounter]);
1514            VIDENCTEST_CHECK_EXIT(eError, "Error from OMX_UseBuffer function");
1515       }
1516       else {
1517            eError = OMX_AllocateBuffer(pHandle,
1518                                       &pAppData->pInBuff[nCounter],
1519                                       pAppData->pInPortDef->nPortIndex,
1520                                       pAppData,
1521                                       pAppData->pInPortDef->nBufferSize);
1522            VIDENCTEST_CHECK_EXIT(eError, "Error from OMX_AllocateBuffer State function");
1523       }
1524    }
1525
1526    pAppData->nInBufferCount = NUM_OF_IN_BUFFERS;
1527
1528    for (nCounter = 0; nCounter < NUM_OF_OUT_BUFFERS; nCounter++) {
1529        if (pAppData->bAllocateOBuf == OMX_TRUE) {
1530            eError = OMX_UseBuffer(pHandle,
1531                                   &pAppData->pOutBuff[nCounter],
1532                                   pAppData->pOutPortDef->nPortIndex,
1533                                   pAppData,
1534                                   pAppData->pOutPortDef->nBufferSize,
1535                                   pAppData->pOBuffer[nCounter]);
1536            VIDENCTEST_CHECK_EXIT(eError, "Error from OMX_UseBuffer function");
1537        }
1538        else {
1539            eError = OMX_AllocateBuffer(pHandle,
1540                                        &pAppData->pOutBuff[nCounter],
1541                                        pAppData->pOutPortDef->nPortIndex,
1542                                        pAppData,
1543                                        pAppData->pOutPortDef->nBufferSize);
1544            VIDENCTEST_CHECK_EXIT(eError, "Error from OMX_AllocateBuffer function");
1545        }
1546    }
1547
1548    pAppData->nOutBufferCount = NUM_OF_OUT_BUFFERS;
1549
1550    pAppData->bLastOutBuffer = 0;
1551
1552
1553EXIT:
1554    return eError;
1555
1556}
1557
1558/*-----------------------------------------------------------------------------*/
1559/**
1560  * PassToExecuting()
1561  *
1562  *Pass the component to executing  and fill the first 4 buffers.
1563  *
1564  * @param  pAppData MYDATA handle
1565  *
1566  * @retval OMX_ErrorNone
1567  *
1568  *
1569  **/
1570/*-----------------------------------------------------------------------------*/
1571OMX_ERRORTYPE VIDENCTEST_Starting(MYDATATYPE* pAppData)
1572{
1573    OMX_ERRORTYPE eError = OMX_ErrorNone;
1574    OMX_HANDLETYPE pHandle;
1575    OMX_U32 nCounter = 0;
1576    OMX_U32 nBuffersToSend;
1577
1578    pHandle = pAppData->pHandle;
1579    pAppData->pComponent = (OMX_COMPONENTTYPE*)pHandle;
1580
1581    /* SR10519/17735: Set the interval for the insertion of intra frames at run-time using a custom OMX index */
1582    eError = OMX_GetExtensionIndex(pHandle,"OMX.TI.VideoEncode.Config.IntraFrameInterval", (OMX_INDEXTYPE*)(&(pAppData->nVideoEncodeCustomParamIndex)));
1583    VIDENCTEST_CHECK_EXIT(eError, "Error in OMX_GetExtensionIndex function");
1584
1585   /* MPEG4/H263 DSP socket node default value */
1586    if(pAppData->nIntraFrameInterval == VIDENCTEST_USE_DEFAULT_VALUE){
1587            pAppData->nIntraFrameInterval = 30;
1588    }
1589    eError = OMX_SetConfig(pHandle, pAppData->nVideoEncodeCustomParamIndex, &(pAppData->nIntraFrameInterval));
1590    VIDENCTEST_CHECK_EXIT(eError, "Error in OMX_SetConfig function");
1591
1592    /* This test only applies to MPEG4/H.263 encoding */
1593    if (pAppData->eCompressionFormat == OMX_VIDEO_CodingMPEG4 ||
1594        pAppData->eCompressionFormat == OMX_VIDEO_CodingH263) {
1595        /* SR10540: Set the Target Frame Rate at run-time using a custom OMX index */
1596        eError = OMX_GetExtensionIndex(pHandle,
1597                                       "OMX.TI.VideoEncode.Config.TargetFrameRate",
1598                                       (OMX_INDEXTYPE*)(&(pAppData->nVideoEncodeCustomParamIndex)));
1599        VIDENCTEST_CHECK_EXIT(eError, "Error in OMX_GetExtensionIndex function");
1600
1601        pAppData->nTargetFrameRate = pAppData->nFramerate; /* Refer to DSP socket node interface guide for usage */
1602        eError = OMX_SetConfig(pHandle, pAppData->nVideoEncodeCustomParamIndex, &(pAppData->nTargetFrameRate));
1603        VIDENCTEST_CHECK_EXIT(eError, "Error in OMX_SetConfig function");
1604    }
1605
1606    /* SR10523: Set the AIRRate at run-time using a custom OMX index */
1607    eError = OMX_GetExtensionIndex(pHandle,
1608                                   "OMX.TI.VideoEncode.Config.AIRRate",
1609                                   (OMX_INDEXTYPE*)(&(pAppData->nVideoEncodeCustomParamIndex)));
1610    VIDENCTEST_CHECK_EXIT(eError, "Error in OMX_GetExtensionIndex function");
1611    pAppData->nAIRRate = 0; /* Refer to DSP socket node interface guide for usage */
1612    eError = OMX_SetConfig(pHandle, pAppData->nVideoEncodeCustomParamIndex, &(pAppData->nAIRRate));
1613    VIDENCTEST_CHECK_EXIT(eError, "Error in OMX_SetConfig function");
1614
1615    /* SR12005: Set the Target Bit Rate at run-time using a custom OMX index */
1616    eError = OMX_GetExtensionIndex(pHandle,"OMX.TI.VideoEncode.Config.TargetBitRate", (OMX_INDEXTYPE*)(&(pAppData->nVideoEncodeCustomParamIndex)));
1617    VIDENCTEST_CHECK_EXIT(eError, "Error in OMX_GetExtensionIndex function");
1618
1619    pAppData->nTargetBitRate = pAppData->nBitrate; /* Refer to DSP socket node interface guide for usage */
1620    eError = OMX_SetConfig(pHandle, pAppData->nVideoEncodeCustomParamIndex, &(pAppData->nTargetBitRate));
1621    VIDENCTEST_CHECK_EXIT(eError, "Error in OMX_SetConfig function");
1622
1623    /*Initialize Frame Counter */
1624    pAppData->nCurrentFrameIn = 0;
1625    pAppData->nCurrentFrameOut = 0;
1626
1627
1628    /*Validation of stopframe in cases of Pause->Resume and Stop->Restart test cases*/
1629    if ( pAppData->eTypeOfTest == VIDENCTEST_StopRestart || pAppData->eTypeOfTest == VIDENCTEST_PauseResume) {
1630        if (pAppData->nReferenceFrame <= 1 ){
1631            nBuffersToSend = 1;
1632        }
1633        else if (pAppData->nReferenceFrame < NUM_OF_IN_BUFFERS){
1634            nBuffersToSend = pAppData->nReferenceFrame;
1635        }
1636        else {
1637            nBuffersToSend = NUM_OF_IN_BUFFERS;
1638        }
1639    }
1640    else {
1641        nBuffersToSend = NUM_OF_IN_BUFFERS;
1642    }
1643        /* Send FillThisBuffertoOMXVideoEncoder */
1644
1645        if (pAppData->eTypeOfTest == VIDENCTEST_PartialRecord && pAppData->nReferenceFrame < NUM_OF_IN_BUFFERS) {
1646            nBuffersToSend = pAppData->nReferenceFrame;
1647            }
1648
1649
1650
1651    for (nCounter = 0; nCounter < nBuffersToSend; nCounter++) {
1652        pAppData->pOutBuff[nCounter]->nFilledLen = 0;
1653        eError = pAppData->pComponent->FillThisBuffer(pHandle, pAppData->pOutBuff[nCounter]);
1654        VIDENCTEST_CHECK_EXIT(eError, "Error in FillThisBuffer");
1655        pAppData->nOutBufferCount--;
1656    }
1657
1658    /* Send EmptyThisBuffer to OMX Video Encoder */
1659    for (nCounter = 0; nCounter < nBuffersToSend; nCounter++) {
1660        pAppData->pInBuff[nCounter]->nFilledLen = VIDENCTEST_fill_data(pAppData->pInBuff[nCounter], pAppData->fIn , pAppData->pInPortDef->nBufferSize);
1661
1662        if (pAppData->pInBuff[nCounter]->nFlags == OMX_BUFFERFLAG_EOS && pAppData->pInBuff[nCounter]->nFilledLen == 0) {
1663            pAppData->eCurrentState = VIDENCTEST_StateStopping;
1664            eError = pAppData->pComponent->EmptyThisBuffer(pHandle, pAppData->pInBuff[nCounter]);
1665            VIDENCTEST_CHECK_ERROR(eError, "Error at EmptyThisBuffer function");
1666            pAppData->nInBufferCount--;
1667            goto EXIT;
1668        }
1669        else {
1670            pAppData->pComponent->EmptyThisBuffer(pHandle, pAppData->pInBuff[nCounter]);
1671            pAppData->nInBufferCount--;
1672            pAppData->nCurrentFrameIn++;
1673        }
1674    }
1675
1676    pAppData->eCurrentState = VIDENCTEST_StateEncoding;
1677
1678EXIT:
1679    return eError;
1680}
1681
1682/*-----------------------------------------------------------------------------*/
1683/**
1684  * DeInit()
1685  *
1686  *Pass the component to executing  and fill the first 4 buffers.
1687  *
1688  * @param  pAppData MYDATA handle
1689  *
1690  * @retval OMX_ErrorNone
1691  *
1692  *
1693  **/
1694/*-----------------------------------------------------------------------------*/
1695 OMX_ERRORTYPE VIDENCTEST_DeInit(MYDATATYPE* pAppData)
1696 {
1697    OMX_ERRORTYPE eError = OMX_ErrorNone;
1698    OMX_ERRORTYPE eErr = OMX_ErrorNone;
1699    VIDENCTEST_NODE* pListHead;
1700    OMX_HANDLETYPE pHandle = pAppData->pHandle;
1701    pListHead = pAppData->pMemoryListHead;
1702
1703    /* Free Component Handle */
1704    eError = TIOMX_FreeHandle(pHandle);
1705    VIDENCTEST_CHECK_EXIT(eError, "Error in TIOMX_FreeHandle");
1706
1707    /* De-Initialize OMX Core */
1708    eError = TIOMX_Deinit();
1709    VIDENCTEST_CHECK_EXIT(eError, "Error in TIOMX_Deinit");
1710
1711    /* shutdown */
1712    fclose(pAppData->fIn);
1713    fclose(pAppData->fOut);
1714    if(pAppData->NalFormat == VIDENC_TEST_NAL_FRAME || pAppData->NalFormat == VIDENC_TEST_NAL_SLICE) {
1715        fclose(pAppData->fNalnd);
1716    }
1717
1718    eErr = close(pAppData->IpBuf_Pipe[0]);
1719    if (0 != eErr && OMX_ErrorNone == eError) {
1720        eError = OMX_ErrorHardware;
1721        VIDENCTEST_DPRINT ("Error while closing data pipe\n");
1722    }
1723
1724    eErr = close(pAppData->OpBuf_Pipe[0]);
1725    if (0 != eErr && OMX_ErrorNone == eError) {
1726        eError = OMX_ErrorHardware;
1727        VIDENCTEST_DPRINT ("Error while closing data pipe\n");
1728    }
1729
1730    eErr = close(pAppData->eventPipe[0]);
1731    if (0 != eErr && OMX_ErrorNone == eError) {
1732        eError = OMX_ErrorHardware;
1733        VIDENCTEST_DPRINT ("Error while closing data pipe\n");
1734    }
1735
1736    eErr = close(pAppData->IpBuf_Pipe[1]);
1737    if (0 != eErr && OMX_ErrorNone == eError) {
1738        eError = OMX_ErrorHardware;
1739        VIDENCTEST_DPRINT ("Error while closing data pipe\n");
1740    }
1741
1742    eErr = close(pAppData->OpBuf_Pipe[1]);
1743    if (0 != eErr && OMX_ErrorNone == eError) {
1744        eError = OMX_ErrorHardware;
1745        VIDENCTEST_DPRINT ("Error while closing data pipe\n");
1746    }
1747
1748    eErr = close(pAppData->eventPipe[1]);
1749    if (0 != eErr && OMX_ErrorNone == eError) {
1750        eError = OMX_ErrorHardware;
1751        VIDENCTEST_DPRINT ("Error while closing data pipe\n");
1752    }
1753
1754    pAppData->fIn = NULL;
1755    pAppData->fOut = NULL;
1756    pAppData->fNalnd = NULL;
1757
1758    VIDENCTEST_FreeResources(pAppData);
1759    VIDENCTEST_CHECK_EXIT(eError, "Error in FillThisBuffer");
1760
1761    VIDENCTEST_FREE(pAppData, pListHead);
1762    VIDENCTEST_ListDestroy(pListHead);
1763    pAppData = NULL;
1764
1765EXIT:
1766    return eError;
1767
1768}
1769
1770/*-----------------------------------------------------------------------------*/
1771/**
1772  * HandleState()
1773  *
1774  *StateTransitions Driven.
1775  *
1776  * @param  pAppData
1777  * @param  nData2 - State that has been set.
1778  *
1779  * @retval OMX_ErrorNone
1780  *
1781  *
1782  **/
1783/*-----------------------------------------------------------------------------*/
1784OMX_ERRORTYPE VIDENCTEST_HandleState(MYDATATYPE* pAppData, OMX_U32 eState)
1785{
1786    OMX_ERRORTYPE eError = OMX_ErrorNone;
1787    OMX_HANDLETYPE pHandle = pAppData->pHandle;
1788    OMX_U32 nCounter = 0;
1789    VIDENCTEST_NODE* pListHead;
1790
1791    pListHead = pAppData->pMemoryListHead;
1792
1793    switch (eState) {
1794        case OMX_StateLoaded:
1795            VIDENCTEST_PRINT("Component in OMX_StateLoaded\n");
1796            if(pAppData->eCurrentState == VIDENCTEST_StateLoaded) {
1797                pAppData->eCurrentState = VIDENCTEST_StateUnLoad;
1798            }
1799            break;
1800        case OMX_StateIdle:
1801            VIDENCTEST_PRINT("Component in OMX_StateIdle\n");
1802            if (pAppData->eCurrentState == VIDENCTEST_StateLoaded) {
1803                pAppData->eCurrentState = VIDENCTEST_StateReady;
1804                VIDENCTEST_PRINT("Send Component to OMX_StateExecuting\n");
1805                eError = OMX_SendCommand(pHandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
1806                VIDENCTEST_CHECK_EXIT(eError, "Error from OMX_SendCommand function\n");
1807            }
1808            else if(pAppData->eCurrentState == VIDENCTEST_StateWaitEvent){
1809                if(pAppData->bStop == OMX_TRUE){
1810                    int count;
1811                    VIDENCTEST_PRINT("Component in OMX_StateStop\n");
1812                    pAppData->eCurrentState = VIDENCTEST_StateStop;
1813                    /*printf("Press any key to resume...");*/
1814                    /*getchar();*/
1815                    for(count = 5; count >= 0; count--) {
1816                        printf("App stopped: restart in %d seconds\n", count);
1817                        sleep(1);
1818                    }
1819                    pAppData->bStop = OMX_FALSE;
1820                }
1821
1822                VIDENCTEST_PRINT("Disable Input Port\n");
1823                eError = OMX_SendCommand(pHandle, OMX_CommandPortDisable, VIDENC_INPUT_PORT, NULL);
1824                VIDENCTEST_CHECK_EXIT(eError, "Error from OMX_SendCommand function\n");
1825
1826                if (pAppData->bAllocateIBuf == OMX_TRUE) {
1827                    for (nCounter = 0; nCounter < NUM_OF_IN_BUFFERS; nCounter++) {
1828                        pAppData->pIBuffer[nCounter] -= 128;
1829                        pAppData->pIBuffer[nCounter] = (unsigned char*)pAppData->pIBuffer[nCounter];
1830                        VIDENCTEST_FREE(pAppData->pIBuffer[nCounter], pListHead);
1831                        pAppData->pIBuffer[nCounter] = NULL;
1832                    }
1833                }
1834                for (nCounter = 0; nCounter < NUM_OF_IN_BUFFERS; nCounter++) {
1835                    eError = OMX_FreeBuffer(pHandle, pAppData->pInPortDef->nPortIndex, pAppData->pInBuff[nCounter]);
1836                }
1837            }
1838            break;
1839        case OMX_StateExecuting:
1840        VIDENCTEST_PRINT("Component in OMX_StateExecuting\n");
1841                pAppData->eCurrentState = VIDENCTEST_StateStarting;
1842                eError = VIDENCTEST_Starting(pAppData);
1843            break;
1844        case OMX_StatePause:
1845            VIDENCTEST_PRINT("Component in OMX_StatePause\n");
1846            pAppData->eCurrentState = VIDENCTEST_StatePause;
1847            /*printf("Press any key to resume...");*/
1848            /*getchar();*/
1849            int count;
1850            for(count = 5; count >= 0; count--) {
1851                printf("App paused: resume in %d seconds\n", count);
1852                sleep(1);
1853            }
1854            pAppData->bStop = OMX_FALSE;
1855            eError = OMX_SendCommand(pHandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
1856            break;
1857        case OMX_StateWaitForResources:
1858        VIDENCTEST_PRINT("Component in OMX_StateWaitForResources\n");
1859            break;
1860        case OMX_StateInvalid:
1861        VIDENCTEST_PRINT("Component in OMX_StateInvalid\n");
1862             eError = OMX_ErrorInvalidState;
1863        }
1864
1865EXIT:
1866    return eError;
1867}
1868
1869/*-----------------------------------------------------------------------------*/
1870/**
1871  * CheckArgs_H263()
1872  *
1873  *Validates h.263 input parameters
1874  *
1875  * @param  pAppData
1876  * @param  argv
1877  *
1878  * @retval OMX_ErrorNone
1879  *
1880  *
1881  **/
1882/*-----------------------------------------------------------------------------*/
1883OMX_ERRORTYPE VIDENCTEST_CheckArgs_H263(MYDATATYPE* pAppData, char** argv)
1884{
1885    OMX_ERRORTYPE eError = OMX_ErrorNone;
1886
1887    switch (atoi(argv[9])) {
1888        case 0:
1889            pAppData->eControlRate = OMX_Video_ControlRateDisable;
1890            break;
1891        case 1:
1892            pAppData->eControlRate = OMX_Video_ControlRateVariable;
1893            break;
1894        case 2:
1895            pAppData->eControlRate = OMX_Video_ControlRateConstant;
1896            break;
1897        default:
1898            eError = OMX_ErrorBadParameter;
1899            printf("*Error: Input Argument CONTROL RATE is not valid");
1900            goto EXIT;
1901    }
1902
1903    pAppData->nGOBHeaderInterval = atoi(argv[10]);
1904    pAppData->nQpI = atoi(argv[11]);
1905
1906    switch (atoi(argv[12])) {
1907        case 10:
1908            pAppData->eLevelH63 = OMX_VIDEO_H263Level10;
1909            break;
1910        case 20:
1911            pAppData->eLevelH63 = OMX_VIDEO_H263Level20;
1912            break;
1913        case 30:
1914            pAppData->eLevelH63 = OMX_VIDEO_H263Level30;
1915            break;
1916        case 40:
1917            pAppData->eLevelH63 = OMX_VIDEO_H263Level40;
1918            break;
1919        case 45:
1920            pAppData->eLevelH63 = OMX_VIDEO_H263Level45;
1921            break;
1922        case 50:
1923            pAppData->eLevelH63 = OMX_VIDEO_H263Level50;
1924            break;
1925        case 60:
1926            pAppData->eLevelH63 = OMX_VIDEO_H263Level60;
1927            break;
1928        case 70:
1929            pAppData->eLevelH63 = OMX_VIDEO_H263Level70;
1930            break;
1931        default:
1932            eError = OMX_ErrorBadParameter;
1933            printf("*Error: Input Argument LEVEL is not valid");
1934            goto EXIT;
1935    }
1936
1937    if (atoi(argv[13]) == 0) {
1938        pAppData->bAllocateIBuf = OMX_FALSE;
1939        pAppData->bAllocateOBuf = OMX_FALSE;
1940    }
1941    else {
1942        pAppData->bAllocateIBuf = OMX_TRUE;
1943        pAppData->bAllocateOBuf = OMX_TRUE;
1944    }
1945
1946    pAppData->nVBVSize = atoi(argv[14]);
1947
1948
1949EXIT:
1950    return eError;
1951}
1952
1953/*-----------------------------------------------------------------------------*/
1954/**
1955  * CheckArgs_Mpeg4()
1956  *
1957  *Validates Mpeg4 input parameters
1958  *
1959  * @param  pAppData
1960  * @param  argv
1961  *
1962  * @retval OMX_ErrorNone
1963  *
1964  *
1965  **/
1966/*-----------------------------------------------------------------------------*/
1967OMX_ERRORTYPE VIDENCTEST_CheckArgs_Mpeg4(MYDATATYPE* pAppData, char** argv)
1968{
1969    OMX_ERRORTYPE eError = OMX_ErrorNone;
1970
1971    switch (atoi(argv[9])) {
1972        case 0:
1973            pAppData->eControlRate = OMX_Video_ControlRateDisable;
1974            break;
1975        case 1:
1976            pAppData->eControlRate = OMX_Video_ControlRateVariable;
1977            break;
1978        case 2:
1979            pAppData->eControlRate = OMX_Video_ControlRateConstant;
1980            break;
1981        default:
1982            eError = OMX_ErrorBadParameter;
1983            printf("*Error: Input Argument CONTROL RATE is not valid");
1984            goto EXIT;
1985    }
1986
1987    pAppData->nQpI = atoi(argv[11]);
1988
1989#if 0
1990   pAppData->eLevelMpeg4 = atoi(argv[12]);
1991
1992#else
1993    switch (atoi(argv[12])) {
1994        case 0:
1995            pAppData->eLevelMpeg4 = OMX_VIDEO_MPEG4Level0;
1996            break;
1997        case 1:
1998            pAppData->eLevelMpeg4 = OMX_VIDEO_MPEG4Level1;
1999            break;
2000        case 2:
2001            pAppData->eLevelMpeg4 = OMX_VIDEO_MPEG4Level2;
2002            break;
2003        case 3:
2004            pAppData->eLevelMpeg4 = OMX_VIDEO_MPEG4Level3;
2005            break;
2006        case 4:
2007            pAppData->eLevelMpeg4 = OMX_VIDEO_MPEG4Level4;
2008            break;
2009        case 5:
2010            pAppData->eLevelMpeg4 = OMX_VIDEO_MPEG4Level5;
2011            break;
2012        case 100:
2013            pAppData->eLevelMpeg4 = OMX_VIDEO_MPEG4Level0b;
2014            break;
2015        default:
2016            eError = OMX_ErrorBadParameter;
2017            printf("*Error: Input Argument LEVEL is not valid");
2018            goto EXIT;
2019        }
2020#endif
2021
2022
2023    if (atoi(argv[13]) == 0) {
2024        pAppData->bAllocateIBuf = OMX_FALSE;
2025        pAppData->bAllocateOBuf = OMX_FALSE;
2026    }
2027    else {
2028        pAppData->bAllocateIBuf = OMX_TRUE;
2029        pAppData->bAllocateOBuf = OMX_TRUE;
2030    }
2031
2032    pAppData->nVBVSize = atoi(argv[14]);
2033
2034
2035EXIT:
2036    return eError;
2037}
2038
2039/*-----------------------------------------------------------------------------*/
2040/**
2041  * CheckArgs_AVC()
2042  *
2043  *Validates Mpeg4 input parameters
2044  *
2045  * @param  pAppData
2046  * @param  argv
2047  *
2048  * @retval OMX_ErrorNone
2049  *
2050  *
2051  **/
2052/*-----------------------------------------------------------------------------*/
2053OMX_ERRORTYPE VIDENCTEST_CheckArgs_AVC(MYDATATYPE* pAppData, char** argv)
2054{
2055    OMX_ERRORTYPE eError = OMX_ErrorNone;
2056
2057    switch (atoi(argv[9])) {
2058        case 10:
2059            pAppData->eLevelH264 = OMX_VIDEO_AVCLevel1;
2060            break;
2061        case 11:
2062            pAppData->eLevelH264 = OMX_VIDEO_AVCLevel11;
2063            break;
2064        case 12:
2065            pAppData->eLevelH264 = OMX_VIDEO_AVCLevel12;
2066            break;
2067        case 13:
2068            pAppData->eLevelH264 = OMX_VIDEO_AVCLevel13;
2069            break;
2070        case 20:
2071            pAppData->eLevelH264 = OMX_VIDEO_AVCLevel2;
2072            break;
2073        case 21:
2074            pAppData->eLevelH264 = OMX_VIDEO_AVCLevel21;
2075            break;
2076        case 22:
2077            pAppData->eLevelH264 = OMX_VIDEO_AVCLevel22;
2078            break;
2079        case 30:
2080            pAppData->eLevelH264 = OMX_VIDEO_AVCLevel3;
2081            break;
2082        case 9:
2083            pAppData->eLevelH264 = OMX_VIDEO_AVCLevel1b;
2084            break;
2085        default:
2086            eError = OMX_ErrorBadParameter;
2087            printf("*Error: Input Argument CONTROL RATE is not valid");
2088            goto EXIT;
2089    }
2090
2091    pAppData->nOutBuffSize  = atoi(argv[10]);
2092
2093    if (atoi(argv[11]) == 0) {
2094        pAppData->bAllocateIBuf = OMX_FALSE;
2095        pAppData->bAllocateOBuf = OMX_FALSE;
2096    }
2097    else {
2098        pAppData->bAllocateIBuf = OMX_TRUE;
2099        pAppData->bAllocateOBuf = OMX_TRUE;
2100    }
2101
2102    if (atoi(argv[12]) == 0) {
2103            pAppData->bDeblockFilter = OMX_FALSE;
2104    }
2105    else if (atoi(argv[12]) == 1) {
2106        pAppData->bDeblockFilter = OMX_TRUE;
2107    }
2108    else {
2109        eError = OMX_ErrorBadParameter;
2110        printf("*Error: Input Argument DEBLOCK FILTER is not valid");
2111        goto EXIT;
2112    }
2113
2114
2115    switch (atoi(argv[13])) {
2116        case 0:
2117            pAppData->eControlRate = OMX_Video_ControlRateDisable;
2118            break;
2119        case 1:
2120            pAppData->eControlRate = OMX_Video_ControlRateVariable;
2121            break;
2122        case 2:
2123            pAppData->eControlRate = OMX_Video_ControlRateConstant;
2124            break;
2125        default:
2126            ;
2127    }
2128
2129    pAppData->nQpI = atoi(argv[14]);
2130
2131EXIT:
2132    return eError;
2133}
2134
2135/*-----------------------------------------------------------------------------*/
2136/**
2137  * VIDENCTEST_CheckOptionalArgs()
2138  *
2139  *Validates input argument from user.
2140  *
2141  * @param  argc
2142  * @param  argv
2143  *
2144  * @retval OMX_ErrorNone
2145  *
2146  *
2147  **/
2148/*-----------------------------------------------------------------------------*/
2149
2150
2151OMX_ERRORTYPE VIDENCTEST_CheckOptionalArgs(MYDATATYPE* pAppData, int argc, char* argv []){
2152    OMX_ERRORTYPE eError = OMX_ErrorNone;
2153    int next_option;
2154    const char* const short_options = "m:r:i:p:e:n";
2155    const struct option long_options[] = {
2156        {"nMIRRate",    1, NULL, 'm'},
2157        {"nResyncMarker",   1, NULL, 'r'},
2158        {"nIntraFrameInterval",   1, NULL, 'i'},
2159        {"nEncodingPreset",   1, NULL, 'p'},
2160        {"nRrker",   1, NULL, 'e'},
2161        {"NALFormat",   1, NULL, 'n'},
2162        {"nQPIoF", 1, NULL, 'q'},
2163        {"nUnrestrictedMV", 1, NULL, 'u'},
2164        {NULL,          0, NULL,   0}
2165    };
2166
2167    VIDENCTEST_PRINT("checking for optional args\n");
2168    do
2169        {
2170        next_option = getopt_long(argc, argv, short_options, long_options, NULL);
2171        switch (next_option)
2172            {
2173            case 'm':
2174                printf("%d MIRRate found, Value= %s\n",next_option,optarg);
2175                pAppData->nMIRRate=atoi(optarg);
2176                break;
2177            case 'r':
2178                printf("%d ResyncMarker found, Value= %s\n",next_option,optarg);
2179                pAppData->nResynchMarkerSpacing=atoi(optarg);
2180                break;
2181            case 'i':
2182                printf("%d IntraFrameInterval found, Value= %s\n",next_option,optarg);
2183                pAppData->nIntraFrameInterval=atoi(optarg);
2184                break;
2185            case 'p':
2186                if(pAppData->eCompressionFormat == OMX_VIDEO_CodingAVC){
2187                    printf("%d EncodingPreset found, Value= %s\n",next_option,optarg);
2188                    pAppData->nEncodingPreset=atoi(optarg);
2189                    }
2190                else
2191                    printf("** Warning: EncodingPreset valid only for H264. Proceeding with test.\n");
2192                break;
2193            case 'n':
2194                printf("%d Nal Format found, Value= %s\n",next_option,optarg);
2195                pAppData->NalFormat=atoi(optarg);
2196                break;
2197            case 'q':
2198                printf("%d QPI value changed each %d frames\n",next_option,atoi(optarg));
2199                pAppData->nQPIoF=atoi(optarg);
2200            case 'u':
2201                printf("%d nUnrestrictedMV found, Value= %s\n",next_option,optarg);
2202                pAppData->nUnrestrictedMV=atoi(optarg);
2203                break;
2204            case -1:
2205                break;
2206            default:
2207                printf("** Warning: %d No valid param found. Proceeding with test. optarg= %s\n",next_option,optarg);
2208
2209            }
2210
2211    }
2212    while(next_option != -1);
2213
2214    return eError;
2215
2216}
2217
2218/*-----------------------------------------------------------------------------*/
2219/**
2220  * CheckArgs()
2221  *
2222  *Validates input argument from user.
2223  *
2224  * @param  argc
2225  * @param  argv
2226  * @param pAppDataTmp
2227  *
2228  * @retval OMX_ErrorNone
2229  *
2230  *
2231  **/
2232/*-----------------------------------------------------------------------------*/
2233OMX_ERRORTYPE VIDENCTEST_CheckArgs(int argc, char** argv, MYDATATYPE** pAppDataTmp)
2234{
2235    OMX_ERRORTYPE eError = OMX_ErrorNone;
2236    VIDENCTEST_NODE*  pMemoryListHead;
2237    MYDATATYPE* pAppData;
2238
2239    eError = VIDENCTEST_ListCreate(&pMemoryListHead);
2240    VIDENCTEST_CHECK_EXIT(eError, "Error at Creating Memory List");
2241
2242    VIDENCTEST_MALLOC(pAppData, sizeof(MYDATATYPE), MYDATATYPE, pMemoryListHead);
2243    VIDENCTEST_CHECK_EXIT(eError, "Error at Allocating MYDATATYPE structure");
2244    *pAppDataTmp = pAppData;
2245    pAppData->pMemoryListHead = pMemoryListHead;
2246    pAppData->eCurrentState = VIDENCTEST_StateUnLoad;
2247    pAppData->nMIRRate=VIDENCTEST_USE_DEFAULT_VALUE;
2248    pAppData->nResynchMarkerSpacing=VIDENCTEST_USE_DEFAULT_VALUE;
2249    pAppData->nIntraFrameInterval=VIDENCTEST_USE_DEFAULT_VALUE;
2250    pAppData->nEncodingPreset=VIDENCTEST_USE_DEFAULT_VALUE_UI;
2251    pAppData->nUnrestrictedMV=(OMX_U8)VIDENCTEST_USE_DEFAULT_VALUE_UI;
2252    pAppData->NalFormat = 0;
2253    pAppData->nQPIoF = 0;
2254    pAppData->bForceIFrame = 0;
2255
2256
2257    if (argc < 15){
2258        printf("*Error: Input argument COLOR FORMAT is not valid");
2259        VIDENCTEST_PrintCorrectArgs(OMX_TRUE, OMX_TRUE);
2260        eError = OMX_ErrorBadParameter;
2261        goto EXIT;
2262    }
2263    else {
2264
2265        pAppData->szInFile = argv[1];
2266        pAppData->fIn = fopen(pAppData->szInFile, "r");
2267        if (!pAppData->fIn) {
2268            printf("Error: failed to open the file <%s>", pAppData->szInFile);
2269            eError = OMX_ErrorBadParameter;
2270            goto EXIT;
2271        }
2272
2273        pAppData->szOutFile = argv[2];
2274        pAppData->fOut = fopen(pAppData->szOutFile, "w");
2275        if (!pAppData->fOut) {
2276            VIDENCTEST_DPRINT("Error: failed to open the file <%s>", pAppData->szOutFile);
2277            eError = OMX_ErrorBadParameter;
2278            goto EXIT;
2279        }
2280
2281        pAppData->nWidth = atoi(argv[3]);
2282        if (pAppData->nWidth & 15) {
2283            printf("**Warning: Input Argument WIDTH is not multiple of 16. \n");
2284        }
2285
2286        pAppData->nHeight = atoi(argv[4]);
2287        if (pAppData->nHeight & 15) {
2288            printf("**Warning: Input Argument HEIGHT is not multiple of 16. \n");
2289        }
2290
2291        switch (atoi(argv[5])) {
2292            case 19:
2293                pAppData->eColorFormat = OMX_COLOR_FormatYUV420Planar;/*420*/
2294                break;
2295            case 25:
2296                pAppData->eColorFormat = OMX_COLOR_FormatYCbYCr;/*422-BE*/
2297                break;
2298            case 26:
2299                pAppData->eColorFormat = OMX_COLOR_FormatCbYCrY;/*422-LE*/
2300                break;
2301            default:
2302                printf("*Error: Input Argument COLOR FORMAT is not valid");
2303                VIDENCTEST_PrintCorrectArgs(OMX_TRUE, OMX_TRUE);
2304                eError = OMX_ErrorBadParameter;
2305                goto EXIT;
2306        }
2307
2308        pAppData->nBitrate = atoi(argv[6]);
2309        if(pAppData->nBitrate > 10000000) {
2310            printf("**Warning: Input argument BITRATE outside of tested range, behavior of component unknown.\n");
2311        }
2312
2313        pAppData->nFramerate = atoi(argv[7]);
2314        if(pAppData->nFramerate < 7 || pAppData->nFramerate > 30) {
2315            printf("**Warning: Input argument FRAMERATE outside of tested range, behavior of component unknown.\n");
2316        }
2317
2318        switch (atoi(argv[8])) {
2319            case 3:
2320                pAppData->eCompressionFormat = OMX_VIDEO_CodingH263;
2321                eError = VIDENCTEST_CheckArgs_H263(pAppData, argv);
2322                VIDENCTEST_CHECK_EXIT(eError, "Error at Checking arguments for H263");
2323                break;
2324            case 4:
2325                pAppData->eCompressionFormat = OMX_VIDEO_CodingMPEG4;
2326                eError = VIDENCTEST_CheckArgs_Mpeg4(pAppData, argv);
2327                VIDENCTEST_CHECK_EXIT(eError, "Error at Checking arguments for MPEG4");
2328                break;
2329            case 7:
2330                pAppData->eCompressionFormat = OMX_VIDEO_CodingAVC;
2331                eError = VIDENCTEST_CheckArgs_AVC(pAppData, argv);
2332                VIDENCTEST_CHECK_EXIT(eError, "Error at Checking arguments for H264");
2333                break;
2334            default:
2335                printf("*Error: Input argument COLOR FORMAT is not valid");
2336                VIDENCTEST_PrintCorrectArgs(OMX_TRUE, OMX_TRUE);
2337                eError = OMX_ErrorBadParameter;
2338                goto EXIT;
2339        }
2340    }
2341
2342    if (argc < 16) {
2343        pAppData->eTypeOfTest = VIDENCTEST_FullRecord;
2344        printf("**Warning: Input Arguments TYPE OF TEST is not include input. Using Default value VIDENCTEST_FullRecord.\n");
2345    }
2346    else {
2347        switch (atoi(argv[15])){
2348            case 0:
2349                pAppData->eTypeOfTest = VIDENCTEST_FullRecord;
2350                pAppData->bStop = OMX_FALSE;
2351                break;
2352            case 1:
2353                pAppData->eTypeOfTest = VIDENCTEST_PartialRecord;
2354                pAppData->bStop = OMX_FALSE;
2355                break;
2356            case 2:
2357                pAppData->eTypeOfTest = VIDENCTEST_PauseResume;
2358                pAppData->bStop = OMX_TRUE;
2359                break;
2360            case 3:
2361                pAppData->eTypeOfTest = VIDENCTEST_StopRestart;
2362                pAppData->bStop = OMX_TRUE;
2363                break;
2364            default:
2365                pAppData->eTypeOfTest = VIDENCTEST_FullRecord;
2366                printf("**Warning: Input Argument TYPE OF TEST is out of range. Using Default value VIDENCTEST_FullRecord.\n");
2367        }
2368    }
2369
2370    if (argc < 17) {
2371        pAppData->nReferenceFrame = 0;
2372        printf("**Warning: Input Arguments nReferenceFrame has not been specified. Using Default value 0.\n");
2373    }
2374    else{
2375        pAppData->nReferenceFrame = atoi(argv[16]);
2376    }
2377
2378    if (argc < 18) {
2379        pAppData->nNumberOfTimesTodo = 1;
2380    }
2381    else{
2382        if(argv[17][0]<'0' || argv[17][0] > '9'){
2383            pAppData->nNumberOfTimesTodo = 1;
2384        }
2385        else{
2386            pAppData->nNumberOfTimesTodo  = atoi(argv[17]);
2387            VIDENCTEST_PRINT("nNumberOfTimesTodo %lu \n", pAppData->nNumberOfTimesTodo);
2388        }
2389    }
2390
2391    VIDENCTEST_CheckOptionalArgs(pAppData, argc, argv);
2392
2393    if(pAppData->NalFormat == VIDENC_TEST_NAL_FRAME || pAppData->NalFormat == VIDENC_TEST_NAL_SLICE) {
2394        VIDENCTEST_MALLOC(pAppData->szOutFileNal, strlen(pAppData->szOutFile)+3, char, pMemoryListHead);
2395        strcpy(pAppData->szOutFileNal, pAppData->szOutFile);
2396        strcat(pAppData->szOutFileNal, "nd");
2397        pAppData->fNalnd = fopen(pAppData->szOutFileNal, "w");
2398        if (!pAppData->szOutFileNal) {
2399            VIDENCTEST_DPRINT("Error: failed to open the file <%s>", pAppData->szOutFileNal);
2400            eError = OMX_ErrorBadParameter;
2401            goto EXIT;
2402        }
2403    }
2404
2405EXIT:
2406    return eError;
2407}
2408
2409/*-----------------------------------------------------------------------------*/
2410/**
2411  * Confirm()
2412  *
2413  *Check what type of test, repetions to be done and takes certain path.
2414  *
2415  * @param  argc
2416  * @param  argv
2417  * @param pAppDataTmp
2418  *
2419  * @retval OMX_ErrorNone
2420  *
2421  *
2422  **/
2423/*-----------------------------------------------------------------------------*/
2424OMX_ERRORTYPE VIDENCTEST_Confirm(MYDATATYPE* pAppData)
2425{
2426    OMX_ERRORTYPE eError = OMX_ErrorNone;
2427    OMX_HANDLETYPE pHandle = pAppData->pHandle;
2428
2429    switch (pAppData->eTypeOfTest){
2430        case VIDENCTEST_FullRecord:
2431        case VIDENCTEST_PartialRecord:
2432            pAppData->nNumberOfTimesDone++;
2433            if(pAppData->nNumberOfTimesTodo == pAppData->nNumberOfTimesDone) {
2434                pAppData->bExit = OMX_TRUE;
2435            }
2436            else {
2437                pAppData->bExit = OMX_FALSE;
2438                VIDENCTEST_PRINT("\nTimes Done: %i of %i \n", pAppData->nNumberOfTimesDone, pAppData->nNumberOfTimesTodo);
2439                pAppData->fOut = fopen(pAppData->szOutFile, "w");
2440                if(pAppData->NalFormat == VIDENC_TEST_NAL_FRAME || pAppData->NalFormat == VIDENC_TEST_NAL_SLICE) {
2441                    pAppData->fNalnd = fopen(pAppData->szOutFileNal, "w");
2442                }
2443                if (!pAppData->fIn){
2444                    VIDENCTEST_CHECK_EXIT(OMX_ErrorUndefined, "Error at fopen function");
2445                }
2446                rewind(pAppData->fIn);
2447            }
2448            eError = OMX_SendCommand(pHandle,OMX_CommandStateSet, OMX_StateIdle, NULL);
2449            VIDENCTEST_CHECK_EXIT(eError, "Error at OMX_SendCommand function");
2450            break;
2451        case VIDENCTEST_PauseResume:
2452        case VIDENCTEST_StopRestart:
2453            if (pAppData->bStop == OMX_TRUE) {
2454                if(pAppData->eTypeOfTest == VIDENCTEST_StopRestart) {
2455                    rewind(pAppData->fIn);
2456                    eError = OMX_SendCommand(pHandle,OMX_CommandStateSet, OMX_StateIdle, NULL);
2457                    VIDENCTEST_CHECK_EXIT(eError, "Error at OMX_SendCommand function");
2458                }
2459                else if (pAppData->eTypeOfTest == VIDENCTEST_PauseResume) {
2460                    eError = OMX_SendCommand(pHandle,OMX_CommandStateSet, OMX_StatePause, NULL);
2461                    VIDENCTEST_CHECK_EXIT(eError, "Error at OMX_SendCommand function");
2462                }
2463            }
2464            else {
2465                pAppData->nNumberOfTimesDone++;
2466                if(pAppData->nNumberOfTimesTodo == pAppData->nNumberOfTimesDone) {
2467                    pAppData->bExit = OMX_TRUE;
2468                }
2469                else {
2470                    pAppData->bExit = OMX_FALSE;
2471                    fprintf(stdout, "\nTimes Done: %lx of %lx \n", pAppData->nNumberOfTimesDone, pAppData->nNumberOfTimesTodo);
2472                    if(pAppData->eTypeOfTest == VIDENCTEST_StopRestart || pAppData->eTypeOfTest == VIDENCTEST_PauseResume) {
2473                        pAppData->bStop = OMX_TRUE;
2474                    }
2475                    else{
2476                        pAppData->bStop = OMX_FALSE;
2477                    }
2478
2479                    pAppData->fOut = fopen(pAppData->szOutFile, "w");
2480                    if (!pAppData->fOut){
2481                        VIDENCTEST_CHECK_EXIT(OMX_ErrorUndefined, "Error at fopen function");
2482                    }
2483                    if(pAppData->NalFormat == VIDENC_TEST_NAL_FRAME || pAppData->NalFormat == VIDENC_TEST_NAL_SLICE) {
2484                        pAppData->fNalnd = fopen(pAppData->szOutFileNal, "w");
2485                        if (!pAppData->fNalnd){
2486                            VIDENCTEST_CHECK_EXIT(OMX_ErrorUndefined, "Error at fopen function");
2487                        }
2488                    }
2489                    rewind(pAppData->fIn);
2490                }
2491                eError = OMX_SendCommand(pHandle,OMX_CommandStateSet, OMX_StateIdle, NULL);
2492                VIDENCTEST_CHECK_EXIT(eError, "Error at OMX_SendCommand function");
2493            }
2494        }
2495
2496        pAppData->eCurrentState = VIDENCTEST_StateWaitEvent;
2497
2498EXIT:
2499    return eError;
2500}
2501
2502/*-----------------------------------------------------------------------------*/
2503/**
2504  * HandlePortDisable()
2505  *
2506  *Handles PortDisable Event
2507  *
2508  * @param  argc
2509  * @param  argv
2510  * @param pAppDataTmp
2511  *
2512  * @retval OMX_ErrorNone
2513  *
2514  *
2515  **/
2516/*-----------------------------------------------------------------------------*/
2517OMX_ERRORTYPE VIDENCTEST_HandlePortDisable(MYDATATYPE* pAppData, OMX_U32 ePort)
2518{
2519    OMX_ERRORTYPE eError = OMX_ErrorNone;
2520    OMX_HANDLETYPE pHandle = pAppData->pHandle;
2521    OMX_U32 nCounter;
2522    VIDENCTEST_NODE* pListHead;
2523
2524    pAppData->nUnresponsiveCount = 0;
2525    pListHead = pAppData->pMemoryListHead;
2526
2527    if (ePort == VIDENC_INPUT_PORT){
2528        eError = OMX_SendCommand(pHandle, OMX_CommandPortDisable, VIDENC_OUTPUT_PORT, NULL);
2529        VIDENCTEST_CHECK_EXIT(eError, "Error at OMX_SendCommand function");
2530
2531        if (pAppData->bAllocateOBuf == OMX_TRUE) {
2532            for (nCounter = 0; nCounter < NUM_OF_OUT_BUFFERS; nCounter++) {
2533                pAppData->pOBuffer[nCounter] -= 128;
2534                pAppData->pOBuffer[nCounter] = (unsigned char*)pAppData->pOBuffer[nCounter];
2535                VIDENCTEST_FREE(pAppData->pOBuffer[nCounter], pListHead);
2536                pAppData->pOBuffer[nCounter] = NULL;
2537            }
2538        }
2539        for (nCounter = 0; nCounter < NUM_OF_OUT_BUFFERS; nCounter++) {
2540            eError = OMX_FreeBuffer(pHandle, pAppData->pOutPortDef->nPortIndex, pAppData->pOutBuff[nCounter]);
2541            VIDENCTEST_CHECK_EXIT(eError, "Error at OMX_FreeBuffer function");
2542        }
2543    }
2544    else if(ePort == VIDENC_OUTPUT_PORT) {
2545        if (pAppData->bExit == OMX_TRUE) {
2546            eError = OMX_SendCommand(pHandle,OMX_CommandStateSet, OMX_StateLoaded, NULL);
2547            VIDENCTEST_CHECK_EXIT(eError, "Error at OMX_SendCommand function");
2548            pAppData->eCurrentState = VIDENCTEST_StateLoaded;
2549        }
2550        else {
2551            eError = OMX_SendCommand(pHandle, OMX_CommandPortEnable, VIDENC_INPUT_PORT, NULL);
2552            VIDENCTEST_CHECK_EXIT(eError, "Error at OMX_SendCommand function");
2553
2554            for (nCounter = 0; nCounter < NUM_OF_IN_BUFFERS; nCounter++) {
2555                if (pAppData->bAllocateIBuf == OMX_TRUE) {
2556                    VIDENCTEST_MALLOC(pAppData->pIBuffer[nCounter], pAppData->nSizeIn + 256, OMX_U8, pListHead);
2557                    pAppData->pIBuffer[nCounter] += 128;
2558                    pAppData->pIBuffer[nCounter] = (unsigned char*)pAppData->pIBuffer[nCounter];
2559                }
2560            }
2561
2562            for (nCounter = 0; nCounter < NUM_OF_IN_BUFFERS; nCounter++) {
2563                if (pAppData->bAllocateIBuf == OMX_TRUE) {
2564                eError = OMX_UseBuffer(pHandle,
2565                                        &pAppData->pInBuff[nCounter],
2566                                        pAppData->pInPortDef->nPortIndex,
2567                                        pAppData,
2568                                        pAppData->pInPortDef->nBufferSize,
2569                                        pAppData->pIBuffer[nCounter]);
2570                VIDENCTEST_CHECK_EXIT(eError, "Error at OMX_UseBuffer function");
2571                }
2572                else {
2573                    eError = OMX_AllocateBuffer(pHandle,
2574                                                &pAppData->pInBuff[nCounter],
2575                                                pAppData->pInPortDef->nPortIndex,
2576                                                pAppData,
2577                                                pAppData->pInPortDef->nBufferSize);
2578                    VIDENCTEST_CHECK_EXIT(eError, "Error at OMX_AllocateBuffer function");
2579                }
2580            }
2581        }
2582    }
2583
2584
2585EXIT:
2586    return eError;
2587}
2588
2589/*-----------------------------------------------------------------------------*/
2590/**
2591  * HandlePortEnable()
2592  *
2593  *Handles PortEnable Event
2594  *
2595  * @param  pAppData
2596  * @param  nPort
2597  *
2598  * @retval OMX_ErrorNone
2599  *
2600  *
2601  **/
2602/*-----------------------------------------------------------------------------*/
2603OMX_ERRORTYPE VIDENCTEST_HandlePortEnable(MYDATATYPE* pAppData, OMX_U32 ePort)
2604{
2605    OMX_ERRORTYPE eError = OMX_ErrorNone;
2606    OMX_HANDLETYPE pHandle = pAppData->pHandle;
2607    OMX_U32 nCounter;
2608    VIDENCTEST_NODE* pListHead;
2609
2610    pAppData->nUnresponsiveCount = 0;
2611    pListHead = pAppData->pMemoryListHead;
2612
2613    if (ePort == VIDENC_INPUT_PORT){
2614        eError = OMX_SendCommand(pHandle, OMX_CommandPortEnable, VIDENC_OUTPUT_PORT, NULL);
2615        VIDENCTEST_CHECK_EXIT(eError, "Error at OMX_SendCommand function");
2616
2617        for (nCounter = 0; nCounter < NUM_OF_OUT_BUFFERS; nCounter++) {
2618            if (pAppData->bAllocateOBuf == OMX_TRUE) {
2619                VIDENCTEST_MALLOC(pAppData->pOBuffer[nCounter], pAppData->nSizeOut + 256, OMX_U8, pListHead);
2620                pAppData->pOBuffer[nCounter] += 128;
2621                pAppData->pOBuffer[nCounter] = (unsigned char*)pAppData->pOBuffer[nCounter];
2622            }
2623        }
2624
2625        for (nCounter = 0; nCounter < NUM_OF_OUT_BUFFERS; nCounter++) {
2626            if (pAppData->bAllocateOBuf == OMX_TRUE) {
2627                eError = OMX_UseBuffer(pHandle,
2628                                        &pAppData->pOutBuff[nCounter],
2629                                        pAppData->pOutPortDef->nPortIndex,
2630                                        pAppData,
2631                                        pAppData->pOutPortDef->nBufferSize,
2632                                        pAppData->pOBuffer[nCounter]);
2633                VIDENCTEST_CHECK_EXIT(eError, "Error at OMX_UseBuffer function");
2634            }
2635            else {
2636                eError = OMX_AllocateBuffer(pHandle,
2637                                            &pAppData->pOutBuff[nCounter],
2638                                            pAppData->pOutPortDef->nPortIndex,
2639                                            pAppData,
2640                                            pAppData->pOutPortDef->nBufferSize);
2641                VIDENCTEST_CHECK_EXIT(eError, "Error at OMX_AllocateBuffer function");
2642            }
2643        }
2644    }
2645    else if(ePort == VIDENC_OUTPUT_PORT){
2646        eError = OMX_SendCommand(pHandle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
2647        VIDENCTEST_CHECK_EXIT(eError, "Error at OMX_SendCommand function");
2648    }
2649
2650EXIT:
2651    return eError;
2652}
2653
2654/*-----------------------------------------------------------------------------*/
2655/**
2656  * HandlePortEnable()
2657  *
2658  *Handles PortEnable Event
2659  *
2660  * @param  pAppData
2661  * @param  nPort
2662  *
2663  * @retval OMX_ErrorNone
2664  *
2665  *
2666  **/
2667/*-----------------------------------------------------------------------------*/
2668OMX_ERRORTYPE VIDENCTEST_HandleEventError(MYDATATYPE* pAppData, OMX_U32 eErr, OMX_U32 nData2)
2669{
2670    OMX_ERRORTYPE eError = OMX_ErrorNone;
2671    VIDENCTEST_UNUSED_ARG(nData2);
2672    VIDENCTEST_PRINT("\n------VIDENCTEST ERROR-------\nOMX_EventError\n");
2673    VIDENCTEST_PRINT("eErr : %x \n", eErr);
2674    VIDENCTEST_PRINT("nData2 : %x \n", nData2);
2675
2676    switch (eErr){
2677     case OMX_ErrorNone:
2678        break;
2679     case OMX_ErrorInsufficientResources:
2680     case OMX_ErrorUndefined:
2681     case OMX_ErrorInvalidComponentName:
2682     case OMX_ErrorComponentNotFound:
2683     case OMX_ErrorInvalidComponent:
2684        eError = eErr;
2685        break;
2686     case OMX_ErrorBadParameter:
2687     case OMX_ErrorNotImplemented:
2688     case OMX_ErrorUnderflow:
2689     case OMX_ErrorOverflow:
2690        break;
2691     case OMX_ErrorInvalidState:
2692#ifdef DSP_MMU_FAULT_HANDLING
2693        bInvalid_state = OMX_TRUE;
2694#endif
2695     case OMX_ErrorHardware:
2696     case OMX_ErrorStreamCorrupt:
2697     case OMX_ErrorPortsNotCompatible:
2698     case OMX_ErrorResourcesLost:
2699     case OMX_ErrorNoMore:
2700     case OMX_ErrorVersionMismatch:
2701     case OMX_ErrorNotReady:
2702     case OMX_ErrorTimeout:
2703     case OMX_ErrorSameState:
2704     case OMX_ErrorResourcesPreempted:
2705        eError = eErr;
2706        break;
2707     case OMX_ErrorPortUnresponsiveDuringAllocation:
2708     case OMX_ErrorPortUnresponsiveDuringDeallocation:
2709     case OMX_ErrorPortUnresponsiveDuringStop:
2710        if(pAppData->nUnresponsiveCount++ > MAX_UNRESPONSIVE_COUNT){
2711            eError = eErr;
2712        }
2713        break;
2714     case OMX_ErrorIncorrectStateTransition:
2715     case OMX_ErrorIncorrectStateOperation:
2716     case OMX_ErrorUnsupportedSetting:
2717     case OMX_ErrorUnsupportedIndex:
2718     case OMX_ErrorBadPortIndex:
2719     case OMX_ErrorMax:
2720     default:
2721        ;
2722    }
2723
2724    return eError;
2725 }
2726
2727
2728/*-----------------------------------------------------------------------------*/
2729/**
2730  * Main()
2731  *
2732  *Control flow of the Stand Alone Test Application
2733  *
2734  * @param  argc
2735  * @param argv
2736  *
2737  * @retval OMX_ErrorNone
2738  *
2739  *
2740  **/
2741/*-----------------------------------------------------------------------------*/
2742int main(int argc, char** argv)
2743{
2744    OMX_ERRORTYPE eError = OMX_ErrorNone;
2745    OMX_HANDLETYPE pHandle;
2746    OMX_BUFFERHEADERTYPE* pBuffer;
2747    OMX_U32 nError;
2748    OMX_U32 nTimeCount;
2749    MYDATATYPE* pAppData;
2750    fd_set rfds;
2751    VIDENCTEST_NODE* pListHead;
2752    sigset_t set;
2753
2754    nTimeCount = 0;
2755#ifdef DSP_MMU_FAULT_HANDLING
2756    bInvalid_state = OMX_FALSE;
2757#endif
2758    OMX_OTHER_EXTRADATATYPE_1_1_2 *pExtraDataType;
2759    OMX_U8* pTemp;
2760    OMX_U32* pIndexNal;
2761    OMX_U32 nNalSlices;
2762
2763
2764    VIDENCTEST_PRINT("Enter to CheckArgs\n");
2765
2766    eError = VIDENCTEST_CheckArgs(argc, argv, &pAppData);
2767
2768    VIDENCTEST_CHECK_ERROR(eError, "Invalid Arguments");
2769    VIDENCTEST_PRINT("Exit to CheckArgs\n");
2770
2771    VIDENCTEST_PRINT("Enter to PassToLoaded\n");
2772    eError = VIDENCTEST_PassToLoaded(pAppData);
2773    VIDENCTEST_CHECK_ERROR(eError, "Error at Initialization of Component");
2774    VIDENCTEST_PRINT("Exit to PassToLoaded\n");
2775
2776    pListHead = pAppData->pMemoryListHead;
2777    pHandle = pAppData->pHandle;
2778
2779    VIDENCTEST_PRINT("Enter to PassToReady\n");
2780    eError = VIDENCTEST_PassToReady(pAppData);
2781    VIDENCTEST_CHECK_ERROR(eError, "Error at Passing to ComponentReady State");
2782    VIDENCTEST_PRINT("Exit to PassToReady\n");
2783
2784    while(1){
2785        FD_ZERO(&rfds);
2786        FD_SET(pAppData->IpBuf_Pipe[0], &rfds);
2787        FD_SET(pAppData->OpBuf_Pipe[0], &rfds);
2788        FD_SET(pAppData->eventPipe[0], &rfds);
2789
2790        sigemptyset(&set);
2791        sigaddset(&set,SIGALRM);
2792        pAppData->nRetVal = pselect(pAppData->fdmax+1, &rfds, NULL, NULL, NULL,&set);
2793
2794        if (pAppData->nRetVal == -1) {
2795            perror("pselect()");
2796            VIDENCTEST_DPRINT("Error\n");
2797            break;
2798        }
2799
2800        if (pAppData->nRetVal == 0) {
2801            if (nTimeCount++ > VIDENCTEST_MAX_TIME_OUTS) {
2802                VIDENCTEST_DPRINT("Application: Timeout!!!\n");
2803                printf("\n------VIDENCTEST FATAL ERROR-------\n Component Unresponsive \n");
2804                VIDENCTEST_HandleError(pAppData, OMX_ErrorUndefined);
2805                goto EXIT;
2806            }
2807            sched_yield();
2808        }
2809        else{
2810            nTimeCount = 0;
2811        }
2812
2813        if (FD_ISSET(pAppData->eventPipe[0], &rfds)) {
2814            EVENT_PRIVATE* pEventPrivate = NULL;
2815            OMX_EVENTTYPE eEvent = -1;
2816            OMX_U32 nData1 = 0;
2817            OMX_U32 nData2 = 0;
2818
2819            read(pAppData->eventPipe[0], &pEventPrivate, sizeof(pEventPrivate));
2820            eEvent = pEventPrivate->eEvent;
2821            nData1 = pEventPrivate->nData1;
2822            nData2 = pEventPrivate->nData2;
2823
2824            switch (eEvent) {
2825                case OMX_EventCmdComplete:
2826                    switch (nData1){
2827                        case OMX_CommandStateSet:
2828                            VIDENCTEST_PRINT("Enter to HandleState\n");
2829                            eError = VIDENCTEST_HandleState(pAppData, nData2);
2830                            VIDENCTEST_CHECK_ERROR(eError, "Error at HandleState function");
2831                            VIDENCTEST_PRINT("Exit to HandleState\n");
2832                            break;
2833                        case OMX_CommandFlush:
2834                            break;
2835                        case OMX_CommandPortDisable:
2836                            VIDENCTEST_PRINT("Enter to HandlePortDisable\n");
2837                            eError = VIDENCTEST_HandlePortDisable(pAppData, nData2);
2838                            VIDENCTEST_CHECK_ERROR(eError, "Error at HandlePortDisable function");
2839                            VIDENCTEST_PRINT("Exits to HandlePortDisable\n");
2840                            break;
2841                        case OMX_CommandPortEnable:
2842                            VIDENCTEST_PRINT("Enter to HandlePortEnable\n");
2843                            eError = VIDENCTEST_HandlePortEnable(pAppData, nData2);
2844                            VIDENCTEST_CHECK_ERROR(eError, "Error at PortPortEnable function");
2845                            VIDENCTEST_PRINT("Exits to HandlePortEnable\n");
2846                            break;
2847                        case OMX_CommandMarkBuffer:
2848                            ;
2849                    }
2850                    break;
2851                case OMX_EventError:
2852                    eError = VIDENCTEST_HandleEventError(pAppData, nData1, nData2);
2853                    VIDENCTEST_CHECK_ERROR(eError, "Fatal EventError");
2854                    break;
2855                case OMX_EventMax:
2856                    VIDENCTEST_PRINT("OMX_EventMax recived, nothing to do\n");
2857                    break;
2858                case OMX_EventMark:
2859                    VIDENCTEST_PRINT("OMX_EventMark recived, nothing to do\n");
2860                    break;
2861                case OMX_EventPortSettingsChanged:
2862                    VIDENCTEST_PRINT("OMX_EventPortSettingsChanged recived, nothing to do\n");
2863                    break;
2864                case OMX_EventBufferFlag:
2865                    VIDENCTEST_PRINT("OMX_EventBufferFlag recived, nothing to do\n");
2866                    break;
2867                case OMX_EventResourcesAcquired:
2868                    VIDENCTEST_PRINT("OMX_EventResourcesAcquired recived, nothing to do\n");
2869                    break;
2870                case OMX_EventComponentResumed:
2871                    VIDENCTEST_PRINT("OMX_EventComponentResumed recived, nothing to do\n");
2872                    break;
2873                case OMX_EventDynamicResourcesAvailable:
2874                    VIDENCTEST_PRINT("OMX_EventDynamicResourcesAvailable recived, nothing to do\n");
2875                    break;
2876                case OMX_EventPortFormatDetected:
2877                    VIDENCTEST_PRINT("OMX_EventPortFormatDetected recived, nothing to do\n");
2878                    break;
2879                case OMX_EventKhronosExtensions:
2880                    VIDENCTEST_PRINT("OMX_EventKhronosExtensions recived, nothing to do\n");
2881                    break;
2882                case OMX_EventVendorStartUnused:
2883                    VIDENCTEST_PRINT("OMX_EventVendorStartUnused recived, nothing to do\n");
2884                    break;
2885                default:
2886                    VIDENCTEST_CHECK_ERROR(OMX_ErrorUndefined, "Error at EmptyThisBuffer function");
2887                    break;
2888            }
2889
2890            VIDENCTEST_FREE(pEventPrivate, pListHead);
2891        }
2892
2893        if(FD_ISSET(pAppData->IpBuf_Pipe[0], &rfds)){
2894            VIDENCTEST_PRINT("Input Pipe event receive\n");
2895            read(pAppData->IpBuf_Pipe[0], &pBuffer, sizeof(pBuffer));
2896            pAppData->nInBufferCount++;
2897
2898            if(pAppData->eCurrentState == VIDENCTEST_StateEncoding) {
2899                pBuffer->nFilledLen = VIDENCTEST_fill_data(pBuffer, pAppData->fIn , pAppData->pInPortDef->nBufferSize);
2900
2901                if (pBuffer->nFlags == OMX_BUFFERFLAG_EOS && pBuffer->nFilledLen == 0) {
2902                    pAppData->eCurrentState = VIDENCTEST_StateStopping;
2903                    eError = pAppData->pComponent->EmptyThisBuffer(pHandle, pBuffer);
2904                    VIDENCTEST_CHECK_ERROR(eError, "Error at EmptyThisBuffer function");
2905                    pAppData->nInBufferCount--;
2906                }
2907
2908                if(pAppData->eTypeOfTest != VIDENCTEST_FullRecord){
2909                    if(pAppData->nCurrentFrameIn == pAppData->nReferenceFrame){
2910                        pAppData->eCurrentState = VIDENCTEST_StateStopping;
2911                        if(pAppData->eTypeOfTest == VIDENCTEST_PauseResume) {
2912                            eError = pAppData->pComponent->EmptyThisBuffer(pHandle, pBuffer);
2913                            VIDENCTEST_CHECK_ERROR(eError, "Error at EmptyThisBuffer function");
2914                            pAppData->nInBufferCount--;
2915                            pAppData->nCurrentFrameIn++;
2916                        }
2917                    }
2918                }
2919
2920                if(pAppData->eCurrentState == VIDENCTEST_StateEncoding){
2921                    if(pAppData->nQPIoF > 0) {
2922                        if(!(pAppData->nCurrentFrameIn % pAppData->nQPIoF)) {
2923                            pAppData->bForceIFrame = OMX_TRUE;
2924
2925                            eError = OMX_GetExtensionIndex(pHandle,"OMX.TI.VideoEncode.Config.ForceIFrame", (OMX_INDEXTYPE*)(&(pAppData->nVideoEncodeCustomParamIndex)));
2926                            VIDENCTEST_CHECK_EXIT(eError, "Error in OMX_GetExtensionIndex function");
2927                            eError = OMX_SetConfig(pHandle, pAppData->nVideoEncodeCustomParamIndex, &(pAppData->bForceIFrame));
2928                            VIDENCTEST_CHECK_EXIT(eError, "Error at SetConfig for bForceIFrame");
2929                            eError = OMX_GetExtensionIndex(pHandle,"OMX.TI.VideoEncode.Config.QPI", (OMX_INDEXTYPE*)(&(pAppData->nVideoEncodeCustomParamIndex)));
2930                            VIDENCTEST_CHECK_EXIT(eError, "Error in OMX_GetExtensionIndex function");
2931                            eError = OMX_SetConfig(pHandle, pAppData->nVideoEncodeCustomParamIndex, &(pAppData->nQpI));
2932                            VIDENCTEST_CHECK_EXIT(eError, "Error at SetConfig for bForceIFrame");
2933                        }
2934                        else {
2935                            pAppData->bForceIFrame = OMX_FALSE;
2936                            eError = OMX_GetExtensionIndex(pHandle,"OMX.TI.VideoEncode.Config.ForceIFrame", (OMX_INDEXTYPE*)(&(pAppData->nVideoEncodeCustomParamIndex)));
2937                            VIDENCTEST_CHECK_EXIT(eError, "Error in OMX_GetExtensionIndex function");
2938                            eError = OMX_SetConfig(pHandle, pAppData->nVideoEncodeCustomParamIndex, &(pAppData->bForceIFrame));
2939                            VIDENCTEST_CHECK_EXIT(eError, "Error at SetConfig for bForceIFrame");
2940                        }
2941                    }
2942                    eError = pAppData->pComponent->EmptyThisBuffer(pHandle, pBuffer);
2943                    VIDENCTEST_CHECK_ERROR(eError, "Error at EmptyThisBuffer function");
2944                    pAppData->nInBufferCount--;
2945                    pAppData->nCurrentFrameIn++;
2946                }
2947            }
2948
2949            if(pAppData->eCurrentState == VIDENCTEST_StateStopping) {
2950                if(pAppData->nInBufferCount == NUM_OF_IN_BUFFERS){
2951                    pAppData->eCurrentState = VIDENCTEST_StateConfirm;
2952                }
2953            }
2954        }
2955
2956        if(FD_ISSET(pAppData->OpBuf_Pipe[0], &rfds)){
2957            VIDENCTEST_PRINT("Output Pipe event receive\n");
2958            read(pAppData->OpBuf_Pipe[0], &pBuffer, sizeof(pBuffer));
2959            pAppData->nOutBufferCount++;
2960
2961
2962            /* check is it is the last buffer */
2963            if((pBuffer->nFlags & OMX_BUFFERFLAG_EOS) ||
2964                (pAppData->eTypeOfTest != VIDENCTEST_FullRecord &&
2965                pAppData->nCurrentFrameIn == pAppData->nReferenceFrame)) {
2966                pAppData->bLastOutBuffer = 1;
2967            }
2968
2969            /*App sends last buffer as null buffer, so buffer with EOS contains only garbage*/
2970            if(pBuffer->nFilledLen) {
2971                pAppData->nCurrentFrameOut++;
2972                fwrite(pBuffer->pBuffer, 1, pBuffer->nFilledLen, pAppData->fOut);
2973                nError = ferror(pAppData->fOut);
2974                if (nError != 0) {
2975                    VIDENCTEST_DPRINT("ERROR: writing to file\n");
2976                }
2977                nError = fflush(pAppData->fOut);
2978                if (nError != 0) {
2979                    VIDENCTEST_DPRINT("ERROR: flushing file\n");
2980                }
2981
2982                if(pAppData->NalFormat == VIDENC_TEST_NAL_SLICE){
2983                    nNalSlices = 1;
2984                    fwrite(&nNalSlices, 1, sizeof(OMX_U32), pAppData->fNalnd);
2985                    fwrite(&(pBuffer->nFilledLen), 1, sizeof(OMX_U32), pAppData->fNalnd);
2986                    nError = ferror(pAppData->fNalnd);
2987                    if (nError != 0) {
2988                        VIDENCTEST_DPRINT("ERROR: writing to file\n");
2989                    }
2990                    nError = fflush(pAppData->fNalnd);
2991                    if (nError != 0) {
2992                        VIDENCTEST_DPRINT("ERROR: flushing file\n");
2993                    }
2994                }
2995                /* Check if it is Nal format and if it has extra data*/
2996                if((pAppData->NalFormat == VIDENC_TEST_NAL_FRAME) &&
2997                    (pBuffer->nFlags & OMX_BUFFERFLAG_EXTRADATA)){
2998
2999                    pTemp = pBuffer->pBuffer + pBuffer->nOffset + pBuffer->nFilledLen + 3;
3000                    pExtraDataType = (OMX_OTHER_EXTRADATATYPE_1_1_2*) (((OMX_U32) pTemp) & ~3);
3001                    pIndexNal = (OMX_U32*)(pExtraDataType->data);
3002
3003                    nNalSlices = *pIndexNal;
3004                    fwrite(pIndexNal, 1, sizeof(OMX_U32), pAppData->fNalnd);
3005
3006                    while(nNalSlices--) {
3007                        pIndexNal++;
3008                        fwrite(pIndexNal, 1, sizeof(OMX_U32), pAppData->fNalnd);
3009                        nError = ferror(pAppData->fNalnd);
3010                        if (nError != 0) {
3011                            VIDENCTEST_DPRINT("ERROR: writing to file\n");
3012                        }
3013                        nError = fflush(pAppData->fNalnd);
3014                        if (nError != 0) {
3015                            VIDENCTEST_DPRINT("ERROR: flushing file\n");
3016                        }
3017                    }
3018                }
3019            }
3020
3021            if(pAppData->eCurrentState == VIDENCTEST_StateEncoding ||
3022                pAppData->eCurrentState == VIDENCTEST_StateStopping) {
3023                pBuffer->nFilledLen = 0;
3024                eError = pAppData->pComponent->FillThisBuffer(pHandle, pBuffer);
3025                VIDENCTEST_CHECK_ERROR(eError, "Error at FillThisBuffer function");
3026                pAppData->nOutBufferCount--;
3027            }
3028        }
3029
3030        if (pAppData->eCurrentState == VIDENCTEST_StateConfirm ) {
3031            if (pAppData->bLastOutBuffer){
3032                VIDENCTEST_PRINT("Number of Input  Buffer at Client Side : %i\n", pAppData->nInBufferCount);
3033                VIDENCTEST_PRINT("Number of Output Buffer at Client Side : %i\n", pAppData->nOutBufferCount);
3034                VIDENCTEST_PRINT("Frames Out: %i\n", pAppData->nCurrentFrameOut);
3035                VIDENCTEST_PRINT("Enter to Confirm Function\n");
3036                eError = VIDENCTEST_Confirm(pAppData);
3037                VIDENCTEST_CHECK_ERROR(eError, "Error at VIDENCTEST_Confirm function");
3038                VIDENCTEST_PRINT("Exits to Confirm Function\n");
3039            }
3040        }
3041
3042        if (pAppData->eCurrentState == VIDENCTEST_StateUnLoad) {
3043            VIDENCTEST_PRINT("Exiting while\n");
3044            break;
3045        }
3046        sched_yield();
3047    }
3048    if(pAppData->nCurrentFrameIn != pAppData->nCurrentFrameOut)
3049    {
3050        printf("App: Warning!!! FrameIn: %d FrameOut: %d\n", (int)pAppData->nCurrentFrameIn, (int)pAppData->nCurrentFrameOut);
3051    }
3052
3053    eError = VIDENCTEST_DeInit(pAppData);
3054
3055EXIT:
3056    return eError;
3057}
3058
3059#ifdef DSP_MMU_FAULT_HANDLING
3060int LoadBaseImage()
3061{
3062    unsigned int uProcId = 0;   /* default proc ID is 0. */
3063    unsigned int index = 0;
3064
3065    struct DSP_PROCESSORINFO dspInfo;
3066    DSP_HPROCESSOR hProc;
3067    DSP_STATUS status = DSP_SOK;
3068    unsigned int numProcs;
3069    char* argv[2];
3070
3071    argv[0] = "/lib/dsp/baseimage.dof";
3072
3073    status = (DBAPI)DspManager_Open(0, NULL);
3074    if (DSP_FAILED(status)) {
3075        printf("DSPManager_Open failed \n");
3076        return -1;
3077    }
3078    while (DSP_SUCCEEDED(DSPManager_EnumProcessorInfo(index,&dspInfo,
3079        (unsigned int)sizeof(struct DSP_PROCESSORINFO),&numProcs))) {
3080        if ((dspInfo.uProcessorType == DSPTYPE_55) ||
3081            (dspInfo.uProcessorType == DSPTYPE_64)) {
3082            uProcId = index;
3083            status = DSP_SOK;
3084            break;
3085        }
3086        index++;
3087    }
3088    status = DSPProcessor_Attach(uProcId, NULL, &hProc);
3089    if (DSP_SUCCEEDED(status)) {
3090        status = DSPProcessor_Stop(hProc);
3091        if (DSP_SUCCEEDED(status)) {
3092            status = DSPProcessor_Load(hProc,1,(const char **)argv,NULL);
3093            if (DSP_SUCCEEDED(status)) {
3094                status = DSPProcessor_Start(hProc);
3095                if (DSP_SUCCEEDED(status)) {
3096                    fprintf(stderr,"Baseimage Loaded\n");
3097                }
3098                else {
3099                    fprintf(stderr,"APP: Baseimage start error!\n");
3100                }
3101            }
3102            else {
3103                fprintf(stderr,"APP: Baseimage load error!\n");
3104            }
3105            DSPProcessor_Detach(hProc);
3106        }
3107        else {
3108            fprintf(stderr,"APP: Baseimage stop error!\n");
3109        }
3110    }
3111    else {
3112        fprintf(stderr,"APP: Baseimage attach error!\n");
3113    }
3114
3115    return 0;
3116}
3117#endif
3118
3119
3120