golomb.h
上传用户:jylinhe
上传日期:2022-07-11
资源大小:334k
文件大小:13k
源码类别:

多媒体编程

开发平台:

Visual C++

  1. /*
  2.  * exp golomb vlc stuff
  3.  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
  4.  * Copyright (c) 2004 Alex Beregszaszi
  5.  *
  6.  * This file is part of FFmpeg.
  7.  *
  8.  * FFmpeg is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Lesser General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2.1 of the License, or (at your option) any later version.
  12.  *
  13.  * FFmpeg is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Lesser General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Lesser General Public
  19.  * License along with FFmpeg; if not, write to the Free Software
  20.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21.  */
  22. /**
  23.  * @file golomb.h
  24.  * @brief
  25.  *     exp golomb vlc stuff
  26.  * @author Michael Niedermayer <michaelni@gmx.at> and Alex Beregszaszi
  27.  */
  28. #ifndef AVCODEC_GOLOMB_H
  29. #define AVCODEC_GOLOMB_H
  30. //#include <stdint.h>
  31. #include "bitstream.h"
  32. #define INVALID_VLC           0x80000000
  33. extern const uint8_t ff_golomb_vlc_len[512];
  34. extern const uint8_t ff_ue_golomb_vlc_code[512];
  35. extern const  int8_t ff_se_golomb_vlc_code[512];
  36. extern const uint8_t ff_ue_golomb_len[256];
  37. extern const uint8_t ff_interleaved_golomb_vlc_len[256];
  38. extern const uint8_t ff_interleaved_ue_golomb_vlc_code[256];
  39. extern const  int8_t ff_interleaved_se_golomb_vlc_code[256];
  40. extern const uint8_t ff_interleaved_dirac_golomb_vlc_code[256];
  41.  /**
  42.  * read unsigned exp golomb code.
  43.  */
  44. static inline int get_ue_golomb(GetBitContext *gb){
  45.     unsigned int buf;
  46.     int log;
  47.     OPEN_READER(re, gb);
  48.     UPDATE_CACHE(re, gb);
  49.     buf=GET_CACHE(re, gb);
  50.     if(buf >= (1<<27)){
  51.         buf >>= 32 - 9;
  52.         LAST_SKIP_BITS(re, gb, ff_golomb_vlc_len[buf]);
  53.         CLOSE_READER(re, gb);
  54.         return ff_ue_golomb_vlc_code[buf];
  55.     }else{
  56.         log= 2*av_log2(buf) - 31;
  57.         buf>>= log;
  58.         buf--;
  59.         LAST_SKIP_BITS(re, gb, 32 - log);
  60.         CLOSE_READER(re, gb);
  61.         return buf;
  62.     }
  63. }
  64.  /**
  65.  * read unsigned exp golomb code, constraint to a max of 31
  66.  */
  67. static inline int get_ue_golomb_31(GetBitContext *gb){
  68.     unsigned int buf;
  69.     OPEN_READER(re, gb);
  70.     UPDATE_CACHE(re, gb);
  71.     buf=GET_CACHE(re, gb);
  72.     buf >>= 32 - 9;
  73.     LAST_SKIP_BITS(re, gb, ff_golomb_vlc_len[buf]);
  74.     CLOSE_READER(re, gb);
  75.     return ff_ue_golomb_vlc_code[buf];
  76. }
  77. static inline int svq3_get_ue_golomb(GetBitContext *gb){
  78.     uint32_t buf;
  79.     OPEN_READER(re, gb);
  80.     UPDATE_CACHE(re, gb);
  81.     buf=GET_CACHE(re, gb);
  82.     if(buf&0xAA800000){
  83.         buf >>= 32 - 8;
  84.         LAST_SKIP_BITS(re, gb, ff_interleaved_golomb_vlc_len[buf]);
  85.         CLOSE_READER(re, gb);
  86.         return ff_interleaved_ue_golomb_vlc_code[buf];
  87.     }else{
  88.         int ret = 1;
  89.         while (1) {
  90.             buf >>= 32 - 8;
  91.             LAST_SKIP_BITS(re, gb, FFMIN(ff_interleaved_golomb_vlc_len[buf], 8));
  92.             if (ff_interleaved_golomb_vlc_len[buf] != 9){
  93.                 ret <<= (ff_interleaved_golomb_vlc_len[buf] - 1) >> 1;
  94.                 ret |= ff_interleaved_dirac_golomb_vlc_code[buf];
  95.                 break;
  96.             }
  97.             ret = (ret << 4) | ff_interleaved_dirac_golomb_vlc_code[buf];
  98.             UPDATE_CACHE(re, gb);
  99.             buf = GET_CACHE(re, gb);
  100.         }
  101.         CLOSE_READER(re, gb);
  102.         return ret - 1;
  103.     }
  104. }
  105. /**
  106.  * read unsigned truncated exp golomb code.
  107.  */
  108. static inline int get_te0_golomb(GetBitContext *gb, int range){
  109.     assert(range >= 1);
  110.     if(range==1)      return 0;
  111.     else if(range==2) return get_bits1(gb)^1;
  112.     else              return get_ue_golomb(gb);
  113. }
  114. /**
  115.  * read unsigned truncated exp golomb code.
  116.  */
  117. static inline int get_te_golomb(GetBitContext *gb, int range){
  118.     assert(range >= 1);
  119.     if(range==2) return get_bits1(gb)^1;
  120.     else         return get_ue_golomb(gb);
  121. }
  122. /**
  123.  * read signed exp golomb code.
  124.  */
  125. static inline int get_se_golomb(GetBitContext *gb){
  126.     unsigned int buf;
  127.     int log,ret;
  128.     OPEN_READER(re, gb);
  129.     UPDATE_CACHE(re, gb);
  130.     buf=GET_CACHE(re, gb);
  131.     if(buf >= (1<<27)){
  132.         buf >>= 32 - 9;
  133.         LAST_SKIP_BITS(re, gb, ff_golomb_vlc_len[buf]);
  134.         CLOSE_READER(re, gb);
  135.         return ff_se_golomb_vlc_code[buf];
  136.     }else{
  137.         log= 2*av_log2(buf) - 31;
  138.         buf>>= log;
  139.         LAST_SKIP_BITS(re, gb, 32 - log);
  140.         CLOSE_READER(re, gb);
  141.         /*if(buf&1) 
  142. buf= -(buf>>1);
  143.         else      
  144. buf=  (buf>>1);
  145.         return buf;*/
  146. ret = buf;
  147. if(buf&1) 
  148. buf= -(ret>>1);
  149.         else      
  150. buf=  (ret>>1);
  151.         return buf;
  152.     }
  153. }
  154. static inline int svq3_get_se_golomb(GetBitContext *gb){
  155.     unsigned int buf;
  156.     int log,ret;
  157.     OPEN_READER(re, gb);
  158.     UPDATE_CACHE(re, gb);
  159.     buf=GET_CACHE(re, gb);
  160.     if(buf&0xAA800000){
  161.         buf >>= 32 - 8;
  162.         LAST_SKIP_BITS(re, gb, ff_interleaved_golomb_vlc_len[buf]);
  163.         CLOSE_READER(re, gb);
  164.         return ff_interleaved_se_golomb_vlc_code[buf];
  165.     }else{
  166.         LAST_SKIP_BITS(re, gb, 8);
  167.         UPDATE_CACHE(re, gb);
  168.         buf |= 1 | (GET_CACHE(re, gb) >> 8);
  169.         if((buf & 0xAAAAAAAA) == 0)
  170.             return INVALID_VLC;
  171.         for(log=31; (buf & 0x80000000) == 0; log--){
  172.             buf = (buf << 2) - ((buf << log) >> (log - 1)) + (buf >> 30);
  173.         }
  174.         LAST_SKIP_BITS(re, gb, 63 - 2*log - 8);
  175.         CLOSE_READER(re, gb);
  176.         //return (signed) (((((buf << log) >> log) - 1) ^ -(buf & 0x1)) + 1) >> 1;
  177. ret = buf;
  178. return (signed) (((((buf << log) >> log) - 1) ^ -(ret & 0x1)) + 1) >> 1;
  179.     }
  180. }
  181. static inline int dirac_get_se_golomb(GetBitContext *gb){
  182.     uint32_t buf;
  183.     uint32_t ret;
  184.     ret = svq3_get_ue_golomb(gb);
  185.     if (ret) {
  186.         OPEN_READER(re, gb);
  187.         UPDATE_CACHE(re, gb);
  188.         buf = SHOW_SBITS(re, gb, 1);
  189.         LAST_SKIP_BITS(re, gb, 1);
  190.         ret = (ret ^ buf) - buf;
  191.         CLOSE_READER(re, gb);
  192.     }
  193.     return ret;
  194. }
  195. /**
  196.  * read unsigned golomb rice code (ffv1).
  197.  */
  198. static inline int get_ur_golomb(GetBitContext *gb, int k, int limit, int esc_len){
  199.     unsigned int buf;
  200.     int log;
  201.     OPEN_READER(re, gb);
  202.     UPDATE_CACHE(re, gb);
  203.     buf=GET_CACHE(re, gb);
  204.     log= av_log2(buf);
  205.     if(log > 31-limit){
  206.         buf >>= log - k;
  207.         buf += (30-log)<<k;
  208.         LAST_SKIP_BITS(re, gb, 32 + k - log);
  209.         CLOSE_READER(re, gb);
  210.         return buf;
  211.     }else{
  212.         buf >>= 32 - limit - esc_len;
  213.         LAST_SKIP_BITS(re, gb, esc_len + limit);
  214.         CLOSE_READER(re, gb);
  215.         return buf + limit - 1;
  216.     }
  217. }
  218. /**
  219.  * read unsigned golomb rice code (jpegls).
  220.  */
  221. static inline int get_ur_golomb_jpegls(GetBitContext *gb, int k, int limit, int esc_len){
  222.     unsigned int buf;
  223.     int log;
  224.     OPEN_READER(re, gb);
  225.     UPDATE_CACHE(re, gb);
  226.     buf=GET_CACHE(re, gb);
  227.     log= av_log2(buf);
  228.     if(log - k >= 32-MIN_CACHE_BITS && 32-log < limit){
  229.         buf >>= log - k;
  230.         buf += (30-log)<<k;
  231.         LAST_SKIP_BITS(re, gb, 32 + k - log);
  232.         CLOSE_READER(re, gb);
  233.         return buf;
  234.     }else{
  235.         int i;
  236.         for(i=0; SHOW_UBITS(re, gb, 1) == 0; i++){
  237.             LAST_SKIP_BITS(re, gb, 1);
  238.             UPDATE_CACHE(re, gb);
  239.         }
  240.         SKIP_BITS(re, gb, 1);
  241.         if(i < limit - 1){
  242.             if(k){
  243.                 buf = SHOW_UBITS(re, gb, k);
  244.                 LAST_SKIP_BITS(re, gb, k);
  245.             }else{
  246.                 buf=0;
  247.             }
  248.             CLOSE_READER(re, gb);
  249.             return buf + (i<<k);
  250.         }else if(i == limit - 1){
  251.             buf = SHOW_UBITS(re, gb, esc_len);
  252.             LAST_SKIP_BITS(re, gb, esc_len);
  253.             CLOSE_READER(re, gb);
  254.             return buf + 1;
  255.         }else
  256.             return -1;
  257.     }
  258. }
  259. /**
  260.  * read signed golomb rice code (ffv1).
  261.  */
  262. static inline int get_sr_golomb(GetBitContext *gb, int k, int limit, int esc_len){
  263.     int v= get_ur_golomb(gb, k, limit, esc_len);
  264.     v++;
  265.     if (v&1) return v>>1;
  266.     else return -(v>>1);
  267. //    return (v>>1) ^ -(v&1);
  268. }
  269. /**
  270.  * read signed golomb rice code (flac).
  271.  */
  272. static inline int get_sr_golomb_flac(GetBitContext *gb, int k, int limit, int esc_len){
  273.     int v= get_ur_golomb_jpegls(gb, k, limit, esc_len);
  274.     return (v>>1) ^ -(v&1);
  275. }
  276. /**
  277.  * read unsigned golomb rice code (shorten).
  278.  */
  279. static inline unsigned int get_ur_golomb_shorten(GetBitContext *gb, int k){
  280.         return get_ur_golomb_jpegls(gb, k, INT_MAX, 0);
  281. }
  282. /**
  283.  * read signed golomb rice code (shorten).
  284.  */
  285. static inline int get_sr_golomb_shorten(GetBitContext* gb, int k)
  286. {
  287.     int uvar = get_ur_golomb_jpegls(gb, k + 1, INT_MAX, 0);
  288.     if (uvar & 1)
  289.         return ~(uvar >> 1);
  290.     else
  291.         return uvar >> 1;
  292. }
  293. #ifdef TRACE
  294. static inline int get_ue(GetBitContext *s, char *file, const char *func, int line){
  295.     int show= show_bits(s, 24);
  296.     int pos= get_bits_count(s);
  297.     int i= get_ue_golomb(s);
  298.     int len= get_bits_count(s) - pos;
  299.     int bits= show>>(24-len);
  300.     print_bin(bits, len);
  301.     av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d ue  @%5d in %s %s:%dn", bits, len, i, pos, file, func, line);
  302.     return i;
  303. }
  304. static inline int get_se(GetBitContext *s, char *file, const char *func, int line){
  305.     int show= show_bits(s, 24);
  306.     int pos= get_bits_count(s);
  307.     int i= get_se_golomb(s);
  308.     int len= get_bits_count(s) - pos;
  309.     int bits= show>>(24-len);
  310.     print_bin(bits, len);
  311.     av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d se  @%5d in %s %s:%dn", bits, len, i, pos, file, func, line);
  312.     return i;
  313. }
  314. static inline int get_te(GetBitContext *s, int r, char *file, const char *func, int line){
  315.     int show= show_bits(s, 24);
  316.     int pos= get_bits_count(s);
  317.     int i= get_te0_golomb(s, r);
  318.     int len= get_bits_count(s) - pos;
  319.     int bits= show>>(24-len);
  320.     print_bin(bits, len);
  321.     av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d te  @%5d in %s %s:%dn", bits, len, i, pos, file, func, line);
  322.     return i;
  323. }
  324. #define get_ue_golomb(a) get_ue(a, __FILE__, __PRETTY_FUNCTION__, __LINE__)
  325. #define get_se_golomb(a) get_se(a, __FILE__, __PRETTY_FUNCTION__, __LINE__)
  326. #define get_te_golomb(a, r) get_te(a, r, __FILE__, __PRETTY_FUNCTION__, __LINE__)
  327. #define get_te0_golomb(a, r) get_te(a, r, __FILE__, __PRETTY_FUNCTION__, __LINE__)
  328. #endif
  329. /**
  330.  * write unsigned exp golomb code.
  331.  */
  332. static inline void set_ue_golomb(PutBitContext *pb, int i){
  333.     int e;
  334.     assert(i>=0);
  335. #if 0
  336.     if(i=0){
  337.         put_bits(pb, 1, 1);
  338.         return;
  339.     }
  340. #endif
  341.     if(i<256)
  342.         put_bits(pb, ff_ue_golomb_len[i], i+1);
  343.     else{
  344.         e= av_log2(i+1);
  345.         put_bits(pb, 2*e+1, i+1);
  346.     }
  347. }
  348. /**
  349.  * write truncated unsigned exp golomb code.
  350.  */
  351. static inline void set_te_golomb(PutBitContext *pb, int i, int range){
  352.     assert(range >= 1);
  353.     assert(i<=range);
  354.     if(range==2) put_bits(pb, 1, i^1);
  355.     else         set_ue_golomb(pb, i);
  356. }
  357. /**
  358.  * write signed exp golomb code. 16 bits at most.
  359.  */
  360. static inline void set_se_golomb(PutBitContext *pb, int i){
  361. //    if (i>32767 || i<-32767)
  362. //        av_log(NULL,AV_LOG_ERROR,"value out of range %dn", i);
  363. #if 0
  364.     if(i<=0) i= -2*i;
  365.     else     i=  2*i-1;
  366. #elif 1
  367.     i= 2*i-1;
  368.     if(i<0) i^= -1; //FIXME check if gcc does the right thing
  369. #else
  370.     i= 2*i-1;
  371.     i^= (i>>31);
  372. #endif
  373.     set_ue_golomb(pb, i);
  374. }
  375. /**
  376.  * write unsigned golomb rice code (ffv1).
  377.  */
  378. static inline void set_ur_golomb(PutBitContext *pb, int i, int k, int limit, int esc_len){
  379.     int e;
  380.     assert(i>=0);
  381.     e= i>>k;
  382.     if(e<limit){
  383.         put_bits(pb, e + k + 1, (1<<k) + (i&((1<<k)-1)));
  384.     }else{
  385.         put_bits(pb, limit + esc_len, i - limit + 1);
  386.     }
  387. }
  388. /**
  389.  * write unsigned golomb rice code (jpegls).
  390.  */
  391. static inline void set_ur_golomb_jpegls(PutBitContext *pb, int i, int k, int limit, int esc_len){
  392.     int e;
  393.     assert(i>=0);
  394.     e= (i>>k) + 1;
  395.     if(e<limit){
  396.         while(e > 31) {
  397.             put_bits(pb, 31, 0);
  398.             e -= 31;
  399.         }
  400.         put_bits(pb, e, 1);
  401.         if(k)
  402.             put_sbits(pb, k, i);
  403.     }else{
  404.         while(limit > 31) {
  405.             put_bits(pb, 31, 0);
  406.             limit -= 31;
  407.         }
  408.         put_bits(pb, limit  , 1);
  409.         put_bits(pb, esc_len, i - 1);
  410.     }
  411. }
  412. /**
  413.  * write signed golomb rice code (ffv1).
  414.  */
  415. static inline void set_sr_golomb(PutBitContext *pb, int i, int k, int limit, int esc_len){
  416.     int v;
  417.     v = -2*i-1;
  418.     v ^= (v>>31);
  419.     set_ur_golomb(pb, v, k, limit, esc_len);
  420. }
  421. /**
  422.  * write signed golomb rice code (flac).
  423.  */
  424. static inline void set_sr_golomb_flac(PutBitContext *pb, int i, int k, int limit, int esc_len){
  425.     int v;
  426.     v = -2*i-1;
  427.     v ^= (v>>31);
  428.     set_ur_golomb_jpegls(pb, v, k, limit, esc_len);
  429. }
  430. #endif /* AVCODEC_GOLOMB_H */