[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.21.2.20, Mon Nov 24 22:06:19 2003 UTC revision 1.27, Sun Dec 19 12:49:05 2004 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 138  Line 137 
137    
138          /* Quantize the block */          /* Quantize the block */
139          start_timer();          start_timer();
140          quant[mpeg](&data[0 * 64], &qcoeff[0 * 64], pMB->quant, scaler_lum);          quant[mpeg](&data[0 * 64], &qcoeff[0 * 64], pMB->quant, scaler_lum, pParam->mpeg_quant_matrices);
141          quant[mpeg](&data[1 * 64], &qcoeff[1 * 64], pMB->quant, scaler_lum);          quant[mpeg](&data[1 * 64], &qcoeff[1 * 64], pMB->quant, scaler_lum, pParam->mpeg_quant_matrices);
142          quant[mpeg](&data[2 * 64], &qcoeff[2 * 64], pMB->quant, scaler_lum);          quant[mpeg](&data[2 * 64], &qcoeff[2 * 64], pMB->quant, scaler_lum, pParam->mpeg_quant_matrices);
143          quant[mpeg](&data[3 * 64], &qcoeff[3 * 64], pMB->quant, scaler_lum);          quant[mpeg](&data[3 * 64], &qcoeff[3 * 64], pMB->quant, scaler_lum, pParam->mpeg_quant_matrices);
144          quant[mpeg](&data[4 * 64], &qcoeff[4 * 64], pMB->quant, scaler_chr);          quant[mpeg](&data[4 * 64], &qcoeff[4 * 64], pMB->quant, scaler_chr, pParam->mpeg_quant_matrices);
145          quant[mpeg](&data[5 * 64], &qcoeff[5 * 64], pMB->quant, scaler_chr);          quant[mpeg](&data[5 * 64], &qcoeff[5 * 64], pMB->quant, scaler_chr, pParam->mpeg_quant_matrices);
146          stop_quant_timer();          stop_quant_timer();
147  }  }
148    
# Line 168  Line 167 
167          scaler_chr = get_dc_scaler(iQuant, 0);          scaler_chr = get_dc_scaler(iQuant, 0);
168    
169          start_timer();          start_timer();
170          dequant[mpeg](&qcoeff[0 * 64], &data[0 * 64], iQuant, scaler_lum);          dequant[mpeg](&qcoeff[0 * 64], &data[0 * 64], iQuant, scaler_lum, pParam->mpeg_quant_matrices);
171          dequant[mpeg](&qcoeff[1 * 64], &data[1 * 64], iQuant, scaler_lum);          dequant[mpeg](&qcoeff[1 * 64], &data[1 * 64], iQuant, scaler_lum, pParam->mpeg_quant_matrices);
172          dequant[mpeg](&qcoeff[2 * 64], &data[2 * 64], iQuant, scaler_lum);          dequant[mpeg](&qcoeff[2 * 64], &data[2 * 64], iQuant, scaler_lum, pParam->mpeg_quant_matrices);
173          dequant[mpeg](&qcoeff[3 * 64], &data[3 * 64], iQuant, scaler_lum);          dequant[mpeg](&qcoeff[3 * 64], &data[3 * 64], iQuant, scaler_lum, pParam->mpeg_quant_matrices);
174          dequant[mpeg](&qcoeff[4 * 64], &data[4 * 64], iQuant, scaler_chr);          dequant[mpeg](&qcoeff[4 * 64], &data[4 * 64], iQuant, scaler_chr, pParam->mpeg_quant_matrices);
175          dequant[mpeg](&qcoeff[5 * 64], &data[5 * 64], iQuant, scaler_chr);          dequant[mpeg](&qcoeff[5 * 64], &data[5 * 64], iQuant, scaler_chr, pParam->mpeg_quant_matrices);
176          stop_iquant_timer();          stop_iquant_timer();
177  }  }
178    
# Line 183  Line 182 
182                                             int Q,                                             int Q,
183                                             const uint16_t * const Zigzag,                                             const uint16_t * const Zigzag,
184                                             const uint16_t * const QuantMatrix,                                             const uint16_t * const QuantMatrix,
185                                             int Non_Zero);                                             int Non_Zero,
186                                               int Sum);
187    
188  /* Quantize all blocks -- Inter mode */  /* Quantize all blocks -- Inter mode */
189  static __inline uint8_t  static __inline uint8_t
# Line 214  Line 214 
214                  /* Quantize the block */                  /* Quantize the block */
215                  start_timer();                  start_timer();
216    
217                  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);
218    
219                  if(sum && (frame->vop_flags & XVID_VOP_TRELLISQUANT)) {                  if(sum && (pMB->quant > 2) && (frame->vop_flags & XVID_VOP_TRELLISQUANT)) {
220                            const uint16_t *matrix;
221                          const static uint16_t h263matrix[] =                          const static uint16_t h263matrix[] =
222                                  {                                  {
223                                          16, 16, 16, 16, 16, 16, 16, 16,                                          16, 16, 16, 16, 16, 16, 16, 16,
# Line 228  Line 229 
229                                          16, 16, 16, 16, 16, 16, 16, 16,                                          16, 16, 16, 16, 16, 16, 16, 16,
230                                          16, 16, 16, 16, 16, 16, 16, 16                                          16, 16, 16, 16, 16, 16, 16, 16
231                                  };                                  };
232    
233                            matrix = (mpeg)?get_inter_matrix(pParam->mpeg_quant_matrices):h263matrix;
234                          sum = dct_quantize_trellis_c(&qcoeff[i*64], &data[i*64],                          sum = dct_quantize_trellis_c(&qcoeff[i*64], &data[i*64],
235                                                                                   pMB->quant, &scan_tables[0][0],                                                                                   pMB->quant, &scan_tables[0][0],
236                                                                                   (mpeg)?(uint16_t*)get_inter_matrix():h263matrix,                                                                                   matrix,
237                                                                                   63);                                                                                   63,
238                                                                                     sum);
239                  }                  }
240                  stop_quant_timer();                  stop_quant_timer();
241    
# Line 281  Line 285 
285          mpeg = !!(pParam->vol_flags & XVID_VOL_MPEGQUANT);          mpeg = !!(pParam->vol_flags & XVID_VOL_MPEGQUANT);
286    
287          start_timer();          start_timer();
288          if(cbp & (1 << (5 - 0))) dequant[mpeg](&data[0 * 64], &qcoeff[0 * 64], iQuant);          if(cbp & (1 << (5 - 0))) dequant[mpeg](&data[0 * 64], &qcoeff[0 * 64], iQuant, pParam->mpeg_quant_matrices);
289          if(cbp & (1 << (5 - 1))) dequant[mpeg](&data[1 * 64], &qcoeff[1 * 64], iQuant);          if(cbp & (1 << (5 - 1))) dequant[mpeg](&data[1 * 64], &qcoeff[1 * 64], iQuant, pParam->mpeg_quant_matrices);
290          if(cbp & (1 << (5 - 2))) dequant[mpeg](&data[2 * 64], &qcoeff[2 * 64], iQuant);          if(cbp & (1 << (5 - 2))) dequant[mpeg](&data[2 * 64], &qcoeff[2 * 64], iQuant, pParam->mpeg_quant_matrices);
291          if(cbp & (1 << (5 - 3))) dequant[mpeg](&data[3 * 64], &qcoeff[3 * 64], iQuant);          if(cbp & (1 << (5 - 3))) dequant[mpeg](&data[3 * 64], &qcoeff[3 * 64], iQuant, pParam->mpeg_quant_matrices);
292          if(cbp & (1 << (5 - 4))) dequant[mpeg](&data[4 * 64], &qcoeff[4 * 64], iQuant);          if(cbp & (1 << (5 - 4))) dequant[mpeg](&data[4 * 64], &qcoeff[4 * 64], iQuant, pParam->mpeg_quant_matrices);
293          if(cbp & (1 << (5 - 5))) dequant[mpeg](&data[5 * 64], &qcoeff[5 * 64], iQuant);          if(cbp & (1 << (5 - 5))) dequant[mpeg](&data[5 * 64], &qcoeff[5 * 64], iQuant, pParam->mpeg_quant_matrices);
294          stop_iquant_timer();          stop_iquant_timer();
295  }  }
296    
# Line 305  Line 309 
309          uint32_t stride = pParam->edged_width;          uint32_t stride = pParam->edged_width;
310          uint32_t stride2 = stride / 2;          uint32_t stride2 = stride / 2;
311          uint32_t next_block = stride * 8;          uint32_t next_block = stride * 8;
         int32_t cst;  
         int vop_reduced;  
