Debian Codegraph @

libs/gst/base/gstbitwriter.h

raw
1 /*
2 * gstbitwriter.h - bitstream writer
3 *
4 * Copyright (C) 2013 Intel Corporation
5 * Copyright (C) 2018 Igalia, S. L.
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public License
9 * as published by the Free Software Foundation; either version 2.1
10 * of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free
19 * Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 * Boston, MA 02110-1301 USA
21 */
22
23 #ifndef GST_BIT_WRITER_H
24 #define GST_BIT_WRITER_H
25
26 #include <gst/gst.h>
27 #include <gst/base/base-prelude.h>
28
29 #include <string.h>
30
31 G_BEGIN_DECLS
32
33 #define GST_BIT_WRITER_DATA(writer) ((writer)->data)
34 #define GST_BIT_WRITER_BIT_SIZE(writer) ((writer)->bit_size)
35 #define GST_BIT_WRITER(writer) ((GstBitWriter *) (writer))
36
37 typedef struct _GstBitWriter GstBitWriter;
38
39 /**
40 * GstBitWriter:
41 * @data: Allocated @data for bit writer to write
42 * @bit_size: Size of written @data in bits
43 *
44 * A bit writer instance.
45 *
46 * Since: 1.16
47 */
48 struct _GstBitWriter
49 {
50 guint8 *data;
51 guint bit_size;
52
53 /*< private >*/
54 guint bit_capacity; /* Capacity of the allocated data */
55 gboolean auto_grow; /* Whether space can auto grow */
56 gboolean owned;
57 gpointer _gst_reserved[GST_PADDING];
58 };
59
60 GST_BASE_API
61 GstBitWriter * gst_bit_writer_new (void) G_GNUC_MALLOC;
62
63 GST_BASE_API
64 GstBitWriter * gst_bit_writer_new_with_size (guint32 size, gboolean fixed) G_GNUC_MALLOC;
65
66 GST_BASE_API
67 GstBitWriter * gst_bit_writer_new_with_data (guint8 *data, guint size,
68 gboolean initialized) G_GNUC_MALLOC;
69
70 GST_BASE_API
71 void gst_bit_writer_free (GstBitWriter *bitwriter);
72
73 GST_BASE_API
74 guint8 * gst_bit_writer_free_and_get_data (GstBitWriter *bitwriter) G_GNUC_WARN_UNUSED_RESULT;
75
76 GST_BASE_API
77 GstBuffer * gst_bit_writer_free_and_get_buffer (GstBitWriter *bitwriter) G_GNUC_WARN_UNUSED_RESULT;
78
79 GST_BASE_API
80 void gst_bit_writer_init (GstBitWriter *bitwriter);
81
82 GST_BASE_API
83 void gst_bit_writer_init_with_size (GstBitWriter *bitwriter,
84 guint32 size, gboolean fixed);
85
86 GST_BASE_API
87 void gst_bit_writer_init_with_data (GstBitWriter *bitwriter, guint8 *data,
88 guint size, gboolean initialized);
89
90 GST_BASE_API
91 void gst_bit_writer_reset (GstBitWriter *bitwriter);
92
93 GST_BASE_API
94 guint8 * gst_bit_writer_reset_and_get_data (GstBitWriter *bitwriter) G_GNUC_WARN_UNUSED_RESULT;
95
96 GST_BASE_API
97 GstBuffer * gst_bit_writer_reset_and_get_buffer (GstBitWriter *bitwriter) G_GNUC_WARN_UNUSED_RESULT;
98
99 GST_BASE_API
100 guint gst_bit_writer_get_size (const GstBitWriter *bitwriter);
101
102 GST_BASE_API
103 guint8 * gst_bit_writer_get_data (const GstBitWriter *bitwriter);
104
105 GST_BASE_API
106 gboolean gst_bit_writer_set_pos (GstBitWriter *bitwriter, guint pos);
107
108 GST_BASE_API
109 guint gst_bit_writer_get_remaining (const GstBitWriter *bitwriter);
110
111 GST_BASE_API
112 gboolean gst_bit_writer_put_bits_uint8 (GstBitWriter *bitwriter, guint8 value,
113 guint nbits);
114
115 GST_BASE_API
116 gboolean gst_bit_writer_put_bits_uint16 (GstBitWriter *bitwriter, guint16 value,
117 guint nbits);
118
119 GST_BASE_API
120 gboolean gst_bit_writer_put_bits_uint32 (GstBitWriter *bitwriter, guint32 value,
121 guint nbits);
122
123 GST_BASE_API
124 gboolean gst_bit_writer_put_bits_uint64 (GstBitWriter *bitwriter, guint64 value,
125 guint nbits);
126
127 GST_BASE_API
128 gboolean gst_bit_writer_put_bytes (GstBitWriter *bitwriter, const guint8 *data,
129 guint nbytes);
130
131 GST_BASE_API
132 gboolean gst_bit_writer_align_bytes (GstBitWriter *bitwriter, guint8 trailing_bit);
133
134 static const guint8 _gst_bit_writer_bit_filling_mask[9] = {
135 0x00, 0x01, 0x03, 0x07,
136 0x0F, 0x1F, 0x3F, 0x7F,
137 0xFF
138 };
139
140 /* Aligned to 256 bytes */
141 #define __GST_BITS_WRITER_ALIGNMENT_MASK 2047
142 #define __GST_BITS_WRITER_ALIGNED(bitsize) \
143 (((bitsize) + __GST_BITS_WRITER_ALIGNMENT_MASK)&(~__GST_BITS_WRITER_ALIGNMENT_MASK))
144
145 static inline gboolean
146 _gst_bit_writer_check_remaining (GstBitWriter * bitwriter, guint32 bits)
147 {
148 guint32 new_bit_size = bits + bitwriter->bit_size;
149 guint32 clear_pos;
150
151 g_assert (bitwriter->bit_size <= bitwriter->bit_capacity);
152 if (new_bit_size <= bitwriter->bit_capacity)
153 return TRUE;
154
155 if (!bitwriter->auto_grow)
156 return FALSE;
157
158 /* auto grow space */
159 new_bit_size = __GST_BITS_WRITER_ALIGNED (new_bit_size);
160 g_assert (new_bit_size
161 && ((new_bit_size & __GST_BITS_WRITER_ALIGNMENT_MASK) == 0));
162 clear_pos = ((bitwriter->bit_size + 7) >> 3);
163 bitwriter->data = (guint8 *) g_realloc (bitwriter->data, (new_bit_size >> 3));
164 memset (bitwriter->data + clear_pos, 0, (new_bit_size >> 3) - clear_pos);
165 bitwriter->bit_capacity = new_bit_size;
166 return TRUE;
167 }
168
169 #undef __GST_BITS_WRITER_ALIGNMENT_MASK
170 #undef __GST_BITS_WRITER_ALIGNED
171
172 #define __GST_BIT_WRITER_WRITE_BITS_UNCHECKED(bits) \
173 static inline void \
174 gst_bit_writer_put_bits_uint##bits##_unchecked( \
175 GstBitWriter *bitwriter, \
176 guint##bits value, \
177 guint nbits \
178 ) \
179 { \
180 guint byte_pos, bit_offset; \
181 guint8 *cur_byte, mask; \
182 guint fill_bits; \
183 \
184 byte_pos = (bitwriter->bit_size >> 3); \
185 bit_offset = (bitwriter->bit_size & 0x07); \
186 cur_byte = bitwriter->data + byte_pos; \
187 g_assert (nbits <= bits); \
188 g_assert (bit_offset < 8 && \
189 bitwriter->bit_size <= bitwriter->bit_capacity); \
190 \
191 while (nbits) { \
192 fill_bits = ((8 - bit_offset) < nbits ? (8 - bit_offset) : nbits); \
193 nbits -= fill_bits; \
194 bitwriter->bit_size += fill_bits; \
195 mask = _gst_bit_writer_bit_filling_mask[fill_bits] << (8 - bit_offset - fill_bits); \
196 \
197 *cur_byte = ((*cur_byte) & (~mask)) | \
198 (((value >> nbits) << (8 - bit_offset - fill_bits)) & mask); \
199 ++cur_byte; \
200 bit_offset = 0; \
201 } \
202 g_assert (cur_byte <= \
203 (bitwriter->data + (bitwriter->bit_capacity >> 3))); \
204 }
205
206 __GST_BIT_WRITER_WRITE_BITS_UNCHECKED (8)
207 __GST_BIT_WRITER_WRITE_BITS_UNCHECKED (16)
208 __GST_BIT_WRITER_WRITE_BITS_UNCHECKED (32)
209 __GST_BIT_WRITER_WRITE_BITS_UNCHECKED (64)
210 #undef __GST_BIT_WRITER_WRITE_BITS_UNCHECKED
211
212 static inline guint
213 gst_bit_writer_get_size_unchecked (const GstBitWriter * bitwriter)
214 {
215 return GST_BIT_WRITER_BIT_SIZE (bitwriter);
216 }
217
218 static inline guint8 *
219 gst_bit_writer_get_data_unchecked (const GstBitWriter * bitwriter)
220 {
221 return GST_BIT_WRITER_DATA (bitwriter);
222 }
223
224 static inline gboolean
225 gst_bit_writer_set_pos_unchecked (GstBitWriter * bitwriter, guint pos)
226 {
227 GST_BIT_WRITER_BIT_SIZE (bitwriter) = pos;
228 return TRUE;
229 }
230
231 static inline guint
232 gst_bit_writer_get_remaining_unchecked (const GstBitWriter * bitwriter)
233 {
234 return bitwriter->bit_capacity - bitwriter->bit_size;
235 }
236
237 static inline void
238 gst_bit_writer_put_bytes_unchecked (GstBitWriter * bitwriter,
239 const guint8 * data, guint nbytes)
240 {
241 if ((bitwriter->bit_size & 0x07) == 0) {
242 memcpy (&bitwriter->data[bitwriter->bit_size >> 3], data, nbytes);
243 bitwriter->bit_size += (nbytes << 3);
244 } else {
245 g_assert (0);
246 while (nbytes) {
247 gst_bit_writer_put_bits_uint8_unchecked (bitwriter, *data, 8);
248 --nbytes;
249 ++data;
250 }
251 }
252 }
253
254 static inline void
255 gst_bit_writer_align_bytes_unchecked (GstBitWriter * bitwriter,
256 guint8 trailing_bit)
257 {
258 guint32 bit_offset, bit_left;
259 guint8 value = 0;
260
261 bit_offset = (bitwriter->bit_size & 0x07);
262 if (!bit_offset)
263 return;
264
265 bit_left = 8 - bit_offset;
266 if (trailing_bit)
267 value = _gst_bit_writer_bit_filling_mask[bit_left];
268 gst_bit_writer_put_bits_uint8_unchecked (bitwriter, value, bit_left);
269 }
270
271 #define __GST_BIT_WRITER_WRITE_BITS_INLINE(bits) \
272 static inline gboolean \
273 _gst_bit_writer_put_bits_uint##bits##_inline( \
274 GstBitWriter *bitwriter, \
275 guint##bits value, \
276 guint nbits \
277 ) \
278 { \
279 g_return_val_if_fail(bitwriter != NULL, FALSE); \
280 g_return_val_if_fail(nbits != 0, FALSE); \
281 g_return_val_if_fail(nbits <= bits, FALSE); \
282 \
283 if (!_gst_bit_writer_check_remaining(bitwriter, nbits)) \
284 return FALSE; \
285 gst_bit_writer_put_bits_uint##bits##_unchecked(bitwriter, value, nbits); \
286 return TRUE; \
287 }
288
289 __GST_BIT_WRITER_WRITE_BITS_INLINE (8)
290 __GST_BIT_WRITER_WRITE_BITS_INLINE (16)
291 __GST_BIT_WRITER_WRITE_BITS_INLINE (32)
292 __GST_BIT_WRITER_WRITE_BITS_INLINE (64)
293 #undef __GST_BIT_WRITER_WRITE_BITS_INLINE
294
295 static inline guint
296 _gst_bit_writer_get_size_inline (const GstBitWriter * bitwriter)
297 {
298 g_return_val_if_fail (bitwriter != NULL, 0);
299
300 return gst_bit_writer_get_size_unchecked (bitwriter);
301 }
302
303 static inline guint8 *
304 _gst_bit_writer_get_data_inline (const GstBitWriter * bitwriter)
305 {
306 g_return_val_if_fail (bitwriter != NULL, NULL);
307
308 return gst_bit_writer_get_data_unchecked (bitwriter);
309 }
310
311 static inline gboolean
312 _gst_bit_writer_set_pos_inline (GstBitWriter * bitwriter, guint pos)
313 {
314 g_return_val_if_fail (bitwriter != NULL, FALSE);
315 g_return_val_if_fail (pos <= bitwriter->bit_capacity, FALSE);
316
317 return gst_bit_writer_set_pos_unchecked (bitwriter, pos);
318 }
319
320 static inline guint
321 _gst_bit_writer_get_remaining_inline (const GstBitWriter * bitwriter)
322 {
323 g_return_val_if_fail (bitwriter != NULL, 0);
324 g_return_val_if_fail (bitwriter->bit_size < bitwriter->bit_capacity, 0);
325
326 return gst_bit_writer_get_remaining_unchecked (bitwriter);
327 }
328
329 static inline gboolean
330 _gst_bit_writer_put_bytes_inline (GstBitWriter * bitwriter,
331 const guint8 * data, guint nbytes)
332 {
333 g_return_val_if_fail (bitwriter != NULL, FALSE);
334 g_return_val_if_fail (data != NULL, FALSE);
335 g_return_val_if_fail (nbytes, FALSE);
336
337 if (!_gst_bit_writer_check_remaining (bitwriter, nbytes * 8))
338 return FALSE;
339
340 gst_bit_writer_put_bytes_unchecked (bitwriter, data, nbytes);
341 return TRUE;
342 }
343
344 static inline gboolean
345 _gst_bit_writer_align_bytes_inline (GstBitWriter * bitwriter,
346 guint8 trailing_bit)
347 {
348 g_return_val_if_fail (bitwriter != NULL, FALSE);
349 g_return_val_if_fail ((trailing_bit == 0 || trailing_bit == 1), FALSE);
350 g_return_val_if_fail (((bitwriter->bit_size + 7) & (~7)) <=
351 bitwriter->bit_capacity, FALSE);
352
353 gst_bit_writer_align_bytes_unchecked (bitwriter, trailing_bit);
354 return TRUE;
355 }
356
357 #ifndef GST_BIT_WRITER_DISABLE_INLINES
358 #define gst_bit_writer_get_size(bitwriter) \
359 _gst_bit_writer_get_size_inline(bitwriter)
360 #define gst_bit_writer_get_data(bitwriter) \
361 _gst_bit_writer_get_data_inline(bitwriter)
362 #define gst_bit_writer_set_pos(bitwriter, pos) \
363 G_LIKELY (_gst_bit_writer_set_pos_inline (bitwriter, pos))
364 #define gst_bit_writer_get_remaining(bitwriter) \
365 _gst_bit_writer_get_remaining_inline(bitwriter)
366
367 #define gst_bit_writer_put_bits_uint8(bitwriter, value, nbits) \
368 G_LIKELY (_gst_bit_writer_put_bits_uint8_inline (bitwriter, value, nbits))
369 #define gst_bit_writer_put_bits_uint16(bitwriter, value, nbits) \
370 G_LIKELY (_gst_bit_writer_put_bits_uint16_inline (bitwriter, value, nbits))
371 #define gst_bit_writer_put_bits_uint32(bitwriter, value, nbits) \
372 G_LIKELY (_gst_bit_writer_put_bits_uint32_inline (bitwriter, value, nbits))
373 #define gst_bit_writer_put_bits_uint64(bitwriter, value, nbits) \
374 G_LIKELY (_gst_bit_writer_put_bits_uint64_inline (bitwriter, value, nbits))
375
376 #define gst_bit_writer_put_bytes(bitwriter, data, nbytes) \
377 G_LIKELY (_gst_bit_writer_put_bytes_inline (bitwriter, data, nbytes))
378
379 #define gst_bit_writer_align_bytes(bitwriter, trailing_bit) \
380 G_LIKELY (_gst_bit_writer_align_bytes_inline(bitwriter, trailing_bit))
381 #endif
382
383 G_END_DECLS
384
385 #endif /* GST_BIT_WRITER_H */