main.c

H.263的压缩算法

    /* P_frameskip = (successive_B_frames) ? (successive_B_frames+1)*fixed_frameskip : frameskip; */
    P_frameskip = frameskip;

    prev_pict_type = pic->picture_coding_type;
  }
  /***** end of main loop *****/

  /* Closing files */
  fclose (streamfile);
  if (trace) 
  {
    fclose(tf);
  }

  /* Print total results */
  total_frames_passed = frame_no - start - first_frameskip;

  fprintf(stdout,"\n==== TOTAL ====\n");
  fprintf(stdout,"for %d images of %s\n", frames, seqfilename);

  if (frames != 0) {
    if (write_repeated) 
      fprintf(stdout,"Frames saved : %d predicted + %d intra\n",
              total_frames_passed,icopies);

    fprintf(stdout,"--------------\n");

    if ((pb_frames||improved_pb_frames) && bframes != 0) {
      fprintf(stdout,"SNR for %d B-frames:\n",bframes);
      PrintSNR(pb_res,bframes);
    }

    if (successive_B_frames && Bframes != 0) {
      fprintf(stdout,"SNR for %d true B-frames:\n",Bframes);
      PrintSNR(b_res,Bframes);
    }

    if (scalability_mode && EIframes != 0) {
      fprintf(stdout,"SNR for %d EI frames:\n",EIframes);
      PrintSNR(ei_res,EIframes);
    }

    if (scalability_mode && EPframes != 0) {
      fprintf(stdout,"SNR for %d EP frames:\n",EPframes);
      PrintSNR(ep_res,EPframes);
    }

    fprintf(stdout,"SNR for %d P-frames:\n",pframes);
    PrintSNR(inter_res,pframes);

    if ((pb_frames||improved_pb_frames) && bframes != 0) 
    {	
      fprintf(stdout,"SNR for total %d frames:\n",pframes+bframes);
      fprintf(stdout,"SNR_Y  : %.2f\n", (pb_res->SNR_l+inter_res->SNR_l)/(bframes+pframes));
      fprintf(stdout,"SNR_Cb : %.2f\n", (pb_res->SNR_Cb+inter_res->SNR_Cb)/(bframes+pframes));
      fprintf(stdout,"SNR_Cr : %.2f\n", (pb_res->SNR_Cr+inter_res->SNR_Cr)/(bframes+pframes));
      fprintf(stdout,"--------------\n");
    }

    if (successive_B_frames && Bframes != 0) 
    {	
      fprintf(stdout,"SNR for total %d frames:\n",pframes+Bframes);
      fprintf(stdout,"SNR_Y  : %.2f\n", (b_res->SNR_l+inter_res->SNR_l)/(Bframes+pframes));
      fprintf(stdout,"SNR_Cb : %.2f\n", (b_res->SNR_Cb+inter_res->SNR_Cb)/(Bframes+pframes));
      fprintf(stdout,"SNR_Cr : %.2f\n", (b_res->SNR_Cr+inter_res->SNR_Cr)/(Bframes+pframes));
      fprintf(stdout,"--------------\n");
    }

    if (scalability_mode) 
    {	
      fprintf(stdout,"SNR for total %d enhancement frames:\n",EIframes+EPframes);
      fprintf(stdout,"SNR_Y  : %.2f\n", (ei_res->SNR_l+ep_res->SNR_l)/(EIframes+EPframes));
      fprintf(stdout,"SNR_Cb : %.2f\n", (ei_res->SNR_Cb+ep_res->SNR_Cb)/(EIframes+EPframes));
      fprintf(stdout,"SNR_Cr : %.2f\n", (ei_res->SNR_Cr+ep_res->SNR_Cr)/(EIframes+EPframes));
      fprintf(stdout,"--------------\n");
    }

    fprintf(stdout,"Bit totals for %d(%d) base layer frames:\n",frames, pframes);
    PrintResult(total_bits, pframes, frames);

    if (scalability_mode)
    {
      fprintf(stdout,"Bit totals for %d(%d) enhancement layer frames:\n",EIframes+EPframes, EPframes);
      PrintResult(scal_bits, EIframes+EPframes, EIframes+EPframes);
    }

    if (targetrate != 0 || pic->bit_rate != 0) 
      fprintf(stdout,"Original seq time: %.2f (%.2f) sec\n", 
              (total_frames_passed + first_frameskip) /
              ref_frame_rate * orig_frameskip,
              total_frames_passed /
              ref_frame_rate * orig_frameskip);

    fprintf(stdout,"Mean quantizer for inter frames : %.2f\n", inter_res->QP_mean/pframes);

    if (scalability_mode)
    {
      fprintf(stdout,"Mean quantizer for enhancement frames : %.2f\n", 
              scal_res->QP_mean/(EIframes+EPframes));
    }

    if (successive_B_frames)
    {
      fprintf(stdout,"Mean quantizer for enhancement B frames: %.2f\n",
              b_res->QP_mean/(Bframes));
    }

#if 0
    fprintf(stdout,"Total frames     : %3d (%3d)\n", 
            total_frames_passed + first_frameskip,
            total_frames_passed);
#endif

    fprintf(stdout,"Encoded frames   : I: %3d P: %3d\n", 
            Iframes,
            pframes);

    if (scalability_mode)
    {
      fprintf(stdout,"Encoded frames   : %3d (%3d)\n", 
              EIframes + EPframes,
              EPframes);
    }

    if (successive_B_frames)
    {
      fprintf(stdout,"Encoded B frames : %3d (%3d)\n",
              Bframes);
    }

    mean_frame_rate = frames  / (float)total_frames_passed * 
      ref_frame_rate / (float)orig_frameskip;

    fprintf(stdout,"Mean frame rate  : %.2f Hz\n", mean_frame_rate);

    if (targetrate != 0)
      fprintf(stdout,"Target bit rate  : %.2f kbit/sec\n", 
              targetrate/1000.0);

    fprintf(stdout,"Obtained bit rate: %.2f (%.2f) kbit/sec\n",
            (total_bits->total + intra_bits->total) / 
            ((total_frames_passed + first_frameskip) / 
             ref_frame_rate * orig_frameskip)/1000.0,
            (total_bits->total / (float)frames) * mean_frame_rate/1000.0);

    if (scalability_mode)
    {
      fprintf(stdout,"Obtained enhancement layer bit rate: %.2f kbit/sec\n",
              (scal_bits->total) / 
              ((total_frames_passed + first_frameskip) / 
               ref_frame_rate * orig_frameskip)/1000.0);
    }

    if (successive_B_frames)
    {
      fprintf(stdout,"Obtained enhancement B layer bit rate: %.2f kbit/sec\n",
              (b_bits->total) / ((total_frames_passed + first_frameskip) /
              ref_frame_rate * orig_frameskip)/1000.0);
    }
    
    fprintf(stdout,"============================================\n");

  }
