GCC Code Coverage Report

Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 44.6% 66 / 0 / 148
Functions: 16.7% 12 / 0 / 72
Branches: 10.4% 34 / 0 / 328
libfprint/fpi-byte-reader.h
Line Branch Exec Source
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., 51 Franklin St, Fifth Floor,
19 * Boston, MA 02110-1301, USA.
20 */
21
22 #pragma once
23
24 #include <glib.h>
25 #include "fpi-compat.h"
26 #include "fpi-byte-utils.h"
27
28 G_BEGIN_DECLS
29
30 #define FPI_BYTE_READER(reader) ((FpiByteReader *) (reader))
31
32 /**
33 * FpiByteReader:
34 * @data: (array length=size): Data from which the bit reader will
35 * read
36 * @size: Size of @data in bytes
37 * @byte: Current byte position
38 *
39 * A byte reader instance.
40 */
41 typedef struct {
42 const guint8 *data;
43 guint size;
44
45 guint byte; /* Byte position */
46
47 /* < private > */
48 } FpiByteReader;
49
50
51 FpiByteReader * fpi_byte_reader_new (const guint8 *data, guint size) G_GNUC_MALLOC;
52
53 FpiByteReader * fpi_byte_reader_new_bytes (GBytes *bytes) G_GNUC_MALLOC;
54
55 void fpi_byte_reader_free (FpiByteReader *reader);
56
57
58 void fpi_byte_reader_init (FpiByteReader *reader, const guint8 *data, guint size);
59
60
61 FpiByteReader * fpi_byte_reader_init_bytes (FpiByteReader *reader, GBytes *bytes);
62
63
64 gboolean fpi_byte_reader_peek_sub_reader (FpiByteReader * reader,
65 FpiByteReader * sub_reader,
66 guint size);
67
68 gboolean fpi_byte_reader_get_sub_reader (FpiByteReader * reader,
69 FpiByteReader * sub_reader,
70 guint size);
71
72 gboolean fpi_byte_reader_set_pos (FpiByteReader *reader, guint pos);
73
74
75 guint fpi_byte_reader_get_pos (const FpiByteReader *reader);
76
77
78 guint fpi_byte_reader_get_remaining (const FpiByteReader *reader);
79
80
81 guint fpi_byte_reader_get_size (const FpiByteReader *reader);
82
83
84 gboolean fpi_byte_reader_skip (FpiByteReader *reader, guint nbytes);
85
86
87 gboolean fpi_byte_reader_get_uint8 (FpiByteReader *reader, guint8 *val);
88
89
90 gboolean fpi_byte_reader_get_int8 (FpiByteReader *reader, gint8 *val);
91
92
93 gboolean fpi_byte_reader_get_uint16_le (FpiByteReader *reader, guint16 *val);
94
95
96 gboolean fpi_byte_reader_get_int16_le (FpiByteReader *reader, gint16 *val);
97
98
99 gboolean fpi_byte_reader_get_uint16_be (FpiByteReader *reader, guint16 *val);
100
101
102 gboolean fpi_byte_reader_get_int16_be (FpiByteReader *reader, gint16 *val);
103
104
105 gboolean fpi_byte_reader_get_uint24_le (FpiByteReader *reader, guint32 *val);
106
107
108 gboolean fpi_byte_reader_get_int24_le (FpiByteReader *reader, gint32 *val);
109
110
111 gboolean fpi_byte_reader_get_uint24_be (FpiByteReader *reader, guint32 *val);
112
113
114 gboolean fpi_byte_reader_get_int24_be (FpiByteReader *reader, gint32 *val);
115
116
117 gboolean fpi_byte_reader_get_uint32_le (FpiByteReader *reader, guint32 *val);
118
119
120 gboolean fpi_byte_reader_get_int32_le (FpiByteReader *reader, gint32 *val);
121
122
123 gboolean fpi_byte_reader_get_uint32_be (FpiByteReader *reader, guint32 *val);
124
125
126 gboolean fpi_byte_reader_get_int32_be (FpiByteReader *reader, gint32 *val);
127
128
129 gboolean fpi_byte_reader_get_uint64_le (FpiByteReader *reader, guint64 *val);
130
131
132 gboolean fpi_byte_reader_get_int64_le (FpiByteReader *reader, gint64 *val);
133
134
135 gboolean fpi_byte_reader_get_uint64_be (FpiByteReader *reader, guint64 *val);
136
137
138 gboolean fpi_byte_reader_get_int64_be (FpiByteReader *reader, gint64 *val);
139
140
141 gboolean fpi_byte_reader_peek_uint8 (const FpiByteReader *reader, guint8 *val);
142
143
144 gboolean fpi_byte_reader_peek_int8 (const FpiByteReader *reader, gint8 *val);
145
146
147 gboolean fpi_byte_reader_peek_uint16_le (const FpiByteReader *reader, guint16 *val);
148
149
150 gboolean fpi_byte_reader_peek_int16_le (const FpiByteReader *reader, gint16 *val);
151
152
153 gboolean fpi_byte_reader_peek_uint16_be (const FpiByteReader *reader, guint16 *val);
154
155
156 gboolean fpi_byte_reader_peek_int16_be (const FpiByteReader *reader, gint16 *val);
157
158
159 gboolean fpi_byte_reader_peek_uint24_le (const FpiByteReader *reader, guint32 *val);
160
161
162 gboolean fpi_byte_reader_peek_int24_le (const FpiByteReader *reader, gint32 *val);
163
164
165 gboolean fpi_byte_reader_peek_uint24_be (const FpiByteReader *reader, guint32 *val);
166
167
168 gboolean fpi_byte_reader_peek_int24_be (const FpiByteReader *reader, gint32 *val);
169
170
171 gboolean fpi_byte_reader_peek_uint32_le (const FpiByteReader *reader, guint32 *val);
172
173
174 gboolean fpi_byte_reader_peek_int32_le (const FpiByteReader *reader, gint32 *val);
175
176
177 gboolean fpi_byte_reader_peek_uint32_be (const FpiByteReader *reader, guint32 *val);
178
179
180 gboolean fpi_byte_reader_peek_int32_be (const FpiByteReader *reader, gint32 *val);
181
182
183 gboolean fpi_byte_reader_peek_uint64_le (const FpiByteReader *reader, guint64 *val);
184
185
186 gboolean fpi_byte_reader_peek_int64_le (const FpiByteReader *reader, gint64 *val);
187
188
189 gboolean fpi_byte_reader_peek_uint64_be (const FpiByteReader *reader, guint64 *val);
190
191
192 gboolean fpi_byte_reader_peek_int64_be (const FpiByteReader *reader, gint64 *val);
193
194
195 gboolean fpi_byte_reader_get_float32_le (FpiByteReader *reader, gfloat *val);
196
197
198 gboolean fpi_byte_reader_get_float32_be (FpiByteReader *reader, gfloat *val);
199
200
201 gboolean fpi_byte_reader_get_float64_le (FpiByteReader *reader, gdouble *val);
202
203
204 gboolean fpi_byte_reader_get_float64_be (FpiByteReader *reader, gdouble *val);
205
206
207 gboolean fpi_byte_reader_peek_float32_le (const FpiByteReader *reader, gfloat *val);
208
209
210 gboolean fpi_byte_reader_peek_float32_be (const FpiByteReader *reader, gfloat *val);
211
212
213 gboolean fpi_byte_reader_peek_float64_le (const FpiByteReader *reader, gdouble *val);
214
215
216 gboolean fpi_byte_reader_peek_float64_be (const FpiByteReader *reader, gdouble *val);
217
218
219 gboolean fpi_byte_reader_dup_data (FpiByteReader * reader, guint size, guint8 ** val);
220
221
222 gboolean fpi_byte_reader_get_data (FpiByteReader * reader, guint size, const guint8 ** val);
223
224
225 gboolean fpi_byte_reader_get_data_static (FpiByteReader * reader, guint size, const guint8 * val);
226
227
228 gboolean fpi_byte_reader_peek_data (const FpiByteReader * reader, guint size, const guint8 ** val);
229
230
231 gboolean fpi_byte_reader_peek_data_static (const FpiByteReader * reader, guint size, guint8 * val);
232
233
234 GBytes * fpi_byte_reader_get_bytes (FpiByteReader *reader, guint size);
235
236
237 GBytes * fpi_byte_reader_peek_bytes (const FpiByteReader *reader, guint size);
238
239
240 #define fpi_byte_reader_dup_string(reader,str) \
241 fpi_byte_reader_dup_string_utf8(reader,str)
242
243
244 gboolean fpi_byte_reader_dup_string_utf8 (FpiByteReader * reader, gchar ** str);
245
246
247 gboolean fpi_byte_reader_dup_string_utf16 (FpiByteReader * reader, guint16 ** str);
248
249
250 gboolean fpi_byte_reader_dup_string_utf32 (FpiByteReader * reader, guint32 ** str);
251
252 #define fpi_byte_reader_skip_string(reader) \
253 fpi_byte_reader_skip_string_utf8(reader)
254
255
256 gboolean fpi_byte_reader_skip_string_utf8 (FpiByteReader * reader);
257
258
259 gboolean fpi_byte_reader_skip_string_utf16 (FpiByteReader * reader);
260
261
262 gboolean fpi_byte_reader_skip_string_utf32 (FpiByteReader * reader);
263
264 #define fpi_byte_reader_get_string(reader,str) \
265 fpi_byte_reader_get_string_utf8(reader,str)
266
267 #define fpi_byte_reader_peek_string(reader,str) \
268 fpi_byte_reader_peek_string_utf8(reader,str)
269
270
271 gboolean fpi_byte_reader_get_string_utf8 (FpiByteReader * reader, const gchar ** str);
272
273
274 gboolean fpi_byte_reader_peek_string_utf8 (const FpiByteReader * reader, const gchar ** str);
275
276
277 guint fpi_byte_reader_masked_scan_uint32 (const FpiByteReader * reader,
278 guint32 mask,
279 guint32 pattern,
280 guint offset,
281 guint size);
282
283 guint fpi_byte_reader_masked_scan_uint32_peek (const FpiByteReader * reader,
284 guint32 mask,
285 guint32 pattern,
286 guint offset,
287 guint size,
288 guint32 * value);
289
290 /**
291 * FPI_BYTE_READER_INIT:
292 * @data: Data from which the #FpiByteReader should read
293 * @size: Size of @data in bytes
294 *
295 * A #FpiByteReader must be initialized with this macro, before it can be
296 * used. This macro can used be to initialize a variable, but it cannot
297 * be assigned to a variable. In that case you have to use
298 * fpi_byte_reader_init().
299 */
300 #define FPI_BYTE_READER_INIT(data, size) {data, size, 0}
301
302 /* unchecked variants */
303 static inline void
304 129 fpi_byte_reader_skip_unchecked (FpiByteReader * reader, guint nbytes)
305 {
306 129 reader->byte += nbytes;
307 }
308
309 #define __FPI_BYTE_READER_GET_PEEK_BITS_UNCHECKED(bits,type,lower,upper,adj) \
310 \
311 static inline type \
312 fpi_byte_reader_peek_##lower##_unchecked (const FpiByteReader * reader) \
313 { \
314 type val = (type) FP_READ_##upper (reader->data + reader->byte); \
315 adj \
316 return val; \
317 } \
318 \
319 static inline type \
320 fpi_byte_reader_get_##lower##_unchecked (FpiByteReader * reader) \
321 { \
322 type val = fpi_byte_reader_peek_##lower##_unchecked (reader); \
323 reader->byte += bits / 8; \
324 return val; \
325 }
326
327 1039 __FPI_BYTE_READER_GET_PEEK_BITS_UNCHECKED(8,guint8,uint8,UINT8,/* */)
328 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_UNCHECKED(8,gint8,int8,UINT8,/* */)
329
330 133 __FPI_BYTE_READER_GET_PEEK_BITS_UNCHECKED(16,guint16,uint16_le,UINT16_LE,/* */)
331 7951 __FPI_BYTE_READER_GET_PEEK_BITS_UNCHECKED(16,guint16,uint16_be,UINT16_BE,/* */)
332 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_UNCHECKED(16,gint16,int16_le,UINT16_LE,/* */)
333 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_UNCHECKED(16,gint16,int16_be,UINT16_BE,/* */)
334
335 260 __FPI_BYTE_READER_GET_PEEK_BITS_UNCHECKED(32,guint32,uint32_le,UINT32_LE,/* */)
336 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_UNCHECKED(32,guint32,uint32_be,UINT32_BE,/* */)
337 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_UNCHECKED(32,gint32,int32_le,UINT32_LE,/* */)
338 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_UNCHECKED(32,gint32,int32_be,UINT32_BE,/* */)
339
340 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_UNCHECKED(24,guint32,uint24_le,UINT24_LE,/* */)
341 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_UNCHECKED(24,guint32,uint24_be,UINT24_BE,/* */)
342
343 /* fix up the sign for 24-bit signed ints stored in 32-bit signed ints */
344 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_UNCHECKED(24,gint32,int24_le,UINT24_LE,
345 if (val & 0x00800000) val |= 0xff000000;)
346 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_UNCHECKED(24,gint32,int24_be,UINT24_BE,
347 if (val & 0x00800000) val |= 0xff000000;)
348
349 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_UNCHECKED(64,guint64,uint64_le,UINT64_LE,/* */)
350 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_UNCHECKED(64,guint64,uint64_be,UINT64_BE,/* */)
351 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_UNCHECKED(64,gint64,int64_le,UINT64_LE,/* */)
352 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_UNCHECKED(64,gint64,int64_be,UINT64_BE,/* */)
353
354 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_UNCHECKED(32,gfloat,float32_le,FLOAT_LE,/* */)
355 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_UNCHECKED(32,gfloat,float32_be,FLOAT_BE,/* */)
356 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_UNCHECKED(64,gdouble,float64_le,DOUBLE_LE,/* */)
357 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_UNCHECKED(64,gdouble,float64_be,DOUBLE_BE,/* */)
358
359 #undef __GET_PEEK_BITS_UNCHECKED
360
361 static inline const guint8 *
362 126 fpi_byte_reader_peek_data_unchecked (const FpiByteReader * reader)
363 {
364 126 return (const guint8 *) (reader->data + reader->byte);
365 }
366
367 static inline const guint8 *
368 126 fpi_byte_reader_get_data_unchecked (FpiByteReader * reader, guint size)
369 {
370 126 const guint8 *data;
371
372 126 data = fpi_byte_reader_peek_data_unchecked (reader);
373 126 fpi_byte_reader_skip_unchecked (reader, size);
374 126 return data;
375 }
376
377 static inline guint8 *
378 ✗ fpi_byte_reader_dup_data_unchecked (FpiByteReader * reader, guint size)
379 {
380 ✗ gconstpointer data = fpi_byte_reader_get_data_unchecked (reader, size);
381 ✗ return (guint8 *) g_memdup2 (data, size);
382 }
383
384 /* Unchecked variants that should not be used */
385 static inline guint
386 780 fpi_byte_reader_get_pos_unchecked (const FpiByteReader * reader)
387 {
388 780 return reader->byte;
389 }
390
391 static inline guint
392 10127 fpi_byte_reader_get_remaining_unchecked (const FpiByteReader * reader)
393 {
394 10127 return reader->size - reader->byte;
395 }
396
397 static inline guint
398 9 fpi_byte_reader_get_size_unchecked (const FpiByteReader * reader)
399 {
400 9 return reader->size;
401 }
402
403 /* inlined variants (do not use directly) */
404
405 static inline guint
406 1 fpi_byte_reader_get_remaining_inline (const FpiByteReader * reader)
407 {
408
0/2
✗ Branch 2 → 3 not taken.
✗ Branch 2 → 4 not taken.
 1 g_return_val_if_fail (reader != NULL, 0);
409
410 1 return fpi_byte_reader_get_remaining_unchecked (reader);
411 }
412
413 static inline guint
414 9 fpi_byte_reader_get_size_inline (const FpiByteReader * reader)
415 {
416
1/2
✗ Branch 2 → 3 not taken.
✓ Branch 2 → 4 taken 9 times.
 9 g_return_val_if_fail (reader != NULL, 0);
417
418 9 return fpi_byte_reader_get_size_unchecked (reader);
419 }
420
421 #define __FPI_BYTE_READER_GET_PEEK_BITS_INLINE(bits,type,name) \
422 \
423 static inline gboolean \
424 fpi_byte_reader_peek_##name##_inline (const FpiByteReader * reader, type * val) \
425 { \
426 g_return_val_if_fail (reader != NULL, FALSE); \
427 g_return_val_if_fail (val != NULL, FALSE); \
428 \
429 if (fpi_byte_reader_get_remaining_unchecked (reader) < (bits / 8)) \
430 return FALSE; \
431 \
432 *val = fpi_byte_reader_peek_##name##_unchecked (reader); \
433 return TRUE; \
434 } \
435 \
436 static inline gboolean \
437 fpi_byte_reader_get_##name##_inline (FpiByteReader * reader, type * val) \
438 { \
439 g_return_val_if_fail (reader != NULL, FALSE); \
440 g_return_val_if_fail (val != NULL, FALSE); \
441 \
442 if (fpi_byte_reader_get_remaining_unchecked (reader) < (bits / 8)) \
443 return FALSE; \
444 \
445 *val = fpi_byte_reader_get_##name##_unchecked (reader); \
446 return TRUE; \
447 }
448
449
3/12
fpi_byte_reader_get_uint8_inline:
✗ Branch 2 → 3 not taken.
✓ Branch 2 → 4 taken 1039 times.
✓ Branch 4 → 5 taken 1039 times.
✗ Branch 4 → 6 not taken.
✓ Branch 5 → 7 taken 1039 times.
✗ Branch 5 → 8 not taken.
fpi_byte_reader_peek_uint8_inline:
✗ Branch 2 → 3 not taken.
✗ Branch 2 → 4 not taken.
✗ Branch 4 → 5 not taken.
✗ Branch 4 → 6 not taken.
✗ Branch 5 → 7 not taken.
✗ Branch 5 → 8 not taken.
 1039 __FPI_BYTE_READER_GET_PEEK_BITS_INLINE(8,guint8,uint8)