312          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
313          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);  
314    
315          /* Image pointers */          /* Image pointers */
316          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);
317          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);
318          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];  
319    
320          /* Do the transfer */          /* Do the transfer */
321          start_timer();          start_timer();
322          transfer_op(&data[0 * 64], pY_Cur, stride);          transfer_8to16copy(&data[0 * 64], pY_Cur, stride);
323          transfer_op(&data[1 * 64], pY_Cur + cst, stride);          transfer_8to16copy(&data[1 * 64], pY_Cur + 8, stride);
324          transfer_op(&data[2 * 64], pY_Cur + next_block, stride);          transfer_8to16copy(&data[2 * 64], pY_Cur + next_block, stride);
325          transfer_op(&data[3 * 64], pY_Cur + next_block + cst, stride);          transfer_8to16copy(&data[3 * 64], pY_Cur + next_block + 8, stride);
326          transfer_op(&data[4 * 64], pU_Cur, stride2);          transfer_8to16copy(&data[4 * 64], pU_Cur, stride2);
327          transfer_op(&data[5 * 64], pV_Cur, stride2);          transfer_8to16copy(&data[5 * 64], pV_Cur, stride2);
328          stop_transfer_timer();          stop_transfer_timer();
329  }  }
330    
# Line 354  Line 342 
342          uint32_t stride = pParam->edged_width;          uint32_t stride = pParam->edged_width;
343          uint32_t stride2 = stride / 2;          uint32_t stride2 = stride / 2;
344          uint32_t next_block = stride * 8;          uint32_t next_block = stride * 8;
         uint32_t cst;  
         int vop_reduced;  
