report.c

来自「the newest JM software by h.264 JVT offi」· C语言 代码 · 共 1,204 行 · 第 1/5 页

    fprintf(stdout,  " Total encoding time for the seq.  : %7.3f sec (%3.2f fps)\n", (float) tot_time * 0.001, 1000.0 * (float) (stats->frame_counter) / (float)tot_time);
    fprintf(stdout,  " Total ME time for sequence        : %7.3f sec \n\n", (float)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]/(float)impix);
    fprintf(stdout," U { PSNR (dB), cSNR (dB), MSE }   : { %5.2f, %5.2f, %5.2f }\n",
      snr->average[1], csnr_u, sse->average[1]/(float)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]/(float)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] / (float) 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] / (float) 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] / (float) 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.  : %5.3f sec (%5.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);
  }


  stats->bitrate= ((float) total_bits * (float) params->output.frame_rate) / ((float) (stats->frame_counter));
  fprintf(stdout, " Bit rate (kbit/s)  @ %2.2f Hz     : %5.2f\n", params->output.frame_rate, stats->bitrate / 1000.0);
  
  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;
  case 3:
    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);

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

  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;
  case 3:
    printf("------------------------------------------ JM %4.4s %7.7s ------------------------------------------\n", VERSION, EXT_VERSION);
    break;
  }

  fprintf(stdout,  " Input YUV file                    : %s \n", params->input_file1.fname);
  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_frm_base, (params->NumberBFrames * (params->no_frm_base - 1)));
  if (params->Verbose != 0)
  {
    fprintf(stdout,  " Freq. for encoded bitstream       : %3.2f\n", params->output.frame_rate);
    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]);

    switch ( params->ChromaMEEnable )
    {
    case 1:
      fprintf(stdout," Motion Estimation for components  : YCbCr\n");
      break;
    default:
      fprintf(stdout," Motion Estimation for components  : Y\n");
      break;
    }

    fprintf(stdout,  " Image format                      : %dx%d (%dx%d)\n", params->output.width, params->output.height, img->width,img->height);

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

    fprintf(stdout,  " Total number of references        : %d\n", params->num_ref_frames);
    fprintf(stdout,  " References for P slices           : %d\n", params->P_List0_refs ? params->P_List0_refs : params->num_ref_frames);
    fprintf(stdout,  " References for B slices (L0, L1)  : %d\n", params->B_List0_refs ? params->B_List0_refs : params->num_ref_frames);
    fprintf(stdout,  " List1 references for B slices     : %d\n", params->B_List1_refs ? params->B_List1_refs : params->num_ref_frames);

    // Sequence Type
    fprintf(stdout,  " Sequence type                     :");
    if (stats->NumberBFrames > 0 && params->HierarchicalCoding)
    {
      fprintf(stdout, " Hierarchy (QP: I %d, P %d, B %d) \n",
        params->qp[0][I_SLICE], params->qp[0][P_SLICE], params->qp[0][B_SLICE]);
    }
    else if (stats->NumberBFrames > 0)
    {
      char seqtype[80];
      int i,j;

      strcpy (seqtype,"I");

      for (j=0; j < 2; j++)
      {
        for (i=0; i < stats->NumberBFrames; i++)
        {
          if (params->BRefPictures)
            strncat(seqtype,"-RB", imax(0, (int) (79 - strlen(seqtype))));
          else
            strncat(seqtype,"-B", imax(0, (int) (79 - strlen(seqtype))));
        }
        strncat(seqtype,"-P", imax(0, (int) (79 - strlen(seqtype))));
      }
      if (params->BRefPictures)
        fprintf(stdout, " %s (QP: I %d, P %d, RB %d) \n", seqtype, params->qp[0][I_SLICE], params->qp[0][P_SLICE], iClip3(0, 51, params->qp[0][B_SLICE] + params->qpBRSOffset[0]));
      else
        fprintf(stdout, " %s (QP: I %d, P %d, B %d) \n", seqtype, params->qp[0][I_SLICE], params->qp[0][P_SLICE], params->qp[0][B_SLICE]);
    }
    else if (stats->NumberBFrames == 0 && params->sp_periodicity == 0) 
      fprintf(stdout, " IPPP (QP: I %d, P %d) \n", params->qp[0][I_SLICE], params->qp[0][P_SLICE]);
    else 
      fprintf(stdout, " I-P-P-SP-P (QP: I %d, P %d, SP (%d, %d)) \n",  params->qp[0][I_SLICE], params->qp[0][P_SLICE], params->qp[0][SP_SLICE], params->qpsp[0]);

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

    fprintf(stdout,  " Profile/Level IDC                 : (%d,%d)\n", params->ProfileIDC, params->LevelIDC);