lencod.c

H.264的JM源码93a版本

  fprintf(p_stat_frm, " %5d|",(stats->b8_mode_0_use [B_SLICE][0]+stats->b8_mode_0_use [B_SLICE][1]) - (last_b8_mode_0[B_SLICE][0]+last_b8_mode_0[B_SLICE][1]));
  fprintf(p_stat_frm, " %5d|",stats->b8_mode_0_use [B_SLICE][1] - last_b8_mode_0[B_SLICE][1]);
  fprintf(p_stat_frm, " %5d|",stats->b8_mode_0_use [B_SLICE][0] - last_b8_mode_0[B_SLICE][0]);
  fprintf(p_stat_frm, " %5d|",stats->mode_use[B_SLICE][4   ] - last_mode_use[B_SLICE][4   ]);
  fprintf(p_stat_frm, " %5d|",stats->mode_use_transform_8x8[1][4]);
  fprintf(p_stat_frm, " %5d|",stats->mode_use_transform_4x4[1][4]);
  fprintf(p_stat_frm, " %5d|",stats->mode_use[B_SLICE][5   ] - last_mode_use[B_SLICE][5   ]);
  fprintf(p_stat_frm, " %5d|",stats->mode_use[B_SLICE][6   ] - last_mode_use[B_SLICE][6   ]);
  fprintf(p_stat_frm, " %5d|",stats->mode_use[B_SLICE][7   ] - last_mode_use[B_SLICE][7   ]);

  fprintf(p_stat_frm, "\n");
  
  //save the last results
  last_mode_use[I_SLICE][I4MB] = stats->mode_use[I_SLICE][I4MB];
  last_mode_use[I_SLICE][I8MB] = stats->mode_use[I_SLICE][I8MB];
  last_mode_use[I_SLICE][I16MB] = stats->mode_use[I_SLICE][I16MB];
  for(i=0; i<MAXMODE; i++)
  {
    last_mode_use[P_SLICE][i] = stats->mode_use[P_SLICE][i];
    last_mode_use[B_SLICE][i] = stats->mode_use[B_SLICE][i];
    stats->mode_use_transform_8x8[0][i] = 0;
    stats->mode_use_transform_8x8[1][i] = 0;
    stats->mode_use_transform_4x4[0][i] = 0;
    stats->mode_use_transform_4x4[1][i] = 0;
  }
//  last_b8_mode_0[P_SLICE][0] = stats->b8_mode_0_use[P_SLICE];
  last_b8_mode_0[B_SLICE][0] = stats->b8_mode_0_use[B_SLICE][0];
  last_b8_mode_0[B_SLICE][1] = stats->b8_mode_0_use[B_SLICE][1];
  
  for(i=0;i<4;i++)
    last_mode_chroma_use[i]=stats->intra_chroma_mode[i];

  frame_statistic_start = 0;
  fclose(p_stat_frm);
}


/*!
 ************************************************************************
 * \brief
 *    Reports the gathered information to appropriate outputs
 * \par Input:
 *    struct inp_par *inp,                                            \n
 *    struct img_par *img,                                            \n
 *    struct stat_par *stats,                                          \n
 *    struct stat_par *stats                                           \n
 *
 * \par Output:
 *    None
 ************************************************************************
 */
