Subversion Repositories shark

/* 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 OLD

static int  Get_Val _ANSI_ARGS_((char *argv[]));

#endif

/* #define DEBUG */

static void Clear_Options();

#ifdef DEBUG

static void Print_Options();

#endif

int main(argc,argv)

int argc;

char *argv[];

{

  int ret, code;

  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");

  }

  // PJ

  Initialize_framebuf( Coded_Picture_Width*Coded_Picture_Height*sizeof(WORD) );

  gvideo_init();

  init_jetcontrol();

#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;

      case 'F':

        Frame_Store_Flag = 1;

        break;

      case 'G':

        Big_Picture_Flag = 1;

        break;

      case 'I':

#ifdef VERIFY

        Stats_Flag = atoi(&argv[i][2]);

#else /* VERIFY */

        printf("WARNING: This program not compiled for -i option\n");

#endif /* VERIFY */     

        break;

      case 'L':  /* spatial scalability flag */

        Spatial_Flag = 1;

       if(NextArg || LastArg)

       {

         printf("ERROR: -l must be followed by filename\n");

         exit(ERROR);

       }

       else

         Lower_Layer_Picture_Filename = argv[++i];

        break;

      case 'O':

        Output_Type = atoi(&argv[i][2]);

        if((Output_Type==4) || (Output_Type==5))

          Output_Picture_Filename = "";  /* no need of filename */

        else if(NextArg || LastArg)  

        {

          printf("ERROR: -o must be followed by filename\n");

          exit(ERROR);

        }

        else

        /* filename is separated by space, so it becomes the next argument */

          Output_Picture_Filename = argv[++i];

#ifdef DISPLAY

        if (Output_Type==T_X11HIQ)

        {

          hiQdither = 1;

          Output_Type=T_X11;

        }

#endif /* DISPLAY */

        break;

      case 'Q':

        Quiet_Flag = 1;

        break;

      case 'R':

        Reference_IDCT_Flag = 1;

        break;

      case 'T':

#ifdef TRACE

        Trace_Flag = 1;

#else /* TRACE */

        printf("WARNING: This program not compiled for -t option\n");

#endif /* TRACE */

        break;

      case 'U':

        User_Data_Flag = 1;

      case 'V':

#ifdef VERBOSE

        Verbose_Flag = atoi(&argv[i][2]);

#else /* VERBOSE */

        printf("This program not compiled for -v option\n");

#endif /* VERBOSE */

        break;

      case 'X':

        Ersatz_Flag = 1;

       if(NextArg || LastArg)

       {

         printf("ERROR: -x must be followed by filename\n");

         exit(ERROR);

       }

       else

        Substitute_Picture_Filename = argv[++i];

        break;

      default:

        fprintf(stderr,"undefined option -%c ignored. Exiting program\n",

          argv[i][1]);

        exit(ERROR);

      } /* switch() */

    } /* if argv[i][0] == '-' */

    i++;

        /* check for bitstream filename argument (there must always be one, at the very end

           of the command line arguments */

  } /* while() */

  /* options sense checking */

  if(Main_Bitstream_Flag!=1)

  {

    printf("There must be a main bitstream specified (-b filename)\n");

  }

  /* force display process to show frame pictures */

  if((Output_Type==4 || Output_Type==5) && Frame_Store_Flag)

    Display_Progressive_Flag = 1;

  else

    Display_Progressive_Flag = 0;

#ifdef VERIFY

  /* parse the bitstream, do not actually decode it completely */

#if 0

  if(Output_Type==-1)

  {

    Decode_Layer = Verify_Flag;

    printf("FYI: Decoding bitstream elements up to: %s\n",

      Layer_Table[Decode_Layer]);

  }

  else

#endif

    Decode_Layer = ALL_LAYERS;

#endif /* VERIFY */

  /* no output type specified */

  if(Output_Type==-1)

  {

    Output_Type = 9;

    Output_Picture_Filename = "";

  }

#ifdef DISPLAY

  if (Output_Type==T_X11)

  {

    if(Frame_Store_Flag)

      Display_Progressive_Flag = 1;

    else

      Display_Progressive_Flag = 0;

    Frame_Store_Flag = 1; /* to avoid calling dither() twice */

  }

#endif

}

#ifdef OLD

/*

   this is an old routine used to convert command line arguments

   into integers

*/

static int Get_Val(argv)

char *argv[];

{

  int val;

  if (sscanf(argv[1]+2,"%d",&val)!=1)

    return 0;

  while (isdigit(argv[1][2]))

    argv[1]++;

  return val;

}

#endif

static int Headers()

{

  int ret;

  ld = &base;

  /* return when end of sequence (0) or picture

     header has been parsed (1) */

  ret = Get_Hdr();

  if (Two_Streams)

  {

    ld = &enhan;

    if (Get_Hdr()!=ret && !Quiet_Flag)

      fprintf(stderr,"streams out of sync\n");

    ld = &base;

  }

  return ret;

}

