[cvs] / xvidcore / src / utils / mbtransquant.c Repository:
ViewVC logotype

Diff of /xvidcore/src/utils/mbtransquant.c

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

revision 1.23.2.3, Sun Dec 19 12:04:27 2004 UTC revision 1.32, Mon Jul 10 08:09:59 2006 UTC
# Line 42  Line 42 
42  #include "../quant/quant.h"  #include "../quant/quant.h"
43  #include "../encoder.h"  #include "../encoder.h"
44    
 #include "../image/reduced.h"  
45  #include  "../quant/quant_matrix.h"  #include  "../quant/quant_matrix.h"
46    
47  MBFIELDTEST_PTR MBFieldTest;  MBFIELDTEST_PTR MBFieldTest;
# Line 91  Line 90 
90    
91          /* Perform DCT */          /* Perform DCT */
92          start_timer();          start_timer();
93          fdct(&data[0 * 64]);          fdct((short * const)&data[0 * 64]);
94          fdct(&data[1 * 64]);          fdct((short * const)&data[1 * 64]);
95          fdct(&data[2 * 64]);          fdct((short * const)&data[2 * 64]);
96          fdct(&data[3 * 64]);          fdct((short * const)&data[3 * 64]);
97          fdct(&data[4 * 64]);          fdct((short * const)&data[4 * 64]);
98          fdct(&data[5 * 64]);          fdct((short * const)&data[5 * 64]);
99          stop_dct_timer();          stop_dct_timer();
100  }  }
101    
# Line 106  Line 105 
105             const uint8_t cbp)             const uint8_t cbp)
106  {  {
107          start_timer();          start_timer();
108          if(cbp & (1 << (5 - 0))) idct(&data[0 * 64]);          if(cbp & (1 << (5 - 0))) idct((short * const)&data[0 * 64]);
109          if(cbp & (1 << (5 - 1))) idct(&data[1 * 64]);          if(cbp & (1 << (5 - 1))) idct((short * const)&data[1 * 64]);
110          if(cbp & (1 << (5 - 2))) idct(&data[2 * 64]);          if(cbp & (1 << (5 - 2))) idct((short * const)&data[2 * 64]);
111          if(cbp & (1 << (5 - 3))) idct(&data[3 * 64]);          if(cbp & (1 << (5 - 3))) idct((short * const)&data[3 * 64]);
112          if(cbp & (1 << (5 - 4))) idct(&data[4 * 64]);          if(cbp & (1 << (5 - 4))) idct((short * const)&data[4 * 64]);
113          if(cbp & (1 << (5 - 5))) idct(&data[5 * 64]);          if(cbp & (1 << (5 - 5))) idct((short * const)&data[5 * 64]);
114          stop_idct_timer();          stop_idct_timer();
115  }  }
116    
# Line 123  Line 122 
122                           int16_t qcoeff[6 * 64],                           int16_t qcoeff[6 * 64],
123                           int16_t data[6*64])                           int16_t data[6*64])
124  {  {
         int mpeg;  
125          int scaler_lum, scaler_chr;          int scaler_lum, scaler_chr;
126            quant_intraFuncPtr quant;
127    
128          quant_intraFuncPtr const quant[2] =          /* check if quant matrices need to be re-initialized with new quant */
129                  {          if (pParam->vol_flags & XVID_VOL_MPEGQUANT) {
130                          quant_h263_intra,                  if (pParam->last_quant_initialized_intra != pMB->quant) {
131                          quant_mpeg_intra                          init_intra_matrix(pParam->mpeg_quant_matrices, pMB->quant);
132                  };                  }
133                    quant = quant_mpeg_intra;
134            } else {
135                    quant = quant_h263_intra;
136            }
137    
         mpeg = !!(pParam->vol_flags & XVID_VOL_MPEGQUANT);  
138          scaler_lum = get_dc_scaler(pMB->quant, 1);          scaler_lum = get_dc_scaler(pMB->quant, 1);
139          scaler_chr = get_dc_scaler(pMB->quant, 0);          scaler_chr = get_dc_scaler(pMB->quant, 0);
140    
141          /* Quantize the block */          /* Quantize the block */
142          start_timer();          start_timer();
143          quant[mpeg](&data[0 * 64], &qcoeff[0 * 64], pMB->quant, scaler_lum, pParam->mpeg_quant_matrices);          quant(&data[0 * 64], &qcoeff[0 * 64], pMB->quant, scaler_lum, pParam->mpeg_quant_matrices);
144          quant[mpeg](&data[1 * 64], &qcoeff[1 * 64], pMB->quant, scaler_lum, pParam->mpeg_quant_matrices);          quant(&data[1 * 64], &qcoeff[1 * 64], pMB->quant, scaler_lum, pParam->mpeg_quant_matrices);
145          quant[mpeg](&data[2 * 64], &qcoeff[2 * 64], pMB->quant, scaler_lum, pParam->mpeg_quant_matrices);          quant(&data[2 * 64], &qcoeff[2 * 64], pMB->quant, scaler_lum, pParam->mpeg_quant_matrices);
146          quant[mpeg](&data[3 * 64], &qcoeff[3 * 64], pMB->quant, scaler_lum, pParam->mpeg_quant_matrices);          quant(&data[3 * 64], &qcoeff[3 * 64], pMB->quant, scaler_lum, pParam->mpeg_quant_matrices);
147          quant[mpeg](&data[4 * 64], &qcoeff[4 * 64], pMB->quant, scaler_chr, pParam->mpeg_quant_matrices);          quant(&data[4 * 64], &qcoeff[4 * 64], pMB->quant, scaler_chr, pParam->mpeg_quant_matrices);
148          quant[mpeg](&data[5 * 64], &qcoeff[5 * 64], pMB->quant, scaler_chr, pParam->mpeg_quant_matrices);          quant(&data[5 * 64], &qcoeff[5 * 64], pMB->quant, scaler_chr, pParam->mpeg_quant_matrices);
149          stop_quant_timer();          stop_quant_timer();
150  }  }
151    
# Line 184  Line 186 
186                                             const uint16_t * const Zigzag,                                             const uint16_t * const Zigzag,
187                                             const uint16_t * const QuantMatrix,                                             const uint16_t * const QuantMatrix,
188                                             int Non_Zero,                                             int Non_Zero,
189                                             int Sum);                                             int Sum,
190                                               int Lambda_Mod);
191    
192  /* Quantize all blocks -- Inter mode */  /* Quantize all blocks -- Inter mode */
193  static __inline uint8_t  static __inline uint8_t
# Line 236  Line 239 
239                                                                                   pMB->quant, &scan_tables[0][0],                                                                                   pMB->quant, &scan_tables[0][0],
240                                                                                   matrix,                                                                                   matrix,
241                                                                                   63,                                                                                   63,
242                                                                                   sum);                                                                                   sum,
243                                                                                     pMB->lambda[i]);
244                  }                  }
245                  stop_quant_timer();                  stop_quant_timer();
246    
# Line 310  Line 314 
314          uint32_t stride = pParam->edged_width;          uint32_t stride = pParam->edged_width;
315          uint32_t stride2 = stride / 2;          uint32_t stride2 = stride / 2;
316          uint32_t next_block = stride * 8;          uint32_t next_block = stride * 8;
         int32_t cst;  
         int vop_reduced;  
