estimation_rd_based.c

从FFMPEG转换而来的H264解码程序,VC下编译..

		xvid_me_SquareSearch(Data->currentMV->x, Data->currentMV->y, Data, 255, CheckCandidateRD16);

	if (MotionFlags&XVID_ME_HALFPELREFINE16_RD)
		xvid_me_SubpelRefine(Data->currentMV[0], Data, CheckCandidateRD16, 0);

	if (Data->qpel) {
		if (MotionFlags&(XVID_ME_EXTSEARCH_RD | XVID_ME_HALFPELREFINE16_RD)) { /* there was halfpel-precision search */
			for(i = 0; i < 5; i++) if (bsad[i] > Data->iMinSAD[i]) {
				Data->currentQMV[i].x = 2 * Data->currentMV[i].x; /* we have found a better match */
				Data->currentQMV[i].y = 2 * Data->currentMV[i].y;
			}

			/* preparing for qpel-precision search */
			Data->qpel_precision = 1;
			get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4,
					pParam->width, pParam->height, Data->iFcode, 2);
		}
		if (MotionFlags & XVID_ME_QUARTERPELREFINE16_RD) {
			if (MotionFlags & XVID_ME_FASTREFINE16)
				FullRefine_Fast(Data, CheckCandidateRD16, 0);
			else 
				xvid_me_SubpelRefine(Data->currentQMV[0], Data, CheckCandidateRD16, 0);
		}
	}

	if (MotionFlags&XVID_ME_CHECKPREDICTION_RD) { /* let's check vector equal to prediction */
		VECTOR * v = Data->qpel ? Data->currentQMV : Data->currentMV;
		if (!MVequal(Data->predMV, *v))
			CheckCandidateRD16(Data->predMV.x, Data->predMV.y, Data, 255);
	}
	return Data->iMinSAD[0];
}

