--- encoder.c	2002/03/29 07:08:09	1.16
+++ encoder.c	2002/04/15 08:03:50	1.25
@@ -1,3 +1,5 @@
+// 14.04.2002	added FrameCodeB()
+
 #include <stdlib.h>
 #include <stdio.h>
 #include <math.h>
@@ -78,11 +80,17 @@
 		pParam->fincr = (int)(pParam->fincr / div);
 	}
 
-	if (pParam->bitrate <= 0)
-		pParam->bitrate = 900000;
+	if (pParam->rc_bitrate <= 0)
+		pParam->rc_bitrate = 900000;
+
+	if (pParam->rc_reaction_delay_factor <= 0)
+		pParam->rc_reaction_delay_factor = 16;
+
+	if (pParam->rc_averaging_period <= 0)
+		pParam->rc_averaging_period = 100;
 
-	if (pParam->rc_buffersize <= 0)
-		pParam->rc_buffersize = 16;
+	if (pParam->rc_buffer <= 0)
+		pParam->rc_buffer = 100;
 
 	if ((pParam->min_quantizer <= 0) || (pParam->min_quantizer > 31))
 		pParam->min_quantizer = 1;
@@ -116,60 +124,49 @@
 
 	pEnc->mbParam.quant = 4;
 
-	pEnc->bitrate = pParam->bitrate;
+	pEnc->bitrate = pParam->rc_bitrate;
 
 	pEnc->iFrameNum = 0;
 	pEnc->iMaxKeyInterval = pParam->max_key_interval;
 
