libs/gst/base/gstbytereader.h

   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 (GstByteReader *reader, guint8 *val);
  82 gboolean gst_byte_reader_peek_int8 (GstByteReader *reader, gint8 *val);
  83 gboolean gst_byte_reader_peek_uint16_le (GstByteReader *reader, guint16 *val);
  84 gboolean gst_byte_reader_peek_int16_le (GstByteReader *reader, gint16 *val);
  85 gboolean gst_byte_reader_peek_uint16_be (GstByteReader *reader, guint16 *val);
  86 gboolean gst_byte_reader_peek_int16_be (GstByteReader *reader, gint16 *val);
  87 gboolean gst_byte_reader_peek_uint24_le (GstByteReader *reader, guint32 *val);
  88 gboolean gst_byte_reader_peek_int24_le (GstByteReader *reader, gint32 *val);
  89 gboolean gst_byte_reader_peek_uint24_be (GstByteReader *reader, guint32 *val);
  90 gboolean gst_byte_reader_peek_int24_be (GstByteReader *reader, gint32 *val);
  91 gboolean gst_byte_reader_peek_uint32_le (GstByteReader *reader, guint32 *val);
  92 gboolean gst_byte_reader_peek_int32_le (GstByteReader *reader, gint32 *val);
  93 gboolean gst_byte_reader_peek_uint32_be (GstByteReader *reader, guint32 *val);
  94 gboolean gst_byte_reader_peek_int32_be (GstByteReader *reader, gint32 *val);
  95 gboolean gst_byte_reader_peek_uint64_le (GstByteReader *reader, guint64 *val);
  96 gboolean gst_byte_reader_peek_int64_le (GstByteReader *reader, gint64 *val);
  97 gboolean gst_byte_reader_peek_uint64_be (GstByteReader *reader, guint64 *val);
  98 gboolean gst_byte_reader_peek_int64_be (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 (GstByteReader *reader, gfloat *val);
 106 gboolean gst_byte_reader_peek_float32_be (GstByteReader *reader, gfloat *val);
 107 gboolean gst_byte_reader_peek_float64_le (GstByteReader *reader, gdouble *val);
 108 gboolean gst_byte_reader_peek_float64_be (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 (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  (GstByteReader * reader, const gchar ** str);
 136
 137 guint    gst_byte_reader_masked_scan_uint32 (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 gst_byte_reader_skip_unchecked (GstByteReader * reader, guint nbytes)
 174 {
 175   reader->byte += nbytes;
 176 }
 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 (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 __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(8,guint8,uint8,UINT8,/* */)
 197 __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(8,gint8,int8,UINT8,/* */)
 198
 199 __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(16,guint16,uint16_le,UINT16_LE,/* */)
 200 __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(16,guint16,uint16_be,UINT16_BE,/* */)
 201 __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(16,gint16,int16_le,UINT16_LE,/* */)
 202 __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(16,gint16,int16_be,UINT16_BE,/* */)
 203
 204 __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(32,guint32,uint32_le,UINT32_LE,/* */)
 205 __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(32,guint32,uint32_be,UINT32_BE,/* */)
 206 __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(32,gint32,int32_le,UINT32_LE,/* */)
 207 __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(32,gint32,int32_be,UINT32_BE,/* */)
 208
 209 __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(24,guint32,uint24_le,UINT24_LE,/* */)
 210 __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 __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(24,gint32,int24_le,UINT24_LE,
 214     if (val & 0x00800000) val |= 0xff000000;)
 215 __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(24,gint32,int24_be,UINT24_BE,
 216     if (val & 0x00800000) val |= 0xff000000;)
 217
 218 __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(64,guint64,uint64_le,UINT64_LE,/* */)
 219 __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(64,guint64,uint64_be,UINT64_BE,/* */)
 220 __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(64,gint64,int64_le,UINT64_LE,/* */)
 221 __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(64,gint64,int64_be,UINT64_BE,/* */)
 222
 223 __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(32,gfloat,float32_le,FLOAT_LE,/* */)
 224 __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(32,gfloat,float32_be,FLOAT_BE,/* */)
 225 __GST_BYTE_READER_GET_PEEK_BITS_UNCHECKED(64,gdouble,float64_le,DOUBLE_LE,/* */)
 226 __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 gst_byte_reader_peek_data_unchecked (GstByteReader * reader)
 232 {
 233   return (const guint8 *) (reader->data + reader->byte);
 234 }
 235
 236 static inline const guint8 *
 237 gst_byte_reader_get_data_unchecked (GstByteReader * reader, guint size)
 238 {
 239   const guint8 *data;
 240
 241   data = gst_byte_reader_peek_data_unchecked (reader);
 242   gst_byte_reader_skip_unchecked (reader, size);
 243   return data;
 244 }
 245
 246 static inline guint8 *
 247 gst_byte_reader_dup_data_unchecked (GstByteReader * reader, guint size)
 248 {
 249   return g_memdup (gst_byte_reader_get_data_unchecked (reader, size), size);
 250 }
 251
 252 /* Unchecked variants that should not be used */
 253 static inline guint
 254 _gst_byte_reader_get_pos_unchecked (const GstByteReader * reader)
 255 {
 256   return reader->byte;
 257 }
 258
 259 static inline guint
 260 _gst_byte_reader_get_remaining_unchecked (const GstByteReader * reader)
 261 {
 262   return reader->size - reader->byte;
 263 }
 264
 265 static inline guint
 266 _gst_byte_reader_get_size_unchecked (const GstByteReader * reader)
 267 {
 268   return reader->size;
 269 }
 270
 271 /* inlined variants (do not use directly) */
 272
 273 static inline guint
 274 _gst_byte_reader_get_remaining_inline (const GstByteReader * reader)
 275 {
 276   g_return_val_if_fail (reader != NULL, 0);
 277
 278   return _gst_byte_reader_get_remaining_unchecked (reader);
 279 }
 280
 281 static inline guint
 282 _gst_byte_reader_get_size_inline (const GstByteReader * reader)
 283 {
 284   g_return_val_if_fail (reader != NULL, 0);
 285
 286   return _gst_byte_reader_get_size_unchecked (reader);
 287 }
 288
 289 #define __GST_BYTE_READER_GET_PEEK_BITS_INLINE(bits,type,name) \
 290 \
 291 static inline gboolean \
 292 _gst_byte_reader_peek_##name##_inline (GstByteReader * reader, type * val) \
 293 { \
 294   g_return_val_if_fail (reader != NULL, FALSE); \
 295   g_return_val_if_fail (val != NULL, FALSE); \
 296   \
 297   if (_gst_byte_reader_get_remaining_unchecked (reader) < (bits / 8)) \
 298     return FALSE; \
 299 \
 300   *val = gst_byte_reader_peek_##name##_unchecked (reader); \
 301   return TRUE; \
 302 } \
 303 \
 304 static inline gboolean \
 305 _gst_byte_reader_get_##name##_inline (GstByteReader * reader, type * val) \
 306 { \
 307   g_return_val_if_fail (reader != NULL, FALSE); \
 308   g_return_val_if_fail (val != NULL, FALSE); \
 309   \
 310   if (_gst_byte_reader_get_remaining_unchecked (reader) < (bits / 8)) \
 311     return FALSE; \
 312 \
 313   *val = gst_byte_reader_get_##name##_unchecked (reader); \
 314   return TRUE; \
 315 }
 316
 317 __GST_BYTE_READER_GET_PEEK_BITS_INLINE(8,guint8,uint8)
 318 __GST_BYTE_READER_GET_PEEK_BITS_INLINE(8,gint8,int8)
 319
 320 __GST_BYTE_READER_GET_PEEK_BITS_INLINE(16,guint16,uint16_le)
 321 __GST_BYTE_READER_GET_PEEK_BITS_INLINE(16,guint16,uint16_be)
 322 __GST_BYTE_READER_GET_PEEK_BITS_INLINE(16,gint16,int16_le)
 323 __GST_BYTE_READER_GET_PEEK_BITS_INLINE(16,gint16,int16_be)
 324
 325 __GST_BYTE_READER_GET_PEEK_BITS_INLINE(32,guint32,uint32_le)
 326 __GST_BYTE_READER_GET_PEEK_BITS_INLINE(32,guint32,uint32_be)
 327 __GST_BYTE_READER_GET_PEEK_BITS_INLINE(32,gint32,int32_le)
 328 __GST_BYTE_READER_GET_PEEK_BITS_INLINE(32,gint32,int32_be)
 329
 330 __GST_BYTE_READER_GET_PEEK_BITS_INLINE(24,guint32,uint24_le)
 331 __GST_BYTE_READER_GET_PEEK_BITS_INLINE(24,guint32,uint24_be)
 332 __GST_BYTE_READER_GET_PEEK_BITS_INLINE(24,gint32,int24_le)
 333 __GST_BYTE_READER_GET_PEEK_BITS_INLINE(24,gint32,int24_be)
 334
 335 __GST_BYTE_READER_GET_PEEK_BITS_INLINE(64,guint64,uint64_le)
 336 __GST_BYTE_READER_GET_PEEK_BITS_INLINE(64,guint64,uint64_be)
 337 __GST_BYTE_READER_GET_PEEK_BITS_INLINE(64,gint64,int64_le)
 338 __GST_BYTE_READER_GET_PEEK_BITS_INLINE(64,gint64,int64_be)
 339
 340 __GST_BYTE_READER_GET_PEEK_BITS_INLINE(32,gfloat,float32_le)
 341 __GST_BYTE_READER_GET_PEEK_BITS_INLINE(32,gfloat,float32_be)
 342 __GST_BYTE_READER_GET_PEEK_BITS_INLINE(64,gdouble,float64_le)
 343 __GST_BYTE_READER_GET_PEEK_BITS_INLINE(64,gdouble,float64_be)
 344
 345 #undef __GST_BYTE_READER_GET_PEEK_BITS_INLINE
 346
 347 #ifndef GST_BYTE_READER_DISABLE_INLINES
 348
 349 #define gst_byte_reader_get_remaining(reader) \
 350     _gst_byte_reader_get_remaining_inline(reader)
 351
 352 #define gst_byte_reader_get_size(reader) \
 353     _gst_byte_reader_get_size_inline(reader)
 354
 355 #define gst_byte_reader_get_pos(reader) \
 356     _gst_byte_reader_get_pos_inline(reader)
 357
 358 /* we use defines here so we can add the G_LIKELY() */
 359 #define gst_byte_reader_get_uint8(reader,val) \
 360     G_LIKELY(_gst_byte_reader_get_uint8_inline(reader,val))
 361 #define gst_byte_reader_get_int8(reader,val) \
 362     G_LIKELY(_gst_byte_reader_get_int8_inline(reader,val))
 363 #define gst_byte_reader_get_uint16_le(reader,val) \
 364     G_LIKELY(_gst_byte_reader_get_uint16_le_inline(reader,val))
 365 #define gst_byte_reader_get_int16_le(reader,val) \
 366     G_LIKELY(_gst_byte_reader_get_int16_le_inline(reader,val))
 367 #define gst_byte_reader_get_uint16_be(reader,val) \
 368     G_LIKELY(_gst_byte_reader_get_uint16_be_inline(reader,val))
 369 #define gst_byte_reader_get_int16_be(reader,val) \
 370     G_LIKELY(_gst_byte_reader_get_int16_be_inline(reader,val))
 371 #define gst_byte_reader_get_uint24_le(reader,val) \
 372     G_LIKELY(_gst_byte_reader_get_uint24_le_inline(reader,val))
 373 #define gst_byte_reader_get_int24_le(reader,val) \
 374     G_LIKELY(_gst_byte_reader_get_int24_le_inline(reader,val))
 375 #define gst_byte_reader_get_uint24_be(reader,val) \
 376     G_LIKELY(_gst_byte_reader_get_uint24_be_inline(reader,val))
 377 #define gst_byte_reader_get_int24_be(reader,val) \
 378     G_LIKELY(_gst_byte_reader_get_int24_be_inline(reader,val))
 379 #define gst_byte_reader_get_uint32_le(reader,val) \
 380     G_LIKELY(_gst_byte_reader_get_uint32_le_inline(reader,val))
 381 #define gst_byte_reader_get_int32_le(reader,val) \
 382     G_LIKELY(_gst_byte_reader_get_int32_le_inline(reader,val))
 383 #define gst_byte_reader_get_uint32_be(reader,val) \
 384     G_LIKELY(_gst_byte_reader_get_uint32_be_inline(reader,val))
 385 #define gst_byte_reader_get_int32_be(reader,val) \
 386     G_LIKELY(_gst_byte_reader_get_int32_be_inline(reader,val))
 387 #define gst_byte_reader_get_uint64_le(reader,val) \
 388     G_LIKELY(_gst_byte_reader_get_uint64_le_inline(reader,val))
 389 #define gst_byte_reader_get_int64_le(reader,val) \
 390     G_LIKELY(_gst_byte_reader_get_int64_le_inline(reader,val))
 391 #define gst_byte_reader_get_uint64_be(reader,val) \
 392     G_LIKELY(_gst_byte_reader_get_uint64_be_inline(reader,val))
 393 #define gst_byte_reader_get_int64_be(reader,val) \
 394     G_LIKELY(_gst_byte_reader_get_int64_be_inline(reader,val))
 395
 396 #define gst_byte_reader_peek_uint8(reader,val) \
 397     G_LIKELY(_gst_byte_reader_peek_uint8_inline(reader,val))
 398 #define gst_byte_reader_peek_int8(reader,val) \
 399     G_LIKELY(_gst_byte_reader_peek_int8_inline(reader,val))
 400 #define gst_byte_reader_peek_uint16_le(reader,val) \
 401     G_LIKELY(_gst_byte_reader_peek_uint16_le_inline(reader,val))
 402 #define gst_byte_reader_peek_int16_le(reader,val) \
 403     G_LIKELY(_gst_byte_reader_peek_int16_le_inline(reader,val))
 404 #define gst_byte_reader_peek_uint16_be(reader,val) \
 405     G_LIKELY(_gst_byte_reader_peek_uint16_be_inline(reader,val))
 406 #define gst_byte_reader_peek_int16_be(reader,val) \
 407     G_LIKELY(_gst_byte_reader_peek_int16_be_inline(reader,val))
 408 #define gst_byte_reader_peek_uint24_le(reader,val) \
 409     G_LIKELY(_gst_byte_reader_peek_uint24_le_inline(reader,val))
 410 #define gst_byte_reader_peek_int24_le(reader,val) \
 411     G_LIKELY(_gst_byte_reader_peek_int24_le_inline(reader,val))
 412 #define gst_byte_reader_peek_uint24_be(reader,val) \
 413     G_LIKELY(_gst_byte_reader_peek_uint24_be_inline(reader,val))
 414 #define gst_byte_reader_peek_int24_be(reader,val) \
 415     G_LIKELY(_gst_byte_reader_peek_int24_be_inline(reader,val))
 416 #define gst_byte_reader_peek_uint32_le(reader,val) \
 417     G_LIKELY(_gst_byte_reader_peek_uint32_le_inline(reader,val))
 418 #define gst_byte_reader_peek_int32_le(reader,val) \
 419     G_LIKELY(_gst_byte_reader_peek_int32_le_inline(reader,val))
 420 #define gst_byte_reader_peek_uint32_be(reader,val) \
 421     G_LIKELY(_gst_byte_reader_peek_uint32_be_inline(reader,val))
 422 #define gst_byte_reader_peek_int32_be(reader,val) \
 423     G_LIKELY(_gst_byte_reader_peek_int32_be_inline(reader,val))
 424 #define gst_byte_reader_peek_uint64_le(reader,val) \
 425     G_LIKELY(_gst_byte_reader_peek_uint64_le_inline(reader,val))
 426 #define gst_byte_reader_peek_int64_le(reader,val) \
 427     G_LIKELY(_gst_byte_reader_peek_int64_le_inline(reader,val))
 428 #define gst_byte_reader_peek_uint64_be(reader,val) \
 429     G_LIKELY(_gst_byte_reader_peek_uint64_be_inline(reader,val))
 430 #define gst_byte_reader_peek_int64_be(reader,val) \
 431     G_LIKELY(_gst_byte_reader_peek_int64_be_inline(reader,val))
 432
 433 #define gst_byte_reader_get_float32_le(reader,val) \
 434     G_LIKELY(_gst_byte_reader_get_float32_le_inline(reader,val))
 435 #define gst_byte_reader_get_float32_be(reader,val) \
 436     G_LIKELY(_gst_byte_reader_get_float32_be_inline(reader,val))
 437 #define gst_byte_reader_get_float64_le(reader,val) \
 438     G_LIKELY(_gst_byte_reader_get_float64_le_inline(reader,val))
 439 #define gst_byte_reader_get_float64_be(reader,val) \
 440     G_LIKELY(_gst_byte_reader_get_float64_be_inline(reader,val))
 441 #define gst_byte_reader_peek_float32_le(reader,val) \
 442     G_LIKELY(_gst_byte_reader_peek_float32_le_inline(reader,val))
 443 #define gst_byte_reader_peek_float32_be(reader,val) \
 444     G_LIKELY(_gst_byte_reader_peek_float32_be_inline(reader,val))
 445 #define gst_byte_reader_peek_float64_le(reader,val) \
 446     G_LIKELY(_gst_byte_reader_peek_float64_le_inline(reader,val))
 447 #define gst_byte_reader_peek_float64_be(reader,val) \
 448     G_LIKELY(_gst_byte_reader_peek_float64_be_inline(reader,val))
 449
 450 #endif /* GST_BYTE_READER_DISABLE_INLINES */
 451
 452 static inline gboolean
 453 _gst_byte_reader_dup_data_inline (GstByteReader * reader, guint size, guint8 ** val)
 454 {
 455   g_return_val_if_fail (reader != NULL, FALSE);
 456   g_return_val_if_fail (val != NULL, FALSE);
 457
 458   if (G_UNLIKELY (size > reader->size || _gst_byte_reader_get_remaining_inline (reader) < size))
 459     return FALSE;
 460
 461   *val = gst_byte_reader_dup_data_unchecked (reader, size);
 462   return TRUE;
 463 }
 464
 465 static inline gboolean
 466 _gst_byte_reader_get_data_inline (GstByteReader * reader, guint size, const guint8 ** val)
 467 {
 468   g_return_val_if_fail (reader != NULL, FALSE);
 469   g_return_val_if_fail (val != NULL, FALSE);
 470
 471   if (G_UNLIKELY (size > reader->size || _gst_byte_reader_get_remaining_inline (reader) < size))
 472     return FALSE;
 473
 474   *val = gst_byte_reader_get_data_unchecked (reader, size);
 475   return TRUE;
 476 }
 477
 478 static inline gboolean
 479 _gst_byte_reader_peek_data_inline (GstByteReader * reader, guint size, const guint8 ** val)
 480 {
 481   g_return_val_if_fail (reader != NULL, FALSE);
 482   g_return_val_if_fail (val != NULL, FALSE);
 483
 484   if (G_UNLIKELY (size > reader->size || _gst_byte_reader_get_remaining_inline (reader) < size))
 485     return FALSE;
 486
 487   *val = gst_byte_reader_peek_data_unchecked (reader);
 488   return TRUE;
 489 }
 490
 491 static inline guint
 492 _gst_byte_reader_get_pos_inline (const GstByteReader * reader)
 493 {
 494   g_return_val_if_fail (reader != NULL, 0);
 495
 496   return _gst_byte_reader_get_pos_unchecked (reader);
 497 }
 498
 499 static inline gboolean
 500 _gst_byte_reader_skip_inline (GstByteReader * reader, guint nbytes)
 501 {
 502   g_return_val_if_fail (reader != NULL, FALSE);
 503
 504   if (G_UNLIKELY (_gst_byte_reader_get_remaining_unchecked (reader) < nbytes))
 505     return FALSE;
 506
 507   reader->byte += nbytes;
 508   return TRUE;
 509 }
 510
 511 #ifndef GST_BYTE_READER_DISABLE_INLINES
 512
 513 #define gst_byte_reader_dup_data(reader,size,val) \
 514     G_LIKELY(_gst_byte_reader_dup_data_inline(reader,size,val))
 515 #define gst_byte_reader_get_data(reader,size,val) \
 516     G_LIKELY(_gst_byte_reader_get_data_inline(reader,size,val))
 517 #define gst_byte_reader_peek_data(reader,size,val) \
 518     G_LIKELY(_gst_byte_reader_peek_data_inline(reader,size,val))
 519 #define gst_byte_reader_skip(reader,nbytes) \
 520     G_LIKELY(_gst_byte_reader_skip_inline(reader,nbytes))
 521
 522 #endif /* GST_BYTE_READER_DISABLE_INLINES */
 523
 524 G_END_DECLS
 525
 526 #endif /* __GST_BYTE_READER_H__ */