1 /* GStreamer
2 *
3 * unit test for GstBitReader
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/gstbitreader.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 GstBitReader reader = GST_BIT_READER_INIT (data, 4);
47 GstBitReader *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_bit_reader_get_bits_uint8 (&reader, &x, 8));
56 fail_unless_equals_int (x, 0x01);
57 fail_unless (gst_bit_reader_get_bits_uint8 (&reader, &x, 8));
58 fail_unless_equals_int (x, 0x02);
59
60 memset (&reader, 0, sizeof (GstBitReader));
61
62 gst_bit_reader_init (&reader, data, 4);
63 fail_unless (gst_bit_reader_get_bits_uint8 (&reader, &x, 8));
64 fail_unless_equals_int (x, 0x01);
65 fail_unless (gst_bit_reader_get_bits_uint8 (&reader, &x, 8));
66 fail_unless_equals_int (x, 0x02);
67
68 fail_unless (gst_buffer_map (buffer, &info, GST_MAP_READ));
69 gst_bit_reader_init (&reader, info.data, info.size);
70 fail_unless (gst_bit_reader_get_bits_uint8 (&reader, &x, 8));
71 fail_unless_equals_int (x, 0x01);
72 fail_unless (gst_bit_reader_get_bits_uint8 (&reader, &x, 8));
73 fail_unless_equals_int (x, 0x02);
74 gst_buffer_unmap (buffer, &info);
75
76 reader2 = gst_bit_reader_new (data, 4);
77 fail_unless (gst_bit_reader_get_bits_uint8 (reader2, &x, 8));
78 fail_unless_equals_int (x, 0x01);
79 fail_unless (gst_bit_reader_get_bits_uint8 (reader2, &x, 8));
80 fail_unless_equals_int (x, 0x02);
81 gst_bit_reader_free (reader2);
82
83 fail_unless (gst_buffer_map (buffer, &info, GST_MAP_READ));
84 reader2 = gst_bit_reader_new (info.data, info.size);
85 fail_unless (gst_bit_reader_get_bits_uint8 (reader2, &x, 8));
86 fail_unless_equals_int (x, 0x01);
87 fail_unless (gst_bit_reader_get_bits_uint8 (reader2, &x, 8));
88 fail_unless_equals_int (x, 0x02);
89 gst_bit_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_CHECK(reader, dest, bits, nbits, val) { \
98 fail_unless (gst_bit_reader_get_bits_uint##bits (reader, &dest, nbits)); \
99 fail_unless_equals_uint64 (dest, val); \
100 }
101
102 #define PEEK_CHECK(reader, dest, bits, nbits, val) { \
103 fail_unless (gst_bit_reader_peek_bits_uint##bits (reader, &dest, nbits)); \
104 fail_unless_equals_uint64 (dest, val); \
105 }
106
107 #define GET_CHECK_FAIL(reader, dest, bits, nbits) { \
108 fail_if (gst_bit_reader_get_bits_uint##bits (reader, &dest, nbits)); \
109 }
110
111 #define PEEK_CHECK_FAIL(reader, dest, bits, nbits) { \
112 fail_if (gst_bit_reader_peek_bits_uint##bits (reader, &dest, nbits)); \
113 }
114
GST_START_TEST(test_get_bits)115 GST_START_TEST (test_get_bits)
116 {
117 guint8 data[] = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef,
118 0xfe, 0xdc, 0xba, 0x09, 0x87, 0x65, 0x43, 0x21
119 };
120 GstBitReader reader = GST_BIT_READER_INIT (data, 16);
121 guint8 a = 0;
122 guint16 b = 0;
123 guint32 c = 0;
124 guint64 d = 0;
125
126 /* 8 bit */
127 GET_CHECK (&reader, a, 8, 8, 0x12);
128 GET_CHECK (&reader, a, 8, 4, 0x03);
129 GET_CHECK (&reader, a, 8, 4, 0x04);
130 GET_CHECK (&reader, a, 8, 3, 0x02);
131 GET_CHECK (&reader, a, 8, 1, 0x01);
132 GET_CHECK (&reader, a, 8, 2, 0x01);
133 GET_CHECK (&reader, a, 8, 2, 0x02);
134
135 PEEK_CHECK (&reader, a, 8, 8, 0x78);
136 PEEK_CHECK (&reader, a, 8, 8, 0x78);
137 fail_unless (gst_bit_reader_skip (&reader, 8));
138
139 PEEK_CHECK (&reader, a, 8, 8, 0x90);
140 GET_CHECK (&reader, a, 8, 1, 0x01);
141 GET_CHECK (&reader, a, 8, 1, 0x00);
142 GET_CHECK (&reader, a, 8, 1, 0x00);
143 GET_CHECK (&reader, a, 8, 1, 0x01);
144 fail_unless (gst_bit_reader_skip (&reader, 4));
145
146 fail_unless (gst_bit_reader_skip (&reader, 10 * 8));
147 GET_CHECK (&reader, a, 8, 8, 0x21);
148 GET_CHECK_FAIL (&reader, a, 8, 1);
149 PEEK_CHECK_FAIL (&reader, a, 8, 1);
150
151 /* 16 bit */
152 gst_bit_reader_init (&reader, data, 16);
153
154 GET_CHECK (&reader, b, 16, 16, 0x1234);
155 PEEK_CHECK (&reader, b, 16, 13, 0x0acf);
156 GET_CHECK (&reader, b, 16, 8, 0x56);
157 GET_CHECK (&reader, b, 16, 4, 0x07);
158 GET_CHECK (&reader, b, 16, 2, 0x02);
159 GET_CHECK (&reader, b, 16, 2, 0x00);
160 PEEK_CHECK (&reader, b, 16, 8, 0x90);
161 fail_unless (gst_bit_reader_skip (&reader, 11 * 8));
162 GET_CHECK (&reader, b, 16, 8, 0x21);
163 GET_CHECK_FAIL (&reader, b, 16, 16);
164 PEEK_CHECK_FAIL (&reader, b, 16, 16);
165
166 /* 32 bit */
167 gst_bit_reader_init (&reader, data, 16);
168
169 GET_CHECK (&reader, c, 32, 32, 0x12345678);
170 GET_CHECK (&reader, c, 32, 24, 0x90abcd);
171 GET_CHECK (&reader, c, 32, 16, 0xeffe);
172 GET_CHECK (&reader, c, 32, 8, 0xdc);
173 GET_CHECK (&reader, c, 32, 4, 0x0b);
174 GET_CHECK (&reader, c, 32, 2, 0x02);
175 GET_CHECK (&reader, c, 32, 2, 0x02);
176 PEEK_CHECK (&reader, c, 32, 8, 0x09);
177 fail_unless (gst_bit_reader_skip (&reader, 3 * 8));
178 GET_CHECK (&reader, c, 32, 15, 0x2190);
179 GET_CHECK (&reader, c, 32, 1, 0x1);
180 GET_CHECK_FAIL (&reader, c, 32, 1);
181
182 /* 64 bit */
183 gst_bit_reader_init (&reader, data, 16);
184
185 GET_CHECK (&reader, d, 64, 64, G_GINT64_CONSTANT (0x1234567890abcdef));
186 GET_CHECK (&reader, d, 64, 7, 0xfe >> 1);
187 GET_CHECK (&reader, d, 64, 1, 0x00);
188 GET_CHECK (&reader, d, 64, 24, 0xdcba09);
189 GET_CHECK (&reader, d, 64, 32, 0x87654321);
190 GET_CHECK_FAIL (&reader, d, 64, 32);
191 }
192
193 GST_END_TEST;
194
195 #undef GET_CHECK
196 #undef PEEK_CHECK
197 #undef GET_CHECK_FAIL
198 #undef PEEK_CHECK_FAIL
199
GST_START_TEST(test_position_tracking)200 GST_START_TEST (test_position_tracking)
201 {
202 guint8 data[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
203 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
204 };
205 GstBitReader reader = GST_BIT_READER_INIT (data, 16);
206 guint8 a = 0;
207
208 fail_unless_equals_int (gst_bit_reader_get_pos (&reader), 0);
209 fail_unless_equals_int (gst_bit_reader_get_remaining (&reader), 16 * 8);
210
211 fail_unless (gst_bit_reader_get_bits_uint8 (&reader, &a, 3));
212 fail_unless_equals_int (gst_bit_reader_get_pos (&reader), 3);
213 fail_unless_equals_int (gst_bit_reader_get_remaining (&reader), 16 * 8 - 3);
214
215 fail_unless (gst_bit_reader_set_pos (&reader, 9));
216 fail_unless_equals_int (gst_bit_reader_get_pos (&reader), 9);
217 fail_unless_equals_int (gst_bit_reader_get_remaining (&reader), 16 * 8 - 9);
218
219 fail_unless (gst_bit_reader_skip (&reader, 3));
220 fail_unless_equals_int (gst_bit_reader_get_pos (&reader), 12);
221 fail_unless_equals_int (gst_bit_reader_get_remaining (&reader), 16 * 8 - 12);
222
223 fail_unless (gst_bit_reader_skip_to_byte (&reader));
224 fail_unless_equals_int (gst_bit_reader_get_pos (&reader), 16);
225 fail_unless_equals_int (gst_bit_reader_get_remaining (&reader), 16 * 8 - 16);
226
227 fail_unless (gst_bit_reader_set_pos (&reader, 16 * 8));
228 fail_unless_equals_int (gst_bit_reader_get_pos (&reader), 16 * 8);
229 fail_unless_equals_int (gst_bit_reader_get_remaining (&reader), 0);
230
231 fail_unless (gst_bit_reader_skip (&reader, 0));
232 fail_if (gst_bit_reader_skip (&reader, 1));
233 fail_unless (gst_bit_reader_skip_to_byte (&reader));
234 }
235
236 GST_END_TEST;
237
238 static Suite *
gst_bit_reader_suite(void)239 gst_bit_reader_suite (void)
240 {
241 Suite *s = suite_create ("GstBitReader");
242 TCase *tc_chain = tcase_create ("general");
243
244 suite_add_tcase (s, tc_chain);
245
246 tcase_add_test (tc_chain, test_initialization);
247 tcase_add_test (tc_chain, test_get_bits);
248 tcase_add_test (tc_chain, test_position_tracking);
249
250 return s;
251 }
252
253
254 GST_CHECK_MAIN (gst_bit_reader);
255