--- encoder.c	2003/03/09 00:28:09	1.95.2.2
+++ encoder.c	2003/03/15 17:06:53	1.95.2.8
@@ -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.2.2 2003/03/09 00:28:09 edgomez Exp $
+ *  $Id: encoder.c,v 1.95.2.8 2003/03/15 17:06:53 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"
@@ -167,7 +166,48 @@
     /* framerate */
     pEnc->mbParam.fincr = MAX(create->fincr, 0);
 	pEnc->mbParam.fbase = create->fincr <= 0 ? 25 : create->fbase;
-	simplify_time(&pEnc->mbParam.fincr, &pEnc->mbParam.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);
@@ -183,20 +223,6 @@
 
 	/* Bitrate allocator defaults 
 
-	if (create->rc_bitrate <= 0)
-		create->rc_bitrate = 900000;
-
-	if (create->rc_reaction_delay_factor <= 0)
-		create->rc_reaction_delay_factor = 16;
-
-	if (create->rc_averaging_period <= 0)
-		create->rc_averaging_period = 100;
-
-	if (create->rc_buffer <= 0)
-		create->rc_buffer = 100;
-
-	
-
 	if ((create->min_quantizer <= 0) || (create->min_quantizer > 31))
 		create->min_quantizer = 1;
 
@@ -204,9 +230,7 @@
 		create->max_quantizer = 31;
 
 	if (create->max_quantizer < create->min_quantizer)
-		create->max_quantizer = create->min_quantizer;
-
-	pEnc->bitrate = create->rc_bitrate; */
+		create->max_quantizer = create->min_quantizer; */
 	
 
     /* allocate working frame-image memory */
@@ -231,8 +255,10 @@
 
 	/* allocate interpolation image memory */
 
-	if (create->global & XVID_EXTRASTATS_ENABLE)
-		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);
@@ -246,11 +272,16 @@
 	image_null(&pEnc->vInterHV);
 	image_null(&pEnc->vInterHVf);
 
-	if (create->global & XVID_EXTRASTATS_ENABLE)
-	{	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
@@ -385,15 +416,6 @@
 	pEnc->iFrameNum = 0;
 	pEnc->fMvPrevSigma = -1;
 
-    /* XXX: cleanup ratecontol when new code is ready */
-/*	if (create->rc_bitrate) {
-		RateControlInit(&pEnc->rate_control, create->rc_bitrate,
-						create->rc_reaction_delay_factor,
-						create->rc_averaging_period, create->rc_buffer,
-						create->fbase * 1000 / create->fincr,
-						create->max_quantizer, create->min_quantizer);
-	} */
-
     create->handle = (void *) pEnc;
 
 	init_timer();
@@ -440,8 +462,10 @@
 
   xvid_err_memory3:
 
-	if (pEnc->mbParam.global_flags & XVID_EXTRASTATS_ENABLE)
-	{	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);
 	}
 
@@ -479,6 +503,17 @@
   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);
 
 	create->handle = NULL;
@@ -557,8 +592,10 @@
 	image_destroy(&pEnc->f_refhv, pEnc->mbParam.edged_width,
 				  pEnc->mbParam.edged_height);
 
-	if (pEnc->mbParam.global_flags & XVID_EXTRASTATS_ENABLE)
-	{	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);
 	}
 
@@ -569,6 +606,15 @@
 
 	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);
 
@@ -576,14 +622,145 @@
 }
 
 
+/*
+  call the plugins
+  */
+
+static void call_plugins(Encoder * pEnc, FRAMEINFO * frame, IMAGE * original, 
+                         int opt, int * type, int * quant, xvid_enc_stats_t * stats)
+{
+    int i;
+    xvid_plg_data_t data;
+
+    memset(&data, 0, sizeof(xvid_plg_data_t));
+    data.version = XVID_VERSION;
+
+    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*/
+    }
+
+}
+
+
+
+
 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->mbParam.fincr;
-
+	
+    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 
@@ -606,27 +783,6 @@
 }
 
 
