h26l.c

网络MPEG4IP流媒体开发源代码

  else
    fprintf(p_stat," Error robustness             : Off\n");

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

  if(input->mv_res)
    fprintf(p_stat," MV resolution                : 1/8-pel\n");
  else
    fprintf(p_stat," MV resolution                : 1/4-pel\n");

#ifdef _ADDITIONAL_REFERENCE_FRAME_
  if (input->add_ref_frame >= input->no_multpred)
    {
      fprintf(p_stat,   " No of frame used in P pred   : %d (+ no. %d)\n",input->no_multpred,input->add_ref_frame);
      if(input->successive_Bframe != 0)
        fprintf(p_stat,   " No of frame used in B pred   : %d (+ no. %d)\n",input->no_multpred,input->add_ref_frame);
    }
  else
#endif
  {
    fprintf(p_stat,   " No of frame used in P pred   : %d\n",input->no_multpred);
    if(input->successive_Bframe != 0)
      fprintf(p_stat,   " No of frame used in B pred   : %d\n",input->no_multpred);
  }
  if (input->symbol_mode == UVLC)
    fprintf(p_stat,   " Entropy coding method        : UVLC\n");
  else
    fprintf(p_stat,   " Entropy coding method        : CABAC\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)       |");
  fprintf(p_stat," %5.2f/%5.2f   |",snr->snr_u1,snr->snr_v1);
  fprintf(p_stat," %5.2f/%5.2f   |\n",snr->snr_ua,snr->snr_va);

  // QUANT.
  fprintf(p_stat," Average quant      |");
  fprintf(p_stat," %5d         |",absm(input->qp0));
  fprintf(p_stat," %5.2f         |\n",(float)h26lstat->quant1/max(1.0,(float)h26lstat->quant0));

  // MODE
  fprintf(p_stat,"\n -------------------|---------------|\n");
  fprintf(p_stat,"   Intra            |   Mode used   |\n");
  fprintf(p_stat," -------------------|---------------|\n");

  fprintf(p_stat," Mode 0  intra old\t| %5d         |\n",h26lstat->mode_use_intra[0]);
  for (i=1;i<24;i++)
    fprintf(p_stat," Mode %d intra new\t| %5d         |\n",i,h26lstat->mode_use_intra[i]);

  fprintf(p_stat,"\n -------------------|---------------|---------------|\n");
  fprintf(p_stat,"   Inter            |   Mode used   | Vector bit use|\n");
  fprintf(p_stat," -------------------|---------------|---------------|");

  fprintf(p_stat,"\n Mode 0  (copy)  \t| %5d         | %5.0f         |",h26lstat->mode_use_inter[0],(float)h26lstat->bit_use_mode_inter[0]/(float)bit_use[1][0]);
  fprintf(p_stat,"\n Mode 1  (16x16) \t| %5d         | %5.0f         |",h26lstat->mode_use_inter[1],(float)h26lstat->bit_use_mode_inter[1]/(float)bit_use[1][0]);
  fprintf(p_stat,"\n Mode 2  (16x8)  \t| %5d         | %5.0f         |",h26lstat->mode_use_inter[2],(float)h26lstat->bit_use_mode_inter[2]/(float)bit_use[1][0]);
  fprintf(p_stat,"\n Mode 3  (8x16)  \t| %5d         | %5.0f         |",h26lstat->mode_use_inter[3],(float)h26lstat->bit_use_mode_inter[3]/(float)bit_use[1][0]);
  fprintf(p_stat,"\n Mode 4  (8x8)   \t| %5d         | %5.0f         |",h26lstat->mode_use_inter[4],(float)h26lstat->bit_use_mode_inter[4]/(float)bit_use[1][0]);
  fprintf(p_stat,"\n Mode 5  (8x4)   \t| %5d         | %5.0f         |",h26lstat->mode_use_inter[5],(float)h26lstat->bit_use_mode_inter[5]/(float)bit_use[1][0]);
  fprintf(p_stat,"\n Mode 6  (4x8)   \t| %5d         | %5.0f         |",h26lstat->mode_use_inter[6],(float)h26lstat->bit_use_mode_inter[6]/(float)bit_use[1][0]);
  fprintf(p_stat,"\n Mode 7  (4x4)   \t| %5d         | %5.0f         |",h26lstat->mode_use_inter[7],(float)h26lstat->bit_use_mode_inter[7]/(float)bit_use[1][0]);
  fprintf(p_stat,"\n Mode 8 intra old\t| %5d         | --------------|",h26lstat->mode_use_inter[8]);
  for (i=9;i<33;i++)
    fprintf(p_stat,"\n Mode %d intr.new \t| %5d         |",i,h26lstat->mode_use_inter[i]);

  // B pictures
  if(input->successive_Bframe!=0 && Bframe_ctr!=0)
  {
    fprintf(p_stat,"\n\n -------------------|---------------|\n");
    fprintf(p_stat,"   B frame          |   Mode used   |\n");
    fprintf(p_stat," -------------------|---------------|");

    for(i=0; i<16; i++)
      fprintf(p_stat,"\n Mode %d   \t| %5d         |", i, h26lstat->mode_use_Bframe[i]);
    fprintf(p_stat,"\n Mode %d intra old\t| %5d     |", 16, h26lstat->mode_use_Bframe[16]);
    for (i=17; i<41; i++)
      fprintf(p_stat,"\n Mode %d intr.new \t| %5d     |",i, h26lstat->mode_use_Bframe[i]);
  }

  fprintf(p_stat,"\n\n -------------------|---------------|---------------|---------------|\n");
  fprintf(p_stat,"  Bit usage:        |     Intra     |    Inter      |   B frame     |\n");
  fprintf(p_stat," -------------------|---------------|---------------|---------------|\n");

  fprintf(p_stat," Header+modeinfo    |");
  fprintf(p_stat," %7d       |",h26lstat->bit_use_header[0]);
  fprintf(p_stat," %7d       |",h26lstat->bit_use_header[1]/bit_use[1][0]);
  if(input->successive_Bframe!=0 && Bframe_ctr!=0)
    fprintf(p_stat," %7d       |",h26lstat->bit_use_header[2]/Bframe_ctr);
  else fprintf(p_stat," %7d       |", 0);
  fprintf(p_stat,"\n");

  fprintf(p_stat," CBP Y/C            |");
  for (j=0; j < 2; j++)
  {
    fprintf(p_stat," %7.2f       |", (float)h26lstat->tmp_bit_use_cbp[j]/bit_use[j][0]);
  }
  if(input->successive_Bframe!=0 && Bframe_ctr!=0)
    fprintf(p_stat," %7.2f       |", (float)h26lstat->tmp_bit_use_cbp[2]/Bframe_ctr);
  else fprintf(p_stat," %7.2f       |", 0.);
  fprintf(p_stat,"\n");

  if(input->successive_Bframe!=0 && Bframe_ctr!=0)
    fprintf(p_stat," Coeffs. Y          | %7.2f      | %7.2f       | %7.2f       |\n",
      (float)h26lstat->bit_use_coeffY[0]/bit_use[0][0], (float)h26lstat->bit_use_coeffY[1]/bit_use[1][0], (float)h26lstat->bit_use_coeffY[2]/Bframe_ctr);
  else
    fprintf(p_stat," Coeffs. Y          | %7.2f      | %7.2f       | %7.2f       |\n",
      (float)h26lstat->bit_use_coeffY[0]/bit_use[0][0], (float)h26lstat->bit_use_coeffY[1]/bit_use[1][0], 0.);

  if(input->successive_Bframe!=0 && Bframe_ctr!=0)
    fprintf(p_stat," Coeffs. C          | %7.2f       | %7.2f       | %7.2f       |\n",
      (float)h26lstat->bit_use_coeffC[0]/bit_use[0][0], (float)h26lstat->bit_use_coeffC[1]/bit_use[1][0], (float)h26lstat->bit_use_coeffC[2]/Bframe_ctr);
  else
    fprintf(p_stat," Coeffs. C          | %7.2f       | %7.2f       | %7.2f       |\n",
      (float)h26lstat->bit_use_coeffC[0]/bit_use[0][0], (float)h26lstat->bit_use_coeffC[1]/bit_use[1][0], 0.);

  if(input->successive_Bframe!=0 && Bframe_ctr!=0)
    fprintf(p_stat," Delta quant        | %7.2f       | %7.2f       | %7.2f       |\n",
      (float)h26lstat->bit_use_delta_quant[0]/bit_use[0][0], (float)h26lstat->bit_use_delta_quant[1]/bit_use[1][0], (float)h26lstat->bit_use_delta_quant[2]/Bframe_ctr);
  else
    fprintf(p_stat," Delta quant        | %7.2f       | %7.2f       | %7.2f       |\n",
      (float)h26lstat->bit_use_delta_quant[0]/bit_use[0][0], (float)h26lstat->bit_use_delta_quant[1]/bit_use[1][0], 0.);


  fprintf(p_stat," -------------------|---------------|---------------|---------------|\n");

  fprintf(p_stat," average bits/frame |");
  for (i=0; i < 2; i++)
  {
    fprintf(p_stat," %7d       |",bit_use[i][1]/bit_use[i][0]);
  }
  if(input->successive_Bframe!=0 && Bframe_ctr!=0)
    fprintf(p_stat," %7d       |", bit_use_Bframe/Bframe_ctr);
  else fprintf(p_stat," %7d       |", 0);

  fprintf(p_stat,"\n");
  fprintf(p_stat," -------------------|---------------|---------------|---------------|\n");

  // write to log file
  if (fopen("log.dat","r")==0)                      // check if file exist
  {
    if ((p_log=fopen("log.dat","a"))==NULL)            // append new statistic at the end
    {
      snprintf(errortext, ET_SIZE, "Error open file %s  \n","log.dat");
      error(errortext, 500);
    }
    else                                            // Create header for new log file
    {
      fprintf(p_log," ---------------------------------------------------------------------------------------------------------------------------------------------------------------- \n");
      fprintf(p_log,"|            Encoder statistics. This file is generated during first encoding session, new sessions will be appended                                               |\n");
      fprintf(p_log," ---------------------------------------------------------------------------------------------------------------------------------------------------------------- \n");
      fprintf(p_log,"| Date  | Time  |    Sequence        |#Img|Quant1|QuantN|Format|Hadamard|Search r|#Ref |Freq |Intra upd|SNRY 1|SNRU 1|SNRV 1|SNRY N|SNRU N|SNRV N|#Bitr P|#Bitr B|\n");
      fprintf(p_log," ---------------------------------------------------------------------------------------------------------------------------------------------------------------- \n");
    }
  }
  else
    if ((p_log=fopen("log.dat","a"))==NULL)            // File exist,just open for appending
    {
      snprintf(errortext, ET_SIZE, "Error open file %s  \n","log.dat");
      error(errortext, 500);
    }

