--- trunk/xvidcore/src/encoder.c	2002/06/09 13:16:26	192
+++ trunk/xvidcore/src/encoder.c	2002/06/25 09:41:54	240
@@ -1,4 +1,4 @@
-/**************************************************************************
+/*****************************************************************************
  *
  *  XVID MPEG-4 VIDEO CODEC
  *  -  Encoder main module  -
@@ -26,29 +26,34 @@
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  *
- ***************************************************************************/
+ ****************************************************************************/
 
-/****************************************************************************
+/*****************************************************************************
  * 
  *  History
  *
+ *	20.06.2002 bframe patch
  *  08.05.2002 fix some problem in DEBUG mode;
  *             MinChen <chenm001@163.com>
  *  14.04.2002 added FrameCodeB()
  *
- *  $Id: encoder.c,v 1.39 2002-06-09 13:16:26 edgomez Exp $
+ *  $Id: encoder.c,v 1.49 2002-06-25 09:41:53 suxen_drol Exp $
  *
- ***************************************************************************/
+ ****************************************************************************/
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <math.h>
+#include <string.h>
 
 #include "encoder.h"
 #include "prediction/mbprediction.h"
 #include "global.h"
 #include "utils/timer.h"
 #include "image/image.h"
+#ifdef BFRAMES
+#include "image/font.h"
+#endif
 #include "motion/motion.h"
 #include "bitstream/cbp.h"
 #include "utils/mbfunctions.h"
@@ -61,47 +66,77 @@
 #include "quant/quant_matrix.h"
 #include "utils/mem_align.h"
 
+/*****************************************************************************
+ * Local macros
+ ****************************************************************************/
+
 #define ENC_CHECK(X) if(!(X)) return XVID_ERR_FORMAT
 #define SWAP(A,B)    { void * tmp = A; A = B; B = tmp; }
 
+/*****************************************************************************
+ * Local function prototypes
+ ****************************************************************************/
+
 static int FrameCodeI(Encoder * pEnc,
-		      Bitstream * bs,
-		      uint32_t *pBits);
+					  Bitstream * bs,
+					  uint32_t * pBits);
 
 static int FrameCodeP(Encoder * pEnc,
-		      Bitstream * bs,
-		      uint32_t *pBits,
-		      bool force_inter,
-		      bool vol_header);
+					  Bitstream * bs,
+					  uint32_t * pBits,
+					  bool force_inter,
+					  bool vol_header);
 
 #ifdef BFRAMES
 static void FrameCodeB(Encoder * pEnc,
-		       FRAMEINFO * frame,
-		       Bitstream * bs,
-		       uint32_t *pBits);
+					   FRAMEINFO * frame,
+					   Bitstream * bs,
+					   uint32_t * pBits);
 #endif
 