#if 0
  fprintf(stdout,"Total number of bits: %d (%d)\n",
          total_bits->total + intra_bits->total,
          (total_bits->total + intra_bits->total) / 8);
#endif

  /* Free memory */
  free(streamname);
  free(seqfilename);
  free(outputfile);
  free(tracefile);
  free(enhance_seqfilename);

  if (pb_frames || improved_pb_frames)
  {
    free(pb_bits);
    free(pb_res);
  }
  free (pic);

  free(bits);
  free (res);

  free(total_bits);
  free(total_res);

  free(intra_bits);
  free(intra_res);

  free(inter_bits);
  free(inter_res);

  if (successive_B_frames)
  {
    FreeImage(prev_P_image);
    FreeImage(prev_P_recon);
    FreeImage(next_P_image);
    FreeImage(next_P_recon);
    free(b_bits);
    free(b_res);
  }

  if (scalability_mode)
  {
    FreeImage(prev_enhancement_image);
    FreeImage(prev_enhancement_recon);
    free(scal_bits);
    free(scal_res);
  }
  else if (PCT_B != prev_pict_type)
  {
    FreeImage(curr_image);
    FreeImage(curr_recon);
  }
  
  exit(0);
}

/**********************************************************************
 *
 *	Name:        Help
 *	Description:        Prints usage
 *	
 *
 ***********************************************************************/

