report.c

H.264编码实现

    fprintf(p_log, "%3d %2d %2d %2.2f %2.2f %2.2f %5" FORMAT_OFF_T  " "
      "%2.2f %2.2f %2.2f %5d "
      "%2.2f %2.2f %2.2f %5" FORMAT_OFF_T  " %5" FORMAT_OFF_T  " %.3f\n",
      params->no_frames, params->qp0, params->qpN,
      dist->metric[PSNR].avslice[I_SLICE][0],
      dist->metric[PSNR].avslice[I_SLICE][1],
      dist->metric[PSNR].avslice[I_SLICE][2],
      stats->bit_counter[I_SLICE],
      0.0,
      0.0,
      0.0,
      0,
      dist->metric[PSNR].average[0],
      dist->metric[PSNR].average[1],
      dist->metric[PSNR].average[2],
      (stats->bit_counter[I_SLICE] + stats->bit_ctr) / stats->frame_counter,
      stats->bit_counter[B_SLICE] / stats->frame_ctr[B_SLICE],
      (double) 0.001 * tot_time / (stats->frame_counter));
  }
  else
  {
    if (params->no_frames != 0)
      fprintf(p_log, "%3d %2d %2d %2.2f %2.2f %2.2f %5" FORMAT_OFF_T  " "
      "%2.2f %2.2f %2.2f %5d "
      "%2.2f %2.2f %2.2f %5" FORMAT_OFF_T  " %5d %.3f\n",
      params->no_frames, params->qp0, params->qpN,
      dist->metric[PSNR].avslice[I_SLICE][0],
      dist->metric[PSNR].avslice[I_SLICE][1],
      dist->metric[PSNR].avslice[I_SLICE][2],
      stats->bit_counter[I_SLICE],
      0.0,
      0.0,
      0.0,
      0,
      dist->metric[PSNR].average[0],
      dist->metric[PSNR].average[1],
      dist->metric[PSNR].average[2],
      (stats->bit_counter[I_SLICE] + stats->bit_ctr)/ stats->frame_counter,
      0,
      (double)0.001*tot_time/params->no_frames);
  }

  fclose(p_log);
}

/*!
 ************************************************************************
 * \brief
 *    Reports the gathered information to appropriate outputs
 * \par Input:
 *    struct inp_par *inp,                                            \n
 *    ImageParameters *img,                                            \n
 *    struct stat_par *stats,                                          \n
 *
 * \par Output:
 *    None
 ************************************************************************
 */
