LCOV - code coverage report
Current view: top level - libs/gst/base - gstbytereader.c (source / functions) Hit Total Coverage
Test: GStreamer 0.10.32.1 Lines: 61 100 61.0 %
Date: 2011-03-25 Functions: 18 69 26.1 %
Branches: 59 90 65.6 %

           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                 :            : #ifdef HAVE_CONFIG_H
      23                 :            : #include "config.h"
      24                 :            : #endif
      25                 :            : 
      26                 :            : #define GST_BYTE_READER_DISABLE_INLINES
      27                 :            : #include "gstbytereader.h"
      28                 :            : 
      29                 :            : #include <string.h>
      30                 :            : 
      31                 :            : /**
      32                 :            :  * SECTION:gstbytereader
      33                 :            :  * @short_description: Reads different integer, string and floating point
      34                 :            :  *     types from a memory buffer
      35                 :            :  *
      36                 :            :  * #GstByteReader provides a byte reader that can read different integer and
      37                 :            :  * floating point types from a memory buffer. It provides functions for reading
      38                 :            :  * signed/unsigned, little/big endian integers of 8, 16, 24, 32 and 64 bits
      39                 :            :  * and functions for reading little/big endian floating points numbers of
      40                 :            :  * 32 and 64 bits. It also provides functions to read NUL-terminated strings
      41                 :            :  * in various character encodings.
      42                 :            :  */
      43                 :            : 
      44                 :            : /**
      45                 :            :  * gst_byte_reader_new:
      46                 :            :  * @data: (in) (transfer none) (array length=size): data from which the
      47                 :            :  *     #GstByteReader should read
      48                 :            :  * @size: Size of @data in bytes
      49                 :            :  *
      50                 :            :  * Create a new #GstByteReader instance, which will read from @data.
      51                 :            :  *
      52                 :            :  * Free-function: gst_byte_reader_free
      53                 :            :  *
      54                 :            :  * Returns: (transfer full): a new #GstByteReader instance
      55                 :            :  *
      56                 :            :  * Since: 0.10.22
      57                 :            :  */
      58                 :            : GstByteReader *
      59                 :          2 : gst_byte_reader_new (const guint8 * data, guint size)
      60                 :            : {
      61                 :          2 :   GstByteReader *ret = g_slice_new0 (GstByteReader);
      62                 :            : 
      63                 :          2 :   ret->data = data;
      64                 :          2 :   ret->size = size;
      65                 :            : 
      66                 :          2 :   return ret;
      67                 :            : }
      68                 :            : 
      69                 :            : /**
      70                 :            :  * gst_byte_reader_new_from_buffer:
      71                 :            :  * @buffer: (transfer none): Buffer from which the #GstByteReader should read
      72                 :            :  *
      73                 :            :  * Create a new #GstByteReader instance, which will read from the
      74                 :            :  * #GstBuffer @buffer.
      75                 :            :  *
      76                 :            :  * Free-function: gst_byte_reader_free
      77                 :            :  *
      78                 :            :  * Returns: (transfer full): a new #GstByteReader instance
      79                 :            :  *
      80                 :            :  * Since: 0.10.22
      81                 :            :  */
      82                 :            : GstByteReader *
      83                 :          1 : gst_byte_reader_new_from_buffer (const GstBuffer * buffer)
      84                 :            : {
      85 [ -  + ][ +  - ]:          1 :   g_return_val_if_fail (GST_IS_BUFFER (buffer), NULL);
         [ +  - ][ -  + ]
      86                 :            : 
      87                 :          1 :   return gst_byte_reader_new (GST_BUFFER_DATA (buffer),
      88                 :            :       GST_BUFFER_SIZE (buffer));
      89                 :            : }
      90                 :            : 
      91                 :            : /**
      92                 :            :  * gst_byte_reader_free:
      93                 :            :  * @reader: (in) (transfer full): a #GstByteReader instance
      94                 :            :  *
      95                 :            :  * Frees a #GstByteReader instance, which was previously allocated by
      96                 :            :  * gst_byte_reader_new() or gst_byte_reader_new_from_buffer().
      97                 :            :  * 
      98                 :            :  * Since: 0.10.22
      99                 :            :  */
     100                 :            : void
     101                 :          2 : gst_byte_reader_free (GstByteReader * reader)
     102                 :            : {
     103         [ -  + ]:          4 :   g_return_if_fail (reader != NULL);
     104                 :            : 
     105                 :          2 :   g_slice_free (GstByteReader, reader);
     106                 :            : }
     107                 :            : 
     108                 :            : /**
     109                 :            :  * gst_byte_reader_init:
     110                 :            :  * @reader: a #GstByteReader instance
     111                 :            :  * @data: (in) (transfer none) (array length=size): data from which
     112                 :            :  *     the #GstByteReader should read
     113                 :            :  * @size: Size of @data in bytes
     114                 :            :  *
     115                 :            :  * Initializes a #GstByteReader instance to read from @data. This function
     116                 :            :  * can be called on already initialized instances.
     117                 :            :  * 
     118                 :            :  * Since: 0.10.22
     119                 :            :  */
     120                 :            : void
     121                 :          9 : gst_byte_reader_init (GstByteReader * reader, const guint8 * data, guint size)
     122                 :            : {
     123         [ -  + ]:         18 :   g_return_if_fail (reader != NULL);
     124                 :            : 
     125                 :          9 :   reader->data = data;
     126                 :          9 :   reader->size = size;
     127                 :          9 :   reader->byte = 0;
     128                 :            : }
     129                 :            : 
     130                 :            : /**
     131                 :            :  * gst_byte_reader_init_from_buffer:
     132                 :            :  * @reader: a #GstByteReader instance
     133                 :            :  * @buffer: (transfer none): Buffer from which the #GstByteReader should read
     134                 :            :  *
     135                 :            :  * Initializes a #GstByteReader instance to read from @buffer. This function
     136                 :            :  * can be called on already initialized instances.
     137                 :            :  * 
     138                 :            :  * Since: 0.10.22
     139                 :            :  */
     140                 :            : void
     141                 :          1 : gst_byte_reader_init_from_buffer (GstByteReader * reader,
     142                 :            :     const GstBuffer * buffer)
     143                 :            : {
     144 [ -  + ][ +  - ]:          2 :   g_return_if_fail (GST_IS_BUFFER (buffer));
         [ +  - ][ -  + ]
     145                 :            : 
     146                 :          1 :   gst_byte_reader_init (reader, GST_BUFFER_DATA (buffer),
     147                 :            :       GST_BUFFER_SIZE (buffer));
     148                 :            : }
     149                 :            : 
     150                 :            : /**
     151                 :            :  * gst_byte_reader_set_pos:
     152                 :            :  * @reader: a #GstByteReader instance
     153                 :            :  * @pos: The new position in bytes
     154                 :            :  *
     155                 :            :  * Sets the new position of a #GstByteReader instance to @pos in bytes.
     156                 :            :  *
     157                 :            :  * Returns: %TRUE if the position could be set successfully, %FALSE
     158                 :            :  * otherwise.
     159                 :            :  * 
     160                 :            :  * Since: 0.10.22
     161                 :            :  */
     162                 :            : gboolean
     163                 :         19 : gst_byte_reader_set_pos (GstByteReader * reader, guint pos)
     164                 :            : {
     165         [ -  + ]:         19 :   g_return_val_if_fail (reader != NULL, FALSE);
     166                 :            : 
     167         [ -  + ]:         19 :   if (pos > reader->size)
     168                 :          0 :     return FALSE;
     169                 :            : 
     170                 :         19 :   reader->byte = pos;
     171                 :            : 
     172                 :         19 :   return TRUE;
     173                 :            : }
     174                 :            : 
     175                 :            : /**
     176                 :            :  * gst_byte_reader_get_pos:
     177                 :            :  * @reader: a #GstByteReader instance
     178                 :            :  *
     179                 :            :  * Returns the current position of a #GstByteReader instance in bytes.
     180                 :            :  *
     181                 :            :  * Returns: The current position of @reader in bytes.
     182                 :            :  * 
     183                 :            :  * Since: 0.10.22
     184                 :            :  */
     185                 :            : guint
     186                 :          0 : gst_byte_reader_get_pos (const GstByteReader * reader)
     187                 :            : {
     188                 :          0 :   return _gst_byte_reader_get_pos_inline (reader);
     189                 :            : }
     190                 :            : 
     191                 :            : /**
     192                 :            :  * gst_byte_reader_get_remaining:
     193                 :            :  * @reader: a #GstByteReader instance
     194                 :            :  *
     195                 :            :  * Returns the remaining number of bytes of a #GstByteReader instance.
     196                 :            :  *
     197                 :            :  * Returns: The remaining number of bytes of @reader instance.
     198                 :            :  * 
     199                 :            :  * Since: 0.10.22
     200                 :            :  */
     201                 :            : guint
     202                 :          0 : gst_byte_reader_get_remaining (const GstByteReader * reader)
     203                 :            : {
     204                 :          0 :   return _gst_byte_reader_get_remaining_inline (reader);
     205                 :            : }
     206                 :            : 
     207                 :            : /**
     208                 :            :  * gst_byte_reader_get_size:
     209                 :            :  * @reader: a #GstByteReader instance
     210                 :            :  *
     211                 :            :  * Returns the total number of bytes of a #GstByteReader instance.
     212                 :            :  *
     213                 :            :  * Returns: The total number of bytes of @reader instance.
     214                 :            :  * 
     215                 :            :  * Since: 0.10.26
     216                 :            :  */
     217                 :            : guint
     218                 :          0 : gst_byte_reader_get_size (const GstByteReader * reader)
     219                 :            : {
     220                 :          0 :   return _gst_byte_reader_get_size_inline (reader);
     221                 :            : }
     222                 :            : 
     223                 :            : #define gst_byte_reader_get_remaining _gst_byte_reader_get_remaining_inline
     224                 :            : #define gst_byte_reader_get_size _gst_byte_reader_get_size_inline
     225                 :            : 
     226                 :            : /**
     227                 :            :  * gst_byte_reader_skip:
     228                 :            :  * @reader: a #GstByteReader instance
     229                 :            :  * @nbytes: the number of bytes to skip
     230                 :            :  *
     231                 :            :  * Skips @nbytes bytes of the #GstByteReader instance.
     232                 :            :  *
     233                 :            :  * Returns: %TRUE if @nbytes bytes could be skipped, %FALSE otherwise.
     234                 :            :  * 
     235                 :            :  * Since: 0.10.22
     236                 :            :  */
     237                 :            : gboolean
     238                 :          0 : gst_byte_reader_skip (GstByteReader * reader, guint nbytes)
     239                 :            : {
     240                 :          0 :   return _gst_byte_reader_skip_inline (reader, nbytes);
     241                 :            : }
     242                 :            : 
     243                 :            : /**
     244                 :            :  * gst_byte_reader_get_uint8:
     245                 :            :  * @reader: a #GstByteReader instance
     246                 :            :  * @val: Pointer to a #guint8 to store the result
     247                 :            :  *
     248                 :            :  * Read an unsigned 8 bit integer into @val and update the current position.
     249                 :            :  *
     250                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     251                 :            :  * 
     252                 :            :  * Since: 0.10.22
     253                 :            :  */
     254                 :            : 
     255                 :            : /**
     256                 :            :  * gst_byte_reader_get_int8:
     257                 :            :  * @reader: a #GstByteReader instance
     258                 :            :  * @val: Pointer to a #gint8 to store the result
     259                 :            :  *
     260                 :            :  * Read a signed 8 bit integer into @val and update the current position.
     261                 :            :  *
     262                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     263                 :            :  * 
     264                 :            :  * Since: 0.10.22
     265                 :            :  */
     266                 :            : 
     267                 :            : /**
     268                 :            :  * gst_byte_reader_peek_uint8:
     269                 :            :  * @reader: a #GstByteReader instance
     270                 :            :  * @val: Pointer to a #guint8 to store the result
     271                 :            :  *
     272                 :            :  * Read an unsigned 8 bit integer into @val but keep the current position.
     273                 :            :  *
     274                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     275                 :            :  * 
     276                 :            :  * Since: 0.10.22
     277                 :            :  */
     278                 :            : 
     279                 :            : /**
     280                 :            :  * gst_byte_reader_peek_int8:
     281                 :            :  * @reader: a #GstByteReader instance
     282                 :            :  * @val: Pointer to a #gint8 to store the result
     283                 :            :  *
     284                 :            :  * Read a signed 8 bit integer into @val but keep the current position.
     285                 :            :  *
     286                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     287                 :            :  * 
     288                 :            :  * Since: 0.10.22
     289                 :            :  */
     290                 :            : 
     291                 :            : /**
     292                 :            :  * gst_byte_reader_get_uint16_le:
     293                 :            :  * @reader: a #GstByteReader instance
     294                 :            :  * @val: Pointer to a #guint16 to store the result
     295                 :            :  *
     296                 :            :  * Read an unsigned 16 bit little endian integer into @val
     297                 :            :  * and update the current position.
     298                 :            :  *
     299                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     300                 :            :  * 
     301                 :            :  * Since: 0.10.22
     302                 :            :  */
     303                 :            : 
     304                 :            : /**
     305                 :            :  * gst_byte_reader_get_int16_le:
     306                 :            :  * @reader: a #GstByteReader instance
     307                 :            :  * @val: Pointer to a #gint16 to store the result
     308                 :            :  *
     309                 :            :  * Read a signed 16 bit little endian integer into @val
     310                 :            :  * and update the current position.
     311                 :            :  *
     312                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     313                 :            :  * 
     314                 :            :  * Since: 0.10.22
     315                 :            :  */
     316                 :            : 
     317                 :            : /**
     318                 :            :  * gst_byte_reader_peek_uint16_le:
     319                 :            :  * @reader: a #GstByteReader instance
     320                 :            :  * @val: Pointer to a #guint16 to store the result
     321                 :            :  *
     322                 :            :  * Read an unsigned 16 bit little endian integer into @val
     323                 :            :  * but keep the current position.
     324                 :            :  *
     325                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     326                 :            :  * 
     327                 :            :  * Since: 0.10.22
     328                 :            :  */
     329                 :            : 
     330                 :            : /**
     331                 :            :  * gst_byte_reader_peek_int16_le:
     332                 :            :  * @reader: a #GstByteReader instance
     333                 :            :  * @val: Pointer to a #gint16 to store the result
     334                 :            :  *
     335                 :            :  * Read a signed 16 bit little endian integer into @val
     336                 :            :  * but keep the current position.
     337                 :            :  *
     338                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     339                 :            :  * 
     340                 :            :  * Since: 0.10.22
     341                 :            :  */
     342                 :            : 
     343                 :            : /**
     344                 :            :  * gst_byte_reader_get_uint16_be:
     345                 :            :  * @reader: a #GstByteReader instance
     346                 :            :  * @val: Pointer to a #guint16 to store the result
     347                 :            :  *
     348                 :            :  * Read an unsigned 16 bit big endian integer into @val
     349                 :            :  * and update the current position.
     350                 :            :  *
     351                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     352                 :            :  * 
     353                 :            :  * Since: 0.10.22
     354                 :            :  */
     355                 :            : 
     356                 :            : /**
     357                 :            :  * gst_byte_reader_get_int16_be:
     358                 :            :  * @reader: a #GstByteReader instance
     359                 :            :  * @val: Pointer to a #gint16 to store the result
     360                 :            :  *
     361                 :            :  * Read a signed 16 bit big endian integer into @val
     362                 :            :  * and update the current position.
     363                 :            :  *
     364                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     365                 :            :  * 
     366                 :            :  * Since: 0.10.22
     367                 :            :  */
     368                 :            : 
     369                 :            : /**
     370                 :            :  * gst_byte_reader_peek_uint16_be:
     371                 :            :  * @reader: a #GstByteReader instance
     372                 :            :  * @val: Pointer to a #guint16 to store the result
     373                 :            :  *
     374                 :            :  * Read an unsigned 16 bit big endian integer into @val
     375                 :            :  * but keep the current position.
     376                 :            :  *
     377                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     378                 :            :  * 
     379                 :            :  * Since: 0.10.22
     380                 :            :  */
     381                 :            : 
     382                 :            : /**
     383                 :            :  * gst_byte_reader_peek_int16_be:
     384                 :            :  * @reader: a #GstByteReader instance
     385                 :            :  * @val: Pointer to a #gint16 to store the result
     386                 :            :  *
     387                 :            :  * Read a signed 16 bit big endian integer into @val
     388                 :            :  * but keep the current position.
     389                 :            :  *
     390                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     391                 :            :  * 
     392                 :            :  * Since: 0.10.22
     393                 :            :  */
     394                 :            : 
     395                 :            : /**
     396                 :            :  * gst_byte_reader_get_uint24_le:
     397                 :            :  * @reader: a #GstByteReader instance
     398                 :            :  * @val: Pointer to a #guint32 to store the result
     399                 :            :  *
     400                 :            :  * Read an unsigned 24 bit little endian integer into @val
     401                 :            :  * and update the current position.
     402                 :            :  *
     403                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     404                 :            :  * 
     405                 :            :  * Since: 0.10.22
     406                 :            :  */
     407                 :            : 
     408                 :            : /**
     409                 :            :  * gst_byte_reader_get_int24_le:
     410                 :            :  * @reader: a #GstByteReader instance
     411                 :            :  * @val: Pointer to a #gint32 to store the result
     412                 :            :  *
     413                 :            :  * Read a signed 24 bit little endian integer into @val
     414                 :            :  * and update the current position.
     415                 :            :  *
     416                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     417                 :            :  * 
     418                 :            :  * Since: 0.10.22
     419                 :            :  */
     420                 :            : 
     421                 :            : /**
     422                 :            :  * gst_byte_reader_peek_uint24_le:
     423                 :            :  * @reader: a #GstByteReader instance
     424                 :            :  * @val: Pointer to a #guint32 to store the result
     425                 :            :  *
     426                 :            :  * Read an unsigned 24 bit little endian integer into @val
     427                 :            :  * but keep the current position.
     428                 :            :  *
     429                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     430                 :            :  * 
     431                 :            :  * Since: 0.10.22
     432                 :            :  */
     433                 :            : 
     434                 :            : /**
     435                 :            :  * gst_byte_reader_peek_int24_le:
     436                 :            :  * @reader: a #GstByteReader instance
     437                 :            :  * @val: Pointer to a #gint32 to store the result
     438                 :            :  *
     439                 :            :  * Read a signed 24 bit little endian integer into @val
     440                 :            :  * but keep the current position.
     441                 :            :  *
     442                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     443                 :            :  * 
     444                 :            :  * Since: 0.10.22
     445                 :            :  */
     446                 :            : 
     447                 :            : /**
     448                 :            :  * gst_byte_reader_get_uint24_be:
     449                 :            :  * @reader: a #GstByteReader instance
     450                 :            :  * @val: Pointer to a #guint32 to store the result
     451                 :            :  *
     452                 :            :  * Read an unsigned 24 bit big endian integer into @val
     453                 :            :  * and update the current position.
     454                 :            :  *
     455                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     456                 :            :  * 
     457                 :            :  * Since: 0.10.22
     458                 :            :  */
     459                 :            : 
     460                 :            : /**
     461                 :            :  * gst_byte_reader_get_int24_be:
     462                 :            :  * @reader: a #GstByteReader instance
     463                 :            :  * @val: Pointer to a #gint32 to store the result
     464                 :            :  *
     465                 :            :  * Read a signed 24 bit big endian integer into @val
     466                 :            :  * and update the current position.
     467                 :            :  *
     468                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     469                 :            :  * 
     470                 :            :  * Since: 0.10.22
     471                 :            :  */
     472                 :            : 
     473                 :            : /**
     474                 :            :  * gst_byte_reader_peek_uint24_be:
     475                 :            :  * @reader: a #GstByteReader instance
     476                 :            :  * @val: Pointer to a #guint32 to store the result
     477                 :            :  *
     478                 :            :  * Read an unsigned 24 bit big endian integer into @val
     479                 :            :  * but keep the current position.
     480                 :            :  *
     481                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     482                 :            :  * 
     483                 :            :  * Since: 0.10.22
     484                 :            :  */
     485                 :            : 
     486                 :            : /**
     487                 :            :  * gst_byte_reader_peek_int24_be:
     488                 :            :  * @reader: a #GstByteReader instance
     489                 :            :  * @val: Pointer to a #gint32 to store the result
     490                 :            :  *
     491                 :            :  * Read a signed 24 bit big endian integer into @val
     492                 :            :  * but keep the current position.
     493                 :            :  *
     494                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     495                 :            :  * 
     496                 :            :  * Since: 0.10.22
     497                 :            :  */
     498                 :            : 
     499                 :            : 
     500                 :            : /**
     501                 :            :  * gst_byte_reader_get_uint32_le:
     502                 :            :  * @reader: a #GstByteReader instance
     503                 :            :  * @val: Pointer to a #guint32 to store the result
     504                 :            :  *
     505                 :            :  * Read an unsigned 32 bit little endian integer into @val
     506                 :            :  * and update the current position.
     507                 :            :  *
     508                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     509                 :            :  * 
     510                 :            :  * Since: 0.10.22
     511                 :            :  */
     512                 :            : 
     513                 :            : /**
     514                 :            :  * gst_byte_reader_get_int32_le:
     515                 :            :  * @reader: a #GstByteReader instance
     516                 :            :  * @val: Pointer to a #gint32 to store the result
     517                 :            :  *
     518                 :            :  * Read a signed 32 bit little endian integer into @val
     519                 :            :  * and update the current position.
     520                 :            :  *
     521                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     522                 :            :  * 
     523                 :            :  * Since: 0.10.22
     524                 :            :  */
     525                 :            : 
     526                 :            : /**
     527                 :            :  * gst_byte_reader_peek_uint32_le:
     528                 :            :  * @reader: a #GstByteReader instance
     529                 :            :  * @val: Pointer to a #guint32 to store the result
     530                 :            :  *
     531                 :            :  * Read an unsigned 32 bit little endian integer into @val
     532                 :            :  * but keep the current position.
     533                 :            :  *
     534                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     535                 :            :  * 
     536                 :            :  * Since: 0.10.22
     537                 :            :  */
     538                 :            : 
     539                 :            : /**
     540                 :            :  * gst_byte_reader_peek_int32_le:
     541                 :            :  * @reader: a #GstByteReader instance
     542                 :            :  * @val: Pointer to a #gint32 to store the result
     543                 :            :  *
     544                 :            :  * Read a signed 32 bit little endian integer into @val
     545                 :            :  * but keep the current position.
     546                 :            :  *
     547                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     548                 :            :  * 
     549                 :            :  * Since: 0.10.22
     550                 :            :  */
     551                 :            : 
     552                 :            : /**
     553                 :            :  * gst_byte_reader_get_uint32_be:
     554                 :            :  * @reader: a #GstByteReader instance
     555                 :            :  * @val: Pointer to a #guint32 to store the result
     556                 :            :  *
     557                 :            :  * Read an unsigned 32 bit big endian integer into @val
     558                 :            :  * and update the current position.
     559                 :            :  *
     560                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     561                 :            :  * 
     562                 :            :  * Since: 0.10.22
     563                 :            :  */
     564                 :            : 
     565                 :            : /**
     566                 :            :  * gst_byte_reader_get_int32_be:
     567                 :            :  * @reader: a #GstByteReader instance
     568                 :            :  * @val: Pointer to a #gint32 to store the result
     569                 :            :  *
     570                 :            :  * Read a signed 32 bit big endian integer into @val
     571                 :            :  * and update the current position.
     572                 :            :  *
     573                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     574                 :            :  * 
     575                 :            :  * Since: 0.10.22
     576                 :            :  */
     577                 :            : 
     578                 :            : /**
     579                 :            :  * gst_byte_reader_peek_uint32_be:
     580                 :            :  * @reader: a #GstByteReader instance
     581                 :            :  * @val: Pointer to a #guint32 to store the result
     582                 :            :  *
     583                 :            :  * Read an unsigned 32 bit big endian integer into @val
     584                 :            :  * but keep the current position.
     585                 :            :  *
     586                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     587                 :            :  * 
     588                 :            :  * Since: 0.10.22
     589                 :            :  */
     590                 :            : 
     591                 :            : /**
     592                 :            :  * gst_byte_reader_peek_int32_be:
     593                 :            :  * @reader: a #GstByteReader instance
     594                 :            :  * @val: Pointer to a #gint32 to store the result
     595                 :            :  *
     596                 :            :  * Read a signed 32 bit big endian integer into @val
     597                 :            :  * but keep the current position.
     598                 :            :  *
     599                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     600                 :            :  * 
     601                 :            :  * Since: 0.10.22
     602                 :            :  */
     603                 :            : 
     604                 :            : /**
     605                 :            :  * gst_byte_reader_get_uint64_le:
     606                 :            :  * @reader: a #GstByteReader instance
     607                 :            :  * @val: Pointer to a #guint64 to store the result
     608                 :            :  *
     609                 :            :  * Read an unsigned 64 bit little endian integer into @val
     610                 :            :  * and update the current position.
     611                 :            :  *
     612                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     613                 :            :  * 
     614                 :            :  * Since: 0.10.22
     615                 :            :  */
     616                 :            : 
     617                 :            : /**
     618                 :            :  * gst_byte_reader_get_int64_le:
     619                 :            :  * @reader: a #GstByteReader instance
     620                 :            :  * @val: Pointer to a #gint64 to store the result
     621                 :            :  *
     622                 :            :  * Read a signed 64 bit little endian integer into @val
     623                 :            :  * and update the current position.
     624                 :            :  *
     625                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     626                 :            :  * 
     627                 :            :  * Since: 0.10.22
     628                 :            :  */
     629                 :            : 
     630                 :            : /**
     631                 :            :  * gst_byte_reader_peek_uint64_le:
     632                 :            :  * @reader: a #GstByteReader instance
     633                 :            :  * @val: Pointer to a #guint64 to store the result
     634                 :            :  *
     635                 :            :  * Read an unsigned 64 bit little endian integer into @val
     636                 :            :  * but keep the current position.
     637                 :            :  *
     638                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     639                 :            :  * 
     640                 :            :  * Since: 0.10.22
     641                 :            :  */
     642                 :            : 
     643                 :            : /**
     644                 :            :  * gst_byte_reader_peek_int64_le:
     645                 :            :  * @reader: a #GstByteReader instance
     646                 :            :  * @val: Pointer to a #gint64 to store the result
     647                 :            :  *
     648                 :            :  * Read a signed 64 bit little endian integer into @val
     649                 :            :  * but keep the current position.
     650                 :            :  *
     651                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     652                 :            :  * 
     653                 :            :  * Since: 0.10.22
     654                 :            :  */
     655                 :            : 
     656                 :            : /**
     657                 :            :  * gst_byte_reader_get_uint64_be:
     658                 :            :  * @reader: a #GstByteReader instance
     659                 :            :  * @val: Pointer to a #guint64 to store the result
     660                 :            :  *
     661                 :            :  * Read an unsigned 64 bit big endian integer into @val
     662                 :            :  * and update the current position.
     663                 :            :  *
     664                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     665                 :            :  * 
     666                 :            :  * Since: 0.10.22
     667                 :            :  */
     668                 :            : 
     669                 :            : /**
     670                 :            :  * gst_byte_reader_get_int64_be:
     671                 :            :  * @reader: a #GstByteReader instance
     672                 :            :  * @val: Pointer to a #gint64 to store the result
     673                 :            :  *
     674                 :            :  * Read a signed 64 bit big endian integer into @val
     675                 :            :  * and update the current position.
     676                 :            :  *
     677                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     678                 :            :  * 
     679                 :            :  * Since: 0.10.22
     680                 :            :  */
     681                 :            : 
     682                 :            : /**
     683                 :            :  * gst_byte_reader_peek_uint64_be:
     684                 :            :  * @reader: a #GstByteReader instance
     685                 :            :  * @val: Pointer to a #guint64 to store the result
     686                 :            :  *
     687                 :            :  * Read an unsigned 64 bit big endian integer into @val
     688                 :            :  * but keep the current position.
     689                 :            :  *
     690                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     691                 :            :  * 
     692                 :            :  * Since: 0.10.22
     693                 :            :  */
     694                 :            : 
     695                 :            : /**
     696                 :            :  * gst_byte_reader_peek_int64_be:
     697                 :            :  * @reader: a #GstByteReader instance
     698                 :            :  * @val: Pointer to a #gint64 to store the result
     699                 :            :  *
     700                 :            :  * Read a signed 64 bit big endian integer into @val
     701                 :            :  * but keep the current position.
     702                 :            :  *
     703                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     704                 :            :  * 
     705                 :            :  * Since: 0.10.22
     706                 :            :  */
     707                 :            : 
     708                 :            : #define GST_BYTE_READER_PEEK_GET(bits,type,name) \
     709                 :            : gboolean \
     710                 :            : gst_byte_reader_get_##name (GstByteReader * reader, type * val) \
     711                 :            : { \
     712                 :            :   return _gst_byte_reader_get_##name##_inline (reader, val); \
     713                 :            : } \
     714                 :            : \
     715                 :            : gboolean \
     716                 :            : gst_byte_reader_peek_##name (const GstByteReader * reader, type * val) \
     717                 :            : { \
     718                 :            :   return _gst_byte_reader_peek_##name##_inline (reader, val); \
     719                 :            : }
     720                 :            : 
     721                 :            : /* *INDENT-OFF* */
     722                 :            : 
     723                 :          0 : GST_BYTE_READER_PEEK_GET(8,guint8,uint8)
     724                 :          0 : GST_BYTE_READER_PEEK_GET(8,gint8,int8)
     725                 :            : 
     726                 :          0 : GST_BYTE_READER_PEEK_GET(16,guint16,uint16_le)
     727                 :          0 : GST_BYTE_READER_PEEK_GET(16,guint16,uint16_be)
     728                 :          0 : GST_BYTE_READER_PEEK_GET(16,gint16,int16_le)
     729                 :          0 : GST_BYTE_READER_PEEK_GET(16,gint16,int16_be)
     730                 :            : 
     731                 :          0 : GST_BYTE_READER_PEEK_GET(24,guint32,uint24_le)
     732                 :          0 : GST_BYTE_READER_PEEK_GET(24,guint32,uint24_be)
     733                 :          0 : GST_BYTE_READER_PEEK_GET(24,gint32,int24_le)
     734                 :          0 : GST_BYTE_READER_PEEK_GET(24,gint32,int24_be)
     735                 :            : 
     736                 :          0 : GST_BYTE_READER_PEEK_GET(32,guint32,uint32_le)
     737                 :          0 : GST_BYTE_READER_PEEK_GET(32,guint32,uint32_be)
     738                 :          0 : GST_BYTE_READER_PEEK_GET(32,gint32,int32_le)
     739                 :          0 : GST_BYTE_READER_PEEK_GET(32,gint32,int32_be)
     740                 :            : 
     741                 :          0 : GST_BYTE_READER_PEEK_GET(64,guint64,uint64_le)
     742                 :          0 : GST_BYTE_READER_PEEK_GET(64,guint64,uint64_be)
     743                 :          0 : GST_BYTE_READER_PEEK_GET(64,gint64,int64_le)
     744                 :          0 : GST_BYTE_READER_PEEK_GET(64,gint64,int64_be)
     745                 :            : 
     746                 :            : /**
     747                 :            :  * gst_byte_reader_get_float32_le:
     748                 :            :  * @reader: a #GstByteReader instance
     749                 :            :  * @val: Pointer to a #gfloat to store the result
     750                 :            :  *
     751                 :            :  * Read a 32 bit little endian floating point value into @val
     752                 :            :  * and update the current position.
     753                 :            :  *
     754                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     755                 :            :  * 
     756                 :            :  * Since: 0.10.22
     757                 :            :  */
     758                 :            : 
     759                 :            : /**
     760                 :            :  * gst_byte_reader_peek_float32_le:
     761                 :            :  * @reader: a #GstByteReader instance
     762                 :            :  * @val: Pointer to a #gfloat to store the result
     763                 :            :  *
     764                 :            :  * Read a 32 bit little endian floating point value into @val
     765                 :            :  * but keep the current position.
     766                 :            :  *
     767                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     768                 :            :  * 
     769                 :            :  * Since: 0.10.22
     770                 :            :  */
     771                 :            : 
     772                 :            : /**
     773                 :            :  * gst_byte_reader_get_float32_be:
     774                 :            :  * @reader: a #GstByteReader instance
     775                 :            :  * @val: Pointer to a #gfloat to store the result
     776                 :            :  *
     777                 :            :  * Read a 32 bit big endian floating point value into @val
     778                 :            :  * and update the current position.
     779                 :            :  *
     780                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     781                 :            :  * 
     782                 :            :  * Since: 0.10.22
     783                 :            :  */
     784                 :            : 
     785                 :            : /**
     786                 :            :  * gst_byte_reader_peek_float32_be:
     787                 :            :  * @reader: a #GstByteReader instance
     788                 :            :  * @val: Pointer to a #gfloat to store the result
     789                 :            :  *
     790                 :            :  * Read a 32 bit big endian floating point value into @val
     791                 :            :  * but keep the current position.
     792                 :            :  *
     793                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     794                 :            :  * 
     795                 :            :  * Since: 0.10.22
     796                 :            :  */
     797                 :            : 
     798                 :            : /**
     799                 :            :  * gst_byte_reader_get_float64_le:
     800                 :            :  * @reader: a #GstByteReader instance
     801                 :            :  * @val: Pointer to a #gdouble to store the result
     802                 :            :  *
     803                 :            :  * Read a 64 bit little endian floating point value into @val
     804                 :            :  * and update the current position.
     805                 :            :  *
     806                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     807                 :            :  * 
     808                 :            :  * Since: 0.10.22
     809                 :            :  */
     810                 :            : 
     811                 :            : /**
     812                 :            :  * gst_byte_reader_peek_float64_le:
     813                 :            :  * @reader: a #GstByteReader instance
     814                 :            :  * @val: Pointer to a #gdouble to store the result
     815                 :            :  *
     816                 :            :  * Read a 64 bit little endian floating point value into @val
     817                 :            :  * but keep the current position.
     818                 :            :  *
     819                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     820                 :            :  * 
     821                 :            :  * Since: 0.10.22
     822                 :            :  */
     823                 :            : 
     824                 :            : /**
     825                 :            :  * gst_byte_reader_get_float64_be:
     826                 :            :  * @reader: a #GstByteReader instance
     827                 :            :  * @val: Pointer to a #gdouble to store the result
     828                 :            :  *
     829                 :            :  * Read a 64 bit big endian floating point value into @val
     830                 :            :  * and update the current position.
     831                 :            :  *
     832                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     833                 :            :  * 
     834                 :            :  * Since: 0.10.22
     835                 :            :  */
     836                 :            : 
     837                 :            : /**
     838                 :            :  * gst_byte_reader_peek_float64_be:
     839                 :            :  * @reader: a #GstByteReader instance
     840                 :            :  * @val: Pointer to a #gdouble to store the result
     841                 :            :  *
     842                 :            :  * Read a 64 bit big endian floating point value into @val
     843                 :            :  * but keep the current position.
     844                 :            :  *
     845                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     846                 :            :  * 
     847                 :            :  * Since: 0.10.22
     848                 :            :  */
     849                 :            : 
     850                 :          0 : GST_BYTE_READER_PEEK_GET(32,gfloat,float32_le)
     851                 :          0 : GST_BYTE_READER_PEEK_GET(32,gfloat,float32_be)
     852                 :          0 : GST_BYTE_READER_PEEK_GET(64,gdouble,float64_le)
     853                 :          0 : GST_BYTE_READER_PEEK_GET(64,gdouble,float64_be)
     854                 :            : 
     855                 :            : /* *INDENT-ON* */
     856                 :            : 
     857                 :            : /**
     858                 :            :  * gst_byte_reader_get_data:
     859                 :            :  * @reader: a #GstByteReader instance
     860                 :            :  * @size: Size in bytes
     861                 :            :  * @val: (out) (transfer none) (array length=size): address of a
     862                 :            :  *     #guint8 pointer variable in which to store the result
     863                 :            :  *
     864                 :            :  * Returns a constant pointer to the current data
     865                 :            :  * position if at least @size bytes are left and
     866                 :            :  * updates the current position.
     867                 :            :  *
     868                 :            :  *
     869                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     870                 :            :  * 
     871                 :            :  * Since: 0.10.22
     872                 :            :  */
     873                 :            : gboolean
     874                 :          0 : gst_byte_reader_get_data (GstByteReader * reader, guint size,
     875                 :            :     const guint8 ** val)
     876                 :            : {
     877                 :          0 :   return _gst_byte_reader_get_data_inline (reader, size, val);
     878                 :            : }
     879                 :            : 
     880                 :            : /**
     881                 :            :  * gst_byte_reader_peek_data:
     882                 :            :  * @reader: a #GstByteReader instance
     883                 :            :  * @size: Size in bytes
     884                 :            :  * @val: (out) (transfer none) (array length=size): address of a
     885                 :            :  *     #guint8 pointer variable in which to store the result
     886                 :            :  *
     887                 :            :  * Returns a constant pointer to the current data
     888                 :            :  * position if at least @size bytes are left and
     889                 :            :  * keeps the current position.
     890                 :            :  *
     891                 :            :  *
     892                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     893                 :            :  * 
     894                 :            :  * Since: 0.10.22
     895                 :            :  */
     896                 :            : gboolean
     897                 :          0 : gst_byte_reader_peek_data (const GstByteReader * reader, guint size,
     898                 :            :     const guint8 ** val)
     899                 :            : {
     900                 :          0 :   return _gst_byte_reader_peek_data_inline (reader, size, val);
     901                 :            : }
     902                 :            : 
     903                 :            : /**
     904                 :            :  * gst_byte_reader_dup_data:
     905                 :            :  * @reader: a #GstByteReader instance
     906                 :            :  * @size: Size in bytes
     907                 :            :  * @val: (out) (transfer full) (array length=size): address of a
     908                 :            :  *     #guint8 pointer variable in which to store the result
     909                 :            :  *
     910                 :            :  * Free-function: g_free
     911                 :            :  *
     912                 :            :  * Returns a newly-allocated copy of the current data
     913                 :            :  * position if at least @size bytes are left and
     914                 :            :  * updates the current position. Free with g_free() when no longer needed.
     915                 :            :  *
     916                 :            :  * Returns: %TRUE if successful, %FALSE otherwise.
     917                 :            :  *
     918                 :            :  * Since: 0.10.24
     919                 :            :  */
     920                 :            : gboolean
     921                 :          0 : gst_byte_reader_dup_data (GstByteReader * reader, guint size, guint8 ** val)
     922                 :            : {
     923                 :          0 :   return _gst_byte_reader_dup_data_inline (reader, size, val);
     924                 :            : }
     925                 :            : 
     926                 :            : /**
     927                 :            :  * gst_byte_reader_masked_scan_uint32:
     928                 :            :  * @reader: a #GstByteReader
     929                 :            :  * @mask: mask to apply to data before matching against @pattern
     930                 :            :  * @pattern: pattern to match (after mask is applied)
     931                 :            :  * @offset: offset from which to start scanning, relative to the current
     932                 :            :  *     position
     933                 :            :  * @size: number of bytes to scan from offset
     934                 :            :  *
     935                 :            :  * Scan for pattern @pattern with applied mask @mask in the byte reader data,
     936                 :            :  * starting from offset @offset relative to the current position.
     937                 :            :  *
     938                 :            :  * The bytes in @pattern and @mask are interpreted left-to-right, regardless
     939                 :            :  * of endianness.  All four bytes of the pattern must be present in the
     940                 :            :  * byte reader data for it to match, even if the first or last bytes are masked
     941                 :            :  * out.
     942                 :            :  *
     943                 :            :  * It is an error to call this function without making sure that there is
     944                 :            :  * enough data (offset+size bytes) in the byte reader.
     945                 :            :  *
     946                 :            :  * Returns: offset of the first match, or -1 if no match was found.
     947                 :            :  *
     948                 :            :  * Example:
     949                 :            :  * <programlisting>
     950                 :            :  * // Assume the reader contains 0x00 0x01 0x02 ... 0xfe 0xff
     951                 :            :  *
     952                 :            :  * gst_byte_reader_masked_scan_uint32 (reader, 0xffffffff, 0x00010203, 0, 256);
     953                 :            :  * // -> returns 0
     954                 :            :  * gst_byte_reader_masked_scan_uint32 (reader, 0xffffffff, 0x00010203, 1, 255);
     955                 :            :  * // -> returns -1
     956                 :            :  * gst_byte_reader_masked_scan_uint32 (reader, 0xffffffff, 0x01020304, 1, 255);
     957                 :            :  * // -> returns 1
     958                 :            :  * gst_byte_reader_masked_scan_uint32 (reader, 0xffff, 0x0001, 0, 256);
     959                 :            :  * // -> returns -1
     960                 :            :  * gst_byte_reader_masked_scan_uint32 (reader, 0xffff, 0x0203, 0, 256);
     961                 :            :  * // -> returns 0
     962                 :            :  * gst_byte_reader_masked_scan_uint32 (reader, 0xffff0000, 0x02030000, 0, 256);
     963                 :            :  * // -> returns 2
     964                 :            :  * gst_byte_reader_masked_scan_uint32 (reader, 0xffff0000, 0x02030000, 0, 4);
     965                 :            :  * // -> returns -1
     966                 :            :  * </programlisting>
     967                 :            :  *
     968                 :            :  * Since: 0.10.24
     969                 :            :  */
     970                 :            : guint
     971                 :         42 : gst_byte_reader_masked_scan_uint32 (const GstByteReader * reader, guint32 mask,
     972                 :            :     guint32 pattern, guint offset, guint size)
     973                 :            : {
     974                 :            :   const guint8 *data;
     975                 :            :   guint32 state;
     976                 :            :   guint i;
     977                 :            : 
     978         [ -  + ]:         42 :   g_return_val_if_fail (size > 0, -1);
     979         [ -  + ]:         42 :   g_return_val_if_fail ((guint64) offset + size <= reader->size - reader->byte,
     980                 :            :       -1);
     981                 :            : 
     982                 :            :   /* we can't find the pattern with less than 4 bytes */
     983         [ +  + ]:         42 :   if (G_UNLIKELY (size < 4))
     984                 :          3 :     return -1;
     985                 :            : 
     986                 :         39 :   data = reader->data + reader->byte + offset;
     987                 :            : 
     988                 :            :   /* set the state to something that does not match */
     989                 :         39 :   state = ~pattern;
     990                 :            : 
     991                 :            :   /* now find data */
     992         [ +  + ]:       1990 :   for (i = 0; i < size; i++) {
     993                 :            :     /* throw away one byte and move in the next byte */
     994                 :       1976 :     state = ((state << 8) | data[i]);
     995         [ +  + ]:       1976 :     if (G_UNLIKELY ((state & mask) == pattern)) {
     996                 :            :       /* we have a match but we need to have skipped at
     997                 :            :        * least 4 bytes to fill the state. */
     998         [ +  + ]:         27 :       if (G_LIKELY (i >= 3))
     999                 :         25 :         return offset + i - 3;
    1000                 :            :     }
    1001                 :            :   }
    1002                 :            : 
    1003                 :            :   /* nothing found */
    1004                 :         42 :   return -1;
    1005                 :            : }
    1006                 :            : 
    1007                 :            : #define GST_BYTE_READER_SCAN_STRING(bits) \
    1008                 :            : static guint \
    1009                 :            : gst_byte_reader_scan_string_utf##bits (const GstByteReader * reader) \
    1010                 :            : { \
    1011                 :            :   guint len, off, max_len; \
    1012                 :            :   \
    1013                 :            :   max_len = (reader->size - reader->byte) / sizeof (guint##bits); \
    1014                 :            :   \
    1015                 :            :   /* need at least a single NUL terminator */ \
    1016                 :            :   if (max_len < 1) \
    1017                 :            :     return 0; \
    1018                 :            :   \
    1019                 :            :   len = 0; \
    1020                 :            :   off = reader->byte; \
    1021                 :            :   /* endianness does not matter if we are looking for a NUL terminator */ \
    1022                 :            :   while (GST_READ_UINT##bits##_LE (&reader->data[off]) != 0) { \
    1023                 :            :     ++len; \
    1024                 :            :     off += sizeof (guint##bits); \
    1025                 :            :     /* have we reached the end without finding a NUL terminator? */ \
    1026                 :            :     if (len == max_len) \
    1027                 :            :       return 0; \
    1028                 :            :   } \
    1029                 :            :   /* return size in bytes including the NUL terminator (hence the +1) */ \
    1030                 :            :   return (len + 1) * sizeof (guint##bits); \
    1031                 :            : }
    1032                 :            : 
    1033                 :            : #define GST_READ_UINT8_LE GST_READ_UINT8
    1034 [ -  + ][ +  + ]:       1773 : GST_BYTE_READER_SCAN_STRING (8);
                 [ +  + ]
    1035                 :            : #undef GST_READ_UINT8_LE
    1036 [ -  + ][ +  + ]:        455 : GST_BYTE_READER_SCAN_STRING (16);
                 [ +  + ]
    1037 [ -  + ][ +  + ]:        271 : GST_BYTE_READER_SCAN_STRING (32);
                 [ +  + ]
    1038                 :            : 
    1039                 :            : #define GST_BYTE_READER_SKIP_STRING(bits) \
    1040                 :            : gboolean \
    1041                 :            : gst_byte_reader_skip_string_utf##bits (GstByteReader * reader) \
    1042                 :            : { \
    1043                 :            :   guint size; /* size in bytes including the terminator */ \
    1044                 :            :   \
    1045                 :            :   g_return_val_if_fail (reader != NULL, FALSE); \
    1046                 :            :   \
    1047                 :            :   size = gst_byte_reader_scan_string_utf##bits (reader); \
    1048                 :            :   reader->byte += size; \
    1049                 :            :   return (size > 0); \
    1050                 :            : }
    1051                 :            : 
    1052                 :            : /**
    1053                 :            :  * gst_byte_reader_skip_string:
    1054                 :            :  * @reader: a #GstByteReader instance
    1055                 :            :  *
    1056                 :            :  * Skips a NUL-terminated string in the #GstByteReader instance, advancing
    1057                 :            :  * the current position to the byte after the string. This will work for
    1058                 :            :  * any NUL-terminated string with a character width of 8 bits, so ASCII,
    1059                 :            :  * UTF-8, ISO-8859-N etc.
    1060                 :            :  *
    1061                 :            :  * This function will fail if no NUL-terminator was found in in the data.
    1062                 :            :  *
    1063                 :            :  * Returns: %TRUE if a string could be skipped, %FALSE otherwise.
    1064                 :            :  *
    1065                 :            :  * Since: 0.10.24
    1066                 :            :  */
    1067                 :            : /**
    1068                 :            :  * gst_byte_reader_skip_string_utf8:
    1069                 :            :  * @reader: a #GstByteReader instance
    1070                 :            :  *
    1071                 :            :  * Skips a NUL-terminated string in the #GstByteReader instance, advancing
    1072                 :            :  * the current position to the byte after the string. This will work for
    1073                 :            :  * any NUL-terminated string with a character width of 8 bits, so ASCII,
    1074                 :            :  * UTF-8, ISO-8859-N etc. No input checking for valid UTF-8 is done.
    1075                 :            :  *
    1076                 :            :  * This function will fail if no NUL-terminator was found in in the data.
    1077                 :            :  *
    1078                 :            :  * Returns: %TRUE if a string could be skipped, %FALSE otherwise.
    1079                 :            :  *
    1080                 :            :  * Since: 0.10.24
    1081                 :            :  */
    1082         [ -  + ]:          8 : GST_BYTE_READER_SKIP_STRING (8);
    1083                 :            : 
    1084                 :            : /**
    1085                 :            :  * gst_byte_reader_skip_string_utf16:
    1086                 :            :  * @reader: a #GstByteReader instance
    1087                 :            :  *
    1088                 :            :  * Skips a NUL-terminated UTF-16 string in the #GstByteReader instance,
    1089                 :            :  * advancing the current position to the byte after the string.
    1090                 :            :  *
    1091                 :            :  * No input checking for valid UTF-16 is done.
    1092                 :            :  *
    1093                 :            :  * This function will fail if no NUL-terminator was found in in the data.
    1094                 :            :  *
    1095                 :            :  * Returns: %TRUE if a string could be skipped, %FALSE otherwise.
    1096                 :            :  *
    1097                 :            :  * Since: 0.10.24
    1098                 :            :  */
    1099         [ -  + ]:          5 : GST_BYTE_READER_SKIP_STRING (16);
    1100                 :            : 
    1101                 :            : /**
    1102                 :            :  * gst_byte_reader_skip_string_utf32:
    1103                 :            :  * @reader: a #GstByteReader instance
    1104                 :            :  *
    1105                 :            :  * Skips a NUL-terminated UTF-32 string in the #GstByteReader instance,
    1106                 :            :  * advancing the current position to the byte after the string.
    1107                 :            :  *
    1108                 :            :  * No input checking for valid UTF-32 is done.
    1109                 :            :  *
    1110                 :            :  * This function will fail if no NUL-terminator was found in in the data.
    1111                 :            :  *
    1112                 :            :  * Returns: %TRUE if a string could be skipped, %FALSE otherwise.
    1113                 :            :  *
    1114                 :            :  * Since: 0.10.24
    1115                 :            :  */
    1116         [ -  + ]:          5 : GST_BYTE_READER_SKIP_STRING (32);
    1117                 :            : 
    1118                 :            : /**
    1119                 :            :  * gst_byte_reader_peek_string:
    1120                 :            :  * @reader: a #GstByteReader instance
    1121                 :            :  * @str: (out) (transfer none) (array zero-terminated=1): address of a
    1122                 :            :  *     #gchar pointer varieble in which to store the result
    1123                 :            :  *
    1124                 :            :  * Returns a constant pointer to the current data position if there is
    1125                 :            :  * a NUL-terminated string in the data (this could be just a NUL terminator).
    1126                 :            :  * The current position will be maintained. This will work for any
    1127                 :            :  * NUL-terminated string with a character width of 8 bits, so ASCII,
    1128                 :            :  * UTF-8, ISO-8859-N etc.
    1129                 :            :  *
    1130                 :            :  * This function will fail if no NUL-terminator was found in in the data.
    1131                 :            :  *
    1132                 :            :  * Returns: %TRUE if a string could be skipped, %FALSE otherwise.
    1133                 :            :  *
    1134                 :            :  * Since: 0.10.24
    1135                 :            :  */
    1136                 :            : /**
    1137                 :            :  * gst_byte_reader_peek_string_utf8:
    1138                 :            :  * @reader: a #GstByteReader instance
    1139                 :            :  * @str: (out) (transfer none) (array zero-terminated=1): address of a
    1140                 :            :  *     #gchar pointer varieble in which to store the result
    1141                 :            :  *
    1142                 :            :  * Returns a constant pointer to the current data position if there is
    1143                 :            :  * a NUL-terminated string in the data (this could be just a NUL terminator).
    1144                 :            :  * The current position will be maintained. This will work for any
    1145                 :            :  * NUL-terminated string with a character width of 8 bits, so ASCII,
    1146                 :            :  * UTF-8, ISO-8859-N etc.
    1147                 :            :  *
    1148                 :            :  * No input checking for valid UTF-8 is done.
    1149                 :            :  *
    1150                 :            :  * This function will fail if no NUL-terminator was found in in the data.
    1151                 :            :  *
    1152                 :            :  * Returns: %TRUE if a string could be skipped, %FALSE otherwise.
    1153                 :            :  *
    1154                 :            :  * Since: 0.10.24
    1155                 :            :  */
    1156                 :            : gboolean
    1157                 :          8 : gst_byte_reader_peek_string_utf8 (const GstByteReader * reader,
    1158                 :            :     const gchar ** str)
    1159                 :            : {
    1160         [ -  + ]:          8 :   g_return_val_if_fail (reader != NULL, FALSE);
    1161         [ -  + ]:          8 :   g_return_val_if_fail (str != NULL, FALSE);
    1162                 :            : 
    1163         [ +  + ]:          8 :   if (gst_byte_reader_scan_string_utf8 (reader) > 0) {
    1164                 :          6 :     *str = (const gchar *) (reader->data + reader->byte);
    1165                 :            :   } else {
    1166                 :          2 :     *str = NULL;
    1167                 :            :   }
    1168                 :          8 :   return (*str != NULL);
    1169                 :            : }
    1170                 :            : 
    1171                 :            : /**
    1172                 :            :  * gst_byte_reader_get_string_utf8:
    1173                 :            :  * @reader: a #GstByteReader instance
    1174                 :            :  * @str: (out) (transfer none) (array zero-terminated=1): address of a
    1175                 :            :  *     #gchar pointer varieble in which to store the result
    1176                 :            :  *
    1177                 :            :  * Returns a constant pointer to the current data position if there is
    1178                 :            :  * a NUL-terminated string in the data (this could be just a NUL terminator),
    1179                 :            :  * advancing the current position to the byte after the string. This will work
    1180                 :            :  * for any NUL-terminated string with a character width of 8 bits, so ASCII,
    1181                 :            :  * UTF-8, ISO-8859-N etc.
    1182                 :            :  *
    1183                 :            :  * No input checking for valid UTF-8 is done.
    1184                 :            :  *
    1185                 :            :  * This function will fail if no NUL-terminator was found in in the data.
    1186                 :            :  *
    1187                 :            :  * Returns: %TRUE if a string could be found, %FALSE otherwise.
    1188                 :            :  *
    1189                 :            :  * Since: 0.10.24
    1190                 :            :  */
    1191                 :            : gboolean
    1192                 :          2 : gst_byte_reader_get_string_utf8 (GstByteReader * reader, const gchar ** str)
    1193                 :            : {
    1194                 :            :   guint size;                   /* size in bytes including the terminator */
    1195                 :            : 
    1196         [ -  + ]:          2 :   g_return_val_if_fail (reader != NULL, FALSE);
    1197         [ -  + ]:          2 :   g_return_val_if_fail (str != NULL, FALSE);
    1198                 :            : 
    1199                 :          2 :   size = gst_byte_reader_scan_string_utf8 (reader);
    1200         [ +  - ]:          2 :   if (size == 0) {
    1201                 :          2 :     *str = NULL;
    1202                 :          2 :     return FALSE;
    1203                 :            :   }
    1204                 :            : 
    1205                 :          0 :   *str = (const gchar *) (reader->data + reader->byte);
    1206                 :          0 :   reader->byte += size;
    1207                 :          2 :   return TRUE;
    1208                 :            : }
    1209                 :            : 
    1210                 :            : #define GST_BYTE_READER_DUP_STRING(bits,type) \
    1211                 :            : gboolean \
    1212                 :            : gst_byte_reader_dup_string_utf##bits (GstByteReader * reader, type ** str) \
    1213                 :            : { \
    1214                 :            :   guint size; /* size in bytes including the terminator */ \
    1215                 :            :   \
    1216                 :            :   g_return_val_if_fail (reader != NULL, FALSE); \
    1217                 :            :   g_return_val_if_fail (str != NULL, FALSE); \
    1218                 :            :   \
    1219                 :            :   size = gst_byte_reader_scan_string_utf##bits (reader); \
    1220                 :            :   if (size == 0) { \
    1221                 :            :     *str = NULL; \
    1222                 :            :     return FALSE; \
    1223                 :            :   } \
    1224                 :            :   *str = g_memdup (reader->data + reader->byte, size); \
    1225                 :            :   reader->byte += size; \
    1226                 :            :   return TRUE; \
    1227                 :            : }
    1228                 :            : 
    1229                 :            : /**
    1230                 :            :  * gst_byte_reader_dup_string_utf8:
    1231                 :            :  * @reader: a #GstByteReader instance
    1232                 :            :  * @str: (out) (transfer full) (array zero-terminated=1): address of a
    1233                 :            :  *     #gchar pointer varieble in which to store the result
    1234                 :            :  *
    1235                 :            :  * Free-function: g_free
    1236                 :            :  *
    1237                 :            :  * FIXME:Reads (copies) a NUL-terminated string in the #GstByteReader instance,
    1238                 :            :  * advancing the current position to the byte after the string. This will work
    1239                 :            :  * for any NUL-terminated string with a character width of 8 bits, so ASCII,
    1240                 :            :  * UTF-8, ISO-8859-N etc. No input checking for valid UTF-8 is done.
    1241                 :            :  *
    1242                 :            :  * This function will fail if no NUL-terminator was found in in the data.
    1243                 :            :  *
    1244                 :            :  * Returns: %TRUE if a string could be read into @str, %FALSE otherwise. The
    1245                 :            :  *     string put into @str must be freed with g_free() when no longer needed.
    1246                 :            :  *
    1247                 :            :  * Since: 0.10.24
    1248                 :            :  */
    1249 [ -  + ][ -  + ]:          3 : GST_BYTE_READER_DUP_STRING (8, gchar);
                 [ +  + ]
    1250                 :            : 
    1251                 :            : /**
    1252                 :            :  * gst_byte_reader_dup_string_utf16:
    1253                 :            :  * @reader: a #GstByteReader instance
    1254                 :            :  * @str: (out) (transfer full) (array zero-terminated=1): address of a
    1255                 :            :  *     #guint16 pointer varieble in which to store the result
    1256                 :            :  *
    1257                 :            :  * Free-function: g_free
    1258                 :            :  *
    1259                 :            :  * Returns a newly-allocated copy of the current data position if there is
    1260                 :            :  * a NUL-terminated UTF-16 string in the data (this could be an empty string
    1261                 :            :  * as well), and advances the current position.
    1262                 :            :  *
    1263                 :            :  * No input checking for valid UTF-16 is done. This function is endianness
    1264                 :            :  * agnostic - you should not assume the UTF-16 characters are in host
    1265                 :            :  * endianness.
    1266                 :            :  *
    1267                 :            :  * This function will fail if no NUL-terminator was found in in the data.
    1268                 :            :  *
    1269                 :            :  * Note: there is no peek or get variant of this function to ensure correct
    1270                 :            :  * byte alignment of the UTF-16 string.
    1271                 :            :  *
    1272                 :            :  * Returns: %TRUE if a string could be read, %FALSE otherwise. The
    1273                 :            :  *     string put into @str must be freed with g_free() when no longer needed.
    1274                 :            :  *
    1275                 :            :  * Since: 0.10.24
    1276                 :            :  */
    1277 [ -  + ][ -  + ]:          5 : GST_BYTE_READER_DUP_STRING (16, guint16);
                 [ +  + ]
    1278                 :            : 
    1279                 :            : /**
    1280                 :            :  * gst_byte_reader_dup_string_utf32:
    1281                 :            :  * @reader: a #GstByteReader instance
    1282                 :            :  * @str: (out) (transfer full) (array zero-terminated=1): address of a
    1283                 :            :  *     #guint32 pointer varieble in which to store the result
    1284                 :            :  *
    1285                 :            :  * Free-function: g_free
    1286                 :            :  *
    1287                 :            :  * Returns a newly-allocated copy of the current data position if there is
    1288                 :            :  * a NUL-terminated UTF-32 string in the data (this could be an empty string
    1289                 :            :  * as well), and advances the current position.
    1290                 :            :  *
    1291                 :            :  * No input checking for valid UTF-32 is done. This function is endianness
    1292                 :            :  * agnostic - you should not assume the UTF-32 characters are in host
    1293                 :            :  * endianness.
    1294                 :            :  *
    1295                 :            :  * This function will fail if no NUL-terminator was found in in the data.
    1296                 :            :  *
    1297                 :            :  * Note: there is no peek or get variant of this function to ensure correct
    1298                 :            :  * byte alignment of the UTF-32 string.
    1299                 :            :  *
    1300                 :            :  * Returns: %TRUE if a string could be read, %FALSE otherwise. The
    1301                 :            :  *     string put into @str must be freed with g_free() when no longer needed.
    1302                 :            :  *
    1303                 :            :  * Since: 0.10.24
    1304                 :            :  */
    1305 [ -  + ][ -  + ]:          6 : GST_BYTE_READER_DUP_STRING (32, guint32);
                 [ +  + ]

Generated by: LCOV version 1.9