Branch data Line data Source code
1 : : /* GStreamer byte reader
2 : : *
3 : : * Copyright (C) 2008 Sebastian Dröge <sebastian.droege@collabora.co.uk>.
4 : : * Copyright (C) 2009 Tim-Philipp Müller <tim centricular net>
5 : : *
6 : : * This library is free software; you can redistribute it and/or
7 : : * modify it under the terms of the GNU Library General Public
8 : : * License as published by the Free Software Foundation; either
9 : : * version 2 of the License, or (at your option) any later version.
10 : : *
11 : : * This library 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 : : * Library General Public License for more details.
15 : : *
16 : : * You should have received a copy of the GNU Library General Public
17 : : * License along with this library; if not, write to the
18 : : * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 : : * Boston, MA 02111-1307, USA.
20 : : */
21 : :
22 : : #ifndef __GST_BYTE_READER_H__
23 : : #define __GST_BYTE_READER_H__
24 : :
25 : : #include <gst/gst.h>
26 : :
27 : : G_BEGIN_DECLS
28 : :
29 : : #define GST_BYTE_READER(reader) ((GstByteReader *) (reader))
30 : :
31 : : /**
32 : : * GstByteReader:
33 : : * @data: Data from which the bit reader will read
34 : : * @size: Size of @data in bytes
35 : : * @byte: Current byte position
36 : : *
37 : : * A byte reader instance.
38 : : */
39 : : typedef struct {
40 : : const guint8 *data;
41 : : guint size;
42 : :
43 : : guint byte; /* Byte position */
44 : : } GstByteReader;
45 : :
46 : : GstByteReader * gst_byte_reader_new (const guint8 *data, guint size);
47 : : GstByteReader * gst_byte_reader_new_from_buffer (const GstBuffer *buffer);
48 : : void gst_byte_reader_free (GstByteReader *reader);
49 : :
50 : : void gst_byte_reader_init (GstByteReader *reader, const guint8 *data, guint size);
51 : : void gst_byte_reader_init_from_buffer (GstByteReader *reader, const GstBuffer *buffer);
52 : :
53 : : gboolean gst_byte_reader_set_pos (GstByteReader *reader, guint pos);
54 : :
55 : : guint gst_byte_reader_get_pos (const GstByteReader *reader);
56 : : guint gst_byte_reader_get_remaining (const GstByteReader *reader);
57 : :
58 : : guint gst_byte_reader_get_size (const GstByteReader *reader);
59 : :
60 : : gboolean gst_byte_reader_skip (GstByteReader *reader, guint nbytes);
61 : :
62 : : gboolean gst_byte_reader_get_uint8 (GstByteReader *reader, guint8 *val);
63 : : gboolean gst_byte_reader_get_int8 (GstByteReader *reader, gint8 *val);
64 : : gboolean gst_byte_reader_get_uint16_le (GstByteReader *reader, guint16 *val);
65 : : gboolean gst_byte_reader_get_int16_le (GstByteReader *reader, gint16 *val);
66 : : gboolean gst_byte_reader_get_uint16_be (GstByteReader *reader, guint16 *val);
67 : : gboolean gst_byte_reader_get_int16_be (GstByteReader *reader, gint16 *val);
68 : : gboolean gst_byte_reader_get_uint24_le (GstByteReader *reader, guint32 *val);
69 : : gboolean gst_byte_reader_get_int24_le (GstByteReader *reader, gint32 *val);
70 : : gboolean gst_byte_reader_get_uint24_be (GstByteReader *reader, guint32 *val);
71 : : gboolean gst_byte_reader_get_int24_be (GstByteReader *reader, gint32 *val);
72 : : gboolean gst_byte_reader_get_uint32_le (GstByteReader *reader, guint32 *val);
73 : : gboolean gst_byte_reader_get_int32_le (GstByteReader *reader, gint32 *val);
74 : : gboolean gst_byte_reader_get_uint32_be (GstByteReader *reader, guint32 *val);
75 : : gboolean gst_byte_reader_get_int32_be (GstByteReader *reader, gint32 *val);
76 : : gboolean gst_byte_reader_get_uint64_le (GstByteReader *reader, guint64 *val);
77 : : gboolean gst_byte_reader_get_int64_le (GstByteReader *reader, gint64 *val);
78 : : gboolean gst_byte_reader_get_uint64_be (GstByteReader *reader, guint64 *val);
79 : : gboolean gst_byte_reader_get_int64_be (GstByteReader *reader, gint64 *val);
80 : :
81 : : gboolean gst_byte_reader_peek_uint8 (const GstByteReader *reader, guint8 *val);
82 : : gboolean gst_byte_reader_peek_int8 (const GstByteReader *reader, gint8 *val);
83 : : gboolean gst_byte_reader_peek_uint16_le (const GstByteReader *reader, guint16 *val);
84 : : gboolean gst_byte_reader_peek_int16_le (const GstByteReader *reader, gint16 *val);
85 : : gboolean gst_byte_reader_peek_uint16_be (const GstByteReader *reader, guint16 *val);
86 : : gboolean gst_byte_reader_peek_int16_be (const GstByteReader *reader, gint16 *val);
87 : : gboolean gst_byte_reader_peek_uint24_le (const GstByteReader *reader, guint32 *val);
88 : : gboolean gst_byte_reader_peek_int24_le (const GstByteReader *reader, gint32 *val);
89 : : gboolean gst_byte_reader_peek_uint24_be (const GstByteReader *reader, guint32 *val);
90 : : gboolean gst_byte_reader_peek_int24_be (const GstByteReader *reader, gint32 *val);
91 : : gboolean gst_byte_reader_peek_uint32_le (const GstByteReader *reader, guint32 *val);
92 : : gboolean gst_byte_reader_peek_int32_le (const GstByteReader *reader, gint32 *val);
93 : : gboolean gst_byte_reader_peek_uint32_be (const GstByteReader *reader, guint32 *val);
94 : : gboolean gst_byte_reader_peek_int32_be (const GstByteReader *reader, gint32 *val);
95 : : gboolean gst_byte_reader_peek_uint64_le (const GstByteReader *reader, guint64 *val);
96 : : gboolean gst_byte_reader_peek_int64_le (const GstByteReader *reader, gint64 *val);
97 : : gboolean gst_byte_reader_peek_uint64_be (const GstByteReader *reader, guint64 *val);
98 : : gboolean gst_byte_reader_peek_int64_be (const GstByteReader *reader, gint64 *val);
99 : :
100 : : gboolean gst_byte_reader_get_float32_le (GstByteReader *reader, gfloat *val);
101 : : gboolean gst_byte_reader_get_float32_be (GstByteReader *reader, gfloat *val);
102 : : gboolean gst_byte_reader_get_float64_le (GstByteReader *reader, gdouble *val);
103 : : gboolean gst_byte_reader_get_float64_be (GstByteReader *reader, gdouble *val);
104 : :
105 : : gboolean gst_byte_reader_peek_float32_le (const GstByteReader *reader, gfloat *val);
106 : : gboolean gst_byte_reader_peek_float32_be (const GstByteReader *reader, gfloat *val);
107 : : gboolean gst_byte_reader_peek_float64_le (const GstByteReader *reader, gdouble *val);
108 : : gboolean gst_byte_reader_peek_float64_be (const GstByteReader *reader, gdouble *val);
109 : :
110 : : gboolean gst_byte_reader_dup_data (GstByteReader * reader, guint size, guint8 ** val);
111 : : gboolean gst_byte_reader_get_data (GstByteReader * reader, guint size, const guint8 ** val);
112 : : gboolean gst_byte_reader_peek_data (const GstByteReader * reader, guint size, const guint8 ** val);
113 : :
114 : : #define gst_byte_reader_dup_string(reader,str) \
115 : : gst_byte_reader_dup_string_utf8(reader,str)
116 : :
117 : : gboolean gst_byte_reader_dup_string_utf8 (GstByteReader * reader, gchar ** str);
118 : : gboolean gst_byte_reader_dup_string_utf16 (GstByteReader * reader, guint16 ** str);
119 : : gboolean gst_byte_reader_dup_string_utf32 (GstByteReader * reader, guint32 ** str);
120 : :
121 : : #define gst_byte_reader_skip_string(reader) \
122 : : gst_byte_reader_skip_string_utf8(reader)
123 : :
124 : : gboolean gst_byte_reader_skip_string_utf8 (GstByteReader * reader);
125 : : gboolean gst_byte_reader_skip_string_utf16 (GstByteReader * reader);
126 : : gboolean gst_byte_reader_skip_string_utf32 (GstByteReader * reader);
127 : :
128 : : #define gst_byte_reader_get_string(reader,str) \
129 : : gst_byte_reader_get_string_utf8(reader,str)
130 : :
131 : : #define gst_byte_reader_peek_string(reader,str) \
132 : : gst_byte_reader_peek_string_utf8(reader,str)
133 : :
134 : : gboolean gst_byte_reader_get_string_utf8 (GstByteReader * reader, const gchar ** str);
135 : : gboolean gst_byte_reader_peek_string_utf8 (const GstByteReader * reader, const gchar ** str);
136 : :
137 : : guint gst_byte_reader_masked_scan_uint32 (const GstByteReader * reader,
138 : : guint32 mask,
139 : : guint32 pattern,
140 : : guint offset,
141 : : guint size);
142 : :
143 : : /**
144 : : * GST_BYTE_READER_INIT:
145 : : * @data: Data from which the #GstByteReader should read
146 : : * @size: Size of @data in bytes
147 : : *
148 : : * A #GstByteReader must be initialized with this macro, before it can be
149 : : * used. This macro can used be to initialize a variable, but it cannot
150 : : * be assigned to a variable. In that case you have to use
151 : : * gst_byte_reader_init().
152 : : *
153 : : * Since: 0.10.22
154 : : */
155 : : #define GST_BYTE_READER_INIT(data, size) {data, size, 0}
156 : :
157 : : /**
158 : : * GST_BYTE_READER_INIT_FROM_BUFFER:
159 : : * @buffer: Buffer from which the #GstByteReader should read
160 : : *
161 : : * A #GstByteReader must be initialized with this macro, before it can be
162 : : * used. This macro can used be to initialize a variable, but it cannot
163 : : * be assigned to a variable. In that case you have to use
164 : : * gst_byte_reader_init().
165 : : *
166 : : * Since: 0.10.22
167 : : */
168 : : #define GST_BYTE_READER_INIT_FROM_BUFFER(buffer) {GST_BUFFER_DATA (buffer), GST_BUFFER_SIZE (buffer), 0}
169 : :
170 : :
171 : : /* unchecked variants */
172 : : static inline void
173 : 1 : gst_byte_reader_skip_unchecked (GstByteReader * reader, guint nbytes)
174 : : {
175 : 1 : reader->byte += nbytes;
176 : 1 : }
177 : :
178 : : #define __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(bits,type,lower,upper,adj) \
179 : : \
180 : : static inline type \
181 : : gst_byte_reader_peek_##lower##_unchecked (const GstByteReader * reader) \
182 : : { \
183 : : type val = (type) GST_READ_##upper (reader->data + reader->byte); \
184 : : adj \
185 : : return val; \
186 : : } \
187 : : \
188 : : static inline type \
189 : : gst_byte_reader_get_##lower##_unchecked (GstByteReader * reader) \
190 : : { \
191 : : type val = gst_byte_reader_peek_##lower##_unchecked (reader); \
192 : : reader->byte += bits / 8; \
193 : : return val; \
194 : : }
195 : :
196 : 30 : __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(8,guint8,uint8,UINT8,/* */)
197 : 6 : __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(8,gint8,int8,UINT8,/* */)
198 : :
199 : 3 : __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(16,guint16,uint16_le,UINT16_LE,/* */)
200 : 5 : __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(16,guint16,uint16_be,UINT16_BE,/* */)
201 : 3 : __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(16,gint16,int16_le,UINT16_LE,/* */)
202 : 3 : __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(16,gint16,int16_be,UINT16_BE,/* */)
203 : :
204 : 3 : __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(32,guint32,uint32_le,UINT32_LE,/* */)
205 : 3 : __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(32,guint32,uint32_be,UINT32_BE,/* */)
206 : 3 : __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(32,gint32,int32_le,UINT32_LE,/* */)
207 : 3 : __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(32,gint32,int32_be,UINT32_BE,/* */)
208 : :
209 : 3 : __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(24,guint32,uint24_le,UINT24_LE,/* */)
210 : 3 : __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(24,guint32,uint24_be,UINT24_BE,/* */)
211 : :
212 : : /* fix up the sign for 24-bit signed ints stored in 32-bit signed ints */
213 : 2 : __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(24,gint32,int24_le,UINT24_LE,
214 [ + - ]: 3 : if (val & 0x00800000) val |= 0xff000000;)
215 : 2 : __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(24,gint32,int24_be,UINT24_BE,
216 [ + - ]: 3 : if (val & 0x00800000) val |= 0xff000000;)
217 : :
218 : 5 : __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(64,guint64,uint64_le,UINT64_LE,/* */)
219 : 11 : __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(64,guint64,uint64_be,UINT64_BE,/* */)
220 : 5 : __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(64,gint64,int64_le,UINT64_LE,/* */)
221 : 5 : __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(64,gint64,int64_be,UINT64_BE,/* */)
222 : :
223 : 5 : __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(32,gfloat,float32_le,FLOAT_LE,/* */)
224 : 5 : __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(32,gfloat,float32_be,FLOAT_BE,/* */)
225 : 5 : __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(64,gdouble,float64_le,DOUBLE_LE,/* */)
226 : 5 : __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(64,gdouble,float64_be,DOUBLE_BE,/* */)
227 : :
228 : : #undef __GET_PEEK_BITS_UNCHECKED
229 : :
230 : : static inline const guint8 *
231 : 1 : gst_byte_reader_peek_data_unchecked (const GstByteReader * reader)
232 : : {
233 : 1 : return (const guint8 *) (reader->data + reader->byte);
234 : : }
235 : :
236 : : static inline const guint8 *
237 : 1 : gst_byte_reader_get_data_unchecked (GstByteReader * reader, guint size)
238 : : {
239 : : const guint8 *data;
240 : :
241 : 1 : data = gst_byte_reader_peek_data_unchecked (reader);
242 : 1 : gst_byte_reader_skip_unchecked (reader, size);
243 : 1 : return data;
244 : : }
245 : :
246 : : static inline guint8 *
247 : 1 : gst_byte_reader_dup_data_unchecked (GstByteReader * reader, guint size)
248 : : {
249 : 1 : gconstpointer data = gst_byte_reader_get_data_unchecked (reader, size);
250 : 1 : return (guint8 *) g_memdup (data, size);
251 : : }
252 : :
253 : : /* Unchecked variants that should not be used */
254 : : static inline guint
255 : 14 : _gst_byte_reader_get_pos_unchecked (const GstByteReader * reader)
256 : : {
257 : 14 : return reader->byte;
258 : : }
259 : :
260 : : static inline guint
261 : 141 : _gst_byte_reader_get_remaining_unchecked (const GstByteReader * reader)
262 : : {
263 : 141 : return reader->size - reader->byte;
264 : : }
265 : :
266 : : static inline guint
267 : 7 : _gst_byte_reader_get_size_unchecked (const GstByteReader * reader)
268 : : {
269 : 7 : return reader->size;
270 : : }
271 : :
272 : : /* inlined variants (do not use directly) */
273 : :
274 : : static inline guint
275 : 15 : _gst_byte_reader_get_remaining_inline (const GstByteReader * reader)
276 : : {
277 [ - + ]: 15 : g_return_val_if_fail (reader != NULL, 0);
278 : :
279 : 15 : return _gst_byte_reader_get_remaining_unchecked (reader);
280 : : }
281 : :
282 : : static inline guint
283 : 7 : _gst_byte_reader_get_size_inline (const GstByteReader * reader)
284 : : {
285 [ - + ]: 7 : g_return_val_if_fail (reader != NULL, 0);
286 : :
287 : 7 : return _gst_byte_reader_get_size_unchecked (reader);
288 : : }
289 : :
290 : : #define __GST_BYTE_READER_GET_PEEK_BITS_INLINE(bits,type,name) \
291 : : \
292 : : static inline gboolean \
293 : : _gst_byte_reader_peek_##name##_inline (const GstByteReader * reader, type * val) \
294 : : { \
295 : : g_return_val_if_fail (reader != NULL, FALSE); \
296 : : g_return_val_if_fail (val != NULL, FALSE); \
297 : : \
298 : : if (_gst_byte_reader_get_remaining_unchecked (reader) < (bits / 8)) \
299 : : return FALSE; \
300 : : \
301 : : *val = gst_byte_reader_peek_##name##_unchecked (reader); \
302 : : return TRUE; \
303 : : } \
304 : : \
305 : : static inline gboolean \
306 : : _gst_byte_reader_get_##name##_inline (GstByteReader * reader, type * val) \
307 : : { \
308 : : g_return_val_if_fail (reader != NULL, FALSE); \
309 : : g_return_val_if_fail (val != NULL, FALSE); \
310 : : \
311 : : if (_gst_byte_reader_get_remaining_unchecked (reader) < (bits / 8)) \
312 : : return FALSE; \
313 : : \
314 : : *val = gst_byte_reader_get_##name##_unchecked (reader); \
315 : : return TRUE; \
316 : : }
317 : :
318 [ - + ][ - + ]: 21 : __GST_BYTE_READER_GET_PEEK_BITS_INLINE(8,guint8,uint8)
[ + + ][ - + ]
[ - + ][ + + ]
319 [ - + ][ - + ]: 8 : __GST_BYTE_READER_GET_PEEK_BITS_INLINE(8,gint8,int8)
[ + + ][ - + ]
[ - + ][ + + ]
320 : :
321 [ - + ][ - + ]: 4 : __GST_BYTE_READER_GET_PEEK_BITS_INLINE(16,guint16,uint16_le)
[ + + ][ - + ]
[ - + ][ + + ]
322 [ - + ][ - + ]: 5 : __GST_BYTE_READER_GET_PEEK_BITS_INLINE(16,guint16,uint16_be)
[ + + ][ - + ]
[ - + ][ + + ]
323 [ - + ][ - + ]: 4 : __GST_BYTE_READER_GET_PEEK_BITS_INLINE(16,gint16,int16_le)
[ + + ][ - + ]
[ - + ][ + + ]
324 [ - + ][ - + ]: 4 : __GST_BYTE_READER_GET_PEEK_BITS_INLINE(16,gint16,int16_be)
[ + + ][ - + ]
[ - + ][ + + ]
325 : :
326 [ - + ][ - + ]: 4 : __GST_BYTE_READER_GET_PEEK_BITS_INLINE(32,guint32,uint32_le)
[ + + ][ - + ]
[ - + ][ + + ]
327 [ - + ][ - + ]: 4 : __GST_BYTE_READER_GET_PEEK_BITS_INLINE(32,guint32,uint32_be)
[ + + ][ - + ]
[ - + ][ + + ]
328 [ - + ][ - + ]: 4 : __GST_BYTE_READER_GET_PEEK_BITS_INLINE(32,gint32,int32_le)
[ + + ][ - + ]
[ - + ][ + + ]
329 [ - + ][ - + ]: 4 : __GST_BYTE_READER_GET_PEEK_BITS_INLINE(32,gint32,int32_be)
[ + + ][ - + ]
[ - + ][ + + ]
330 : :
331 [ - + ][ - + ]: 4 : __GST_BYTE_READER_GET_PEEK_BITS_INLINE(24,guint32,uint24_le)
[ + + ][ - + ]
[ - + ][ + + ]
332 [ - + ][ - + ]: 4 : __GST_BYTE_READER_GET_PEEK_BITS_INLINE(24,guint32,uint24_be)
[ + + ][ - + ]
[ - + ][ + + ]
333 [ - + ][ - + ]: 4 : __GST_BYTE_READER_GET_PEEK_BITS_INLINE(24,gint32,int24_le)
[ + + ][ - + ]
[ - + ][ + + ]
334 [ - + ][ - + ]: 4 : __GST_BYTE_READER_GET_PEEK_BITS_INLINE(24,gint32,int24_be)
[ + + ][ - + ]
[ - + ][ + + ]
335 : :
336 [ - + ][ - + ]: 5 : __GST_BYTE_READER_GET_PEEK_BITS_INLINE(64,guint64,uint64_le)
[ + + ][ - + ]
[ - + ][ + + ]
337 [ - + ][ - + ]: 9 : __GST_BYTE_READER_GET_PEEK_BITS_INLINE(64,guint64,uint64_be)
[ + + ][ - + ]
[ - + ][ + + ]
338 [ - + ][ - + ]: 5 : __GST_BYTE_READER_GET_PEEK_BITS_INLINE(64,gint64,int64_le)
[ + + ][ - + ]
[ - + ][ + + ]
339 [ - + ][ - + ]: 5 : __GST_BYTE_READER_GET_PEEK_BITS_INLINE(64,gint64,int64_be)
[ + + ][ - + ]
[ - + ][ + + ]
340 : :
341 [ - + ][ - + ]: 5 : __GST_BYTE_READER_GET_PEEK_BITS_INLINE(32,gfloat,float32_le)
[ + + ][ - + ]
[ - + ][ + + ]
342 [ - + ][ - + ]: 5 : __GST_BYTE_READER_GET_PEEK_BITS_INLINE(32,gfloat,float32_be)
[ + + ][ - + ]
[ - + ][ + + ]
343 [ - + ][ - + ]: 5 : __GST_BYTE_READER_GET_PEEK_BITS_INLINE(64,gdouble,float64_le)
[ + + ][ - + ]
[ - + ][ + + ]
344 [ - + ][ - + ]: 5 : __GST_BYTE_READER_GET_PEEK_BITS_INLINE(64,gdouble,float64_be)
[ + + ][ - + ]
[ - + ][ + + ]
345 : :
346 : : #undef __GST_BYTE_READER_GET_PEEK_BITS_INLINE
347 : :
348 : : #ifndef GST_BYTE_READER_DISABLE_INLINES
349 : :
350 : : #define gst_byte_reader_get_remaining(reader) \
351 : : _gst_byte_reader_get_remaining_inline(reader)
352 : :
353 : : #define gst_byte_reader_get_size(reader) \
354 : : _gst_byte_reader_get_size_inline(reader)
355 : :
356 : : #define gst_byte_reader_get_pos(reader) \
357 : : _gst_byte_reader_get_pos_inline(reader)
358 : :
359 : : /* we use defines here so we can add the G_LIKELY() */
360 : : #define gst_byte_reader_get_uint8(reader,val) \
361 : : G_LIKELY(_gst_byte_reader_get_uint8_inline(reader,val))
362 : : #define gst_byte_reader_get_int8(reader,val) \
363 : : G_LIKELY(_gst_byte_reader_get_int8_inline(reader,val))
364 : : #define gst_byte_reader_get_uint16_le(reader,val) \
365 : : G_LIKELY(_gst_byte_reader_get_uint16_le_inline(reader,val))
366 : : #define gst_byte_reader_get_int16_le(reader,val) \
367 : : G_LIKELY(_gst_byte_reader_get_int16_le_inline(reader,val))
368 : : #define gst_byte_reader_get_uint16_be(reader,val) \
369 : : G_LIKELY(_gst_byte_reader_get_uint16_be_inline(reader,val))
370 : : #define gst_byte_reader_get_int16_be(reader,val) \
371 : : G_LIKELY(_gst_byte_reader_get_int16_be_inline(reader,val))
372 : : #define gst_byte_reader_get_uint24_le(reader,val) \
373 : : G_LIKELY(_gst_byte_reader_get_uint24_le_inline(reader,val))
374 : : #define gst_byte_reader_get_int24_le(reader,val) \
375 : : G_LIKELY(_gst_byte_reader_get_int24_le_inline(reader,val))
376 : : #define gst_byte_reader_get_uint24_be(reader,val) \
377 : : G_LIKELY(_gst_byte_reader_get_uint24_be_inline(reader,val))
378 : : #define gst_byte_reader_get_int24_be(reader,val) \
379 : : G_LIKELY(_gst_byte_reader_get_int24_be_inline(reader,val))
380 : : #define gst_byte_reader_get_uint32_le(reader,val) \
381 : : G_LIKELY(_gst_byte_reader_get_uint32_le_inline(reader,val))
382 : : #define gst_byte_reader_get_int32_le(reader,val) \
383 : : G_LIKELY(_gst_byte_reader_get_int32_le_inline(reader,val))
384 : : #define gst_byte_reader_get_uint32_be(reader,val) \
385 : : G_LIKELY(_gst_byte_reader_get_uint32_be_inline(reader,val))
386 : : #define gst_byte_reader_get_int32_be(reader,val) \
387 : : G_LIKELY(_gst_byte_reader_get_int32_be_inline(reader,val))
388 : : #define gst_byte_reader_get_uint64_le(reader,val) \
389 : : G_LIKELY(_gst_byte_reader_get_uint64_le_inline(reader,val))
390 : : #define gst_byte_reader_get_int64_le(reader,val) \
391 : : G_LIKELY(_gst_byte_reader_get_int64_le_inline(reader,val))
392 : : #define gst_byte_reader_get_uint64_be(reader,val) \
393 : : G_LIKELY(_gst_byte_reader_get_uint64_be_inline(reader,val))
394 : : #define gst_byte_reader_get_int64_be(reader,val) \
395 : : G_LIKELY(_gst_byte_reader_get_int64_be_inline(reader,val))
396 : :
397 : : #define gst_byte_reader_peek_uint8(reader,val) \
398 : : G_LIKELY(_gst_byte_reader_peek_uint8_inline(reader,val))
399 : : #define gst_byte_reader_peek_int8(reader,val) \
400 : : G_LIKELY(_gst_byte_reader_peek_int8_inline(reader,val))
401 : : #define gst_byte_reader_peek_uint16_le(reader,val) \
402 : : G_LIKELY(_gst_byte_reader_peek_uint16_le_inline(reader,val))
403 : : #define gst_byte_reader_peek_int16_le(reader,val) \
404 : : G_LIKELY(_gst_byte_reader_peek_int16_le_inline(reader,val))
405 : : #define gst_byte_reader_peek_uint16_be(reader,val) \
406 : : G_LIKELY(_gst_byte_reader_peek_uint16_be_inline(reader,val))
407 : : #define gst_byte_reader_peek_int16_be(reader,val) \
408 : : G_LIKELY(_gst_byte_reader_peek_int16_be_inline(reader,val))
409 : : #define gst_byte_reader_peek_uint24_le(reader,val) \
410 : : G_LIKELY(_gst_byte_reader_peek_uint24_le_inline(reader,val))
411 : : #define gst_byte_reader_peek_int24_le(reader,val) \
412 : : G_LIKELY(_gst_byte_reader_peek_int24_le_inline(reader,val))
413 : : #define gst_byte_reader_peek_uint24_be(reader,val) \
414 : : G_LIKELY(_gst_byte_reader_peek_uint24_be_inline(reader,val))
415 : : #define gst_byte_reader_peek_int24_be(reader,val) \
416 : : G_LIKELY(_gst_byte_reader_peek_int24_be_inline(reader,val))
417 : : #define gst_byte_reader_peek_uint32_le(reader,val) \
418 : : G_LIKELY(_gst_byte_reader_peek_uint32_le_inline(reader,val))
419 : : #define gst_byte_reader_peek_int32_le(reader,val) \
420 : : G_LIKELY(_gst_byte_reader_peek_int32_le_inline(reader,val))
421 : : #define gst_byte_reader_peek_uint32_be(reader,val) \
422 : : G_LIKELY(_gst_byte_reader_peek_uint32_be_inline(reader,val))
423 : : #define gst_byte_reader_peek_int32_be(reader,val) \
424 : : G_LIKELY(_gst_byte_reader_peek_int32_be_inline(reader,val))
425 : : #define gst_byte_reader_peek_uint64_le(reader,val) \
426 : : G_LIKELY(_gst_byte_reader_peek_uint64_le_inline(reader,val))
427 : : #define gst_byte_reader_peek_int64_le(reader,val) \
428 : : G_LIKELY(_gst_byte_reader_peek_int64_le_inline(reader,val))
429 : : #define gst_byte_reader_peek_uint64_be(reader,val) \
430 : : G_LIKELY(_gst_byte_reader_peek_uint64_be_inline(reader,val))
431 : : #define gst_byte_reader_peek_int64_be(reader,val) \
432 : : G_LIKELY(_gst_byte_reader_peek_int64_be_inline(reader,val))
433 : :
434 : : #define gst_byte_reader_get_float32_le(reader,val) \
435 : : G_LIKELY(_gst_byte_reader_get_float32_le_inline(reader,val))
436 : : #define gst_byte_reader_get_float32_be(reader,val) \
437 : : G_LIKELY(_gst_byte_reader_get_float32_be_inline(reader,val))
438 : : #define gst_byte_reader_get_float64_le(reader,val) \
439 : : G_LIKELY(_gst_byte_reader_get_float64_le_inline(reader,val))
440 : : #define gst_byte_reader_get_float64_be(reader,val) \
441 : : G_LIKELY(_gst_byte_reader_get_float64_be_inline(reader,val))
442 : : #define gst_byte_reader_peek_float32_le(reader,val) \
443 : : G_LIKELY(_gst_byte_reader_peek_float32_le_inline(reader,val))
444 : : #define gst_byte_reader_peek_float32_be(reader,val) \
445 : : G_LIKELY(_gst_byte_reader_peek_float32_be_inline(reader,val))
446 : : #define gst_byte_reader_peek_float64_le(reader,val) \
447 : : G_LIKELY(_gst_byte_reader_peek_float64_le_inline(reader,val))
448 : : #define gst_byte_reader_peek_float64_be(reader,val) \
449 : : G_LIKELY(_gst_byte_reader_peek_float64_be_inline(reader,val))
450 : :
451 : : #endif /* GST_BYTE_READER_DISABLE_INLINES */
452 : :
453 : : static inline gboolean
454 : 4 : _gst_byte_reader_dup_data_inline (GstByteReader * reader, guint size, guint8 ** val)
455 : : {
456 [ - + ]: 4 : g_return_val_if_fail (reader != NULL, FALSE);
457 [ - + ]: 4 : g_return_val_if_fail (val != NULL, FALSE);
458 : :
459 [ + + ][ + + ]: 4 : if (G_UNLIKELY (size > reader->size || _gst_byte_reader_get_remaining_inline (reader) < size))
460 : 3 : return FALSE;
461 : :
462 : 1 : *val = gst_byte_reader_dup_data_unchecked (reader, size);
463 : 4 : return TRUE;
464 : : }
465 : :
466 : : static inline gboolean
467 : 0 : _gst_byte_reader_get_data_inline (GstByteReader * reader, guint size, const guint8 ** val)
468 : : {
469 [ # # ]: 0 : g_return_val_if_fail (reader != NULL, FALSE);
470 [ # # ]: 0 : g_return_val_if_fail (val != NULL, FALSE);
471 : :
472 [ # # ][ # # ]: 0 : if (G_UNLIKELY (size > reader->size || _gst_byte_reader_get_remaining_inline (reader) < size))
473 : 0 : return FALSE;
474 : :
475 : 0 : *val = gst_byte_reader_get_data_unchecked (reader, size);
476 : 0 : return TRUE;
477 : : }
478 : :
479 : : static inline gboolean
480 : 0 : _gst_byte_reader_peek_data_inline (const GstByteReader * reader, guint size, const guint8 ** val)
481 : : {
482 [ # # ]: 0 : g_return_val_if_fail (reader != NULL, FALSE);
483 [ # # ]: 0 : g_return_val_if_fail (val != NULL, FALSE);
484 : :
485 [ # # ][ # # ]: 0 : if (G_UNLIKELY (size > reader->size || _gst_byte_reader_get_remaining_inline (reader) < size))
486 : 0 : return FALSE;
487 : :
488 : 0 : *val = gst_byte_reader_peek_data_unchecked (reader);
489 : 0 : return TRUE;
490 : : }
491 : :
492 : : static inline guint
493 : 14 : _gst_byte_reader_get_pos_inline (const GstByteReader * reader)
494 : : {
495 [ - + ]: 14 : g_return_val_if_fail (reader != NULL, 0);
496 : :
497 : 14 : return _gst_byte_reader_get_pos_unchecked (reader);
498 : : }
499 : :
500 : : static inline gboolean
501 : 4 : _gst_byte_reader_skip_inline (GstByteReader * reader, guint nbytes)
502 : : {
503 [ - + ]: 4 : g_return_val_if_fail (reader != NULL, FALSE);
504 : :
505 [ + + ]: 4 : if (G_UNLIKELY (_gst_byte_reader_get_remaining_unchecked (reader) < nbytes))
506 : 1 : return FALSE;
507 : :
508 : 3 : reader->byte += nbytes;
509 : 4 : return TRUE;
510 : : }
511 : :
512 : : #ifndef GST_BYTE_READER_DISABLE_INLINES
513 : :
514 : : #define gst_byte_reader_dup_data(reader,size,val) \
515 : : G_LIKELY(_gst_byte_reader_dup_data_inline(reader,size,val))
516 : : #define gst_byte_reader_get_data(reader,size,val) \
517 : : G_LIKELY(_gst_byte_reader_get_data_inline(reader,size,val))
518 : : #define gst_byte_reader_peek_data(reader,size,val) \
519 : : G_LIKELY(_gst_byte_reader_peek_data_inline(reader,size,val))
520 : : #define gst_byte_reader_skip(reader,nbytes) \
521 : : G_LIKELY(_gst_byte_reader_skip_inline(reader,nbytes))
522 : :
523 : : #endif /* GST_BYTE_READER_DISABLE_INLINES */
524 : :
525 : : G_END_DECLS
526 : :
527 : : #endif /* __GST_BYTE_READER_H__ */
|
