--- mbtransquant.c	2003/11/23 17:01:08	1.21.2.19
+++ mbtransquant.c	2004/12/19 12:49:05	1.27
@@ -21,7 +21,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: mbtransquant.c,v 1.21.2.19 2003/11/23 17:01:08 edgomez Exp $
+ * $Id: mbtransquant.c,v 1.27 2004/12/19 12:49:05 edgomez Exp $
  *
  ****************************************************************************/
 
@@ -42,7 +42,6 @@
 #include "../quant/quant.h"
 #include "../encoder.h"
 
-#include "../image/reduced.h"
 #include  "../quant/quant_matrix.h"
 
 MBFIELDTEST_PTR MBFieldTest;
@@ -138,12 +137,12 @@
 
 	/* Quantize the block */
 	start_timer();
-	quant[mpeg](&data[0 * 64], &qcoeff[0 * 64], pMB->quant, scaler_lum);
-	quant[mpeg](&data[1 * 64], &qcoeff[1 * 64], pMB->quant, scaler_lum);
-	quant[mpeg](&data[2 * 64], &qcoeff[2 * 64], pMB->quant, scaler_lum);
-	quant[mpeg](&data[3 * 64], &qcoeff[3 * 64], pMB->quant, scaler_lum);
-	quant[mpeg](&data[4 * 64], &qcoeff[4 * 64], pMB->quant, scaler_chr);
-	quant[mpeg](&data[5 * 64], &qcoeff[5 * 64], pMB->quant, scaler_chr);
+	quant[mpeg](&data[0 * 64], &qcoeff[0 * 64], pMB->quant, scaler_lum, pParam->mpeg_quant_matrices);
+	quant[mpeg](&data[1 * 64], &qcoeff[1 * 64], pMB->quant, scaler_lum, pParam->mpeg_quant_matrices);
+	quant[mpeg](&data[2 * 64], &qcoeff[2 * 64], pMB->quant, scaler_lum, pParam->mpeg_quant_matrices);
+	quant[mpeg](&data[3 * 64], &qcoeff[3 * 64], pMB->quant, scaler_lum, pParam->mpeg_quant_matrices);
+	quant[mpeg](&data[4 * 64], &qcoeff[4 * 64], pMB->quant, scaler_chr, pParam->mpeg_quant_matrices);
+	quant[mpeg](&data[5 * 64], &qcoeff[5 * 64], pMB->quant, scaler_chr, pParam->mpeg_quant_matrices);
 	stop_quant_timer();
 }
 
@@ -168,12 +167,12 @@
 	scaler_chr = get_dc_scaler(iQuant, 0);
 
 	start_timer();
-	dequant[mpeg](&qcoeff[0 * 64], &data[0 * 64], iQuant, scaler_lum);
-	dequant[mpeg](&qcoeff[1 * 64], &data[1 * 64], iQuant, scaler_lum);
-	dequant[mpeg](&qcoeff[2 * 64], &data[2 * 64], iQuant, scaler_lum);
-	dequant[mpeg](&qcoeff[3 * 64], &data[3 * 64], iQuant, scaler_lum);
-	dequant[mpeg](&qcoeff[4 * 64], &data[4 * 64], iQuant, scaler_chr);
-	dequant[mpeg](&qcoeff[5 * 64], &data[5 * 64], iQuant, scaler_chr);
+	dequant[mpeg](&qcoeff[0 * 64], &data[0 * 64], iQuant, scaler_lum, pParam->mpeg_quant_matrices);
+	dequant[mpeg](&qcoeff[1 * 64], &data[1 * 64], iQuant, scaler_lum, pParam->mpeg_quant_matrices);
+	dequant[mpeg](&qcoeff[2 * 64], &data[2 * 64], iQuant, scaler_lum, pParam->mpeg_quant_matrices);
+	dequant[mpeg](&qcoeff[3 * 64], &data[3 * 64], iQuant, scaler_lum, pParam->mpeg_quant_matrices);
+	dequant[mpeg](&qcoeff[4 * 64], &data[4 * 64], iQuant, scaler_chr, pParam->mpeg_quant_matrices);
+	dequant[mpeg](&qcoeff[5 * 64], &data[5 * 64], iQuant, scaler_chr, pParam->mpeg_quant_matrices);
 	stop_iquant_timer();
 }
 
