diff.c

经典的MP4编解码核心库

/*
 * Add SSE2 support for Pentium 4
 * David, Sigma Designs Inc
 */

#include "../mp4v.h"
#include "../global.h"

#include "mefunctions.h"

uint32_t sad16x16_c(const uint8_t * const cur,
		 const uint8_t * const ref,
		 const uint32_t stride)
{

	uint32_t sad = 0;
	uint32_t j;
	uint8_t const *ptr_cur = cur;
	uint8_t const *ptr_ref = ref;

	for (j = 0; j < 16; j++) {
			sad += ABS(*(ptr_cur ++) - *(ptr_ref ++));
			sad += ABS(*(ptr_cur ++) - *(ptr_ref ++));
			sad += ABS(*(ptr_cur ++) - *(ptr_ref ++));
			sad += ABS(*(ptr_cur ++) - *(ptr_ref ++));

			sad += ABS(*(ptr_cur ++) - *(ptr_ref ++));
			sad += ABS(*(ptr_cur ++) - *(ptr_ref ++));
			sad += ABS(*(ptr_cur ++) - *(ptr_ref ++));
			sad += ABS(*(ptr_cur ++) - *(ptr_ref ++));

			sad += ABS(*(ptr_cur ++) - *(ptr_ref ++));
			sad += ABS(*(ptr_cur ++) - *(ptr_ref ++));
			sad += ABS(*(ptr_cur ++) - *(ptr_ref ++));
			sad += ABS(*(ptr_cur ++) - *(ptr_ref ++));

			sad += ABS(*(ptr_cur ++) - *(ptr_ref ++));
			sad += ABS(*(ptr_cur ++) - *(ptr_ref ++));
			sad += ABS(*(ptr_cur ++) - *(ptr_ref ++));
			sad += ABS(*(ptr_cur ++) - *(ptr_ref ++));
	

		ptr_cur += stride - 16;
		ptr_ref += stride - 16;

	}

	return sad;

}



uint32_t sad8_c(const uint8_t * const cur,
					const uint8_t * const ref,
					const uint32_t stride)
{
	uint32_t sad = 0;
	uint32_t j;
	uint8_t const *ptr_cur = cur;
	uint8_t const *ptr_ref = ref;

	for (j = 0; j < 8; j++) {

		sad += ABS(*(ptr_cur ++) - *(ptr_ref ++));
		sad += ABS(*(ptr_cur ++) - *(ptr_ref ++));
		sad += ABS(*(ptr_cur ++) - *(ptr_ref ++));
		sad += ABS(*(ptr_cur ++) - *(ptr_ref ++));

		sad += ABS(*(ptr_cur ++) - *(ptr_ref ++));
		sad += ABS(*(ptr_cur ++) - *(ptr_ref ++));
		sad += ABS(*(ptr_cur ++) - *(ptr_ref ++));
		sad += ABS(*(ptr_cur ++) - *(ptr_ref ++));

		ptr_cur += stride - 8;
		ptr_ref += stride - 8;

	}

	return sad;
}




/* Purpose: get average deviation from mean, and return both dev and mean */
/* Assumption: only work for MB with all positive value					*/
/* Author: David, 2002, Sigma Designs, Inc. */
uint32_t dev16_c(const uint8_t * const cur,
				 const uint32_t stride,
				 int32_t * const mean)
{
	uint8_t const *ptr_cur = cur;

	uint32_t dev = 0;		// result
	uint32_t x,y;
	int32_t  avg;

	*mean = 0;

	for (y = 0; y < 16; y++) {
		*mean += *(ptr_cur ++);	*mean += *(ptr_cur ++);	*mean += *(ptr_cur ++);	*mean += *(ptr_cur ++);
		*mean += *(ptr_cur ++);	*mean += *(ptr_cur ++);	*mean += *(ptr_cur ++);	*mean += *(ptr_cur ++);
		*mean += *(ptr_cur ++);	*mean += *(ptr_cur ++);	*mean += *(ptr_cur ++);	*mean += *(ptr_cur ++);
		*mean += *(ptr_cur ++);	*mean += *(ptr_cur ++);	*mean += *(ptr_cur ++);	*mean += *(ptr_cur ++);

		ptr_cur += stride - 16;

	}

	*mean >>= 8;		//( Total 256 pixels in a MB)
	avg = *mean;
	ptr_cur = cur;

	for (y = 0; y < 16; y++) {

		for (x = 0; x < 16; x++)
			dev += ABS(*(ptr_cur + x) - avg);

		ptr_cur += stride;

	}

	return dev;
}

