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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
golomb.h
资源名称：ffh264lib_ffmpeg-r16537_2009(fast64bits).zip　[点击查看]
上传用户：chinavct
上传日期：2022-06-20
资源大小：330k
文件大小：13k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

golomb.h：源码内容
  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.  */
  23. /**
  24.  * @file golomb.h
  25.  * @brief
  26.  *     exp golomb vlc stuff
  27.  * @author Michael Niedermayer <michaelni@gmx.at> and Alex Beregszaszi
  28.  */
  30. #ifndef AVCODEC_GOLOMB_H
  31. #define AVCODEC_GOLOMB_H
  33. //#include <stdint.h>
  34. #include "bitstream.h"
  36. #define INVALID_VLC           0x80000000
  38. extern const uint8_t ff_golomb_vlc_len[512];
  39. extern const uint8_t ff_ue_golomb_vlc_code[512];
  40. extern const  int8_t ff_se_golomb_vlc_code[512];
  41. extern const uint8_t ff_ue_golomb_len[256];
  43. extern const uint8_t ff_interleaved_golomb_vlc_len[256];
  44. extern const uint8_t ff_interleaved_ue_golomb_vlc_code[256];
  45. extern const  int8_t ff_interleaved_se_golomb_vlc_code[256];
  46. extern const uint8_t ff_interleaved_dirac_golomb_vlc_code[256];
  49.  /**
  50.  * read unsigned exp golomb code.
  51.  */
  52. static inline int get_ue_golomb(GetBitContext *gb){
  53.     unsigned int buf;
  54.     int log;
  56.     OPEN_READER(re, gb);
  57.     UPDATE_CACHE(re, gb);
  58.     buf=GET_CACHE(re, gb);
  60.     if(buf >= (1<<27)){
  61.         buf >>= 32 - 9;
  62.         LAST_SKIP_BITS(re, gb, ff_golomb_vlc_len[buf]);
  63.         CLOSE_READER(re, gb);
  65.         return ff_ue_golomb_vlc_code[buf];
  66.     }else{
  67.         log= 2*av_log2(buf) - 31;
  68.         buf>>= log;
  69.         buf--;
  70.         LAST_SKIP_BITS(re, gb, 32 - log);
  71.         CLOSE_READER(re, gb);
  73.         return buf;
  74.     }
  75. }
  77.  /**
  78.  * read unsigned exp golomb code, constraint to a max of 31
  79.  */
  80. static inline int get_ue_golomb_31(GetBitContext *gb){
  81.     unsigned int buf;
  83.     OPEN_READER(re, gb);
  84.     UPDATE_CACHE(re, gb);
  85.     buf=GET_CACHE(re, gb);
  87.     buf >>= 32 - 9;
  88.     LAST_SKIP_BITS(re, gb, ff_golomb_vlc_len[buf]);
  89.     CLOSE_READER(re, gb);
  91.     return ff_ue_golomb_vlc_code[buf];
  92. }
  94. static inline int svq3_get_ue_golomb(GetBitContext *gb){
  95.     uint32_t buf;
  97.     OPEN_READER(re, gb);
  98.     UPDATE_CACHE(re, gb);
  99.     buf=GET_CACHE(re, gb);
  101.     if(buf&0xAA800000){
  102.         buf >>= 32 - 8;
  103.         LAST_SKIP_BITS(re, gb, ff_interleaved_golomb_vlc_len[buf]);
  104.         CLOSE_READER(re, gb);
  106.         return ff_interleaved_ue_golomb_vlc_code[buf];
  107.     }else{
  108.         int ret = 1;
  110.         while (1) {
  111.             buf >>= 32 - 8;
  112.             LAST_SKIP_BITS(re, gb, FFMIN(ff_interleaved_golomb_vlc_len[buf], 8));
  114.             if (ff_interleaved_golomb_vlc_len[buf] != 9){
  115.                 ret <<= (ff_interleaved_golomb_vlc_len[buf] - 1) >> 1;
  116.                 ret |= ff_interleaved_dirac_golomb_vlc_code[buf];
  117.                 break;
  118.             }
  119.             ret = (ret << 4) | ff_interleaved_dirac_golomb_vlc_code[buf];
  120.             UPDATE_CACHE(re, gb);
  121.             buf = GET_CACHE(re, gb);
  122.         }
  124.         CLOSE_READER(re, gb);
  125.         return ret - 1;
  126.     }
  127. }
  129. /**
  130.  * read unsigned truncated exp golomb code.
  131.  */
  132. static inline int get_te0_golomb(GetBitContext *gb, int range){
  133.     assert(range >= 1);
  135.     if(range==1)      return 0;
  136.     else if(range==2) return get_bits1(gb)^1;
  137.     else              return get_ue_golomb(gb);
  138. }
  140. /**
  141.  * read unsigned truncated exp golomb code.
  142.  */
  143. static inline int get_te_golomb(GetBitContext *gb, int range){
  144.     assert(range >= 1);
  146.     if(range==2) return get_bits1(gb)^1;
  147.     else         return get_ue_golomb(gb);
  148. }
  151. /**
  152.  * read signed exp golomb code.
  153.  */
  154. static inline int get_se_golomb(GetBitContext *gb){
  155.     unsigned int buf;
  156.     int log,ret;
  158.     OPEN_READER(re, gb);
  159.     UPDATE_CACHE(re, gb);
  160.     buf=GET_CACHE(re, gb);
  162.     if(buf >= (1<<27)){
  163.         buf >>= 32 - 9;
  164.         LAST_SKIP_BITS(re, gb, ff_golomb_vlc_len[buf]);
  165.         CLOSE_READER(re, gb);
  167.         return ff_se_golomb_vlc_code[buf];
  168.     }else{
  169.         log= 2*av_log2(buf) - 31;
  170.         buf>>= log;
  172.         LAST_SKIP_BITS(re, gb, 32 - log);
  173.         CLOSE_READER(re, gb);
  175.         /*if(buf&1) 
  176. buf= -(buf>>1);
  177.         else      
  178. buf=  (buf>>1);
  180.         return buf;*/
  182. ret = buf;
  183. if(buf&1) 
  184. buf= -(ret>>1);
  185.         else      
  186. buf=  (ret>>1);
  188.         return buf;
  189.     }
  190. }
  192. static inline int svq3_get_se_golomb(GetBitContext *gb){
  193.     unsigned int buf;
  194.     int log,ret;
  196.     OPEN_READER(re, gb);
  197.     UPDATE_CACHE(re, gb);
  198.     buf=GET_CACHE(re, gb);
  200.     if(buf&0xAA800000){
  201.         buf >>= 32 - 8;
  202.         LAST_SKIP_BITS(re, gb, ff_interleaved_golomb_vlc_len[buf]);
  203.         CLOSE_READER(re, gb);
  205.         return ff_interleaved_se_golomb_vlc_code[buf];
  206.     }else{
  207.         LAST_SKIP_BITS(re, gb, 8);
  208.         UPDATE_CACHE(re, gb);
  209.         buf |= 1 | (GET_CACHE(re, gb) >> 8);
  211.         if((buf & 0xAAAAAAAA) == 0)
  212.             return INVALID_VLC;
  214.         for(log=31; (buf & 0x80000000) == 0; log--){
  215.             buf = (buf << 2) - ((buf << log) >> (log - 1)) + (buf >> 30);
  216.         }
  218.         LAST_SKIP_BITS(re, gb, 63 - 2*log - 8);
  219.         CLOSE_READER(re, gb);
  221.         //return (signed) (((((buf << log) >> log) - 1) ^ -(buf & 0x1)) + 1) >> 1;
  223. ret = buf;
  224. return (signed) (((((buf << log) >> log) - 1) ^ -(ret & 0x1)) + 1) >> 1;
  225.     }
  226. }
  228. static inline int dirac_get_se_golomb(GetBitContext *gb){
  229.     uint32_t buf;
  230.     uint32_t ret;
  232.     ret = svq3_get_ue_golomb(gb);
  234.     if (ret) {
  235.         OPEN_READER(re, gb);
  236.         UPDATE_CACHE(re, gb);
  237.         buf = SHOW_SBITS(re, gb, 1);
  238.         LAST_SKIP_BITS(re, gb, 1);
  239.         ret = (ret ^ buf) - buf;
  240.         CLOSE_READER(re, gb);
  241.     }
  243.     return ret;
  244. }
  246. /**
  247.  * read unsigned golomb rice code (ffv1).
  248.  */
  249. static inline int get_ur_golomb(GetBitContext *gb, int k, int limit, int esc_len){
  250.     unsigned int buf;
  251.     int log;
  253.     OPEN_READER(re, gb);
  254.     UPDATE_CACHE(re, gb);
  255.     buf=GET_CACHE(re, gb);
  257.     log= av_log2(buf);
  259.     if(log > 31-limit){
  260.         buf >>= log - k;
  261.         buf += (30-log)<<k;
  262.         LAST_SKIP_BITS(re, gb, 32 + k - log);
  263.         CLOSE_READER(re, gb);
  265.         return buf;
  266.     }else{
  267.         buf >>= 32 - limit - esc_len;
  268.         LAST_SKIP_BITS(re, gb, esc_len + limit);
  269.         CLOSE_READER(re, gb);
  271.         return buf + limit - 1;
  272.     }
  273. }
  275. /**
  276.  * read unsigned golomb rice code (jpegls).
  277.  */
  278. static inline int get_ur_golomb_jpegls(GetBitContext *gb, int k, int limit, int esc_len){
  279.     unsigned int buf;
  280.     int log;
  282.     OPEN_READER(re, gb);
  283.     UPDATE_CACHE(re, gb);
  284.     buf=GET_CACHE(re, gb);
  286.     log= av_log2(buf);
  288.     if(log - k >= 32-MIN_CACHE_BITS && 32-log < limit){
  289.         buf >>= log - k;
  290.         buf += (30-log)<<k;
  291.         LAST_SKIP_BITS(re, gb, 32 + k - log);
  292.         CLOSE_READER(re, gb);
  294.         return buf;
  295.     }else{
  296.         int i;
  297.         for(i=0; SHOW_UBITS(re, gb, 1) == 0; i++){
  298.             LAST_SKIP_BITS(re, gb, 1);
  299.             UPDATE_CACHE(re, gb);
  300.         }
  301.         SKIP_BITS(re, gb, 1);
  303.         if(i < limit - 1){
  304.             if(k){
  305.                 buf = SHOW_UBITS(re, gb, k);
  306.                 LAST_SKIP_BITS(re, gb, k);
  307.             }else{
  308.                 buf=0;
  309.             }
  311.             CLOSE_READER(re, gb);
  312.             return buf + (i<<k);
  313.         }else if(i == limit - 1){
  314.             buf = SHOW_UBITS(re, gb, esc_len);
  315.             LAST_SKIP_BITS(re, gb, esc_len);
  316.             CLOSE_READER(re, gb);
  318.             return buf + 1;
  319.         }else
  320.             return -1;
  321.     }
  322. }
  324. /**
  325.  * read signed golomb rice code (ffv1).
  326.  */
  327. static inline int get_sr_golomb(GetBitContext *gb, int k, int limit, int esc_len){
  328.     int v= get_ur_golomb(gb, k, limit, esc_len);
  330.     v++;
  331.     if (v&1) return v>>1;
  332.     else return -(v>>1);
  334. //    return (v>>1) ^ -(v&1);
  335. }
  337. /**
  338.  * read signed golomb rice code (flac).
  339.  */
  340. static inline int get_sr_golomb_flac(GetBitContext *gb, int k, int limit, int esc_len){
  341.     int v= get_ur_golomb_jpegls(gb, k, limit, esc_len);
  342.     return (v>>1) ^ -(v&1);
  343. }
  345. /**
  346.  * read unsigned golomb rice code (shorten).
  347.  */
  348. static inline unsigned int get_ur_golomb_shorten(GetBitContext *gb, int k){
  349.         return get_ur_golomb_jpegls(gb, k, INT_MAX, 0);
  350. }
  352. /**
  353.  * read signed golomb rice code (shorten).
  354.  */
  355. static inline int get_sr_golomb_shorten(GetBitContext* gb, int k)
  356. {
  357.     int uvar = get_ur_golomb_jpegls(gb, k + 1, INT_MAX, 0);
  358.     if (uvar & 1)
  359.         return ~(uvar >> 1);
  360.     else
  361.         return uvar >> 1;
  362. }
  366. #ifdef TRACE
  368. static inline int get_ue(GetBitContext *s, char *file, const char *func, int line){
  369.     int show= show_bits(s, 24);
  370.     int pos= get_bits_count(s);
  371.     int i= get_ue_golomb(s);
  372.     int len= get_bits_count(s) - pos;
  373.     int bits= show>>(24-len);
  375.     print_bin(bits, len);
  377.     av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d ue  @%5d in %s %s:%dn", bits, len, i, pos, file, func, line);
  379.     return i;
  380. }
  382. static inline int get_se(GetBitContext *s, char *file, const char *func, int line){
  383.     int show= show_bits(s, 24);
  384.     int pos= get_bits_count(s);
  385.     int i= get_se_golomb(s);
  386.     int len= get_bits_count(s) - pos;
  387.     int bits= show>>(24-len);
  389.     print_bin(bits, len);
  391.     av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d se  @%5d in %s %s:%dn", bits, len, i, pos, file, func, line);
  393.     return i;
  394. }
  396. static inline int get_te(GetBitContext *s, int r, char *file, const char *func, int line){
  397.     int show= show_bits(s, 24);
  398.     int pos= get_bits_count(s);
  399.     int i= get_te0_golomb(s, r);
  400.     int len= get_bits_count(s) - pos;
  401.     int bits= show>>(24-len);
  403.     print_bin(bits, len);
  405.     av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d te  @%5d in %s %s:%dn", bits, len, i, pos, file, func, line);
  407.     return i;
  408. }
  410. #define get_ue_golomb(a) get_ue(a, __FILE__, __PRETTY_FUNCTION__, __LINE__)
  411. #define get_se_golomb(a) get_se(a, __FILE__, __PRETTY_FUNCTION__, __LINE__)
  412. #define get_te_golomb(a, r) get_te(a, r, __FILE__, __PRETTY_FUNCTION__, __LINE__)
  413. #define get_te0_golomb(a, r) get_te(a, r, __FILE__, __PRETTY_FUNCTION__, __LINE__)
  415. #endif
  417. /**
  418.  * write unsigned exp golomb code.
  419.  */
  420. static inline void set_ue_golomb(PutBitContext *pb, int i){
  421.     int e;
  423.     assert(i>=0);
  425. #if 0
  426.     if(i=0){
  427.         put_bits(pb, 1, 1);
  428.         return;
  429.     }
  430. #endif
  431.     if(i<256)
  432.         put_bits(pb, ff_ue_golomb_len[i], i+1);
  433.     else{
  434.         e= av_log2(i+1);
  436.         put_bits(pb, 2*e+1, i+1);
  437.     }
  438. }
  440. /**
  441.  * write truncated unsigned exp golomb code.
  442.  */
  443. static inline void set_te_golomb(PutBitContext *pb, int i, int range){
  444.     assert(range >= 1);
  445.     assert(i<=range);
  447.     if(range==2) put_bits(pb, 1, i^1);
  448.     else         set_ue_golomb(pb, i);
  449. }
  451. /**
  452.  * write signed exp golomb code. 16 bits at most.
  453.  */
  454. static inline void set_se_golomb(PutBitContext *pb, int i){
  455. //    if (i>32767 || i<-32767)
  456. //        av_log(NULL,AV_LOG_ERROR,"value out of range %dn", i);
  457. #if 0
  458.     if(i<=0) i= -2*i;
  459.     else     i=  2*i-1;
  460. #elif 1
  461.     i= 2*i-1;
  462.     if(i<0) i^= -1; //FIXME check if gcc does the right thing
  463. #else
  464.     i= 2*i-1;
  465.     i^= (i>>31);
  466. #endif
  467.     set_ue_golomb(pb, i);
  468. }
  470. /**
  471.  * write unsigned golomb rice code (ffv1).
  472.  */
  473. static inline void set_ur_golomb(PutBitContext *pb, int i, int k, int limit, int esc_len){
  474.     int e;
  476.     assert(i>=0);
  478.     e= i>>k;
  479.     if(e<limit){
  480.         put_bits(pb, e + k + 1, (1<<k) + (i&((1<<k)-1)));
  481.     }else{
  482.         put_bits(pb, limit + esc_len, i - limit + 1);
  483.     }
  484. }
  486. /**
  487.  * write unsigned golomb rice code (jpegls).
  488.  */
  489. static inline void set_ur_golomb_jpegls(PutBitContext *pb, int i, int k, int limit, int esc_len){
  490.     int e;
  492.     assert(i>=0);
  494.     e= (i>>k) + 1;
  495.     if(e<limit){
  496.         while(e > 31) {
  497.             put_bits(pb, 31, 0);
  498.             e -= 31;
  499.         }
  500.         put_bits(pb, e, 1);
  501.         if(k)
  502.             put_sbits(pb, k, i);
  503.     }else{
  504.         while(limit > 31) {
  505.             put_bits(pb, 31, 0);
  506.             limit -= 31;
  507.         }
  508.         put_bits(pb, limit  , 1);
  509.         put_bits(pb, esc_len, i - 1);
  510.     }
  511. }
  513. /**
  514.  * write signed golomb rice code (ffv1).
  515.  */
  516. static inline void set_sr_golomb(PutBitContext *pb, int i, int k, int limit, int esc_len){
  517.     int v;
  519.     v = -2*i-1;
  520.     v ^= (v>>31);
  522.     set_ur_golomb(pb, v, k, limit, esc_len);
  523. }
  525. /**
  526.  * write signed golomb rice code (flac).
  527.  */
  528. static inline void set_sr_golomb_flac(PutBitContext *pb, int i, int k, int limit, int esc_len){
  529.     int v;
  531.     v = -2*i-1;
  532.     v ^= (v>>31);
  534.     set_ur_golomb_jpegls(pb, v, k, limit, esc_len);
  535. }
  537. #endif /* AVCODEC_GOLOMB_H */