@@ -183,7 +182,8 @@
 					   int Q,
 					   const uint16_t * const Zigzag,
 					   const uint16_t * const QuantMatrix,
-					   int Non_Zero);
+					   int Non_Zero,
+					   int Sum);
 
 /* Quantize all blocks -- Inter mode */
 static __inline uint8_t
@@ -214,9 +214,10 @@
 		/* Quantize the block */
 		start_timer();
 
-		sum = quant[mpeg](&qcoeff[i*64], &data[i*64], pMB->quant);
+		sum = quant[mpeg](&qcoeff[i*64], &data[i*64], pMB->quant, pParam->mpeg_quant_matrices);
 
-		if(sum && (frame->vop_flags & XVID_VOP_TRELLISQUANT)) {
+		if(sum && (pMB->quant > 2) && (frame->vop_flags & XVID_VOP_TRELLISQUANT)) {
+			const uint16_t *matrix;
 			const static uint16_t h263matrix[] =
 				{
 					16, 16, 16, 16, 16, 16, 16, 16,
@@ -228,10 +229,13 @@
 					16, 16, 16, 16, 16, 16, 16, 16,
 					16, 16, 16, 16, 16, 16, 16, 16
 				};
+
+			matrix = (mpeg)?get_inter_matrix(pParam->mpeg_quant_matrices):h263matrix;
 			sum = dct_quantize_trellis_c(&qcoeff[i*64], &data[i*64],
 										 pMB->quant, &scan_tables[0][0],
-										 (mpeg)?(uint16_t*)get_inter_matrix():h263matrix,
-										 63);
+										 matrix,
+										 63,
+										 sum);
 		}
 		stop_quant_timer();
 
@@ -281,12 +285,12 @@
 	mpeg = !!(pParam->vol_flags & XVID_VOL_MPEGQUANT);
 
 	start_timer();
-	if(cbp & (1 << (5 - 0))) dequant[mpeg](&data[0 * 64], &qcoeff[0 * 64], iQuant);
-	if(cbp & (1 << (5 - 1))) dequant[mpeg](&data[1 * 64], &qcoeff[1 * 64], iQuant);
-	if(cbp & (1 << (5 - 2))) dequant[mpeg](&data[2 * 64], &qcoeff[2 * 64], iQuant);
-	if(cbp & (1 << (5 - 3))) dequant[mpeg](&data[3 * 64], &qcoeff[3 * 64], iQuant);
-	if(cbp & (1 << (5 - 4))) dequant[mpeg](&data[4 * 64], &qcoeff[4 * 64], iQuant);
-	if(cbp & (1 << (5 - 5))) dequant[mpeg](&data[5 * 64], &qcoeff[5 * 64], iQuant);
+	if(cbp & (1 << (5 - 0))) dequant[mpeg](&data[0 * 64], &qcoeff[0 * 64], iQuant, pParam->mpeg_quant_matrices);
+	if(cbp & (1 << (5 - 1))) dequant[mpeg](&data[1 * 64], &qcoeff[1 * 64], iQuant, pParam->mpeg_quant_matrices);
+	if(cbp & (1 << (5 - 2))) dequant[mpeg](&data[2 * 64], &qcoeff[2 * 64], iQuant, pParam->mpeg_quant_matrices);
+	if(cbp & (1 << (5 - 3))) dequant[mpeg](&data[3 * 64], &qcoeff[3 * 64], iQuant, pParam->mpeg_quant_matrices);
+	if(cbp & (1 << (5 - 4))) dequant[mpeg](&data[4 * 64], &qcoeff[4 * 64], iQuant, pParam->mpeg_quant_matrices);
+	if(cbp & (1 << (5 - 5))) dequant[mpeg](&data[5 * 64], &qcoeff[5 * 64], iQuant, pParam->mpeg_quant_matrices);
 	stop_iquant_timer();
 }
 