static int
findRD_inter4v(SearchData * const Data,
				MACROBLOCK * const pMB, const MACROBLOCK * const pMBs,
				const int x, const int y,
				const MBParam * const pParam, const uint32_t MotionFlags,
				const VECTOR * const backup)
{

	unsigned int cbp = 0, t = 0, i;
	
	/* minimum number of bits INTER4V can take is 2 (cbpy) + 3 (mcbpc) + 4*2 (vectors)*/
	int bits = (2+3+4*2)*BITS_MULT;
	SearchData Data2, *Data8 = &Data2;
	int sumx = 0, sumy = 0;
	int16_t *in = Data->dctSpace, *coeff = Data->dctSpace + 64;
	uint8_t * ptr;

	memcpy(Data8, Data, sizeof(SearchData));

	for (i = 0; i < 4; i++) { /* for all luma blocks */

		*Data8->iMinSAD = *(Data->iMinSAD + i + 1);
		*Data8->currentMV = *(Data->currentMV + i + 1);
		*Data8->currentQMV = *(Data->currentQMV + i + 1);
		Data8->Cur = Data->Cur + 8*((i&1) + (i>>1)*Data->iEdgedWidth);
		Data8->RefP[0] = Data->RefP[0] + 8*((i&1) + (i>>1)*Data->iEdgedWidth);
		Data8->RefP[2] = Data->RefP[2] + 8*((i&1) + (i>>1)*Data->iEdgedWidth);
		Data8->RefP[1] = Data->RefP[1] + 8*((i&1) + (i>>1)*Data->iEdgedWidth);
		Data8->RefP[3] = Data->RefP[3] + 8*((i&1) + (i>>1)*Data->iEdgedWidth);
		*Data8->cbp = (Data->cbp[1] & (1<<(5-i))) ? 1:0; /* copy corresponding cbp bit */
		Data8->lambda[0] = Data->lambda[i];

		if(Data->qpel) {
			Data8->predMV = get_qpmv2(pMBs, pParam->mb_width, 0, x, y, i);
			if (i != 0)	t = d_mv_bits(	Data8->currentQMV->x, Data8->currentQMV->y,
										Data8->predMV, Data8->iFcode, 0) - 2;
		} else {
			Data8->predMV = get_pmv2(pMBs, pParam->mb_width, 0, x, y, i);
			if (i != 0)	t = d_mv_bits(	Data8->currentMV->x, Data8->currentMV->y,
										Data8->predMV, Data8->iFcode, 0) - 2;
		}

		get_range(&Data8->min_dx, &Data8->max_dx, &Data8->min_dy, &Data8->max_dy, 2*x + (i&1), 2*y + (i>>1), 3,
					pParam->width, pParam->height, Data8->iFcode, Data8->qpel+1);

		*Data8->iMinSAD += BITS_MULT * t;

		Data8->qpel_precision = Data8->qpel;
		/* checking the vector which has been found by SAD-based 8x8 search (if it's different than the one found so far) */
		{
			VECTOR *v = Data8->qpel ? Data8->currentQMV : Data8->currentMV;
			if (!MVequal (*v, backup[i+1]) )
				CheckCandidateRD8(backup[i+1].x, backup[i+1].y, Data8, 255);
		}

		if (Data8->qpel) {
			int bsad = Data8->iMinSAD[0];
			int bx = Data8->currentQMV->x;
			int by = Data8->currentQMV->y;

			Data8->currentMV->x = Data8->currentQMV->x/2;
			Data8->currentMV->y = Data8->currentQMV->y/2;

			if (MotionFlags&XVID_ME_HALFPELREFINE8_RD || (MotionFlags&XVID_ME_EXTSEARCH8 && MotionFlags&XVID_ME_EXTSEARCH_RD)) { /* halfpixel motion search follows */
				Data8->qpel_precision = 0;
				get_range(&Data8->min_dx, &Data8->max_dx, &Data8->min_dy, &Data8->max_dy, 2*x + (i&1), 2*y + (i>>1), 3,
							pParam->width, pParam->height, Data8->iFcode - 1, 1);

				if (Data8->currentQMV->x & 1 || Data8->currentQMV->y & 1)
					CheckCandidateRD8(Data8->currentMV->x, Data8->currentMV->y, Data8, 255);

				if (MotionFlags & XVID_ME_EXTSEARCH8 && MotionFlags & XVID_ME_EXTSEARCH_RD)
					xvid_me_SquareSearch(Data8->currentMV->x, Data8->currentMV->x, Data8, 255, CheckCandidateRD8);

				if (MotionFlags & XVID_ME_HALFPELREFINE8_RD)
					xvid_me_SubpelRefine(Data->currentMV[0], Data8, CheckCandidateRD8, 0);

				if(bsad > *Data8->iMinSAD) { /* we have found a better match */
					bx = Data8->currentQMV->x = 2*Data8->currentMV->x;
					by = Data8->currentQMV->y = 2*Data8->currentMV->y;
					bsad = Data8->iMinSAD[0];
				}

				Data8->qpel_precision = 1;
				get_range(&Data8->min_dx, &Data8->max_dx, &Data8->min_dy, &Data8->max_dy, 2*x + (i&1), 2*y + (i>>1), 3,
							pParam->width, pParam->height, Data8->iFcode, 2);

			}

			if (MotionFlags & XVID_ME_QUARTERPELREFINE8_RD) {
				if (MotionFlags & XVID_ME_FASTREFINE8)
					FullRefine_Fast(Data8, CheckCandidateRD8, 0);
				else xvid_me_SubpelRefine(Data->currentQMV[0], Data8, CheckCandidateRD8, 0);
			}

			if (bsad <= Data->iMinSAD[0]) { 
				/* we have not found a better match */
				Data8->iMinSAD[0] = bsad;
				Data8->currentQMV->x = bx;
				Data8->currentQMV->y = by;
			}

		} else { /* not qpel */

			if (MotionFlags & XVID_ME_EXTSEARCH8 && MotionFlags & XVID_ME_EXTSEARCH_RD) /* extsearch */
				xvid_me_SquareSearch(Data8->currentMV->x, Data8->currentMV->x, Data8, 255, CheckCandidateRD8);

			if (MotionFlags & XVID_ME_HALFPELREFINE8_RD)
				xvid_me_SubpelRefine(Data->currentMV[0], Data8, CheckCandidateRD8, 0); /* halfpel refinement */
		}

		/* checking vector equal to predicion */
		if (i != 0 && MotionFlags & XVID_ME_CHECKPREDICTION_RD) {
			const VECTOR * v = Data->qpel ? Data8->currentQMV : Data8->currentMV;
			if (!MVequal(*v, Data8->predMV))
				CheckCandidateRD8(Data8->predMV.x, Data8->predMV.y, Data8, 255);
		}

		bits += *Data8->iMinSAD;
		if (bits >= Data->iMinSAD[0]) return bits; /* no chances for INTER4V */

		/* MB structures for INTER4V mode; we have to set them here, we don't have predictor anywhere else */
		if(Data->qpel) {
			pMB->pmvs[i].x = Data8->currentQMV->x - Data8->predMV.x;
			pMB->pmvs[i].y = Data8->currentQMV->y - Data8->predMV.y;
			pMB->qmvs[i] = *Data8->currentQMV;
			sumx += Data8->currentQMV->x/2;
			sumy += Data8->currentQMV->y/2;
		} else {
			pMB->pmvs[i].x = Data8->currentMV->x - Data8->predMV.x;
			pMB->pmvs[i].y = Data8->currentMV->y - Data8->predMV.y;
			sumx += Data8->currentMV->x;
			sumy += Data8->currentMV->y;
		}
		pMB->mvs[i] = *Data8->currentMV;
		pMB->sad8[i] = 4 * *Data8->iMinSAD;
		if (Data8->cbp[0]) cbp |= 1 << (5 - i);

	} /* end - for all luma blocks */

	bits += BITS_MULT * (xvid_cbpy_tab[15-(cbp>>2)].len - 2); /* 2 were added before */

	/* let's check chroma */
	sumx = (sumx >> 3) + roundtab_76[sumx & 0xf];
	sumy = (sumy >> 3) + roundtab_76[sumy & 0xf];

	/* chroma U */
	ptr = interpolate8x8_switch2(Data->RefQ + 64, Data->RefP[4], 0, 0, sumx, sumy, Data->iEdgedWidth/2, Data->rounding);
	transfer_8to16subro(in, Data->CurU, ptr, Data->iEdgedWidth/2);
	bits += Block_CalcBits(coeff, in, Data->dctSpace + 128, Data->iQuant, Data->quant_type, &cbp, 4,
							Data->scan_table, Data->lambda[4], Data->mpeg_quant_matrices, Data->quant_sq);

	if (bits >= *Data->iMinSAD) return bits;

	/* chroma V */
	ptr = interpolate8x8_switch2(Data->RefQ + 64, Data->RefP[5], 0, 0, sumx, sumy, Data->iEdgedWidth/2, Data->rounding);
	transfer_8to16subro(in, Data->CurV, ptr, Data->iEdgedWidth/2);
	bits += Block_CalcBits(coeff, in, Data->dctSpace + 128, Data->iQuant, Data->quant_type, &cbp, 5,
							Data->scan_table, Data->lambda[5], Data->mpeg_quant_matrices, Data->quant_sq);

	bits += BITS_MULT*(mcbpc_inter_tab[(MODE_INTER4V & 7) | ((cbp & 3) << 3)].len - 3); /* 3 were added before */

	*Data->cbp = cbp;
	return bits;
}

