"Fossies" - the Fresh Open Source Software Archive

Member "gstreamer-1.16.1/libs/gst/base/gstbytewriter.h" (19 Apr 2019, 16345 Bytes) of package /linux/misc/gstreamer-1.16.1.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "gstbytewriter.h" see the Fossies "Dox" file reference documentation.

    1 /* GStreamer byte writer
    2  *
    3  * Copyright (C) 2009 Sebastian Dröge <sebastian.droege@collabora.co.uk>.
    4  *
    5  * This library is free software; you can redistribute it and/or
    6  * modify it under the terms of the GNU Library General Public
    7  * License as published by the Free Software Foundation; either
    8  * version 2 of the License, or (at your option) any later version.
    9  *
   10  * This library is distributed in the hope that it will be useful,
   11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
   12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   13  * Library General Public License for more details.
   14  *
   15  * You should have received a copy of the GNU Library General Public
   16  * License along with this library; if not, write to the
   17  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
   18  * Boston, MA 02110-1301, USA.
   19  */
   20 
   21 #ifndef __GST_BYTE_WRITER_H__
   22 #define __GST_BYTE_WRITER_H__
   23 
   24 #include <gst/gst.h>
   25 #include <gst/base/gstbytereader.h>
   26 
   27 #include <string.h>
   28 
   29 G_BEGIN_DECLS
   30 
   31 #define GST_BYTE_WRITER(writer) ((GstByteWriter *) (writer))
   32 
   33 /**
   34  * GstByteWriter:
   35  * @parent: #GstByteReader parent
   36  * @alloc_size: Allocation size of the data
   37  * @fixed: If %TRUE no reallocations are allowed
   38  * @owned: If %FALSE no reallocations are allowed and copies of data are returned
   39  *
   40  * A byte writer instance.
   41  */
   42 typedef struct {
   43   GstByteReader parent;
   44 
   45   guint alloc_size;
   46 
   47   gboolean fixed;
   48   gboolean owned;
   49 
   50   /* < private > */
   51   gpointer _gst_reserved[GST_PADDING];
   52 } GstByteWriter;
   53 
   54 GST_BASE_API
   55 GstByteWriter * gst_byte_writer_new             (void) G_GNUC_MALLOC;
   56 
   57 GST_BASE_API
   58 GstByteWriter * gst_byte_writer_new_with_size   (guint size, gboolean fixed) G_GNUC_MALLOC;
   59 
   60 GST_BASE_API
   61 GstByteWriter * gst_byte_writer_new_with_data   (guint8 *data, guint size, gboolean initialized) G_GNUC_MALLOC;
   62 
   63 GST_BASE_API
   64 void            gst_byte_writer_init            (GstByteWriter *writer);
   65 
   66 GST_BASE_API
   67 void            gst_byte_writer_init_with_size  (GstByteWriter *writer, guint size, gboolean fixed);
   68 
   69 GST_BASE_API
   70 void            gst_byte_writer_init_with_data  (GstByteWriter *writer, guint8 *data,
   71                                                  guint size, gboolean initialized);
   72 GST_BASE_API
   73 void            gst_byte_writer_free                    (GstByteWriter *writer);
   74 
   75 GST_BASE_API
   76 guint8 *        gst_byte_writer_free_and_get_data       (GstByteWriter *writer);
   77 
   78 GST_BASE_API
   79 GstBuffer *     gst_byte_writer_free_and_get_buffer     (GstByteWriter *writer) G_GNUC_MALLOC;
   80 
   81 GST_BASE_API
   82 void            gst_byte_writer_reset                   (GstByteWriter *writer);
   83 
   84 GST_BASE_API
   85 guint8 *        gst_byte_writer_reset_and_get_data      (GstByteWriter *writer);
   86 
   87 GST_BASE_API
   88 GstBuffer *     gst_byte_writer_reset_and_get_buffer    (GstByteWriter *writer) G_GNUC_MALLOC;
   89 
   90 /**
   91  * gst_byte_writer_get_pos:
   92  * @writer: #GstByteWriter instance
   93  *
   94  * Returns: The current position of the read/write cursor
   95  */
   96 /**
   97  * gst_byte_writer_set_pos:
   98  * @writer: #GstByteWriter instance
   99  * @pos: new position
  100  *
  101  * Sets the current read/write cursor of @writer. The new position
  102  * can only be between 0 and the current size.
  103  *
  104  * Returns: %TRUE if the new position could be set
  105  */
  106 /**
  107  * gst_byte_writer_get_size:
  108  * @writer: #GstByteWriter instance
  109  *
  110  * Returns: The current, initialized size of the data
  111  */
  112 static inline guint
  113 gst_byte_writer_get_pos (const GstByteWriter *writer)
  114 {
  115   return gst_byte_reader_get_pos ((const GstByteReader *) writer);
  116 }
  117 
  118 static inline gboolean
  119 gst_byte_writer_set_pos (GstByteWriter *writer, guint pos)
  120 {
  121   return gst_byte_reader_set_pos (GST_BYTE_READER (writer), pos);
  122 }
  123 
  124 static inline guint
  125 gst_byte_writer_get_size (const GstByteWriter *writer)
  126 {
  127   return gst_byte_reader_get_size ((const GstByteReader *) writer);
  128 }
  129 
  130 GST_BASE_API
  131 guint           gst_byte_writer_get_remaining     (const GstByteWriter *writer);
  132 
  133 GST_BASE_API
  134 gboolean        gst_byte_writer_ensure_free_space (GstByteWriter *writer, guint size);
  135 
  136 GST_BASE_API
  137 gboolean        gst_byte_writer_put_uint8         (GstByteWriter *writer, guint8 val);
  138 
  139 GST_BASE_API
  140 gboolean        gst_byte_writer_put_int8          (GstByteWriter *writer, gint8 val);
  141 
  142 GST_BASE_API
  143 gboolean        gst_byte_writer_put_uint16_be     (GstByteWriter *writer, guint16 val);
  144 
  145 GST_BASE_API
  146 gboolean        gst_byte_writer_put_uint16_le     (GstByteWriter *writer, guint16 val);
  147 
  148 GST_BASE_API
  149 gboolean        gst_byte_writer_put_int16_be      (GstByteWriter *writer, gint16 val);
  150 
  151 GST_BASE_API
  152 gboolean        gst_byte_writer_put_int16_le      (GstByteWriter *writer, gint16 val);
  153 
  154 GST_BASE_API
  155 gboolean        gst_byte_writer_put_uint24_be     (GstByteWriter *writer, guint32 val);
  156 
  157 GST_BASE_API
  158 gboolean        gst_byte_writer_put_uint24_le     (GstByteWriter *writer, guint32 val);
  159 
  160 GST_BASE_API
  161 gboolean        gst_byte_writer_put_int24_be      (GstByteWriter *writer, gint32 val);
  162 
  163 GST_BASE_API
  164 gboolean        gst_byte_writer_put_int24_le      (GstByteWriter *writer, gint32 val);
  165 
  166 GST_BASE_API
  167 gboolean        gst_byte_writer_put_uint32_be     (GstByteWriter *writer, guint32 val);
  168 
  169 GST_BASE_API
  170 gboolean        gst_byte_writer_put_uint32_le     (GstByteWriter *writer, guint32 val);
  171 
  172 GST_BASE_API
  173 gboolean        gst_byte_writer_put_int32_be      (GstByteWriter *writer, gint32 val);
  174 
  175 GST_BASE_API
  176 gboolean        gst_byte_writer_put_int32_le      (GstByteWriter *writer, gint32 val);
  177 
  178 GST_BASE_API
  179 gboolean        gst_byte_writer_put_uint64_be     (GstByteWriter *writer, guint64 val);
  180 
  181 GST_BASE_API
  182 gboolean        gst_byte_writer_put_uint64_le     (GstByteWriter *writer, guint64 val);
  183 
  184 GST_BASE_API
  185 gboolean        gst_byte_writer_put_int64_be      (GstByteWriter *writer, gint64 val);
  186 
  187 GST_BASE_API
  188 gboolean        gst_byte_writer_put_int64_le      (GstByteWriter *writer, gint64 val);
  189 
  190 GST_BASE_API
  191 gboolean        gst_byte_writer_put_float32_be    (GstByteWriter *writer, gfloat val);
  192 
  193 GST_BASE_API
  194 gboolean        gst_byte_writer_put_float32_le    (GstByteWriter *writer, gfloat val);
  195 
  196 GST_BASE_API
  197 gboolean        gst_byte_writer_put_float64_be    (GstByteWriter *writer, gdouble val);
  198 
  199 GST_BASE_API
  200 gboolean        gst_byte_writer_put_float64_le    (GstByteWriter *writer, gdouble val);
  201 
  202 GST_BASE_API
  203 gboolean        gst_byte_writer_put_data          (GstByteWriter *writer, const guint8 *data, guint size);
  204 
  205 GST_BASE_API
  206 gboolean        gst_byte_writer_fill              (GstByteWriter *writer, guint8 value, guint size);
  207 
  208 GST_BASE_API
  209 gboolean        gst_byte_writer_put_string_utf8   (GstByteWriter *writer, const gchar *data);
  210 
  211 GST_BASE_API
  212 gboolean        gst_byte_writer_put_string_utf16  (GstByteWriter *writer, const guint16 *data);
  213 
  214 GST_BASE_API
  215 gboolean        gst_byte_writer_put_string_utf32  (GstByteWriter *writer, const guint32 *data);
  216 gboolean        gst_byte_writer_put_buffer        (GstByteWriter *writer, GstBuffer * buffer, gsize offset, gssize size);
  217 
  218 /**
  219  * gst_byte_writer_put_string:
  220  * @writer: #GstByteWriter instance
  221  * @data: (in) (array zero-terminated=1): Null terminated string
  222  *
  223  * Write a NUL-terminated string to @writer (including the terminator). The
  224  * string is assumed to be in an 8-bit encoding (e.g. ASCII,UTF-8 or
  225  * ISO-8859-1).
  226  *
  227  * Returns: %TRUE if the string could be written
  228  */
  229 #define gst_byte_writer_put_string(writer, data) \
  230   gst_byte_writer_put_string_utf8(writer, data)
  231 
  232 static inline guint
  233 _gst_byte_writer_next_pow2 (guint n)
  234 {
  235   guint ret = 16;
  236 
  237   /* We start with 16, smaller allocations make no sense */
  238 
  239   while (ret < n && ret > 0)
  240     ret <<= 1;
  241 
  242   return ret ? ret : n;
  243 }
  244 
  245 static inline gboolean
  246 _gst_byte_writer_ensure_free_space_inline (GstByteWriter * writer, guint size)
  247 {
  248   gpointer data;
  249 
  250   if (G_LIKELY (size <= writer->alloc_size - writer->parent.byte))
  251     return TRUE;
  252   if (G_UNLIKELY (writer->fixed || !writer->owned))
  253     return FALSE;
  254   if (G_UNLIKELY (writer->parent.byte > G_MAXUINT - size))
  255     return FALSE;
  256 
  257   writer->alloc_size = _gst_byte_writer_next_pow2 (writer->parent.byte + size);
  258   data = g_try_realloc ((guint8 *) writer->parent.data, writer->alloc_size);
  259   if (G_UNLIKELY (data == NULL))
  260     return FALSE;
  261 
  262   writer->parent.data = (guint8 *) data;
  263 
  264   return TRUE;
  265 }
  266 
  267 #define __GST_BYTE_WRITER_CREATE_WRITE_FUNC(bits,type,name,write_func) \
  268 static inline void \
  269 gst_byte_writer_put_##name##_unchecked (GstByteWriter *writer, type val) \
  270 { \
  271   guint8 *write_data; \
  272   \
  273   write_data = (guint8 *) writer->parent.data + writer->parent.byte; \
  274   write_func (write_data, val); \
  275   writer->parent.byte += bits/8; \
  276   writer->parent.size = MAX (writer->parent.size, writer->parent.byte); \
  277 } \
  278 \
  279 static inline gboolean \
  280 _gst_byte_writer_put_##name##_inline (GstByteWriter *writer, type val) \
  281 { \
  282   g_return_val_if_fail (writer != NULL, FALSE); \
  283   \
  284   if (G_UNLIKELY (!_gst_byte_writer_ensure_free_space_inline(writer, bits/8))) \
  285     return FALSE; \
  286   \
  287   gst_byte_writer_put_##name##_unchecked (writer, val); \
  288   \
  289   return TRUE; \
  290 }
  291 
  292 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (8, guint8, uint8, GST_WRITE_UINT8)
  293 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (8, gint8, int8, GST_WRITE_UINT8)
  294 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (16, guint16, uint16_le, GST_WRITE_UINT16_LE)
  295 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (16, guint16, uint16_be, GST_WRITE_UINT16_BE)
  296 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (16, gint16, int16_le, GST_WRITE_UINT16_LE)
  297 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (16, gint16, int16_be, GST_WRITE_UINT16_BE)
  298 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (24, guint32, uint24_le, GST_WRITE_UINT24_LE)
  299 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (24, guint32, uint24_be, GST_WRITE_UINT24_BE)
  300 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (24, gint32, int24_le, GST_WRITE_UINT24_LE)
  301 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (24, gint32, int24_be, GST_WRITE_UINT24_BE)
  302 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (32, guint32, uint32_le, GST_WRITE_UINT32_LE)
  303 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (32, guint32, uint32_be, GST_WRITE_UINT32_BE)
  304 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (32, gint32, int32_le, GST_WRITE_UINT32_LE)
  305 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (32, gint32, int32_be, GST_WRITE_UINT32_BE)
  306 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (64, guint64, uint64_le, GST_WRITE_UINT64_LE)
  307 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (64, guint64, uint64_be, GST_WRITE_UINT64_BE)
  308 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (64, gint64, int64_le, GST_WRITE_UINT64_LE)
  309 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (64, gint64, int64_be, GST_WRITE_UINT64_BE)
  310 
  311 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (32, gfloat, float32_be, GST_WRITE_FLOAT_BE)
  312 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (32, gfloat, float32_le, GST_WRITE_FLOAT_LE)
  313 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (64, gdouble, float64_be, GST_WRITE_DOUBLE_BE)
  314 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (64, gdouble, float64_le, GST_WRITE_DOUBLE_LE)
  315 
  316 #undef __GST_BYTE_WRITER_CREATE_WRITE_FUNC
  317 
  318 static inline void
  319 gst_byte_writer_put_data_unchecked (GstByteWriter * writer, const guint8 * data,
  320     guint size)
  321 {
  322   memcpy ((guint8 *) & writer->parent.data[writer->parent.byte], data, size);
  323   writer->parent.byte += size;
  324   writer->parent.size = MAX (writer->parent.size, writer->parent.byte);
  325 }
  326 
  327 static inline gboolean
  328 _gst_byte_writer_put_data_inline (GstByteWriter * writer, const guint8 * data,
  329     guint size)
  330 {
  331   g_return_val_if_fail (writer != NULL, FALSE);
  332 
  333   if (G_UNLIKELY (!_gst_byte_writer_ensure_free_space_inline (writer, size)))
  334     return FALSE;
  335 
  336   gst_byte_writer_put_data_unchecked (writer, data, size);
  337 
  338   return TRUE;
  339 }
  340 
  341 static inline void
  342 gst_byte_writer_fill_unchecked (GstByteWriter * writer, guint8 value, guint size)
  343 {
  344   memset ((guint8 *) & writer->parent.data[writer->parent.byte], value, size);
  345   writer->parent.byte += size;
  346   writer->parent.size = MAX (writer->parent.size, writer->parent.byte);
  347 }
  348 
  349 static inline gboolean
  350 _gst_byte_writer_fill_inline (GstByteWriter * writer, guint8 value, guint size)
  351 {
  352   g_return_val_if_fail (writer != NULL, FALSE);
  353 
  354   if (G_UNLIKELY (!_gst_byte_writer_ensure_free_space_inline (writer, size)))
  355     return FALSE;
  356 
  357   gst_byte_writer_fill_unchecked (writer, value, size);
  358 
  359   return TRUE;
  360 }
  361 
  362 static inline void
  363 gst_byte_writer_put_buffer_unchecked (GstByteWriter * writer, GstBuffer * buffer,
  364     gsize offset, gssize size)
  365 {
  366   if (size == -1) {
  367     size = gst_buffer_get_size (buffer);
  368 
  369     if (offset >= (gsize) size)
  370       return;
  371 
  372     size -= offset;
  373   }
  374 
  375   gst_buffer_extract (buffer, offset,
  376       (guint8 *) & writer->parent.data[writer->parent.byte], size);
  377   writer->parent.byte += size;
  378   writer->parent.size = MAX (writer->parent.size, writer->parent.byte);
  379 }
  380 
  381 static inline gboolean
  382 _gst_byte_writer_put_buffer_inline (GstByteWriter * writer, GstBuffer * buffer,
  383     gsize offset, gssize size)
  384 {
  385   g_return_val_if_fail (writer != NULL, FALSE);
  386   g_return_val_if_fail (size >= -1, FALSE);
  387 
  388   if (size == -1) {
  389     size = gst_buffer_get_size (buffer);
  390 
  391     if (offset >= (gsize) size)
  392       return TRUE;
  393 
  394     size -= offset;
  395   }
  396 
  397   if (G_UNLIKELY (!_gst_byte_writer_ensure_free_space_inline (writer, size)))
  398     return FALSE;
  399 
  400   gst_byte_writer_put_buffer_unchecked (writer, buffer, offset, size);
  401 
  402   return TRUE;
  403 }
  404 
  405 #ifndef GST_BYTE_WRITER_DISABLE_INLINES
  406 
  407 /* we use defines here so we can add the G_LIKELY() */
  408 
  409 #define gst_byte_writer_ensure_free_space(writer, size) \
  410     G_LIKELY (_gst_byte_writer_ensure_free_space_inline (writer, size))
  411 #define gst_byte_writer_put_uint8(writer, val) \
  412     G_LIKELY (_gst_byte_writer_put_uint8_inline (writer, val))
  413 #define gst_byte_writer_put_int8(writer, val) \
  414     G_LIKELY (_gst_byte_writer_put_int8_inline (writer, val))
  415 #define gst_byte_writer_put_uint16_be(writer, val) \
  416     G_LIKELY (_gst_byte_writer_put_uint16_be_inline (writer, val))
  417 #define gst_byte_writer_put_uint16_le(writer, val) \
  418     G_LIKELY (_gst_byte_writer_put_uint16_le_inline (writer, val))
  419 #define gst_byte_writer_put_int16_be(writer, val) \
  420     G_LIKELY (_gst_byte_writer_put_int16_be_inline (writer, val))
  421 #define gst_byte_writer_put_int16_le(writer, val) \
  422     G_LIKELY (_gst_byte_writer_put_int16_le_inline (writer, val))
  423 #define gst_byte_writer_put_uint24_be(writer, val) \
  424     G_LIKELY (_gst_byte_writer_put_uint24_be_inline (writer, val))
  425 #define gst_byte_writer_put_uint24_le(writer, val) \
  426     G_LIKELY (_gst_byte_writer_put_uint24_le_inline (writer, val))
  427 #define gst_byte_writer_put_int24_be(writer, val) \
  428     G_LIKELY (_gst_byte_writer_put_int24_be_inline (writer, val))
  429 #define gst_byte_writer_put_int24_le(writer, val) \
  430     G_LIKELY (_gst_byte_writer_put_int24_le_inline (writer, val))
  431 #define gst_byte_writer_put_uint32_be(writer, val) \
  432     G_LIKELY (_gst_byte_writer_put_uint32_be_inline (writer, val))
  433 #define gst_byte_writer_put_uint32_le(writer, val) \
  434     G_LIKELY (_gst_byte_writer_put_uint32_le_inline (writer, val))
  435 #define gst_byte_writer_put_int32_be(writer, val) \
  436     G_LIKELY (_gst_byte_writer_put_int32_be_inline (writer, val))
  437 #define gst_byte_writer_put_int32_le(writer, val) \
  438     G_LIKELY (_gst_byte_writer_put_int32_le_inline (writer, val))
  439 #define gst_byte_writer_put_uint64_be(writer, val) \
  440     G_LIKELY (_gst_byte_writer_put_uint64_be_inline (writer, val))
  441 #define gst_byte_writer_put_uint64_le(writer, val) \
  442     G_LIKELY (_gst_byte_writer_put_uint64_le_inline (writer, val))
  443 #define gst_byte_writer_put_int64_be(writer, val) \
  444     G_LIKELY (_gst_byte_writer_put_int64_be_inline (writer, val))
  445 #define gst_byte_writer_put_int64_le(writer, val) \
  446     G_LIKELY (_gst_byte_writer_put_int64_le_inline (writer, val))
  447 
  448 #define gst_byte_writer_put_float32_be(writer, val) \
  449     G_LIKELY (_gst_byte_writer_put_float32_be_inline (writer, val))
  450 #define gst_byte_writer_put_float32_le(writer, val) \
  451     G_LIKELY (_gst_byte_writer_put_float32_le_inline (writer, val))
  452 #define gst_byte_writer_put_float64_be(writer, val) \
  453     G_LIKELY (_gst_byte_writer_put_float64_be_inline (writer, val))
  454 #define gst_byte_writer_put_float64_le(writer, val) \
  455     G_LIKELY (_gst_byte_writer_put_float64_le_inline (writer, val))
  456 
  457 #define gst_byte_writer_put_data(writer, data, size) \
  458     G_LIKELY (_gst_byte_writer_put_data_inline (writer, data, size))
  459 #define gst_byte_writer_fill(writer, val, size) \
  460     G_LIKELY (_gst_byte_writer_fill_inline (writer, val, size))
  461 #define gst_byte_writer_put_buffer(writer, buffer, offset, size) \
  462     G_LIKELY (_gst_byte_writer_put_buffer_inline (writer, buffer, offset, size))
  463 
  464 #endif
  465 
  466 G_END_DECLS
  467 
  468 #endif /* __GST_BYTE_WRITER_H__ */