mvmc.c

优化过的xvid1.1.2源代码

#include "MVGlobal.h"
#include "MVCommon.h"
#include "MVMc.h"

extern const uint32_t MTab[16];
extern const int32_t FIR_Tab_8[9][8];

#define   STORE(d,s)      (d) = (s)

/* memory copy functions*/
void transfer_16to8copy(uint8_t * const dst,
					              const int16_t * const src,
					              uint32_t stride)
{
	int i, j, tmp_src, tmp_dst;

	for (j = 0; j < 8; j++)
	{
		tmp_src = j << 3;
		tmp_dst = j * stride;
		for (i = 0; i < 8; i++)
		{
   			const int16_t pixel = src[tmp_src++];
		   	const uint8_t value = (uint8_t)( (pixel&~255) ? (-pixel)>>(8*sizeof(pixel)-1) : pixel );
			  dst[tmp_dst++] = value;
    }
	}
}

void transfer8x8_copy(uint8_t * const dst,
							  const uint8_t * const src,
							  const uint32_t stride)
{
	int j, i;

	for (j = 0; j < 8; ++j) 
	{
	    uint8_t *d = dst + j*stride;
	   	const uint8_t *s = src + j*stride;

		  for (i = 0; i < 8; ++i)
		 {
			  *d++ = *s++;
		 }
	}
}

void  transfer8x4_copy(uint8_t * const dst,
					   const uint8_t * const src,
					   const uint32_t stride)
{
	uint32_t j, tmp;
    uint32_t *s, *d;

	for (j = 0; j < 4; j++) 
	{
		tmp = j * stride;
		d= (uint32_t*)(dst + tmp);
		s = (uint32_t*)(src + tmp);
		*(d+0) = *(s+0);
		*(d+1) = *(s+1);
	}
}


/* 1/2 pix compensation */
void interpolate8x8_halfpel_h(uint8_t * const dst,
							   const uint8_t * const src,
							   const uint32_t stride,
							   const uint32_t rounding)
{
	int j, s, t, k = stride << 3;

	if (rounding)
	{
		for (j = 0; j < k; j+=stride)
		{
				s = j; t = j + 1;
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
		}
	} 
	else
	{
		for (j = 0; j < k; j+=stride)
		{
				s = j; t = j + 1;
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
		}
	}
}

void interpolate8x8_halfpel_v(uint8_t * const dst,
							   const uint8_t * const src,
							   const uint32_t stride,
							   const uint32_t rounding)
{
	int j, s, t, k = stride << 3;

	if (rounding)
	{
		for (j = 0; j < k; j+=stride)
		{
				s = j; t = j + stride;
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
		}
	} 
	else
	{
		for (j = 0; j < k; j+=stride)
		{
				s = j; t = j + stride;
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
		}
	}
}

void interpolate8x8_halfpel_hv(uint8_t * const dst,
								const uint8_t * const src,
								const uint32_t stride,
								const uint32_t rounding)
{
	int j, s, t, p, q, k = stride << 3;

	if (rounding)
	{
		for (j = 0; j < k; j+=stride) 
		{
				s = j; t = j + 1; p = j + stride; q = p + 1;
				
				dst[s++] = (uint8_t)((src[s] + src[t++] + src[p++] + src[q++] +1)>>2);
				dst[s++] = (uint8_t)((src[s] + src[t++] + src[p++] + src[q++] +1)>>2);
				dst[s++] = (uint8_t)((src[s] + src[t++] + src[p++] + src[q++] +1)>>2);
				dst[s++] = (uint8_t)((src[s] + src[t++] + src[p++] + src[q++] +1)>>2);
				dst[s++] = (uint8_t)((src[s] + src[t++] + src[p++] + src[q++] +1)>>2);
				dst[s++] = (uint8_t)((src[s] + src[t++] + src[p++] + src[q++] +1)>>2);
				dst[s++] = (uint8_t)((src[s] + src[t++] + src[p++] + src[q++] +1)>>2);
				dst[s++] = (uint8_t)((src[s] + src[t++] + src[p++] + src[q++] +1)>>2);
		}
	} 
	else
	{
		for (j = 0; j < k; j+=stride) 
		{
		    s = j; t = j + 1; p = j + stride; q = p + 1;
				
				dst[s++] = (uint8_t)((src[s] + src[t++] + src[p++] + src[q++] + 2)>>2);
				dst[s++] = (uint8_t)((src[s] + src[t++] + src[p++] + src[q++] + 2)>>2);
				dst[s++] = (uint8_t)((src[s] + src[t++] + src[p++] + src[q++] + 2)>>2);
				dst[s++] = (uint8_t)((src[s] + src[t++] + src[p++] + src[q++] + 2)>>2);
				dst[s++] = (uint8_t)((src[s] + src[t++] + src[p++] + src[q++] + 2)>>2);
				dst[s++] = (uint8_t)((src[s] + src[t++] + src[p++] + src[q++] + 2)>>2);
				dst[s++] = (uint8_t)((src[s] + src[t++] + src[p++] + src[q++] + 2)>>2);
				dst[s++] = (uint8_t)((src[s] + src[t++] + src[p++] + src[q++] + 2)>>2);
		}
	}
}

