interpolate8x8.c

这是一个压缩解压包,用C语言进行编程的,里面有详细的源代码.

/*****************************************************************************
 *
 *	XVID MPEG-4 VIDEO CODEC
 *	- 8x8 block-based halfpel interpolation -
 *
 *  Copyright(C) 2001-2003 Peter Ross <[e-mail]>
 *
 *  This program is free software ; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation ; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY ; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program ; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 *
 * $Id: interpolate8x8.c,v 1.15 2005/09/13 12:12:15 suxen_drol Exp $
 *
 ****************************************************************************/

#include "../portab.h"
#include "../global.h"
#include "interpolate8x8.h"

/* function pointers */
INTERPOLATE8X8_PTR interpolate8x8_halfpel_h;
INTERPOLATE8X8_PTR interpolate8x8_halfpel_v;
INTERPOLATE8X8_PTR interpolate8x8_halfpel_hv;

INTERPOLATE8X8_PTR interpolate8x4_halfpel_h;
INTERPOLATE8X8_PTR interpolate8x4_halfpel_v;
INTERPOLATE8X8_PTR interpolate8x4_halfpel_hv;

INTERPOLATE8X8_PTR interpolate8x8_halfpel_add;
INTERPOLATE8X8_PTR interpolate8x8_halfpel_h_add;
INTERPOLATE8X8_PTR interpolate8x8_halfpel_v_add;
INTERPOLATE8X8_PTR interpolate8x8_halfpel_hv_add;

INTERPOLATE8X8_AVG2_PTR interpolate8x8_avg2;
INTERPOLATE8X8_AVG4_PTR interpolate8x8_avg4;

INTERPOLATE_LOWPASS_PTR interpolate8x8_lowpass_h;
INTERPOLATE_LOWPASS_PTR interpolate8x8_lowpass_v;

INTERPOLATE_LOWPASS_PTR interpolate16x16_lowpass_h;
INTERPOLATE_LOWPASS_PTR interpolate16x16_lowpass_v;

INTERPOLATE_LOWPASS_HV_PTR interpolate8x8_lowpass_hv;
INTERPOLATE_LOWPASS_HV_PTR interpolate16x16_lowpass_hv;

INTERPOLATE8X8_6TAP_LOWPASS_PTR interpolate8x8_6tap_lowpass_h;
INTERPOLATE8X8_6TAP_LOWPASS_PTR interpolate8x8_6tap_lowpass_v;

void
interpolate8x8_avg2_c(uint8_t * dst, const uint8_t * src1, const uint8_t *src2, const uint32_t stride, const uint32_t rounding, const uint32_t height)
{
    uint32_t i;
	const int32_t round = 1 - rounding;

    for(i = 0; i < height; i++) {
        dst[0] = (src1[0] + src2[0] + round) >> 1;
        dst[1] = (src1[1] + src2[1] + round) >> 1;
        dst[2] = (src1[2] + src2[2] + round) >> 1;
        dst[3] = (src1[3] + src2[3] + round) >> 1;
        dst[4] = (src1[4] + src2[4] + round) >> 1;
        dst[5] = (src1[5] + src2[5] + round) >> 1;
        dst[6] = (src1[6] + src2[6] + round) >> 1;
        dst[7] = (src1[7] + src2[7] + round) >> 1;

        dst += stride;
        src1 += stride;
        src2 += stride;
    }
}

void
interpolate8x8_halfpel_add_c(uint8_t * const dst, const uint8_t * const src, const uint32_t stride, const uint32_t rounding)
{
	interpolate8x8_avg2_c(dst, dst, src, stride, 0, 8);
}