-static void
-set_stats(xvid_enc_stats_t * stats, RateControl * rc,
-		  const MBParam * pParam, const FRAMEINFO * frame)
-{
-	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;
-	}
-
-	RateControlUpdate(rc, frame->quant, frame->length, frame->coding_type==I_VOP );
-}
-
-
 
 /*****************************************************************************
  * IPB frame encoder entry point
@@ -641,8 +797,6 @@
  ****************************************************************************/
 
 
-/* XXX: dx50bvop broken! something todo with queue */
-
 int
 enc_encode(Encoder * pEnc,
 			   xvid_enc_frame_t * xFrame,
@@ -650,7 +804,6 @@
 {
 	xvid_enc_frame_t * frame;
 	int type;
-	uint16_t x, y;
 	Bitstream bs;
 
 	if (XVID_MAJOR(xFrame->version) != 1 || (stats && XVID_MAJOR(stats->version) != 1))	/* v1.x.x */
@@ -706,34 +859,31 @@
 
 
 	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-	 * bframe flush code
+	 * bframe flush code 
 	 * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
 
 repeat:
 
 	if (pEnc->flush_bframes)
 	{
-		if (pEnc->bframenum_head < pEnc->bframenum_tail)
-		{
+		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);
 
-			FrameCodeB(pEnc, pEnc->bframes[pEnc->bframenum_head], &bs);
-			set_stats(stats, &pEnc->rate_control, &pEnc->mbParam, pEnc->bframes[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);
+			}
 
+			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++;
 
-
 			goto done;
 		}
 
-		/* flush complete: reset counters */
-
-		pEnc->flush_bframes = 0;
-		pEnc->bframenum_head = pEnc->bframenum_tail = 0;
-
 		/* write an empty marker to the bitstream.
 	   
 		   for divx5 decoder compatibility, this marker must consist
@@ -741,7 +891,7 @@
 		   indentical to the future-referece frame.
 		*/
 
-		if ((pEnc->mbParam.global_flags & XVID_PACKED)) {
+		if ((pEnc->mbParam.global_flags & XVID_PACKED && pEnc->bframenum_tail > 0)) {
 			int tmp;
 			int bits;
 			
@@ -760,15 +910,19 @@
 
 			/* add the not-coded length to the reference frame size */
 			pEnc->current->length += (BitstreamPos(&bs) - bits) / 8;
-			set_stats(stats, &pEnc->rate_control, &pEnc->mbParam, pEnc->current);
-
-			// xFrame->out_flags |= XVID_PACKED_FIXUP?;
+            call_plugins(pEnc, pEnc->current, &pEnc->sOriginal, XVID_PLG_AFTER, 0, 0, stats);
 
+            /* flush complete: reset counters */
+    		pEnc->flush_bframes = 0;
+		    pEnc->bframenum_head = pEnc->bframenum_tail = 0;
 			goto done;
 
 		}
-	}
 
+        /* flush complete: reset counters */
+		pEnc->flush_bframes = 0;
+		pEnc->bframenum_head = pEnc->bframenum_tail = 0;
+	}
 
 	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 	 * dequeue frame from the encoding queue
@@ -778,19 +932,32 @@
 	{
 		if (xFrame->input.csp == XVID_CSP_NULL)	/* no futher input */
 		{
-			if (pEnc->bframenum_tail > 0)	/* are bframes */
+
+            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);
+            }
+
+            /* if the very last frame is to be b-vop, we must change it to a p-vop */
+            if (pEnc->bframenum_tail > 0)
 			{
+
 				SWAP(FRAMEINFO*, pEnc->current, pEnc->reference);
 				pEnc->bframenum_tail--;
 				SWAP(FRAMEINFO*, pEnc->current, pEnc->bframes[pEnc->bframenum_tail]);
 
-				/* XXX: convert B-VOP to P-VOP */
-				pEnc->current->quant *= 2;
+				/* convert B-VOP to P-VOP */
+                pEnc->current->quant = ((pEnc->current->quant*100) - pEnc->mbParam.bquant_offset) / pEnc->mbParam.bquant_ratio;
+
+                if ((pEnc->mbParam.plugin_flags & XVID_REQORIGINAL)) {
+		            image_copy(&pEnc->sOriginal, &pEnc->current->image,
+		                   pEnc->mbParam.edged_width, pEnc->mbParam.height);
+                }
 
 				FrameCodeP(pEnc, &bs, 1, 0);
+
 				goto done_flush;
 			}
-			
+
 			emms();
 			return XVID_ERR_END;	/* end of stream reached */
 		}