-static int DQtab[4] = 
-{
+/*****************************************************************************
+ * Local data
+ ****************************************************************************/
+
+static int DQtab[4] = {
 	-1, -2, 1, 2
 };
 
-static int iDQtab[5] = 
-{
+static int iDQtab[5] = {
 	1, 0, NO_CHANGE, 2, 3
 };
 
 
-void static image_null(IMAGE * image)
+static void __inline
+image_null(IMAGE * image)
 {
 	image->y = image->u = image->v = NULL;
 }
 
 
-int encoder_create(XVID_ENC_PARAM * pParam)
+/*****************************************************************************
+ * Encoder creation
+ *
+ * This function creates an Encoder instance, it allocates all necessary
+ * image buffers (reference, current and bframes) and initialize the internal
+ * xvid encoder paremeters according to the XVID_ENC_PARAM input parameter.
+ *
+ * The code seems to be very long but is very basic, mainly memory allocation
+ * and cleaning code.
+ *
+ * Returned values :
+ *    - XVID_ERR_OK     - no errors
+ *    - XVID_ERR_MEMORY - the libc could not allocate memory, the function
+ *                        cleans the structure before exiting.
+ *                        pParam->handle is also set to NULL.
+ *
+ ****************************************************************************/
+
+int
+encoder_create(XVID_ENC_PARAM * pParam)
 {
 	Encoder *pEnc;
-	uint32_t i;
+	int i;
 
 	pParam->handle = NULL;
 
@@ -114,8 +149,7 @@
 
 	/* Fps */
 
-	if (pParam->fincr <= 0 || pParam->fbase <= 0)
-	{
+	if (pParam->fincr <= 0 || pParam->fbase <= 0) {
 		pParam->fincr = 1;
 		pParam->fbase = 25;
 	}
@@ -126,10 +160,8 @@
 	 */
 
 	i = pParam->fincr;
-	while (i > 1)
-	{
-		if (pParam->fincr % i == 0 && pParam->fbase % i == 0)
-		{
+	while (i > 1) {
+		if (pParam->fincr % i == 0 && pParam->fbase % i == 0) {
 			pParam->fincr /= i;
 			pParam->fbase /= i;
 			i = pParam->fincr;
@@ -138,11 +170,11 @@
 		i--;
 	}
 
-	if (pParam->fbase > 65535)
-	{
-		float div = (float)pParam->fbase / 65535;
-		pParam->fbase = (int)(pParam->fbase / div);
-		pParam->fincr = (int)(pParam->fincr / div);
+	if (pParam->fbase > 65535) {
+		float div = (float) pParam->fbase / 65535;
+
+		pParam->fbase = (int) (pParam->fbase / div);
+		pParam->fincr = (int) (pParam->fincr / div);
 	}
 
 	/* Bitrate allocator defaults */
@@ -170,16 +202,20 @@
 	if (pParam->max_quantizer < pParam->min_quantizer)
 		pParam->max_quantizer = pParam->min_quantizer;
 
-	/* 1 keyframe each 10 seconds */ 
+	/* 1 keyframe each 10 seconds */
 
 	if (pParam->max_key_interval == 0)
 		pParam->max_key_interval = 10 * pParam->fincr / pParam->fbase;
-					
+
 
 	pEnc = (Encoder *) xvid_malloc(sizeof(Encoder), CACHE_LINE);
 	if (pEnc == NULL)
 		return XVID_ERR_MEMORY;
 
+	/* Zero the Encoder Structure */
+
+	memset(pEnc, 0, sizeof(Encoder));
+
 	/* Fill members of Encoder structure */
 
 	pEnc->mbParam.width = pParam->width;
@@ -188,12 +224,14 @@
 	pEnc->mbParam.mb_width = (pEnc->mbParam.width + 15) / 16;
 	pEnc->mbParam.mb_height = (pEnc->mbParam.height + 15) / 16;
 
-	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.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->mbParam.m_quant_type = H263_QUANT;
+
 	pEnc->sStat.fMvPrevSigma = -1;
 
 	/* Fill rate control parameters */
@@ -208,26 +246,24 @@
 	pEnc->current = xvid_malloc(sizeof(FRAMEINFO), CACHE_LINE);
 	pEnc->reference = xvid_malloc(sizeof(FRAMEINFO), CACHE_LINE);
 
-	if ( pEnc->current == NULL || pEnc->reference == NULL)
+	if (pEnc->current == NULL || pEnc->reference == NULL)
 		goto xvid_err_memory1;
 
 	/* try to allocate mb memory */
 
-	pEnc->current->mbs = xvid_malloc(sizeof(MACROBLOCK) * \
-					 pEnc->mbParam.mb_width * \
-					 pEnc->mbParam.mb_height,
-					 CACHE_LINE);
-	pEnc->reference->mbs = xvid_malloc(sizeof(MACROBLOCK) * \
-					   pEnc->mbParam.mb_width * \
-					   pEnc->mbParam.mb_height,
-					   CACHE_LINE);
+	pEnc->current->mbs =
+		xvid_malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width *
+					pEnc->mbParam.mb_height, CACHE_LINE);
+	pEnc->reference->mbs =
+		xvid_malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width *
+					pEnc->mbParam.mb_height, CACHE_LINE);
 
 	if (pEnc->current->mbs == NULL || pEnc->reference->mbs == NULL)
 		goto xvid_err_memory2;
 
 	/* try to allocate image memory */
 
-#ifdef _DEBUG
+#ifdef _DEBUG_PSNR
 	image_null(&pEnc->sOriginal);
 #endif
 #ifdef BFRAMES
@@ -243,100 +279,97 @@
 	image_null(&pEnc->vInterHV);
 	image_null(&pEnc->vInterHVf);
 
-#ifdef _DEBUG
-	if (image_create(&pEnc->sOriginal,
-			 pEnc->mbParam.edged_width,
-			 pEnc->mbParam.edged_height) < 0)
+#ifdef _DEBUG_PSNR
+	if (image_create
+		(&pEnc->sOriginal, pEnc->mbParam.edged_width,
+		 pEnc->mbParam.edged_height) < 0)
 		goto xvid_err_memory3;
 #endif
 #ifdef BFRAMES
-	if (image_create(&pEnc->f_refh,
-			 pEnc->mbParam.edged_width,
-			 pEnc->mbParam.edged_height) < 0)
+	if (image_create
+		(&pEnc->f_refh, pEnc->mbParam.edged_width,
+		 pEnc->mbParam.edged_height) < 0)
 		goto xvid_err_memory3;
-	if (image_create(&pEnc->f_refv,
-			 pEnc->mbParam.edged_width,
-			 pEnc->mbParam.edged_height) < 0)
+	if (image_create
+		(&pEnc->f_refv, pEnc->mbParam.edged_width,
+		 pEnc->mbParam.edged_height) < 0)
 		goto xvid_err_memory3;
-	if (image_create(&pEnc->f_refhv,
-			 pEnc->mbParam.edged_width,
-			 pEnc->mbParam.edged_height) < 0)
+	if (image_create
+		(&pEnc->f_refhv, pEnc->mbParam.edged_width,
+		 pEnc->mbParam.edged_height) < 0)
 		goto xvid_err_memory3;
 #endif
-	if (image_create(&pEnc->current->image,
-			 pEnc->mbParam.edged_width,
-			 pEnc->mbParam.edged_height) < 0)
+	if (image_create
+		(&pEnc->current->image, pEnc->mbParam.edged_width,
+		 pEnc->mbParam.edged_height) < 0)
 		goto xvid_err_memory3;
-	if (image_create(&pEnc->reference->image,
-			 pEnc->mbParam.edged_width,
-			 pEnc->mbParam.edged_height) < 0)
+	if (image_create
+		(&pEnc->reference->image, pEnc->mbParam.edged_width,
+		 pEnc->mbParam.edged_height) < 0)
 		goto xvid_err_memory3;
-	if (image_create(&pEnc->vInterH,
-			 pEnc->mbParam.edged_width,
-			 pEnc->mbParam.edged_height) < 0)
+	if (image_create
+		(&pEnc->vInterH, pEnc->mbParam.edged_width,
+		 pEnc->mbParam.edged_height) < 0)
 		goto xvid_err_memory3;
-	if (image_create(&pEnc->vInterV,
-			 pEnc->mbParam.edged_width,
-			 pEnc->mbParam.edged_height) < 0)
+	if (image_create
+		(&pEnc->vInterV, pEnc->mbParam.edged_width,
+		 pEnc->mbParam.edged_height) < 0)
 		goto xvid_err_memory3;
-	if (image_create(&pEnc->vInterVf,
-			 pEnc->mbParam.edged_width,
-			 pEnc->mbParam.edged_height) < 0)
+	if (image_create
+		(&pEnc->vInterVf, pEnc->mbParam.edged_width,
+		 pEnc->mbParam.edged_height) < 0)
 		goto xvid_err_memory3;
-	if (image_create(&pEnc->vInterHV,
-			 pEnc->mbParam.edged_width,
-			 pEnc->mbParam.edged_height) < 0)
+	if (image_create
+		(&pEnc->vInterHV, pEnc->mbParam.edged_width,
+		 pEnc->mbParam.edged_height) < 0)
 		goto xvid_err_memory3;
-	if (image_create(&pEnc->vInterHVf,
-			 pEnc->mbParam.edged_width,
-			 pEnc->mbParam.edged_height) < 0)
+	if (image_create
+		(&pEnc->vInterHVf, pEnc->mbParam.edged_width,
+		 pEnc->mbParam.edged_height) < 0)
 		goto xvid_err_memory3;
 
 
 
 	/* B Frames specific init */
 #ifdef BFRAMES
-	
+
+	pEnc->global = pParam->global;
 	pEnc->mbParam.max_bframes = pParam->max_bframes;
 	pEnc->bquant_ratio = pParam->bquant_ratio;
 	pEnc->bframes = NULL;
 
-	if (pEnc->mbParam.max_bframes > 0)
-	{
+	if (pEnc->mbParam.max_bframes > 0) {
 		int n;
 
-		pEnc->bframes = xvid_malloc(pEnc->mbParam.max_bframes * \
-					    sizeof(FRAMEINFO *),
-					    CACHE_LINE);
+		pEnc->bframes =
+			xvid_malloc(pEnc->mbParam.max_bframes * sizeof(FRAMEINFO *),
+						CACHE_LINE);
 
 		if (pEnc->bframes == NULL)
 			goto xvid_err_memory3;
 
-		for (n=0; n<pEnc->mbParam.max_bframes; n++)
+		for (n = 0; n < pEnc->mbParam.max_bframes; n++)
 			pEnc->bframes[n] = NULL;
-			
 
-		for (n = 0; n < pEnc->mbParam.max_bframes; n++)
-		{
-			pEnc->bframes[n] = xvid_malloc(sizeof(FRAMEINFO),
-						       CACHE_LINE);
+
+		for (n = 0; n < pEnc->mbParam.max_bframes; n++) {
+			pEnc->bframes[n] = xvid_malloc(sizeof(FRAMEINFO), CACHE_LINE);
 
 			if (pEnc->bframes[n] == NULL)
 				goto xvid_err_memory4;
 
-			pEnc->bframes[n]->mbs = xvid_malloc(sizeof(MACROBLOCK) * \
-							    pEnc->mbParam.mb_width * \
-							    pEnc->mbParam.mb_height,
-							    CACHE_LINE);
+			pEnc->bframes[n]->mbs =
+				xvid_malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width *
+							pEnc->mbParam.mb_height, CACHE_LINE);
 
 			if (pEnc->bframes[n]->mbs == NULL)
 				goto xvid_err_memory4;
 
 			image_null(&pEnc->bframes[n]->image);
 
-			if (image_create(&pEnc->bframes[n]->image,
-					 pEnc->mbParam.edged_width,
-					 pEnc->mbParam.edged_height) < 0)
+			if (image_create
+				(&pEnc->bframes[n]->image, pEnc->mbParam.edged_width,
+				 pEnc->mbParam.edged_height) < 0)
 				goto xvid_err_memory4;
 
 		}
@@ -345,23 +378,51 @@
 	pEnc->bframenum_head = 0;
 	pEnc->bframenum_tail = 0;
 	pEnc->flush_bframes = 0;
+	pEnc->bframenum_dx50bvop = -1;
+
+	pEnc->queue = NULL;
+
+
+	if (pEnc->mbParam.max_bframes > 0) {
+		int n;
+
+		pEnc->queue =
+			xvid_malloc(pEnc->mbParam.max_bframes * sizeof(IMAGE),
+						CACHE_LINE);
+
+		if (pEnc->queue == NULL)
+			goto xvid_err_memory4;
+
+		for (n = 0; n < pEnc->mbParam.max_bframes; n++)
+			image_null(&pEnc->queue[n]);
+
+		for (n = 0; n < pEnc->mbParam.max_bframes; n++) {
+			if (image_create
+				(&pEnc->queue[n], pEnc->mbParam.edged_width,
+				 pEnc->mbParam.edged_height) < 0)
+				goto xvid_err_memory5;
+
+		}
+	}
+
+	pEnc->queue_head = 0;
+	pEnc->queue_tail = 0;
+	pEnc->queue_size = 0;
+
 
 	pEnc->mbParam.m_seconds = 0;
 	pEnc->mbParam.m_ticks = 0;
+	pEnc->m_framenum = 0;
 #endif
 
-	pParam->handle = (void *)pEnc;
+	pParam->handle = (void *) pEnc;
 
-	if (pParam->rc_bitrate)
-	{
-		RateControlInit(&pEnc->rate_control,
-				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);
+	if (pParam->rc_bitrate) {
+		RateControlInit(&pEnc->rate_control, 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);
 	}
 
 	init_timer();
@@ -370,153 +431,171 @@
 
 	/*
 	 * We handle all XVID_ERR_MEMORY here, this makes the code lighter
-	 *
-	 * ToDo?: We could avoid that piece of code if encoder_destroy could
-	 *        handle different destroy levels
 	 */
 #ifdef BFRAMES
- xvid_err_memory4:
-	for (i=0; i<pEnc->mbParam.max_bframes; i++)
-	{
+  xvid_err_memory5:
+
+
+	if (pEnc->mbParam.max_bframes > 0) {
 
-		if (pEnc->bframes[i] == NULL) continue;
+		for (i = 0; i < pEnc->mbParam.max_bframes; i++) {
+			image_destroy(&pEnc->queue[i], pEnc->mbParam.edged_width,
+						  pEnc->mbParam.edged_height);
+		}
+		xvid_free(pEnc->queue);
+	}
 
-		image_destroy(&pEnc->bframes[i]->image,
-			      pEnc->mbParam.edged_width,
-			      pEnc->mbParam.edged_height);
+  xvid_err_memory4:
 
-		xvid_free(pEnc->bframes[i]->mbs);
+	if (pEnc->mbParam.max_bframes > 0) {
 
-		xvid_free(pEnc->bframes[i]);
+		for (i = 0; i < pEnc->mbParam.max_bframes; i++) {
 
-	}
+			if (pEnc->bframes[i] == NULL)
+				continue;
+
+			image_destroy(&pEnc->bframes[i]->image, pEnc->mbParam.edged_width,
+						  pEnc->mbParam.edged_height);
+	
+			xvid_free(pEnc->bframes[i]->mbs);
+	
+			xvid_free(pEnc->bframes[i]);
 
-	xvid_free(pEnc->bframes);
+		}	
+
+		xvid_free(pEnc->bframes);
+	}
 
 #endif
 
- xvid_err_memory3:
-#ifdef _DEBUG
-	image_destroy(&pEnc->sOriginal,
-		      pEnc->mbParam.edged_width,
-		      pEnc->mbParam.edged_height);
+  xvid_err_memory3:
+#ifdef _DEBUG_PSNR
+	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);
+	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
 
- xvid_err_memory2:
+	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_err_memory2:
 	xvid_free(pEnc->current->mbs);
 	xvid_free(pEnc->reference->mbs);
 
- xvid_err_memory1:
+  xvid_err_memory1:
 	xvid_free(pEnc->current);
 	xvid_free(pEnc->reference);
 	xvid_free(pEnc);
 
+	pParam->handle = NULL;
+
 	return XVID_ERR_MEMORY;
 }
 
-int encoder_destroy(Encoder * pEnc)
+/*****************************************************************************
+ * Encoder destruction
+ *
+ * This function destroy the entire encoder structure created by a previous
+ * successful encoder_create call.
+ *
+ * Returned values (for now only one returned value) :
+ *    - XVID_ERR_OK     - no errors
+ *
+ ****************************************************************************/
+
+int
+encoder_destroy(Encoder * pEnc)
 {
+#ifdef BFRAMES
+	int i;
+#endif
+	
 	ENC_CHECK(pEnc);
 
 	/* B Frames specific */
 #ifdef BFRAMES
-	int i;
+	if (pEnc->mbParam.max_bframes > 0) {
 
-	for (i=0; i<pEnc->mbParam.max_bframes; i++)
-	{
+		for (i = 0; i < pEnc->mbParam.max_bframes; i++) {
+		
+			image_destroy(&pEnc->queue[i], pEnc->mbParam.edged_width,
+					  pEnc->mbParam.edged_height);
+		}
+		xvid_free(pEnc->queue);
+	}
 
-		if (pEnc->bframes[i] == NULL) continue;
 
-		image_destroy(&pEnc->bframes[i]->image,
-			      pEnc->mbParam.edged_width,
-			      pEnc->mbParam.edged_height);
+	if (pEnc->mbParam.max_bframes > 0) {
 
-		xvid_free(pEnc->bframes[i]->mbs);
+		for (i = 0; i < pEnc->mbParam.max_bframes; i++) {
 
-		xvid_free(pEnc->bframes[i]);
+			if (pEnc->bframes[i] == NULL)
+				continue;
 
-	}
+			image_destroy(&pEnc->bframes[i]->image, pEnc->mbParam.edged_width,
+					  pEnc->mbParam.edged_height);
 
-	xvid_free(pEnc->bframes);
+			xvid_free(pEnc->bframes[i]->mbs);
 
+			xvid_free(pEnc->bframes[i]);
+		}
+
+		xvid_free(pEnc->bframes);
+	
+	}
 #endif
 
 	/* All images, reference, current etc ... */
 
-	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);
+	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);
 #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);
+	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_PSNR
+	image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width,
+				  pEnc->mbParam.edged_height);
 #endif
 
 	/* Encoder structure */
-	
+
 	xvid_free(pEnc->current->mbs);
 	xvid_free(pEnc->current);
 
@@ -529,40 +608,99 @@
 }
 
 
+#ifdef BFRAMES
+void inc_frame_num(Encoder * pEnc)
+{
+	pEnc->iFrameNum++;
+	pEnc->mbParam.m_ticks += pEnc->mbParam.fincr;
+
+	pEnc->mbParam.m_seconds = pEnc->mbParam.m_ticks / pEnc->mbParam.fbase;
+	pEnc->mbParam.m_ticks = pEnc->mbParam.m_ticks % pEnc->mbParam.fbase;
+}
+#endif
+
 
-// ==================================================================
 #ifdef BFRAMES
-int encoder_encode(Encoder * pEnc, XVID_ENC_FRAME * pFrame, XVID_ENC_STATS * pResult)
+void queue_image(Encoder * pEnc, XVID_ENC_FRAME * pFrame)
+{
+	if (pEnc->queue_size >= pEnc->mbParam.max_bframes)
+	{
+		DPRINTF("FATAL: QUEUE FULL");
+		return;
+	}
+
+	DPRINTF("*** QUEUE bf: head=%i tail=%i   queue: head=%i tail=%i size=%i",
+				pEnc->bframenum_head, pEnc->bframenum_tail,
+				pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size);
+
+
+	start_timer();
+	if (image_input
+		(&pEnc->queue[pEnc->queue_tail], pEnc->mbParam.width, pEnc->mbParam.height,
+		 pEnc->mbParam.edged_width, pFrame->image, pFrame->colorspace))
+		return;
+	stop_conv_timer();
+
+	pEnc->queue_size++;
+	pEnc->queue_tail =  (pEnc->queue_tail + 1) % pEnc->mbParam.max_bframes;
+}
+#endif
+
+
+#ifdef BFRAMES
+/*****************************************************************************
+ * IPB frame encoder entry point
+ *
+ * Returned values :
+ *    - XVID_ERR_OK     - no errors
+ *    - XVID_ERR_FORMAT - the image subsystem reported the image had a wrong
+ *                        format
+ ****************************************************************************/
+
+int
+encoder_encode_bframes(Encoder * pEnc,
+			   XVID_ENC_FRAME * pFrame,
+			   XVID_ENC_STATS * pResult)
 {
 	uint16_t x, y;
 	Bitstream bs;
 	uint32_t bits;
 
-#ifdef _DEBUG
+	int input_valid = 1;
+
+#ifdef _DEBUG_PSNR
 	float psnr;
 	char temp[128];
 #endif
 
 	ENC_CHECK(pEnc);
 	ENC_CHECK(pFrame);
+	ENC_CHECK(pFrame->image);
 
 	start_global_timer();
-	
+
 	BitstreamInit(&bs, pFrame->bitstream, 0);
 
-// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-// bframe "flush" code
-// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-    
-	if ((pFrame->image == NULL || pEnc->flush_bframes) && 
-		pEnc->bframenum_head < pEnc->bframenum_tail)
-	{
+ipvop_loop:
+
+	/*
+	 * bframe "flush" code
+	 */
+
+	if ((pFrame->image == NULL || pEnc->flush_bframes)
+		&& (pEnc->bframenum_head < pEnc->bframenum_tail)) {
+
+		if (pEnc->flush_bframes == 0) {
+			/*
+			 * we have reached the end of stream without getting
+			 * a future reference frame... so encode last final
+			 * frame as a pframe
+			 */
+
+			DPRINTF("*** BFRAME (final frame) bf: head=%i tail=%i   queue: head=%i tail=%i size=%i",
+				pEnc->bframenum_head, pEnc->bframenum_tail,
+				pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size);
 
-		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);
 
@@ -572,141 +710,308 @@
 
 			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++;
+		
+		DPRINTF("*** BFRAME (flush) bf: head=%i tail=%i   queue: head=%i tail=%i size=%i",
+				pEnc->bframenum_head, pEnc->bframenum_tail,
+				pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size);
 
+		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;
+
+		if (input_valid)
+			queue_image(pEnc, pFrame);
+
 		return XVID_ERR_OK;
 	}
 
-	if (pFrame->image == NULL)
+	if (pEnc->bframenum_head > 0) {
+		pEnc->bframenum_head = pEnc->bframenum_tail = 0;
+
+		if ((pEnc->global & XVID_GLOBAL_PACKED)) {
+			
+			DPRINTF("*** EMPTY bf: head=%i tail=%i   queue: head=%i tail=%i size=%i",
+				pEnc->bframenum_head, pEnc->bframenum_tail,
+				pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size);
+
+			BitstreamWriteVopHeader(&bs, &pEnc->mbParam, pEnc->current, 0);
+			BitstreamPad(&bs);
+			BitstreamPutBits(&bs, 0x7f, 8);
+
+			pFrame->length = BitstreamLength(&bs);
+			pFrame->intra = 0;
+
+			if (input_valid)
+				queue_image(pEnc, pFrame);
+
+			return XVID_ERR_OK;
+		}
+	}
+
+
+bvop_loop:
+
+	if (pEnc->bframenum_dx50bvop != -1)
 	{
-		pFrame->length = 0;
-		pFrame->input_consumed = 1;
+
+		SWAP(pEnc->current, pEnc->reference);
+		SWAP(pEnc->current, pEnc->bframes[pEnc->bframenum_dx50bvop]);		
+
+		if ((pEnc->global & XVID_GLOBAL_DEBUG)) {
+			image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 100, "DX50 IVOP");
+		}
+
+		if (input_valid)
+		{
+			queue_image(pEnc, pFrame);
+			input_valid = 0;
+		}
+
+	} else if (input_valid) {
+
+		SWAP(pEnc->current, pEnc->reference);
+
+		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();
+
+		// queue input frame, and dequue next image
+		if (pEnc->queue_size > 0)
+		{
+			image_swap(&pEnc->current->image, &pEnc->queue[pEnc->queue_tail]);
+			if (pEnc->queue_head != pEnc->queue_tail)
+			{
+				image_swap(&pEnc->current->image, &pEnc->queue[pEnc->queue_head]);
+			}
+			pEnc->queue_head =  (pEnc->queue_head + 1) % pEnc->mbParam.max_bframes;
+			pEnc->queue_tail =  (pEnc->queue_tail + 1) % pEnc->mbParam.max_bframes;
+		}
+
+	} else if (pEnc->queue_size > 0) {
+		
+		SWAP(pEnc->current, pEnc->reference);
+
+		image_swap(&pEnc->current->image, &pEnc->queue[pEnc->queue_head]);
+		pEnc->queue_head =  (pEnc->queue_head + 1) % pEnc->mbParam.max_bframes;
+		pEnc->queue_size--;
+
+	} else if (BitstreamPos(&bs) == 0) {
+
+		DPRINTF("*** SKIP bf: head=%i tail=%i   queue: head=%i tail=%i size=%i",
+				pEnc->bframenum_head, pEnc->bframenum_tail,
+				pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size);
+
 		pFrame->intra = 0;
+
+		BitstreamPutBits(&bs, 0x7f, 8);
+		BitstreamPad(&bs);
+		pFrame->length = BitstreamLength(&bs);
+		
 		return XVID_ERR_OK;
-	}
 
-	if (pEnc->bframenum_head > 0)
-	{
-		pEnc->bframenum_head = pEnc->bframenum_tail = 0;
+	} else {
+
+		pFrame->length = BitstreamLength(&bs);
+		return XVID_ERR_OK;
 	}
 
 	pEnc->flush_bframes = 0;
 
-// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%	
+	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+	 * Well there was a separation here so i put it in ANSI C
+	 * comment style :-)
+	 * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
 
-	SWAP(pEnc->current, pEnc->reference);
+	emms();
 
-	pEnc->current->quant = (pFrame->quant == 0) ? RateControlGetQ(&pEnc->rate_control, 0) : pFrame->quant;
-	
-	if(pEnc->current->quant < 1)
-		pEnc->current->quant = 1;
-	
-	if(pEnc->current->quant > 31)
-		pEnc->current->quant = 31;
+	// only inc frame num, adapt quant, etc. if we havent seen it before
+	if (pEnc->bframenum_dx50bvop < 0 )
+	{
+		if (pFrame->quant == 0)
+			pEnc->current->quant = RateControlGetQ(&pEnc->rate_control, 0);
+		else
+			pEnc->current->quant = pFrame->quant;
 
-	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; 
+		if (pEnc->current->quant < 1)
+			pEnc->current->quant = 1;
 
-	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();
+		if (pEnc->current->quant > 31)
+			pEnc->current->quant = 31;
+
+		pEnc->current->global_flags = pFrame->general;
+		pEnc->current->motion_flags = pFrame->motion;
 
-#ifdef _DEBUG
-	image_copy(&pEnc->sOriginal, &pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height);
+		/* ToDo : dynamic fcode (in both directions) */
+		pEnc->current->fcode = pEnc->mbParam.m_fcode;
+		pEnc->current->bcode = pEnc->mbParam.m_fcode;
+
+		pEnc->current->seconds = pEnc->mbParam.m_seconds;
+		pEnc->current->ticks = pEnc->mbParam.m_ticks;
+
+		inc_frame_num(pEnc);
+
+#ifdef _DEBUG_PSNR
+		image_copy(&pEnc->sOriginal, &pEnc->current->image,
+			   pEnc->mbParam.edged_width, pEnc->mbParam.height);
 #endif
 
+		emms();
 
-// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-// lumi masking
-// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+		if ((pEnc->global & XVID_GLOBAL_DEBUG)) {
+			image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 5, 
+				"%i  if:%i  st:%i:%i", pEnc->m_framenum++, pEnc->iFrameNum, pEnc->current->seconds, pEnc->current->ticks);
+		}
 
-	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)];
+	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+	 * Luminance 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, temp_dquants,
+								  pEnc->current->quant, pEnc->current->quant,
+								  2 * pEnc->current->quant,
+								  pEnc->mbParam.mb_width,
+								  pEnc->mbParam.mb_height);
+
+			for (y = 0; y < pEnc->mbParam.mb_height; y++) {
+
+#define OFFSET(x,y) ((x) + (y)*pEnc->mbParam.mb_width)
+
+				for (x = 0; x < pEnc->mbParam.mb_width; x++) {
+					MACROBLOCK *pMB = &pEnc->current->mbs[OFFSET(x, y)];
+
+					pMB->dquant = iDQtab[temp_dquants[OFFSET(x, y)] + 2];
+				}
+
+#undef OFFSET
 			}
