LCOV - code coverage report
Current view: top level - libs/gst/base - gstbytereader.h (source / functions) Hit Total Coverage
Test: GStreamer 0.10.32.1 Lines: 86 100 86.0 %
Date: 2011-03-25 Functions: 100 102 98.0 %
Branches: 190 302 62.9 %

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

Generated by: LCOV version 1.9