git.sesse.net Git - ffmpeg/blob - libavcodec/put_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 writer API
  24  */
  25
  26 #ifndef AVCODEC_PUT_BITS_H
  27 #define AVCODEC_PUT_BITS_H
  28
  29 #include <stdint.h>
  30 #include <stddef.h>
  31
  32 #include "libavutil/intreadwrite.h"
  33 #include "libavutil/avassert.h"
  34
  35 typedef uint32_t BitBuf;
  36 #define AV_WBBUF AV_WB32
  37 #define AV_WLBUF AV_WL32
  38
  39 static const int BUF_BITS = 8 * sizeof(BitBuf);
  40
  41 typedef struct PutBitContext {
  42     BitBuf bit_buf;
  43     int bit_left;
  44     uint8_t *buf, *buf_ptr, *buf_end;
  45     int size_in_bits;
  46 } PutBitContext;
  47
  48 /**
  49  * Initialize the PutBitContext s.
  50  *
  51  * @param buffer the buffer where to put bits
  52  * @param buffer_size the size in bytes of buffer
  53  */
  54 static inline void init_put_bits(PutBitContext *s, uint8_t *buffer,
  55                                  int buffer_size)
  56 {
  57     if (buffer_size < 0) {
  58         buffer_size = 0;
  59         buffer      = NULL;
  60     }
  61
  62     s->size_in_bits = 8 * buffer_size;
  63     s->buf          = buffer;
  64     s->buf_end      = s->buf + buffer_size;
  65     s->buf_ptr      = s->buf;
  66     s->bit_left     = BUF_BITS;
  67     s->bit_buf      = 0;
  68 }
  69
  70 /**
  71  * @return the total number of bits written to the bitstream.
  72  */
  73 static inline int put_bits_count(PutBitContext *s)
  74 {
  75     return (s->buf_ptr - s->buf) * 8 + BUF_BITS - s->bit_left;
  76 }
  77
  78 /**
  79  * Rebase the bit writer onto a reallocated buffer.
  80  *
  81  * @param buffer the buffer where to put bits
  82  * @param buffer_size the size in bytes of buffer,
  83  *                    must be large enough to hold everything written so far
  84  */
  85 static inline void rebase_put_bits(PutBitContext *s, uint8_t *buffer,
  86                                    int buffer_size)
  87 {
  88     av_assert0(8*buffer_size >= put_bits_count(s));
  89
  90     s->buf_end = buffer + buffer_size;
  91     s->buf_ptr = buffer + (s->buf_ptr - s->buf);
  92     s->buf     = buffer;
  93     s->size_in_bits = 8 * buffer_size;
  94 }
  95
  96 /**
  97  * @return the number of bits available in the bitstream.
  98  */
  99 static inline int put_bits_left(PutBitContext* s)
 100 {
 101     return (s->buf_end - s->buf_ptr) * 8 - BUF_BITS + s->bit_left;
 102 }
 103
 104 /**
 105  * Pad the end of the output stream with zeros.
 106  */
 107 static inline void flush_put_bits(PutBitContext *s)
 108 {
 109 #ifndef BITSTREAM_WRITER_LE
 110     if (s->bit_left < BUF_BITS)
 111         s->bit_buf <<= s->bit_left;
 112 #endif
 113     while (s->bit_left < BUF_BITS) {
 114         av_assert0(s->buf_ptr < s->buf_end);
 115 #ifdef BITSTREAM_WRITER_LE
 116         *s->buf_ptr++ = s->bit_buf;
 117         s->bit_buf  >>= 8;
 118 #else
 119         *s->buf_ptr++ = s->bit_buf >> (BUF_BITS - 8);
 120         s->bit_buf  <<= 8;
 121 #endif
 122         s->bit_left  += 8;
 123     }
 124     s->bit_left = BUF_BITS;
 125     s->bit_buf  = 0;
 126 }
 127
 128 static inline void flush_put_bits_le(PutBitContext *s)
 129 {
 130     while (s->bit_left < BUF_BITS) {
 131         av_assert0(s->buf_ptr < s->buf_end);
 132         *s->buf_ptr++ = s->bit_buf;
 133         s->bit_buf  >>= 8;
 134         s->bit_left  += 8;
 135     }
 136     s->bit_left = BUF_BITS;
 137     s->bit_buf  = 0;
 138 }
 139
 140 #ifdef BITSTREAM_WRITER_LE
 141 #define avpriv_align_put_bits align_put_bits_unsupported_here
 142 #define avpriv_put_string ff_put_string_unsupported_here
 143 #define avpriv_copy_bits avpriv_copy_bits_unsupported_here
 144 #else
 145 /**
 146  * Pad the bitstream with zeros up to the next byte boundary.
 147  */
 148 void avpriv_align_put_bits(PutBitContext *s);
 149
 150 /**
 151  * Put the string string in the bitstream.
 152  *
 153  * @param terminate_string 0-terminates the written string if value is 1
 154  */
 155 void avpriv_put_string(PutBitContext *pb, const char *string,
 156                        int terminate_string);
 157
 158 /**
 159  * Copy the content of src to the bitstream.
 160  *
 161  * @param length the number of bits of src to copy
 162  */
 163 void avpriv_copy_bits(PutBitContext *pb, const uint8_t *src, int length);
 164 #endif
 165
 166 /**
 167  * Write up to 31 bits into a bitstream.
 168  * Use put_bits32 to write 32 bits.
 169  */
 170 static inline void put_bits(PutBitContext *s, int n, BitBuf value)
 171 {
 172     BitBuf bit_buf;
 173     int bit_left;
 174
 175     av_assert2(n <= 31 && value < (1UL << n));
 176
 177     bit_buf  = s->bit_buf;
 178     bit_left = s->bit_left;
 179
 180     /* XXX: optimize */
 181 #ifdef BITSTREAM_WRITER_LE
 182     bit_buf |= value << (BUF_BITS - bit_left);
 183     if (n >= bit_left) {
 184         if (s->buf_end - s->buf_ptr >= sizeof(BitBuf)) {
 185             AV_WLBUF(s->buf_ptr, bit_buf);
 186             s->buf_ptr += sizeof(BitBuf);
 187         } else {
 188             av_log(NULL, AV_LOG_ERROR, "Internal error, put_bits buffer too small\n");
 189             av_assert2(0);
 190         }
 191         bit_buf     = value >> bit_left;
 192         bit_left   += BUF_BITS;
 193     }
 194     bit_left -= n;
 195 #else
 196     if (n < bit_left) {
 197         bit_buf     = (bit_buf << n) | value;
 198         bit_left   -= n;
 199     } else {
 200         bit_buf   <<= bit_left;
 201         bit_buf    |= value >> (n - bit_left);
 202         if (s->buf_end - s->buf_ptr >= sizeof(BitBuf)) {
 203             AV_WBBUF(s->buf_ptr, bit_buf);
 204             s->buf_ptr += sizeof(BitBuf);
 205         } else {
 206             av_log(NULL, AV_LOG_ERROR, "Internal error, put_bits buffer too small\n");
 207             av_assert2(0);
 208         }
 209         bit_left   += BUF_BITS - n;
 210         bit_buf     = value;
 211     }
 212 #endif
 213
 214     s->bit_buf  = bit_buf;
 215     s->bit_left = bit_left;
 216 }
 217
 218 static inline void put_bits_le(PutBitContext *s, int n, BitBuf value)
 219 {
 220     BitBuf bit_buf;
 221     int bit_left;
 222
 223     av_assert2(n <= 31 && value < (1UL << n));
 224
 225     bit_buf  = s->bit_buf;
 226     bit_left = s->bit_left;
 227
 228     bit_buf |= value << (BUF_BITS - bit_left);
 229     if (n >= bit_left) {
 230         if (s->buf_end - s->buf_ptr >= sizeof(BitBuf)) {
 231             AV_WLBUF(s->buf_ptr, bit_buf);
 232             s->buf_ptr += sizeof(BitBuf);
 233         } else {
 234             av_log(NULL, AV_LOG_ERROR, "Internal error, put_bits buffer too small\n");
 235             av_assert2(0);
 236         }
 237         bit_buf     = value >> bit_left;
 238         bit_left   += BUF_BITS;
 239     }
 240     bit_left -= n;
 241
 242     s->bit_buf  = bit_buf;
 243     s->bit_left = bit_left;
 244 }
 245
 246 static inline void put_sbits(PutBitContext *pb, int n, int32_t value)
 247 {
 248     av_assert2(n >= 0 && n <= 31);
 249
 250     put_bits(pb, n, av_mod_uintp2(value, n));
 251 }
 252
 253 /**
 254  * Write exactly 32 bits into a bitstream.
 255  */
 256 static void av_unused put_bits32(PutBitContext *s, uint32_t value)
 257 {
 258     BitBuf bit_buf;
 259     int bit_left;
 260
 261     bit_buf  = s->bit_buf;
 262     bit_left = s->bit_left;
 263
 264 #ifdef BITSTREAM_WRITER_LE
 265     bit_buf |= (BitBuf)value << (BUF_BITS - bit_left);
 266     if (s->buf_end - s->buf_ptr >= sizeof(BitBuf)) {
 267         AV_WLBUF(s->buf_ptr, bit_buf);
 268         s->buf_ptr += sizeof(BitBuf);
 269     } else {
 270         av_log(NULL, AV_LOG_ERROR, "Internal error, put_bits buffer too small\n");
 271         av_assert2(0);
 272     }
 273     bit_buf     = (uint64_t)value >> bit_left;
 274 #else
 275     bit_buf     = (uint64_t)bit_buf << bit_left;
 276     bit_buf    |= (BitBuf)value >> (BUF_BITS - bit_left);
 277     if (s->buf_end - s->buf_ptr >= sizeof(BitBuf)) {
 278         AV_WBBUF(s->buf_ptr, bit_buf);
 279         s->buf_ptr += sizeof(BitBuf);
 280     } else {
 281         av_log(NULL, AV_LOG_ERROR, "Internal error, put_bits buffer too small\n");
 282         av_assert2(0);
 283     }
 284     bit_buf     = value;
 285 #endif
 286
 287     s->bit_buf  = bit_buf;
 288     s->bit_left = bit_left;
 289 }
 290
 291 /**
 292  * Write up to 64 bits into a bitstream.
 293  */
 294 static inline void put_bits64(PutBitContext *s, int n, uint64_t value)
 295 {
 296     av_assert2((n == 64) || (n < 64 && value < (UINT64_C(1) << n)));
 297
 298     if (n < 32)
 299         put_bits(s, n, value);
 300     else if (n == 32)
 301         put_bits32(s, value);
 302     else if (n < 64) {
 303         uint32_t lo = value & 0xffffffff;
 304         uint32_t hi = value >> 32;
 305 #ifdef BITSTREAM_WRITER_LE
 306         put_bits32(s, lo);
 307         put_bits(s, n - 32, hi);
 308 #else
 309         put_bits(s, n - 32, hi);
 310         put_bits32(s, lo);
 311 #endif
 312     } else {
 313         uint32_t lo = value & 0xffffffff;
 314         uint32_t hi = value >> 32;
 315 #ifdef BITSTREAM_WRITER_LE
 316         put_bits32(s, lo);
 317         put_bits32(s, hi);
 318 #else
 319         put_bits32(s, hi);
 320         put_bits32(s, lo);
 321 #endif
 322
 323     }
 324 }
 325
 326 /**
 327  * Return the pointer to the byte where the bitstream writer will put
 328  * the next bit.
 329  */
 330 static inline uint8_t *put_bits_ptr(PutBitContext *s)
 331 {
 332     return s->buf_ptr;
 333 }
 334
 335 /**
 336  * Skip the given number of bytes.
 337  * PutBitContext must be flushed & aligned to a byte boundary before calling this.
 338  */
 339 static inline void skip_put_bytes(PutBitContext *s, int n)
 340 {
 341     av_assert2((put_bits_count(s) & 7) == 0);
 342     av_assert2(s->bit_left == BUF_BITS);
 343     av_assert0(n <= s->buf_end - s->buf_ptr);
 344     s->buf_ptr += n;
 345 }
 346
 347 /**
 348  * Skip the given number of bits.
 349  * Must only be used if the actual values in the bitstream do not matter.
 350  * If n is 0 the behavior is undefined.
 351  */
 352 static inline void skip_put_bits(PutBitContext *s, int n)
 353 {
 354     s->bit_left -= n;
 355     s->buf_ptr  -= sizeof(BitBuf) * ((unsigned)s->bit_left / BUF_BITS);
 356     s->bit_left &= (BUF_BITS - 1);
 357 }
 358
 359 /**
 360  * Change the end of the buffer.
 361  *
 362  * @param size the new size in bytes of the buffer where to put bits
 363  */
 364 static inline void set_put_bits_buffer_size(PutBitContext *s, int size)
 365 {
 366     av_assert0(size <= INT_MAX/8 - BUF_BITS);
 367     s->buf_end = s->buf + size;
 368     s->size_in_bits = 8*size;
 369 }
 370
 371 #undef AV_WBBUF
 372 #undef AV_WLBUF
 373
 374 #endif /* AVCODEC_PUT_BITS_H */