FFmpeg  4.3
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 
162  if (ff_interleaved_golomb_vlc_len[buf] != 9) {
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 
192  if (ff_interleaved_golomb_vlc_len[buf] != 9) {
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(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
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
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_log2
#define av_log2
Definition: intmath.h:83
r
#define r
Definition: input.c:40
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:269
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
pos
unsigned int pos
Definition: spdifenc.c:410
file
FFmpeg Automated Testing Environment ************************************Introduction Using FATE from your FFmpeg source directory Submitting the results to the FFmpeg result aggregation server Uploading new samples to the fate suite FATE makefile targets and variables Makefile targets Makefile variables Examples Introduction **************FATE is an extended regression suite on the client side and a means for results aggregation and presentation on the server side The first part of this document explains how you can use FATE from your FFmpeg source directory to test your ffmpeg binary The second part describes how you can run FATE to submit the results to FFmpeg’s FATE server In any way you can have a look at the publicly viewable FATE results by visiting this as it can be seen if some test on some platform broke with their recent contribution This usually happens on the platforms the developers could not test on The second part of this document describes how you can run FATE to submit your results to FFmpeg’s FATE server If you want to submit your results be sure to check that your combination of OS and compiler is not already listed on the above mentioned website In the third part you can find a comprehensive listing of FATE makefile targets and variables Using FATE from your FFmpeg source directory **********************************************If you want to run FATE on your machine you need to have the samples in place You can get the samples via the build target fate rsync Use this command from the top level source this will cause FATE to fail NOTE To use a custom wrapper to run the pass ‘ target exec’ to ‘configure’ or set the TARGET_EXEC Make variable Submitting the results to the FFmpeg result aggregation server ****************************************************************To submit your results to the server you should run fate through the shell script ‘tests fate sh’ from the FFmpeg sources This script needs to be invoked with a configuration file as its first argument tests fate sh path to fate_config A configuration file template with comments describing the individual configuration variables can be found at ‘doc fate_config sh template’ Create a configuration that suits your based on the configuration template The ‘slot’ configuration variable can be any string that is not yet but it is suggested that you name it adhering to the following pattern ‘ARCH OS COMPILER COMPILER VERSION’ The configuration file itself will be sourced in a shell therefore all shell features may be used This enables you to setup the environment as you need it for your build For your first test runs the ‘fate_recv’ variable should be empty or commented out This will run everything as normal except that it will omit the submission of the results to the server The following files should be present in $workdir as specified in the configuration file
Definition: fate.txt:125
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
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