--- trunk/xvidcore/src/encoder.c	2002/06/13 11:42:15	198
+++ trunk/xvidcore/src/encoder.c	2002/07/29 19:21:23	349
@@ -32,14 +32,18 @@
  * 
  *  History
  *
+ *  10.07.2002  added BFRAMES_DEC_DEBUG support
+ *              MinChen <chenm001@163.com>
+ *  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.42 2002-06-13 11:42:15 edgomez Exp $
+ *  $Id: encoder.c,v 1.66 2002-07-29 19:21:23 chl Exp $
  *
  ****************************************************************************/
 
+
 #include <stdlib.h>
 #include <stdio.h>
 #include <math.h>
@@ -50,6 +54,10 @@
 #include "global.h"
 #include "utils/timer.h"
 #include "image/image.h"
+#ifdef BFRAMES
+#include "image/font.h"
+#include "motion/sad.h"
+#endif
 #include "motion/motion.h"
 #include "bitstream/cbp.h"
 #include "utils/mbfunctions.h"
@@ -62,6 +70,9 @@
 #include "quant/quant_matrix.h"
 #include "utils/mem_align.h"
 
+#ifdef _SMP
+#include "motion/smp_motion_est.h"
+#endif 
 /*****************************************************************************
  * Local macros
  ****************************************************************************/
@@ -132,7 +143,7 @@
 encoder_create(XVID_ENC_PARAM * pParam)
 {
 	Encoder *pEnc;
-	uint32_t i;
+	int i;
 
 	pParam->handle = NULL;
 
@@ -200,10 +211,9 @@
 
 	/* 1 keyframe each 10 seconds */
 
-	if (pParam->max_key_interval == 0)
+	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;
@@ -226,6 +236,12 @@
 	pEnc->mbParam.fbase = pParam->fbase;
 	pEnc->mbParam.fincr = pParam->fincr;
 
+	pEnc->mbParam.m_quant_type = H263_QUANT;
+
+#ifdef _SMP
+	pEnc->mbParam.num_threads = MIN(pParam->num_threads, MAXNUMTHREADS);
+#endif
+
 	pEnc->sStat.fMvPrevSigma = -1;
 
 	/* Fill rate control parameters */
@@ -257,7 +273,7 @@
 
 	/* try to allocate image memory */
 
-#ifdef _DEBUG
+#ifdef _DEBUG_PSNR
 	image_null(&pEnc->sOriginal);
 #endif
 #ifdef BFRAMES
@@ -273,7 +289,7 @@
 	image_null(&pEnc->vInterHV);
 	image_null(&pEnc->vInterHVf);
 
-#ifdef _DEBUG
+#ifdef _DEBUG_PSNR
 	if (image_create
 		(&pEnc->sOriginal, pEnc->mbParam.edged_width,
 		 pEnc->mbParam.edged_height) < 0)
@@ -327,8 +343,10 @@
 	/* B Frames specific init */
 #ifdef BFRAMES
 
+	pEnc->global = pParam->global;
 	pEnc->mbParam.max_bframes = pParam->max_bframes;
 	pEnc->bquant_ratio = pParam->bquant_ratio;
+	pEnc->frame_drop_ratio = pParam->frame_drop_ratio;
 	pEnc->bframes = NULL;
 
 	if (pEnc->mbParam.max_bframes > 0) {
@@ -371,9 +389,42 @@
 	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;
+	pEnc->last_pframe = 0;
 #endif
 
 	pParam->handle = (void *) pEnc;
@@ -394,27 +445,43 @@
 	 * We handle all XVID_ERR_MEMORY here, this makes the code lighter
 	 */
 #ifdef BFRAMES
+  xvid_err_memory5:
+
+
+	if (pEnc->mbParam.max_bframes > 0) {
+
+		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);
+	}
+
   xvid_err_memory4:
-	for (i = 0; i < pEnc->mbParam.max_bframes; i++) {
 
-		if (pEnc->bframes[i] == NULL)
-			continue;
+	if (pEnc->mbParam.max_bframes > 0) {
 
-		image_destroy(&pEnc->bframes[i]->image, pEnc->mbParam.edged_width,
-					  pEnc->mbParam.edged_height);
+		for (i = 0; i < pEnc->mbParam.max_bframes; i++) {
 
-		xvid_free(pEnc->bframes[i]->mbs);
+			if (pEnc->bframes[i] == NULL)
+				continue;
 
-		xvid_free(pEnc->bframes[i]);
+			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
+#ifdef _DEBUG_PSNR
 	image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width,
 				  pEnc->mbParam.edged_height);
 #endif
@@ -471,28 +538,43 @@
 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[i]->mbs);
 
-	xvid_free(pEnc->bframes);
+			xvid_free(pEnc->bframes[i]);
+		}
 
+		xvid_free(pEnc->bframes);
+	
+	}
 #endif
 
 	/* All images, reference, current etc ... */