/* mean of macroblock 16x16*/

uint32_t mean16_c(const uint8_t * const cur,
				const uint32_t stride)
{
	uint32_t mean = 0;
	uint32_t i,j;
	uint8_t const *ptr_cur = cur;

	for (j = 0; j < 16; j++) {

		for (i = 0; i < 16; i++)
			mean += *(ptr_cur + i);

		ptr_cur += stride;

	}

	mean /= (16 * 16);

	return mean;
}

/* average deviation from mean for mv0*/
// Added by David, 2002

uint32_t dev16_mv0_c(const uint8_t * const cur, const uint8_t * const ref,
				const uint32_t stride)
{

	int32_t mean = 0;
	uint32_t dev = 0;
	uint32_t i,j;
	uint8_t const *ptr_cur = cur;
	uint8_t const *ptr_ref = ref;

	for (j = 0; j < 16; j++) {

		for (i = 0; i < 16; i++)
			mean += *(ptr_cur + i)-*(ptr_ref + i);

		ptr_cur += stride;
		ptr_ref += stride;
	}

	mean/=(16 * 16);

	ptr_cur = cur;
	ptr_ref = ref;

	for (j = 0; j < 16; j++) {

		for (i = 0; i < 16; i++)
			dev += ABS(*(ptr_cur + i)-*(ptr_ref + i) - mean);

		ptr_cur += stride;
		ptr_ref += stride;
	}

	return dev;
}
/*
uint32_t dev16_mv0_c(const uint8_t * const cur, const uint8_t * const ref,
				const uint32_t stride)
{

	int32_t mean;
	uint32_t dev;
	uint32_t dev_mb = 0;

	uint32_t i,j;
	int32_t	 blk;
	uint8_t const *ptr_cur;
	uint8_t const *ptr_ref;

	for(blk=0; blk<4; blk++)
	{
	  ptr_cur = cur + ((blk&2)?8:0)*stride + (blk&1?8:0);
	  ptr_ref = ref + ((blk&2)?8:0)*stride + (blk&1?8:0);
	  mean = 0;
	  dev = 0;

	  for (j = 0; j < 8; j++) {

		for (i = 0; i < 8; i++)
			mean += *(ptr_cur + i)-*(ptr_ref + i);

		ptr_cur += stride;
		ptr_ref += stride;
	  }

	  mean/=(8 * 8);
	  ptr_cur = cur + ((blk&2)?8:0)*stride + (blk&1?8:0);
	  ptr_ref = ref + ((blk&2)?8:0)*stride + (blk&1?8:0);

	  for (j = 0; j < 8; j++) {

		for (i = 0; i < 8; i++)
			dev += ABS(*(ptr_cur + i)-*(ptr_ref + i) - mean);

		ptr_cur += stride;
		ptr_ref += stride;
	  }

	  dev_mb += dev;

	}

	return dev_mb;
}
*/
/* to get the prediction error for the input mv*/
// Added by David, 2002

void MB_err(const uint32_t x, const uint32_t y, const uint8_t * const cur, const uint8_t * const ref,
			int32_t mv_x, int32_t mv_y, uint8_t * MB, const uint32_t stride)
{

	uint32_t i,j;
	uint8_t const *ptr_cur = cur+x*16+y*16*stride;
	uint8_t const *ptr_ref = ref+(x+mv_x)*16+(y+mv_y)*16*stride;

	for (j = 0; j < 16; j++) {
		for (i = 0; i < 16; i++)
			*MB++ = *(ptr_cur + i)-*(ptr_ref + i);

		ptr_cur += stride;
		ptr_ref += stride;
	}

}