345          const IMAGE * const pCurrent = &frame->image;          const IMAGE * const pCurrent = &frame->image;
346    
347          /* Array of function pointers, indexed by [vop_reduced<<1+add] */          /* Array of function pointers, indexed by [add] */
348          transfer_operation_16to8_t  * const functions[4] =          transfer_operation_16to8_t  * const functions[2] =
349                  {                  {
350                          (transfer_operation_16to8_t*)transfer_16to8copy,                          (transfer_operation_16to8_t*)transfer_16to8copy,
351                          (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  
352                  };                  };
353    
354          transfer_operation_16to8_t *transfer_op = NULL;          transfer_operation_16to8_t *transfer_op = NULL;
355    
356            /* Image pointers */
357            pY_Cur = pCurrent->y + (y_pos << 4) * stride  + (x_pos << 4);
358            pU_Cur = pCurrent->u + (y_pos << 3) * stride2 + (x_pos << 3);
359            pV_Cur = pCurrent->v + (y_pos << 3) * stride2 + (x_pos << 3);
360    
361          if (pMB->field_dct) {          if (pMB->field_dct) {
362                  next_block = stride;                  next_block = stride;
363                  stride *= 2;                  stride *= 2;
364          }          }
365    
         /* 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;  
   
366          /* Operation function */          /* Operation function */
367          transfer_op = functions[(vop_reduced<<1) + add];          transfer_op = functions[add];
368    
369          /* Do the operation */          /* Do the operation */
370          start_timer();          start_timer();
371          if (cbp&32) transfer_op(pY_Cur,                    &data[0 * 64], stride);          if (cbp&32) transfer_op(pY_Cur,                    &data[0 * 64], stride);
372          if (cbp&16) transfer_op(pY_Cur + cst,              &data[1 * 64], stride);          if (cbp&16) transfer_op(pY_Cur + 8,                                     &data[1 * 64], stride);
373          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);
374          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);
375          if (cbp& 2) transfer_op(pU_Cur,                    &data[4 * 64], stride2);          if (cbp& 2) transfer_op(pU_Cur,                    &data[4 * 64], stride2);
376          if (cbp& 1) transfer_op(pV_Cur,                    &data[5 * 64], stride2);          if (cbp& 1) transfer_op(pV_Cur,                    &data[5 * 64], stride2);
377          stop_transfer_timer();          stop_transfer_timer();
# Line 778  Line 756 
756          return -1;          return -1;
757  }  }
758    
 static int __inline  
 Compute_Sum(const int16_t *C, int last)  
 {  
         int sum = 0;  
   
         while(last--)  
                 sum += abs(C[last]);  
   
         return(sum);  
 }  
   
