Debian Codegraph @

libs/gst/base/gstbytereader-docs.h

raw
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