450 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_INLINE(8,gint8,int8)
451
452
3/12
fpi_byte_reader_get_uint16_le_inline:
✗ Branch 2 → 3 not taken.
✓ Branch 2 → 4 taken 133 times.
✓ Branch 4 → 5 taken 133 times.
✗ Branch 4 → 6 not taken.
✓ Branch 5 → 7 taken 133 times.
✗ Branch 5 → 8 not taken.
fpi_byte_reader_peek_uint16_le_inline:
✗ Branch 2 → 3 not taken.
✗ Branch 2 → 4 not taken.
✗ Branch 4 → 5 not taken.
✗ Branch 4 → 6 not taken.
✗ Branch 5 → 7 not taken.
✗ Branch 5 → 8 not taken.
 133 __FPI_BYTE_READER_GET_PEEK_BITS_INLINE(16,guint16,uint16_le)
453
4/12
fpi_byte_reader_get_uint16_be_inline:
✗ Branch 2 → 3 not taken.
✓ Branch 2 → 4 taken 8639 times.
✓ Branch 4 → 5 taken 8639 times.
✗ Branch 4 → 6 not taken.
✓ Branch 5 → 7 taken 7951 times.
✓ Branch 5 → 8 taken 688 times.
fpi_byte_reader_peek_uint16_be_inline:
✗ Branch 2 → 3 not taken.
✗ Branch 2 → 4 not taken.
✗ Branch 4 → 5 not taken.
✗ Branch 4 → 6 not taken.
✗ Branch 5 → 7 not taken.
✗ Branch 5 → 8 not taken.
 8639 __FPI_BYTE_READER_GET_PEEK_BITS_INLINE(16,guint16,uint16_be)
