FFmpeg  2.6.9
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
golomb.h
Go to the documentation of this file.
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
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 
35 #include "get_bits.h"
36 #include "put_bits.h"
37 
38 #define INVALID_VLC 0x80000000
39 
40 extern const uint8_t ff_golomb_vlc_len[512];
41 extern const uint8_t ff_ue_golomb_vlc_code[512];
42 extern const int8_t ff_se_golomb_vlc_code[512];
43 extern const uint8_t ff_ue_golomb_len[256];
44 
45 extern const uint8_t ff_interleaved_golomb_vlc_len[256];
47 extern const int8_t ff_interleaved_se_golomb_vlc_code[256];
49 
50 /**
51  * read unsigned exp golomb code.
52  */
53 static inline int get_ue_golomb(GetBitContext *gb)
54 {
55  unsigned int buf;
56 
57  OPEN_READER(re, gb);
58  UPDATE_CACHE(re, gb);
59  buf = GET_CACHE(re, gb);
60 
61  if (buf >= (1 << 27)) {
62  buf >>= 32 - 9;
64  CLOSE_READER(re, gb);
65 
66  return ff_ue_golomb_vlc_code[buf];
67  } else {
68  int log = 2 * av_log2(buf) - 31;
69  LAST_SKIP_BITS(re, gb, 32 - log);
70  CLOSE_READER(re, gb);
71  if (log < 7) {
72  av_log(NULL, AV_LOG_ERROR, "Invalid UE golomb code\n");
73  return AVERROR_INVALIDDATA;
74  }
75  buf >>= log;
76  buf--;
77 
78  return buf;
79  }
80 }
81 
82 /**
83  * Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
84  */
85 static inline unsigned get_ue_golomb_long(GetBitContext *gb)
86 {
87  unsigned buf, log;
88 
89  buf = show_bits_long(gb, 32);
90  log = 31 - av_log2(buf);
91  skip_bits_long(gb, log);
92 
93  return get_bits_long(gb, log + 1) - 1;
94 }
95 
96 /**
97  * read unsigned exp golomb code, constraint to a max of 31.
98  * the return value is undefined if the stored value exceeds 31.
99  */
100 static inline int get_ue_golomb_31(GetBitContext *gb)
101 {
102  unsigned int buf;
103 
104  OPEN_READER(re, gb);
105  UPDATE_CACHE(re, gb);
106  buf = GET_CACHE(re, gb);
107 
108  buf >>= 32 - 9;
110  CLOSE_READER(re, gb);
111 
112  return ff_ue_golomb_vlc_code[buf];
113 }
114 
115 static inline unsigned svq3_get_ue_golomb(GetBitContext *gb)
116 {
117  uint32_t buf;
118 
119  OPEN_READER(re, gb);
120  UPDATE_CACHE(re, gb);
121  buf = GET_CACHE(re, gb);
122 
123  if (buf & 0xAA800000) {
124  buf >>= 32 - 8;
126  CLOSE_READER(re, gb);
127 
129  } else {
130  unsigned ret = 1;
131 
132  do {
133  buf >>= 32 - 8;
134  LAST_SKIP_BITS(re, gb,
136 
137  if (ff_interleaved_golomb_vlc_len[buf] != 9) {
138  ret <<= (ff_interleaved_golomb_vlc_len[buf] - 1) >> 1;
140  break;
141  }
142  ret = (ret << 4) | ff_interleaved_dirac_golomb_vlc_code[buf];
143  UPDATE_CACHE(re, gb);
144  buf = GET_CACHE(re, gb);
145  } while (ret<0x8000000U && BITS_AVAILABLE(re, gb));
146 
147  CLOSE_READER(re, gb);
148  return ret - 1;
149  }
150 }
151 
152 /**
153  * read unsigned truncated exp golomb code.
154  */
155 static inline int get_te0_golomb(GetBitContext *gb, int range)
156 {
157  av_assert2(range >= 1);
158 
159  if (range == 1)
160  return 0;
161  else if (range == 2)
162  return get_bits1(gb) ^ 1;
163  else
164  return get_ue_golomb(gb);
165 }
166 
167 /**
168  * read unsigned truncated exp golomb code.
169  */
170 static inline int get_te_golomb(GetBitContext *gb, int range)
171 {
172  av_assert2(range >= 1);
173 
174  if (range == 2)
175  return get_bits1(gb) ^ 1;
176  else
177  return get_ue_golomb(gb);
178 }
179 
180 /**
181  * read signed exp golomb code.
182  */
183 static inline int get_se_golomb(GetBitContext *gb)
184 {
185  unsigned int buf;
186 
187  OPEN_READER(re, gb);
188  UPDATE_CACHE(re, gb);
189  buf = GET_CACHE(re, gb);
190 
191  if (buf >= (1 << 27)) {
192  buf >>= 32 - 9;
194  CLOSE_READER(re, gb);
195 
196  return ff_se_golomb_vlc_code[buf];
197  } else {
198  int log = av_log2(buf), sign;
199  LAST_SKIP_BITS(re, gb, 31 - log);
200  UPDATE_CACHE(re, gb);
201  buf = GET_CACHE(re, gb);
202 
203  buf >>= log;
204 
205  LAST_SKIP_BITS(re, gb, 32 - log);
206  CLOSE_READER(re, gb);
207 
208  sign = -(buf & 1);
209  buf = ((buf >> 1) ^ sign) - sign;
210 
211  return buf;
212  }
213 }
214 
215 static inline int get_se_golomb_long(GetBitContext *gb)
216 {
217  unsigned int buf = get_ue_golomb_long(gb);
218  int sign;
219 
220  sign = (buf & 1) - 1;
221  return ((buf >> 1) ^ sign) + 1;
222 }
223 
224 static inline int svq3_get_se_golomb(GetBitContext *gb)
225 {
226  unsigned int buf;
227 
228  OPEN_READER(re, gb);
229  UPDATE_CACHE(re, gb);
230  buf = GET_CACHE(re, gb);
231 
232  if (buf & 0xAA800000) {
233  buf >>= 32 - 8;
235  CLOSE_READER(re, gb);
236 
238  } else {
239  int log;
240  LAST_SKIP_BITS(re, gb, 8);
241  UPDATE_CACHE(re, gb);
242  buf |= 1 | (GET_CACHE(re, gb) >> 8);
243 
244  if ((buf & 0xAAAAAAAA) == 0)
245  return INVALID_VLC;
246 
247  for (log = 31; (buf & 0x80000000) == 0; log--)
248  buf = (buf << 2) - ((buf << log) >> (log - 1)) + (buf >> 30);
249 
250  LAST_SKIP_BITS(re, gb, 63 - 2 * log - 8);
251  CLOSE_READER(re, gb);
252 
253  return (signed) (((((buf << log) >> log) - 1) ^ -(buf & 0x1)) + 1) >> 1;
254  }
255 }
256 
257 static inline int dirac_get_se_golomb(GetBitContext *gb)
258 {
259  uint32_t ret = svq3_get_ue_golomb(gb);
260 
261  if (ret) {
262  int sign;
263  sign = -get_bits1(gb);
264  ret = (ret ^ sign) - sign;
265  }
266 
267  return ret;
268 }
269 
270 /**
271  * read unsigned golomb rice code (ffv1).
272  */
273 static inline int get_ur_golomb(GetBitContext *gb, int k, int limit,
274  int esc_len)
275 {
276  unsigned int buf;
277  int log;
278 
279  OPEN_READER(re, gb);
280  UPDATE_CACHE(re, gb);
281  buf = GET_CACHE(re, gb);
282 
283  log = av_log2(buf);
284 
285  if (log > 31 - limit) {
286  buf >>= log - k;
287  buf += (30 - log) << k;
288  LAST_SKIP_BITS(re, gb, 32 + k - log);
289  CLOSE_READER(re, gb);
290 
291  return buf;
292  } else {
293  LAST_SKIP_BITS(re, gb, limit);
294  UPDATE_CACHE(re, gb);
295 
296  buf = SHOW_UBITS(re, gb, esc_len);
297 
298  LAST_SKIP_BITS(re, gb, esc_len);
299  CLOSE_READER(re, gb);
300 
301  return buf + limit - 1;
302  }
303 }
304 
305 /**
306  * read unsigned golomb rice code (jpegls).
307  */
308 static inline int get_ur_golomb_jpegls(GetBitContext *gb, int k, int limit,
309  int esc_len)
310 {
311  unsigned int buf;
312  int log;
313 
314  OPEN_READER(re, gb);
315  UPDATE_CACHE(re, gb);
316  buf = GET_CACHE(re, gb);
317 
318  log = av_log2(buf);
319 
320  if (log - k >= 32 - MIN_CACHE_BITS + (MIN_CACHE_BITS == 32) &&
321  32 - log < limit) {
322  buf >>= log - k;
323  buf += (30 - log) << k;
324  LAST_SKIP_BITS(re, gb, 32 + k - log);
325  CLOSE_READER(re, gb);
326 
327  return buf;
328  } else {
329  int i;
330  for (i = 0; i < limit && SHOW_UBITS(re, gb, 1) == 0; i++) {
331  if (gb->size_in_bits <= re_index)
332  return -1;
333  LAST_SKIP_BITS(re, gb, 1);
334  UPDATE_CACHE(re, gb);
335  }
336  SKIP_BITS(re, gb, 1);
337 
338  if (i < limit - 1) {
339  if (k) {
340  if (k > MIN_CACHE_BITS - 1) {
341  buf = SHOW_UBITS(re, gb, 16) << (k-16);
342  LAST_SKIP_BITS(re, gb, 16);
343  UPDATE_CACHE(re, gb);
344  buf |= SHOW_UBITS(re, gb, k-16);
345  LAST_SKIP_BITS(re, gb, k-16);
346  } else {
347  buf = SHOW_UBITS(re, gb, k);
348  LAST_SKIP_BITS(re, gb, k);
349  }
350  } else {
351  buf = 0;
352  }
353 
354  CLOSE_READER(re, gb);
355  return buf + (i << k);
356  } else if (i == limit - 1) {
357  buf = SHOW_UBITS(re, gb, esc_len);
358  LAST_SKIP_BITS(re, gb, esc_len);
359  CLOSE_READER(re, gb);
360 
361  return buf + 1;
362  } else
363  return -1;
364  }
365 }
366 
367 /**
368  * read signed golomb rice code (ffv1).
369  */
370 static inline int get_sr_golomb(GetBitContext *gb, int k, int limit,
371  int esc_len)
372 {
373  int v = get_ur_golomb(gb, k, limit, esc_len);
374  int sign;
375 
376  v++;
377  sign = (v & 1) - 1;
378  return ((v >> 1) ^ sign) - sign;
379 }
380 
381 /**
382  * read signed golomb rice code (flac).
383  */
384 static inline int get_sr_golomb_flac(GetBitContext *gb, int k, int limit,
385  int esc_len)
386 {
387  int v = get_ur_golomb_jpegls(gb, k, limit, esc_len);
388  return (v >> 1) ^ -(v & 1);
389 }
390 
391 /**
392  * read unsigned golomb rice code (shorten).
393  */
394 static inline unsigned int get_ur_golomb_shorten(GetBitContext *gb, int k)
395 {
396  return get_ur_golomb_jpegls(gb, k, INT_MAX, 0);
397 }
398 
399 /**
400  * read signed golomb rice code (shorten).
401  */
402 static inline int get_sr_golomb_shorten(GetBitContext *gb, int k)
403 {
404  int uvar = get_ur_golomb_jpegls(gb, k + 1, INT_MAX, 0);
405  return (uvar >> 1) ^ -(uvar & 1);
406 }
407 
408 #ifdef TRACE
409 
410 static inline int get_ue(GetBitContext *s, const char *file, const char *func,
411  int line)
412 {
413  int show = show_bits(s, 24);
414  int pos = get_bits_count(s);
415  int i = get_ue_golomb(s);
416  int len = get_bits_count(s) - pos;
417  int bits = show >> (24 - len);
418 
419  print_bin(bits, len);
420 
421  av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d ue @%5d in %s %s:%d\n",
422  bits, len, i, pos, file, func, line);
423 
424  return i;
425 }
426 
427 static inline int get_se(GetBitContext *s, const char *file, const char *func,
428  int line)
429 {
430  int show = show_bits(s, 24);
431  int pos = get_bits_count(s);
432  int i = get_se_golomb(s);
433  int len = get_bits_count(s) - pos;
434  int bits = show >> (24 - len);
435 
436  print_bin(bits, len);
437 
438  av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d se @%5d in %s %s:%d\n",
439  bits, len, i, pos, file, func, line);
440 
441  return i;
442 }
443 
444 static inline int get_te(GetBitContext *s, int r, char *file, const char *func,
445  int line)
446 {
447  int show = show_bits(s, 24);
448  int pos = get_bits_count(s);
449  int i = get_te0_golomb(s, r);
450  int len = get_bits_count(s) - pos;
451  int bits = show >> (24 - len);
452 
453  print_bin(bits, len);
454 
455  av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d te @%5d in %s %s:%d\n",
456  bits, len, i, pos, file, func, line);
457 
458  return i;
459 }
460 
461 #define get_ue_golomb(a) get_ue(a, __FILE__, __PRETTY_FUNCTION__, __LINE__)
462 #define get_se_golomb(a) get_se(a, __FILE__, __PRETTY_FUNCTION__, __LINE__)
463 #define get_te_golomb(a, r) get_te(a, r, __FILE__, __PRETTY_FUNCTION__, __LINE__)
464 #define get_te0_golomb(a, r) get_te(a, r, __FILE__, __PRETTY_FUNCTION__, __LINE__)
465 
466 #endif /* TRACE */
467 
468 /**
469  * write unsigned exp golomb code.
470  */
471 static inline void set_ue_golomb(PutBitContext *pb, int i)
472 {
473  av_assert2(i >= 0);
474 
475 #if 0
476  if (i = 0) {
477  put_bits(pb, 1, 1);
478  return;
479  }
480 #endif
481  if (i < 256)
482  put_bits(pb, ff_ue_golomb_len[i], i + 1);
483  else {
484  int e = av_log2(i + 1);
485  put_bits(pb, 2 * e + 1, i + 1);
486  }
487 }
488 
489 /**
490  * write truncated unsigned exp golomb code.
491  */
492 static inline void set_te_golomb(PutBitContext *pb, int i, int range)
493 {
494  av_assert2(range >= 1);
495  av_assert2(i <= range);
496 
497  if (range == 2)
498  put_bits(pb, 1, i ^ 1);
499  else
500  set_ue_golomb(pb, i);
501 }
502 
503 /**
504  * write signed exp golomb code. 16 bits at most.
505  */
506 static inline void set_se_golomb(PutBitContext *pb, int i)
507 {
508 #if 0
509  if (i <= 0)
510  i = -2 * i;
511  else
512  i = 2 * i - 1;
513 #elif 1
514  i = 2 * i - 1;
515  if (i < 0)
516  i ^= -1; //FIXME check if gcc does the right thing
517 #else
518  i = 2 * i - 1;
519  i ^= (i >> 31);
520 #endif
521  set_ue_golomb(pb, i);
522 }
523 
524 /**
525  * write unsigned golomb rice code (ffv1).
526  */
527 static inline void set_ur_golomb(PutBitContext *pb, int i, int k, int limit,
528  int esc_len)
529 {
530  int e;
531 
532  av_assert2(i >= 0);
533 
534  e = i >> k;
535  if (e < limit)
536  put_bits(pb, e + k + 1, (1 << k) + (i & ((1 << k) - 1)));
537  else
538  put_bits(pb, limit + esc_len, i - limit + 1);
539 }
540 
541 /**
542  * write unsigned golomb rice code (jpegls).
543  */
544 static inline void set_ur_golomb_jpegls(PutBitContext *pb, int i, int k,
545  int limit, int esc_len)
546 {
547  int e;
548 
549  av_assert2(i >= 0);
550 
551  e = (i >> k) + 1;
552  if (e < limit) {
553  while (e > 31) {
554  put_bits(pb, 31, 0);
555  e -= 31;
556  }
557  put_bits(pb, e, 1);
558  if (k)
559  put_sbits(pb, k, i);
560  } else {
561  while (limit > 31) {
562  put_bits(pb, 31, 0);
563  limit -= 31;
564  }
565  put_bits(pb, limit, 1);
566  put_bits(pb, esc_len, i - 1);
567  }
568 }
569 
570 /**
571  * write signed golomb rice code (ffv1).
572  */
573 static inline void set_sr_golomb(PutBitContext *pb, int i, int k, int limit,
574  int esc_len)
575 {
576  int v;
577 
578  v = -2 * i - 1;
579  v ^= (v >> 31);
580 
581  set_ur_golomb(pb, v, k, limit, esc_len);
582 }
583 
584 /**
585  * write signed golomb rice code (flac).
586  */
587 static inline void set_sr_golomb_flac(PutBitContext *pb, int i, int k,
588  int limit, int esc_len)
589 {
590  int v;
591 
592  v = -2 * i - 1;
593  v ^= (v >> 31);
594 
595  set_ur_golomb_jpegls(pb, v, k, limit, esc_len);
596 }
597 
598 #endif /* AVCODEC_GOLOMB_H */
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:383
static int get_sr_golomb_flac(GetBitContext *gb, int k, int limit, int esc_len)
read signed golomb rice code (flac).
Definition: golomb.h:384
static void set_ur_golomb(PutBitContext *pb, int i, int k, int limit, int esc_len)
write unsigned golomb rice code (ffv1).
Definition: golomb.h:527
#define NULL
Definition: coverity.c:32
#define BITS_AVAILABLE(name, gb)
Definition: get_bits.h:135
float v
const char * s
Definition: avisynth_c.h:669
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:183
const uint8_t ff_ue_golomb_vlc_code[512]
Definition: golomb.c:50
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:200
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:198
static void skip_bits_long(GetBitContext *s, int n)
Definition: get_bits.h:217
static void set_ue_golomb(PutBitContext *pb, int i)
write unsigned exp golomb code.
Definition: golomb.h:471
const int8_t ff_interleaved_se_golomb_vlc_code[256]
Definition: golomb.c:138
const uint8_t ff_interleaved_golomb_vlc_len[256]
Definition: golomb.c:100
static unsigned svq3_get_ue_golomb(GetBitContext *gb)
Definition: golomb.h:115
#define INVALID_VLC
Definition: golomb.h:38
static int get_te0_golomb(GetBitContext *gb, int range)
read unsigned truncated exp golomb code.
Definition: golomb.h:155
static int get_ur_golomb_jpegls(GetBitContext *gb, int k, int limit, int esc_len)
read unsigned golomb rice code (jpegls).
Definition: golomb.h:308
const uint8_t ff_interleaved_dirac_golomb_vlc_code[256]
Definition: golomb.c:157
uint8_t bits
Definition: crc.c:295
uint8_t
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:63
static void set_te_golomb(PutBitContext *pb, int i, int range)
write truncated unsigned exp golomb code.
Definition: golomb.h:492
static int dirac_get_se_golomb(GetBitContext *gb)
Definition: golomb.h:257
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:212
bitstream reader API header.
const uint8_t ff_golomb_vlc_len[512]
Definition: golomb.c:31
static int get_ur_golomb(GetBitContext *gb, int k, int limit, int esc_len)
read unsigned golomb rice code (ffv1).
Definition: golomb.h:273
#define av_log(a,...)
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:173
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:175
static int get_ue_golomb(GetBitContext *gb)
read unsigned exp golomb code.
Definition: golomb.h:53
const char * r
Definition: vf_curves.c:107
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:196
Definition: graph2dot.c:48
const int8_t ff_se_golomb_vlc_code[512]
Definition: golomb.c:69
#define CLOSE_READER(name, gb)
Definition: get_bits.h:144
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:188
static int svq3_get_se_golomb(GetBitContext *gb)
Definition: golomb.h:224
#define FFMIN(a, b)
Definition: common.h:81
ret
Definition: avfilter.c:974
int size_in_bits
Definition: get_bits.h:57
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:287
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:194
static void set_ur_golomb_jpegls(PutBitContext *pb, int i, int k, int limit, int esc_len)
write unsigned golomb rice code (jpegls).
Definition: golomb.h:544
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:206
static void set_sr_golomb_flac(PutBitContext *pb, int i, int k, int limit, int esc_len)
write signed golomb rice code (flac).
Definition: golomb.h:587
static unsigned get_ue_golomb_long(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
Definition: golomb.h:85
static int get_se_golomb_long(GetBitContext *gb)
Definition: golomb.h:215
static void set_se_golomb(PutBitContext *pb, int i)
write signed exp golomb code.
Definition: golomb.h:506
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:100
#define OPEN_READER(name, gb)
Definition: get_bits.h:133
void * buf
Definition: avisynth_c.h:595
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:304
const uint8_t ff_interleaved_ue_golomb_vlc_code[256]
Definition: golomb.c:119
static void set_sr_golomb(PutBitContext *pb, int i, int k, int limit, int esc_len)
write signed golomb rice code (ffv1).
Definition: golomb.h:573
#define GET_CACHE(name, gb)
Definition: get_bits.h:210
int(* func)(AVBPrint *dst, const char *in, const char *arg)
Definition: jacosubdec.c:67
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:337
#define MIN_CACHE_BITS
Definition: get_bits.h:125
static int get_te_golomb(GetBitContext *gb, int range)
read unsigned truncated exp golomb code.
Definition: golomb.h:170
const uint8_t ff_ue_golomb_len[256]
Definition: golomb.c:89
float re
Definition: fft-test.c:73
int len
#define av_log2
Definition: intmath.h:105
static unsigned int get_ur_golomb_shorten(GetBitContext *gb, int k)
read unsigned golomb rice code (shorten).
Definition: golomb.h:394
static int get_sr_golomb(GetBitContext *gb, int k, int limit, int esc_len)
read signed golomb rice code (ffv1).
Definition: golomb.h:370
static int get_sr_golomb_shorten(GetBitContext *gb, int k)
read signed golomb rice code (shorten).
Definition: golomb.h:402
bitstream writer API