--- encoder.c	2003/02/19 21:30:52	1.95
+++ encoder.c	2003/03/15 17:03:17	1.95.2.7
@@ -26,7 +26,7 @@
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  *
- *  $Id: encoder.c,v 1.95 2003/02/19 21:30:52 edgomez Exp $
+ *  $Id: encoder.c,v 1.95.2.7 2003/03/15 17:03:17 suxen_drol Exp $
  *
  ****************************************************************************/
 
@@ -47,7 +47,6 @@
 #include "utils/mbfunctions.h"
 #include "bitstream/bitstream.h"
 #include "bitstream/mbcoding.h"
-#include "utils/ratecontrol.h"
 #include "utils/emms.h"
 #include "bitstream/mbcoding.h"
 #include "quant/adapt_quant.h"
@@ -58,7 +57,6 @@
  * Local macros
  ****************************************************************************/
 
-#define ENC_CHECK(X) if(!(X)) return XVID_ERR_FORMAT
 #define SWAP(_T_,A,B)    { _T_ tmp = A; A = B; B = tmp; }
 
 /*****************************************************************************
@@ -66,19 +64,16 @@
  ****************************************************************************/
 
 static int FrameCodeI(Encoder * pEnc,
-					  Bitstream * bs,
-					  uint32_t * pBits);
+					  Bitstream * bs);
 
 static int FrameCodeP(Encoder * pEnc,
 					  Bitstream * bs,
-					  uint32_t * pBits,
 					  bool force_inter,
 					  bool vol_header);
 
 static void FrameCodeB(Encoder * pEnc,
 					   FRAMEINFO * frame,
-					   Bitstream * bs,
-					   uint32_t * pBits);
+					   Bitstream * bs);
 
 /*****************************************************************************
  * Local data
@@ -104,122 +99,141 @@
  * and cleaning code.
  *
  * Returned values :
- *    - XVID_ERR_OK     - no errors
+ *    - 0                - 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)
+/*
+ * Simplify the "fincr/fbase" fraction
+*/
+static void
+simplify_time(int *inc, int *base)
 {
-	Encoder *pEnc;
-	int i;
-
-	pParam->handle = NULL;
-
-	ENC_CHECK(pParam);
-
-	ENC_CHECK(pParam->width > 0 && pParam->width <= 1920);
-	ENC_CHECK(pParam->height > 0 && pParam->height <= 1280);
-	ENC_CHECK(!(pParam->width % 2));
-	ENC_CHECK(!(pParam->height % 2));
-
-	/* Fps */
-
-	if (pParam->fincr <= 0 || pParam->fbase <= 0) {
-		pParam->fincr = 1;
-		pParam->fbase = 25;
-	}
-
-	/*
-	 * Simplify the "fincr/fbase" fraction
-	 * (neccessary, since windows supplies us with huge numbers)
-	 */
-
-	i = pParam->fincr;
+	/* common factor */
+	int i = *inc;
 	while (i > 1) {
-		if (pParam->fincr % i == 0 && pParam->fbase % i == 0) {
-			pParam->fincr /= i;
-			pParam->fbase /= i;
-			i = pParam->fincr;
+		if (*inc % i == 0 && *base % i == 0) {
+			*inc /= i;
+			*base /= i;
+			i = *inc;
 			continue;
 		}
 		i--;
 	}
 
-	if (pParam->fbase > 65535) {
-		float div = (float) pParam->fbase / 65535;
-
-		pParam->fbase = (int) (pParam->fbase / div);
-		pParam->fincr = (int) (pParam->fincr / div);
+	/* if neccessary, round to 65535 accuracy */
+	if (*base > 65535) {
+		float div = (float) *base / 65535;
+		*base = (int) (*base / div);
+		*inc = (int) (*inc / div);
 	}
+}
 
-	/* Bitrate allocator defaults */
-
-	if (pParam->rc_bitrate <= 0)
-		pParam->rc_bitrate = 900000;
-
-	if (pParam->rc_reaction_delay_factor <= 0)
-		pParam->rc_reaction_delay_factor = 16;
-
-	if (pParam->rc_averaging_period <= 0)
-		pParam->rc_averaging_period = 100;
-
-	if (pParam->rc_buffer <= 0)
-		pParam->rc_buffer = 100;
-
-	/* Max and min quantizers */
-
-	if ((pParam->min_quantizer <= 0) || (pParam->min_quantizer > 31))
-		pParam->min_quantizer = 1;
 
-	if ((pParam->max_quantizer <= 0) || (pParam->max_quantizer > 31))
-		pParam->max_quantizer = 31;
+int
+enc_create(xvid_enc_create_t * create, xvid_enc_rc_t * rc)
+{
+	Encoder *pEnc;
+    int n;
 
-	if (pParam->max_quantizer < pParam->min_quantizer)
-		pParam->max_quantizer = pParam->min_quantizer;
+	if (XVID_MAJOR(create->version) != 1 || (rc && XVID_MAJOR(rc->version) != 1))	/* v1.x.x */
+		return XVID_ERR_VERSION;
 
-	/* 1 keyframe each 10 seconds */
+	if (create->width%2 || create->height%2)
+		return XVID_ERR_FAIL;
 
-	if (pParam->max_key_interval <= 0)
-		pParam->max_key_interval = 10 * pParam->fincr / pParam->fbase;
+	/* allocate encoder struct */
 
 	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;
-	pEnc->mbParam.height = pParam->height;
+	/* global flags */
+    pEnc->mbParam.global_flags = create->global;
 
+    /* width, height */	
+	pEnc->mbParam.width = create->width;
+	pEnc->mbParam.height = create->height;
 	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.fbase = pParam->fbase;
-	pEnc->mbParam.fincr = pParam->fincr;
+    /* framerate */
+    pEnc->mbParam.fincr = MAX(create->fincr, 0);
+	pEnc->mbParam.fbase = create->fincr <= 0 ? 25 : create->fbase;
+    if (pEnc->mbParam.fincr>0)
+	    simplify_time(&pEnc->mbParam.fincr, &pEnc->mbParam.fbase);
+
+    /* plugin */
+    pEnc->num_plugins = create->num_plugins;
+    pEnc->plugins = xvid_malloc(sizeof(xvid_enc_plugin_t) * pEnc->num_plugins, CACHE_LINE);
+    if (pEnc->plugins == NULL)
+        goto xvid_err_memory0;
+
+    for (n=0; n<pEnc->num_plugins;n++) {
+        xvid_plg_create_t pcreate;
+        xvid_plg_info_t pinfo;
+
+        memset(&pinfo, 0, sizeof(xvid_plg_info_t));
+        pinfo.version = XVID_VERSION;
+        if (create->plugins[n].func(0, XVID_PLG_INFO, &pinfo, 0) >= 0) {
+            pEnc->mbParam.plugin_flags |= pinfo.flags;
+        }
+
+        memset(&pcreate, 0, sizeof(xvid_plg_create_t));
+        pcreate.version = XVID_VERSION;
+        pcreate.width = pEnc->mbParam.width;
+        pcreate.height = pEnc->mbParam.height;
+        pcreate.fincr = pEnc->mbParam.fincr;
+        pcreate.fbase = pEnc->mbParam.fbase;
+        pcreate.param = create->plugins[n].param;
+        
+        pEnc->plugins[n].func = NULL;   /* disable plugins that fail */
+        if (create->plugins[n].func(0, XVID_PLG_CREATE, &pcreate, &pEnc->plugins[n].param) >= 0) {
+            pEnc->plugins[n].func = create->plugins[n].func;
+        }
+    }
+
+    if ((pEnc->mbParam.global_flags & XVID_EXTRASTATS_ENABLE) || 
+        (pEnc->mbParam.plugin_flags & XVID_REQPSNR)) {
+        pEnc->mbParam.plugin_flags |= XVID_REQORIGINAL; /* psnr calculation requires the original */
+    }
+
+    /* temp dquants */
+	pEnc->temp_dquants = (int *) xvid_malloc(pEnc->mbParam.mb_width *
+					pEnc->mbParam.mb_height * sizeof(int), CACHE_LINE);
+    /* XXX: error checking */
+
+	/* bframes */
+	pEnc->mbParam.max_bframes = MAX(create->max_bframes, 0);
+	pEnc->mbParam.bquant_ratio = MAX(create->bquant_ratio, 0);
+	pEnc->mbParam.bquant_offset = create->bquant_offset;
+	
+	/* frame drop ratio */
+	pEnc->mbParam.frame_drop_ratio = MAX(create->frame_drop_ratio, 0);
 
-	pEnc->mbParam.m_quant_type = H263_QUANT;
+    /* max keyframe interval */
+    pEnc->mbParam.iMaxKeyInterval = create->max_key_interval <=0 ? 250 : create->max_key_interval;
+    /*XXX: replace 250 hard code with "10seconds * framerate" */
 
-	pEnc->fMvPrevSigma = -1;
+	/* Bitrate allocator defaults 
 
-	/* Fill rate control parameters */
+	if ((create->min_quantizer <= 0) || (create->min_quantizer > 31))
+		create->min_quantizer = 1;
 
-	pEnc->bitrate = pParam->rc_bitrate;
+	if ((create->max_quantizer <= 0) || (create->max_quantizer > 31))
+		create->max_quantizer = 31;
 
-	pEnc->iFrameNum = -1;
-	pEnc->mbParam.iMaxKeyInterval = pParam->max_key_interval;
+	if (create->max_quantizer < create->min_quantizer)
+		create->max_quantizer = create->min_quantizer; */
+	
 
-	/* try to allocate frame memory */
+    /* allocate working frame-image memory */
 
 	pEnc->current = xvid_malloc(sizeof(FRAMEINFO), CACHE_LINE);
 	pEnc->reference = xvid_malloc(sizeof(FRAMEINFO), CACHE_LINE);
@@ -227,7 +241,7 @@
 	if (pEnc->current == NULL || pEnc->reference == NULL)
 		goto xvid_err_memory1;
 
-	/* try to allocate mb memory */
+	/* allocate macroblock memory */
 
 	pEnc->current->mbs =
 		xvid_malloc(sizeof(MACROBLOCK) * pEnc->mbParam.mb_width *
@@ -239,10 +253,12 @@
 	if (pEnc->current->mbs == NULL || pEnc->reference->mbs == NULL)
 		goto xvid_err_memory2;
 
-	/* try to allocate image memory */
+	/* allocate interpolation image memory */
 
-	if (pParam->global & XVID_GLOBAL_EXTRASTATS)
-		image_null(&pEnc->sOriginal);
+    if ((pEnc->mbParam.plugin_flags & XVID_REQORIGINAL)) {
+        image_null(&pEnc->sOriginal);
+        image_null(&pEnc->sOriginal2);
+    }
 
 	image_null(&pEnc->f_refh);
 	image_null(&pEnc->f_refv);
@@ -256,11 +272,16 @@
 	image_null(&pEnc->vInterHV);
 	image_null(&pEnc->vInterHVf);
 
-	if (pParam->global & XVID_GLOBAL_EXTRASTATS)
-	{	if (image_create
+	if ((pEnc->mbParam.plugin_flags & XVID_REQORIGINAL)) {	
+        if (image_create
 			(&pEnc->sOriginal, pEnc->mbParam.edged_width,
 			 pEnc->mbParam.edged_height) < 0)
 			goto xvid_err_memory3;
+
+        if (image_create
+			(&pEnc->sOriginal2, pEnc->mbParam.edged_width,
+			 pEnc->mbParam.edged_height) < 0)
+			goto xvid_err_memory3;
 	}
 
 	if (image_create
@@ -311,19 +332,17 @@
 		 pEnc->mbParam.edged_height) < 0)
 		goto xvid_err_memory3;
 
+	/* init bframe image buffers */
 
-
-	pEnc->mbParam.global = pParam->global;
+	pEnc->bframenum_head = 0;
+	pEnc->bframenum_tail = 0;
+	pEnc->flush_bframes = 0;
+	pEnc->closed_bframenum = -1;
 
 	/* B Frames specific init */
-	pEnc->mbParam.max_bframes = pParam->max_bframes;
-	pEnc->mbParam.bquant_ratio = pParam->bquant_ratio;
-	pEnc->mbParam.bquant_offset = pParam->bquant_offset;
-	pEnc->mbParam.frame_drop_ratio = pParam->frame_drop_ratio;
 	pEnc->bframes = NULL;
 
 	if (pEnc->mbParam.max_bframes > 0) {
-		int n;
 
 		pEnc->bframes =
 			xvid_malloc(pEnc->mbParam.max_bframes * sizeof(FRAMEINFO *),
@@ -359,59 +378,49 @@
 		}
 	}
 
-	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;
+    /* init incoming frame queue */
+	pEnc->queue_head = 0;
+	pEnc->queue_tail = 0;
+	pEnc->queue_size = 0;
 
-		pEnc->queue =
-			xvid_malloc(pEnc->mbParam.max_bframes * sizeof(IMAGE),
-						CACHE_LINE);
+	pEnc->queue =
+		xvid_malloc((pEnc->mbParam.max_bframes+1) * sizeof(QUEUEINFO),
+					CACHE_LINE);
 
-		if (pEnc->queue == NULL)
-			goto xvid_err_memory4;
+	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+1; n++)
+		image_null(&pEnc->queue[n].image);
 
-		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;
+		
+	for (n = 0; n < pEnc->mbParam.max_bframes+1; n++)
+	{
+		if (image_create
+			(&pEnc->queue[n].image, 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_stamp = 0;
+	/* timestamp stuff */
 
+	pEnc->mbParam.m_stamp = 0;
 	pEnc->m_framenum = 0;
 	pEnc->current->stamp = 0;
 	pEnc->reference->stamp = 0;
 
-	pParam->handle = (void *) pEnc;
+	/* other stuff */
 
-	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);
-	}
+	pEnc->iFrameNum = 0;
+	pEnc->fMvPrevSigma = -1;
+
+    create->handle = (void *) pEnc;
 
 	init_timer();
 
-	return XVID_ERR_OK;
+    return 0;   /* ok */
 
 	/*
 	 * We handle all XVID_ERR_MEMORY here, this makes the code lighter
@@ -419,11 +428,11 @@
 
   xvid_err_memory5:
 
-
 	if (pEnc->mbParam.max_bframes > 0) {
+        int i;
 
-		for (i = 0; i < pEnc->mbParam.max_bframes; i++) {
-			image_destroy(&pEnc->queue[i], pEnc->mbParam.edged_width,
+		for (i = 0; i < pEnc->mbParam.max_bframes+1; i++) {
+			image_destroy(&pEnc->queue[i].image, pEnc->mbParam.edged_width,
 						  pEnc->mbParam.edged_height);
 		}
 		xvid_free(pEnc->queue);
@@ -432,6 +441,7 @@
   xvid_err_memory4:
 
 	if (pEnc->mbParam.max_bframes > 0) {
+        int i;
 
 		for (i = 0; i < pEnc->mbParam.max_bframes; i++) {
 
@@ -452,8 +462,10 @@
 
   xvid_err_memory3:
 
-	if (pEnc->mbParam.global & XVID_GLOBAL_EXTRASTATS)
-	{	image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width,
+	if ((pEnc->mbParam.plugin_flags & XVID_REQORIGINAL)) {	
+		image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width,
+					  pEnc->mbParam.edged_height);
+		image_destroy(&pEnc->sOriginal2, pEnc->mbParam.edged_width,
 					  pEnc->mbParam.edged_height);
 	}
 
@@ -491,9 +503,20 @@
   xvid_err_memory1:
 	xvid_free(pEnc->current);
 	xvid_free(pEnc->reference);
+
+	xvid_free(pEnc->temp_dquants);
+
+  xvid_err_memory0:
+    for (n=0; n<pEnc->num_plugins;n++) {
+        if (pEnc->plugins[n].func) {
+            pEnc->plugins[n].func(pEnc->plugins[n].param, XVID_PLG_DESTROY, 0, 0);
+        }
+    }
+    xvid_free(pEnc->plugins);
+
 	xvid_free(pEnc);
 
-	pParam->handle = NULL;
+	create->handle = NULL;
 
 	return XVID_ERR_MEMORY;
 }
@@ -502,26 +525,24 @@
  * Encoder destruction
  *
  * This function destroy the entire encoder structure created by a previous
- * successful encoder_create call.
+ * successful enc_create call.
  *
  * Returned values (for now only one returned value) :
- *    - XVID_ERR_OK     - no errors
+ *    - 0     - no errors
  *
  ****************************************************************************/
 
 int
-encoder_destroy(Encoder * pEnc)
+enc_destroy(Encoder * pEnc)
 {
 	int i;
 	
-	ENC_CHECK(pEnc);
-
 	/* B Frames specific */
 	if (pEnc->mbParam.max_bframes > 0) {
 
-		for (i = 0; i < pEnc->mbParam.max_bframes; i++) {
+		for (i = 0; i < pEnc->mbParam.max_bframes+1; i++) {
 		
-			image_destroy(&pEnc->queue[i], pEnc->mbParam.edged_width,
+			image_destroy(&pEnc->queue[i].image, pEnc->mbParam.edged_width,
 					  pEnc->mbParam.edged_height);
 		}
 		xvid_free(pEnc->queue);
@@ -571,8 +592,10 @@
 	image_destroy(&pEnc->f_refhv, pEnc->mbParam.edged_width,
 				  pEnc->mbParam.edged_height);
 
-	if (pEnc->mbParam.global & XVID_GLOBAL_EXTRASTATS)
-	{	image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width,
+	if ((pEnc->mbParam.plugin_flags & XVID_REQORIGINAL)) {	
+		image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width,
+					  pEnc->mbParam.edged_height);
+		image_destroy(&pEnc->sOriginal2, pEnc->mbParam.edged_width,
 					  pEnc->mbParam.edged_height);
 	}
 
@@ -583,50 +606,163 @@
 
 	xvid_free(pEnc->reference->mbs);
 	xvid_free(pEnc->reference);
+	
+    xvid_free(pEnc->temp_dquants);
+
+    for (i=0; i<pEnc->num_plugins;i++) {
+        if (pEnc->plugins[i].func) {
+            pEnc->plugins[i].func(pEnc->plugins[i].param, XVID_PLG_DESTROY, 0, 0);
+        }
+    }
+    xvid_free(pEnc->plugins);
 
 	xvid_free(pEnc);
 
-	return XVID_ERR_OK;
+	return 0;  /* ok */
 }
 
 
-static __inline void inc_frame_num(Encoder * pEnc)
+/*
+  call the plugins
+  */
+
+static void call_plugins(Encoder * pEnc, FRAMEINFO * frame, IMAGE * original, 
+                         int opt, int * type, int * quant, xvid_enc_stats_t * stats)
 {
-	pEnc->current->stamp = pEnc->mbParam.m_stamp;	/* first frame is zero */
-	pEnc->mbParam.m_stamp += pEnc->mbParam.fincr;
-}
+    int i;
+    xvid_plg_data_t data;
 
+    memset(&data, 0, sizeof(xvid_plg_data_t));
+    data.version = XVID_VERSION;
 
-static __inline void
-queue_image(Encoder * pEnc, XVID_ENC_FRAME * pFrame)
-{
-	if (pEnc->queue_size >= pEnc->mbParam.max_bframes)
-	{
-		DPRINTF(DPRINTF_DEBUG,"FATAL: QUEUE FULL");
-		return;
-	}
+    data.width = pEnc->mbParam.width;
+    data.height = pEnc->mbParam.height;
+    data.fincr = frame->fincr;
+    data.fbase = pEnc->mbParam.fbase;
+
+    data.reference.csp = XVID_CSP_USER;
+    data.reference.plane[0] = pEnc->reference->image.y;
+    data.reference.plane[1] = pEnc->reference->image.u;
+    data.reference.plane[2] = pEnc->reference->image.v;
+    data.reference.stride[0] = pEnc->mbParam.edged_width;
+    data.reference.stride[1] = pEnc->mbParam.edged_width/2;
+    data.reference.stride[2] = pEnc->mbParam.edged_width/2;
+
+    data.current.csp = XVID_CSP_USER;
+    data.current.plane[0] = frame->image.y;
+    data.current.plane[1] = frame->image.u;
+    data.current.plane[2] = frame->image.v;
+    data.current.stride[0] = pEnc->mbParam.edged_width;
+    data.current.stride[1] = pEnc->mbParam.edged_width/2;
+    data.current.stride[2] = pEnc->mbParam.edged_width/2;
+
+    data.frame_num = frame->frame_num;
+
+    if (opt == XVID_PLG_BEFORE) {
+        data.type = XVID_TYPE_AUTO;
+        data.quant = 2;
+        //memset(pEnc->temp_dquants, NO_CHANGE, pEnc->mbParam.width * pEnc->mbParam.height);
+        //data.qscale_stride = pEnc->mbParam.width;
+        //data.qscale_table = pEnc->temp_dquants;
+        /* todo: vol,vop,motion flags */
+    
+    } else { // XVID_PLG_AFTER
+        if ((pEnc->mbParam.plugin_flags & XVID_REQORIGINAL)) {
+            data.original.csp = XVID_CSP_USER;
+            data.original.plane[0] = original->y;
+            data.original.plane[1] = original->u;
+            data.original.plane[2] = original->v;
+            data.original.stride[0] = pEnc->mbParam.edged_width;
+            data.original.stride[1] = pEnc->mbParam.edged_width/2;
+            data.original.stride[2] = pEnc->mbParam.edged_width/2;
+        }
+
+        if ((frame->vol_flags & XVID_EXTRASTATS) || 
+            (pEnc->mbParam.plugin_flags & XVID_REQPSNR)) {
+
+ 			data.sse_y =
+			    plane_sse( original->y, frame->image.y,
+					       pEnc->mbParam.edged_width, pEnc->mbParam.width,
+					       pEnc->mbParam.height);
+
+            data.sse_u =
+                plane_sse( original->u, frame->image.u,
+				    	   pEnc->mbParam.edged_width/2, pEnc->mbParam.width/2,
+					       pEnc->mbParam.height/2);
+
+ 			data.sse_v =
+                plane_sse( original->v, frame->image.v,
+				    	   pEnc->mbParam.edged_width/2, pEnc->mbParam.width/2,
+					       pEnc->mbParam.height/2);
+        }
+
+        data.type = coding2type(frame->coding_type);
+        data.quant = frame->quant;
+        /* todo: data.qscale */
+        data.vol_flags = frame->vol_flags;
+        data.vop_flags = frame->vop_flags;
+        data.motion_flags = frame->motion_flags;
+
+        data.length = frame->length;
+        data.kblks = frame->sStat.kblks;
+        data.mblks = frame->sStat.mblks;
+        data.ublks = frame->sStat.ublks;
+
+        if (stats)
+        {
+	        stats->type = coding2type(frame->coding_type);
+	        stats->quant = frame->quant;
+	        stats->vol_flags = frame->vol_flags;
+	        stats->vop_flags = frame->vop_flags;
+	        stats->length = frame->length;
+	        stats->hlength = frame->length - (frame->sStat.iTextBits / 8);
+	        stats->kblks = frame->sStat.kblks;
+	        stats->mblks = frame->sStat.mblks;
+	        stats->ublks = frame->sStat.ublks;
+            stats->sse_y = data.sse_y;
+            stats->sse_u = data.sse_u;
+            stats->sse_v = data.sse_v;
+        }
+    }
+
+    emms();
+    for (i=0; i<pEnc->num_plugins;i++) {
+        if (pEnc->plugins[i].func) {
+            if (pEnc->plugins[i].func(pEnc->plugins[i].param, opt, &data, 0) < 0) {
+                continue;
+            }
+        }
+    }
+    emms();
+
+    if (opt == XVID_PLG_BEFORE) {
+        *type = data.type;
+        *quant = data.quant;
+        /* todo: copy modified qscale,vol,vop,motion flags into the frame*/
+    }
+
+}
 
-	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->stride, pFrame->colorspace, pFrame->general & XVID_INTERLACING))
-		return;
-	stop_conv_timer();
-
-	if ((pFrame->general & XVID_CHROMAOPT)) {
-		image_chroma_optimize(&pEnc->queue[pEnc->queue_tail], 
-			pEnc->mbParam.width, pEnc->mbParam.height, pEnc->mbParam.edged_width);
-	}
 
-	pEnc->queue_size++;
-	pEnc->queue_tail =  (pEnc->queue_tail + 1) % pEnc->mbParam.max_bframes;
+static __inline void inc_frame_num(Encoder * pEnc)
+{
+    pEnc->current->frame_num = pEnc->m_framenum;
+	pEnc->current->stamp = pEnc->mbParam.m_stamp;	/* first frame is zero */
+	
+    pEnc->mbParam.m_stamp += pEnc->current->fincr;
+    pEnc->m_framenum++;	/* debug ticker */
 }
 
+static __inline void dec_frame_num(Encoder * pEnc)
+{
+    pEnc->mbParam.m_stamp -= pEnc->mbParam.fincr;
+    pEnc->m_framenum--;	/* debug ticker */
+}
+
+
+
 static __inline void 
 set_timecodes(FRAMEINFO* pCur,FRAMEINFO *pRef, int32_t time_base)
 {
@@ -648,476 +784,302 @@
 
 
 
-/* convert pFrame->intra to coding_type */
-static int intra2coding_type(int intra)
-{
-	if (intra < 0)  return -1;
-	if (intra == 1) return I_VOP;
-	if (intra == 2) return B_VOP;
-
-	return P_VOP;
-}
-
-
-
 /*****************************************************************************
  * 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
+ *    - >0               - output bytes
+ *    - 0                - no output
+ *    - XVID_ERR_VERSION - wrong version passed to core
+ *    - XVID_ERR_END     - End of stream reached before end of coding
+ *    - 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)
+enc_encode(Encoder * pEnc,
+			   xvid_enc_frame_t * xFrame,
+			   xvid_enc_stats_t * stats)
 {
-	uint16_t x, y;
+	xvid_enc_frame_t * frame;
+	int type;
 	Bitstream bs;
-	uint32_t bits;
-	int mode = -1; /* Just to shut up compiler warning */
 
-	int input_valid = 1;
-	int bframes_count = 0;
+	if (XVID_MAJOR(xFrame->version) != 1 || (stats && XVID_MAJOR(stats->version) != 1))	/* v1.x.x */
+		return XVID_ERR_VERSION;
 
-	ENC_CHECK(pEnc);
-	ENC_CHECK(pFrame);
-	ENC_CHECK(pFrame->image);
+	xFrame->out_flags = 0;
 
 	start_global_timer();
+	BitstreamInit(&bs, xFrame->bitstream, 0);
 
-	BitstreamInit(&bs, pFrame->bitstream, 0);
-
-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
-			 */
+	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+	 * enqueue image to the encoding-queue
+	 * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
 
-			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);
+	if (xFrame->input.csp != XVID_CSP_NULL)
+	{
+		QUEUEINFO * q = &pEnc->queue[pEnc->queue_tail];
 
-			pEnc->bframenum_tail--;
-			SWAP(FRAMEINFO *, pEnc->current, pEnc->reference);
+		start_timer();
+		if (image_input
+			(&q->image, pEnc->mbParam.width, pEnc->mbParam.height,
+			pEnc->mbParam.edged_width, (uint8_t**)xFrame->input.plane, xFrame->input.stride, 
+			xFrame->input.csp, xFrame->vol_flags & XVID_INTERLACING))
+		{
+			emms();
+			return XVID_ERR_FORMAT;
+		}
+		stop_conv_timer();
 
-			SWAP(FRAMEINFO *, pEnc->current, pEnc->bframes[pEnc->bframenum_tail]);
+		if ((xFrame->vop_flags & XVID_CHROMAOPT)) {
+			image_chroma_optimize(&q->image, 
+				pEnc->mbParam.width, pEnc->mbParam.height, pEnc->mbParam.edged_width);
+		}
+		
+		q->frame = *xFrame;
 
-			FrameCodeP(pEnc, &bs, &bits, 1, 0);
-			bframes_count = 0;
+		if (xFrame->quant_intra_matrix)
+		{
+			memcpy(q->quant_intra_matrix, xFrame->quant_intra_matrix, sizeof(xFrame->quant_intra_matrix));
+			q->frame.quant_intra_matrix = q->quant_intra_matrix;
+		}
 
-			BitstreamPadAlways(&bs);
-			pFrame->length = BitstreamLength(&bs);
-			pFrame->intra = 0;
+		if (xFrame->quant_inter_matrix)
+		{
+			memcpy(q->quant_inter_matrix, xFrame->quant_inter_matrix, sizeof(xFrame->quant_inter_matrix));
+			q->frame.quant_inter_matrix = q->quant_inter_matrix;
+		}
 
+		pEnc->queue_tail = (pEnc->queue_tail + 1) % (pEnc->mbParam.max_bframes+1);
+		pEnc->queue_size++;
+	}
 
-			emms();
 
-			if (pResult) {
-				pResult->quant = pEnc->current->quant;
-				pResult->hlength = pFrame->length - (pEnc->current->sStat.iTextBits / 8);
-				pResult->kblks = pEnc->current->sStat.kblks;
-				pResult->mblks = pEnc->current->sStat.mblks;
-				pResult->ublks = pEnc->current->sStat.ublks;
-			}
+	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+	 * bframe flush code 
+	 * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
 
-			return XVID_ERR_OK;
-		}
+repeat:
 
+	if (pEnc->flush_bframes)
+	{
+		if (pEnc->bframenum_head < pEnc->bframenum_tail) {
 		
-		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);
+			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++;
+            if ((pEnc->mbParam.plugin_flags & XVID_REQORIGINAL)) {
+				image_copy(&pEnc->sOriginal2, &pEnc->bframes[pEnc->bframenum_head]->image,
+						   pEnc->mbParam.edged_width, pEnc->mbParam.height);
+			}
 
-		BitstreamPadAlways(&bs);
-		pFrame->length = BitstreamLength(&bs);
-		pFrame->intra = 2;
+			FrameCodeB(pEnc, pEnc->bframes[pEnc->bframenum_head], &bs);
+            call_plugins(pEnc, pEnc->bframes[pEnc->bframenum_head], &pEnc->sOriginal2, XVID_PLG_AFTER, 0, 0, stats);
+			pEnc->bframenum_head++;
 
-		if (pResult) {
-			pResult->quant = pEnc->current->quant;
-			pResult->hlength = pFrame->length - (pEnc->current->sStat.iTextBits / 8);
-			pResult->kblks = pEnc->current->sStat.kblks;
-			pResult->mblks = pEnc->current->sStat.mblks;
-			pResult->ublks = pEnc->current->sStat.ublks;
+			goto done;
 		}
 
-		if (input_valid)
-			queue_image(pEnc, pFrame);
-
-		emms();
-
-		return XVID_ERR_OK;
-	}
-
-	if (pEnc->bframenum_head > 0) {
-		pEnc->bframenum_head = pEnc->bframenum_tail = 0;
-
 		/* write an empty marker to the bitstream.
-		   
+	   
 		   for divx5 decoder compatibility, this marker must consist
 		   of a not-coded p-vop, with a time_base of zero, and time_increment 
 		   indentical to the future-referece frame.
 		*/
 
-		if ((pEnc->mbParam.global & XVID_GLOBAL_PACKED)) {
+		if ((pEnc->mbParam.global_flags & XVID_PACKED && pEnc->bframenum_tail > 0)) {
 			int tmp;
+			int bits;
 			
 			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);
 
-
+			bits = BitstreamPos(&bs);
+			
 			tmp = pEnc->current->seconds;
 			pEnc->current->seconds = 0; /* force time_base = 0 */
 
 			BitstreamWriteVopHeader(&bs, &pEnc->mbParam, pEnc->current, 0);
+			BitstreamPad(&bs);
 			pEnc->current->seconds = tmp;
 
-			BitstreamPadAlways(&bs);
-			pFrame->length = BitstreamLength(&bs);
-			pFrame->intra = 4;
-
-			if (pResult) {
-				pResult->quant = pEnc->current->quant;
-				pResult->hlength = pFrame->length - (pEnc->current->sStat.iTextBits / 8);
-				pResult->kblks = pEnc->current->sStat.kblks;
-				pResult->mblks = pEnc->current->sStat.mblks;
-				pResult->ublks = pEnc->current->sStat.ublks;
-			}
-
-			if (input_valid)
-				queue_image(pEnc, pFrame);
+			/* add the not-coded length to the reference frame size */
+			pEnc->current->length += (BitstreamPos(&bs) - bits) / 8;
+            call_plugins(pEnc, pEnc->current, &pEnc->sOriginal, XVID_PLG_AFTER, 0, 0, stats);
 
-			emms();
+            /* flush complete: reset counters */
+    		pEnc->flush_bframes = 0;
+		    pEnc->bframenum_head = pEnc->bframenum_tail = 0;
+			goto done;
 
-			return XVID_ERR_OK;
 		}
-	}
 
+        /* flush complete: reset counters */
+		pEnc->flush_bframes = 0;
+		pEnc->bframenum_head = pEnc->bframenum_tail = 0;
+	}
 
-bvop_loop:
+	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+	 * dequeue frame from the encoding queue
+	 * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
 
-	if (pEnc->bframenum_dx50bvop != -1)
+	if (pEnc->queue_size == 0)		/* empty */
 	{
-
-		SWAP(FRAMEINFO *, pEnc->current, pEnc->reference);
-		SWAP(FRAMEINFO *, pEnc->current, pEnc->bframes[pEnc->bframenum_dx50bvop]);		
-
-		if ((pEnc->mbParam.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(FRAMEINFO *, 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->stride, pFrame->colorspace, pFrame->general & XVID_INTERLACING))
+		if (xFrame->input.csp == XVID_CSP_NULL)	/* no futher input */
 		{
-			emms();
-			return XVID_ERR_FORMAT;
-		}
-		stop_conv_timer();
 
-		if ((pFrame->general & XVID_CHROMAOPT)) {
-			image_chroma_optimize(&pEnc->current->image, 
-				pEnc->mbParam.width, pEnc->mbParam.height, pEnc->mbParam.edged_width);
-		}
+            if (!(pEnc->mbParam.global_flags & XVID_PACKED) && pEnc->mbParam.max_bframes > 0) {
+                call_plugins(pEnc, pEnc->current, &pEnc->sOriginal, XVID_PLG_AFTER, 0, 0, stats);
+            }
 
-		/* 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)
+            /* if the very last frame is to be b-vop, we must change it to a p-vop */
+            if (pEnc->bframenum_tail > 0)
 			{
-				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(FRAMEINFO *, 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--;
+				SWAP(FRAMEINFO*, pEnc->current, pEnc->reference);
+				pEnc->bframenum_tail--;
+				SWAP(FRAMEINFO*, pEnc->current, pEnc->bframes[pEnc->bframenum_tail]);
 
-	} else {
+				/* convert B-VOP to P-VOP */
+                pEnc->current->quant = ((pEnc->current->quant*100) - pEnc->mbParam.bquant_offset) / pEnc->mbParam.bquant_ratio;
 
-		/* if nothing was encoded, write an 'ignore this frame' flag
-		   to the bitstream */
+                if ((pEnc->mbParam.plugin_flags & XVID_REQORIGINAL)) {
+		            image_copy(&pEnc->sOriginal, &pEnc->current->image,
+		                   pEnc->mbParam.edged_width, pEnc->mbParam.height);
+                }
 
-		if (BitstreamPos(&bs) == 0) {
+				FrameCodeP(pEnc, &bs, 1, 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);
-
-			/* That disabled line of code was supposed to inform VirtualDub
-			 * that the frame was a dummy delay frame - now disabled (thx god :-)
-			 */
-			/* BitstreamPutBits(&bs, 0x7f, 8); */
-			pFrame->intra = 5;
-
-			if (pResult) {
-				/*
-				 * We must decide what to put there because i know some apps
-				 * are storing statistics about quantizers and just do
-				 * stats[quant]++ or stats[quant-1]++
-				 * transcode is one of these app with its 2pass module
-				 */
-
-				/*
-				 * For now i prefer 31 than 0 that could lead to a segfault
-				 * in transcode
-				 */
-				pResult->quant = 31;
-
-				pResult->hlength = 0;
-				pResult->kblks = 0;
-				pResult->mblks = 0;
-				pResult->ublks = 0;
-			}
-
-		} else {
-
-			if (pResult) {
-				pResult->quant = pEnc->current->quant;
-				pResult->hlength = pFrame->length - (pEnc->current->sStat.iTextBits / 8);
-				pResult->kblks = pEnc->current->sStat.kblks;
-				pResult->mblks = pEnc->current->sStat.mblks;
-				pResult->ublks = pEnc->current->sStat.ublks;
+				goto done_flush;
 			}
 
+			emms();
+			return XVID_ERR_END;	/* end of stream reached */
 		}
-
-		pFrame->length = BitstreamLength(&bs);
-
-		emms();
-
-		return XVID_ERR_OK;
+		goto done;	/* nothing to encode yet; encoder lag */
 	}
 
-	pEnc->flush_bframes = 0;
-
-	emms();
-
-	/* only inc frame num, adapt quant, etc. if we havent seen it before */
-	if (pEnc->bframenum_dx50bvop < 0 )
-	{
-		mode = intra2coding_type(pFrame->intra);
-		if (pFrame->quant == 0)
-			pEnc->current->quant = RateControlGetQ(&pEnc->rate_control, 0);
-		else
-			pEnc->current->quant = pFrame->quant;
+	// the current FRAME becomes the reference
+	SWAP(FRAMEINFO*, pEnc->current, pEnc->reference);
 
-/*		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;
+	// remove frame from encoding-queue (head), and move it into the current
+	image_swap(&pEnc->current->image, &pEnc->queue[pEnc->queue_head].image);
+	frame = &pEnc->queue[pEnc->queue_head].frame;
+	pEnc->queue_head = (pEnc->queue_head + 1) % (pEnc->mbParam.max_bframes+1);
+	pEnc->queue_size--;
 
-		/* ToDo : dynamic fcode (in both directions) */
-		pEnc->current->fcode = pEnc->mbParam.m_fcode;
-		pEnc->current->bcode = pEnc->mbParam.m_fcode;
-
-		inc_frame_num(pEnc);
-
-		if (pFrame->general & XVID_EXTRASTATS)
-		{	image_copy(&pEnc->sOriginal, &pEnc->current->image,
-				   pEnc->mbParam.edged_width, pEnc->mbParam.height);
-		}
-
-		emms();
-
-		if ((pEnc->mbParam.global & XVID_GLOBAL_DEBUG)) {
-			image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 5, 
-				"%i  if:%i  st:%i", pEnc->m_framenum++, pEnc->iFrameNum, pEnc->current->stamp);
-		}
 
 	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-	 * Luminance masking
+	 * init pEnc->current fields
 	 * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
 
-		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);
+    
+    pEnc->current->fincr = pEnc->mbParam.fincr>0 ? pEnc->mbParam.fincr : frame->fincr; 
+    pEnc->current->vol_flags = pEnc->mbParam.vol_flags;
+    pEnc->current->vop_flags = frame->vop_flags;
+	pEnc->current->motion_flags = frame->motion;
+	pEnc->current->fcode = pEnc->mbParam.m_fcode;
+	pEnc->current->bcode = pEnc->mbParam.m_fcode;
 
-			for (y = 0; y < pEnc->mbParam.mb_height; y++) {
+    if ((xFrame->vop_flags & XVID_CHROMAOPT)) {
+	    image_chroma_optimize(&pEnc->current->image, 
+		    pEnc->mbParam.width, pEnc->mbParam.height, pEnc->mbParam.edged_width);
+    }
+
+	emms();		/* float-point region */
+	if ((pEnc->current->vop_flags & XVID_LUMIMASKING)) {
+        unsigned int x, y;
 
-#define OFFSET(x,y) ((x) + (y)*pEnc->mbParam.mb_width)
+		pEnc->current->quant =
+			adaptive_quantization(pEnc->current->image.y,
+							  pEnc->mbParam.edged_width, pEnc->temp_dquants,
+							  pEnc->current->quant, pEnc->current->quant,
+							  2 * pEnc->current->quant,
+							  pEnc->mbParam.mb_width,
+							  pEnc->mbParam.mb_height);
 
-				for (x = 0; x < pEnc->mbParam.mb_width; x++) {
-					MACROBLOCK *pMB = &pEnc->current->mbs[OFFSET(x, y)];
+		for (y = 0; y < pEnc->mbParam.mb_height; y++) {
 
-					pMB->dquant = iDQtab[temp_dquants[OFFSET(x, y)] + 2];
-				}
+#define OFFSET(x,y) ((x) + (y)*pEnc->mbParam.mb_width)
 
-#undef OFFSET
+			for (x = 0; x < pEnc->mbParam.mb_width; x++) {
+				MACROBLOCK *pMB = &pEnc->current->mbs[OFFSET(x, y)];
+
+				pMB->dquant = iDQtab[pEnc->temp_dquants[OFFSET(x, y)] + 2];
 			}
 
-			xvid_free(temp_dquants);
+#undef OFFSET
 		}
 
 	}
+    emms();		/* END floating-point region */
 
 	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-	 * ivop/pvop/bvop selection
+	 * frame type & quant selection
 	 * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
-	pEnc->iFrameNum++;
-
-	if (pEnc->iFrameNum == 0 || pEnc->bframenum_dx50bvop >= 0 ||
-		(mode < 0 && pEnc->mbParam.iMaxKeyInterval > 0 && 
-			pEnc->iFrameNum >= pEnc->mbParam.iMaxKeyInterval))
-	{
-		mode = I_VOP;
-	}else{
-		mode = MEanalysis(&pEnc->reference->image, pEnc->current,
-					&pEnc->mbParam, pEnc->mbParam.iMaxKeyInterval,
-					(mode < 0) ? pEnc->iFrameNum : 0,
-					bframes_count++);
-	}
-
-	if (mode == I_VOP) {
-		/*
-		 * This will be coded as an Intra Frame
-		 */
-		if ((pEnc->current->global_flags & XVID_QUARTERPEL))
-			pEnc->mbParam.m_quarterpel = 1;
-		else
-			pEnc->mbParam.m_quarterpel = 0;
-
-		if (pEnc->current->global_flags & XVID_MPEGQUANT) pEnc->mbParam.m_quant_type = MPEG4_QUANT;
-
-		if ((pEnc->current->global_flags & XVID_CUSTOM_QMATRIX) > 0) {
-			if (pFrame->quant_intra_matrix != NULL)
-				set_intra_matrix(pFrame->quant_intra_matrix);
-			if (pFrame->quant_inter_matrix != NULL)
-				set_inter_matrix(pFrame->quant_inter_matrix);
-		}
-
-
-		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->mbParam.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 */
+    call_plugins(pEnc, pEnc->current, NULL, XVID_PLG_BEFORE, &type, &pEnc->current->quant, stats);
 
-		if ((pEnc->mbParam.global & XVID_GLOBAL_DX50BVOP) && pEnc->bframenum_tail > 0) {
+    if (frame->type > 0)
+   		type = frame->type;
 
-			pEnc->bframenum_tail--;
-			pEnc->bframenum_dx50bvop = pEnc->bframenum_tail;
+    if (frame->quant > 0)
+		pEnc->current->quant = frame->quant;
 
-			SWAP(FRAMEINFO *, pEnc->current, pEnc->bframes[pEnc->bframenum_dx50bvop]);
-			if ((pEnc->mbParam.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);
-			bframes_count = 0;
-			pFrame->intra = 0;
-
-		} else {
-
-			FrameCodeI(pEnc, &bs, &bits);
-			bframes_count = 0;
-			pFrame->intra = 1;
-
-			pEnc->bframenum_dx50bvop = -1;
-		}
-
-		pEnc->flush_bframes = 1;
+    if (type > 0){ 	/* XVID_TYPE_?VOP */
+		type = type2coding(type);	/* convert XVID_TYPE_?VOP to bitstream coding type */
+    } else{		/* XVID_TYPE_AUTO */
+		if (pEnc->iFrameNum == 0 || (pEnc->mbParam.iMaxKeyInterval > 0 && pEnc->iFrameNum >= pEnc->mbParam.iMaxKeyInterval)){
+			pEnc->iFrameNum = 0;
+			type = I_VOP;
+		}else{
+			type = MEanalysis(&pEnc->reference->image, pEnc->current,
+					&pEnc->mbParam, pEnc->mbParam.iMaxKeyInterval,
+					pEnc->iFrameNum, pEnc->bframenum_tail);
 
-		if ((pEnc->mbParam.global & XVID_GLOBAL_PACKED) && pEnc->bframenum_tail > 0) {
-			BitstreamPadAlways(&bs);
-			input_valid = 0;
-			goto ipvop_loop;
+            if (type == B_VOP && !(pEnc->current->vop_flags & XVID_DYNAMIC_BFRAMES)) {
+                type = P_VOP;   /* disable dynamic bframes */
+            }
 		}
+	}
 
-		/*
-		 * NB : sequences like "IIBB" decode fine with msfdam but,
-		 *      go screwy with divx 5.00
-		 */
-	} else if (mode == P_VOP || mode == S_VOP || pEnc->bframenum_tail >= pEnc->mbParam.max_bframes) {
-		/*
-		 * This will be coded as a Predicted Frame
-		 */
+    /* bframes buffer overflow check */
+    if (type != I_VOP) {
+        if (pEnc->bframenum_tail >= pEnc->mbParam.max_bframes) {
+            type = P_VOP;
+        }else{
+            type = B_VOP;
+        }
+    }
 
-		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->mbParam.global & XVID_GLOBAL_DEBUG)) {
-			image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 200, "PVOP");
-		}
+	inc_frame_num(pEnc);
+	pEnc->iFrameNum++;
 
-		FrameCodeP(pEnc, &bs, &bits, 1, 0);
-		bframes_count = 0;
-		pFrame->intra = 0;
-		pEnc->flush_bframes = 1;
-
-		if ((pEnc->mbParam.global & XVID_GLOBAL_PACKED) && (pEnc->bframenum_tail > 0)) {
-			BitstreamPadAlways(&bs);
-			input_valid = 0;
-			goto ipvop_loop;
-		}
-
-	} else {	/* mode == B_VOP */
-		/*
-		 * This will be coded as a Bidirectional Frame
-		 */
+	if ((pEnc->current->vop_flags & XVID_DEBUG)) {
+		image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 5, 
+			"%i  st:%i  if:%i", pEnc->current->frame_num, pEnc->current->stamp, pEnc->iFrameNum);
+	}
 
-		if ((pEnc->mbParam.global & XVID_GLOBAL_DEBUG)) {
+	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+	 * encode this frame as a b-vop
+     * (we dont encode here, rather we store the frame in the bframes queue, to be encoded later)
+	 * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
+	if (type == B_VOP) {
+		if ((pEnc->current->vop_flags & XVID_DEBUG)) {
 			image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 200, "BVOP");
 		}
 
-		if (pFrame->bquant < 1) {
+		if (frame->bquant < 1) {
 			pEnc->current->quant = ((((pEnc->reference->quant + pEnc->current->quant) * 
 				pEnc->mbParam.bquant_ratio) / 2) + pEnc->mbParam.bquant_offset)/100;
 
 		} else {
-			pEnc->current->quant = pFrame->bquant;
+			pEnc->current->quant = frame->bquant;
 		}
 
 		if (pEnc->current->quant < 1)
@@ -1125,258 +1087,155 @@
 		else 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",
+		DPRINTF(DPRINTF_DEBUG,"*** BFRAME (store) bf: head=%i tail=%i   queue: head=%i tail=%i size=%i  quant=%i",
 				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(FRAMEINFO *, pEnc->current, pEnc->bframes[pEnc->bframenum_tail]);
-		SWAP(FRAMEINFO *, pEnc->current, pEnc->reference);
+		SWAP(FRAMEINFO*, pEnc->current, pEnc->bframes[pEnc->bframenum_tail]);
+		SWAP(FRAMEINFO*, pEnc->current, pEnc->reference);
 
 		pEnc->bframenum_tail++;
 
-		/* bframe report by koepi */
-		pFrame->intra = 2;
-		pFrame->length = 0;
-
-		input_valid = 0;
-		goto bvop_loop;
-	}
-
-	BitstreamPadAlways(&bs);
-	pFrame->length = BitstreamLength(&bs);
-
-	if (pResult) {
-		pResult->quant = pEnc->current->quant;
-		pResult->hlength = pFrame->length - (pEnc->current->sStat.iTextBits / 8);
-		pResult->kblks = pEnc->current->sStat.kblks;
-		pResult->mblks = pEnc->current->sStat.mblks;
-		pResult->ublks = pEnc->current->sStat.ublks;
-
-		if (pFrame->general & XVID_EXTRASTATS)
-		{	pResult->sse_y =
-				plane_sse( pEnc->sOriginal.y, pEnc->current->image.y,
-						   pEnc->mbParam.edged_width, pEnc->mbParam.width,
-						   pEnc->mbParam.height);
-
-			pResult->sse_u =
-				plane_sse( pEnc->sOriginal.u, pEnc->current->image.u,
-						   pEnc->mbParam.edged_width/2, pEnc->mbParam.width/2,
-						   pEnc->mbParam.height/2);
-
-			pResult->sse_v =
-				plane_sse( pEnc->sOriginal.v, pEnc->current->image.v,
-						   pEnc->mbParam.edged_width/2, pEnc->mbParam.width/2,
-						   pEnc->mbParam.height/2);		
-		}
-	}
-
-	emms();
-
-	if (pFrame->quant == 0) {
-		RateControlUpdate(&pEnc->rate_control, pEnc->current->quant,
-						  pFrame->length, pFrame->intra);
-	}
-
-	stop_global_timer();
-	write_timer();
+		goto repeat;
+    }
 
-	emms();
-	return XVID_ERR_OK;
-}
+    /* for unpacked bframes, output the stats for the last encoded frame */
+    if (!(pEnc->mbParam.global_flags & XVID_PACKED) && pEnc->bframenum_tail > 0)
+    {
+        if (pEnc->current->stamp > 0) {
+            call_plugins(pEnc, pEnc->reference, &pEnc->sOriginal, XVID_PLG_AFTER, 0, 0, stats);
+        }
+		else
+			stats->type = XVID_TYPE_NOTHING;
+    }
 
+	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+	 * closed-gop
+     * if the frame prior to an iframe is scheduled as a bframe, we must change it to a pframe
+     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
 
+    if (type == I_VOP && (pEnc->mbParam.global_flags & XVID_CLOSED_GOP) && pEnc->bframenum_tail > 0) {
 
-/*****************************************************************************
- * "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
- ****************************************************************************/
+		// place this frame back on the encoding-queue (head)
+		// we will deal with it next time
+		pEnc->queue_head = (pEnc->queue_head + (pEnc->mbParam.max_bframes+1) - 1) % (pEnc->mbParam.max_bframes+1);
+        pEnc->queue_size++;
+		image_swap(&pEnc->current->image, &pEnc->queue[pEnc->queue_head].image);
 
-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;
+        dec_frame_num(pEnc);
+        pEnc->iFrameNum--;
 
-	float psnr;
-	char temp[128];
+		// grab the last frame from the bframe-queue
 
-	start_global_timer();
+		pEnc->bframenum_tail--;
+		SWAP(FRAMEINFO*, pEnc->current, pEnc->bframes[pEnc->bframenum_tail]);
 
-	ENC_CHECK(pEnc);
-	ENC_CHECK(pFrame);
-	ENC_CHECK(pFrame->bitstream);
-	ENC_CHECK(pFrame->image);
-
-	SWAP(FRAMEINFO *, pEnc->current, pEnc->reference);
-
-	pEnc->current->global_flags = pFrame->general;
-	pEnc->current->motion_flags = pFrame->motion;
-	pEnc->mbParam.hint = &pFrame->hint;
+		if ((pEnc->current->vop_flags & XVID_DEBUG)) {
+			image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 100, "DX50 BVOP->PVOP");
+		}
 
-	inc_frame_num(pEnc);
+		/* convert B-VOP quant to P-VOP */
+		pEnc->current->quant = ((pEnc->current->quant*100) - pEnc->mbParam.bquant_offset) / pEnc->mbParam.bquant_ratio;
+        type = P_VOP;
+    }
 
-	/* disable alternate scan flag if interlacing is not enabled */
-	if ((pEnc->current->global_flags & XVID_ALTERNATESCAN) &&
-		!(pEnc->current->global_flags & XVID_INTERLACING))
-	{
-		pEnc->current->global_flags -= XVID_ALTERNATESCAN;
-	}
 
-	start_timer();
-	if (image_input
-		(&pEnc->current->image, pEnc->mbParam.width, pEnc->mbParam.height,
-		 pEnc->mbParam.edged_width, pFrame->image, pFrame->stride, pFrame->colorspace, pFrame->general & XVID_INTERLACING) < 0)
-		return XVID_ERR_FORMAT;
-	stop_conv_timer();
-
-	if ((pFrame->general & XVID_CHROMAOPT)) {
-		image_chroma_optimize(&pEnc->current->image, 
-			pEnc->mbParam.width, pEnc->mbParam.height, pEnc->mbParam.edged_width);
-	}
+	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+	 * encode this frame as an i-vop
+     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
 
-	if (pFrame->general & XVID_EXTRASTATS)
-	{	image_copy(&pEnc->sOriginal, &pEnc->current->image,
-				   pEnc->mbParam.edged_width, pEnc->mbParam.height);
-	}
+	if (type == I_VOP) {
 
-	emms();
+		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->current->vop_flags & XVID_DEBUG)) {
+			image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 200, "IVOP");
+		}
 
-	BitstreamInit(&bs, pFrame->bitstream, 0);
 
-	if (pFrame->quant == 0) {
-		pEnc->current->quant = RateControlGetQ(&pEnc->rate_control, 0);
-	} else {
-		pEnc->current->quant = pFrame->quant;
-	}
+		/* ---- update vol flags at IVOP ----------- */
+		pEnc->current->vol_flags = pEnc->mbParam.vol_flags = frame->vol_flags;
 
-	if ((pEnc->current->global_flags & XVID_QUARTERPEL))
-		pEnc->mbParam.m_quarterpel = 1;
-	else
-		pEnc->mbParam.m_quarterpel = 0;
+        if ((pEnc->mbParam.vol_flags & XVID_MPEGQUANT)) {
+			if (frame->quant_intra_matrix != NULL)
+				set_intra_matrix(frame->quant_intra_matrix);	
+			if (frame->quant_inter_matrix != NULL)
+				set_inter_matrix(frame->quant_inter_matrix);
+		}
 
-	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);
+        /* prevent vol/vop misuse */
 
-		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);
+        if (!(pEnc->current->vol_flags & XVID_REDUCED_ENABLE))
+            pEnc->current->vop_flags &= ~XVID_REDUCED;
 
-		for (y = 0; y < pEnc->mbParam.mb_height; y++) {
+        if (!(pEnc->current->vol_flags & XVID_INTERLACING))
+            pEnc->current->vop_flags &= ~(XVID_TOPFIELDFIRST|XVID_ALTERNATESCAN);
 
-#define OFFSET(x,y) ((x) + (y)*pEnc->mbParam.mb_width)
+		/* ^^^------------------------ */
 
-			for (x = 0; x < pEnc->mbParam.mb_width; x++) {
+        if ((pEnc->mbParam.plugin_flags & XVID_REQORIGINAL)) {
+		    image_copy(&pEnc->sOriginal, &pEnc->current->image,
+		           pEnc->mbParam.edged_width, pEnc->mbParam.height);
+        }
 
+		FrameCodeI(pEnc, &bs);
+		xFrame->out_flags |= XVID_KEYFRAME;
 
-				MACROBLOCK *pMB = &pEnc->current->mbs[OFFSET(x, y)];
+	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+	 * encode this frame as an p-vop
+     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
 
-				pMB->dquant = iDQtab[temp_dquants[OFFSET(x, y)] + 2];
-			}
+    } else { // (type == P_VOP || type == S_VOP)
 
-#undef OFFSET
+		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->current->vop_flags & XVID_DEBUG)) {
+			image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 200, "PVOP");
 		}
 