void report( ImageParameters *img, InputParameters *params, StatParameters *stats)
{
  int64 bit_use[NUM_SLICE_TYPES][2];
  int i,j;
  int64 total_bits;
  float frame_rate;

  bit_use[ I_SLICE][0] = stats->frame_ctr[I_SLICE];
  bit_use[ P_SLICE][0] = imax(stats->frame_ctr[P_SLICE ] + stats->frame_ctr[SP_SLICE], 1);
  bit_use[ B_SLICE][0] = imax(stats->frame_ctr[B_SLICE ], 1);
  bit_use[SP_SLICE][0] = imax(stats->frame_ctr[SP_SLICE], 1);

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

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

    bit_use[j][1] += stats->bit_use_mb_type[j];
    bit_use[j][1] += stats->bit_use_header[j];    
    bit_use[j][1] += stats->tmp_bit_use_cbp[j];
    bit_use[j][1] += stats->bit_use_coeffC[j];
    bit_use[j][1] += stats->bit_use_coeff[0][j];   
    bit_use[j][1] += stats->bit_use_coeff[1][j]; 
    bit_use[j][1] += stats->bit_use_coeff[2][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) (params->jumpd + 1);

  //! Currently adding NVB bits on P rate. Maybe additional stats info should be created instead and added in log file  
  stats->bitrate_st[ I_SLICE] = (stats->bit_counter[ I_SLICE]) * (frame_rate) / (float) (stats->frame_counter);
  stats->bitrate_st[ P_SLICE] = (stats->bit_counter[ P_SLICE]) * (frame_rate) / (float) (stats->frame_counter);
  stats->bitrate_st[ B_SLICE] = (stats->bit_counter[ B_SLICE]) * (frame_rate) / (float) (stats->frame_counter);
  stats->bitrate_st[SP_SLICE] = (stats->bit_counter[SP_SLICE]) * (frame_rate) / (float) (stats->frame_counter);

  switch (params->Verbose)
  {
  case 0:
  case 1:
  default:
    fprintf(stdout,"------------------ Average data all frames  -----------------------------------\n\n");
    break;
  case 2:
    fprintf(stdout,"------------------------------------  Average data all frames  ---------------------------------\n\n");
    break;
  }

  if (params->Verbose != 0)
  {
    DistMetric *snr     = &dist->metric[PSNR    ];
    DistMetric *sse     = &dist->metric[SSE     ];
    DistMetric *snr_rgb = &dist->metric[PSNR_RGB];
    DistMetric *sse_rgb = &dist->metric[SSE_RGB ];

    int  impix    = params->output.size_cmp[0];
    int  impix_cr = params->output.size_cmp[1];

    float csnr_y = psnr(img->max_imgpel_value_comp_sq[0], impix   , sse->average[0]);
    float csnr_u = psnr(img->max_imgpel_value_comp_sq[1], impix_cr, sse->average[1]);
    float csnr_v = psnr(img->max_imgpel_value_comp_sq[2], impix_cr, sse->average[2]);

    fprintf(stdout,  " Total encoding time for the seq.  : %.3f sec (%.2f fps)\n", tot_time*0.001, 1000.0 * (stats->frame_counter) / tot_time);
    fprintf(stdout,  " Total ME time for sequence        : %.3f sec \n\n", me_tot_time*0.001);

    fprintf(stdout," Y { PSNR (dB), cSNR (dB), MSE }   : { %5.2f, %5.2f, %5.2f }\n", 
      snr->average[0], csnr_y, sse->average[0]/impix);
    fprintf(stdout," U { PSNR (dB), cSNR (dB), MSE }   : { %5.2f, %5.2f, %5.2f }\n",
      snr->average[1], csnr_u, sse->average[1]/impix_cr);
    fprintf(stdout," V { PSNR (dB), cSNR (dB), MSE }   : { %5.2f, %5.2f, %5.2f }\n",
      snr->average[2], csnr_v, sse->average[2]/impix_cr);

    if(params->DistortionYUVtoRGB == 1)
    {
      float csnr_r = psnr(img->max_imgpel_value_comp_sq[0], impix, sse_rgb->average[0]);
      float csnr_g = psnr(img->max_imgpel_value_comp_sq[1], impix, sse_rgb->average[1]);
      float csnr_b = psnr(img->max_imgpel_value_comp_sq[2], impix, sse_rgb->average[2]);

      fprintf(stdout," R { PSNR (dB), cSNR (dB), MSE }   : { %5.2f, %5.2f, %5.2f }\n", 
        snr_rgb->average[0], csnr_r, sse_rgb->average[0]/impix);
      fprintf(stdout," G { PSNR (dB), cSNR (dB), MSE }   : { %5.2f, %5.2f, %5.2f }\n",
        snr_rgb->average[1], csnr_g, sse_rgb->average[1]/impix);
      fprintf(stdout," B { PSNR (dB), cSNR (dB), MSE }   : { %5.2f, %5.2f, %5.2f }\n",
        snr_rgb->average[2], csnr_b, sse_rgb->average[2]/impix);
    }

    if (params->Distortion[SSIM] == 1)
    {
      if(params->DistortionYUVtoRGB == 1)
      {
        fprintf(stdout," SSIM {Y, R}                       : { %5.4f, %5.4f }\n", dist->metric[SSIM].average[0], dist->metric[SSIM_RGB].average[0]);
        fprintf(stdout," SSIM {U, G}                       : { %5.4f, %5.4f }\n", dist->metric[SSIM].average[1], dist->metric[SSIM_RGB].average[1]);
        fprintf(stdout," SSIM {V, B}                       : { %5.4f, %5.4f }\n", dist->metric[SSIM].average[2], dist->metric[SSIM_RGB].average[2]);
      }
      else
      {
        fprintf(stdout," Y SSIM                            : %5.4f\n", dist->metric[SSIM].average[0]);
        fprintf(stdout," U SSIM                            : %5.4f\n", dist->metric[SSIM].average[1]);
        fprintf(stdout," V SSIM                            : %5.4f\n", dist->metric[SSIM].average[2]);
      }
    }
    if (params->Distortion[MS_SSIM] == 1)
    {
      if(params->DistortionYUVtoRGB == 1)
      {
        fprintf(stdout," MS-SSIM {Y, R}                    : { %5.4f, %5.4f }\n", dist->metric[MS_SSIM].average[0], dist->metric[MS_SSIM_RGB].average[0]);
        fprintf(stdout," MS-SSIM {U, G}                    : { %5.4f, %5.4f }\n", dist->metric[MS_SSIM].average[1], dist->metric[MS_SSIM_RGB].average[1]);
        fprintf(stdout," MS-SSIM {V, B}                    : { %5.4f, %5.4f }\n", dist->metric[MS_SSIM].average[2], dist->metric[MS_SSIM_RGB].average[2]);
      }
      else
      {
        fprintf(stdout," Y MS-SSIM                         : %5.4f\n", dist->metric[MS_SSIM].average[0]);
        fprintf(stdout," U MS-SSIM                         : %5.4f\n", dist->metric[MS_SSIM].average[1]);
        fprintf(stdout," V MS-SSIM                         : %5.4f\n", dist->metric[MS_SSIM].average[2]);
      }
    }
    fprintf(stdout,"\n");
  }
  else
    fprintf(stdout,  " Total encoding time for the seq.  : %.3f sec (%.2f fps)\n\n", tot_time*0.001, 1000.0 * (stats->frame_counter) / tot_time);

  total_bits = stats->bit_ctr_parametersets;
  for (i = 0; i < NUM_SLICE_TYPES; i++)
    total_bits += stats->bit_counter[i];

  if (stats->frame_ctr[B_SLICE] != 0)
  {
    fprintf(stdout, " Total bits                        : %" FORMAT_OFF_T  " (I %" FORMAT_OFF_T  ", P %" FORMAT_OFF_T  ", B %" FORMAT_OFF_T  " NVB %d) \n",
      total_bits,  stats->bit_counter[I_SLICE], stats->bit_counter[P_SLICE], stats->bit_counter[B_SLICE], stats->bit_ctr_parametersets);
  }
  else if (params->sp_periodicity == 0)
  {
    fprintf(stdout, " Total bits                        : %" FORMAT_OFF_T  " (I %" FORMAT_OFF_T  ", P %" FORMAT_OFF_T  ", NVB %d) \n",
      total_bits, stats->bit_counter[I_SLICE], stats->bit_counter[P_SLICE], stats->bit_ctr_parametersets);
  }
  else
  {
    fprintf(stdout, " Total bits                        : %" FORMAT_OFF_T  " (I %" FORMAT_OFF_T  ", P %" FORMAT_OFF_T  ", NVB %d) \n",
      total_bits, stats->bit_counter[I_SLICE], stats->bit_counter[P_SLICE], stats->bit_ctr_parametersets);
  }

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

  stats->bitrate= ((float) total_bits * frame_rate) / ((float) (stats->frame_counter));
  fprintf(stdout, " Bit rate (kbit/s)  @ %2.2f Hz     : %5.2f\n", frame_rate, stats->bitrate / 1000);
  
  for (i = 0; i < 5; i++)
    stats->bit_ctr_emulationprevention += stats->bit_use_stuffingBits[i];

  fprintf(stdout, " Bits to avoid Startcode Emulation : %" FORMAT_OFF_T  " \n", stats->bit_ctr_emulationprevention);
  fprintf(stdout, " Bits for parameter sets           : %d \n\n", stats->bit_ctr_parametersets);

  switch (params->Verbose)
  {
  case 0:
  case 1:
  default:
    fprintf(stdout,"-------------------------------------------------------------------------------\n");
    break;
  case 2:
    fprintf(stdout,"------------------------------------------------------------------------------------------------\n");
    break;
  }  
  fprintf(stdout,"Exit JM %s encoder ver %s ", JM, VERSION);
  fprintf(stdout,"\n");

  // status file
  report_stats(params, stats, bit_use, frame_rate);

  // write to log file
  report_log(params, stats, frame_rate);

  if (params->ReportFrameStats)
  {
    if ((p_log = fopen("stat_frame.dat", "a")) == NULL)       // append new statistic at the end
    {
      snprintf(errortext, ET_SIZE, "Error open file %s  \n", "stat_frame.dat.dat");
      //    error(errortext, 500);
    }
    else
    {
      fprintf(p_log," --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- \n");
      fclose(p_log);
    }
    report_log_mode(params, stats, bit_use);
  }
}