@@ -519,7 +601,7 @@
 	image_destroy(&pEnc->f_refhv, pEnc->mbParam.edged_width,
 				  pEnc->mbParam.edged_height);
 #endif
-#ifdef _DEBUG
+#ifdef _DEBUG_PSNR
 	image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width,
 				  pEnc->mbParam.edged_height);
 #endif
@@ -537,11 +619,49 @@
 	return XVID_ERR_OK;
 }
 
+
+#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
+void queue_image(Encoder * pEnc, XVID_ENC_FRAME * pFrame)
+{
+	if (pEnc->queue_size >= pEnc->mbParam.max_bframes)
+	{
+		DPRINTF(DPRINTF_DEBUG,"FATAL: QUEUE FULL");
+		return;
+	}
+
+	DPRINTF(DPRINTF_DEBUG,"*** 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
 /*****************************************************************************
- * Frame encoder entry point
- *
- * At this moment 2 versions coexist : one for IPB compatible encoder,
- *                                     another one for the old IP encoder.
+ * IPB frame encoder entry point
  *
  * Returned values :
  *    - XVID_ERR_OK     - no errors
@@ -549,13 +669,8 @@
  *                        format
  ****************************************************************************/
 
-
-#ifdef BFRAMES
-/*****************************************************************************
- * Frame encoder entry point for IPB capable encoder
- ****************************************************************************/
 int
-encoder_encode(Encoder * pEnc,
+encoder_encode_bframes(Encoder * pEnc,
 			   XVID_ENC_FRAME * pFrame,
 			   XVID_ENC_STATS * pResult)
 {
@@ -563,18 +678,23 @@
 	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);
 
+ipvop_loop:
+
 	/*
 	 * bframe "flush" code
 	 */
@@ -589,10 +709,10 @@
 			 * frame as a pframe
 			 */
 
-			/* ToDo : remove dprintf calls */
-			/*
-			   dprintf("--- PFRAME (final frame correction) --- ");
-			 */
+			DPRINTF(DPRINTF_DEBUG,"*** 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);
+
 			pEnc->bframenum_tail--;
 			SWAP(pEnc->current, pEnc->reference);
 
@@ -602,38 +722,120 @@
 
 			BitstreamPad(&bs);
 			pFrame->length = BitstreamLength(&bs);
-			pFrame->input_consumed = 0;
 			pFrame->intra = 0;
 
 			return XVID_ERR_OK;
 		}
 
-		/* ToDo : remove dprintf calls */
-		/*
-		   dprintf("--- BFRAME (flush) --- ");
-		 */
+		
+		DPRINTF(DPRINTF_DEBUG,"*** 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) {
-		pFrame->length = 0;
-		pFrame->input_consumed = 1;
+	if (pEnc->bframenum_head > 0) {
+		pEnc->bframenum_head = pEnc->bframenum_tail = 0;
+
+		if ((pEnc->global & XVID_GLOBAL_PACKED)) {
+			
+			DPRINTF(DPRINTF_DEBUG,"*** 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)
+	{
+
+		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(DPRINTF_DEBUG,"*** 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;
@@ -643,76 +845,80 @@
 	 * comment style :-)
 	 * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
 
-	SWAP(pEnc->current, pEnc->reference);
-
 	emms();
 
-	if (pFrame->quant == 0)
-		pEnc->current->quant = RateControlGetQ(&pEnc->rate_control, 0);
-	else
-		pEnc->current->quant = pFrame->quant;
+	// 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;
+
+/*		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;
+
+		/* ToDo : dynamic 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;
+		pEnc->current->seconds = pEnc->mbParam.m_seconds;
+		pEnc->current->ticks = pEnc->mbParam.m_ticks;
 
-	if (pEnc->current->quant > 31)
-		pEnc->current->quant = 31;
+		inc_frame_num(pEnc);
 
-	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 : dynamic 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->current->image,
+#ifdef _DEBUG_PSNR
+		image_copy(&pEnc->sOriginal, &pEnc->current->image,
 			   pEnc->mbParam.edged_width, pEnc->mbParam.height);
 #endif
 
-	emms();
+		emms();
+
+		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);
+		}
 
 	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 	 * Luminance masking
 	 * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
 
-	if ((pEnc->current->global_flags & XVID_LUMIMASKING)) {
-		int *temp_dquants =
-			(int *) xvid_malloc(pEnc->mbParam.mb_width *
+		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->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++) {
+			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)];
+				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];
-			}
+					pMB->dquant = iDQtab[temp_dquants[OFFSET(x, y)] + 2];
+				}
 
 #undef OFFSET
+			}
 
+			xvid_free(temp_dquants);
 		}
 
-		xvid_free(temp_dquants);
 	}
 
 	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -720,7 +926,7 @@
 	 * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
 
 
-	if (pEnc->iFrameNum == 0 || pFrame->intra == 1 ||
+	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,
@@ -730,16 +936,45 @@
 		 * This will be coded as an Intra Frame
 		 */
 
-		/* ToDo : Remove dprintf calls */
-		/*
-		   dprintf("--- IFRAME ---");
-		 */
+		DPRINTF(DPRINTF_DEBUG,"*** 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");
+		}
+
+		// 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;
 
-		FrameCodeI(pEnc, &bs, &bits);
+			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);
+
+			pFrame->intra = 0;
+			
+		} else {
+
+			FrameCodeI(pEnc, &bs, &bits);
+			pFrame->intra = 1;
+
+			pEnc->bframenum_dx50bvop = -1;
+		}
 
-		pFrame->intra = 1;
 		pEnc->flush_bframes = 1;
 
+		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
@@ -749,25 +984,32 @@
 		 * This will be coded as a Predicted Frame
 		 */
 
-		/* ToDo : Remove dprintf calls */
-		/*
-		   dprintf("--- PFRAME ---");
-		 */
+		DPRINTF(DPRINTF_DEBUG,"*** 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;
+
+		if ((pEnc->global & XVID_GLOBAL_PACKED)) {
+			BitstreamPad(&bs);
+			input_valid = 0;
+			goto ipvop_loop;
+		}
+
 	} else {
 		/*
 		 * This will be coded as a Bidirectional Frame
 		 */
 
-		/* ToDo : Remove dprintf calls */
-		/*
-		   dprintf("--- BFRAME (store) ---  head=%i tail=%i",
-		   pEnc->bframenum_head,
-		   pEnc->bframenum_tail);
-		 */
+		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 =
@@ -776,6 +1018,18 @@
 		} else {
 			pEnc->current->quant = pFrame->bquant;
 		}
+                if (pEnc->current->quant < 1)
+                        pEnc->current->quant = 1;
+
+                if (pEnc->current->quant > 31)
+                        pEnc->current->quant = 31;
+ 
+
+			DPRINTF(DPRINTF_DEBUG,"*** BFRAME (store) bf: head=%i tail=%i   queue: head=%i tail=%i size=%i  quant=%i\n",
+                                pEnc->bframenum_head, pEnc->bframenum_tail,
+                                pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size,pEnc->current->quant);
+
+
 
 		/* store frame into bframe buffer & swap ref back to current */
 		SWAP(pEnc->current, pEnc->bframes[pEnc->bframenum_tail]);
@@ -785,15 +1039,9 @@
 
 		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);
@@ -809,7 +1057,7 @@
 
 	emms();
 
-#ifdef _DEBUG
+#ifdef _DEBUG_PSNR
 	psnr =
 		image_psnr(&pEnc->sOriginal, &pEnc->current->image,
 				   pEnc->mbParam.edged_width, pEnc->mbParam.width,
@@ -824,23 +1072,26 @@
 						  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
+
+#endif
+
+
+
 /*****************************************************************************
- * Frame encoder entry point for IP capable encoder
+ * "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,
@@ -851,7 +1102,7 @@
 	uint32_t bits;
 	uint16_t write_vol_header = 0;
 
-#ifdef _DEBUG
+#ifdef _DEBUG_PSNR
 	float psnr;
 	uint8_t temp[128];
 #endif
@@ -867,6 +1118,10 @@
 
 	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();
@@ -876,7 +1131,7 @@
 		return XVID_ERR_FORMAT;
 	stop_conv_timer();
 
-#ifdef _DEBUG
+#ifdef _DEBUG_PSNR
 	image_copy(&pEnc->sOriginal, &pEnc->current->image,
 			   pEnc->mbParam.edged_width, pEnc->mbParam.height);
 #endif
@@ -986,7 +1241,7 @@
 		RateControlUpdate(&pEnc->rate_control, pEnc->current->quant,
 						  pFrame->length, pFrame->intra);
 	}
-#ifdef _DEBUG
+#ifdef _DEBUG_PSNR
 	psnr =
 		image_psnr(&pEnc->sOriginal, &pEnc->current->image,
 				   pEnc->mbParam.edged_width, pEnc->mbParam.width,
@@ -996,14 +1251,18 @@
 	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
@@ -1073,9 +1332,8 @@
 				&pEnc->current->mbs[x + y * pEnc->mbParam.mb_width];
 			MVBLOCKHINT *bhint =
 				&hint->mvhint.block[x + y * pEnc->mbParam.mb_width];
-			VECTOR pred[4];
+			VECTOR pred;
 			VECTOR tmp;
-			int32_t dummy[4];
 			int vec;
 
 			pMB->mode =
@@ -1095,14 +1353,13 @@
 				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);
+				pred = get_pmv2(pEnc->current->mbs,pEnc->mbParam.mb_width,0,x,y,0);
 
 				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;
+					pMB->pmvs[vec].x = pMB->mvs[0].x - pred.x;
+					pMB->pmvs[vec].y = pMB->mvs[0].y - pred.y;
 				}
 			} else if (pMB->mode == MODE_INTER4V) {
 				for (vec = 0; vec < 4; ++vec) {
@@ -1115,13 +1372,12 @@
 					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);
+					pred = get_pmv2(pEnc->current->mbs,pEnc->mbParam.mb_width,0,x,y,vec);
 
 					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;
+					pMB->pmvs[vec].x = pMB->mvs[vec].x - pred.x;
+					pMB->pmvs[vec].y = pMB->mvs[vec].y - pred.y;
 				}
 			} else				// intra / stuffing / not_coded
 			{
@@ -1251,7 +1507,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);
 
@@ -1295,6 +1557,7 @@
 
 
 #define INTRA_THRESHOLD 0.5
+#define BFRAME_SKIP_THRESHHOLD 16
 
 static int
 FrameCodeP(Encoder * pEnc,
@@ -1309,10 +1572,11 @@
 	DECLARE_ALIGNED_MATRIX(qcoeff, 6, 64, int16_t, CACHE_LINE);
 
 	int iLimit;
-	uint32_t x, y;
+	int k;
+	int x, y;
 	int iSearchRange;
 	int bIntra;
-
+	
 	/* IMAGE *pCurrent = &pEnc->current->image; */
 	IMAGE *pRef = &pEnc->reference->image;
 
@@ -1346,10 +1610,20 @@
 	if (pEnc->current->global_flags & XVID_HINTEDME_SET) {
 		HintedMESet(pEnc, &bIntra);
 	} else {
+
+#ifdef _SMP
+	if (pEnc->mbParam.num_threads > 1)
+		bIntra =
+			SMP_MotionEstimation(&pEnc->mbParam, pEnc->current, pEnc->reference,
+						 &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV,
+						 iLimit);
+	else
+#endif
 		bIntra =
 			MotionEstimation(&pEnc->mbParam, pEnc->current, pEnc->reference,
-							 &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV,
-							 iLimit);
+                         &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV,
+                         iLimit);
+			
 	}
 	stop_motion_timer();
 
@@ -1362,7 +1636,7 @@
 	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);
 
@@ -1422,12 +1696,51 @@
 					   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++;
-			}
+			} 
 
 			start_timer();
-			MBCoding(pEnc->current, pMB, qcoeff, bs, &pEnc->sStat);
+
+			/* Finished processing the MB, now check if to CODE or SKIP */
+
+			if (pMB->cbp == 0 && pMB->mode == MODE_INTER && pMB->mvs[0].x == 0 &&
+				pMB->mvs[0].y == 0) {
+
+/* This is a candidate for SKIPping, but check intermediate B-frames first */
+
+#ifdef BFRAMES
+				int iSAD=BFRAME_SKIP_THRESHHOLD;
+				int bSkip=1;
+				
+				for (k=pEnc->bframenum_head; k< pEnc->bframenum_tail; k++)
+				{		
+					iSAD = sad16(pEnc->reference->image.y + 16*y*pEnc->mbParam.edged_width + 16*x,
+								pEnc->bframes[k]->image.y + 16*y*pEnc->mbParam.edged_width + 16*x,
+								pEnc->mbParam.edged_width,BFRAME_SKIP_THRESHHOLD);
+					if (iSAD >= BFRAME_SKIP_THRESHHOLD)
+					{	bSkip = 0; 
+						break;
+					}
+				}
+				if (!bSkip) 
+				{	
+					MBCoding(pEnc->current, pMB, qcoeff, bs, &pEnc->sStat);
+					pMB->cbp = 0x80;		/* trick! so cbp!=0, but still nothing is written to bs */
+				}
+				else 
+					MBSkip(bs);
+				
+
+#else
+					MBSkip(bs);	/* without B-frames, no precautions are needed */
+
+#endif			
+
+			} else {
+				MBCoding(pEnc->current, pMB, qcoeff, bs, &pEnc->sStat);
+			}
+
 			stop_coding_timer();
 		}
 	}