-		xvid_free(temp_dquants);
-	}
+        if ((pEnc->mbParam.plugin_flags & XVID_REQORIGINAL)) {
+		    image_copy(&pEnc->sOriginal, &pEnc->current->image,
+		           pEnc->mbParam.edged_width, pEnc->mbParam.height);
+        }
 
-	if (pEnc->current->global_flags & XVID_H263QUANT) {
-		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 matrix1_changed, matrix2_changed;
+		FrameCodeP(pEnc, &bs, 1, 0);
+    }
 
-		matrix1_changed = matrix2_changed = 0;
+	
+    /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+	 * on next enc_encode call we must flush bframes
+	 * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
 
-		if (pEnc->mbParam.m_quant_type != MPEG4_QUANT)
-			write_vol_header = 1;
+done_flush:
 
-		pEnc->mbParam.m_quant_type = MPEG4_QUANT;
+    pEnc->flush_bframes = 1;
 
-		if ((pEnc->current->global_flags & XVID_CUSTOM_QMATRIX) > 0) {
-			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 = matrix1_changed | matrix2_changed;
+	/* packed & queued_bframes: dont bother outputting stats, we do so after the flush */
+	if ((pEnc->mbParam.global_flags & XVID_PACKED) && pEnc->bframenum_tail > 0) {
+		goto repeat;
 	}
 
-	if (pFrame->intra < 0) {
-		if ((pEnc->iFrameNum == -1)
-			|| ((pEnc->mbParam.iMaxKeyInterval > 0)
-				&& (pEnc->iFrameNum >= pEnc->mbParam.iMaxKeyInterval))) {
-			pFrame->intra = FrameCodeI(pEnc, &bs, &bits);
-		} else {
-			pFrame->intra = FrameCodeP(pEnc, &bs, &bits, 0, write_vol_header);
-		}
-	} else {
-		if (pFrame->intra == 1) {
-			pFrame->intra = FrameCodeI(pEnc, &bs, &bits);
-		} else {
-			pFrame->intra = FrameCodeP(pEnc, &bs, &bits, 1, write_vol_header);
-		}
-
-	}
-
-	/* Relic from OpenDivX - now disabled
-	BitstreamPutBits(&bs, 0xFFFF, 16);
-	BitstreamPutBits(&bs, 0xFFFF, 16);
-	*/
-
-	BitstreamPadAlways(&bs);
-	pFrame->length = BitstreamLength(&bs);
-
-	if (pResult) {
-		pResult->quant = pEnc->current->quant;
-		pResult->hlength = pFrame->length - (pEnc->current->sStat.iTextBits / 8);
-		pResult->kblks = pEnc->current->sStat.kblks;
-		pResult->mblks = pEnc->current->sStat.mblks;
-		pResult->ublks = pEnc->current->sStat.ublks;
+    /* packed or no-bframes: output stats */
+    if ((pEnc->mbParam.global_flags & XVID_PACKED) || pEnc->mbParam.max_bframes == 0) {
+        call_plugins(pEnc, pEnc->current, &pEnc->sOriginal, XVID_PLG_AFTER, 0, 0, stats);
 	}
 
-	emms();
-
-	if (pFrame->quant == 0) {
-		RateControlUpdate(&pEnc->rate_control, pEnc->current->quant,
-						  pFrame->length, pFrame->intra);
-	}
-	if (pFrame->general & XVID_EXTRASTATS)
-	{
-		psnr =
-			image_psnr(&pEnc->sOriginal, &pEnc->current->image,
-					   pEnc->mbParam.edged_width, pEnc->mbParam.width,
-					   pEnc->mbParam.height);
-	
-		snprintf(temp, 127, "PSNR: %f\n", psnr);
-	}
+	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+	 * done; return number of bytes consumed
+	 * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
 
-	pEnc->iFrameNum++;
+done:
 
 	stop_global_timer();
 	write_timer();
 
-	return XVID_ERR_OK;
+	emms();
+	return BitstreamLength(&bs);
 }
 
 
@@ -1393,7 +1252,7 @@
 	pMB->sad8[0] = pMB->sad8[1] = pMB->sad8[2] = pMB->sad8[3] = 0;
 	pMB->sad16 = 0;
 
-	if ((pEnc->current->global_flags & XVID_LUMIMASKING)) {
+	if ((pEnc->current->vop_flags & XVID_LUMIMASKING)) {
 		if (pMB->dquant != NO_CHANGE) {
 			pMB->mode = MODE_INTRA_Q;
 			pEnc->current->quant += DQtab[pMB->dquant];
@@ -1409,210 +1268,21 @@
 }
 
 
-#define FCODEBITS	3
-#define MODEBITS	5
-
-void
-HintedMESet(Encoder * pEnc,
-			int *intra)
-{
-	HINTINFO *hint;
-	Bitstream bs;
-	int length, high;
-	uint32_t x, y;
-
-	hint = pEnc->mbParam.hint;
-
-	if (hint->rawhints) {
-		*intra = hint->mvhint.intra;
-	} else {
-		BitstreamInit(&bs, hint->hintstream, hint->hintlength);
-		*intra = BitstreamGetBit(&bs);
-	}
-
-	if (*intra) {
-		return;
-	}
-
-	pEnc->current->fcode = (hint->rawhints) ?
-		(uint32_t)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;
-			VECTOR tmp;
-			int vec;
-
-			pMB->mode =	(hint->rawhints) ?
-				(uint32_t)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 : (int)BitstreamGetBits(&bs, length);
-				tmp.y =	(hint->rawhints) ?
-					bhint->mvs[0].y : (int)BitstreamGetBits(&bs, length);
-				tmp.x -= (tmp.x >= high) ? high * 2 : 0;
-				tmp.y -= (tmp.y >= high) ? high * 2 : 0;
-
-				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.x;
-					pMB->pmvs[vec].y = pMB->mvs[0].y - pred.y;
-				}
-			} else if (pMB->mode == MODE_INTER4V) {
-				for (vec = 0; vec < 4; ++vec) {
-					tmp.x =	(hint->rawhints) ?
-						bhint->mvs[vec].x : (int)BitstreamGetBits(&bs, length);
-					tmp.y =	(hint->rawhints) ?
-						bhint->mvs[vec].y : (int)BitstreamGetBits(&bs, length);
-					tmp.x -= (tmp.x >= high) ? high * 2 : 0;
-					tmp.y -= (tmp.y >= high) ? high * 2 : 0;
-
-					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.x;
-					pMB->pmvs[vec].y = pMB->mvs[vec].y - pred.y;
-				}
-			} else				/* intra / stuffing / not_coded */
-			{
-				for (vec = 0; vec < 4; ++vec) {
-					pMB->mvs[vec].x = pMB->mvs[vec].y = 0;
-				}
-			}
-
-			if (pMB->mode == MODE_INTER4V &&
-				(pEnc->current->global_flags & XVID_LUMIMASKING)
-				&& pMB->dquant != NO_CHANGE) {
-				pMB->mode = MODE_INTRA;
-
-				for (vec = 0; vec < 4; ++vec) {
-					pMB->mvs[vec].x = pMB->mvs[vec].y = 0;
-				}
-			}
-		}
-	}
-}
-
-
-void
-HintedMEGet(Encoder * pEnc,
-			int intra)
-{
-	HINTINFO *hint;
-	Bitstream bs;
-	uint32_t x, y;
-	int length, high;
-
-	hint = pEnc->mbParam.hint;
-
-	if (hint->rawhints) {
-		hint->mvhint.intra = intra;
-	} else {
-		BitstreamInit(&bs, hint->hintstream, 0);
-		BitstreamPutBit(&bs, intra);
-	}
-
-	if (intra) {
-		if (!hint->rawhints) {
-			BitstreamPadAlways(&bs);
-			hint->hintlength = BitstreamLength(&bs);
-		}
-		return;
-	}
-
-	length = pEnc->current->fcode + 5;
-	high = 1 << (length - 1);
-
-	if (hint->rawhints) {
-		hint->mvhint.fcode = pEnc->current->fcode;
-	} else {
-		BitstreamPutBits(&bs, pEnc->current->fcode, FCODEBITS);
-	}
-
-	for (y = 0; y < pEnc->mbParam.mb_height; ++y) {
-		for (x = 0; x < pEnc->mbParam.mb_width; ++x) {
-			MACROBLOCK *pMB =
-				&pEnc->current->mbs[x + y * pEnc->mbParam.mb_width];
-			MVBLOCKHINT *bhint =
-				&hint->mvhint.block[x + y * pEnc->mbParam.mb_width];
-			VECTOR tmp;
-
-			if (hint->rawhints) {
-				bhint->mode = pMB->mode;
-			} else {
-				BitstreamPutBits(&bs, pMB->mode, MODEBITS);
-			}
-
-			if (pMB->mode == MODE_INTER || pMB->mode == MODE_INTER_Q) {
-				tmp.x = pMB->mvs[0].x;
-				tmp.y = pMB->mvs[0].y;
-				tmp.x += (tmp.x < 0) ? high * 2 : 0;
-				tmp.y += (tmp.y < 0) ? high * 2 : 0;
-
-				if (hint->rawhints) {
-					bhint->mvs[0].x = tmp.x;
-					bhint->mvs[0].y = tmp.y;
-				} else {
-					BitstreamPutBits(&bs, tmp.x, length);
-					BitstreamPutBits(&bs, tmp.y, length);
-				}
-			} else if (pMB->mode == MODE_INTER4V) {
-				int vec;
-
-				for (vec = 0; vec < 4; ++vec) {
-					tmp.x = pMB->mvs[vec].x;
-					tmp.y = pMB->mvs[vec].y;
-					tmp.x += (tmp.x < 0) ? high * 2 : 0;
-					tmp.y += (tmp.y < 0) ? high * 2 : 0;
-
-					if (hint->rawhints) {
-						bhint->mvs[vec].x = tmp.x;
-						bhint->mvs[vec].y = tmp.y;
-					} else {
-						BitstreamPutBits(&bs, tmp.x, length);
-						BitstreamPutBits(&bs, tmp.y, length);
-					}
-				}
-			}
-		}
-	}
-
-	if (!hint->rawhints) {
-		BitstreamPad(&bs);
-		hint->hintlength = BitstreamLength(&bs);
-	}
-}
-
 
 static int
 FrameCodeI(Encoder * pEnc,
-		   Bitstream * bs,
-		   uint32_t * pBits)
+		   Bitstream * bs)
 {
+    int bits = BitstreamPos(bs);
 	int mb_width = pEnc->mbParam.mb_width;
 	int mb_height = pEnc->mbParam.mb_height;
-
+    
 	DECLARE_ALIGNED_MATRIX(dct_codes, 6, 64, int16_t, CACHE_LINE);
 	DECLARE_ALIGNED_MATRIX(qcoeff, 6, 64, int16_t, CACHE_LINE);
 
 	uint16_t x, y;
 
-	if ((pEnc->current->global_flags & XVID_REDUCED))
+	if ((pEnc->current->vol_flags & XVID_REDUCED_ENABLE))
 	{
 		mb_width = (pEnc->mbParam.width + 31) / 32;
 		mb_height = (pEnc->mbParam.height + 31) / 32;
@@ -1626,21 +1296,17 @@
 		stop_edges_timer();
 	}
 
-	pEnc->iFrameNum = 0;
 	pEnc->mbParam.m_rounding_type = 1;
 	pEnc->current->rounding_type = pEnc->mbParam.m_rounding_type;
-  	pEnc->current->quarterpel =  pEnc->mbParam.m_quarterpel;
 	pEnc->current->coding_type = I_VOP;
 
-	BitstreamWriteVolHeader(bs, &pEnc->mbParam, pEnc->current);
+	BitstreamWriteVolHeader(bs, &pEnc->mbParam);
 
 	set_timecodes(pEnc->current,pEnc->reference,pEnc->mbParam.fbase);
 
 	BitstreamPadAlways(bs);
 	BitstreamWriteVopHeader(bs, &pEnc->mbParam, pEnc->current, 1);
 
-	*pBits = BitstreamPos(bs);
-
 	pEnc->current->sStat.iTextBits = 0;
 	pEnc->current->sStat.kblks = mb_width * mb_height;
 	pEnc->current->sStat.mblks = pEnc->current->sStat.ublks = 0;
@@ -1660,7 +1326,7 @@
 			stop_prediction_timer();
 
 			start_timer();
-			if (pEnc->current->global_flags & XVID_GREYSCALE)
+			if (pEnc->current->vop_flags & XVID_GREYSCALE)
 			{	pMB->cbp &= 0x3C;		/* keep only bits 5-2 */
 				qcoeff[4*64+0]=0;		/* zero, because for INTRA MBs DC value is saved */
 				qcoeff[5*64+0]=0;
@@ -1669,21 +1335,28 @@
 			stop_coding_timer();
 		}
 
-	if ((pEnc->current->global_flags & XVID_REDUCED))
+	if ((pEnc->current->vop_flags & XVID_REDUCED))
 	{
 		image_deblock_rrv(&pEnc->current->image, pEnc->mbParam.edged_width, 
 			pEnc->current->mbs, mb_width, mb_height, pEnc->mbParam.mb_width,
-			16, XVID_DEC_DEBLOCKY|XVID_DEC_DEBLOCKUV);
+			16, 0);
 	}
 	emms();
 