static int
findRD_intra(SearchData * const Data, MACROBLOCK * pMB,
			 const int x, const int y, const int mb_width)
{
	unsigned int cbp[2] = {0, 0}, bits[2], i;
	/* minimum number of bits that WILL be coded in intra - mcbpc 5, cby 2 acdc flag - 1 and DC coeffs - 4*3+2*2 */
	int bits1 = BITS_MULT*(5+2+1+4*3+2*2), bits2 = BITS_MULT*(5+2+1+4*3+2*2);
	unsigned int distortion = 0;

	int16_t *in = Data->dctSpace, * coeff = Data->dctSpace + 64, * dqcoeff = Data->dctSpace + 128;
	const uint32_t iQuant = Data->iQuant;
	int16_t predictors[6][8];

	for(i = 0; i < 4; i++) {
		int s = 8*((i&1) + (i>>1)*Data->iEdgedWidth);
		transfer_8to16copy(in, Data->Cur + s, Data->iEdgedWidth);
		

		distortion = Block_CalcBitsIntra(pMB, x, y, mb_width, i, in, coeff, dqcoeff,
								predictors[i], iQuant, Data->quant_type, bits, cbp, 
								Data->lambda[i], Data->mpeg_quant_matrices, Data->quant_sq);
		bits1 += distortion + BITS_MULT * bits[0];
		bits2 += distortion + BITS_MULT * bits[1];

		if (bits1 >= Data->iMinSAD[0] && bits2 >= Data->iMinSAD[0]) 
			return bits1;
	}

	bits1 += BITS_MULT * (xvid_cbpy_tab[cbp[0]>>2].len - 2); /* two bits were added before */
	bits2 += BITS_MULT * (xvid_cbpy_tab[cbp[1]>>2].len - 2);

	/*chroma U */
	transfer_8to16copy(in, Data->CurU, Data->iEdgedWidth/2);
	distortion = Block_CalcBitsIntra(pMB, x, y, mb_width, 4, in, coeff, dqcoeff,
									predictors[4], iQuant, Data->quant_type, bits, cbp, 
									Data->lambda[4], Data->mpeg_quant_matrices, Data->quant_sq);
	bits1 += distortion + BITS_MULT * bits[0];
	bits2 += distortion + BITS_MULT * bits[1];

	if (bits1 >= Data->iMinSAD[0] && bits2 >= Data->iMinSAD[0]) 
		return bits1;

	/* chroma V */
	transfer_8to16copy(in, Data->CurV, Data->iEdgedWidth/2);
	distortion = Block_CalcBitsIntra(pMB, x, y, mb_width, 5, in, coeff, dqcoeff,
									predictors[5], iQuant, Data->quant_type, bits, cbp, 
									Data->lambda[5], Data->mpeg_quant_matrices, Data->quant_sq);

	bits1 += distortion + BITS_MULT * bits[0];
	bits2 += distortion + BITS_MULT * bits[1];

	bits1 += BITS_MULT * (mcbpc_inter_tab[(MODE_INTRA & 7) | ((cbp[0] & 3) << 3)].len - 5); /* 5 bits were added before */
	bits2 += BITS_MULT * (mcbpc_inter_tab[(MODE_INTRA & 7) | ((cbp[1] & 3) << 3)].len - 5);

	*Data->cbp = bits1 <= bits2 ? cbp[0] : cbp[1];

	return MIN(bits1, bits2);
}


