--- trunk/xvidcore/src/encoder.c	2002/03/29 07:24:57	87
+++ trunk/xvidcore/src/encoder.c	2002/05/03 15:26:30	158
@@ -1,3 +1,43 @@
+/**************************************************************************
+ *
+ *  XVID MPEG-4 VIDEO CODEC
+ *  -  Encoder main module  -
+ *
+ *  This program is an implementation of a part of one or more MPEG-4
+ *  Video tools as specified in ISO/IEC 14496-2 standard.  Those intending
+ *  to use this software module in hardware or software products are
+ *  advised that its use may infringe existing patents or copyrights, and
+ *  any such use would be at such party's own risk.  The original
+ *  developer of this software module and his/her company, and subsequent
+ *  editors and their companies, will have no liability for use of this
+ *  software or modifications or derivatives thereof.
+ *
+ *  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
+ *
+ ***************************************************************************/
+
+/****************************************************************************
+ * 
+ *  History
+ *
+ *  14.04.2002 added FrameCodeB()
+ *
+ *  $Id: encoder.c,v 1.34 2002-05-03 15:26:30 edgomez Exp $
+ *
+ ***************************************************************************/
+
 #include <stdlib.h>
 #include <stdio.h>
 #include <math.h>
@@ -7,6 +47,7 @@
 #include "global.h"
 #include "utils/timer.h"
 #include "image/image.h"
+#include "motion/motion.h"
 #include "bitstream/cbp.h"
 #include "utils/mbfunctions.h"
 #include "bitstream/bitstream.h"
@@ -19,10 +60,12 @@
 #include "utils/mem_align.h"
 
 #define ENC_CHECK(X) if(!(X)) return XVID_ERR_FORMAT
+#define SWAP(A,B)    { void * tmp = A; A = B; B = tmp; }
 
 
 static int FrameCodeI(Encoder * pEnc, Bitstream * bs, uint32_t *pBits);
 static int FrameCodeP(Encoder * pEnc, Bitstream * bs, uint32_t *pBits, bool force_inter, bool vol_header);
+static void FrameCodeB(Encoder * pEnc, FRAMEINFO * frame, Bitstream * bs, uint32_t *pBits);
 
 static int DQtab[4] = 
 {
@@ -35,6 +78,12 @@
 };
 
 
+void static image_null(IMAGE * image)
+{
+	image->y = image->u = image->v = NULL;
+}
+
+
 int encoder_create(XVID_ENC_PARAM * pParam)
 {
 	Encoder *pEnc;
@@ -78,11 +127,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_buffersize <= 0)
-		pParam->rc_buffersize = 16;
+	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_buffer <= 0)
+		pParam->rc_buffer = 100;
 
 	if ((pParam->min_quantizer <= 0) || (pParam->min_quantizer > 31))
 		pParam->min_quantizer = 1;
@@ -110,67 +165,145 @@
 	pEnc->mbParam.edged_width = 16 * pEnc->mbParam.mb_width + 2 * EDGE_SIZE;
 	pEnc->mbParam.edged_height = 16 * pEnc->mbParam.mb_height + 2 * EDGE_SIZE;
 
+	pEnc->mbParam.fbase = pParam->fbase;
+	pEnc->mbParam.fincr = pParam->fincr;
+
 	pEnc->sStat.fMvPrevSigma = -1;
 
 	/* Fill rate control parameters */
 
-	pEnc->mbParam.quant = 4;
-
-	pEnc->bitrate = pParam->bitrate;
+	pEnc->bitrate = pParam->rc_bitrate;
 
 	pEnc->iFrameNum = 0;
 	pEnc->iMaxKeyInterval = pParam->max_key_interval;
 
-	/* try to allocate memory */
+	/* try to allocate frame memory */
+
+	pEnc->current = NULL;
+	pEnc->reference = NULL;
+	if ( (pEnc->current = xvid_malloc(sizeof(FRAMEINFO), CACHE_LINE)) == NULL ||
+		 (pEnc->reference = xvid_malloc(sizeof(FRAMEINFO), CACHE_LINE)) == NULL)
+	{
+		if (pEnc->current) xvid_free(pEnc->current);
+		xvid_free(pEnc);
+		return XVID_ERR_MEMORY;
+	}
 
-	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;
+	/* try to allocate mb memory */
 
