3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4 * Copyright (c) 2004 Alex Beregszaszi
6 * This file is part of Libav.
8 * Libav 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.
13 * Libav 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.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with Libav; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26 * exp golomb vlc stuff
27 * @author Michael Niedermayer <michaelni@gmx.at> and Alex Beregszaszi
30 #ifndef AVCODEC_GOLOMB_H
31 #define AVCODEC_GOLOMB_H
35 #include "bitstream.h"
38 #define INVALID_VLC 0x80000000
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];
45 extern const uint8_t ff_interleaved_golomb_vlc_len[256];
46 extern const uint8_t ff_interleaved_ue_golomb_vlc_code[256];
47 extern const int8_t ff_interleaved_se_golomb_vlc_code[256];
48 extern const uint8_t ff_interleaved_dirac_golomb_vlc_code[256];
51 * read unsigned exp golomb code.
53 static inline int get_ue_golomb(BitstreamContext *bc)
57 buf = bitstream_peek(bc, 32);
59 if (buf >= (1 << 27)) {
61 bitstream_skip(bc, ff_golomb_vlc_len[buf]);
63 return ff_ue_golomb_vlc_code[buf];
65 int log = 2 * av_log2(buf) - 31;
68 bitstream_skip(bc, 32 - log);
75 * Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
77 static inline unsigned get_ue_golomb_long(BitstreamContext *bc)
81 buf = bitstream_peek(bc, 32);
82 log = 31 - av_log2(buf);
83 bitstream_skip(bc, log);
85 return bitstream_read(bc, log + 1) - 1;
89 * read unsigned exp golomb code, constraint to a max of 31.
90 * the return value is undefined if the stored value exceeds 31.
92 static inline int get_ue_golomb_31(BitstreamContext *bc)
96 buf = bitstream_peek(bc, 32);
99 bitstream_skip(bc, ff_golomb_vlc_len[buf]);
101 return ff_ue_golomb_vlc_code[buf];
104 static inline unsigned get_interleaved_ue_golomb(BitstreamContext *bc)
108 buf = bitstream_peek(bc, 32);
110 if (buf & 0xAA800000) {
112 bitstream_skip(bc, ff_interleaved_golomb_vlc_len[buf]);
114 return ff_interleaved_ue_golomb_vlc_code[buf];
120 bitstream_skip(bc, FFMIN(ff_interleaved_golomb_vlc_len[buf], 8));
122 if (ff_interleaved_golomb_vlc_len[buf] != 9) {
123 ret <<= (ff_interleaved_golomb_vlc_len[buf] - 1) >> 1;
124 ret |= ff_interleaved_dirac_golomb_vlc_code[buf];
127 ret = (ret << 4) | ff_interleaved_dirac_golomb_vlc_code[buf];
128 buf = bitstream_peek(bc, 32);
129 } while (bitstream_bits_left(bc) > 0);
136 * read unsigned truncated exp golomb code.
138 static inline int get_te0_golomb(BitstreamContext *bc, int range)
145 return bitstream_read_bit(bc) ^ 1;
147 return get_ue_golomb(bc);
151 * read unsigned truncated exp golomb code.
153 static inline int get_te_golomb(BitstreamContext *bc, int range)
158 return bitstream_read_bit(bc) ^ 1;
160 return get_ue_golomb(bc);
164 * read signed exp golomb code.
166 static inline int get_se_golomb(BitstreamContext *bc)
170 buf = bitstream_peek(bc, 32);
172 if (buf >= (1 << 27)) {
174 bitstream_skip(bc, ff_golomb_vlc_len[buf]);
176 return ff_se_golomb_vlc_code[buf];
178 int log = 2 * av_log2(buf) - 31;
181 bitstream_skip(bc, 32 - log);
192 static inline int get_se_golomb_long(BitstreamContext *bc)
194 unsigned int buf = get_ue_golomb_long(bc);
197 buf = (buf + 1) >> 1;
204 static inline int get_interleaved_se_golomb(BitstreamContext *bc)
208 buf = bitstream_peek(bc, 32);
210 if (buf & 0xAA800000) {
212 bitstream_skip(bc, ff_interleaved_golomb_vlc_len[buf]);
214 return ff_interleaved_se_golomb_vlc_code[buf];
217 bitstream_skip(bc, 8);
218 buf |= 1 | bitstream_peek(bc, 24);
220 if ((buf & 0xAAAAAAAA) == 0)
223 for (log = 31; (buf & 0x80000000) == 0; log--)
224 buf = (buf << 2) - ((buf << log) >> (log - 1)) + (buf >> 30);
226 bitstream_skip(bc, 63 - 2 * log - 8);
228 return (signed) (((((buf << log) >> log) - 1) ^ -(buf & 0x1)) + 1) >> 1;
232 static inline int dirac_get_se_golomb(BitstreamContext *bc)
234 uint32_t ret = get_interleaved_ue_golomb(bc);
238 buf = bitstream_read_signed(bc, 1);
239 ret = (ret ^ buf) - buf;
246 * read unsigned golomb rice code (ffv1).
248 static inline int get_ur_golomb(BitstreamContext *bc, int k, int limit,
254 buf = bitstream_peek(bc, 32);
258 if (log > 31 - limit) {
260 buf += (30 - log) << k;
261 bitstream_skip(bc, 32 + k - log);
265 bitstream_skip(bc, limit);
266 buf = bitstream_read(bc, esc_len);
268 return buf + limit - 1;
273 * read unsigned golomb rice code (jpegls).
275 static inline int get_ur_golomb_jpegls(BitstreamContext *bc, int k, int limit,
281 buf = bitstream_peek(bc, 32);
285 if (log - k >= 1 && 32 - log < limit) {
287 buf += (30 - log) << k;
288 bitstream_skip(bc, 32 + k - log);
293 for (i = 0; i < limit && bitstream_peek(bc, 1) == 0 && bitstream_bits_left(bc) > 0; i++)
294 bitstream_skip(bc, 1);
295 bitstream_skip(bc, 1);
299 buf = bitstream_read(bc, k);
304 return buf + (i << k);
305 } else if (i == limit - 1) {
306 buf = bitstream_read(bc, esc_len);
315 * read signed golomb rice code (ffv1).
317 static inline int get_sr_golomb(BitstreamContext *bc, int k, int limit,
320 int v = get_ur_golomb(bc, k, limit, esc_len);
328 // return (v>>1) ^ -(v&1);
332 * read signed golomb rice code (flac).
334 static inline int get_sr_golomb_flac(BitstreamContext *bc, int k, int limit,
337 int v = get_ur_golomb_jpegls(bc, k, limit, esc_len);
338 return (v >> 1) ^ -(v & 1);
342 * read unsigned golomb rice code (shorten).
344 static inline unsigned int get_ur_golomb_shorten(BitstreamContext *bc, int k)
346 return get_ur_golomb_jpegls(bc, k, INT_MAX, 0);
350 * read signed golomb rice code (shorten).
352 static inline int get_sr_golomb_shorten(BitstreamContext *bc, int k)
354 int uvar = get_ur_golomb_jpegls(bc, k + 1, INT_MAX, 0);
363 static inline int get_ue(BitstreamContext *s, const char *file, const char *func,
366 int show = bitstream_peek(s, 24);
367 int pos = bitstream_tell(s);
368 int i = get_ue_golomb(s);
369 int len = bitstream_tell(s) - pos;
370 int bits = show >> (24 - len);
372 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d ue @%5d in %s %s:%d\n",
373 bits, len, i, pos, file, func, line);
378 static inline int get_se(BitstreamContext *s, const char *file, const char *func,
381 int show = bitstream_peek(s, 24);
382 int pos = bitstream_tell(s);
383 int i = get_se_golomb(s);
384 int len = bitstream_tell(s) - pos;
385 int bits = show >> (24 - len);
387 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d se @%5d in %s %s:%d\n",
388 bits, len, i, pos, file, func, line);
393 static inline int get_te(BitstreamContext *s, int r, char *file, const char *func,
396 int show = bitstream_peek(s, 24);
397 int pos = bitstream_tell(s);
398 int i = get_te0_golomb(s, r);
399 int len = bitstream_tell(s) - pos;
400 int bits = show >> (24 - len);
402 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d te @%5d in %s %s:%d\n",
403 bits, len, i, pos, file, func, line);
408 #define get_ue_golomb(a) get_ue(a, __FILE__, __func__, __LINE__)
409 #define get_se_golomb(a) get_se(a, __FILE__, __func__, __LINE__)
410 #define get_te_golomb(a, r) get_te(a, r, __FILE__, __func__, __LINE__)
411 #define get_te0_golomb(a, r) get_te(a, r, __FILE__, __func__, __LINE__)
416 * write unsigned exp golomb code.
418 static inline void set_ue_golomb(PutBitContext *pb, int i)
423 put_bits(pb, ff_ue_golomb_len[i], i + 1);
425 int e = av_log2(i + 1);
426 put_bits(pb, 2 * e + 1, i + 1);
431 * write truncated unsigned exp golomb code.
433 static inline void set_te_golomb(PutBitContext *pb, int i, int range)
439 put_bits(pb, 1, i ^ 1);
441 set_ue_golomb(pb, i);
445 * write signed exp golomb code. 16 bits at most.
447 static inline void set_se_golomb(PutBitContext *pb, int i)
451 i ^= -1; //FIXME check if gcc does the right thing
452 set_ue_golomb(pb, i);
456 * write unsigned golomb rice code (ffv1).
458 static inline void set_ur_golomb(PutBitContext *pb, int i, int k, int limit,
467 put_bits(pb, e + k + 1, (1 << k) + (i & ((1 << k) - 1)));
469 put_bits(pb, limit + esc_len, i - limit + 1);
473 * write unsigned golomb rice code (jpegls).
475 static inline void set_ur_golomb_jpegls(PutBitContext *pb, int i, int k,
476 int limit, int esc_len)
496 put_bits(pb, limit, 1);
497 put_bits(pb, esc_len, i - 1);
502 * write signed golomb rice code (ffv1).
504 static inline void set_sr_golomb(PutBitContext *pb, int i, int k, int limit,
512 set_ur_golomb(pb, v, k, limit, esc_len);
516 * write signed golomb rice code (flac).
518 static inline void set_sr_golomb_flac(PutBitContext *pb, int i, int k,
519 int limit, int esc_len)
526 set_ur_golomb_jpegls(pb, v, k, limit, esc_len);
529 #endif /* AVCODEC_GOLOMB_H */