[svn] / branches / dev-api-4 / xvidcore / src / utils / mbtransquant.c Repository:
ViewVC logotype

Diff of /branches/dev-api-4/xvidcore/src/utils/mbtransquant.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1139, Wed Sep 10 00:54:27 2003 UTC revision 1224, Mon Nov 24 22:06:19 2003 UTC
# Line 21  Line 21 
21   *  along with this program ; if not, write to the Free Software   *  along with this program ; if not, write to the Free Software
22   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
23   *   *
24   * $Id: mbtransquant.c,v 1.21.2.16 2003-09-10 00:54:27 edgomez Exp $   * $Id: mbtransquant.c,v 1.21.2.20 2003-11-24 22:06:19 edgomez Exp $
25   *   *
26   ****************************************************************************/   ****************************************************************************/
27    
# Line 39  Line 39 
39  #include "../bitstream/zigzag.h"  #include "../bitstream/zigzag.h"
40  #include "../dct/fdct.h"  #include "../dct/fdct.h"
41  #include "../dct/idct.h"  #include "../dct/idct.h"
42  #include "../quant/quant_mpeg4.h"  #include "../quant/quant.h"
 #include "../quant/quant_h263.h"  
43  #include "../encoder.h"  #include "../encoder.h"
44    
45  #include "../image/reduced.h"  #include "../image/reduced.h"
46    #include  "../quant/quant_matrix.h"
47    
48  MBFIELDTEST_PTR MBFieldTest;  MBFIELDTEST_PTR MBFieldTest;
49    
# Line 126  Line 126 
126          int mpeg;          int mpeg;
127          int scaler_lum, scaler_chr;          int scaler_lum, scaler_chr;
128    
129          quanth263_intraFuncPtr const quant[2] =          quant_intraFuncPtr const quant[2] =
130                  {                  {
131                          (quanth263_intraFuncPtr)quant_intra,                          quant_h263_intra,
132                          (quanth263_intraFuncPtr)quant4_intra                          quant_mpeg_intra
133                  };                  };
134    
135          mpeg = !!(pParam->vol_flags & XVID_VOL_MPEGQUANT);          mpeg = !!(pParam->vol_flags & XVID_VOL_MPEGQUANT);
# Line 157  Line 157 
157          int mpeg;          int mpeg;
158          int scaler_lum, scaler_chr;          int scaler_lum, scaler_chr;
159    
160          quanth263_intraFuncPtr const dequant[2] =          quant_intraFuncPtr const dequant[2] =
161                  {                  {
162                          (quanth263_intraFuncPtr)dequant_intra,                          dequant_h263_intra,
163                          (quanth263_intraFuncPtr)dequant4_intra                          dequant_mpeg_intra
164                  };                  };
165    
166          mpeg = !!(pParam->vol_flags & XVID_VOL_MPEGQUANT);          mpeg = !!(pParam->vol_flags & XVID_VOL_MPEGQUANT);
# Line 177  Line 177 
177          stop_iquant_timer();          stop_iquant_timer();
178  }  }
179    
   
 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);  
   
