--- encoder.c	2002/09/03 17:25:18	1.76
+++ encoder.c	2002/11/02 15:52:30	1.76.2.14
@@ -39,7 +39,7 @@
  *             MinChen <chenm001@163.com>
  *  14.04.2002 added FrameCodeB()
  *
- *  $Id: encoder.c,v 1.76 2002/09/03 17:25:18 chl Exp $
+ *  $Id: encoder.c,v 1.76.2.14 2002/11/02 15:52:30 chl Exp $
  *
  ****************************************************************************/
 
@@ -54,10 +54,8 @@
 #include "global.h"
 #include "utils/timer.h"
 #include "image/image.h"
-#ifdef BFRAMES
 #include "image/font.h"
 #include "motion/sad.h"
-#endif
 #include "motion/motion.h"
 #include "bitstream/cbp.h"
 #include "utils/mbfunctions.h"
@@ -70,9 +68,6 @@
 #include "quant/quant_matrix.h"
 #include "utils/mem_align.h"
 
-#ifdef _SMP
-#include "motion/smp_motion_est.h"
-#endif 
 /*****************************************************************************
  * Local macros
  ****************************************************************************/
@@ -94,12 +89,10 @@
 					  bool force_inter,
 					  bool vol_header);
 
-#ifdef BFRAMES
 static void FrameCodeB(Encoder * pEnc,
 					   FRAMEINFO * frame,
 					   Bitstream * bs,
 					   uint32_t * pBits);
-#endif
 
 /*****************************************************************************
  * Local data
@@ -238,10 +231,6 @@
 
 	pEnc->mbParam.m_quant_type = H263_QUANT;
 
-#ifdef _SMP
-	pEnc->mbParam.num_threads = MIN(pParam->num_threads, MAXNUMTHREADS);
-#endif
-
 	pEnc->sStat.fMvPrevSigma = -1;
 
 	/* Fill rate control parameters */
@@ -276,11 +265,11 @@
 #ifdef _DEBUG_PSNR
 	image_null(&pEnc->sOriginal);
 #endif
-#ifdef BFRAMES
+
 	image_null(&pEnc->f_refh);
 	image_null(&pEnc->f_refv);
 	image_null(&pEnc->f_refhv);
-#endif
+
 	image_null(&pEnc->current->image);
 	image_null(&pEnc->reference->image);
 	image_null(&pEnc->vInterH);
@@ -295,7 +284,7 @@
 		 pEnc->mbParam.edged_height) < 0)
 		goto xvid_err_memory3;
 #endif
-#ifdef BFRAMES
+
 	if (image_create
 		(&pEnc->f_refh, pEnc->mbParam.edged_width,
 		 pEnc->mbParam.edged_height) < 0)
@@ -308,7 +297,7 @@
 		(&pEnc->f_refhv, pEnc->mbParam.edged_width,
 		 pEnc->mbParam.edged_height) < 0)
 		goto xvid_err_memory3;
-#endif
+
 	if (image_create
 		(&pEnc->current->image, pEnc->mbParam.edged_width,
 		 pEnc->mbParam.edged_height) < 0)
@@ -341,7 +330,6 @@
 
 
 	/* B Frames specific init */
-#ifdef BFRAMES
 
 	pEnc->global = pParam->global;
 	pEnc->mbParam.max_bframes = pParam->max_bframes;
@@ -420,13 +408,11 @@
 	pEnc->queue_tail = 0;
 	pEnc->queue_size = 0;
 
+	pEnc->mbParam.m_stamp = 0;
 
-	pEnc->mbParam.m_seconds = 0;
-	pEnc->mbParam.m_ticks = 0;
 	pEnc->m_framenum = 0;
-	pEnc->last_pframe = 0;
-	pEnc->last_sync = 0;
-#endif
+	pEnc->current->stamp = 0;
+	pEnc->reference->stamp = 0;
 
 	pParam->handle = (void *) pEnc;
 
@@ -445,7 +431,7 @@
 	/*
 	 * We handle all XVID_ERR_MEMORY here, this makes the code lighter
 	 */
-#ifdef BFRAMES
+
   xvid_err_memory5:
 
 
@@ -479,22 +465,18 @@
 		xvid_free(pEnc->bframes);
 	}
 
-#endif
-
   xvid_err_memory3:
 #ifdef _DEBUG_PSNR
 	image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width,
 				  pEnc->mbParam.edged_height);
 #endif
 
-#ifdef BFRAMES
 	image_destroy(&pEnc->f_refh, pEnc->mbParam.edged_width,
 				  pEnc->mbParam.edged_height);
 	image_destroy(&pEnc->f_refv, pEnc->mbParam.edged_width,
 				  pEnc->mbParam.edged_height);
 	image_destroy(&pEnc->f_refhv, pEnc->mbParam.edged_width,
 				  pEnc->mbParam.edged_height);
