--- mbtransquant.c 2003/10/07 13:02:35 1.21.2.18 +++ mbtransquant.c 2004/12/19 12:04:27 1.23.2.3 @@ -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.18 2003/10/07 13:02:35 edgomez Exp $ + * $Id: mbtransquant.c,v 1.23.2.3 2004/12/19 12:04:27 edgomez Exp $ * ****************************************************************************/ @@ -43,6 +43,7 @@ #include "../encoder.h" #include "../image/reduced.h" +#include "../quant/quant_matrix.h" MBFIELDTEST_PTR MBFieldTest; @@ -137,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(); } @@ -167,35 +168,23 @@ 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(); } - -typedef int (*trellis_func_ptr_t)(int16_t *const Out, - const int16_t *const In, - int Q, - const uint16_t * const Zigzag, - int Non_Zero); - static int -dct_quantize_trellis_h263_c(int16_t *const Out, - const int16_t *const In, - int Q, - const uint16_t * const Zigzag, - int Non_Zero); - -static int -dct_quantize_trellis_mpeg_c(int16_t *const Out, - const int16_t *const In, - int Q, - const uint16_t * const Zigzag, - int Non_Zero); +dct_quantize_trellis_c(int16_t *const Out, + const int16_t *const In, + int Q, + const uint16_t * const Zigzag, + const uint16_t * const QuantMatrix, + int Non_Zero, + int Sum); /* Quantize all blocks -- Inter mode */ static __inline uint8_t @@ -219,12 +208,6 @@ quant_mpeg_inter }; - trellis_func_ptr_t const trellis[2] = - { - dct_quantize_trellis_h263_c, - dct_quantize_trellis_mpeg_c - }; - mpeg = !!(pParam->vol_flags & XVID_VOL_MPEGQUANT); for (i = 0; i < 6; i++) { @@ -232,10 +215,28 @@ /* 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)) { - sum = trellis[mpeg](&qcoeff[i*64], &data[i*64], pMB->quant, &scan_tables[0][0], 63); + 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, + 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, + 16, 16, 16, 16, 16, 16, 16, 16, + 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], + matrix, + 63, + sum); } stop_quant_timer(); @@ -285,12 +286,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(); } @@ -373,11 +374,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); @@ -386,6 +382,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<>(16-TL_SHIFT))/(q*q)) static const int Trellis_Lambda_Tabs[31] = { TL( 1),TL( 2),TL( 3),TL( 4),TL( 5),TL( 6), TL( 7), @@ -775,55 +783,55 @@ 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_h263_c(int16_t *const Out, const int16_t *const In, int Q, const uint16_t * const Zigzag, int Non_Zero) +dct_quantize_trellis_c(int16_t *const Out, + const int16_t *const In, + int Q, + const uint16_t * const Zigzag, + const uint16_t * const QuantMatrix, + 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 Mult = 2*Q; - const int Bias = (Q-1) | 1; - const int Lev0 = Mult + Bias; - 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<<16; + uint32_t Min_Cost = 2<>4); + const int Mult = 2*q; + const int Bias = (q-1) | 1; + const int Lev0 = Mult + Bias; + const int AC = In[Zigzag[i]]; const int Level1 = Out[Zigzag[i]]; - const int Dist0 = Lambda* AC*AC; + const unsigned int Dist0 = Lambda* AC*AC; uint32_t Best_Cost = 0xf0000000; Last_Cost += Dist0; @@ -843,22 +851,20 @@ Cost0 = Lambda*dQ*dQ; Nodes[i].Run = 1; - Best_Cost = (Code_Len20[0]<<16) + Run_Costs[i-1]+Cost0; + Best_Cost = (Code_Len20[0]<0; --Run) { const uint32_t Cost_Base = Cost0 + Run_Costs[i-Run]; - const uint32_t Cost = Cost_Base + (Code_Len20[Run-1]<<16); - const uint32_t lCost = Cost_Base + (Code_Len24[Run-1]<<16); + const uint32_t Cost = Cost_Base + (Code_Len20[Run-1]< hifreq errors (HVS) -- gruel ) */ + /* Gruel: I'd say, favour short runs => hifreq errors (HVS) */ if (Cost(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; @@ -882,16 +889,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; } @@ -906,14 +913,13 @@ 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]<<16); - Cost2 = Cost_Base + (Tbl_L2[Run-1]<<16) + dDist21; + Cost1 = Cost_Base + (Tbl_L1[Run-1]< Simply pick best Run. */ + int Run; + for(Run=i-Run_Start; Run>0; --Run) { + /* 30 bits + no distortion */ + const uint32_t Cost = (30<Min_Cost+(1<<16) ) + /* 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<=0) { Out[Zigzag[i]] = Nodes[i].Level; - sum += abs(Nodes[i].Level); + Sum += abs(Nodes[i].Level); i -= Nodes[i].Run; } - return sum; -} - -static int -dct_quantize_trellis_mpeg_c(int16_t *const Out, const int16_t *const In, int Q, const uint16_t * const Zigzag, int Non_Zero) -{ - /* ToDo: Ok ok it's just a place holder for Gruel -- damn write this one :-) */ - return Compute_Sum(Out, 63); + return Sum; } /* original version including heavy debugging info */ @@ -1051,7 +1069,7 @@ V -= Ref[Zigzag[i]]; Dist += V*V; } - Cost = Lambda*Dist + (Bits<<16); + Cost = Lambda*Dist + (Bits<>12= %d ", Last,Max, Bits, Dist, Cost, Cost>>12 ); return Cost; @@ -1083,8 +1101,8 @@ const int Lambda = Trellis_Lambda_Tabs[Q-1]; /* it's 1/lambda, actually */ int Run_Start = -1; - Run_Costs[-1] = 2<<16; /* source (w/ CBP penalty) */ - uint32_t Min_Cost = 2<<16; + Run_Costs[-1] = 2<0; --Run) { const uint32_t Cost_Base = Cost0 + Run_Costs[i-Run]; - const uint32_t Cost = Cost_Base + (Code_Len20[Run-1]<<16); - const uint32_t lCost = Cost_Base + (Code_Len24[Run-1]<<16); + const uint32_t Cost = Cost_Base + (Code_Len20[Run-1]<=Best_Cost) continue; */ - Cost1 = Cost_Base + (Tbl_L1[Run-1]<<16); - Cost2 = Cost_Base + (Tbl_L2[Run-1]<<16) + dDist21; + Cost1 = Cost_Base + (Tbl_L1[Run-1]<Min_Cost+(1<<16) ) + while( Run_Costs[Run_Start]>Min_Cost+(1<