/* gethdr.c, header decoding                                                */

/* Copyright (C) 1994, 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 "config.h"
#include "global.h"

/* private prototypes */
static int gethdr _ANSI_ARGS_((void));
static void getseqhdr _ANSI_ARGS_((void));
static void getgophdr _ANSI_ARGS_((void));
static void getpicturehdr _ANSI_ARGS_((void));
static void ext_user_data _ANSI_ARGS_((void));
static void sequence_extension _ANSI_ARGS_((void));
static void sequence_display_extension _ANSI_ARGS_((void));
static void quant_matrix_extension _ANSI_ARGS_((void));
static void sequence_scalable_extension _ANSI_ARGS_((void));
static void picture_display_extension _ANSI_ARGS_((void));
static void picture_coding_extension _ANSI_ARGS_((void));
static void picture_spatial_scalable_extension _ANSI_ARGS_((void));
static void picture_temporal_scalable_extension _ANSI_ARGS_((void));
static void ext_bit_info _ANSI_ARGS_((void));


/* decode headers from all input streams */

int getheader()
{
  int ret;

  ld = &base;
  ret = gethdr();
  if (twostreams)
  {
    ld = &enhan;
    if (gethdr()!=ret && !quiet)
      fprintf(stderr,"streams out of sync\n");
    ld = &base;
  }

  return ret;
}


/*
 * decode headers from one input stream
 * until an End of Sequence or picture start code
 * is found
 */

static int gethdr()
{
  unsigned int code;

  for (;;)
  {
    /* look for startcode */
    startcode();
    code = getbits32();
    switch (code)
    {
    case SEQ_START_CODE:
      getseqhdr();
      break;
    case GOP_START_CODE:
      getgophdr();
      break;
    case PICTURE_START_CODE:
      getpicturehdr();
      return 1;
      break;
    case SEQ_END_CODE:
      return 0;
      break;
    default:
      if (!quiet)
        fprintf(stderr,"Unexpected startcode %08x (ignored)\n",code);
      break;
    }
  }
}


/* align to start of next startcode */

void startcode()
{
  /* byte align */
  flushbits(ld->incnt&7);
  while (showbits(24)!=1l)
    flushbits(8);
}


/* decode sequence header */

static void getseqhdr()
{
  int i;
  int aspect_ratio, picture_rate, vbv_buffer_size;
  int constrained_parameters_flag;
  int load_intra_quantizer_matrix, load_non_intra_quantizer_matrix;
  int bit_rate;
  int pos;

  pos = ld->bitcnt;
  horizontal_size = getbits(12);
  vertical_size = getbits(12);
  aspect_ratio = getbits(4);
  picture_rate = getbits(4);
  bit_rate = getbits(18);
  flushbits(1); /* marker bit (=1) */
  vbv_buffer_size = getbits(10);
  constrained_parameters_flag = getbits(1);

  if (load_intra_quantizer_matrix = getbits(1))
  {
    for (i=0; i<64; i++)
      ld->intra_quantizer_matrix[zig_zag_scan[i]] = getbits(8);
  }
  else
  {
    for (i=0; i<64; i++)
      ld->intra_quantizer_matrix[i] = default_intra_quantizer_matrix[i];
  }

  if (load_non_intra_quantizer_matrix = getbits(1))
  {
    for (i=0; i<64; i++)
      ld->non_intra_quantizer_matrix[zig_zag_scan[i]] = getbits(8);
  }
  else
  {
    for (i=0; i<64; i++)
      ld->non_intra_quantizer_matrix[i] = 16;
  }

  /* copy luminance to chrominance matrices */
  for (i=0; i<64; i++)
  {
    ld->chroma_intra_quantizer_matrix[i] =
      ld->intra_quantizer_matrix[i];

    ld->chroma_non_intra_quantizer_matrix[i] =
      ld->non_intra_quantizer_matrix[i];
  }

  if (verbose>0)
  {
    printf("sequence header (byte %d)\n",(pos>>3)-4);
    if (verbose>1)
    {
      printf("  horizontal_size=%d\n",horizontal_size);
      printf("  vertical_size=%d\n",vertical_size);
      printf("  aspect_ratio=%d\n",aspect_ratio);
      printf("  picture_rate=%d\n",picture_rate);
      printf("  bit_rate=%d\n",bit_rate);
      printf("  vbv_buffer_size=%d\n",vbv_buffer_size);
      printf("  constrained_parameters_flag=%d\n",constrained_parameters_flag);
      printf("  load_intra_quantizer_matrix=%d\n",load_intra_quantizer_matrix);
      printf("  load_non_intra_quantizer_matrix=%d\n",load_non_intra_quantizer_matrix);
    }
  }

  ext_user_data();
}


