ldecod.c

AVS视频编解码器 能实现视频图像的高效率压缩 能在ＶＣ上高速运行

*/

void report(struct inp_par *inp, struct img_par *img, struct snr_par *snr)
{
  #define OUTSTRING_SIZE 255
  char string[OUTSTRING_SIZE];
  FILE *p_log;

#ifndef WIN32
  time_t  now;
  struct tm *l_time;
#else
  char timebuf[128];
#endif

  fprintf(stdout,"-------------------- Average SNR 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);
  fprintf(stdout," Total decoding time : %.3f sec \n",tot_time*0.001);
  fprintf(stdout,"--------------------------------------------------------------------------\n");
  fprintf(stdout," Exit RM %s decoder, ver %s ",RM,VERSION);
  fprintf(stdout,"\n");
  // write to log file

  snprintf(string, OUTSTRING_SIZE, "%s", LOGFILE);
  if ((p_log=fopen(string,"r"))==0)                    // check if file exist
  {
    if ((p_log=fopen(string,"a"))==0)
    {
      snprintf(errortext, ET_SIZE, "Error open file %s for appending",string);
      error(errortext, 500);
    }
    else                                              // Create header to new file
    {
      fprintf(p_log," ------------------------------------------------------------------------------------------\n");
      fprintf(p_log,"|  Decoder statistics. This file is made first time, later runs are appended               |\n");
      fprintf(p_log," ------------------------------------------------------------------------------------------ \n");
      fprintf(p_log,"| Date  | Time  |    Sequence        |#Img|Format|SNRY 1|SNRU 1|SNRV 1|SNRY N|SNRU N|SNRV N|\n");
      fprintf(p_log," ------------------------------------------------------------------------------------------\n");
    }
  }
  else
  { 
    fclose(p_log);
    p_log=fopen(string,"a");                    // File exist,just open for appending
  }

#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

  fprintf(p_log,"%20.20s|",inp->infile);

  fprintf(p_log,"%3d |",img->number);

  fprintf(p_log,"%6.3f|",snr->snr_y1);
  fprintf(p_log,"%6.3f|",snr->snr_u1);
  fprintf(p_log,"%6.3f|",snr->snr_v1);
  fprintf(p_log,"%6.3f|",snr->snr_ya);
  fprintf(p_log,"%6.3f|",snr->snr_ua);
  fprintf(p_log,"%6.3f|\n",snr->snr_va);

  fclose(p_log);

  snprintf(string, OUTSTRING_SIZE,"%s", DATADECFILE);
  p_log=fopen(string,"a");

  if(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 %.3f\n",
      img->number, 0, img->qp,
      snr->snr_y1,
      snr->snr_u1,
      snr->snr_v1,
      0,
      0.0,
      0.0,
      0.0,
      0,
      snr->snr_ya,
      snr->snr_ua,
      snr->snr_va,
      0,
      (double)0.001*tot_time/(img->number+Bframe_ctr-1));
  }
  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 %.3f\n",
      img->number, 0, img->qp,
      snr->snr_y1,
      snr->snr_u1,
      snr->snr_v1,
      0,
      0.0,
      0.0,
      0.0,
      0,
      snr->snr_ya,
      snr->snr_ua,
      snr->snr_va,
      0,
      (double)0.001*tot_time/img->number);
  }
  fclose(p_log);
}

/*
*************************************************************************
* Function:Allocates a Bitstream
* Input:
* Output:allocated Bitstream point
* Return: 
* Attention:
*************************************************************************
*/

Bitstream *AllocBitstream()
{
	 Bitstream *bitstream;
	 
	 bitstream = (Bitstream *) calloc(1, sizeof(Bitstream));
	 if (bitstream == NULL)
	 {
		 snprintf(errortext, ET_SIZE, "AllocBitstream: Memory allocation for Bitstream failed");
		 error(errortext, 100);
	 }
	 bitstream->streamBuffer = (byte *) calloc(MAX_CODED_FRAME_SIZE, sizeof(byte));
	 if (bitstream->streamBuffer == NULL)
	 {
		 snprintf(errortext, ET_SIZE, "AllocBitstream: Memory allocation for streamBuffer failed");
		 error(errortext, 100);
	 }

	 return bitstream;
}


/*
*************************************************************************
* Function:Frees a partition structure (array).  
* Input:Partition to be freed, size of partition Array (Number of Partitions)
* Output:
* Return: 
* Attention:n must be the same as for the corresponding call of AllocPartition
*************************************************************************
*/

