coder.c

h.263 c编码源码。目录下有input。qcif原始未压缩文件

    }
#endif
  }
  free(iblock);
  free(rcoeff);
  return 0;
}


/**********************************************************************
 *
 *	Name:		FillLumBlock
 *	Description:   	Fills the luminance of one block of lines*pels
 *	
 *	Input:	      	Position, pointer to qcif, array to fill
 *	Returns:       	
 *	Side effects:	fills array
 *
 *	Date: 930129	Author: [e-mail]
 *
 ***********************************************************************/
// 从image中放入data->lum[16][16]

void FillLumBlock( int x, int y, unsigned int *image, MB_Structure *data)
{
  int n, m;
  /* OPTIMIZE HERE */
  /* m -> int conversion is done here, so no long optimiz. possible */
  for (n = 0; n < MB_SIZE; n++)
    for (m = 0; m < MB_SIZE; m++)
      data->lum[n][m] = (int) (*(image + x+m + (y+n)*pels));
  return;
}

/**********************************************************************
 *
 *	Name:		FillChromBlock
 *	Description:   	Fills the chrominance of one block of qcif
 *	
 *	Input:	      	Position, pointer to qcif, array to fill
 *	Returns:       	
 *	Side effects:	fills array
 *                      128 subtracted from each
 *
 *	Date: 930129	Author: [e-mail]
 *
 ***********************************************************************/

void FillChromBlock(int x_curr, int y_curr, unsigned int *image,MB_Structure *data)
{
  int n;
  register int m;

  int x, y;

  x = x_curr>>1;
  y = y_curr>>1;

  for (n = 0; n < (MB_SIZE>>1); n++)
    for (m = 0; m < (MB_SIZE>>1); m++) {
      data->Cr[n][m] = (int) (*(image + vskip + x+m + (y+n)*cpels));   //  uskip = 176*144 ; vskip = 176*144 + lines*pels/4;
      data->Cb[n][m] = (int) (*(image + uskip + x+m + (y+n)*cpels));
    }
  return;
}


/**********************************************************************
 *
 *	Name:		ZeroMBlock
 *	Description:   	Fills one MB with Zeros
 *	
 *	Input:	      	MB_Structure to zero out
 *	Returns:       	
 *	Side effects:	
 *
 *	Date: 940829	Author: [e-mail]
 *
 ***********************************************************************/

void ZeroMBlock(MB_Structure *data)
{
  int n;
  register int m;

  /* ALPHA optimization */
#ifdef LONGISDOUBLEINT
  for (n = 0; n < MB_SIZE; n++)
    for (m = 0; m < MB_SIZE; m +=2 )
      *(long *) &(data->lum[n][m]) = 0L;
  for (n = 0; n < (MB_SIZE>>1); n++)
    for (m = 0; m < (MB_SIZE>>1); m +=2 ) {
      *(long *) &(data->Cr[n][m]) = 0L;
      *(long *) &(data->Cb[n][m]) = 0L;
    }
#else
  for (n = 0; n < MB_SIZE; n++)
    for (m = 0; m < MB_SIZE; m++ )
      *(int *) &(data->lum[n][m]) = 0;
  for (n = 0; n < (MB_SIZE>>1); n++)
    for (m = 0; m < (MB_SIZE>>1); m++ ) {
      *(int *) &(data->Cr[n][m]) = 0;
      *(int *) &(data->Cb[n][m]) = 0;
    }
#endif
  return;
}

/**********************************************************************
 *
 *	Name:		ReconImage
 *	Description:	Puts together reconstructed image
 *	
 *	Input:		position of curr block, reconstructed
 *			macroblock, pointer to recontructed image
 *	Returns:
 *	Side effects:
 *
 *	Date: 930123  	Author: [e-mail]
 *
 ***********************************************************************/
// 宏块data(16*16)的数据,放入到recon(width*height)的图像中

