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

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

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

revision 1382, Mon Mar 22 22:36:25 2004 UTC revision 1663, Sat Dec 10 05:20:35 2005 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.23 2004-03-22 22:36:24 edgomez Exp $   * $Id: mbtransquant.c,v 1.31 2005-12-10 05:20:35 syskin Exp $
25   *   *
26   ****************************************************************************/   ****************************************************************************/
27    
# 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 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                                               int Lambda_Mod);
188    
189  /* Quantize all blocks -- Inter mode */  /* Quantize all blocks -- Inter mode */
190  static __inline uint8_t  static __inline uint8_t
# Line 216  Line 217 
217    
218                  sum = quant[mpeg](&qcoeff[i*64], &data[i*64], pMB->quant, pParam->mpeg_quant_matrices);                  sum = quant[mpeg](&qcoeff[i*64], &data[i*64], pMB->quant, pParam->mpeg_quant_matrices);
219    
220                  if(sum && (frame->vop_flags & XVID_VOP_TRELLISQUANT)) {                  if(sum && (pMB->quant > 2) && (frame->vop_flags & XVID_VOP_TRELLISQUANT)) {
221                          const uint16_t *matrix;                          const uint16_t *matrix;
222                          const static uint16_t h263matrix[] =                          const static uint16_t h263matrix[] =
223                                  {                                  {
# Line 234  Line 235 
235                          sum = dct_quantize_trellis_c(&qcoeff[i*64], &data[i*64],                          sum = dct_quantize_trellis_c(&qcoeff[i*64], &data[i*64],
236                                                                                   pMB->quant, &scan_tables[0][0],                                                                                   pMB->quant, &scan_tables[0][0],
237                                                                                   matrix,                                                                                   matrix,
238                                                                                   63);                                                                                   63,
239                                                                                     sum,
240                                                                                     pMB->lambda[i]);
241                  }                  }
242                  stop_quant_timer();                  stop_quant_timer();
243    
# Line 308  Line 311 
311          uint32_t stride = pParam->edged_width;          uint32_t stride = pParam->edged_width;
312          uint32_t stride2 = stride / 2;          uint32_t stride2 = stride / 2;
313          uint32_t next_block = stride * 8;          uint32_t next_block = stride * 8;
         int32_t cst;  
         int vop_reduced;  
314          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;          uint8_t *pY_Cur, *pU_Cur, *pV_Cur;
315          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);  
316    
317          /* Image pointers */          /* Image pointers */
318          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);
319          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);
320          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];  
321    
322          /* Do the transfer */          /* Do the transfer */
323          start_timer();          start_timer();
324          transfer_op(&data[0 * 64], pY_Cur, stride);          transfer_8to16copy(&data[0 * 64], pY_Cur, stride);
325          transfer_op(&data[1 * 64], pY_Cur + cst, stride);          transfer_8to16copy(&data[1 * 64], pY_Cur + 8, stride);
326          transfer_op(&data[2 * 64], pY_Cur + next_block, stride);          transfer_8to16copy(&data[2 * 64], pY_Cur + next_block, stride);
327          transfer_op(&data[3 * 64], pY_Cur + next_block + cst, stride);          transfer_8to16copy(&data[3 * 64], pY_Cur + next_block + 8, stride);
328          transfer_op(&data[4 * 64], pU_Cur, stride2);          transfer_8to16copy(&data[4 * 64], pU_Cur, stride2);
329          transfer_op(&data[5 * 64], pV_Cur, stride2);          transfer_8to16copy(&data[5 * 64], pV_Cur, stride2);
330          stop_transfer_timer();          stop_transfer_timer();
331  }  }
332    
# Line 357  Line 344 
344          uint32_t stride = pParam->edged_width;          uint32_t stride = pParam->edged_width;
345          uint32_t stride2 = stride / 2;          uint32_t stride2 = stride / 2;
346          uint32_t next_block = stride * 8;          uint32_t next_block = stride * 8;
         uint32_t cst;  
         int vop_reduced;  
347          const IMAGE * const pCurrent = &frame->image;          const IMAGE * const pCurrent = &frame->image;
348    
349          /* Array of function pointers, indexed by [vop_reduced<<1+add] */          /* Array of function pointers, indexed by [add] */
350          transfer_operation_16to8_t  * const functions[4] =          transfer_operation_16to8_t  * const functions[2] =
351                  {                  {
352                          (transfer_operation_16to8_t*)transfer_16to8copy,                          (transfer_operation_16to8_t*)transfer_16to8copy,
353                          (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  
354                  };                  };
355    
356          transfer_operation_16to8_t *transfer_op = NULL;          transfer_operation_16to8_t *transfer_op = NULL;
357    
         /* Makes this vars booleans */  
         vop_reduced = !!(frame->vop_flags & XVID_VOP_REDUCED);  
   
358          /* Image pointers */          /* Image pointers */
359          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);
360          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);
361          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);
362    
363          if (pMB->field_dct) {          if (pMB->field_dct) {
364                  next_block = stride;                  next_block = stride;
365                  stride *= 2;                  stride *= 2;
366          }          }
367    
         /* Block size */  
         cst = 8<<vop_reduced;  
   