317          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
318          const IMAGE * const pCurrent = &frame->image;          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);  
319    
320          /* Image pointers */          /* Image pointers */
321          pY_Cur = pCurrent->y + (y_pos << (4+vop_reduced)) * stride  + (x_pos << (4+vop_reduced));          pY_Cur = pCurrent->y + (y_pos << 4) * stride  + (x_pos << 4);
322          pU_Cur = pCurrent->u + (y_pos << (3+vop_reduced)) * stride2 + (x_pos << (3+vop_reduced));          pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
323          pV_Cur = pCurrent->v + (y_pos << (3+vop_reduced)) * stride2 + (x_pos << (3+vop_reduced));          pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);
   
         /* Block size */  
         cst = 8<<vop_reduced;  
   
         /* Operation function */  
         transfer_op = functions[vop_reduced];  
324    
325          /* Do the transfer */          /* Do the transfer */
326          start_timer();          start_timer();
327          transfer_op(&data[0 * 64], pY_Cur, stride);          transfer_8to16copy(&data[0 * 64], pY_Cur, stride);
328          transfer_op(&data[1 * 64], pY_Cur + cst, stride);          transfer_8to16copy(&data[1 * 64], pY_Cur + 8, stride);
329          transfer_op(&data[2 * 64], pY_Cur + next_block, stride);          transfer_8to16copy(&data[2 * 64], pY_Cur + next_block, stride);
330          transfer_op(&data[3 * 64], pY_Cur + next_block + cst, stride);          transfer_8to16copy(&data[3 * 64], pY_Cur + next_block + 8, stride);
331          transfer_op(&data[4 * 64], pU_Cur, stride2);          transfer_8to16copy(&data[4 * 64], pU_Cur, stride2);
332          transfer_op(&data[5 * 64], pV_Cur, stride2);          transfer_8to16copy(&data[5 * 64], pV_Cur, stride2);
333          stop_transfer_timer();          stop_transfer_timer();
334  }  }
335    
# Line 359  Line 347 
347          uint32_t stride = pParam->edged_width;          uint32_t stride = pParam->edged_width;
348          uint32_t stride2 = stride / 2;          uint32_t stride2 = stride / 2;
349          uint32_t next_block = stride * 8;          uint32_t next_block = stride * 8;
         uint32_t cst;  
         int vop_reduced;  
