lavc/aacsbr: fix make checkheaders warning
[ffmpeg.git] / libavcodec / get_bits.h
1 /*
2  * copyright (c) 2004 Michael Niedermayer <michaelni@gmx.at>
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20
21 /**
22  * @file
23  * bitstream reader API header.
24  */
25
26 #ifndef AVCODEC_GET_BITS_H
27 #define AVCODEC_GET_BITS_H
28
29 #include <stdint.h>
30
31 #include "libavutil/common.h"
32 #include "libavutil/intreadwrite.h"
33 #include "libavutil/log.h"
34 #include "libavutil/avassert.h"
35 #include "avcodec.h"
36 #include "mathops.h"
37 #include "vlc.h"
38
39 /*
40  * Safe bitstream reading:
41  * optionally, the get_bits API can check to ensure that we
42  * don't read past input buffer boundaries. This is protected
43  * with CONFIG_SAFE_BITSTREAM_READER at the global level, and
44  * then below that with UNCHECKED_BITSTREAM_READER at the per-
45  * decoder level. This means that decoders that check internally
46  * can "#define UNCHECKED_BITSTREAM_READER 1" to disable
47  * overread checks.
48  * Boundary checking causes a minor performance penalty so for
49  * applications that won't want/need this, it can be disabled
50  * globally using "#define CONFIG_SAFE_BITSTREAM_READER 0".
51  */
52 #ifndef UNCHECKED_BITSTREAM_READER
53 #define UNCHECKED_BITSTREAM_READER !CONFIG_SAFE_BITSTREAM_READER
54 #endif
55
56 typedef struct GetBitContext {
57     const uint8_t *buffer, *buffer_end;
58     int index;
59     int size_in_bits;
60     int size_in_bits_plus8;
61 } GetBitContext;
62
63 /* Bitstream reader API docs:
64  * name
65  *   arbitrary name which is used as prefix for the internal variables
66  *
67  * gb
68  *   getbitcontext
69  *
70  * OPEN_READER(name, gb)
71  *   load gb into local variables
72  *
73  * CLOSE_READER(name, gb)
74  *   store local vars in gb
75  *
76  * UPDATE_CACHE(name, gb)
77  *   Refill the internal cache from the bitstream.
78  *   After this call at least MIN_CACHE_BITS will be available.
79  *
80  * GET_CACHE(name, gb)
81  *   Will output the contents of the internal cache,
82  *   next bit is MSB of 32 or 64 bits (FIXME 64 bits).
83  *
84  * SHOW_UBITS(name, gb, num)
85  *   Will return the next num bits.
86  *
87  * SHOW_SBITS(name, gb, num)
88  *   Will return the next num bits and do sign extension.
89  *
90  * SKIP_BITS(name, gb, num)
91  *   Will skip over the next num bits.
92  *   Note, this is equivalent to SKIP_CACHE; SKIP_COUNTER.
93  *
94  * SKIP_CACHE(name, gb, num)
95  *   Will remove the next num bits from the cache (note SKIP_COUNTER
96  *   MUST be called before UPDATE_CACHE / CLOSE_READER).
97  *
98  * SKIP_COUNTER(name, gb, num)
99  *   Will increment the internal bit counter (see SKIP_CACHE & SKIP_BITS).
100  *
101  * LAST_SKIP_BITS(name, gb, num)
102  *   Like SKIP_BITS, to be used if next call is UPDATE_CACHE or CLOSE_READER.
103  *
104  * BITS_LEFT(name, gb)
105  *   Return the number of bits left
106  *
107  * For examples see get_bits, show_bits, skip_bits, get_vlc.
108  */
109
110 #ifdef LONG_BITSTREAM_READER
111 #   define MIN_CACHE_BITS 32
112 #else
113 #   define MIN_CACHE_BITS 25
114 #endif
115
116 #define OPEN_READER_NOSIZE(name, gb)            \
117     unsigned int name ## _index = (gb)->index;  \
118     unsigned int av_unused name ## _cache
119
120 #if UNCHECKED_BITSTREAM_READER
121 #define OPEN_READER(name, gb) OPEN_READER_NOSIZE(name, gb)
122
123 #define BITS_AVAILABLE(name, gb) 1
124 #else
125 #define OPEN_READER(name, gb)                   \
126     OPEN_READER_NOSIZE(name, gb);               \
127     unsigned int name ## _size_plus8 = (gb)->size_in_bits_plus8
128
129 #define BITS_AVAILABLE(name, gb) name ## _index < name ## _size_plus8
130 #endif
131
132 #define CLOSE_READER(name, gb) (gb)->index = name ## _index
133
134 # ifdef LONG_BITSTREAM_READER
135
136 # define UPDATE_CACHE_LE(name, gb) name ## _cache = \
137       AV_RL64((gb)->buffer + (name ## _index >> 3)) >> (name ## _index & 7)
138
139 # define UPDATE_CACHE_BE(name, gb) name ## _cache = \
140       AV_RB64((gb)->buffer + (name ## _index >> 3)) >> (32 - (name ## _index & 7))
141
142 #else
143
144 # define UPDATE_CACHE_LE(name, gb) name ## _cache = \
145       AV_RL32((gb)->buffer + (name ## _index >> 3)) >> (name ## _index & 7)
146
147 # define UPDATE_CACHE_BE(name, gb) name ## _cache = \
148       AV_RB32((gb)->buffer + (name ## _index >> 3)) << (name ## _index & 7)
149
150 #endif
151
152
153 #ifdef BITSTREAM_READER_LE
154
155 # define UPDATE_CACHE(name, gb) UPDATE_CACHE_LE(name, gb)
156
157 # define SKIP_CACHE(name, gb, num) name ## _cache >>= (num)
158
159 #else
160
161 # define UPDATE_CACHE(name, gb) UPDATE_CACHE_BE(name, gb)
162
163 # define SKIP_CACHE(name, gb, num) name ## _cache <<= (num)
164
165 #endif
166
167 #if UNCHECKED_BITSTREAM_READER
168 #   define SKIP_COUNTER(name, gb, num) name ## _index += (num)
169 #else
170 #   define SKIP_COUNTER(name, gb, num) \
171     name ## _index = FFMIN(name ## _size_plus8, name ## _index + (num))
172 #endif
173
174 #define BITS_LEFT(name, gb) ((int)((gb)->size_in_bits - name ## _index))
175
176 #define SKIP_BITS(name, gb, num)                \
177     do {                                        \
178         SKIP_CACHE(name, gb, num);              \
179         SKIP_COUNTER(name, gb, num);            \
180     } while (0)
181
182 #define LAST_SKIP_BITS(name, gb, num) SKIP_COUNTER(name, gb, num)
183
184 #define SHOW_UBITS_LE(name, gb, num) zero_extend(name ## _cache, num)
185 #define SHOW_SBITS_LE(name, gb, num) sign_extend(name ## _cache, num)
186
187 #define SHOW_UBITS_BE(name, gb, num) NEG_USR32(name ## _cache, num)
188 #define SHOW_SBITS_BE(name, gb, num) NEG_SSR32(name ## _cache, num)
189
190 #ifdef BITSTREAM_READER_LE
191 #   define SHOW_UBITS(name, gb, num) SHOW_UBITS_LE(name, gb, num)
192 #   define SHOW_SBITS(name, gb, num) SHOW_SBITS_LE(name, gb, num)
193 #else
194 #   define SHOW_UBITS(name, gb, num) SHOW_UBITS_BE(name, gb, num)
195 #   define SHOW_SBITS(name, gb, num) SHOW_SBITS_BE(name, gb, num)
196 #endif
197
198 #define GET_CACHE(name, gb) ((uint32_t) name ## _cache)
199
200 static inline int get_bits_count(const GetBitContext *s)
201 {
202     return s->index;
203 }
204
205 /**
206  * Skips the specified number of bits.
207  * @param n the number of bits to skip,
208  *          For the UNCHECKED_BITSTREAM_READER this must not cause the distance
209  *          from the start to overflow int32_t. Staying within the bitstream + padding
210  *          is sufficient, too.
211  */
212 static inline void skip_bits_long(GetBitContext *s, int n)
213 {
214 #if UNCHECKED_BITSTREAM_READER
215     s->index += n;
216 #else
217     s->index += av_clip(n, -s->index, s->size_in_bits_plus8 - s->index);
218 #endif
219 }
220
221 /**
222  * Read MPEG-1 dc-style VLC (sign bit + mantissa with no MSB).
223  * if MSB not set it is negative
224  * @param n length in bits
225  */
226 static inline int get_xbits(GetBitContext *s, int n)
227 {
228     register int sign;
229     register int32_t cache;
230     OPEN_READER(re, s);
231     av_assert2(n>0 && n<=25);
232     UPDATE_CACHE(re, s);
233     cache = GET_CACHE(re, s);
234     sign  = ~cache >> 31;
235     LAST_SKIP_BITS(re, s, n);
236     CLOSE_READER(re, s);
237     return (NEG_USR32(sign ^ cache, n) ^ sign) - sign;
238 }
239
240 static inline int get_xbits_le(GetBitContext *s, int n)
241 {
242     register int sign;
243     register int32_t cache;
244     OPEN_READER(re, s);
245     av_assert2(n>0 && n<=25);
246     UPDATE_CACHE_LE(re, s);
247     cache = GET_CACHE(re, s);
248     sign  = sign_extend(~cache, n) >> 31;
249     LAST_SKIP_BITS(re, s, n);
250     CLOSE_READER(re, s);
251     return (zero_extend(sign ^ cache, n) ^ sign) - sign;
252 }
253
254 static inline int get_sbits(GetBitContext *s, int n)
255 {
256     register int tmp;
257     OPEN_READER(re, s);
258     av_assert2(n>0 && n<=25);
259     UPDATE_CACHE(re, s);
260     tmp = SHOW_SBITS(re, s, n);
261     LAST_SKIP_BITS(re, s, n);
262     CLOSE_READER(re, s);
263     return tmp;
264 }
265
266 /**
267  * Read 1-25 bits.
268  */
269 static inline unsigned int get_bits(GetBitContext *s, int n)
270 {
271     register int tmp;
272     OPEN_READER(re, s);
273     av_assert2(n>0 && n<=25);
274     UPDATE_CACHE(re, s);
275     tmp = SHOW_UBITS(re, s, n);
276     LAST_SKIP_BITS(re, s, n);
277     CLOSE_READER(re, s);
278     return tmp;
279 }
280
281 /**
282  * Read 0-25 bits.
283  */
284 static av_always_inline int get_bitsz(GetBitContext *s, int n)
285 {
286     return n ? get_bits(s, n) : 0;
287 }
288
289 static inline unsigned int get_bits_le(GetBitContext *s, int n)
290 {
291     register int tmp;
292     OPEN_READER(re, s);
293     av_assert2(n>0 && n<=25);
294     UPDATE_CACHE_LE(re, s);
295     tmp = SHOW_UBITS_LE(re, s, n);
296     LAST_SKIP_BITS(re, s, n);
297     CLOSE_READER(re, s);
298     return tmp;
299 }
300
301 /**
302  * Show 1-25 bits.
303  */
304 static inline unsigned int show_bits(GetBitContext *s, int n)
305 {
306     register int tmp;
307     OPEN_READER_NOSIZE(re, s);
308     av_assert2(n>0 && n<=25);
309     UPDATE_CACHE(re, s);
310     tmp = SHOW_UBITS(re, s, n);
311     return tmp;
312 }
313
314 static inline void skip_bits(GetBitContext *s, int n)
315 {
316     OPEN_READER(re, s);
317     LAST_SKIP_BITS(re, s, n);
318     CLOSE_READER(re, s);
319 }
320
321 static inline unsigned int get_bits1(GetBitContext *s)
322 {
323     unsigned int index = s->index;
324     uint8_t result     = s->buffer[index >> 3];
325 #ifdef BITSTREAM_READER_LE
326     result >>= index & 7;
327     result  &= 1;
328 #else
329     result <<= index & 7;
330     result >>= 8 - 1;
331 #endif
332 #if !UNCHECKED_BITSTREAM_READER
333     if (s->index < s->size_in_bits_plus8)
334 #endif
335         index++;
336     s->index = index;
337
338     return result;
339 }
340
341 static inline unsigned int show_bits1(GetBitContext *s)
342 {
343     return show_bits(s, 1);
344 }
345
346 static inline void skip_bits1(GetBitContext *s)
347 {
348     skip_bits(s, 1);
349 }
350
351 /**
352  * Read 0-32 bits.
353  */
354 static inline unsigned int get_bits_long(GetBitContext *s, int n)
355 {
356     av_assert2(n>=0 && n<=32);
357     if (!n) {
358         return 0;
359     } else if (n <= MIN_CACHE_BITS) {
360         return get_bits(s, n);
361     } else {
362 #ifdef BITSTREAM_READER_LE
363         unsigned ret = get_bits(s, 16);
364         return ret | (get_bits(s, n - 16) << 16);
365 #else
366         unsigned ret = get_bits(s, 16) << (n - 16);
367         return ret | get_bits(s, n - 16);
368 #endif
369     }
370 }
371
372 /**
373  * Read 0-64 bits.
374  */
375 static inline uint64_t get_bits64(GetBitContext *s, int n)
376 {
377     if (n <= 32) {
378         return get_bits_long(s, n);
379     } else {
380 #ifdef BITSTREAM_READER_LE
381         uint64_t ret = get_bits_long(s, 32);
382         return ret | (uint64_t) get_bits_long(s, n - 32) << 32;
383 #else
384         uint64_t ret = (uint64_t) get_bits_long(s, n - 32) << 32;
385         return ret | get_bits_long(s, 32);
386 #endif
387     }
388 }
389
390 /**
391  * Read 0-32 bits as a signed integer.
392  */
393 static inline int get_sbits_long(GetBitContext *s, int n)
394 {
395     // sign_extend(x, 0) is undefined
396     if (!n)
397         return 0;
398
399     return sign_extend(get_bits_long(s, n), n);
400 }
401
402 /**
403  * Show 0-32 bits.
404  */
405 static inline unsigned int show_bits_long(GetBitContext *s, int n)
406 {
407     if (n <= MIN_CACHE_BITS) {
408         return show_bits(s, n);
409     } else {
410         GetBitContext gb = *s;
411         return get_bits_long(&gb, n);
412     }
413 }
414
415 static inline int check_marker(void *logctx, GetBitContext *s, const char *msg)
416 {
417     int bit = get_bits1(s);
418     if (!bit)
419         av_log(logctx, AV_LOG_INFO, "Marker bit missing at %d of %d %s\n",
420                get_bits_count(s) - 1, s->size_in_bits, msg);
421
422     return bit;
423 }
424
425 /**
426  * Initialize GetBitContext.
427  * @param buffer bitstream buffer, must be AV_INPUT_BUFFER_PADDING_SIZE bytes
428  *        larger than the actual read bits because some optimized bitstream
429  *        readers read 32 or 64 bit at once and could read over the end
430  * @param bit_size the size of the buffer in bits
431  * @return 0 on success, AVERROR_INVALIDDATA if the buffer_size would overflow.
432  */
433 static inline int init_get_bits(GetBitContext *s, const uint8_t *buffer,
434                                 int bit_size)
435 {
436     int buffer_size;
437     int ret = 0;
438
439     if (bit_size >= INT_MAX - FFMAX(7, AV_INPUT_BUFFER_PADDING_SIZE*8) || bit_size < 0 || !buffer) {
440         bit_size    = 0;
441         buffer      = NULL;
442         ret         = AVERROR_INVALIDDATA;
443     }
444
445     buffer_size = (bit_size + 7) >> 3;
446
447     s->buffer             = buffer;
448     s->size_in_bits       = bit_size;
449     s->size_in_bits_plus8 = bit_size + 8;
450     s->buffer_end         = buffer + buffer_size;
451     s->index              = 0;
452
453     return ret;
454 }
455
456 /**
457  * Initialize GetBitContext.
458  * @param buffer bitstream buffer, must be AV_INPUT_BUFFER_PADDING_SIZE bytes
459  *        larger than the actual read bits because some optimized bitstream
460  *        readers read 32 or 64 bit at once and could read over the end
461  * @param byte_size the size of the buffer in bytes
462  * @return 0 on success, AVERROR_INVALIDDATA if the buffer_size would overflow.
463  */
464 static inline int init_get_bits8(GetBitContext *s, const uint8_t *buffer,
465                                  int byte_size)
466 {
467     if (byte_size > INT_MAX / 8 || byte_size < 0)
468         byte_size = -1;
469     return init_get_bits(s, buffer, byte_size * 8);
470 }
471
472 static inline const uint8_t *align_get_bits(GetBitContext *s)
473 {
474     int n = -get_bits_count(s) & 7;
475     if (n)
476         skip_bits(s, n);
477     return s->buffer + (s->index >> 3);
478 }
479
480 /**
481  * If the vlc code is invalid and max_depth=1, then no bits will be removed.
482  * If the vlc code is invalid and max_depth>1, then the number of bits removed
483  * is undefined.
484  */
485 #define GET_VLC(code, name, gb, table, bits, max_depth)         \
486     do {                                                        \
487         int n, nb_bits;                                         \
488         unsigned int index;                                     \
489                                                                 \
490         index = SHOW_UBITS(name, gb, bits);                     \
491         code  = table[index][0];                                \
492         n     = table[index][1];                                \
493                                                                 \
494         if (max_depth > 1 && n < 0) {                           \
495             LAST_SKIP_BITS(name, gb, bits);                     \
496             UPDATE_CACHE(name, gb);                             \
497                                                                 \
498             nb_bits = -n;                                       \
499                                                                 \
500             index = SHOW_UBITS(name, gb, nb_bits) + code;       \
501             code  = table[index][0];                            \
502             n     = table[index][1];                            \
503             if (max_depth > 2 && n < 0) {                       \
504                 LAST_SKIP_BITS(name, gb, nb_bits);              \
505                 UPDATE_CACHE(name, gb);                         \
506                                                                 \
507                 nb_bits = -n;                                   \
508                                                                 \
509                 index = SHOW_UBITS(name, gb, nb_bits) + code;   \
510                 code  = table[index][0];                        \
511                 n     = table[index][1];                        \
512             }                                                   \
513         }                                                       \
514         SKIP_BITS(name, gb, n);                                 \
515     } while (0)
516
517 #define GET_RL_VLC(level, run, name, gb, table, bits,  \
518                    max_depth, need_update)                      \
519     do {                                                        \
520         int n, nb_bits;                                         \
521         unsigned int index;                                     \
522                                                                 \
523         index = SHOW_UBITS(name, gb, bits);                     \
524         level = table[index].level;                             \
525         n     = table[index].len;                               \
526                                                                 \
527         if (max_depth > 1 && n < 0) {                           \
528             SKIP_BITS(name, gb, bits);                          \
529             if (need_update) {                                  \
530                 UPDATE_CACHE(name, gb);                         \
531             }                                                   \
532                                                                 \
533             nb_bits = -n;                                       \
534                                                                 \
535             index = SHOW_UBITS(name, gb, nb_bits) + level;      \
536             level = table[index].level;                         \
537             n     = table[index].len;                           \
538             if (max_depth > 2 && n < 0) {                       \
539                 LAST_SKIP_BITS(name, gb, nb_bits);              \
540                 if (need_update) {                              \
541                     UPDATE_CACHE(name, gb);                     \
542                 }                                               \
543                 nb_bits = -n;                                   \
544                                                                 \
545                 index = SHOW_UBITS(name, gb, nb_bits) + level;  \
546                 level = table[index].level;                     \
547                 n     = table[index].len;                       \
548             }                                                   \
549         }                                                       \
550         run = table[index].run;                                 \
551         SKIP_BITS(name, gb, n);                                 \
552     } while (0)
553
554 /**
555  * Parse a vlc code.
556  * @param bits is the number of bits which will be read at once, must be
557  *             identical to nb_bits in init_vlc()
558  * @param max_depth is the number of times bits bits must be read to completely
559  *                  read the longest vlc code
560  *                  = (max_vlc_length + bits - 1) / bits
561  * @returns the code parsed or -1 if no vlc matches
562  */
563 static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE (*table)[2],
564                                      int bits, int max_depth)
565 {
566     int code;
567
568     OPEN_READER(re, s);
569     UPDATE_CACHE(re, s);
570
571     GET_VLC(code, re, s, table, bits, max_depth);
572
573     CLOSE_READER(re, s);
574
575     return code;
576 }
577
578 static inline int decode012(GetBitContext *gb)
579 {
580     int n;
581     n = get_bits1(gb);
582     if (n == 0)
583         return 0;
584     else
585         return get_bits1(gb) + 1;
586 }
587
588 static inline int decode210(GetBitContext *gb)
589 {
590     if (get_bits1(gb))
591         return 0;
592     else
593         return 2 - get_bits1(gb);
594 }
595
596 static inline int get_bits_left(GetBitContext *gb)
597 {
598     return gb->size_in_bits - get_bits_count(gb);
599 }
600
601 static inline int skip_1stop_8data_bits(GetBitContext *gb)
602 {
603     if (get_bits_left(gb) <= 0)
604         return AVERROR_INVALIDDATA;
605
606     while (get_bits1(gb)) {
607         skip_bits(gb, 8);
608         if (get_bits_left(gb) <= 0)
609             return AVERROR_INVALIDDATA;
610     }
611
612     return 0;
613 }
614
615 #endif /* AVCODEC_GET_BITS_H */