-		xvid_free(temp_dquants);
+
+			xvid_free(temp_dquants);
+		}
+
 	}
 
+	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+	 * ivop/pvop/bvop selection
+	 * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
+
+
+	if (pEnc->iFrameNum == 0 || pFrame->intra == 1 || pEnc->bframenum_dx50bvop >= 0 ||
+		(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) {
+		/*
+		 * This will be coded as an Intra Frame
+		 */
+
+		DPRINTF("*** IFRAME bf: head=%i tail=%i   queue: head=%i tail=%i size=%i",
+				pEnc->bframenum_head, pEnc->bframenum_tail,
+				pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size);
+		
+		if ((pEnc->global & XVID_GLOBAL_DEBUG)) {
+			image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 200, "IVOP");
+		}
 
-// %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-// 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 ---");
+		// when we reach an iframe in DX50BVOP mode, encode the last bframe as a pframe
+
+		if ((pEnc->global & XVID_GLOBAL_DX50BVOP) && pEnc->bframenum_tail > 0) {
+
+			pEnc->bframenum_tail--;
+			pEnc->bframenum_dx50bvop = pEnc->bframenum_tail;
+
+			SWAP(pEnc->current, pEnc->bframes[pEnc->bframenum_dx50bvop]);
+			if ((pEnc->global & XVID_GLOBAL_DEBUG)) {
+				image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 100, "DX50 BVOP->PVOP");
+			}
+			FrameCodeP(pEnc, &bs, &bits, 1, 0);
 
-		FrameCodeI(pEnc, &bs, &bits);
+			pFrame->intra = 0;
+			
+		} else {
+
+			FrameCodeI(pEnc, &bs, &bits);
+			pFrame->intra = 1;
+
+			pEnc->bframenum_dx50bvop = -1;
+		}
 
