开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
quant.c
资源名称：X264CODEC.rar　[点击查看]
上传用户：lctgjx
上传日期：2022-06-04
资源大小：8887k
文件大小：13k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

quant.c：源码内容
  1. /*****************************************************************************
  2. * quant.c: h264 encoder
  3. *****************************************************************************
  4. * Copyright (C) 2007 Guillaume Poirier <gpoirier@mplayerhq.hu>
  5. *
  6. * This program is free software; you can redistribute it and/or modify
  7. * it under the terms of the GNU General Public License as published by
  8. * the Free Software Foundation; either version 2 of the License, or
  9. * (at your option) any later version.
  10. *
  11. * This program is distributed in the hope that it will be useful,
  12. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. * GNU General Public License for more details.
  15. *
  16. * You should have received a copy of the GNU General Public License
  17. * along with this program; if not, write to the Free Software
  18. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111, USA.
  19. *****************************************************************************/
  21. #include "common/common.h"
  22. #include "ppccommon.h"
  23. #include "quant.h"            
  25. // quant of a whole 4x4 block, unrolled 2x and "pre-scheduled"
  26. #define QUANT_16_U( idx0, idx1 )                                             
  27. temp1v = vec_ld((idx0), *dct);                                               
  28. temp2v = vec_ld((idx1), *dct);                                               
  29. mfvA = vec_ld((idx0), mf);                                                   
  30. mfvB = vec_ld((idx1), mf);                                                   
  31. biasvA = vec_ld((idx0), bias);                                               
  32. biasvB = vec_ld((idx1), bias);                                               
  33. mskA = vec_cmplt(temp1v, zero_s16v);                                         
  34. mskB = vec_cmplt(temp2v, zero_s16v);                                         
  35. coefvA = (vec_u16_t)vec_max(vec_sub(zero_s16v, temp1v), temp1v);             
  36. coefvB = (vec_u16_t)vec_max(vec_sub(zero_s16v, temp2v), temp2v);             
  37. coefvA = vec_adds(coefvA, biasvA);                                           
  38. coefvB = vec_adds(coefvB, biasvB);                                           
  39. multEvenvA = vec_mule(coefvA, mfvA);                                         
  40. multOddvA = vec_mulo(coefvA, mfvA);                                          
  41. multEvenvB = vec_mule(coefvB, mfvB);                                         
  42. multOddvB = vec_mulo(coefvB, mfvB);                                          
  43. multEvenvA = vec_sr(multEvenvA, i_qbitsv);                                   
  44. multOddvA = vec_sr(multOddvA, i_qbitsv);                                     
  45. multEvenvB = vec_sr(multEvenvB, i_qbitsv);                                   
  46. multOddvB = vec_sr(multOddvB, i_qbitsv);                                     
  47. temp1v = (vec_s16_t) vec_packs(vec_mergeh(multEvenvA, multOddvA), vec_mergel(multEvenvA, multOddvA)); 
  48. temp2v = (vec_s16_t) vec_packs(vec_mergeh(multEvenvB, multOddvB), vec_mergel(multEvenvB, multOddvB)); 
  49. temp1v = vec_xor(temp1v, mskA);                                              
  50. temp2v = vec_xor(temp2v, mskB);                                              
  51. temp1v = vec_adds(temp1v, vec_and(mskA, one));                               
  52. vec_st(temp1v, (idx0), (int16_t*)dct);                                       
  53. temp2v = vec_adds(temp2v, vec_and(mskB, one));                               
  54. nz = vec_or(nz, vec_or(temp1v, temp2v));                                     
  55. vec_st(temp2v, (idx1), (int16_t*)dct);
  56.                 
  57. int x264_quant_4x4_altivec( int16_t dct[4][4], uint16_t mf[16], uint16_t bias[16] )
  58. {
  59.     LOAD_ZERO;
  60.     vector bool short mskA;
  61.     vec_u32_t i_qbitsv;
  62.     vec_u16_t coefvA;
  63.     vec_u32_t multEvenvA, multOddvA;
  64.     vec_u16_t mfvA;
  65.     vec_u16_t biasvA;
  66.     vec_s16_t one = vec_splat_s16(1);;
  67.     vec_s16_t nz = zero_s16v;
  69.     vector bool short mskB;
  70.     vec_u16_t coefvB;
  71.     vec_u32_t multEvenvB, multOddvB;
  72.     vec_u16_t mfvB;
  73.     vec_u16_t biasvB;
  75.     vec_s16_t temp1v, temp2v;
  77.     vec_u32_u qbits_u;
  78.     qbits_u.s[0]=16;
  79.     i_qbitsv = vec_splat(qbits_u.v, 0);
  81.     QUANT_16_U( 0, 16 );
  82.     return vec_any_ne(nz, zero_s16v);
  83. }
  85. // DC quant of a whole 4x4 block, unrolled 2x and "pre-scheduled"
  86. #define QUANT_16_U_DC( idx0, idx1 )                             
  87. temp1v = vec_ld((idx0), *dct);                                  
  88. temp2v = vec_ld((idx1), *dct);                                  
  89. mskA = vec_cmplt(temp1v, zero_s16v);                            
  90. mskB = vec_cmplt(temp2v, zero_s16v);                            
  91. coefvA = (vec_u16_t)vec_max(vec_sub(zero_s16v, temp1v), temp1v);
  92. coefvB = (vec_u16_t)vec_max(vec_sub(zero_s16v, temp2v), temp2v);
  93. coefvA = vec_add(coefvA, biasv);                                
  94. coefvB = vec_add(coefvB, biasv);                                
  95. multEvenvA = vec_mule(coefvA, mfv);                             
  96. multOddvA = vec_mulo(coefvA, mfv);                              
  97. multEvenvB = vec_mule(coefvB, mfv);                             
  98. multOddvB = vec_mulo(coefvB, mfv);                              
  99. multEvenvA = vec_sr(multEvenvA, i_qbitsv);                      
  100. multOddvA = vec_sr(multOddvA, i_qbitsv);                        
  101. multEvenvB = vec_sr(multEvenvB, i_qbitsv);                      
  102. multOddvB = vec_sr(multOddvB, i_qbitsv);                        
  103. temp1v = (vec_s16_t) vec_packs(vec_mergeh(multEvenvA, multOddvA), vec_mergel(multEvenvA, multOddvA)); 
  104. temp2v = (vec_s16_t) vec_packs(vec_mergeh(multEvenvB, multOddvB), vec_mergel(multEvenvB, multOddvB)); 
  105. temp1v = vec_xor(temp1v, mskA);                                 
  106. temp2v = vec_xor(temp2v, mskB);                                 
  107. temp1v = vec_add(temp1v, vec_and(mskA, one));                   
  108. vec_st(temp1v, (idx0), (int16_t*)dct);                          
  109. temp2v = vec_add(temp2v, vec_and(mskB, one));                   
  110. nz = vec_or(nz, vec_or(temp1v, temp2v));                        
  111. vec_st(temp2v, (idx1), (int16_t*)dct);
  113. int x264_quant_4x4_dc_altivec( int16_t dct[4][4], int mf, int bias )
  114. {
  115.     LOAD_ZERO;
  116.     vector bool short mskA;
  117.     vec_u32_t i_qbitsv;
  118.     vec_u16_t coefvA;
  119.     vec_u32_t multEvenvA, multOddvA;
  120.     vec_s16_t one = vec_splat_s16(1);
  121.     vec_s16_t nz = zero_s16v;
  123.     vector bool short mskB;
  124.     vec_u16_t coefvB;
  125.     vec_u32_t multEvenvB, multOddvB;
  127.     vec_s16_t temp1v, temp2v;
  129.     vec_u16_t mfv;
  130.     vec_u16_t biasv;
  132.     vec_u16_u mf_u;
  133.     mf_u.s[0]=mf;
  134.     mfv = vec_splat( mf_u.v, 0 );
  136.     vec_u32_u qbits_u;
  137.     qbits_u.s[0]=16;
  138.     i_qbitsv = vec_splat(qbits_u.v, 0);
  140.     vec_u16_u bias_u;
  141.     bias_u.s[0]=bias;
  142.     biasv = vec_splat(bias_u.v, 0);
  144.     QUANT_16_U_DC( 0, 16 );
  145.     return vec_any_ne(nz, zero_s16v);
  146. }
  148. // DC quant of a whole 2x2 block
  149. #define QUANT_4_U_DC( idx0 )                                    
  150. const vec_u16_t sel = (vec_u16_t) CV(-1,-1,-1,-1,0,0,0,0);      
  151. temp1v = vec_ld((idx0), *dct);                                  
  152. mskA = vec_cmplt(temp1v, zero_s16v);                            
  153. coefvA = (vec_u16_t)vec_max(vec_sub(zero_s16v, temp1v), temp1v);
  154. coefvA = vec_add(coefvA, biasv);                                
  155. multEvenvA = vec_mule(coefvA, mfv);                             
  156. multOddvA = vec_mulo(coefvA, mfv);                              
  157. multEvenvA = vec_sr(multEvenvA, i_qbitsv);                      
  158. multOddvA = vec_sr(multOddvA, i_qbitsv);                        
  159. temp2v = (vec_s16_t) vec_packs(vec_mergeh(multEvenvA, multOddvA), vec_mergel(multEvenvA, multOddvA)); 
  160. temp2v = vec_xor(temp2v, mskA);                                 
  161. temp2v = vec_add(temp2v, vec_and(mskA, one));                   
  162. temp1v = vec_sel(temp1v, temp2v, sel);                          
  163. nz = vec_or(nz, temp1v);                                        
  164. vec_st(temp1v, (idx0), (int16_t*)dct);
  166. int x264_quant_2x2_dc_altivec( int16_t dct[2][2], int mf, int bias )
  167. {
  168.     LOAD_ZERO;
  169.     vector bool short mskA;
  170.     vec_u32_t i_qbitsv;
  171.     vec_u16_t coefvA;
  172.     vec_u32_t multEvenvA, multOddvA;
  173.     vec_s16_t one = vec_splat_s16(1);
  174.     vec_s16_t nz = zero_s16v;
  176.     vec_s16_t temp1v, temp2v;
  178.     vec_u16_t mfv;
  179.     vec_u16_t biasv;
  181.     vec_u16_u mf_u;
  182.     mf_u.s[0]=mf;
  183.     mfv = vec_splat( mf_u.v, 0 );
  185.     vec_u32_u qbits_u;
  186.     qbits_u.s[0]=16;
  187.     i_qbitsv = vec_splat(qbits_u.v, 0);
  189.     vec_u16_u bias_u;
  190.     bias_u.s[0]=bias;
  191.     biasv = vec_splat(bias_u.v, 0);
  193.     static const vec_s16_t mask2 = CV(-1, -1, -1, -1,  0, 0, 0, 0);
  194.     QUANT_4_U_DC(0);
  195.     return vec_any_ne(vec_and(nz, mask2), zero_s16v);
  196. }
  198. int x264_quant_8x8_altivec( int16_t dct[8][8], uint16_t mf[64], uint16_t bias[64] )
  199. {
  200.     LOAD_ZERO;
  201.     vector bool short mskA;
  202.     vec_u32_t i_qbitsv;
  203.     vec_u16_t coefvA;
  204.     vec_u32_t multEvenvA, multOddvA;
  205.     vec_u16_t mfvA;
  206.     vec_u16_t biasvA;
  207.     vec_s16_t one = vec_splat_s16(1);;
  208.     vec_s16_t nz = zero_s16v;
  210.     vector bool short mskB;
  211.     vec_u16_t coefvB;
  212.     vec_u32_t multEvenvB, multOddvB;
  213.     vec_u16_t mfvB;
  214.     vec_u16_t biasvB;
  216.     vec_s16_t temp1v, temp2v;
  217.     
  218.     vec_u32_u qbits_u;
  219.     qbits_u.s[0]=16;
  220.     i_qbitsv = vec_splat(qbits_u.v, 0);
  221.     
  222.     int i;
  224.     for ( i=0; i<4; i++ ) {
  225.       QUANT_16_U( i*2*16, i*2*16+16 );
  226.     }
  227.     return vec_any_ne(nz, zero_s16v);
  228. }
  230. #define DEQUANT_SHL()                                                
  231. {                                                                    
  232.     dctv = vec_ld(0, dct[y]);                                        
  233.     mf1v = vec_ld(0, dequant_mf[i_mf][y]);                           
  234.     mf2v = vec_ld(16, dequant_mf[i_mf][y]);                          
  235.     mfv  = vec_packs(mf1v, mf2v);                                    
  236.                                                                      
  237.     multEvenvA = vec_mule(dctv, mfv);                                
  238.     multOddvA = vec_mulo(dctv, mfv);                                 
  239.     dctv = (vec_s16_t) vec_packs(vec_mergeh(multEvenvA, multOddvA),  
  240.                                  vec_mergel(multEvenvA, multOddvA)); 
  241.     dctv = vec_sl(dctv, i_qbitsv);                                   
  242.     vec_st(dctv, 0, dct[y]);                                         
  243. }
  245. #define DEQUANT_SHR()                                          
  246. {                                                              
  247.     dctv = vec_ld(0, dct[y]);                                  
  248.     dct1v = vec_mergeh(dctv, dctv);                            
  249.     dct2v = vec_mergel(dctv, dctv);                            
  250.     mf1v = vec_ld(0, dequant_mf[i_mf][y]);                     
  251.     mf2v = vec_ld(16, dequant_mf[i_mf][y]);                    
  252.                                                                
  253.     multEvenvA = vec_mule(dct1v, (vec_s16_t)mf1v);             
  254.     multOddvA = vec_mulo(dct1v, (vec_s16_t)mf1v);              
  255.     temp1v = vec_add(vec_sl(multEvenvA, sixteenv), multOddvA); 
  256.     temp1v = vec_add(temp1v, fv);                              
  257.     temp1v = vec_sra(temp1v, i_qbitsv);                        
  258.                                                                
  259.     multEvenvA = vec_mule(dct2v, (vec_s16_t)mf2v);             
  260.     multOddvA = vec_mulo(dct2v, (vec_s16_t)mf2v);              
  261.     temp2v = vec_add(vec_sl(multEvenvA, sixteenv), multOddvA); 
  262.     temp2v = vec_add(temp2v, fv);                              
  263.     temp2v = vec_sra(temp2v, i_qbitsv);                        
  264.                                                                
  265.     dctv = (vec_s16_t)vec_packs(temp1v, temp2v);               
  266.     vec_st(dctv, 0, dct[y]);                                   
  267. }
  269. void x264_dequant_4x4_altivec( int16_t dct[4][4], int dequant_mf[6][4][4], int i_qp )
  270. {
  271.     const int i_mf = i_qp%6;
  272.     const int i_qbits = i_qp/6 - 4;
  273.     int y;
  275.     vec_s16_t dctv;
  276.     vec_s16_t dct1v, dct2v;
  277.     vec_s32_t mf1v, mf2v;
  278.     vec_s16_t mfv;
  279.     vec_s32_t multEvenvA, multOddvA;
  280.     vec_s32_t temp1v, temp2v;
  282.     if( i_qbits >= 0 )
  283.     {
  284.         vec_u16_t i_qbitsv;
  285.         vec_u16_u qbits_u;
  286.         qbits_u.s[0]=i_qbits;
  287.         i_qbitsv = vec_splat(qbits_u.v, 0);
  289.         for( y = 0; y < 4; y+=2 )
  290.             DEQUANT_SHL();
  291.     }
  292.     else
  293.     {
  294.         const int f = 1 << (-i_qbits-1);
  296.         vec_s32_t fv;
  297.         vec_u32_u f_u;
  298.         f_u.s[0]=f;
  299.         fv = (vec_s32_t)vec_splat(f_u.v, 0);
  301.         vec_u32_t i_qbitsv;
  302.         vec_u32_u qbits_u;
  303.         qbits_u.s[0]=-i_qbits;
  304.         i_qbitsv = vec_splat(qbits_u.v, 0);
  306.         vec_u32_t sixteenv;
  307.         vec_u32_u sixteen_u;
  308.         sixteen_u.s[0]=16;
  309.         sixteenv = vec_splat(sixteen_u.v, 0);
  311.         for( y = 0; y < 4; y+=2 )
  312.             DEQUANT_SHR();
  313.     }
  314. }
  316. void x264_dequant_8x8_altivec( int16_t dct[8][8], int dequant_mf[6][8][8], int i_qp )
  317. {
  318.     const int i_mf = i_qp%6;
  319.     const int i_qbits = i_qp/6 - 6;
  320.     int y;
  322.     vec_s16_t dctv;
  323.     vec_s16_t dct1v, dct2v;
  324.     vec_s32_t mf1v, mf2v;
  325.     vec_s16_t mfv;
  326.     vec_s32_t multEvenvA, multOddvA;
  327.     vec_s32_t temp1v, temp2v;
  329.     if( i_qbits >= 0 )
  330.     {
  331.         vec_u16_t i_qbitsv;
  332.         vec_u16_u qbits_u;
  333.         qbits_u.s[0]=i_qbits;
  334.         i_qbitsv = vec_splat(qbits_u.v, 0);
  336.         for( y = 0; y < 8; y++ )
  337.             DEQUANT_SHL();
  338.     }
  339.     else
  340.     {
  341.         const int f = 1 << (-i_qbits-1);
  343.         vec_s32_t fv;
  344.         vec_u32_u f_u;
  345.         f_u.s[0]=f;
  346.         fv = (vec_s32_t)vec_splat(f_u.v, 0);
  348.         vec_u32_t i_qbitsv;
  349.         vec_u32_u qbits_u;
  350.         qbits_u.s[0]=-i_qbits;
  351.         i_qbitsv = vec_splat(qbits_u.v, 0);
  353.         vec_u32_t sixteenv;
  354.         vec_u32_u sixteen_u;
  355.         sixteen_u.s[0]=16;
  356.         sixteenv = vec_splat(sixteen_u.v, 0);
  358.         for( y = 0; y < 8; y++ )
  359.             DEQUANT_SHR();
  360.     }
  361. }