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