/* decode group of pictures header */

static void getgophdr()
{
  int drop_flag, hour, minute, sec, frame, closed_gop, broken_link;
  int pos;

  pos = ld->bitcnt;
  drop_flag = getbits(1);
  hour = getbits(5);
  minute = getbits(6);
  flushbits(1);
  sec = getbits(6);
  frame = getbits(6);
  closed_gop = getbits(1);
  broken_link = getbits(1);

  if (verbose>0)
  {
    printf("group of pictures (byte %d)\n",(pos>>3)-4);
    if (verbose>1)
    {
      printf("  drop_flag=%d\n",drop_flag);
      printf("  timecode %d:%02d:%02d:%02d\n",hour,minute,sec,frame);
      printf("  closed_gop=%d\n",closed_gop);
      printf("  broken_link=%d\n",broken_link);
    }
  }

  ext_user_data();
}


/* decode picture header */

static void getpicturehdr()
{
  int temp_ref, vbv_delay;
  int pos;

  ld->pict_scal = 0; /* unless overwritten by pict. spat. scal. ext. */

  pos = ld->bitcnt;
  temp_ref = getbits(10);
  pict_type = getbits(3);
  vbv_delay = getbits(16);
  if (pict_type==P_TYPE || pict_type==B_TYPE)
  {
    full_forw = getbits(1);
    forw_r_size = getbits(3) - 1;
  }
  if (pict_type==B_TYPE)
  {
    full_back = getbits(1);
    back_r_size = getbits(3) - 1;
  }

  if (verbose>0)
  {
    printf("picture header (byte %d)\n",(pos>>3)-4);
    if (verbose>1)
    {
      printf("  temp_ref=%d\n",temp_ref);
      printf("  pict_type=%d\n",pict_type);
      printf("  vbv_delay=%d\n",vbv_delay);
      if (pict_type==P_TYPE || pict_type==B_TYPE)
      {
        printf("  full_forw=%d\n",full_forw);
        printf("  forw_r_size=%d\n",forw_r_size);
      }
      if (pict_type==B_TYPE)
      {
        printf("  full_back=%d\n",full_back);
        printf("  back_r_size=%d\n",back_r_size);
      }
    }
  }
  ext_bit_info();
  ext_user_data();
}

/* decode slice header */

int getslicehdr()
{
  int slice_vertical_position_extension, intra_slice;
  int qs;
  int pos;

  pos = ld->bitcnt;
  slice_vertical_position_extension =
    (ld->mpeg2 && vertical_size>2800) ? getbits(3) : 0;

  if (ld->scalable_mode==SC_DP)
    ld->pri_brk = getbits(7);

  qs = getbits(5);
  ld->quant_scale =
    ld->mpeg2 ? (ld->qscale_type ? non_linear_mquant_table[qs] : qs<<1) : qs;

  if (getbits(1))
  {
    intra_slice = getbits(1);
    flushbits(7);
    ext_bit_info();
  }
  else
    intra_slice = 0;

  if (verbose>2)
  {
    printf("slice header (byte %d)\n",(pos>>3)-4);
    if (verbose>3)
    {
      if (ld->mpeg2 && vertical_size>2800)
        printf("  slice_vertical_position_extension=%d\n",slice_vertical_position_extension);
      if (ld->scalable_mode==SC_DP)
        printf("  priority_breakpoint=%d\n",ld->pri_brk);
      printf("  quantizer_scale_code=%d\n",qs);
    }
  }
  return slice_vertical_position_extension;
}


/* decode extension and user data */

