FFmpeg
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 an unsigned Exp-Golomb code in the range 0 to 8190.
52  *
53  * @returns the read value or a negative error code.
54  */
55 static inline int get_ue_golomb(GetBitContext *gb)
56 {
57  unsigned int buf;
58 
59 #if CACHED_BITSTREAM_READER
60  buf = show_bits_long(gb, 32);
61 
62  if (buf >= (1 << 27)) {
63  buf >>= 32 - 9;
65 
66  return ff_ue_golomb_vlc_code[buf];
67  } else {
68  int log = 2 * av_log2(buf) - 31;
69  buf >>= log;
70  buf--;
71  skip_bits_long(gb, 32 - log);
72 
73  return buf;
74  }
75 #else
76  OPEN_READER(re, gb);
77  UPDATE_CACHE(re, gb);
78  buf = GET_CACHE(re, gb);
79 
80  if (buf >= (1 << 27)) {
81  buf >>= 32 - 9;
83  CLOSE_READER(re, gb);
84 
85  return ff_ue_golomb_vlc_code[buf];
86  } else {
87  int log = 2 * av_log2(buf) - 31;
88  LAST_SKIP_BITS(re, gb, 32 - log);
89  CLOSE_READER(re, gb);
90  if (log < 7) {
91  av_log(NULL, AV_LOG_ERROR, "Invalid UE golomb code\n");
92  return AVERROR_INVALIDDATA;
93  }
94  buf >>= log;
95  buf--;
96 
97  return buf;
98  }
99 #endif
100 }
101 
102 /**
103  * Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
104  */
105 static inline unsigned get_ue_golomb_long(GetBitContext *gb)
106 {
107  unsigned buf, log;
108 
109  buf = show_bits_long(gb, 32);
110  log = 31 - av_log2(buf);
111  skip_bits_long(gb, log);
112 
113  return get_bits_long(gb, log + 1) - 1;
114 }
115 
116 /**
117  * read unsigned exp golomb code, constraint to a max of 31.
118  * the return value is undefined if the stored value exceeds 31.
119  */
120 static inline int get_ue_golomb_31(GetBitContext *gb)
121 {
122  unsigned int buf;
123 
124 #if CACHED_BITSTREAM_READER
125  buf = show_bits_long(gb, 32);
126 
127  buf >>= 32 - 9;
129 #else
130 
131  OPEN_READER(re, gb);
132  UPDATE_CACHE(re, gb);
133  buf = GET_CACHE(re, gb);
134 
135  buf >>= 32 - 9;
137  CLOSE_READER(re, gb);
138 #endif
139 
140  return ff_ue_golomb_vlc_code[buf];
141 }
142 
143 static inline unsigned get_interleaved_ue_golomb(GetBitContext *gb)
144 {
145  uint32_t buf;
146 
147 #if CACHED_BITSTREAM_READER
148  buf = show_bits_long(gb, 32);
149 
150  if (buf & 0xAA800000) {
151  buf >>= 32 - 8;
153 
155  } else {
156  unsigned ret = 1;
157 
158  do {
159  buf >>= 32 - 8;
161 
163  ret <<= (ff_interleaved_golomb_vlc_len[buf] - 1) >> 1;
165  break;
166  }
168  buf = show_bits_long(gb, 32);
169  } while (get_bits_left(gb) > 0);
170 
171  return ret - 1;
172  }
173 #else
174  OPEN_READER(re, gb);
175  UPDATE_CACHE(re, gb);
176  buf = GET_CACHE(re, gb);
177 
178  if (buf & 0xAA800000) {
179  buf >>= 32 - 8;
181  CLOSE_READER(re, gb);
182 
184  } else {
185  unsigned ret = 1;
186 
187  do {
188  buf >>= 32 - 8;
189  LAST_SKIP_BITS(re, gb,
191 
193  ret <<= (ff_interleaved_golomb_vlc_len[buf] - 1) >> 1;
195  break;
196  }
198  UPDATE_CACHE(re, gb);
199  buf = GET_CACHE(re, gb);
200  } while (ret<0x8000000U && BITS_AVAILABLE(re, gb));
201 
202  CLOSE_READER(re, gb);
203  return ret - 1;
204  }
205 #endif
206 }
207 
208 /**
209  * read unsigned truncated exp golomb code.
210  */
211 static inline int get_te0_golomb(GetBitContext *gb, int range)
212 {
213  av_assert2(range >= 1);
214 
215  if (range == 1)
216  return 0;
217  else if (range == 2)
218  return get_bits1(gb) ^ 1;
219  else
220  return get_ue_golomb(gb);
221 }
222 
223 /**
224  * read unsigned truncated exp golomb code.
225  */
226 static inline int get_te_golomb(GetBitContext *gb, int range)
227 {
228  av_assert2(range >= 1);
229 
230  if (range == 2)
231  return get_bits1(gb) ^ 1;
232  else
233  return get_ue_golomb(gb);
234 }
235 
236 /**
237  * read signed exp golomb code.
238  */
239 static inline int get_se_golomb(GetBitContext *gb)
240 {
241  unsigned int buf;
242 
243 #if CACHED_BITSTREAM_READER
244  buf = show_bits_long(gb, 32);
245 
246  if (buf >= (1 << 27)) {
247  buf >>= 32 - 9;
249 
250  return ff_se_golomb_vlc_code[buf];
251  } else {
252  int log = 2 * av_log2(buf) - 31;
253  buf >>= log;
254 
255  skip_bits_long(gb, 32 - log);
256 
257  if (buf & 1)
258  buf = -(buf >> 1);
259  else
260  buf = (buf >> 1);
261 
262  return buf;
263  }
264 #else
265  OPEN_READER(re, gb);
266  UPDATE_CACHE(re, gb);
267  buf = GET_CACHE(re, gb);
268 
269  if (buf >= (1 << 27)) {
270  buf >>= 32 - 9;
272  CLOSE_READER(re, gb);
273 
274  return ff_se_golomb_vlc_code[buf];
275  } else {
276  int log = av_log2(buf), sign;
277  LAST_SKIP_BITS(re, gb, 31 - log);
278  UPDATE_CACHE(re, gb);
279  buf = GET_CACHE(re, gb);
280 
281  buf >>= log;
282 
283  LAST_SKIP_BITS(re, gb, 32 - log);
284  CLOSE_READER(re, gb);
285 
286  sign = -(buf & 1);
287  buf = ((buf >> 1) ^ sign) - sign;
288 
289  return buf;
290  }
291 #endif
292 }
293 
294 static inline int get_se_golomb_long(GetBitContext *gb)
295 {
296  unsigned int buf = get_ue_golomb_long(gb);
297  int sign = (buf & 1) - 1;
298  return ((buf >> 1) ^ sign) + 1;
299 }
300 
302 {
303  unsigned int buf;
304 
305 #if CACHED_BITSTREAM_READER
306  buf = show_bits_long(gb, 32);
307 
308  if (buf & 0xAA800000) {
309  buf >>= 32 - 8;
311 
313  } else {
314  int log;
315  skip_bits(gb, 8);
316  buf |= 1 | show_bits_long(gb, 24);
317 
318  if ((buf & 0xAAAAAAAA) == 0)
319  return INVALID_VLC;
320 
321  for (log = 31; (buf & 0x80000000) == 0; log--)
322  buf = (buf << 2) - ((buf << log) >> (log - 1)) + (buf >> 30);
323 
324  skip_bits_long(gb, 63 - 2 * log - 8);
325 
326  return (signed) (((((buf << log) >> log) - 1) ^ -(buf & 0x1)) + 1) >> 1;
327  }
328 #else
329  OPEN_READER(re, gb);
330  UPDATE_CACHE(re, gb);
331  buf = GET_CACHE(re, gb);
332 
333  if (buf & 0xAA800000) {
334  buf >>= 32 - 8;
336  CLOSE_READER(re, gb);
337 
339  } else {
340  int log;
341  LAST_SKIP_BITS(re, gb, 8);
342  UPDATE_CACHE(re, gb);
343  buf |= 1 | (GET_CACHE(re, gb) >> 8);
344 
345  if ((buf & 0xAAAAAAAA) == 0)
346  return INVALID_VLC;
347 
348  for (log = 31; (buf & 0x80000000) == 0; log--)
349  buf = (buf << 2) - ((buf << log) >> (log - 1)) + (buf >> 30);
350 
351  LAST_SKIP_BITS(re, gb, 63 - 2 * log - 8);
352  CLOSE_READER(re, gb);
353 
354  return (signed) (((((buf << log) >> log) - 1) ^ -(buf & 0x1)) + 1) >> 1;
355  }
356 #endif
357 }
358 
359 static inline int dirac_get_se_golomb(GetBitContext *gb)
360 {
361  uint32_t ret = get_interleaved_ue_golomb(gb);
362 
363  if (ret) {
364  int sign = -get_bits1(gb);
365  ret = (ret ^ sign) - sign;
366  }
367 
368  return ret;
369 }
370 
371 /**
372  * read unsigned golomb rice code (ffv1).
373  */
374 static inline int get_ur_golomb(GetBitContext *gb, int k, int limit,
375  int esc_len)
376 {
377  unsigned int buf;
378  int log;
379 
380 #if CACHED_BITSTREAM_READER
381  buf = show_bits_long(gb, 32);
382 
383  log = av_log2(buf);
384 
385  if (log > 31 - limit) {
386  buf >>= log - k;
387  buf += (30 - log) << k;
388  skip_bits_long(gb, 32 + k - log);
389 
390  return buf;
391  } else {
392  skip_bits_long(gb, limit);
393  buf = get_bits_long(gb, esc_len);
394 
395  return buf + limit - 1;
396  }
397 #else
398  OPEN_READER(re, gb);
399  UPDATE_CACHE(re, gb);
400  buf = GET_CACHE(re, gb);
401 
402  log = av_log2(buf);
403 
404  if (log > 31 - limit) {
405  buf >>= log - k;
406  buf += (30U - log) << k;
407  LAST_SKIP_BITS(re, gb, 32 + k - log);
408  CLOSE_READER(re, gb);
409 
410  return buf;
411  } else {
412  LAST_SKIP_BITS(re, gb, limit);
413  UPDATE_CACHE(re, gb);
414 
415  buf = SHOW_UBITS(re, gb, esc_len);
416 
417  LAST_SKIP_BITS(re, gb, esc_len);
418  CLOSE_READER(re, gb);
419 
420  return buf + limit - 1;
421  }
422 #endif
423 }
424 
425 /**
426  * read unsigned golomb rice code (jpegls).
427  */
428 static inline int get_ur_golomb_jpegls(GetBitContext *gb, int k, int limit,
429  int esc_len)
430 {
431  unsigned int buf;
432  int log;
433 
434 #if CACHED_BITSTREAM_READER
435  buf = show_bits_long(gb, 32);
436 
437  log = av_log2(buf);
438 
439  if (log - k >= 1 && 32 - log < limit) {
440  buf >>= log - k;
441  buf += (30 - log) << k;
442  skip_bits_long(gb, 32 + k - log);
443 
444  return buf;
445  } else {
446  int i;
447  for (i = 0;
448  i < limit && get_bits1(gb) == 0 && get_bits_left(gb) > 0;
449  i++);
450 
451  if (i < limit - 1) {
452  buf = get_bits_long(gb, k);
453 
454  return buf + (i << k);
455  } else if (i == limit - 1) {
456  buf = get_bits_long(gb, esc_len);
457 
458  return buf + 1;
459  } else
460  return -1;
461  }
462 #else
463  OPEN_READER(re, gb);
464  UPDATE_CACHE(re, gb);
465  buf = GET_CACHE(re, gb);
466 
467  log = av_log2(buf);
468 
469  av_assert2(k <= 31);
470 
471  if (log - k >= 32 - MIN_CACHE_BITS + (MIN_CACHE_BITS == 32) &&
472  32 - log < limit) {
473  buf >>= log - k;
474  buf += (30U - log) << k;
475  LAST_SKIP_BITS(re, gb, 32 + k - log);
476  CLOSE_READER(re, gb);
477 
478  return buf;
479  } else {
480  int i;
481  for (i = 0; i + MIN_CACHE_BITS <= limit && SHOW_UBITS(re, gb, MIN_CACHE_BITS) == 0; i += MIN_CACHE_BITS) {
482  if (gb->size_in_bits <= re_index) {
483  CLOSE_READER(re, gb);
484  return -1;
485  }
487  UPDATE_CACHE(re, gb);
488  }
489  for (; i < limit && SHOW_UBITS(re, gb, 1) == 0; i++) {
490  SKIP_BITS(re, gb, 1);
491  }
492  LAST_SKIP_BITS(re, gb, 1);
493  UPDATE_CACHE(re, gb);
494 
495  if (i < limit - 1) {
496  if (k) {
497  if (k > MIN_CACHE_BITS - 1) {
498  buf = SHOW_UBITS(re, gb, 16) << (k-16);
499  LAST_SKIP_BITS(re, gb, 16);
500  UPDATE_CACHE(re, gb);
501  buf |= SHOW_UBITS(re, gb, k-16);
502  LAST_SKIP_BITS(re, gb, k-16);
503  } else {
504  buf = SHOW_UBITS(re, gb, k);
505  LAST_SKIP_BITS(re, gb, k);
506  }
507  } else {
508  buf = 0;
509  }
510 
511  buf += ((SUINT)i << k);
512  } else if (i == limit - 1) {
513  buf = SHOW_UBITS(re, gb, esc_len);
514  LAST_SKIP_BITS(re, gb, esc_len);
515 
516  buf ++;
517  } else {
518  buf = -1;
519  }
520  CLOSE_READER(re, gb);
521  return buf;
522  }
523 #endif
524 }
525 
526 /**
527  * read signed golomb rice code (ffv1).
528  */
529 static inline int get_sr_golomb(GetBitContext *gb, int k, int limit,
530  int esc_len)
531 {
532  unsigned v = get_ur_golomb(gb, k, limit, esc_len);
533  return (v >> 1) ^ -(v & 1);
534 }
535 
536 /**
537  * read signed golomb rice code (flac).
538  */
539 static inline int get_sr_golomb_flac(GetBitContext *gb, int k, int limit,
540  int esc_len)
541 {
542  unsigned v = get_ur_golomb_jpegls(gb, k, limit, esc_len);
543  return (v >> 1) ^ -(v & 1);
544 }
545 
546 /**
547  * read unsigned golomb rice code (shorten).
548  */
549 static inline unsigned int get_ur_golomb_shorten(GetBitContext *gb, int k)
550 {
551  return get_ur_golomb_jpegls(gb, k, INT_MAX, 0);
552 }
553 
554 /**
555  * read signed golomb rice code (shorten).
556  */
557 static inline int get_sr_golomb_shorten(GetBitContext *gb, int k)
558 {
559  int uvar = get_ur_golomb_jpegls(gb, k + 1, INT_MAX, 0);
560  return (uvar >> 1) ^ -(uvar & 1);
561 }
562 
563 #ifdef TRACE
564 
565 static inline int get_ue(GetBitContext *s, const char *file, const char *func,
566  int line)
567 {
568  int show = show_bits(s, 24);
569  int pos = get_bits_count(s);
570  int i = get_ue_golomb(s);
571  int len = get_bits_count(s) - pos;
572  int bits = show >> (24 - len);
573 
574  av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d ue @%5d in %s %s:%d\n",
575  bits, len, i, pos, file, func, line);
576 
577  return i;
578 }
579 
580 static inline int get_se(GetBitContext *s, const char *file, const char *func,
581  int line)
582 {
583  int show = show_bits(s, 24);
584  int pos = get_bits_count(s);
585  int i = get_se_golomb(s);
586  int len = get_bits_count(s) - pos;
587  int bits = show >> (24 - len);
588 
589  av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d se @%5d in %s %s:%d\n",
590  bits, len, i, pos, file, func, line);
591 
592  return i;
593 }
594 
595 static inline int get_te(GetBitContext *s, int r, char *file, const char *func,
596  int line)
597 {
598  int show = show_bits(s, 24);
599  int pos = get_bits_count(s);
600  int i = get_te0_golomb(s, r);
601  int len = get_bits_count(s) - pos;
602  int bits = show >> (24 - len);
603 
604  av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d te @%5d in %s %s:%d\n",
605  bits, len, i, pos, file, func, line);
606 
607  return i;
608 }
609 
610 #define get_ue_golomb(a) get_ue(a, __FILE__, __func__, __LINE__)
611 #define get_se_golomb(a) get_se(a, __FILE__, __func__, __LINE__)
612 #define get_te_golomb(a, r) get_te(a, r, __FILE__, __func__, __LINE__)
613 #define get_te0_golomb(a, r) get_te(a, r, __FILE__, __func__, __LINE__)
614 
615 #endif /* TRACE */
616 
617 /**
618  * write unsigned exp golomb code. 2^16 - 2 at most
619  */
620 static inline void set_ue_golomb(PutBitContext *pb, int i)
621 {
622  av_assert2(i >= 0);
623  av_assert2(i <= 0xFFFE);
624 
625  if (i < 256)
626  put_bits(pb, ff_ue_golomb_len[i], i + 1);
627  else {
628  int e = av_log2(i + 1);
629  put_bits(pb, 2 * e + 1, i + 1);
630  }
631 }
632 
633 /**
634  * write unsigned exp golomb code. 2^32-2 at most.
635  */
636 static inline void set_ue_golomb_long(PutBitContext *pb, uint32_t i)
637 {
638  av_assert2(i <= (UINT32_MAX - 1));
639 
640  if (i < 256)
641  put_bits(pb, ff_ue_golomb_len[i], i + 1);
642  else {
643  int e = av_log2(i + 1);
644  put_bits64(pb, 2 * e + 1, i + 1);
645  }
646 }
647 
648 /**
649  * write truncated unsigned exp golomb code.
650  */
651 static inline void set_te_golomb(PutBitContext *pb, int i, int range)
652 {
653  av_assert2(range >= 1);
654  av_assert2(i <= range);
655 
656  if (range == 2)
657  put_bits(pb, 1, i ^ 1);
658  else
659  set_ue_golomb(pb, i);
660 }
661 
662 /**
663  * write signed exp golomb code. 16 bits at most.
664  */
665 static inline void set_se_golomb(PutBitContext *pb, int i)
666 {
667  i = 2 * i - 1;
668  if (i < 0)
669  i ^= -1; //FIXME check if gcc does the right thing
670  set_ue_golomb(pb, i);
671 }
672 
673 /**
674  * write unsigned golomb rice code (ffv1).
675  */
676 static inline void set_ur_golomb(PutBitContext *pb, int i, int k, int limit,
677  int esc_len)
678 {
679  int e;
680 
681  av_assert2(i >= 0);
682 
683  e = i >> k;
684  if (e < limit)
685  put_bits(pb, e + k + 1, (1 << k) + av_mod_uintp2(i, k));
686  else
687  put_bits(pb, limit + esc_len, i - limit + 1);
688 }
689 
690 /**
691  * write unsigned golomb rice code (jpegls).
692  */
693 static inline void set_ur_golomb_jpegls(PutBitContext *pb, int i, int k,
694  int limit, int esc_len)
695 {
696  int e;
697 
698  av_assert2(i >= 0);
699 
700  e = (i >> k) + 1;
701  if (e < limit) {
702  while (e > 31) {
703  put_bits(pb, 31, 0);
704  e -= 31;
705  }
706  put_bits(pb, e, 1);
707  if (k)
708  put_sbits(pb, k, i);
709  } else {
710  while (limit > 31) {
711  put_bits(pb, 31, 0);
712  limit -= 31;
713  }
714  put_bits(pb, limit, 1);
715  put_bits(pb, esc_len, i - 1);
716  }
717 }
718 
719 /**
720  * write signed golomb rice code (ffv1).
721  */
722 static inline void set_sr_golomb(PutBitContext *pb, int i, int k, int limit,
723  int esc_len)
724 {
725  int v;
726 
727  v = -2 * i - 1;
728  v ^= (v >> 31);
729 
730  set_ur_golomb(pb, v, k, limit, esc_len);
731 }
732 
733 /**
734  * write signed golomb rice code (flac).
735  */
736 static inline void set_sr_golomb_flac(PutBitContext *pb, int i, int k,
737  int limit, int esc_len)
738 {
739  int v;
740 
741  v = -2 * i - 1;
742  v ^= (v >> 31);
743 
744  set_ur_golomb_jpegls(pb, v, k, limit, esc_len);
745 }
746 
747 #endif /* AVCODEC_GOLOMB_H */
func
int(* func)(AVBPrint *dst, const char *in, const char *arg)
Definition: jacosubdec.c:67
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
show_bits_long
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:602
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
r
const char * r
Definition: vf_curves.c:114
set_sr_golomb_flac
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:736
get_se_golomb_long
static int get_se_golomb_long(GetBitContext *gb)
Definition: golomb.h:294
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
put_sbits
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:240
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
get_interleaved_ue_golomb
static unsigned get_interleaved_ue_golomb(GetBitContext *gb)
Definition: golomb.h:143
GetBitContext::size_in_bits
int size_in_bits
Definition: get_bits.h:68
get_sr_golomb
static int get_sr_golomb(GetBitContext *gb, int k, int limit, int esc_len)
read signed golomb rice code (ffv1).
Definition: golomb.h:529
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:208
get_ue_golomb
static int get_ue_golomb(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to 8190.
Definition: golomb.h:55
get_ur_golomb_shorten
static unsigned int get_ur_golomb_shorten(GetBitContext *gb, int k)
read unsigned golomb rice code (shorten).
Definition: golomb.h:549
set_ue_golomb_long
static void set_ue_golomb_long(PutBitContext *pb, uint32_t i)
write unsigned exp golomb code.
Definition: golomb.h:636
put_bits64
static void put_bits64(PutBitContext *s, int n, uint64_t value)
Write up to 64 bits into a bitstream.
Definition: put_bits.h:288
ff_interleaved_ue_golomb_vlc_code
const uint8_t ff_interleaved_ue_golomb_vlc_code[256]
Definition: golomb.c:119
get_ur_golomb
static int get_ur_golomb(GetBitContext *gb, int k, int limit, int esc_len)
read unsigned golomb rice code (ffv1).
Definition: golomb.h:374
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:178
set_ur_golomb
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:676
ff_ue_golomb_len
const uint8_t ff_ue_golomb_len[256]
Definition: golomb.c:89
GET_CACHE
#define GET_CACHE(name, gb)
Definition: get_bits.h:215
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
U
#define U(x)
Definition: vp56_arith.h:37
GetBitContext
Definition: get_bits.h:61
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
buf
void * buf
Definition: avisynth_c.h:766
get_ur_golomb_jpegls
static int get_ur_golomb_jpegls(GetBitContext *gb, int k, int limit, int esc_len)
read unsigned golomb rice code (jpegls).
Definition: golomb.h:428
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
s
#define s(width, name)
Definition: cbs_vp9.c:257
bits
uint8_t bits
Definition: vp3data.h:202
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
get_bits.h
ff_interleaved_dirac_golomb_vlc_code
const uint8_t ff_interleaved_dirac_golomb_vlc_code[256]
Definition: golomb.c:157
SKIP_BITS
#define SKIP_BITS(name, gb, num)
Definition: get_bits.h:193
set_ur_golomb_jpegls
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:693
get_se_golomb
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:239
PutBitContext
Definition: put_bits.h:35
get_te_golomb
static int get_te_golomb(GetBitContext *gb, int range)
read unsigned truncated exp golomb code.
Definition: golomb.h:226
NULL
#define NULL
Definition: coverity.c:32
get_sr_golomb_flac
static int get_sr_golomb_flac(GetBitContext *gb, int k, int limit, int esc_len)
read signed golomb rice code (flac).
Definition: golomb.h:539
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:199
ff_golomb_vlc_len
const uint8_t ff_golomb_vlc_len[512]
Definition: golomb.c:31
set_te_golomb
static void set_te_golomb(PutBitContext *pb, int i, int range)
write truncated unsigned exp golomb code.
Definition: golomb.h:651
set_sr_golomb
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:722
get_interleaved_se_golomb
static int get_interleaved_se_golomb(GetBitContext *gb)
Definition: golomb.h:301
ff_ue_golomb_vlc_code
const uint8_t ff_ue_golomb_vlc_code[512]
Definition: golomb.c:50
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
dirac_get_se_golomb
static int dirac_get_se_golomb(GetBitContext *gb)
Definition: golomb.h:359
line
Definition: graph2dot.c:48
set_ue_golomb
static void set_ue_golomb(PutBitContext *pb, int i)
write unsigned exp golomb code.
Definition: golomb.h:620
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
show_bits
static unsigned int show_bits(GetBitContext *s, int n)
Show 1-25 bits.
Definition: get_bits.h:446
MIN_CACHE_BITS
#define MIN_CACHE_BITS
Definition: get_bits.h:128
SUINT
#define SUINT
Definition: dct32_template.c:30
uint8_t
uint8_t
Definition: audio_convert.c:194
len
int len
Definition: vorbis_enc_data.h:452
get_sr_golomb_shorten
static int get_sr_golomb_shorten(GetBitContext *gb, int k)
read signed golomb rice code (shorten).
Definition: golomb.h:557
ret
ret
Definition: filter_design.txt:187
INVALID_VLC
#define INVALID_VLC
Definition: golomb.h:38
get_ue_golomb_31
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:120
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:211
ff_se_golomb_vlc_code
const int8_t ff_se_golomb_vlc_code[512]
Definition: golomb.c:69
get_ue_golomb_long
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:105
get_te0_golomb
static int get_te0_golomb(GetBitContext *gb, int range)
read unsigned truncated exp golomb code.
Definition: golomb.h:211
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
ff_interleaved_se_golomb_vlc_code
const int8_t ff_interleaved_se_golomb_vlc_code[256]
Definition: golomb.c:138
put_bits.h
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
ff_interleaved_golomb_vlc_len
const uint8_t ff_interleaved_golomb_vlc_len[256]
Definition: golomb.c:100
BITS_AVAILABLE
#define BITS_AVAILABLE(name, gb)
Definition: get_bits.h:140
re
float re
Definition: fft.c:82
set_se_golomb
static void set_se_golomb(PutBitContext *pb, int i)
write signed exp golomb code.
Definition: golomb.h:665