-		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->mbParam.max_bframes)
-	{
-		//dprintf("--- PFRAME ---");
+		if ((pEnc->global & XVID_GLOBAL_PACKED) && pEnc->bframenum_tail > 0) {
+			BitstreamPad(&bs);
+			input_valid = 0;
+			goto ipvop_loop;
+		}
+
+		/*
+		 * NB : sequences like "IIBB" decode fine with msfdam but,
+		 *      go screwy with divx 5.00
+		 */
+	} else if (pEnc->bframenum_tail >= pEnc->mbParam.max_bframes) {
+		/*
+		 * This will be coded as a Predicted Frame
+		 */
+
+		DPRINTF("*** PFRAME bf: head=%i tail=%i   queue: head=%i tail=%i size=%i",
+				pEnc->bframenum_head, pEnc->bframenum_tail,
+				pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size);
+		
+		if ((pEnc->global & XVID_GLOBAL_DEBUG)) {
+			image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 200, "PVOP");
+		}
 
 		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;
+		if ((pEnc->global & XVID_GLOBAL_PACKED)) {
+			BitstreamPad(&bs);
+			input_valid = 0;
+			goto ipvop_loop;
 		}
-		else
-		{
+
+	} else {
+		/*
+		 * This will be coded as a Bidirectional Frame
+		 */
+
+		DPRINTF("*** BFRAME (store) bf: head=%i tail=%i   queue: head=%i tail=%i size=%i",
+				pEnc->bframenum_head, pEnc->bframenum_tail,
+				pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size);
+
+		if ((pEnc->global & XVID_GLOBAL_DEBUG)) {
+			image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 200, "BVOP");
+		}
+
+		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
+
+		/* store frame into bframe buffer & swap ref back to current */
 		SWAP(pEnc->current, pEnc->bframes[pEnc->bframenum_tail]);
 		SWAP(pEnc->current, pEnc->reference);
 
