1. /*
  2.     Project  : H.264 encoder test    
  3.     Module   : Quantization
  4.  
  5.     Author   : Marko 'Fador' Viitanen
  6.  
  7.     Date     : 28/6/2009
  8.     Modified : 28/6/2009
  9. */
  10. #include "common.h"
  11. #include "tables.h"
  12.  
  13.  
  14. /*
  15. //Inverse
  16. double E_i[4*4]= {
  17.     0.25000,   0.31623,   0.25000,   0.31623,
  18.     0.31623,   0.40000,   0.31623,   0.40000,
  19.     0.25000,   0.31623,   0.25000,   0.31623,
  20.     0.31623,   0.40000,   0.31623,   0.40000
  21. };
  22.  
  23. //E=[a^2,(a*b)/2,a^2,(a*b)/2;(1*b)/2,(b^2)/4,(a*b)/2,(b^2)/4;a^2,(a*b)/2,a^2,(a*b)/2;(a*b)/2,(b^2)/4,(a*b)/2,(b^2)/4]
  24.  
  25. //Forward
  26. double E_f[4*4]={
  27.    0.25000,   0.15811,   0.25000,   0.15811,
  28.    0.15811,   0.10000,   0.15811,   0.10000,
  29.    0.25000,   0.15811,   0.25000,   0.15811,
  30.    0.15811,   0.10000,   0.15811,   0.10000
  31.  
  32. };
  33. */
  34.  
  35. void init_QPstep()
  36. {
  37.     static const double Qsteps[6] = { 0.625, 0.6875, 0.8125, 0.875, 1.0, 1.125 };
  38.     uint8 i;
  39.  
  40.     //QPstep doubles every 6th QP
  41.     for(i=0;i<52;i++)
  42.     {
  43.         Qstep[i]=Qsteps[i%6]*(1<<(i/6));
  44.     }
  45. }
  46.  
  47. void init_MF()
  48. {
  49.     uint8 QP;
  50.  
  51.     uint16 PF1[6]={13107,11916,10082,9362,8192,7282};
  52.     uint16 PF2[6]={5243,4660,4194,3647,3355,2893};
  53.     uint16 PF3[6]={8066,7490,6554,5825,5243,4559};
  54.  
  55.     for(QP=0;QP<52;QP++)
  56.     {
  57.         MF[QP][0]=PF1[QP%6];
  58.         MF[QP][1]=PF2[QP%6];
  59.         MF[QP][2]=PF3[QP%6];        
  60.     }    
  61. }
  62.  
  63. void init_V()
  64. {
  65.     uint32 QP;
  66.  
  67.     uint32 V1[6]={10,11,13,14,16,18};
  68.     uint32 V2[6]={16,18,20,23,25,29};
  69.     uint32 V3[6]={13,14,16,18,20,23};
  70.  
  71.     for(QP=0;QP<52;QP++)
  72.     {
  73.         V[QP][0]=V1[QP%6]<<(QP/6);
  74.         V[QP][1]=V2[QP%6]<<(QP/6);
  75.         V[QP][2]=V3[QP%6]<<(QP/6);
  76.     }    
  77. }
  78.  
  79. void init_quant()
  80. {
  81.     init_QPstep();
  82.     init_MF();
  83.     init_V();
  84. }
  85. //Quantisation for 4x4 blocks, mode 0 for intra, 1 for inter
  86. uint8 quant_4x4(sint32* block, sint32* target, uint32 QP, uint32 mode)
  87. {
  88.  
  89.     uint32 i;
  90.     uint32 qbits=(15+(QP/6));
  91.     uint32 divider=mode?6:3;
  92.     uint32 helper;
  93.     uint32 qval=((1<<qbits)/divider);
  94.     uint32 MFtable[16]={MF[QP][0],MF[QP][2],MF[QP][0],MF[QP][2],
  95.                         MF[QP][2],MF[QP][1],MF[QP][2],MF[QP][1],
  96.                         MF[QP][0],MF[QP][2],MF[QP][0],MF[QP][2],
  97.                         MF[QP][2],MF[QP][1],MF[QP][2],MF[QP][1]};
  98.  
  99.     //Zij=round(Wij*(MF/2^qbits));
  100.     for(i=0;i<16;i++)
  101.     {
  102.         //Defined in book page 192
  103.         helper=((uint32)(abs(block[i])*MFtable[i]+qval))>>qbits;
  104.         if(block[i]<0) target[i]=-1*helper;
  105.         else target[i]=helper;
  106.     }
  107.  
  108.    
  109.     return 1;
  110. }
  111.  
  112. //Inverse quantisation for 4x4 blocks
  113. uint8 rescale_4x4(sint32* block, sint32* target, uint32 QP)
  114. {
  115.  
  116.    
  117.     uint32 i;
  118.     uint32 helper;
  119.  
  120.     uint32 Vtable[16]={V[QP][0],V[QP][2],V[QP][0],V[QP][2],
  121.                         V[QP][2],V[QP][1],V[QP][2],V[QP][1],
  122.                         V[QP][0],V[QP][2],V[QP][0],V[QP][2],
  123.                         V[QP][2],V[QP][1],V[QP][2],V[QP][1]};
  124.  
  125.     for(i=0;i<16;i++)
  126.     {
  127.         target[i]=block[i]*Vtable[i]/**(1<<(QP/6))*/;
  128.     }
  129.    
  130.     return 1;
  131. }
  132.  
  133. //Quantisation for DC 4x4 blocks, mode 0 for intra, 1 for inter
  134. uint8 quantDC_4x4(sint32* block, sint32* target, uint32 QP, uint32 mode)
  135. {
  136.  
  137.     uint32 i;
  138.  
  139.     uint32 qbits=(15+(QP/6));
  140.     uint32 divider=mode?6:3;
  141.     uint32 helper;
  142.     uint32 qval=2*((1<<qbits)/divider);
  143.  
  144.     //|Zij| = (|Yij*MF[0]+qval) >> (qbits-1)
  145.     for(i=0;i<16;i++)
  146.     {
  147.         //Defined in book page 194
  148.         helper=((uint32)(abs(block[i])*MF[QP][0]+qval))>>(qbits-1);
  149.         if(block[i]<0) target[i]=-1*helper;
  150.         else target[i]=helper;
  151.     }    
  152.     return 1;
  153. }
  154.  
  155.  
  156. //Inverse quantisation for 4x4 DC blocks
  157. uint8 rescaleDC_4x4(sint32* block, sint32* target, uint32 QP)
  158. {
  159.  
  160.    
  161.     uint32 i;
  162.     uint32 helper;
  163.  
  164.     if(QP>=12)
  165.     {
  166.         for(i=0;i<16;i++)
  167.         {
  168.             target[i]=block[i]*V[QP][0]*(1<<((QP/6)-2));
  169.         }
  170.     }
  171.     else
  172.     {
  173.         for(i=0;i<16;i++)
  174.         {
  175.             helper=(abs(block[i])*V[QP][0]*(1<<(1-(QP/6))))>>(2-(QP/6));
  176.             if(block[i]<0) target[i]=-1*helper;
  177.             else target[i]=helper;
  178.         }
  179.     }
  180.    
  181.     return 1;
  182. }
  183.  
  184.  
  185. //Quantisation for DC 2x2 blocks, mode 0 for intra, 1 for inter
  186. uint8 quantDC_2x2(sint32* block, sint32* target, uint32 QP, uint32 mode)
  187. {
  188.  
  189.     uint32 i;
  190.  
  191.     uint32 qbits=(15+(QP/6));
  192.     uint32 divider=mode?6:3;
  193.     uint32 helper;
  194.     uint32 qval=2*((1<<qbits)/divider);
  195.  
  196.     //|Zij| = (|Yij*MF[0]+qval) >> (qbits-1)
  197.     for(i=0;i<4;i++)
  198.     {
  199.         //Defined in book page 194
  200.         helper=((uint32)(abs(block[i])*MF[QP][0]+qval))>>(qbits+1);
  201.         if(block[i]<0) target[i]=-1*helper;
  202.         else target[i]=helper;
  203.     }    
  204.     return 1;
  205. }
  206.  
  207. //Inverse quantisation for 2x2 DC blocks
  208. uint8 rescaleDC_2x2(sint32* block, sint32* target, uint32 QP)
  209. {
  210.  
  211.    
  212.     uint32 i;
  213.     uint32 helper;
  214.  
  215.     if(QP>=6)
  216.     {
  217.         for(i=0;i<4;i++)
  218.         {
  219.             target[i]=block[i]*V[QP][0]*(1<<((QP/6)-1));
  220.         }
  221.     }
  222.     else
  223.     {
  224.         for(i=0;i<4;i++)
  225.         {
  226.             helper=(abs(block[i])*V[QP][0])>>1;
  227.             if(block[i]<0) target[i]=-1*helper;
  228.             else target[i]=helper;
  229.         }
  230.     }
  231.    
  232.     return 1;
  233. }
  234.  
  235.  
  236.