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