RawSpeed
fast raw decoding library
Loading...
Searching...
No Matches
BitVacuumerMSB16Test.cpp
Go to the documentation of this file.
1/*
2 RawSpeed - RAW file decoder.
3
4 Copyright (C) 2024 Roman Lebedev
5
6 This library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser 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 Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public
17 License along with this library; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19*/
20
21#include "bitstreams/BitVacuumerMSB16.h"
22#include "adt/Array1DRef.h"
23#include "adt/Bit.h"
24#include "adt/Casts.h"
25#include "adt/PartitioningOutputIterator.h"
26#include "bitstreams/BitStreamPosition.h"
27#include "bitstreams/BitStreamerMSB16.h"
28#include "common/Common.h"
29#include <climits>
30#include <cstdint>
31#include <iterator>
32#include <utility>
33#include <vector>
34#include <gmock/gmock.h>
35#include <gtest/gtest.h>
36
37#pragma GCC diagnostic push
38#pragma GCC diagnostic ignored "-Wpragmas"
39#pragma GCC diagnostic ignored "-Wunknown-warning-option"
40#pragma GCC diagnostic ignored "-Wunknown-pragmas"
41#pragma GCC diagnostic ignored "-Wframe-larger-than="
42#pragma GCC diagnostic ignored "-Wstack-usage="
43
44namespace rawspeed {
45
46namespace {
47
48using RecepieEntryType = std::pair<uint32_t, uint8_t>;
49using RecepieType = std::vector<RecepieEntryType>;
50using ResultType = std::vector<uint8_t>;
51
52using valueType = std::pair<RecepieType, ResultType>;
53class BitVacuumerMSB16Test : public ::testing::TestWithParam<valueType> {
54protected:
55 BitVacuumerMSB16Test() = default;
56 virtual void SetUp() {
57 recepie = std::get<0>(GetParam());
58 expectedOutput = std::get<1>(GetParam());
59 }
60
61 RecepieType recepie;
62 ResultType expectedOutput;
63};
64const std::vector<valueType> values = {{
65 // clang-format off
66 {RecepieType({{std::make_pair(0x00, 0)}}), ResultType()},
67 {RecepieType({{std::make_pair(0x00, 1)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
68 {RecepieType({{std::make_pair(0x00, 2)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
69 {RecepieType({{std::make_pair(0x00, 3)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
70 {RecepieType({{std::make_pair(0x00, 4)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
71 {RecepieType({{std::make_pair(0x00, 5)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
72 {RecepieType({{std::make_pair(0x00, 6)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
73 {RecepieType({{std::make_pair(0x00, 7)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
74 {RecepieType({{std::make_pair(0x00, 8)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
75 {RecepieType({{std::make_pair(0x00, 9)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
76 {RecepieType({{std::make_pair(0x00, 10)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
77 {RecepieType({{std::make_pair(0x00, 11)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
78 {RecepieType({{std::make_pair(0x00, 12)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
79 {RecepieType({{std::make_pair(0x00, 13)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
80 {RecepieType({{std::make_pair(0x00, 14)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
81 {RecepieType({{std::make_pair(0x00, 15)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
82 {RecepieType({{std::make_pair(0x00, 16)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
83 {RecepieType({{std::make_pair(0x00, 17)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
84 {RecepieType({{std::make_pair(0x00, 18)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
85 {RecepieType({{std::make_pair(0x00, 19)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
86 {RecepieType({{std::make_pair(0x00, 20)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
87 {RecepieType({{std::make_pair(0x00, 21)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
88 {RecepieType({{std::make_pair(0x00, 22)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
89 {RecepieType({{std::make_pair(0x00, 23)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
90 {RecepieType({{std::make_pair(0x00, 24)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
91 {RecepieType({{std::make_pair(0x00, 25)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
92 {RecepieType({{std::make_pair(0x00, 26)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
93 {RecepieType({{std::make_pair(0x00, 27)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
94 {RecepieType({{std::make_pair(0x00, 28)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
95 {RecepieType({{std::make_pair(0x00, 29)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
96 {RecepieType({{std::make_pair(0x00, 30)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
97 {RecepieType({{std::make_pair(0x00, 31)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
98 {RecepieType({{std::make_pair(0x00, 32)}}), ResultType({{0x00, 0x00, 0x00, 0x00}})},
99 {RecepieType({{std::make_pair(0XFF, 8)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
100 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 0)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
101 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 1)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
102 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 2)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
103 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 3)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
104 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 4)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
105 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 5)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
106 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 6)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
107 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 7)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
108 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 8)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
109 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 9)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
110 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 10)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
111 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 11)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
112 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 12)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
113 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 13)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
114 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 14)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
115 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 15)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
116 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 16)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
117 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 17)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
118 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 18)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
119 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 19)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
120 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 20)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
121 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 21)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
122 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 22)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
123 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 23)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
124 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 24)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
125 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 25)}}), ResultType({{0x00, 0XFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}})},
126 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 26)}}), ResultType({{0x00, 0XFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}})},
127 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 27)}}), ResultType({{0x00, 0XFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}})},
128 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 28)}}), ResultType({{0x00, 0XFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}})},
129 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 29)}}), ResultType({{0x00, 0XFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}})},
130 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 30)}}), ResultType({{0x00, 0XFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}})},
131 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 31)}}), ResultType({{0x00, 0XFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}})},
132 {RecepieType({{std::make_pair(0XFF, 8), std::make_pair(0x00, 32)}}), ResultType({{0x00, 0XFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}})},
133 {RecepieType({{std::make_pair(0x00, 0), std::make_pair(0XFF, 8)}}), ResultType({{0x00, 0XFF, 0x00, 0x00}})},
134 {RecepieType({{std::make_pair(0x00, 1), std::make_pair(0XFF, 8)}}), ResultType({{0X80, 0X7F, 0x00, 0x00}})},
135 {RecepieType({{std::make_pair(0x00, 2), std::make_pair(0XFF, 8)}}), ResultType({{0XC0, 0X3F, 0x00, 0x00}})},
136 {RecepieType({{std::make_pair(0x00, 3), std::make_pair(0XFF, 8)}}), ResultType({{0XE0, 0X1F, 0x00, 0x00}})},
137 {RecepieType({{std::make_pair(0x00, 4), std::make_pair(0XFF, 8)}}), ResultType({{0XF0, 0XF, 0x00, 0x00}})},
138 {RecepieType({{std::make_pair(0x00, 5), std::make_pair(0XFF, 8)}}), ResultType({{0XF8, 0X7, 0x00, 0x00}})},
139 {RecepieType({{std::make_pair(0x00, 6), std::make_pair(0XFF, 8)}}), ResultType({{0XFC, 0X3, 0x00, 0x00}})},
140 {RecepieType({{std::make_pair(0x00, 7), std::make_pair(0XFF, 8)}}), ResultType({{0XFE, 0X1, 0x00, 0x00}})},
141 {RecepieType({{std::make_pair(0x00, 8), std::make_pair(0XFF, 8)}}), ResultType({{0XFF, 0x00, 0x00, 0x00}})},
142 {RecepieType({{std::make_pair(0x00, 9), std::make_pair(0XFF, 8)}}), ResultType({{0X7F, 0x00, 0x00, 0X80}})},
143 {RecepieType({{std::make_pair(0x00, 10), std::make_pair(0XFF, 8)}}), ResultType({{0X3F, 0x00, 0x00, 0XC0}})},
144 {RecepieType({{std::make_pair(0x00, 11), std::make_pair(0XFF, 8)}}), ResultType({{0X1F, 0x00, 0x00, 0XE0}})},
145 {RecepieType({{std::make_pair(0x00, 12), std::make_pair(0XFF, 8)}}), ResultType({{0XF, 0x00, 0x00, 0XF0}})},
146 {RecepieType({{std::make_pair(0x00, 13), std::make_pair(0XFF, 8)}}), ResultType({{0X7, 0x00, 0x00, 0XF8}})},
147 {RecepieType({{std::make_pair(0x00, 14), std::make_pair(0XFF, 8)}}), ResultType({{0X3, 0x00, 0x00, 0XFC}})},
148 {RecepieType({{std::make_pair(0x00, 15), std::make_pair(0XFF, 8)}}), ResultType({{0X1, 0x00, 0x00, 0XFE}})},
149 {RecepieType({{std::make_pair(0x00, 16), std::make_pair(0XFF, 8)}}), ResultType({{0x00, 0x00, 0x00, 0XFF}})},
150 {RecepieType({{std::make_pair(0x00, 17), std::make_pair(0XFF, 8)}}), ResultType({{0x00, 0x00, 0X80, 0X7F}})},
151 {RecepieType({{std::make_pair(0x00, 18), std::make_pair(0XFF, 8)}}), ResultType({{0x00, 0x00, 0XC0, 0X3F}})},
152 {RecepieType({{std::make_pair(0x00, 19), std::make_pair(0XFF, 8)}}), ResultType({{0x00, 0x00, 0XE0, 0X1F}})},
153 {RecepieType({{std::make_pair(0x00, 20), std::make_pair(0XFF, 8)}}), ResultType({{0x00, 0x00, 0XF0, 0XF}})},
154 {RecepieType({{std::make_pair(0x00, 21), std::make_pair(0XFF, 8)}}), ResultType({{0x00, 0x00, 0XF8, 0X7}})},
155 {RecepieType({{std::make_pair(0x00, 22), std::make_pair(0XFF, 8)}}), ResultType({{0x00, 0x00, 0XFC, 0X3}})},
156 {RecepieType({{std::make_pair(0x00, 23), std::make_pair(0XFF, 8)}}), ResultType({{0x00, 0x00, 0XFE, 0X1}})},
157 {RecepieType({{std::make_pair(0x00, 24), std::make_pair(0XFF, 8)}}), ResultType({{0x00, 0x00, 0XFF, 0x00}})},
158 {RecepieType({{std::make_pair(0x00, 25), std::make_pair(0XFF, 8)}}), ResultType({{0x00, 0x00, 0X7F, 0x00, 0x00, 0X80, 0x00, 0x00}})},
159 {RecepieType({{std::make_pair(0x00, 26), std::make_pair(0XFF, 8)}}), ResultType({{0x00, 0x00, 0X3F, 0x00, 0x00, 0XC0, 0x00, 0x00}})},
160 {RecepieType({{std::make_pair(0x00, 27), std::make_pair(0XFF, 8)}}), ResultType({{0x00, 0x00, 0X1F, 0x00, 0x00, 0XE0, 0x00, 0x00}})},
161 {RecepieType({{std::make_pair(0x00, 28), std::make_pair(0XFF, 8)}}), ResultType({{0x00, 0x00, 0XF, 0x00, 0x00, 0XF0, 0x00, 0x00}})},
162 {RecepieType({{std::make_pair(0x00, 29), std::make_pair(0XFF, 8)}}), ResultType({{0x00, 0x00, 0X7, 0x00, 0x00, 0XF8, 0x00, 0x00}})},
163 {RecepieType({{std::make_pair(0x00, 30), std::make_pair(0XFF, 8)}}), ResultType({{0x00, 0x00, 0X3, 0x00, 0x00, 0XFC, 0x00, 0x00}})},
164 {RecepieType({{std::make_pair(0x00, 31), std::make_pair(0XFF, 8)}}), ResultType({{0x00, 0x00, 0X1, 0x00, 0x00, 0XFE, 0x00, 0x00}})},
165 {RecepieType({{std::make_pair(0x00, 32), std::make_pair(0XFF, 8)}}), ResultType({{0x00, 0x00, 0x00, 0x00, 0x00, 0XFF, 0x00, 0x00}})},
166 // clang-format on
167}};
168
169INSTANTIATE_TEST_SUITE_P(Patterns, BitVacuumerMSB16Test,
170 ::testing::ValuesIn(values));
171
172ResultType synthesizeBitstream(const RecepieType& recepie) {
173 ResultType bitstream;
174
175 {
176 auto bsInserter = PartitioningOutputIterator(std::back_inserter(bitstream));
177 using BitVacuumer = BitVacuumerMSB16<decltype(bsInserter)>;
178 auto bv = BitVacuumer(bsInserter);
179
180 for (const auto& e : recepie)
181 bv.put(e.first, e.second);
182 }
183
184 return bitstream;
185}
186
187TEST_P(BitVacuumerMSB16Test, Synthesis) {
188 const ResultType bitstream = synthesizeBitstream(recepie);
189 ASSERT_THAT(bitstream, testing::ContainerEq(expectedOutput));
190}
191
192TEST_P(BitVacuumerMSB16Test, Dissolution) {
193 if (expectedOutput.empty())
194 return;
195
196 auto bs = BitStreamerMSB16(Array1DRef(
197 expectedOutput.data(), implicit_cast<int>(expectedOutput.size())));
198 for (int i = 0; i != implicit_cast<int>(recepie.size()); ++i) {
199 const auto [expectedVal, len] = recepie[i];
200 bs.fill(32);
201 const auto actualVal = len != 0 ? bs.getBitsNoFill(len) : 0;
202 ASSERT_THAT(actualVal, expectedVal);
203 }
204}
205
206TEST(BitVacuumerMSB16Test, LoadPos) {
207 std::vector<uint8_t> bitstream;
208
209 constexpr int numByteElts = 64;
210
211 {
212 auto bsInserter = PartitioningOutputIterator(std::back_inserter(bitstream));
213 using BitVacuumer = BitVacuumerMSB16<decltype(bsInserter)>;
214 auto bv = BitVacuumer(bsInserter);
215
216 for (int e = 0; e != numByteElts; ++e)
217 bv.put(e, 8);
218 }
219
220 auto fullInput =
221 Array1DRef(bitstream.data(), implicit_cast<int>(bitstream.size()));
222
223 using BitStreamer = BitStreamerMSB16;
224 using BitStreamerTraits = BitStreamer::Traits;
225 using BitStreamTraits = BitStreamer::StreamTraits;
226
227 for (int fillLevel : {8, 32}) {
228 for (int baseLoadPosStep = 1;
229 baseLoadPosStep <= 2 * BitStreamTraits::MinLoadStepByteMultiple;
230 ++baseLoadPosStep) {
231 for (int baseLoadPos = 0;
232 baseLoadPos <= numByteElts - BitStreamerTraits::MaxProcessBytes;
233 baseLoadPos += baseLoadPosStep) {
234 auto input =
235 fullInput.getCrop(baseLoadPos, fullInput.size() - baseLoadPos)
236 .getAsArray1DRef();
237 auto bs = BitStreamer(input);
238 for (int i = 0; i != input.size(); ++i) {
239 const auto expectedVal = baseLoadPos + i;
240 bs.fill(fillLevel);
241 const auto actualVal = bs.getBitsNoFill(8);
242 if (baseLoadPosStep % BitStreamTraits::MinLoadStepByteMultiple == 0 ||
243 baseLoadPos % BitStreamTraits::MinLoadStepByteMultiple == 0) {
244 ASSERT_THAT(actualVal, expectedVal);
245 } else {
246 ASSERT_NE(actualVal, expectedVal);
247 }
248 }
249 }
250 }
251 }
252}
253
254TEST(BitVacuumerMSB16Test, DependencyBreaking) {
255 std::vector<uint8_t> bitstream;
256
257 using BitStreamer = BitStreamerMSB16;
258 using BitStreamerTraits = BitStreamer::Traits;
259
260 constexpr int numByteElts = 256;
261
262 {
263 auto bsInserter = PartitioningOutputIterator(std::back_inserter(bitstream));
264 using BitVacuumer = BitVacuumerMSB16<decltype(bsInserter)>;
265 auto bv = BitVacuumer(bsInserter);
266
267 for (int e = 0; e != numByteElts + BitStreamerTraits::MaxProcessBytes; ++e)
268 bv.put(e, 8);
269 }
270 constexpr int numBitsTotal = CHAR_BIT * numByteElts;
271
272 auto fullInput =
273 Array1DRef(bitstream.data(), implicit_cast<int>(bitstream.size()));
274
275 for (int numBitsToSkip = 0; numBitsToSkip <= numBitsTotal; ++numBitsToSkip) {
276 auto bsRef = BitStreamer(fullInput);
277 bsRef.fill();
278
279 for (int i = 0; i != numBitsToSkip / 8; ++i) {
280 const auto expectedVal = i;
281 ASSERT_THAT(bsRef.getBits(8), expectedVal);
282 }
283 if ((numBitsToSkip % 8) != 0) {
284 const auto expectedVal = extractHighBits<unsigned>(
285 numBitsToSkip / CHAR_BIT, numBitsToSkip % 8, CHAR_BIT);
286 ASSERT_THAT(bsRef.getBits(numBitsToSkip % 8), expectedVal);
287 }
288
289 const int numBitsRemaining = numBitsTotal - numBitsToSkip;
290
291 BitStreamPosition<BitStreamerTraits::Tag> state;
292 state.pos = bsRef.getInputPosition();
293 state.fillLevel = bsRef.getFillLevel();
294 const auto bsPos = getAsByteStreamPosition(state);
295
296 auto rebasedInput =
297 fullInput.getCrop(bsPos.bytePos, fullInput.size() - bsPos.bytePos)
298 .getAsArray1DRef();
299 auto bsRebased = BitStreamer(rebasedInput);
300 if (bsPos.numBitsToSkip != 0)
301 bsRebased.skipBits(bsPos.numBitsToSkip);
302
303 int numSubByteBitsRemaining = numBitsRemaining % CHAR_BIT;
304 int numBytesRemaining = numBitsRemaining / CHAR_BIT;
305 if (numSubByteBitsRemaining != 0) {
306 const auto expectedVal = extractLowBits<unsigned>(
307 numBitsToSkip / CHAR_BIT, numSubByteBitsRemaining);
308 ASSERT_THAT(bsRef.getBits(numSubByteBitsRemaining), expectedVal);
309 ASSERT_THAT(bsRebased.getBits(numSubByteBitsRemaining), expectedVal);
310 }
311
312 for (int i = 0; i != numBytesRemaining; ++i) {
313 const auto expectedVal = roundUpDivision(numBitsToSkip, CHAR_BIT) + i;
314 ASSERT_THAT(bsRef.getBits(8), expectedVal);
315 ASSERT_THAT(bsRebased.getBits(8), expectedVal);
316 }
317 }
318}
319
320TEST(BitVacuumerMSB16Test, ReloadCache) {
321 std::vector<uint8_t> bitstream;
322
323 using BitStreamer = BitStreamerMSB16;
324 using BitStreamerTraits = BitStreamer::Traits;
325
326 constexpr int numByteElts = 256;
327
328 {
329 auto bsInserter = PartitioningOutputIterator(std::back_inserter(bitstream));
330 using BitVacuumer = BitVacuumerMSB16<decltype(bsInserter)>;
331 auto bv = BitVacuumer(bsInserter);
332
333 for (int e = 0; e != numByteElts + BitStreamerTraits::MaxProcessBytes; ++e)
334 bv.put(e, 8);
335 }
336 constexpr int numBitsTotal = CHAR_BIT * numByteElts;
337
338 auto fullInput =
339 Array1DRef(bitstream.data(), implicit_cast<int>(bitstream.size()));
340
341 for (int numBitsToSkip = 0; numBitsToSkip <= numBitsTotal; ++numBitsToSkip) {
342 auto bsRef = BitStreamer(fullInput);
343 bsRef.fill();
344
345 for (int i = 0; i != numBitsToSkip / 8; ++i) {
346 const auto expectedVal = i;
347 ASSERT_THAT(bsRef.getBits(8), expectedVal);
348 }
349 if ((numBitsToSkip % 8) != 0) {
350 const auto expectedVal = extractHighBits<unsigned>(
351 numBitsToSkip / CHAR_BIT, numBitsToSkip % 8, CHAR_BIT);
352 ASSERT_THAT(bsRef.getBits(numBitsToSkip % 8), expectedVal);
353 }
354
355 bsRef.reload();
356
357 const int numBitsRemaining = numBitsTotal - numBitsToSkip;
358
359 int numSubByteBitsRemaining = numBitsRemaining % CHAR_BIT;
360 int numBytesRemaining = numBitsRemaining / CHAR_BIT;
361 if (numSubByteBitsRemaining != 0) {
362 const auto expectedVal = extractLowBits<unsigned>(
363 numBitsToSkip / CHAR_BIT, numSubByteBitsRemaining);
364 ASSERT_THAT(bsRef.getBits(numSubByteBitsRemaining), expectedVal);
365 }
366
367 for (int i = 0; i != numBytesRemaining; ++i) {
368 const auto expectedVal = roundUpDivision(numBitsToSkip, CHAR_BIT) + i;
369 ASSERT_THAT(bsRef.getBits(8), expectedVal);
370 }
371 }
372}
373
374} // namespace
375
376} // namespace rawspeed
377
378// NOTE: no `#pragma GCC diagnostic pop` wanted!
INSTANTIATE_TEST_SUITE_P
INSTANTIATE_TEST_SUITE_P(MD5Test, MD5Test, ::testing::ValuesIn(testCases))
TEST_P
TEST_P(MD5Test, CheckTestCaseSet)
Definition MD5Test.cpp:388
rawspeed::BitStreamer::Traits
BitStreamerTraits< Derived > Traits
Definition BitStreamer.h:141
rawspeed::BitStreamer::StreamTraits
BitStreamTraits< Traits::Tag > StreamTraits
Definition BitStreamer.h:142
rawspeed::BitVacuumer::put
void put(uint32_t bits, int count)
Definition BitVacuumer.h:121
rawspeed::anonymous_namespace{BitVacuumerMSB16Test.cpp}::BitVacuumerMSB16Test
Definition BitVacuumerMSB16Test.cpp:53
rawspeed::anonymous_namespace{BitVacuumerMSB16Test.cpp}::BitVacuumerMSB16Test::recepie
RecepieType recepie
Definition BitVacuumerMSB16Test.cpp:61
rawspeed::anonymous_namespace{BitVacuumerMSB16Test.cpp}::BitVacuumerMSB16Test::SetUp
virtual void SetUp()
Definition BitVacuumerMSB16Test.cpp:56
rawspeed::anonymous_namespace{BitVacuumerMSB16Test.cpp}::BitVacuumerMSB16Test::BitVacuumerMSB16Test
BitVacuumerMSB16Test()=default
rawspeed::anonymous_namespace{BitVacuumerMSB16Test.cpp}::BitVacuumerMSB16Test::expectedOutput
ResultType expectedOutput
Definition BitVacuumerMSB16Test.cpp:62
rawspeed::anonymous_namespace{BitVacuumerMSB16Test.cpp}::values
const std::vector< valueType > values
Definition BitVacuumerMSB16Test.cpp:64
rawspeed::anonymous_namespace{BitVacuumerMSB16Test.cpp}::TEST
TEST(BitVacuumerMSB16Test, LoadPos)
Definition BitVacuumerMSB16Test.cpp:206
rawspeed::anonymous_namespace{BitVacuumerMSB16Test.cpp}::RecepieEntryType
std::pair< uint32_t, uint8_t > RecepieEntryType
Definition BitVacuumerMSB16Test.cpp:48
rawspeed::anonymous_namespace{BitVacuumerMSB16Test.cpp}::RecepieType
std::vector< RecepieEntryType > RecepieType
Definition BitVacuumerMSB16Test.cpp:49
rawspeed::anonymous_namespace{BitVacuumerMSB16Test.cpp}::valueType
std::pair< RecepieType, ResultType > valueType
Definition BitVacuumerMSB16Test.cpp:52
rawspeed::anonymous_namespace{BitVacuumerMSB16Test.cpp}::ResultType
std::vector< uint8_t > ResultType
Definition BitVacuumerMSB16Test.cpp:50
rawspeed::anonymous_namespace{BitVacuumerMSB16Test.cpp}::synthesizeBitstream
ResultType synthesizeBitstream(const RecepieType &recepie)
Definition BitVacuumerMSB16Test.cpp:172
rawspeed::implicit_cast
constexpr RAWSPEED_READNONE Ttgt implicit_cast(Tsrc value)
Definition Casts.h:32
rawspeed::roundUpDivision
constexpr uint64_t RAWSPEED_READNONE roundUpDivision(uint64_t value, uint64_t div)
Definition Common.h:139
rawspeed::getAsByteStreamPosition
ByteStreamPosition< bo > getAsByteStreamPosition(BitStreamPosition< bo > state)
Definition BitStreamPosition.h:45
rawspeed::Array1DRef
Array1DRef(T *data_, int numElts_) -> Array1DRef< T >
rawspeed::PartitioningOutputIterator
PartitioningOutputIterator(T) -> PartitioningOutputIterator< T >
rawspeed::extractHighBits
constexpr RAWSPEED_READNONE T extractHighBits(T value, unsigned nBits, unsigned effectiveBitwidth=bitwidth< T >())
Definition Bit.h:120
rawspeed::extractLowBits
constexpr RAWSPEED_READNONE T extractLowBits(T value, unsigned nBits)
Definition Bit.h:96