--- trunk/xvidcore/src/motion/estimation_pvop.c	2004/11/24 22:14:11	1563
+++ trunk/xvidcore/src/motion/estimation_pvop.c	2004/12/05 04:53:01	1564
@@ -21,7 +21,7 @@
  *  along with this program ; if not, write to the Free Software
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  *
- * $Id: estimation_pvop.c,v 1.8 2004-07-08 07:12:54 syskin Exp $
+ * $Id: estimation_pvop.c,v 1.9 2004-12-05 04:53:01 syskin Exp $
  *
  ****************************************************************************/
 
@@ -80,7 +80,7 @@
 	}
 
 	sad = sad16v(data->Cur, Reference, data->iEdgedWidth, data->temp);
-	t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0);
+	t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision);
 
 	sad += (data->lambda16 * t * sad)>>10;
 	data->temp[0] += (data->lambda8 * t * (data->temp[0] + NEIGH_8X8_BIAS))>>10;
@@ -127,7 +127,7 @@
 	}
 
 	sad = sad8(data->Cur, Reference, data->iEdgedWidth);
-	t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision, 0);
+	t = d_mv_bits(x, y, data->predMV, data->iFcode, data->qpel^data->qpel_precision);
 
 	sad += (data->lambda8 * t * (sad+NEIGH_8X8_BIAS))>>10;
 
@@ -138,65 +138,19 @@
 	}
 }
 
-static void
-CheckCandidate32(const int x, const int y, SearchData * const data, const unsigned int Direction)
-{
-	uint32_t t;
-	const uint8_t * Reference;
-	int sad;
-
-	if ( (!(x&1) && x !=0) || (!(y&1) && y !=0) || /* non-zero even value */
-		(x > data->max_dx) || (x < data->min_dx)
-		|| (y > data->max_dy) || (y < data->min_dy) ) return;
-
-	Reference = GetReference(x, y, data);
-	t = d_mv_bits(x, y, data->predMV, data->iFcode, 0, 1);
-
-	sad = sad32v_c(data->Cur, Reference, data->iEdgedWidth, data->temp);
-
-	sad += (data->lambda16 * t * sad) >> 10;
-	data->temp[0] += (data->lambda8 * t * (data->temp[0] + NEIGH_8X8_BIAS))>>10;
-
-	if (sad < data->iMinSAD[0]) {
-		data->iMinSAD[0] = sad;
-		data->currentMV[0].x = x; data->currentMV[0].y = y;
-		data->dir = Direction;
-	}
-
-	if (data->temp[0] < data->iMinSAD[1]) {
-		data->iMinSAD[1] = data->temp[0]; data->currentMV[1].x = x; data->currentMV[1].y = y; }
-	if (data->temp[1] < data->iMinSAD[2]) {
-		data->iMinSAD[2] = data->temp[1]; data->currentMV[2].x = x; data->currentMV[2].y = y; }
-	if (data->temp[2] < data->iMinSAD[3]) {
-		data->iMinSAD[3] = data->temp[2]; data->currentMV[3].x = x; data->currentMV[3].y = y; }
-	if (data->temp[3] < data->iMinSAD[4]) {
-		data->iMinSAD[4] = data->temp[3]; data->currentMV[4].x = x; data->currentMV[4].y = y; }
-}
-
 int
 xvid_me_SkipDecisionP(const IMAGE * current, const IMAGE * reference,
 							const int x, const int y,
-							const uint32_t stride, const uint32_t iQuant, int rrv)
+							const uint32_t stride, const uint32_t iQuant)
 {
 	int offset = (x + y*stride)*8;
-	if(!rrv) {
-		uint32_t sadC = sad8(current->u + offset,
-						reference->u + offset, stride);
-		if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0;
-		sadC += sad8(current->v + offset,
-						reference->v + offset, stride);
-		if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0;
-		return 1;
-
-	} else {
-		uint32_t sadC = sad16(current->u + 2*offset,
-						reference->u + 2*offset, stride, 256*4096);
-		if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP*4) return 0;
-		sadC += sad16(current->v + 2*offset,
-						reference->v + 2*offset, stride, 256*4096);
-		if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP*4) return 0;
-		return 1;
-	}
+	uint32_t sadC = sad8(current->u + offset,
+					reference->u + offset, stride);
+	if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0;
+	sadC += sad8(current->v + offset,
+					reference->v + offset, stride);
+	if (sadC > iQuant * MAX_CHROMA_SAD_FOR_SKIP) return 0;
+	return 1;
 }
 
 	/*
@@ -341,7 +295,7 @@
 	/* final skip decision, a.k.a. "the vector you found, really that good?" */
 	if (skip_possible && (skip_sad < (int)iQuant * MAX_SAD00_FOR_SKIP))
 		if ( (100*skip_sad)/(pMB->sad16+1) > FINAL_SKIP_THRESH)