void report()
{
  int bit_use[NUM_PIC_TYPE][2] ;
  int i,j;
  char name[20];
  int total_bits;
  float frame_rate;
  float mean_motion_info_bit_use[2];

#ifndef WIN32
  time_t now;
  struct tm *l_time;
  char string[1000];
#else
  char timebuf[128];
#endif
  bit_use[I_SLICE][0] = Iframe_ctr;
  bit_use[P_SLICE][0] = max(Pframe_ctr,1);
  bit_use[B_SLICE][0] = Bframe_ctr;

  //  Accumulate bit usage for inter and intra frames
  for (j=0;j<NUM_PIC_TYPE;j++)
  {
    bit_use[j][1] = 0;
  }

  for (j=0;j<NUM_PIC_TYPE;j++)
  {
    for(i=0; i<MAXMODE; i++)
      bit_use[j][1] += stats->bit_use_mode    [j][i]; 

    bit_use[j][1]+=stats->bit_use_header[j];
    bit_use[j][1]+=stats->bit_use_mb_type[j];
    bit_use[j][1]+=stats->tmp_bit_use_cbp[j];
    bit_use[j][1]+=stats->bit_use_coeffY[j];
    bit_use[j][1]+=stats->bit_use_coeffC[j];
    bit_use[j][1]+=stats->bit_use_delta_quant[j];
    bit_use[j][1]+=stats->bit_use_stuffingBits[j];
  }

  frame_rate = (img->framerate *(float)(stats->successive_Bframe + 1)) / (float) (input->jumpd+1);

//! Currently adding NVB bits on P rate. Maybe additional stats info should be created instead and added in log file
  stats->bitrate_I = (stats->bit_ctr_I)*(frame_rate)/(float) (input->no_frames + Bframe_ctr);
  stats->bitrate_P = (stats->bit_ctr_P)*(frame_rate)/(float) (input->no_frames + Bframe_ctr);
  stats->bitrate_B = (stats->bit_ctr_B)*(frame_rate)/(float) (input->no_frames + Bframe_ctr);    

  fprintf(stdout,"-------------------------------------------------------------------------------\n");
  fprintf(stdout,  " Freq. for encoded bitstream       : %1.0f\n",img->framerate/(float)(input->jumpd+1));
  if(input->hadamard)
  {
    if(input->hadamardqpel)
      fprintf(stdout," Hadamard transform                : Used for QPel\n");
    else
      fprintf(stdout," Hadamard transform                : Used\n");    
  }
  else
    fprintf(stdout," Hadamard transform                : Not used\n");

  fprintf(stdout,  " Image format                      : %dx%d\n",input->img_width,input->img_height);

  if(input->intra_upd)
    fprintf(stdout," Error robustness                  : On\n");
  else
    fprintf(stdout," Error robustness                  : Off\n");
  fprintf(stdout,  " Search range                      : %d\n",input->search_range);

  fprintf(stdout,  " Total number of references        : %d\n",input->num_ref_frames);
  fprintf(stdout,  " References for P slices           : %d\n",input->P_List0_refs? input->P_List0_refs:input->num_ref_frames);
  if(stats->successive_Bframe != 0)
  {
    fprintf(stdout," List0 references for B slices     : %d\n",input->B_List0_refs? input->B_List0_refs:input->num_ref_frames);
    fprintf(stdout," List1 references for B slices     : %d\n",input->B_List1_refs? input->B_List1_refs:input->num_ref_frames);
  }

  fprintf(stdout,  " Total encoding time for the seq.  : %.3f sec \n",tot_time*0.001);
  fprintf(stdout,  " Total ME time for sequence        : %.3f sec \n",me_tot_time*0.001);

  // B pictures
  fprintf(stdout,  " Sequence type                     :" );

  if(stats->successive_Bframe>0 && input->PyramidCoding) 
  {
    fprintf(stdout, " Pyramid (QP: I %d, P %d, B %d) \n",
    input->qp0, input->qpN, input->qpB);
  }
  else if(stats->successive_Bframe>0) 
  {
    char seqtype[80];
    int i,j;

    strcpy (seqtype,"I");

    for (j=0;j<2;j++)
    {
      for (i=0;i<stats->successive_Bframe;i++)
      {
        if (input->BRefPictures)
          strncat(seqtype,"-RB",max (0, (int) (79-strlen(seqtype))));
        else
          strncat(seqtype,"-B",max (0, (int) (79-strlen(seqtype))));
      }
      strncat(seqtype,"-P",max (0, (int) (79-strlen(seqtype))));
    }
    if (input->BRefPictures)
      fprintf(stdout, " %s (QP: I %d, P %d, RB %d) \n", seqtype,input->qp0, input->qpN, Clip3(0,51,input->qpB+input->qpBRSOffset));
    else
      fprintf(stdout, " %s (QP: I %d, P %d, B %d) \n", seqtype,input->qp0, input->qpN, input->qpB);
  }
  else if(stats->successive_Bframe==0 && input->sp_periodicity==0) fprintf(stdout, " IPPP (QP: I %d, P %d) \n",   input->qp0, input->qpN);

  else fprintf(stdout, " I-P-P-SP-P (QP: I %d, P %d, SP (%d, %d)) \n",  input->qp0, input->qpN, input->qpsp, input->qpsp_pred);

  // report on entropy coding  method
  if (input->symbol_mode == UVLC)
    fprintf(stdout," Entropy coding method             : CAVLC\n");
  else
    fprintf(stdout," Entropy coding method             : CABAC\n");

  fprintf(stdout,  " Profile/Level IDC                 : (%d,%d)\n",input->ProfileIDC,input->LevelIDC);
#ifdef _FULL_SEARCH_RANGE_
  if (input->full_search == 2)
    fprintf(stdout," Search range restrictions         : none\n");
  else if (input->full_search == 1)
    fprintf(stdout," Search range restrictions         : older reference frames\n");
  else
    fprintf(stdout," Search range restrictions         : smaller blocks and older reference frames\n");
#endif

  if (input->rdopt)
    fprintf(stdout," RD-optimized mode decision        : used\n");
  else
    fprintf(stdout," RD-optimized mode decision        : not used\n");

  switch(input->partition_mode)
    {
    case PAR_DP_1:
      fprintf(stdout," Data Partitioning Mode            : 1 partition \n");
      break;
    case PAR_DP_3:
      fprintf(stdout," Data Partitioning Mode            : 3 partitions \n");
      break;
    default:
      fprintf(stdout," Data Partitioning Mode            : not supported\n");
      break;
    }

    switch(input->of_mode)
    {
    case PAR_OF_ANNEXB:
      fprintf(stdout," Output File Format                : H.264 Bit Stream File Format \n");
      break;
    case PAR_OF_RTP:
      fprintf(stdout," Output File Format                : RTP Packet File Format \n");
      break;
    default:
      fprintf(stdout," Output File Format                : not supported\n");
      break;
    }
  // Residue Color Transform
  if(input->residue_transform_flag)
    fprintf(stdout," Residue Color Transform           : used\n");
  else
    fprintf(stdout," Residue Color Transform           : not used\n");


  fprintf(stdout,"------------------ Average data all frames  -----------------------------------\n");
  fprintf(stdout," SNR Y(dB)                         : %5.2f\n",snr->snr_ya);
  fprintf(stdout," SNR U(dB)                         : %5.2f\n",snr->snr_ua);
  fprintf(stdout," SNR V(dB)                         : %5.2f\n",snr->snr_va);
  
  if(Bframe_ctr!=0)
  {
    fprintf(stdout, " Total bits                        : %d (I %5d, P %5d, B %d NVB %d) \n",
      total_bits=stats->bit_ctr_P + stats->bit_ctr_I + stats->bit_ctr_B + stats->bit_ctr_parametersets, stats->bit_ctr_I, stats->bit_ctr_P, stats->bit_ctr_B,stats->bit_ctr_parametersets);
    
    frame_rate = (img->framerate *(float)(stats->successive_Bframe + 1)) / (float) (input->jumpd+1);
    stats->bitrate= ((float) total_bits * frame_rate)/((float) (input->no_frames + Bframe_ctr));
    
    fprintf(stdout, " Bit rate (kbit/s)  @ %2.2f Hz     : %5.2f\n", frame_rate, stats->bitrate/1000);
    
  }
  else if (input->sp_periodicity==0)
  {
    fprintf(stdout, " Total bits                        : %d (I %5d, P %5d, NVB %d) \n",
      total_bits=stats->bit_ctr_P + stats->bit_ctr_I + stats->bit_ctr_parametersets, stats->bit_ctr_I, stats->bit_ctr_P, stats->bit_ctr_parametersets);
    
    
    frame_rate = img->framerate / ( (float) (input->jumpd + 1) );
    stats->bitrate= ((float) total_bits * frame_rate)/((float) input->no_frames );
    
    fprintf(stdout, " Bit rate (kbit/s)  @ %2.2f Hz     : %5.2f\n", frame_rate, stats->bitrate/1000);
  }
  else
  {
    fprintf(stdout, " Total bits                        : %d (I %5d, P %5d, NVB %d) \n",
      total_bits=stats->bit_ctr_P + stats->bit_ctr_I + stats->bit_ctr_parametersets, stats->bit_ctr_I, stats->bit_ctr_P, stats->bit_ctr_parametersets);
    
    
    frame_rate = img->framerate / ( (float) (input->jumpd + 1) );
    stats->bitrate= ((float) total_bits * frame_rate)/((float) input->no_frames );
    
    fprintf(stdout, " Bit rate (kbit/s)  @ %2.2f Hz     : %5.2f\n", frame_rate, stats->bitrate/1000);
  }
  
  fprintf(stdout, " Bits to avoid Startcode Emulation : %d \n", stats->bit_ctr_emulationprevention);
  fprintf(stdout, " Bits for parameter sets           : %d \n", stats->bit_ctr_parametersets);
  
  fprintf(stdout,"-------------------------------------------------------------------------------\n");
  fprintf(stdout,"Exit JM %s encoder ver %s ", JM, VERSION);
  fprintf(stdout,"\n");

  // status file
  if ((p_stat=fopen("stats.dat","wt"))==0)
  {
    snprintf(errortext, ET_SIZE, "Error open file %s", "stats.dat");
    error(errortext, 500);
  }
  fprintf(p_stat," -------------------------------------------------------------- \n");
  fprintf(p_stat,"  This file contains statistics for the last encoded sequence   \n");
  fprintf(p_stat," -------------------------------------------------------------- \n");
  fprintf(p_stat,   " Sequence                     : %s\n",input->infile);
  fprintf(p_stat,   " No.of coded pictures         : %4d\n",input->no_frames+Bframe_ctr);
  fprintf(p_stat,   " Freq. for encoded bitstream  : %4.0f\n",frame_rate);

  fprintf(p_stat,   " I Slice Bitrate(kb/s)        : %6.2f\n", stats->bitrate_I/1000);
  fprintf(p_stat,   " P Slice Bitrate(kb/s)        : %6.2f\n", stats->bitrate_P/1000);
  // B pictures
  if(stats->successive_Bframe != 0)
    fprintf(p_stat,   " B Slice Bitrate(kb/s)        : %6.2f\n", stats->bitrate_B/1000);
  fprintf(p_stat,   " Total Bitrate(kb/s)          : %6.2f\n", stats->bitrate/1000);

  if(input->hadamard)
  {
    if(input->hadamardqpel)
      fprintf(p_stat," Hadamard transform           : Used for QPel\n");
    else
      fprintf(p_stat," Hadamard transform           : Used\n");
  }  
  else
    fprintf(p_stat," Hadamard transform           : Not used\n");

  fprintf(p_stat,  " Image format                 : %dx%d\n",input->img_width,input->img_height);

  if(input->intra_upd)
    fprintf(p_stat," Error robustness             : On\n");
  else
    fprintf(p_stat," Error robustness             : Off\n");

  fprintf(p_stat,  " Search range                 : %d\n",input->search_range);

  fprintf(p_stat,   " Total number of references   : %d\n",input->num_ref_frames);
  fprintf(p_stat,   " References for P slices      : %d\n",input->P_List0_refs? input->P_List0_refs:input->num_ref_frames);
  if(stats->successive_Bframe != 0)
  {
    fprintf(p_stat, " List0 refs for B slices      : %d\n",input->B_List0_refs? input->B_List0_refs:input->num_ref_frames);
    fprintf(p_stat, " List1 refs for B slices      : %d\n",input->B_List1_refs? input->B_List1_refs:input->num_ref_frames);
  }

  if (input->symbol_mode == UVLC)
    fprintf(p_stat,   " Entropy coding method        : CAVLC\n");
  else
    fprintf(p_stat,   " Entropy coding method        : CABAC\n");

    fprintf(p_stat,   " Profile/Level IDC            : (%d,%d)\n",input->ProfileIDC,input->LevelIDC);
  if(input->MbInterlace)
    fprintf(p_stat, " MB Field Coding : On \n");

#ifdef _FULL_SEARCH_RANGE_
  if (input->full_search == 2)
    fprintf(p_stat," Search range restrictions    : none\n");
  else if (input->full_search == 1)
    fprintf(p_stat," Search range restrictions    : older reference frames\n");
  else
    fprintf(p_stat," Search range restrictions    : smaller blocks and older reference frames\n");
#endif
  if (input->rdopt)
    fprintf(p_stat," RD-optimized mode decision   : used\n");
  else
    fprintf(p_stat," RD-optimized mode decision   : not used\n");

  fprintf(p_stat," ---------------------|----------------|---------------|\n");
  fprintf(p_stat,"     Item             |     Intra      |   All frames  |\n");
  fprintf(p_stat," ---------------------|----------------|---------------|\n");
  fprintf(p_stat," SNR Y(dB)            |");
  fprintf(p_stat," %5.2f          |",snr->snr_y1);
  fprintf(p_stat," %5.2f         |\n",snr->snr_ya);
  fprintf(p_stat," SNR U/V (dB)         |");