libs/gst/base/gstbytewriter.h

   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., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, 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 GstByteWriter * gst_byte_writer_new             (void) G_GNUC_MALLOC;
  55 GstByteWriter * gst_byte_writer_new_with_size   (guint size, gboolean fixed) G_GNUC_MALLOC;
  56 GstByteWriter * gst_byte_writer_new_with_data   (guint8 *data, guint size, gboolean initialized) G_GNUC_MALLOC;
  57
  58 void            gst_byte_writer_init            (GstByteWriter *writer);
  59 void            gst_byte_writer_init_with_size  (GstByteWriter *writer, guint size, gboolean fixed);
  60 void            gst_byte_writer_init_with_data  (GstByteWriter *writer, guint8 *data,
  61                                                  guint size, gboolean initialized);
  62
  63 void            gst_byte_writer_free                    (GstByteWriter *writer);
  64 guint8 *        gst_byte_writer_free_and_get_data       (GstByteWriter *writer);
  65 GstBuffer *     gst_byte_writer_free_and_get_buffer     (GstByteWriter *writer) G_GNUC_MALLOC;
  66
  67 void            gst_byte_writer_reset                   (GstByteWriter *writer);
  68 guint8 *        gst_byte_writer_reset_and_get_data      (GstByteWriter *writer);
  69 GstBuffer *     gst_byte_writer_reset_and_get_buffer    (GstByteWriter *writer) G_GNUC_MALLOC;
  70
  71 /**
  72  * gst_byte_writer_get_pos:
  73  * @writer: #GstByteWriter instance
  74  *
  75  * Returns: The current position of the read/write cursor
  76  *
  77  * Since: 0.10.26
  78  */
  79 /**
  80  * gst_byte_writer_set_pos:
  81  * @writer: #GstByteWriter instance
  82  * @pos: new position
  83  *
  84  * Sets the current read/write cursor of @writer. The new position
  85  * can only be between 0 and the current size.
  86  *
  87  * Returns: %TRUE if the new position could be set
  88  *
  89  * Since: 0.10.26
  90  */
  91 /**
  92  * gst_byte_writer_get_size:
  93  * @writer: #GstByteWriter instance
  94  *
  95  * Returns: The current, initialized size of the data
  96  *
  97  * Since: 0.10.26
  98  */
  99 #ifdef _FOOL_GTK_DOC_
 100 G_INLINE_FUNC guint     gst_byte_writer_get_pos  (const GstByteWriter *writer);
 101 G_INLINE_FUNC gboolean  gst_byte_writer_set_pos  (GstByteWriter *writer, guint pos);
 102 G_INLINE_FUNC guint     gst_byte_writer_get_size (const GstByteWriter *writer);
 103 #else
 104 static inline guint
 105 gst_byte_writer_get_pos (const GstByteWriter *writer)
 106 {
 107   return gst_byte_reader_get_pos ((const GstByteReader *) writer);
 108 }
 109
 110 static inline gboolean
 111 gst_byte_writer_set_pos (GstByteWriter *writer, guint pos)
 112 {
 113   return gst_byte_reader_set_pos (GST_BYTE_READER (writer), pos);
 114 }
 115
 116 static inline guint
 117 gst_byte_writer_get_size (const GstByteWriter *writer)
 118 {
 119   return gst_byte_reader_get_size ((const GstByteReader *) writer);
 120 }
 121 #endif
 122
 123 guint           gst_byte_writer_get_remaining     (const GstByteWriter *writer);
 124 gboolean        gst_byte_writer_ensure_free_space (GstByteWriter *writer, guint size);
 125
 126 gboolean        gst_byte_writer_put_uint8         (GstByteWriter *writer, guint8 val);
 127 gboolean        gst_byte_writer_put_int8          (GstByteWriter *writer, gint8 val);
 128 gboolean        gst_byte_writer_put_uint16_be     (GstByteWriter *writer, guint16 val);
 129 gboolean        gst_byte_writer_put_uint16_le     (GstByteWriter *writer, guint16 val);
 130 gboolean        gst_byte_writer_put_int16_be      (GstByteWriter *writer, gint16 val);
 131 gboolean        gst_byte_writer_put_int16_le      (GstByteWriter *writer, gint16 val);
 132 gboolean        gst_byte_writer_put_uint24_be     (GstByteWriter *writer, guint32 val);
 133 gboolean        gst_byte_writer_put_uint24_le     (GstByteWriter *writer, guint32 val);
 134 gboolean        gst_byte_writer_put_int24_be      (GstByteWriter *writer, gint32 val);
 135 gboolean        gst_byte_writer_put_int24_le      (GstByteWriter *writer, gint32 val);
 136 gboolean        gst_byte_writer_put_uint32_be     (GstByteWriter *writer, guint32 val);
 137 gboolean        gst_byte_writer_put_uint32_le     (GstByteWriter *writer, guint32 val);
 138 gboolean        gst_byte_writer_put_int32_be      (GstByteWriter *writer, gint32 val);
 139 gboolean        gst_byte_writer_put_int32_le      (GstByteWriter *writer, gint32 val);
 140 gboolean        gst_byte_writer_put_uint64_be     (GstByteWriter *writer, guint64 val);
 141 gboolean        gst_byte_writer_put_uint64_le     (GstByteWriter *writer, guint64 val);
 142 gboolean        gst_byte_writer_put_int64_be      (GstByteWriter *writer, gint64 val);
 143 gboolean        gst_byte_writer_put_int64_le      (GstByteWriter *writer, gint64 val);
 144
 145 gboolean        gst_byte_writer_put_float32_be    (GstByteWriter *writer, gfloat val);
 146 gboolean        gst_byte_writer_put_float32_le    (GstByteWriter *writer, gfloat val);
 147 gboolean        gst_byte_writer_put_float64_be    (GstByteWriter *writer, gdouble val);
 148 gboolean        gst_byte_writer_put_float64_le    (GstByteWriter *writer, gdouble val);
 149
 150 gboolean        gst_byte_writer_put_data          (GstByteWriter *writer, const guint8 *data, guint size);
 151 gboolean        gst_byte_writer_fill              (GstByteWriter *writer, guint8 value, guint size);
 152 gboolean        gst_byte_writer_put_string_utf8   (GstByteWriter *writer, const gchar *data);
 153 gboolean        gst_byte_writer_put_string_utf16  (GstByteWriter *writer, const guint16 *data);
 154 gboolean        gst_byte_writer_put_string_utf32  (GstByteWriter *writer, const guint32 *data);
 155 gboolean        gst_byte_writer_put_buffer        (GstByteWriter *writer, GstBuffer * buffer, gsize offset, gssize size);
 156
 157 /**
 158  * gst_byte_writer_put_string:
 159  * @writer: #GstByteWriter instance
 160  * @data: (in) (array zero-terminated=1): Null terminated string
 161  *
 162  * Write a NUL-terminated string to @writer (including the terminator). The
 163  * string is assumed to be in an 8-bit encoding (e.g. ASCII,UTF-8 or
 164  * ISO-8859-1).
 165  *
 166  * Returns: %TRUE if the string could be written
 167  *
 168  * Since: 0.10.26
 169  */
 170 #define gst_byte_writer_put_string(writer, data) \
 171   gst_byte_writer_put_string_utf8(writer, data)
 172
 173 static inline guint
 174 _gst_byte_writer_next_pow2 (guint n)
 175 {
 176   guint ret = 16;
 177
 178   /* We start with 16, smaller allocations make no sense */
 179
 180   while (ret < n && ret > 0)
 181     ret <<= 1;
 182
 183   return ret ? ret : n;
 184 }
 185
 186 static inline gboolean
 187 _gst_byte_writer_ensure_free_space_inline (GstByteWriter * writer, guint size)
 188 {
 189   gpointer data;
 190
 191   if (G_LIKELY (size <= writer->alloc_size - writer->parent.byte))
 192     return TRUE;
 193   if (G_UNLIKELY (writer->fixed || !writer->owned))
 194     return FALSE;
 195   if (G_UNLIKELY (writer->parent.byte > G_MAXUINT - size))
 196     return FALSE;
 197
 198   writer->alloc_size = _gst_byte_writer_next_pow2 (writer->parent.byte + size);
 199   data = g_try_realloc ((guint8 *) writer->parent.data, writer->alloc_size);
 200   if (G_UNLIKELY (data == NULL))
 201     return FALSE;
 202
 203   writer->parent.data = (guint8 *) data;
 204
 205   return TRUE;
 206 }
 207
 208 #define __GST_BYTE_WRITER_CREATE_WRITE_FUNC(bits,type,name,write_func) \
 209 static inline void \
 210 gst_byte_writer_put_##name##_unchecked (GstByteWriter *writer, type val) \
 211 { \
 212   guint8 *write_data; \
 213   \
 214   write_data = (guint8 *) writer->parent.data + writer->parent.byte; \
 215   write_func (write_data, val); \
 216   writer->parent.byte += bits/8; \
 217   writer->parent.size = MAX (writer->parent.size, writer->parent.byte); \
 218 } \
 219 \
 220 static inline gboolean \
 221 _gst_byte_writer_put_##name##_inline (GstByteWriter *writer, type val) \
 222 { \
 223   g_return_val_if_fail (writer != NULL, FALSE); \
 224   \
 225   if (G_UNLIKELY (!_gst_byte_writer_ensure_free_space_inline(writer, bits/8))) \
 226     return FALSE; \
 227   \
 228   gst_byte_writer_put_##name##_unchecked (writer, val); \
 229   \
 230   return TRUE; \
 231 }
 232
 233 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (8, guint8, uint8, GST_WRITE_UINT8)
 234 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (8, gint8, int8, GST_WRITE_UINT8)
 235 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (16, guint16, uint16_le, GST_WRITE_UINT16_LE)
 236 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (16, guint16, uint16_be, GST_WRITE_UINT16_BE)
 237 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (16, gint16, int16_le, GST_WRITE_UINT16_LE)
 238 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (16, gint16, int16_be, GST_WRITE_UINT16_BE)
 239 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (24, guint32, uint24_le, GST_WRITE_UINT24_LE)
 240 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (24, guint32, uint24_be, GST_WRITE_UINT24_BE)
 241 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (24, gint32, int24_le, GST_WRITE_UINT24_LE)
 242 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (24, gint32, int24_be, GST_WRITE_UINT24_BE)
 243 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (32, guint32, uint32_le, GST_WRITE_UINT32_LE)
 244 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (32, guint32, uint32_be, GST_WRITE_UINT32_BE)
 245 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (32, gint32, int32_le, GST_WRITE_UINT32_LE)
 246 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (32, gint32, int32_be, GST_WRITE_UINT32_BE)
 247 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (64, guint64, uint64_le, GST_WRITE_UINT64_LE)
 248 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (64, guint64, uint64_be, GST_WRITE_UINT64_BE)
 249 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (64, gint64, int64_le, GST_WRITE_UINT64_LE)
 250 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (64, gint64, int64_be, GST_WRITE_UINT64_BE)
 251
 252 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (32, gfloat, float32_be, GST_WRITE_FLOAT_BE)
 253 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (32, gfloat, float32_le, GST_WRITE_FLOAT_LE)
 254 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (64, gdouble, float64_be, GST_WRITE_DOUBLE_BE)
 255 __GST_BYTE_WRITER_CREATE_WRITE_FUNC (64, gdouble, float64_le, GST_WRITE_DOUBLE_LE)
 256
 257 #undef __GST_BYTE_WRITER_CREATE_WRITE_FUNC
 258
 259 static inline void
 260 gst_byte_writer_put_data_unchecked (GstByteWriter * writer, const guint8 * data,
 261     guint size)
 262 {
 263   memcpy ((guint8 *) & writer->parent.data[writer->parent.byte], data, size);
 264   writer->parent.byte += size;
 265   writer->parent.size = MAX (writer->parent.size, writer->parent.byte);
 266 }
 267
 268 static inline gboolean
 269 _gst_byte_writer_put_data_inline (GstByteWriter * writer, const guint8 * data,
 270     guint size)
 271 {
 272   g_return_val_if_fail (writer != NULL, FALSE);
 273
 274   if (G_UNLIKELY (!_gst_byte_writer_ensure_free_space_inline (writer, size)))
 275     return FALSE;
 276
 277   gst_byte_writer_put_data_unchecked (writer, data, size);
 278
 279   return TRUE;
 280 }
 281
 282 static inline void
 283 gst_byte_writer_fill_unchecked (GstByteWriter * writer, guint8 value, guint size)
 284 {
 285   memset ((guint8 *) & writer->parent.data[writer->parent.byte], value, size);
 286   writer->parent.byte += size;
 287   writer->parent.size = MAX (writer->parent.size, writer->parent.byte);
 288 }
 289
 290 static inline gboolean
 291 _gst_byte_writer_fill_inline (GstByteWriter * writer, guint8 value, guint size)
 292 {
 293   g_return_val_if_fail (writer != NULL, FALSE);
 294
 295   if (G_UNLIKELY (!_gst_byte_writer_ensure_free_space_inline (writer, size)))
 296     return FALSE;
 297
 298   gst_byte_writer_fill_unchecked (writer, value, size);
 299
 300   return TRUE;
 301 }
 302
 303 #ifndef GST_BYTE_WRITER_DISABLE_INLINES
 304
 305 /* we use defines here so we can add the G_LIKELY() */
 306
 307 #define gst_byte_writer_ensure_free_space(writer, size) \
 308     G_LIKELY (_gst_byte_writer_ensure_free_space_inline (writer, size))
 309 #define gst_byte_writer_put_uint8(writer, val) \
 310     G_LIKELY (_gst_byte_writer_put_uint8_inline (writer, val))
 311 #define gst_byte_writer_put_int8(writer, val) \
 312     G_LIKELY (_gst_byte_writer_put_int8_inline (writer, val))
 313 #define gst_byte_writer_put_uint16_be(writer, val) \
 314     G_LIKELY (_gst_byte_writer_put_uint16_be_inline (writer, val))
 315 #define gst_byte_writer_put_uint16_le(writer, val) \
 316     G_LIKELY (_gst_byte_writer_put_uint16_le_inline (writer, val))
 317 #define gst_byte_writer_put_int16_be(writer, val) \
 318     G_LIKELY (_gst_byte_writer_put_int16_be_inline (writer, val))
 319 #define gst_byte_writer_put_int16_le(writer, val) \
 320     G_LIKELY (_gst_byte_writer_put_int16_le_inline (writer, val))
 321 #define gst_byte_writer_put_uint24_be(writer, val) \
 322     G_LIKELY (_gst_byte_writer_put_uint24_be_inline (writer, val))
 323 #define gst_byte_writer_put_uint24_le(writer, val) \
 324     G_LIKELY (_gst_byte_writer_put_uint24_le_inline (writer, val))
 325 #define gst_byte_writer_put_int24_be(writer, val) \
 326     G_LIKELY (_gst_byte_writer_put_int24_be_inline (writer, val))
 327 #define gst_byte_writer_put_int24_le(writer, val) \
 328     G_LIKELY (_gst_byte_writer_put_int24_le_inline (writer, val))
 329 #define gst_byte_writer_put_uint32_be(writer, val) \
 330     G_LIKELY (_gst_byte_writer_put_uint32_be_inline (writer, val))
 331 #define gst_byte_writer_put_uint32_le(writer, val) \
 332     G_LIKELY (_gst_byte_writer_put_uint32_le_inline (writer, val))
 333 #define gst_byte_writer_put_int32_be(writer, val) \
 334     G_LIKELY (_gst_byte_writer_put_int32_be_inline (writer, val))
 335 #define gst_byte_writer_put_int32_le(writer, val) \
 336     G_LIKELY (_gst_byte_writer_put_int32_le_inline (writer, val))
 337 #define gst_byte_writer_put_uint64_be(writer, val) \
 338     G_LIKELY (_gst_byte_writer_put_uint64_be_inline (writer, val))
 339 #define gst_byte_writer_put_uint64_le(writer, val) \
 340     G_LIKELY (_gst_byte_writer_put_uint64_le_inline (writer, val))
 341 #define gst_byte_writer_put_int64_be(writer, val) \
 342     G_LIKELY (_gst_byte_writer_put_int64_be_inline (writer, val))
 343 #define gst_byte_writer_put_int64_le(writer, val) \
 344     G_LIKELY (_gst_byte_writer_put_int64_le_inline (writer, val))
 345
 346 #define gst_byte_writer_put_float32_be(writer, val) \
 347     G_LIKELY (_gst_byte_writer_put_float32_be_inline (writer, val))
 348 #define gst_byte_writer_put_float32_le(writer, val) \
 349     G_LIKELY (_gst_byte_writer_put_float32_le_inline (writer, val))
 350 #define gst_byte_writer_put_float64_be(writer, val) \
 351     G_LIKELY (_gst_byte_writer_put_float64_be_inline (writer, val))
 352 #define gst_byte_writer_put_float64_le(writer, val) \
 353     G_LIKELY (_gst_byte_writer_put_float64_le_inline (writer, val))
 354
 355 #define gst_byte_writer_put_data(writer, data, size) \
 356     G_LIKELY (_gst_byte_writer_put_data_inline (writer, data, size))
 357 #define gst_byte_writer_fill(writer, val, size) \
 358     G_LIKELY (_gst_byte_writer_fill_inline (writer, val, size))
 359
 360 #endif
 361
 362 G_END_DECLS
 363
 364 #endif /* __GST_BYTE_WRITER_H__ */