180  static int  static int
181  dct_quantize_trellis_mpeg_c(int16_t *const Out,  dct_quantize_trellis_c(int16_t *const Out,
182                                                          const int16_t *const In,                                                          const int16_t *const In,
183                                                          int Q,                                                          int Q,
184                                                          const uint16_t * const Zigzag,                                                          const uint16_t * const Zigzag,
185                                               const uint16_t * const QuantMatrix,
186                                                          int Non_Zero);                                                          int Non_Zero);
187    
188  /* Quantize all blocks -- Inter mode */  /* Quantize all blocks -- Inter mode */
# Line 214  Line 201 
201          int sum;          int sum;
202          int code_block, mpeg;          int code_block, mpeg;
203    
204          quanth263_interFuncPtr const quant[2] =          quant_interFuncPtr const quant[2] =
205                  {                  {
206                          (quanth263_interFuncPtr)quant_inter,                          quant_h263_inter,
207                          (quanth263_interFuncPtr)quant4_inter                          quant_mpeg_inter
                 };  
   
         trellis_func_ptr_t const trellis[2] =  
                 {  
                         (trellis_func_ptr_t)dct_quantize_trellis_h263_c,  
                         (trellis_func_ptr_t)dct_quantize_trellis_mpeg_c  
208                  };                  };
209    
210          mpeg = !!(pParam->vol_flags & XVID_VOL_MPEGQUANT);          mpeg = !!(pParam->vol_flags & XVID_VOL_MPEGQUANT);
# Line 236  Line 217 
217                  sum = quant[mpeg](&qcoeff[i*64], &data[i*64], pMB->quant);                  sum = quant[mpeg](&qcoeff[i*64], &data[i*64], pMB->quant);
218    
219                  if(sum && (frame->vop_flags & XVID_VOP_TRELLISQUANT)) {                  if(sum && (frame->vop_flags & XVID_VOP_TRELLISQUANT)) {
220                          sum = trellis[mpeg](&qcoeff[i*64], &data[i*64], pMB->quant, &scan_tables[0][0], 63);                          const static uint16_t h263matrix[] =
221                                    {
222                                            16, 16, 16, 16, 16, 16, 16, 16,
223                                            16, 16, 16, 16, 16, 16, 16, 16,
224                                            16, 16, 16, 16, 16, 16, 16, 16,
225                                            16, 16, 16, 16, 16, 16, 16, 16,
226                                            16, 16, 16, 16, 16, 16, 16, 16,
227                                            16, 16, 16, 16, 16, 16, 16, 16,
228                                            16, 16, 16, 16, 16, 16, 16, 16,
229                                            16, 16, 16, 16, 16, 16, 16, 16
230                                    };
231                            sum = dct_quantize_trellis_c(&qcoeff[i*64], &data[i*64],
232                                                                                     pMB->quant, &scan_tables[0][0],
233                                                                                     (mpeg)?(uint16_t*)get_inter_matrix():h263matrix,
234                                                                                     63);
235                  }                  }
236                  stop_quant_timer();                  stop_quant_timer();
237    
# Line 277  Line 272 
272  {  {
273          int mpeg;          int mpeg;
274    
275          quanth263_interFuncPtr const dequant[2] =          quant_interFuncPtr const dequant[2] =
276                  {                  {
277                          (quanth263_interFuncPtr)dequant_inter,                          dequant_h263_inter,
278                          (quanth263_interFuncPtr)dequant4_inter                          dequant_mpeg_inter
279                  };                  };
280    
281          mpeg = !!(pParam->vol_flags & XVID_VOL_MPEGQUANT);          mpeg = !!(pParam->vol_flags & XVID_VOL_MPEGQUANT);
# Line 362  Line 357 
357          uint32_t cst;          uint32_t cst;
358          int vop_reduced;          int vop_reduced;
359          const IMAGE * const pCurrent = &frame->image;          const IMAGE * const pCurrent = &frame->image;
360    
361          /* Array of function pointers, indexed by [vop_reduced<<1+add] */          /* Array of function pointers, indexed by [vop_reduced<<1+add] */
362          transfer_operation_16to8_t  * const functions[4] =          transfer_operation_16to8_t  * const functions[4] =
363                  {                  {
# Line 449  Line 445 
445          uint8_t cbp;          uint8_t cbp;
446          uint32_t limit;          uint32_t limit;
447    
448          /*          /* There is no MBTrans8to16 for Inter block, that's done in motion compensation
449           * There is no MBTrans8to16 for Inter block, that's done in motion compensation           * already */
          * already  
          */  
450    
451          /* Perform DCT (and field decision) */          /* Perform DCT (and field decision) */
452          MBfDCT(pParam, frame, pMB, x_pos, y_pos, data);          MBfDCT(pParam, frame, pMB, x_pos, y_pos, data);
# Line 490  Line 484 
484          uint8_t cbp;          uint8_t cbp;
485          uint32_t limit;          uint32_t limit;
486    
487          /*          /* There is no MBTrans8to16 for Inter block, that's done in motion compensation
488           * There is no MBTrans8to16 for Inter block, that's done in motion compensation           * already */
          * already  
          */  
489    
490          /* Perform DCT (and field decision) */          /* Perform DCT (and field decision) */
491          MBfDCT(pParam, frame, pMB, x_pos, y_pos, data);          MBfDCT(pParam, frame, pMB, x_pos, y_pos, data);
# Line 511  Line 503 
503           * History comment:           * History comment:
504           * We don't have to DeQuant, iDCT and Transfer back data for B-frames.           * We don't have to DeQuant, iDCT and Transfer back data for B-frames.
505           *           *
506           * BUT some plugins require the original frame to be passed so we have           * BUT some plugins require the rebuilt original frame to be passed so we
507           * to take care of that here           * have to take care of that here
508           */           */
509          if((pParam->plugin_flags & XVID_REQORIGINAL)) {          if((pParam->plugin_flags & XVID_REQORIGINAL)) {
510    
# Line 637  Line 629 
629          MOVLINE(LINE(3, 3), tmp);          MOVLINE(LINE(3, 3), tmp);
630  }  }
631    
   
   
   
   
632  /*****************************************************************************  /*****************************************************************************
633   *               Trellis based R-D optimal quantization   *               Trellis based R-D optimal quantization
634   *   *
# Line 648  Line 636 
636   *   *
637   ****************************************************************************/   ****************************************************************************/
638    
   
 #if 0  
 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)  
 {  
         return 63;  
 }  
 #endif  
   
639  /*----------------------------------------------------------------------------  /*----------------------------------------------------------------------------
640   *   *
641   *        Trellis-Based quantization   *        Trellis-Based quantization
# Line 672  Line 647 
647   *    IEEE Transactions on Image Processing, Vol.9, No.8, Aug. 2000.   *    IEEE Transactions on Image Processing, Vol.9, No.8, Aug. 2000.
648   *   *
649   * we are at stake with a simplified Bellmand-Ford / Dijkstra Single   * we are at stake with a simplified Bellmand-Ford / Dijkstra Single
650   * Source Shorted Path algo. But due to the underlying graph structure   * Source Shortest Path algo. But due to the underlying graph structure
651   * ("Trellis"), it can be turned into a dynamic programming algo,   * ("Trellis"), it can be turned into a dynamic programming algo,
652   * partially saving the explicit graph's nodes representation. And   * partially saving the explicit graph's nodes representation. And
653   * without using a heap, since the open frontier of the DAG is always   * without using a heap, since the open frontier of the DAG is always
654   * known, and of fixed sized.   * known, and of fixed size.
655   *--------------------------------------------------------------------------*/   *--------------------------------------------------------------------------*/
656    
657    
# Line 776  Line 751 
751          Code_Len24,Code_Len23,Code_Len22,Code_Len21, Code_Len3, Code_Len1,          Code_Len24,Code_Len23,Code_Len22,Code_Len21, Code_Len3, Code_Len1,
752  };  };
753    
754  #define TL(q) 0xfe00/(q*q)  /* TL_SHIFT controls the precision of the RD optimizations in trellis
755     * valid range is [10..16]. The bigger, the more trellis is vulnerable
756     * to overflows in cost formulas.
757     *  - 10 allows ac values up to 2^11 == 2048
758     *  - 16 allows ac values up to 2^8 == 256
759     */
760    #define TL_SHIFT 11
761    #define TL(q) ((0xfe00>>(16-TL_SHIFT))/(q*q))
762    
763  static const int Trellis_Lambda_Tabs[31] = {  static const int Trellis_Lambda_Tabs[31] = {
764          TL( 1),TL( 2),TL( 3),TL( 4),TL( 5),TL( 6), TL( 7),          TL( 1),TL( 2),TL( 3),TL( 4),TL( 5),TL( 6), TL( 7),
# Line 806  Line 788 
788    
789          return(sum);          return(sum);
790  }  }
 /* this routine has been strippen of all debug code */  
791    
792    /* this routine has been strippen of all debug code */
793  static int  static int
794  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,
795                                               const int16_t *const In,
796                                               int Q,
797                                               const uint16_t * const Zigzag,
798                                               const uint16_t * const QuantMatrix,
799                                               int Non_Zero)
800  {  {
801    
802      /*          /* Note: We should search last non-zero coeffs on *real* DCT input coeffs
803           * Note: We should search last non-zero coeffs on *real* DCT input coeffs (In[]),           * (In[]), not quantized one (Out[]). However, it only improves the result
804           * not quantized one (Out[]). However, it only improves the result *very*           * *very* slightly (~0.01dB), whereas speed drops to crawling level :)
805           * slightly (~0.01dB), whereas speed drops to crawling level :)           * Well, actually, taking 1 more coeff past Non_Zero into account sometimes
806           * Well, actually, taking 1 more coeff past Non_Zero into account sometimes helps.           * helps. */
          */  
807          typedef struct { int16_t Run, Level; } NODE;          typedef struct { int16_t Run, Level; } NODE;
808    
809          NODE Nodes[65], Last;          NODE Nodes[65], Last;
810          uint32_t Run_Costs0[64+1];          uint32_t Run_Costs0[64+1];
811          uint32_t * const Run_Costs = Run_Costs0 + 1;          uint32_t * const Run_Costs = Run_Costs0 + 1;
812          const int Mult = 2*Q;  
813          const int Bias = (Q-1) | 1;          /* it's 1/lambda, actually */
814          const int Lev0 = Mult + Bias;          const int Lambda = Trellis_Lambda_Tabs[Q-1];
         const int Lambda = Trellis_Lambda_Tabs[Q-1];    /* it's 1/lambda, actually */  
815    
816          int Run_Start = -1;          int Run_Start = -1;
817          uint32_t Min_Cost = 2<<16;          uint32_t Min_Cost = 2<<TL_SHIFT;
818    
819          int Last_Node = -1;          int Last_Node = -1;
820          uint32_t Last_Cost = 0;          uint32_t Last_Cost = 0;
821    
822          int i, j, sum;          int i, j, sum;
823          Run_Costs[-1] = 2<<16;                          /* source (w/ CBP penalty) */  
824            /* source (w/ CBP penalty) */
825            Run_Costs[-1] = 2<<TL_SHIFT;
826    
827          Non_Zero = Find_Last(Out, Zigzag, Non_Zero);          Non_Zero = Find_Last(Out, Zigzag, Non_Zero);
828          if (Non_Zero<0)          if (Non_Zero<0)
829                  return 0; /* Sum is zero if there are only zero coeffs */                  return 0; /* Sum is zero if there are only zero coeffs */
830    
831          for(i=0; i<=Non_Zero; i++) {          for(i=0; i<=Non_Zero; i++) {
832                    const int q = ((Q*QuantMatrix[Zigzag[i]])>>4);
833                    const int Mult = 2*q;
834                    const int Bias = (q-1) | 1;
835                    const int Lev0 = Mult + Bias;
836    
837                  const int AC = In[Zigzag[i]];                  const int AC = In[Zigzag[i]];
838                  const int Level1 = Out[Zigzag[i]];                  const int Level1 = Out[Zigzag[i]];
839                  const int Dist0 = Lambda* AC*AC;                  const unsigned int Dist0 = Lambda* AC*AC;
840                  uint32_t Best_Cost = 0xf0000000;                  uint32_t Best_Cost = 0xf0000000;
841                  Last_Cost += Dist0;                  Last_Cost += Dist0;
842    
# Line 864  Line 856 
856                          Cost0 = Lambda*dQ*dQ;                          Cost0 = Lambda*dQ*dQ;
857    
858                          Nodes[i].Run = 1;                          Nodes[i].Run = 1;
859                          Best_Cost = (Code_Len20[0]<<16) + Run_Costs[i-1]+Cost0;                          Best_Cost = (Code_Len20[0]<<TL_SHIFT) + Run_Costs[i-1]+Cost0;
860                          for(Run=i-Run_Start; Run>0; --Run) {                          for(Run=i-Run_Start; Run>0; --Run) {
861                                  const uint32_t Cost_Base = Cost0 + Run_Costs[i-Run];                                  const uint32_t Cost_Base = Cost0 + Run_Costs[i-Run];
862                                  const uint32_t Cost = Cost_Base + (Code_Len20[Run-1]<<16);                                  const uint32_t Cost = Cost_Base + (Code_Len20[Run-1]<<TL_SHIFT);
863                                  const uint32_t lCost = Cost_Base + (Code_Len24[Run-1]<<16);                                  const uint32_t lCost = Cost_Base + (Code_Len24[Run-1]<<TL_SHIFT);
864    
865                                  /*                                  /* TODO: what about tie-breaks? Should we favor short runs or
                                  * TODO: what about tie-breaks? Should we favor short runs or  
866                                   * long runs? Although the error is the same, it would not be                                   * long runs? Although the error is the same, it would not be
867                                   * spread the same way along high and low frequencies...                                   * spread the same way along high and low frequencies... */
                                  */  
868    
869                                  /* (I'd say: favour short runs => hifreq errors (HVS) -- gruel ) */                                  /* Gruel: I'd say, favour short runs => hifreq errors (HVS) */
870    
871                                  if (Cost<Best_Cost) {                                  if (Cost<Best_Cost) {
872                                          Best_Cost    = Cost;                                          Best_Cost    = Cost;
# Line 891  Line 881 
881                          }                          }
882                          if (Last_Node==i)                          if (Last_Node==i)
883                                  Last.Level = Nodes[i].Level;                                  Last.Level = Nodes[i].Level;
884                  } else { /* "big" levels */                  } else if (51U>(uint32_t)(Level1+25)) {
885                            /* "big" levels (not less than ESC3, though) */
886                          const uint8_t *Tbl_L1, *Tbl_L2, *Tbl_L1_Last, *Tbl_L2_Last;                          const uint8_t *Tbl_L1, *Tbl_L2, *Tbl_L1_Last, *Tbl_L2_Last;
887                          int Level2;                          int Level2;
888                          int dQ1, dQ2;                          int dQ1, dQ2;
# Line 927  Line 918 
918                                  uint32_t Cost1, Cost2;                                  uint32_t Cost1, Cost2;
919                                  int bLevel;                                  int bLevel;
920    
921                                  /*                                  /* for sub-optimal (but slightly worth it, speed-wise) search,
922                                   * for sub-optimal (but slightly worth it, speed-wise) search, uncomment the following:                                   * uncomment the following:
923                                   *      if (Cost_Base>=Best_Cost) continue;                                   *      if (Cost_Base>=Best_Cost) continue;
924                                   * (? doesn't seem to have any effect -- gruel )                                   * (? doesn't seem to have any effect -- gruel ) */
                                  */  
925    
926                                  Cost1 = Cost_Base + (Tbl_L1[Run-1]<<16);                                  Cost1 = Cost_Base + (Tbl_L1[Run-1]<<TL_SHIFT);
927                                  Cost2 = Cost_Base + (Tbl_L2[Run-1]<<16) + dDist21;                                  Cost2 = Cost_Base + (Tbl_L2[Run-1]<<TL_SHIFT) + dDist21;
928    
929                                  if (Cost2<Cost1) {                                  if (Cost2<Cost1) {
930                                          Cost1 = Cost2;                                          Cost1 = Cost2;
# Line 949  Line 939 
939                                          Nodes[i].Level = bLevel;                                          Nodes[i].Level = bLevel;
940                                  }                                  }
941    
942                                  Cost1 = Cost_Base + (Tbl_L1_Last[Run-1]<<16);                                  Cost1 = Cost_Base + (Tbl_L1_Last[Run-1]<<TL_SHIFT);
943                                  Cost2 = Cost_Base + (Tbl_L2_Last[Run-1]<<16) + dDist21;                                  Cost2 = Cost_Base + (Tbl_L2_Last[Run-1]<<TL_SHIFT) + dDist21;
944    
945                                  if (Cost2<Cost1) {                                  if (Cost2<Cost1) {
946                                          Cost1 = Cost2;                                          Cost1 = Cost2;
# Line 966  Line 956 
956                                          Last_Node  = i;                                          Last_Node  = i;
957                                  }                                  }
958                          } /* end of "for Run" */                          } /* end of "for Run" */
959                    } else {
960                            /* Very very high levels, with no chance of being optimizable
961                             * => Simply pick best Run. */
962                            int Run;
963                            for(Run=i-Run_Start; Run>0; --Run) {
964                                    /* 30 bits + no distortion */
965                                    const uint32_t Cost = (30<<TL_SHIFT) + Run_Costs[i-Run];
966                                    if (Cost<Best_Cost) {
967                                            Best_Cost = Cost;
968                                            Nodes[i].Run   = Run;
969                                            Nodes[i].Level = Level1;
970                                    }
971    
972                                    if (Cost<Last_Cost) {
973                                            Last_Cost  = Cost;
974                                            Last.Run   = Run;
975                                            Last.Level = Level1;
976                                            Last_Node  = i;
977                                    }
978                  }                  }
979                    }
980    
981    
982                  Run_Costs[i] = Best_Cost;                  Run_Costs[i] = Best_Cost;
983    
# Line 975  Line 985 
985                          Min_Cost = Best_Cost;                          Min_Cost = Best_Cost;
986                          Run_Start = i;                          Run_Start = i;
987                  } else {                  } else {
988                          /*                          /* as noticed by Michael Niedermayer (michaelni at gmx.at),
989                           * as noticed by Michael Niedermayer (michaelni at gmx.at), there's                           * there's a code shorter by 1 bit for a larger run (!), same
990                           * a code shorter by 1 bit for a larger run (!), same level. We give                           * level. We give it a chance by not moving the left barrier too
991                           * it a chance by not moving the left barrier too much.                           * much. */
992                           */                          while( Run_Costs[Run_Start]>Min_Cost+(1<<TL_SHIFT) )
   
                         while( Run_Costs[Run_Start]>Min_Cost+(1<<16) )  
993                                  Run_Start++;                                  Run_Start++;
994    
995                          /* spread on preceding coeffs the cost incurred by skipping this one */                          /* spread on preceding coeffs the cost incurred by skipping this
996                             * one */
997                          for(j=Run_Start; j<i; ++j) Run_Costs[j] += Dist0;                          for(j=Run_Start; j<i; ++j) Run_Costs[j] += Dist0;
998                          Min_Cost += Dist0;                          Min_Cost += Dist0;
999                  }                  }
1000          }          }
1001    
1002          /* It seems trellis doesn't give good results... just compute the Out sum and          /* It seems trellis doesn't give good results... just compute the Out sum
1003           * quit (even if we did not modify it, upperlayer relies on this data) */           * and quit */
1004          if (Last_Node<0)          if (Last_Node<0)
1005                  return Compute_Sum(Out, Non_Zero);                  return Compute_Sum(Out, Non_Zero);
1006    
# Line 1009  Line 1018 
1018          return sum;          return sum;
1019  }  }
1020    
 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);  
 }  
   
