lencod.c

Mobile IP VCEG的信道模拟程序

		free(imgUV[0][i]);
		free(imgUV[1][i]);
	}
	free(imgUV[0]);
	free(imgUV[1]);
	free(imgUV);
	
	/* free ref frame buffers*/
	for(i=0;i<img->height;i++)
	{
		free(imgY_org[i]);
	}
	free(imgY_org);
	
	for(i=0;i<img->height_cr;i++)
	{
		free(imgUV_org[0][i]);
		free(imgUV_org[1][i]);
	}
	free(imgUV_org[0]);
	free(imgUV_org[1]);
	free(imgUV_org);
	
	/* free post filtering frame buffers*/
	for(i=0;i<img->height;i++)
	{
		free(imgY_pf[i]);
	}
	free(imgY_pf);
	
	for(i=0;i<img->height_cr;i++)
	{
		free(imgUV_pf[0][i]);
		free(imgUV_pf[1][i]);
	}
	free(imgUV_pf[0]);
	free(imgUV_pf[1]);
	free(imgUV_pf);
	
	/* free next frame buffers (for B frames)*/
	for(i=0;i<img->height;i++)
	{
		free(nextP_imgY[i]);
	}
	free(nextP_imgY);
	
	for(i=0;i<img->height_cr;i++)
	{
		free(nextP_imgUV[0][i]);
		free(nextP_imgUV[1][i]);
	}
	free(nextP_imgUV[0]);
	free(nextP_imgUV[1]);
	free(nextP_imgUV);
	
	
	/* free multiple ref frame buffers*/
	/* number of reference frames increased by one for next P-frame*/
	for(j=0;j<=img->buf_cycle;j++)
	{
		for(i=0;i<img->height*4;i++)
		{
			free(mref[j][i]);
		}
		free(mref[j]);
		
		for(i=0;i<img->width_cr*2;i++)
		{
			free(mcef[j][0][i]);
			free(mcef[j][1][i]);
		}
		free(mcef[j][0]);
		free(mcef[j][1]);
		free(mcef[j]);
	} 
	free(mref);
	free(mcef);
	for(i=0;i<img->height*4;i++)
	{
		free(mref_P[i]);
	}
	free(mref_P);
	
	for(i=0;i<img->width_cr*2;i++)
	{
		free(mcef_P[0][i]);
		free(mcef_P[1][i]);
	}
	free(mcef_P[0]);
	free(mcef_P[1]);
	free(mcef_P);
	
	if(input->successive_Bframe!=0)
	{
    /* free last P-frame buffers for B-frame coding*/
    for(j=0;i<2;j++)
    {
      for(i=0;i<img->height/BLOCK_SIZE;i++)
      {
        free(tmp_fwMV[j][i]);
				free(tmp_bwMV[j][i]);
				free(dfMV[j][i]);
				free(dbMV[j][i]);
      }
      free(tmp_fwMV[j]);
      free(tmp_bwMV[j]);
      free(dfMV[j]);
      free(dbMV[j]);
    }
    free(tmp_fwMV);
    free(tmp_bwMV);
    free(dfMV);
    free(dbMV);
    
		
    for(i=0;i<img->height/BLOCK_SIZE;i++)
    {
      free(fw_refFrArr[i]);
      free(bw_refFrArr[i]);
    }
    free(fw_refFrArr);
    free(bw_refFrArr);
	} /* end if B frame*/
	
	
	for(j=0;i<2;j++)
	{
		for(i=0;i<img->height/BLOCK_SIZE;i++)
		{
			free(tmp_mv[j][i]);
		}
		free(tmp_mv[j]);
	}
	free(tmp_mv);
	
	/* free temp quarter pel frame buffer*/
	for(i=0;i<img->height*2;i++)
	{
		free(img4Y_tmp[i]);
	}
	free(img4Y_tmp);
	
	
	/* free temp 1/8 pel frame buffer*/
	for(i=0;i<4*img->width;i++)
	{
		free(img8Y_tmp[i]);
	}
	free(img8Y_tmp);
	
	
	/* free temp loop filter frame buffer*/
	for(i=0;i<img->height;i++)
	{
		free(imgY_tmp[i]);
	}
	free(imgY_tmp);
	
	for(i=0;i<img->height_cr;i++)
	{
		free(imgUV_tmp[0][i]);
		free(imgUV_tmp[1][i]);
	}
	free(imgUV_tmp[0]);
	free(imgUV_tmp[1]);
	free(imgUV_tmp);
	
	/* free ref frame buffer for blocks*/
	for(i=0;i<img->height/BLOCK_SIZE;i++)
	{
		free(refFrArr[i]);
	}
	free(refFrArr);
	
	/* free loop filter strength buffer for 4x4 blocks*/
	for(i=0;i<img->width/BLOCK_SIZE+3;i++)
	{
		free(loopb[i]);
	}
	free(loopb);
	
	for(i=0;i<img->width_cr/BLOCK_SIZE+3;i++)
	{
		free(loopc[i]);
	}
	free(loopc);
	
	/* free mem, allocated in init_img()*/
	/* free intra pred mode buffer for blocks*/
	for(i=0;i<img->width/BLOCK_SIZE+2;i++)
	{
		free(img->ipredmode[i]);
	}
	free(img->ipredmode);
	
	free(img->mb_data); 
	
	free(img->slice_numbers);
}