350          const IMAGE * const pCurrent = &frame->image;          const IMAGE * const pCurrent = &frame->image;
351    
352          /* Array of function pointers, indexed by [vop_reduced<<1+add] */          /* Array of function pointers, indexed by [add] */
353          transfer_operation_16to8_t  * const functions[4] =          transfer_operation_16to8_t  * const functions[2] =
354                  {                  {
355                          (transfer_operation_16to8_t*)transfer_16to8copy,                          (transfer_operation_16to8_t*)transfer_16to8copy,
356                          (transfer_operation_16to8_t*)transfer_16to8add,                          (transfer_operation_16to8_t*)transfer_16to8add,
                         (transfer_operation_16to8_t*)copy_upsampled_8x8_16to8,  
                         (transfer_operation_16to8_t*)add_upsampled_8x8_16to8  
357                  };                  };
358    
359          transfer_operation_16to8_t *transfer_op = NULL;          transfer_operation_16to8_t *transfer_op = NULL;
360    
         /* Makes this vars booleans */  
         vop_reduced = !!(frame->vop_flags & XVID_VOP_REDUCED);  
   
361          /* Image pointers */          /* Image pointers */
362          pY_Cur = pCurrent->y + (y_pos << (4+vop_reduced)) * stride  + (x_pos << (4+vop_reduced));          pY_Cur = pCurrent->y + (y_pos << 4) * stride  + (x_pos << 4);
363          pU_Cur = pCurrent->u + (y_pos << (3+vop_reduced)) * stride2 + (x_pos << (3+vop_reduced));          pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
364          pV_Cur = pCurrent->v + (y_pos << (3+vop_reduced)) * stride2 + (x_pos << (3+vop_reduced));          pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);
365    
366          if (pMB->field_dct) {          if (pMB->field_dct) {
367                  next_block = stride;                  next_block = stride;
368                  stride *= 2;                  stride *= 2;
369          }          }
370    
         /* Block size */  
         cst = 8<<vop_reduced;  
   