#ifdef WIN32
  _strdate( timebuf );
  fprintf(p_log,"| %1.5s |",timebuf );

  _strtime( timebuf);
  fprintf(p_log," % 1.5s |",timebuf);
#else
  now = time ((time_t *) NULL); // Get the system time and put it into 'now' as 'calender time'
  time (&now);
  l_time = localtime (&now);
  strftime (string, sizeof string, "%d-%b-%Y", l_time);
  fprintf(p_log,"| %1.5s |",string );

  strftime (string, sizeof string, "%H:%M:%S", l_time);
  fprintf(p_log," %1.5s |",string );
#endif

  for (i=0;i<20;i++)
    name[i]=input->infile[i+max(0,strlen(input->infile)-20)]; // write last part of path, max 20 chars
  fprintf(p_log,"%20.20s|",name);

  fprintf(p_log,"%3d |",input->no_frames);
  fprintf(p_log,"  %2d  |",input->qp0);
  fprintf(p_log,"  %2d  |",input->qpN);


  fprintf(p_log,"%dx%d|",input->img_width,input->img_height);


  if (input->hadamard==1)
    fprintf(p_log,"   ON   |");
  else
    fprintf(p_log,"   OFF  |");

  fprintf(p_log,"   %2d   |",input->search_range );

  fprintf(p_log," %2d  |",input->no_multpred);

  fprintf(p_log," %2d  |",img->framerate/(input->jumpd+1));

  if (input->intra_upd==1)
    fprintf(p_log,"   ON    |");
  else
    fprintf(p_log,"   OFF   |");

  fprintf(p_log,"%5.3f|",snr->snr_y1);
  fprintf(p_log,"%5.3f|",snr->snr_u1);
  fprintf(p_log,"%5.3f|",snr->snr_v1);
  fprintf(p_log,"%5.3f|",snr->snr_ya);
  fprintf(p_log,"%5.3f|",snr->snr_ua);
  fprintf(p_log,"%5.3f|",snr->snr_va);
  if(input->successive_Bframe != 0)
  {
    fprintf(p_log,"%7.0f|",h26lstat->bitrate_P);
    fprintf(p_log,"%7.0f|\n",h26lstat->bitrate_B);
  }
  else
  {
    fprintf(p_log,"%7.0f|",h26lstat->bitrate);
    fprintf(p_log,"%7.0f|\n",0.0);
  }

  fclose(p_log);

  p_log=fopen("data.txt","a");

  if(input->successive_Bframe != 0 && Bframe_ctr != 0) // B picture used
  {
    fprintf(p_log, "%3d %2d %2d %2.2f %2.2f %2.2f %5d "
          "%2.2f %2.2f %2.2f %5d "
        "%2.2f %2.2f %2.2f %5d %5d %.3f\n",
        input->no_frames, input->qp0, input->qpN,
        snr->snr_y1,
        snr->snr_u1,
        snr->snr_v1,
        h26lstat->bit_ctr_0,
        0.0,
        0.0,
        0.0,
        0,
        snr->snr_ya,
        snr->snr_ua,
        snr->snr_va,
        (h26lstat->bit_ctr_0+h26lstat->bit_ctr)/input->no_frames,
        h26lstat->bit_ctr_B/Bframe_ctr,
        (double)0.001*tot_time/(input->no_frames+Bframe_ctr));
  }
  else
  {
    fprintf(p_log, "%3d %2d %2d %2.2f %2.2f %2.2f %5d "
          "%2.2f %2.2f %2.2f %5d "
        "%2.2f %2.2f %2.2f %5d %5d %.3f\n",
        input->no_frames, input->qp0, input->qpN,
        snr->snr_y1,
        snr->snr_u1,
        snr->snr_v1,
        h26lstat->bit_ctr_0,
        0.0,
        0.0,
        0.0,
        0,
        snr->snr_ya,
        snr->snr_ua,
        snr->snr_va,
        (h26lstat->bit_ctr_0+h26lstat->bit_ctr)/input->no_frames,
        0,
        (double)0.001*tot_time/input->no_frames);
  }

  fclose(p_log);

  // B pictures
  free(h26lstat->mode_use_Bframe);
  free(h26lstat->bit_use_mode_Bframe);
}