368          /* Operation function */          /* Operation function */
369          transfer_op = functions[(vop_reduced<<1) + add];          transfer_op = functions[add];
370    
371          /* Do the operation */          /* Do the operation */
372          start_timer();          start_timer();
373          if (cbp&32) transfer_op(pY_Cur,                    &data[0 * 64], stride);          if (cbp&32) transfer_op(pY_Cur,                    &data[0 * 64], stride);
374          if (cbp&16) transfer_op(pY_Cur + cst,              &data[1 * 64], stride);          if (cbp&16) transfer_op(pY_Cur + 8,                                     &data[1 * 64], stride);
375          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);
376          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);
377          if (cbp& 2) transfer_op(pU_Cur,                    &data[4 * 64], stride2);          if (cbp& 2) transfer_op(pU_Cur,                    &data[4 * 64], stride2);
378          if (cbp& 1) transfer_op(pV_Cur,                    &data[5 * 64], stride2);          if (cbp& 1) transfer_op(pV_Cur,                    &data[5 * 64], stride2);
379          stop_transfer_timer();          stop_transfer_timer();
# Line 781  Line 758 
758          return -1;          return -1;
759  }  }
760    
761  static int __inline  #define TRELLIS_MIN_EFFORT      3
 Compute_Sum(const int16_t *C, int last)  
 {  
         int sum = 0;  
   
         while(last--)  
                 sum += abs(C[last]);  
   
         return(sum);  
 }  
762    
763  /* this routine has been strippen of all debug code */  /* this routine has been strippen of all debug code */
764  static int  static int
# Line 799  Line 767 
767                                             int Q,                                             int Q,
768                                             const uint16_t * const Zigzag,                                             const uint16_t * const Zigzag,
769                                             const uint16_t * const QuantMatrix,                                             const uint16_t * const QuantMatrix,
770                                             int Non_Zero)                                             int Non_Zero,
771                                               int Sum,
772                                               int Lambda_Mod)
773  {  {
774    
775          /* 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 809  Line 779 
779           * helps. */           * helps. */
780          typedef struct { int16_t Run, Level; } NODE;          typedef struct { int16_t Run, Level; } NODE;
781    
782          NODE Nodes[65], Last;          NODE Nodes[65], Last = { 0, 0};
783          uint32_t Run_Costs0[64+1];          uint32_t Run_Costs0[64+1];
784          uint32_t * const Run_Costs = Run_Costs0 + 1;          uint32_t * const Run_Costs = Run_Costs0 + 1;
785    
786          /* it's 1/lambda, actually */          /* it's 1/lambda, actually */
787          const int Lambda = Trellis_Lambda_Tabs[Q-1];          const int Lambda = (Lambda_Mod*Trellis_Lambda_Tabs[Q-1])>>LAMBDA_EXP;
788    
789          int Run_Start = -1;          int Run_Start = -1;
790          uint32_t Min_Cost = 2<<TL_SHIFT;          uint32_t Min_Cost = 2<<TL_SHIFT;
# Line 822  Line 792 
792          int Last_Node = -1;          int Last_Node = -1;
793          uint32_t Last_Cost = 0;          uint32_t Last_Cost = 0;
794    
795          int i, j, sum;          int i, j;
796    
797          /* source (w/ CBP penalty) */          /* source (w/ CBP penalty) */
798          Run_Costs[-1] = 2<<TL_SHIFT;          Run_Costs[-1] = 2<<TL_SHIFT;
799    
800          Non_Zero = Find_Last(Out, Zigzag, Non_Zero);          Non_Zero = Find_Last(Out, Zigzag, Non_Zero);
801          if (Non_Zero<0)          if (Non_Zero < TRELLIS_MIN_EFFORT)
802                  return 0; /* Sum is zero if there are only zero coeffs */                  Non_Zero = TRELLIS_MIN_EFFORT;
803    
804          for(i=0; i<=Non_Zero; i++) {          for(i=0; i<=Non_Zero; i++) {
805                  const int q = ((Q*QuantMatrix[Zigzag[i]])>>4);                  const int q = ((Q*QuantMatrix[Zigzag[i]])>>4);
# Line 1002  Line 972 
972                  }                  }
973          }          }
974    
975          /* 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
976           * and quit */           * and return the original sum value */
977          if (Last_Node<0)          if (Last_Node<0)
978                  return Compute_Sum(Out, Non_Zero);                  return Sum;
979    
980          /* reconstruct optimal sequence backward with surviving paths */          /* reconstruct optimal sequence backward with surviving paths */
981          memset(Out, 0x00, 64*sizeof(*Out));          memset(Out, 0x00, 64*sizeof(*Out));
982          Out[Zigzag[Last_Node]] = Last.Level;          Out[Zigzag[Last_Node]] = Last.Level;
983          i = Last_Node - Last.Run;          i = Last_Node - Last.Run;
984          sum = 0;          Sum = abs(Last.Level);
985          while(i>=0) {          while(i>=0) {
986                  Out[Zigzag[i]] = Nodes[i].Level;                  Out[Zigzag[i]] = Nodes[i].Level;
987                  sum += abs(Nodes[i].Level);                  Sum += abs(Nodes[i].Level);
988                  i -= Nodes[i].Run;                  i -= Nodes[i].Run;
989          }          }
990    
991          return sum;          return Sum;
992  }  }
993    
994  /* original version including heavy debugging info */  /* original version including heavy debugging info */
Legend:
Removed from v.1382  
changed lines
  Added in v.1663
No admin address has been configured
 ViewVC Help
Powered by ViewVC 1.0.4