1 /* GStreamer
2 *
3 * unit test for GstByteReader
4 *
5 * Copyright (C) <2008> Sebastian Dröge <sebastian.droege@collabora.co.uk>
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Library General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Library General Public License for more details.
16 *
17 * You should have received a copy of the GNU Library General Public
18 * License along with this library; if not, write to the
19 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
20 * Boston, MA 02110-1301, USA.
21 */
22
23 #ifdef HAVE_CONFIG_H
24 #include "config.h"
25 #endif
26
27 #include <gst/gst.h>
28 #include <gst/check/gstcheck.h>
29 #include <gst/base/gstbytereader.h>
30
31 #ifndef fail_unless_equals_int64
32 #define fail_unless_equals_int64(a, b) \
33 G_STMT_START { \
34 gint64 first = a; \
35 gint64 second = b; \
36 fail_unless(first == second, \
37 "'" #a "' (%" G_GINT64_FORMAT ") is not equal to '" #b"' (%" \
38 G_GINT64_FORMAT ")", first, second); \
39 } G_STMT_END;
40 #endif
41
GST_START_TEST(test_initialization)42 GST_START_TEST (test_initialization)
43 {
44 guint8 data[] = { 0x01, 0x02, 0x03, 0x04 };
45 GstBuffer *buffer = gst_buffer_new ();
46 GstByteReader reader = GST_BYTE_READER_INIT (data, 4);
47 GstByteReader *reader2;
48 guint8 x = 0;
49 GstMapInfo info;
50
51 gst_buffer_insert_memory (buffer, -1,
52 gst_memory_new_wrapped (GST_MEMORY_FLAG_READONLY, data, 4, 0, 4, NULL,
53 NULL));
54
55 fail_unless (gst_byte_reader_get_uint8 (&reader, &x));
56 fail_unless_equals_int (x, 0x01);
57 fail_unless (gst_byte_reader_get_uint8 (&reader, &x));
58 fail_unless_equals_int (x, 0x02);
59
60 memset (&reader, 0, sizeof (GstByteReader));
61
62 gst_byte_reader_init (&reader, data, 4);
63 fail_unless (gst_byte_reader_get_uint8 (&reader, &x));
64 fail_unless_equals_int (x, 0x01);
65 fail_unless (gst_byte_reader_get_uint8 (&reader, &x));
66 fail_unless_equals_int (x, 0x02);
67
68 fail_unless (gst_buffer_map (buffer, &info, GST_MAP_READ));
69 gst_byte_reader_init (&reader, info.data, info.size);
70 fail_unless (gst_byte_reader_get_uint8 (&reader, &x));
71 fail_unless_equals_int (x, 0x01);
72 fail_unless (gst_byte_reader_get_uint8 (&reader, &x));
73 fail_unless_equals_int (x, 0x02);
74 gst_buffer_unmap (buffer, &info);
75
76 reader2 = gst_byte_reader_new (data, 4);
77 fail_unless (gst_byte_reader_get_uint8 (reader2, &x));
78 fail_unless_equals_int (x, 0x01);
79 fail_unless (gst_byte_reader_get_uint8 (reader2, &x));
80 fail_unless_equals_int (x, 0x02);
81 gst_byte_reader_free (reader2);
82
83 fail_unless (gst_buffer_map (buffer, &info, GST_MAP_READ));
84 reader2 = gst_byte_reader_new (info.data, info.size);
85 fail_unless (gst_byte_reader_get_uint8 (reader2, &x));
86 fail_unless_equals_int (x, 0x01);
87 fail_unless (gst_byte_reader_get_uint8 (reader2, &x));
88 fail_unless_equals_int (x, 0x02);
89 gst_byte_reader_free (reader2);
90 gst_buffer_unmap (buffer, &info);
91
92 gst_buffer_unref (buffer);
93 }
94
95 GST_END_TEST;
96
97 #define GET_CHECK8(reader, dest, val) { \
98 fail_unless (gst_byte_reader_get_uint8 (reader, &dest)); \
99 fail_unless_equals_uint64 (dest, val); \
100 }
101
102 #define GET_CHECK(reader, dest, bits, endianness, val) { \
103 fail_unless (gst_byte_reader_get_uint##bits##_##endianness (reader, &dest)); \
104 fail_unless_equals_uint64 (dest, val); \
105 }
106
107 #define GET_CHECK_FAIL8(reader, dest) { \
108 fail_if (gst_byte_reader_get_uint8 (reader, &dest)); \
109 }
110
111 #define GET_CHECK_FAIL(reader, dest, bits, endianness) { \
112 fail_if (gst_byte_reader_get_uint##bits##_##endianness (reader, &dest)); \
113 }
114
115 #define PEEK_CHECK8(reader, dest, val) { \
116 fail_unless (gst_byte_reader_peek_uint8 (reader, &dest)); \
117 fail_unless_equals_uint64 (dest, val); \
118 }
119
120 #define PEEK_CHECK(reader, dest, bits, endianness, val) { \
121 fail_unless (gst_byte_reader_peek_uint##bits##_##endianness (reader, &dest)); \
122 fail_unless_equals_uint64 (dest, val); \
123 }
124
125 #define PEEK_CHECK_FAIL8(reader, dest) { \
126 fail_if (gst_byte_reader_peek_uint8 (reader, &dest)); \
127 }
128
129 #define PEEK_CHECK_FAIL(reader, dest, bits, endianness) { \
130 fail_if (gst_byte_reader_peek_uint##bits##_##endianness (reader, &dest)); \
131 }
132
GST_START_TEST(test_get_uint_le)133 GST_START_TEST (test_get_uint_le)
134 {
135 guint8 data[] = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef,
136 0xfe, 0xdc, 0xba, 0x09, 0x87, 0x65, 0x43, 0x21
137 };
138 GstByteReader reader = GST_BYTE_READER_INIT (data, 16);
139 guint8 a = 0;
140 guint16 b = 0;
141 guint32 c = 0;
142 guint64 d = 0;
143
144 GET_CHECK8 (&reader, a, 0x12);
145 GET_CHECK (&reader, b, 16, le, 0x5634);
146 GET_CHECK (&reader, c, 24, le, 0xab9078);
147 GET_CHECK (&reader, c, 32, le, 0xdcfeefcd);
148 fail_unless (gst_byte_reader_set_pos (&reader, 0));
149 GET_CHECK (&reader, d, 64, le, G_GINT64_CONSTANT (0xefcdab9078563412));
150 GET_CHECK (&reader, d, 64, le, G_GINT64_CONSTANT (0x2143658709badcfe));
151
152 GET_CHECK_FAIL8 (&reader, a);
153 GET_CHECK_FAIL (&reader, b, 16, le);
154 GET_CHECK_FAIL (&reader, c, 24, le);
155 GET_CHECK_FAIL (&reader, c, 32, le);
156 GET_CHECK_FAIL (&reader, d, 64, le);
157
158 fail_unless (gst_byte_reader_set_pos (&reader, 0));
159
160 PEEK_CHECK8 (&reader, a, 0x12);
161 PEEK_CHECK (&reader, b, 16, le, 0x3412);
162 PEEK_CHECK (&reader, c, 24, le, 0x563412);
163 PEEK_CHECK (&reader, c, 32, le, 0x78563412);
164 PEEK_CHECK (&reader, d, 64, le, G_GINT64_CONSTANT (0xefcdab9078563412));
165
166 fail_unless (gst_byte_reader_set_pos (&reader, 16));
167 PEEK_CHECK_FAIL8 (&reader, a);
168 PEEK_CHECK_FAIL (&reader, b, 16, le);
169 PEEK_CHECK_FAIL (&reader, c, 24, le);
170 PEEK_CHECK_FAIL (&reader, c, 32, le);
171 PEEK_CHECK_FAIL (&reader, d, 64, le);
172 }
173
174 GST_END_TEST;
175
GST_START_TEST(test_get_uint_be)176 GST_START_TEST (test_get_uint_be)
177 {
178 guint8 data[] = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef,
179 0xfe, 0xdc, 0xba, 0x09, 0x87, 0x65, 0x43, 0x21
180 };
181 GstByteReader reader = GST_BYTE_READER_INIT (data, 16);
182 guint8 a = 0;
183 guint16 b = 0;
184 guint32 c = 0;
185 guint64 d = 0;
186
187 GET_CHECK8 (&reader, a, 0x12);
188 GET_CHECK (&reader, b, 16, be, 0x3456);
189 GET_CHECK (&reader, c, 24, be, 0x7890ab);
190 GET_CHECK (&reader, c, 32, be, 0xcdeffedc);
191 fail_unless (gst_byte_reader_set_pos (&reader, 0));
192 GET_CHECK (&reader, d, 64, be, G_GINT64_CONSTANT (0x1234567890abcdef));
193 GET_CHECK (&reader, d, 64, be, G_GINT64_CONSTANT (0xfedcba0987654321));
194
195 GET_CHECK_FAIL8 (&reader, a);
196 GET_CHECK_FAIL (&reader, b, 16, be);
197 GET_CHECK_FAIL (&reader, c, 24, be);
198 GET_CHECK_FAIL (&reader, c, 32, be);
199 GET_CHECK_FAIL (&reader, d, 64, be);
200
201 fail_unless (gst_byte_reader_set_pos (&reader, 0));
202
203 PEEK_CHECK8 (&reader, a, 0x12);
204 PEEK_CHECK (&reader, b, 16, be, 0x1234);
205 PEEK_CHECK (&reader, c, 24, be, 0x123456);
206 PEEK_CHECK (&reader, c, 32, be, 0x12345678);
207 PEEK_CHECK (&reader, d, 64, be, G_GINT64_CONSTANT (0x1234567890abcdef));
208
209 fail_unless (gst_byte_reader_set_pos (&reader, 16));
210 PEEK_CHECK_FAIL8 (&reader, a);
211 PEEK_CHECK_FAIL (&reader, b, 16, be);
212 PEEK_CHECK_FAIL (&reader, c, 24, be);
213 PEEK_CHECK_FAIL (&reader, c, 32, be);
214 PEEK_CHECK_FAIL (&reader, d, 64, be);
215 }
216
217 GST_END_TEST;
218
219 #undef GET_CHECK8
220 #undef GET_CHECK
221 #undef PEEK_CHECK8
222 #undef PEEK_CHECK
223 #undef GET_CHECK_FAIL8
224 #undef GET_CHECK_FAIL
225 #undef PEEK_CHECK_FAIL8
226 #undef PEEK_CHECK_FAIL
227
228 #define GET_CHECK8(reader, dest, val) { \
229 fail_unless (gst_byte_reader_get_int8 (reader, &dest)); \
230 fail_unless_equals_int64 (dest, val); \
231 }
232
233 #define GET_CHECK(reader, dest, bits, endianness, val) { \
234 fail_unless (gst_byte_reader_get_int##bits##_##endianness (reader, &dest)); \
235 fail_unless_equals_int64 (dest, val); \
236 }
237
238 #define GET_CHECK_FAIL8(reader, dest) { \
239 fail_if (gst_byte_reader_get_int8 (reader, &dest)); \
240 }
241
242 #define GET_CHECK_FAIL(reader, dest, bits, endianness) { \
243 fail_if (gst_byte_reader_get_int##bits##_##endianness (reader, &dest)); \
244 }
245
246 #define PEEK_CHECK8(reader, dest, val) { \
247 fail_unless (gst_byte_reader_peek_int8 (reader, &dest)); \
248 fail_unless_equals_int64 (dest, val); \
249 }
250
251 #define PEEK_CHECK(reader, dest, bits, endianness, val) { \
252 fail_unless (gst_byte_reader_peek_int##bits##_##endianness (reader, &dest)); \
253 fail_unless_equals_int64 (dest, val); \
254 }
255
256 #define PEEK_CHECK_FAIL8(reader, dest) { \
257 fail_if (gst_byte_reader_peek_int8 (reader, &dest)); \
258 }
259
260 #define PEEK_CHECK_FAIL(reader, dest, bits, endianness) { \
261 fail_if (gst_byte_reader_peek_int##bits##_##endianness (reader, &dest)); \
262 }
263
GST_START_TEST(test_get_int_le)264 GST_START_TEST (test_get_int_le)
265 {
266 guint8 data[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
267 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
268 };
269 GstByteReader reader = GST_BYTE_READER_INIT (data, 16);
270 gint8 a = 0;
271 gint16 b = 0;
272 gint32 c = 0;
273 gint64 d = 0;
274
275 GET_CHECK8 (&reader, a, -1);
276 GET_CHECK (&reader, b, 16, le, -1);
277 GET_CHECK (&reader, c, 24, le, -1);
278 GET_CHECK (&reader, c, 32, le, -1);
279 fail_unless (gst_byte_reader_set_pos (&reader, 0));
280 GET_CHECK (&reader, d, 64, le, G_GINT64_CONSTANT (-1));
281 GET_CHECK (&reader, d, 64, le, G_GINT64_CONSTANT (-1));
282
283 GET_CHECK_FAIL8 (&reader, a);
284 GET_CHECK_FAIL (&reader, b, 16, le);
285 GET_CHECK_FAIL (&reader, c, 24, le);
286 GET_CHECK_FAIL (&reader, c, 32, le);
287 GET_CHECK_FAIL (&reader, d, 64, le);
288
289 fail_unless (gst_byte_reader_set_pos (&reader, 0));
290
291 PEEK_CHECK8 (&reader, a, -1);
292 PEEK_CHECK (&reader, b, 16, le, -1);
293 PEEK_CHECK (&reader, c, 24, le, -1);
294 PEEK_CHECK (&reader, c, 32, le, -1);
295 PEEK_CHECK (&reader, d, 64, le, G_GINT64_CONSTANT (-1));
296
297 fail_unless (gst_byte_reader_set_pos (&reader, 16));
298 PEEK_CHECK_FAIL8 (&reader, a);
299 PEEK_CHECK_FAIL (&reader, b, 16, le);
300 PEEK_CHECK_FAIL (&reader, c, 24, le);
301 PEEK_CHECK_FAIL (&reader, c, 32, le);
302 PEEK_CHECK_FAIL (&reader, d, 64, le);
303
304 }
305
306 GST_END_TEST;
307
GST_START_TEST(test_get_int_be)308 GST_START_TEST (test_get_int_be)
309 {
310 guint8 data[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
311 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
312 };
313 GstByteReader reader = GST_BYTE_READER_INIT (data, 16);
314 gint8 a = 0;
315 gint16 b = 0;
316 gint32 c = 0;
317 gint64 d = 0;
318
319 GET_CHECK8 (&reader, a, -1);
320 GET_CHECK (&reader, b, 16, be, -1);
321 GET_CHECK (&reader, c, 24, be, -1);
322 GET_CHECK (&reader, c, 32, be, -1);
323 fail_unless (gst_byte_reader_set_pos (&reader, 0));
324 GET_CHECK (&reader, d, 64, be, G_GINT64_CONSTANT (-1));
325 GET_CHECK (&reader, d, 64, be, G_GINT64_CONSTANT (-1));
326
327 GET_CHECK_FAIL8 (&reader, a);
328 GET_CHECK_FAIL (&reader, b, 16, be);
329 GET_CHECK_FAIL (&reader, c, 24, be);
330 GET_CHECK_FAIL (&reader, c, 32, be);
331 GET_CHECK_FAIL (&reader, d, 64, be);
332
333 fail_unless (gst_byte_reader_set_pos (&reader, 0));
334
335 PEEK_CHECK8 (&reader, a, -1);
336 PEEK_CHECK (&reader, b, 16, be, -1);
337 PEEK_CHECK (&reader, c, 24, be, -1);
338 PEEK_CHECK (&reader, c, 32, be, -1);
339 PEEK_CHECK (&reader, d, 64, be, G_GINT64_CONSTANT (-1));
340
341 fail_unless (gst_byte_reader_set_pos (&reader, 16));
342 PEEK_CHECK_FAIL8 (&reader, a);
343 PEEK_CHECK_FAIL (&reader, b, 16, be);
344 PEEK_CHECK_FAIL (&reader, c, 24, be);
345 PEEK_CHECK_FAIL (&reader, c, 32, be);
346 PEEK_CHECK_FAIL (&reader, d, 64, be);
347
348 }
349
350 GST_END_TEST;
351
352 #undef GET_CHECK8
353 #undef GET_CHECK
354 #undef PEEK_CHECK8
355 #undef PEEK_CHECK
356 #undef GET_CHECK_FAIL8
357 #undef GET_CHECK_FAIL
358 #undef PEEK_CHECK_FAIL8
359 #undef PEEK_CHECK_FAIL
360
361 #define GET_CHECK(reader, dest, bits, endianness, val) { \
362 fail_unless (gst_byte_reader_get_float##bits##_##endianness (reader, &dest)); \
363 fail_unless_equals_float (dest, val); \
364 }
365
366 #define GET_CHECK_FAIL(reader, dest, bits, endianness) { \
367 fail_if (gst_byte_reader_get_float##bits##_##endianness (reader, &dest)); \
368 }
369
370 #define PEEK_CHECK(reader, dest, bits, endianness, val) { \
371 fail_unless (gst_byte_reader_peek_float##bits##_##endianness (reader, &dest)); \
372 fail_unless_equals_float (dest, val); \
373 }
374
375 #define PEEK_CHECK_FAIL(reader, dest, bits, endianness) { \
376 fail_if (gst_byte_reader_peek_float##bits##_##endianness (reader, &dest)); \
377 }
378
GST_START_TEST(test_get_float_le)379 GST_START_TEST (test_get_float_le)
380 {
381 guint8 data[] = {
382 0x00, 0x00, 0x80, 0x3f,
383 0x00, 0x00, 0x80, 0xbf,
384 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x3f,
385 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0xbf,
386 };
387 GstByteReader reader = GST_BYTE_READER_INIT (data, 24);
388 gfloat a = 0.0;
389 gdouble b = 0.0;
390
391 PEEK_CHECK (&reader, a, 32, le, 1.0);
392 GET_CHECK (&reader, a, 32, le, 1.0);
393 GET_CHECK (&reader, a, 32, le, -1.0);
394 PEEK_CHECK (&reader, b, 64, le, 1.0);
395 GET_CHECK (&reader, b, 64, le, 1.0);
396 GET_CHECK (&reader, b, 64, le, -1.0);
397 GET_CHECK_FAIL (&reader, a, 32, le);
398 GET_CHECK_FAIL (&reader, b, 64, le);
399 PEEK_CHECK_FAIL (&reader, a, 32, le);
400 PEEK_CHECK_FAIL (&reader, b, 64, le);
401 }
402
403 GST_END_TEST;
404
GST_START_TEST(test_get_float_be)405 GST_START_TEST (test_get_float_be)
406 {
407 guint8 data[] = {
408 0x3f, 0x80, 0x00, 0x00,
409 0xbf, 0x80, 0x00, 0x00,
410 0x3f, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
411 0xbf, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
412 };
413 GstByteReader reader = GST_BYTE_READER_INIT (data, 24);
414 gfloat a = 0.0;
415 gdouble b = 0.0;
416
417 PEEK_CHECK (&reader, a, 32, be, 1.0);
418 GET_CHECK (&reader, a, 32, be, 1.0);
419 GET_CHECK (&reader, a, 32, be, -1.0);
420 PEEK_CHECK (&reader, b, 64, be, 1.0);
421 GET_CHECK (&reader, b, 64, be, 1.0);
422 GET_CHECK (&reader, b, 64, be, -1.0);
423 GET_CHECK_FAIL (&reader, a, 32, be);
424 GET_CHECK_FAIL (&reader, b, 64, be);
425 PEEK_CHECK_FAIL (&reader, a, 32, be);
426 PEEK_CHECK_FAIL (&reader, b, 64, be);
427 }
428
429 GST_END_TEST;
430
431 #undef GET_CHECK
432 #undef PEEK_CHECK
433 #undef GET_CHECK_FAIL
434 #undef PEEK_CHECK_FAIL
435
GST_START_TEST(test_position_tracking)436 GST_START_TEST (test_position_tracking)
437 {
438 guint8 data[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
439 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
440 };
441 GstByteReader reader = GST_BYTE_READER_INIT (data, 16);
442 guint8 a = 0;
443
444 fail_unless_equals_int (gst_byte_reader_get_pos (&reader), 0);
445 fail_unless_equals_int (gst_byte_reader_get_remaining (&reader), 16);
446
447 fail_unless (gst_byte_reader_get_uint8 (&reader, &a));
448 fail_unless_equals_int (gst_byte_reader_get_pos (&reader), 1);
449 fail_unless_equals_int (gst_byte_reader_get_remaining (&reader), 16 - 1);
450
451 fail_unless (gst_byte_reader_set_pos (&reader, 8));
452 fail_unless_equals_int (gst_byte_reader_get_pos (&reader), 8);
453 fail_unless_equals_int (gst_byte_reader_get_remaining (&reader), 16 - 8);
454
455 fail_unless (gst_byte_reader_skip (&reader, 4));
456 fail_unless_equals_int (gst_byte_reader_get_pos (&reader), 12);
457 fail_unless_equals_int (gst_byte_reader_get_remaining (&reader), 16 - 12);
458
459 fail_unless (gst_byte_reader_set_pos (&reader, 16));
460 fail_unless_equals_int (gst_byte_reader_get_pos (&reader), 16);
461 fail_unless_equals_int (gst_byte_reader_get_remaining (&reader), 0);
462
463 fail_unless (gst_byte_reader_skip (&reader, 0));
464 fail_if (gst_byte_reader_skip (&reader, 1));
465 }
466
467 GST_END_TEST;
468
469 #define do_scan(r,m,p,o,s,x) \
470 G_STMT_START { \
471 fail_unless_equals_int (gst_byte_reader_masked_scan_uint32 (r,m,p,o,s), x); \
472 if (x != -1) { \
473 guint32 v, res_v; \
474 const guint8 *rdata = NULL; \
475 fail_unless (gst_byte_reader_peek_data (r, x + 4, &rdata)); \
476 res_v = GST_READ_UINT32_BE (rdata + x); \
477 fail_unless_equals_int (gst_byte_reader_masked_scan_uint32_peek (r,m,p,o,s,&v), x); \
478 fail_unless_equals_int (v, res_v); \
479 } \
480 } G_STMT_END;
481
GST_START_TEST(test_scan)482 GST_START_TEST (test_scan)
483 {
484 GstByteReader reader;
485 guint8 data[200];
486 guint i;
487
488 /* fill half the buffer with a pattern */
489 for (i = 0; i < 100; i++)
490 data[i] = i;
491
492 gst_byte_reader_init (&reader, data, 100);
493
494 /* find first bytes */
495 do_scan (&reader, 0xffffffff, 0x00010203, 0, 100, 0);
496 do_scan (&reader, 0xffffffff, 0x01020304, 0, 100, 1);
497 do_scan (&reader, 0xffffffff, 0x01020304, 1, 99, 1);
498 /* offset is past the pattern start */
499 do_scan (&reader, 0xffffffff, 0x01020304, 2, 98, -1);
500 /* not enough bytes to find the pattern */
501 do_scan (&reader, 0xffffffff, 0x02030405, 2, 3, -1);
502 do_scan (&reader, 0xffffffff, 0x02030405, 2, 4, 2);
503 /* size does not include the last scanned byte */
504 do_scan (&reader, 0xffffffff, 0x40414243, 0, 0x41, -1);
505 do_scan (&reader, 0xffffffff, 0x40414243, 0, 0x43, -1);
506 do_scan (&reader, 0xffffffff, 0x40414243, 0, 0x44, 0x40);
507 /* past the start */
508 do_scan (&reader, 0xffffffff, 0x40414243, 65, 10, -1);
509 do_scan (&reader, 0xffffffff, 0x40414243, 64, 5, 64);
510 do_scan (&reader, 0xffffffff, 0x60616263, 65, 35, 0x60);
511 do_scan (&reader, 0xffffffff, 0x60616263, 0x60, 4, 0x60);
512 /* past the start */
513 do_scan (&reader, 0xffffffff, 0x60616263, 0x61, 3, -1);
514 do_scan (&reader, 0xffffffff, 0x60616263, 99, 1, -1);
515
516 /* add more data to the buffer */
517 for (i = 100; i < 200; i++)
518 data[i] = i;
519 gst_byte_reader_init (&reader, data, 200);
520
521 /* past the start */
522 do_scan (&reader, 0xffffffff, 0x60616263, 0x61, 6, -1);
523 /* this should work */
524 do_scan (&reader, 0xffffffff, 0x61626364, 0x61, 4, 0x61);
525 /* not enough data */
526 do_scan (&reader, 0xffffffff, 0x62636465, 0x61, 4, -1);
527 do_scan (&reader, 0xffffffff, 0x62636465, 0x61, 5, 0x62);
528 do_scan (&reader, 0xffffffff, 0x62636465, 0, 120, 0x62);
529
530 /* border conditions */
531 do_scan (&reader, 0xffffffff, 0x62636465, 0, 200, 0x62);
532 do_scan (&reader, 0xffffffff, 0x63646566, 0, 200, 0x63);
533 /* we completely searched the first list */
534 do_scan (&reader, 0xffffffff, 0x64656667, 0, 200, 0x64);
535 /* skip first buffer */
536 do_scan (&reader, 0xffffffff, 0x64656667, 0x64, 100, 0x64);
537 /* past the start */
538 do_scan (&reader, 0xffffffff, 0x64656667, 0x65, 10, -1);
539 /* not enough data to scan */
540 do_scan (&reader, 0xffffffff, 0x64656667, 0x63, 4, -1);
541 do_scan (&reader, 0xffffffff, 0x64656667, 0x63, 5, 0x64);
542 do_scan (&reader, 0xffffffff, 0xc4c5c6c7, 0, 199, -1);
543 do_scan (&reader, 0xffffffff, 0xc4c5c6c7, 0x62, 102, 0xc4);
544 /* different masks */
545 do_scan (&reader, 0x00ffffff, 0x00656667, 0x64, 100, 0x64);
546 do_scan (&reader, 0x000000ff, 0x00000000, 0, 100, -1);
547 do_scan (&reader, 0x000000ff, 0x00000003, 0, 100, 0);
548 do_scan (&reader, 0x000000ff, 0x00000061, 0x61, 100, -1);
549 do_scan (&reader, 0xff000000, 0x61000000, 0, 0x62, -1);
550 /* does not even exist */
551 do_scan (&reader, 0x00ffffff, 0xffffffff, 0x65, 99, -1);
552
553 /* flush some bytes */
554 fail_unless (gst_byte_reader_skip (&reader, 0x20));
555
556 do_scan (&reader, 0xffffffff, 0x20212223, 0, 100, 0);
557 do_scan (&reader, 0xffffffff, 0x20212223, 0, 4, 0);
558 do_scan (&reader, 0xffffffff, 0xc4c5c6c7, 0x62, 70, 0xa4);
559 do_scan (&reader, 0xffffffff, 0xc4c5c6c7, 0, 168, 0xa4);
560
561 do_scan (&reader, 0xffffffff, 0xc4c5c6c7, 164, 4, 0xa4);
562 do_scan (&reader, 0xffffffff, 0xc4c5c6c7, 0x44, 100, 0xa4);
563
564 /* not enough bytes */
565 do_scan (&reader, 0xffffffff, 0xc4c5c6c7, 0x44, 99, -1);
566
567 /* check special code path that exists for 00 00 01 sync marker */
568 {
569 const guint8 sync_data[] = { 0xA0, 0x00, 0x00, 0x00, 0x01, 0xA5, 0xA6,
570 0xA7, 0xA8, 0xA9, 0xAA, 0x00, 0x00, 0x00, 0x01, 0xAF, 0xB0, 0xB1
571 };
572 guint32 val = 0;
573 guint8 *m;
574 gint found;
575
576 /* dup so valgrind can detect out of bounds access more easily */
577 m = g_memdup (sync_data, sizeof (sync_data));
578 gst_byte_reader_init (&reader, m, sizeof (sync_data));
579
580 found = gst_byte_reader_masked_scan_uint32_peek (&reader, 0xffffff00,
581 0x00000100, 0, sizeof (sync_data), &val);
582 fail_unless_equals_int (found, 2);
583 fail_unless_equals_int (val, 0x000001A5);
584
585 found = gst_byte_reader_masked_scan_uint32_peek (&reader, 0xffffff00,
586 0x00000100, 2, sizeof (sync_data) - 2, &val);
587 fail_unless_equals_int (found, 2);
588 fail_unless_equals_int (val, 0x000001A5);
589
590 found = gst_byte_reader_masked_scan_uint32_peek (&reader, 0xffffff00,
591 0x00000100, 3, sizeof (sync_data) - 3, &val);
592 fail_unless_equals_int (found, 12);
593 fail_unless_equals_int (val, 0x000001AF);
594
595 found = gst_byte_reader_masked_scan_uint32_peek (&reader, 0xffffff00,
596 0x00000100, 12, sizeof (sync_data) - 12, &val);
597 fail_unless_equals_int (found, 12);
598 fail_unless_equals_int (val, 0x000001AF);
599
600 found = gst_byte_reader_masked_scan_uint32_peek (&reader, 0xffffff00,
601 0x00000100, 13, sizeof (sync_data) - 13, &val);
602 fail_unless_equals_int (found, -1);
603
604 g_free (m);
605 }
606 }
607
608 GST_END_TEST;
609
GST_START_TEST(test_string_funcs)610 GST_START_TEST (test_string_funcs)
611 {
612 GstByteReader reader, backup;
613 const gchar *s8;
614 guint32 *c32;
615 guint16 *c16;
616 gchar *c8;
617 guint8 data[200], *d = 0;
618 guint i;
619
620 /* fill half the buffer with a pattern */
621 for (i = 0; i < 100; i++)
622 data[i] = i + 1;
623
624 gst_byte_reader_init (&reader, data, 100);
625
626 /* no NUL terminator, so these should all fail */
627 fail_if (gst_byte_reader_get_string (&reader, &s8));
628 fail_if (gst_byte_reader_get_string_utf8 (&reader, &s8));
629 fail_if (gst_byte_reader_dup_string (&reader, &c8));
630 fail_if (gst_byte_reader_dup_string_utf8 (&reader, &c8));
631 fail_if (gst_byte_reader_skip_string (&reader));
632 fail_if (gst_byte_reader_skip_string_utf8 (&reader));
633 fail_if (gst_byte_reader_skip_string_utf16 (&reader));
634 fail_if (gst_byte_reader_skip_string_utf32 (&reader));
635 fail_if (gst_byte_reader_peek_string (&reader, &s8));
636 fail_if (gst_byte_reader_peek_string_utf8 (&reader, &s8));
637 fail_if (gst_byte_reader_dup_string_utf16 (&reader, &c16));
638 fail_if (gst_byte_reader_dup_string_utf32 (&reader, &c32));
639
640 /* let's add a single NUL terminator */
641 data[80] = '\0';
642 backup = reader;
643 fail_if (gst_byte_reader_skip_string_utf32 (&reader));
644 fail_if (gst_byte_reader_skip_string_utf16 (&reader));
645 fail_if (gst_byte_reader_dup_string_utf16 (&reader, &c16));
646 fail_if (gst_byte_reader_dup_string_utf32 (&reader, &c32));
647 fail_unless (gst_byte_reader_skip_string (&reader));
648 reader = backup;
649 fail_unless (gst_byte_reader_skip_string_utf8 (&reader));
650 reader = backup;
651 fail_unless (gst_byte_reader_peek_string (&reader, &s8));
652 fail_unless (gst_byte_reader_peek_string_utf8 (&reader, &s8));
653 fail_if (gst_byte_reader_dup_string_utf16 (&reader, &c16));
654 fail_if (gst_byte_reader_dup_string_utf32 (&reader, &c32));
655
656 /* let's add another NUL terminator */
657 data[81] = '\0';
658 reader = backup;
659 fail_if (gst_byte_reader_skip_string_utf32 (&reader));
660 fail_if (gst_byte_reader_dup_string_utf32 (&reader, &c32));
661 fail_unless (gst_byte_reader_skip_string_utf16 (&reader));
662 reader = backup;
663 fail_unless (gst_byte_reader_dup_string_utf16 (&reader, &c16));
664 g_free (c16);
665 reader = backup;
666 fail_unless (gst_byte_reader_skip_string (&reader));
667 reader = backup;
668 fail_unless (gst_byte_reader_skip_string_utf8 (&reader));
669 reader = backup;
670 fail_unless (gst_byte_reader_peek_string (&reader, &s8));
671 fail_unless (gst_byte_reader_peek_string_utf8 (&reader, &s8));
672 fail_if (gst_byte_reader_dup_string_utf32 (&reader, &c32));
673
674 /* two more NUL terminators */
675 data[79] = '\0';
676 data[82] = '\0';
677 reader = backup;
678 /* we're at pos. 80 now, so have only 3 NUL terminators in front of us */
679 fail_if (gst_byte_reader_skip_string_utf32 (&reader));
680 /* let's rewind */
681 gst_byte_reader_init (&reader, data, 100);
682 backup = reader;
683 /* oops, 79 is not dividable by 4, so not aligned, so should fail as well! */
684 fail_if (gst_byte_reader_skip_string_utf32 (&reader));
685 /* let's try that again */
686 data[83] = '\0';
687 gst_byte_reader_init (&reader, data, 100);
688 backup = reader;
689 fail_unless (gst_byte_reader_skip_string_utf16 (&reader));
690 reader = backup;
691 fail_unless (gst_byte_reader_skip_string (&reader));
692 reader = backup;
693 fail_unless (gst_byte_reader_skip_string_utf8 (&reader));
694 reader = backup;
695 fail_unless (gst_byte_reader_peek_string (&reader, &s8));
696 fail_unless (gst_byte_reader_peek_string_utf8 (&reader, &s8));
697 fail_unless (gst_byte_reader_dup_string_utf16 (&reader, &c16));
698 g_free (c16);
699 reader = backup;
700 fail_unless (gst_byte_reader_dup_string_utf32 (&reader, &c32));
701 g_free (c32);
702
703 /* and again from the start */
704 gst_byte_reader_init (&reader, data, 100);
705 fail_unless (gst_byte_reader_skip_string_utf16 (&reader));
706 fail_if (gst_byte_reader_dup_data (&reader, 200, &d));
707 fail_if (gst_byte_reader_dup_data (&reader, 100, &d));
708 fail_if (gst_byte_reader_dup_data (&reader, 20, &d));
709 fail_unless (gst_byte_reader_dup_data (&reader, 10, &d));
710 fail_unless_equals_int (d[0], 0);
711 fail_unless_equals_int (d[1], 0);
712 fail_unless_equals_int (d[2], 85);
713 fail_unless_equals_int (d[3], 86);
714 g_free (d);
715 }
716
717 GST_END_TEST;
718
GST_START_TEST(test_dup_string)719 GST_START_TEST (test_dup_string)
720 {
721 const gchar moredata[] = { 0x99, 0x10, 'f', '0', '0', '!', '\0', 0xff };
722 GstByteReader reader;
723 guint16 num = 0;
724 guint8 x = 0;
725 gchar *s;
726
727 gst_byte_reader_init (&reader, (guint8 *) moredata, sizeof (moredata));
728 fail_unless (gst_byte_reader_get_uint16_be (&reader, &num));
729 fail_unless_equals_int (num, 0x9910);
730 fail_unless (gst_byte_reader_dup_string (&reader, &s));
731 fail_unless_equals_string (s, "f00!");
732 fail_unless (gst_byte_reader_get_uint8 (&reader, &x));
733 fail_unless_equals_int (x, 0xff);
734 g_free (s);
735 }
736
737 GST_END_TEST;
738
GST_START_TEST(test_sub_reader)739 GST_START_TEST (test_sub_reader)
740 {
741 const guint8 memdata[] = {
742 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
743 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
744 };
745 GstByteReader reader = GST_BYTE_READER_INIT (memdata, sizeof (memdata));
746 GstByteReader sub;
747 const guint8 *data = NULL, *sub_data = NULL;
748 guint16 v = 0;
749
750 /* init sub reader */
751 fail_if (gst_byte_reader_peek_sub_reader (&reader, &sub, 17));
752 fail_unless (gst_byte_reader_peek_sub_reader (&reader, &sub, 16));
753 fail_unless_equals_int (gst_byte_reader_get_remaining (&sub), 16);
754 fail_unless (gst_byte_reader_peek_data (&reader, 16, &data));
755 fail_unless (gst_byte_reader_peek_data (&sub, 16, &sub_data));
756 fail_unless (memcmp (data, sub_data, 16) == 0);
757
758 fail_unless_equals_int (gst_byte_reader_get_remaining (&reader), 16);
759 fail_unless (gst_byte_reader_skip (&reader, 3));
760 fail_if (gst_byte_reader_peek_sub_reader (&reader, &sub, 14));
761 fail_unless (gst_byte_reader_peek_sub_reader (&reader, &sub, 13));
762 fail_unless_equals_int (gst_byte_reader_get_remaining (&sub), 13);
763 fail_unless (gst_byte_reader_peek_data (&reader, 13, &data));
764 fail_unless (gst_byte_reader_peek_data (&sub, 13, &sub_data));
765 fail_unless (memcmp (data, sub_data, 13) == 0);
766 fail_unless (memcmp (memdata + 3, sub_data, 13) == 0);
767
768 fail_unless_equals_int (gst_byte_reader_get_remaining (&reader), 13);
769 fail_unless (gst_byte_reader_peek_sub_reader (&reader, &sub, 3));
770 fail_unless_equals_int (gst_byte_reader_get_remaining (&sub), 3);
771 fail_if (gst_byte_reader_peek_data (&sub, 10, &sub_data));
772 fail_unless (gst_byte_reader_get_uint16_be (&sub, &v));
773 fail_unless_equals_int (v, 0x0304);
774 fail_if (gst_byte_reader_get_uint16_be (&sub, &v));
775 fail_unless_equals_int (gst_byte_reader_get_remaining (&sub), 1);
776
777 fail_unless (gst_byte_reader_get_uint16_be (&reader, &v));
778 fail_unless_equals_int (v, 0x0304);
779 fail_unless (gst_byte_reader_get_uint16_be (&reader, &v));
780 fail_unless_equals_int (v, 0x0506);
781 fail_unless_equals_int (gst_byte_reader_get_remaining (&reader), 9);
782
783 /* get sub reader */
784 gst_byte_reader_init (&reader, memdata, sizeof (memdata));
785 fail_if (gst_byte_reader_get_sub_reader (&reader, &sub, 17));
786 fail_unless (gst_byte_reader_get_sub_reader (&reader, &sub, 16));
787 fail_if (gst_byte_reader_get_sub_reader (&reader, &sub, 1));
788 fail_unless (gst_byte_reader_get_sub_reader (&reader, &sub, 0));
789
790 gst_byte_reader_init (&reader, memdata, sizeof (memdata));
791 fail_unless (gst_byte_reader_get_sub_reader (&reader, &sub, 2));
792 fail_unless (gst_byte_reader_get_uint16_be (&sub, &v));
793 fail_unless_equals_int (v, 0x0001);
794 fail_if (gst_byte_reader_get_uint16_be (&sub, &v));
795 fail_unless (gst_byte_reader_get_sub_reader (&reader, &sub, 3));
796 fail_unless (gst_byte_reader_get_uint16_be (&sub, &v));
797 fail_unless_equals_int (v, 0x0203);
798 fail_if (gst_byte_reader_get_uint16_be (&sub, &v));
799 fail_unless_equals_int (gst_byte_reader_get_uint8_unchecked (&sub), 0x04);
800 fail_unless (gst_byte_reader_get_sub_reader (&reader, &sub, 9));
801 fail_unless (gst_byte_reader_get_uint16_be (&sub, &v));
802 fail_unless_equals_int (v, 0x0506);
803 fail_unless (gst_byte_reader_get_uint16_be (&sub, &v));
804 fail_unless_equals_int (v, 0x0708);
805 fail_unless (gst_byte_reader_get_uint16_be (&sub, &v));
806 fail_unless_equals_int (v, 0x090a);
807 fail_unless (gst_byte_reader_get_uint16_be (&sub, &v));
808 fail_unless_equals_int (v, 0x0b0c);
809 fail_if (gst_byte_reader_get_uint16_be (&sub, &v));
810 fail_unless_equals_int (gst_byte_reader_get_uint8_unchecked (&sub), 0x0d);
811 fail_if (gst_byte_reader_get_sub_reader (&reader, &sub, 3));
812 fail_unless (gst_byte_reader_get_sub_reader (&reader, &sub, 2));
813 fail_unless (gst_byte_reader_get_uint16_be (&sub, &v));
814 fail_unless_equals_int (v, 0x0e0f);
815 fail_if (gst_byte_reader_get_uint16_be (&sub, &v));
816 fail_if (gst_byte_reader_get_uint16_be (&reader, &v));
817 }
818
819 GST_END_TEST;
820
821 static Suite *
gst_byte_reader_suite(void)822 gst_byte_reader_suite (void)
823 {
824 Suite *s = suite_create ("GstByteReader");
825 TCase *tc_chain = tcase_create ("general");
826
827 suite_add_tcase (s, tc_chain);
828
829 tcase_add_test (tc_chain, test_initialization);
830 tcase_add_test (tc_chain, test_get_uint_le);
831 tcase_add_test (tc_chain, test_get_uint_be);
832 tcase_add_test (tc_chain, test_get_int_le);
833 tcase_add_test (tc_chain, test_get_int_be);
834 tcase_add_test (tc_chain, test_get_float_le);
835 tcase_add_test (tc_chain, test_get_float_be);
836 tcase_add_test (tc_chain, test_position_tracking);
837 tcase_add_test (tc_chain, test_scan);
838 tcase_add_test (tc_chain, test_string_funcs);
839 tcase_add_test (tc_chain, test_dup_string);
840 tcase_add_test (tc_chain, test_sub_reader);
841
842 return s;
843 }
844
845
846 GST_CHECK_MAIN (gst_byte_reader);
847