void ReconImage (int i, int j, MB_Structure *data, unsigned int *recon)
{
  int n;
  int x_curr, y_curr;
  int *lum_ptr, *Cb_ptr, *Cr_ptr;
  unsigned int *recon_ptr, *recon_Cb_ptr, *recon_Cr_ptr;

 
  x_curr = i * MB_SIZE;
  y_curr = j * MB_SIZE;
  
  lum_ptr = &(data->lum[0][0]);
  recon_ptr = recon + x_curr + y_curr*pels;

  /* Fill in luminance data */
  for (n = 0; n < MB_SIZE; n++) {  //16
#ifdef LONGISDOUBLEINT
    * (long *) recon_ptr = * (long *) lum_ptr;
    recon_ptr += 2; lum_ptr += 2;
    * (long *) recon_ptr = * (long *) lum_ptr;
    recon_ptr += 2; lum_ptr += 2;
    * (long *) recon_ptr = * (long *) lum_ptr;
    recon_ptr += 2; lum_ptr += 2;
    * (long *) recon_ptr = * (long *) lum_ptr;
    recon_ptr += 2; lum_ptr += 2;
    * (long *) recon_ptr = * (long *) lum_ptr;
    recon_ptr += 2; lum_ptr += 2;
    * (long *) recon_ptr = * (long *) lum_ptr;
    recon_ptr += 2; lum_ptr += 2;
    * (long *) recon_ptr = * (long *) lum_ptr;
    recon_ptr += 2; lum_ptr += 2;
    * (long *) recon_ptr = * (long *) lum_ptr;
    recon_ptr += pels - 14; lum_ptr += 2;
    /* Was: for every m = 0..15 :
     *(recon->lum + x_curr+m + (y_curr+n)*pels) = *(lum_ptr++);
     */
#else
    * (int *) recon_ptr = * (int *) lum_ptr;
    recon_ptr++; lum_ptr++;
    * (int *) recon_ptr = * (int *) lum_ptr;
    recon_ptr++; lum_ptr++;
    * (int *) recon_ptr = * (int *) lum_ptr;
    recon_ptr++; lum_ptr++;
    * (int *) recon_ptr = * (int *) lum_ptr;
    recon_ptr++; lum_ptr++;
    * (int *) recon_ptr = * (int *) lum_ptr;
    recon_ptr++; lum_ptr++;
    * (int *) recon_ptr = * (int *) lum_ptr;
    recon_ptr++; lum_ptr++;
    * (int *) recon_ptr = * (int *) lum_ptr;
    recon_ptr++; lum_ptr++;
    * (int *) recon_ptr = * (int *) lum_ptr;
    recon_ptr++; lum_ptr++;
    * (int *) recon_ptr = * (int *) lum_ptr;
    recon_ptr++; lum_ptr++;
    * (int *) recon_ptr = * (int *) lum_ptr;
    recon_ptr++; lum_ptr++;
    * (int *) recon_ptr = * (int *) lum_ptr;
    recon_ptr++; lum_ptr++;
    * (int *) recon_ptr = * (int *) lum_ptr;
    recon_ptr++; lum_ptr++;
    * (int *) recon_ptr = * (int *) lum_ptr;
    recon_ptr++; lum_ptr++;
    * (int *) recon_ptr = * (int *) lum_ptr;
    recon_ptr++; lum_ptr++;
    * (int *) recon_ptr = * (int *) lum_ptr;
    recon_ptr++; lum_ptr++;
    * (int *) recon_ptr = * (int *) lum_ptr;

    recon_ptr += pels - 15; lum_ptr++;
#endif
  }

  recon_Cb_ptr = recon+uskip+ (x_curr>>1) + (y_curr>>1)*cpels;
  recon_Cr_ptr = recon+vskip+ (x_curr>>1) + (y_curr>>1)*cpels;
  Cb_ptr = &(data->Cb[0][0]);
  Cr_ptr = &(data->Cr[0][0]);

  /* Fill in chrominance data */
  for (n = 0; n < MB_SIZE>>1; n++) {
#ifdef LONGISDOUBLEINT
    * (long *) recon_Cb_ptr = * (long *) Cb_ptr;
    recon_Cb_ptr += 2; Cb_ptr += 2;
    * (long *) recon_Cr_ptr = * (long *) Cr_ptr;
    recon_Cr_ptr += 2; Cr_ptr += 2;
    * (long *) recon_Cb_ptr = * (long *) Cb_ptr;
    recon_Cb_ptr += 2; Cb_ptr += 2;
    * (long *) recon_Cr_ptr = * (long *) Cr_ptr;
    recon_Cr_ptr += 2; Cr_ptr += 2;
    * (long *) recon_Cb_ptr = * (long *) Cb_ptr;
    recon_Cb_ptr += 2; Cb_ptr += 2;
    * (long *) recon_Cr_ptr = * (long *) Cr_ptr;
    recon_Cr_ptr += 2; Cr_ptr += 2;
    * (long *) recon_Cb_ptr = * (long *) Cb_ptr;
    recon_Cb_ptr += cpels - 6; Cb_ptr += 2;
    * (long *) recon_Cr_ptr = * (long *) Cr_ptr;
    recon_Cr_ptr += cpels - 6; Cr_ptr += 2;
#else
    * (int *) recon_Cb_ptr = * (int *) Cb_ptr;
    recon_Cb_ptr++; Cb_ptr++;
    * (int *) recon_Cr_ptr = * (int *) Cr_ptr;
    recon_Cr_ptr++; Cr_ptr++;    
    * (int *) recon_Cb_ptr = * (int *) Cb_ptr;
    recon_Cb_ptr++; Cb_ptr++;
    * (int *) recon_Cr_ptr = * (int *) Cr_ptr;
    recon_Cr_ptr++; Cr_ptr++;    
    * (int *) recon_Cb_ptr = * (int *) Cb_ptr;
    recon_Cb_ptr++; Cb_ptr++;
    * (int *) recon_Cr_ptr = * (int *) Cr_ptr;
    recon_Cr_ptr++; Cr_ptr++;    
    * (int *) recon_Cb_ptr = * (int *) Cb_ptr;
    recon_Cb_ptr++; Cb_ptr++;
    * (int *) recon_Cr_ptr = * (int *) Cr_ptr;
    recon_Cr_ptr++; Cr_ptr++;   
    * (int *) recon_Cb_ptr = * (int *) Cb_ptr;
    recon_Cb_ptr++; Cb_ptr++;
    * (int *) recon_Cr_ptr = * (int *) Cr_ptr;
    recon_Cr_ptr++; Cr_ptr++;    
    * (int *) recon_Cb_ptr = * (int *) Cb_ptr;
    recon_Cb_ptr++; Cb_ptr++;
    * (int *) recon_Cr_ptr = * (int *) Cr_ptr;
    recon_Cr_ptr++; Cr_ptr++;    
    * (int *) recon_Cb_ptr = * (int *) Cb_ptr;
    recon_Cb_ptr++; Cb_ptr++;
    * (int *) recon_Cr_ptr = * (int *) Cr_ptr;
    recon_Cr_ptr++; Cr_ptr++;    

    * (int *) recon_Cb_ptr = * (int *) Cb_ptr;
    * (int *) recon_Cr_ptr = * (int *) Cr_ptr;

    recon_Cb_ptr += cpels - 7; Cb_ptr ++;
    recon_Cr_ptr += cpels - 7; Cr_ptr ++;
#endif
  }
  /* WAS:   
     for (m = 0; m < MB_SIZE>>1; m++) {
     *(recon->Cr + (x_curr>>1)+m + ((y_curr>>1)+n)*cpels) = data->Cr[n][m];
     *(recon->Cb + (x_curr>>1)+m + ((y_curr>>1)+n)*cpels) = data->Cb[n][m];
     }
     */
  return;
}