371          /* Operation function */          /* Operation function */
372          transfer_op = functions[(vop_reduced<<1) + add];          transfer_op = functions[add];
373    
374          /* Do the operation */          /* Do the operation */
375          start_timer();          start_timer();
376          if (cbp&32) transfer_op(pY_Cur,                    &data[0 * 64], stride);          if (cbp&32) transfer_op(pY_Cur,                    &data[0 * 64], stride);
377          if (cbp&16) transfer_op(pY_Cur + cst,              &data[1 * 64], stride);          if (cbp&16) transfer_op(pY_Cur + 8,                                     &data[1 * 64], stride);
378          if (cbp& 8) transfer_op(pY_Cur + next_block,       &data[2 * 64], stride);          if (cbp& 8) transfer_op(pY_Cur + next_block,       &data[2 * 64], stride);
379          if (cbp& 4) transfer_op(pY_Cur + next_block + cst, &data[3 * 64], stride);          if (cbp& 4) transfer_op(pY_Cur + next_block + 8,        &data[3 * 64], stride);
380          if (cbp& 2) transfer_op(pU_Cur,                    &data[4 * 64], stride2);          if (cbp& 2) transfer_op(pU_Cur,                    &data[4 * 64], stride2);
381          if (cbp& 1) transfer_op(pV_Cur,                    &data[5 * 64], stride2);          if (cbp& 1) transfer_op(pV_Cur,                    &data[5 * 64], stride2);
382          stop_transfer_timer();          stop_transfer_timer();
# Line 783  Line 761 
761          return -1;          return -1;
762  }  }
763    
764    #define TRELLIS_MIN_EFFORT      3
765    
766  /* this routine has been strippen of all debug code */  /* this routine has been strippen of all debug code */
767  static int  static int
768  dct_quantize_trellis_c(int16_t *const Out,  dct_quantize_trellis_c(int16_t *const Out,
# Line 791  Line 771 
771                                             const uint16_t * const Zigzag,                                             const uint16_t * const Zigzag,
772                                             const uint16_t * const QuantMatrix,                                             const uint16_t * const QuantMatrix,
773                                             int Non_Zero,                                             int Non_Zero,
774                                             int Sum)                                             int Sum,
775                                               int Lambda_Mod)
776  {  {
777    
778          /* Note: We should search last non-zero coeffs on *real* DCT input coeffs          /* Note: We should search last non-zero coeffs on *real* DCT input coeffs
# Line 801  Line 782 
782           * helps. */           * helps. */
783          typedef struct { int16_t Run, Level; } NODE;          typedef struct { int16_t Run, Level; } NODE;
784    
785          NODE Nodes[65], Last;          NODE Nodes[65], Last = { 0, 0};
786          uint32_t Run_Costs0[64+1];          uint32_t Run_Costs0[64+1];
787          uint32_t * const Run_Costs = Run_Costs0 + 1;          uint32_t * const Run_Costs = Run_Costs0 + 1;
788    
789          /* it's 1/lambda, actually */          /* it's 1/lambda, actually */
790          const int Lambda = Trellis_Lambda_Tabs[Q-1];          const int Lambda = (Lambda_Mod*Trellis_Lambda_Tabs[Q-1])>>LAMBDA_EXP;
791    
792          int Run_Start = -1;          int Run_Start = -1;
793          uint32_t Min_Cost = 2<<TL_SHIFT;          uint32_t Min_Cost = 2<<TL_SHIFT;
# Line 820  Line 801 
801          Run_Costs[-1] = 2<<TL_SHIFT;          Run_Costs[-1] = 2<<TL_SHIFT;
802    
803          Non_Zero = Find_Last(Out, Zigzag, Non_Zero);          Non_Zero = Find_Last(Out, Zigzag, Non_Zero);
804          if (Non_Zero<0)          if (Non_Zero < TRELLIS_MIN_EFFORT)
805                  return 0; /* Sum is zero if there are only zero coeffs */                  Non_Zero = TRELLIS_MIN_EFFORT;
806    
807          for(i=0; i<=Non_Zero; i++) {          for(i=0; i<=Non_Zero; i++) {
808                  const int q = ((Q*QuantMatrix[Zigzag[i]])>>4);                  const int q = ((Q*QuantMatrix[Zigzag[i]])>>4);
Legend:
Removed from v.1.23.2.3  
changed lines
  Added in v.1.32
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4