/*!
 ************************************************************************
 * \brief
 *    Some matrices are initilized here.
 * \par Input:
 *    none
 * \par Output:
 *    none
 ************************************************************************
 */
void init()
{
  int i, ii, ind, j, i2;

  InitMotionVectorSearchModule();

  /*  img->mv_bituse[] is the number of bits used for motion vectors.
  It is used to add a portion to the SAD depending on bit usage in the motion search
  */

  img->mv_bituse[0]=1;
  ind=0;
  for (i=0; i < 9; i++)
  {
    ii= 2*i + 3;
    for (j=1; j <= (int)pow(2,i); j++)
    {
      ind++;
      img->mv_bituse[ind]=ii;
    }
  }

  // quad(0:255) SNR quad array
  for (i=0; i < 256; ++i) // fix from TML1 / TML2 sw, truncation removed
  {
    i2=i*i;
    img->quad[i]=i2;
  }

  // B pictures : img->blk_bitsue[] is used when getting bidirection SAD
  for (i=0; i < 7; i++)
  {
    if(i==0) img->blk_bituse[i]=1;
    else if(i==1 || i==2) img->blk_bituse[i]=3;
    else img->blk_bituse[i]=5;
  }
}

/*!
 ************************************************************************
 * \brief
 *    Prints the header of the protocol.
 * \par Input:
 *    struct inp_par *inp
 * \par Output:
 *    none
 ************************************************************************
 */