static void ext_user_data()
{
  int code,ext_ID;

  startcode();

  while ((code = showbits(32))==EXT_START_CODE || code==USER_START_CODE)
  {
    if (code==EXT_START_CODE)
    {
      flushbits32();
      ext_ID = getbits(4);
      switch (ext_ID)
      {
      case SEQ_ID:
        sequence_extension();
        break;
      case DISP_ID:
        sequence_display_extension();
        break;
      case QUANT_ID:
        quant_matrix_extension();
        break;
      case SEQSCAL_ID:
        sequence_scalable_extension();
        break;
      case PANSCAN_ID:
        picture_display_extension();
        break;
      case CODING_ID:
        picture_coding_extension();
        break;
      case SPATSCAL_ID:
        picture_spatial_scalable_extension();
        break;
      case TEMPSCAL_ID:
        picture_temporal_scalable_extension();
        break;
      default:
        fprintf(stderr,"reserved extension start code ID %d\n",ext_ID);
        break;
      }
      startcode();
    }
    else
    {
      if (verbose)
        printf("user data\n");
      flushbits32();
      startcode();
    }
  }
}


/* decode sequence extension */

static void sequence_extension()
{
  int prof_lev;
  int horizontal_size_extension, vertical_size_extension;
  int bit_rate_extension, vbv_buffer_size_extension, low_delay;
  int frame_rate_extension_n, frame_rate_extension_d;
  int pos;

  pos = ld->bitcnt;
  ld->mpeg2 = 1;
  ld->scalable_mode = SC_NONE; /* unless overwritten by seq. scal. ext. */
  prof_lev = getbits(8);
  prog_seq = getbits(1);
  chroma_format = getbits(2);
  horizontal_size_extension = getbits(2);
  vertical_size_extension = getbits(2);
  bit_rate_extension = getbits(12);
  flushbits(1);
  vbv_buffer_size_extension = getbits(8);
  low_delay = getbits(1);
  frame_rate_extension_n = getbits(2);
  frame_rate_extension_d = getbits(5);

  horizontal_size = (horizontal_size_extension<<12) | (horizontal_size&0x0fff);
  vertical_size = (vertical_size_extension<<12) | (vertical_size&0x0fff);

  if (verbose>0)
  {
    printf("sequence extension (byte %d)\n",(pos>>3)-4);
    if (verbose>1)
    {
      printf("  profile_and_level_indication=%d\n",prof_lev);
      if (prof_lev<128)
      {
        printf("    profile=%d, level=%d\n",prof_lev>>4,prof_lev&15);
      }
      printf("  progressive_sequence=%d\n",prog_seq);
      printf("  chroma_format=%d\n",chroma_format);
      printf("  horizontal_size_extension=%d\n",horizontal_size_extension);
      printf("  vertical_size_extension=%d\n",vertical_size_extension);
      printf("  bit_rate_extension=%d\n",bit_rate_extension);
      printf("  vbv_buffer_size_extension=%d\n",vbv_buffer_size_extension);
      printf("  low_delay=%d\n",low_delay);
      printf("  frame_rate_extension_n=%d\n",frame_rate_extension_n);
      printf("  frame_rate_extension_d=%d\n",frame_rate_extension_d);
    }
  }
}


/* decode sequence display extension */

static void sequence_display_extension()
{
  int video_format, colour_description;
  int colour_primaries, transfer_characteristics;
  int display_horizontal_size, display_vertical_size;
  int pos;

  pos = ld->bitcnt;
  video_format = getbits(3);
  colour_description = getbits(1);

  if (colour_description)
  {
    colour_primaries = getbits(8);
    transfer_characteristics = getbits(8);
    matrix_coefficients = getbits(8);
  }

  display_horizontal_size = getbits(14);
  flushbits(1);
  display_vertical_size = getbits(14);

  if (verbose>0)
  {
    printf("sequence display extension (byte %d)\n",(pos>>3)-4);
    if (verbose>1)
    {
      printf("  video_format=%d\n",video_format);
      printf("  colour_description=%d\n",colour_description);
      if (colour_description)
      {
        printf("    colour_primaries=%d\n",colour_primaries);
        printf("    transfer_characteristics=%d\n",transfer_characteristics);
        printf("    matrix_coefficients=%d\n",matrix_coefficients);
      }
      printf("  display_horizontal_size=%d\n",display_horizontal_size);
      printf("  display_vertical_size=%d\n",display_vertical_size);
    }
  }
}


/* decode quant matrix entension */