@@ -305,38 +309,22 @@
 	uint32_t stride = pParam->edged_width;
 	uint32_t stride2 = stride / 2;
 	uint32_t next_block = stride * 8;
-	int32_t cst;
-	int vop_reduced;
 	uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
 	const IMAGE * const pCurrent = &frame->image;
-	transfer_operation_8to16_t * const functions[2] =
-		{
-			(transfer_operation_8to16_t *)transfer_8to16copy,
-			(transfer_operation_8to16_t *)filter_18x18_to_8x8
-		};
-	transfer_operation_8to16_t *transfer_op = NULL;
-
-	vop_reduced = !!(frame->vop_flags & XVID_VOP_REDUCED);
 
 	/* Image pointers */
-	pY_Cur = pCurrent->y + (y_pos << (4+vop_reduced)) * stride  + (x_pos << (4+vop_reduced));
-	pU_Cur = pCurrent->u + (y_pos << (3+vop_reduced)) * stride2 + (x_pos << (3+vop_reduced));
-	pV_Cur = pCurrent->v + (y_pos << (3+vop_reduced)) * stride2 + (x_pos << (3+vop_reduced));
-
-	/* Block size */
-	cst = 8<<vop_reduced;
-
-	/* Operation function */
-	transfer_op = functions[vop_reduced];
+	pY_Cur = pCurrent->y + (y_pos << 4) * stride  + (x_pos << 4);
+	pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
+	pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);
 
 	/* Do the transfer */
 	start_timer();
-	transfer_op(&data[0 * 64], pY_Cur, stride);
-	transfer_op(&data[1 * 64], pY_Cur + cst, stride);
-	transfer_op(&data[2 * 64], pY_Cur + next_block, stride);
-	transfer_op(&data[3 * 64], pY_Cur + next_block + cst, stride);
-	transfer_op(&data[4 * 64], pU_Cur, stride2);
-	transfer_op(&data[5 * 64], pV_Cur, stride2);
+	transfer_8to16copy(&data[0 * 64], pY_Cur, stride);
+	transfer_8to16copy(&data[1 * 64], pY_Cur + 8, stride);
+	transfer_8to16copy(&data[2 * 64], pY_Cur + next_block, stride);
+	transfer_8to16copy(&data[3 * 64], pY_Cur + next_block + 8, stride);
+	transfer_8to16copy(&data[4 * 64], pU_Cur, stride2);
+	transfer_8to16copy(&data[5 * 64], pV_Cur, stride2);
 	stop_transfer_timer();
 }
 
@@ -354,48 +342,38 @@
 	uint32_t stride = pParam->edged_width;
 	uint32_t stride2 = stride / 2;
 	uint32_t next_block = stride * 8;
-	uint32_t cst;
-	int vop_reduced;
 	const IMAGE * const pCurrent = &frame->image;
 
-	/* Array of function pointers, indexed by [vop_reduced<<1+add] */
-	transfer_operation_16to8_t  * const functions[4] =
+	/* Array of function pointers, indexed by [add] */
+	transfer_operation_16to8_t  * const functions[2] =
 		{
 			(transfer_operation_16to8_t*)transfer_16to8copy,
 			(transfer_operation_16to8_t*)transfer_16to8add,
-			(transfer_operation_16to8_t*)copy_upsampled_8x8_16to8,
-			(transfer_operation_16to8_t*)add_upsampled_8x8_16to8
 		};
 
 	transfer_operation_16to8_t *transfer_op = NULL;
 
+	/* Image pointers */
+	pY_Cur = pCurrent->y + (y_pos << 4) * stride  + (x_pos << 4);
+	pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
+	pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);
+
 	if (pMB->field_dct) {
 		next_block = stride;
 		stride *= 2;
 	}
 