@@ -714,22 +1019,15 @@
 
 		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;
+		input_valid = 0;
+		goto bvop_loop;
 	}
 
 	BitstreamPad(&bs);
 	pFrame->length = BitstreamLength(&bs);
 
-	if (pResult)
-	{
+	if (pResult) {
 		pResult->quant = pEnc->current->quant;
 		pResult->hlength = pFrame->length - (pEnc->sStat.iTextBits / 8);
 		pResult->kblks = pEnc->sStat.kblks;
@@ -737,47 +1035,56 @@
 		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);
+	emms();
+
+#ifdef _DEBUG_PSNR
+	psnr =
+		image_psnr(&pEnc->sOriginal, &pEnc->current->image,
+				   pEnc->mbParam.edged_width, pEnc->mbParam.width,
+				   pEnc->mbParam.height);
 
-	sprintf(temp, "PSNR: %f\n", psnr);
+	snprintf(temp, 127, "PSNR: %f\n", psnr);
 	DEBUG(temp);
 #endif
 
-	if (pFrame->quant == 0)
-	{
-		RateControlUpdate(&pEnc->rate_control,
-				  pEnc->current->quant,
-				  pFrame->length,
-				  pFrame->intra);
+	if (pFrame->quant == 0) {
+		RateControlUpdate(&pEnc->rate_control, 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)
+
+#endif
+
+
+
+/*****************************************************************************
+ * "original" IP frame encoder entry point
+ *
+ * Returned values :
+ *    - XVID_ERR_OK     - no errors
+ *    - XVID_ERR_FORMAT - the image subsystem reported the image had a wrong
+ *                        format
+ ****************************************************************************/
+
+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
+
+#ifdef _DEBUG_PSNR
 	float psnr;
-	uint8_t temp[100];
+	uint8_t temp[128];
 #endif
 
 	start_global_timer();
@@ -791,99 +1098,108 @@
 
 	pEnc->current->global_flags = pFrame->general;
 	pEnc->current->motion_flags = pFrame->motion;
+#ifdef BFRAMES
+	pEnc->current->seconds = pEnc->mbParam.m_seconds;
+	pEnc->current->ticks = pEnc->mbParam.m_ticks;
+#endif
 	pEnc->mbParam.hint = &pFrame->hint;
 
 	start_timer();
-	if (image_input(&pEnc->current->image, pEnc->mbParam.width, pEnc->mbParam.height, pEnc->mbParam.edged_width,
-			pFrame->image, pFrame->colorspace))
-	{
+	if (image_input
+		(&pEnc->current->image, pEnc->mbParam.width, pEnc->mbParam.height,
+		 pEnc->mbParam.edged_width, pFrame->image, pFrame->colorspace) < 0)
 		return XVID_ERR_FORMAT;
-	}
 	stop_conv_timer();
 
-#ifdef _DEBUG
-        image_copy(&pEnc->sOriginal, &pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height);
+#ifdef _DEBUG_PSNR
+	image_copy(&pEnc->sOriginal, &pEnc->current->image,
+			   pEnc->mbParam.edged_width, pEnc->mbParam.height);
 #endif
 
-	EMMS();
+	emms();
 
 	BitstreamInit(&bs, pFrame->bitstream, 0);
 
-	if (pFrame->quant == 0)
-	{
-		pEnc->current->quant = RateControlGetQ(&pEnc->rate_control,0);
-	}
-	else
-	{
+	if (pFrame->quant == 0) {
+		pEnc->current->quant = RateControlGetQ(&pEnc->rate_control, 0);
+	} else {
 		pEnc->current->quant = pFrame->quant;
 	}
 
-	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)];
+	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, temp_dquants,
+								  pEnc->current->quant, pEnc->current->quant,
+								  2 * pEnc->current->quant,
+								  pEnc->mbParam.mb_width,
+								  pEnc->mbParam.mb_height);
+
+		for (y = 0; y < pEnc->mbParam.mb_height; y++) {
+
+#define OFFSET(x,y) ((x) + (y)*pEnc->mbParam.mb_width)
+
+			for (x = 0; x < pEnc->mbParam.mb_width; x++) {
+
+
+				MACROBLOCK *pMB = &pEnc->current->mbs[OFFSET(x, y)];
+
+				pMB->dquant = iDQtab[temp_dquants[OFFSET(x, y)] + 2];
 			}
+
+#undef OFFSET
+		}
+
 		xvid_free(temp_dquants);
 	}
 
 	if (pEnc->current->global_flags & XVID_H263QUANT) {
-		if(pEnc->mbParam.m_quant_type != H263_QUANT)
+		if (pEnc->mbParam.m_quant_type != H263_QUANT)
 			write_vol_header = 1;
 		pEnc->mbParam.m_quant_type = H263_QUANT;
-	}
-	else if(pEnc->current->global_flags & XVID_MPEGQUANT) {
-		int ret1, ret2;
+	} else if (pEnc->current->global_flags & XVID_MPEGQUANT) {
+		int matrix1_changed, matrix2_changed;
 
-		ret1 = ret2 = 0;
+		matrix1_changed = matrix2_changed = 0;
 
-		if(pEnc->mbParam.m_quant_type != MPEG4_QUANT)
+		if (pEnc->mbParam.m_quant_type != MPEG4_QUANT)
 			write_vol_header = 1;
-		
+
 		pEnc->mbParam.m_quant_type = MPEG4_QUANT;
-		
+
 		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)
