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., 51 Franklin St, Fifth Floor,
19 * Boston, MA 02110-1301, USA.
20 */
21
22#ifndef __GST_BYTE_READER_H__
23#define __GST_BYTE_READER_H__
24
25#include <gst/gst.h>
26#include <gst/base/base-prelude.h>
27
28G_BEGIN_DECLS
29
30#define GST_BYTE_READER(reader) ((GstByteReader *) (reader))
31
32/**
33 * GstByteReader:
34 * @data: (array length=size): Data from which the bit reader will
35 * read
36 * @size: Size of @data in bytes
37 * @byte: Current byte position
38 *
39 * A byte reader instance.
40 */
41typedef struct {
42 const guint8 *data;
43 guint size;
44
45 guint byte; /* Byte position */
46
47 /* < private > */
48 gpointer _gst_reserved[GST_PADDING];
49} GstByteReader;
50
51GST_BASE_API
52GstByteReader * gst_byte_reader_new (const guint8 *data, guint size) G_GNUC_MALLOC;
53
54GST_BASE_API
55void gst_byte_reader_free (GstByteReader *reader);
56
57GST_BASE_API
58void gst_byte_reader_init (GstByteReader *reader, const guint8 *data, guint size);
59
60GST_BASE_API
61gboolean gst_byte_reader_peek_sub_reader (GstByteReader * reader,
62 GstByteReader * sub_reader,
63 guint size);
64GST_BASE_API
65gboolean gst_byte_reader_get_sub_reader (GstByteReader * reader,
66 GstByteReader * sub_reader,
67 guint size);
68GST_BASE_API
69gboolean gst_byte_reader_set_pos (GstByteReader *reader, guint pos);
70
71GST_BASE_API
72guint gst_byte_reader_get_pos (const GstByteReader *reader);
73
74GST_BASE_API
75guint gst_byte_reader_get_remaining (const GstByteReader *reader);
76
77GST_BASE_API
78guint gst_byte_reader_get_size (const GstByteReader *reader);
79
80GST_BASE_API
81gboolean gst_byte_reader_skip (GstByteReader *reader, guint nbytes);
82
83GST_BASE_API
84gboolean gst_byte_reader_get_uint8 (GstByteReader *reader, guint8 *val);
85
86GST_BASE_API
87gboolean gst_byte_reader_get_int8 (GstByteReader *reader, gint8 *val);
88
89GST_BASE_API
90gboolean gst_byte_reader_get_uint16_le (GstByteReader *reader, guint16 *val);
91
92GST_BASE_API
93gboolean gst_byte_reader_get_int16_le (GstByteReader *reader, gint16 *val);
94
95GST_BASE_API
96gboolean gst_byte_reader_get_uint16_be (GstByteReader *reader, guint16 *val);
97
98GST_BASE_API
99gboolean gst_byte_reader_get_int16_be (GstByteReader *reader, gint16 *val);
100
101GST_BASE_API
102gboolean gst_byte_reader_get_uint24_le (GstByteReader *reader, guint32 *val);
103
104GST_BASE_API
105gboolean gst_byte_reader_get_int24_le (GstByteReader *reader, gint32 *val);
106
107GST_BASE_API
108gboolean gst_byte_reader_get_uint24_be (GstByteReader *reader, guint32 *val);
109
110GST_BASE_API
111gboolean gst_byte_reader_get_int24_be (GstByteReader *reader, gint32 *val);
112
113GST_BASE_API
114gboolean gst_byte_reader_get_uint32_le (GstByteReader *reader, guint32 *val);
115
116GST_BASE_API
117gboolean gst_byte_reader_get_int32_le (GstByteReader *reader, gint32 *val);
118
119GST_BASE_API
120gboolean gst_byte_reader_get_uint32_be (GstByteReader *reader, guint32 *val);
121
122GST_BASE_API
123gboolean gst_byte_reader_get_int32_be (GstByteReader *reader, gint32 *val);
124
125GST_BASE_API
126gboolean gst_byte_reader_get_uint64_le (GstByteReader *reader, guint64 *val);
127
128GST_BASE_API
129gboolean gst_byte_reader_get_int64_le (GstByteReader *reader, gint64 *val);
130
131GST_BASE_API
132gboolean gst_byte_reader_get_uint64_be (GstByteReader *reader, guint64 *val);
133
134GST_BASE_API
135gboolean gst_byte_reader_get_int64_be (GstByteReader *reader, gint64 *val);
136
137GST_BASE_API
138gboolean gst_byte_reader_peek_uint8 (const GstByteReader *reader, guint8 *val);
139
140GST_BASE_API
141gboolean gst_byte_reader_peek_int8 (const GstByteReader *reader, gint8 *val);
142
143GST_BASE_API
144gboolean gst_byte_reader_peek_uint16_le (const GstByteReader *reader, guint16 *val);
145
146GST_BASE_API
147gboolean gst_byte_reader_peek_int16_le (const GstByteReader *reader, gint16 *val);
148
149GST_BASE_API
150gboolean gst_byte_reader_peek_uint16_be (const GstByteReader *reader, guint16 *val);
151
152GST_BASE_API
153gboolean gst_byte_reader_peek_int16_be (const GstByteReader *reader, gint16 *val);
154
155GST_BASE_API
156gboolean gst_byte_reader_peek_uint24_le (const GstByteReader *reader, guint32 *val);
157
158GST_BASE_API
159gboolean gst_byte_reader_peek_int24_le (const GstByteReader *reader, gint32 *val);
160
161GST_BASE_API
162gboolean gst_byte_reader_peek_uint24_be (const GstByteReader *reader, guint32 *val);
163
164GST_BASE_API
165gboolean gst_byte_reader_peek_int24_be (const GstByteReader *reader, gint32 *val);
166
167GST_BASE_API
168gboolean gst_byte_reader_peek_uint32_le (const GstByteReader *reader, guint32 *val);
169
170GST_BASE_API
171gboolean gst_byte_reader_peek_int32_le (const GstByteReader *reader, gint32 *val);
172
173GST_BASE_API
174gboolean gst_byte_reader_peek_uint32_be (const GstByteReader *reader, guint32 *val);
175
176GST_BASE_API
177gboolean gst_byte_reader_peek_int32_be (const GstByteReader *reader, gint32 *val);
178
179GST_BASE_API
180gboolean gst_byte_reader_peek_uint64_le (const GstByteReader *reader, guint64 *val);
181
182GST_BASE_API
183gboolean gst_byte_reader_peek_int64_le (const GstByteReader *reader, gint64 *val);
184
185GST_BASE_API
186gboolean gst_byte_reader_peek_uint64_be (const GstByteReader *reader, guint64 *val);
187
188GST_BASE_API
189gboolean gst_byte_reader_peek_int64_be (const GstByteReader *reader, gint64 *val);
190
191GST_BASE_API
192gboolean gst_byte_reader_get_float32_le (GstByteReader *reader, gfloat *val);
193
194GST_BASE_API
195gboolean gst_byte_reader_get_float32_be (GstByteReader *reader, gfloat *val);
196
197GST_BASE_API
198gboolean gst_byte_reader_get_float64_le (GstByteReader *reader, gdouble *val);
199
200GST_BASE_API
201gboolean gst_byte_reader_get_float64_be (GstByteReader *reader, gdouble *val);
202
203GST_BASE_API
204gboolean gst_byte_reader_peek_float32_le (const GstByteReader *reader, gfloat *val);
205
206GST_BASE_API
207gboolean gst_byte_reader_peek_float32_be (const GstByteReader *reader, gfloat *val);
208
209GST_BASE_API
210gboolean gst_byte_reader_peek_float64_le (const GstByteReader *reader, gdouble *val);
211
212GST_BASE_API
213gboolean gst_byte_reader_peek_float64_be (const GstByteReader *reader, gdouble *val);
214
215GST_BASE_API
216gboolean gst_byte_reader_dup_data (GstByteReader * reader, guint size, guint8 ** val);
217
218GST_BASE_API
219gboolean gst_byte_reader_get_data (GstByteReader * reader, guint size, const guint8 ** val);
220
221GST_BASE_API
222gboolean gst_byte_reader_peek_data (const GstByteReader * reader, guint size, const guint8 ** val);
223
224#define gst_byte_reader_dup_string(reader,str) \
225 gst_byte_reader_dup_string_utf8(reader,str)
226
227GST_BASE_API
228gboolean gst_byte_reader_dup_string_utf8 (GstByteReader * reader, gchar ** str);
229
230GST_BASE_API
231gboolean gst_byte_reader_dup_string_utf16 (GstByteReader * reader, guint16 ** str);
232
233GST_BASE_API
234gboolean gst_byte_reader_dup_string_utf32 (GstByteReader * reader, guint32 ** str);
235
236#define gst_byte_reader_skip_string(reader) \
237 gst_byte_reader_skip_string_utf8(reader)
238
239GST_BASE_API
240gboolean gst_byte_reader_skip_string_utf8 (GstByteReader * reader);
241
242GST_BASE_API
243gboolean gst_byte_reader_skip_string_utf16 (GstByteReader * reader);
244
245GST_BASE_API
246gboolean gst_byte_reader_skip_string_utf32 (GstByteReader * reader);
247
248#define gst_byte_reader_get_string(reader,str) \
249 gst_byte_reader_get_string_utf8(reader,str)
250
251#define gst_byte_reader_peek_string(reader,str) \
252 gst_byte_reader_peek_string_utf8(reader,str)
253
254GST_BASE_API
255gboolean gst_byte_reader_get_string_utf8 (GstByteReader * reader, const gchar ** str);
256
257GST_BASE_API
258gboolean gst_byte_reader_peek_string_utf8 (const GstByteReader * reader, const gchar ** str);
259
260GST_BASE_API
261guint gst_byte_reader_masked_scan_uint32 (const GstByteReader * reader,
262 guint32 mask,
263 guint32 pattern,
264 guint offset,
265 guint size);
266GST_BASE_API
267guint gst_byte_reader_masked_scan_uint32_peek (const GstByteReader * reader,
268 guint32 mask,
269 guint32 pattern,
270 guint offset,
271 guint size,
272 guint32 * value);
273
274/**
275 * GST_BYTE_READER_INIT:
276 * @data: Data from which the #GstByteReader should read
277 * @size: Size of @data in bytes
278 *
279 * A #GstByteReader must be initialized with this macro, before it can be
280 * used. This macro can used be to initialize a variable, but it cannot
281 * be assigned to a variable. In that case you have to use
282 * gst_byte_reader_init().
283 */
284#define GST_BYTE_READER_INIT(data, size) {data, size, 0}
285
286/* unchecked variants */
287static inline void
288gst_byte_reader_skip_unchecked (GstByteReader * reader, guint nbytes)
289{
290 reader->byte += nbytes;
291}
292
293#define __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(bits,type,lower,upper,adj) \
294\
295static inline type \
296gst_byte_reader_peek_##lower##_unchecked (const GstByteReader * reader) \
297{ \
298 type val = (type) GST_READ_##upper (reader->data + reader->byte); \
299 adj \
300 return val; \
301} \
302\
303static inline type \
304gst_byte_reader_get_##lower##_unchecked (GstByteReader * reader) \
305{ \
306 type val = gst_byte_reader_peek_##lower##_unchecked (reader); \
307 reader->byte += bits / 8; \
308 return val; \
309}
310
311__GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(8,guint8,uint8,UINT8,/* */)
312__GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(8,gint8,int8,UINT8,/* */)
313
314__GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(16,guint16,uint16_le,UINT16_LE,/* */)
315__GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(16,guint16,uint16_be,UINT16_BE,/* */)
316__GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(16,gint16,int16_le,UINT16_LE,/* */)
317__GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(16,gint16,int16_be,UINT16_BE,/* */)
318
319__GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(32,guint32,uint32_le,UINT32_LE,/* */)
320__GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(32,guint32,uint32_be,UINT32_BE,/* */)
321__GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(32,gint32,int32_le,UINT32_LE,/* */)
322__GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(32,gint32,int32_be,UINT32_BE,/* */)
323
324__GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(24,guint32,uint24_le,UINT24_LE,/* */)
325__GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(24,guint32,uint24_be,UINT24_BE,/* */)
326
327/* fix up the sign for 24-bit signed ints stored in 32-bit signed ints */
328__GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(24,gint32,int24_le,UINT24_LE,
329 if (val & 0x00800000) val |= 0xff000000;)
330__GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(24,gint32,int24_be,UINT24_BE,
331 if (val & 0x00800000) val |= 0xff000000;)
332
333__GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(64,guint64,uint64_le,UINT64_LE,/* */)
334__GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(64,guint64,uint64_be,UINT64_BE,/* */)
335__GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(64,gint64,int64_le,UINT64_LE,/* */)
336__GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(64,gint64,int64_be,UINT64_BE,/* */)
337
338__GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(32,gfloat,float32_le,FLOAT_LE,/* */)
339__GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(32,gfloat,float32_be,FLOAT_BE,/* */)
340__GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(64,gdouble,float64_le,DOUBLE_LE,/* */)
341__GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(64,gdouble,float64_be,DOUBLE_BE,/* */)
342
343#undef __GET_PEEK_BITS_UNCHECKED
344
345static inline const guint8 *
346gst_byte_reader_peek_data_unchecked (const GstByteReader * reader)
347{
348 return (const guint8 *) (reader->data + reader->byte);
349}
350
351static inline const guint8 *
352gst_byte_reader_get_data_unchecked (GstByteReader * reader, guint size)
353{
354 const guint8 *data;
355
356 data = gst_byte_reader_peek_data_unchecked (reader);
357 gst_byte_reader_skip_unchecked (reader, size);
358 return data;
359}
360
361static inline guint8 *
362gst_byte_reader_dup_data_unchecked (GstByteReader * reader, guint size)
363{
364 gconstpointer data = gst_byte_reader_get_data_unchecked (reader, size);
365 return (guint8 *) g_memdup (data, size);
366}
367
368/* Unchecked variants that should not be used */
369static inline guint
370_gst_byte_reader_get_pos_unchecked (const GstByteReader * reader)
371{
372 return reader->byte;
373}
374
375static inline guint
376_gst_byte_reader_get_remaining_unchecked (const GstByteReader * reader)
377{
378 return reader->size - reader->byte;
379}
380
381static inline guint
382_gst_byte_reader_get_size_unchecked (const GstByteReader * reader)
383{
384 return reader->size;
385}
386
387/* inlined variants (do not use directly) */
388
389static inline guint
390_gst_byte_reader_get_remaining_inline (const GstByteReader * reader)
391{
392 g_return_val_if_fail (reader != NULL, 0);
393
394 return _gst_byte_reader_get_remaining_unchecked (reader);
395}
396
397static inline guint
398_gst_byte_reader_get_size_inline (const GstByteReader * reader)
399{
400 g_return_val_if_fail (reader != NULL, 0);
401
402 return _gst_byte_reader_get_size_unchecked (reader);
403}
404
405#define __GST_BYTE_READER_GET_PEEK_BITS_INLINE(bits,type,name) \
406\
407static inline gboolean \
408_gst_byte_reader_peek_##name##_inline (const GstByteReader * reader, type * val) \
409{ \
410 g_return_val_if_fail (reader != NULL, FALSE); \
411 g_return_val_if_fail (val != NULL, FALSE); \
412 \
413 if (_gst_byte_reader_get_remaining_unchecked (reader) < (bits / 8)) \
414 return FALSE; \
415\
416 *val = gst_byte_reader_peek_##name##_unchecked (reader); \
417 return TRUE; \
418} \
419\
420static inline gboolean \
421_gst_byte_reader_get_##name##_inline (GstByteReader * reader, type * val) \
422{ \
423 g_return_val_if_fail (reader != NULL, FALSE); \
424 g_return_val_if_fail (val != NULL, FALSE); \
425 \
426 if (_gst_byte_reader_get_remaining_unchecked (reader) < (bits / 8)) \
427 return FALSE; \
428\
429 *val = gst_byte_reader_get_##name##_unchecked (reader); \
430 return TRUE; \
431}
432
433__GST_BYTE_READER_GET_PEEK_BITS_INLINE(8,guint8,uint8)
434__GST_BYTE_READER_GET_PEEK_BITS_INLINE(8,gint8,int8)
435
436__GST_BYTE_READER_GET_PEEK_BITS_INLINE(16,guint16,uint16_le)
437__GST_BYTE_READER_GET_PEEK_BITS_INLINE(16,guint16,uint16_be)
438__GST_BYTE_READER_GET_PEEK_BITS_INLINE(16,gint16,int16_le)
439__GST_BYTE_READER_GET_PEEK_BITS_INLINE(16,gint16,int16_be)
440
441__GST_BYTE_READER_GET_PEEK_BITS_INLINE(32,guint32,uint32_le)
442__GST_BYTE_READER_GET_PEEK_BITS_INLINE(32,guint32,uint32_be)
443__GST_BYTE_READER_GET_PEEK_BITS_INLINE(32,gint32,int32_le)
444__GST_BYTE_READER_GET_PEEK_BITS_INLINE(32,gint32,int32_be)
445
446__GST_BYTE_READER_GET_PEEK_BITS_INLINE(24,guint32,uint24_le)
447__GST_BYTE_READER_GET_PEEK_BITS_INLINE(24,guint32,uint24_be)
448__GST_BYTE_READER_GET_PEEK_BITS_INLINE(24,gint32,int24_le)
449__GST_BYTE_READER_GET_PEEK_BITS_INLINE(24,gint32,int24_be)
450
451__GST_BYTE_READER_GET_PEEK_BITS_INLINE(64,guint64,uint64_le)
452__GST_BYTE_READER_GET_PEEK_BITS_INLINE(64,guint64,uint64_be)
453__GST_BYTE_READER_GET_PEEK_BITS_INLINE(64,gint64,int64_le)
454__GST_BYTE_READER_GET_PEEK_BITS_INLINE(64,gint64,int64_be)
455
456__GST_BYTE_READER_GET_PEEK_BITS_INLINE(32,gfloat,float32_le)
457__GST_BYTE_READER_GET_PEEK_BITS_INLINE(32,gfloat,float32_be)
458__GST_BYTE_READER_GET_PEEK_BITS_INLINE(64,gdouble,float64_le)
459__GST_BYTE_READER_GET_PEEK_BITS_INLINE(64,gdouble,float64_be)
460
461#undef __GST_BYTE_READER_GET_PEEK_BITS_INLINE
462
463#ifndef GST_BYTE_READER_DISABLE_INLINES
464
465#define gst_byte_reader_init(reader,data,size) \
466 _gst_byte_reader_init_inline(reader,data,size)
467
468#define gst_byte_reader_get_remaining(reader) \
469 _gst_byte_reader_get_remaining_inline(reader)
470
471#define gst_byte_reader_get_size(reader) \
472 _gst_byte_reader_get_size_inline(reader)
473
474#define gst_byte_reader_get_pos(reader) \
475 _gst_byte_reader_get_pos_inline(reader)
476
477/* we use defines here so we can add the G_LIKELY() */
478#define gst_byte_reader_get_uint8(reader,val) \
479 G_LIKELY(_gst_byte_reader_get_uint8_inline(reader,val))
480#define gst_byte_reader_get_int8(reader,val) \
481 G_LIKELY(_gst_byte_reader_get_int8_inline(reader,val))
482#define gst_byte_reader_get_uint16_le(reader,val) \
483 G_LIKELY(_gst_byte_reader_get_uint16_le_inline(reader,val))
484#define gst_byte_reader_get_int16_le(reader,val) \
485 G_LIKELY(_gst_byte_reader_get_int16_le_inline(reader,val))
486#define gst_byte_reader_get_uint16_be(reader,val) \
487 G_LIKELY(_gst_byte_reader_get_uint16_be_inline(reader,val))
488#define gst_byte_reader_get_int16_be(reader,val) \
489 G_LIKELY(_gst_byte_reader_get_int16_be_inline(reader,val))
490#define gst_byte_reader_get_uint24_le(reader,val) \
491 G_LIKELY(_gst_byte_reader_get_uint24_le_inline(reader,val))
492#define gst_byte_reader_get_int24_le(reader,val) \
493 G_LIKELY(_gst_byte_reader_get_int24_le_inline(reader,val))
494#define gst_byte_reader_get_uint24_be(reader,val) \
495 G_LIKELY(_gst_byte_reader_get_uint24_be_inline(reader,val))
496#define gst_byte_reader_get_int24_be(reader,val) \
497 G_LIKELY(_gst_byte_reader_get_int24_be_inline(reader,val))
498#define gst_byte_reader_get_uint32_le(reader,val) \
499 G_LIKELY(_gst_byte_reader_get_uint32_le_inline(reader,val))
500#define gst_byte_reader_get_int32_le(reader,val) \
501 G_LIKELY(_gst_byte_reader_get_int32_le_inline(reader,val))
502#define gst_byte_reader_get_uint32_be(reader,val) \
503 G_LIKELY(_gst_byte_reader_get_uint32_be_inline(reader,val))
504#define gst_byte_reader_get_int32_be(reader,val) \
505 G_LIKELY(_gst_byte_reader_get_int32_be_inline(reader,val))
506#define gst_byte_reader_get_uint64_le(reader,val) \
507 G_LIKELY(_gst_byte_reader_get_uint64_le_inline(reader,val))
508#define gst_byte_reader_get_int64_le(reader,val) \
509 G_LIKELY(_gst_byte_reader_get_int64_le_inline(reader,val))
510#define gst_byte_reader_get_uint64_be(reader,val) \
511 G_LIKELY(_gst_byte_reader_get_uint64_be_inline(reader,val))
512#define gst_byte_reader_get_int64_be(reader,val) \
513 G_LIKELY(_gst_byte_reader_get_int64_be_inline(reader,val))
514
515#define gst_byte_reader_peek_uint8(reader,val) \
516 G_LIKELY(_gst_byte_reader_peek_uint8_inline(reader,val))
517#define gst_byte_reader_peek_int8(reader,val) \
518 G_LIKELY(_gst_byte_reader_peek_int8_inline(reader,val))
519#define gst_byte_reader_peek_uint16_le(reader,val) \
520 G_LIKELY(_gst_byte_reader_peek_uint16_le_inline(reader,val))
521#define gst_byte_reader_peek_int16_le(reader,val) \
522 G_LIKELY(_gst_byte_reader_peek_int16_le_inline(reader,val))
523#define gst_byte_reader_peek_uint16_be(reader,val) \
524 G_LIKELY(_gst_byte_reader_peek_uint16_be_inline(reader,val))
525#define gst_byte_reader_peek_int16_be(reader,val) \
526 G_LIKELY(_gst_byte_reader_peek_int16_be_inline(reader,val))
527#define gst_byte_reader_peek_uint24_le(reader,val) \
528 G_LIKELY(_gst_byte_reader_peek_uint24_le_inline(reader,val))
529#define gst_byte_reader_peek_int24_le(reader,val) \
530 G_LIKELY(_gst_byte_reader_peek_int24_le_inline(reader,val))
531#define gst_byte_reader_peek_uint24_be(reader,val) \
532 G_LIKELY(_gst_byte_reader_peek_uint24_be_inline(reader,val))
533#define gst_byte_reader_peek_int24_be(reader,val) \
534 G_LIKELY(_gst_byte_reader_peek_int24_be_inline(reader,val))
535#define gst_byte_reader_peek_uint32_le(reader,val) \
536 G_LIKELY(_gst_byte_reader_peek_uint32_le_inline(reader,val))
537#define gst_byte_reader_peek_int32_le(reader,val) \
538 G_LIKELY(_gst_byte_reader_peek_int32_le_inline(reader,val))
539#define gst_byte_reader_peek_uint32_be(reader,val) \
540 G_LIKELY(_gst_byte_reader_peek_uint32_be_inline(reader,val))
541#define gst_byte_reader_peek_int32_be(reader,val) \
542 G_LIKELY(_gst_byte_reader_peek_int32_be_inline(reader,val))
543#define gst_byte_reader_peek_uint64_le(reader,val) \
544 G_LIKELY(_gst_byte_reader_peek_uint64_le_inline(reader,val))
545#define gst_byte_reader_peek_int64_le(reader,val) \
546 G_LIKELY(_gst_byte_reader_peek_int64_le_inline(reader,val))
547#define gst_byte_reader_peek_uint64_be(reader,val) \
548 G_LIKELY(_gst_byte_reader_peek_uint64_be_inline(reader,val))
549#define gst_byte_reader_peek_int64_be(reader,val) \
550 G_LIKELY(_gst_byte_reader_peek_int64_be_inline(reader,val))
551
552#define gst_byte_reader_get_float32_le(reader,val) \
553 G_LIKELY(_gst_byte_reader_get_float32_le_inline(reader,val))
554#define gst_byte_reader_get_float32_be(reader,val) \
555 G_LIKELY(_gst_byte_reader_get_float32_be_inline(reader,val))
556#define gst_byte_reader_get_float64_le(reader,val) \
557 G_LIKELY(_gst_byte_reader_get_float64_le_inline(reader,val))
558#define gst_byte_reader_get_float64_be(reader,val) \
559 G_LIKELY(_gst_byte_reader_get_float64_be_inline(reader,val))
560#define gst_byte_reader_peek_float32_le(reader,val) \
561 G_LIKELY(_gst_byte_reader_peek_float32_le_inline(reader,val))
562#define gst_byte_reader_peek_float32_be(reader,val) \
563 G_LIKELY(_gst_byte_reader_peek_float32_be_inline(reader,val))
564#define gst_byte_reader_peek_float64_le(reader,val) \
565 G_LIKELY(_gst_byte_reader_peek_float64_le_inline(reader,val))
566#define gst_byte_reader_peek_float64_be(reader,val) \
567 G_LIKELY(_gst_byte_reader_peek_float64_be_inline(reader,val))
568
569#endif /* GST_BYTE_READER_DISABLE_INLINES */
570
571static inline void
572_gst_byte_reader_init_inline (GstByteReader * reader, const guint8 * data, guint size)
573{
574 g_return_if_fail (reader != NULL);
575
576 reader->data = data;
577 reader->size = size;
578 reader->byte = 0;
579}
580
581static inline gboolean
582_gst_byte_reader_peek_sub_reader_inline (GstByteReader * reader,
583 GstByteReader * sub_reader, guint size)
584{
585 g_return_val_if_fail (reader != NULL, FALSE);
586 g_return_val_if_fail (sub_reader != NULL, FALSE);
587
588 if (_gst_byte_reader_get_remaining_unchecked (reader) < size)
589 return FALSE;
590
591 sub_reader->data = reader->data + reader->byte;
592 sub_reader->byte = 0;
593 sub_reader->size = size;
594 return TRUE;
595}
596
597static inline gboolean
598_gst_byte_reader_get_sub_reader_inline (GstByteReader * reader,
599 GstByteReader * sub_reader, guint size)
600{
601 if (!_gst_byte_reader_peek_sub_reader_inline (reader, sub_reader, size))
602 return FALSE;
603 gst_byte_reader_skip_unchecked (reader, size);
604 return TRUE;
605}
606
607static inline gboolean
608_gst_byte_reader_dup_data_inline (GstByteReader * reader, guint size, guint8 ** val)
609{
610 g_return_val_if_fail (reader != NULL, FALSE);
611 g_return_val_if_fail (val != NULL, FALSE);
612
613 if (G_UNLIKELY (size > reader->size || _gst_byte_reader_get_remaining_unchecked (reader) < size))
614 return FALSE;
615
616 *val = gst_byte_reader_dup_data_unchecked (reader, size);
617 return TRUE;
618}
619
620static inline gboolean
621_gst_byte_reader_get_data_inline (GstByteReader * reader, guint size, const guint8 ** val)
622{
623 g_return_val_if_fail (reader != NULL, FALSE);
624 g_return_val_if_fail (val != NULL, FALSE);
625
626 if (G_UNLIKELY (size > reader->size || _gst_byte_reader_get_remaining_unchecked (reader) < size))
627 return FALSE;
628
629 *val = gst_byte_reader_get_data_unchecked (reader, size);
630 return TRUE;
631}
632
633static inline gboolean
634_gst_byte_reader_peek_data_inline (const GstByteReader * reader, guint size, const guint8 ** val)
635{
636 g_return_val_if_fail (reader != NULL, FALSE);
637 g_return_val_if_fail (val != NULL, FALSE);
638
639 if (G_UNLIKELY (size > reader->size || _gst_byte_reader_get_remaining_unchecked (reader) < size))
640 return FALSE;
641
642 *val = gst_byte_reader_peek_data_unchecked (reader);
643 return TRUE;
644}
645
646static inline guint
647_gst_byte_reader_get_pos_inline (const GstByteReader * reader)
648{
649 g_return_val_if_fail (reader != NULL, 0);
650
651 return _gst_byte_reader_get_pos_unchecked (reader);
652}
653
654static inline gboolean
655_gst_byte_reader_skip_inline (GstByteReader * reader, guint nbytes)
656{
657 g_return_val_if_fail (reader != NULL, FALSE);
658
659 if (G_UNLIKELY (_gst_byte_reader_get_remaining_unchecked (reader) < nbytes))
660 return FALSE;
661
662 reader->byte += nbytes;
663 return TRUE;
664}
665
666#ifndef GST_BYTE_READER_DISABLE_INLINES
667
668#define gst_byte_reader_dup_data(reader,size,val) \
669 G_LIKELY(_gst_byte_reader_dup_data_inline(reader,size,val))
670#define gst_byte_reader_get_data(reader,size,val) \
671 G_LIKELY(_gst_byte_reader_get_data_inline(reader,size,val))
672#define gst_byte_reader_peek_data(reader,size,val) \
673 G_LIKELY(_gst_byte_reader_peek_data_inline(reader,size,val))
674#define gst_byte_reader_skip(reader,nbytes) \
675 G_LIKELY(_gst_byte_reader_skip_inline(reader,nbytes))
676
677#endif /* GST_BYTE_READER_DISABLE_INLINES */
678
679G_END_DECLS
680
681#endif /* __GST_BYTE_READER_H__ */
682