1021  /* original version including heavy debugging info */  /* original version including heavy debugging info */
1022    
1023  #ifdef DBGTRELL  #ifdef DBGTRELL
# Line 1072  Line 1074 
1074                  V -= Ref[Zigzag[i]];                  V -= Ref[Zigzag[i]];
1075                  Dist += V*V;                  Dist += V*V;
1076          }          }
1077          Cost = Lambda*Dist + (Bits<<16);          Cost = Lambda*Dist + (Bits<<TL_SHIFT);
1078          if (DBG==1)          if (DBG==1)
1079                  printf( " Last:%2d/%2d Cost = [(Bits=%5.0d) + Lambda*(Dist=%6.0d) = %d ] >>12= %d ", Last,Max, Bits, Dist, Cost, Cost>>12 );                  printf( " Last:%2d/%2d Cost = [(Bits=%5.0d) + Lambda*(Dist=%6.0d) = %d ] >>12= %d ", Last,Max, Bits, Dist, Cost, Cost>>12 );
1080          return Cost;          return Cost;
# Line 1104  Line 1106 
1106          const int Lambda = Trellis_Lambda_Tabs[Q-1];    /* it's 1/lambda, actually */          const int Lambda = Trellis_Lambda_Tabs[Q-1];    /* it's 1/lambda, actually */
1107    
1108          int Run_Start = -1;          int Run_Start = -1;
1109          Run_Costs[-1] = 2<<16;                          /* source (w/ CBP penalty) */          Run_Costs[-1] = 2<<TL_SHIFT;                          /* source (w/ CBP penalty) */
1110          uint32_t Min_Cost = 2<<16;          uint32_t Min_Cost = 2<<TL_SHIFT;
1111    
1112          int Last_Node = -1;          int Last_Node = -1;
1113          uint32_t Last_Cost = 0;          uint32_t Last_Cost = 0;
# Line 1144  Line 1146 
1146                          Cost0 = Lambda*dQ*dQ;                          Cost0 = Lambda*dQ*dQ;
1147    
1148                          Nodes[i].Run = 1;                          Nodes[i].Run = 1;
1149                          Best_Cost = (Code_Len20[0]<<16) + Run_Costs[i-1]+Cost0;                          Best_Cost = (Code_Len20[0]<<TL_SHIFT) + Run_Costs[i-1]+Cost0;
1150                          for(Run=i-Run_Start; Run>0; --Run)                          for(Run=i-Run_Start; Run>0; --Run)
1151                          {                          {
1152                                  const uint32_t Cost_Base = Cost0 + Run_Costs[i-Run];                                  const uint32_t Cost_Base = Cost0 + Run_Costs[i-Run];
1153                                  const uint32_t Cost = Cost_Base + (Code_Len20[Run-1]<<16);                                  const uint32_t Cost = Cost_Base + (Code_Len20[Run-1]<<TL_SHIFT);
1154                                  const uint32_t lCost = Cost_Base + (Code_Len24[Run-1]<<16);                                  const uint32_t lCost = Cost_Base + (Code_Len24[Run-1]<<TL_SHIFT);
1155    
1156                                  /*                                  /*
1157                                   * TODO: what about tie-breaks? Should we favor short runs or                                   * TODO: what about tie-breaks? Should we favor short runs or
# Line 1225  Line 1227 
1227   * for sub-optimal (but slightly worth it, speed-wise) search, uncomment the following:   * for sub-optimal (but slightly worth it, speed-wise) search, uncomment the following:
1228   *        if (Cost_Base>=Best_Cost) continue;   *        if (Cost_Base>=Best_Cost) continue;
1229   */   */
1230                                  Cost1 = Cost_Base + (Tbl_L1[Run-1]<<16);                                  Cost1 = Cost_Base + (Tbl_L1[Run-1]<<TL_SHIFT);
1231                                  Cost2 = Cost_Base + (Tbl_L2[Run-1]<<16) + dDist21;                                  Cost2 = Cost_Base + (Tbl_L2[Run-1]<<TL_SHIFT) + dDist21;
1232    
1233                                  if (Cost2<Cost1) {                                  if (Cost2<Cost1) {
1234                                          Cost1 = Cost2;                                          Cost1 = Cost2;
# Line 1240  Line 1242 
1242                                          Nodes[i].Level = bLevel;                                          Nodes[i].Level = bLevel;
1243                                  }                                  }
1244    
1245                                  Cost1 = Cost_Base + (Tbl_L1_Last[Run-1]<<16);                                  Cost1 = Cost_Base + (Tbl_L1_Last[Run-1]<<TL_SHIFT);
1246                                  Cost2 = Cost_Base + (Tbl_L2_Last[Run-1]<<16) + dDist21;                                  Cost2 = Cost_Base + (Tbl_L2_Last[Run-1]<<TL_SHIFT) + dDist21;
1247    
1248                                  if (Cost2<Cost1) {                                  if (Cost2<Cost1) {
1249                                          Cost1 = Cost2;                                          Cost1 = Cost2;
# Line 1287  Line 1289 
1289                           * it a chance by not moving the left barrier too much.                           * it a chance by not moving the left barrier too much.
1290                           */                           */
1291    
1292                          while( Run_Costs[Run_Start]>Min_Cost+(1<<16) )                          while( Run_Costs[Run_Start]>Min_Cost+(1<<TL_SHIFT) )
1293                                  Run_Start++;                                  Run_Start++;
1294    
1295                          /* spread on preceding coeffs the cost incurred by skipping this one */                          /* spread on preceding coeffs the cost incurred by skipping this one */
Legend:
Removed from v.1139  
changed lines
  Added in v.1224
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4