static int Decode_Bitstream()

{

  int ret;

  int Bitstream_Framenum;

  Bitstream_Framenum = 0;

  for(;;)

  {

#ifdef VERIFY

    Clear_Verify_Headers();

#endif /* VERIFY */

    ret = Headers();

    if(ret==1)

    {

      ret = video_sequence(&Bitstream_Framenum);

    }

    else

      return(ret);

  }

}

static void Deinitialize_Sequence()

{

  int i;

  /* clear flags */

  base.MPEG2_Flag=0;

  for(i=0;i<3;i++)

  {

    free(backward_reference_frame[i]);

    free(forward_reference_frame[i]);

    free(auxframe[i]);

    if (base.scalable_mode==SC_SPAT)

    {

     free(llframe0[i]);

     free(llframe1[i]);

    }

  }

  if (base.scalable_mode==SC_SPAT)

    free(lltmp);

#ifdef DISPLAY

  if (Output_Type==T_X11)

    Terminate_Display_Process();

#endif

}

static int video_sequence(Bitstream_Framenumber)

int *Bitstream_Framenumber;

{

  int Bitstream_Framenum;

  int Sequence_Framenum;

  int Return_Value;

  Bitstream_Framenum = *Bitstream_Framenumber;

  Sequence_Framenum=0;

  Initialize_Sequence();

  /* decode picture whose header has already been parsed in

     Decode_Bitstream() */

  Decode_Picture(Bitstream_Framenum, Sequence_Framenum);

  /* update picture numbers */

  if (!Second_Field)

  {

    Bitstream_Framenum++;

    Sequence_Framenum++;

  }

  /* loop through the rest of the pictures in the sequence */

  while ((Return_Value=Headers()))

  {

    Decode_Picture(Bitstream_Framenum, Sequence_Framenum);

    if (!Second_Field)

    {

      Bitstream_Framenum++;

      Sequence_Framenum++;

    }

  }

  /* put last frame */

  if (Sequence_Framenum!=0)

  {

    Output_Last_Frame_of_Sequence(Bitstream_Framenum);

  }

  Deinitialize_Sequence();

#ifdef VERIFY

    Clear_Verify_Headers();

#endif /* VERIFY */

  *Bitstream_Framenumber = Bitstream_Framenum;

  return(Return_Value);

}

static void Clear_Options()

{

  Verbose_Flag = 0;

  Output_Type = 0;

  Output_Picture_Filename = " ";

  hiQdither  = 0;

  Output_Type = 0;

  Frame_Store_Flag = 0;

  Spatial_Flag = 0;

  Lower_Layer_Picture_Filename = " ";

  Reference_IDCT_Flag = 0;

  Trace_Flag = 0;

  Quiet_Flag = 0;

  Ersatz_Flag = 0;

  Substitute_Picture_Filename  = " ";

  Two_Streams = 0;

  Enhancement_Layer_Bitstream_Filename = " ";

  Big_Picture_Flag = 0;

  Main_Bitstream_Flag = 0;

  Main_Bitstream_Filename = " ";

  Verify_Flag = 0;

  Stats_Flag  = 0;

  User_Data_Flag = 0;

}

#ifdef DEBUG

static void Print_Options()

{

  printf("Verbose_Flag                         = %d\n", Verbose_Flag);

  printf("Output_Type                          = %d\n", Output_Type);

  printf("Output_Picture_Filename              = %s\n", Output_Picture_Filename);

  printf("hiQdither                            = %d\n", hiQdither);

  printf("Output_Type                          = %d\n", Output_Type);

  printf("Frame_Store_Flag                     = %d\n", Frame_Store_Flag);

  printf("Spatial_Flag                         = %d\n", Spatial_Flag);

  printf("Lower_Layer_Picture_Filename         = %s\n", Lower_Layer_Picture_Filename);

  printf("Reference_IDCT_Flag                  = %d\n", Reference_IDCT_Flag);

  printf("Trace_Flag                           = %d\n", Trace_Flag);

  printf("Quiet_Flag                           = %d\n", Quiet_Flag);

  printf("Ersatz_Flag                          = %d\n", Ersatz_Flag);

  printf("Substitute_Picture_Filename          = %s\n", Substitute_Picture_Filename);

  printf("Two_Streams                          = %d\n", Two_Streams);

  printf("Enhancement_Layer_Bitstream_Filename = %s\n", Enhancement_Layer_Bitstream_Filename);

  printf("Big_Picture_Flag                     = %d\n", Big_Picture_Flag);

  printf("Main_Bitstream_Flag                  = %d\n", Main_Bitstream_Flag);

  printf("Main_Bitstream_Filename              = %s\n", Main_Bitstream_Filename);

  printf("Verify_Flag                          = %d\n", Verify_Flag);

  printf("Stats_Flag                           = %d\n", Stats_Flag);

  printf("User_Data_Flag                       = %d\n", User_Data_Flag);

}

#endif