@@ -803,16 +970,16 @@
 	// 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_head = (pEnc->queue_head + 1) % (pEnc->mbParam.max_bframes+1);
 	pEnc->queue_size--;
 
 
 	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-	 * init pEnc->current field
+	 * init pEnc->current fields
 	 * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
 
-	emms();		/* float-point region */
-
+    
+    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;
@@ -824,18 +991,13 @@
 		    pEnc->mbParam.width, pEnc->mbParam.height, pEnc->mbParam.edged_width);
     }
 
-    if (xFrame->vop_flags & XVID_EXTRASTATS)
-    {	image_copy(&pEnc->sOriginal, &pEnc->current->image,
-		       pEnc->mbParam.edged_width, pEnc->mbParam.height);
-    }
-
+	emms();		/* float-point region */
 	if ((pEnc->current->vop_flags & XVID_LUMIMASKING)) {
-		int *temp_dquants =	(int *) xvid_malloc(pEnc->mbParam.mb_width *
-					pEnc->mbParam.mb_height * sizeof(int), CACHE_LINE);
+        unsigned int x, y;
 
 		pEnc->current->quant =
 			adaptive_quantization(pEnc->current->image.y,
-							  pEnc->mbParam.edged_width, temp_dquants,
+							  pEnc->mbParam.edged_width, pEnc->temp_dquants,
 							  pEnc->current->quant, pEnc->current->quant,
 							  2 * pEnc->current->quant,
 							  pEnc->mbParam.mb_width,
@@ -848,217 +1010,219 @@
 			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[pEnc->temp_dquants[OFFSET(x, y)] + 2];
 			}
 
 #undef OFFSET
 		}
 
-		xvid_free(temp_dquants);
 	}
+    emms();		/* END floating-point region */
 
-	if (frame->quant > 0)
-	{
-		pEnc->current->quant = frame->quant;
-		type = frame->type;
-	}
-	else
-	{
-		pEnc->current->quant = RateControlGetQ(&pEnc->rate_control, 0);
-		type = XVID_TYPE_AUTO;	//RateControlGetType(&pEnc->rate_control, ...);
-	}
+	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+	 * frame type & quant selection
+	 * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
 
-	emms();		/* END floating-point region */
+    call_plugins(pEnc, pEnc->current, NULL, XVID_PLG_BEFORE, &type, &pEnc->current->quant, stats);
 
+    if (frame->type > 0)
+   		type = frame->type;
 
-	if (type > 0) 	/* XVID_TYPE_?VOP */
-	{
+    if (frame->quant > 0)
+		pEnc->current->quant = frame->quant;
+
+    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))
-		{
+    } 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 (type == B_VOP && !(pEnc->current->vop_flags & XVID_DYNAMIC_BFRAMES)) {
+                type = P_VOP;   /* disable dynamic bframes */
+            }
 		}
 	}
+
+    /* bframes buffer overflow check */
+    if (type != I_VOP) {
+        if (pEnc->bframenum_tail >= pEnc->mbParam.max_bframes) {
+            type = P_VOP;
+        }else{
+            type = B_VOP;
+        }
+    }
+
 	inc_frame_num(pEnc);
 	pEnc->iFrameNum++;
 
-
 	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->m_framenum, pEnc->current->stamp, pEnc->iFrameNum);
+			"%i  st:%i  if:%i", pEnc->current->frame_num, pEnc->current->stamp, pEnc->iFrameNum);
 	}
 
 	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-	 * ivop/pvop/bvop selection
+	 * 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 == I_VOP) {
-
-		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 (type == B_VOP) {
 		if ((pEnc->current->vop_flags & XVID_DEBUG)) {
-			image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 200, "IVOP");
+			image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 200, "BVOP");
 		}
 
