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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > Audio > 查看源码
cabac.h
资源名称：chapter15.rar　[点击查看]
上传用户：hjq518
上传日期：2021-12-09
资源大小：5084k
文件大小：10k
源码类别：

Audio

开发平台：

Visual C++

cabac.h：源码内容
  1. /*  * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>  *  * This library is free software; you can redistribute it and/or  * modify it under the terms of the GNU Lesser General Public  * License as published by the Free Software Foundation; either  * version 2 of the License, or (at your option) any later version.  *  * This library is distributed in the hope that it will be useful,  * but WITHOUT ANY WARRANTY; without even the implied warranty of  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU  * Lesser General Public License for more details.  *  * You should have received a copy of the GNU Lesser General Public  * License along with this library; if not, write to the Free Software  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA  *  */   /**  * @file cabac.h  * Context Adaptive Binary Arithmetic Coder.  */ #include "common.h" //Add by ty
  2. #undef NDEBUG #include <assert.h>
  4. typedef struct CABACContext{     int low;     int range;     int outstanding_count; #ifdef STRICT_LIMITS     int symCount; #endif     uint8_t lps_range[2*64][4];   ///< rangeTabLPS     uint8_t lps_state[2*64];      ///< transIdxLPS     uint8_t mps_state[2*64];      ///< transIdxMPS     const uint8_t *bytestream_start;     const uint8_t *bytestream;     const uint8_t *bytestream_end;     int bits_left;                ///<
  5.     PutBitContext pb;
  6. }CABACContext; extern const uint8_t ff_h264_lps_range[64][4]; extern const uint8_t ff_h264_mps_state[64]; extern const uint8_t ff_h264_lps_state[64]; void ff_init_cabac_encoder(CABACContext *c, uint8_t *buf, int buf_size);
  7. void ff_init_cabac_decoder(CABACContext *c, const uint8_t *buf, int buf_size);
  8. void ff_init_cabac_states(CABACContext *c, uint8_t const (*lps_range)[4], 
  9.                           uint8_t const *mps_state, uint8_t const *lps_state, int state_count);
  10. //static inline void put_cabac_bit(CABACContext *c, int b){
  11. static void put_cabac_bit(CABACContext *c, int b){
  12.     put_bits(&c->pb, 1, b); 
  13.     for(;c->outstanding_count; c->outstanding_count--){ 
  14.         put_bits(&c->pb, 1, 1-b);
  15.     }
  16. }
  17. //static inline void renorm_cabac_encoder(CABACContext *c){
  18. static void renorm_cabac_encoder(CABACContext *c){
  19.     while(c->range < 0x100){
  20.         //FIXME optimize
  21.         if(c->low<0x100){
  22.             put_cabac_bit(c, 0);
  23.         }else if(c->low<0x200){
  24.             c->outstanding_count++;
  25.             c->low -= 0x100;
  26.         }else{
  27.             put_cabac_bit(c, 1);
  28.             c->low -= 0x200;
  29.         }
  30.         
  31.         c->range+= c->range;
  32.         c->low += c->low;
  33.     }
  34. }
  35. //static inline void put_cabac(CABACContext *c, uint8_t * const state, int bit){
  36. static void put_cabac(CABACContext *c, uint8_t * const state, int bit){
  37.     int RangeLPS= c->lps_range[*state][((c->range)>>6)&3];
  38.     
  39.     if(bit == ((*state)&1)){
  40.         c->range -= RangeLPS;
  41.         *state= c->mps_state[*state];
  42.     }else{
  43.         c->low += c->range - RangeLPS;
  44.         c->range = RangeLPS;
  45.         *state= c->lps_state[*state];
  46.     }
  47.     
  48.     renorm_cabac_encoder(c);
  49. #ifdef STRICT_LIMITS
  50.     c->symCount++;
  51. #endif
  52. }
  53. static inline void put_cabac_static(CABACContext *c, int RangeLPS, int bit){
  54. //static void put_cabac_static(CABACContext *c, int RangeLPS, int bit){
  55.     assert(c->range > RangeLPS);
  56.     if(!bit){
  57.         c->range -= RangeLPS;
  58.     }else{
  59.         c->low += c->range - RangeLPS;
  60.         c->range = RangeLPS;
  61.     }
  62.     renorm_cabac_encoder(c);
  63. #ifdef STRICT_LIMITS
  64.     c->symCount++;
  65. #endif
  66. }
  67. /**
  68.  * @param bit 0 -> write zero bit, !=0 write one bit
  69.  */
  70. static inline void put_cabac_bypass(CABACContext *c, int bit){
  71. //static void put_cabac_bypass(CABACContext *c, int bit){
  72.     c->low += c->low;
  73.     if(bit){
  74.         c->low += c->range;
  75.     }
  76. //FIXME optimize
  77.     if(c->low<0x200){
  78.         put_cabac_bit(c, 0);
  79.     }else if(c->low<0x400){
  80.         c->outstanding_count++;
  81.         c->low -= 0x200;
  82.     }else{
  83.         put_cabac_bit(c, 1);
  84.         c->low -= 0x400;
  85.     }
  86.         
  87. #ifdef STRICT_LIMITS
  88.     c->symCount++;
  89. #endif
  90. }
  91. /**
  92.  *
  93.  * @return the number of bytes written
  94.  */
  95. //static inline int put_cabac_terminate(CABACContext *c, int bit){
  96. static int put_cabac_terminate(CABACContext *c, int bit){
  97.     c->range -= 2;
  98.     if(!bit){
  99.         renorm_cabac_encoder(c);
  100.     }else{
  101.         c->low += c->range;
  102.         c->range= 2;
  103.         
  104.         renorm_cabac_encoder(c);
  105.         assert(c->low <= 0x1FF);
  106.         put_cabac_bit(c, c->low>>9);
  107.         put_bits(&c->pb, 2, ((c->low>>7)&3)|1);
  108.         
  109.         flush_put_bits(&c->pb); //FIXME FIXME FIXME XXX wrong
  110.     }
  111.         
  112. #ifdef STRICT_LIMITS
  113.     c->symCount++;
  114. #endif
  115.     return (put_bits_count(&c->pb)+7)>>3;
  116. }
  117. /**
  118.  * put (truncated) unary binarization.
  119.  */
  120. //static inline void put_cabac_u(CABACContext *c, uint8_t * state, int v, int max, int max_index, int truncated){
  121. static void put_cabac_u(CABACContext *c, uint8_t * state, int v, int max, int max_index, int truncated){
  122.     int i;
  123.     
  124.     assert(v <= max);
  125.     
  126. #if 1
  127.     for(i=0; i<v; i++){
  128.         put_cabac(c, state, 1);
  129.         if(i < max_index) state++;
  130.     }
  131.     if(truncated==0 || v<max)
  132.         put_cabac(c, state, 0);
  133. #else
  134.     if(v <= max_index){
  135.         for(i=0; i<v; i++){
  136.             put_cabac(c, state+i, 1);
  137.         }
  138.         if(truncated==0 || v<max)
  139.             put_cabac(c, state+i, 0);
  140.     }else{
  141.         for(i=0; i<=max_index; i++){
  142.             put_cabac(c, state+i, 1);
  143.         }
  144.         for(; i<v; i++){
  145.             put_cabac(c, state+max_index, 1);
  146.         }
  147.         if(truncated==0 || v<max)
  148.             put_cabac(c, state+max_index, 0);
  149.     }
  150. #endif
  151. }
  152. /**
  153.  * put unary exp golomb k-th order binarization.
  154.  */
  155. //static inline void put_cabac_ueg(CABACContext *c, uint8_t * state, int v, int max, int is_signed, int k, int max_index){
  156. static void put_cabac_ueg(CABACContext *c, uint8_t * state, int v, int max, int is_signed, int k, int max_index){
  157.     int i;
  158.     
  159.     if(v==0)
  160.         put_cabac(c, state, 0);
  161.     else{
  162.         const int sign= v < 0;
  163.         
  164.         if(is_signed) v= ABS(v);
  165.         
  166.         if(v<max){
  167.             for(i=0; i<v; i++){
  168.                 put_cabac(c, state, 1);
  169.                 if(i < max_index) state++;
  170.             }
  171.             put_cabac(c, state, 0);
  172.         }else{
  173.             int m= 1<<k;
  174.             for(i=0; i<max; i++){
  175.                 put_cabac(c, state, 1);
  176.                 if(i < max_index) state++;
  177.             }
  178.             v -= max;
  179.             while(v >= m){ //FIXME optimize
  180.                 put_cabac_bypass(c, 1);
  181.                 v-= m;
  182.                 m+= m;
  183.             }
  184.             put_cabac_bypass(c, 0);
  185.             while(m>>=1){
  186.                 put_cabac_bypass(c, v&m);
  187.             }
  188.         }
  189.         if(is_signed)
  190.             put_cabac_bypass(c, sign);
  191.     }
  192. }
  193. //static inline void renorm_cabac_decoder(CABACContext *c){
  194. static void renorm_cabac_decoder(CABACContext *c){
  195.     while(c->range < 0x10000){
  196.         c->range+= c->range;
  197.         c->low+= c->low;
  198.         if(--c->bits_left == 0){
  199.             if(c->bytestream < c->bytestream_end)
  200.                 c->low+= *c->bytestream;
  201.             c->bytestream++;
  202.             c->bits_left= 8;
  203.         }
  204.     }
  205. }
  206. //static inline int get_cabac(CABACContext *c, uint8_t * const state){
  207. static int get_cabac(CABACContext *c, uint8_t * const state){
  208.     int RangeLPS= c->lps_range[*state][((c->range)>>14)&3]<<8;
  209.     int bit;
  210.     
  211.     c->range -= RangeLPS;
  212.     if(c->low < c->range){
  213.         bit= (*state)&1;
  214.         *state= c->mps_state[*state];
  215.     }else{
  216.         bit= ((*state)&1)^1;
  217.         c->low -= c->range;
  218.         c->range = RangeLPS;
  219.         *state= c->lps_state[*state];
  220.     }
  221.     renorm_cabac_decoder(c);
  222.     
  223.     return bit;    
  224. }
  225. //static inline int get_cabac_static(CABACContext *c, int RangeLPS){
  226. static int get_cabac_static(CABACContext *c, int RangeLPS){
  227.     int bit;
  228.     
  229.     c->range -= RangeLPS;
  230.     if(c->low < c->range){
  231.         bit= 0;
  232.     }else{
  233.         bit= 1;
  234.         c->low -= c->range;
  235.         c->range = RangeLPS;
  236.     }
  237.     renorm_cabac_decoder(c);
  238.     
  239.     return bit;    
  240. }
  241. //static inline int get_cabac_bypass(CABACContext *c){
  242. static int get_cabac_bypass(CABACContext *c){
  243.     c->low += c->low;
  244.     if(--c->bits_left == 0){
  245.         if(c->bytestream < c->bytestream_end)
  246.             c->low+= *c->bytestream;
  247.         c->bytestream++;
  248.         c->bits_left= 8;
  249.     }
  250.     
  251.     if(c->low < c->range){
  252.         return 0;
  253.     }else{
  254.         c->low -= c->range;
  255.         return 1;
  256.     }
  257. }
  258. /**
  259.  *
  260.  * @return the number of bytes read or 0 if no end
  261.  */
  262. //static inline int get_cabac_terminate(CABACContext *c){
  263. static int get_cabac_terminate(CABACContext *c){
  264.     c->range -= 2<<8;
  265.     if(c->low < c->range){
  266.         renorm_cabac_decoder(c);    
  267.         return 0;
  268.     }else{
  269.         return c->bytestream - c->bytestream_start;
  270.     }    
  271. }
  272. /**
  273.  * get (truncated) unnary binarization.
  274.  */
  275. //static inline int get_cabac_u(CABACContext *c, uint8_t * state, int max, int max_index, int truncated){
  276. static int get_cabac_u(CABACContext *c, uint8_t * state, int max, int max_index, int truncated){
  277.     int i;
  278.     
  279.     for(i=0; i<max; i++){ 
  280.         if(get_cabac(c, state)==0)
  281.             return i;
  282.             
  283.         if(i< max_index) state++;
  284.     }
  285.     return truncated ? max : -1;
  286. }
  287. /**
  288.  * get unary exp golomb k-th order binarization.
  289.  */
  290. //static inline int get_cabac_ueg(CABACContext *c, uint8_t * state, int max, int is_signed, int k, int max_index){
  291. static int get_cabac_ueg(CABACContext *c, uint8_t * state, int max, int is_signed, int k, int max_index){
  292.     int i, v;
  293.     int m= 1<<k;
  294.     
  295.     if(get_cabac(c, state)==0) 
  296.         return 0;
  297.         
  298.     if(0 < max_index) state++;
  299.     
  300.     for(i=1; i<max; i++){ 
  301.         if(get_cabac(c, state)==0){
  302.             if(is_signed && get_cabac_bypass(c)){
  303.                 return -i;
  304.             }else
  305.                 return i;
  306.         }
  307.         if(i < max_index) state++;
  308.     }
  309.     
  310.     while(get_cabac_bypass(c)){
  311.         i+= m;
  312.         m+= m;
  313.     }
  314.     
  315.     v=0;
  316.     while(m>>=1){
  317.         v+= v + get_cabac_bypass(c);
  318.     }
  319.     i += v;
  320.     if(is_signed && get_cabac_bypass(c)){
  321.         return -i;
  322.     }else
  323.         return i;
  324. }