Branch data Line data Source code
1 : : /* GStreamer byte reader
2 : : *
3 : : * Copyright (C) 2008 Sebastian Dröge <sebastian.droege@collabora.co.uk>.
4 : : * Copyright (C) 2009 Tim-Philipp Müller <tim centricular net>
5 : : *
6 : : * This library is free software; you can redistribute it and/or
7 : : * modify it under the terms of the GNU Library General Public
8 : : * License as published by the Free Software Foundation; either
9 : : * version 2 of the License, or (at your option) any later version.
10 : : *
11 : : * This library is distributed in the hope that it will be useful,
12 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 : : * Library General Public License for more details.
15 : : *
16 : : * You should have received a copy of the GNU Library General Public
17 : : * License along with this library; if not, write to the
18 : : * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 : : * Boston, MA 02111-1307, USA.
20 : : */
21 : :
22 : : #ifdef HAVE_CONFIG_H
23 : : #include "config.h"
24 : : #endif
25 : :
26 : : #define GST_BYTE_READER_DISABLE_INLINES
27 : : #include "gstbytereader.h"
28 : :
29 : : #include <string.h>
30 : :
31 : : /**
32 : : * SECTION:gstbytereader
33 : : * @short_description: Reads different integer, string and floating point
34 : : * types from a memory buffer
35 : : *
36 : : * #GstByteReader provides a byte reader that can read different integer and
37 : : * floating point types from a memory buffer. It provides functions for reading
38 : : * signed/unsigned, little/big endian integers of 8, 16, 24, 32 and 64 bits
39 : : * and functions for reading little/big endian floating points numbers of
40 : : * 32 and 64 bits. It also provides functions to read NUL-terminated strings
41 : : * in various character encodings.
42 : : */
43 : :
44 : : /**
45 : : * gst_byte_reader_new:
46 : : * @data: (in) (transfer none) (array length=size): data from which the
47 : : * #GstByteReader should read
48 : : * @size: Size of @data in bytes
49 : : *
50 : : * Create a new #GstByteReader instance, which will read from @data.
51 : : *
52 : : * Free-function: gst_byte_reader_free
53 : : *
54 : : * Returns: (transfer full): a new #GstByteReader instance
55 : : *
56 : : * Since: 0.10.22
57 : : */
58 : : GstByteReader *
59 : 2 : gst_byte_reader_new (const guint8 * data, guint size)
60 : : {
61 : 2 : GstByteReader *ret = g_slice_new0 (GstByteReader);
62 : :
63 : 2 : ret->data = data;
64 : 2 : ret->size = size;
65 : :
66 : 2 : return ret;
67 : : }
68 : :
69 : : /**
70 : : * gst_byte_reader_new_from_buffer:
71 : : * @buffer: (transfer none): Buffer from which the #GstByteReader should read
72 : : *
73 : : * Create a new #GstByteReader instance, which will read from the
74 : : * #GstBuffer @buffer.
75 : : *
76 : : * Free-function: gst_byte_reader_free
77 : : *
78 : : * Returns: (transfer full): a new #GstByteReader instance
79 : : *
80 : : * Since: 0.10.22
81 : : */
82 : : GstByteReader *
83 : 1 : gst_byte_reader_new_from_buffer (const GstBuffer * buffer)
84 : : {
85 [ - + ][ + - ]: 1 : g_return_val_if_fail (GST_IS_BUFFER (buffer), NULL);
[ + - ][ - + ]
86 : :
87 : 1 : return gst_byte_reader_new (GST_BUFFER_DATA (buffer),
88 : : GST_BUFFER_SIZE (buffer));
89 : : }
90 : :
91 : : /**
92 : : * gst_byte_reader_free:
93 : : * @reader: (in) (transfer full): a #GstByteReader instance
94 : : *
95 : : * Frees a #GstByteReader instance, which was previously allocated by
96 : : * gst_byte_reader_new() or gst_byte_reader_new_from_buffer().
97 : : *
98 : : * Since: 0.10.22
99 : : */
100 : : void
101 : 2 : gst_byte_reader_free (GstByteReader * reader)
102 : : {
103 [ - + ]: 4 : g_return_if_fail (reader != NULL);
104 : :
105 : 2 : g_slice_free (GstByteReader, reader);
106 : : }
107 : :
108 : : /**
109 : : * gst_byte_reader_init:
110 : : * @reader: a #GstByteReader instance
111 : : * @data: (in) (transfer none) (array length=size): data from which
112 : : * the #GstByteReader should read
113 : : * @size: Size of @data in bytes
114 : : *
115 : : * Initializes a #GstByteReader instance to read from @data. This function
116 : : * can be called on already initialized instances.
117 : : *
118 : : * Since: 0.10.22
119 : : */
120 : : void
121 : 9 : gst_byte_reader_init (GstByteReader * reader, const guint8 * data, guint size)
122 : : {
123 [ - + ]: 18 : g_return_if_fail (reader != NULL);
124 : :
125 : 9 : reader->data = data;
126 : 9 : reader->size = size;
127 : 9 : reader->byte = 0;
128 : : }
129 : :
130 : : /**
131 : : * gst_byte_reader_init_from_buffer:
132 : : * @reader: a #GstByteReader instance
133 : : * @buffer: (transfer none): Buffer from which the #GstByteReader should read
134 : : *
135 : : * Initializes a #GstByteReader instance to read from @buffer. This function
136 : : * can be called on already initialized instances.
137 : : *
138 : : * Since: 0.10.22
139 : : */
140 : : void
141 : 1 : gst_byte_reader_init_from_buffer (GstByteReader * reader,
142 : : const GstBuffer * buffer)
143 : : {
144 [ - + ][ + - ]: 2 : g_return_if_fail (GST_IS_BUFFER (buffer));
[ + - ][ - + ]
145 : :
146 : 1 : gst_byte_reader_init (reader, GST_BUFFER_DATA (buffer),
147 : : GST_BUFFER_SIZE (buffer));
148 : : }
149 : :
150 : : /**
151 : : * gst_byte_reader_set_pos:
152 : : * @reader: a #GstByteReader instance
153 : : * @pos: The new position in bytes
154 : : *
155 : : * Sets the new position of a #GstByteReader instance to @pos in bytes.
156 : : *
157 : : * Returns: %TRUE if the position could be set successfully, %FALSE
158 : : * otherwise.
159 : : *
160 : : * Since: 0.10.22
161 : : */
162 : : gboolean
163 : 19 : gst_byte_reader_set_pos (GstByteReader * reader, guint pos)
164 : : {
165 [ - + ]: 19 : g_return_val_if_fail (reader != NULL, FALSE);
166 : :
167 [ - + ]: 19 : if (pos > reader->size)
168 : 0 : return FALSE;
169 : :
170 : 19 : reader->byte = pos;
171 : :
172 : 19 : return TRUE;
173 : : }
174 : :
175 : : /**
176 : : * gst_byte_reader_get_pos:
177 : : * @reader: a #GstByteReader instance
178 : : *
179 : : * Returns the current position of a #GstByteReader instance in bytes.
180 : : *
181 : : * Returns: The current position of @reader in bytes.
182 : : *
183 : : * Since: 0.10.22
184 : : */
185 : : guint
186 : 0 : gst_byte_reader_get_pos (const GstByteReader * reader)
187 : : {
188 : 0 : return _gst_byte_reader_get_pos_inline (reader);
189 : : }
190 : :
191 : : /**
192 : : * gst_byte_reader_get_remaining:
193 : : * @reader: a #GstByteReader instance
194 : : *
195 : : * Returns the remaining number of bytes of a #GstByteReader instance.
196 : : *
197 : : * Returns: The remaining number of bytes of @reader instance.
198 : : *
199 : : * Since: 0.10.22
200 : : */
201 : : guint
202 : 0 : gst_byte_reader_get_remaining (const GstByteReader * reader)
203 : : {
204 : 0 : return _gst_byte_reader_get_remaining_inline (reader);
205 : : }
206 : :
207 : : /**
208 : : * gst_byte_reader_get_size:
209 : : * @reader: a #GstByteReader instance
210 : : *
211 : : * Returns the total number of bytes of a #GstByteReader instance.
212 : : *
213 : : * Returns: The total number of bytes of @reader instance.
214 : : *
215 : : * Since: 0.10.26
216 : : */
217 : : guint
218 : 0 : gst_byte_reader_get_size (const GstByteReader * reader)
219 : : {
220 : 0 : return _gst_byte_reader_get_size_inline (reader);
221 : : }
222 : :
223 : : #define gst_byte_reader_get_remaining _gst_byte_reader_get_remaining_inline
224 : : #define gst_byte_reader_get_size _gst_byte_reader_get_size_inline
225 : :
226 : : /**
227 : : * gst_byte_reader_skip:
228 : : * @reader: a #GstByteReader instance
229 : : * @nbytes: the number of bytes to skip
230 : : *
231 : : * Skips @nbytes bytes of the #GstByteReader instance.
232 : : *
233 : : * Returns: %TRUE if @nbytes bytes could be skipped, %FALSE otherwise.
234 : : *
235 : : * Since: 0.10.22
236 : : */
237 : : gboolean
238 : 0 : gst_byte_reader_skip (GstByteReader * reader, guint nbytes)
239 : : {
240 : 0 : return _gst_byte_reader_skip_inline (reader, nbytes);
241 : : }
242 : :
243 : : /**
244 : : * gst_byte_reader_get_uint8:
245 : : * @reader: a #GstByteReader instance
246 : : * @val: Pointer to a #guint8 to store the result
247 : : *
248 : : * Read an unsigned 8 bit integer into @val and update the current position.
249 : : *
250 : : * Returns: %TRUE if successful, %FALSE otherwise.
251 : : *
252 : : * Since: 0.10.22
253 : : */
254 : :
255 : : /**
256 : : * gst_byte_reader_get_int8:
257 : : * @reader: a #GstByteReader instance
258 : : * @val: Pointer to a #gint8 to store the result
259 : : *
260 : : * Read a signed 8 bit integer into @val and update the current position.
261 : : *
262 : : * Returns: %TRUE if successful, %FALSE otherwise.
263 : : *
264 : : * Since: 0.10.22
265 : : */
266 : :
267 : : /**
268 : : * gst_byte_reader_peek_uint8:
269 : : * @reader: a #GstByteReader instance
270 : : * @val: Pointer to a #guint8 to store the result
271 : : *
272 : : * Read an unsigned 8 bit integer into @val but keep the current position.
273 : : *
274 : : * Returns: %TRUE if successful, %FALSE otherwise.
275 : : *
276 : : * Since: 0.10.22
277 : : */
278 : :
279 : : /**
280 : : * gst_byte_reader_peek_int8:
281 : : * @reader: a #GstByteReader instance
282 : : * @val: Pointer to a #gint8 to store the result
283 : : *
284 : : * Read a signed 8 bit integer into @val but keep the current position.
285 : : *
286 : : * Returns: %TRUE if successful, %FALSE otherwise.
287 : : *
288 : : * Since: 0.10.22
289 : : */
290 : :
291 : : /**
292 : : * gst_byte_reader_get_uint16_le:
293 : : * @reader: a #GstByteReader instance
294 : : * @val: Pointer to a #guint16 to store the result
295 : : *
296 : : * Read an unsigned 16 bit little endian integer into @val
297 : : * and update the current position.
298 : : *
299 : : * Returns: %TRUE if successful, %FALSE otherwise.
300 : : *
301 : : * Since: 0.10.22
302 : : */
303 : :
304 : : /**
305 : : * gst_byte_reader_get_int16_le:
306 : : * @reader: a #GstByteReader instance
307 : : * @val: Pointer to a #gint16 to store the result
308 : : *
309 : : * Read a signed 16 bit little endian integer into @val
310 : : * and update the current position.
311 : : *
312 : : * Returns: %TRUE if successful, %FALSE otherwise.
313 : : *
314 : : * Since: 0.10.22
315 : : */
316 : :
317 : : /**
318 : : * gst_byte_reader_peek_uint16_le:
319 : : * @reader: a #GstByteReader instance
320 : : * @val: Pointer to a #guint16 to store the result
321 : : *
322 : : * Read an unsigned 16 bit little endian integer into @val
323 : : * but keep the current position.
324 : : *
325 : : * Returns: %TRUE if successful, %FALSE otherwise.
326 : : *
327 : : * Since: 0.10.22
328 : : */
329 : :
330 : : /**
331 : : * gst_byte_reader_peek_int16_le:
332 : : * @reader: a #GstByteReader instance
333 : : * @val: Pointer to a #gint16 to store the result
334 : : *
335 : : * Read a signed 16 bit little endian integer into @val
336 : : * but keep the current position.
337 : : *
338 : : * Returns: %TRUE if successful, %FALSE otherwise.
339 : : *
340 : : * Since: 0.10.22
341 : : */
342 : :
343 : : /**
344 : : * gst_byte_reader_get_uint16_be:
345 : : * @reader: a #GstByteReader instance
346 : : * @val: Pointer to a #guint16 to store the result
347 : : *
348 : : * Read an unsigned 16 bit big endian integer into @val
349 : : * and update the current position.
350 : : *
351 : : * Returns: %TRUE if successful, %FALSE otherwise.
352 : : *
353 : : * Since: 0.10.22
354 : : */
355 : :
356 : : /**
357 : : * gst_byte_reader_get_int16_be:
358 : : * @reader: a #GstByteReader instance
359 : : * @val: Pointer to a #gint16 to store the result
360 : : *
361 : : * Read a signed 16 bit big endian integer into @val
362 : : * and update the current position.
363 : : *
364 : : * Returns: %TRUE if successful, %FALSE otherwise.
365 : : *
366 : : * Since: 0.10.22
367 : : */
368 : :
369 : : /**
370 : : * gst_byte_reader_peek_uint16_be:
371 : : * @reader: a #GstByteReader instance
372 : : * @val: Pointer to a #guint16 to store the result
373 : : *
374 : : * Read an unsigned 16 bit big endian integer into @val
375 : : * but keep the current position.
376 : : *
377 : : * Returns: %TRUE if successful, %FALSE otherwise.
378 : : *
379 : : * Since: 0.10.22
380 : : */
381 : :
382 : : /**
383 : : * gst_byte_reader_peek_int16_be:
384 : : * @reader: a #GstByteReader instance
385 : : * @val: Pointer to a #gint16 to store the result
386 : : *
387 : : * Read a signed 16 bit big endian integer into @val
388 : : * but keep the current position.
389 : : *
390 : : * Returns: %TRUE if successful, %FALSE otherwise.
391 : : *
392 : : * Since: 0.10.22
393 : : */
394 : :
395 : : /**
396 : : * gst_byte_reader_get_uint24_le:
397 : : * @reader: a #GstByteReader instance
398 : : * @val: Pointer to a #guint32 to store the result
399 : : *
400 : : * Read an unsigned 24 bit little endian integer into @val
401 : : * and update the current position.
402 : : *
403 : : * Returns: %TRUE if successful, %FALSE otherwise.
404 : : *
405 : : * Since: 0.10.22
406 : : */
407 : :
408 : : /**
409 : : * gst_byte_reader_get_int24_le:
410 : : * @reader: a #GstByteReader instance
411 : : * @val: Pointer to a #gint32 to store the result
412 : : *
413 : : * Read a signed 24 bit little endian integer into @val
414 : : * and update the current position.
415 : : *
416 : : * Returns: %TRUE if successful, %FALSE otherwise.
417 : : *
418 : : * Since: 0.10.22
419 : : */
420 : :
421 : : /**
422 : : * gst_byte_reader_peek_uint24_le:
423 : : * @reader: a #GstByteReader instance
424 : : * @val: Pointer to a #guint32 to store the result
425 : : *
426 : : * Read an unsigned 24 bit little endian integer into @val
427 : : * but keep the current position.
428 : : *
429 : : * Returns: %TRUE if successful, %FALSE otherwise.
430 : : *
431 : : * Since: 0.10.22
432 : : */
433 : :
434 : : /**
435 : : * gst_byte_reader_peek_int24_le:
436 : : * @reader: a #GstByteReader instance
437 : : * @val: Pointer to a #gint32 to store the result
438 : : *
439 : : * Read a signed 24 bit little endian integer into @val
440 : : * but keep the current position.
441 : : *
442 : : * Returns: %TRUE if successful, %FALSE otherwise.
443 : : *
444 : : * Since: 0.10.22
445 : : */
446 : :
447 : : /**
448 : : * gst_byte_reader_get_uint24_be:
449 : : * @reader: a #GstByteReader instance
450 : : * @val: Pointer to a #guint32 to store the result
451 : : *
452 : : * Read an unsigned 24 bit big endian integer into @val
453 : : * and update the current position.
454 : : *
455 : : * Returns: %TRUE if successful, %FALSE otherwise.
456 : : *
457 : : * Since: 0.10.22
458 : : */
459 : :
460 : : /**
461 : : * gst_byte_reader_get_int24_be:
462 : : * @reader: a #GstByteReader instance
463 : : * @val: Pointer to a #gint32 to store the result
464 : : *
465 : : * Read a signed 24 bit big endian integer into @val
466 : : * and update the current position.
467 : : *
468 : : * Returns: %TRUE if successful, %FALSE otherwise.
469 : : *
470 : : * Since: 0.10.22
471 : : */
472 : :
473 : : /**
474 : : * gst_byte_reader_peek_uint24_be:
475 : : * @reader: a #GstByteReader instance
476 : : * @val: Pointer to a #guint32 to store the result
477 : : *
478 : : * Read an unsigned 24 bit big endian integer into @val
479 : : * but keep the current position.
480 : : *
481 : : * Returns: %TRUE if successful, %FALSE otherwise.
482 : : *
483 : : * Since: 0.10.22
484 : : */
485 : :
486 : : /**
487 : : * gst_byte_reader_peek_int24_be:
488 : : * @reader: a #GstByteReader instance
489 : : * @val: Pointer to a #gint32 to store the result
490 : : *
491 : : * Read a signed 24 bit big endian integer into @val
492 : : * but keep the current position.
493 : : *
494 : : * Returns: %TRUE if successful, %FALSE otherwise.
495 : : *
496 : : * Since: 0.10.22
497 : : */
498 : :
499 : :
500 : : /**
501 : : * gst_byte_reader_get_uint32_le:
502 : : * @reader: a #GstByteReader instance
503 : : * @val: Pointer to a #guint32 to store the result
504 : : *
505 : : * Read an unsigned 32 bit little endian integer into @val
506 : : * and update the current position.
507 : : *
508 : : * Returns: %TRUE if successful, %FALSE otherwise.
509 : : *
510 : : * Since: 0.10.22
511 : : */
512 : :
513 : : /**
514 : : * gst_byte_reader_get_int32_le:
515 : : * @reader: a #GstByteReader instance
516 : : * @val: Pointer to a #gint32 to store the result
517 : : *
518 : : * Read a signed 32 bit little endian integer into @val
519 : : * and update the current position.
520 : : *
521 : : * Returns: %TRUE if successful, %FALSE otherwise.
522 : : *
523 : : * Since: 0.10.22
524 : : */
525 : :
526 : : /**
527 : : * gst_byte_reader_peek_uint32_le:
528 : : * @reader: a #GstByteReader instance
529 : : * @val: Pointer to a #guint32 to store the result
530 : : *
531 : : * Read an unsigned 32 bit little endian integer into @val
532 : : * but keep the current position.
533 : : *
534 : : * Returns: %TRUE if successful, %FALSE otherwise.
535 : : *
536 : : * Since: 0.10.22
537 : : */
538 : :
539 : : /**
540 : : * gst_byte_reader_peek_int32_le:
541 : : * @reader: a #GstByteReader instance
542 : : * @val: Pointer to a #gint32 to store the result
543 : : *
544 : : * Read a signed 32 bit little endian integer into @val
545 : : * but keep the current position.
546 : : *
547 : : * Returns: %TRUE if successful, %FALSE otherwise.
548 : : *
549 : : * Since: 0.10.22
550 : : */
551 : :
552 : : /**
553 : : * gst_byte_reader_get_uint32_be:
554 : : * @reader: a #GstByteReader instance
555 : : * @val: Pointer to a #guint32 to store the result
556 : : *
557 : : * Read an unsigned 32 bit big endian integer into @val
558 : : * and update the current position.
559 : : *
560 : : * Returns: %TRUE if successful, %FALSE otherwise.
561 : : *
562 : : * Since: 0.10.22
563 : : */
564 : :
565 : : /**
566 : : * gst_byte_reader_get_int32_be:
567 : : * @reader: a #GstByteReader instance
568 : : * @val: Pointer to a #gint32 to store the result
569 : : *
570 : : * Read a signed 32 bit big endian integer into @val
571 : : * and update the current position.
572 : : *
573 : : * Returns: %TRUE if successful, %FALSE otherwise.
574 : : *
575 : : * Since: 0.10.22
576 : : */
577 : :
578 : : /**
579 : : * gst_byte_reader_peek_uint32_be:
580 : : * @reader: a #GstByteReader instance
581 : : * @val: Pointer to a #guint32 to store the result
582 : : *
583 : : * Read an unsigned 32 bit big endian integer into @val
584 : : * but keep the current position.
585 : : *
586 : : * Returns: %TRUE if successful, %FALSE otherwise.
587 : : *
588 : : * Since: 0.10.22
589 : : */
590 : :
591 : : /**
592 : : * gst_byte_reader_peek_int32_be:
593 : : * @reader: a #GstByteReader instance
594 : : * @val: Pointer to a #gint32 to store the result
595 : : *
596 : : * Read a signed 32 bit big endian integer into @val
597 : : * but keep the current position.
598 : : *
599 : : * Returns: %TRUE if successful, %FALSE otherwise.
600 : : *
601 : : * Since: 0.10.22
602 : : */
603 : :
604 : : /**
605 : : * gst_byte_reader_get_uint64_le:
606 : : * @reader: a #GstByteReader instance
607 : : * @val: Pointer to a #guint64 to store the result
608 : : *
609 : : * Read an unsigned 64 bit little endian integer into @val
610 : : * and update the current position.
611 : : *
612 : : * Returns: %TRUE if successful, %FALSE otherwise.
613 : : *
614 : : * Since: 0.10.22
615 : : */
616 : :
617 : : /**
618 : : * gst_byte_reader_get_int64_le:
619 : : * @reader: a #GstByteReader instance
620 : : * @val: Pointer to a #gint64 to store the result
621 : : *
622 : : * Read a signed 64 bit little endian integer into @val
623 : : * and update the current position.
624 : : *
625 : : * Returns: %TRUE if successful, %FALSE otherwise.
626 : : *
627 : : * Since: 0.10.22
628 : : */
629 : :
630 : : /**
631 : : * gst_byte_reader_peek_uint64_le:
632 : : * @reader: a #GstByteReader instance
633 : : * @val: Pointer to a #guint64 to store the result
634 : : *
635 : : * Read an unsigned 64 bit little endian integer into @val
636 : : * but keep the current position.
637 : : *
638 : : * Returns: %TRUE if successful, %FALSE otherwise.
639 : : *
640 : : * Since: 0.10.22
641 : : */
642 : :
643 : : /**
644 : : * gst_byte_reader_peek_int64_le:
645 : : * @reader: a #GstByteReader instance
646 : : * @val: Pointer to a #gint64 to store the result
647 : : *
648 : : * Read a signed 64 bit little endian integer into @val
649 : : * but keep the current position.
650 : : *
651 : : * Returns: %TRUE if successful, %FALSE otherwise.
652 : : *
653 : : * Since: 0.10.22
654 : : */
655 : :
656 : : /**
657 : : * gst_byte_reader_get_uint64_be:
658 : : * @reader: a #GstByteReader instance
659 : : * @val: Pointer to a #guint64 to store the result
660 : : *
661 : : * Read an unsigned 64 bit big endian integer into @val
662 : : * and update the current position.
663 : : *
664 : : * Returns: %TRUE if successful, %FALSE otherwise.
665 : : *
666 : : * Since: 0.10.22
667 : : */
668 : :
669 : : /**
670 : : * gst_byte_reader_get_int64_be:
671 : : * @reader: a #GstByteReader instance
672 : : * @val: Pointer to a #gint64 to store the result
673 : : *
674 : : * Read a signed 64 bit big endian integer into @val
675 : : * and update the current position.
676 : : *
677 : : * Returns: %TRUE if successful, %FALSE otherwise.
678 : : *
679 : : * Since: 0.10.22
680 : : */
681 : :
682 : : /**
683 : : * gst_byte_reader_peek_uint64_be:
684 : : * @reader: a #GstByteReader instance
685 : : * @val: Pointer to a #guint64 to store the result
686 : : *
687 : : * Read an unsigned 64 bit big endian integer into @val
688 : : * but keep the current position.
689 : : *
690 : : * Returns: %TRUE if successful, %FALSE otherwise.
691 : : *
692 : : * Since: 0.10.22
693 : : */
694 : :
695 : : /**
696 : : * gst_byte_reader_peek_int64_be:
697 : : * @reader: a #GstByteReader instance
698 : : * @val: Pointer to a #gint64 to store the result
699 : : *
700 : : * Read a signed 64 bit big endian integer into @val
701 : : * but keep the current position.
702 : : *
703 : : * Returns: %TRUE if successful, %FALSE otherwise.
704 : : *
705 : : * Since: 0.10.22
706 : : */
707 : :
708 : : #define GST_BYTE_READER_PEEK_GET(bits,type,name) \
709 : : gboolean \
710 : : gst_byte_reader_get_##name (GstByteReader * reader, type * val) \
711 : : { \
712 : : return _gst_byte_reader_get_##name##_inline (reader, val); \
713 : : } \
714 : : \
715 : : gboolean \
716 : : gst_byte_reader_peek_##name (const GstByteReader * reader, type * val) \
717 : : { \
718 : : return _gst_byte_reader_peek_##name##_inline (reader, val); \
719 : : }
720 : :
721 : : /* *INDENT-OFF* */
722 : :
723 : 0 : GST_BYTE_READER_PEEK_GET(8,guint8,uint8)
724 : 0 : GST_BYTE_READER_PEEK_GET(8,gint8,int8)
725 : :
726 : 0 : GST_BYTE_READER_PEEK_GET(16,guint16,uint16_le)
727 : 0 : GST_BYTE_READER_PEEK_GET(16,guint16,uint16_be)
728 : 0 : GST_BYTE_READER_PEEK_GET(16,gint16,int16_le)
729 : 0 : GST_BYTE_READER_PEEK_GET(16,gint16,int16_be)
730 : :
731 : 0 : GST_BYTE_READER_PEEK_GET(24,guint32,uint24_le)
732 : 0 : GST_BYTE_READER_PEEK_GET(24,guint32,uint24_be)
733 : 0 : GST_BYTE_READER_PEEK_GET(24,gint32,int24_le)
734 : 0 : GST_BYTE_READER_PEEK_GET(24,gint32,int24_be)
735 : :
736 : 0 : GST_BYTE_READER_PEEK_GET(32,guint32,uint32_le)
737 : 0 : GST_BYTE_READER_PEEK_GET(32,guint32,uint32_be)
738 : 0 : GST_BYTE_READER_PEEK_GET(32,gint32,int32_le)
739 : 0 : GST_BYTE_READER_PEEK_GET(32,gint32,int32_be)
740 : :
741 : 0 : GST_BYTE_READER_PEEK_GET(64,guint64,uint64_le)
742 : 0 : GST_BYTE_READER_PEEK_GET(64,guint64,uint64_be)
743 : 0 : GST_BYTE_READER_PEEK_GET(64,gint64,int64_le)
744 : 0 : GST_BYTE_READER_PEEK_GET(64,gint64,int64_be)
745 : :
746 : : /**
747 : : * gst_byte_reader_get_float32_le:
748 : : * @reader: a #GstByteReader instance
749 : : * @val: Pointer to a #gfloat to store the result
750 : : *
751 : : * Read a 32 bit little endian floating point value into @val
752 : : * and update the current position.
753 : : *
754 : : * Returns: %TRUE if successful, %FALSE otherwise.
755 : : *
756 : : * Since: 0.10.22
757 : : */
758 : :
759 : : /**
760 : : * gst_byte_reader_peek_float32_le:
761 : : * @reader: a #GstByteReader instance
762 : : * @val: Pointer to a #gfloat to store the result
763 : : *
764 : : * Read a 32 bit little endian floating point value into @val
765 : : * but keep the current position.
766 : : *
767 : : * Returns: %TRUE if successful, %FALSE otherwise.
768 : : *
769 : : * Since: 0.10.22
770 : : */
771 : :
772 : : /**
773 : : * gst_byte_reader_get_float32_be:
774 : : * @reader: a #GstByteReader instance
775 : : * @val: Pointer to a #gfloat to store the result
776 : : *
777 : : * Read a 32 bit big endian floating point value into @val
778 : : * and update the current position.
779 : : *
780 : : * Returns: %TRUE if successful, %FALSE otherwise.
781 : : *
782 : : * Since: 0.10.22
783 : : */
784 : :
785 : : /**
786 : : * gst_byte_reader_peek_float32_be:
787 : : * @reader: a #GstByteReader instance
788 : : * @val: Pointer to a #gfloat to store the result
789 : : *
790 : : * Read a 32 bit big endian floating point value into @val
791 : : * but keep the current position.
792 : : *
793 : : * Returns: %TRUE if successful, %FALSE otherwise.
794 : : *
795 : : * Since: 0.10.22
796 : : */
797 : :
798 : : /**
799 : : * gst_byte_reader_get_float64_le:
800 : : * @reader: a #GstByteReader instance
801 : : * @val: Pointer to a #gdouble to store the result
802 : : *
803 : : * Read a 64 bit little endian floating point value into @val
804 : : * and update the current position.
805 : : *
806 : : * Returns: %TRUE if successful, %FALSE otherwise.
807 : : *
808 : : * Since: 0.10.22
809 : : */
810 : :
811 : : /**
812 : : * gst_byte_reader_peek_float64_le:
813 : : * @reader: a #GstByteReader instance
814 : : * @val: Pointer to a #gdouble to store the result
815 : : *
816 : : * Read a 64 bit little endian floating point value into @val
817 : : * but keep the current position.
818 : : *
819 : : * Returns: %TRUE if successful, %FALSE otherwise.
820 : : *
821 : : * Since: 0.10.22
822 : : */
823 : :
824 : : /**
825 : : * gst_byte_reader_get_float64_be:
826 : : * @reader: a #GstByteReader instance
827 : : * @val: Pointer to a #gdouble to store the result
828 : : *
829 : : * Read a 64 bit big endian floating point value into @val
830 : : * and update the current position.
831 : : *
832 : : * Returns: %TRUE if successful, %FALSE otherwise.
833 : : *
834 : : * Since: 0.10.22
835 : : */
836 : :
837 : : /**
838 : : * gst_byte_reader_peek_float64_be:
839 : : * @reader: a #GstByteReader instance
840 : : * @val: Pointer to a #gdouble to store the result
841 : : *
842 : : * Read a 64 bit big endian floating point value into @val
843 : : * but keep the current position.
844 : : *
845 : : * Returns: %TRUE if successful, %FALSE otherwise.
846 : : *
847 : : * Since: 0.10.22
848 : : */
849 : :
850 : 0 : GST_BYTE_READER_PEEK_GET(32,gfloat,float32_le)
851 : 0 : GST_BYTE_READER_PEEK_GET(32,gfloat,float32_be)
852 : 0 : GST_BYTE_READER_PEEK_GET(64,gdouble,float64_le)
853 : 0 : GST_BYTE_READER_PEEK_GET(64,gdouble,float64_be)
854 : :
855 : : /* *INDENT-ON* */
856 : :
857 : : /**
858 : : * gst_byte_reader_get_data:
859 : : * @reader: a #GstByteReader instance
860 : : * @size: Size in bytes
861 : : * @val: (out) (transfer none) (array length=size): address of a
862 : : * #guint8 pointer variable in which to store the result
863 : : *
864 : : * Returns a constant pointer to the current data
865 : : * position if at least @size bytes are left and
866 : : * updates the current position.
867 : : *
868 : : *
869 : : * Returns: %TRUE if successful, %FALSE otherwise.
870 : : *
871 : : * Since: 0.10.22
872 : : */
873 : : gboolean
874 : 0 : gst_byte_reader_get_data (GstByteReader * reader, guint size,
875 : : const guint8 ** val)
876 : : {
877 : 0 : return _gst_byte_reader_get_data_inline (reader, size, val);
878 : : }
879 : :
880 : : /**
881 : : * gst_byte_reader_peek_data:
882 : : * @reader: a #GstByteReader instance
883 : : * @size: Size in bytes
884 : : * @val: (out) (transfer none) (array length=size): address of a
885 : : * #guint8 pointer variable in which to store the result
886 : : *
887 : : * Returns a constant pointer to the current data
888 : : * position if at least @size bytes are left and
889 : : * keeps the current position.
890 : : *
891 : : *
892 : : * Returns: %TRUE if successful, %FALSE otherwise.
893 : : *
894 : : * Since: 0.10.22
895 : : */
896 : : gboolean
897 : 0 : gst_byte_reader_peek_data (const GstByteReader * reader, guint size,
898 : : const guint8 ** val)
899 : : {
900 : 0 : return _gst_byte_reader_peek_data_inline (reader, size, val);
901 : : }
902 : :
903 : : /**
904 : : * gst_byte_reader_dup_data:
905 : : * @reader: a #GstByteReader instance
906 : : * @size: Size in bytes
907 : : * @val: (out) (transfer full) (array length=size): address of a
908 : : * #guint8 pointer variable in which to store the result
909 : : *
910 : : * Free-function: g_free
911 : : *
912 : : * Returns a newly-allocated copy of the current data
913 : : * position if at least @size bytes are left and
914 : : * updates the current position. Free with g_free() when no longer needed.
915 : : *
916 : : * Returns: %TRUE if successful, %FALSE otherwise.
917 : : *
918 : : * Since: 0.10.24
919 : : */
920 : : gboolean
921 : 0 : gst_byte_reader_dup_data (GstByteReader * reader, guint size, guint8 ** val)
922 : : {
923 : 0 : return _gst_byte_reader_dup_data_inline (reader, size, val);
924 : : }
925 : :
926 : : /**
927 : : * gst_byte_reader_masked_scan_uint32:
928 : : * @reader: a #GstByteReader
929 : : * @mask: mask to apply to data before matching against @pattern
930 : : * @pattern: pattern to match (after mask is applied)
931 : : * @offset: offset from which to start scanning, relative to the current
932 : : * position
933 : : * @size: number of bytes to scan from offset
934 : : *
935 : : * Scan for pattern @pattern with applied mask @mask in the byte reader data,
936 : : * starting from offset @offset relative to the current position.
937 : : *
938 : : * The bytes in @pattern and @mask are interpreted left-to-right, regardless
939 : : * of endianness. All four bytes of the pattern must be present in the
940 : : * byte reader data for it to match, even if the first or last bytes are masked
941 : : * out.
942 : : *
943 : : * It is an error to call this function without making sure that there is
944 : : * enough data (offset+size bytes) in the byte reader.
945 : : *
946 : : * Returns: offset of the first match, or -1 if no match was found.
947 : : *
948 : : * Example:
949 : : * <programlisting>
950 : : * // Assume the reader contains 0x00 0x01 0x02 ... 0xfe 0xff
951 : : *
952 : : * gst_byte_reader_masked_scan_uint32 (reader, 0xffffffff, 0x00010203, 0, 256);
953 : : * // -> returns 0
954 : : * gst_byte_reader_masked_scan_uint32 (reader, 0xffffffff, 0x00010203, 1, 255);
955 : : * // -> returns -1
956 : : * gst_byte_reader_masked_scan_uint32 (reader, 0xffffffff, 0x01020304, 1, 255);
957 : : * // -> returns 1
958 : : * gst_byte_reader_masked_scan_uint32 (reader, 0xffff, 0x0001, 0, 256);
959 : : * // -> returns -1
960 : : * gst_byte_reader_masked_scan_uint32 (reader, 0xffff, 0x0203, 0, 256);
961 : : * // -> returns 0
962 : : * gst_byte_reader_masked_scan_uint32 (reader, 0xffff0000, 0x02030000, 0, 256);
963 : : * // -> returns 2
964 : : * gst_byte_reader_masked_scan_uint32 (reader, 0xffff0000, 0x02030000, 0, 4);
965 : : * // -> returns -1
966 : : * </programlisting>
967 : : *
968 : : * Since: 0.10.24
969 : : */
970 : : guint
971 : 42 : gst_byte_reader_masked_scan_uint32 (const GstByteReader * reader, guint32 mask,
972 : : guint32 pattern, guint offset, guint size)
973 : : {
974 : : const guint8 *data;
975 : : guint32 state;
976 : : guint i;
977 : :
978 [ - + ]: 42 : g_return_val_if_fail (size > 0, -1);
979 [ - + ]: 42 : g_return_val_if_fail ((guint64) offset + size <= reader->size - reader->byte,
980 : : -1);
981 : :
982 : : /* we can't find the pattern with less than 4 bytes */
983 [ + + ]: 42 : if (G_UNLIKELY (size < 4))
984 : 3 : return -1;
985 : :
986 : 39 : data = reader->data + reader->byte + offset;
987 : :
988 : : /* set the state to something that does not match */
989 : 39 : state = ~pattern;
990 : :
991 : : /* now find data */
992 [ + + ]: 1990 : for (i = 0; i < size; i++) {
993 : : /* throw away one byte and move in the next byte */
994 : 1976 : state = ((state << 8) | data[i]);
995 [ + + ]: 1976 : if (G_UNLIKELY ((state & mask) == pattern)) {
996 : : /* we have a match but we need to have skipped at
997 : : * least 4 bytes to fill the state. */
998 [ + + ]: 27 : if (G_LIKELY (i >= 3))
999 : 25 : return offset + i - 3;
1000 : : }
1001 : : }
1002 : :
1003 : : /* nothing found */
1004 : 42 : return -1;
1005 : : }
1006 : :
1007 : : #define GST_BYTE_READER_SCAN_STRING(bits) \
1008 : : static guint \
1009 : : gst_byte_reader_scan_string_utf##bits (const GstByteReader * reader) \
1010 : : { \
1011 : : guint len, off, max_len; \
1012 : : \
1013 : : max_len = (reader->size - reader->byte) / sizeof (guint##bits); \
1014 : : \
1015 : : /* need at least a single NUL terminator */ \
1016 : : if (max_len < 1) \
1017 : : return 0; \
1018 : : \
1019 : : len = 0; \
1020 : : off = reader->byte; \
1021 : : /* endianness does not matter if we are looking for a NUL terminator */ \
1022 : : while (GST_READ_UINT##bits##_LE (&reader->data[off]) != 0) { \
1023 : : ++len; \
1024 : : off += sizeof (guint##bits); \
1025 : : /* have we reached the end without finding a NUL terminator? */ \
1026 : : if (len == max_len) \
1027 : : return 0; \
1028 : : } \
1029 : : /* return size in bytes including the NUL terminator (hence the +1) */ \
1030 : : return (len + 1) * sizeof (guint##bits); \
1031 : : }
1032 : :
1033 : : #define GST_READ_UINT8_LE GST_READ_UINT8
1034 [ - + ][ + + ]: 1773 : GST_BYTE_READER_SCAN_STRING (8);
[ + + ]
1035 : : #undef GST_READ_UINT8_LE
1036 [ - + ][ + + ]: 455 : GST_BYTE_READER_SCAN_STRING (16);
[ + + ]
1037 [ - + ][ + + ]: 271 : GST_BYTE_READER_SCAN_STRING (32);
[ + + ]
1038 : :
1039 : : #define GST_BYTE_READER_SKIP_STRING(bits) \
1040 : : gboolean \
1041 : : gst_byte_reader_skip_string_utf##bits (GstByteReader * reader) \
1042 : : { \
1043 : : guint size; /* size in bytes including the terminator */ \
1044 : : \
1045 : : g_return_val_if_fail (reader != NULL, FALSE); \
1046 : : \
1047 : : size = gst_byte_reader_scan_string_utf##bits (reader); \
1048 : : reader->byte += size; \
1049 : : return (size > 0); \
1050 : : }
1051 : :
1052 : : /**
1053 : : * gst_byte_reader_skip_string:
1054 : : * @reader: a #GstByteReader instance
1055 : : *
1056 : : * Skips a NUL-terminated string in the #GstByteReader instance, advancing
1057 : : * the current position to the byte after the string. This will work for
1058 : : * any NUL-terminated string with a character width of 8 bits, so ASCII,
1059 : : * UTF-8, ISO-8859-N etc.
1060 : : *
1061 : : * This function will fail if no NUL-terminator was found in in the data.
1062 : : *
1063 : : * Returns: %TRUE if a string could be skipped, %FALSE otherwise.
1064 : : *
1065 : : * Since: 0.10.24
1066 : : */
1067 : : /**
1068 : : * gst_byte_reader_skip_string_utf8:
1069 : : * @reader: a #GstByteReader instance
1070 : : *
1071 : : * Skips a NUL-terminated string in the #GstByteReader instance, advancing
1072 : : * the current position to the byte after the string. This will work for
1073 : : * any NUL-terminated string with a character width of 8 bits, so ASCII,
1074 : : * UTF-8, ISO-8859-N etc. No input checking for valid UTF-8 is done.
1075 : : *
1076 : : * This function will fail if no NUL-terminator was found in in the data.
1077 : : *
1078 : : * Returns: %TRUE if a string could be skipped, %FALSE otherwise.
1079 : : *
1080 : : * Since: 0.10.24
1081 : : */
1082 [ - + ]: 8 : GST_BYTE_READER_SKIP_STRING (8);
1083 : :
1084 : : /**
1085 : : * gst_byte_reader_skip_string_utf16:
1086 : : * @reader: a #GstByteReader instance
1087 : : *
1088 : : * Skips a NUL-terminated UTF-16 string in the #GstByteReader instance,
1089 : : * advancing the current position to the byte after the string.
1090 : : *
1091 : : * No input checking for valid UTF-16 is done.
1092 : : *
1093 : : * This function will fail if no NUL-terminator was found in in the data.
1094 : : *
1095 : : * Returns: %TRUE if a string could be skipped, %FALSE otherwise.
1096 : : *
1097 : : * Since: 0.10.24
1098 : : */
1099 [ - + ]: 5 : GST_BYTE_READER_SKIP_STRING (16);
1100 : :
1101 : : /**
1102 : : * gst_byte_reader_skip_string_utf32:
1103 : : * @reader: a #GstByteReader instance
1104 : : *
1105 : : * Skips a NUL-terminated UTF-32 string in the #GstByteReader instance,
1106 : : * advancing the current position to the byte after the string.
1107 : : *
1108 : : * No input checking for valid UTF-32 is done.
1109 : : *
1110 : : * This function will fail if no NUL-terminator was found in in the data.
1111 : : *
1112 : : * Returns: %TRUE if a string could be skipped, %FALSE otherwise.
1113 : : *
1114 : : * Since: 0.10.24
1115 : : */
1116 [ - + ]: 5 : GST_BYTE_READER_SKIP_STRING (32);
1117 : :
1118 : : /**
1119 : : * gst_byte_reader_peek_string:
1120 : : * @reader: a #GstByteReader instance
1121 : : * @str: (out) (transfer none) (array zero-terminated=1): address of a
1122 : : * #gchar pointer varieble in which to store the result
1123 : : *
1124 : : * Returns a constant pointer to the current data position if there is
1125 : : * a NUL-terminated string in the data (this could be just a NUL terminator).
1126 : : * The current position will be maintained. This will work for any
1127 : : * NUL-terminated string with a character width of 8 bits, so ASCII,
1128 : : * UTF-8, ISO-8859-N etc.
1129 : : *
1130 : : * This function will fail if no NUL-terminator was found in in the data.
1131 : : *
1132 : : * Returns: %TRUE if a string could be skipped, %FALSE otherwise.
1133 : : *
1134 : : * Since: 0.10.24
1135 : : */
1136 : : /**
1137 : : * gst_byte_reader_peek_string_utf8:
1138 : : * @reader: a #GstByteReader instance
1139 : : * @str: (out) (transfer none) (array zero-terminated=1): address of a
1140 : : * #gchar pointer varieble in which to store the result
1141 : : *
1142 : : * Returns a constant pointer to the current data position if there is
1143 : : * a NUL-terminated string in the data (this could be just a NUL terminator).
1144 : : * The current position will be maintained. This will work for any
1145 : : * NUL-terminated string with a character width of 8 bits, so ASCII,
1146 : : * UTF-8, ISO-8859-N etc.
1147 : : *
1148 : : * No input checking for valid UTF-8 is done.
1149 : : *
1150 : : * This function will fail if no NUL-terminator was found in in the data.
1151 : : *
1152 : : * Returns: %TRUE if a string could be skipped, %FALSE otherwise.
1153 : : *
1154 : : * Since: 0.10.24
1155 : : */
1156 : : gboolean
1157 : 8 : gst_byte_reader_peek_string_utf8 (const GstByteReader * reader,
1158 : : const gchar ** str)
1159 : : {
1160 [ - + ]: 8 : g_return_val_if_fail (reader != NULL, FALSE);
1161 [ - + ]: 8 : g_return_val_if_fail (str != NULL, FALSE);
1162 : :
1163 [ + + ]: 8 : if (gst_byte_reader_scan_string_utf8 (reader) > 0) {
1164 : 6 : *str = (const gchar *) (reader->data + reader->byte);
1165 : : } else {
1166 : 2 : *str = NULL;
1167 : : }
1168 : 8 : return (*str != NULL);
1169 : : }
1170 : :
1171 : : /**
1172 : : * gst_byte_reader_get_string_utf8:
1173 : : * @reader: a #GstByteReader instance
1174 : : * @str: (out) (transfer none) (array zero-terminated=1): address of a
1175 : : * #gchar pointer varieble in which to store the result
1176 : : *
1177 : : * Returns a constant pointer to the current data position if there is
1178 : : * a NUL-terminated string in the data (this could be just a NUL terminator),
1179 : : * advancing the current position to the byte after the string. This will work
1180 : : * for any NUL-terminated string with a character width of 8 bits, so ASCII,
1181 : : * UTF-8, ISO-8859-N etc.
1182 : : *
1183 : : * No input checking for valid UTF-8 is done.
1184 : : *
1185 : : * This function will fail if no NUL-terminator was found in in the data.
1186 : : *
1187 : : * Returns: %TRUE if a string could be found, %FALSE otherwise.
1188 : : *
1189 : : * Since: 0.10.24
1190 : : */
1191 : : gboolean
1192 : 2 : gst_byte_reader_get_string_utf8 (GstByteReader * reader, const gchar ** str)
1193 : : {
1194 : : guint size; /* size in bytes including the terminator */
1195 : :
1196 [ - + ]: 2 : g_return_val_if_fail (reader != NULL, FALSE);
1197 [ - + ]: 2 : g_return_val_if_fail (str != NULL, FALSE);
1198 : :
1199 : 2 : size = gst_byte_reader_scan_string_utf8 (reader);
1200 [ + - ]: 2 : if (size == 0) {
1201 : 2 : *str = NULL;
1202 : 2 : return FALSE;
1203 : : }
1204 : :
1205 : 0 : *str = (const gchar *) (reader->data + reader->byte);
1206 : 0 : reader->byte += size;
1207 : 2 : return TRUE;
1208 : : }
1209 : :
1210 : : #define GST_BYTE_READER_DUP_STRING(bits,type) \
1211 : : gboolean \
1212 : : gst_byte_reader_dup_string_utf##bits (GstByteReader * reader, type ** str) \
1213 : : { \
1214 : : guint size; /* size in bytes including the terminator */ \
1215 : : \
1216 : : g_return_val_if_fail (reader != NULL, FALSE); \
1217 : : g_return_val_if_fail (str != NULL, FALSE); \
1218 : : \
1219 : : size = gst_byte_reader_scan_string_utf##bits (reader); \
1220 : : if (size == 0) { \
1221 : : *str = NULL; \
1222 : : return FALSE; \
1223 : : } \
1224 : : *str = g_memdup (reader->data + reader->byte, size); \
1225 : : reader->byte += size; \
1226 : : return TRUE; \
1227 : : }
1228 : :
1229 : : /**
1230 : : * gst_byte_reader_dup_string_utf8:
1231 : : * @reader: a #GstByteReader instance
1232 : : * @str: (out) (transfer full) (array zero-terminated=1): address of a
1233 : : * #gchar pointer varieble in which to store the result
1234 : : *
1235 : : * Free-function: g_free
1236 : : *
1237 : : * FIXME:Reads (copies) a NUL-terminated string in the #GstByteReader instance,
1238 : : * advancing the current position to the byte after the string. This will work
1239 : : * for any NUL-terminated string with a character width of 8 bits, so ASCII,
1240 : : * UTF-8, ISO-8859-N etc. No input checking for valid UTF-8 is done.
1241 : : *
1242 : : * This function will fail if no NUL-terminator was found in in the data.
1243 : : *
1244 : : * Returns: %TRUE if a string could be read into @str, %FALSE otherwise. The
1245 : : * string put into @str must be freed with g_free() when no longer needed.
1246 : : *
1247 : : * Since: 0.10.24
1248 : : */
1249 [ - + ][ - + ]: 3 : GST_BYTE_READER_DUP_STRING (8, gchar);
[ + + ]
1250 : :
1251 : : /**
1252 : : * gst_byte_reader_dup_string_utf16:
1253 : : * @reader: a #GstByteReader instance
1254 : : * @str: (out) (transfer full) (array zero-terminated=1): address of a
1255 : : * #guint16 pointer varieble in which to store the result
1256 : : *
1257 : : * Free-function: g_free
1258 : : *
1259 : : * Returns a newly-allocated copy of the current data position if there is
1260 : : * a NUL-terminated UTF-16 string in the data (this could be an empty string
1261 : : * as well), and advances the current position.
1262 : : *
1263 : : * No input checking for valid UTF-16 is done. This function is endianness
1264 : : * agnostic - you should not assume the UTF-16 characters are in host
1265 : : * endianness.
1266 : : *
1267 : : * This function will fail if no NUL-terminator was found in in the data.
1268 : : *
1269 : : * Note: there is no peek or get variant of this function to ensure correct
1270 : : * byte alignment of the UTF-16 string.
1271 : : *
1272 : : * Returns: %TRUE if a string could be read, %FALSE otherwise. The
1273 : : * string put into @str must be freed with g_free() when no longer needed.
1274 : : *
1275 : : * Since: 0.10.24
1276 : : */
1277 [ - + ][ - + ]: 5 : GST_BYTE_READER_DUP_STRING (16, guint16);
[ + + ]
1278 : :
1279 : : /**
1280 : : * gst_byte_reader_dup_string_utf32:
1281 : : * @reader: a #GstByteReader instance
1282 : : * @str: (out) (transfer full) (array zero-terminated=1): address of a
1283 : : * #guint32 pointer varieble in which to store the result
1284 : : *
1285 : : * Free-function: g_free
1286 : : *
1287 : : * Returns a newly-allocated copy of the current data position if there is
1288 : : * a NUL-terminated UTF-32 string in the data (this could be an empty string
1289 : : * as well), and advances the current position.
1290 : : *
1291 : : * No input checking for valid UTF-32 is done. This function is endianness
1292 : : * agnostic - you should not assume the UTF-32 characters are in host
1293 : : * endianness.
1294 : : *
1295 : : * This function will fail if no NUL-terminator was found in in the data.
1296 : : *
1297 : : * Note: there is no peek or get variant of this function to ensure correct
1298 : : * byte alignment of the UTF-32 string.
1299 : : *
1300 : : * Returns: %TRUE if a string could be read, %FALSE otherwise. The
1301 : : * string put into @str must be freed with g_free() when no longer needed.
1302 : : *
1303 : : * Since: 0.10.24
1304 : : */
1305 [ - + ][ - + ]: 6 : GST_BYTE_READER_DUP_STRING (32, guint32);
[ + + ]
|
