[libDCE] Add IPC 3.x Adapted code to Repository
[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, 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 != 8 ) {
609         printf("usage:   %s width height framefile inpattern outpattern codec tilerbuffer\n", argv[0]);
610         printf("example: %s 320 240 frame.txt in.h264 out.yuv h264 tiler\n", argv[0]);
611         printf("example: %s 640 480 frame.txt in.m4v out.yuv mpeg4 nontiler\n", argv[0]);
612         printf("example: %s 720 480 frame.txt in.vc1 out.yuv vc1ap tiler\n", argv[0]);
613         printf("example: %s 320 240 frame.txt in.vc1 out.yuv vc1smp nontiler\n", argv[0]);
614         printf("example: %s 1280 720 frame.txt in.bin out.yuv mjpeg tiler\n", argv[0]);
615         printf("example: %s 1920 1088 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     frameData   = argv[3];
624     in_pattern  = argv[4];
625     out_pattern = argv[5];
626     strcpy(vid_codec, argv[6]);
627     strcpy(tilerbuffer, argv[7]);
629     printf("Selected codec: %s\n", vid_codec);
630     printf("Selected buffer: %s\n", tilerbuffer);
632     enum {
633         DCE_TEST_H264   = 1,
634         DCE_TEST_MPEG4  = 2,
635         DCE_TEST_VC1SMP = 3,
636         DCE_TEST_VC1AP  = 4,
637         DCE_TEST_MJPEG  = 5,
638         DCE_TEST_MPEG2  = 6
639     };
641     if((!(strcmp(vid_codec, "h264")))) {
642         ivahd_decode_type = IVAHD_H264_DECODE;
643         codec_switch = DCE_TEST_H264;
645     } else if((!(strcmp(vid_codec, "mpeg4")))) {
646         ivahd_decode_type = IVAHD_MP4V_DECODE;
647         codec_switch = DCE_TEST_MPEG4;
649     } else if((!(strcmp(vid_codec, "vc1smp")))) {
650         ivahd_decode_type = IVAHD_VC1SMP_DECODE;
651         codec_switch = DCE_TEST_VC1SMP;
652         vc1_flush = 1;
654     } else if((!(strcmp(vid_codec, "vc1ap")))) {
655         ivahd_decode_type = IVAHD_VC1AP_DECODE;
656         codec_switch = DCE_TEST_VC1AP;
657         vc1_flush = 1;
659     } else if((!(strcmp(vid_codec, "mjpeg")))) {
660         ivahd_decode_type = IVAHD_JPEGV_DECODE;
661         codec_switch = DCE_TEST_MJPEG;
663     } else if((!(strcmp(vid_codec, "mpeg2")))) {
664         ivahd_decode_type = IVAHD_MP2V_DECODE;
665         codec_switch = DCE_TEST_MPEG2;
667     } else {
668         printf("No valid codec entry. Please use: h264, mpeg4, vc1ap, vc1smp, mjpeg or mpeg2\n");
669         return (1);
670     }
672     DEBUG("Storing frame size data");
673     frameFile = fopen(frameData, "rb");
674     DEBUG("frameFile open %p errno %d", frameFile, errno);
675     if( frameFile == NULL ) {
676         DEBUG("Opening framesize file FAILED");
677     }
679     /* Read the frame Size from the frame size file */
680     while( NULL != fgets((char *)frameinput, 10, frameFile)) {
681         frameSize[frameCount] = atoi((char *)frameinput);
682         //DEBUG("frameSize[%d] = %d \n", frameCount, frameSize[frameCount]);
684         if( frameCount > 64000 ) {
685             DEBUG("Num Frames %d exceeded MAX limit %d \n", frameCount, 64000);
686             goto out;
687         }
688         frameCount++;
689     }
691     DEBUG("Num Frames is %d width=%d, height=%d", frameCount, width, height);
693     /* calculate output buffer parameters: */
694     width  = ALIGN2(width, 4);         /* round up to MB */
695     height = ALIGN2(height, 4);        /* round up to MB */
697     switch( codec_switch ) {
698         case DCE_TEST_H264 :
699             padded_width  = ALIGN2(width + (2 * PADX_H264), 7);
700             padded_height = height + 4 * PADY_H264;
701             // Some clips don't have enough buffers based on N+3 formula
702             // Need sps->num_ref_frames data to match filter precisely
703             //num_buffers   = 2 * (MIN(16, 32768 / ((width / 16) * (height / 16)))) + 1;
704             num_buffers   = (MIN(16, 32768 / ((width / 16) * (height / 16)))) + 3;
705             break;
706         case DCE_TEST_MPEG4 :
707             padded_width = ALIGN2(width + PADX_MPEG4, 7);
708             padded_height = height + PADY_MPEG4;
709             num_buffers = 8;
710             break;
711         case DCE_TEST_VC1SMP :
712         case DCE_TEST_VC1AP :
713             padded_width = ALIGN2(width + (2 * PADX_VC1), 7);
714             padded_height = (ALIGN2(height / 2, 4) * 2) + 4 * PADY_VC1;
715             num_buffers = 5;
716             break;
717         case DCE_TEST_MJPEG :
718             padded_width = ALIGN2(width, 4);
719             padded_height = ALIGN2(height, 4);
720             num_buffers = 5;
721             break;
722         case DCE_TEST_MPEG2 :
723             padded_width = ALIGN2(width, 7);
724             padded_height = height;
725             num_buffers = 4;
726             break;
727     }
729     if( oned ) {
730         stride = padded_width;
731     } else {
732         stride = 4096;
733     }
735     DEBUG("padded_width=%d, padded_height=%d, stride=%d, num_buffers=%d",
736           padded_width, padded_height, stride, num_buffers);
737 #ifdef PROFILE_TIME
738     init_start_time = mark_microsecond(NULL);
739 #endif
740     engine = Engine_open("ivahd_vidsvr", NULL, &ec);
742     if( !engine ) {
743         ERROR("fail");
744         goto out;
745     }
747     DEBUG("Engine_open successful engine=%p", engine);
749     switch( codec_switch ) {
750         case DCE_TEST_H264 :
751             params = dce_alloc(sizeof(IH264VDEC_Params));
752             if( !params ) {
753                 ERROR("dce_alloc fail");
754                 goto out;
755             }
756             params->size = sizeof(IH264VDEC_Params);
757             params->maxBitRate      = 10000000;
758             params->displayDelay    = IVIDDEC3_DISPLAY_DELAY_AUTO;
759             params->numOutputDataUnits  = 0;
760             params->maxWidth            = width;
761             break;
762         case DCE_TEST_MPEG4 :
763             params = dce_alloc(sizeof(IMPEG4VDEC_Params));
764             if( !params ) {
765                 ERROR("dce_alloc fail");
766                 goto out;
767             }
768             params->size = sizeof(IMPEG4VDEC_Params);
769             params->maxBitRate      = 10000000;
770             params->displayDelay    = IVIDDEC3_DISPLAY_DELAY_1;
771             params->numOutputDataUnits  = 0;
772             params->maxWidth            = width;
773             break;
774         case DCE_TEST_VC1SMP :
775         case DCE_TEST_VC1AP :
776             params = dce_alloc(sizeof(IVC1VDEC_Params));
777             if( !params ) {
778                 ERROR("dce_alloc fail");
779                 goto out;
780             }
781             params->size = sizeof(IVC1VDEC_Params);
782             params->maxBitRate      = 45000000;
783             params->displayDelay    = IVIDDEC3_DISPLAY_DELAY_1;
784             params->numOutputDataUnits  = 0;
785             params->maxWidth            = width;
786             break;
787         case DCE_TEST_MJPEG :
788             params = dce_alloc(sizeof(IJPEGVDEC_Params));
789             if( !params ) {
790                 ERROR("dce_alloc fail");
791                 goto out;
792             }
793             params->size = sizeof(IJPEGVDEC_Params);
794             params->maxBitRate      = 10000000;
795             params->displayDelay    = IVIDDEC3_DISPLAY_DELAY_1;
796             params->numOutputDataUnits  = 1;
797             params->maxWidth            = width;
798             break;
799 #ifdef ENABLE_MPEG2
800         case DCE_TEST_MPEG2 :
801             params = dce_alloc(sizeof(IMPEG2VDEC_Params));
802             if( !params ) {
803                 ERROR("dce_alloc fail");
804                 goto out;
805             }
806             params->size = sizeof(IMPEG2VDEC_Params);
807             params->maxBitRate      = 10000000;
808             params->displayDelay    = IVIDDEC3_DISPLAY_DELAY_1;
809             params->numOutputDataUnits  = 0;
810             params->maxWidth            = padded_width;
811             break;
812 #endif
813     }
815     params->maxHeight           = height;
816     params->maxFrameRate        = 30000;
817     params->dataEndianness      = XDM_BYTE;
818     params->forceChromaFormat   = XDM_YUV_420SP;
819     params->operatingMode       = IVIDEO_DECODE_ONLY;
820     //params->displayDelay        = IVIDDEC3_DECODE_ORDER;
821     params->displayBufsMode     = IVIDDEC3_DISPLAYBUFS_EMBEDDED;
822     params->inputDataMode       = IVIDEO_ENTIREFRAME;
823     params->metadataType[0]     = IVIDEO_METADATAPLANE_NONE;
824     params->metadataType[1]     = IVIDEO_METADATAPLANE_NONE;
825     params->metadataType[2]     = IVIDEO_METADATAPLANE_NONE;
826     params->outputDataMode      = IVIDEO_ENTIREFRAME;
827     params->numInputDataUnits   = 0;
828     params->errorInfoMode       = IVIDEO_ERRORINFO_OFF;
830     DEBUG("dce_alloc VIDDEC3_Params successful params=%p", params);
832     switch( codec_switch ) {
833         case DCE_TEST_H264 :
834             h264_params = (IH264VDEC_Params *) params;
835             h264_params->dpbSizeInFrames = IH264VDEC_DPB_NUMFRAMES_AUTO;
836             h264_params->pConstantMemory = 0;
837             h264_params->presetLevelIdc = IH264VDEC_LEVEL41;
838             h264_params->errConcealmentMode = IH264VDEC_APPLY_CONCEALMENT;
839             h264_params->temporalDirModePred = TRUE;
840             h264_params->detectCabacAlignErr = IH264VDEC_DISABLE_CABACALIGNERR_DETECTION;
842             DEBUG("dce_alloc VIDDEC3_Params successful h264_params=%p", h264_params);
844             err = msync((Ptr)h264_params, sizeof(IH264VDEC_Params), MS_CACHE_ONLY | MS_SYNC);
846             codec = VIDDEC3_create(engine, "ivahd_h264dec", (VIDDEC3_Params *)h264_params);
847             break;
849         case DCE_TEST_MPEG4 :
850             mpeg4_params = (IMPEG4VDEC_Params *) params;
851             mpeg4_params->outloopDeBlocking = TRUE;
852             mpeg4_params->sorensonSparkStream = FALSE;
853             mpeg4_params->errorConcealmentEnable = FALSE;
854             mpeg4_params->debugTraceLevel = 0;
855             mpeg4_params->lastNFramesToLog = 0;
856             mpeg4_params->paddingMode = IMPEG4VDEC_DEFAULT_MODE_PADDING;
858             DEBUG("dce_alloc VIDDEC3_Params successful mpeg4_params=%p", mpeg4_params);
860             err = msync((Ptr)mpeg4_params, sizeof(IMPEG4VDEC_Params), MS_CACHE_ONLY | MS_SYNC);
861 #ifdef OMAP5
862             codec = VIDDEC3_create(engine, "ivahd_mpeg4dec", (VIDDEC3_Params *)mpeg4_params);
863 #else
864             codec = VIDDEC3_create(engine, "ivahd_mpeg4vdec", (VIDDEC3_Params *)mpeg4_params);
865 #endif
866             break;
868         case DCE_TEST_VC1SMP :
869         case DCE_TEST_VC1AP :
870             vc1_params = (IVC1VDEC_Params *) params;
872             DEBUG("dce_alloc VIDDEC3_Params successful vc1_params=%p", vc1_params);
874             err = msync((Ptr)vc1_params, sizeof(IVC1VDEC_Params), MS_CACHE_ONLY | MS_SYNC);
876             codec = VIDDEC3_create(engine, "ivahd_vc1vdec", (VIDDEC3_Params *)vc1_params);
877             break;
879         case DCE_TEST_MJPEG :
880             mjpeg_params = (IJPEGVDEC_Params *) params;
881             mjpeg_params->ErrorConcealmentON = TRUE;
882             mjpeg_params->debugTraceLevel = 0;
883             mjpeg_params->lastNFramesToLog = 0;
884             mjpeg_params->sliceSwitchON = 0;
885             mjpeg_params->numSwitchPerFrame = 0;
886             mjpeg_params->numRestartMarkerPerSwitch = 0;
888             DEBUG("dce_alloc VIDDEC3_Params successful mjpeg_params=%p", mjpeg_params);
890             err = msync((Ptr)mjpeg_params, sizeof(IJPEGVDEC_Params), MS_CACHE_ONLY | MS_SYNC);
892             codec = VIDDEC3_create(engine, "ivahd_jpegvdec", (VIDDEC3_Params *)mjpeg_params);
893             break;
894 #ifdef ENABLE_MPEG2
895         case DCE_TEST_MPEG2 :
896             mpeg2_params = (IMPEG2VDEC_Params *) params;
897             mpeg2_params->outloopDeBlocking = TRUE;
898             mpeg2_params->ErrorConcealmentON = FALSE;
899             mpeg2_params->debugTraceLevel = 0;
900             mpeg2_params->lastNFramesToLog = 0;
902             DEBUG("dce_alloc VIDDEC3_Params successful mpeg2_params=%p", mpeg2_params);
904             err = msync((Ptr)mpeg2_params, sizeof(IMPEG2VDEC_Params), MS_CACHE_ONLY | MS_SYNC);
906             codec = VIDDEC3_create(engine, "ivahd_mpeg2vdec", (VIDDEC3_Params *)mpeg2_params);
907             break;
908 #endif
909     }
911     if( !codec ) {
912         ERROR("fail");
913         goto out;
914     }
916     DEBUG("VIDDEC3_create successful codec=%p", codec);
918     switch( codec_switch ) {
919         case DCE_TEST_H264 :
920             dynParams = dce_alloc(sizeof(IH264VDEC_DynamicParams));
921             dynParams->size = sizeof(IH264VDEC_DynamicParams);
922             break;
923         case DCE_TEST_MPEG4 :
924             dynParams = dce_alloc(sizeof(IMPEG4VDEC_DynamicParams));
925             dynParams->size = sizeof(IMPEG4VDEC_DynamicParams);
926             dynParams->lateAcquireArg = -1;
927             break;
928         case DCE_TEST_VC1SMP :
929         case DCE_TEST_VC1AP :
930             dynParams = dce_alloc(sizeof(IVC1VDEC_DynamicParams));
931             dynParams->size = sizeof(IVC1VDEC_DynamicParams);
932             dynParams->lateAcquireArg = -1;
933             break;
934         case DCE_TEST_MJPEG :
935             dynParams = dce_alloc(sizeof(IJPEGVDEC_DynamicParams));
936             dynParams->size = sizeof(IJPEGVDEC_DynamicParams);
937             dynParams->lateAcquireArg = -1;
938             break;
939 #ifdef ENABLE_MPEG2
940         case DCE_TEST_MPEG2 :
941             dynParams = dce_alloc(sizeof(IMPEG2VDEC_DynamicParams));
942             dynParams->size = sizeof(IMPEG2VDEC_DynamicParams);
943             dynParams->lateAcquireArg = -1;
944             break;
945 #endif
946     }
948     dynParams->decodeHeader  = XDM_DECODE_AU;
949     /*Not Supported: Set default*/
950     dynParams->displayWidth  = 0;
951     dynParams->frameSkipMode = IVIDEO_NO_SKIP;
952     dynParams->newFrameFlag  = XDAS_TRUE;
955     //Testing XDM_GETVERSION
956     // NOT WORKING
957 #if 0
959     switch( codec_switch ) {
960         case DCE_TEST_H264 :
962             DEBUG("dce_alloc IH264VDEC_DynamicParams successful dynParams=%p", dynParams);
963             h264_dynParams = (IH264VDEC_DynamicParams *) dynParams;
964             DEBUG("dce_alloc IH264VDEC_DynamicParams successful h264_dynParams=%p", h264_dynParams);
966             status = dce_alloc(sizeof(IH264VDEC_Status));
967             status->size = sizeof(IH264VDEC_Status);
968             DEBUG("dce_alloc IH264VDEC_Status successful status=%p", status);
970             status->data.buf = (XDAS_Int8 *) version_buffer;
971             h264_status = (IH264VDEC_Status *) status;
972             DEBUG("dce_alloc IH264VDEC_Status successful h264_status=%p", h264_status);
974             //((IH264VDEC_Status*)h264_status)->viddec3Status->data.buf = version_buffer;
975             err = VIDDEC3_control(codec, XDM_GETVERSION, (VIDDEC3_DynamicParams *) h264_dynParams, (VIDDEC3_Status *) h264_status);
977             DEBUG("dce_alloc IH264VDEC_Status get_version h264_status=%s", (((VIDDEC3_Status *)h264_status)->data.buf));
978             break;
979         default :
980             DEBUG("Not implemented or supported codec_switch %d", codec_switch);
981     }
983     if( status ) {
984         dce_free(status);
985     }
986 #endif
988     switch( codec_switch ) {
989         case DCE_TEST_H264 :
991             DEBUG("dce_alloc IH264VDEC_DynamicParams successful dynParams=%p", dynParams);
992             h264_dynParams = (IH264VDEC_DynamicParams *) dynParams;
993             DEBUG("dce_alloc IH264VDEC_DynamicParams successful h264_dynParams=%p", h264_dynParams);
995             status = dce_alloc(sizeof(IH264VDEC_Status));
996             status->size = sizeof(IH264VDEC_Status);
997             DEBUG("dce_alloc IH264VDEC_Status successful status=%p", status);
999             h264_status = (IH264VDEC_Status *) status;
1000             DEBUG("dce_alloc IH264VDEC_Status successful h264_status=%p", h264_status);
1001             err = VIDDEC3_control(codec, XDM_SETPARAMS, (VIDDEC3_DynamicParams *) h264_dynParams, (VIDDEC3_Status *) h264_status);
1002             break;
1004         case DCE_TEST_MPEG4 :
1006             DEBUG("dce_alloc IMPEG4VDEC_DynamicParams successful dynParams=%p", dynParams);
1007             mpeg4_dynParams = (IMPEG4VDEC_DynamicParams *) dynParams;
1008             DEBUG("dce_alloc IMPEG4VDEC_DynamicParams successful mpeg4_dynParams=%p", mpeg4_dynParams);
1010             status = dce_alloc(sizeof(IMPEG4VDEC_Status));
1011             status->size = sizeof(IMPEG4VDEC_Status);
1012             DEBUG("dce_alloc IMPEG4VDEC_Status successful status=%p", status);
1014             mpeg4_status = (IMPEG4VDEC_Status *) status;
1015             DEBUG("dce_alloc IMPEG4VDEC_Status successful mpeg4_status=%p", mpeg4_status);
1016             err = VIDDEC3_control(codec, XDM_SETPARAMS, (VIDDEC3_DynamicParams *) mpeg4_dynParams, (VIDDEC3_Status *) mpeg4_status);
1017             break;
1019         case DCE_TEST_VC1SMP :
1020         case DCE_TEST_VC1AP :
1022             DEBUG("dce_alloc IVC1VDEC_DynamicParams successful dynParams=%p", dynParams);
1023             vc1_dynParams = (IVC1VDEC_DynamicParams *) dynParams;
1024             DEBUG("dce_alloc IVC1VDEC_DynamicParams successful vc1_dynParams=%p", vc1_dynParams);
1026             status = dce_alloc(sizeof(IVC1VDEC_Status));
1027             status->size = sizeof(IVC1VDEC_Status);
1028             DEBUG("dce_alloc IVC1VDEC_Status successful status=%p", status);
1030             vc1_status = (IVC1VDEC_Status *) status;
1031             DEBUG("dce_alloc IVC1VDEC_Status successful vc1_status=%p", vc1_status);
1032             err = VIDDEC3_control(codec, XDM_SETPARAMS, (VIDDEC3_DynamicParams *) vc1_dynParams, (VIDDEC3_Status *) vc1_status);
1033             break;
1035         case DCE_TEST_MJPEG :
1037             DEBUG("dce_alloc IJPEGVDEC_DynamicParams successful dynParams=%p", dynParams);
1038             mjpeg_dynParams = (IJPEGVDEC_DynamicParams *) dynParams;
1039             mjpeg_dynParams->decodeThumbnail = 0;
1040             mjpeg_dynParams->thumbnailMode = IJPEGVDEC_THUMBNAIL_DOWNSAMPLE;
1041             mjpeg_dynParams->downsamplingFactor = IJPEGVDEC_NODOWNSAMPLE;
1042             mjpeg_dynParams->streamingCompliant = 1;
1044             DEBUG("dce_alloc IJPEGVDEC_DynamicParams successful mjpeg_dynParams=%p", mjpeg_dynParams);
1046             status = dce_alloc(sizeof(IVC1VDEC_Status));
1047             status->size = sizeof(IJPEGVDEC_Status);
1048             DEBUG("dce_alloc IVC1VDEC_Status successful status=%p", status);
1050             mjpeg_status = (IJPEGVDEC_Status *) status;
1051             DEBUG("dce_alloc IJPEGVDEC_Status successful mjpeg_status=%p", mjpeg_status);
1052             err = VIDDEC3_control(codec, XDM_SETPARAMS, (VIDDEC3_DynamicParams *) mjpeg_dynParams, (VIDDEC3_Status *) mjpeg_status);
1053             break;
1054 #ifdef ENABLE_MPEG2
1055         case DCE_TEST_MPEG2 :
1057             DEBUG("dce_alloc IMPEG2VDEC_DynamicParams successful dynParams=%p", dynParams);
1058             mpeg2_dynParams = (IMPEG2VDEC_DynamicParams *) dynParams;
1059             //MPEG2 buffer width should be 128 byte aligned for non TILER (atleast)
1060             //If displayWidth=0 then MPEG2 codec does not have a way to calculate
1061             //the stride as compared to other codecs which can calculate it from
1062             //buffer size and image height.stride=buffersize/(height*1.5)
1063             mpeg2_dynParams->viddecDynamicParams.displayWidth = padded_width;
1065             DEBUG("dce_alloc IMPEG2VDEC_DynamicParams successful mpeg2_dynParams=%p", mpeg2_dynParams);
1067             status = dce_alloc(sizeof(IMPEG2VDEC_Status));
1068             status->size = sizeof(IMPEG2VDEC_Status);
1069             DEBUG("dce_alloc IMPEG2VDEC_Status successful status=%p", status);
1071             mpeg2_status = (IMPEG2VDEC_Status *) status;
1072             DEBUG("dce_alloc IMPEG2VDEC_Status successful mpeg2_status=%p", mpeg2_status);
1073             err = VIDDEC3_control(codec, XDM_SETPARAMS, (VIDDEC3_DynamicParams *) mpeg2_dynParams, (VIDDEC3_Status *) mpeg2_status);
1074             break;
1075 #endif
1076         default :
1077             DEBUG("Not implemented or supported codec_switch %d", codec_switch);
1078     }
1080     if( err ) {
1081         ERROR("fail: %d", err);
1082         goto shutdown;
1083     }
1085     DEBUG("VIDDEC3_control XDM_SETPARAMS successful");
1087     DEBUG("input buffer configuration width %d height %d", width, height);
1088     inBufs = dce_alloc(sizeof(XDM2_BufDesc));
1089     inBufs->numBufs = 1;
1090     input = tiler_alloc(width * height, 0);
1091     inBufs->descs[0].buf = (XDAS_Int8 *)input;
1092     inBufs->descs[0].memType = XDM_MEMTYPE_RAW;
1094     DEBUG("inBufs->descs[0].buf %p input %p", inBufs->descs[0].buf, input);
1096     outBufs = dce_alloc(sizeof(XDM2_BufDesc));
1098     DEBUG("output buffer configuration num_buffers %d padded_width %d padded_height %d", num_buffers, padded_width, padded_height);
1100 #ifdef PROFILE_TIME
1101     uint64_t    alloc_time_start = mark_microsecond(NULL);
1102 #endif
1104     if( !(strcmp(tilerbuffer, "tiler"))) {
1105         DEBUG("Output allocate through tiler");
1106         tiler = 1;
1107         err = output_allocate(outBufs, num_buffers,
1108                               padded_width, padded_height, stride);
1109     } else {
1110         DEBUG("Output allocate through non-tiler");
1111         tiler = 0;
1112         err = output_allocate_nonTiler(outBufs, num_buffers,
1113                                        padded_width, padded_height, stride);
1114     }
1116 #ifdef PROFILE_TIME
1117     output_alloc_time = mark_microsecond(&alloc_time_start);
1118 #endif
1120     if( err ) {
1121         ERROR("fail: %d", err);
1122         goto shutdown;
1123     }
1125     inArgs = dce_alloc(sizeof(IVIDDEC3_InArgs));
1126     inArgs->size = sizeof(IVIDDEC3_InArgs);
1128     outArgs = dce_alloc(sizeof(IVIDDEC3_OutArgs));
1129     outArgs->size = sizeof(IVIDDEC3_OutArgs);
1131 #ifdef PROFILE_TIME
1132     total_init_time = (uint64_t)mark_microsecond(&init_start_time);
1133     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);
1134 #endif
1136     while( inBufs->numBufs && outBufs->numBufs ) {
1137         OutputBuffer   *buf;
1138         int             n, i;
1140         if( !outBufsInUse ) {
1141             buf = output_get();
1142             if( !buf ) {
1143                 ERROR("fail: out of buffers");
1144                 goto shutdown;
1145             }
1146         } else {
1147             buf = 0;
1148         }
1150         n = read_input(in_pattern, in_cnt, input);
1151         if( n && (n != -1)) {
1152             eof = 0;
1153             inBufs->numBufs = 1;
1154             inBufs->descs[0].buf = (XDAS_Int8 *)input;
1155             inBufs->descs[0].bufSize.bytes = n;
1156             inArgs->numBytes = n;
1157             DEBUG("push: %d (%d bytes) (%p)", in_cnt, n, buf);
1158             in_cnt++;
1160             /*
1161              * Input buffer has data to be decoded.
1162              */
1163             inArgs->inputID = (XDAS_Int32)buf;
1164             if( !outBufsInUse ) {
1165                 outBufs->numBufs = 2;
1166                 outBufs->descs[0].buf = (XDAS_Int8 *)buf->y;
1167                 outBufs->descs[1].buf = (XDAS_Int8 *)buf->uv;
1168             }
1169         } else if( n == -1 ) {
1171             // Set EOF as 1 to ensure flush completes
1172             eof = 1;
1173             in_cnt++;
1175             switch( codec_switch ) {
1176                 case DCE_TEST_H264 :
1177                     DEBUG("Calling VIDDEC3_control XDM_FLUSH h264_dynParams %p h264_status %p", h264_dynParams, h264_status);
1178                     err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) h264_dynParams, (VIDDEC3_Status *) h264_status);
1179                     break;
1180                 case DCE_TEST_MPEG4 :
1181                     DEBUG("Calling VIDDEC3_control XDM_FLUSH mpeg4_dynParams %p mpeg4_status %p", mpeg4_dynParams, mpeg4_status);
1182                     err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) mpeg4_dynParams, (VIDDEC3_Status *) mpeg4_status);
1183                     break;
1184                 case DCE_TEST_VC1SMP :
1185                 case DCE_TEST_VC1AP :
1186                     DEBUG("Calling VIDDEC3_control XDM_FLUSH vc1_dynParams %p vc1_status %p", vc1_dynParams, vc1_status);
1187                     err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) vc1_dynParams, (VIDDEC3_Status *) vc1_status);
1188                     break;
1189                 case DCE_TEST_MJPEG :
1190                     DEBUG("Calling VIDDEC3_control XDM_FLUSH mjpeg_dynParams %p mjpeg_status %p", mjpeg_dynParams, mjpeg_status);
1191                     err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) mjpeg_dynParams, (VIDDEC3_Status *) mjpeg_status);
1192                     break;
1193 #ifdef ENABLE_MPEG2
1194                 case DCE_TEST_MPEG2 :
1195                     DEBUG("Calling VIDDEC3_control XDM_FLUSH mpeg2_dynParams %p mpeg2_status %p", mpeg2_dynParams, mpeg2_status);
1196                     err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) mpeg2_dynParams, (VIDDEC3_Status *) mpeg2_status);
1197                     break;
1198 #endif
1199             }
1201             /* We have sent the XDM_FLUSH, call VIDDEC3_process until we get
1202              * an error of XDM_EFAIL which tells us there are no more buffers
1203              * at codec level.
1204              */
1206             inArgs->inputID = 0;
1207             inArgs->numBytes = 0;
1208             inBufs->descs[0].buf = NULL;
1209             inBufs->descs[0].bufSize.bytes = 0;
1210             outBufs->numBufs = 0;
1211             outBufs->descs[0].buf = NULL;
1212             outBufs->descs[1].buf = NULL;
1213             if( buf ) {
1214                 output_release(buf);
1215             }
1216             outBufsInUse = 0;
1219         } else {
1220             /* end of input.. */
1221             inBufs->numBufs = 0;
1222             eof = 1;
1224             switch( codec_switch ) {
1225                 case DCE_TEST_H264 :
1226                     DEBUG("Calling VIDDEC3_control XDM_FLUSH h264_dynParams %p h264_status %p", h264_dynParams, h264_status);
1227                     err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) h264_dynParams, (VIDDEC3_Status *) h264_status);
1228                     break;
1229                 case DCE_TEST_MPEG4 :
1230                     DEBUG("Calling VIDDEC3_control XDM_FLUSH mpeg4_dynParams %p mpeg4_status %p", mpeg4_dynParams, mpeg4_status);
1231                     err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) mpeg4_dynParams, (VIDDEC3_Status *) mpeg4_status);
1232                     break;
1233                 case DCE_TEST_VC1SMP :
1234                 case DCE_TEST_VC1AP :
1235                     DEBUG("Calling VIDDEC3_control XDM_FLUSH vc1_dynParams %p vc1_status %p", vc1_dynParams, vc1_status);
1236                     err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) vc1_dynParams, (VIDDEC3_Status *) vc1_status);
1237                     break;
1238                 case DCE_TEST_MJPEG :
1239                     DEBUG("Calling VIDDEC3_control XDM_FLUSH mjpeg_dynParams %p mjpeg_status %p", mjpeg_dynParams, mjpeg_status);
1240                     err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) mjpeg_dynParams, (VIDDEC3_Status *) mjpeg_status);
1241                     break;
1242 #ifdef ENABLE_MPEG2
1243                 case DCE_TEST_MPEG2 :
1244                     DEBUG("Calling VIDDEC3_control XDM_FLUSH mpeg2_dynParams %p mpeg2_status %p", mpeg2_dynParams, mpeg2_status);
1245                     err = VIDDEC3_control(codec, XDM_FLUSH, (VIDDEC3_DynamicParams *) mpeg2_dynParams, (VIDDEC3_Status *) mpeg2_status);
1246                     break;
1247 #endif
1248             }
1250             /* We have sent the XDM_FLUSH, call VIDDEC3_process until we get
1251              * an error of XDM_EFAIL which tells us there are no more buffers
1252              * at codec level.
1253              */
1255             inArgs->inputID = 0;
1256             inArgs->numBytes = 0;
1257             inBufs->numBufs = 0;
1258             inBufs->descs[0].buf = NULL;
1259             inBufs->descs[0].bufSize.bytes = 0;
1260             outBufs->numBufs = 0;
1261             outBufs->descs[0].buf = NULL;
1262             outBufs->descs[1].buf = NULL;
1263             if( buf ) {
1264                 output_release(buf);
1265             }
1266         }
1268 #ifdef DUMPINPUTDATA
1269         DEBUG("input data dump inArgs->numBytes[%d] inputDump[%p]", inArgs->numBytes, inputDump);
1271         //Dump the file
1272         if( inputDump == NULL ) {
1273             inputDump = fopen("/tmp/inputdump.h264", "ab");
1274             DEBUG("input data dump file open %p errno %d", inputDump, errno);
1275             if( inputDump == NULL ) {
1276                 DEBUG("Opening input Dump /tmp/inputdump.h264 file FAILED");
1277             }
1278         }
1279         DEBUG("input data dump file open %p Successful", inputDump);
1281         fwrite(input, sizeof(char), inArgs->numBytes, inputDump);
1282         DEBUG("Dumping input file with size = %d ", inArgs->numBytes);
1283         fflush(inputDump);
1284         fclose(inputDump);
1285         inputDump = NULL;
1286     #endif
1288         int    iters = 0;
1290         do {
1291             DEBUG("Calling VIDDEC3_process inArgs->inputID=%x inBufs->descs[0].buf %p inBufs->descs.bufSize %d input %p",
1292                   inArgs->inputID, inBufs->descs[0].buf, (int) inBufs->descs[0].bufSize.bytes, input);
1293 #ifdef PROFILE_TIME
1294             codec_process_time = mark_microsecond(NULL);
1295 #endif
1296             err = VIDDEC3_process(codec, inBufs, outBufs, inArgs, outArgs);
1297 #ifdef PROFILE_TIME
1298             INFO("processed returned in: %llu us", (uint64_t) mark_microsecond(&codec_process_time));
1299 #endif
1300             if( err ) {
1301                 if( XDM_ISFATALERROR(outArgs->extendedError)) {
1302                     ERROR("process returned error: %d\n", err);
1303                     ERROR("extendedError: %08x", outArgs->extendedError);
1304                     goto shutdown;
1305                 } else if( eof ) {
1306                     /*
1307                      * Flush has been ordered, processing the returned output from codec.
1308                      * For H.264, bit 18 - IH264VDEC_ERR_STREAM_END indicates flush is completed.
1309                      * For MPEG4, bit 24 - IMPEG4VDEC_ERR_STREAM_END indicates flush is completed.
1310                      * Only return XDM_EFAIL, when those bit are set.
1311                      */
1312                     ERROR("Codec_process returned err=%d, extendedError=%08x", err, outArgs->extendedError);
1313                     err = XDM_EFAIL;
1315                     if((!(((outArgs->extendedError) >> 24) & 0x1)) &&
1316                        ((ivahd_decode_type == 2 /*IVAHD_MP4V_DECODE*/) ||
1317                         (ivahd_decode_type == 3 /*IVAHD_S263_DECODE*/))) {
1318                         err = XDM_EOK;
1319                     }
1321                     if((!(((outArgs->extendedError) >> 18) & 0x1)) &&
1322                        ((ivahd_decode_type == 1 /*IVAHD_H264_DECODE*/) ||
1323                         (ivahd_decode_type == 0 /*IVAHD_AVC1_DECODE*/))) {
1324                         err = XDM_EOK;
1325                     }
1327                     if( err == XDM_EFAIL ) {
1328                         DEBUG("-------------------- Flush completed------------------------");
1329                     }
1330                 } else {
1331                     DEBUG("Non-fatal err=%d, extendedError=%08x", err, outArgs->extendedError);
1332                     err = XDM_EOK;
1333                 }
1334             }
1336             /*
1337              * Handling of output data from codec
1338              */
1339             if( tiler ) {
1340                 for( i = 0; outArgs->outputID[i]; i++ ) {
1341                     /* calculate offset to region of interest */
1342                     XDM_Rect   *r = &(outArgs->displayBufs.bufDesc[0].activeFrameRegion);
1344                     int    yoff  = (r->topLeft.y * stride) + r->topLeft.x;
1345                     int    uvoff = (r->topLeft.y * stride / 2) + (stride * padded_height) + r->topLeft.x;
1347                     /* get the output buffer and write it to file */
1348                     buf = (OutputBuffer *)outArgs->outputID[i];
1349                     DEBUG("pop: %d (%p)", out_cnt, buf);
1351                     if( out_cnt < 30 ) {  // write first 30 frames to output file out_cnt < 300
1352                         write_output(out_pattern, out_cnt++, buf->buf + yoff,
1353                                      buf->buf + uvoff, stride);
1354                     } else {
1355                         out_cnt++;
1356                     }
1357                 }
1358             } else {
1359                 for( i = 0; outArgs->outputID[i]; i++ ) {
1360                     /* calculate offset to region of interest */
1361                     XDM_Rect   *r = &(outArgs->displayBufs.bufDesc[0].activeFrameRegion);
1363                     int    yoff  = (r->topLeft.y * padded_width) + r->topLeft.x;
1364                     int    uvoff = (r->topLeft.y * padded_width / 2) + (padded_height * padded_width) + r->topLeft.x;
1366                     /* get the output buffer and write it to file */
1367                     buf = (OutputBuffer *)outArgs->outputID[i];
1368                     DEBUG("pop: %d (%p)", out_cnt, buf);
1370                     if( out_cnt < 300 ) {  // write first 300 frames to output file
1371                         write_output(out_pattern, out_cnt++, buf->buf + yoff,
1372                                      buf->buf + uvoff, padded_width);
1373                     } else {
1374                         out_cnt++;
1375                     }
1376                 }
1377             }
1379             for( i = 0; outArgs->freeBufID[i]; i++ ) {
1380                 DEBUG("freeBufID[%d] = %d", i, outArgs->freeBufID[i]);
1381                 buf = (OutputBuffer *)outArgs->freeBufID[i];
1382                 output_release(buf);
1383             }
1385             if( outArgs->outBufsInUseFlag ) {
1386                 outBufsInUse = TRUE;
1387                 DEBUG("outBufsInUseFlag is SET. Not sending a new output buffer to codec on the next Codec_process ");
1388             } else {
1389                 outBufsInUse = FALSE;
1390             }
1392             ++iters; // Guard for infinite VIDDEC3_PROCESS loop when codec never return XDM_EFAIL
1393         } while( eof && (err != XDM_EFAIL) && (iters < 100));  // Multiple VIDDEC3_process when eof until err == XDM_EFAIL
1395     }
1397 shutdown:
1399     printf("\nDeleting codec...\n");
1400     VIDDEC3_delete(codec);
1402 out:
1403     if( engine ) {
1404         Engine_close(engine);
1405     }
1406     if( params ) {
1407         dce_free(params);
1408     }
1409     if( dynParams ) {
1410         dce_free(dynParams);
1411     }
1412     if( status ) {
1413         dce_free(status);
1414     }
1415     if( inBufs ) {
1416         dce_free(inBufs);
1417     }
1418     if( outBufs ) {
1419         dce_free(outBufs);
1420     }
1421     if( inArgs ) {
1422         dce_free(inArgs);
1423     }
1424     if( outArgs ) {
1425         dce_free(outArgs);
1426     }
1427     if( input ) {
1428         MemMgr_Free(input);
1429     }
1431     output_free();
1433     printf("DCE test completed...\n");
1435     return (0);