-	/* Makes this vars booleans */
-	vop_reduced = !!(frame->vop_flags & XVID_VOP_REDUCED);
-
-	/* Image pointers */
-	pY_Cur = pCurrent->y + (y_pos << (4+vop_reduced)) * stride  + (x_pos << (4+vop_reduced));
-	pU_Cur = pCurrent->u + (y_pos << (3+vop_reduced)) * stride2 + (x_pos << (3+vop_reduced));
-	pV_Cur = pCurrent->v + (y_pos << (3+vop_reduced)) * stride2 + (x_pos << (3+vop_reduced));
-
-	/* Block size */
-	cst = 8<<vop_reduced;
-
 	/* Operation function */
-	transfer_op = functions[(vop_reduced<<1) + add];
+	transfer_op = functions[add];
 
 	/* Do the operation */
 	start_timer();
-	if (cbp&32) transfer_op(pY_Cur,                    &data[0 * 64], stride);
-	if (cbp&16) transfer_op(pY_Cur + cst,              &data[1 * 64], stride);
-	if (cbp& 8) transfer_op(pY_Cur + next_block,       &data[2 * 64], stride);
-	if (cbp& 4) transfer_op(pY_Cur + next_block + cst, &data[3 * 64], stride);
-	if (cbp& 2) transfer_op(pU_Cur,                    &data[4 * 64], stride2);
-	if (cbp& 1) transfer_op(pV_Cur,                    &data[5 * 64], stride2);
+	if (cbp&32) transfer_op(pY_Cur,						&data[0 * 64], stride);
+	if (cbp&16) transfer_op(pY_Cur + 8,					&data[1 * 64], stride);
+	if (cbp& 8) transfer_op(pY_Cur + next_block,		&data[2 * 64], stride);
+	if (cbp& 4) transfer_op(pY_Cur + next_block + 8,	&data[3 * 64], stride);
+	if (cbp& 2) transfer_op(pU_Cur,						&data[4 * 64], stride2);
+	if (cbp& 1) transfer_op(pV_Cur,						&data[5 * 64], stride2);
 	stop_transfer_timer();
 }
 
@@ -647,11 +625,11 @@
  *    IEEE Transactions on Image Processing, Vol.9, No.8, Aug. 2000.
  *
  * we are at stake with a simplified Bellmand-Ford / Dijkstra Single
- * Source Shorted Path algo. But due to the underlying graph structure
+ * Source Shortest Path algo. But due to the underlying graph structure
  * ("Trellis"), it can be turned into a dynamic programming algo,
  * partially saving the explicit graph's nodes representation. And
  * without using a heap, since the open frontier of the DAG is always
- * known, and of fixed sized.
+ * known, and of fixed size.
  *--------------------------------------------------------------------------*/
 
 
@@ -778,17 +756,6 @@
 	return -1;
 }
 
