docs: add a missing const in bytereader docs
[platform/upstream/gstreamer.git] / 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