1 // Copyright 2021 The libgav1 Authors
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #include "src/utils/raw_bit_reader.h"
16
17 #include <bitset>
18 #include <cstddef>
19 #include <cstdint>
20 #include <memory>
21 #include <new>
22 #include <string>
23 #include <tuple>
24 #include <vector>
25
26 #include "gtest/gtest.h"
27 #include "src/utils/constants.h"
28 #include "tests/third_party/libvpx/acm_random.h"
29
30 namespace libgav1 {
31 namespace {
32
IntegerToString(int x)33 std::string IntegerToString(int x) { return std::bitset<8>(x).to_string(); }
34
35 class RawBitReaderTest : public testing::TestWithParam<std::tuple<int, int>> {
36 protected:
RawBitReaderTest()37 RawBitReaderTest()
38 : literal_size_(std::get<0>(GetParam())),
39 test_data_size_(std::get<1>(GetParam())) {}
40
CreateReader(const std::vector<uint8_t> & data)41 void CreateReader(const std::vector<uint8_t>& data) {
42 data_ = data;
43 raw_bit_reader_.reset(new (std::nothrow)
44 RawBitReader(data_.data(), data_.size()));
45 }
46
CreateReader(int size)47 void CreateReader(int size) {
48 libvpx_test::ACMRandom rnd(libvpx_test::ACMRandom::DeterministicSeed());
49 data_.clear();
50 for (int i = 0; i < size; ++i) {
51 data_.push_back(rnd.Rand8());
52 }
53 raw_bit_reader_.reset(new (std::nothrow)
54 RawBitReader(data_.data(), data_.size()));
55 }
56
57 // Some tests don't depend on |literal_size_|. For those tests, return true if
58 // the |literal_size_| is greater than 1. If this function returns true, the
59 // test will abort.
RunOnlyOnce() const60 bool RunOnlyOnce() const { return literal_size_ > 1; }
61
62 std::unique_ptr<RawBitReader> raw_bit_reader_;
63 std::vector<uint8_t> data_;
64 int literal_size_;
65 int test_data_size_;
66 };
67
TEST_P(RawBitReaderTest,ReadBit)68 TEST_P(RawBitReaderTest, ReadBit) {
69 if (RunOnlyOnce()) return;
70 CreateReader(test_data_size_);
71 for (const auto& value : data_) {
72 const std::string expected = IntegerToString(value);
73 for (int j = 0; j < 8; ++j) {
74 EXPECT_FALSE(raw_bit_reader_->Finished());
75 EXPECT_EQ(static_cast<int>(expected[j] == '1'),
76 raw_bit_reader_->ReadBit());
77 }
78 }
79 EXPECT_TRUE(raw_bit_reader_->Finished());
80 EXPECT_EQ(raw_bit_reader_->ReadBit(), -1);
81 }
82
TEST_P(RawBitReaderTest,ReadLiteral)83 TEST_P(RawBitReaderTest, ReadLiteral) {
84 const int size_bytes = literal_size_;
85 const int size_bits = 8 * size_bytes;
86 CreateReader(test_data_size_ * size_bytes);
87 for (size_t i = 0; i < data_.size(); i += size_bytes) {
88 uint32_t expected_literal = 0;
89 for (int j = 0; j < size_bytes; ++j) {
90 expected_literal |=
91 static_cast<uint32_t>(data_[i + j] << (8 * (size_bytes - j - 1)));
92 }
93 EXPECT_FALSE(raw_bit_reader_->Finished());
94 const int64_t actual_literal = raw_bit_reader_->ReadLiteral(size_bits);
95 EXPECT_EQ(static_cast<int64_t>(expected_literal), actual_literal);
96 EXPECT_GE(actual_literal, 0);
97 }
98 EXPECT_TRUE(raw_bit_reader_->Finished());
99 EXPECT_EQ(raw_bit_reader_->ReadLiteral(10), -1);
100 }
101
TEST_P(RawBitReaderTest,ReadLiteral32BitsWithMsbSet)102 TEST_P(RawBitReaderTest, ReadLiteral32BitsWithMsbSet) {
103 if (RunOnlyOnce()) return;
104 // Three 32-bit values with MSB set.
105 CreateReader({0xff, 0xff, 0xff, 0xff, // 4294967295
106 0x80, 0xff, 0xee, 0xdd, // 2164256477
107 0xa0, 0xaa, 0xbb, 0xcc}); // 2695543756
108 static constexpr int64_t expected_literals[] = {4294967295, 2164256477,
109 2695543756};
110 for (const int64_t expected_literal : expected_literals) {
111 EXPECT_FALSE(raw_bit_reader_->Finished());
112 const int64_t actual_literal = raw_bit_reader_->ReadLiteral(32);
113 EXPECT_EQ(expected_literal, actual_literal);
114 EXPECT_GE(actual_literal, 0);
115 }
116 EXPECT_TRUE(raw_bit_reader_->Finished());
117 EXPECT_EQ(raw_bit_reader_->ReadLiteral(10), -1);
118 }
119
TEST_P(RawBitReaderTest,ReadLiteralNotEnoughBits)120 TEST_P(RawBitReaderTest, ReadLiteralNotEnoughBits) {
121 if (RunOnlyOnce()) return;
122 CreateReader(4); // 32 bits.
123 EXPECT_GE(raw_bit_reader_->ReadLiteral(16), 0);
124 EXPECT_EQ(raw_bit_reader_->ReadLiteral(32), -1);
125 }
126
TEST_P(RawBitReaderTest,ReadLiteralMaxNumBits)127 TEST_P(RawBitReaderTest, ReadLiteralMaxNumBits) {
128 if (RunOnlyOnce()) return;
129 CreateReader(4); // 32 bits.
130 EXPECT_NE(raw_bit_reader_->ReadLiteral(32), -1);
131 }
132
TEST_P(RawBitReaderTest,ReadInverseSignedLiteral)133 TEST_P(RawBitReaderTest, ReadInverseSignedLiteral) {
134 if (RunOnlyOnce()) return;
135 // This is the only usage for this function in the decoding process. So
136 // testing just that case.
137 const int size_bits = 6;
138 data_.clear();
139 // Negative value followed by a positive value.
140 data_.push_back(0xd2);
141 data_.push_back(0xa4);
142 raw_bit_reader_.reset(new (std::nothrow)
143 RawBitReader(data_.data(), data_.size()));
144 int value;
145 EXPECT_TRUE(raw_bit_reader_->ReadInverseSignedLiteral(size_bits, &value));
146 EXPECT_EQ(value, -23);
147 EXPECT_TRUE(raw_bit_reader_->ReadInverseSignedLiteral(size_bits, &value));
148 EXPECT_EQ(value, 41);
149 // We have only two bits left. Trying to read an inverse signed literal of 2
150 // bits actually needs 3 bits. So this should fail.
151 EXPECT_FALSE(raw_bit_reader_->ReadInverseSignedLiteral(2, &value));
152 }
153
TEST_P(RawBitReaderTest,ZeroSize)154 TEST_P(RawBitReaderTest, ZeroSize) {
155 if (RunOnlyOnce()) return;
156 // Valid data, zero size.
157 data_.clear();
158 data_.push_back(0xf0);
159 raw_bit_reader_.reset(new (std::nothrow) RawBitReader(data_.data(), 0));
160 EXPECT_EQ(raw_bit_reader_->ReadBit(), -1);
161 EXPECT_EQ(raw_bit_reader_->ReadLiteral(2), -1);
162 // NULL data, zero size.
163 raw_bit_reader_.reset(new (std::nothrow) RawBitReader(nullptr, 0));
164 EXPECT_EQ(raw_bit_reader_->ReadBit(), -1);
165 EXPECT_EQ(raw_bit_reader_->ReadLiteral(2), -1);
166 }
167
TEST_P(RawBitReaderTest,AlignToNextByte)168 TEST_P(RawBitReaderTest, AlignToNextByte) {
169 if (RunOnlyOnce()) return;
170 CreateReader({0x00, 0x00, 0x00, 0x0f});
171 EXPECT_EQ(raw_bit_reader_->bit_offset(), 0);
172 EXPECT_EQ(raw_bit_reader_->byte_offset(), 0);
173 EXPECT_TRUE(raw_bit_reader_->AlignToNextByte());
174 EXPECT_EQ(raw_bit_reader_->bit_offset(), 0);
175 EXPECT_EQ(raw_bit_reader_->byte_offset(), 0);
176 EXPECT_NE(raw_bit_reader_->ReadBit(), -1);
177 EXPECT_EQ(raw_bit_reader_->bit_offset(), 1);
178 EXPECT_EQ(raw_bit_reader_->byte_offset(), 1);
179 EXPECT_TRUE(raw_bit_reader_->AlignToNextByte());
180 EXPECT_EQ(raw_bit_reader_->bit_offset(), 8);
181 EXPECT_EQ(raw_bit_reader_->byte_offset(), 1);
182 EXPECT_NE(raw_bit_reader_->ReadLiteral(16), -1);
183 EXPECT_EQ(raw_bit_reader_->bit_offset(), 24);
184 EXPECT_EQ(raw_bit_reader_->byte_offset(), 3);
185 EXPECT_TRUE(raw_bit_reader_->AlignToNextByte());
186 EXPECT_EQ(raw_bit_reader_->bit_offset(), 24);
187 EXPECT_EQ(raw_bit_reader_->byte_offset(), 3);
188 EXPECT_NE(raw_bit_reader_->ReadBit(), -1);
189 EXPECT_EQ(raw_bit_reader_->bit_offset(), 25);
190 EXPECT_EQ(raw_bit_reader_->byte_offset(), 4);
191 // Some bits are non-zero.
192 EXPECT_FALSE(raw_bit_reader_->AlignToNextByte());
193 }
194
TEST_P(RawBitReaderTest,VerifyAndSkipTrailingBits)195 TEST_P(RawBitReaderTest, VerifyAndSkipTrailingBits) {
196 if (RunOnlyOnce()) return;
197 std::vector<uint8_t> data;
198
199 // 1 byte trailing byte.
200 data.push_back(0x80);
201 CreateReader(data);
202 EXPECT_EQ(raw_bit_reader_->bit_offset(), 0);
203 EXPECT_TRUE(raw_bit_reader_->VerifyAndSkipTrailingBits(8));
204 EXPECT_EQ(raw_bit_reader_->bit_offset(), 8);
205
206 // 2 byte trailing byte beginning at a byte-aligned offset.
207 data.clear();
208 data.push_back(0xf8);
209 data.push_back(0x80);
210 CreateReader(data);
211 EXPECT_NE(raw_bit_reader_->ReadLiteral(8), -1);
212 EXPECT_EQ(raw_bit_reader_->bit_offset(), 8);
213 EXPECT_TRUE(raw_bit_reader_->VerifyAndSkipTrailingBits(8));
214 EXPECT_EQ(raw_bit_reader_->bit_offset(), 16);
215
216 // 2 byte trailing byte beginning at a non-byte-aligned offset.
217 data.clear();
218 data.push_back(0xf8);
219 data.push_back(0x00);
220 CreateReader(data);
221 EXPECT_NE(raw_bit_reader_->ReadLiteral(4), -1);
222 EXPECT_EQ(raw_bit_reader_->bit_offset(), 4);
223 EXPECT_TRUE(raw_bit_reader_->VerifyAndSkipTrailingBits(4));
224 EXPECT_EQ(raw_bit_reader_->bit_offset(), 8);
225
226 // Invalid trailing byte at a byte-aligned offset.
227 data.clear();
228 data.push_back(0xf7);
229 data.push_back(0x70);
230 CreateReader(data);
231 EXPECT_NE(raw_bit_reader_->ReadLiteral(8), -1);
232 EXPECT_EQ(raw_bit_reader_->bit_offset(), 8);
233 EXPECT_FALSE(raw_bit_reader_->VerifyAndSkipTrailingBits(8));
234
235 // Invalid trailing byte at a non-byte-aligned offset.
236 CreateReader(data);
237 EXPECT_NE(raw_bit_reader_->ReadLiteral(4), -1);
238 EXPECT_EQ(raw_bit_reader_->bit_offset(), 4);
239 EXPECT_FALSE(raw_bit_reader_->VerifyAndSkipTrailingBits(12));
240
241 // No more data available.
242 CreateReader(data);
243 EXPECT_NE(raw_bit_reader_->ReadLiteral(16), -1);
244 EXPECT_EQ(raw_bit_reader_->bit_offset(), 16);
245 EXPECT_TRUE(raw_bit_reader_->Finished());
246 EXPECT_FALSE(raw_bit_reader_->VerifyAndSkipTrailingBits(8));
247 }
248
TEST_P(RawBitReaderTest,ReadLittleEndian)249 TEST_P(RawBitReaderTest, ReadLittleEndian) {
250 if (RunOnlyOnce()) return;
251 std::vector<uint8_t> data;
252 size_t actual;
253
254 // Invalid input.
255 data.push_back(0x00); // dummy.
256 CreateReader(data);
257 EXPECT_FALSE(raw_bit_reader_->ReadLittleEndian(1, nullptr));
258
259 // One byte value.
260 data.clear();
261 data.push_back(0x01);
262 CreateReader(data);
263 ASSERT_TRUE(raw_bit_reader_->ReadLittleEndian(1, &actual));
264 EXPECT_EQ(actual, 1);
265 EXPECT_EQ(raw_bit_reader_->bit_offset(), 8);
266 EXPECT_TRUE(raw_bit_reader_->Finished());
267
268 // One byte value with leading bytes.
269 data.clear();
270 data.push_back(0x01);
271 data.push_back(0x00);
272 data.push_back(0x00);
273 data.push_back(0x00);
274 CreateReader(data);
275 ASSERT_TRUE(raw_bit_reader_->ReadLittleEndian(4, &actual));
276 EXPECT_EQ(actual, 1);
277 EXPECT_EQ(raw_bit_reader_->bit_offset(), 32);
278 EXPECT_TRUE(raw_bit_reader_->Finished());
279
280 // Two byte value.
281 data.clear();
282 data.push_back(0xD9);
283 data.push_back(0x01);
284 CreateReader(data);
285 ASSERT_TRUE(raw_bit_reader_->ReadLittleEndian(2, &actual));
286 EXPECT_EQ(actual, 473);
287 EXPECT_EQ(raw_bit_reader_->bit_offset(), 16);
288 EXPECT_TRUE(raw_bit_reader_->Finished());
289
290 // Two byte value with leading bytes.
291 data.clear();
292 data.push_back(0xD9);
293 data.push_back(0x01);
294 data.push_back(0x00);
295 data.push_back(0x00);
296 CreateReader(data);
297 ASSERT_TRUE(raw_bit_reader_->ReadLittleEndian(4, &actual));
298 EXPECT_EQ(actual, 473);
299 EXPECT_EQ(raw_bit_reader_->bit_offset(), 32);
300 EXPECT_TRUE(raw_bit_reader_->Finished());
301
302 // Not enough bytes.
303 data.clear();
304 data.push_back(0x01);
305 CreateReader(data);
306 EXPECT_FALSE(raw_bit_reader_->ReadLittleEndian(2, &actual));
307 }
308
TEST_P(RawBitReaderTest,ReadUnsignedLeb128)309 TEST_P(RawBitReaderTest, ReadUnsignedLeb128) {
310 if (RunOnlyOnce()) return;
311 std::vector<uint8_t> data;
312 size_t actual;
313
314 // Invalid input.
315 data.push_back(0x00); // dummy.
316 CreateReader(data);
317 EXPECT_FALSE(raw_bit_reader_->ReadUnsignedLeb128(nullptr));
318
319 // One byte value.
320 data.clear();
321 data.push_back(0x01);
322 CreateReader(data);
323 ASSERT_TRUE(raw_bit_reader_->ReadUnsignedLeb128(&actual));
324 EXPECT_EQ(actual, 1);
325 EXPECT_EQ(raw_bit_reader_->bit_offset(), 8);
326 EXPECT_TRUE(raw_bit_reader_->Finished());
327
328 // One byte value with trailing bytes.
329 data.clear();
330 data.push_back(0x81);
331 data.push_back(0x80);
332 data.push_back(0x80);
333 data.push_back(0x00);
334 CreateReader(data);
335 ASSERT_TRUE(raw_bit_reader_->ReadUnsignedLeb128(&actual));
336 EXPECT_EQ(actual, 1);
337 EXPECT_EQ(raw_bit_reader_->bit_offset(), 32);
338 EXPECT_TRUE(raw_bit_reader_->Finished());
339
340 // Two byte value.
341 data.clear();
342 data.push_back(0xD9);
343 data.push_back(0x01);
344 CreateReader(data);
345 ASSERT_TRUE(raw_bit_reader_->ReadUnsignedLeb128(&actual));
346 EXPECT_EQ(actual, 217);
347 EXPECT_EQ(raw_bit_reader_->bit_offset(), 16);
348 EXPECT_TRUE(raw_bit_reader_->Finished());
349
350 // Two byte value with trailing bytes.
351 data.clear();
352 data.push_back(0xD9);
353 data.push_back(0x81);
354 data.push_back(0x80);
355 data.push_back(0x80);
356 data.push_back(0x00);
357 CreateReader(data);
358 ASSERT_TRUE(raw_bit_reader_->ReadUnsignedLeb128(&actual));
359 EXPECT_EQ(actual, 217);
360 EXPECT_EQ(raw_bit_reader_->bit_offset(), 40);
361 EXPECT_TRUE(raw_bit_reader_->Finished());
362
363 // Value > 32 bits.
364 data.clear();
365 for (int i = 0; i < 5; ++i) data.push_back(0xD9);
366 data.push_back(0x00);
367 CreateReader(data);
368 EXPECT_FALSE(raw_bit_reader_->ReadUnsignedLeb128(&actual));
369
370 // Not enough bytes (truncated leb128 value).
371 data.clear();
372 data.push_back(0x81);
373 data.push_back(0x81);
374 data.push_back(0x81);
375 CreateReader(data);
376 EXPECT_FALSE(raw_bit_reader_->ReadUnsignedLeb128(&actual));
377
378 // Exceeds kMaximumLeb128Size.
379 data.clear();
380 for (int i = 0; i < 10; ++i) data.push_back(0x80);
381 CreateReader(data);
382 EXPECT_FALSE(raw_bit_reader_->ReadUnsignedLeb128(&actual));
383 }
384
TEST_P(RawBitReaderTest,ReadUvlc)385 TEST_P(RawBitReaderTest, ReadUvlc) {
386 if (RunOnlyOnce()) return;
387 std::vector<uint8_t> data;
388 uint32_t actual;
389
390 // Invalid input.
391 data.push_back(0x00); // dummy.
392 CreateReader(data);
393 EXPECT_FALSE(raw_bit_reader_->ReadUvlc(nullptr));
394
395 // Zero bit value.
396 data.clear();
397 data.push_back(0x80);
398 CreateReader(data);
399 ASSERT_TRUE(raw_bit_reader_->ReadUvlc(&actual));
400 EXPECT_EQ(actual, 0);
401 EXPECT_EQ(raw_bit_reader_->bit_offset(), 1);
402
403 // One bit value.
404 data.clear();
405 data.push_back(0x60); // 011...
406 CreateReader(data);
407 ASSERT_TRUE(raw_bit_reader_->ReadUvlc(&actual));
408 EXPECT_EQ(actual, 2);
409 EXPECT_EQ(raw_bit_reader_->bit_offset(), 3);
410
411 // Two bit value.
412 data.clear();
413 data.push_back(0x38); // 00111...
414 CreateReader(data);
415 ASSERT_TRUE(raw_bit_reader_->ReadUvlc(&actual));
416 EXPECT_EQ(actual, 6);
417 EXPECT_EQ(raw_bit_reader_->bit_offset(), 5);
418
419 // 31 bit value.
420 data.clear();
421 // (1 << 32) - 2 (= UINT32_MAX - 1) is the largest value that can be encoded
422 // as uvlc().
423 data.push_back(0x00);
424 data.push_back(0x00);
425 data.push_back(0x00);
426 data.push_back(0x01);
427 data.push_back(0xFF);
428 data.push_back(0xFF);
429 data.push_back(0xFF);
430 data.push_back(0xFE);
431 CreateReader(data);
432 ASSERT_TRUE(raw_bit_reader_->ReadUvlc(&actual));
433 EXPECT_EQ(actual, UINT32_MAX - 1);
434 EXPECT_EQ(raw_bit_reader_->bit_offset(), 63);
435
436 // Not enough bits (truncated uvlc value).
437 data.clear();
438 data.push_back(0x07);
439 CreateReader(data);
440 EXPECT_FALSE(raw_bit_reader_->ReadUvlc(&actual));
441
442 // 32 bits.
443 data.clear();
444 data.push_back(0x00);
445 data.push_back(0x00);
446 data.push_back(0x00);
447 data.push_back(0x00);
448 data.push_back(0xFF);
449 CreateReader(data);
450 EXPECT_FALSE(raw_bit_reader_->ReadUvlc(&actual));
451
452 // Exceeds 32 bits.
453 data.clear();
454 data.push_back(0x00);
455 data.push_back(0x00);
456 data.push_back(0x00);
457 data.push_back(0x00);
458 data.push_back(0x0F);
459 CreateReader(data);
460 EXPECT_FALSE(raw_bit_reader_->ReadUvlc(&actual));
461 }
462
TEST_P(RawBitReaderTest,DecodeSignedSubexpWithReference)463 TEST_P(RawBitReaderTest, DecodeSignedSubexpWithReference) {
464 if (RunOnlyOnce()) return;
465 std::vector<uint8_t> data;
466 int actual;
467
468 data.push_back(0xa0); // v = 5;
469 CreateReader(data);
470 EXPECT_TRUE(raw_bit_reader_->DecodeSignedSubexpWithReference(
471 10, 20, 15, kGlobalMotionReadControl, &actual));
472 EXPECT_EQ(actual, 12);
473
474 data.clear();
475 data.push_back(0xd0); // v = 6; extra_bit = 1;
476 CreateReader(data);
477 EXPECT_TRUE(raw_bit_reader_->DecodeSignedSubexpWithReference(
478 10, 20, 15, kGlobalMotionReadControl, &actual));
479 EXPECT_EQ(actual, 11);
480
481 data.clear();
482 data.push_back(0xc8); // subexp_more_bits = 1; v = 9;
483 CreateReader(data);
484 EXPECT_TRUE(raw_bit_reader_->DecodeSignedSubexpWithReference(
485 10, 40, 15, kGlobalMotionReadControl, &actual));
486 EXPECT_EQ(actual, 27);
487
488 data.clear();
489 data.push_back(0x60); // subexp_more_bits = 0; subexp_bits = 6.
490 CreateReader(data);
491 EXPECT_TRUE(raw_bit_reader_->DecodeSignedSubexpWithReference(
492 10, 40, 15, kGlobalMotionReadControl, &actual));
493 EXPECT_EQ(actual, 18);
494
495 data.clear();
496 data.push_back(0x60);
497 CreateReader(data);
498 // Control is greater than 32, which makes b >= 32 in DecodeSubexp() and
499 // should return false.
500 EXPECT_FALSE(raw_bit_reader_->DecodeSignedSubexpWithReference(10, 40, 15, 35,
501 &actual));
502 }
503
TEST_P(RawBitReaderTest,DecodeUniform)504 TEST_P(RawBitReaderTest, DecodeUniform) {
505 if (RunOnlyOnce()) return;
506 // Test the example from the AV1 spec, Section 4.10.7. ns(n).
507 // n = 5
508 // Value ns(n) encoding
509 // -------------------------------
510 // 0 00
511 // 1 01
512 // 2 10
513 // 3 110
514 // 4 111
515 //
516 // The five encoded values are concatenated into two bytes.
517 std::vector<uint8_t> data = {0x1b, 0x70};
518 CreateReader(data);
519 int actual;
520 for (int i = 0; i < 5; ++i) {
521 EXPECT_TRUE(raw_bit_reader_->DecodeUniform(5, &actual));
522 EXPECT_EQ(actual, i);
523 }
524
525 // If n is a power of 2, ns(n) is simply the log2(n)-bit representation of
526 // the unsigned number.
527 // Test n = 16.
528 // The 16 encoded values are concatenated into 8 bytes.
529 data = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef};
530 CreateReader(data);
531 for (int i = 0; i < 16; ++i) {
532 EXPECT_TRUE(raw_bit_reader_->DecodeUniform(16, &actual));
533 EXPECT_EQ(actual, i);
534 }
535 }
536
TEST_P(RawBitReaderTest,SkipBytes)537 TEST_P(RawBitReaderTest, SkipBytes) {
538 if (RunOnlyOnce()) return;
539 std::vector<uint8_t> data = {0x00, 0x00, 0x00, 0x00, 0x00};
540 CreateReader(data);
541 EXPECT_EQ(raw_bit_reader_->bit_offset(), 0);
542 EXPECT_TRUE(raw_bit_reader_->SkipBytes(1));
543 EXPECT_EQ(raw_bit_reader_->bit_offset(), 8);
544 EXPECT_GE(raw_bit_reader_->ReadBit(), 0);
545 EXPECT_EQ(raw_bit_reader_->bit_offset(), 9);
546 EXPECT_FALSE(raw_bit_reader_->SkipBytes(1)); // Not at a byte boundary.
547 EXPECT_TRUE(raw_bit_reader_->AlignToNextByte());
548 EXPECT_EQ(raw_bit_reader_->bit_offset(), 16);
549 EXPECT_FALSE(raw_bit_reader_->SkipBytes(10)); // Not enough bytes.
550 EXPECT_EQ(raw_bit_reader_->bit_offset(), 16);
551 EXPECT_TRUE(raw_bit_reader_->SkipBytes(3));
552 EXPECT_TRUE(raw_bit_reader_->Finished());
553 EXPECT_EQ(raw_bit_reader_->ReadBit(), -1);
554 }
555
TEST_P(RawBitReaderTest,SkipBits)556 TEST_P(RawBitReaderTest, SkipBits) {
557 if (RunOnlyOnce()) return;
558 std::vector<uint8_t> data = {0x00, 0x00, 0x00, 0x00, 0x00};
559 CreateReader(data);
560 EXPECT_EQ(raw_bit_reader_->bit_offset(), 0);
561 EXPECT_TRUE(raw_bit_reader_->SkipBits(8));
562 EXPECT_EQ(raw_bit_reader_->bit_offset(), 8);
563 EXPECT_GE(raw_bit_reader_->ReadBit(), 0);
564 EXPECT_EQ(raw_bit_reader_->bit_offset(), 9);
565 EXPECT_TRUE(raw_bit_reader_->SkipBits(10)); // Not at a byte boundary.
566 EXPECT_EQ(raw_bit_reader_->bit_offset(), 19);
567 EXPECT_FALSE(raw_bit_reader_->SkipBits(80)); // Not enough bytes.
568 EXPECT_EQ(raw_bit_reader_->bit_offset(), 19);
569 EXPECT_TRUE(raw_bit_reader_->SkipBits(21));
570 EXPECT_TRUE(raw_bit_reader_->Finished());
571 EXPECT_EQ(raw_bit_reader_->ReadBit(), -1);
572 }
573
574 INSTANTIATE_TEST_SUITE_P(
575 RawBitReaderTestInstance, RawBitReaderTest,
576 testing::Combine(testing::Range(1, 5), // literal size.
577 testing::Values(100))); // number of bits/literals.
578
579 } // namespace
580 } // namespace libgav1
581