-static int __inline
-Compute_Sum(const int16_t *C, int last)
-{
-	int sum = 0;
-
-	while(last--)
-		sum += abs(C[last]);
-
-	return(sum);
-}
-
 /* this routine has been strippen of all debug code */
 static int
 dct_quantize_trellis_c(int16_t *const Out,
@@ -796,22 +763,23 @@
 					   int Q,
 					   const uint16_t * const Zigzag,
 					   const uint16_t * const QuantMatrix,
-					   int Non_Zero)
+					   int Non_Zero,
+					   int Sum)
 {
 
-    /*
-	 * Note: We should search last non-zero coeffs on *real* DCT input coeffs (In[]),
-	 * not quantized one (Out[]). However, it only improves the result *very*
-	 * slightly (~0.01dB), whereas speed drops to crawling level :)
-	 * Well, actually, taking 1 more coeff past Non_Zero into account sometimes helps.
-	 */
+	/* Note: We should search last non-zero coeffs on *real* DCT input coeffs
+	 * (In[]), not quantized one (Out[]). However, it only improves the result
+	 * *very* slightly (~0.01dB), whereas speed drops to crawling level :)
+	 * Well, actually, taking 1 more coeff past Non_Zero into account sometimes
+	 * helps. */
 	typedef struct { int16_t Run, Level; } NODE;
 
 	NODE Nodes[65], Last;
 	uint32_t Run_Costs0[64+1];
 	uint32_t * const Run_Costs = Run_Costs0 + 1;
 
-	const int Lambda = Trellis_Lambda_Tabs[Q-1];    /* it's 1/lambda, actually */
+	/* it's 1/lambda, actually */
+	const int Lambda = Trellis_Lambda_Tabs[Q-1];
 
 	int Run_Start = -1;
 	uint32_t Min_Cost = 2<<TL_SHIFT;
@@ -819,8 +787,10 @@
 	int Last_Node = -1;
 	uint32_t Last_Cost = 0;
 
-	int i, j, sum;
-	Run_Costs[-1] = 2<<TL_SHIFT;                          /* source (w/ CBP penalty) */
+	int i, j;
+
+	/* source (w/ CBP penalty) */
+	Run_Costs[-1] = 2<<TL_SHIFT;
 
 	Non_Zero = Find_Last(Out, Zigzag, Non_Zero);
 	if (Non_Zero<0)
@@ -860,16 +830,14 @@
 				const uint32_t Cost = Cost_Base + (Code_Len20[Run-1]<<TL_SHIFT);
 				const uint32_t lCost = Cost_Base + (Code_Len24[Run-1]<<TL_SHIFT);
 
-				/*
-				 * TODO: what about tie-breaks? Should we favor short runs or
+				/* TODO: what about tie-breaks? Should we favor short runs or
 				 * long runs? Although the error is the same, it would not be
-				 * spread the same way along high and low frequencies...
-				 */
+				 * spread the same way along high and low frequencies... */
 
-				/* (I'd say: favour short runs => hifreq errors (HVS) -- gruel ) */
+				/* Gruel: I'd say, favour short runs => hifreq errors (HVS) */
 
 				if (Cost<Best_Cost) {
-					Best_Cost    = Cost;
+					Best_Cost	 = Cost;
 					Nodes[i].Run = Run;
 				}
 
@@ -881,7 +849,8 @@
 			}
 			if (Last_Node==i)
 				Last.Level = Nodes[i].Level;
-		} else { /* "big" levels */
+		} else if (51U>(uint32_t)(Level1+25)) {
+			/* "big" levels (not less than ESC3, though) */
 			const uint8_t *Tbl_L1, *Tbl_L2, *Tbl_L1_Last, *Tbl_L2_Last;
 			int Level2;
 			int dQ1, dQ2;
@@ -893,16 +862,16 @@
 				dQ1 = Level1*Mult-AC + Bias;
 				dQ2 = dQ1 - Mult;
 				Level2 = Level1-1;
-				Tbl_L1      = (Level1<=24) ? B16_17_Code_Len[Level1-1]     : Code_Len0;
-				Tbl_L2      = (Level2<=24) ? B16_17_Code_Len[Level2-1]     : Code_Len0;
+				Tbl_L1		= (Level1<=24) ? B16_17_Code_Len[Level1-1]	   : Code_Len0;
+				Tbl_L2		= (Level2<=24) ? B16_17_Code_Len[Level2-1]	   : Code_Len0;
 				Tbl_L1_Last = (Level1<=6) ? B16_17_Code_Len_Last[Level1-1] : Code_Len0;
 				Tbl_L2_Last = (Level2<=6) ? B16_17_Code_Len_Last[Level2-1] : Code_Len0;
 			} else { /* Level1<-1 */
 				dQ1 = Level1*Mult-AC - Bias;
 				dQ2 = dQ1 + Mult;
 				Level2 = Level1 + 1;
-				Tbl_L1      = (Level1>=-24) ? B16_17_Code_Len[Level1^-1]      : Code_Len0;
-				Tbl_L2      = (Level2>=-24) ? B16_17_Code_Len[Level2^-1]      : Code_Len0;
+				Tbl_L1		= (Level1>=-24) ? B16_17_Code_Len[Level1^-1]	  : Code_Len0;
+				Tbl_L2		= (Level2>=-24) ? B16_17_Code_Len[Level2^-1]	  : Code_Len0;
 				Tbl_L1_Last = (Level1>=- 6) ? B16_17_Code_Len_Last[Level1^-1] : Code_Len0;
 				Tbl_L2_Last = (Level2>=- 6) ? B16_17_Code_Len_Last[Level2^-1] : Code_Len0;
 			}