/*!
 ************************************************************************
 * \brief
 *    Prints the header of the protocol.
 * \par Input:
 *    struct inp_par *inp
 * \par Output:
 *    none
 ************************************************************************
 */
void information_init ( ImageParameters *img, InputParameters *params, StatParameters *stats)
{
  int i;
  static char yuv_types[4][10] = {"YUV 4:0:0", "YUV 4:2:0", "YUV 4:2:2", "YUV 4:4:4"};
  switch (params->Verbose)
  {
  case 0:
  case 1:
  default:
    printf("------------------------------- JM %4.4s %7.7s -------------------------------\n", VERSION, EXT_VERSION);
    break;
  case 2:
    printf("--------------------------------------- JM %4.4s %7.7s ----------------------------------------\n", VERSION, EXT_VERSION);
    break;
  }

  fprintf(stdout,  " Input YUV file                    : %s \n", params->infile);
  fprintf(stdout,  " Output H.264 bitstream            : %s \n", params->outfile);
  if (p_dec != -1)
    fprintf(stdout,  " Output YUV file                   : %s \n", params->ReconFile);
  fprintf(stdout,  " YUV Format                        : %s \n", &yuv_types[img->yuv_format][0]);//img->yuv_format==YUV422?"YUV 4:2:2":(img->yuv_format==YUV444)?"YUV 4:4:4":"YUV 4:2:0");
  fprintf(stdout,  " Frames to be encoded I-P/B        : %d/%d\n", params->no_frames, (params->successive_Bframe*(params->no_frames-1)));
  if (params->Verbose != 0)
  {
    fprintf(stdout,  " Freq. for encoded bitstream       : %1.0f\n", img->framerate/(float)(params->jumpd+1));
    fprintf(stdout,  " PicInterlace / MbInterlace        : %d/%d\n", params->PicInterlace, params->MbInterlace);
    fprintf(stdout,  " Transform8x8Mode                  : %d\n", params->Transform8x8Mode);

    for (i=0; i<3; i++)
    {
      fprintf(stdout," ME Metric for Refinement Level %1d  : %s\n", i, DistortionType[params->MEErrorMetric[i]]);
    }
    fprintf(stdout,  " Mode Decision Metric              : %s\n", DistortionType[params->ModeDecisionMetric]);