-#endif
 
 	image_destroy(&pEnc->current->image, pEnc->mbParam.edged_width,
 				  pEnc->mbParam.edged_height);
@@ -539,14 +521,11 @@
 int
 encoder_destroy(Encoder * pEnc)
 {
-#ifdef BFRAMES
 	int i;
-#endif
 	
 	ENC_CHECK(pEnc);
 
 	/* B Frames specific */
-#ifdef BFRAMES
 	if (pEnc->mbParam.max_bframes > 0) {
 
 		for (i = 0; i < pEnc->mbParam.max_bframes; i++) {
@@ -576,7 +555,6 @@
 		xvid_free(pEnc->bframes);
 	
 	}
-#endif
 
 	/* All images, reference, current etc ... */
 
@@ -594,14 +572,14 @@
 				  pEnc->mbParam.edged_height);
 	image_destroy(&pEnc->vInterHVf, pEnc->mbParam.edged_width,
 				  pEnc->mbParam.edged_height);
-#ifdef BFRAMES
+
 	image_destroy(&pEnc->f_refh, pEnc->mbParam.edged_width,
 				  pEnc->mbParam.edged_height);
 	image_destroy(&pEnc->f_refv, pEnc->mbParam.edged_width,
 				  pEnc->mbParam.edged_height);
 	image_destroy(&pEnc->f_refhv, pEnc->mbParam.edged_width,
 				  pEnc->mbParam.edged_height);
-#endif
+
 #ifdef _DEBUG_PSNR
 	image_destroy(&pEnc->sOriginal, pEnc->mbParam.edged_width,
 				  pEnc->mbParam.edged_height);
@@ -621,31 +599,15 @@
 }
 
 
-void inc_frame_num(Encoder * pEnc)
+static __inline void inc_frame_num(Encoder * pEnc)
 {
-	pEnc->mbParam.m_ticks += pEnc->mbParam.fincr;
-
-#ifdef BFRAMES
-	pEnc->mbParam.m_ticks = pEnc->mbParam.m_ticks % pEnc->mbParam.fbase;
-	if (pEnc->mbParam.m_ticks < pEnc->last_sync) 
-		pEnc->mbParam.m_seconds = 1;		// more than 1 second since last I or P is not supported. 
-	else
-		pEnc->mbParam.m_seconds = 0;
-
-	if (pEnc->current->coding_type != B_VOP)
-		pEnc->last_sync = pEnc->mbParam.m_ticks;
-#else
-
-	pEnc->mbParam.m_seconds = pEnc->mbParam.m_ticks / pEnc->mbParam.fbase;
-	pEnc->mbParam.m_ticks = pEnc->mbParam.m_ticks % pEnc->mbParam.fbase;
-	
-#endif
-
+	pEnc->current->stamp = pEnc->mbParam.m_stamp;	// first frame is zero
+	pEnc->mbParam.m_stamp += pEnc->mbParam.fincr;
 }
 
 