void Help()
{
  fprintf(stdout,"Usage:\tmn [options] -i <filename> [more options]\n");
  fprintf(stdout,"Options:\n");
  fprintf(stdout,"\t-i <filename> original sequence [required parameter]\n");
  fprintf(stdout,"\t-o <filename> reconstructed frames [%s]\n",
          DEF_OUTFILENAME);
  fprintf(stdout,"\t-B <filename> filename for bitstream [%s]\n",
          DEF_STREAMNAME);
  fprintf(stdout,"\t-a <n> image to start at [%d]\n",
          DEF_START_FRAME);
  fprintf(stdout,"\t-b <n> image to stop at [%d]\n",
          DEF_STOP_FRAME);
  fprintf(stdout,"\t-x <n> (<pels> <lines>) coding format [%d]\n",DEF_CODING_FORMAT);
  fprintf(stdout,"\t       n=1: SQCIF n=2: QCIF n=3: CIF n=4: 4CIF n=5: 16CIF  n=6:  Custom (12:11 PAR)\n");
  fprintf(stdout,"\t           128x96   176x144  352x288   704x576  1408x1152  pels x lines\n");
  fprintf(stdout,"\t-s <n> (0..15) integer pel search window [%d]\n",
          DEF_SEEK_DIST);
  fprintf(stdout,"\t-q <n> (1..31) quantization parameter QP [%d]\n",
          DEF_INTER_QUANT);
  fprintf(stdout,"\t-A <n> (1..31) QP for first frame [%d]\n",
          DEF_INTRA_QUANT);
  fprintf(stdout,"\t-r <n> target bitrate in bits/s, default is variable bitrate\n");
  fprintf(stdout,"\t -C <n> Rate control method [%d]\n",
          DEF_RC_METHOD);
  fprintf(stdout,"\t-k <n> frames to skip between each encoded frame [%d]\n",
          DEF_FRAMESKIP);
  fprintf(stdout,"\t-Z <n> reference frame rate (25 or 30 fps) [%.1f]\n",
          DEF_REF_FRAME_RATE);
  fprintf(stdout,"\t-l <n> frames skipped in original compared to reference frame rate [%d]\n", DEF_ORIG_SKIP);
  fprintf(stdout,"\t-e <n> original sequence has n bytes header [%d]\n",
          DEF_HEADERLENGTH);
  fprintf(stdout,"\t-g <n> insert sync after each n GOB (slice) [%d]\n",
          DEF_INSERT_SYNC);
  fprintf(stdout,"\t       zero above means no extra syncs inserted\n");
  fprintf(stdout,"\t-w write difference image to file \"%s\" [%s]\n",
          DEF_DIFFILENAME,
          DEF_WRITE_DIFF ? "ON" : "OFF");
  fprintf(stdout,"\t-m write repeated reconstructed frames to disk [%s]\n",
          DEF_WRITE_REPEATED ? "ON" : "OFF");
  fprintf(stdout,"\t-t write trace to tracefile trace.intra/trace [%s]\n",
          DEF_WRITE_TRACE ? "ON" : "OFF");
  fprintf(stdout,"\t-f <n> force an Intra frame every <n> frames [%d]\n",
          DEF_FORCE_INTRA);
  fprintf(stdout,"\t-j <n> force an Intra MB refresh rate every <n> macroblocks [%d]\n",
          DEF_INTRA_MB_REFRESH);
  fprintf(stdout,"\t-D <n> use unrestricted motion vector mode (annex D) [%s]\n",
          DEF_UMV_MODE ? "ON" : "OFF");
  fprintf(stdout,"\t       n=1: H.263 n=2: H.263+ n=3: H.263+ unlimited range\n");
  fprintf(stdout,"\t-E use syntax-based arithmetic coding (annex E) [%s]\n",
          DEF_SAC_MODE ? "ON" : "OFF");
  fprintf(stdout,"\t-F use advanced prediction mode (annex F) [%s]\n",
          DEF_ADV_MODE ? "ON" : "OFF");
  fprintf(stdout,"\t-G use PB-frames (annex G) [%s]\n",
          DEF_PBF_MODE ? "ON" : "OFF");
  fprintf(stdout,"\t   -U <n> (0..3) BQUANT parameter [%d]\n",DEF_BQUANT);
  fprintf(stdout,"\t-I use advanced intra coding mode (annex I) [%s]\n",
          DEF_AIC_MODE ? "ON" : "OFF");
  fprintf(stdout,"\t-J use deblocking filter (annex J) [%s]\n",
          DEF_DF_MODE ? "ON" : "OFF");
/*fprintf(stdout,"\t-K use slice structure (annex K) [%s]\n",
          DEF_SS_MODE ? "ON" : "OFF"); */
  fprintf(stdout,"\t-M use improved PB-frames (annex M) [%s]\n",
          DEF_PBF_MODE ? "ON" : "OFF");

  fprintf(stdout,"\t-N <m> <n> use reference picture selection mode (annex N) [%s] \n",
          DEF_RPS_MODE ? "ON" : "OFF");
  fprintf(stdout,"\t   VRC with <m> threads and <n> pictures per thread [m = %d, n = %d] \n",
          NUMBER_OF_THREADS, FRAMES_PER_THREAD); 
  fprintf(stdout,"\t-c <n> frames to select number of true B pictures between P pictures (annex O) [%d]\n",
          DEF_TEMP_SCAL);
  fprintf(stdout,"\t-d <n> to set QP for true B pictures (annex O) [%d]\n",
          DEF_TRUE_B_QUANT);
  fprintf(stdout,"\t-i <filename> enhancement layer sequence\n");
  fprintf(stdout,"\t-u <n> to select SNR or spatial scalability mode (annex O) [%s]\n",
          DEF_SNR_SPAT_SCAL_MODE? "ON" : "OFF");
  fprintf(stdout,"\t       n=1: SNR n=3: SPATIAL(horiz) n=5: SPATIAL(vert) n=7: SPATIAL(both)\n");
  fprintf(stdout,"\t-v <n> to set QP for enhancement layer (annex O) [%d]\n",
          DEF_EI_EP_QUANT); 
/*  fprintf(stdout,"\t-O use SNR/spatial scalability (annex O) [%s]\n",
          DEF_SNRSS_TYPE ? "ON" : "OFF");
  fprintf(stdout,"\t-P use reference picture resampling mode (annex P) [%s]\n",
          DEF_RPR_MODE ? "ON" : "OFF");
  fprintf(stdout,"\t-Q use reduced resolution update mode (annex Q) [%s]\n",
          DEF_RRU_MODE ? "ON" : "OFF");
  fprintf(stdout,"\t-R use  independently segmented decoding mode (annex R) [%s]\n",
          DEF_ISD_MODE ? "ON" : "OFF"); */
  fprintf(stdout,"\t-S use alternative inter vlc mode (annex S) [%s]\n",
          DEF_AIV_MODE ? "ON" : "OFF");
  fprintf(stdout,"\t-T use modified quantization mode (annex T) [%s]\n",
          DEF_MQ_MODE ? "ON" : "OFF");
		  
  fprintf(stdout,"\t-h Prints help\n");
  fprintf(stdout,"\n\tDefault filenames and other options in square brackets \n\tare chosen in config.h\n");
  return;
}