static void quant_matrix_extension()
{
  int i;
  int load_intra_quantiser_matrix, load_non_intra_quantiser_matrix;
  int load_chroma_intra_quantiser_matrix;
  int load_chroma_non_intra_quantiser_matrix;
  int pos;

  pos = ld->bitcnt;

  if (load_intra_quantiser_matrix = getbits(1))
  {
    for (i=0; i<64; i++)
    {
      ld->chroma_intra_quantizer_matrix[zig_zag_scan[i]]
      = ld->intra_quantizer_matrix[zig_zag_scan[i]]
      = getbits(8);
    }
  }

  if (load_non_intra_quantiser_matrix = getbits(1))
  {
    for (i=0; i<64; i++)
    {
      ld->chroma_non_intra_quantizer_matrix[zig_zag_scan[i]]
      = ld->non_intra_quantizer_matrix[zig_zag_scan[i]]
      = getbits(8);
    }
  }

  if (load_chroma_intra_quantiser_matrix = getbits(1))
  {
    for (i=0; i<64; i++)
      ld->chroma_intra_quantizer_matrix[zig_zag_scan[i]] = getbits(8);
  }

  if (load_chroma_non_intra_quantiser_matrix = getbits(1))
  {
    for (i=0; i<64; i++)
      ld->chroma_non_intra_quantizer_matrix[zig_zag_scan[i]] = getbits(8);
  }

  if (verbose>0)
  {
    printf("quant matrix extension (byte %d)\n",(pos>>3)-4);
    printf("  load_intra_quantiser_matrix=%d\n",
      load_intra_quantiser_matrix);
    printf("  load_non_intra_quantiser_matrix=%d\n",
      load_non_intra_quantiser_matrix);
    printf("  load_chroma_intra_quantiser_matrix=%d\n",
      load_chroma_intra_quantiser_matrix);
    printf("  load_chroma_non_intra_quantiser_matrix=%d\n",
      load_chroma_non_intra_quantiser_matrix);
  }
}


/* decode sequence scalable extension */

static void sequence_scalable_extension()
{
  int layer_id;
  int pos;

  pos = ld->bitcnt;
  ld->scalable_mode = getbits(2) + 1; /* add 1 to make SC_DP != SC_NONE */
  layer_id = getbits(4);

  if (ld->scalable_mode==SC_SPAT)
  {
    llw = getbits(14); /* lower_layer_prediction_horizontal_size */
    flushbits(1);
    llh = getbits(14); /* lower_layer_prediction_vertical_size */
    hm = getbits(5);
    hn = getbits(5);
    vm = getbits(5);
    vn = getbits(5);
  }

  if (ld->scalable_mode==SC_TEMP)
    error("temporal scalability not implemented\n");

  if (verbose>0)
  {
    printf("sequence scalable extension (byte %d)\n",(pos>>3)-4);
    if (verbose>1)
    {
      printf("  scalable_mode=%d\n",ld->scalable_mode-1);
      printf("  layer_id=%d\n",layer_id);
      if (ld->scalable_mode==SC_SPAT)
      {
        printf("    lower_layer_prediction_horiontal_size=%d\n",llw);
        printf("    lower_layer_prediction_vertical_size=%d\n",llh);
        printf("    horizontal_subsampling_factor_m=%d\n",hm);
        printf("    horizontal_subsampling_factor_n=%d\n",hn);
        printf("    vertical_subsampling_factor_m=%d\n",vm);
        printf("    vertical_subsampling_factor_n=%d\n",vn);
      }
    }
  }
}


/* decode picture display extension */

static void picture_display_extension()
{
  int i,n;
  short frame_centre_horizontal_offset[3];
  short frame_centre_vertical_offset[3];
  int pos;

  pos = ld->bitcnt;

  if (prog_seq || pict_struct!=FRAME_PICTURE)
    n = 1;
  else
    n = repeatfirst ? 3 : 2;

  for (i=0; i<n; i++)
  {
    frame_centre_horizontal_offset[i] = (short)getbits(16);
    flushbits(1);
    frame_centre_vertical_offset[i] = (short)getbits(16);
    flushbits(1);
  }

  if (verbose>0)
  {
    printf("picture display extension (byte %d)\n",(pos>>3)-4);
    if (verbose>1)
    {
      for (i=0; i<n; i++)
      {
        printf("  frame_centre_horizontal_offset[%d]=%d\n",i,
          frame_centre_horizontal_offset[i]);
        printf("  frame_centre_vertical_offset[%d]=%d\n",i,
          frame_centre_vertical_offset[i]);
      }
    }
  }
}