void interpolate8x8_switch(uint8_t * const cur,
						  const uint8_t * const refn,
						  const uint32_t x,
						  const uint32_t y,
						  const int32_t dx,
						  const int dy,
						  const uint32_t stride,
						  const uint32_t rounding)
{

	const uint8_t * const src = refn + (int)((y + (dy>>1)) * stride + x + (dx>>1));
	uint8_t * const dst = cur + (int)(y * stride + x);

	switch (((dx & 1) << 1) + (dy & 1))	{ /* ((dx%2)?2:0)+((dy%2)?1:0) */
	case 0:
		transfer8x8_copy(dst, src, stride);
		break;
	case 1:
		interpolate8x8_halfpel_v(dst, src, stride, rounding);
		break;
	case 2:
		interpolate8x8_halfpel_h(dst, src, stride, rounding);
		break;
	default:
		interpolate8x8_halfpel_hv(dst, src, stride, rounding);
		break;
	}
}

void interpolate16x16_switch(uint8_t * const cur,
							  const uint8_t * const refn,
							  const uint32_t x,
							  const uint32_t y,
							  const int32_t dx,
							  const int dy,
							  const uint32_t stride,
							  const uint32_t rounding)
{
			interpolate8x8_switch(cur, refn, x,   y,   dx, dy, stride, rounding);
			interpolate8x8_switch(cur, refn, x+8, y,   dx, dy, stride, rounding);
			interpolate8x8_switch(cur, refn, x,   y+8, dx, dy, stride, rounding);
			interpolate8x8_switch(cur, refn, x+8, y+8, dx, dy, stride, rounding);
}


void interpolate8x4_halfpel_h(uint8_t * const dst,
							   const uint8_t * const src,
							   const uint32_t stride,
							   const uint32_t rounding)
{
	int j, s, t, k = stride << 2;

	if (rounding) 
	{
		for (j = 0; j < k; j+=stride) 
		{
				s = j ; t = j + 1;
				
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
		}
	}
	else
	{
		for (j = 0; j < k; j+=stride) 
		{
		    s = j ; t = j + 1;
				
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				
		}
	}
}

void interpolate8x4_halfpel_v(uint8_t * const dst,
							   const uint8_t * const src,
							   const uint32_t stride,
							   const uint32_t rounding)
{
	int j , s, t, k = stride <<2;


	if (rounding) 
	{
		for (j = 0; j < k; j+=stride)
		 {
				s = j; t = j + stride;
				
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] )>>1);
		}
	} else 
	{
		for (j = 0; j < k; j+=stride) 
		{
				s = j; t = j + stride;
				
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
				dst[s++] = (uint8_t)((src[s] + src[t++] + 1)>>1);
		}
	}
}

void interpolate8x4_halfpel_hv(uint8_t * const dst,
								const uint8_t * const src,
								const uint32_t stride,
								const uint32_t rounding)
{
	int j, p, q, s, t, k = stride << 2;

	if (rounding) 
	{
		for (j = 0; j < k; j+=stride) 
		{
				p = j; q = j + 1; s = j + stride; t = s + 1; 
				dst[p++] = (uint8_t)((src[p] + src[q++] + src[s++] + src[t++] +1)>>2);
				dst[p++] = (uint8_t)((src[p] + src[q++] + src[s++] + src[t++] +1)>>2);
				dst[p++] = (uint8_t)((src[p] + src[q++] + src[s++] + src[t++] +1)>>2);
				dst[p++] = (uint8_t)((src[p] + src[q++] + src[s++] + src[t++] +1)>>2);
				dst[p++] = (uint8_t)((src[p] + src[q++] + src[s++] + src[t++] +1)>>2);
				dst[p++] = (uint8_t)((src[p] + src[q++] + src[s++] + src[t++] +1)>>2);
				dst[p++] = (uint8_t)((src[p] + src[q++] + src[s++] + src[t++] +1)>>2);
				dst[p++] = (uint8_t)((src[p] + src[q++] + src[s++] + src[t++] +1)>>2);
				
		}
	} 
	else
	{
		for (j = 0; j < k; j+=stride) 
		{
				p = j; q = j + 1; s = j + stride; t = s + 1; 
				dst[p++] = (uint8_t)((src[p] + src[q++] + src[s++] + src[t++] +2)>>2);
				dst[p++] = (uint8_t)((src[p] + src[q++] + src[s++] + src[t++] +2)>>2);
				dst[p++] = (uint8_t)((src[p] + src[q++] + src[s++] + src[t++] +2)>>2);
				dst[p++] = (uint8_t)((src[p] + src[q++] + src[s++] + src[t++] +2)>>2);
				dst[p++] = (uint8_t)((src[p] + src[q++] + src[s++] + src[t++] +2)>>2);
				dst[p++] = (uint8_t)((src[p] + src[q++] + src[s++] + src[t++] +2)>>2);
				dst[p++] = (uint8_t)((src[p] + src[q++] + src[s++] + src[t++] +2)>>2);