-			if (Data->chroma || xvid_me_SkipDecisionP(pCurrent, pRef, x, y, Data->iEdgedWidth/2, iQuant, Data->rrv)) {
+			if (Data->chroma || xvid_me_SkipDecisionP(pCurrent, pRef, x, y, Data->iEdgedWidth/2, iQuant)) {
 				mode = MODE_NOT_CODED;
 				sad = 0;
 			}
@@ -373,29 +327,15 @@
 		if ((pMB - 1)->mode == MODE_INTRA ) InterBias -= 80;
 
 	if (Data->chroma) InterBias += 50; /* dev8(chroma) ??? <-- yes, we need dev8 (no big difference though) */
-	if (Data->rrv) InterBias *= 4;
 
 	if (InterBias < sad) {
-		int32_t deviation;
-		if (!Data->rrv)
-			deviation = dev16(Data->Cur, Data->iEdgedWidth);
-		else
-			deviation = dev16(Data->Cur, Data->iEdgedWidth) + /* dev32() */
-						dev16(Data->Cur+16, Data->iEdgedWidth) +
-						dev16(Data->Cur + 16*Data->iEdgedWidth, Data->iEdgedWidth) +
-						dev16(Data->Cur+16+16*Data->iEdgedWidth, Data->iEdgedWidth);
-
+		int32_t deviation = dev16(Data->Cur, Data->iEdgedWidth);
 		if (deviation < (sad - InterBias)) mode = MODE_INTRA;
 	}
 
 	pMB->cbp = 63;
 	pMB->sad16 = pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] = sad;
 
-	if (Data->rrv) {
-			Data->currentMV[0].x = RRV_MV_SCALEDOWN(Data->currentMV[0].x);
-			Data->currentMV[0].y = RRV_MV_SCALEDOWN(Data->currentMV[0].y);
-	}
-
 	if (mode == MODE_INTER && mcsel == 0) {
 		pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = Data->currentMV[0];
 
@@ -429,10 +369,8 @@
 
 static __inline void
 PreparePredictionsP(VECTOR * const pmv, int x, int y, int iWcount,
-			int iHcount, const MACROBLOCK * const prevMB, int rrv)
+			int iHcount, const MACROBLOCK * const prevMB)
 {
-	/* this function depends on get_pmvdata which means that it sucks. It should get the predictions by itself */
-	if (rrv) { iWcount /= 2; iHcount /= 2; }
 
 	if ( (y != 0) && (x < (iWcount-1)) ) {		/* [5] top-right neighbour */
 		pmv[5].x = EVEN(pmv[3].x);
@@ -457,14 +395,6 @@
 		pmv[6].x = EVEN((prevMB+1+iWcount)->mvs[0].x); /* [6] right-down neighbour in last frame */
 		pmv[6].y = EVEN((prevMB+1+iWcount)->mvs[0].y);
 	} else pmv[6].x = pmv[6].y = 0;
-
-	if (rrv) {
-		int i;
-		for (i = 0; i < 7; i++) {
-			pmv[i].x = RRV_MV_SCALEUP(pmv[i].x);
-			pmv[i].y = RRV_MV_SCALEUP(pmv[i].y);
-		}
-	}
 }
 
 static void
