/* mpeg2dec.c, main(), initialization, option processing                    *//* Copyright (C) 1996, MPEG Software Simulation Group. All Rights Reserved. *//* * Disclaimer of Warranty * * These software programs are available to the user without any license fee or * royalty on an "as is" basis.  The MPEG Software Simulation Group disclaims * any and all warranties, whether express, implied, or statuary, including any * implied warranties or merchantability or of fitness for a particular * purpose.  In no event shall the copyright-holder be liable for any * incidental, punitive, or consequential damages of any kind whatsoever * arising from the use of these programs. * * This disclaimer of warranty extends to the user of these programs and user's * customers, employees, agents, transferees, successors, and assigns. * * The MPEG Software Simulation Group does not represent or warrant that the * programs furnished hereunder are free of infringement of any third-party * patents. * * Commercial implementations of MPEG-1 and MPEG-2 video, including shareware, * are subject to royalty fees to patent holders.  Many of these patents are * general enough such that they are unavoidable regardless of implementation * design. * */#include <stdio.h>#include <stdlib.h>#include <ctype.h>#include <fcntl.h>#define GLOBAL#include "config.h"#include "global.h"/* private prototypes */static int  video_sequence _ANSI_ARGS_((int *framenum));static int Decode_Bitstream _ANSI_ARGS_((void));static int  Headers _ANSI_ARGS_((void));static void Initialize_Sequence _ANSI_ARGS_((void));static void Initialize_Decoder _ANSI_ARGS_((void));static void Deinitialize_Sequence _ANSI_ARGS_((void));static void Process_Options _ANSI_ARGS_((int argc, char *argv[]));#if OLDstatic int  Get_Val _ANSI_ARGS_((char *argv[]));#endif/* #define DEBUG */static void Clear_Options();#ifdef DEBUGstatic void Print_Options();#endifint main(argc,argv)int argc;char *argv[];{ 
  int ret, code;  argc=1;
  argv[1]="test.M2V";
    Clear_Options();  /* decode command line arguments */  Process_Options(argc,argv);#ifdef DEBUG  Print_Options();#endif  ld = &base; /* select base layer context */  /* open MPEG base layer bitstream file(s) */  /* NOTE: this is either a base layer stream or a spatial enhancement stream */  if ((base.Infile=open(Main_Bitstream_Filename,O_RDONLY|O_BINARY))<0)  {    fprintf(stderr,"Base layer input file %s not found\n", Main_Bitstream_Filename);    exit(1);  }  if(base.Infile != 0)  {    Initialize_Buffer();       if(Show_Bits(8)==0x47)    {      sprintf(Error_Text,"Decoder currently does not parse transport streams\n");      Error(Error_Text);    }    next_start_code();    code = Show_Bits(32);    switch(code)    {    case SEQUENCE_HEADER_CODE:      break;    case PACK_START_CODE:      System_Stream_Flag = 1;    case VIDEO_ELEMENTARY_STREAM:      System_Stream_Flag = 1;      break;    default:      sprintf(Error_Text,"Unable to recognize stream type\n");      Error(Error_Text);      break;    }    lseek(base.Infile, 0l, 0);    Initialize_Buffer();   }  if(base.Infile!=0)  {    lseek(base.Infile, 0l, 0);  }  Initialize_Buffer();   if(Two_Streams)  {    ld = &enhan; /* select enhancement layer context */    if ((enhan.Infile = open(Enhancement_Layer_Bitstream_Filename,O_RDONLY|O_BINARY))<0)    {      sprintf(Error_Text,"enhancment layer bitstream file %s not found\n",        Enhancement_Layer_Bitstream_Filename);      Error(Error_Text);    }    Initialize_Buffer();    ld = &base;  }  Initialize_Decoder();  ret = Decode_Bitstream();  close(base.Infile);  if (Two_Streams)    close(enhan.Infile);  return 0;}/* IMPLEMENTAION specific rouintes */static void Initialize_Decoder(){  int i;  /* Clip table */  if (!(Clip=(unsigned char *)malloc(1024)))    Error("Clip[] malloc failed\n");  Clip += 384;  for (i=-384; i<640; i++)    Clip[i] = (i<0) ? 0 : ((i>255) ? 255 : i);  /* IDCT */  if (Reference_IDCT_Flag)    Initialize_Reference_IDCT();  else    Initialize_Fast_IDCT();}/* mostly IMPLEMENTAION specific rouintes */static void Initialize_Sequence(){  int cc, size;  static int Table_6_20[3] = {6,8,12};  /* check scalability mode of enhancement layer */  if (Two_Streams && (enhan.scalable_mode!=SC_SNR) && (base.scalable_mode!=SC_DP))    Error("unsupported scalability mode\n");  /* force MPEG-1 parameters for proper decoder behavior */  /* see ISO/IEC 13818-2 section D.9.14 */  if (!base.MPEG2_Flag)  {    progressive_sequence = 1;    progressive_frame = 1;    picture_structure = FRAME_PICTURE;    frame_pred_frame_dct = 1;    chroma_format = CHROMA420;    matrix_coefficients = 5;  }  /* round to nearest multiple of coded macroblocks */  /* ISO/IEC 13818-2 section 6.3.3 sequence_header() */  mb_width = (horizontal_size+15)/16;  mb_height = (base.MPEG2_Flag && !progressive_sequence) ? 2*((vertical_size+31)/32)                                        : (vertical_size+15)/16;  Coded_Picture_Width = 16*mb_width;  Coded_Picture_Height = 16*mb_height;  /* ISO/IEC 13818-2 sections 6.1.1.8, 6.1.1.9, and 6.1.1.10 */  Chroma_Width = (chroma_format==CHROMA444) ? Coded_Picture_Width                                           : Coded_Picture_Width>>1;  Chroma_Height = (chroma_format!=CHROMA420) ? Coded_Picture_Height                                            : Coded_Picture_Height>>1;    /* derived based on Table 6-20 in ISO/IEC 13818-2 section 6.3.17 */  block_count = Table_6_20[chroma_format-1];  for (cc=0; cc<3; cc++)  {    if (cc==0)      size = Coded_Picture_Width*Coded_Picture_Height;    else      size = Chroma_Width*Chroma_Height;    if (!(backward_reference_frame[cc] = (unsigned char *)malloc(size)))      Error("backward_reference_frame[] malloc failed\n");    if (!(forward_reference_frame[cc] = (unsigned char *)malloc(size)))      Error("forward_reference_frame[] malloc failed\n");    if (!(auxframe[cc] = (unsigned char *)malloc(size)))      Error("auxframe[] malloc failed\n");    if(Ersatz_Flag)      if (!(substitute_frame[cc] = (unsigned char *)malloc(size)))        Error("substitute_frame[] malloc failed\n");    if (base.scalable_mode==SC_SPAT)    {      /* this assumes lower layer is 4:2:0 */      if (!(llframe0[cc] = (unsigned char *)malloc((lower_layer_prediction_horizontal_size*lower_layer_prediction_vertical_size)/(cc?4:1))))        Error("llframe0 malloc failed\n");      if (!(llframe1[cc] = (unsigned char *)malloc((lower_layer_prediction_horizontal_size*lower_layer_prediction_vertical_size)/(cc?4:1))))        Error("llframe1 malloc failed\n");    }  }  /* SCALABILITY: Spatial */  if (base.scalable_mode==SC_SPAT)  {    if (!(lltmp = (short *)malloc(lower_layer_prediction_horizontal_size*((lower_layer_prediction_vertical_size*vertical_subsampling_factor_n)/vertical_subsampling_factor_m)*sizeof(short))))      Error("lltmp malloc failed\n");  }#ifdef DISPLAY  if (Output_Type==T_X11)  {    Initialize_Display_Process("");    Initialize_Dither_Matrix();  }#endif /* DISPLAY */}void Error(text)char *text;{  fprintf(stderr,text);  exit(1);}/* Trace_Flag output */void Print_Bits(code,bits,len)int code,bits,len;{  int i;  for (i=0; i<len; i++)    printf("%d",(code>>(bits-1-i))&1);}/* option processing */static void Process_Options(argc,argv)int argc;                  /* argument count  */char *argv[];              /* argument vector */{  int i, LastArg, NextArg;  /* at least one argument should be present */  if (argc<2)  {    printf("\n%s, %s\n",Version,Author);    printf("Usage:  mpeg2decode {options}\n\Options: -b  file  main bitstream (base or spatial enhancement layer)\n\         -cn file  conformance report (n: level)\n\         -e  file  enhancement layer bitstream (SNR or Data Partitioning)\n\         -f        store/display interlaced video in frame format\n\         -g        concatenated file format for substitution method (-x)\n\         -in file  information & statistics report  (n: level)\n\         -l  file  file name pattern for lower layer sequence\n\                   (for spatial scalability)\n\         -on file  output format (0:YUV 1:SIF 2:TGA 3:PPM 4:X11 5:X11HiQ)\n\         -q        disable warnings to stderr\n\         -r        use double precision reference IDCT\n\         -t        enable low level tracing to stdout\n\         -u  file  print user_data to stdio or file\n\         -vn       verbose output (n: level)\n\         -x  file  filename pattern of picture substitution sequence\n\n\File patterns:  for sequential filenames, \"printf\" style, e.g. rec%%d\n\                 or rec%%d%%c for fieldwise storage\n\Levels:        0:none 1:sequence 2:picture 3:slice 4:macroblock 5:block\n\n\Example:       mpeg2decode -b bitstream.mpg -f -r -o0 rec%%d\n\         \n");    exit(0);  }  Output_Type = -1;  i = 1;  /* command-line options are proceeded by '-' */  while(i < argc)  {    /* check if this is the last argument */    LastArg = ((argc-i)==1);    /* parse ahead to see if another flag immediately follows current       argument (this is used to tell if a filename is missing) */    if(!LastArg)      NextArg = (argv[i+1][0]=='-');    else      NextArg = 0;    /* second character, [1], after '-' is the switch */    if(argv[i][0]=='-')    {      switch(toupper(argv[i][1]))      {        /* third character. [2], is the value */      case 'B':        Main_Bitstream_Flag = 1;        if(NextArg || LastArg)        {          printf("ERROR: -b must be followed the main bitstream filename\n");	}        else          Main_Bitstream_Filename = argv[++i];         break;      case 'C':#ifdef VERIFY        Verify_Flag = atoi(&argv[i][2]);         if((Verify_Flag < NO_LAYER) || (Verify_Flag > ALL_LAYERS))        {          printf("ERROR: -c level (%d) out of range [%d,%d]\n",            Verify_Flag, NO_LAYER, ALL_LAYERS);          exit(ERROR);        }#else  /* VERIFY */        printf("This program not compiled for Verify_Flag option\n");#endif /* VERIFY */        break;      case 'E':        Two_Streams = 1; /* either Data Partitioning (DP) or SNR Scalability enhancment */	                           if(NextArg || LastArg)        {          printf("ERROR: -e must be followed by filename\n");          exit(ERROR);        }        else          Enhancement_Layer_Bitstream_Filename = argv[++i];         break;