759  /* this routine has been strippen of all debug code */  /* this routine has been strippen of all debug code */
760  static int  static int
761  dct_quantize_trellis_c(int16_t *const Out,  dct_quantize_trellis_c(int16_t *const Out,
# Line 796  Line 763 
763                                             int Q,                                             int Q,
764                                             const uint16_t * const Zigzag,                                             const uint16_t * const Zigzag,
765                                             const uint16_t * const QuantMatrix,                                             const uint16_t * const QuantMatrix,
766                                             int Non_Zero)                                             int Non_Zero,
767                                               int Sum)
768  {  {
769    
770          /* 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 819  Line 787 
787          int Last_Node = -1;          int Last_Node = -1;
788          uint32_t Last_Cost = 0;          uint32_t Last_Cost = 0;
789    
790          int i, j, sum;          int i, j;
791    
792          /* source (w/ CBP penalty) */          /* source (w/ CBP penalty) */
793          Run_Costs[-1] = 2<<TL_SHIFT;          Run_Costs[-1] = 2<<TL_SHIFT;
# Line 999  Line 967 
967                  }                  }
968          }          }
969    
970          /* It seems trellis doesn't give good results... just compute the Out sum          /* It seems trellis doesn't give good results... just leave the block untouched
971           * and quit */           * and return the original sum value */
972          if (Last_Node<0)          if (Last_Node<0)
973                  return Compute_Sum(Out, Non_Zero);                  return Sum;
974    
975          /* reconstruct optimal sequence backward with surviving paths */          /* reconstruct optimal sequence backward with surviving paths */
976          memset(Out, 0x00, 64*sizeof(*Out));          memset(Out, 0x00, 64*sizeof(*Out));
977          Out[Zigzag[Last_Node]] = Last.Level;          Out[Zigzag[Last_Node]] = Last.Level;
978          i = Last_Node - Last.Run;          i = Last_Node - Last.Run;
979          sum = 0;          Sum = abs(Last.Level);
980          while(i>=0) {          while(i>=0) {
981                  Out[Zigzag[i]] = Nodes[i].Level;                  Out[Zigzag[i]] = Nodes[i].Level;
982                  sum += abs(Nodes[i].Level);                  Sum += abs(Nodes[i].Level);
983                  i -= Nodes[i].Run;                  i -= Nodes[i].Run;
984          }          }
985    
986          return sum;          return Sum;
987  }  }
988    
989  /* original version including heavy debugging info */  /* original version including heavy debugging info */
Legend:
Removed from v.1.21.2.20  
changed lines
  Added in v.1.27
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4