-	if (image_create(&pEnc->sCurrent, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0)
-	{
-		xvid_free(pEnc);
-		return XVID_ERR_MEMORY;
-	}
-
-	if (image_create(&pEnc->sReference, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0)
-	{
-		image_destroy(&pEnc->sCurrent, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
-		xvid_free(pEnc);
-		return XVID_ERR_MEMORY;
-	}
-
-	if (image_create(&pEnc->vInterH, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0)
-	{
-		image_destroy(&pEnc->sCurrent, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
-		image_destroy(&pEnc->sReference, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
-		xvid_free(pEnc);
-		return XVID_ERR_MEMORY;
-	}
-
-	if (image_create(&pEnc->vInterV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0)
-	{
-		image_destroy(&pEnc->sCurrent, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
-		image_destroy(&pEnc->sReference, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
-		image_destroy(&pEnc->vInterH, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
-		xvid_free(pEnc);
-		return XVID_ERR_MEMORY;
-	}
-
-	if (image_create(&pEnc->vInterHV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0)
-	{
-		image_destroy(&pEnc->sCurrent, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
-		image_destroy(&pEnc->sReference, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
-		image_destroy(&pEnc->vInterH, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
-		image_destroy(&pEnc->vInterV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
-		xvid_free(pEnc);
-		return XVID_ERR_MEMORY;
-	}
+	/* try to allocate memory */
 
-	pEnc->pMBs = xvid_malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width * pEnc->mbParam.mb_height, CACHE_LINE);
-	if (pEnc->pMBs == NULL)
+	pEnc->sCurrent.y	=	pEnc->sCurrent.u	=	pEnc->sCurrent.v	= NULL;
+	pEnc->sReference.y	=	pEnc->sReference.u	=	pEnc->sReference.v	= NULL;
+	pEnc->vInterH.y		=	pEnc->vInterH.u		=	pEnc->vInterH.v		= NULL;
+	pEnc->vInterV.y		=	pEnc->vInterV.u		=	pEnc->vInterV.v		= NULL;
+	pEnc->vInterVf.y	=	pEnc->vInterVf.u	=	pEnc->vInterVf.v	= NULL;
+	pEnc->vInterHV.y	=	pEnc->vInterHV.u	=	pEnc->vInterHV.v	= NULL;
+	pEnc->vInterHVf.y	=	pEnc->vInterHVf.u	=	pEnc->vInterHVf.v	= NULL;
+
+	pEnc->pMBs = NULL;
+
+	if (image_create(&pEnc->sCurrent, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
+		image_create(&pEnc->sReference, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
+		image_create(&pEnc->vInterH, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
+		image_create(&pEnc->vInterV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
+		image_create(&pEnc->vInterVf, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
+		image_create(&pEnc->vInterHV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
+		image_create(&pEnc->vInterHVf, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
+#ifdef _DEBUG
+		image_create(&pEnc->sOriginal, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
+#endif
+		(pEnc->pMBs = xvid_malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width * pEnc->mbParam.mb_height, CACHE_LINE)) == NULL)
 	{
 		image_destroy(&pEnc->sCurrent, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
 		image_destroy(&pEnc->sReference, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
 		image_destroy(&pEnc->vInterH, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
 		image_destroy(&pEnc->vInterV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
+		image_destroy(&pEnc->vInterVf, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
 		image_destroy(&pEnc->vInterHV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
-		xvid_free(pEnc);
+		image_destroy(&pEnc->vInterHVf, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
+#ifdef _DEBUG
+		image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
+#endif
+		if (pEnc)
+		{
+			xvid_free(pEnc);
+		}
 		return XVID_ERR_MEMORY;
 	}
 
@@ -181,13 +178,13 @@
 
 	pParam->handle = (void *)pEnc;
 
-	if (pParam->bitrate)
+	if (pParam->rc_bitrate)
 	{
-		RateControlInit(pParam->bitrate, pParam->rc_buffersize, pParam->fbase * 100 / pParam->fincr,
-				pParam->max_quantizer, pParam->min_quantizer);
+		RateControlInit(pParam->rc_bitrate, pParam->rc_reaction_delay_factor,
+			pParam->rc_averaging_period, pParam->rc_buffer, pParam->fbase * 1000 / pParam->fincr,
+			pParam->max_quantizer, pParam->min_quantizer);
 	}
 
-	create_vlc_tables();
 	init_timer();
 
 	return XVID_ERR_OK;
@@ -205,11 +202,14 @@
 	image_destroy(&pEnc->sReference, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
 	image_destroy(&pEnc->vInterH, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
 	image_destroy(&pEnc->vInterV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
+	image_destroy(&pEnc->vInterVf, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
 	image_destroy(&pEnc->vInterHV, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
+	image_destroy(&pEnc->vInterHVf, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
+#ifdef _DEBUG
+		image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
+#endif
 	xvid_free(pEnc);
 
-	destroy_vlc_tables();
-
 	return XVID_ERR_OK;
 }
 
@@ -219,6 +219,10 @@
 	Bitstream bs;
 	uint32_t bits;
 	uint16_t write_vol_header = 0;
+#ifdef _DEBUG
+	float psnr;
+	uint8_t temp[100];
+#endif
 
 	start_global_timer();
 
@@ -229,6 +233,7 @@
 
 	pEnc->mbParam.global_flags = pFrame->general;
 	pEnc->mbParam.motion_flags = pFrame->motion;
+	pEnc->mbParam.hint = &pFrame->hint;
 
 	start_timer();
 	if (image_input(&pEnc->sCurrent, pEnc->mbParam.width, pEnc->mbParam.height, pEnc->mbParam.edged_width,
@@ -240,6 +245,10 @@
 
 	EMMS();
 
+#ifdef _DEBUG
+	image_copy(&pEnc->sOriginal, &pEnc->sCurrent, pEnc->mbParam.edged_width, pEnc->mbParam.height);
+#endif
+
 	BitstreamInit(&bs, pFrame->bitstream, 0);
 
 	if (pFrame->quant == 0)
@@ -340,6 +349,14 @@
 		RateControlUpdate(pEnc->mbParam.quant, pFrame->length, pFrame->intra);
 	}
 
+#ifdef _DEBUG
+	psnr = image_psnr(&pEnc->sOriginal, &pEnc->sCurrent, pEnc->mbParam.edged_width,
+				pEnc->mbParam.width, pEnc->mbParam.height);
+
+	sprintf(temp, "PSNR: %f\n", psnr);
+	DEBUG(temp);
+#endif
+
 	pEnc->iFrameNum++;
 	image_swap(&pEnc->sCurrent, &pEnc->sReference);
 	
@@ -369,6 +386,207 @@
 }
 
 
+#define FCODEBITS	3
+#define MODEBITS	5
+
+void HintedMESet(Encoder * pEnc, int * intra)
+{
+	HINTINFO * hint;
+	Bitstream bs;
+	int length, high;
+	uint32_t x, y;
+
+	hint = pEnc->mbParam.hint;
+
+	if (hint->rawhints)
+	{
+		*intra = hint->mvhint.intra;
+	}
+	else
+	{
+		BitstreamInit(&bs, hint->hintstream, hint->hintlength);
+		*intra = BitstreamGetBit(&bs);
+	}
+
+	if (*intra)
+	{
+		return;
+	}
+
+	pEnc->mbParam.fixed_code = (hint->rawhints) ? hint->mvhint.fcode : BitstreamGetBits(&bs, FCODEBITS);
+
+	length	= pEnc->mbParam.fixed_code + 5;
+	high	= 1 << (length - 1);
+
+	for (y=0 ; y<pEnc->mbParam.mb_height ; ++y)
+	{
+		for (x=0 ; x<pEnc->mbParam.mb_width ; ++x)
+		{
+			MACROBLOCK * pMB = &pEnc->pMBs[x + y * pEnc->mbParam.mb_width];
+			MVBLOCKHINT * bhint = &hint->mvhint.block[x + y * pEnc->mbParam.mb_width];
+			VECTOR pred[4];
+			VECTOR tmp;
+			int dummy[4];
+			int vec;
+
+			pMB->mode = (hint->rawhints) ? bhint->mode : BitstreamGetBits(&bs, MODEBITS);
+
+			if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q)
+			{
+				tmp.x  = (hint->rawhints) ? bhint->mvs[0].x : BitstreamGetBits(&bs, length);
+				tmp.y  = (hint->rawhints) ? bhint->mvs[0].y : BitstreamGetBits(&bs, length);
+				tmp.x -= (tmp.x >= high) ? high*2 : 0;
+				tmp.y -= (tmp.y >= high) ? high*2 : 0;
+
+				get_pmvdata(pEnc->pMBs, x, y, pEnc->mbParam.mb_width, 0, pred, dummy);
+
+				for (vec=0 ; vec<4 ; ++vec)
+				{
+					pMB->mvs[vec].x  = tmp.x;
+					pMB->mvs[vec].y  = tmp.y;
+					pMB->pmvs[vec].x = pMB->mvs[0].x - pred[0].x;
+					pMB->pmvs[vec].y = pMB->mvs[0].y - pred[0].y;
+				}
+			}
+			else if (pMB->mode == MODE_INTER4V)
+			{
+				for (vec=0 ; vec<4 ; ++vec)
+				{
+					tmp.x  = (hint->rawhints) ? bhint->mvs[vec].x : BitstreamGetBits(&bs, length);
+					tmp.y  = (hint->rawhints) ? bhint->mvs[vec].y : BitstreamGetBits(&bs, length);
+					tmp.x -= (tmp.x >= high) ? high*2 : 0;
+					tmp.y -= (tmp.y >= high) ? high*2 : 0;
+
+					get_pmvdata(pEnc->pMBs, x, y, pEnc->mbParam.mb_width, vec, pred, dummy);
+
+					pMB->mvs[vec].x  = tmp.x;
+					pMB->mvs[vec].y  = tmp.y;
+					pMB->pmvs[vec].x = pMB->mvs[vec].x - pred[0].x;
+					pMB->pmvs[vec].y = pMB->mvs[vec].y - pred[0].y;
+				}
+			}
+			else	// intra / intra_q / stuffing / not_coded
+			{
+				for (vec=0 ; vec<4 ; ++vec)
+				{
+					pMB->mvs[vec].x  = pMB->mvs[vec].y  = 0;
+				}
+			}
+		}
+	}
+}
+
+
+void HintedMEGet(Encoder * pEnc, int intra)
+{
+	HINTINFO * hint;
+	Bitstream bs;
+	uint32_t x, y;
+	int length, high;
+
+	hint = pEnc->mbParam.hint;
+
+	if (hint->rawhints)
+	{
+		hint->mvhint.intra = intra;
+	}
+	else
+	{
+		BitstreamInit(&bs, hint->hintstream, 0);
+		BitstreamPutBit(&bs, intra);
+	}
+
+	if (intra)
+	{
+		if (!hint->rawhints)
+		{
+			BitstreamPad(&bs);
+			hint->hintlength = BitstreamLength(&bs);
+		}
+		return;
+	}
+
+	length	= pEnc->mbParam.fixed_code + 5;
+	high	= 1 << (length - 1);
+
+	if (hint->rawhints)
+	{
+		hint->mvhint.fcode = pEnc->mbParam.fixed_code;
+	}
+	else
+	{
+		BitstreamPutBits(&bs, pEnc->mbParam.fixed_code, FCODEBITS);
+	}
+
+	for (y=0 ; y<pEnc->mbParam.mb_height ; ++y)
+	{
+		for (x=0 ; x<pEnc->mbParam.mb_width ; ++x)
+		{
+			MACROBLOCK * pMB = &pEnc->pMBs[x + y * pEnc->mbParam.mb_width];
+			MVBLOCKHINT * bhint = &hint->mvhint.block[x + y * pEnc->mbParam.mb_width];
+			VECTOR tmp;
+
+			if (hint->rawhints)
+			{
+				bhint->mode = pMB->mode;
+			}
+			else
+			{
+				BitstreamPutBits(&bs, pMB->mode, MODEBITS);
+			}
+
+			if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q)
+			{
+				tmp.x  = pMB->mvs[0].x;
+				tmp.y  = pMB->mvs[0].y;
+				tmp.x += (tmp.x < 0) ? high*2 : 0;
+				tmp.y += (tmp.y < 0) ? high*2 : 0;
+
+				if (hint->rawhints)
+				{
+					bhint->mvs[0].x = tmp.x;
+					bhint->mvs[0].y = tmp.y;
+				}
+				else
+				{
+					BitstreamPutBits(&bs, tmp.x, length);
+					BitstreamPutBits(&bs, tmp.y, length);
+				}
+			}
+			else if (pMB->mode == MODE_INTER4V)
+			{
+				int vec;
+
+				for (vec=0 ; vec<4 ; ++vec)
+				{
+					tmp.x  = pMB->mvs[vec].x;
+					tmp.y  = pMB->mvs[vec].y;
+					tmp.x += (tmp.x < 0) ? high*2 : 0;
+					tmp.y += (tmp.y < 0) ? high*2 : 0;
+
+					if (hint->rawhints)
+					{
+						bhint->mvs[vec].x = tmp.x;
+						bhint->mvs[vec].y = tmp.y;
+					}
+					else
+					{
+						BitstreamPutBits(&bs, tmp.x, length);
+						BitstreamPutBits(&bs, tmp.y, length);
+					}
+				}
+			}
+		}
+	}
+
+	if (!hint->rawhints)
+	{
+		BitstreamPad(&bs);
+		hint->hintlength = BitstreamLength(&bs);
+	}
+}
+
+
 static int FrameCodeI(Encoder * pEnc, Bitstream * bs, uint32_t *pBits)
 {
 
@@ -416,6 +634,11 @@
 	pEnc->sStat.iMvCount = 0;
 	pEnc->mbParam.fixed_code = 2;
 
+	if (pEnc->mbParam.global_flags & XVID_HINTEDME_GET)
+	{
+		HintedMEGet(pEnc, 1);
+	}
+
 	return 1;					 // intra
 }
 
@@ -462,13 +685,22 @@
 	}
 
 	start_timer();
-	bIntra = MotionEstimation(pEnc->pMBs, &pEnc->mbParam, &pEnc->sReference,
-				  &pEnc->vInterH, &pEnc->vInterV,
-				  &pEnc->vInterHV, &pEnc->sCurrent, iLimit);
+	if (pEnc->mbParam.global_flags & XVID_HINTEDME_SET)
+	{
+		HintedMESet(pEnc, &bIntra);
+	}
+	else
+	{
+		bIntra = MotionEstimation(pEnc->pMBs, &pEnc->mbParam, &pEnc->sReference,
+					  &pEnc->vInterH, &pEnc->vInterV,
+					  &pEnc->vInterHV, &pEnc->sCurrent, iLimit);
+	}
 	stop_motion_timer();
 
 	if (bIntra == 1)
+	{
 		return FrameCodeI(pEnc, bs, pBits);
+	}
 
 	pEnc->mbParam.coding_type = P_VOP;
 
@@ -558,6 +790,11 @@
 
 	emms();
 
+	if (pEnc->mbParam.global_flags & XVID_HINTEDME_GET)
+	{
+		HintedMEGet(pEnc, 0);
+	}
+
 	if (pEnc->sStat.iMvCount == 0)
 		pEnc->sStat.iMvCount = 1;
 
@@ -586,3 +823,130 @@
 
 	return 0;					 // inter
 }
+
+
+
+/*
+static void FrameCodeB(Encoder * pEnc, FRAMEINFO * frame, Bitstream * bs, uint32_t *pBits)
+{
+    int16_t dct_codes[6][64];
+    int16_t qcoeff[6][64];
+    uint32_t x, y;
+	VECTOR forward;
+	VECTOR backward;
+
+    IMAGE *f_ref = &pEnc->reference->image;
+	IMAGE *b_ref = &pEnc->current->image;
+
+	// forward 
+	image_setedges(f_ref, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height, pEnc->mbParam.width, pEnc->mbParam.height);
+	start_timer();
+	image_interpolate(f_ref, &pEnc->f_refh, &pEnc->f_refv, &pEnc->f_refhv,
+		pEnc->mbParam.edged_width, pEnc->mbParam.edged_height, 0);
+	stop_inter_timer();
+
+	// backward
+	image_setedges(b_ref, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height, pEnc->mbParam.width, pEnc->mbParam.height);
+    start_timer();
+	image_interpolate(b_ref, &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV,
+		pEnc->mbParam.edged_width, pEnc->mbParam.edged_height, 0);
+	stop_inter_timer();
+
+	start_timer();
+	MotionEstimationBVOP(&pEnc->mbParam, frame, 
+		pEnc->reference->mbs, f_ref, &pEnc->f_refh, &pEnc->f_refv, &pEnc->f_refhv,
+		pEnc->current->mbs, b_ref, &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV);
+
+	stop_motion_timer();
+	
+	if (test_quant_type(&pEnc->mbParam, pEnc->current))
+	{
+		BitstreamWriteVolHeader(bs, pEnc->mbParam.width, pEnc->mbParam.height, pEnc->mbParam.quant_type);
+	}
+
+    frame->coding_type = B_VOP;
+    BitstreamWriteVopHeader(bs, B_VOP, frame->tick, 0,
+			frame->quant, frame->fcode, frame->bcode);
+
+    *pBits = BitstreamPos(bs);
+
+    pEnc->sStat.iTextBits = 0;
+    pEnc->sStat.iMvSum = 0;
+    pEnc->sStat.iMvCount = 0;
+	pEnc->sStat.kblks = pEnc->sStat.mblks = pEnc->sStat.ublks = 0;
+
+
+    for (y = 0; y < pEnc->mbParam.mb_height; y++)
+	{
+		// reset prediction
+
+		forward.x = 0;
+		forward.y = 0;
+		backward.x = 0;
+		backward.y = 0;
+
+		for (x = 0; x < pEnc->mbParam.mb_width; x++)
+		{
+			MACROBLOCK * f_mb = &pEnc->reference->mbs[x + y * pEnc->mbParam.mb_width];
+			MACROBLOCK * b_mb = &pEnc->current->mbs[x + y * pEnc->mbParam.mb_width];
+			MACROBLOCK * mb = &frame->mbs[x + y * pEnc->mbParam.mb_width];
+
+			// decoder ignores mb when refence block is INTER(0,0), CBP=0 
+			if (mb->mode == MODE_NOT_CODED)
+			{
+				mb->mvs[0].x = 0;
+				mb->mvs[0].y = 0;
+				continue;
+			}
+
+			MBMotionCompensationBVOP(&pEnc->mbParam, mb, x, y, &frame->image,
+					f_ref, &pEnc->f_refh, &pEnc->f_refv, &pEnc->f_refhv, 
+					b_ref, &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV, 
+					dct_codes);
+	
+			mb->quant = frame->quant;
+			mb->cbp = MBTransQuantInter(&pEnc->mbParam, frame, x, y, dct_codes, qcoeff);
+			//mb->cbp = MBTransQuantBVOP(&pEnc->mbParam, x, y, dct_codes, qcoeff, &frame->image, frame->quant);
+
+
+			if ((mb->mode == MODE_INTERPOLATE || mb->mode == MODE_DIRECT) &&
+				mb->cbp == 0 &&
+				mb->mvs[0].x == 0 && 
+				mb->mvs[0].y == 0)
+			{
+				mb->mode = 5;  // skipped
+			}
+
+			if (mb->mode == MODE_INTERPOLATE || mb->mode == MODE_FORWARD)
+			{
+				mb->pmvs[0].x = mb->mvs[0].x - forward.x;
+				mb->pmvs[0].y = mb->mvs[0].y - forward.y;
+				forward.x = mb->mvs[0].x;
+				forward.y = mb->mvs[0].y;
+			}
+			
+			if (mb->mode == MODE_INTERPOLATE || mb->mode == MODE_BACKWARD)
+			{
+				mb->b_pmvs[0].x = mb->b_mvs[0].x - backward.x;
+				mb->b_pmvs[0].y = mb->b_mvs[0].y - backward.y;
+				backward.x = mb->b_mvs[0].x;
+				backward.y = mb->b_mvs[0].y;
+			}
+
+//			printf("[%i %i] M=%i CBP=%i MVX=%i MVY=%i %i,%i  %i,%i\n", x, y, pMB->mode, pMB->cbp, pMB->mvs[0].x, bmb->pmvs[0].x, bmb->pmvs[0].y, forward.x, forward.y);
+
+			start_timer();			
+			MBCodingBVOP(frame, mb, qcoeff, bs, &pEnc->sStat);
+			stop_coding_timer();
+		}
+	}
+
+	emms();
+
+	// TODO: dynamic fcode/bcode ???
+
+	*pBits = BitstreamPos(bs) - *pBits;
+
+}
+
+*/
\ No newline at end of file