-#ifdef BFRAMES
-void queue_image(Encoder * pEnc, XVID_ENC_FRAME * pFrame)
+static __inline void
+queue_image(Encoder * pEnc, XVID_ENC_FRAME * pFrame)
 {
 	if (pEnc->queue_size >= pEnc->mbParam.max_bframes)
 	{
@@ -668,10 +630,30 @@
 	pEnc->queue_size++;
 	pEnc->queue_tail =  (pEnc->queue_tail + 1) % pEnc->mbParam.max_bframes;
 }
-#endif
+
+static __inline void 
+set_timecodes(FRAMEINFO* pCur,FRAMEINFO *pRef, int32_t time_base)
+{
+
+		pCur->ticks = (int32_t)pCur->stamp % time_base;
+		pCur->seconds =  ((int32_t)pCur->stamp / time_base)	- ((int32_t)pRef->stamp / time_base) ;
+		
+		//HEAVY DEBUG OUTPUT	remove when timecodes prove to be stable 
+
+/*		fprintf(stderr,"WriteVop:   %d - %d \n",
+			((int32_t)pCur->stamp / time_base), ((int32_t)pRef->stamp / time_base));
+		fprintf(stderr,"set_timecodes: VOP %1d   stamp=%lld ref_stamp=%lld  base=%d\n",
+			pCur->coding_type, pCur->stamp, pRef->stamp, time_base);
+		fprintf(stderr,"set_timecodes: VOP %1d   seconds=%d   ticks=%d   (ref-sec=%d  ref-tick=%d)\n",
+			pCur->coding_type, pCur->seconds, pCur->ticks, pRef->seconds, pRef->ticks);
+
+*/
+}
+
+
+
 
 
-#ifdef BFRAMES
 /*****************************************************************************
  * IPB frame encoder entry point
  *
@@ -688,7 +670,7 @@
 {
 	uint16_t x, y;
 	Bitstream bs;
-	uint32_t bits;
+	uint32_t bits, mode;
 
 	int input_valid = 1;
 
@@ -760,15 +742,26 @@
 	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->global & XVID_GLOBAL_PACKED)) {
+			int tmp;
 			
 			DPRINTF(DPRINTF_DEBUG,"*** EMPTY bf: head=%i tail=%i   queue: head=%i tail=%i size=%i",
 				pEnc->bframenum_head, pEnc->bframenum_tail,
 				pEnc->queue_head, pEnc->queue_tail, pEnc->queue_size);
 
-			BitstreamWriteVopHeader(&bs, &pEnc->mbParam, pEnc->current, 0);
 			BitstreamPad(&bs);
-			BitstreamPutBits(&bs, 0x7f, 8);
+
+			tmp = pEnc->current->seconds;
+			pEnc->current->seconds = 0; /* force time_base = 0 */
+			BitstreamWriteVopHeader(&bs, &pEnc->mbParam, pEnc->current, 0);
+			pEnc->current->seconds = tmp;
 
 			pFrame->length = BitstreamLength(&bs);
 			pFrame->intra = 0;
@@ -830,21 +823,20 @@
 		pEnc->queue_head =  (pEnc->queue_head + 1) % pEnc->mbParam.max_bframes;
 		pEnc->queue_size--;
 
-	} else if (BitstreamPos(&bs) == 0) {
+	} else {
 
-		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);
+		/* if nothing was encoded, write an 'ignore this frame' flag
+		   to the bitstream */
 
-		pFrame->intra = 0;
+		if (BitstreamPos(&bs) == 0) {
 
-		BitstreamWriteVopHeader(&bs, &pEnc->mbParam, pEnc->current, 0); // write N_VOP
-		BitstreamPad(&bs);
-		pFrame->length = BitstreamLength(&bs);
-		
-		return XVID_ERR_OK;
+			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);
 
-	} else {
+			BitstreamPutBits(&bs, 0x7f, 8);
+			pFrame->intra = 0;
+		}
 
 		pFrame->length = BitstreamLength(&bs);
 		return XVID_ERR_OK;
@@ -852,11 +844,6 @@
 
 	pEnc->flush_bframes = 0;
 
-	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
-	 * Well there was a separation here so i put it in ANSI C
-	 * comment style :-)
-	 * %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% */
-
 	emms();
 
 	// only inc frame num, adapt quant, etc. if we havent seen it before
@@ -880,9 +867,6 @@
 		pEnc->current->fcode = pEnc->mbParam.m_fcode;
 		pEnc->current->bcode = pEnc->mbParam.m_fcode;
 
-		pEnc->current->seconds = pEnc->mbParam.m_seconds;
-		pEnc->current->ticks = pEnc->mbParam.m_ticks;
-
 		inc_frame_num(pEnc);
 
 #ifdef _DEBUG_PSNR
@@ -894,7 +878,7 @@
 
 		if ((pEnc->global & XVID_GLOBAL_DEBUG)) {
 			image_printf(&pEnc->current->image, pEnc->mbParam.edged_width, pEnc->mbParam.height, 5, 5, 
-				"%i  if:%i  st:%i:%i", pEnc->m_framenum++, pEnc->iFrameNum, pEnc->current->seconds, pEnc->current->ticks);
+				"%i  if:%i  st:%i", pEnc->m_framenum++, pEnc->iFrameNum, pEnc->current->stamp);
 		}
 
 	/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -941,9 +925,12 @@
 	if (pEnc->iFrameNum == 0 || pFrame->intra == 1 || pEnc->bframenum_dx50bvop >= 0 ||
 		(pFrame->intra < 0 && pEnc->iMaxKeyInterval > 0 &&
 		 pEnc->iFrameNum >= pEnc->iMaxKeyInterval)
-		|| image_mad(&pEnc->reference->image, &pEnc->current->image,
+		|| /*image_mad(&pEnc->reference->image, &pEnc->current->image,
 					 pEnc->mbParam.edged_width, pEnc->mbParam.width,
-					 pEnc->mbParam.height) > 30) {
+					 pEnc->mbParam.height) > 30) {*/
+			2 == (mode = MEanalysis(&pEnc->reference->image, &pEnc->current->image,
+					 &pEnc->mbParam, pEnc->current->mbs, pEnc->current->fcode))) {
+
 		/*
 		 * This will be coded as an Intra Frame
 		 */
@@ -982,7 +969,7 @@
 		pEnc->flush_bframes = 1;
 
 		if ((pEnc->global & XVID_GLOBAL_PACKED) && pEnc->bframenum_tail > 0) {
-			BitstreamPad(&bs);
+			BitstreamPadAlways(&bs);
 			input_valid = 0;
 			goto ipvop_loop;
 		}
@@ -991,7 +978,7 @@
 		 * NB : sequences like "IIBB" decode fine with msfdam but,
 		 *      go screwy with divx 5.00
 		 */
-	} else if (pEnc->bframenum_tail >= pEnc->mbParam.max_bframes) {
+	} else if (pEnc->bframenum_tail >= pEnc->mbParam.max_bframes || mode != 0) {
 		/*
 		 * This will be coded as a Predicted Frame
 		 */
@@ -1009,7 +996,7 @@
 		pEnc->flush_bframes = 1;
 
 		if ((pEnc->global & XVID_GLOBAL_PACKED)) {
-			BitstreamPad(&bs);
+			BitstreamPadAlways(&bs);
 			input_valid = 0;
 			goto ipvop_loop;
 		}
@@ -1086,15 +1073,12 @@
 						  pFrame->length, pFrame->intra);
 	}
 
