falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
10157 Commits
32 Branches
434MB
Tree: dc0c20f99b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'dc0c20f99b'
${ noResults }
FFmpeg/libavcodec/golomb.h

487 lines
11KB
Raw Blame History 

  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. /**

  24.  * @file golomb.h

  25.  * @brief

  26.  *     exp golomb vlc stuff

  27.  * @author Michael Niedermayer <michaelni@gmx.at> and Alex Beregszaszi

  28.  */

  29. 

  30. #ifndef AVCODEC_GOLOMB_H

  31. #define AVCODEC_GOLOMB_H

  32. 

  33. #include <stdint.h>

  34. #include "bitstream.h"

  35. 

  36. #define INVALID_VLC           0x80000000

  37. 

  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];

  42. 

  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. 

  47. 

  48.  /**

  49.  * read unsigned exp golomb code.

  50.  */

  51. static inline int get_ue_golomb(GetBitContext *gb){

  52.     unsigned int buf;

  53.     int log;

  54. 

  55.     OPEN_READER(re, gb);

  56.     UPDATE_CACHE(re, gb);

  57.     buf=GET_CACHE(re, gb);

  58. 

  59.     if(buf >= (1<<27)){

  60.         buf >>= 32 - 9;

  61.         LAST_SKIP_BITS(re, gb, ff_golomb_vlc_len[buf]);

  62.         CLOSE_READER(re, gb);

  63. 

  64.         return ff_ue_golomb_vlc_code[buf];

  65.     }else{

  66.         log= 2*av_log2(buf) - 31;

  67.         buf>>= log;

  68.         buf--;

  69.         LAST_SKIP_BITS(re, gb, 32 - log);

  70.         CLOSE_READER(re, gb);

  71. 

  72.         return buf;

  73.     }

  74. }

  75. 

  76. static inline int svq3_get_ue_golomb(GetBitContext *gb){

  77.     uint32_t buf;

  78.     int log;

  79. 

  80.     OPEN_READER(re, gb);

  81.     UPDATE_CACHE(re, gb);

  82.     buf=GET_CACHE(re, gb);

  83. 

  84.     if(buf&0xAA800000){

  85.         buf >>= 32 - 8;

  86.         LAST_SKIP_BITS(re, gb, ff_interleaved_golomb_vlc_len[buf]);

  87.         CLOSE_READER(re, gb);

  88. 

  89.         return ff_interleaved_ue_golomb_vlc_code[buf];

  90.     }else{

  91.         LAST_SKIP_BITS(re, gb, 8);

  92.         UPDATE_CACHE(re, gb);

  93.         buf |= 1 | (GET_CACHE(re, gb) >> 8);

  94. 

  95.         if((buf & 0xAAAAAAAA) == 0)

  96.             return INVALID_VLC;

  97. 

  98.         for(log=31; (buf & 0x80000000) == 0; log--){

  99.             buf = (buf << 2) - ((buf << log) >> (log - 1)) + (buf >> 30);

  100.         }

  101. 

  102.         LAST_SKIP_BITS(re, gb, 63 - 2*log - 8);

  103.         CLOSE_READER(re, gb);

  104. 

  105.         return ((buf << log) >> log) - 1;

  106.     }

  107. }

  108. 

  109. /**

  110.  * read unsigned truncated exp golomb code.

  111.  */

  112. static inline int get_te0_golomb(GetBitContext *gb, int range){

  113.     assert(range >= 1);

  114. 

  115.     if(range==1)      return 0;

  116.     else if(range==2) return get_bits1(gb)^1;

  117.     else              return get_ue_golomb(gb);

  118. }

  119. 

  120. /**

  121.  * read unsigned truncated exp golomb code.

  122.  */

  123. static inline int get_te_golomb(GetBitContext *gb, int range){

  124.     assert(range >= 1);

  125. 

  126.     if(range==2) return get_bits1(gb)^1;

  127.     else         return get_ue_golomb(gb);

  128. }

  129. 

  130. 

  131. /**

  132.  * read signed exp golomb code.

  133.  */

  134. static inline int get_se_golomb(GetBitContext *gb){

  135.     unsigned int buf;

  136.     int log;

  137. 

  138.     OPEN_READER(re, gb);

  139.     UPDATE_CACHE(re, gb);

  140.     buf=GET_CACHE(re, gb);

  141. 

  142.     if(buf >= (1<<27)){

  143.         buf >>= 32 - 9;

  144.         LAST_SKIP_BITS(re, gb, ff_golomb_vlc_len[buf]);

  145.         CLOSE_READER(re, gb);

  146. 

  147.         return ff_se_golomb_vlc_code[buf];

  148.     }else{

  149.         log= 2*av_log2(buf) - 31;

  150.         buf>>= log;

  151. 

  152.         LAST_SKIP_BITS(re, gb, 32 - log);

  153.         CLOSE_READER(re, gb);

  154. 

  155.         if(buf&1) buf= -(buf>>1);

  156.         else      buf=  (buf>>1);

  157. 

  158.         return buf;

  159.     }

  160. }

  161. 

  162. static inline int svq3_get_se_golomb(GetBitContext *gb){

  163.     unsigned int buf;

  164.     int log;

  165. 

  166.     OPEN_READER(re, gb);

  167.     UPDATE_CACHE(re, gb);

  168.     buf=GET_CACHE(re, gb);

  169. 

  170.     if(buf&0xAA800000){

  171.         buf >>= 32 - 8;

  172.         LAST_SKIP_BITS(re, gb, ff_interleaved_golomb_vlc_len[buf]);

  173.         CLOSE_READER(re, gb);

  174. 

  175.         return ff_interleaved_se_golomb_vlc_code[buf];

  176.     }else{

  177.         LAST_SKIP_BITS(re, gb, 8);

  178.         UPDATE_CACHE(re, gb);

  179.         buf |= 1 | (GET_CACHE(re, gb) >> 8);

  180. 

  181.         if((buf & 0xAAAAAAAA) == 0)

  182.             return INVALID_VLC;

  183. 

  184.         for(log=31; (buf & 0x80000000) == 0; log--){

  185.             buf = (buf << 2) - ((buf << log) >> (log - 1)) + (buf >> 30);

  186.         }

  187. 

  188.         LAST_SKIP_BITS(re, gb, 63 - 2*log - 8);

  189.         CLOSE_READER(re, gb);

  190. 

  191.         return (signed) (((((buf << log) >> log) - 1) ^ -(buf & 0x1)) + 1) >> 1;

  192.     }

  193. }

  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. 

  202.     OPEN_READER(re, gb);

  203.     UPDATE_CACHE(re, gb);

  204.     buf=GET_CACHE(re, gb);

  205. 

  206.     log= av_log2(buf);

  207. 

  208.     if(log > 31-limit){

  209.         buf >>= log - k;

  210.         buf += (30-log)<<k;

  211.         LAST_SKIP_BITS(re, gb, 32 + k - log);

  212.         CLOSE_READER(re, gb);

  213. 

  214.         return buf;

  215.     }else{

  216.         buf >>= 32 - limit - esc_len;

  217.         LAST_SKIP_BITS(re, gb, esc_len + limit);

  218.         CLOSE_READER(re, gb);

  219. 

  220.         return buf + limit - 1;

  221.     }

  222. }

  223. 

  224. /**

  225.  * read unsigned golomb rice code (jpegls).

  226.  */

  227. static inline int get_ur_golomb_jpegls(GetBitContext *gb, int k, int limit, int esc_len){

  228.     unsigned int buf;

  229.     int log;

  230. 

  231.     OPEN_READER(re, gb);

  232.     UPDATE_CACHE(re, gb);

  233.     buf=GET_CACHE(re, gb);

  234. 

  235.     log= av_log2(buf);

  236. 

  237.     if(log > 31-11){

  238.         buf >>= log - k;

  239.         buf += (30-log)<<k;

  240.         LAST_SKIP_BITS(re, gb, 32 + k - log);

  241.         CLOSE_READER(re, gb);

  242. 

  243.         return buf;

  244.     }else{

  245.         int i;

  246.         for(i=0; SHOW_UBITS(re, gb, 1) == 0; i++){

  247.             LAST_SKIP_BITS(re, gb, 1);

  248.             UPDATE_CACHE(re, gb);

  249.         }

  250.         SKIP_BITS(re, gb, 1);

  251. 

  252.         if(i < limit - 1){

  253.             if(k){

  254.                 buf = SHOW_UBITS(re, gb, k);

  255.                 LAST_SKIP_BITS(re, gb, k);

  256.             }else{

  257.                 buf=0;

  258.             }

  259. 

  260.             CLOSE_READER(re, gb);

  261.             return buf + (i<<k);

  262.         }else if(i == limit - 1){

  263.             buf = SHOW_UBITS(re, gb, esc_len);

  264.             LAST_SKIP_BITS(re, gb, esc_len);

  265.             CLOSE_READER(re, gb);

  266. 

  267.             return buf + 1;

  268.         }else

  269.             return -1;

  270.     }

  271. }

  272. 

  273. /**

  274.  * read signed golomb rice code (ffv1).

  275.  */

  276. static inline int get_sr_golomb(GetBitContext *gb, int k, int limit, int esc_len){

  277.     int v= get_ur_golomb(gb, k, limit, esc_len);

  278. 

  279.     v++;

  280.     if (v&1) return v>>1;

  281.     else return -(v>>1);

  282. 

  283. //    return (v>>1) ^ -(v&1);

  284. }

  285. 

  286. /**

  287.  * read signed golomb rice code (flac).

  288.  */

  289. static inline int get_sr_golomb_flac(GetBitContext *gb, int k, int limit, int esc_len){

  290.     int v= get_ur_golomb_jpegls(gb, k, limit, esc_len);

  291.     return (v>>1) ^ -(v&1);

  292. }

  293. 

  294. /**

  295.  * read unsigned golomb rice code (shorten).

  296.  */

  297. static inline unsigned int get_ur_golomb_shorten(GetBitContext *gb, int k){

  298.         return get_ur_golomb_jpegls(gb, k, INT_MAX, 0);

  299. }

  300. 

  301. /**

  302.  * read signed golomb rice code (shorten).

  303.  */

  304. static inline int get_sr_golomb_shorten(GetBitContext* gb, int k)

  305. {

  306.     int uvar = get_ur_golomb_jpegls(gb, k + 1, INT_MAX, 0);

  307.     if (uvar & 1)

  308.         return ~(uvar >> 1);

  309.     else

  310.         return uvar >> 1;

  311. }

  312. 

  313. 

  314. 

  315. #ifdef TRACE

  316. 

  317. static inline int get_ue(GetBitContext *s, char *file, const char *func, int line){

  318.     int show= show_bits(s, 24);

  319.     int pos= get_bits_count(s);

  320.     int i= get_ue_golomb(s);

  321.     int len= get_bits_count(s) - pos;

  322.     int bits= show>>(24-len);

  323. 

  324.     print_bin(bits, len);

  325. 

  326.     av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d ue  @%5d in %s %s:%d\n", bits, len, i, pos, file, func, line);

  327. 

  328.     return i;

  329. }

  330. 

  331. static inline int get_se(GetBitContext *s, char *file, const char *func, int line){

  332.     int show= show_bits(s, 24);

  333.     int pos= get_bits_count(s);

  334.     int i= get_se_golomb(s);

  335.     int len= get_bits_count(s) - pos;

  336.     int bits= show>>(24-len);

  337. 

  338.     print_bin(bits, len);

  339. 

  340.     av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d se  @%5d in %s %s:%d\n", bits, len, i, pos, file, func, line);

  341. 

  342.     return i;

  343. }

  344. 

  345. static inline int get_te(GetBitContext *s, int r, char *file, const char *func, int line){

  346.     int show= show_bits(s, 24);

  347.     int pos= get_bits_count(s);

  348.     int i= get_te0_golomb(s, r);

  349.     int len= get_bits_count(s) - pos;

  350.     int bits= show>>(24-len);

  351. 

  352.     print_bin(bits, len);

  353. 

  354.     av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d te  @%5d in %s %s:%d\n", bits, len, i, pos, file, func, line);

  355. 

  356.     return i;

  357. }

  358. 

  359. #define get_ue_golomb(a) get_ue(a, __FILE__, __PRETTY_FUNCTION__, __LINE__)

  360. #define get_se_golomb(a) get_se(a, __FILE__, __PRETTY_FUNCTION__, __LINE__)

  361. #define get_te_golomb(a, r) get_te(a, r, __FILE__, __PRETTY_FUNCTION__, __LINE__)

  362. #define get_te0_golomb(a, r) get_te(a, r, __FILE__, __PRETTY_FUNCTION__, __LINE__)

  363. 

  364. #endif

  365. 

  366. /**

  367.  * write unsigned exp golomb code.

  368.  */

  369. static inline void set_ue_golomb(PutBitContext *pb, int i){

  370.     int e;

  371. 

  372.     assert(i>=0);

  373. 

  374. #if 0

  375.     if(i=0){

  376.         put_bits(pb, 1, 1);

  377.         return;

  378.     }

  379. #endif

  380.     if(i<256)

  381.         put_bits(pb, ff_ue_golomb_len[i], i+1);

  382.     else{

  383.         e= av_log2(i+1);

  384. 

  385.         put_bits(pb, 2*e+1, i+1);

  386.     }

  387. }

  388. 

  389. /**

  390.  * write truncated unsigned exp golomb code.

  391.  */

  392. static inline void set_te_golomb(PutBitContext *pb, int i, int range){

  393.     assert(range >= 1);

  394.     assert(i<=range);

  395. 

  396.     if(range==2) put_bits(pb, 1, i^1);

  397.     else         set_ue_golomb(pb, i);

  398. }

  399. 

  400. /**

  401.  * write signed exp golomb code. 16 bits at most.

  402.  */

  403. static inline void set_se_golomb(PutBitContext *pb, int i){

  404. //    if (i>32767 || i<-32767)

  405. //        av_log(NULL,AV_LOG_ERROR,"value out of range %d\n", i);

  406. #if 0

  407.     if(i<=0) i= -2*i;

  408.     else     i=  2*i-1;

  409. #elif 1

  410.     i= 2*i-1;

  411.     if(i<0) i^= -1; //FIXME check if gcc does the right thing

  412. #else

  413.     i= 2*i-1;

  414.     i^= (i>>31);

  415. #endif

  416.     set_ue_golomb(pb, i);

  417. }

  418. 

  419. /**

  420.  * write unsigned golomb rice code (ffv1).

  421.  */

  422. static inline void set_ur_golomb(PutBitContext *pb, int i, int k, int limit, int esc_len){

  423.     int e;

  424. 

  425.     assert(i>=0);

  426. 

  427.     e= i>>k;

  428.     if(e<limit){

  429.         put_bits(pb, e + k + 1, (1<<k) + (i&((1<<k)-1)));

  430.     }else{

  431.         put_bits(pb, limit + esc_len, i - limit + 1);

  432.     }

  433. }

  434. 

  435. /**

  436.  * write unsigned golomb rice code (jpegls).

  437.  */

  438. static inline void set_ur_golomb_jpegls(PutBitContext *pb, int i, int k, int limit, int esc_len){

  439.     int e;

  440. 

  441.     assert(i>=0);

  442. 

  443.     e= (i>>k) + 1;

  444.     if(e<limit){

  445.         while(e > 31) {

  446.             put_bits(pb, 31, 0);

  447.             e -= 31;

  448.         }

  449.         put_bits(pb, e, 1);

  450.         if(k)

  451.             put_bits(pb, k, i&((1<<k)-1));

  452.     }else{

  453.         while(limit > 31) {

  454.             put_bits(pb, 31, 0);

  455.             limit -= 31;

  456.         }

  457.         put_bits(pb, limit  , 1);

  458.         put_bits(pb, esc_len, i - 1);

  459.     }

  460. }

  461. 

  462. /**

  463.  * write signed golomb rice code (ffv1).

  464.  */

  465. static inline void set_sr_golomb(PutBitContext *pb, int i, int k, int limit, int esc_len){

  466.     int v;

  467. 

  468.     v = -2*i-1;

  469.     v ^= (v>>31);

  470. 

  471.     set_ur_golomb(pb, v, k, limit, esc_len);

  472. }

  473. 

  474. /**

  475.  * write signed golomb rice code (flac).

  476.  */

  477. static inline void set_sr_golomb_flac(PutBitContext *pb, int i, int k, int limit, int esc_len){

  478.     int v;

  479. 

  480.     v = -2*i-1;

  481.     v ^= (v>>31);

  482. 

  483.     set_ur_golomb_jpegls(pb, v, k, limit, esc_len);

  484. }

  485. 

  486. #endif // AVCODEC_GOLOMB_H