-	pEnc->pMBs = NULL;
+	pEnc->current->mbs = NULL;
+	pEnc->reference->mbs = 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 ||
+	if ((pEnc->current->mbs = xvid_malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width * pEnc->mbParam.mb_height, CACHE_LINE)) == NULL ||
+		(pEnc->reference->mbs = xvid_malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width * pEnc->mbParam.mb_height, CACHE_LINE)) == NULL)
+	{
+		if (pEnc->current->mbs) xvid_free(pEnc->current->mbs);
+		xvid_free(pEnc->current);
+		xvid_free(pEnc->reference);
+		xvid_free(pEnc);
+	}
+
+	/* try to allocate image memory */
+
+#ifdef _DEBUG
+	image_null(&pEnc->sOriginal);
+#endif
+#ifdef BFRAMES
+	image_null(&pEnc->f_refh);
+	image_null(&pEnc->f_refv);
+	image_null(&pEnc->f_refhv);
+#endif
+	image_null(&pEnc->current->image);
+	image_null(&pEnc->reference->image);
+	image_null(&pEnc->vInterH);
+	image_null(&pEnc->vInterV);
+	image_null(&pEnc->vInterVf);
+	image_null(&pEnc->vInterHV);
+	image_null(&pEnc->vInterHVf);
+	
+	if (
+#ifdef _DEBUG
+		image_create(&pEnc->sOriginal, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
+#endif
+#ifdef BFRAMES
+		image_create(&pEnc->f_refh, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
+		image_create(&pEnc->f_refv, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
+		image_create(&pEnc->f_refhv, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
+#endif
+		image_create(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0 ||
+		image_create(&pEnc->reference->image, 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 ||
-		(pEnc->pMBs = xvid_malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width * pEnc->mbParam.mb_height, CACHE_LINE)) == NULL)
+		image_create(&pEnc->vInterHVf, 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);
+#ifdef _DEBUG
+		image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
+#endif
+#ifdef BFRAMES
+		image_destroy(&pEnc->f_refh, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
+		image_destroy(&pEnc->f_refv, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
+		image_destroy(&pEnc->f_refhv, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
+#endif
+		image_destroy(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
+		image_destroy(&pEnc->reference->image, 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);
-		if (pEnc)
-		{
-			xvid_free(pEnc);
-		}
+
+		xvid_free(pEnc->current);
+		xvid_free(pEnc->reference);
+		xvid_free(pEnc);
 		return XVID_ERR_MEMORY;
 	}
 
-	// init macroblock array
-	for (i = 0; i < pEnc->mbParam.mb_width * pEnc->mbParam.mb_height; i++)
+// ==============================================================================
+#ifdef BFRAMES
+	
+	// TODO: handle malloc() == NULL
+	pEnc->max_bframes = pParam->max_bframes;
+	pEnc->bquant_ratio = pParam->bquant_ratio;
+	if (pEnc->max_bframes > 0)
 	{
-		pEnc->pMBs[i].dquant = NO_CHANGE;
+		int n;
+
+		pEnc->bframes = malloc(pEnc->max_bframes * sizeof(FRAMEINFO *));
+
+		for (n = 0; n < pEnc->max_bframes; n++)
+		{
+			pEnc->bframes[n] = malloc(sizeof(FRAMEINFO));
+			pEnc->bframes[n]->mbs = malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width * pEnc->mbParam.mb_height);
+
+			if (image_create(&pEnc->bframes[n]->image, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height) < 0)
+			{
+				return XVID_ERR_MEMORY;
+			}
+		}
 	}
+	pEnc->bframenum_head = 0;
+	pEnc->bframenum_tail = 0;
+	pEnc->flush_bframes = 0;
+
+	pEnc->mbParam.m_seconds = 0;
+	pEnc->mbParam.m_ticks = 0;
+#endif
+
+
+// ==============================================================================
+
 
 	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;
@@ -180,30 +313,291 @@
 int encoder_destroy(Encoder * pEnc)
 {
 	ENC_CHECK(pEnc);
-	ENC_CHECK(pEnc->sCurrent.y);
-	ENC_CHECK(pEnc->sReference.y);
 
-	xvid_free(pEnc->pMBs);
-	image_destroy(&pEnc->sCurrent, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
-	image_destroy(&pEnc->sReference, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
+// =================================================================
+#ifdef BFRAMES
+	if (pEnc->max_bframes > 0)
+	{
+		int n;
+		for (n = 0; n < pEnc->max_bframes; n++)
+		{
+			image_destroy(&pEnc->bframes[n]->image, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
+			free(pEnc->bframes[n]->mbs);
+			free(pEnc->bframes[n]);
+		}
+		free(pEnc->bframes);
+	}
+#endif
+//====================================================================
+
+	image_destroy(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
+	image_destroy(&pEnc->reference->image, 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);
-	xvid_free(pEnc);
+#ifdef BFRAMES
+	image_destroy(&pEnc->f_refh, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
+	image_destroy(&pEnc->f_refv, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
+	image_destroy(&pEnc->f_refhv, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
+#endif
+#ifdef _DEBUG
+		image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height);
+#endif
+	xvid_free(pEnc->current->mbs);
+	xvid_free(pEnc->current);
 
-	destroy_vlc_tables();
+	xvid_free(pEnc->reference->mbs);
+	xvid_free(pEnc->reference);
 
+	xvid_free(pEnc);
 	return XVID_ERR_OK;
 }
 
+
+
+// ==================================================================
+#ifdef BFRAMES
+int encoder_encode(Encoder * pEnc, XVID_ENC_FRAME * pFrame, XVID_ENC_STATS * pResult)
+{
+	uint16_t x, y;
+	Bitstream bs;
+	uint32_t bits;
+
+	ENC_CHECK(pEnc);
+	ENC_CHECK(pFrame);
+
+	start_global_timer();
+	
+	BitstreamInit(&bs, pFrame->bitstream, 0);
+
+// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+// bframe "flush" code
+// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+    
+	if ((pFrame->image == NULL || pEnc->flush_bframes) && 
+		pEnc->bframenum_head < pEnc->bframenum_tail)
+	{
+
+		if (pEnc->flush_bframes == 0)	
+		{
+			// we have reached end of stream without getting a future reference
+			// .. so encode last final frame a pframe
+			dprintf("--- PFRAME (final frame correction) --- ");
+			pEnc->bframenum_tail--;
+			SWAP(pEnc->current, pEnc->reference);
+
+			SWAP(pEnc->current, pEnc->bframes[pEnc->bframenum_tail]);
+
+			FrameCodeP(pEnc, &bs, &bits, 1, 0);
+
+			BitstreamPad(&bs);
+			pFrame->length = BitstreamLength(&bs);
+			pFrame->input_consumed = 0;
+			pFrame->intra = 0;
+			return XVID_ERR_OK;
+		}
+
+		dprintf("--- BFRAME (flush) --- ");
+		FrameCodeB(pEnc, 
+			pEnc->bframes[pEnc->bframenum_head],
+			 &bs, &bits);
+		pEnc->bframenum_head++;
+
+
+		BitstreamPad(&bs);
+		pFrame->length = BitstreamLength(&bs);
+		pFrame->input_consumed = 0;
+		pFrame->intra = 0;
+		return XVID_ERR_OK;
+	}
+
+	if (pFrame->image == NULL)
+	{
+		pFrame->length = 0;
+		pFrame->input_consumed = 1;
+		pFrame->intra = 0;
+		return XVID_ERR_OK;
+	}
+
+	if (pEnc->bframenum_head > 0)
+	{
+		pEnc->bframenum_head = pEnc->bframenum_tail = 0;
+	}
+
+	pEnc->flush_bframes = 0;
+
+// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%	
+
+	SWAP(pEnc->current, pEnc->reference);
+
+	pEnc->current->quant = (pFrame->quant == 0) ? RateControlGetQ(0) : pFrame->quant;
+	
+	if(pEnc->current->quant < 1)
+		pEnc->current->quant = 1;
+	
+	if(pEnc->current->quant > 31)
+		pEnc->current->quant = 31;
+
+	pEnc->current->global_flags = pFrame->general;
+	pEnc->current->motion_flags = pFrame->motion;
+	pEnc->current->seconds = pEnc->mbParam.m_seconds;
+	pEnc->current->ticks = pEnc->mbParam.m_ticks;
+	//@@@ TODO: dyanmic fcode (in both directions)
+	pEnc->current->fcode = pEnc->mbParam.m_fcode;
+	pEnc->current->bcode = pEnc->mbParam.m_fcode; 
+
+	start_timer();
+	if (image_input(&pEnc->current->image, pEnc->mbParam.width, pEnc->mbParam.height, pEnc->mbParam.edged_width,
+			pFrame->image, pFrame->colorspace))
+	{
+		return XVID_ERR_FORMAT;
+	}
+	stop_conv_timer();
+
+#ifdef _DEBUG
+	image_copy(&pEnc->sOriginal, &pEnc->sCurrent, pEnc->mbParam.edged_width, pEnc->mbParam.height);
+#endif
+
+
+// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+// lumi masking
+// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+	if ((pEnc->current->global_flags & XVID_LUMIMASKING))
+	{
+		int * temp_dquants = (int *) xvid_malloc(pEnc->mbParam.mb_width * pEnc->mbParam.mb_height * sizeof(int), CACHE_LINE);
+		
+		pEnc->current->quant = adaptive_quantization(pEnc->current->image.y,
+							    pEnc->mbParam.edged_width,	// stride
+							    temp_dquants,
+							    pEnc->current->quant,
+							    pEnc->current->quant,	// min_quant
+							    2*pEnc->current->quant,	// max_quant
+							    pEnc->mbParam.mb_width,
+							    pEnc->mbParam.mb_height);
+			
+		for (y = 0; y < pEnc->mbParam.mb_height; y++)
+			for (x = 0; x < pEnc->mbParam.mb_width; x++)
+			{
+				MACROBLOCK *pMB = &pEnc->current->mbs[x + y * pEnc->mbParam.mb_width];
+				pMB->dquant = iDQtab[(temp_dquants[y * pEnc->mbParam.mb_width + x] + 2)];
+			}
+		xvid_free(temp_dquants);
+	}
+
+
+// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+// ivop/pvop/bvop selection
+// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+
+	if (pEnc->iFrameNum == 0 || 
+		pFrame->intra == 1 ||
+		(pFrame->intra < 0 && (pEnc->iMaxKeyInterval > 0 && pEnc->iFrameNum >= pEnc->iMaxKeyInterval)) ||
+		image_mad(&pEnc->reference->image, &pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.width, pEnc->mbParam.height) > 30)
+	{
+		dprintf("--- IFRAME ---");
+
+		FrameCodeI(pEnc, &bs, &bits);
+
+		pFrame->intra = 1;
+		pEnc->flush_bframes = 1;
+
+		/* note: sequences like "IIBB" decode fine with msfdam but,
+		   go screwy with divx5.00 */
+	}
+	else if (pEnc->bframenum_tail >= pEnc->max_bframes)
+	{
+		dprintf("--- PFRAME ---");
+
+		FrameCodeP(pEnc, &bs, &bits, 1, 0);
+		pFrame->intra = 0;
+		pEnc->flush_bframes = 1;
+	}
+	else
+	{
+		dprintf("--- BFRAME (store) ---  head=%i tail=%i", pEnc->bframenum_head, pEnc->bframenum_tail);
+
+		if (pFrame->bquant < 1)
+		{
+			pEnc->current->quant = ((pEnc->reference->quant + pEnc->current->quant) * pEnc->bquant_ratio) / 200;
+		}
+		else
+		{
+			pEnc->current->quant = pFrame->bquant;
+		}
+		
+		// store frame into bframe buffer & swap ref back to current
+		SWAP(pEnc->current, pEnc->bframes[pEnc->bframenum_tail]);
+		SWAP(pEnc->current, pEnc->reference);
+
+		pEnc->bframenum_tail++;
+
+		pFrame->intra = 0;
+		pFrame->length = 0;
+		pFrame->input_consumed = 1;
+
+		pEnc->mbParam.m_ticks += pEnc->mbParam.fincr;
+		if (pEnc->mbParam.m_ticks > pEnc->mbParam.fbase)
+		{
+			pEnc->mbParam.m_seconds++;
+			pEnc->mbParam.m_ticks = 0;
+		}
+		return XVID_ERR_OK;
+	}
+
+	BitstreamPad(&bs);
+	pFrame->length = BitstreamLength(&bs);
+
+	if (pResult)
+	{
+		pResult->quant = pEnc->current->quant;
+		pResult->hlength = pFrame->length - (pEnc->sStat.iTextBits / 8);
+		pResult->kblks = pEnc->sStat.kblks;
+		pResult->mblks = pEnc->sStat.mblks;
+		pResult->ublks = pEnc->sStat.ublks;
+	}
+
+#ifdef _DEBUG
+	psnr = image_psnr(&pEnc->sOriginal, &pEnc->current->image, pEnc->mbParam.edged_width,
+				pEnc->mbParam.width, pEnc->mbParam.height);
+
+	sprintf(temp, "PSNR: %f\n", psnr);
+	DEBUG(temp);
+#endif
+
+	if (pFrame->quant == 0)
+	{
+		RateControlUpdate(pEnc->current->quant, pFrame->length, pFrame->intra);
+	}
+
+	pEnc->iFrameNum++;
+	pEnc->mbParam.m_ticks += pEnc->mbParam.fincr;
+	if (pEnc->mbParam.m_ticks > pEnc->mbParam.fbase)
+	{
+		pEnc->mbParam.m_seconds++;
+		pEnc->mbParam.m_ticks = 0;
+	}
+	pFrame->input_consumed = 1;
+	
+	stop_global_timer();
+	write_timer();
+
+	return XVID_ERR_OK;
+}
+// ==================================================================
+#else
 int encoder_encode(Encoder * pEnc, XVID_ENC_FRAME * pFrame, XVID_ENC_STATS * pResult)
 {
 	uint16_t x, y;
 	Bitstream bs;
 	uint32_t bits;
 	uint16_t write_vol_header = 0;
+#ifdef _DEBUG
+	float psnr;
+	uint8_t temp[100];
+#endif
 
 	start_global_timer();
 
@@ -212,68 +606,75 @@
 	ENC_CHECK(pFrame->bitstream);
 	ENC_CHECK(pFrame->image);
 
-	pEnc->mbParam.global_flags = pFrame->general;
-	pEnc->mbParam.motion_flags = pFrame->motion;
+	SWAP(pEnc->current, pEnc->reference);
+
+	pEnc->current->global_flags = pFrame->general;
+	pEnc->current->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,
+	if (image_input(&pEnc->current->image, pEnc->mbParam.width, pEnc->mbParam.height, pEnc->mbParam.edged_width,
 			pFrame->image, pFrame->colorspace))
 	{
 		return XVID_ERR_FORMAT;
 	}
 	stop_conv_timer();
 
+#ifdef _DEBUG
+        image_copy(&pEnc->sOriginal, &pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height);
+#endif
+
 	EMMS();
 
 	BitstreamInit(&bs, pFrame->bitstream, 0);
 
 	if (pFrame->quant == 0)
 	{
-		pEnc->mbParam.quant = RateControlGetQ(0);
+		pEnc->current->quant = RateControlGetQ(0);
 	}
 	else
 	{
-		pEnc->mbParam.quant = pFrame->quant;
+		pEnc->current->quant = pFrame->quant;
 	}
 
-	if ((pEnc->mbParam.global_flags & XVID_LUMIMASKING) > 0)
+	if ((pEnc->current->global_flags & XVID_LUMIMASKING))
 	{
 		int * temp_dquants = (int *) xvid_malloc(pEnc->mbParam.mb_width * pEnc->mbParam.mb_height * sizeof(int), CACHE_LINE);
 		
-		pEnc->mbParam.quant = adaptive_quantization(pEnc->sCurrent.y,
-							    pEnc->mbParam.width,
+		pEnc->current->quant = adaptive_quantization(pEnc->current->image.y,
+							    pEnc->mbParam.edged_width,	// stride
 							    temp_dquants,
-							    pEnc->mbParam.quant,
-							    pEnc->mbParam.quant,
-							    2*pEnc->mbParam.quant,
+							    pEnc->current->quant,
+							    pEnc->current->quant,	// min_quant
+							    2*pEnc->current->quant,	// max_quant
 							    pEnc->mbParam.mb_width,
 							    pEnc->mbParam.mb_height);
 			
 		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];
+				MACROBLOCK *pMB = &pEnc->current->mbs[x + y * pEnc->mbParam.mb_width];
 				pMB->dquant = iDQtab[(temp_dquants[y * pEnc->mbParam.mb_width + x] + 2)];
 			}
 		xvid_free(temp_dquants);
 	}
 
-	if(pEnc->mbParam.global_flags & XVID_H263QUANT) {
-		if(pEnc->mbParam.quant_type != H263_QUANT)
+	if (pEnc->current->global_flags & XVID_H263QUANT) {
+		if(pEnc->mbParam.m_quant_type != H263_QUANT)
 			write_vol_header = 1;
-		pEnc->mbParam.quant_type = H263_QUANT;
+		pEnc->mbParam.m_quant_type = H263_QUANT;
 	}
-	else if(pEnc->mbParam.global_flags & XVID_MPEGQUANT) {
+	else if(pEnc->current->global_flags & XVID_MPEGQUANT) {
 		int ret1, ret2;
 
 		ret1 = ret2 = 0;
 
-		if(pEnc->mbParam.quant_type != MPEG4_QUANT)
+		if(pEnc->mbParam.m_quant_type != MPEG4_QUANT)
 			write_vol_header = 1;
 		
-		pEnc->mbParam.quant_type = MPEG4_QUANT;
+		pEnc->mbParam.m_quant_type = MPEG4_QUANT;
 		
-		if ((pEnc->mbParam.global_flags & XVID_CUSTOM_QMATRIX) > 0) {
+		if ((pEnc->current->global_flags & XVID_CUSTOM_QMATRIX) > 0) {
 			if(pFrame->quant_intra_matrix != NULL)
 				ret1 = set_intra_matrix(pFrame->quant_intra_matrix);
 			if(pFrame->quant_inter_matrix != NULL)
@@ -311,7 +712,7 @@
 
 	if (pResult)
 	{
-		pResult->quant = pEnc->mbParam.quant;
+		pResult->quant = pEnc->current->quant;
 		pResult->hlength = pFrame->length - (pEnc->sStat.iTextBits / 8);
 		pResult->kblks = pEnc->sStat.kblks;
 		pResult->mblks = pEnc->sStat.mblks;
@@ -322,35 +723,264 @@
 
 	if (pFrame->quant == 0)
 	{
-		RateControlUpdate(pEnc->mbParam.quant, pFrame->length, pFrame->intra);
+		RateControlUpdate(pEnc->current->quant, pFrame->length, pFrame->intra);
 	}
 
+#ifdef _DEBUG
+	psnr = image_psnr(&pEnc->sOriginal, &pEnc->current->image, 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);
 	
 	stop_global_timer();
 	write_timer();
 
 	return XVID_ERR_OK;
 }
+#endif
 
 
 static __inline void CodeIntraMB(Encoder *pEnc, MACROBLOCK *pMB) {
 
 	pMB->mode = MODE_INTRA;
 
-	if ((pEnc->mbParam.global_flags & XVID_LUMIMASKING) > 0) {
+	/* zero mv statistics */
+	pMB->mvs[0].x = pMB->mvs[1].x = pMB->mvs[2].x = pMB->mvs[3].x = 0;
+	pMB->mvs[0].y = pMB->mvs[1].y = pMB->mvs[2].y = pMB->mvs[3].y = 0;
+	pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] = 0;
+	pMB->sad16 = 0;
+
+	if ((pEnc->current->global_flags & XVID_LUMIMASKING)) {
 		if(pMB->dquant != NO_CHANGE)
 		{
 			pMB->mode = MODE_INTRA_Q;
-			pEnc->mbParam.quant += DQtab[pMB->dquant];
+			pEnc->current->quant += DQtab[pMB->dquant];
 		
-			if (pEnc->mbParam.quant > 31) pEnc->mbParam.quant = 31;
-			if (pEnc->mbParam.quant < 1) pEnc->mbParam.quant = 1;
+			if (pEnc->current->quant > 31) pEnc->current->quant = 31;
+			if (pEnc->current->quant < 1) pEnc->current->quant = 1;
 		}
 	}
 
-	pMB->quant = pEnc->mbParam.quant;
+	pMB->quant = pEnc->current->quant;
+}
+
+
+#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->current->fcode = (hint->rawhints) ? hint->mvhint.fcode : BitstreamGetBits(&bs, FCODEBITS);
+
+	length	= pEnc->current->fcode + 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->current->mbs[x + y * pEnc->mbParam.mb_width];
+			MVBLOCKHINT * bhint = &hint->mvhint.block[x + y * pEnc->mbParam.mb_width];
+			VECTOR pred[4];
+			VECTOR tmp;
+			int32_t dummy[4];
+			int vec;
+
+			pMB->mode = (hint->rawhints) ? bhint->mode : BitstreamGetBits(&bs, MODEBITS);
+
+			pMB->mode = (pMB->mode == MODE_INTER_Q) ? MODE_INTER : pMB->mode;
+			pMB->mode = (pMB->mode == MODE_INTRA_Q) ? MODE_INTRA : pMB->mode;
+
+			if (pMB->mode == MODE_INTER)
+			{
+				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->current->mbs, 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->current->mbs, 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 / stuffing / not_coded
+			{
+				for (vec=0 ; vec<4 ; ++vec)
+				{
+					pMB->mvs[vec].x  = pMB->mvs[vec].y  = 0;
+				}
+			}
+
+			if (pMB->mode == MODE_INTER4V &&
+				(pEnc->current->global_flags & XVID_LUMIMASKING) && pMB->dquant != NO_CHANGE)
+			{
+				pMB->mode = MODE_INTRA;
+
+				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->current->fcode + 5;
+	high	= 1 << (length - 1);
+
+	if (hint->rawhints)
+	{
+		hint->mvhint.fcode = pEnc->current->fcode;
+	}
+	else
+	{
+		BitstreamPutBits(&bs, pEnc->current->fcode, FCODEBITS);
+	}
+
+	for (y=0 ; y<pEnc->mbParam.mb_height ; ++y)
+	{
+		for (x=0 ; x<pEnc->mbParam.mb_width ; ++x)
+		{
+			MACROBLOCK * pMB = &pEnc->current->mbs[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);
+	}
 }
 
 
@@ -363,11 +993,12 @@
 	uint16_t x, y;
 
 	pEnc->iFrameNum = 0;
-	pEnc->mbParam.rounding_type = 1;
-	pEnc->mbParam.coding_type = I_VOP;
+	pEnc->mbParam.m_rounding_type = 1;
+	pEnc->current->rounding_type = pEnc->mbParam.m_rounding_type;
+	pEnc->current->coding_type = I_VOP;
 
-	BitstreamWriteVolHeader(bs, &pEnc->mbParam);
-	BitstreamWriteVopHeader(bs, &pEnc->mbParam);
+	BitstreamWriteVolHeader(bs, &pEnc->mbParam, pEnc->current);
+	BitstreamWriteVopHeader(bs, &pEnc->mbParam, pEnc->current);
 
 	*pBits = BitstreamPos(bs);
 
@@ -378,18 +1009,18 @@
 	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];
+			MACROBLOCK *pMB = &pEnc->current->mbs[x + y * pEnc->mbParam.mb_width];
 
 			CodeIntraMB(pEnc, pMB);
 
-			MBTransQuantIntra(&pEnc->mbParam, pMB, x, y, dct_codes, qcoeff, &pEnc->sCurrent);
+			MBTransQuantIntra(&pEnc->mbParam, pEnc->current, pMB, x, y, dct_codes, qcoeff);
 
 			start_timer();
-			MBPrediction(&pEnc->mbParam, x, y, pEnc->mbParam.mb_width, qcoeff, pEnc->pMBs);
+			MBPrediction(pEnc->current, x, y, pEnc->mbParam.mb_width, qcoeff);
 			stop_prediction_timer();
 
 			start_timer();
-			MBCoding(&pEnc->mbParam, pMB, qcoeff, bs, &pEnc->sStat);
+			MBCoding(pEnc->current, pMB, qcoeff, bs, &pEnc->sStat);
 			stop_coding_timer();
 		}
 
@@ -399,7 +1030,12 @@
 	pEnc->sStat.fMvPrevSigma = -1;
 	pEnc->sStat.iMvSum = 0;
 	pEnc->sStat.iMvCount = 0;
-	pEnc->mbParam.fixed_code = 2;
+	pEnc->mbParam.m_fcode = 2;
+
+	if (pEnc->current->global_flags & XVID_HINTEDME_GET)
+	{
+		HintedMEGet(pEnc, 1);
+	}
 
 	return 1;					 // intra
 }
@@ -417,10 +1053,10 @@
 	int iLimit;
 	uint32_t x, y;
 	int iSearchRange;
-	bool bIntra;
+	int bIntra;
 
-	IMAGE *pCurrent = &pEnc->sCurrent;
-	IMAGE *pRef = &pEnc->sReference;
+	/* IMAGE *pCurrent = &pEnc->current->image; */
+	IMAGE *pRef = &pEnc->reference->image;
 
 	start_timer();
 	image_setedges(pRef,
@@ -428,39 +1064,55 @@
 		       pEnc->mbParam.edged_height,
 		       pEnc->mbParam.width,
 		       pEnc->mbParam.height,
-		       pEnc->mbParam.global_flags & XVID_INTERLACING);
+		       pEnc->current->global_flags & XVID_INTERLACING);
 	stop_edges_timer();
 
-	pEnc->mbParam.rounding_type = 1 - pEnc->mbParam.rounding_type;
+	pEnc->mbParam.m_rounding_type = 1 - pEnc->mbParam.m_rounding_type;
+	pEnc->current->rounding_type = pEnc->mbParam.m_rounding_type;
+	pEnc->current->fcode = pEnc->mbParam.m_fcode;
 
 	if (!force_inter)
 		iLimit = (int)(pEnc->mbParam.mb_width * pEnc->mbParam.mb_height * INTRA_THRESHOLD);
 	else
 		iLimit = pEnc->mbParam.mb_width * pEnc->mbParam.mb_height + 1;
 
-	if ((pEnc->mbParam.global_flags & XVID_HALFPEL) > 0) {
+	if ((pEnc->current->global_flags & XVID_HALFPEL)) {
 		start_timer();
 		image_interpolate(pRef, &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV,
 				  pEnc->mbParam.edged_width, pEnc->mbParam.edged_height,
-				  pEnc->mbParam.rounding_type);
+				  pEnc->current->rounding_type);
 		stop_inter_timer();
 	}
 
 	start_timer();
-	bIntra = MotionEstimation(pEnc->pMBs, &pEnc->mbParam, &pEnc->sReference,
-				  &pEnc->vInterH, &pEnc->vInterV,
-				  &pEnc->vInterHV, &pEnc->sCurrent, iLimit);
+	if (pEnc->current->global_flags & XVID_HINTEDME_SET)
+	{
+		HintedMESet(pEnc, &bIntra);
+	}
+	else
+	{
+		bIntra = MotionEstimation(
+			&pEnc->mbParam, 
+			pEnc->current, 
+			pEnc->reference, 
+			&pEnc->vInterH, 
+			&pEnc->vInterV,
+			&pEnc->vInterHV, 
+			iLimit);
+	}
 	stop_motion_timer();
 
 	if (bIntra == 1)
+	{
 		return FrameCodeI(pEnc, bs, pBits);
+	}
 
-	pEnc->mbParam.coding_type = P_VOP;
+	pEnc->current->coding_type = P_VOP;
 
 	if(vol_header)
-		BitstreamWriteVolHeader(bs, &pEnc->mbParam);
+		BitstreamWriteVolHeader(bs, &pEnc->mbParam, pEnc->current);
 
-	BitstreamWriteVopHeader(bs, &pEnc->mbParam);
+	BitstreamWriteVopHeader(bs, &pEnc->mbParam, pEnc->current);
 
 	*pBits = BitstreamPos(bs);
 
@@ -473,7 +1125,7 @@
 	{
 		for(x = 0; x < pEnc->mbParam.mb_width; x++)
 		{
-			MACROBLOCK * pMB = &pEnc->pMBs[x + y * pEnc->mbParam.mb_width];
+			MACROBLOCK * pMB = &pEnc->current->mbs[x + y * pEnc->mbParam.mb_width];
 
 			bIntra = (pMB->mode == MODE_INTRA) || (pMB->mode == MODE_INTRA_Q);
 
@@ -482,40 +1134,40 @@
 				start_timer();
 				MBMotionCompensation(pMB,
 						     x, y,
-						     &pEnc->sReference,
+						     &pEnc->reference->image,
 						     &pEnc->vInterH,
 						     &pEnc->vInterV,
 						     &pEnc->vInterHV,
-						     &pEnc->sCurrent,
+						     &pEnc->current->image,
 						     dct_codes,
 						     pEnc->mbParam.width,
 						     pEnc->mbParam.height,
 						     pEnc->mbParam.edged_width,
-						     pEnc->mbParam.rounding_type);
+						     pEnc->current->rounding_type);
 				stop_comp_timer();
 
-				if ((pEnc->mbParam.global_flags & XVID_LUMIMASKING) > 0) {
+				if ((pEnc->current->global_flags & XVID_LUMIMASKING)) {
 					if(pMB->dquant != NO_CHANGE) {
 						pMB->mode = MODE_INTER_Q;
-						pEnc->mbParam.quant += DQtab[pMB->dquant];
-						if (pEnc->mbParam.quant > 31) pEnc->mbParam.quant = 31;
-						else if(pEnc->mbParam.quant < 1) pEnc->mbParam.quant = 1;
+						pEnc->current->quant += DQtab[pMB->dquant];
+						if (pEnc->current->quant > 31) pEnc->current->quant = 31;
+						else if(pEnc->current->quant < 1) pEnc->current->quant = 1;
 					}
 				}
-				pMB->quant = pEnc->mbParam.quant;
+				pMB->quant = pEnc->current->quant;
 
 				pMB->field_pred = 0;
 
-				pMB->cbp = MBTransQuantInter(&pEnc->mbParam, pMB, x, y, dct_codes, qcoeff, pCurrent);
+				pMB->cbp = MBTransQuantInter(&pEnc->mbParam, pEnc->current, pMB, x, y, dct_codes, qcoeff);
 			}
 			else 
 			{
 				CodeIntraMB(pEnc, pMB);
-				MBTransQuantIntra(&pEnc->mbParam, pMB, x, y, dct_codes, qcoeff, pCurrent);
+				MBTransQuantIntra(&pEnc->mbParam, pEnc->current, pMB, x, y, dct_codes, qcoeff);
 			}
 
 			start_timer();
-			MBPrediction(&pEnc->mbParam, x, y, pEnc->mbParam.mb_width, qcoeff, pEnc->pMBs);
+			MBPrediction(pEnc->current, x, y, pEnc->mbParam.mb_width, qcoeff);			
 			stop_prediction_timer();
 
 			if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)
@@ -536,32 +1188,37 @@
 			}
 
 			start_timer();
-			MBCoding(&pEnc->mbParam, pMB, qcoeff, bs, &pEnc->sStat);
+			MBCoding(pEnc->current, pMB, qcoeff, bs, &pEnc->sStat);
 			stop_coding_timer();
 		}
 	}
 
 	emms();
 
+	if (pEnc->current->global_flags & XVID_HINTEDME_GET)
+	{
+		HintedMEGet(pEnc, 0);
+	}
+
 	if (pEnc->sStat.iMvCount == 0)
 		pEnc->sStat.iMvCount = 1;
 
 	fSigma = (float)sqrt((float) pEnc->sStat.iMvSum / pEnc->sStat.iMvCount);
 
-	iSearchRange = 1 << (3 + pEnc->mbParam.fixed_code);
+	iSearchRange = 1 << (3 + pEnc->mbParam.m_fcode);
 
 	if ((fSigma > iSearchRange / 3) 
-	    && (pEnc->mbParam.fixed_code <= 3))	// maximum search range 128
+	    && (pEnc->mbParam.m_fcode <= 3))	// maximum search range 128
 	{
-		pEnc->mbParam.fixed_code++;
+		pEnc->mbParam.m_fcode++;
 		iSearchRange *= 2;
 	}
 	else if ((fSigma < iSearchRange / 6)
 		 && (pEnc->sStat.fMvPrevSigma >= 0)
 		 && (pEnc->sStat.fMvPrevSigma < iSearchRange / 6)
-		 && (pEnc->mbParam.fixed_code >= 2))	// minimum search range 16
+		 && (pEnc->mbParam.m_fcode >= 2))	// minimum search range 16
 	{
-		pEnc->mbParam.fixed_code--;
+		pEnc->mbParam.m_fcode--;
 		iSearchRange /= 2;
 	}
 
@@ -571,3 +1228,127 @@
 
 	return 0;					 // inter
 }
+
+
+#ifdef BFRAMES
+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, frame->global_flags & XVID_INTERLACING);
+	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, frame->global_flags & XVID_INTERLACING);
+    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, &pEnc->mbParam, frame);
+
+    *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, mb, 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(mb, qcoeff, frame->fcode, frame->bcode, bs, &pEnc->sStat);
+			stop_coding_timer();
+		}
+	}
+
+	emms();
+
+	// TODO: dynamic fcode/bcode ???
+
+	*pBits = BitstreamPos(bs) - *pBits;
+}
+#endif
\ No newline at end of file