-
 	stop_global_timer();
 	write_timer();
 
 	return XVID_ERR_OK;
 }
 
-#endif
-
 
 
 /*****************************************************************************
@@ -1132,10 +1116,17 @@
 
 	pEnc->current->global_flags = pFrame->general;
 	pEnc->current->motion_flags = pFrame->motion;
-	pEnc->current->seconds = pEnc->mbParam.m_seconds;
-	pEnc->current->ticks = pEnc->mbParam.m_ticks;
 	pEnc->mbParam.hint = &pFrame->hint;
 
+	inc_frame_num(pEnc);
+
+	/* 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,
@@ -1158,6 +1149,11 @@
 		pEnc->current->quant = pFrame->quant;
 	}
 
+	if ((pEnc->current->global_flags & XVID_QUARTERPEL))
+		pEnc->mbParam.m_quarterpel = 1;
+	else
+		pEnc->mbParam.m_quarterpel = 0;
+
 	if ((pEnc->current->global_flags & XVID_LUMIMASKING)) {
 		int *temp_dquants =
 			(int *) xvid_malloc(pEnc->mbParam.mb_width *
@@ -1263,7 +1259,6 @@
 	DEBUG(temp);
 #endif
 
-	inc_frame_num(pEnc);
 	pEnc->iFrameNum++;
 
 	stop_global_timer();
@@ -1512,15 +1507,20 @@
 	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);
-#ifdef BFRAMES
+
 #define DIVX501B481P "DivX501b481p"
 	if ((pEnc->global & XVID_GLOBAL_PACKED)) {
 		BitstreamWriteUserData(bs, DIVX501B481P, strlen(DIVX501B481P));
 	}
-#endif
+
+#define XVID_ID "XviD" XVID_BS_VERSION
+	BitstreamWriteUserData(bs, XVID_ID, strlen(XVID_ID));
+
+	set_timecodes(pEnc->current,pEnc->reference,pEnc->mbParam.fbase);
 	BitstreamWriteVopHeader(bs, &pEnc->mbParam, pEnc->current, 1);
 
 	*pBits = BitstreamPos(bs);
@@ -1570,7 +1570,7 @@
 
 
 #define INTRA_THRESHOLD 0.5
-#define BFRAME_SKIP_THRESHHOLD 16
+#define BFRAME_SKIP_THRESHHOLD 30
 
 static int
 FrameCodeP(Encoder * pEnc,
@@ -1587,19 +1587,19 @@
 	int iLimit;
 	int x, y, k;
 	int iSearchRange;
-	int bIntra;
+	int bIntra, skip_possible;
 	
 	/* IMAGE *pCurrent = &pEnc->current->image; */
 	IMAGE *pRef = &pEnc->reference->image;
 
 	start_timer();
 	image_setedges(pRef, pEnc->mbParam.edged_width, pEnc->mbParam.edged_height,
-				   pEnc->mbParam.width, pEnc->mbParam.height,
-				   pEnc->current->global_flags & XVID_INTERLACING);
+				   pEnc->mbParam.width, pEnc->mbParam.height);
 	stop_edges_timer();
 
 	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->fcode = pEnc->mbParam.m_fcode;
 
 	if (!force_inter)
@@ -1614,48 +1614,52 @@
 		image_interpolate(pRef, &pEnc->vInterH, &pEnc->vInterV,
 						  &pEnc->vInterHV, pEnc->mbParam.edged_width,
 						  pEnc->mbParam.edged_height,
+						  pEnc->mbParam.m_quarterpel,
 						  pEnc->current->rounding_type);
 		stop_inter_timer();
 	}
 
