OpenCores
URL https://opencores.org/ocsvn/mpeg2fpga/mpeg2fpga/trunk

Subversion Repositories mpeg2fpga

[/] [mpeg2fpga/] [trunk/] [tools/] [mpeg2dec/] [mpeg2dec.c] - Blame information for rev 2

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 2 kdv
 
2
/* mpeg2dec.c, main(), initialization, option processing                    */
3
 
4
/* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. */
5
 
6
/*
7
 * Disclaimer of Warranty
8
 *
9
 * These software programs are available to the user without any license fee or
10
 * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims
11
 * any and all warranties, whether express, implied, or statuary, including any
12
 * implied warranties or merchantability or of fitness for a particular
13
 * purpose.  In no event shall the copyright-holder be liable for any
14
 * incidental, punitive, or consequential damages of any kind whatsoever
15
 * arising from the use of these programs.
16
 *
17
 * This disclaimer of warranty extends to the user of these programs and user's
18
 * customers, employees, agents, transferees, successors, and assigns.
19
 *
20
 * The MPEG Software Simulation Group does not represent or warrant that the
21
 * programs furnished hereunder are free of infringement of any third-party
22
 * patents.
23
 *
24
 * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware,
25
 * are subject to royalty fees to patent holders.  Many of these patents are
26
 * general enough such that they are unavoidable regardless of implementation
27
 * design.
28
 *
29
 */
30
 
31
#include <stdio.h>
32
#include <stdlib.h>
33
#include <ctype.h>
34
#include <fcntl.h>
35
#ifdef PROFILE
36
#include <signal.h>
37
#endif
38
 
39
#define GLOBAL
40
#include "config.h"
41
#include "global.h"
42
 
43
/* private prototypes */
44
static int  video_sequence _ANSI_ARGS_((int *framenum));
45
static int Decode_Bitstream _ANSI_ARGS_((void));
46
static int  Headers _ANSI_ARGS_((void));
47
static void Initialize_Sequence _ANSI_ARGS_((void));
48
static void Initialize_Decoder _ANSI_ARGS_((void));
49
static void Deinitialize_Sequence _ANSI_ARGS_((void));
50
static void Process_Options _ANSI_ARGS_((int argc, char *argv[]));
51
 
52
 
53
#if OLD
54
static int  Get_Val _ANSI_ARGS_((char *argv[]));
55
#endif
56
 
57
/* #define DEBUG */
58
 
59
static void Clear_Options();
60
#ifdef DEBUG
61
static void Print_Options();
62
#endif
63
 
64
int main(argc,argv)
65
int argc;
66
char *argv[];
67
{
68
  int ret, code;
69
#ifdef PROFILE
70
  signal(SIGINT, exit);
71
#endif
72
 
73
  Clear_Options();
74
 
75
  /* decode command line arguments */
76
  Process_Options(argc,argv);
77
 
78
#ifdef DEBUG
79
  Print_Options();
80
#endif
81
 
82
  ld = &base; /* select base layer context */
83
 
84
  /* open MPEG base layer bitstream file(s) */
85
  /* NOTE: this is either a base layer stream or a spatial enhancement stream */
86
  if ((base.Infile=open(Main_Bitstream_Filename,O_RDONLY|O_BINARY))<0)
87
  {
88
    fprintf(stderr,"Base layer input file %s not found\n", Main_Bitstream_Filename);
89
    exit(1);
90
  }
91
 
92
 
93
  if(base.Infile != 0)
94
  {
95
    Initialize_Buffer();
96
 
97
    if(Show_Bits(8)==0x47)
98
    {
99
      sprintf(Error_Text,"Decoder currently does not parse transport streams\n");
100
      Error(Error_Text);
101
    }
102
 
103
    next_start_code();
104
    code = Show_Bits(32);
105
 
106
    switch(code)
107
    {
108
    case SEQUENCE_HEADER_CODE:
109
      break;
110
    case PACK_START_CODE:
111
    case VIDEO_ELEMENTARY_STREAM:
112
      System_Stream_Flag = 1;
113
      break;
114
    default:
115
      sprintf(Error_Text,"Unable to recognize stream type\n");
116
      Error(Error_Text);
117
      break;
118
    }
119
 
120
    lseek(base.Infile, 0l, 0);
121
    Initialize_Buffer();
122
  }
123
 
124
  if(base.Infile!=0)
125
  {
126
    lseek(base.Infile, 0l, 0);
127
  }
128
 
129
  Initialize_Buffer();
130
 
131
  if(Two_Streams)
132
  {
133
    ld = &enhan; /* select enhancement layer context */
134
 
135
    if ((enhan.Infile = open(Enhancement_Layer_Bitstream_Filename,O_RDONLY|O_BINARY))<0)
136
    {
137
      sprintf(Error_Text,"enhancment layer bitstream file %s not found\n",
138
        Enhancement_Layer_Bitstream_Filename);
139
 
140
      Error(Error_Text);
141
    }
142
 
143
    Initialize_Buffer();
144
    ld = &base;
145
  }
146
 
147
  Initialize_Decoder();
148
 
149
  ret = Decode_Bitstream();
150
 
151
  close(base.Infile);
152
 
153
  if (Two_Streams)
154
    close(enhan.Infile);
155
 
156
  return 0;
157
}
158
 