-				ret2 = set_inter_matrix(pFrame->quant_inter_matrix);
-		}
-		else {
-			ret1 = set_intra_matrix(get_default_intra_matrix());
-			ret2 = set_inter_matrix(get_default_inter_matrix());
+			if (pFrame->quant_intra_matrix != NULL)
+				matrix1_changed = set_intra_matrix(pFrame->quant_intra_matrix);
+			if (pFrame->quant_inter_matrix != NULL)
+				matrix2_changed = set_inter_matrix(pFrame->quant_inter_matrix);
+		} else {
+			matrix1_changed = set_intra_matrix(get_default_intra_matrix());
+			matrix2_changed = set_inter_matrix(get_default_inter_matrix());
 		}
-		if(write_vol_header == 0)
-			write_vol_header = ret1 | ret2;
+		if (write_vol_header == 0)
+			write_vol_header = matrix1_changed | matrix2_changed;
 	}
 
-	if (pFrame->intra < 0)
-	{
-		if ((pEnc->iFrameNum == 0) || ((pEnc->iMaxKeyInterval > 0) 
-					       && (pEnc->iFrameNum >= pEnc->iMaxKeyInterval)))
-
+	if (pFrame->intra < 0) {
+		if ((pEnc->iFrameNum == 0)
+			|| ((pEnc->iMaxKeyInterval > 0)
+				&& (pEnc->iFrameNum >= pEnc->iMaxKeyInterval))) {
 			pFrame->intra = FrameCodeI(pEnc, &bs, &bits);
-		else
+		} else {
 			pFrame->intra = FrameCodeP(pEnc, &bs, &bits, 0, write_vol_header);
-	}
-	else
-	{
-		if (pFrame->intra == 1)
+		}
+	} else {
+		if (pFrame->intra == 1) {
 			pFrame->intra = FrameCodeI(pEnc, &bs, &bits);
-		else
+		} else {
 			pFrame->intra = FrameCodeP(pEnc, &bs, &bits, 1, write_vol_header);
+		}
+
 	}
 
 	BitstreamPutBits(&bs, 0xFFFF, 16);
@@ -891,44 +1207,48 @@
 	BitstreamPad(&bs);
 	pFrame->length = BitstreamLength(&bs);
 
-	if (pResult)
-	{
+	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;
 	}
-   
-	EMMS();
 
-	if (pFrame->quant == 0)
-	{
-		RateControlUpdate(&pEnc->rate_control,
-				  pEnc->current->quant,
-				  pFrame->length,
-				  pFrame->intra);
-	}
+	emms();
 
-#ifdef _DEBUG
-	psnr = image_psnr(&pEnc->sOriginal, &pEnc->current->image, pEnc->mbParam.edged_width,
-				pEnc->mbParam.width, pEnc->mbParam.height);
+	if (pFrame->quant == 0) {
+		RateControlUpdate(&pEnc->rate_control, pEnc->current->quant,
+						  pFrame->length, pFrame->intra);
+	}
+#ifdef _DEBUG_PSNR
+	psnr =
+		image_psnr(&pEnc->sOriginal, &pEnc->current->image,
+				   pEnc->mbParam.edged_width, pEnc->mbParam.width,
+				   pEnc->mbParam.height);
 
-	sprintf(temp, "PSNR: %f\n", psnr);
+	snprintf(temp, 127, "PSNR: %f\n", psnr);
 	DEBUG(temp);
 #endif
 
+#ifdef BFRAMES
+	inc_frame_num(pEnc);
+#else
 	pEnc->iFrameNum++;
-	
+#endif
+
+
 	stop_global_timer();
 	write_timer();
 
 	return XVID_ERR_OK;
 }