-		// when we reach an iframe in CLOSED_GOP mode, encode the last bframe as a xFrame
-		if ((pEnc->mbParam.global_flags & XVID_CLOSED_GOP) && pEnc->bframenum_tail > 0) {
+		if (frame->bquant < 1) {
+			pEnc->current->quant = ((((pEnc->reference->quant + pEnc->current->quant) * 
+				pEnc->mbParam.bquant_ratio) / 2) + pEnc->mbParam.bquant_offset)/100;
 
-			// 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);
-			image_swap(&pEnc->current->image, &pEnc->queue[pEnc->queue_head].image);
+		} else {
+			pEnc->current->quant = frame->bquant;
+		}
 
-			// grab the last frame from the bframe-queue
+		if (pEnc->current->quant < 1)
+			pEnc->current->quant = 1;
+		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",
+				pEnc->bframenum_head, pEnc->bframenum_tail,
+				pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size,pEnc->current->quant);
 
-			pEnc->bframenum_tail--;
-			SWAP(FRAMEINFO*, pEnc->current, pEnc->bframes[pEnc->bframenum_tail]);
+		/* 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);
 
-			if ((pEnc->current->vop_flags & XVID_DEBUG)) {
-				image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 100, "DX50 BVOP->PVOP");
-			}
+		pEnc->bframenum_tail++;
 
-			/* XXX: convert B-VOP to P-VOP */
-			pEnc->current->quant *= 2;
+		goto repeat;
+    }
 
-			FrameCodeP(pEnc, &bs, 1, 0);
-			
-		} else {
+    /* 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;
+    }
 
-			/* ---- update vol flags at IVOP ----------- */
-			pEnc->current->vol_flags = pEnc->mbParam.vol_flags = frame->vol_flags;
+	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+	 * closed-gop
+     * if the frame prior to an iframe is scheduled as a bframe, we must change it to a pframe
+     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
 
-            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 (type == I_VOP && (pEnc->mbParam.global_flags & XVID_CLOSED_GOP) && pEnc->bframenum_tail > 0) {
 
-            /* prevent vol/vop misuse */
+		// place this frame back on the encoding-queue (head)
+		// we will deal with it next time
+        dec_frame_num(pEnc);
+        pEnc->iFrameNum--;
 
-            if (!(pEnc->current->vol_flags & XVID_REDUCED_ENABLE))
-                pEnc->current->vop_flags &= ~XVID_REDUCED;
+        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);
 
-            if (!(pEnc->current->vol_flags & XVID_INTERLACING))
-                pEnc->current->vop_flags &= ~(XVID_TOPFIELDFIRST|XVID_ALTERNATESCAN);
+		// grab the last frame from the bframe-queue
 
-			/* ^^^------------------------ */
+		pEnc->bframenum_tail--;
+		SWAP(FRAMEINFO*, pEnc->current, pEnc->bframes[pEnc->bframenum_tail]);
 
-			FrameCodeI(pEnc, &bs);
-			xFrame->out_flags |= XVID_KEYFRAME;
+		if ((pEnc->current->vop_flags & XVID_DEBUG)) {
+			image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 100, "DX50 BVOP->PVOP");
 		}
 
-	} else if (((pEnc->current->vop_flags & XVID_DYNAMIC_BFRAMES) && type == P_VOP) || 
-				pEnc->bframenum_tail >= pEnc->mbParam.max_bframes) {
-		/*
-		 * This will be coded as a Predicted Frame
-		 */
+		/* 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;
+    }
+
+
+	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+	 * encode this frame as an i-vop
+     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
+
+	if (type == I_VOP) {
 
-		DPRINTF(DPRINTF_DEBUG,"*** xFrame bf: head=%i tail=%i   queue: head=%i tail=%i size=%i",
+		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, "PVOP");
+			image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 200, "IVOP");
 		}
 
-		FrameCodeP(pEnc, &bs, 1, 0);
 
-	} else {	/* type == B_VOP */
+		/* ---- update vol flags at IVOP ----------- */
+		pEnc->current->vol_flags = pEnc->mbParam.vol_flags = frame->vol_flags;
 
-		if ((pEnc->current->vop_flags & XVID_DEBUG)) {
-			image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 200, "BVOP");
+        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 (frame->bquant < 1) {
-			pEnc->current->quant = ((((pEnc->reference->quant + pEnc->current->quant) * 
-				pEnc->mbParam.bquant_ratio) / 2) + pEnc->mbParam.bquant_offset)/100;
+        /* prevent vol/vop misuse */
 
-		} else {
-			pEnc->current->quant = frame->bquant;
-		}
+        if (!(pEnc->current->vol_flags & XVID_REDUCED_ENABLE))
+            pEnc->current->vop_flags &= ~XVID_REDUCED;
 
-		if (pEnc->current->quant < 1)
-			pEnc->current->quant = 1;
-		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",
-				pEnc->bframenum_head, pEnc->bframenum_tail,
-				pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size,pEnc->current->quant);
+        if (!(pEnc->current->vol_flags & XVID_INTERLACING))
+            pEnc->current->vop_flags &= ~(XVID_TOPFIELDFIRST|XVID_ALTERNATESCAN);
 