@@ -917,11 +886,10 @@
 				uint32_t Cost1, Cost2;
 				int bLevel;
 
-				/*
-				 * for sub-optimal (but slightly worth it, speed-wise) search, uncomment the following:
-				 *      if (Cost_Base>=Best_Cost) continue;
-				 * (? doesn't seem to have any effect -- gruel )
-				 */
+				/* for sub-optimal (but slightly worth it, speed-wise) search,
+				 * uncomment the following:
+				 *		if (Cost_Base>=Best_Cost) continue;
+				 * (? doesn't seem to have any effect -- gruel ) */
 
 				Cost1 = Cost_Base + (Tbl_L1[Run-1]<<TL_SHIFT);
 				Cost2 = Cost_Base + (Tbl_L2[Run-1]<<TL_SHIFT) + dDist21;
@@ -956,47 +924,66 @@
 					Last_Node  = i;
 				}
 			} /* end of "for Run" */
+		} else {
+			/* Very very high levels, with no chance of being optimizable
+			 * => Simply pick best Run. */
+			int Run;
+			for(Run=i-Run_Start; Run>0; --Run) {  
+				/* 30 bits + no distortion */
+				const uint32_t Cost = (30<<TL_SHIFT) + Run_Costs[i-Run];
+				if (Cost<Best_Cost) {
+					Best_Cost = Cost;
+					Nodes[i].Run   = Run;
+					Nodes[i].Level = Level1;
+				}
 
+				if (Cost<Last_Cost) {
+					Last_Cost  = Cost;
+					Last.Run   = Run;
+					Last.Level = Level1;
+					Last_Node  = i;	 
+				}
+			}
 		}
 
+
 		Run_Costs[i] = Best_Cost;
 
 		if (Best_Cost < Min_Cost + Dist0) {
 			Min_Cost = Best_Cost;
 			Run_Start = i;
 		} else {
-			/*
-			 * as noticed by Michael Niedermayer (michaelni at gmx.at), there's
-			 * a code shorter by 1 bit for a larger run (!), same level. We give
-			 * it a chance by not moving the left barrier too much.
-			 */
-
+			/* as noticed by Michael Niedermayer (michaelni at gmx.at),
+			 * there's a code shorter by 1 bit for a larger run (!), same
+			 * level. We give it a chance by not moving the left barrier too
+			 * much. */
 			while( Run_Costs[Run_Start]>Min_Cost+(1<<TL_SHIFT) )
 				Run_Start++;
 
-			/* spread on preceding coeffs the cost incurred by skipping this one */
+			/* spread on preceding coeffs the cost incurred by skipping this
+			 * one */
 			for(j=Run_Start; j<i; ++j) Run_Costs[j] += Dist0;
 			Min_Cost += Dist0;
 		}
 	}
 
-	/* It seems trellis doesn't give good results... just compute the Out sum and
-	 * quit (even if we did not modify it, upperlayer relies on this data) */
+	/* It seems trellis doesn't give good results... just leave the block untouched
+	 * and return the original sum value */
 	if (Last_Node<0)
-		return Compute_Sum(Out, Non_Zero);
+		return Sum;
 
 	/* reconstruct optimal sequence backward with surviving paths */
 	memset(Out, 0x00, 64*sizeof(*Out));
 	Out[Zigzag[Last_Node]] = Last.Level;
 	i = Last_Node - Last.Run;
-	sum = 0;
+	Sum = abs(Last.Level);
 	while(i>=0) {
 		Out[Zigzag[i]] = Nodes[i].Level;
-		sum += abs(Nodes[i].Level);
+		Sum += abs(Nodes[i].Level);
 		i -= Nodes[i].Run;
 	}
 
-	return sum;
+	return Sum;
 }
 
 /* original version including heavy debugging info */