@@ -1461,8 +1774,38 @@
 
 	pEnc->sStat.fMvPrevSigma = fSigma;
 
+#ifdef BFRAMES
+	/* frame drop code */
+	// DPRINTF(DPRINTF_DEBUG, "kmu %i %i %i", pEnc->sStat.kblks, pEnc->sStat.mblks, pEnc->sStat.ublks);
+	if (pEnc->sStat.kblks + pEnc->sStat.mblks <=
+		(pEnc->frame_drop_ratio * pEnc->mbParam.mb_width * pEnc->mbParam.mb_height) / 100)
+	{
+		pEnc->sStat.kblks = pEnc->sStat.mblks = 0;
+		pEnc->sStat.ublks = pEnc->mbParam.mb_width * pEnc->mbParam.mb_height;
+
+		BitstreamReset(bs);
+		BitstreamWriteVopHeader(bs, &pEnc->mbParam, pEnc->current, 0);
+
+		// copy reference frame details into the current frame
+		pEnc->current->quant = pEnc->reference->quant;
+		pEnc->current->motion_flags = pEnc->reference->motion_flags;
+		pEnc->current->rounding_type = pEnc->reference->rounding_type;
+		pEnc->current->fcode = pEnc->reference->fcode;
+		pEnc->current->bcode = pEnc->reference->bcode;
+		image_copy(&pEnc->current->image, &pEnc->reference->image, pEnc->mbParam.edged_width, pEnc->mbParam.height);
+		memcpy(pEnc->current->mbs, pEnc->reference->mbs, sizeof(MACROBLOCK) * pEnc->mbParam.mb_width * pEnc->mbParam.mb_height);
+
+	}
+#endif
+
 	*pBits = BitstreamPos(bs) - *pBits;
 