/**********************************************************************
 *
 *	Name:		ReconCopyImage
 *	Description:	Copies previous recon_image to current recon image
 *	
 *	Input:		position of curr block, reconstructed
 *			macroblock, pointer to recontructed image
 *	Returns:
 *	Side effects:
 *
 *	Date: 960423  	Author: Roalt Aalmoes
 *
 ***********************************************************************/
// 把原来重建的宏块,复制到当前宏块重建的位置(宏块为SKIP)
void ReconCopyImage (int i, int j, unsigned int *recon, unsigned int *prev_recon)
{
  int n;
  int x_curr, y_curr;
  unsigned int *lum_now, *lum_prev, *cb_now, *cr_now, *cb_prev, *cr_prev;

 
  x_curr = i * MB_SIZE;
  y_curr = j * MB_SIZE;

  lum_now = recon + x_curr + y_curr*pels;
  lum_prev = prev_recon + x_curr + y_curr*pels;

  /* Fill in luminance data */
  for (n = 0; n < 16; n++) {
#ifdef LONGISDOUBLEINT
    *(long *)(lum_now) = *(long *)(lum_prev);
    *(long *)(lum_now + 2) = *(long *)(lum_prev + 2);
    *(long *)(lum_now + 4) = *(long *)(lum_prev + 4);
    *(long *)(lum_now + 6) = *(long *)(lum_prev + 6);
    *(long *)(lum_now + 8) = *(long *)(lum_prev + 8);
    *(long *)(lum_now + 10) = *(long *)(lum_prev + 10);
    *(long *)(lum_now + 12) = *(long *)(lum_prev + 12);
    *(long *)(lum_now + 14) = *(long *)(lum_prev + 14);
#else
    *(int *)(lum_now) = *(int *)(lum_prev);
    *(int *)(lum_now + 1) = *(int *)(lum_prev + 1);

    *(int *)(lum_now + 2) = *(int *)(lum_prev + 2);
    *(int *)(lum_now + 3) = *(int *)(lum_prev + 3);
    *(int *)(lum_now + 4) = *(int *)(lum_prev + 4);
    *(int *)(lum_now + 5) = *(int *)(lum_prev + 5);
    *(int *)(lum_now + 6) = *(int *)(lum_prev + 6);
    *(int *)(lum_now + 7) = *(int *)(lum_prev + 7);
    *(int *)(lum_now + 8) = *(int *)(lum_prev + 8);
    *(int *)(lum_now + 9) = *(int *)(lum_prev + 9);
    *(int *)(lum_now + 10) = *(int *)(lum_prev + 10);
    *(int *)(lum_now + 11) = *(int *)(lum_prev + 11);
    *(int *)(lum_now + 12) = *(int *)(lum_prev + 12);
    *(int *)(lum_now + 13) = *(int *)(lum_prev + 13);
    *(int *)(lum_now + 14) = *(int *)(lum_prev + 14);
    *(int *)(lum_now + 15) = *(int *)(lum_prev + 15);

#endif
    lum_now += pels;
    lum_prev += pels;
     
  }


  cb_now = recon+uskip + (x_curr>>1) + (y_curr>>1)*cpels;
  cr_now = recon+vskip + (x_curr>>1) + (y_curr>>1)*cpels;
  cb_prev = prev_recon+uskip+ (x_curr>>1) + (y_curr>>1)*cpels;
  cr_prev = prev_recon+vskip + (x_curr>>1) + (y_curr>>1)*cpels;

  /* Fill in chrominance data */
  for (n = 0; n < (MB_SIZE>>1); n++) {
#ifdef LONGISDOUBLEINT
    *(long *)(cb_now) = *(long *)(cb_prev);
    *(long *)(cb_now + 2) = *(long *)(cb_prev + 2);
    *(long *)(cb_now + 4) = *(long *)(cb_prev + 4);
    *(long *)(cb_now + 6) = *(long *)(cb_prev + 6);
    cb_now += cpels;
    cb_prev += cpels;

    *(long *)(cr_now) = *(long *)(cr_prev);
    *(long *)(cr_now + 2) = *(long *)(cr_prev + 2);
    *(long *)(cr_now + 4) = *(long *)(cr_prev + 4);
    *(long *)(cr_now + 6) = *(long *)(cr_prev + 6);
    cr_now += cpels;
    cr_prev += cpels;
#else
    *(int *)(cb_now) = *(int *)(cb_prev);
    *(int *)(cb_now + 1) = *(int *)(cb_prev + 1);
    *(int *)(cb_now + 2) = *(int *)(cb_prev + 2);
    *(int *)(cb_now + 3) = *(int *)(cb_prev + 3);
    *(int *)(cb_now + 4) = *(int *)(cb_prev + 4);
    *(int *)(cb_now + 5) = *(int *)(cb_prev + 5);
    *(int *)(cb_now + 6) = *(int *)(cb_prev + 6);
    *(int *)(cb_now + 7) = *(int *)(cb_prev + 7);
    cb_now += cpels;
    cb_prev += cpels;

    *(int *)(cr_now) = *(int *)(cr_prev);
    *(int *)(cr_now + 1) = *(int *)(cr_prev + 1);
    *(int *)(cr_now + 2) = *(int *)(cr_prev + 2);
    *(int *)(cr_now + 3) = *(int *)(cr_prev + 3);
    *(int *)(cr_now + 4) = *(int *)(cr_prev + 4);
    *(int *)(cr_now + 5) = *(int *)(cr_prev + 5);