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