void information_init()
{
  printf("--------------------------------------------------------------------------\n");
  printf(" Input YUV file                    : %s \n",input->infile);
  printf(" Output H.26L bitstream            : %s \n",input->outfile);
  if (p_dec != NULL)
    printf(" Output YUV file(debug)            : %s \n",input->ReconFile);
  printf(" Output log file                   : log.dat \n");
  printf(" Output statistics file            : stat.dat \n");
  printf("--------------------------------------------------------------------------\n");


  printf(" Frame   Bit/pic   QP   SnrY    SnrU    SnrV    Time(ms) IntraMBs\n");
}


/*!
 ************************************************************************
 * \brief
 *    Dynamic memory allocation of frame size related global buffers
 *    buffers are defined in global.h, allocated memory must be freed in
 *    void free_mem4global_buffers()
 * \par Input:
 *    Input Parameters struct inp_par *inp,                            \n
 *    Image Parameters struct img_par *img
 * \return Number of allocated bytes
 ************************************************************************
 */
int get_mem4global_buffers()
{
  int j,memory_size=0;
#ifdef _ADAPT_LAST_GROUP_
  extern int *last_P_no;

  if ((last_P_no = (int*)malloc(img->buf_cycle*sizeof(int))) == NULL)
    no_mem_exit("get_mem4global_buffers: last_P_no");
#endif

  // allocate memory for encoding frame buffers: imgY, imgUV
  // byte imgY[288][352];
  // byte imgUV[2][144][176];
  memory_size += get_mem2D(&imgY, img->height, img->width);
  memory_size += get_mem3D(&imgUV, 2, img->height_cr, img->width_cr);

  // allocate memory for reference frame buffers: imgY_org, imgUV_org
  // byte imgY_org[288][352];
  // byte imgUV_org[2][144][176];
  memory_size += get_mem2D(&imgY_org, img->height, img->width);
  memory_size += get_mem3D(&imgUV_org, 2, img->height_cr, img->width_cr);

  // allocate memory for post filter frame buffers: imgY_pf, imgUV_pf
  // byte imgY_pf[288][352];
  // byte imgUV_pf[2][144][176];
  memory_size += get_mem2D(&imgY_pf, img->height, img->width);
  memory_size += get_mem3D(&imgUV_pf, 2, img->height_cr, img->width_cr);

  // allocate memory for B frame coding: nextP_imgY, nextP_imgUV
  // byte nextP_imgY[288][352];
  // byte nextP_imgUV[2][144][176];
  memory_size += get_mem2D(&nextP_imgY, img->height, img->width);
  memory_size += get_mem3D(&nextP_imgUV, 2, img->height_cr, img->width_cr);

  // allocate memory for multiple ref. frame buffers: mref, mcref
  //byte mref[MAX_MULT_PRED][1152][1408];  */   /* 1/4 pix luma
  //byte mcef[MAX_MULT_PRED][2][352][288]; */   /* pix chroma
  // rows and cols for croma component mcef[ref][croma][4x][4y] are switched
  // compared to luma mref[ref][4y][4x] for whatever reason
  // number of reference frames increased by one for next P-frame
  memory_size += get_mem3D(&mref, img->buf_cycle+1, (img->height+2*IMG_PAD_SIZE)*4, (img->width+2*IMG_PAD_SIZE)*4);
  if((mcef = (byte****)calloc(img->buf_cycle+1,sizeof(byte***))) == NULL)
    no_mem_exit("get_mem4global_buffers: mcef");