159
/* IMPLEMENTAION specific rouintes */
160
static void Initialize_Decoder()
161
{
162
  int i;
163
 
164
  /* Clip table */
165
  if (!(Clip=(unsigned char *)malloc(1024)))
166
    Error("Clip[] malloc failed\n");
167
 
168
  Clip += 384;
169
 
170
  for (i=-384; i<640; i++)
171
    Clip[i] = (i<0) ? 0 : ((i>255) ? 255 : i);
172
 
173
  /* IDCT */
174
  if (Reference_IDCT_Flag)
175
    Initialize_Reference_IDCT();
176
  else
177
    Initialize_Fast_IDCT();
178
 
179
}
180
 
181
/* mostly IMPLEMENTAION specific rouintes */
182
static void Initialize_Sequence()
183
{
184
  int cc, size;
185
  static int Table_6_20[3] = {6,8,12};
186
 
187
  /* check scalability mode of enhancement layer */
188
  if (Two_Streams && (enhan.scalable_mode!=SC_SNR) && (base.scalable_mode!=SC_DP))
189
    Error("unsupported scalability mode\n");
190
 
191
  /* force MPEG-1 parameters for proper decoder behavior */
192
  /* see ISO/IEC 13818-2 section D.9.14 */
193
  if (!base.MPEG2_Flag)
194
  {
195
    progressive_sequence = 1;
196
    progressive_frame = 1;
197
    picture_structure = FRAME_PICTURE;
198
    frame_pred_frame_dct = 1;
199
    chroma_format = CHROMA420;
200
    matrix_coefficients = 5;
201
  }
202
 
203
  /* round to nearest multiple of coded macroblocks */
204
  /* ISO/IEC 13818-2 section 6.3.3 sequence_header() */
205
  mb_width = (horizontal_size+15)/16;
206
  mb_height = (base.MPEG2_Flag && !progressive_sequence) ? 2*((vertical_size+31)/32)
207
                                        : (vertical_size+15)/16;
208
 
209
  Coded_Picture_Width = 16*mb_width;
210
  Coded_Picture_Height = 16*mb_height;
211
 
212
  /* ISO/IEC 13818-2 sections 6.1.1.8, 6.1.1.9, and 6.1.1.10 */
213
  Chroma_Width = (chroma_format==CHROMA444) ? Coded_Picture_Width
214
                                           : Coded_Picture_Width>>1;
215
  Chroma_Height = (chroma_format!=CHROMA420) ? Coded_Picture_Height
216
                                            : Coded_Picture_Height>>1;
217
 
218
  /* derived based on Table 6-20 in ISO/IEC 13818-2 section 6.3.17 */
219
  block_count = Table_6_20[chroma_format-1];
220
 
221
  for (cc=0; cc<3; cc++)
222
  {
223
    if (cc==0)
224
      size = Coded_Picture_Width*Coded_Picture_Height;
225
    else
226
      size = Chroma_Width*Chroma_Height;
227
 
228
    if (!(backward_reference_frame[cc] = (unsigned char *)malloc(size)))
229
      Error("backward_reference_frame[] malloc failed\n");
230
 
231
    if (!(forward_reference_frame[cc] = (unsigned char *)malloc(size)))
232
      Error("forward_reference_frame[] malloc failed\n");
233
 
234
    if (!(auxframe[cc] = (unsigned char *)malloc(size)))
235
      Error("auxframe[] malloc failed\n");
236
 
237
    if(Ersatz_Flag)
238
      if (!(substitute_frame[cc] = (unsigned char *)malloc(size)))
239
        Error("substitute_frame[] malloc failed\n");
240
 
241
 
242
    if (base.scalable_mode==SC_SPAT)
243
    {
244
      /* this assumes lower layer is 4:2:0 */
245
      if (!(llframe0[cc] = (unsigned char *)malloc((lower_layer_prediction_horizontal_size*lower_layer_prediction_vertical_size)/(cc?4:1))))
246
        Error("llframe0 malloc failed\n");
247
      if (!(llframe1[cc] = (unsigned char *)malloc((lower_layer_prediction_horizontal_size*lower_layer_prediction_vertical_size)/(cc?4:1))))
248
        Error("llframe1 malloc failed\n");
249
    }
250
  }
251
 
252
  /* SCALABILITY: Spatial */
253
  if (base.scalable_mode==SC_SPAT)
254
  {
255
    if (!(lltmp = (short *)malloc(lower_layer_prediction_horizontal_size*((lower_layer_prediction_vertical_size*vertical_subsampling_factor_n)/vertical_subsampling_factor_m)*sizeof(short))))
256
      Error("lltmp malloc failed\n");
257
  }
258
 
259
#ifdef DISPLAY
260
  if (Output_Type==T_X11)
261
    Initialize_Display_Process("");
262
#endif /* DISPLAY */
263
 
264
}
265
 