@@ -479,7 +409,6 @@
 {
 	int i = 0;
 	VECTOR vbest_q; int32_t sbest_q;
-	CheckFunc * CheckCandidate;
 	*Data->iMinSAD = *(OldData->iMinSAD + 1 + block);
 	*Data->currentMV = *(OldData->currentMV + 1 + block);
 	*Data->currentQMV = *(OldData->currentQMV + 1 + block);
@@ -487,11 +416,11 @@
 	if(Data->qpel) {
 		Data->predMV = get_qpmv2(pMBs, pParam->mb_width, 0, x/2, y/2, block);
 		if (block != 0)	i = d_mv_bits(	Data->currentQMV->x, Data->currentQMV->y,
-										Data->predMV, Data->iFcode, 0, 0);
+										Data->predMV, Data->iFcode, 0);
 	} else {
 		Data->predMV = get_pmv2(pMBs, pParam->mb_width, 0, x/2, y/2, block);
 		if (block != 0)	i = d_mv_bits(	Data->currentMV->x, Data->currentMV->y,
-										Data->predMV, Data->iFcode, 0, Data->rrv);
+										Data->predMV, Data->iFcode, 0);
 	}
 
 	*(Data->iMinSAD) += (Data->lambda8 * i * (*Data->iMinSAD + NEIGH_8X8_BIAS))>>10;
@@ -501,21 +430,17 @@
 		vbest_q = Data->currentQMV[0];
 		sbest_q = Data->iMinSAD[0];
 
-		if (Data->rrv) i = 16; else i = 8;
 
-		Data->RefP[0] = OldData->RefP[0] + i * ((block&1) + Data->iEdgedWidth*(block>>1));
-		Data->RefP[1] = OldData->RefP[1] + i * ((block&1) + Data->iEdgedWidth*(block>>1));
-		Data->RefP[2] = OldData->RefP[2] + i * ((block&1) + Data->iEdgedWidth*(block>>1));
-		Data->RefP[3] = OldData->RefP[3] + i * ((block&1) + Data->iEdgedWidth*(block>>1));
+		Data->RefP[0] = OldData->RefP[0] + 8 * ((block&1) + Data->iEdgedWidth*(block>>1));
+		Data->RefP[1] = OldData->RefP[1] + 8 * ((block&1) + Data->iEdgedWidth*(block>>1));
+		Data->RefP[2] = OldData->RefP[2] + 8 * ((block&1) + Data->iEdgedWidth*(block>>1));
+		Data->RefP[3] = OldData->RefP[3] + 8 * ((block&1) + Data->iEdgedWidth*(block>>1));
 
-		Data->Cur = OldData->Cur + i * ((block&1) + Data->iEdgedWidth*(block>>1));
+		Data->Cur = OldData->Cur + 8 * ((block&1) + Data->iEdgedWidth*(block>>1));
 		Data->qpel_precision = 0;
 
 		get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 3,
-					pParam->width, pParam->height, Data->iFcode - Data->qpel, 1, Data->rrv);
-
-		if (!Data->rrv) CheckCandidate = CheckCandidate8;
-		else CheckCandidate = CheckCandidate16no4v;
+					pParam->width, pParam->height, Data->iFcode - Data->qpel, 1);
 
 		if (MotionFlags & XVID_ME_EXTSEARCH8 && (!(MotionFlags & XVID_ME_EXTSEARCH_RD))) {
 
@@ -524,14 +449,14 @@
 				else if (MotionFlags & XVID_ME_ADVANCEDDIAMOND8) MainSearchPtr = xvid_me_AdvDiamondSearch;
 					else MainSearchPtr = xvid_me_DiamondSearch;
 
-			MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, 255, CheckCandidate);
+			MainSearchPtr(Data->currentMV->x, Data->currentMV->y, Data, 255, CheckCandidate8);
 		}
 
 		if(!Data->qpel) {
 			/* halfpel mode */
 			if (MotionFlags & XVID_ME_HALFPELREFINE8)
 				/* perform halfpel refine of current best vector */
-				xvid_me_SubpelRefine(Data->currentMV[0], Data, CheckCandidate, 0);
+				xvid_me_SubpelRefine(Data->currentMV[0], Data, CheckCandidate8, 0);
 		} else {
 			/* qpel mode */
 			Data->currentQMV->x = 2*Data->currentMV->x;
@@ -540,7 +465,7 @@
 			if(MotionFlags & XVID_ME_FASTREFINE8) {
 				/* fast */
 				get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 3,
-					pParam->width, pParam->height, Data->iFcode, 2, 0);
+					pParam->width, pParam->height, Data->iFcode, 2);
 				FullRefine_Fast(Data, CheckCandidate8, 0);
 			} else if(MotionFlags & XVID_ME_QUARTERPELREFINE8) {
 				/* full */
@@ -551,7 +476,7 @@
 				}
 
 				get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 3,