-#endif
 
 
-static __inline void CodeIntraMB(Encoder *pEnc, MACROBLOCK *pMB) {
+static __inline void
+CodeIntraMB(Encoder * pEnc,
+			MACROBLOCK * pMB)
+{
 
 	pMB->mode = MODE_INTRA;
 
@@ -939,13 +1259,14 @@
 	pMB->sad16 = 0;
 
 	if ((pEnc->current->global_flags & XVID_LUMIMASKING)) {
-		if(pMB->dquant != NO_CHANGE)
-		{
+		if (pMB->dquant != NO_CHANGE) {
 			pMB->mode = MODE_INTRA_Q;
 			pEnc->current->quant += DQtab[pMB->dquant];
-		
-			if (pEnc->current->quant > 31) pEnc->current->quant = 31;
-			if (pEnc->current->quant < 1) pEnc->current->quant = 1;
+
+			if (pEnc->current->quant > 31)
+				pEnc->current->quant = 31;
+			if (pEnc->current->quant < 1)
+				pEnc->current->quant = 1;
 		}
 	}
 
@@ -956,100 +1277,104 @@
 #define FCODEBITS	3
 #define MODEBITS	5
 
-void HintedMESet(Encoder * pEnc, int * intra)
+void
+HintedMESet(Encoder * pEnc,
+			int *intra)
 {
-	HINTINFO * hint;
+	HINTINFO *hint;
 	Bitstream bs;
 	int length, high;
 	uint32_t x, y;
 
 	hint = pEnc->mbParam.hint;
 
-	if (hint->rawhints)
-	{
+	if (hint->rawhints) {
 		*intra = hint->mvhint.intra;
-	}
-	else
-	{
+	} else {
 		BitstreamInit(&bs, hint->hintstream, hint->hintlength);
 		*intra = BitstreamGetBit(&bs);
 	}
 
-	if (*intra)
-	{
+	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];
+	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 =
+				(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;
+			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;
+			} 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);
+					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->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
+			} else				// intra / stuffing / not_coded
 			{
-				for (vec=0 ; vec<4 ; ++vec)
-				{
-					pMB->mvs[vec].x  = pMB->mvs[vec].y  = 0;
+				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)
-			{
+				(pEnc->current->global_flags & XVID_LUMIMASKING)
+				&& pMB->dquant != NO_CHANGE) {
 				pMB->mode = MODE_INTRA;
 
-				for (vec=0 ; vec<4 ; ++vec)
-				{
+				for (vec = 0; vec < 4; ++vec) {
 					pMB->mvs[vec].x = pMB->mvs[vec].y = 0;
 				}
 			}
@@ -1058,100 +1383,81 @@
 }
 
 
-void HintedMEGet(Encoder * pEnc, int intra)
+void
+HintedMEGet(Encoder * pEnc,
+			int intra)
 {
-	HINTINFO * hint;
+	HINTINFO *hint;
 	Bitstream bs;
 	uint32_t x, y;
 	int length, high;
 
 	hint = pEnc->mbParam.hint;
 
-	if (hint->rawhints)
-	{
+	if (hint->rawhints) {
 		hint->mvhint.intra = intra;
-	}
-	else
-	{
+	} else {
 		BitstreamInit(&bs, hint->hintstream, 0);
 		BitstreamPutBit(&bs, intra);
 	}
 
-	if (intra)
-	{
-		if (!hint->rawhints)
-		{
+	if (intra) {
+		if (!hint->rawhints) {
 			BitstreamPad(&bs);
 			hint->hintlength = BitstreamLength(&bs);
 		}
 		return;
 	}
 
-	length	= pEnc->current->fcode + 5;
-	high	= 1 << (length - 1);
+	length = pEnc->current->fcode + 5;
+	high = 1 << (length - 1);
 
-	if (hint->rawhints)
-	{
+	if (hint->rawhints) {
 		hint->mvhint.fcode = pEnc->current->fcode;
-	}
-	else
-	{
+	} 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];
+	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)
-			{
+			if (hint->rawhints) {
 				bhint->mode = pMB->mode;
-			}
-			else
-			{
+			} 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 (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)
-				{
+				if (hint->rawhints) {
 					bhint->mvs[0].x = tmp.x;
 					bhint->mvs[0].y = tmp.y;
-				}
-				else
-				{
+				} else {
 					BitstreamPutBits(&bs, tmp.x, length);
 					BitstreamPutBits(&bs, tmp.y, length);
 				}
-			}
-			else if (pMB->mode == MODE_INTER4V)
-			{
+			} 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;
+				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)
-					{
+					if (hint->rawhints) {
 						bhint->mvs[vec].x = tmp.x;
 						bhint->mvs[vec].y = tmp.y;
-					}
-					else
-					{
+					} else {
 						BitstreamPutBits(&bs, tmp.x, length);
 						BitstreamPutBits(&bs, tmp.y, length);
 					}
@@ -1160,19 +1466,21 @@
 		}
 	}
 
-	if (!hint->rawhints)
-	{
+	if (!hint->rawhints) {
 		BitstreamPad(&bs);
 		hint->hintlength = BitstreamLength(&bs);
 	}
 }
 
 
-static int FrameCodeI(Encoder * pEnc, Bitstream * bs, uint32_t *pBits)
+static int
+FrameCodeI(Encoder * pEnc,
+		   Bitstream * bs,
+		   uint32_t * pBits)
 {
 
 	DECLARE_ALIGNED_MATRIX(dct_codes, 6, 64, int16_t, CACHE_LINE);
-	DECLARE_ALIGNED_MATRIX(qcoeff,    6, 64, int16_t, CACHE_LINE);
+	DECLARE_ALIGNED_MATRIX(qcoeff, 6, 64, int16_t, CACHE_LINE);
 
 	uint16_t x, y;
 
@@ -1182,7 +1490,13 @@
 	pEnc->current->coding_type = I_VOP;
 
 	BitstreamWriteVolHeader(bs, &pEnc->mbParam, pEnc->current);
-	BitstreamWriteVopHeader(bs, &pEnc->mbParam, pEnc->current);
+#ifdef BFRAMES
+#define DIVX501B481P "DivX501b481p"
+	if ((pEnc->global & XVID_GLOBAL_PACKED)) {
+		BitstreamWriteUserData(bs, DIVX501B481P, strlen(DIVX501B481P));
+	}
+#endif
+	BitstreamWriteVopHeader(bs, &pEnc->mbParam, pEnc->current, 1);
 
 	*pBits = BitstreamPos(bs);
 
@@ -1191,13 +1505,14 @@
 	pEnc->sStat.mblks = pEnc->sStat.ublks = 0;
 
 	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];
+		for (x = 0; x < pEnc->mbParam.mb_width; x++) {
+			MACROBLOCK *pMB =
+				&pEnc->current->mbs[x + y * pEnc->mbParam.mb_width];
 
 			CodeIntraMB(pEnc, pMB);
 
-			MBTransQuantIntra(&pEnc->mbParam, pEnc->current, pMB, x, y, dct_codes, qcoeff);
+			MBTransQuantIntra(&pEnc->mbParam, pEnc->current, pMB, x, y,
+							  dct_codes, qcoeff);
 
 			start_timer();
 			MBPrediction(pEnc->current, x, y, pEnc->mbParam.mb_width, qcoeff);
@@ -1216,39 +1531,40 @@
 	pEnc->sStat.iMvCount = 0;
 	pEnc->mbParam.m_fcode = 2;
 
-	if (pEnc->current->global_flags & XVID_HINTEDME_GET)
-	{
+	if (pEnc->current->global_flags & XVID_HINTEDME_GET) {
 		HintedMEGet(pEnc, 1);
 	}
 
-	return 1;					 // intra
+	return 1;					// intra
 }
 
 
 #define INTRA_THRESHOLD 0.5
 
-static int FrameCodeP(Encoder * pEnc, Bitstream * bs, uint32_t *pBits, bool force_inter, bool vol_header)
+static int
+FrameCodeP(Encoder * pEnc,
+		   Bitstream * bs,
+		   uint32_t * pBits,
+		   bool force_inter,
+		   bool vol_header)
 {
 	float fSigma;
 
 	DECLARE_ALIGNED_MATRIX(dct_codes, 6, 64, int16_t, CACHE_LINE);
-	DECLARE_ALIGNED_MATRIX(qcoeff,    6, 64, int16_t, CACHE_LINE);
+	DECLARE_ALIGNED_MATRIX(qcoeff, 6, 64, int16_t, CACHE_LINE);
 
 	int iLimit;
 	uint32_t x, y;
 	int iSearchRange;
 	int bIntra;
-
+	
 	/* IMAGE *pCurrent = &pEnc->current->image; */
 	IMAGE *pRef = &pEnc->reference->image;
 
 	start_timer();
-	image_setedges(pRef,
-		       pEnc->mbParam.edged_width,
-		       pEnc->mbParam.edged_height,
-		       pEnc->mbParam.width,
-		       pEnc->mbParam.height,
-		       pEnc->current->global_flags & XVID_INTERLACING);
+	image_setedges(pRef, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height,
+				   pEnc->mbParam.width, pEnc->mbParam.height,
+				   pEnc->current->global_flags & XVID_INTERLACING);
 	stop_edges_timer();
 
 	pEnc->mbParam.m_rounding_type = 1 - pEnc->mbParam.m_rounding_type;
@@ -1256,47 +1572,42 @@
 	pEnc->current->fcode = pEnc->mbParam.m_fcode;
 
 	if (!force_inter)
-		iLimit = (int)(pEnc->mbParam.mb_width * pEnc->mbParam.mb_height * INTRA_THRESHOLD);
+		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->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->current->rounding_type);
+		image_interpolate(pRef, &pEnc->vInterH, &pEnc->vInterV,
+						  &pEnc->vInterHV, pEnc->mbParam.edged_width,
+						  pEnc->mbParam.edged_height,
+						  pEnc->current->rounding_type);
 		stop_inter_timer();
 	}
 
 	start_timer();
-	if (pEnc->current->global_flags & XVID_HINTEDME_SET)
-	{
+	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);
+	} else {
+		bIntra =
+			MotionEstimation(&pEnc->mbParam, pEnc->current, pEnc->reference,
+							 &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV,
+							 iLimit);
 	}
 	stop_motion_timer();
 
-	if (bIntra == 1)
-	{
+	if (bIntra == 1) {
 		return FrameCodeI(pEnc, bs, pBits);
 	}
 
 	pEnc->current->coding_type = P_VOP;
 
-	if(vol_header)
+	if (vol_header)
 		BitstreamWriteVolHeader(bs, &pEnc->mbParam, pEnc->current);
 
-	BitstreamWriteVopHeader(bs, &pEnc->mbParam, pEnc->current);
+	BitstreamWriteVopHeader(bs, &pEnc->mbParam, pEnc->current, 1);
 
 	*pBits = BitstreamPos(bs);
 
@@ -1305,69 +1616,58 @@
 	pEnc->sStat.iMvCount = 0;
 	pEnc->sStat.kblks = pEnc->sStat.mblks = pEnc->sStat.ublks = 0;
 
-	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];
+	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];
 
 			bIntra = (pMB->mode == MODE_INTRA) || (pMB->mode == MODE_INTRA_Q);
 
-			if (!bIntra)
-			{
+			if (!bIntra) {
 				start_timer();
-				MBMotionCompensation(pMB,
-						     x, y,
-						     &pEnc->reference->image,
-						     &pEnc->vInterH,
-						     &pEnc->vInterV,
-						     &pEnc->vInterHV,
-						     &pEnc->current->image,
-						     dct_codes,
-						     pEnc->mbParam.width,
-						     pEnc->mbParam.height,
-						     pEnc->mbParam.edged_width,
-						     pEnc->current->rounding_type);
+				MBMotionCompensation(pMB, x, y, &pEnc->reference->image,
+									 &pEnc->vInterH, &pEnc->vInterV,
+									 &pEnc->vInterHV, &pEnc->current->image,
+									 dct_codes, pEnc->mbParam.width,
+									 pEnc->mbParam.height,
+									 pEnc->mbParam.edged_width,
+									 pEnc->current->rounding_type);
 				stop_comp_timer();
 
 				if ((pEnc->current->global_flags & XVID_LUMIMASKING)) {
-					if(pMB->dquant != NO_CHANGE) {
+					if (pMB->dquant != NO_CHANGE) {
 						pMB->mode = MODE_INTER_Q;
 						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;
+						if (pEnc->current->quant > 31)
+							pEnc->current->quant = 31;
+						else if (pEnc->current->quant < 1)
+							pEnc->current->quant = 1;
 					}
 				}
 				pMB->quant = pEnc->current->quant;
 
 				pMB->field_pred = 0;
 
-				pMB->cbp = MBTransQuantInter(&pEnc->mbParam, pEnc->current, pMB, x, y, dct_codes, qcoeff);
-			}
-			else 
-			{
+				pMB->cbp =
+					MBTransQuantInter(&pEnc->mbParam, pEnc->current, pMB, x, y,
+									  dct_codes, qcoeff);
+			} else {
 				CodeIntraMB(pEnc, pMB);
-				MBTransQuantIntra(&pEnc->mbParam, pEnc->current, pMB, x, y, dct_codes, qcoeff);
+				MBTransQuantIntra(&pEnc->mbParam, pEnc->current, pMB, x, y,
+								  dct_codes, qcoeff);
 			}
 
 			start_timer();
-			MBPrediction(pEnc->current, x, y, pEnc->mbParam.mb_width, qcoeff);			
+			MBPrediction(pEnc->current, x, y, pEnc->mbParam.mb_width, qcoeff);
 			stop_prediction_timer();
 
-			if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q)
-			{
+			if (pMB->mode == MODE_INTRA || pMB->mode == MODE_INTRA_Q) {
 				pEnc->sStat.kblks++;
-			}
-			else if (pMB->cbp || 
-				 pMB->mvs[0].x || pMB->mvs[0].y ||
-				 pMB->mvs[1].x || pMB->mvs[1].y ||
-				 pMB->mvs[2].x || pMB->mvs[2].y ||
-				 pMB->mvs[3].x || pMB->mvs[3].y)
-			{
+			} else if (pMB->cbp || pMB->mvs[0].x || pMB->mvs[0].y ||
+					   pMB->mvs[1].x || pMB->mvs[1].y || pMB->mvs[2].x ||
+					   pMB->mvs[2].y || pMB->mvs[3].x || pMB->mvs[3].y) {
 				pEnc->sStat.mblks++;
-			}
-			else
-			{
+			} else {
 				pEnc->sStat.ublks++;
 			}
 
@@ -1379,93 +1679,103 @@
 
 	emms();
 
-	if (pEnc->current->global_flags & XVID_HINTEDME_GET)
-	{
+	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);
+	fSigma = (float) sqrt((float) pEnc->sStat.iMvSum / pEnc->sStat.iMvCount);
 
 	iSearchRange = 1 << (3 + pEnc->mbParam.m_fcode);
 
-	if ((fSigma > iSearchRange / 3) 
-	    && (pEnc->mbParam.m_fcode <= 3))	// maximum search range 128
+	if ((fSigma > iSearchRange / 3)
+		&& (pEnc->mbParam.m_fcode <= 3))	// maximum search range 128
 	{
 		pEnc->mbParam.m_fcode++;
 		iSearchRange *= 2;
-	}
-	else if ((fSigma < iSearchRange / 6)
-		 && (pEnc->sStat.fMvPrevSigma >= 0)
-		 && (pEnc->sStat.fMvPrevSigma < iSearchRange / 6)
-		 && (pEnc->mbParam.m_fcode >= 2))	// minimum search range 16
+	} else if ((fSigma < iSearchRange / 6)
+			   && (pEnc->sStat.fMvPrevSigma >= 0)
+			   && (pEnc->sStat.fMvPrevSigma < iSearchRange / 6)
+			   && (pEnc->mbParam.m_fcode >= 2))	// minimum search range 16
 	{
 		pEnc->mbParam.m_fcode--;
 		iSearchRange /= 2;
 	}
 
 	pEnc->sStat.fMvPrevSigma = fSigma;
-    
+
 	*pBits = BitstreamPos(bs) - *pBits;
 
-	return 0;					 // inter
+	return 0;					// inter
 }
 
 
 #ifdef BFRAMES
-static void FrameCodeB(Encoder * pEnc, FRAMEINFO * frame, Bitstream * bs, uint32_t *pBits)
+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;
+	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 *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);
+	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);
+					  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_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);
+					  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);
-		
+	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);
-	}*/
+	   {
+	   BitstreamWriteVolHeader(bs, pEnc->mbParam.width, pEnc->mbParam.height, pEnc->mbParam.quant_type);
+	   } */
 