+	if (pEnc->current->global_flags & XVID_GMC) {
+		printf("Global Motion = %d %d quarterpel=%d\n", pEnc->current->GMC_MV.x, pEnc->current->GMC_MV.y,pEnc->current->quarterpel);
+		pEnc->current->coding_type = S_VOP;
+	} else
+		pEnc->current->coding_type = P_VOP;
+	
 	start_timer();
 	if (pEnc->current->global_flags & XVID_HINTEDME_SET) {
 		HintedMESet(pEnc, &bIntra);
+	if (bIntra == 0) {
+			pEnc->current->fcode = FindFcode(&pEnc->mbParam, pEnc->current);
+			MotionEstimationHinted(&pEnc->mbParam, pEnc->current, pEnc->reference,
+											&pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV);
+		}
+
 	} else {
 
-#ifdef _SMP
-	if (pEnc->mbParam.num_threads > 1)
-		bIntra =
-			SMP_MotionEstimation(&pEnc->mbParam, pEnc->current, pEnc->reference,
-						 &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV,
-						 iLimit);
-	else
-#endif
 		bIntra =
 			MotionEstimation(&pEnc->mbParam, pEnc->current, pEnc->reference,
                          &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV,
                          iLimit);
-			
 	}
 	stop_motion_timer();
 
-	if (bIntra == 1) {
-		return FrameCodeI(pEnc, bs, pBits);
-	}
+	if (bIntra == 1) return FrameCodeI(pEnc, bs, pBits);
+
+	if ( (pEnc->current->GMC_MV.x == 0) && (pEnc->current->GMC_MV.y == 0) )
+			pEnc->current->coding_type = P_VOP;		/* no global motion -> no GMC */
 
-	pEnc->current->coding_type = P_VOP;
 
 	if (vol_header)
 		BitstreamWriteVolHeader(bs, &pEnc->mbParam, pEnc->current);
+		
 
+	set_timecodes(pEnc->current,pEnc->reference,pEnc->mbParam.fbase);
 	BitstreamWriteVopHeader(bs, &pEnc->mbParam, pEnc->current, 1);
 
 	*pBits = BitstreamPos(bs);
 
