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>
  44
  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"
  59
  60 #define OMAP5
  61
  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))
  72
  73 /* align x to next highest multiple of 2^n */
  74 #define ALIGN2(x, n)   (((x) + ((1 << (n)) - 1)) & ~((1 << (n)) - 1))
  75
  76 // Profile the init and decode calls
  77 //#define PROFILE_TIME
  78
  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 };
  90
  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  */
  95
  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;
 106
 107 IH264VDEC_Params          *h264_params    = NULL;
 108 IH264VDEC_DynamicParams   *h264_dynParams = NULL;
 109 IH264VDEC_Status          *h264_status    = NULL;
 110
 111 IMPEG4VDEC_Params          *mpeg4_params       = NULL;
 112 IMPEG4VDEC_DynamicParams   *mpeg4_dynParams    = NULL;
 113 IMPEG4VDEC_Status          *mpeg4_status       = NULL;
 114
 115 IVC1VDEC_Params          *vc1_params     = NULL;
 116 IVC1VDEC_DynamicParams   *vc1_dynParams  = NULL;
 117 IVC1VDEC_Status          *vc1_status     = NULL;
 118
 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;
 129
 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
 138
 139 static void *tiler_alloc(int width, int height)
 140 {
 141     int              dimensions;
 142     void            *bufPtr = NULL;
 143     MemAllocBlock    block;
 144     MemAllocBlock    blocks[2];
 145
 146     memset(&block, 0, sizeof(MemAllocBlock));
 147     memset(blocks, 0, sizeof(MemAllocBlock) * 2);
 148
 149     if( !height ) {
 150         DEBUG("tiler alloc 1D allocation width=%d", width);
 151         /* 1d allocation: */
 152         dimensions = 1;
 153
 154         block.pixelFormat = PIXEL_FMT_PAGE;
 155         block.dim.len = width;
 156         block.stride = 0;
 157
 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;
 167
 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;
 172
 173         bufPtr = MemMgr_Alloc(blocks, dimensions);
 174     }
 175     DEBUG("tiler alloc return bufPtr %p", bufPtr);
 176
 177     return (bufPtr);
 178 }
 179
 180 /* ************************************************************************* */
 181 /* utilities to allocate/manage 2d output buffers */
 182
 183 typedef struct OutputBuffer OutputBuffer;
 184
 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 };
 193
 194 static XDAS_Int16
 195 get_mem_type (uint32_t paddr)
 196 {
 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);
 210 }
 211
 212 /* list of free buffers, not locked by codec! */
 213 static OutputBuffer   *head = NULL;
 214
 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
 221
 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
 227
 228 static Int
 229 SysLinkMemUtils_translateAddr (UInt32 physAddr)
 230 {
 231     Int    ret = 0;
 232
 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     }
 238
 239     return (ret);
 240 }
 241
 242 #endif
 243
 244 int output_allocate(XDM2_BufDesc *outBufs, int cnt,
 245                     int width, int height, int stride)
 246 {
 247     int    tw, th;
 248
 249     outBufs->numBufs = 2;
 250
 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     }
 271
 272     while( cnt ) {
 273         OutputBuffer   *buf = calloc(sizeof(OutputBuffer), 1);
 274
 275         DEBUG(" ----------------- create TILER buf 0x%x --------------------", (unsigned int)buf);
 276
 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));
 281
 282             DEBUG("cnt=%d buf=%p, y=%08x, uv=%08x", cnt, buf, buf->y, buf->uv);
 283
 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     }
 294
 295     return (0);
 296 }
 297
 298 int output_allocate_nonTiler(XDM2_BufDesc *outBufs, int cnt,
 299                              int width, int height, int stride)
 300 {
 301     int           tw;
 302     XDAS_Int16    y_type, uv_type;
 303
 304     outBufs->numBufs = 2;
 305
 306     while( cnt ) {
 307         OutputBuffer   *buf = calloc(sizeof(OutputBuffer), 1);
 308
 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;
 313
 314         // Allocation through mmap
 315         uint64_t   *vaddr;
 316         int32_t     ret, len = 0;
 317         int64_t     paddr = 0;
 318         uint32_t    uv_addr;
 319
 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;
 330
 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         }
 346
 347         buf->buf = (char *) vaddr;
 348         buf->y = (uint32_t)vaddr;
 349         uv_addr = (uint32_t) vaddr + (width * height);
 350         buf->uv = uv_addr;
 351
 352         DEBUG("cnt=%d nonTILER buf=%p, y=%08x, uv=%08x paddr=%08x", cnt, buf, buf->y, buf->uv, (unsigned int) paddr);
 353
 354         y_type = get_mem_type(buf->y);
 355         uv_type = get_mem_type(buf->uv);
 356
 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         }
 371
 372         buf->next = head;
 373         buf->tiler = FALSE;
 374         buf->len = tw;
 375         head = buf;
 376
 377         cnt--;
 378     }
 379
 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     }
 386
 387     return (0);
 388 }
 389
 390 void output_free(void)
 391 {
 392     OutputBuffer   *buf = head;
 393
 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     }
 404 }
 405
 406 OutputBuffer *output_get(void)
 407 {
 408     OutputBuffer   *buf = head;
 409
 410     if( buf ) {
 411         head = buf->next;
 412     }
 413     DEBUG("output_get: %p", buf);
 414     return (buf);
 415 }
 416
 417 void output_release(OutputBuffer *buf)
 418 {
 419     DEBUG("output_release: %p", buf);
 420     buf->next = head;
 421     head = buf;
 422 }
 423
 424 /* ************************************************************************* */
 425
 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)
 428 {
 429     static int     len = 0;
 430     static char   *path = NULL;
 431
 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     }
 439
 440     snprintf(path, len - 1, pattern, cnt);
 441
 442     return (path);
 443 }
 444
 445 /* helper to read one frame of input */
 446 int read_input(const char *pattern, int cnt, char *input)
 447 {
 448     int           sz = 0, n = 0;
 449     const char   *path = get_path(pattern, cnt);
 450     int           fd = open(path, O_RDONLY);
 451
 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     }
 458
 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     }
 470
 471     close(fd);
 472
 473     DEBUG("sz=%d", sz);
 474     return (sz);
 475 }
 476
 477 /* helper to write one frame of output */
 478 int write_output(const char *pattern, int cnt, char *y, char *uv, int stride)
 479 {
 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);
 483
 484     if( fd < 0 ) {
 485         ERROR("could open output file: %s (%d)", path, errno);
 486         return (0);
 487     }
 488
 489     for( i = 0; i < height; i++ ) {
 490         char   *p = y;
 491         int     len = width;
 492
 493         while( len && ((n = write(fd, p, len)) > 0)) {
 494             sz  += n;
 495             p   += n;
 496             len -= n;
 497         }
 498
 499         if( n < 0 ) {
 500             ERROR("couldn't write to output file: (%d)", errno);
 501             break;
 502         }
 503         y += stride;
 504     }
 505
 506     if( n >= 0 ) {
 507         for( i = 0; i < height / 2; i++ ) {
 508             char   *p = uv;
 509             int     len = width;
 510
 511             while( len && ((n = write(fd, p, len)) > 0)) {
 512                 sz  += n;
 513                 p   += n;
 514                 len -= n;
 515             }
 516
 517             if( n < 0 ) {
 518                 ERROR("couldn't write to output file: (%d)", errno);
 519                 break;
 520             }
 521             uv += stride;
 522         }
 523     }
 524
 525     close(fd);
 526
 527     return (sz);
 528 }
 529
 530 #ifdef PROFILE_TIME
 531 /* for timing in microsecond */
 532 uint64_t mark_microsecond(uint64_t *last)
 533 {
 534 #if 0
 535     struct timespec    time;
 536     uint64_t           t1 = 0;
 537
 538     clock_gettime(CLOCK_REALTIME, &time);
 539     t1 = timespec2nsec(&time);
 540     t1 = t1 / 1000;
 541 #else
 542     uint64_t    t1 = 0;
 543
 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);
 552 }
 553
 554 #endif
 555 //#define DUMPINPUTDATA
 556
 557 #ifdef DUMPINPUTDATA
 558 FILE   *inputDump;
 559 #endif
 560
 561 #define VERSION_SIZE 128
 562 static char    version_buffer[VERSION_SIZE];
 563
 564 /* decoder body */
 565 int main(int argc, char * *argv)
 566 {
 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;
 583
 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
 590
 591 #if 0
 592     int    loop = 0;
 593
 594     while( loop == 0 ) {
 595         loop = 0;
 596     }
 597
 598 #endif
 599
 600     if((argc >= 2) && !strcmp(argv[1], "-1")) {
 601         oned = TRUE;
 602         argc--;
 603         argv++;
 604     } else {
 605         oned = FALSE;
 606     }
 607
 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     }
 619
 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]);
 628
 629     printf("Selected codec: %s\n", vid_codec);
 630     printf("Selected buffer: %s\n", tilerbuffer);
 631
 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     };
 640
 641     if((!(strcmp(vid_codec, "h264")))) {
 642         ivahd_decode_type = IVAHD_H264_DECODE;
 643         codec_switch = DCE_TEST_H264;
 644
 645     } else if((!(strcmp(vid_codec, "mpeg4")))) {
 646         ivahd_decode_type = IVAHD_MP4V_DECODE;
 647         codec_switch = DCE_TEST_MPEG4;
 648
 649     } else if((!(strcmp(vid_codec, "vc1smp")))) {
 650         ivahd_decode_type = IVAHD_VC1SMP_DECODE;
 651         codec_switch = DCE_TEST_VC1SMP;
 652         vc1_flush = 1;
 653
 654     } else if((!(strcmp(vid_codec, "vc1ap")))) {
 655         ivahd_decode_type = IVAHD_VC1AP_DECODE;
 656         codec_switch = DCE_TEST_VC1AP;
 657         vc1_flush = 1;
 658
 659     } else if((!(strcmp(vid_codec, "mjpeg")))) {
 660         ivahd_decode_type = IVAHD_JPEGV_DECODE;
 661         codec_switch = DCE_TEST_MJPEG;
 662
 663     } else if((!(strcmp(vid_codec, "mpeg2")))) {
 664         ivahd_decode_type = IVAHD_MP2V_DECODE;
 665         codec_switch = DCE_TEST_MPEG2;
 666
 667     } else {
 668         printf("No valid codec entry. Please use: h264, mpeg4, vc1ap, vc1smp, mjpeg or mpeg2\n");
 669         return (1);
 670     }
 671
 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     }
 678
 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]);
 683
 684         if( frameCount > 64000 ) {
 685             DEBUG("Num Frames %d exceeded MAX limit %d \n", frameCount, 64000);
 686             goto out;
 687         }
 688         frameCount++;
 689     }
 690
 691     DEBUG("Num Frames is %d width=%d, height=%d", frameCount, width, height);
 692
 693     /* calculate output buffer parameters: */
 694     width  = ALIGN2(width, 4);         /* round up to MB */
 695     height = ALIGN2(height, 4);        /* round up to MB */
 696
 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     }
 728
 729     if( oned ) {
 730         stride = padded_width;
 731     } else {
 732         stride = 4096;
 733     }
 734
 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);
 741
 742     if( !engine ) {
 743         ERROR("fail");
 744         goto out;
 745     }
 746
 747     DEBUG("Engine_open successful engine=%p", engine);
 748
 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     }
 814
 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;
 829
 830     DEBUG("dce_alloc VIDDEC3_Params successful params=%p", params);
 831
 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;
 841
 842             DEBUG("dce_alloc VIDDEC3_Params successful h264_params=%p", h264_params);
 843
 844             err = msync((Ptr)h264_params, sizeof(IH264VDEC_Params), MS_CACHE_ONLY | MS_SYNC);
 845
 846             codec = VIDDEC3_create(engine, "ivahd_h264dec", (VIDDEC3_Params *)h264_params);
 847             break;
 848
 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;
 857
 858             DEBUG("dce_alloc VIDDEC3_Params successful mpeg4_params=%p", mpeg4_params);
 859
 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;
 867
 868         case DCE_TEST_VC1SMP :
 869         case DCE_TEST_VC1AP :
 870             vc1_params = (IVC1VDEC_Params *) params;
 871
 872             DEBUG("dce_alloc VIDDEC3_Params successful vc1_params=%p", vc1_params);
 873
 874             err = msync((Ptr)vc1_params, sizeof(IVC1VDEC_Params), MS_CACHE_ONLY | MS_SYNC);
 875
 876             codec = VIDDEC3_create(engine, "ivahd_vc1vdec", (VIDDEC3_Params *)vc1_params);
 877             break;
 878
 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;
 887
 888             DEBUG("dce_alloc VIDDEC3_Params successful mjpeg_params=%p", mjpeg_params);
 889
 890             err = msync((Ptr)mjpeg_params, sizeof(IJPEGVDEC_Params), MS_CACHE_ONLY | MS_SYNC);
 891
 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;
 901
 902             DEBUG("dce_alloc VIDDEC3_Params successful mpeg2_params=%p", mpeg2_params);
 903
 904             err = msync((Ptr)mpeg2_params, sizeof(IMPEG2VDEC_Params), MS_CACHE_ONLY | MS_SYNC);
 905
 906             codec = VIDDEC3_create(engine, "ivahd_mpeg2vdec", (VIDDEC3_Params *)mpeg2_params);
 907             break;
 908 #endif
 909     }
 910
 911     if( !codec ) {
 912         ERROR("fail");
 913         goto out;
 914     }
 915
 916     DEBUG("VIDDEC3_create successful codec=%p", codec);
 917
 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     }
 947
 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;
 953
 954
 955     //Testing XDM_GETVERSION
 956     // NOT WORKING
 957 #if 0
 958
 959     switch( codec_switch ) {
 960         case DCE_TEST_H264 :
 961
 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);
 965
 966             status = dce_alloc(sizeof(IH264VDEC_Status));
 967             status->size = sizeof(IH264VDEC_Status);
 968             DEBUG("dce_alloc IH264VDEC_Status successful status=%p", status);
 969
 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);
 973
 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);
 976
 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     }
 982
 983     if( status ) {
 984         dce_free(status);
 985     }
 986 #endif
 987
 988     switch( codec_switch ) {
 989         case DCE_TEST_H264 :
 990
 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);
 994
 995             status = dce_alloc(sizeof(IH264VDEC_Status));
 996             status->size = sizeof(IH264VDEC_Status);
 997             DEBUG("dce_alloc IH264VDEC_Status successful status=%p", status);
 998
 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;