/**********************************************************************
 *
 *	Name:        PrintResult
 *	Description:	add bits and prints results
 *	
 *	Input:        Bits struct
 *        
 *	Returns:	
 *	Side effects:	
 *
 *	Date: 940116	Author:	[e-mail]
 *
 ***********************************************************************/


void PrintResult(Bits *bits,int num_units, int num)
{
  fprintf(stdout,"# intra   : %d\n", bits->no_intra/num_units);
  fprintf(stdout,"# inter   : %d\n", bits->no_inter/num_units);
  fprintf(stdout,"# inter4v : %d\n", bits->no_inter4v/num_units);
  fprintf(stdout,"--------------\n");
  fprintf(stdout,"Coeff_Y: %d\n", bits->Y/num);
  fprintf(stdout,"Coeff_C: %d\n", bits->C/num);
  fprintf(stdout,"Vectors: %d\n", bits->vec/num);
  fprintf(stdout,"CBPY   : %d\n", bits->CBPY/num);
  fprintf(stdout,"MCBPC  : %d\n", bits->CBPCM/num);
  fprintf(stdout,"MODB   : %d\n", bits->MODB/num);
  fprintf(stdout,"CBPB   : %d\n", bits->CBPB/num);
  fprintf(stdout,"COD    : %d\n", bits->COD/num);
  fprintf(stdout,"DQUANT : %d\n", bits->DQUANT/num);
  if (advanced_intra_coding) 
      fprintf(stdout,"INTRA_MODE: %d\n", bits->INTRA_MODE/num);
  fprintf(stdout,"header : %d\n", bits->header/num);
  fprintf(stdout,"==============\n");
  fprintf(stdout,"Total  : %d\n", bits->total/num);
  fprintf(stdout,"\n");
  return;
}