-					pParam->width, pParam->height, Data->iFcode, 2, 0);
+					pParam->width, pParam->height, Data->iFcode, 2);
 				Data->qpel_precision = 1;
 
 				xvid_me_SubpelRefine(Data->currentQMV[0], Data, CheckCandidate8, 0); /* qpel part */
@@ -563,10 +488,7 @@
 
 	}
 
-	if (Data->rrv) {
-			Data->currentMV->x = RRV_MV_SCALEDOWN(Data->currentMV->x);
-			Data->currentMV->y = RRV_MV_SCALEDOWN(Data->currentMV->y);
-	} else if(Data->qpel) {		
+	if(Data->qpel) {		
 		pMB->pmvs[block].x = Data->currentQMV->x - Data->predMV.x;
 		pMB->pmvs[block].y = Data->currentQMV->y - Data->predMV.y;
 		pMB->qmvs[block] = *Data->currentQMV;
@@ -608,22 +530,21 @@
 	CheckFunc * CheckCandidate;
 
 	get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4,
-						pParam->width, pParam->height, Data->iFcode - Data->qpel, 1, Data->rrv);
+						pParam->width, pParam->height, Data->iFcode - Data->qpel, 1);
 
 	get_pmvdata2(pMBs, pParam->mb_width, 0, x, y, pmv, Data->temp);
 
 	Data->chromaX = Data->chromaY = 0; /* chroma-sad cache */
-	i = Data->rrv ? 2 : 1;
-	Data->Cur = pCur->y + (x + y * Data->iEdgedWidth) * 16*i;
-	Data->CurV = pCur->v + (x + y * (Data->iEdgedWidth/2)) * 8*i;
-	Data->CurU = pCur->u + (x + y * (Data->iEdgedWidth/2)) * 8*i;
-
-	Data->RefP[0] = pRef->y + (x + Data->iEdgedWidth*y) * 16*i;
-	Data->RefP[2] = pRefH + (x + Data->iEdgedWidth*y) * 16*i;
-	Data->RefP[1] = pRefV + (x + Data->iEdgedWidth*y) * 16*i;
-	Data->RefP[3] = pRefHV + (x + Data->iEdgedWidth*y) * 16*i;
-	Data->RefP[4] = pRef->u + (x + y * (Data->iEdgedWidth/2)) * 8*i;
-	Data->RefP[5] = pRef->v + (x + y * (Data->iEdgedWidth/2)) * 8*i;
+	Data->Cur = pCur->y + (x + y * Data->iEdgedWidth) * 16;
+	Data->CurV = pCur->v + (x + y * (Data->iEdgedWidth/2)) * 8;
+	Data->CurU = pCur->u + (x + y * (Data->iEdgedWidth/2)) * 8;
+
+	Data->RefP[0] = pRef->y + (x + Data->iEdgedWidth*y) * 16;
+	Data->RefP[2] = pRefH + (x + Data->iEdgedWidth*y) * 16;
+	Data->RefP[1] = pRefV + (x + Data->iEdgedWidth*y) * 16;
+	Data->RefP[3] = pRefHV + (x + Data->iEdgedWidth*y) * 16;
+	Data->RefP[4] = pRef->u + (x + y * (Data->iEdgedWidth/2)) * 8;
+	Data->RefP[5] = pRef->v + (x + y * (Data->iEdgedWidth/2)) * 8;
 
 	Data->lambda16 = xvid_me_lambda_vec16[pMB->quant];
 	Data->lambda8 = xvid_me_lambda_vec8[pMB->quant];
@@ -635,7 +556,7 @@
 	if (Data->qpel) Data->predMV = get_qpmv2(pMBs, pParam->mb_width, 0, x, y, 0);
 	else Data->predMV = pmv[0];
 
-	i = d_mv_bits(0, 0, Data->predMV, Data->iFcode, 0, 0);
+	i = d_mv_bits(0, 0, Data->predMV, Data->iFcode, 0);
 	Data->iMinSAD[0] = pMB->sad16 + ((Data->lambda16 * i * pMB->sad16)>>10);
 	Data->iMinSAD[1] = pMB->sad8[0] + ((Data->lambda8 * i * (pMB->sad8[0]+NEIGH_8X8_BIAS)) >> 10);
 	Data->iMinSAD[2] = pMB->sad8[1];
