libs/gst/base/gstbytereader-docs.h

   1 /* GStreamer byte reader dummy header for gtk-doc
   2  * Copyright (C) 2009 Tim-Philipp Müller <tim centricular net>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
  17  * Boston, MA 02110-1301, USA.
  18  */
  19
  20 /* This header is not installed, it just contains stuff for gtk-doc to parse,
  21  * in particular docs and some dummy function declarations for the static
  22  * inline functions we generate via macros in gstbytereader.h.
  23  */
  24
  25 #error "This header should never be included in code, it is only for gtk-doc"
  26
  27 /**
  28  * gst_byte_reader_skip_unchecked:
  29  * @reader: a #GstByteReader instance
  30  * @nbytes: the number of bytes to skip
  31  *
  32  * Skips @nbytes bytes of the #GstByteReader instance without checking if
  33  * there are enough bytes available in the byte reader.
  34  */
  35 void gst_byte_reader_skip_unchecked (GstByteReader * reader, guint nbytes);
  36
  37 /**
  38  * gst_byte_reader_get_uint8_unchecked:
  39  * @reader: a #GstByteReader instance
  40  *
  41  * Read an unsigned 8 bit integer without checking if there are enough bytes
  42  * available in the byte reader and update the current position.
  43  *
  44  * Returns: unsigned 8 bit integer.
  45  */
  46 /**
  47  * gst_byte_reader_peek_uint8_unchecked:
  48  * @reader: a #GstByteReader instance
  49  *
  50  * Read an unsigned 8 bit integer without checking if there are enough bytes
  51  * available in the byte reader, but do not advance the current read position.
  52  *
  53  * Returns: unsigned 8 bit integer.
  54  */
  55 /**
  56  * gst_byte_reader_get_int8_unchecked:
  57  * @reader: a #GstByteReader instance
  58  *
  59  * Read an signed 8 bit integer without checking if there are enough bytes
  60  * available in the byte reader and update the current position.
  61  *
  62  * Returns: signed 8 bit integer.
  63  */
  64 /**
  65  * gst_byte_reader_peek_int8_unchecked:
  66  * @reader: a #GstByteReader instance
  67  *
  68  * Read an signed 8 bit integer without checking if there are enough bytes
  69  * available in the byte reader, but do not advance the current read position.
  70  *
  71  * Returns: signed 8 bit integer.
  72  */
  73 guint8  gst_byte_reader_get_uint8_unchecked     (GstByteReader * reader);
  74 guint8  gst_byte_reader_peek_uint8_unchecked    (GstByteReader * reader);
  75 gint8   gst_byte_reader_get_int8_unchecked      (GstByteReader * reader);
  76 gint8   gst_byte_reader_peek_int8_unchecked     (GstByteReader * reader);
  77
  78 /**
  79  * gst_byte_reader_get_uint16_le_unchecked:
  80  * @reader: a #GstByteReader instance
  81  *
  82  * Read an unsigned 16 bit integer in little endian format without checking
  83  * if there are enough bytes available in the byte reader and update the
  84  * current position.
  85  *
  86  * Returns: unsigned 16 bit integer.
  87  */
  88 /**
  89  * gst_byte_reader_peek_uint16_le_unchecked:
  90  * @reader: a #GstByteReader instance
  91  *
  92  * Read an unsigned 16 bit integer in little endian format without checking
  93  * if there are enough bytes available in the byte reader, but do not advance
  94  * the current position.
  95  *
  96  * Returns: unsigned 16 bit integer.
  97  */
  98 /**
  99  * gst_byte_reader_get_uint16_be_unchecked:
 100  * @reader: a #GstByteReader instance
 101  *
 102  * Read an unsigned 16 bit integer in big endian format without checking
 103  * if there are enough bytes available in the byte reader and update the
 104  * current position.
 105  *
 106  * Returns: unsigned 16 bit integer.
 107  */
 108 /**
 109  * gst_byte_reader_peek_uint16_be_unchecked:
 110  * @reader: a #GstByteReader instance
 111  *
 112  * Read an unsigned 16 bit integer in big endian format without checking
 113  * if there are enough bytes available in the byte reader, but do not advance
 114  * the current position.
 115  *
 116  * Returns: unsigned 16 bit integer.
 117  */
 118 /**
 119  * gst_byte_reader_get_int16_le_unchecked:
 120  * @reader: a #GstByteReader instance
 121  *
 122  * Read a signed 16 bit integer in little endian format without checking
 123  * if there are enough bytes available in the byte reader and update the
 124  * current position.
 125  *
 126  * Returns: signed 16 bit integer.
 127  */
 128 /**
 129  * gst_byte_reader_peek_int16_le_unchecked:
 130  * @reader: a #GstByteReader instance
 131  *
 132  * Read a signed 16 bit integer in little endian format without checking
 133  * if there are enough bytes available in the byte reader, but do not advance
 134  * the current position.
 135  *
 136  * Returns: signed 16 bit integer.
 137  */
 138 /**
 139  * gst_byte_reader_get_int16_be_unchecked:
 140  * @reader: a #GstByteReader instance
 141  *
 142  * Read a signed 16 bit integer in big endian format without checking
 143  * if there are enough bytes available in the byte reader and update the
 144  * current position.
 145  *
 146  * Returns: signed 16 bit integer.
 147  */
 148 /**
 149  * gst_byte_reader_peek_int16_be_unchecked:
 150  * @reader: a #GstByteReader instance
 151  *
 152  * Read a signed 16 bit integer in big endian format without checking
 153  * if there are enough bytes available in the byte reader, but do not advance
 154  * the current position.
 155  *
 156  * Returns: signed 16 bit integer.
 157  */
 158 guint16 gst_byte_reader_get_uint16_le_unchecked  (GstByteReader * reader);
 159 guint16 gst_byte_reader_get_uint16_be_unchecked  (GstByteReader * reader);
 160 guint16 gst_byte_reader_peek_uint16_le_unchecked (GstByteReader * reader);
 161 guint16 gst_byte_reader_peek_uint16_be_unchecked (GstByteReader * reader);
 162 gint16  gst_byte_reader_get_int16_le_unchecked   (GstByteReader * reader);
 163 gint16  gst_byte_reader_get_int16_be_unchecked   (GstByteReader * reader);
 164 gint16  gst_byte_reader_peek_int16_le_unchecked  (GstByteReader * reader);
 165 gint16  gst_byte_reader_peek_int16_be_unchecked  (GstByteReader * reader);
 166
 167 /**
 168  * gst_byte_reader_get_uint24_le_unchecked:
 169  * @reader: a #GstByteReader instance
 170  *
 171  * Read an unsigned 24 bit integer in little endian format without checking
 172  * if there are enough bytes available in the byte reader and update the
 173  * current position.
 174  *
 175  * Returns: unsigned 24 bit integer (as guint32)
 176  */
 177 /**
 178  * gst_byte_reader_peek_uint24_le_unchecked:
 179  * @reader: a #GstByteReader instance
 180  *
 181  * Read an unsigned 24 bit integer in little endian format without checking
 182  * if there are enough bytes available in the byte reader, but do not advance
 183  * the current position.
 184  *
 185  * Returns: unsigned 24 bit integer (as guint32)
 186  */
 187 /**
 188  * gst_byte_reader_get_uint24_be_unchecked:
 189  * @reader: a #GstByteReader instance
 190  *
 191  * Read an unsigned 24 bit integer in big endian format without checking
 192  * if there are enough bytes available in the byte reader and update the
 193  * current position.
 194  *
 195  * Returns: unsigned 24 bit integer (as guint32)
 196  */
 197 /**
 198  * gst_byte_reader_peek_uint24_be_unchecked:
 199  * @reader: a #GstByteReader instance
 200  *
 201  * Read an unsigned 24 bit integer in big endian format without checking
 202  * if there are enough bytes available in the byte reader, but do not advance
 203  * the current position.
 204  *
 205  * Returns: unsigned 24 bit integer (as guint32)
 206  */
 207 /**
 208  * gst_byte_reader_get_int24_le_unchecked:
 209  * @reader: a #GstByteReader instance
 210  *
 211  * Read a signed 24 bit integer in little endian format without checking
 212  * if there are enough bytes available in the byte reader and update the
 213  * current position.
 214  *
 215  * Returns: signed 24 bit integer (as gint32)
 216  */
 217 /**
 218  * gst_byte_reader_peek_int24_le_unchecked:
 219  * @reader: a #GstByteReader instance
 220  *
 221  * Read a signed 24 bit integer in little endian format without checking
 222  * if there are enough bytes available in the byte reader, but do not advance
 223  * the current position.
 224  *
 225  * Returns: signed 24 bit integer (as gint32)
 226  */
 227 /**
 228  * gst_byte_reader_get_int24_be_unchecked:
 229  * @reader: a #GstByteReader instance
 230  *
 231  * Read a signed 24 bit integer in big endian format without checking
 232  * if there are enough bytes available in the byte reader and update the
 233  * current position.
 234  *
 235  * Returns: signed 24 bit integer (as gint32)
 236  */
 237 /**
 238  * gst_byte_reader_peek_int24_be_unchecked:
 239  * @reader: a #GstByteReader instance
 240  *
 241  * Read a signed 24 bit integer in big endian format without checking
 242  * if there are enough bytes available in the byte reader, but do not advance
 243  * the current position.
 244  *
 245  * Returns: signed 24 bit integer (as gint32)
 246  */
 247 guint32 gst_byte_reader_get_uint24_le_unchecked  (GstByteReader * reader);
 248 guint32 gst_byte_reader_get_uint24_be_unchecked  (GstByteReader * reader);
 249 guint32 gst_byte_reader_peek_uint24_le_unchecked (GstByteReader * reader);
 250 guint32 gst_byte_reader_peek_uint24_be_unchecked (GstByteReader * reader);
 251 gint32  gst_byte_reader_get_int24_le_unchecked   (GstByteReader * reader);
 252 gint32  gst_byte_reader_get_int24_be_unchecked   (GstByteReader * reader);
 253 gint32  gst_byte_reader_peek_int24_le_unchecked  (GstByteReader * reader);
 254 gint32  gst_byte_reader_peek_int24_be_unchecked  (GstByteReader * reader);
 255
 256 /**
 257  * gst_byte_reader_get_uint32_le_unchecked:
 258  * @reader: a #GstByteReader instance
 259  *
 260  * Read an unsigned 32 bit integer in little endian format without checking
 261  * if there are enough bytes available in the byte reader and update the
 262  * current position.
 263  *
 264  * Returns: unsigned 32 bit integer.
 265  */
 266 /**
 267  * gst_byte_reader_peek_uint32_le_unchecked:
 268  * @reader: a #GstByteReader instance
 269  *
 270  * Read an unsigned 32 bit integer in little endian format without checking
 271  * if there are enough bytes available in the byte reader, but do not advance
 272  * the current position.
 273  *
 274  * Returns: unsigned 32 bit integer.
 275  */
 276 /**
 277  * gst_byte_reader_get_uint32_be_unchecked:
 278  * @reader: a #GstByteReader instance
 279  *
 280  * Read an unsigned 32 bit integer in big endian format without checking
 281  * if there are enough bytes available in the byte reader and update the
 282  * current position.
 283  *
 284  * Returns: unsigned 32 bit integer.
 285  */
 286 /**
 287  * gst_byte_reader_peek_uint32_be_unchecked:
 288  * @reader: a #GstByteReader instance
 289  *
 290  * Read an unsigned 32 bit integer in big endian format without checking
 291  * if there are enough bytes available in the byte reader, but do not advance
 292  * the current position.
 293  *
 294  * Returns: unsigned 32 bit integer.
 295  */
 296 /**
 297  * gst_byte_reader_get_int32_le_unchecked:
 298  * @reader: a #GstByteReader instance
 299  *
 300  * Read a signed 32 bit integer in little endian format without checking
 301  * if there are enough bytes available in the byte reader and update the
 302  * current position.
 303  *
 304  * Returns: signed 32 bit integer.
 305  */
 306 /**
 307  * gst_byte_reader_peek_int32_le_unchecked:
 308  * @reader: a #GstByteReader instance
 309  *
 310  * Read a signed 32 bit integer in little endian format without checking
 311  * if there are enough bytes available in the byte reader, but do not advance
 312  * the current position.
 313  *
 314  * Returns: signed 32 bit integer.
 315  */
 316 /**
 317  * gst_byte_reader_get_int32_be_unchecked:
 318  * @reader: a #GstByteReader instance
 319  *
 320  * Read a signed 32 bit integer in big endian format without checking
 321  * if there are enough bytes available in the byte reader and update the
 322  * current position.
 323  *
 324  * Returns: signed 32 bit integer.
 325  */
 326 /**
 327  * gst_byte_reader_peek_int32_be_unchecked:
 328  * @reader: a #GstByteReader instance
 329  *
 330  * Read a signed 32 bit integer in big endian format without checking
 331  * if there are enough bytes available in the byte reader, but do not advance
 332  * the current position.
 333  *
 334  * Returns: signed 32 bit integer.
 335  */
 336 guint32 gst_byte_reader_get_uint32_le_unchecked  (GstByteReader * reader);
 337 guint32 gst_byte_reader_get_uint32_be_unchecked  (GstByteReader * reader);
 338 guint32 gst_byte_reader_peek_uint32_le_unchecked (GstByteReader * reader);
 339 guint32 gst_byte_reader_peek_uint32_be_unchecked (GstByteReader * reader);
 340 gint32  gst_byte_reader_get_int32_le_unchecked   (GstByteReader * reader);
 341 gint32  gst_byte_reader_get_int32_be_unchecked   (GstByteReader * reader);
 342 gint32  gst_byte_reader_peek_int32_le_unchecked  (GstByteReader * reader);
 343 gint32  gst_byte_reader_peek_int32_be_unchecked  (GstByteReader * reader);
 344
 345 /**
 346  * gst_byte_reader_get_uint64_le_unchecked:
 347  * @reader: a #GstByteReader instance
 348  *
 349  * Read an unsigned 64 bit integer in little endian format without checking
 350  * if there are enough bytes available in the byte reader and update the
 351  * current position.
 352  *
 353  * Returns: unsigned 64 bit integer.
 354  */
 355 /**
 356  * gst_byte_reader_peek_uint64_le_unchecked:
 357  * @reader: a #GstByteReader instance
 358  *
 359  * Read an unsigned 64 bit integer in little endian format without checking
 360  * if there are enough bytes available in the byte reader, but do not advance
 361  * the current position.
 362  *
 363  * Returns: unsigned 64 bit integer.
 364  */
 365 /**
 366  * gst_byte_reader_get_uint64_be_unchecked:
 367  * @reader: a #GstByteReader instance
 368  *
 369  * Read an unsigned 64 bit integer in big endian format without checking
 370  * if there are enough bytes available in the byte reader and update the
 371  * current position.
 372  *
 373  * Returns: unsigned 64 bit integer.
 374  */
 375 /**
 376  * gst_byte_reader_peek_uint64_be_unchecked:
 377  * @reader: a #GstByteReader instance
 378  *
 379  * Read an unsigned 64 bit integer in big endian format without checking
 380  * if there are enough bytes available in the byte reader, but do not advance
 381  * the current position.
 382  *
 383  * Returns: unsigned 64 bit integer.
 384  */
 385 /**
 386  * gst_byte_reader_get_int64_le_unchecked:
 387  * @reader: a #GstByteReader instance
 388  *
 389  * Read a signed 64 bit integer in little endian format without checking
 390  * if there are enough bytes available in the byte reader and update the
 391  * current position.
 392  *
 393  * Returns: signed 64 bit integer.
 394  */
 395 /**
 396  * gst_byte_reader_peek_int64_le_unchecked:
 397  * @reader: a #GstByteReader instance
 398  *
 399  * Read a signed 64 bit integer in little endian format without checking
 400  * if there are enough bytes available in the byte reader, but do not advance
 401  * the current position.
 402  *
 403  * Returns: signed 64 bit integer.
 404  */
 405 /**
 406  * gst_byte_reader_get_int64_be_unchecked:
 407  * @reader: a #GstByteReader instance
 408  *
 409  * Read a signed 64 bit integer in big endian format without checking
 410  * if there are enough bytes available in the byte reader and update the
 411  * current position.
 412  *
 413  * Returns: signed 64 bit integer.
 414  */
 415 /**
 416  * gst_byte_reader_peek_int64_be_unchecked:
 417  * @reader: a #GstByteReader instance
 418  *
 419  * Read a signed 64 bit integer in big endian format without checking
 420  * if there are enough bytes available in the byte reader, but do not advance
 421  * the current position.
 422  *
 423  * Returns: signed 64 bit integer.
 424  */
 425 guint64 gst_byte_reader_get_uint64_le_unchecked  (GstByteReader * reader);
 426 guint64 gst_byte_reader_get_uint64_be_unchecked  (GstByteReader * reader);
 427 guint64 gst_byte_reader_peek_uint64_le_unchecked (GstByteReader * reader);
 428 guint64 gst_byte_reader_peek_uint64_be_unchecked (GstByteReader * reader);
 429 gint64  gst_byte_reader_get_int64_le_unchecked   (GstByteReader * reader);
 430 gint64  gst_byte_reader_get_int64_be_unchecked   (GstByteReader * reader);
 431 gint64  gst_byte_reader_peek_int64_le_unchecked  (GstByteReader * reader);
 432 gint64  gst_byte_reader_peek_int64_be_unchecked  (GstByteReader * reader);
 433
 434 /**
 435  * gst_byte_reader_get_float32_le_unchecked:
 436  * @reader: a #GstByteReader instance
 437  *
 438  * Read a 32 bit little endian float without checking if there is enough
 439  * data available and update the current position.
 440  *
 441  * Returns: floating point value read
 442  */
 443 /**
 444  * gst_byte_reader_peek_float32_le_unchecked:
 445  * @reader: a #GstByteReader instance
 446  *
 447  * Read a 32 bit little endian float without checking if there is enough
 448  * data available, but keep the current position.
 449  *
 450  * Returns: floating point value read
 451  */
 452 /**
 453  * gst_byte_reader_get_float32_be_unchecked:
 454  * @reader: a #GstByteReader instance
 455  *
 456  * Read a 32 bit big endian float without checking if there is enough
 457  * data available and update the current position.
 458  *
 459  * Returns: floating point value read
 460  */
 461 /**
 462  * gst_byte_reader_peek_float32_be_unchecked:
 463  * @reader: a #GstByteReader instance
 464  *
 465  * Read a 32 bit big endian float without checking if there is enough
 466  * data available, but keep the current position.
 467  *
 468  * Returns: floating point value read
 469  */
 470 /**
 471  * gst_byte_reader_get_float64_le_unchecked:
 472  * @reader: a #GstByteReader instance
 473  *
 474  * Read a 64 bit little endian float without checking if there is enough
 475  * data available and update the current position.
 476  *
 477  * Returns: double precision floating point value read
 478  */
 479 /**
 480  * gst_byte_reader_peek_float64_le_unchecked:
 481  * @reader: a #GstByteReader instance
 482  *
 483  * Read a 64 bit little endian float without checking if there is enough
 484  * data available, but keep the current position.
 485  *
 486  * Returns: double precision floating point value read
 487  */
 488 /**
 489  * gst_byte_reader_get_float64_be_unchecked:
 490  * @reader: a #GstByteReader instance
 491  *
 492  * Read a 64 bit big endian float without checking if there is enough
 493  * data available and update the current position.
 494  *
 495  * Returns: double precision floating point value read
 496  */
 497 /**
 498  * gst_byte_reader_peek_float64_be_unchecked:
 499  * @reader: a #GstByteReader instance
 500  *
 501  * Read a 64 bit big endian float without checking if there is enough
 502  * data available, but keep the current position.
 503  *
 504  * Returns: double precision floating point value read
 505  */
 506
 507 gfloat  gst_byte_reader_get_float32_le_unchecked  (GstByteReader * reader);
 508 gfloat  gst_byte_reader_get_float32_be_unchecked  (GstByteReader * reader);
 509 gdouble gst_byte_reader_get_float64_le_unchecked  (GstByteReader * reader);
 510 gdouble gst_byte_reader_get_float64_be_unchecked  (GstByteReader * reader);
 511
 512 gfloat  gst_byte_reader_peek_float32_le_unchecked (GstByteReader * reader);
 513 gfloat  gst_byte_reader_peek_float32_be_unchecked (GstByteReader * reader);
 514 gdouble gst_byte_reader_peek_float64_le_unchecked (GstByteReader * reader);
 515 gdouble gst_byte_reader_peek_float64_be_unchecked (GstByteReader * reader);
 516
 517 /**
 518  * gst_byte_reader_peek_data_unchecked:
 519  * @reader: a #GstByteReader instance
 520  *
 521  * Returns: (transfer none): a constant pointer to the current data position
 522  */
 523 const guint8 * gst_byte_reader_peek_data_unchecked (const GstByteReader * reader);
 524 /**
 525  * gst_byte_reader_get_data_unchecked:
 526  * @reader: a #GstByteReader instance
 527  * @size: Size in bytes
 528  *
 529  * Returns a constant pointer to the current data position without checking
 530  * if at least @size bytes are left. Advances the current read position by
 531  * @size bytes.
 532  *
 533  * Returns: (transfer none) (array length=size): a constant pointer to the
 534  *     current data position.
 535  */
 536 const guint8 * gst_byte_reader_get_data_unchecked (GstByteReader * reader, guint size);
 537 /**
 538  * gst_byte_reader_dup_data_unchecked:
 539  * @reader: a #GstByteReader instance
 540  * @size: Size in bytes
 541  *
 542  * Returns a newly-allocated copy of the data at the current data position
 543  * without checking if at least @size bytes are left. Advances the current read
 544  * position by @size bytes.
 545  *
 546  * Free-function: g_free
 547  *
 548  * Returns: (transfer full) (array length=size): a newly-allocated copy of the
 549  *     data @size bytes in size. Free with g_free() when no longer needed.
 550  */
 551 guint8 * gst_byte_reader_dup_data_unchecked (GstByteReader * reader, guint size);
 552