/************************************************************************
*
*  Name :       int get_mem2D(byte ***array2D, int rows, int columns)
*
*  Description: Allocate 2D memory array -> unsigned char array2D[rows][columns]  
*
*  Input      : 
*
*  Output     : memory size in bytes
*
************************************************************************/
int get_mem2D(byte ***array2D, int rows, int columns)
{
  int i;
  
  if((*array2D = (byte**)calloc(rows,sizeof(byte*))) == NULL) no_mem_exit(1);
  for(i=0;i<rows;i++)
  {
    if(((*array2D)[i] = (byte*)calloc(columns,sizeof(byte))) == NULL) no_mem_exit(1);
  }
  return rows*columns;
}



int get_mem_mv (int****** mv)
{
  int i, j, k, l;

  if ((*mv = (int*****)calloc(4,sizeof(int****))) == NULL) no_mem_exit (1);
  for (i=0; i<4; i++)
    {
      if (((*mv)[i] = (int****)calloc(4,sizeof(int***))) == NULL) no_mem_exit (1);
      for (j=0; j<4; j++)
	{
	  if (((*mv)[i][j] = (int***)calloc(img->buf_cycle,sizeof(int**))) == NULL) no_mem_exit (1);
	  for (k=0; k<img->buf_cycle; k++)
	    {
	      if (((*mv)[i][j][k] = (int**)calloc(9,sizeof(int*))) == NULL) no_mem_exit (1);
	      for (l=0; l<9; l++)
		if (((*mv)[i][j][k][l] = (int*)calloc(2,sizeof(int))) == NULL) no_mem_exit (1);
	    }
	}
    }
  return 4*4*img->buf_cycle*9*2*sizeof(int);
}

void free_mem_mv (int***** mv)
{
  int i, j, k, l;

  for (i=0; i<4; i++)
    {
      for (j=0; j<4; j++)
	{
	  for (k=0; k<img->buf_cycle; k++)
	    {
	      for (l=0; l<9; l++)
		free (mv[i][j][k][l]);
	      free (mv[i][j][k]);
	    }
	  free (mv[i][j]);
	}
      free (mv[i]);
    }
  free (mv);
}

/************************************************************************
*
*  Name :       int get_mem2Dint(int ***array2D, int rows, int columns)
*
*  Description: Allocate 2D memory array -> int array2D[rows][columns]  
*
*  Input      : 
*
*  Output     : memory size in bytes
*
************************************************************************/
int get_mem2Dint(int ***array2D, int rows, int columns)
{
  int i;
  
  if((*array2D = (int**)calloc(rows,sizeof(int*))) == NULL) no_mem_exit(1);
  for(i=0;i<rows;i++)
  {
    if(((*array2D)[i] = (int*)calloc(columns,sizeof(int))) == NULL) no_mem_exit(1);
  }
  return rows*columns*sizeof(int);
}

/************************************************************************
*
*  Name :       int get_mem3D(byte ****array3D, int frames, int rows, int columns)
*
*  Description: Allocate 3D memory array -> unsigned char array3D[frames][rows][columns]  
*
*  Input      : 
*
*  Output     : memory size in bytes
*
************************************************************************/
int get_mem3D(byte ****array3D, int frames, int rows, int columns)
{
  int i, j;
	
  if(((*array3D) = (byte***)calloc(frames,sizeof(byte**))) == NULL) no_mem_exit(1);
	
  for(j=0;j<frames;j++)
  {
    if(((*array3D)[j] = (byte**)calloc(rows,sizeof(byte*))) == NULL) no_mem_exit(1);
    for(i=0;i<rows;i++)
    {
      if(((*array3D)[j][i] = (byte*)calloc(columns,sizeof(byte))) == NULL) no_mem_exit(1);
    }
  }
  
  return frames*rows*columns;
}
/************************************************************************
*
*  Name :       int get_mem3Dint(int ****array3D, int frames, int rows, int columns)
*
*  Description: Allocate 3D memory array -> int array3D[frames][rows][columns]  
*
*  Input      : 
*
*  Output     : memory size in bytes
*
************************************************************************/
int get_mem3Dint(int ****array3D, int frames, int rows, int columns)
{
  int i, j;
	
  if(((*array3D) = (int***)calloc(frames,sizeof(int**))) == NULL) no_mem_exit(1);
	
  for(j=0;j<frames;j++)
  {
    if(((*array3D)[j] = (int**)calloc(rows,sizeof(int*))) == NULL) no_mem_exit(1);
    for(i=0;i<rows;i++)
    {
      if(((*array3D)[j][i] = (int*)calloc(columns,sizeof(int))) == NULL) no_mem_exit(1);
    }
  }
  
  return frames*rows*columns*sizeof(int);
}
/************************************************************************
*
*  Name :       void no_mem_exit(int code)
*
*  Description: Exit program if there is not enough memory for frame buffers 
*
*  Input      : code for exit()
*
*  Output     : none
*
************************************************************************/
void no_mem_exit(int code)
{
   printf("Could not allocate frame buffer memory!\n");
   exit (code);
}