@@ -650,12 +571,10 @@
 		threshA = 512;
 
 	PreparePredictionsP(pmv, x, y, pParam->mb_width, pParam->mb_height,
-					prevMBs + x + y * pParam->mb_width, Data->rrv);
+					prevMBs + x + y * pParam->mb_width);
 
-	if (!Data->rrv) {
-		if (inter4v) CheckCandidate = CheckCandidate16;
-			else CheckCandidate = CheckCandidate16no4v; /* for extra speed */
-	} else CheckCandidate = CheckCandidate32;
+	if (inter4v) CheckCandidate = CheckCandidate16;
+	else CheckCandidate = CheckCandidate16no4v; /* for extra speed */
 
 /* main loop. checking all predictions (but first, which is 0,0 and has been checked in MotionEstimation())*/
 
@@ -690,9 +609,6 @@
 			if (Data->qpel) {
 				startMV.x /= 2;
 				startMV.y /= 2;
-			} else if (Data->rrv) {
-				startMV.x = RRV_MV_SCALEUP(startMV.x);
-				startMV.y = RRV_MV_SCALEUP(startMV.y);
 			}
 			if (!(MVequal(startMV, backupMV))) {
 				bSAD = Data->iMinSAD[0]; Data->iMinSAD[0] = MV_MAX_ERROR;
@@ -701,7 +617,8 @@
 				xvid_me_DiamondSearch(startMV.x, startMV.y, Data, 255, CheckCandidate);
 				if (bSAD < Data->iMinSAD[0]) {
 					Data->currentMV[0] = backupMV;
-					Data->iMinSAD[0] = bSAD; }
+					Data->iMinSAD[0] = bSAD; 
+				}
 			}
 
 			backupMV = Data->currentMV[0];
@@ -734,7 +651,7 @@
 		if(MotionFlags & XVID_ME_FASTREFINE16 && MotionFlags & XVID_ME_QUARTERPELREFINE16) {
 			/* fast */
 			get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4,
-						pParam->width, pParam->height, Data->iFcode, 2, 0);				
+						pParam->width, pParam->height, Data->iFcode, 2);
 			FullRefine_Fast(Data, CheckCandidate, 0);
 		} else {
 			if(MotionFlags & (XVID_ME_QUARTERPELREFINE16 | XVID_ME_QUARTERPELREFINE16_RD)) {
@@ -747,7 +664,7 @@
 					}
 				}
 				get_range(&Data->min_dx, &Data->max_dx, &Data->min_dy, &Data->max_dy, x, y, 4,
-							pParam->width, pParam->height, Data->iFcode, 2, 0);
+							pParam->width, pParam->height, Data->iFcode, 2);
 				Data->qpel_precision = 1;
 				if(MotionFlags & XVID_ME_QUARTERPELREFINE16)
 					xvid_me_SubpelRefine(Data->currentQMV[0], Data, CheckCandidate, 0); /* qpel part */
@@ -755,7 +672,7 @@
 		}
 	}
 
