FFmpeg
put_bits.h
Go to the documentation of this file.
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 struct PutBitContext {
36  uint32_t bit_buf;
37  int bit_left;
41 
42 /**
43  * Initialize the PutBitContext s.
44  *
45  * @param buffer the buffer where to put bits
46  * @param buffer_size the size in bytes of buffer
47  */
48 static inline void init_put_bits(PutBitContext *s, uint8_t *buffer,
49  int buffer_size)
50 {
51  if (buffer_size < 0) {
52  buffer_size = 0;
53  buffer = NULL;
54  }
55 
56  s->size_in_bits = 8 * buffer_size;
57  s->buf = buffer;
58  s->buf_end = s->buf + buffer_size;
59  s->buf_ptr = s->buf;
60  s->bit_left = 32;
61  s->bit_buf = 0;
62 }
63 
64 /**
65  * @return the total number of bits written to the bitstream.
66  */
67 static inline int put_bits_count(PutBitContext *s)
68 {
69  return (s->buf_ptr - s->buf) * 8 + 32 - s->bit_left;
70 }
71 
72 /**
73  * Rebase the bit writer onto a reallocated buffer.
74  *
75  * @param buffer the buffer where to put bits
76  * @param buffer_size the size in bytes of buffer,
77  * must be large enough to hold everything written so far
78  */
80  int buffer_size)
81 {
82  av_assert0(8*buffer_size >= put_bits_count(s));
83 
84  s->buf_end = buffer + buffer_size;
85  s->buf_ptr = buffer + (s->buf_ptr - s->buf);
86  s->buf = buffer;
87  s->size_in_bits = 8 * buffer_size;
88 }
89 
90 /**
91  * @return the number of bits available in the bitstream.
92  */
93 static inline int put_bits_left(PutBitContext* s)
94 {
95  return (s->buf_end - s->buf_ptr) * 8 - 32 + s->bit_left;
96 }
97 
98 /**
99  * Pad the end of the output stream with zeros.
100  */
101 static inline void flush_put_bits(PutBitContext *s)
102 {
103 #ifndef BITSTREAM_WRITER_LE
104  if (s->bit_left < 32)
105  s->bit_buf <<= s->bit_left;
106 #endif
107  while (s->bit_left < 32) {
108  av_assert0(s->buf_ptr < s->buf_end);
109 #ifdef BITSTREAM_WRITER_LE
110  *s->buf_ptr++ = s->bit_buf;
111  s->bit_buf >>= 8;
112 #else
113  *s->buf_ptr++ = s->bit_buf >> 24;
114  s->bit_buf <<= 8;
115 #endif
116  s->bit_left += 8;
117  }
118  s->bit_left = 32;
119  s->bit_buf = 0;
120 }
121 
122 static inline void flush_put_bits_le(PutBitContext *s)
123 {
124  while (s->bit_left < 32) {
125  av_assert0(s->buf_ptr < s->buf_end);
126  *s->buf_ptr++ = s->bit_buf;
127  s->bit_buf >>= 8;
128  s->bit_left += 8;
129  }
130  s->bit_left = 32;
131  s->bit_buf = 0;
132 }
133 
134 #ifdef BITSTREAM_WRITER_LE
135 #define avpriv_align_put_bits align_put_bits_unsupported_here
136 #define avpriv_put_string ff_put_string_unsupported_here
137 #define avpriv_copy_bits avpriv_copy_bits_unsupported_here
138 #else
139 /**
140  * Pad the bitstream with zeros up to the next byte boundary.
141  */
143 
144 /**
145  * Put the string string in the bitstream.
146  *
147  * @param terminate_string 0-terminates the written string if value is 1
148  */
149 void avpriv_put_string(PutBitContext *pb, const char *string,
150  int terminate_string);
151 
152 /**
153  * Copy the content of src to the bitstream.
154  *
155  * @param length the number of bits of src to copy
156  */
157 void avpriv_copy_bits(PutBitContext *pb, const uint8_t *src, int length);
158 #endif
159 
160 /**
161  * Write up to 31 bits into a bitstream.
162  * Use put_bits32 to write 32 bits.
163  */
164 static inline void put_bits(PutBitContext *s, int n, unsigned int value)
165 {
166  unsigned int bit_buf;
167  int bit_left;
168 
169  av_assert2(n <= 31 && value < (1U << n));
170 
171  bit_buf = s->bit_buf;
172  bit_left = s->bit_left;
173 
174  /* XXX: optimize */
175 #ifdef BITSTREAM_WRITER_LE
176  bit_buf |= value << (32 - bit_left);
177  if (n >= bit_left) {
178  if (3 < s->buf_end - s->buf_ptr) {
179  AV_WL32(s->buf_ptr, bit_buf);
180  s->buf_ptr += 4;
181  } else {
182  av_log(NULL, AV_LOG_ERROR, "Internal error, put_bits buffer too small\n");
183  av_assert2(0);
184  }
185  bit_buf = value >> bit_left;
186  bit_left += 32;
187  }
188  bit_left -= n;
189 #else
190  if (n < bit_left) {
191  bit_buf = (bit_buf << n) | value;
192  bit_left -= n;
193  } else {
194  bit_buf <<= bit_left;
195  bit_buf |= value >> (n - bit_left);
196  if (3 < s->buf_end - s->buf_ptr) {
197  AV_WB32(s->buf_ptr, bit_buf);
198  s->buf_ptr += 4;
199  } else {
200  av_log(NULL, AV_LOG_ERROR, "Internal error, put_bits buffer too small\n");
201  av_assert2(0);
202  }
203  bit_left += 32 - n;
204  bit_buf = value;
205  }
206 #endif
207 
208  s->bit_buf = bit_buf;
209  s->bit_left = bit_left;
210 }
211 
212 static inline void put_bits_le(PutBitContext *s, int n, unsigned int value)
213 {
214  unsigned int bit_buf;
215  int bit_left;
216 
217  av_assert2(n <= 31 && value < (1U << n));
218 
219  bit_buf = s->bit_buf;
220  bit_left = s->bit_left;
221 
222  bit_buf |= value << (32 - bit_left);
223  if (n >= bit_left) {
224  if (3 < s->buf_end - s->buf_ptr) {
225  AV_WL32(s->buf_ptr, bit_buf);
226  s->buf_ptr += 4;
227  } else {
228  av_log(NULL, AV_LOG_ERROR, "Internal error, put_bits buffer too small\n");
229  av_assert2(0);
230  }
231  bit_buf = value >> bit_left;
232  bit_left += 32;
233  }
234  bit_left -= n;
235 
236  s->bit_buf = bit_buf;
237  s->bit_left = bit_left;
238 }
239 
240 static inline void put_sbits(PutBitContext *pb, int n, int32_t value)
241 {
242  av_assert2(n >= 0 && n <= 31);
243 
244  put_bits(pb, n, av_mod_uintp2(value, n));
245 }
246 
247 /**
248  * Write exactly 32 bits into a bitstream.
249  */
250 static void av_unused put_bits32(PutBitContext *s, uint32_t value)
251 {
252  unsigned int bit_buf;
253  int bit_left;
254 
255  bit_buf = s->bit_buf;
256  bit_left = s->bit_left;
257 
258 #ifdef BITSTREAM_WRITER_LE
259  bit_buf |= value << (32 - bit_left);
260  if (3 < s->buf_end - s->buf_ptr) {
261  AV_WL32(s->buf_ptr, bit_buf);
262  s->buf_ptr += 4;
263  } else {
264  av_log(NULL, AV_LOG_ERROR, "Internal error, put_bits buffer too small\n");
265  av_assert2(0);
266  }
267  bit_buf = (uint64_t)value >> bit_left;
268 #else
269  bit_buf = (uint64_t)bit_buf << bit_left;
270  bit_buf |= value >> (32 - bit_left);
271  if (3 < s->buf_end - s->buf_ptr) {
272  AV_WB32(s->buf_ptr, bit_buf);
273  s->buf_ptr += 4;
274  } else {
275  av_log(NULL, AV_LOG_ERROR, "Internal error, put_bits buffer too small\n");
276  av_assert2(0);
277  }
278  bit_buf = value;
279 #endif
280 
281  s->bit_buf = bit_buf;
282  s->bit_left = bit_left;
283 }
284 
285 /**
286  * Write up to 64 bits into a bitstream.
287  */
288 static inline void put_bits64(PutBitContext *s, int n, uint64_t value)
289 {
290  av_assert2((n == 64) || (n < 64 && value < (UINT64_C(1) << n)));
291 
292  if (n < 32)
293  put_bits(s, n, value);
294  else if (n == 32)
295  put_bits32(s, value);
296  else if (n < 64) {
297  uint32_t lo = value & 0xffffffff;
298  uint32_t hi = value >> 32;
299 #ifdef BITSTREAM_WRITER_LE
300  put_bits32(s, lo);
301  put_bits(s, n - 32, hi);
302 #else
303  put_bits(s, n - 32, hi);
304  put_bits32(s, lo);
305 #endif
306  } else {
307  uint32_t lo = value & 0xffffffff;
308  uint32_t hi = value >> 32;
309 #ifdef BITSTREAM_WRITER_LE
310  put_bits32(s, lo);
311  put_bits32(s, hi);
312 #else
313  put_bits32(s, hi);
314  put_bits32(s, lo);
315 #endif
316 
317  }
318 }
319 
320 /**
321  * Return the pointer to the byte where the bitstream writer will put
322  * the next bit.
323  */
325 {
326  return s->buf_ptr;
327 }
328 
329 /**
330  * Skip the given number of bytes.
331  * PutBitContext must be flushed & aligned to a byte boundary before calling this.
332  */
333 static inline void skip_put_bytes(PutBitContext *s, int n)
334 {
335  av_assert2((put_bits_count(s) & 7) == 0);
336  av_assert2(s->bit_left == 32);
337  av_assert0(n <= s->buf_end - s->buf_ptr);
338  s->buf_ptr += n;
339 }
340 
341 /**
342  * Skip the given number of bits.
343  * Must only be used if the actual values in the bitstream do not matter.
344  * If n is 0 the behavior is undefined.
345  */
346 static inline void skip_put_bits(PutBitContext *s, int n)
347 {
348  s->bit_left -= n;
349  s->buf_ptr -= 4 * (s->bit_left >> 5);
350  s->bit_left &= 31;
351 }
352 
353 /**
354  * Change the end of the buffer.
355  *
356  * @param size the new size in bytes of the buffer where to put bits
357  */
358 static inline void set_put_bits_buffer_size(PutBitContext *s, int size)
359 {
360  av_assert0(size <= INT_MAX/8 - 32);
361  s->buf_end = s->buf + size;
362  s->size_in_bits = 8*size;
363 }
364 
365 #endif /* AVCODEC_PUT_BITS_H */
put_bits_le
static void put_bits_le(PutBitContext *s, int n, unsigned int value)
Definition: put_bits.h:212
put_bits32
static void av_unused put_bits32(PutBitContext *s, uint32_t value)
Write exactly 32 bits into a bitstream.
Definition: put_bits.h:250
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:426
put_sbits
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:240
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
av_unused
#define av_unused
Definition: attributes.h:131
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
U
#define U(x)
Definition: vp56_arith.h:37
PutBitContext::size_in_bits
int size_in_bits
Definition: put_bits.h:39
put_bits_left
static int put_bits_left(PutBitContext *s)
Definition: put_bits.h:93
avpriv_align_put_bits
void avpriv_align_put_bits(PutBitContext *s)
Pad the bitstream with zeros up to the next byte boundary.
Definition: bitstream.c:48
avassert.h
put_bits
static void put_bits(PutBitContext *s, int n, unsigned int value)
Write up to 31 bits into a bitstream.
Definition: put_bits.h:164
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
rebase_put_bits
static void rebase_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Rebase the bit writer onto a reallocated buffer.
Definition: put_bits.h:79
skip_put_bits
static void skip_put_bits(PutBitContext *s, int n)
Skip the given number of bits.
Definition: put_bits.h:346
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
PutBitContext
Definition: put_bits.h:35
int32_t
int32_t
Definition: audio_convert.c:194
PutBitContext::buf
uint8_t * buf
Definition: put_bits.h:38
NULL
#define NULL
Definition: coverity.c:32
src
#define src
Definition: vp8dsp.c:254
flush_put_bits_le
static void flush_put_bits_le(PutBitContext *s)
Definition: put_bits.h:122
AV_WB32
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
set_put_bits_buffer_size
static void set_put_bits_buffer_size(PutBitContext *s, int size)
Change the end of the buffer.
Definition: put_bits.h:358
avpriv_copy_bits
void avpriv_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
Copy the content of src to the bitstream.
Definition: bitstream.c:64
size
int size
Definition: twinvq_data.h:11134
PutBitContext::bit_left
int bit_left
Definition: put_bits.h:37
avpriv_put_string
void avpriv_put_string(PutBitContext *pb, const char *string, int terminate_string)
Put the string string in the bitstream.
Definition: bitstream.c:53
PutBitContext::buf_end
uint8_t * buf_end
Definition: put_bits.h:38
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:67
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
uint8_t
uint8_t
Definition: audio_convert.c:194
put_bits_ptr
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
Definition: put_bits.h:324
PutBitContext::buf_ptr
uint8_t * buf_ptr
Definition: put_bits.h:38
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
skip_put_bytes
static void skip_put_bytes(PutBitContext *s, int n)
Skip the given number of bytes.
Definition: put_bits.h:333
PutBitContext::bit_buf
uint32_t bit_buf
Definition: put_bits.h:36
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28