gethdr.cc

ac3的解码程序

/*
  File: gethdr.cc

*/

#pragma implementation

#include <stdio.h>
#include <fstream.h>
#include <sys/time.h>

#include "athread.hh"

#include "error.hh"
#include "debug.hh"
#include "util.hh"

#include "sync.hh"
#include "mpeg2const.hh"
#include "mpeg2buff.hh"

#include "videoconst.hh"
#include "display.hh"
#include "idct.hh"
#include "vstream.hh"
#include "layerdata.hh"
#include "global.hh"

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

int LayerData::getheader(){
  unsigned int code;
  static int found_seqhdr=False; 
  // a sequence header should be found before returning from `getheader' the
  // first time (this is to set horizontal/vertical size properly)

  while (1){
    // look for startcode
    code=input->startcode();
    input->flushbits(32);
    switch (code){
    case Sequence_start_code: 
      TRACER("sequence start code");
      found_seqhdr=True;
      getseqhdr();  
      ext_user_data();
      break;
    case Gop_start_code:
      TRACER("gop start code"); 
      getgophdr();
      ext_user_data();
      break;
    case Picture_start_code:
      TRACER("picture start code");
      getpicturehdr();
      ext_user_data();
      if (found_seqhdr) return 1;
      break;
    case Sequence_end_code:
      TRACER("sequence end code");
      return 0;
    default:
      if (!quiet && framerate==0)
        fprintf(stderr,"Unexpected startcode %08x (ignored)\n", code);
      break;
    }
  }
  return 0;
}

// decode sequence header

void LayerData::getseqhdr(){
  TRACER("void LayerData::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=0;
  if (verbose>0)
    pos = input->getposition();

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

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

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

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

    chroma_non_intra_quantizer_matrix[i] =
      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);
    }
  }
}


/* decode group of pictures header */

void LayerData::getgophdr(){
  int drop_flag, hour, minute, sec, frame, closed_gop, broken_link;
  int pos=0;
  if (verbose>0)
    pos = input->getposition();

  drop_flag = input->getbits(1);
  hour = input->getbits(5);
  minute = input->getbits(6);
  input->flushbits(1);
  sec = input->getbits(6);
  frame = input->getbits(6);
  closed_gop = input->getbits(1);
  broken_link = input->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);
    }
  }
}


/* decode picture header */

void LayerData::getpicturehdr(){
  int temp_ref, vbv_delay;
  int pos=0;
  if (verbose>0)
    pos = input->getposition();

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

  temp_ref = input->getbits(10);
  pict_type = input->getbits(3);
  vbv_delay = input->getbits(16);
  if (pict_type==P_TYPE || pict_type==B_TYPE){
    full_forw = input->getbits(1);
    forw_r_size = input->getbits(3) - 1;
  }
  if (pict_type==B_TYPE){
    full_back = input->getbits(1);
    back_r_size = input->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);
      }
    }
  }

  // get extra bit picture
  while (input->getbits(1)) input->flushbits(8);
}

/* decode slice header */

int LayerData::getslicehdr(){
  int slice_vertical_position_extension, intra_slice;
  int pos=0;
  if (verbose>0)
    pos = input->getposition();

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

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

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

  if (input->getbits(1)){
    intra_slice = input->getbits(1);
    input->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 (mpeg2 && vertical_size>2800)
        printf("  slice_vertical_position_extension=%d\n",slice_vertical_position_extension);
      if (scalable_mode==SC_DP)
        printf("  priority_breakpoint=%d\n",pri_brk);
      printf("  quantizer_scale_code=%d\n",qs);
    }
  }
  return slice_vertical_position_extension;
}


/* decode extension and user data */

void LayerData::ext_user_data(){
  int code=input->startcode();
  while (code==Ext_start_code || code==User_start_code){
    input->flushbits(32);  
    if (code==Ext_start_code){
      int ext_ID = input->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;
      }
    }
    else {
      if (verbose) printf("user data\n");
    }
    code=input->startcode();
  }
}


/* decode sequence extension */

void LayerData::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=0;
  if (verbose>0)
    pos = input->getposition();
  mpeg2 = 1;
  scalable_mode = SC_NONE; /* unless overwritten by seq. scal. ext. */
  prof_lev = input->getbits(8);