void PrintSNR(Results *res, int num)
{
  fprintf(stdout,"SNR_Y  : %.2f\n", res->SNR_l/num);
  fprintf(stdout,"SNR_Cb : %.2f\n", res->SNR_Cb/num);
  fprintf(stdout,"SNR_Cr : %.2f\n", res->SNR_Cr/num);
  fprintf(stdout,"--------------\n");
  return;
}

void InitializeCoder(Pict *pic)
{
  /* Default variable values */
  adv_pred = DEF_ADV_MODE;
  syntax_arith_coding = DEF_SAC_MODE;
  pic->unrestricted_mv_mode = DEF_UMV_MODE;
  mv_outside_frame = DEF_UMV_MODE || DEF_ADV_MODE || DEF_DF_MODE;
  long_vectors = DEF_UMV_MODE;
  pb_frames = DEF_PBF_MODE;
  
  /* h263+ options */
  improved_pb_frames = DEF_IM_PBF_MODE;
  advanced_intra_coding = DEF_AIC_MODE;
  deblocking_filter = DEF_DF_MODE;
  slice_structure = DEF_SS_MODE;
  pic->reference_picture_selection = DEF_RPS_MODE;
  number_of_threads = NUMBER_OF_THREADS;
  frames_per_thread = FRAMES_PER_THREAD;
  sync_gobs_per_frame = SYNC_GOBS_PER_FRAME;
  independent_segment_decoding = DEF_ISD_MODE;
  alternative_inter_vlc = DEF_AIV_MODE;
  modified_quantization = DEF_MQ_MODE;
  scalability_mode = DEF_SNR_SPAT_SCAL_MODE;
  reference_picture_resampling = DEF_RPR_MODE;
  reduced_resolution_update = DEF_RRU_MODE;
  successive_B_frames = DEF_TEMP_SCAL;
  b_picture_quant = DEF_TRUE_B_QUANT;
  enhancement_layer_quant = DEF_EI_EP_QUANT;
  B_pictures_to_code = 0;
  unlimited_unrestricted_motion_vectors = 0;