-		/* 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);
+		/* ^^^------------------------ */
 
-		pEnc->bframenum_tail++;
+        if ((pEnc->mbParam.plugin_flags & XVID_REQORIGINAL)) {
+		    image_copy(&pEnc->sOriginal, &pEnc->current->image,
+		           pEnc->mbParam.edged_width, pEnc->mbParam.height);
+        }
 
-		goto repeat;
+		FrameCodeI(pEnc, &bs);
+		xFrame->out_flags |= XVID_KEYFRAME;
 
-    }
+	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+	 * encode this frame as an p-vop
+     * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
 
-	if (xFrame->vop_flags & XVID_EXTRASTATS)
-	{	stats->sse_y =
-			plane_sse( pEnc->sOriginal.y, pEnc->current->image.y,
-					   pEnc->mbParam.edged_width, pEnc->mbParam.width,
-					   pEnc->mbParam.height);
-
-		stats->sse_u =
-			plane_sse( pEnc->sOriginal.u, pEnc->current->image.u,
-					   pEnc->mbParam.edged_width/2, pEnc->mbParam.width/2,
-					   pEnc->mbParam.height/2);
-
-		stats->sse_v =
-			plane_sse( pEnc->sOriginal.v, pEnc->current->image.v,
-					   pEnc->mbParam.edged_width/2, pEnc->mbParam.width/2,
-					   pEnc->mbParam.height/2);		
-	}
+    } else { // (type == P_VOP || type == S_VOP)
 
-	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-	 * okay, on next enc_encode call we must flush bframes
+		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");
+		}
+
+        if ((pEnc->mbParam.plugin_flags & XVID_REQORIGINAL)) {
+		    image_copy(&pEnc->sOriginal, &pEnc->current->image,
+		           pEnc->mbParam.edged_width, pEnc->mbParam.height);
+        }
+
+		FrameCodeP(pEnc, &bs, 1, 0);
+    }
+
+	
+    /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+	 * on next enc_encode call we must flush bframes
 	 * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
 
 done_flush:
 
-#if 0
-	{
-		char tmp[100];
-		wsprintf(tmp,"\\frame%03i.pgm", pEnc->m_framenum);
-		image_dump_yuvpgm(&pEnc->current->image, pEnc->mbParam.edged_width,
-			pEnc->mbParam.width, pEnc->mbParam.height, tmp);
-	}
-#endif
+    pEnc->flush_bframes = 1;
 
-	/* packed_mode: repeat */
-	pEnc->flush_bframes = 1;
+	/* 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 ((pEnc->mbParam.global_flags & XVID_PACKED) || pEnc->mbParam.max_bframes == 0)
-	{
-		/* packed(and low_delay) encoding gives us graceful reorded-stats output */
-		set_stats(stats, &pEnc->rate_control, &pEnc->mbParam, pEnc->current);
-	}
-	else	
-	{
-		/* outherwise, output the previous frame */
-		/* XXX: for this to work, refernce must be valid for IVOPs too */
-		if (pEnc->current->stamp > 0)
-			set_stats(stats, &pEnc->rate_control, &pEnc->mbParam, pEnc->reference);
-		else
-			stats->type = XVID_TYPE_NOTHING;
+    /* 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);
 	}
 
 	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -1132,10 +1296,8 @@
 		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);
@@ -1701,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) ) {