[DCE_TEST] Add Input argument to take in number of frames to write.
[glsdk/libdce2.git] / test_qnx / dce_test.c
1 /*
2  * Copyright (c) 2013, Texas Instruments Incorporated
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * *  Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  *
12  * *  Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * *  Neither the name of Texas Instruments Incorporated nor the names of
17  *    its contributors may be used to endorse or promote products derived
18  *    from this software without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
22  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
24  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
25  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
26  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
27  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
28  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
29  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
30  * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32 #include <xdc/std.h>
33 #include <stdlib.h>
34 #include <string.h>
35 #include <stdio.h>
36 #include <stdint.h>
37 #include <sys/types.h>
38 #include <sys/stat.h>
39 #include <sys/time.h>
40 #include <fcntl.h>
41 #include <errno.h>
42 #include <time.h>
43 #include <sys/mman.h>
45 #include <tilermem.h>
46 #include <memmgr.h>
47 #include <xdc/std.h>
48 #include <ti/sdo/ce/Engine.h>
49 #include <ti/sdo/ce/video3/viddec3.h>
50 #include <ti/sdo/codecs/h264vdec/ih264vdec.h>
51 #include <ti/sdo/codecs/mpeg4vdec/impeg4vdec.h>
52 #include <ti/sdo/codecs/vc1vdec/ivc1vdec.h>
53 #include <ti/sdo/codecs/jpegvdec/ijpegvdec.h>
54 #ifdef ENABLE_MPEG2
55 #include <ti/sdo/codecs/mpeg2vdec/impeg2vdec.h>
56 #endif
57 #include "ti/shmemallocator/SharedMemoryAllocatorUsr.h"
58 #include "libdce.h"
60 #define OMAP5
62 #define PRINT_DEBUG
63 #define ERROR(FMT, ...)  printf("%s:%d:\t%s\terror: " FMT "\n", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__)
64 // enable below to print debug information
65 #ifdef PRINT_DEBUG
66 #define DEBUG(FMT, ...)  printf("%s:%d:\t%s\tdebug: " FMT "\n", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__)
67 #else
68 #define DEBUG(FMT, ...)
69 #endif
70 #define INFO(FMT, ...)  printf("%s:%d:\t%s\tinfo: " FMT "\n", __FILE__, __LINE__, __FUNCTION__, ##__VA_ARGS__)
71 #define MIN(a, b)        (((a) < (b)) ? (a) : (b))
73 /* align x to next highest multiple of 2^n */
74 #define ALIGN2(x, n)   (((x) + ((1 << (n)) - 1)) & ~((1 << (n)) - 1))
76 // Profile the init and decode calls
77 //#define PROFILE_TIME
79 enum {
80     IVAHD_AVC1_DECODE,
81     IVAHD_H264_DECODE,
82     IVAHD_MP4V_DECODE,
83     IVAHD_S263_DECODE,
84     IVAHD_VC1AP_DECODE,
85     IVAHD_VC1SMP_DECODE,
86     IVAHD_VP6V_DECODE,
87     IVAHD_MP2V_DECODE,
88     IVAHD_JPEGV_DECODE
89 };
91 /*
92  * A very simple VIDDEC3 client which will decode h264 frames (one per file),
93  * and write out raw (unstrided) nv12 frames (one per file).
94  */
96 int                      width, height, frames_to_write, padded_width, padded_height, num_buffers, tiler;
97 Engine_Handle            engine    = NULL;
98 VIDDEC3_Handle           codec     = NULL;
99 VIDDEC3_Params          *params    = NULL;
100 VIDDEC3_DynamicParams   *dynParams = NULL;
101 VIDDEC3_Status          *status    = NULL;
102 XDM2_BufDesc            *inBufs    = NULL;
103 XDM2_BufDesc            *outBufs   = NULL;
104 VIDDEC3_InArgs          *inArgs    = NULL;
105 VIDDEC3_OutArgs         *outArgs   = NULL;
107 IH264VDEC_Params          *h264_params    = NULL;
108 IH264VDEC_DynamicParams   *h264_dynParams = NULL;
109 IH264VDEC_Status          *h264_status    = NULL;
111 IMPEG4VDEC_Params          *mpeg4_params       = NULL;
112 IMPEG4VDEC_DynamicParams   *mpeg4_dynParams    = NULL;
113 IMPEG4VDEC_Status          *mpeg4_status       = NULL;
115 IVC1VDEC_Params          *vc1_params     = NULL;
116 IVC1VDEC_DynamicParams   *vc1_dynParams  = NULL;
117 IVC1VDEC_Status          *vc1_status     = NULL;
119 IJPEGVDEC_Params          *mjpeg_params       = NULL;
120 IJPEGVDEC_DynamicParams   *mjpeg_dynParams    = NULL;
121 IJPEGVDEC_Status          *mjpeg_status       = NULL;
122 #ifdef ENABLE_MPEG2
123 IMPEG2VDEC_Params          *mpeg2_params       = NULL;
124 IMPEG2VDEC_DynamicParams   *mpeg2_dynParams    = NULL;
125 IMPEG2VDEC_Status          *mpeg2_status       = NULL;
126 #endif
127 unsigned int    frameSize[64000]; /* Buffer for keeping frame sizes */
128 static int      input_offset = 0;
130 /*! Padding for width as per  Codec Requirement */
131 #define PADX_H264   32
132 #define PADX_MPEG4  32
133 #define PADX_VC1    32
134 /*! Padding for height as per Codec Requirement */
135 #define PADY_H264   24
136 #define PADY_MPEG4  32
137 #define PADY_VC1    40
139 static void *tiler_alloc(int width, int height)
141     int              dimensions;
142     void            *bufPtr = NULL;
143     MemAllocBlock    block;
144     MemAllocBlock    blocks[2];
146     memset(&block, 0, sizeof(MemAllocBlock));
147     memset(blocks, 0, sizeof(MemAllocBlock) * 2);
149     if( !height ) {
150         DEBUG("tiler alloc 1D allocation width=%d", width);
151         /* 1d allocation: */
152         dimensions = 1;
154         block.pixelFormat = PIXEL_FMT_PAGE;
155         block.dim.len = width;
156         block.stride = 0;
158         bufPtr = MemMgr_Alloc(&block, dimensions);
159     } else {
160         DEBUG("tiler alloc 2D allocation width=%d height=%d", width, height);
161         /* 2d allocation: */
162         dimensions = 2;
163         blocks[0].pixelFormat = PIXEL_FMT_8BIT;
164         blocks[0].dim.area.width  = width;
165         blocks[0].dim.area.height = height;
166         blocks[0].stride = 0;
168         blocks[1].pixelFormat = PIXEL_FMT_16BIT;
169         blocks[1].dim.area.width  = width >> 1;
170         blocks[1].dim.area.height = height >> 1;
171         blocks[1].stride = 0;
173         bufPtr = MemMgr_Alloc(blocks, dimensions);
174     }
175     DEBUG("tiler alloc return bufPtr %p", bufPtr);
177     return (bufPtr);
180 /* ************************************************************************* */
181 /* utilities to allocate/manage 2d output buffers */
183 typedef struct OutputBuffer OutputBuffer;
185 struct OutputBuffer {
186     char         *buf; /* virtual address for local access, 4kb stride */
187     uint32_t      y, uv; /* virtual address of Y and UV for remote access */
188     OutputBuffer *next;      /* next free buffer */
189     bool          tiler;
190     uint32_t      len;
191     shm_buf       shmBuf;
192 };
194 static XDAS_Int16
195 get_mem_type (uint32_t paddr)
197     if((0x60000000 <= paddr) && (paddr < 0x68000000)) {
198         return (XDM_MEMTYPE_TILED8);
199     }
200     if((0x68000000 <= paddr) && (paddr < 0x70000000)) {
201         return (XDM_MEMTYPE_TILED16);
202     }
203     if((0x70000000 <= paddr) && (paddr < 0x78000000)) {
204         return (XDM_MEMTYPE_TILED32);
205     }
206     if((0x78000000 <= paddr) && (paddr < 0x80000000)) {
207         return (XDM_MEMTYPE_RAW);
208     }
209     return (-1);
212 /* list of free buffers, not locked by codec! */
213 static OutputBuffer   *head = NULL;
215 #if 0
216 /*! @brief Start address of DDR region for 1GB RAM */
217 #define DDR_1G_ADDRESS_START           0x80000000
218 /*! @brief End address of DDR region for 1GB RAM */
219 #define DDR_1G_ADDRESS_END             0xBFFFFFFF
220 #define DDR_1G_DUCATI_OFFSET           0x40000000
222 /*! @brief Start address of DDR region for 2GB RAM */
223 #define DDR_2G_ADDRESS_START           0xC0000000
224 /*! @brief End address of DDR region for 2GB RAM */
225 #define DDR_2G_ADDRESS_END             0xFFFFFFFF
226 #define DDR_2G_DUCATI_OFFSET           0xA0000000
228 static Int
229 SysLinkMemUtils_translateAddr (UInt32 physAddr)
231     Int    ret = 0;
233     if( physAddr >= DDR_1G_ADDRESS_START && physAddr <= DDR_1G_ADDRESS_END ) {
234         ret = physAddr + DDR_1G_DUCATI_OFFSET;
235     } else if( physAddr >= DDR_2G_ADDRESS_START && physAddr <= DDR_2G_ADDRESS_END ) {
236         ret = physAddr - DDR_2G_DUCATI_OFFSET;
237     }
239     return (ret);
242 #endif
244 int output_allocate(XDM2_BufDesc *outBufs, int cnt,
245                     int width, int height, int stride)
247     int    tw, th;
249     outBufs->numBufs = 2;
251     if( stride != 4096 ) {
252         /* non-2d allocation! */
253         int    size_y = stride * height;
254         int    size_uv = stride * height / 2;
255         tw = size_y + size_uv;
256         th = 0;
257         outBufs->descs[0].memType = XDM_MEMTYPE_TILEDPAGE;
258         outBufs->descs[0].bufSize.bytes = size_y;
259         outBufs->descs[1].memType = XDM_MEMTYPE_TILEDPAGE;
260         outBufs->descs[1].bufSize.bytes = size_uv;
261     } else {
262         tw = width;
263         th = height;
264         outBufs->descs[0].memType = XDM_MEMTYPE_TILED8;
265         outBufs->descs[0].bufSize.tileMem.width  = width;
266         outBufs->descs[0].bufSize.tileMem.height = height;
267         outBufs->descs[1].memType = XDM_MEMTYPE_TILED16;
268         outBufs->descs[1].bufSize.tileMem.width  = width; /* UV interleaved width is same a Y */
269         outBufs->descs[1].bufSize.tileMem.height = height / 2;
270     }
272     while( cnt ) {
273         OutputBuffer   *buf = calloc(sizeof(OutputBuffer), 1);
275         DEBUG(" ----------------- create TILER buf 0x%x --------------------", (unsigned int)buf);
277         buf->buf = tiler_alloc(tw, th);
278         if( buf->buf ) {
279             buf->y   = (uint32_t) buf->buf;
280             buf->uv  = (uint32_t)(buf->buf + (height * stride));
282             DEBUG("cnt=%d buf=%p, y=%08x, uv=%08x", cnt, buf, buf->y, buf->uv);
284             buf->tiler = TRUE;
285             buf->next = head;
286             head = buf;
287         } else {
288             ERROR(" ---------------- tiler_alloc failed --------------------");
289             free(buf);
290             return (-EAGAIN);
291         }
292         cnt--;
293     }
295     return (0);
298 int output_allocate_nonTiler(XDM2_BufDesc *outBufs, int cnt,
299                              int width, int height, int stride)
301     int           tw;
302     XDAS_Int16    y_type, uv_type;
304     outBufs->numBufs = 2;
306     while( cnt ) {
307         OutputBuffer   *buf = calloc(sizeof(OutputBuffer), 1);
309         DEBUG(" ----------------- create nonTILER buf 0x%x --------------------", (unsigned int)buf);
310         int    size_y = width * height;
311         int    size_uv = width * height * 1 / 2;
312         tw = size_y + size_uv;
314         // Allocation through mmap
315         uint64_t   *vaddr;
316         int32_t     ret, len = 0;
317         int64_t     paddr = 0;
318         uint32_t    uv_addr;
320         //vaddr = mmap64(0, tw, PROT_NOCACHE | PROT_READ | PROT_WRITE, MAP_ANON | MAP_PHYS | MAP_SHARED, NOFD, 0);
321         ret = SHM_alloc(tw, &buf->shmBuf);
322         //if (vaddr == MAP_FAILED) {
323         if( ret < 0 ) {
324             //ERROR("Failed to do memory mapping\n");
325             ERROR("Failed to alloc shmem buffer\n");
326             free(buf);
327             return (-ENOMEM);
328         }
329         vaddr = (uint64_t *)buf->shmBuf.vir_addr;
331         // Make sure the memory is contiguous
332         ret = mem_offset64(vaddr, NOFD, (size_t) tw, &paddr, (size_t *) &len);
333         if( ret ) {
334             ERROR("Failed to check memory contiguous ret %d errno %d\n", ret, errno);
335             //munmap(vaddr, tw);
336             SHM_release(&buf->shmBuf);
337             free(buf);
338             return (-ENOMEM);
339         } else if( len != (tw)) {
340             ERROR("Failed to check len %d != %d\n", len, tw);
341             //munmap(vaddr, tw);
342             SHM_release(&buf->shmBuf);
343             free(buf);
344             return (-ENOMEM);
345         }
347         buf->buf = (char *) vaddr;
348         buf->y = (uint32_t)vaddr;
349         uv_addr = (uint32_t) vaddr + (width * height);
350         buf->uv = uv_addr;
352         DEBUG("cnt=%d nonTILER buf=%p, y=%08x, uv=%08x paddr=%08x", cnt, buf, buf->y, buf->uv, (unsigned int) paddr);
354         y_type = get_mem_type(buf->y);
355         uv_type = get_mem_type(buf->uv);
357         if((y_type < 0) || (uv_type < 0)) {
358             DEBUG("non TILER buffer address translation buf->y %x buf->uv %x", buf->y, buf->uv);
359             //buf->y = SysLinkMemUtils_translateAddr(buf->y);
360             //buf->uv = SysLinkMemUtils_translateAddr(buf->uv);
361             y_type = XDM_MEMTYPE_RAW;
362             uv_type = XDM_MEMTYPE_RAW;
363             DEBUG("buf->y %x buf->uv %x", buf->y, buf->uv);
364             if( !buf->y || !buf->uv ) {
365                 //munmap(vaddr, tw);
366                 SHM_release(&buf->shmBuf);
367                 free(buf);
368                 return (-ENOMEM);
369             }
370         }
372         buf->next = head;
373         buf->tiler = FALSE;
374         buf->len = tw;
375         head = buf;
377         cnt--;
378     }
380     if((y_type == XDM_MEMTYPE_RAW) && (uv_type == XDM_MEMTYPE_RAW)) {
381         outBufs->descs[0].memType = y_type;
382         outBufs->descs[0].bufSize.bytes = width * height;
383         outBufs->descs[1].memType = uv_type;
384         outBufs->descs[1].bufSize.bytes = width * height * 1 / 2;
385     }
387     return (0);
390 void output_free(void)
392     OutputBuffer   *buf = head;
394     while((buf=head)) {
395         if( buf->tiler ) {
396             MemMgr_Free(buf->buf);
397         } else {
398             //munmap(buf->buf, buf->len);
399             SHM_release(&buf->shmBuf);
400         }
401         head = buf->next;
402         free(buf);
403     }
406 OutputBuffer *output_get(void)
408     OutputBuffer   *buf = head;
410     if( buf ) {
411         head = buf->next;
412     }
413     DEBUG("output_get: %p", buf);
414     return (buf);
417 void output_release(OutputBuffer *buf)
419     DEBUG("output_release: %p", buf);
420     buf->next = head;
421     head = buf;
424 /* ************************************************************************* */
426 /* get file path.. return path is only valid until next time this is called */
427 static const char *get_path(const char *pattern, int cnt)
429     static int     len = 0;
430     static char   *path = NULL;
432     /* It would be better to not assume the pattern doesn't expand to
433      * less than 10 chars it's original length..
434      */
435     if((strlen(pattern) + 10) > len ) {
436         len  = strlen(pattern) + 10;
437         path = realloc(path, len);
438     }
440     snprintf(path, len - 1, pattern, cnt);
442     return (path);
445 /* helper to read one frame of input */
446 int read_input(const char *pattern, int cnt, char *input)
448     int           sz = 0, n = 0;
449     const char   *path = get_path(pattern, cnt);
450     int           fd = open(path, O_RDONLY);
452     //DEBUG("Open file fd %d errno %d", fd, errno);
453     /* if we can't find the file, then at the end of stream */
454     if( fd < 0 ) {
455         DEBUG("open input file failed");
456         return (0);
457     }
459     if( frameSize[cnt] && (frameSize[cnt] != -1)) {
460         lseek(fd, input_offset, SEEK_SET);
461         n = read(fd, input, frameSize[cnt]);
462         //DEBUG("reading input frameSize[%d] = n =%d", cnt, n);
463         sz += n;
464         input_offset += n;
465     } else if((frameSize[cnt] == -1)) {
466         // This happens to indicate flush command
467         DEBUG("Flush requested from file size -1,frameSize[%d] is %d", cnt, frameSize[cnt]);
468         sz = -1;
469     }
471     close(fd);
473     DEBUG("sz=%d", sz);
474     return (sz);
477 /* helper to write one frame of output */
478 int write_output(const char *pattern, int cnt, char *y, char *uv, int stride)
480     int           sz = 0, n, i;
481     const char   *path = get_path(pattern, cnt);
482     int           fd = open(path, O_WRONLY | O_CREAT | O_APPEND, 0644);
484     if( fd < 0 ) {
485         ERROR("could open output file: %s (%d)", path, errno);
486         return (0);
487     }
489     for( i = 0; i < height; i++ ) {
490         char   *p = y;
491         int     len = width;
493         while( len && ((n = write(fd, p, len)) > 0)) {
494             sz  += n;
495             p   += n;
496             len -= n;
497         }
499         if( n < 0 ) {
500             ERROR("couldn't write to output file: (%d)", errno);
501             break;
502         }
503         y += stride;
504     }
506     if( n >= 0 ) {
507         for( i = 0; i < height / 2; i++ ) {
508             char   *p = uv;
509             int     len = width;
511             while( len && ((n = write(fd, p, len)) > 0)) {
512                 sz  += n;
513                 p   += n;
514                 len -= n;
515             }
517             if( n < 0 ) {
518                 ERROR("couldn't write to output file: (%d)", errno);
519                 break;
520             }
521             uv += stride;
522         }
523     }
525     close(fd);
527     return (sz);
530 #ifdef PROFILE_TIME
531 /* for timing in microsecond */
532 uint64_t mark_microsecond(uint64_t *last)
534 #if 0
535     struct timespec    time;
536     uint64_t           t1 = 0;
538     clock_gettime(CLOCK_REALTIME, &time);
539     t1 = timespec2nsec(&time);
540     t1 = t1 / 1000;
541 #else
542     uint64_t    t1 = 0;
544     t1 = ClockCycles();
545     t1 = t1 * 1000000000 / SYSPAGE_ENTRY(qtime)->cycles_per_sec;
546     t1 = t1 / 1000;
547 #endif
548     if( last ) {
549         return (t1 - *last);
550     }
551     return (t1);
554 #endif
555 //#define DUMPINPUTDATA
557 #ifdef DUMPINPUTDATA
558 FILE   *inputDump;
559 #endif
561 #define VERSION_SIZE 128
562 static char    version_buffer[VERSION_SIZE];
564 /* decoder body */
565 int main(int argc, char * *argv)
567     Engine_Error     ec;
568     XDAS_Int32       err;
569     char            *input = NULL;
570     char            *in_pattern, *out_pattern, *frameData;
571     int              in_cnt = 0, out_cnt = 0;
572     int              oned, stride;
573     unsigned int     frameCount = 0;
574     FILE            *frameFile;
575     unsigned char    frameinput[10] = { "\0" };
576     int              eof = 0;
577     int              ivahd_decode_type;
578     char             vid_codec[10];
579     char             tilerbuffer[10];
580     unsigned int     codec_switch = 0;
581     unsigned int     vc1_flush = 0;
582     Bool             outBufsInUse = FALSE;
584 #ifdef PROFILE_TIME
585     uint64_t    init_start_time = 0;
586     uint64_t    codec_process_time = 0;
587     uint64_t    total_init_time = 0;
588     uint64_t    output_alloc_time = 0;
589 #endif
591 #if 0
592     int    loop = 0;
594     while( loop == 0 ) {
595         loop = 0;
596     }
598 #endif
600     if((argc >= 2) && !strcmp(argv[1], "-1")) {
601         oned = TRUE;
602         argc--;
603         argv++;
604     } else {
605         oned = FALSE;
606     }
608     if( argc != 9 ) {
609         printf("usage:   %s width height frames_to_write framefile inpattern outpattern codec tilerbuffer\n", argv[0]);
610         printf("example: %s 320 240 30 frame.txt in.h264 out.yuv h264 tiler\n", argv[0]);
611         printf("example: %s 640 480 30 frame.txt in.m4v out.yuv mpeg4 nontiler\n", argv[0]);
612         printf("example: %s 720 480 30 frame.txt in.vc1 out.yuv vc1ap tiler\n", argv[0]);
613         printf("example: %s 320 240 30 frame.txt in.vc1 out.yuv vc1smp nontiler\n", argv[0]);
614         printf("example: %s 1280 720 30 frame.txt in.bin out.yuv mjpeg tiler\n", argv[0]);
615         printf("example: %s 1920 1088 30 frame.txt in.bin out.yuv mpeg2 nontiler\n", argv[0]);
616         printf("Currently supported codecs: h264, mpeg4, vc1ap, vc1smp, mjpeg, mpeg2\n");
617         return (1);
618     }
620     /* error checking? */
621     width  = atoi(argv[1]);
622     height = atoi(argv[2]);
623     frames_to_write = atoi(argv[3]);
624     frameData   = argv[4];
625     in_pattern  = argv[5];
626     out_pattern = argv[6];
627     strcpy(vid_codec, argv[7]);
628     strcpy(tilerbuffer, argv[8]);
630     printf("Selected codec: %s\n", vid_codec);
631     printf("Selected buffer: %s\n", tilerbuffer);
633     if( frames_to_write == -1 ) {
634         /* Default : 30 frames to write into output file */
635         frames_to_write = 30;
636     }
638     enum {
639         DCE_TEST_H264   = 1,
640         DCE_TEST_MPEG4  = 2,
641         DCE_TEST_VC1SMP = 3,
642         DCE_TEST_VC1AP  = 4,
643         DCE_TEST_MJPEG  = 5,
644         DCE_TEST_MPEG2  = 6
645     };
647     if((!(strcmp(vid_codec, "h264")))) {
648         ivahd_decode_type = IVAHD_H264_DECODE;
649         codec_switch = DCE_TEST_H264;
651     } else if((!(strcmp(vid_codec, "mpeg4")))) {
652         ivahd_decode_type = IVAHD_MP4V_DECODE;
653         codec_switch = DCE_TEST_MPEG4;
655     } else if((!(strcmp(vid_codec, "vc1smp")))) {
656         ivahd_decode_type = IVAHD_VC1SMP_DECODE;
657         codec_switch = DCE_TEST_VC1SMP;
658         vc1_flush = 1;
660     } else if((!(strcmp(vid_codec, "vc1ap")))) {
661         ivahd_decode_type = IVAHD_VC1AP_DECODE;
662         codec_switch = DCE_TEST_VC1AP;
663         vc1_flush = 1;
665     } else if((!(strcmp(vid_codec, "mjpeg")))) {
666         ivahd_decode_type = IVAHD_JPEGV_DECODE;
667         codec_switch = DCE_TEST_MJPEG;
669     } else if((!(strcmp(vid_codec, "mpeg2")))) {
670         ivahd_decode_type = IVAHD_MP2V_DECODE;
671         codec_switch = DCE_TEST_MPEG2;
673     } else {
674         printf("No valid codec entry. Please use: h264, mpeg4, vc1ap, vc1smp, mjpeg or mpeg2\n");
675         return (1);
676     }
678     DEBUG("Storing frame size data");
679     frameFile = fopen(frameData, "rb");
680     DEBUG("frameFile open %p errno %d", frameFile, errno);
681     if( frameFile == NULL ) {
682         DEBUG("Opening framesize file FAILED");
683     }
685     /* Read the frame Size from the frame size file */
686     while( NULL != fgets((char *)frameinput, 10, frameFile)) {
687         frameSize[frameCount] = atoi((char *)frameinput);
688         //DEBUG("frameSize[%d] = %d \n", frameCount, frameSize[frameCount]);
690         if( frameCount > 64000 ) {
691             DEBUG("Num Frames %d exceeded MAX limit %d \n", frameCount, 64000);
692             goto out;
693         }
694         frameCount++;
695     }
697     DEBUG("Num Frames is %d width=%d, height=%d", frameCount, width, height);
699     /* calculate output buffer parameters: */
700     width  = ALIGN2(width, 4);         /* round up to MB */
701     height = ALIGN2(height, 4);        /* round up to MB */
703     switch( codec_switch ) {
704         case DCE_TEST_H264 :
705             padded_width  = ALIGN2(width + (2 * PADX_H264), 7);
706             padded_height = height + 4 * PADY_H264;
707             // Some clips don't have enough buffers based on N+3 formula
708             // Need sps->num_ref_frames data to match filter precisely
709             //num_buffers   = 2 * (MIN(16, 32768 / ((width / 16) * (height / 16)))) + 1;
710             num_buffers   = (MIN(16, 32768 / ((width / 16) * (height / 16)))) + 3;
711             break;
712         case DCE_TEST_MPEG4 :
713             padded_width = ALIGN2(width + PADX_MPEG4, 7);
714             padded_height = height + PADY_MPEG4;
715             num_buffers = 8;
716             break;
717         case DCE_TEST_VC1SMP :
718         case DCE_TEST_VC1AP :
719             padded_width = ALIGN2(width + (2 * PADX_VC1), 7);
720             padded_height = (ALIGN2(height / 2, 4) * 2) + 4 * PADY_VC1;
721             num_buffers = 5;
722             break;
723         case DCE_TEST_MJPEG :
724             padded_width = ALIGN2(width, 4);
725             padded_height = ALIGN2(height, 4);
726             num_buffers = 5;
727             break;
728         case DCE_TEST_MPEG2 :
729             padded_width = ALIGN2(width, 7);
730             padded_height = height;
731             num_buffers = 4;
732             break;
733     }
735     if( oned ) {
736         stride = padded_width;
737     } else {
738         stride = 4096;
739     }
741     DEBUG("padded_width=%d, padded_height=%d, stride=%d, num_buffers=%d",
742           padded_width, padded_height, stride, num_buffers);
743 #ifdef PROFILE_TIME
744     init_start_time = mark_microsecond(NULL);
745 #endif
746     engine = Engine_open("ivahd_vidsvr", NULL, &ec);
748     if( !engine ) {
749         ERROR("fail");
750         goto out;
751     }
753     DEBUG("Engine_open successful engine=%p", engine);
755     switch( codec_switch ) {
756         case DCE_TEST_H264 :
757             params = dce_alloc(sizeof(IH264VDEC_Params));
758             if( !params ) {
759                 ERROR("dce_alloc fail");
760                 goto out;
761             }
762             params->size = sizeof(IH264VDEC_Params);
763             params->maxBitRate      = 10000000;
764             params->displayDelay    = IVIDDEC3_DISPLAY_DELAY_AUTO;
765             params->numOutputDataUnits  = 0;
766             params->maxWidth            = width;
767             break;
768         case DCE_TEST_MPEG4 :
769             params = dce_alloc(sizeof(IMPEG4VDEC_Params));
770             if( !params ) {
771                 ERROR("dce_alloc fail");
772                 goto out;
773             }
774             params->size = sizeof(IMPEG4VDEC_Params);
775             params->maxBitRate      = 10000000;
776             params->displayDelay    = IVIDDEC3_DISPLAY_DELAY_1;
777             params->numOutputDataUnits  = 0;
778             params->maxWidth            = width;
779             break;
780         case DCE_TEST_VC1SMP :
781         case DCE_TEST_VC1AP :
782             params = dce_alloc(sizeof(IVC1VDEC_Params));
783             if( !params ) {
784                 ERROR("dce_alloc fail");
785                 goto out;
786             }
787             params->size = sizeof(IVC1VDEC_Params);
788             params->maxBitRate      = 45000000;
789             params->displayDelay    = IVIDDEC3_DISPLAY_DELAY_1;
790             params->numOutputDataUnits  = 0;
791             params->maxWidth            = width;
792             break;
793         case DCE_TEST_MJPEG :
794             params = dce_alloc(sizeof(IJPEGVDEC_Params));
795             if( !params ) {
796                 ERROR("dce_alloc fail");
797                 goto out;
798             }
799             params->size = sizeof(IJPEGVDEC_Params);
800             params->maxBitRate      = 10000000;
801             params->displayDelay    = IVIDDEC3_DISPLAY_DELAY_1;
802             params->numOutputDataUnits  = 1;
803             params->maxWidth            = width;
804             break;
805 #ifdef ENABLE_MPEG2
806         case DCE_TEST_MPEG2 :
807             params = dce_alloc(sizeof(IMPEG2VDEC_Params));
808             if( !params ) {
809                 ERROR("dce_alloc fail");
810                 goto out;
811             }
812             params->size = sizeof(IMPEG2VDEC_Params);
813             params->maxBitRate      = 10000000;
814             params->displayDelay    = IVIDDEC3_DISPLAY_DELAY_1;
815             params->numOutputDataUnits  = 0;
816             params->maxWidth            = padded_width;
817             break;
818 #endif
819     }
821     params->maxHeight           = height;
822     params->maxFrameRate        = 30000;
823     params->dataEndianness      = XDM_BYTE;
824     params->forceChromaFormat   = XDM_YUV_420SP;
825     params->operatingMode       = IVIDEO_DECODE_ONLY;
826     //params->displayDelay        = IVIDDEC3_DECODE_ORDER;
827     params->displayBufsMode     = IVIDDEC3_DISPLAYBUFS_EMBEDDED;
828     params->inputDataMode       = IVIDEO_ENTIREFRAME;
829     params->metadataType[0]     = IVIDEO_METADATAPLANE_NONE;
830     params->metadataType[1]     = IVIDEO_METADATAPLANE_NONE;
831     params->metadataType[2]     = IVIDEO_METADATAPLANE_NONE;
832     params->outputDataMode      = IVIDEO_ENTIREFRAME;
833     params->numInputDataUnits   = 0;
834     params->errorInfoMode       = IVIDEO_ERRORINFO_OFF;
836     DEBUG("dce_alloc VIDDEC3_Params successful params=%p", params);
838     switch( codec_switch ) {
839         case DCE_TEST_H264 :
840             h264_params = (IH264VDEC_Params *) params;
841             h264_params->dpbSizeInFrames = IH264VDEC_DPB_NUMFRAMES_AUTO;
842             h264_params->pConstantMemory = 0;
843             h264_params->presetLevelIdc = IH264VDEC_LEVEL41;
844             h264_params->errConcealmentMode = IH264VDEC_APPLY_CONCEALMENT;
845             h264_params->temporalDirModePred = TRUE;
846             h264_params->detectCabacAlignErr = IH264VDEC_DISABLE_CABACALIGNERR_DETECTION;
848             DEBUG("dce_alloc VIDDEC3_Params successful h264_params=%p", h264_params);
850             err = msync((Ptr)h264_params, sizeof(IH264VDEC_Params), MS_CACHE_ONLY | MS_SYNC);
852             codec = VIDDEC3_create(engine, "ivahd_h264dec", (VIDDEC3_Params *)h264_params);
853             break;
855         case DCE_TEST_MPEG4 :
856             mpeg4_params = (IMPEG4VDEC_Params *) params;
857             mpeg4_params->outloopDeBlocking = TRUE;
858             mpeg4_params->sorensonSparkStream = FALSE;
859             mpeg4_params->errorConcealmentEnable = FALSE;
860             mpeg4_params->debugTraceLevel = 0;
861             mpeg4_params->lastNFramesToLog = 0;
862             mpeg4_params->paddingMode = IMPEG4VDEC_DEFAULT_MODE_PADDING;
864             DEBUG("dce_alloc VIDDEC3_Params successful mpeg4_params=%p", mpeg4_params);
866             err = msync((Ptr)mpeg4_params, sizeof(IMPEG4VDEC_Params), MS_CACHE_ONLY | MS_SYNC);
867 #ifdef OMAP5
868             codec = VIDDEC3_create(engine, "ivahd_mpeg4dec", (VIDDEC3_Params *)mpeg4_params);
869 #else
870             codec = VIDDEC3_create(engine, "ivahd_mpeg4vdec", (VIDDEC3_Params *)mpeg4_params);
871 #endif
872             break;
874         case DCE_TEST_VC1SMP :
875         case DCE_TEST_VC1AP :
876             vc1_params = (IVC1VDEC_Params *) params;
878             DEBUG("dce_alloc VIDDEC3_Params successful vc1_params=%p", vc1_params);
880             err = msync((Ptr)vc1_params, sizeof(IVC1VDEC_Params), MS_CACHE_ONLY | MS_SYNC);
882             codec = VIDDEC3_create(engine, "ivahd_vc1vdec", (VIDDEC3_Params *)vc1_params);
883             break;
885         case DCE_TEST_MJPEG :
886             mjpeg_params = (IJPEGVDEC_Params *) params;
887             mjpeg_params->ErrorConcealmentON = TRUE;
888             mjpeg_params->debugTraceLevel = 0;
889             mjpeg_params->lastNFramesToLog = 0;
890             mjpeg_params->sliceSwitchON = 0;
891             mjpeg_params->numSwitchPerFrame = 0;
892             mjpeg_params->numRestartMarkerPerSwitch = 0;
894             DEBUG("dce_alloc VIDDEC3_Params successful mjpeg_params=%p", mjpeg_params);
896             err = msync((Ptr)mjpeg_params, sizeof(IJPEGVDEC_Params), MS_CACHE_ONLY | MS_SYNC);
898             codec = VIDDEC3_create(engine, "ivahd_jpegvdec", (VIDDEC3_Params *)mjpeg_params);
899             break;
900 #ifdef ENABLE_MPEG2
901         case DCE_TEST_MPEG2 :
902             mpeg2_params = (IMPEG2VDEC_Params *) params;
903             mpeg2_params->outloopDeBlocking = TRUE;
904             mpeg2_params->ErrorConcealmentON = FALSE;
905             mpeg2_params->debugTraceLevel = 0;
906             mpeg2_params->lastNFramesToLog = 0;
908             DEBUG("dce_alloc VIDDEC3_Params successful mpeg2_params=%p", mpeg2_params);
910             err = msync((Ptr)mpeg2_params, sizeof(IMPEG2VDEC_Params), MS_CACHE_ONLY | MS_SYNC);
912             codec = VIDDEC3_create(engine, "ivahd_mpeg2vdec", (VIDDEC3_Params *)mpeg2_params);
913             break;
914 #endif
915     }
917     if( !codec ) {
918         ERROR("fail");
919         goto out;
920     }
922     DEBUG("VIDDEC3_create successful codec=%p", codec);
924     switch( codec_switch ) {
925         case DCE_TEST_H264 :
926             dynParams = dce_alloc(sizeof(IH264VDEC_DynamicParams));
927             dynParams->size = sizeof(IH264VDEC_DynamicParams);
928             break;
929         case DCE_TEST_MPEG4 :
930             dynParams = dce_alloc(sizeof(IMPEG4VDEC_DynamicParams));
931             dynParams->size = sizeof(IMPEG4VDEC_DynamicParams);
932             dynParams->lateAcquireArg = -1;
933             break;
934         case DCE_TEST_VC1SMP :
935         case DCE_TEST_VC1AP :
936             dynParams = dce_alloc(sizeof(IVC1VDEC_DynamicParams));
937             dynParams->size = sizeof(IVC1VDEC_DynamicParams);
938             dynParams->lateAcquireArg = -1;
939             break;
940         case DCE_TEST_MJPEG :
941             dynParams = dce_alloc(sizeof(IJPEGVDEC_DynamicParams));
942             dynParams->size = sizeof(IJPEGVDEC_DynamicParams);
943             dynParams->lateAcquireArg = -1;
944             break;
945 #ifdef ENABLE_MPEG2
946         case DCE_TEST_MPEG2 :
947             dynParams = dce_alloc(sizeof(IMPEG2VDEC_DynamicParams));
948             dynParams->size = sizeof(IMPEG2VDEC_DynamicParams);
949             dynParams->lateAcquireArg = -1;
950             break;
951 #endif
952     }
954     dynParams->decodeHeader  = XDM_DECODE_AU;
955     /*Not Supported: Set default*/
956     dynParams->displayWidth  = 0;
957     dynParams->frameSkipMode = IVIDEO_NO_SKIP;
958     dynParams->newFrameFlag  = XDAS_TRUE;
961     //Testing XDM_GETVERSION
962     // NOT WORKING
963 #if 0
965     switch( codec_switch ) {
966         case DCE_TEST_H264 :
968             DEBUG("dce_alloc IH264VDEC_DynamicParams successful dynParams=%p", dynParams);
969             h264_dynParams = (IH264VDEC_DynamicParams *) dynParams;
970             DEBUG("dce_alloc IH264VDEC_DynamicParams successful h264_dynParams=%p", h264_dynParams);
972             status = dce_alloc(sizeof(IH264VDEC_Status));
973             status->size = sizeof(IH264VDEC_Status);
974             DEBUG("dce_alloc IH264VDEC_Status successful status=%p", status);
976             status->data.buf = (XDAS_Int8 *) version_buffer;
977             h264_status = (IH264VDEC_Status *) status;
978             DEBUG("dce_alloc IH264VDEC_Status successful h264_status=%p", h264_status);
980             //((IH264VDEC_Status*)h264_status)->viddec3Status->data.buf = version_buffer;
981             err = VIDDEC3_control(codec, XDM_GETVERSION, (VIDDEC3_DynamicParams *) h264_dynParams, (VIDDEC3_Status *) h264_status);
983             DEBUG("dce_alloc IH264VDEC_Status get_version h264_status=%s", (((VIDDEC3_Status *)h264_status)->data.buf));
984             break;
985         default :
986             DEBUG("Not implemented or supported codec_switch %d", codec_switch);
987     }
989     if( status ) {
990         dce_free(status);
991     }
992 #endif
994     switch( codec_switch ) {
995         case DCE_TEST_H264 :
997             DEBUG("dce_alloc IH264VDEC_DynamicParams successful dynParams=%p", dynParams);
998             h264_dynParams = (IH264VDEC_DynamicParams *) dynParams;
999             DEBUG("dce_alloc IH264VDEC_DynamicParams successful h264_dynParams=%p", h264_dynParams);
1001             status = dce_alloc(sizeof(IH264VDEC_Status));
1002             status->size = sizeof(IH264VDEC_Status);
1003             DEBUG("dce_alloc IH264VDEC_Status successful status=%p", status);
1005             h264_status = (IH264VDEC_Status *) status;
1006             DEBUG("dce_alloc IH264VDEC_Status successful h264_status=%p", h264_status);
1007             err = VIDDEC3_control(codec, XDM_SETPARAMS, (VIDDEC3_DynamicParams *) h264_dynParams, (VIDDEC3_Status *) h264_status);
1008             break;
1010         case DCE_TEST_MPEG4 :
1012             DEBUG("dce_alloc IMPEG4VDEC_DynamicParams successful dynParams=%p", dynParams);
1013             mpeg4_dynParams = (IMPEG4VDEC_DynamicParams *) dynParams;
1014             DEBUG("dce_alloc IMPEG4VDEC_DynamicParams successful mpeg4_dynParams=%p", mpeg4_dynParams);
1016             status = dce_alloc(sizeof(IMPEG4VDEC_Status));
1017             status->size = sizeof(IMPEG4VDEC_Status);
1018             DEBUG("dce_alloc IMPEG4VDEC_Status successful status=%p", status);
1020             mpeg4_status = (IMPEG4VDEC_Status *) status;
1021             DEBUG("dce_alloc IMPEG4VDEC_Status successful mpeg4_status=%p", mpeg4_status);
1022             err = VIDDEC3_control(codec, XDM_SETPARAMS, (VIDDEC3_DynamicParams *) mpeg4_dynParams, (VIDDEC3_Status *) mpeg4_status);
1023             break;
1025         case DCE_TEST_VC1SMP :
1026         case DCE_TEST_VC1AP :
1028             DEBUG("dce_alloc IVC1VDEC_DynamicParams successful dynParams=%p", dynParams);
1029             vc1_dynParams = (IVC1VDEC_DynamicParams *) dynParams;
1030             DEBUG("dce_alloc IVC1VDEC_DynamicParams successful vc1_dynParams=%p", vc1_dynParams);
1032             status = dce_alloc(sizeof(IVC1VDEC_Status));
1033             status->size = sizeof(IVC1VDEC_Status);
1034             DEBUG("dce_alloc IVC1VDEC_Status successful status=%p", status);
1036             vc1_status = (IVC1VDEC_Status *) status;
1037             DEBUG("dce_alloc IVC1VDEC_Status successful vc1_status=%p", vc1_status);
1038             err = VIDDEC3_control(codec, XDM_SETPARAMS, (VIDDEC3_DynamicParams *) vc1_dynParams, (VIDDEC3_Status *) vc1_status);
1039             break;
1041         case DCE_TEST_MJPEG :
1043             DEBUG("dce_alloc IJPEGVDEC_DynamicParams successful dynParams=%p", dynParams);
1044             mjpeg_dynParams = (IJPEGVDEC_DynamicParams *) dynParams;
1045             mjpeg_dynParams->decodeThumbnail = 0;
1046             mjpeg_dynParams->thumbnailMode = IJPEGVDEC_THUMBNAIL_DOWNSAMPLE;
1047             mjpeg_dynParams->downsamplingFactor = IJPEGVDEC_NODOWNSAMPLE;
1048             mjpeg_dynParams->streamingCompliant = 1;
1050             DEBUG("dce_alloc IJPEGVDEC_DynamicParams successful mjpeg_dynParams=%p", mjpeg_dynParams);
1052             status = dce_alloc(sizeof(IVC1VDEC_Status));
1053             status->size = sizeof(IJPEGVDEC_Status);
1054             DEBUG("dce_alloc IVC1VDEC_Status successful status=%p", status);
1056             mjpeg_status = (IJPEGVDEC_Status *) status;
1057             DEBUG("dce_alloc IJPEGVDEC_Status successful mjpeg_status=%p", mjpeg_status);
1058             err = VIDDEC3_control(codec, XDM_SETPARAMS, (VIDDEC3_DynamicParams *) mjpeg_dynParams, (VIDDEC3_Status *) mjpeg_status);
1059             break;
1060 #ifdef ENABLE_MPEG2
1061         case DCE_TEST_MPEG2 :
1063             DEBUG("dce_alloc IMPEG2VDEC_DynamicParams successful dynParams=%p", dynParams);
1064             mpeg2_dynParams = (IMPEG2VDEC_DynamicParams *) dynParams;
1065             //MPEG2 buffer width should be 128 byte aligned for non TILER (atleast)
1066             //If displayWidth=0 then MPEG2 codec does not have a way to calculate
1067             //the stride as compared to other codecs which can calculate it from
1068             //buffer size and image height.stride=buffersize/(height*1.5)
1069             mpeg2_dynParams->viddecDynamicParams.displayWidth = padded_width;
1071             DEBUG("dce_alloc IMPEG2VDEC_DynamicParams successful mpeg2_dynParams=%p", mpeg2_dynParams);
1073             status = dce_alloc(sizeof(IMPEG2VDEC_Status));
1074             status->size = sizeof(IMPEG2VDEC_Status);
1075             DEBUG("dce_alloc IMPEG2VDEC_Status successful status=%p", status);
1077             mpeg2_status = (IMPEG2VDEC_Status *) status;
1078             DEBUG("dce_alloc IMPEG2VDEC_Status successful mpeg2_status=%p", mpeg2_status);
1079             err = VIDDEC3_control(codec, XDM_SETPARAMS, (VIDDEC3_DynamicParams *) mpeg2_dynParams, (VIDDEC3_Status *) mpeg2_status);
1080             break;
1081 #endif
1082         default :
1083             DEBUG("Not implemented or supported codec_switch %d", codec_switch);
1084     }
1086     if( err ) {
1087         ERROR("fail: %d", err);
1088         goto shutdown;
1089     }
1091     DEBUG("VIDDEC3_control XDM_SETPARAMS successful");
1093     DEBUG("input buffer configuration width %d height %d", width, height);
1094     inBufs = dce_alloc(sizeof(XDM2_BufDesc));
1095     inBufs->numBufs = 1;
1096     input = tiler_alloc(width * height, 0);
1097     inBufs->descs[0].buf = (XDAS_Int8 *)input;
1098     inBufs->descs[0].memType = XDM_MEMTYPE_RAW;
1100     DEBUG("inBufs->descs[0].buf %p input %p", inBufs->descs[0].buf, input);
1102     outBufs = dce_alloc(sizeof(XDM2_BufDesc));
1104     DEBUG("output buffer configuration num_buffers %d padded_width %d padded_height %d", num_buffers, padded_width, padded_height);
1106 #ifdef PROFILE_TIME
1107     uint64_t    alloc_time_start = mark_microsecond(NULL);
1108 #endif
1110     if( !(strcmp(tilerbuffer, "tiler"))) {
1111         DEBUG("Output allocate through tiler");
1112         tiler = 1;
1113         err = output_allocate(outBufs, num_buffers,
1114                               padded_width, padded_height, stride);
1115     } else {
1116         DEBUG("Output allocate through non-tiler");
1117         tiler = 0;
1118         err = output_allocate_nonTiler(outBufs, num_buffers,
1119                                        padded_width, padded_height, stride);
1120     }
1122 #ifdef PROFILE_TIME
1123     output_alloc_time = mark_microsecond(&alloc_time_start);
1124 #endif
1126     if( err ) {
1127         ERROR("fail: %d", err);
1128         goto shutdown;
1129     }
1131     inArgs = dce_alloc(sizeof(IVIDDEC3_InArgs));
1132     inArgs->size = sizeof(IVIDDEC3_InArgs);
1134     outArgs = dce_alloc(sizeof(IVIDDEC3_OutArgs));
1135     outArgs->size = sizeof(IVIDDEC3_OutArgs);
1137 #ifdef PROFILE_TIME
1138     total_init_time = (uint64_t)mark_microsecond(&init_start_time);
1139     INFO("total_init_time %llu output_alloc_time %llu actual init time in: %lld us", total_init_time, output_alloc_time, total_init_time  - output_alloc_time);
1140 #endif
1142     while( inBufs->numBufs && outBufs->numBufs ) {
1143         OutputBuffer   *buf;
1144         int             n, i;
1146         if( !outBufsInUse ) {
1147             buf = output_get();
1148             if( !buf ) {
1149                 ERROR("fail: out of buffers");
1150                 goto shutdown;
1151             }
1152         } else {
1153             buf = 0;
1154         }
1156         n = read_input(in_pattern, in_cnt, input);
1157         if( n && (n != -1)) {
1158             eof = 0;
1159             inBufs->numBufs = 1;
1160             inBufs->descs[0].buf = (XDAS_Int8 *)input;
1161             inBufs->descs[0].bufSize.bytes = n;
1162             inArgs->numBytes = n;
1163             DEBUG("push: %d (%d bytes) (%p)", in_cnt, n, buf);
1164             in_cnt++;
1166             /*
1167              * Input buffer has data to be decoded.
1168              */
1169             inArgs->inputID = (XDAS_Int32)buf;
1170             if( !outBufsInUse ) {
1171                 outBufs->numBufs = 2;
1172                 outBufs->descs[0].buf = (XDAS_Int8 *)buf->y;
1173                 outBufs->descs[1].buf = (XDAS_Int8 *)buf->uv;
1174             }
1175         } else if( n == -1 ) {
1177             // Set EOF as 1 to ensure flush completes
1178             eof = 1;
1179             in_cnt++;
1181             switch( codec_switch ) {
1182                 case DCE_TEST_H264 :
1183                     DEBUG("Calling VIDDEC3_control XDM_FLUSH h264_dynParams %p h264_status %p", h264_dynParams, h264_status);
1184                     err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) h264_dynParams, (VIDDEC3_Status *) h264_status);
1185                     break;
1186                 case DCE_TEST_MPEG4 :
1187                     DEBUG("Calling VIDDEC3_control XDM_FLUSH mpeg4_dynParams %p mpeg4_status %p", mpeg4_dynParams, mpeg4_status);
1188                     err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) mpeg4_dynParams, (VIDDEC3_Status *) mpeg4_status);
1189                     break;
1190                 case DCE_TEST_VC1SMP :
1191                 case DCE_TEST_VC1AP :
1192                     DEBUG("Calling VIDDEC3_control XDM_FLUSH vc1_dynParams %p vc1_status %p", vc1_dynParams, vc1_status);
1193                     err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) vc1_dynParams, (VIDDEC3_Status *) vc1_status);
1194                     break;
1195                 case DCE_TEST_MJPEG :
1196                     DEBUG("Calling VIDDEC3_control XDM_FLUSH mjpeg_dynParams %p mjpeg_status %p", mjpeg_dynParams, mjpeg_status);
1197                     err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) mjpeg_dynParams, (VIDDEC3_Status *) mjpeg_status);
1198                     break;
1199 #ifdef ENABLE_MPEG2
1200                 case DCE_TEST_MPEG2 :
1201                     DEBUG("Calling VIDDEC3_control XDM_FLUSH mpeg2_dynParams %p mpeg2_status %p", mpeg2_dynParams, mpeg2_status);
1202                     err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) mpeg2_dynParams, (VIDDEC3_Status *) mpeg2_status);
1203                     break;
1204 #endif
1205             }
1207             /* We have sent the XDM_FLUSH, call VIDDEC3_process until we get
1208              * an error of XDM_EFAIL which tells us there are no more buffers
1209              * at codec level.
1210              */
1212             inArgs->inputID = 0;
1213             inArgs->numBytes = 0;
1214             inBufs->descs[0].buf = NULL;
1215             inBufs->descs[0].bufSize.bytes = 0;
1216             outBufs->numBufs = 0;
1217             outBufs->descs[0].buf = NULL;
1218             outBufs->descs[1].buf = NULL;
1219             if( buf ) {
1220                 output_release(buf);
1221             }
1222             outBufsInUse = 0;
1225         } else {
1226             /* end of input.. */
1227             inBufs->numBufs = 0;
1228             eof = 1;
1230             switch( codec_switch ) {
1231                 case DCE_TEST_H264 :
1232                     DEBUG("Calling VIDDEC3_control XDM_FLUSH h264_dynParams %p h264_status %p", h264_dynParams, h264_status);
1233                     err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) h264_dynParams, (VIDDEC3_Status *) h264_status);
1234                     break;
1235                 case DCE_TEST_MPEG4 :
1236                     DEBUG("Calling VIDDEC3_control XDM_FLUSH mpeg4_dynParams %p mpeg4_status %p", mpeg4_dynParams, mpeg4_status);
1237                     err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) mpeg4_dynParams, (VIDDEC3_Status *) mpeg4_status);
1238                     break;
1239                 case DCE_TEST_VC1SMP :
1240                 case DCE_TEST_VC1AP :
1241                     DEBUG("Calling VIDDEC3_control XDM_FLUSH vc1_dynParams %p vc1_status %p", vc1_dynParams, vc1_status);
1242                     err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) vc1_dynParams, (VIDDEC3_Status *) vc1_status);
1243                     break;
1244                 case DCE_TEST_MJPEG :
1245                     DEBUG("Calling VIDDEC3_control XDM_FLUSH mjpeg_dynParams %p mjpeg_status %p", mjpeg_dynParams, mjpeg_status);
1246                     err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) mjpeg_dynParams, (VIDDEC3_Status *) mjpeg_status);
1247                     break;
1248 #ifdef ENABLE_MPEG2
1249                 case DCE_TEST_MPEG2 :
1250                     DEBUG("Calling VIDDEC3_control XDM_FLUSH mpeg2_dynParams %p mpeg2_status %p", mpeg2_dynParams, mpeg2_status);
1251                     err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) mpeg2_dynParams, (VIDDEC3_Status *) mpeg2_status);
1252                     break;
1253 #endif
1254             }
1256             /* We have sent the XDM_FLUSH, call VIDDEC3_process until we get
1257              * an error of XDM_EFAIL which tells us there are no more buffers
1258              * at codec level.
1259              */
1261             inArgs->inputID = 0;
1262             inArgs->numBytes = 0;
1263             inBufs->numBufs = 0;
1264             inBufs->descs[0].buf = NULL;
1265             inBufs->descs[0].bufSize.bytes = 0;
1266             outBufs->numBufs = 0;
1267             outBufs->descs[0].buf = NULL;
1268             outBufs->descs[1].buf = NULL;
1269             if( buf ) {
1270                 output_release(buf);
1271             }
1272         }
1274 #ifdef DUMPINPUTDATA
1275         DEBUG("input data dump inArgs->numBytes[%d] inputDump[%p]", inArgs->numBytes, inputDump);
1277         //Dump the file
1278         if( inputDump == NULL ) {
1279             inputDump = fopen("/tmp/inputdump.h264", "ab");
1280             DEBUG("input data dump file open %p errno %d", inputDump, errno);
1281             if( inputDump == NULL ) {
1282                 DEBUG("Opening input Dump /tmp/inputdump.h264 file FAILED");
1283             }
1284         }
1285         DEBUG("input data dump file open %p Successful", inputDump);
1287         fwrite(input, sizeof(char), inArgs->numBytes, inputDump);
1288         DEBUG("Dumping input file with size = %d ", inArgs->numBytes);
1289         fflush(inputDump);
1290         fclose(inputDump);
1291         inputDump = NULL;
1292     #endif
1294         int    iters = 0;
1296         do {
1297             DEBUG("Calling VIDDEC3_process inArgs->inputID=%x inBufs->descs[0].buf %p inBufs->descs.bufSize %d input %p",
1298                   inArgs->inputID, inBufs->descs[0].buf, (int) inBufs->descs[0].bufSize.bytes, input);
1299 #ifdef PROFILE_TIME
1300             codec_process_time = mark_microsecond(NULL);
1301 #endif
1302             err = VIDDEC3_process(codec, inBufs, outBufs, inArgs, outArgs);
1303 #ifdef PROFILE_TIME
1304             INFO("processed returned in: %llu us", (uint64_t) mark_microsecond(&codec_process_time));
1305 #endif
1306             if( err ) {
1307                 if( XDM_ISFATALERROR(outArgs->extendedError)) {
1308                     ERROR("process returned error: %d\n", err);
1309                     ERROR("extendedError: %08x", outArgs->extendedError);
1310                     goto shutdown;
1311                 } else if( eof ) {
1312                     /*
1313                      * Flush has been ordered, processing the returned output from codec.
1314                      * For H.264, bit 18 - IH264VDEC_ERR_STREAM_END indicates flush is completed.
1315                      * For MPEG4, bit 24 - IMPEG4VDEC_ERR_STREAM_END indicates flush is completed.
1316                      * Only return XDM_EFAIL, when those bit are set.
1317                      */
1318                     ERROR("Codec_process returned err=%d, extendedError=%08x", err, outArgs->extendedError);
1319                     err = XDM_EFAIL;
1321                     if((!(((outArgs->extendedError) >> 24) & 0x1)) &&
1322                        ((ivahd_decode_type == 2 /*IVAHD_MP4V_DECODE*/) ||
1323                         (ivahd_decode_type == 3 /*IVAHD_S263_DECODE*/))) {
1324                         err = XDM_EOK;
1325                     }
1327                     if((!(((outArgs->extendedError) >> 18) & 0x1)) &&
1328                        ((ivahd_decode_type == 1 /*IVAHD_H264_DECODE*/) ||
1329                         (ivahd_decode_type == 0 /*IVAHD_AVC1_DECODE*/))) {
1330                         err = XDM_EOK;
1331                     }
1333                     if( err == XDM_EFAIL ) {
1334                         DEBUG("-------------------- Flush completed------------------------");
1335                     }
1336                 } else {
1337                     DEBUG("Non-fatal err=%d, extendedError=%08x", err, outArgs->extendedError);
1338                     err = XDM_EOK;
1339                 }
1340             }
1342             /*
1343              * Handling of output data from codec
1344              */
1345             if( tiler ) {
1346                 for( i = 0; outArgs->outputID[i]; i++ ) {
1347                     /* calculate offset to region of interest */
1348                     XDM_Rect   *r = &(outArgs->displayBufs.bufDesc[0].activeFrameRegion);
1350                     int    yoff  = (r->topLeft.y * stride) + r->topLeft.x;
1351                     int    uvoff = (r->topLeft.y * stride / 2) + (stride * padded_height) + r->topLeft.x;
1353                     /* get the output buffer and write it to file */
1354                     buf = (OutputBuffer *)outArgs->outputID[i];
1355                     DEBUG("pop: %d (%p)", out_cnt, buf);
1357                     if( out_cnt < frames_to_write ) {  // write first 30 frames to output file out_cnt < 300
1358                         write_output(out_pattern, out_cnt++, buf->buf + yoff,
1359                                      buf->buf + uvoff, stride);
1360                     } else {
1361                         out_cnt++;
1362                     }
1363                 }
1364             } else {
1365                 for( i = 0; outArgs->outputID[i]; i++ ) {
1366                     /* calculate offset to region of interest */
1367                     XDM_Rect   *r = &(outArgs->displayBufs.bufDesc[0].activeFrameRegion);
1369                     int    yoff  = (r->topLeft.y * padded_width) + r->topLeft.x;
1370                     int    uvoff = (r->topLeft.y * padded_width / 2) + (padded_height * padded_width) + r->topLeft.x;
1372                     /* get the output buffer and write it to file */
1373                     buf = (OutputBuffer *)outArgs->outputID[i];
1374                     DEBUG("pop: %d (%p)", out_cnt, buf);
1376                     if( out_cnt < 300 ) {  // write first 300 frames to output file
1377                         write_output(out_pattern, out_cnt++, buf->buf + yoff,
1378                                      buf->buf + uvoff, padded_width);
1379                     } else {
1380                         out_cnt++;
1381                     }
1382                 }
1383             }
1385             for( i = 0; outArgs->freeBufID[i]; i++ ) {
1386                 DEBUG("freeBufID[%d] = %d", i, outArgs->freeBufID[i]);
1387                 buf = (OutputBuffer *)outArgs->freeBufID[i];
1388                 output_release(buf);
1389             }
1391             if( outArgs->outBufsInUseFlag ) {
1392                 outBufsInUse = TRUE;
1393                 DEBUG("outBufsInUseFlag is SET. Not sending a new output buffer to codec on the next Codec_process ");
1394             } else {
1395                 outBufsInUse = FALSE;
1396             }
1398             ++iters; // Guard for infinite VIDDEC3_PROCESS loop when codec never return XDM_EFAIL
1399         } while( eof && (err != XDM_EFAIL) && (iters < 100));  // Multiple VIDDEC3_process when eof until err == XDM_EFAIL
1401     }
1403 shutdown:
1405     printf("\nDeleting codec...\n");
1406     VIDDEC3_delete(codec);
1408 out:
1409     if( engine ) {
1410         Engine_close(engine);
1411     }
1412     if( params ) {
1413         dce_free(params);
1414     }
1415     if( dynParams ) {
1416         dce_free(dynParams);
1417     }
1418     if( status ) {
1419         dce_free(status);
1420     }
1421     if( inBufs ) {
1422         dce_free(inBufs);
1423     }
1424     if( outBufs ) {
1425         dce_free(outBufs);
1426     }
1427     if( inArgs ) {
1428         dce_free(inArgs);
1429     }
1430     if( outArgs ) {
1431         dce_free(outArgs);
1432     }
1433     if( input ) {
1434         MemMgr_Free(input);
1435     }
1437     output_free();
1439     printf("DCE test completed...\n");
1441     return (0);