454 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_INLINE(16,gint16,int16_le)
455 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_INLINE(16,gint16,int16_be)
456
457
3/12
fpi_byte_reader_get_uint32_le_inline:
✗ Branch 2 → 3 not taken.
✓ Branch 2 → 4 taken 130 times.
✓ Branch 4 → 5 taken 130 times.
✗ Branch 4 → 6 not taken.
✓ Branch 5 → 7 taken 130 times.
✗ Branch 5 → 8 not taken.
fpi_byte_reader_peek_uint32_le_inline:
✗ Branch 2 → 3 not taken.
✗ Branch 2 → 4 not taken.
✗ Branch 4 → 5 not taken.
✗ Branch 4 → 6 not taken.
✗ Branch 5 → 7 not taken.
✗ Branch 5 → 8 not taken.
 130 __FPI_BYTE_READER_GET_PEEK_BITS_INLINE(32,guint32,uint32_le)
458 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_INLINE(32,guint32,uint32_be)
459 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_INLINE(32,gint32,int32_le)
460 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_INLINE(32,gint32,int32_be)
461
462 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_INLINE(24,guint32,uint24_le)
463 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_INLINE(24,guint32,uint24_be)
464 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_INLINE(24,gint32,int24_le)
465 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_INLINE(24,gint32,int24_be)
466
467 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_INLINE(64,guint64,uint64_le)
468 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_INLINE(64,guint64,uint64_be)
469 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_INLINE(64,gint64,int64_le)
470 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_INLINE(64,gint64,int64_be)
471
472 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_INLINE(32,gfloat,float32_le)
473 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_INLINE(32,gfloat,float32_be)
474 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_INLINE(64,gdouble,float64_le)
475 ✗ __FPI_BYTE_READER_GET_PEEK_BITS_INLINE(64,gdouble,float64_be)
476
477 #undef __FPI_BYTE_READER_GET_PEEK_BITS_INLINE
478
479 #ifndef FPI_BYTE_READER_DISABLE_INLINES
480
481 #define fpi_byte_reader_init(reader,data,size) \
482 fpi_byte_reader_init_inline(reader,data,size)
483
484 #define fpi_byte_reader_get_remaining(reader) \
485 fpi_byte_reader_get_remaining_inline(reader)
486
487 #define fpi_byte_reader_get_size(reader) \
488 fpi_byte_reader_get_size_inline(reader)
489
490 #define fpi_byte_reader_get_pos(reader) \
491 fpi_byte_reader_get_pos_inline(reader)
492
493 /* we use defines here so we can add the G_LIKELY() */
494 #define fpi_byte_reader_get_uint8(reader,val) \
495 G_LIKELY(fpi_byte_reader_get_uint8_inline(reader,val))
496 #define fpi_byte_reader_get_int8(reader,val) \
497 G_LIKELY(fpi_byte_reader_get_int8_inline(reader,val))
498 #define fpi_byte_reader_get_uint16_le(reader,val) \
499 G_LIKELY(fpi_byte_reader_get_uint16_le_inline(reader,val))
500 #define fpi_byte_reader_get_int16_le(reader,val) \
501 G_LIKELY(fpi_byte_reader_get_int16_le_inline(reader,val))
502 #define fpi_byte_reader_get_uint16_be(reader,val) \
503 G_LIKELY(fpi_byte_reader_get_uint16_be_inline(reader,val))
504 #define fpi_byte_reader_get_int16_be(reader,val) \
505 G_LIKELY(fpi_byte_reader_get_int16_be_inline(reader,val))
506 #define fpi_byte_reader_get_uint24_le(reader,val) \
507 G_LIKELY(fpi_byte_reader_get_uint24_le_inline(reader,val))
508 #define fpi_byte_reader_get_int24_le(reader,val) \
509 G_LIKELY(fpi_byte_reader_get_int24_le_inline(reader,val))
510 #define fpi_byte_reader_get_uint24_be(reader,val) \
511 G_LIKELY(fpi_byte_reader_get_uint24_be_inline(reader,val))
512 #define fpi_byte_reader_get_int24_be(reader,val) \
513 G_LIKELY(fpi_byte_reader_get_int24_be_inline(reader,val))
514 #define fpi_byte_reader_get_uint32_le(reader,val) \
515 G_LIKELY(fpi_byte_reader_get_uint32_le_inline(reader,val))
516 #define fpi_byte_reader_get_int32_le(reader,val) \
517 G_LIKELY(fpi_byte_reader_get_int32_le_inline(reader,val))
518 #define fpi_byte_reader_get_uint32_be(reader,val) \
519 G_LIKELY(fpi_byte_reader_get_uint32_be_inline(reader,val))
520 #define fpi_byte_reader_get_int32_be(reader,val) \
521 G_LIKELY(fpi_byte_reader_get_int32_be_inline(reader,val))
522 #define fpi_byte_reader_get_uint64_le(reader,val) \
523 G_LIKELY(fpi_byte_reader_get_uint64_le_inline(reader,val))
524 #define fpi_byte_reader_get_int64_le(reader,val) \
525 G_LIKELY(fpi_byte_reader_get_int64_le_inline(reader,val))
526 #define fpi_byte_reader_get_uint64_be(reader,val) \
527 G_LIKELY(fpi_byte_reader_get_uint64_be_inline(reader,val))
528 #define fpi_byte_reader_get_int64_be(reader,val) \
529 G_LIKELY(fpi_byte_reader_get_int64_be_inline(reader,val))
530
531 #define fpi_byte_reader_peek_uint8(reader,val) \
532 G_LIKELY(fpi_byte_reader_peek_uint8_inline(reader,val))
533 #define fpi_byte_reader_peek_int8(reader,val) \
534 G_LIKELY(fpi_byte_reader_peek_int8_inline(reader,val))
535 #define fpi_byte_reader_peek_uint16_le(reader,val) \
536 G_LIKELY(fpi_byte_reader_peek_uint16_le_inline(reader,val))
537 #define fpi_byte_reader_peek_int16_le(reader,val) \
538 G_LIKELY(fpi_byte_reader_peek_int16_le_inline(reader,val))
539 #define fpi_byte_reader_peek_uint16_be(reader,val) \
540 G_LIKELY(fpi_byte_reader_peek_uint16_be_inline(reader,val))
541 #define fpi_byte_reader_peek_int16_be(reader,val) \
542 G_LIKELY(fpi_byte_reader_peek_int16_be_inline(reader,val))
543 #define fpi_byte_reader_peek_uint24_le(reader,val) \
544 G_LIKELY(fpi_byte_reader_peek_uint24_le_inline(reader,val))
545 #define fpi_byte_reader_peek_int24_le(reader,val) \
546 G_LIKELY(fpi_byte_reader_peek_int24_le_inline(reader,val))
547 #define fpi_byte_reader_peek_uint24_be(reader,val) \
548 G_LIKELY(fpi_byte_reader_peek_uint24_be_inline(reader,val))
549 #define fpi_byte_reader_peek_int24_be(reader,val) \
550 G_LIKELY(fpi_byte_reader_peek_int24_be_inline(reader,val))
551 #define fpi_byte_reader_peek_uint32_le(reader,val) \
552 G_LIKELY(fpi_byte_reader_peek_uint32_le_inline(reader,val))
553 #define fpi_byte_reader_peek_int32_le(reader,val) \
554 G_LIKELY(fpi_byte_reader_peek_int32_le_inline(reader,val))
555 #define fpi_byte_reader_peek_uint32_be(reader,val) \
556 G_LIKELY(fpi_byte_reader_peek_uint32_be_inline(reader,val))
557 #define fpi_byte_reader_peek_int32_be(reader,val) \
558 G_LIKELY(fpi_byte_reader_peek_int32_be_inline(reader,val))
559 #define fpi_byte_reader_peek_uint64_le(reader,val) \
560 G_LIKELY(fpi_byte_reader_peek_uint64_le_inline(reader,val))
561 #define fpi_byte_reader_peek_int64_le(reader,val) \
562 G_LIKELY(fpi_byte_reader_peek_int64_le_inline(reader,val))
563 #define fpi_byte_reader_peek_uint64_be(reader,val) \
564 G_LIKELY(fpi_byte_reader_peek_uint64_be_inline(reader,val))
565 #define fpi_byte_reader_peek_int64_be(reader,val) \
566 G_LIKELY(fpi_byte_reader_peek_int64_be_inline(reader,val))
567
568 #define fpi_byte_reader_get_float32_le(reader,val) \
569 G_LIKELY(fpi_byte_reader_get_float32_le_inline(reader,val))
570 #define fpi_byte_reader_get_float32_be(reader,val) \
571 G_LIKELY(fpi_byte_reader_get_float32_be_inline(reader,val))
572 #define fpi_byte_reader_get_float64_le(reader,val) \
573 G_LIKELY(fpi_byte_reader_get_float64_le_inline(reader,val))
574 #define fpi_byte_reader_get_float64_be(reader,val) \
575 G_LIKELY(fpi_byte_reader_get_float64_be_inline(reader,val))
576 #define fpi_byte_reader_peek_float32_le(reader,val) \
577 G_LIKELY(fpi_byte_reader_peek_float32_le_inline(reader,val))
578 #define fpi_byte_reader_peek_float32_be(reader,val) \
579 G_LIKELY(fpi_byte_reader_peek_float32_be_inline(reader,val))
580 #define fpi_byte_reader_peek_float64_le(reader,val) \
581 G_LIKELY(fpi_byte_reader_peek_float64_le_inline(reader,val))
582 #define fpi_byte_reader_peek_float64_be(reader,val) \
583 G_LIKELY(fpi_byte_reader_peek_float64_be_inline(reader,val))
584
585 #endif /* FPI_BYTE_READER_DISABLE_INLINES */
586
587 static inline void
588 105 fpi_byte_reader_init_inline (FpiByteReader * reader, const guint8 * data, guint size)
589 {
590 105 g_return_if_fail (reader != NULL);
591
592 105 reader->data = data;
593 105 reader->size = size;
594
1/2
✓ Branch 2 → 3 taken 19 times.
✗ Branch 2 → 8 not taken.
 105 reader->byte = 0;
595 }
596
597 static inline gboolean
598 3 fpi_byte_reader_peek_sub_reader_inline (FpiByteReader * reader,
599 FpiByteReader * sub_reader, guint size)
600 {
601
1/2
✗ Branch 2 → 3 not taken.
✓ Branch 2 → 4 taken 3 times.
 3 g_return_val_if_fail (reader != NULL, FALSE);
602
1/2
✓ Branch 4 → 5 taken 3 times.
✗ Branch 4 → 6 not taken.
 3 g_return_val_if_fail (sub_reader != NULL, FALSE);
603
604
1/2
✓ Branch 5 → 7 taken 3 times.
✗ Branch 5 → 8 not taken.
 3 if (fpi_byte_reader_get_remaining_unchecked (reader) < size)
605 return FALSE;
606
607 3 sub_reader->data = reader->data + reader->byte;
608 3 sub_reader->byte = 0;
609 3 sub_reader->size = size;
610 3 return TRUE;
611 }
612
613 static inline gboolean
614 3 fpi_byte_reader_get_sub_reader_inline (FpiByteReader * reader,
615 FpiByteReader * sub_reader, guint size)
616 {
617
1/2
✓ Branch 3 → 4 taken 3 times.
✗ Branch 3 → 5 not taken.
 3 if (!fpi_byte_reader_peek_sub_reader_inline (reader, sub_reader, size))
618 return FALSE;
619 3 fpi_byte_reader_skip_unchecked (reader, size);
620 3 return TRUE;
621 }
622
623 static inline gboolean
624 ✗ fpi_byte_reader_dup_data_inline (FpiByteReader * reader, guint size, guint8 ** val)
625 {
626 ✗ g_return_val_if_fail (reader != NULL, FALSE);
627 ✗ g_return_val_if_fail (val != NULL, FALSE);
628
629 ✗ if (G_UNLIKELY (size > reader->size || fpi_byte_reader_get_remaining_unchecked (reader) < size))
630 return FALSE;
631
632 ✗ *val = fpi_byte_reader_dup_data_unchecked (reader, size);
633 ✗ return TRUE;
634 }
635
636 static inline gboolean
637 180 fpi_byte_reader_get_data_inline (FpiByteReader * reader, guint size, const guint8 ** val)
638 {
639
1/2
✗ Branch 2 → 3 not taken.
✓ Branch 2 → 4 taken 180 times.
 180 g_return_val_if_fail (reader != NULL, FALSE);
640
1/2
✓ Branch 4 → 5 taken 180 times.
✗ Branch 4 → 6 not taken.
 180 g_return_val_if_fail (val != NULL, FALSE);
641
642
4/4
✓ Branch 5 → 7 taken 168 times.
✓ Branch 5 → 9 taken 12 times.
✓ Branch 7 → 8 taken 120 times.
✓ Branch 7 → 9 taken 48 times.
 180 if (G_UNLIKELY (size > reader->size || fpi_byte_reader_get_remaining_unchecked (reader) < size))
643 return FALSE;
644
645 120 *val = fpi_byte_reader_get_data_unchecked (reader, size);
646 120 return TRUE;
647 }
648
649 static inline gboolean
650 ✗ fpi_byte_reader_peek_data_inline (const FpiByteReader * reader, guint size, const guint8 ** val)
651 {
652 ✗ g_return_val_if_fail (reader != NULL, FALSE);
653 ✗ g_return_val_if_fail (val != NULL, FALSE);
654
655 ✗ if (G_UNLIKELY (size > reader->size || fpi_byte_reader_get_remaining_unchecked (reader) < size))
656 return FALSE;
657
658 ✗ *val = fpi_byte_reader_peek_data_unchecked (reader);
659 ✗ return TRUE;
660 }
661
662 static inline GBytes *
663 fpi_byte_reader_peek_bytes_inline (const FpiByteReader *reader, guint size)
664 {
665 const guint8 *data;
666
667 g_return_val_if_fail (reader != NULL, NULL);
668
669 if (G_UNLIKELY (size > reader->size || fpi_byte_reader_get_remaining_unchecked (reader) < size))
670 return NULL;
671
672 data = fpi_byte_reader_peek_data_unchecked (reader);
673 return g_bytes_new_static (data, size);
674 }
675
676 static inline GBytes *
677 fpi_byte_reader_get_bytes_inline (FpiByteReader *reader, guint size)
678 {
679 const guint8 *data;
680
681 g_return_val_if_fail (reader != NULL, NULL);
682
683 if (G_UNLIKELY (size > reader->size || fpi_byte_reader_get_remaining_unchecked (reader) < size))
684 return NULL;
685
686 data = fpi_byte_reader_get_data_unchecked (reader, size);
687 return g_bytes_new_static (data, size);
688 }
689
690 static inline gboolean
691 12 (fpi_byte_reader_get_data_inline_static) (FpiByteReader * reader, guint size, const guint8 * val)
692 {
693
1/2
✗ Branch 2 → 3 not taken.
✓ Branch 2 → 4 taken 12 times.
 12 g_return_val_if_fail (reader != NULL, FALSE);
694
1/2
✓ Branch 4 → 5 taken 12 times.
✗ Branch 4 → 6 not taken.
 12 g_return_val_if_fail (val != NULL, FALSE);
695
696
4/4
✓ Branch 5 → 7 taken 10 times.
✓ Branch 5 → 9 taken 2 times.
✓ Branch 7 → 8 taken 6 times.
✓ Branch 7 → 9 taken 4 times.
 12 if (G_UNLIKELY (size > reader->size || fpi_byte_reader_get_remaining_unchecked (reader) < size))
697 return FALSE;
698
699 6 memcpy ((void *) val, fpi_byte_reader_get_data_unchecked (reader, size), size);
700 6 return TRUE;
701 }
702
703 static inline gboolean
704 ✗ (fpi_byte_reader_peek_data_inline_static) (const FpiByteReader * reader, guint size, guint8 * val)
705 {
706 ✗ g_return_val_if_fail (reader != NULL, FALSE);
707 ✗ g_return_val_if_fail (val != NULL, FALSE);
708
709 ✗ if (G_UNLIKELY (size > reader->size || fpi_byte_reader_get_remaining_unchecked (reader) < size))
710 return FALSE;
711
712 ✗ memcpy (val, fpi_byte_reader_peek_data_unchecked (reader), size);
713 ✗ return TRUE;
714 }
715
716 static inline guint
717 780 fpi_byte_reader_get_pos_inline (const FpiByteReader * reader)
718 {
719
1/2
✗ Branch 2 → 3 not taken.
✓ Branch 2 → 4 taken 780 times.
 780 g_return_val_if_fail (reader != NULL, 0);
720
721 780 return fpi_byte_reader_get_pos_unchecked (reader);
722 }
723
724 static inline gboolean
725 4 fpi_byte_reader_skip_inline (FpiByteReader * reader, guint nbytes)
726 {
727
1/2
✗ Branch 2 → 3 not taken.
✓ Branch 2 → 4 taken 4 times.
 4 g_return_val_if_fail (reader != NULL, FALSE);
728
729
1/2
✓ Branch 4 → 5 taken 4 times.
✗ Branch 4 → 6 not taken.
 4 if (G_UNLIKELY (fpi_byte_reader_get_remaining_unchecked (reader) < nbytes))
730 return FALSE;
731
732 4 reader->byte += nbytes;
733 4 return TRUE;
734 }
735
736 #ifndef FPI_BYTE_READER_DISABLE_INLINES
737
738 #define fpi_byte_reader_dup_data(reader,size,val) \
739 G_LIKELY(fpi_byte_reader_dup_data_inline(reader,size,val))
740 #define fpi_byte_reader_get_data(reader,size,val) \
741 G_LIKELY(fpi_byte_reader_get_data_inline(reader,size,val))
742 #define fpi_byte_reader_peek_data(reader,size,val) \
743 G_LIKELY(fpi_byte_reader_peek_data_inline(reader,size,val))
744 #define fpi_byte_reader_skip(reader,nbytes) \
745 G_LIKELY(fpi_byte_reader_skip_inline(reader,nbytes))
746 #define fpi_byte_reader_get_bytes(reader,size) \
747 fpi_byte_reader_get_bytes_inline(reader,size)
748 #define fpi_byte_reader_peek_bytes(reader,size) \
749 fpi_byte_reader_peek_bytes_inline(reader,size)
750
751 /**
752 * fpi_byte_reader_get_data_static:
753 * @reader: a #FpiByteReader
754 * @val: fixed-size array (e.g. `uint8_t buf[32]`)
755 *
756 * Reads @size bytes from @reader directly into @val, where @size is
757 * deduced via `sizeof()` - only safe with true C arrays.
758 *
759 * Returns: %TRUE on success, %FALSE otherwise.
760 */
761 #define fpi_byte_reader_get_data_static(reader,val) \
762 (fpi_byte_reader_get_data_static) (reader,sizeof(val),val)
763
764 /**
765 * fpi_byte_reader_peek_data_static:
766 * @reader: a #FpiByteReader
767 * @val: fixed-size array (e.g. `uint8_t buf[32]`)
768 *
769 * Like fpi_byte_reader_get_data_static() but does not advance the position.
770 *
771 * Returns: %TRUE on success, %FALSE otherwise.
772 */
773 #define fpi_byte_reader_peek_data_static(reader,val) \
774 (fpi_byte_reader_peek_data_static) (reader,sizeof(val),val)
775
776 #endif /* FPI_BYTE_READER_DISABLE_INLINES */
777
778 G_DEFINE_AUTOPTR_CLEANUP_FUNC (FpiByteReader, fpi_byte_reader_free);
779
780 G_END_DECLS
781