ldecod.c

Mobile IP VCEG的信道模拟程序

	int i,j;
	
    /* imgY, imgUV */
	for(i=0;i<img->height;i++)
	{
		if(imgY[i] != NULL) free(imgY[i]);
	}
	if(imgY != NULL) free(imgY);
	
	for(i=0;i<img->height_cr;i++)
	{
		if(imgUV[0][i] != NULL) free(imgUV[0][i]);
		if(imgUV[1][i] != NULL) free(imgUV[1][i]);
	}
	if(imgUV[0] != NULL) free(imgUV[0]);
	if(imgUV[1] != NULL) free(imgUV[1]);
	if(imgUV != NULL) free(imgUV);

    /* imgY_prev, imgUV_prev */
	for(i=0;i<img->height;i++)
	{
		if(imgY_prev[i] != NULL) free(imgY_prev[i]);
	}
	if(imgY_prev != NULL) free(imgY_prev);
	
	for(i=0;i<img->height_cr;i++)
	{
		if(imgUV_prev[0][i] != NULL) free(imgUV_prev[0][i]);
		if(imgUV_prev[1][i] != NULL) free(imgUV_prev[1][i]);
	}
	if(imgUV_prev[0] != NULL) free(imgUV_prev[0]);
	if(imgUV_prev[1] != NULL) free(imgUV_prev[1]);
	if(imgUV_prev != NULL) free(imgUV_prev);
	
    /* mref_P_small */
/*	for(i=0;i<img->height;i++)  StW
	{
        if(mref_P_small[i] != NULL) free(mref_P_small[i]);
	}
	if(mref_P_small[i] != NULL) free(mref_P_small);
*/ 	
	/* 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;i++)
		{
			if(mref[j][i] != NULL) free(mref[j][i]);
		}
		if(mref[j] != NULL) free(mref[j]);
		
		for(i=0;i<img->height_cr*2;i++)
		{
			if(mcef[j][0][i] != NULL) free(mcef[j][0][i]);
			if(mcef[j][1][i] != NULL) free(mcef[j][1][i]);
		}
		if(mcef[j][0] != NULL) free(mcef[j][0]);
		if(mcef[j][1] != NULL) free(mcef[j][1]);
		if(mcef[j] != NULL) free(mcef[j]);
	} 
	if(mref != NULL) free(mref);
	if(mcef != NULL) free(mcef);
	
    /* mref_P, mcef_P */