/* decode picture coding extension */

static void picture_coding_extension()
{
  int chroma_420_type, composite_display_flag;
  int v_axis, field_sequence, sub_carrier, burst_amplitude, sub_carrier_phase;
  int pos;

  pos = ld->bitcnt;

  h_forw_r_size = getbits(4) - 1;
  v_forw_r_size = getbits(4) - 1;
  h_back_r_size = getbits(4) - 1;
  v_back_r_size = getbits(4) - 1;
  dc_prec = getbits(2);
  pict_struct = getbits(2);
  topfirst = getbits(1);
  frame_pred_dct = getbits(1);
  conceal_mv = getbits(1);
  ld->qscale_type = getbits(1);
  intravlc = getbits(1);
  ld->altscan = getbits(1);
  repeatfirst = getbits(1);
  chroma_420_type = getbits(1);
  prog_frame = getbits(1);
  composite_display_flag = getbits(1);
  if (composite_display_flag)
  {
    v_axis = getbits(1);
    field_sequence = getbits(3);
    sub_carrier = getbits(1);
    burst_amplitude = getbits(7);
    sub_carrier_phase = getbits(8);
  }

  if (verbose>0)
  {
    printf("picture coding extension (byte %d)\n",(pos>>3)-4);
    if (verbose>1)
    {
      printf("  forward_horizontal_f_code=%d\n",h_forw_r_size+1);
      printf("  forward_vertical_f_code=%d\n",v_forw_r_size+1);
      printf("  backward_horizontal_f_code=%d\n",h_back_r_size+1);
      printf("  backward_vertical_f_code=%d\n",v_back_r_size+1);
      printf("  intra_dc_precision=%d\n",dc_prec);
      printf("  picture_structure=%d\n",pict_struct);
      printf("  top_field_first=%d\n",topfirst);
      printf("  frame_pred_frame_dct=%d\n",frame_pred_dct);
      printf("  concealment_motion_vectors=%d\n",conceal_mv);
      printf("  q_scale_type=%d\n",ld->qscale_type);
      printf("  intra_vlc_format=%d\n",intravlc);
      printf("  alternate_scan=%d\n",ld->altscan);
      printf("  repeat_first_field=%d\n",repeatfirst);
      printf("  chroma_420_type=%d\n",chroma_420_type);
      printf("  progressive_frame=%d\n",prog_frame);
      printf("  composite_display_flag=%d\n",composite_display_flag);
      if (composite_display_flag)
      {
        printf("    v_axis=%d\n",v_axis);
        printf("    field_sequence=%d\n",field_sequence);
        printf("    sub_carrier=%d\n",sub_carrier);
        printf("    burst_amplitude=%d\n",burst_amplitude);
        printf("    sub_carrier_phase=%d\n",sub_carrier_phase);
      }
    }
  }
}


/* decode picture spatial scalable extension */

static void picture_spatial_scalable_extension()
{
  int pos;

  pos = ld->bitcnt;

  ld->pict_scal = 1; /* use spatial scalability in this picture */

  lltempref = getbits(10);
  flushbits(1);
  llx0 = getbits(15);
  if (llx0>=16384)
    llx0-= 32768;
  flushbits(1);
  lly0 = getbits(15);
  if (lly0>=16384)
    lly0-= 32768;
  stwc_table_index = getbits(2);
  llprog_frame = getbits(1);
  llfieldsel = getbits(1);
  if (verbose>0)
  {
    printf("picture spatial scalable extension (byte %d)\n",(pos>>3)-4);
    if (verbose>1)
    {
      printf("  lower_layer_temporal_reference=%d\n",lltempref);
      printf("  lower_layer_horizontal_offset=%d\n",llx0);
      printf("  lower_layer_vertical_offset=%d\n",lly0);
      printf("  spatial_temporal_weight_code_table_index=%d\n",
        stwc_table_index);
      printf("  lower_layer_progressive_frame=%d\n",llprog_frame);
      printf("  lower_layer_deinterlaced_field_select=%d\n",llfieldsel);
    }
  }
}


/* decode picture temporal scalable extension
 *
 * not implemented
 */

static void picture_temporal_scalable_extension()
{
  error("temporal scalability not supported\n");
}


/* decode extra bit information */

static void ext_bit_info()
{
  while (getbits1())
    flushbits(8);
}