--- mbtransquant.c	2003/11/23 17:01:08	1.21.2.19
+++ mbtransquant.c	2003/12/01 10:46:40	1.21.2.22
@@ -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.21.2.22 2003/12/01 10:46:40 syskin Exp $
  *
  ****************************************************************************/
 
@@ -138,12 +138,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 +168,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();
 }
 
@@ -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)) {
+			const uint16_t *matrix;
 			const static uint16_t h263matrix[] =
 				{
 					16, 16, 16, 16, 16, 16, 16, 16,
@@ -228,9 +229,11 @@
 					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,
+										 matrix,
 										 63);
 		}
 		stop_quant_timer();
@@ -281,12 +284,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();
 }
 
@@ -369,11 +372,6 @@
 
 	transfer_operation_16to8_t *transfer_op = NULL;
 
-	if (pMB->field_dct) {
-		next_block = stride;
-		stride *= 2;
-	}
-
 	/* Makes this vars booleans */
 	vop_reduced = !!(frame->vop_flags & XVID_VOP_REDUCED);
 
@@ -382,6 +380,11 @@
 	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));
 
+	if (pMB->field_dct) {
+		next_block = stride;
+		stride *= 2;
+	}
+
 	/* Block size */
 	cst = 8<<vop_reduced;
 
@@ -647,11 +650,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.
  *--------------------------------------------------------------------------*/
 
 
@@ -799,19 +802,19 @@
 					   int Non_Zero)
 {
 
-    /*
-	 * 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;
@@ -820,7 +823,9 @@
 	uint32_t Last_Cost = 0;
 
 	int i, j, sum;
-	Run_Costs[-1] = 2<<TL_SHIFT;                          /* source (w/ CBP penalty) */
+
+	/* source (w/ CBP penalty) */
+	Run_Costs[-1] = 2<<TL_SHIFT;
 
 	Non_Zero = Find_Last(Out, Zigzag, Non_Zero);
 	if (Non_Zero<0)
@@ -860,16 +865,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 +884,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 +897,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 +921,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,32 +959,51 @@
 					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 compute the Out sum
+	 * and quit */
 	if (Last_Node<0)
 		return Compute_Sum(Out, Non_Zero);