-    frame->coding_type = B_VOP;
-    BitstreamWriteVopHeader(bs, &pEnc->mbParam, frame);
+	frame->coding_type = B_VOP;
+	BitstreamWriteVopHeader(bs, &pEnc->mbParam, frame, 1);
 
-    *pBits = BitstreamPos(bs);
+	*pBits = BitstreamPos(bs);
 
-    pEnc->sStat.iTextBits = 0;
-    pEnc->sStat.iMvSum = 0;
-    pEnc->sStat.iMvCount = 0;
+	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++)
-	{
+	for (y = 0; y < pEnc->mbParam.mb_height; y++) {
 		// reset prediction
 
 		forward.x = 0;
@@ -1473,58 +1783,56 @@
 		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];
+		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)
-			{
+			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);
-	
+									 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 =
+				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_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)
-			{
+			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)
-			{
+
+			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;
 			}
+//			DPRINTF("%05i : [%i %i] M=%i CBP=%i MVS=%i,%i forward=%i,%i", pEnc->m_framenum, x, y, mb->mode, mb->cbp, mb->mvs[0].x, mb->mvs[0].y, forward.x, forward.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);
+			start_timer();
+			MBCodingBVOP(mb, qcoeff, frame->fcode, frame->bcode, bs,
+						 &pEnc->sStat);
 			stop_coding_timer();
 		}
 	}