void interpolate8x8_avg4_c(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, const uint8_t *src3, const uint8_t *src4, const uint32_t stride, const uint32_t rounding)
{
    int32_t i;
	const int32_t round = 2 - rounding;

    for(i = 0; i < 8; i++) {
        dst[0] = (src1[0] + src2[0] + src3[0] + src4[0] + round) >> 2;
        dst[1] = (src1[1] + src2[1] + src3[1] + src4[1] + round) >> 2;
        dst[2] = (src1[2] + src2[2] + src3[2] + src4[2] + round) >> 2;
        dst[3] = (src1[3] + src2[3] + src3[3] + src4[3] + round) >> 2;
        dst[4] = (src1[4] + src2[4] + src3[4] + src4[4] + round) >> 2;
        dst[5] = (src1[5] + src2[5] + src3[5] + src4[5] + round) >> 2;
        dst[6] = (src1[6] + src2[6] + src3[6] + src4[6] + round) >> 2;
        dst[7] = (src1[7] + src2[7] + src3[7] + src4[7] + round) >> 2;

		dst += stride;
        src1 += stride;
        src2 += stride;
        src3 += stride;
        src4 += stride;
    }
}

/* dst = interpolate(src) */

void
interpolate8x8_halfpel_h_c(uint8_t * const dst,
						   const uint8_t * const src,
						   const uint32_t stride,
						   const uint32_t rounding)
{
	uintptr_t j;

	if (rounding) {
		for (j = 0; j < 8*stride; j+=stride) {
				dst[j + 0] = (uint8_t)((src[j + 0] + src[j + 1] )>>1);
				dst[j + 1] = (uint8_t)((src[j + 1] + src[j + 2] )>>1);
				dst[j + 2] = (uint8_t)((src[j + 2] + src[j + 3] )>>1);
				dst[j + 3] = (uint8_t)((src[j + 3] + src[j + 4] )>>1);
				dst[j + 4] = (uint8_t)((src[j + 4] + src[j + 5] )>>1);
				dst[j + 5] = (uint8_t)((src[j + 5] + src[j + 6] )>>1);
				dst[j + 6] = (uint8_t)((src[j + 6] + src[j + 7] )>>1);
				dst[j + 7] = (uint8_t)((src[j + 7] + src[j + 8] )>>1);
		}
	} else {
		for (j = 0; j < 8*stride; j+=stride) {
				dst[j + 0] = (uint8_t)((src[j + 0] + src[j + 1] + 1)>>1);
				dst[j + 1] = (uint8_t)((src[j + 1] + src[j + 2] + 1)>>1);
				dst[j + 2] = (uint8_t)((src[j + 2] + src[j + 3] + 1)>>1);
				dst[j + 3] = (uint8_t)((src[j + 3] + src[j + 4] + 1)>>1);
				dst[j + 4] = (uint8_t)((src[j + 4] + src[j + 5] + 1)>>1);
				dst[j + 5] = (uint8_t)((src[j + 5] + src[j + 6] + 1)>>1);
				dst[j + 6] = (uint8_t)((src[j + 6] + src[j + 7] + 1)>>1);
				dst[j + 7] = (uint8_t)((src[j + 7] + src[j + 8] + 1)>>1);
		}
	}
}

/* dst = interpolate(src) */

void
interpolate8x4_halfpel_h_c(uint8_t * const dst,
						   const uint8_t * const src,
						   const uint32_t stride,
						   const uint32_t rounding)
{
	uintptr_t j;

	if (rounding) {
		for (j = 0; j < 4*stride; j+=stride) {
				dst[j + 0] = (uint8_t)((src[j + 0] + src[j + 1] )>>1);
				dst[j + 1] = (uint8_t)((src[j + 1] + src[j + 2] )>>1);
				dst[j + 2] = (uint8_t)((src[j + 2] + src[j + 3] )>>1);
				dst[j + 3] = (uint8_t)((src[j + 3] + src[j + 4] )>>1);
				dst[j + 4] = (uint8_t)((src[j + 4] + src[j + 5] )>>1);
				dst[j + 5] = (uint8_t)((src[j + 5] + src[j + 6] )>>1);
				dst[j + 6] = (uint8_t)((src[j + 6] + src[j + 7] )>>1);
				dst[j + 7] = (uint8_t)((src[j + 7] + src[j + 8] )>>1);
		}
	} else {
		for (j = 0; j < 4*stride; j+=stride) {
				dst[j + 0] = (uint8_t)((src[j + 0] + src[j + 1] + 1)>>1);
				dst[j + 1] = (uint8_t)((src[j + 1] + src[j + 2] + 1)>>1);
				dst[j + 2] = (uint8_t)((src[j + 2] + src[j + 3] + 1)>>1);
				dst[j + 3] = (uint8_t)((src[j + 3] + src[j + 4] + 1)>>1);
				dst[j + 4] = (uint8_t)((src[j + 4] + src[j + 5] + 1)>>1);
				dst[j + 5] = (uint8_t)((src[j + 5] + src[j + 6] + 1)>>1);
				dst[j + 6] = (uint8_t)((src[j + 6] + src[j + 7] + 1)>>1);
				dst[j + 7] = (uint8_t)((src[j + 7] + src[j + 8] + 1)>>1);
		}
	}
}