1003
1004         case DCE_TEST_MPEG4 :
1005
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);
1009
1010             status = dce_alloc(sizeof(IMPEG4VDEC_Status));
1011             status->size = sizeof(IMPEG4VDEC_Status);
1012             DEBUG("dce_alloc IMPEG4VDEC_Status successful status=%p", status);
1013
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;
1018
1019         case DCE_TEST_VC1SMP :
1020         case DCE_TEST_VC1AP :
1021
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);
1025
1026             status = dce_alloc(sizeof(IVC1VDEC_Status));
1027             status->size = sizeof(IVC1VDEC_Status);
1028             DEBUG("dce_alloc IVC1VDEC_Status successful status=%p", status);
1029
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;
1034
1035         case DCE_TEST_MJPEG :
1036
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;
1043
1044             DEBUG("dce_alloc IJPEGVDEC_DynamicParams successful mjpeg_dynParams=%p", mjpeg_dynParams);
1045
1046             status = dce_alloc(sizeof(IVC1VDEC_Status));
1047             status->size = sizeof(IJPEGVDEC_Status);
1048             DEBUG("dce_alloc IVC1VDEC_Status successful status=%p", status);
1049
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 :
1056
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;
1064
1065             DEBUG("dce_alloc IMPEG2VDEC_DynamicParams successful mpeg2_dynParams=%p", mpeg2_dynParams);
1066
1067             status = dce_alloc(sizeof(IMPEG2VDEC_Status));
1068             status->size = sizeof(IMPEG2VDEC_Status);
1069             DEBUG("dce_alloc IMPEG2VDEC_Status successful status=%p", status);
1070
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     }
1079
1080     if( err ) {
1081         ERROR("fail: %d", err);
1082         goto shutdown;
1083     }
1084
1085     DEBUG("VIDDEC3_control XDM_SETPARAMS successful");
1086
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;
1093
1094     DEBUG("inBufs->descs[0].buf %p input %p", inBufs->descs[0].buf, input);
1095
1096     outBufs = dce_alloc(sizeof(XDM2_BufDesc));
1097
1098     DEBUG("output buffer configuration num_buffers %d padded_width %d padded_height %d", num_buffers, padded_width, padded_height);
1099
1100 #ifdef PROFILE_TIME
1101     uint64_t    alloc_time_start = mark_microsecond(NULL);
1102 #endif
1103
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     }
1115
1116 #ifdef PROFILE_TIME
1117     output_alloc_time = mark_microsecond(&alloc_time_start);
1118 #endif
1119
1120     if( err ) {
1121         ERROR("fail: %d", err);
1122         goto shutdown;
1123     }
1124
1125     inArgs = dce_alloc(sizeof(IVIDDEC3_InArgs));
1126     inArgs->size = sizeof(IVIDDEC3_InArgs);
1127
1128     outArgs = dce_alloc(sizeof(IVIDDEC3_OutArgs));
1129     outArgs->size = sizeof(IVIDDEC3_OutArgs);
1130
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
1135
1136     while( inBufs->numBufs && outBufs->numBufs ) {
1137         OutputBuffer   *buf;
1138         int             n, i;
1139
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         }
1149
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++;
1159
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 ) {
1170
1171             // Set EOF as 1 to ensure flush completes
1172             eof = 1;
1173             in_cnt++;
1174
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             }
1200
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              */
1205
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;
1217
1218
1219         } else {
1220             /* end of input.. */
1221             inBufs->numBufs = 0;
1222             eof = 1;
1223
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             }
1249
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              */
1254
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         }
1267
1268 #ifdef DUMPINPUTDATA
1269         DEBUG("input data dump inArgs->numBytes[%d] inputDump[%p]", inArgs->numBytes, inputDump);
1270
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);
1280
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
1287
1288         int    iters = 0;
1289
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;
1314
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                     }
1320
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                     }
1326
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             }
1335
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);
1343
1344                     int    yoff  = (r->topLeft.y * stride) + r->topLeft.x;
1345                     int    uvoff = (r->topLeft.y * stride / 2) + (stride * padded_height) + r->topLeft.x;
1346
1347                     /* get the output buffer and write it to file */
1348                     buf = (OutputBuffer *)outArgs->outputID[i];
1349                     DEBUG("pop: %d (%p)", out_cnt, buf);
1350
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);
1362
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;
1365
1366                     /* get the output buffer and write it to file */
1367                     buf = (OutputBuffer *)outArgs->outputID[i];
1368                     DEBUG("pop: %d (%p)", out_cnt, buf);
1369
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             }
1378
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             }
1384
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             }
1391
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
1394
1395     }
1396
1397 shutdown:
1398
1399     printf("\nDeleting codec...\n");
1400     VIDDEC3_delete(codec);
1401
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     }
1430
1431     output_free();
1432
1433     printf("DCE test completed...\n");
1434
1435     return (0);
1436 }
1437