266
void Error(text)
267
char *text;
268
{
269
  fprintf(stderr,text);
270
  exit(1);
271
}
272
 
273
/* Trace_Flag output */
274
void Print_Bits(code,bits,len)
275
int code,bits,len;
276
{
277
  int i;
278
  for (i=0; i<len; i++)
279
    printf("%d",(code>>(bits-1-i))&1);
280
}
281
 
282
 
283
 
284
/* option processing */
285
static void Process_Options(argc,argv)
286
int argc;                  /* argument count  */
287
char *argv[];              /* argument vector */
288
{
289
  int i, LastArg, NextArg;
290
  for (i = 0; i < 12; i++) {     /* allocate page-aligned blocks */
291
    if ((base.block[i] = valloc(64)) == 0) {
292
        fprintf(stderr, "out of memory\n");
293
        exit(1);
294
    }
295
    if ((enhan.block[i] = valloc(64)) == 0) {
296
        fprintf(stderr, "out of memory\n");
297
        exit(1);
298
    }
299
  }
300
 
301
  /* at least one argument should be present */
302
  if (argc<2)
303
  {
304
    printf("\n%s, %s\n",Version,Author);
305
    printf("Usage:  mpeg2decode {options}\n\
306
Options: -b  file  main bitstream (base or spatial enhancement layer)\n\
307
         -cn file  conformance report (n: level)\n\
308
         -e  file  enhancement layer bitstream (SNR or Data Partitioning)\n\
309
         -f        store/display interlaced video in frame format\n\
310
         -g        concatenated file format for substitution method (-x)\n\
311
         -in file  information & statistics report  (n: level)\n\
312
         -l  file  file name pattern for lower layer sequence\n\
313
                   (for spatial scalability)\n\
314
         -on file  output format (0:YUV 1:SIF 2:TGA 3:PPM 4:X11 5:X11HiQ)\n\
315
         -q        disable warnings to stderr\n\
316
         -r        use double precision reference IDCT\n\
317
         -t        enable low level tracing to stdout\n\
318
         -u  file  print user_data to stdio or file\n\
319
         -vn       verbose output (n: level)\n\
320
         -x  file  filename pattern of picture substitution sequence\n\n\
321
File patterns:  for sequential filenames, \"printf\" style, e.g. rec%%d\n\
322
                 or rec%%d%%c for fieldwise storage\n\
323
Levels:        0:none 1:sequence 2:picture 3:slice 4:macroblock 5:block\n\n\
324
Example:       mpeg2decode -b bitstream.mpg -f -r -o0 rec%%d\n\
325
         \n");
326
    exit(0);
327
  }
328
 
329
 
330
  Output_Type = -1;
331
  i = 1;
332
 
333
  /* command-line options are proceeded by '-' */
334
 
335
  while(i < argc)
336
  {
337
    /* check if this is the last argument */
338
    LastArg = ((argc-i)==1);
339
 
340
    /* parse ahead to see if another flag immediately follows current
341
       argument (this is used to tell if a filename is missing) */
342
    if(!LastArg)
343
      NextArg = (argv[i+1][0]=='-');
344
    else
345
      NextArg = 0;
346
 
347
    /* second character, [1], after '-' is the switch */
348
    if(argv[i][0]=='-')
349
    {
350
      switch(toupper(argv[i][1]))
351
      {
352
        /* third character. [2], is the value */
353
      case 'B':
354
        Main_Bitstream_Flag = 1;
355
 
356
        if(NextArg || LastArg)
357
        {
358
          printf("ERROR: -b must be followed the main bitstream filename\n");
359
        }
360
        else
361
          Main_Bitstream_Filename = argv[++i];
362
 
363
        break;
364
 
365
 
366
      case 'C':
367
 
368
#ifdef VERIFY
369
        Verify_Flag = atoi(&argv[i][2]);
370
 
371
        if((Verify_Flag < NO_LAYER) || (Verify_Flag > ALL_LAYERS))
372
        {
373
          printf("ERROR: -c level (%d) out of range [%d,%d]\n",
374
            Verify_Flag, NO_LAYER, ALL_LAYERS);
375
          exit(ERROR);
376
        }
377
#else  /* VERIFY */
378
        printf("This program not compiled for Verify_Flag option\n");
379
#endif /* VERIFY */
380
        break;
381
 
382
      case 'E':
383
        Two_Streams = 1; /* either Data Partitioning (DP) or SNR Scalability enhancment */
384
 
385
        if(NextArg || LastArg)
386
        {
387
          printf("ERROR: -e must be followed by filename\n");
388
          exit(ERROR);
389
        }
390
        else
391
          Enhancement_Layer_Bitstream_Filename = argv[++i];
392
 
393
        break;
394
 
395
 
396
      case 'F':
397
        Frame_Store_Flag = 1;
398
        break;
399
 
400
      case 'G':
401
        Big_Picture_Flag = 1;
402
        break;
403
 
404
 
405
      case 'I':
406
#ifdef VERIFY
407
        Stats_Flag = atoi(&argv[i][2]);
408
#else /* VERIFY */
409
        printf("WARNING: This program not compiled for -i option\n");
410
#endif /* VERIFY */     
411
        break;
412
 
413
      case 'L':  /* spatial scalability flag */
414
        Spatial_Flag = 1;
415
 
416
       if(NextArg || LastArg)
417
       {
418
         printf("ERROR: -l must be followed by filename\n");
419
         exit(ERROR);
420
       }
421
       else
422
         Lower_Layer_Picture_Filename = argv[++i];
423
 
424
        break;
425
 
426
      case 'O':
427
 
428
        Output_Type = atoi(&argv[i][2]);
429
 
430
        if((Output_Type==4) || (Output_Type==5))
431
          Output_Picture_Filename = "";  /* no need of filename */
432
        else if(NextArg || LastArg)
433
        {
434
          printf("ERROR: -o must be followed by filename\n");
435
          exit(ERROR);
436
        }
437
        else
438
        /* filename is separated by space, so it becomes the next argument */
439
          Output_Picture_Filename = argv[++i];
440
 
441
#ifdef DISPLAY
442
        if (Output_Type==T_X11HIQ)
443
        {
444
          hiQdither = 1;
445
          Output_Type=T_X11;
446
        }
447
#endif /* DISPLAY */
448
        break;
449
 
450
      case 'Q':
451
        Quiet_Flag = 1;
452
        break;
453
 
454
      case 'R':
455
        Reference_IDCT_Flag = 1;
456
        break;
457
 
458
      case 'T':
459
#ifdef TRACE
460
        Trace_Flag = 1;
461
#else /* TRACE */
462
        printf("WARNING: This program not compiled for -t option\n");
463
#endif /* TRACE */
464
        break;
465
 
466
      case 'U':
467
        User_Data_Flag = 1;
468
 
469
      case 'V':
470
#ifdef VERBOSE
471
        Verbose_Flag = atoi(&argv[i][2]);
472
#else /* VERBOSE */
473
        printf("This program not compiled for -v option\n");
474
#endif /* VERBOSE */
475
        break;
476
 
477
 
478
      case 'X':
479
        Ersatz_Flag = 1;
480
 
481
       if(NextArg || LastArg)
482
       {
483
         printf("ERROR: -x must be followed by filename\n");
484
         exit(ERROR);
485
       }
486
       else
487
        Substitute_Picture_Filename = argv[++i];
488
 
489
        break;
490
 
491
 
492
 
493
      default:
494
        fprintf(stderr,"undefined option -%c ignored. Exiting program\n",
495
          argv[i][1]);
496
 
497
        exit(ERROR);
498
 
499
      } /* switch() */
500
    } /* if argv[i][0] == '-' */
501
 
502
    i++;
503
 
504
        /* check for bitstream filename argument (there must always be one, at the very end
505
           of the command line arguments */
506
 
507
  } /* while() */
508
 
509
 
510
  /* options sense checking */
511
 
512
  if(Main_Bitstream_Flag!=1)
513
  {
514
    printf("There must be a main bitstream specified (-b filename)\n");
515
  }
516
 
517
  /* force display process to show frame pictures */
518
  if((Output_Type==4 || Output_Type==5) && Frame_Store_Flag)
519
    Display_Progressive_Flag = 1;
520
  else
521
    Display_Progressive_Flag = 0;
522
 
523
#ifdef VERIFY
524
  /* parse the bitstream, do not actually decode it completely */
525
 
526
 
527
#if 0
528
  if(Output_Type==-1)
529
  {
530
    Decode_Layer = Verify_Flag;
531
    printf("FYI: Decoding bitstream elements up to: %s\n",
532
      Layer_Table[Decode_Layer]);
533
  }
534
  else
535
#endif
536
    Decode_Layer = ALL_LAYERS;
537
 
538
#endif /* VERIFY */
539
 
540
  /* no output type specified */
541
  if(Output_Type==-1)
542
  {
543
    Output_Type = 9;
544
    Output_Picture_Filename = "";
545
  }
546
 
547
 
548
#ifdef DISPLAY
549
  if (Output_Type==T_X11)
550
  {
551
    if(Frame_Store_Flag)
552
      Display_Progressive_Flag = 1;
553
    else
554
      Display_Progressive_Flag = 0;
555
 
556
    Frame_Store_Flag = 1; /* to avoid calling dither() twice */
557
  }
558
#endif
559
 
560
 
561
}
562
 
563
 
564
#ifdef OLD
565
/*
566
   this is an old routine used to convert command line arguments
567
   into integers
568
*/
569
static int Get_Val(argv)
570
char *argv[];
571
{
572
  int val;
573
 
574
  if (sscanf(argv[1]+2,"%d",&val)!=1)
575
    return 0;
576
 
577
  while (isdigit(argv[1][2]))
578
    argv[1]++;
579
 
580
  return val;
581
}
582
#endif
583
 
584
 
585
 
586
static int Headers()
587
{
588
  int ret;
589
 
590
  ld = &base;
591
 
592
 
593
  /* return when end of sequence (0) or picture
594
     header has been parsed (1) */
595
 
596
  ret = Get_Hdr();
597
 
598
 
599
  if (Two_Streams)
600
  {
601
    ld = &enhan;
602
    if (Get_Hdr()!=ret && !Quiet_Flag)
603
      fprintf(stderr,"streams out of sync\n");
604
    ld = &base;
605
  }
606
 
607
  return ret;
608
}
609
 
610
 
611
 
612
static int Decode_Bitstream()
613
{
614
  int ret;
615
  int Bitstream_Framenum;
616
 
617
  Bitstream_Framenum = 0;
618
 
619
  for(;;)
620
  {
621
 
622
#ifdef VERIFY
623
    Clear_Verify_Headers();
624
#endif /* VERIFY */
625
 
626
    ret = Headers();
627
 
628
    if(ret==1)
629
    {
630
      ret = video_sequence(&Bitstream_Framenum);
631
    }
632
    else
633
      return(ret);
634
  }
635
 
636
}
637
 
638
 
639
static void Deinitialize_Sequence()
640
{
641
  int i;
642
 
643
  /* clear flags */
644
  base.MPEG2_Flag=0;
645
 
646
  for(i=0;i<3;i++)
647
  {
648
    free(backward_reference_frame[i]);
649
    free(forward_reference_frame[i]);
650
    free(auxframe[i]);
651
 
652
    if (base.scalable_mode==SC_SPAT)
653
    {
654
     free(llframe0[i]);
655
     free(llframe1[i]);
656
    }
657
  }
658
 
659
  if (base.scalable_mode==SC_SPAT)
660
    free(lltmp);
661
 
662
#ifdef DISPLAY
663
  if (Output_Type==T_X11)
664
    Terminate_Display_Process();
665
#endif
666
}
667
 
668
 
669
static int video_sequence(Bitstream_Framenumber)
670
int *Bitstream_Framenumber;
671
{
672
  int Bitstream_Framenum;
673
  int Sequence_Framenum;
674
  int Return_Value;
675
 
676
  Bitstream_Framenum = *Bitstream_Framenumber;
677
  Sequence_Framenum=0;
678
 
679
  Initialize_Sequence();
680
 
681
  /* decode picture whose header has already been parsed in
682
     Decode_Bitstream() */
683
 
684
 
685
  Decode_Picture(Bitstream_Framenum, Sequence_Framenum);
686
 
687
  /* update picture numbers */
688
  if (!Second_Field)
689
  {
690
    Bitstream_Framenum++;
691
    Sequence_Framenum++;
692
  }
693
 
694
  /* loop through the rest of the pictures in the sequence */
695
  while ((Return_Value=Headers()))
696
  {
697
    Decode_Picture(Bitstream_Framenum, Sequence_Framenum);
698
 
699
    if (!Second_Field)
700
    {
701
      Bitstream_Framenum++;
702
      Sequence_Framenum++;
703
    }
704
  }
705
 
706
  /* put last frame */
707
  if (Sequence_Framenum!=0)
708
  {
709
    Output_Last_Frame_of_Sequence(Bitstream_Framenum);
710
  }
711
 
712
  Deinitialize_Sequence();
713
 
714
#ifdef VERIFY
715
    Clear_Verify_Headers();
716
#endif /* VERIFY */
717
 
718
  *Bitstream_Framenumber = Bitstream_Framenum;
719
  return(Return_Value);
720
}
721
 
722
 
723
 
724
static void Clear_Options()
725
{
726
  Verbose_Flag = 0;
727
  Output_Type = 0;
728
  Output_Picture_Filename = " ";
729
  hiQdither  = 0;
730
  Output_Type = 0;
731
  Frame_Store_Flag = 0;
732
  Spatial_Flag = 0;
733
  Lower_Layer_Picture_Filename = " ";
734
  Reference_IDCT_Flag = 0;
735
  Trace_Flag = 0;
736
  Quiet_Flag = 0;
737
  Ersatz_Flag = 0;
738
  Substitute_Picture_Filename  = " ";
739
  Two_Streams = 0;
740
  Enhancement_Layer_Bitstream_Filename = " ";
741
  Big_Picture_Flag = 0;
742
  Main_Bitstream_Flag = 0;
743
  Main_Bitstream_Filename = " ";
744
  Verify_Flag = 0;
745
  Stats_Flag  = 0;
746
  User_Data_Flag = 0;
747
}
748
 
749
 
750
#ifdef DEBUG
751
static void Print_Options()
752
{
753
 
754
  printf("Verbose_Flag                         = %d\n", Verbose_Flag);
755
  printf("Output_Type                          = %d\n", Output_Type);
756
  printf("Output_Picture_Filename              = %s\n", Output_Picture_Filename);
757
  printf("hiQualityX11                         = %d\n", hiQdither);
758
  printf("Output_Type                          = %d\n", Output_Type);
759
  printf("Frame_Store_Flag                     = %d\n", Frame_Store_Flag);
760
  printf("Spatial_Flag                         = %d\n", Spatial_Flag);
761
  printf("Lower_Layer_Picture_Filename         = %s\n", Lower_Layer_Picture_Filename);
762
  printf("Reference_IDCT_Flag                  = %d\n", Reference_IDCT_Flag);
763
  printf("Trace_Flag                           = %d\n", Trace_Flag);
764
  printf("Quiet_Flag                           = %d\n", Quiet_Flag);
765
  printf("Ersatz_Flag                          = %d\n", Ersatz_Flag);
766
  printf("Substitute_Picture_Filename          = %s\n", Substitute_Picture_Filename);
767
  printf("Two_Streams                          = %d\n", Two_Streams);
768
  printf("Enhancement_Layer_Bitstream_Filename = %s\n", Enhancement_Layer_Bitstream_Filename);
769
  printf("Big_Picture_Flag                     = %d\n", Big_Picture_Flag);
770
  printf("Main_Bitstream_Flag                  = %d\n", Main_Bitstream_Flag);
771
  printf("Main_Bitstream_Filename              = %s\n", Main_Bitstream_Filename);
772
  printf("Verify_Flag                          = %d\n", Verify_Flag);
773
  printf("Stats_Flag                           = %d\n", Stats_Flag);
774
  printf("User_Data_Flag                       = %d\n", User_Data_Flag);
775
 
776
}
777
#endif

powered by: WebSVN 2.1.0

© copyright 1999-2019 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.