/* dst = (dst + interpolate(src)/2 */

void
interpolate8x8_halfpel_h_add_c(uint8_t * const dst,
						   const uint8_t * const src,
						   const uint32_t stride,
						   const uint32_t rounding)
{
	uintptr_t j;

	if (rounding) {
		for (j = 0; j < 8*stride; j+=stride) {
				dst[j + 0] = (uint8_t)((((src[j + 0] + src[j + 1] )>>1) + dst[j+0] + 1)>>1);
				dst[j + 1] = (uint8_t)((((src[j + 1] + src[j + 2] )>>1) + dst[j+1] + 1)>>1);
				dst[j + 2] = (uint8_t)((((src[j + 2] + src[j + 3] )>>1) + dst[j+2] + 1)>>1);
				dst[j + 3] = (uint8_t)((((src[j + 3] + src[j + 4] )>>1) + dst[j+3] + 1)>>1);
				dst[j + 4] = (uint8_t)((((src[j + 4] + src[j + 5] )>>1) + dst[j+4] + 1)>>1);
				dst[j + 5] = (uint8_t)((((src[j + 5] + src[j + 6] )>>1) + dst[j+5] + 1)>>1);
				dst[j + 6] = (uint8_t)((((src[j + 6] + src[j + 7] )>>1) + dst[j+6] + 1)>>1);
				dst[j + 7] = (uint8_t)((((src[j + 7] + src[j + 8] )>>1) + dst[j+7] + 1)>>1);
		}
	} else {
		for (j = 0; j < 8*stride; j+=stride) {
				dst[j + 0] = (uint8_t)((((src[j + 0] + src[j + 1] + 1)>>1) + dst[j+0] + 1)>>1);
				dst[j + 1] = (uint8_t)((((src[j + 1] + src[j + 2] + 1)>>1) + dst[j+1] + 1)>>1);
				dst[j + 2] = (uint8_t)((((src[j + 2] + src[j + 3] + 1)>>1) + dst[j+2] + 1)>>1);
				dst[j + 3] = (uint8_t)((((src[j + 3] + src[j + 4] + 1)>>1) + dst[j+3] + 1)>>1);
				dst[j + 4] = (uint8_t)((((src[j + 4] + src[j + 5] + 1)>>1) + dst[j+4] + 1)>>1);
				dst[j + 5] = (uint8_t)((((src[j + 5] + src[j + 6] + 1)>>1) + dst[j+5] + 1)>>1);
				dst[j + 6] = (uint8_t)((((src[j + 6] + src[j + 7] + 1)>>1) + dst[j+6] + 1)>>1);
				dst[j + 7] = (uint8_t)((((src[j + 7] + src[j + 8] + 1)>>1) + dst[j+7] + 1)>>1);
		}
	}
}

/* dst = interpolate(src) */

void
interpolate8x8_halfpel_v_c(uint8_t * const dst,
						   const uint8_t * const src,
						   const uint32_t stride,
						   const uint32_t rounding)
{
	uintptr_t j;


	if (rounding) {
		for (j = 0; j < 8*stride; j+=stride) {
				dst[j + 0] = (uint8_t)((src[j + 0] + src[j + stride + 0] )>>1);
				dst[j + 1] = (uint8_t)((src[j + 1] + src[j + stride + 1] )>>1);