void FreeBitstream ()
{
  assert (currStream!= NULL);
  assert (currStream->streamBuffer != NULL);

  free (currStream->streamBuffer);
  free (currStream);
}

/*
*************************************************************************
* Function:Dynamic memory allocation of frame size related global buffers
      buffers are defined in global.h, allocated memory must be freed in
      void free_global_buffers()
* Input:Input Parameters struct inp_par *inp, Image Parameters struct img_par *img
* Output:Number of allocated bytes
* Return: 
* Attention:
*************************************************************************
*/


int init_global_buffers(struct inp_par *inp, struct img_par *img)
{
  int i,j;
	int refnum;
	
  int memory_size=0;
	
  img->buf_cycle = inp->buf_cycle+1;
	
  img->buf_cycle *= 2;
	

  if(!progressive_sequence)
  {
	  
	  memory_size += get_mem2Dint(&refFrArr_top, vertical_size/(2*B8_SIZE), img->width/B8_SIZE);
	  memory_size += get_mem2Dint(&refFrArr_bot, vertical_size/(2*B8_SIZE), img->width/B8_SIZE);
	  
	  memory_size += get_mem3Dint(&(img->mv_top),img->width/B8_SIZE +4, vertical_size/(2*B8_SIZE),3);
	  memory_size += get_mem3Dint(&(img->mv_bot),img->width/B8_SIZE +4, vertical_size/(2*B8_SIZE),3);
	  // int fw_refFrArr[72][88];
	  memory_size += get_mem2Dint(&(img->fw_refFrArr_top),vertical_size/(2*B8_SIZE),img->width/B8_SIZE);
	  // int bw_refFrArr[72][88];
	  memory_size += get_mem2Dint(&(img->bw_refFrArr_top),vertical_size/(2*B8_SIZE),img->width/B8_SIZE);
	  
	  memory_size += get_mem2Dint(&(img->fw_refFrArr_bot),vertical_size/(2*B8_SIZE),img->width/B8_SIZE);
	  // int bw_refFrArr[72][88];
	  memory_size += get_mem2Dint(&(img->bw_refFrArr_bot),vertical_size/(2*B8_SIZE),img->width/B8_SIZE);
	  
	  memory_size += get_mem3Dint(&(img->fw_mv_top),img->width/B8_SIZE +4, vertical_size/(2*B8_SIZE),3);
	  memory_size += get_mem3Dint(&(img->fw_mv_bot),img->width/B8_SIZE +4, vertical_size/(2*B8_SIZE),3);
	  
	  memory_size += get_mem3Dint(&(img->bw_mv_top),img->width/B8_SIZE +4, vertical_size/(2*B8_SIZE),3);
	  memory_size += get_mem3Dint(&(img->bw_mv_bot),img->width/B8_SIZE +4, vertical_size/(2*B8_SIZE),3);
	  
	  memory_size += get_mem3Dint(&(img->dfMV_top),img->width/B8_SIZE +4, vertical_size/(2*B8_SIZE),3);
	  memory_size += get_mem3Dint(&(img->dbMV_top),img->width/B8_SIZE +4, vertical_size/(2*B8_SIZE),3);
	  
	  memory_size += get_mem3Dint(&(img->dfMV_bot),img->width/B8_SIZE +4, vertical_size/(2*B8_SIZE),3);
	  memory_size += get_mem3Dint(&(img->dbMV_bot),img->width/B8_SIZE +4, vertical_size/(2*B8_SIZE),3);
  }

  // allocate memory for imgY_prev
  memory_size += get_mem2D(&imgY_prev, vertical_size, img->width);
  memory_size += get_mem3D(&imgUV_prev, 2, vertical_size/2, img->width_cr);
	
  // allocate memory for reference frames of each block: refFrArr
  memory_size += get_mem2Dint(&refFrArr_frm, vertical_size/B8_SIZE, img->width/B8_SIZE);
	
  // allocate memory for reference frame in find_snr
  memory_size += get_mem2D(&imgY_ref, vertical_size, img->width);
  memory_size += get_mem3D(&imgUV_ref, 2, vertical_size/2, img->width_cr);
	
  // allocate memory in structure img
  if(((mb_data) = (Macroblock *) calloc((img->width/MB_BLOCK_SIZE) * (vertical_size/MB_BLOCK_SIZE),sizeof(Macroblock))) == NULL)
    no_mem_exit("init_global_buffers: mb_data");

  if(((img->intra_block) = (int**)calloc((j=(img->width/MB_BLOCK_SIZE) * (vertical_size/MB_BLOCK_SIZE)),sizeof(int))) == NULL)
    no_mem_exit("init_global_buffers: img->intra_block");
  for (i=0; i<j; i++)
  {
    if ((img->intra_block[i] = (int*)calloc(4, sizeof(int))) == NULL)
      no_mem_exit ("init_global_buffers: img->intra_block");
  }

  memory_size += get_mem3Dint(&(img->mv_frm),img->width/B8_SIZE +4, vertical_size/B8_SIZE,3);
  memory_size += get_mem2Dint(&(img->ipredmode),img->width/B8_SIZE +2 , vertical_size/B8_SIZE +2);
  memory_size += get_mem3Dint(&(img->dfMV),img->width/B8_SIZE +4, vertical_size/B8_SIZE,3);
  memory_size += get_mem3Dint(&(img->dbMV),img->width/B8_SIZE +4, vertical_size/B8_SIZE,3);
  memory_size += get_mem2Dint(&(img->fw_refFrArr_frm),vertical_size/B8_SIZE,img->width/B8_SIZE);
  memory_size += get_mem2Dint(&(img->bw_refFrArr_frm),vertical_size/B8_SIZE,img->width/B8_SIZE);
  memory_size += get_mem3Dint(&(img->fw_mv),img->width/B8_SIZE +4, vertical_size/B8_SIZE,3);
  memory_size += get_mem3Dint(&(img->bw_mv),img->width/B8_SIZE +4, vertical_size/B8_SIZE,3);

 // Prediction mode is set to -1 outside the frame, indicating that no prediction can be made from this part
	for (i=0; i < img->width/(B8_SIZE)+2; i++)
	{
		for (j=0; j < vertical_size/(B8_SIZE)+2; j++)
		{
				img->ipredmode[i][j]=-1;
		}
	}
//by oliver 0512

	 img->buf_cycle = inp->buf_cycle+1;

	// allocate frame buffer
	for(refnum=0; refnum<3; refnum++)
		for (i=0; i<3; i++)
		{
			if (i==0)
			{
				get_mem2D(&reference_frame[refnum][i],vertical_size,img->width);
			}else
			{
				get_mem2D(&reference_frame[refnum][i],vertical_size/2,img->width_cr);
			}
		}
		
	//allocate field buffer
	if(!progressive_sequence)
	{
		for(refnum=0; refnum<6; refnum++)
			for (i=0; i<3; i++)
			{
				if (i==0)
				{
					get_mem2D(&reference_field[refnum][i],vertical_size/2,img->width);
				}else
				{
					get_mem2D(&reference_field[refnum][i],vertical_size/4,img->width_cr);
				}
			}
	}

	//forward reference frame buffer
	ref_frm[0] = reference_frame[0]; //reference_frame[ref_index][yuv][height][width],ref_frm[ref_index][yuv][height][width]
	ref_frm[1] = reference_frame[1];
	current_frame = reference_frame[2];
	
	//luma for forward
	for (j=0;j<2;j++)//ref_index = 0
	{
		mref_frm[j] = ref_frm[j][0];
	}
 
	//chroma for forward
 	for (j=0;j<2;j++)//ref_index = 0
		for (i=0;i<2;i++) // chroma uv =0,1; 1,2 for reference_frame
	{
		mcef_frm[j][i] = ref_frm[j][i+1];
	}
  
	//luma for backward
	//forward/backward reference buffer
	f_ref_frm[0] = ref_frm[1]; //f_ref_frm[ref_index][yuv][height(height/2)][width] ref_index=0 for B frame, ref_index = 0,1 for B field
	b_ref_frm[0] = ref_frm[0]; //b_ref_frm[ref_index][yuv][height(height/2)][width] ref_index=0 for B frame, ref_index = 0,1 for B field
	for (j=0;j<1;j++)//ref_index = 0 luma = 0
	{
		mref_fref_frm[j] = f_ref_frm[j][0];
		mref_bref_frm[j] = b_ref_frm[j][0];
	}
 	
	//chroma for backward
	for (j=0;j<1;j++)//ref_index = 0
	for (i=0;i<2;i++) // chroma uv =0,1; 1,2 for reference_frame
	{
		mcef_fref_frm[j][i] = f_ref_frm[j][i+1];
		mcef_bref_frm[j][i] = b_ref_frm[j][i+1];
	}

	if(!progressive_sequence)
	{
		//forward reference frame buffer