static int
findRD_gmc(SearchData * const Data, const IMAGE * const vGMC, const int x, const int y)
{
	/* minimum nubler of bits - 1 (mcbpc) + 2 (cby) + 1 (mcsel) */
	int bits = BITS_MULT * (1+2+1);
	unsigned int cbp = 0, i;
	int16_t *in = Data->dctSpace, * coeff = Data->dctSpace + 64;

	for(i = 0; i < 4; i++) {
		int s = 8*((i&1) + (i>>1)*Data->iEdgedWidth);
		transfer_8to16subro(in, Data->Cur + s, vGMC->y + s + 16*(x+y*Data->iEdgedWidth), Data->iEdgedWidth);
		bits += Block_CalcBits(coeff, in, Data->dctSpace + 128, Data->iQuant, Data->quant_type, &cbp, i,
								Data->scan_table, Data->lambda[i], Data->mpeg_quant_matrices, Data->quant_sq);
		if (bits >= Data->iMinSAD[0]) return bits;
	}

	bits += BITS_MULT * (xvid_cbpy_tab[15-(cbp>>2)].len - 2);

	/*chroma U */
	transfer_8to16subro(in, Data->CurU, vGMC->u + 8*(x+y*(Data->iEdgedWidth/2)), Data->iEdgedWidth/2);
	bits += Block_CalcBits(coeff, in, Data->dctSpace + 128, Data->iQuant, Data->quant_type, &cbp, 4,
							Data->scan_table, Data->lambda[4], Data->mpeg_quant_matrices, Data->quant_sq);

	if (bits >= Data->iMinSAD[0]) return bits;

	/* chroma V */
	transfer_8to16subro(in, Data->CurV , vGMC->v + 8*(x+y*(Data->iEdgedWidth/2)), Data->iEdgedWidth/2);
	bits += Block_CalcBits(coeff, in, Data->dctSpace + 128, Data->iQuant, Data->quant_type, &cbp, 5,
							Data->scan_table, Data->lambda[5], Data->mpeg_quant_matrices, Data->quant_sq);

	bits += BITS_MULT * (mcbpc_inter_tab[(MODE_INTER & 7) | ((cbp & 3) << 3)].len - 1);

	*Data->cbp = cbp;

	return bits;
}

void
xvid_me_ModeDecision_RD(SearchData * const Data,
				MACROBLOCK * const pMB,
				const MACROBLOCK * const pMBs,
				const int x, const int y,
				const MBParam * const pParam,
				const uint32_t MotionFlags,
				const uint32_t VopFlags,
				const uint32_t VolFlags,
				const IMAGE * const pCurrent,
				const IMAGE * const pRef,
				const IMAGE * const vGMC,
				const int coding_type)
{
	int mode = MODE_INTER;
	int mcsel = 0;
	int inter4v = (VopFlags & XVID_VOP_INTER4V) && (pMB->dquant == 0);
	const uint32_t iQuant = pMB->quant;
	int min_rd, intra_rd, i, cbp;
	VECTOR backup[5], *v;
	Data->iQuant = iQuant;
	Data->quant_sq = iQuant*iQuant;
	Data->scan_table = VopFlags & XVID_VOP_ALTERNATESCAN ?
						scan_tables[2] : scan_tables[0];

	pMB->mcsel = 0;

	v = Data->qpel ? Data->currentQMV : Data->currentMV;
	for (i = 0; i < 5; i++) {
		Data->iMinSAD[i] = 256*4096;
		backup[i] = v[i];