/*	for(i=0;i<img->height*4;i++)
	{
		if(mref_P[i] != NULL) free(mref_P[i]);
	}
	if(mref_P != NULL)free(mref_P);
	
	for(i=0;i<img->height_cr*2;i++)
	{
		if(mcef_P[0][i] != NULL) free(mcef_P[0][i]);
		if(mcef_P[1][i] != NULL)free(mcef_P[1][i]);
	}
	if(mcef_P[0] != NULL) free(mcef_P[0]);
	if(mcef_P[1] != NULL) free(mcef_P[1]);
	if(mcef_P != NULL)free(mcef_P);
*/
	
	/* free ref frame buffer for blocks*/
	for(i=0;i<img->height/BLOCK_SIZE;i++)
	{
		if(refFrArr[i] != NULL) free(refFrArr[i]);
	}
	if(refFrArr != NULL) free(refFrArr);
	
	/* free loop filter strength buffer for 4x4 blocks*/
	for(i=0;i<img->width/BLOCK_SIZE+3;i++)
	{
		if(loopb[i] != NULL) free(loopb[i]);
	}
	if(loopb != NULL) free(loopb);
	
	for(i=0;i<img->width_cr/BLOCK_SIZE+3;i++)
	{
		if(loopc[i] != NULL) free(loopc[i]);
	}
	if(loopc != NULL) free(loopc);
	
    /* find_snr */
    for(i=0;i<img->height;i++)
	{
		if(imgY_ref[i] != NULL) free(imgY_ref[i]);
	}
	if(imgY_ref != NULL) free(imgY_ref);
	
	for(i=0;i<img->height_cr;i++)
	{
		if(imgUV_ref[0][i] != NULL) free(imgUV_ref[0][i]);
		if(imgUV_ref[1][i] != NULL) free(imgUV_ref[1][i]);
	}
	if(imgUV_ref[0] != NULL) free(imgUV_ref[0]);
	if(imgUV_ref[1] != NULL) free(imgUV_ref[1]);
	if(imgUV_ref != NULL) free(imgUV_ref);

    /* loop_filter */
     for(i=0;i<img->height;i++)
	{
		if(imgY_tmp[i] != NULL) free(imgY_tmp[i]);
	}
	if(imgY_tmp != NULL) free(imgY_tmp);
	
	for(i=0;i<img->height_cr;i++)
	{
		if(imgUV_tmp[0][i] != NULL) free(imgUV_tmp[0][i]);
		if(imgUV_tmp[1][i] != NULL) free(imgUV_tmp[1][i]);
	}
	if(imgUV_tmp[0] != NULL) free(imgUV_tmp[0]);
	if(imgUV_tmp[1] != NULL) free(imgUV_tmp[1]);
	if(imgUV_tmp != NULL) free(imgUV_tmp);

	/* free mem, allocated for structure img */
	if (img->mb_data != NULL) free(img->mb_data); 
    if (img->slice_numbers != NULL) free(img->slice_numbers);
	
    // img => int mv[92][72][3]
    for(i=0;i<(img->width/BLOCK_SIZE + 4);i++)
	    for(j=0;j<(img->height/BLOCK_SIZE);j++)
		    if(img->mv[i][j] != NULL) free(img->mv[i][j]);
    for(i=0;i<(img->width/BLOCK_SIZE + 4);i++)
		if(img->mv[i] != NULL) free(img->mv[i]);
    if(img->mv != NULL) free(img->mv);

    // img => int ipredmode[90][74]
    for(i=0;i<(img->width/BLOCK_SIZE + 2);i++)
		if(img->ipredmode[i] != NULL) free(img->ipredmode[i]);
    if(img->ipredmode != NULL) free(img->ipredmode);
  
    // int dfMV[92][72][3]; 
    for(i=0;i<(img->width/BLOCK_SIZE + 4);i++)
	    for(j=0;j<(img->height/BLOCK_SIZE);j++)
		    if(img->dfMV[i][j] != NULL) free(img->dfMV[i][j]);
    for(i=0;i<(img->width/BLOCK_SIZE + 4);i++)
		if(img->dfMV[i] != NULL) free(img->dfMV[i]);
    if(img->dfMV != NULL) free(img->dfMV);
   
    // int dbMV[92][72][3];
    for(i=0;i<(img->width/BLOCK_SIZE + 4);i++)
	    for(j=0;j<(img->height/BLOCK_SIZE);j++)
		    if(img->dbMV[i][j] != NULL) free(img->dbMV[i][j]);
    for(i=0;i<(img->width/BLOCK_SIZE + 4);i++)
		if(img->dbMV[i] != NULL) free(img->dbMV[i]);
    if(img->dbMV != NULL) free(img->dbMV);
    
    // int fw_refFrArr[72][88];
    for(i=0;i<img->height/BLOCK_SIZE;i++)
		if(img->fw_refFrArr[i] != NULL) free(img->fw_refFrArr[i]);
    if(img->fw_refFrArr != NULL) free(img->fw_refFrArr);

    // int bw_refFrArr[72][88];
    for(i=0;i<img->height/BLOCK_SIZE;i++)
		if(img->bw_refFrArr[i] != NULL) free(img->bw_refFrArr[i]);
    if(img->bw_refFrArr != NULL) free(img->bw_refFrArr);

    // int fw_mv[92][72][3];
    for(i=0;i<(img->width/BLOCK_SIZE + 4);i++)
	    for(j=0;j<(img->height/BLOCK_SIZE);j++)
		    if(img->fw_mv[i][j] != NULL) free(img->fw_mv[i][j]);
    for(i=0;i<(img->width/BLOCK_SIZE + 4);i++)
		if(img->fw_mv[i] != NULL) free(img->fw_mv[i]);
    if(img->fw_mv != NULL) free(img->fw_mv);
  
    // int bw_mv[92][72][3];
    for(i=0;i<(img->width/BLOCK_SIZE + 4);i++)
	    for(j=0;j<(img->height/BLOCK_SIZE);j++)
		    if(img->bw_mv[i][j] != NULL) free(img->bw_mv[i][j]);
    for(i=0;i<(img->width/BLOCK_SIZE + 4);i++)
		if(img->bw_mv[i] != NULL) free(img->bw_mv[i]);
    if(img->bw_mv != NULL) free(img->bw_mv);

}

/************************************************************************
*
*  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;
}

/************************************************************************
*
*  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);
}