+#ifdef BFRAMES
+	pEnc->time_pp = ((int32_t)pEnc->mbParam.fbase - (int32_t)pEnc->last_pframe + (int32_t)pEnc->current->ticks) %
+			(int32_t)pEnc->mbParam.fbase;
+	pEnc->last_pframe = pEnc->current->ticks;
+#endif
+
 	return 0;					// inter
 }
 
@@ -1483,6 +1826,18 @@
 	IMAGE *f_ref = &pEnc->reference->image;
 	IMAGE *b_ref = &pEnc->current->image;
 
+#ifdef BFRAMES_DEC_DEBUG
+	FILE *fp;
+	static char first=0;
+#define BFRAME_DEBUG  	if (!first && fp){ \
+		fprintf(fp,"Y=%3d   X=%3d   MB=%2d   CBP=%02X\n",y,x,mb->mode,mb->cbp); \
+	}
+
+	if (!first){
+		fp=fopen("C:\\XVIDDBGE.TXT","w");
+	}
+#endif
+
 	// forward 
 	image_setedges(f_ref, pEnc->mbParam.edged_width,
 				   pEnc->mbParam.edged_height, pEnc->mbParam.width,
@@ -1506,7 +1861,10 @@
 	stop_inter_timer();
 
 	start_timer();
-	MotionEstimationBVOP(&pEnc->mbParam, frame, pEnc->reference->mbs, f_ref,
+	MotionEstimationBVOP(&pEnc->mbParam, frame, 
+		((int32_t)pEnc->mbParam.fbase + pEnc->last_pframe - frame->ticks) % pEnc->mbParam.fbase,
+						pEnc->time_pp, 
+						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);
@@ -1520,7 +1878,7 @@
 	   } */
 
 	frame->coding_type = B_VOP;
-	BitstreamWriteVopHeader(bs, &pEnc->mbParam, frame);
+	BitstreamWriteVopHeader(bs, &pEnc->mbParam, frame, 1);
 
 	*pBits = BitstreamPos(bs);
 
@@ -1549,6 +1907,11 @@
 			if (mb->mode == MODE_NOT_CODED) {
 				mb->mvs[0].x = 0;
 				mb->mvs[0].y = 0;
+
+				mb->cbp = 0;
+#ifdef BFRAMES_DEC_DEBUG
+	BFRAME_DEBUG
+#endif
 				continue;
 			}
 
@@ -1564,12 +1927,12 @@
 								  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_DIRECT) && (mb->cbp == 0)