-	if (Data->iMinSAD[0] < (int32_t)pMB->quant * 30* ((MotionFlags & XVID_ME_FASTREFINE16) ? 8 : 1))
+	if (Data->iMinSAD[0] < (int32_t)pMB->quant * 30 * ((MotionFlags & XVID_ME_FASTREFINE16) ? 8 : 1))
 		inter4v = 0;
 
 	if (inter4v) {
@@ -822,7 +739,7 @@
 	if (!(VopFlags & XVID_VOP_HALFPEL))
 		Flags &= ~(XVID_ME_EXTSEARCH16+XVID_ME_HALFPELREFINE16+XVID_ME_HALFPELREFINE8+XVID_ME_HALFPELREFINE16_RD+XVID_ME_HALFPELREFINE8_RD);
 
-	if ((VopFlags & XVID_VOP_GREYSCALE) || (VopFlags & XVID_VOP_REDUCED))
+	if (VopFlags & XVID_VOP_GREYSCALE)
 		Flags &= ~(XVID_ME_CHROMA_PVOP + XVID_ME_CHROMA_BVOP);
 
 	if (Flags & XVID_ME_FASTREFINE8)
@@ -848,17 +765,15 @@
 	const IMAGE *const pCurrent = &current->image;
 	const IMAGE *const pRef = &reference->image;
 
-	uint32_t mb_width = pParam->mb_width;
-	uint32_t mb_height = pParam->mb_height;
+	const uint32_t mb_width = pParam->mb_width;
+	const uint32_t mb_height = pParam->mb_height;
 	const uint32_t iEdgedWidth = pParam->edged_width;
 	const uint32_t MotionFlags = MakeGoodMotionFlags(current->motion_flags, current->vop_flags, current->vol_flags);
 	int stat_thresh = 0;
 
 	uint32_t x, y;
-	uint32_t iIntra = 0;
 	int32_t sad00;
 	int skip_thresh = INITIAL_SKIP_THRESH * \
-		(current->vop_flags & XVID_VOP_REDUCED ? 4:1) * \
 		(current->vop_flags & XVID_VOP_MODEDECISION_RD ? 2:1);
 
 	/* some pre-initialized thingies for SearchP */
@@ -870,17 +785,10 @@
 	Data.rounding = pParam->m_rounding_type;
 	Data.qpel = (current->vol_flags & XVID_VOL_QUARTERPEL ? 1:0);
 	Data.chroma = MotionFlags & XVID_ME_CHROMA_PVOP;
-	Data.rrv = (current->vop_flags & XVID_VOP_REDUCED) ? 1:0;
 	Data.dctSpace = dct_space;
 	Data.quant_type = !(pParam->vol_flags & XVID_VOL_MPEGQUANT);
 	Data.mpeg_quant_matrices = pParam->mpeg_quant_matrices;
 
-	if ((current->vop_flags & XVID_VOP_REDUCED)) {
-		mb_width = (pParam->width + 31) / 32;
-		mb_height = (pParam->height + 31) / 32;
-		Data.qpel = 0;
-	}
-
 	Data.RefQ = pRefV->u; /* a good place, also used in MC (for similar purpose) */
 	if (sadInit) (*sadInit) ();
 
@@ -889,15 +797,10 @@
 			MACROBLOCK *pMB = &pMBs[x + y * pParam->mb_width];
 			MACROBLOCK *prevMB = &reference->mbs[x + y * pParam->mb_width];
 
-			if (!Data.rrv) pMB->sad16 =
+			pMB->sad16 =
 				sad16v(pCurrent->y + (x + y * iEdgedWidth) * 16,
 							pRef->y + (x + y * iEdgedWidth) * 16,
-							pParam->edged_width, pMB->sad8 );
-
-			else pMB->sad16 =
-				sad32v_c(pCurrent->y + (x + y * iEdgedWidth) * 32,
-							pRef->y + (x + y * iEdgedWidth) * 32,
-							pParam->edged_width, pMB->sad8 );
+							pParam->edged_width, pMB->sad8);
 			
 			sad00 = 4*MAX(MAX(pMB->sad8[0], pMB->sad8[1]), MAX(pMB->sad8[2], pMB->sad8[3]));
 
@@ -911,10 +814,9 @@
 			}
 
 			/* initial skip decision */
-			/* no early skip for GMC (global vector = skip vector is unknown!)  */
 			if (current->coding_type != S_VOP)	{ /* no fast SKIP for S(GMC)-VOPs */
 				if (pMB->dquant == 0 && sad00 < pMB->quant * skip_thresh)
-					if (Data.chroma || xvid_me_SkipDecisionP(pCurrent, pRef, x, y, iEdgedWidth/2, pMB->quant, Data.rrv)) {
+					if (Data.chroma || xvid_me_SkipDecisionP(pCurrent, pRef, x, y, iEdgedWidth/2, pMB->quant)) {
 						ZeroMacroblockP(pMB, sad00);
 						pMB->mode = MODE_NOT_CODED;
 						continue;
@@ -966,8 +868,6 @@
 								pCurrent, pRef, pGMC, current->coding_type, sad00);
 
 
-			if (pMB->mode == MODE_INTRA)
-				if (++iIntra > iLimit) return 1;
 		}
 	}
 	return 0;