-	pEnc->sStat.iTextBits = 0;
-	pEnc->sStat.iMvSum = 0;
-	pEnc->sStat.iMvCount = 0;
-	pEnc->sStat.kblks = pEnc->sStat.mblks = pEnc->sStat.ublks = 0;
+	pEnc->sStat.iTextBits = pEnc->sStat.iMvSum = pEnc->sStat.iMvCount = 
+		pEnc->sStat.kblks = pEnc->sStat.mblks = pEnc->sStat.ublks = 0;
 
 	for (y = 0; y < pEnc->mbParam.mb_height; y++) {
 		for (x = 0; x < pEnc->mbParam.mb_width; x++) {
@@ -1672,6 +1676,7 @@
 									 dct_codes, pEnc->mbParam.width,
 									 pEnc->mbParam.height,
 									 pEnc->mbParam.edged_width,
+									 pEnc->mbParam.m_quarterpel,
 									 pEnc->current->rounding_type);
 				stop_comp_timer();
 
@@ -1689,9 +1694,10 @@
 
 				pMB->field_pred = 0;
 
-				pMB->cbp =
-					MBTransQuantInter(&pEnc->mbParam, pEnc->current, pMB, x, y,
-									  dct_codes, qcoeff);
+				if (pMB->mode != MODE_NOT_CODED)
+					pMB->cbp =
+						MBTransQuantInter(&pEnc->mbParam, pEnc->current, pMB, x, y,
+										  dct_codes, qcoeff);
 			} else {
 				CodeIntraMB(pEnc, pMB);
 				MBTransQuantIntra(&pEnc->mbParam, pEnc->current, pMB, x, y,
@@ -1716,43 +1722,57 @@
 
 			/* Finished processing the MB, now check if to CODE or SKIP */
 
-			if (pMB->cbp == 0 && pMB->mode == MODE_INTER && pMB->mvs[0].x == 0 &&
-				pMB->mvs[0].y == 0) {
+			skip_possible = (pMB->cbp == 0) & (pMB->mode == MODE_INTER) &
+							(pMB->dquant == NO_CHANGE);
 
-/* This is a candidate for SKIPping, but check intermediate B-frames first */
+			if(pEnc->mbParam.m_quarterpel)
+			{	skip_possible &= (pMB->qmvs[0].x == pEnc->current->GMC_MV.x) & (pMB->qmvs[0].y == pEnc->current->GMC_MV.y);
+			}
+			else
+			{	skip_possible &= (pMB->mvs[0].x == pEnc->current->GMC_MV.x) & (pMB->mvs[0].y == pEnc->current->GMC_MV.y);
+			}
+			
+			if ( (pMB->mode == MODE_NOT_CODED) || (skip_possible)) {
 
-#ifdef BFRAMES
-				int iSAD=BFRAME_SKIP_THRESHHOLD;
-				int bSkip=1;
-				
-				for (k=pEnc->bframenum_head; k< pEnc->bframenum_tail; k++)
-				{		
-					iSAD = sad16(pEnc->reference->image.y + 16*y*pEnc->mbParam.edged_width + 16*x,
-								pEnc->bframes[k]->image.y + 16*y*pEnc->mbParam.edged_width + 16*x,
+/* This is a candidate for SKIPping, but for P-VOPs check intermediate B-frames first */
+				int bSkip = 1; 
+
+				if (pEnc->current->coding_type == P_VOP)	/* special rule for P-VOP's SKIP */
+					for (k=pEnc->bframenum_head; k< pEnc->bframenum_tail; k++)
+					{
+						int iSAD;
+						iSAD = sad16(pEnc->reference->image.y + 16*y*pEnc->mbParam.edged_width + 16*x,
+									pEnc->bframes[k]->image.y + 16*y*pEnc->mbParam.edged_width + 16*x,
 								pEnc->mbParam.edged_width,BFRAME_SKIP_THRESHHOLD);
-					if (iSAD >= BFRAME_SKIP_THRESHHOLD)
-					{	bSkip = 0; 
-						break;
+						if (iSAD >= BFRAME_SKIP_THRESHHOLD * pMB->quant)
+						{	bSkip = 0; 
+							break;
+						}
 					}
-				}
-				if (!bSkip) 
-				{	
-					if (pEnc->current->global_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 (!bSkip)
+				{
+					VECTOR predMV;
+					if(pEnc->mbParam.m_quarterpel) {
+						predMV = get_qpmv2(pEnc->current->mbs, pEnc->mbParam.mb_width, 0, x, y, 0);
+						pMB->pmvs[0].x = pMB->qmvs[0].x - predMV.x;  /* with GMC, qmvs doesn't have to be (0,0)! */
+						pMB->pmvs[0].y = pMB->qmvs[0].y - predMV.y; 
 					}
+					else {
+						predMV = get_pmv2(pEnc->current->mbs, pEnc->mbParam.mb_width, 0, x, y, 0);
+						pMB->pmvs[0].x = pMB->mvs[0].x - predMV.x; /* with GMC, mvs doesn't have to be (0,0)! */
+						pMB->pmvs[0].y = pMB->mvs[0].y - predMV.y; 
+					}
+					pMB->mode = MODE_INTER;
+					pMB->cbp = 0;
 					MBCoding(pEnc->current, pMB, qcoeff, bs, &pEnc->sStat);
-					pMB->cbp = 0x80;		/* trick! so cbp!=0, but still nothing is written to bs */
 				}
 				else 
+				{
+					pMB->mode = MODE_NOT_CODED;
 					MBSkip(bs);
-
-#else
-					MBSkip(bs);	/* without B-frames, no precautions are needed */
-
-#endif
-
+				}
+			
 			} else {
 				if (pEnc->current->global_flags & XVID_GREYSCALE)
 				{	pMB->cbp &= 0x3C;		/* keep only bits 5-2 */
@@ -1780,14 +1800,14 @@
 	iSearchRange = 1 << (3 + pEnc->mbParam.m_fcode);
 
 	if ((fSigma > iSearchRange / 3)
-		&& (pEnc->mbParam.m_fcode <= 3))	// maximum search range 128
+		&& (pEnc->mbParam.m_fcode <= (3 + pEnc->mbParam.m_quarterpel)))	// maximum search range 128
 	{
 		pEnc->mbParam.m_fcode++;
 		iSearchRange *= 2;
 	} else if ((fSigma < iSearchRange / 6)
 			   && (pEnc->sStat.fMvPrevSigma >= 0)
 			   && (pEnc->sStat.fMvPrevSigma < iSearchRange / 6)
-			   && (pEnc->mbParam.m_fcode >= 2))	// minimum search range 16
+			&& (pEnc->mbParam.m_fcode >= (2 + pEnc->mbParam.m_quarterpel)))	// minimum search range 16
 	{
 		pEnc->mbParam.m_fcode--;
 		iSearchRange /= 2;
@@ -1795,7 +1815,7 @@
 
 	pEnc->sStat.fMvPrevSigma = fSigma;
 
-#ifdef BFRAMES
+#ifdef FRAMEDROP
 	/* frame drop code */
 	// DPRINTF(DPRINTF_DEBUG, "kmu %i %i %i", pEnc->sStat.kblks, pEnc->sStat.mblks, pEnc->sStat.ublks);
 	if (pEnc->sStat.kblks + pEnc->sStat.mblks <
@@ -1805,12 +1825,15 @@
 		pEnc->sStat.ublks = pEnc->mbParam.mb_width * pEnc->mbParam.mb_height;
 
 		BitstreamReset(bs);
+
+		set_timecodes(pEnc->current,pEnc->reference,pEnc->mbParam.fbase);
 		BitstreamWriteVopHeader(bs, &pEnc->mbParam, pEnc->current, 0);
 
 		// copy reference frame details into the current frame
 		pEnc->current->quant = pEnc->reference->quant;
 		pEnc->current->motion_flags = pEnc->reference->motion_flags;
 		pEnc->current->rounding_type = pEnc->reference->rounding_type;
+	  	pEnc->current->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);
@@ -1821,18 +1844,11 @@
 
 	*pBits = BitstreamPos(bs) - *pBits;
 
-#ifdef BFRAMES
-	pEnc->time_pp = ((int32_t)pEnc->mbParam.fbase - (int32_t)pEnc->last_pframe + (int32_t)pEnc->current->ticks) %
-			(int32_t)pEnc->mbParam.fbase;
-	pEnc->last_pframe = pEnc->current->ticks;
-#endif
-
 	return 0;					// inter
 }
 
 
-#ifdef BFRAMES
-static void
+static __inline void
 FrameCodeB(Encoder * pEnc,
 		   FRAMEINFO * frame,
 		   Bitstream * bs,
@@ -1841,8 +1857,6 @@
 	int16_t dct_codes[6 * 64];
 	int16_t qcoeff[6 * 64];
 	uint32_t x, y;
-	VECTOR forward;
-	VECTOR backward;
 
 	IMAGE *f_ref = &pEnc->reference->image;
 	IMAGE *b_ref = &pEnc->current->image;
@@ -1859,33 +1873,34 @@
 	}
 #endif
 
+  	frame->quarterpel =  pEnc->mbParam.m_quarterpel;
+
 	// forward 
 	image_setedges(f_ref, pEnc->mbParam.edged_width,
 				   pEnc->mbParam.edged_height, pEnc->mbParam.width,
-				   pEnc->mbParam.height,
-				   frame->global_flags & XVID_INTERLACING);
+				   pEnc->mbParam.height);
 	start_timer();
 	image_interpolate(f_ref, &pEnc->f_refh, &pEnc->f_refv, &pEnc->f_refhv,
 					  pEnc->mbParam.edged_width, pEnc->mbParam.edged_height,
-					  0);
+					  pEnc->mbParam.m_quarterpel, 0);
 	stop_inter_timer();
 
 	// backward
 	image_setedges(b_ref, pEnc->mbParam.edged_width,
 				   pEnc->mbParam.edged_height, pEnc->mbParam.width,
-				   pEnc->mbParam.height,
-				   frame->global_flags & XVID_INTERLACING);
+				   pEnc->mbParam.height);
 	start_timer();
 	image_interpolate(b_ref, &pEnc->vInterH, &pEnc->vInterV, &pEnc->vInterHV,
 					  pEnc->mbParam.edged_width, pEnc->mbParam.edged_height,
-					  0);
+					  pEnc->mbParam.m_quarterpel, 0);
 	stop_inter_timer();
 
 	start_timer();
+
 	MotionEstimationBVOP(&pEnc->mbParam, frame, 
-		((int32_t)pEnc->mbParam.fbase + pEnc->last_pframe - frame->ticks) % pEnc->mbParam.fbase,
-						pEnc->time_pp, 
-						pEnc->reference->mbs, f_ref,
+		((int32_t)(pEnc->current->stamp - frame->stamp)),				// time_bp 
+		((int32_t)(pEnc->current->stamp - pEnc->reference->stamp)), 	// time_pp
+			pEnc->reference->mbs, f_ref,
 						 &pEnc->f_refh, &pEnc->f_refv, &pEnc->f_refhv,
 						 pEnc->current->mbs, b_ref, &pEnc->vInterH,
 						 &pEnc->vInterV, &pEnc->vInterHV);
@@ -1899,6 +1914,8 @@
 	   } */
 
 	frame->coding_type = B_VOP;
+
+	set_timecodes(frame, pEnc->reference,pEnc->mbParam.fbase);
 	BitstreamWriteVopHeader(bs, &pEnc->mbParam, frame, 1);
 
 	*pBits = BitstreamPos(bs);
@@ -1910,71 +1927,41 @@
 
 
 	for (y = 0; y < pEnc->mbParam.mb_height; y++) {
-		// reset prediction
-
-		forward.x = 0;
-		forward.y = 0;
-		backward.x = 0;
-		backward.y = 0;
-
 		for (x = 0; x < pEnc->mbParam.mb_width; x++) {
-			MACROBLOCK *f_mb =
-				&pEnc->reference->mbs[x + y * pEnc->mbParam.mb_width];
-			MACROBLOCK *b_mb =
-				&pEnc->current->mbs[x + y * pEnc->mbParam.mb_width];
-			MACROBLOCK *mb = &frame->mbs[x + y * pEnc->mbParam.mb_width];
+			MACROBLOCK * const mb = &frame->mbs[x + y * pEnc->mbParam.mb_width];
+			int direction = pEnc->global & XVID_ALTERNATESCAN ? 2 : 0;
 
 			// decoder ignores mb when refence block is INTER(0,0), CBP=0 
 			if (mb->mode == MODE_NOT_CODED) {
-				mb->mvs[0].x = 0;
-				mb->mvs[0].y = 0;
-
-				mb->cbp = 0;
-#ifdef BFRAMES_DEC_DEBUG
-	BFRAME_DEBUG
-#endif
+				//mb->mvs[0].x = mb->mvs[0].y = mb->cbp = 0;
 				continue;
 			}
 
-			MBMotionCompensationBVOP(&pEnc->mbParam, mb, x, y, &frame->image,
+			if (mb->mode != MODE_DIRECT_NONE_MV) {
+				MBMotionCompensationBVOP(&pEnc->mbParam, mb, x, y, &frame->image,
 									 f_ref, &pEnc->f_refh, &pEnc->f_refv,
 									 &pEnc->f_refhv, b_ref, &pEnc->vInterH,
 									 &pEnc->vInterV, &pEnc->vInterHV,
 									 dct_codes);
 
-			mb->quant = frame->quant;
-			mb->cbp =
-				MBTransQuantInterBVOP(&pEnc->mbParam, frame, mb, dct_codes, qcoeff);
-			//mb->cbp = MBTransQuantBVOP(&pEnc->mbParam, x, y, dct_codes, qcoeff, &frame->image, frame->quant);
-
-			if ( (mb->mode == MODE_DIRECT) && (mb->cbp == 0)
-				&& (mb->deltamv.x == 0) && (mb->deltamv.y == 0) ) {
-				mb->mode = MODE_DIRECT_NONE_MV;	// skipped
-			}
-
-/* update predictors for forward and backward vectors */
-			if (mb->mode == MODE_INTERPOLATE || mb->mode == MODE_FORWARD) {
-				mb->pmvs[0].x = mb->mvs[0].x - forward.x;
-				mb->pmvs[0].y = mb->mvs[0].y - forward.y;
-				forward.x = mb->mvs[0].x;
-				forward.y = mb->mvs[0].y;
-			}
+				if (mb->mode == MODE_DIRECT_NO4V) mb->mode = MODE_DIRECT;
+				mb->quant = frame->quant;
+			
+				mb->cbp =
+					MBTransQuantInterBVOP(&pEnc->mbParam, frame, mb, dct_codes, qcoeff);
 
-			if (mb->mode == MODE_INTERPOLATE || mb->mode == MODE_BACKWARD) {
-				mb->b_pmvs[0].x = mb->b_mvs[0].x - backward.x;
-				mb->b_pmvs[0].y = mb->b_mvs[0].y - backward.y;
-				backward.x = mb->b_mvs[0].x;
-				backward.y = mb->b_mvs[0].y;
+				if ( (mb->mode == MODE_DIRECT) && (mb->cbp == 0)
+					&& (mb->pmvs[3].x == 0) && (mb->pmvs[3].y == 0) ) {
+					mb->mode = MODE_DIRECT_NONE_MV;	// skipped
+				}
 			}
-			
-//			DPRINTF("%05i : [%i %i] M=%i CBP=%i MVS=%i,%i forward=%i,%i", pEnc->m_framenum, x, y, mb->mode, mb->cbp, mb->mvs[0].x, mb->mvs[0].y, forward.x, forward.y);
 
 #ifdef BFRAMES_DEC_DEBUG
 	BFRAME_DEBUG
 #endif
 			start_timer();
 			MBCodingBVOP(mb, qcoeff, frame->fcode, frame->bcode, bs,
-						 &pEnc->sStat);
+						 &pEnc->sStat, direction);
 			stop_coding_timer();
 		}
 	}
@@ -1993,7 +1980,6 @@
 	}
 #endif
 }
-#endif
 
 
 /*	in case internal output is needed somewhere... */