-	*pBits = BitstreamPos(bs) - *pBits;
+	/* for divx5 compatibility, we must always pad between the packed p and b frames */
+	if ((pEnc->mbParam.global_flags & XVID_PACKED) && pEnc->bframenum_tail > 0)
+		BitstreamPadAlways(bs);
+	else
+		BitstreamPad(bs);
+    pEnc->current->length = (BitstreamPos(bs) - bits) / 8;
+
 	pEnc->fMvPrevSigma = -1;
 	pEnc->mbParam.m_fcode = 2;
 
+    /* XXX: hinted me 
 	if (pEnc->current->global_flags & XVID_HINTEDME_GET) {
 		HintedMEGet(pEnc, 1);
-	}
+	}*/
 
 	return 1;					/* intra */
 }
@@ -1697,11 +1370,11 @@
 static int
 FrameCodeP(Encoder * pEnc,
 		   Bitstream * bs,
-		   uint32_t * pBits,
 		   bool force_inter,
 		   bool vol_header)
 {
 	float fSigma;
+    int bits = BitstreamPos(bs);
 
 	DECLARE_ALIGNED_MATRIX(dct_codes, 6, 64, int16_t, CACHE_LINE);
 	DECLARE_ALIGNED_MATRIX(qcoeff, 6, 64, int16_t, CACHE_LINE);
@@ -1713,11 +1386,11 @@
 	int x, y, k;
 	int iSearchRange;
 	int bIntra, skip_possible;
-	
+
 	/* IMAGE *pCurrent = &pEnc->current->image; */
 	IMAGE *pRef = &pEnc->reference->image;
 
-	if ((pEnc->current->global_flags & XVID_REDUCED))
+	if ((pEnc->current->vop_flags & XVID_REDUCED))
 	{
 		mb_width = (pEnc->mbParam.width + 31) / 32;
 		mb_height = (pEnc->mbParam.height + 31) / 32;
@@ -1731,7 +1404,7 @@
 
 	pEnc->mbParam.m_rounding_type = 1 - pEnc->mbParam.m_rounding_type;
 	pEnc->current->rounding_type = pEnc->mbParam.m_rounding_type;
-  	pEnc->current->quarterpel =  pEnc->mbParam.m_quarterpel;
+  	//pEnc->current->quarterpel =  pEnc->mbParam.m_quarterpel;
 	pEnc->current->fcode = pEnc->mbParam.m_fcode;
 
 	if (!force_inter)
@@ -1739,12 +1412,12 @@
 	else
 		iLimit = mb_width * mb_height + 1;
 
-	if ((pEnc->current->global_flags & XVID_HALFPEL)) {
+	if ((pEnc->current->vop_flags & XVID_HALFPEL)) {
 		start_timer();
 		image_interpolate(pRef, &pEnc->vInterH, &pEnc->vInterV,
 						  &pEnc->vInterHV, pEnc->mbParam.edged_width,
 						  pEnc->mbParam.edged_height,
-						  pEnc->mbParam.m_quarterpel,
+						  (pEnc->mbParam.vol_flags & XVID_QUARTERPEL),
 						  pEnc->current->rounding_type);
 		stop_inter_timer();
 	}
@@ -1752,9 +1425,9 @@
 	pEnc->current->coding_type = P_VOP;
 	
 	start_timer();
-	if (pEnc->current->global_flags & XVID_HINTEDME_SET)
+	/*if (pEnc->current->global_flags & XVID_HINTEDME_SET)
 		HintedMESet(pEnc, &bIntra);
-	else
+	else*/
 		bIntra =
 			MotionEstimation(&pEnc->mbParam, pEnc->current, pEnc->reference,
                          &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV,
@@ -1762,9 +1435,9 @@
 
 	stop_motion_timer();
 
-	if (bIntra == 1) return FrameCodeI(pEnc, bs, pBits);
+	if (bIntra == 1) return FrameCodeI(pEnc, bs);
 
-	if ( ( pEnc->current->global_flags & XVID_GMC ) 
+	if ( ( pEnc->current->vol_flags & XVID_GMC ) 
 		&& ( (pEnc->current->warp.duv[1].x != 0) || (pEnc->current->warp.duv[1].y != 0) ) )
 	{
 		pEnc->current->coding_type = S_VOP;
@@ -1776,21 +1449,19 @@
 		generate_GMCimage(&pEnc->current->gmc_data, &pEnc->reference->image, 
 				pEnc->mbParam.mb_width, pEnc->mbParam.mb_height,
 				pEnc->mbParam.edged_width, pEnc->mbParam.edged_width/2, 
-				pEnc->mbParam.m_fcode, pEnc->mbParam.m_quarterpel, 0, 
+				pEnc->mbParam.m_fcode, (pEnc->mbParam.vol_flags & XVID_QUARTERPEL), 0, 
 				pEnc->current->rounding_type, pEnc->current->mbs, &pEnc->vGMC);
 
 	}
 
 	set_timecodes(pEnc->current,pEnc->reference,pEnc->mbParam.fbase);
 	if (vol_header)
-	{	BitstreamWriteVolHeader(bs, &pEnc->mbParam, pEnc->current);	
+	{	BitstreamWriteVolHeader(bs, &pEnc->mbParam);	
 		BitstreamPadAlways(bs);
 	}
 
 	BitstreamWriteVopHeader(bs, &pEnc->mbParam, pEnc->current, 1);
 
-	*pBits = BitstreamPos(bs);
-
 	pEnc->current->sStat.iTextBits = pEnc->current->sStat.iMvSum = pEnc->current->sStat.iMvCount = 
 		pEnc->current->sStat.kblks = pEnc->current->sStat.mblks = pEnc->current->sStat.ublks = 0;
 
@@ -1837,7 +1508,7 @@
 
 				if (iSAD <= pMB->sad16) {		/* mode decision GMC */
 
-					if (pEnc->mbParam.m_quarterpel)
+					if ((pEnc->mbParam.vol_flags & XVID_QUARTERPEL))
 						pMB->qmvs[0] = pMB->qmvs[1] = pMB->qmvs[2] = pMB->qmvs[3] = pMB->amv;
 					else
 						pMB->mvs[0] = pMB->mvs[1] = pMB->mvs[2] = pMB->mvs[3] = pMB->amv;
@@ -1860,13 +1531,13 @@
 								 dct_codes, pEnc->mbParam.width,
 								 pEnc->mbParam.height,
 								 pEnc->mbParam.edged_width,
-								 pEnc->mbParam.m_quarterpel,
-								 (pEnc->current->global_flags & XVID_REDUCED),
+								 (pEnc->current->vol_flags & XVID_QUARTERPEL),
+								 (pEnc->current->vop_flags & XVID_REDUCED),
 								 pEnc->current->rounding_type);
 
 			stop_comp_timer();
 
-			if ((pEnc->current->global_flags & XVID_LUMIMASKING)) {
+			if ((pEnc->current->vop_flags & XVID_LUMIMASKING)) {
 				if (pMB->dquant != NO_CHANGE) {
 					pMB->mode = MODE_INTER_Q;
 					pEnc->current->quant += DQtab[pMB->dquant];
@@ -1904,7 +1575,7 @@
 			if (pEnc->current->coding_type == S_VOP)
 				skip_possible &= (pMB->mcsel == 1);
 			else if (pEnc->current->coding_type == P_VOP) {
-				if (pEnc->mbParam.m_quarterpel)
+				if ((pEnc->mbParam.vol_flags & XVID_QUARTERPEL))
 					skip_possible &= ( (pMB->qmvs[0].x == 0) && (pMB->qmvs[0].y == 0) );
 				else 
 					skip_possible &= ( (pMB->mvs[0].x == 0) && (pMB->mvs[0].y == 0) );
@@ -1931,7 +1602,7 @@
 					}
 					
 					if (!bSkip) {	/* no SKIP, but trivial block */
-						if(pEnc->mbParam.m_quarterpel) {
+						if((pEnc->mbParam.vol_flags & XVID_QUARTERPEL)) {
 							VECTOR predMV = get_qpmv2(pEnc->current->mbs, pEnc->mbParam.mb_width, 0, x, y, 0);
 							pMB->pmvs[0].x = - predMV.x; 
 							pMB->pmvs[0].y = - predMV.y; 
@@ -1958,13 +1629,13 @@
 			}
 			/* ordinary case: normal coded INTER/INTER4V block */
 
-			if (pEnc->current->global_flags & XVID_GREYSCALE)
+			if ((pEnc->current->vop_flags & XVID_GREYSCALE))
 			{	pMB->cbp &= 0x3C;		/* keep only bits 5-2 */
 				qcoeff[4*64+0]=0;		/* zero, because DC for INTRA MBs DC value is saved */
 				qcoeff[5*64+0]=0;
 			}
 
-			if(pEnc->mbParam.m_quarterpel) {
+			if((pEnc->mbParam.vol_flags & XVID_QUARTERPEL)) {
 				VECTOR predMV = get_qpmv2(pEnc->current->mbs, pEnc->mbParam.mb_width, 0, x, y, 0);
 				pMB->pmvs[0].x = pMB->qmvs[0].x - predMV.x;  
 				pMB->pmvs[0].y = pMB->qmvs[0].y - predMV.y; 
@@ -1981,7 +1652,7 @@
 			{	int k;
 				for (k=1;k<4;k++)
 				{
-					if(pEnc->mbParam.m_quarterpel) {
+					if((pEnc->mbParam.vol_flags & XVID_QUARTERPEL)) {
 						VECTOR predMV = get_qpmv2(pEnc->current->mbs, pEnc->mbParam.mb_width, 0, x, y, k);
 						pMB->pmvs[k].x = pMB->qmvs[k].x - predMV.x;  
 						pMB->pmvs[k].y = pMB->qmvs[k].y - predMV.y; 
@@ -2002,18 +1673,19 @@
 		}
 	}
 
-	if ((pEnc->current->global_flags & XVID_REDUCED))
+	if ((pEnc->current->vop_flags & XVID_REDUCED))
 	{
 		image_deblock_rrv(&pEnc->current->image, pEnc->mbParam.edged_width, 
 			pEnc->current->mbs, mb_width, mb_height, pEnc->mbParam.mb_width,
-			16, XVID_DEC_DEBLOCKY|XVID_DEC_DEBLOCKUV);
+			16, 0);
 	}
 
 	emms();
 
+    /* XXX: hinted me 
 	if (pEnc->current->global_flags & XVID_HINTEDME_GET) {
 		HintedMEGet(pEnc, 0);
-	}
+	}*/
 
 	if (pEnc->current->sStat.iMvCount == 0)
 		pEnc->current->sStat.iMvCount = 1;
@@ -2023,14 +1695,14 @@
 	iSearchRange = 1 << (3 + pEnc->mbParam.m_fcode);
 
 	if ((fSigma > iSearchRange / 3)
-		&& (pEnc->mbParam.m_fcode <= (3 + pEnc->mbParam.m_quarterpel)))	/* maximum search range 128 */
+        && (pEnc->mbParam.m_fcode <= (3 +  (pEnc->mbParam.vol_flags & XVID_QUARTERPEL?1:0)  )))	/* maximum search range 128 */
 	{
 		pEnc->mbParam.m_fcode++;
 		iSearchRange *= 2;
 	} else if ((fSigma < iSearchRange / 6)
 			   && (pEnc->fMvPrevSigma >= 0)
 			   && (pEnc->fMvPrevSigma < iSearchRange / 6)
-			   && (pEnc->mbParam.m_fcode >= (2 + pEnc->mbParam.m_quarterpel)))	/* minimum search range 16 */
+			   && (pEnc->mbParam.m_fcode >= (2 + (pEnc->mbParam.vol_flags & XVID_QUARTERPEL?1:0) )))	/* minimum search range 16 */
 	{
 		pEnc->mbParam.m_fcode--;
 		iSearchRange /= 2;
@@ -2055,7 +1727,7 @@
 		pEnc->current->quant = pEnc->reference->quant;
 		pEnc->current->motion_flags = pEnc->reference->motion_flags;
 		pEnc->current->rounding_type = pEnc->reference->rounding_type;
-	  	pEnc->current->quarterpel =  pEnc->reference->quarterpel;
+	  	//pEnc->current->quarterpel =  pEnc->reference->quarterpel;
 		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);
@@ -2077,8 +1749,13 @@
 	} 
 	*/
 
+   	/* for divx5 compatibility, we must always pad between the packed p and b frames */
+	if ((pEnc->mbParam.global_flags & XVID_PACKED) && pEnc->bframenum_tail > 0)
+		BitstreamPadAlways(bs);
+	else
+		BitstreamPad(bs);
 
-	*pBits = BitstreamPos(bs) - *pBits;
+    pEnc->current->length = (BitstreamPos(bs) - bits) / 8;
 
 	return 0;					/* inter */
 }
@@ -2087,9 +1764,9 @@
 static void
 FrameCodeB(Encoder * pEnc,
 		   FRAMEINFO * frame,
-		   Bitstream * bs,
-		   uint32_t * pBits)
+		   Bitstream * bs)
 {
+    int bits = BitstreamPos(bs);
 	DECLARE_ALIGNED_MATRIX(dct_codes, 6, 64, int16_t, CACHE_LINE);
 	DECLARE_ALIGNED_MATRIX(qcoeff, 6, 64, int16_t, CACHE_LINE);
 	uint32_t x, y;
@@ -2097,21 +1774,21 @@
 	IMAGE *f_ref = &pEnc->reference->image;
 	IMAGE *b_ref = &pEnc->current->image;
 
-#ifdef BFRAMES_DEC_DEBUG
+    #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); \
 	}
 
-	pEnc->current->global_flags &= ~XVID_REDUCED;	/* reduced resoltion not yet supported */
+	/* XXX: pEnc->current->global_flags &= ~XVID_REDUCED;  reduced resoltion not yet supported */
 
 	if (!first){
 		fp=fopen("C:\\XVIDDBGE.TXT","w");
 	}
 #endif
 
-  	frame->quarterpel =  pEnc->mbParam.m_quarterpel;
+  	//frame->quarterpel =  pEnc->mbParam.m_quarterpel;
 	
 	/* forward  */
 	image_setedges(f_ref, pEnc->mbParam.edged_width,
@@ -2120,7 +1797,7 @@
 	start_timer();
 	image_interpolate(f_ref, &pEnc->f_refh, &pEnc->f_refv, &pEnc->f_refhv,
 					  pEnc->mbParam.edged_width, pEnc->mbParam.edged_height,
-					  pEnc->mbParam.m_quarterpel, 0);
+					  (pEnc->mbParam.vol_flags & XVID_QUARTERPEL), 0);
 	stop_inter_timer();
 
 	/* backward */
@@ -2130,7 +1807,7 @@
 	start_timer();
 	image_interpolate(b_ref, &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV,
 					  pEnc->mbParam.edged_width, pEnc->mbParam.edged_height,
-					  pEnc->mbParam.m_quarterpel, 0);
+					  (pEnc->mbParam.vol_flags & XVID_QUARTERPEL), 0);
 	stop_inter_timer();
 
 	start_timer();
@@ -2157,18 +1834,17 @@
 	set_timecodes(frame, pEnc->reference,pEnc->mbParam.fbase);
 	BitstreamWriteVopHeader(bs, &pEnc->mbParam, frame, 1);
 
-	*pBits = BitstreamPos(bs);
-
 	frame->sStat.iTextBits = 0;
 	frame->sStat.iMvSum = 0;
 	frame->sStat.iMvCount = 0;
 	frame->sStat.kblks = frame->sStat.mblks = frame->sStat.ublks = 0;
-
+	frame->sStat.mblks = pEnc->mbParam.mb_width * pEnc->mbParam.mb_height;
+	frame->sStat.kblks = frame->sStat.ublks = 0;
 
 	for (y = 0; y < pEnc->mbParam.mb_height; y++) {
 		for (x = 0; x < pEnc->mbParam.mb_width; x++) {
 			MACROBLOCK * const mb = &frame->mbs[x + y * pEnc->mbParam.mb_width];
-			int direction = pEnc->mbParam.global & XVID_ALTERNATESCAN ? 2 : 0;
+			int direction = frame->vop_flags & XVID_ALTERNATESCAN ? 2 : 0;
 
 			/* decoder ignores mb when refence block is INTER(0,0), CBP=0 */
 			if (mb->mode == MODE_NOT_CODED) {
@@ -2187,7 +1863,7 @@
 				mb->quant = frame->quant;
 			
 				mb->cbp =
-					MBTransQuantInterBVOP(&pEnc->mbParam, frame, mb, dct_codes, qcoeff);
+					MBTransQuantInterBVOP(&pEnc->mbParam, frame, mb, x, y,  dct_codes, qcoeff);
 
 				if ( (mb->mode == MODE_DIRECT) && (mb->cbp == 0)
 					&& (mb->pmvs[3].x == 0) && (mb->pmvs[3].y == 0) ) {
@@ -2209,7 +1885,8 @@
 
 	/* TODO: dynamic fcode/bcode ??? */
 
-	*pBits = BitstreamPos(bs) - *pBits;
+    BitstreamPad(bs);
+	frame->length = (BitstreamPos(bs) - bits) / 8;
 
 #ifdef BFRAMES_DEC_DEBUG
 	if (!first){