+				&& (mb->deltamv.x == 0) && (mb->deltamv.y == 0) ) {
+				mb->mode = MODE_DIRECT_NONE_MV;	// skipped
 			}
 
+/* update predictors for forward and backward vectors */
 			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;
@@ -1583,8 +1946,12 @@
 				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);
+			
+//			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);
 
+#ifdef BFRAMES_DEC_DEBUG
+	BFRAME_DEBUG
+#endif
 			start_timer();
 			MBCodingBVOP(mb, qcoeff, frame->fcode, frame->bcode, bs,
 						 &pEnc->sStat);
@@ -1597,5 +1964,28 @@
 	// TODO: dynamic fcode/bcode ???
 
 	*pBits = BitstreamPos(bs) - *pBits;
+
+#ifdef BFRAMES_DEC_DEBUG
+	if (!first){
+		first=1;
+		if (fp)
+			fclose(fp);
+	}
+#endif
 }
 #endif
+
+
+/*	in case internal output is needed somewhere... */
+/*	{
+        FILE *filehandle;
+        filehandle=fopen("last-b.pgm","wb");
+        if (filehandle)
+        {
+                fprintf(filehandle,"P5\n\n");           //
+                fprintf(filehandle,"%d %d 255\n",pEnc->mbParam.edged_width,pEnc->mbParam.edged_height);
+                fwrite(frame->image.y,pEnc->mbParam.edged_width,pEnc->mbParam.edged_height,filehandle);
+                fclose(filehandle);
+		}
+	}
+*/