Qt
Internal/Contributor docs for the Qt SDK. Note: These are NOT official API docs; those are found at https://doc.qt.io/
Loading...
Searching...
No Matches
progressive_decoder_unittest.cpp
Go to the documentation of this file.
1// Copyright 2019 The PDFium Authors
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "core/fxcodec/progressive_decoder.h"
6
7#include <stddef.h>
8#include <stdint.h>
9
10#include <array>
11#include <numeric>
12#include <tuple>
13#include <utility>
14
15#include "core/fxcodec/fx_codec.h"
16#include "core/fxcodec/fx_codec_def.h"
17#include "core/fxcodec/jpeg/jpeg_progressive_decoder.h"
18#include "core/fxcrt/cfx_read_only_span_stream.h"
19#include "core/fxcrt/cfx_read_only_vector_stream.h"
20#include "core/fxcrt/data_vector.h"
21#include "core/fxcrt/retain_ptr.h"
22#include "core/fxge/dib/cfx_dibitmap.h"
23#include "core/fxge/dib/fx_dib.h"
24#include "testing/gmock/include/gmock/gmock.h"
25#include "testing/gtest/include/gtest/gtest.h"
26#include "third_party/base/containers/span.h"
27
28#ifdef PDF_ENABLE_XFA_BMP
29#include "core/fxcodec/bmp/bmp_decoder.h"
30#include "core/fxcodec/bmp/bmp_progressive_decoder.h"
31#endif // PDF_ENABLE_XFA_BMP
32
33#ifdef PDF_ENABLE_XFA_GIF
34#include "core/fxcodec/gif/gif_decoder.h"
35#include "core/fxcodec/gif/gif_progressive_decoder.h"
36#endif // PDF_ENABLE_XFA_GIF
37
38namespace fxcodec {
39
40namespace {
41
42using ::testing::ElementsAre;
43using ::testing::ElementsAreArray;
44
45template <size_t Size>
46constexpr std::array<uint8_t, Size> IotaArray(uint8_t start) {
47 std::array<uint8_t, Size> result;
48 std::iota(result.begin(), result.end(), start);
49 return result;
50}
51
52FXCODEC_STATUS DecodeToBitmap(ProgressiveDecoder& decoder,
53 const fxcrt::RetainPtr<CFX_DIBitmap>& bitmap) {
54 FXCODEC_STATUS status = decoder.StartDecode(bitmap, 0, 0, bitmap->GetWidth(),
55 bitmap->GetHeight());
56 while (status == FXCODEC_STATUS::kDecodeToBeContinued)
57 status = decoder.ContinueDecode();
58 return status;
59}
60
61class ProgressiveDecoderTest : public testing::Test {
62 void SetUp() override {
63#ifdef PDF_ENABLE_XFA_BMP
64 BmpProgressiveDecoder::InitializeGlobals();
65#endif
66#ifdef PDF_ENABLE_XFA_GIF
67 GifProgressiveDecoder::InitializeGlobals();
68#endif
69 JpegProgressiveDecoder::InitializeGlobals();
70 }
71 void TearDown() override {
72 JpegProgressiveDecoder::DestroyGlobals();
73#ifdef PDF_ENABLE_XFA_GIF
74 GifProgressiveDecoder::DestroyGlobals();
75#endif
76#ifdef PDF_ENABLE_XFA_BMP
77 BmpProgressiveDecoder::DestroyGlobals();
78#endif
79 }
80};
81
82} // namespace
83
84#ifdef PDF_ENABLE_XFA_BMP
85TEST_F(ProgressiveDecoderTest, Indexed8Bmp) {
86 static constexpr uint8_t kInput[] = {
87 0x42, 0x4d, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a,
88 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
89 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
90 0x00, 0x04, 0x00, 0x00, 0x00, 0x13, 0x0b, 0x00, 0x00, 0x13, 0x0b,
91 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xc0,
92 0x80, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00};
93
94 ProgressiveDecoder decoder;
95
96 auto source = pdfium::MakeRetain<CFX_ReadOnlySpanStream>(kInput);
97 CFX_DIBAttribute attr;
98 FXCODEC_STATUS status =
99 decoder.LoadImageInfo(std::move(source), FXCODEC_IMAGE_BMP, &attr, true);
100 ASSERT_EQ(FXCODEC_STATUS::kFrameReady, status);
101
102 ASSERT_EQ(1, decoder.GetWidth());
103 ASSERT_EQ(1, decoder.GetHeight());
104
105 auto bitmap = pdfium::MakeRetain<CFX_DIBitmap>();
106 bitmap->Create(decoder.GetWidth(), decoder.GetHeight(), FXDIB_Format::kRgb);
107
108 size_t frames;
109 std::tie(status, frames) = decoder.GetFrames();
110 ASSERT_EQ(FXCODEC_STATUS::kDecodeReady, status);
111 ASSERT_EQ(1u, frames);
112
113 status = DecodeToBitmap(decoder, bitmap);
114 EXPECT_EQ(FXCODEC_STATUS::kDecodeFinished, status);
115 EXPECT_THAT(bitmap->GetScanline(0), ElementsAre(0xc0, 0x80, 0x40, 0x00));
116}
117
118TEST_F(ProgressiveDecoderTest, Indexed8BmpWithInvalidIndex) {
119 static constexpr uint8_t kInput[] = {
120 0x42, 0x4d, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3a,
121 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
122 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
123 0x00, 0x04, 0x00, 0x00, 0x00, 0x13, 0x0b, 0x00, 0x00, 0x13, 0x0b,
124 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0xc0,
125 0x80, 0x40, 0x00, 0x01, 0x00, 0x00, 0x00};
126
127 ProgressiveDecoder decoder;
128
129 auto source = pdfium::MakeRetain<CFX_ReadOnlySpanStream>(kInput);
130 CFX_DIBAttribute attr;
131 FXCODEC_STATUS status =
132 decoder.LoadImageInfo(std::move(source), FXCODEC_IMAGE_BMP, &attr, true);
133 ASSERT_EQ(FXCODEC_STATUS::kFrameReady, status);
134
135 ASSERT_EQ(1, decoder.GetWidth());
136 ASSERT_EQ(1, decoder.GetHeight());
137
138 auto bitmap = pdfium::MakeRetain<CFX_DIBitmap>();
139 bitmap->Create(decoder.GetWidth(), decoder.GetHeight(), FXDIB_Format::kRgb);
140
141 size_t frames;
142 std::tie(status, frames) = decoder.GetFrames();
143 ASSERT_EQ(FXCODEC_STATUS::kDecodeReady, status);
144 ASSERT_EQ(1u, frames);
145
146 status = DecodeToBitmap(decoder, bitmap);
147 EXPECT_EQ(FXCODEC_STATUS::kError, status);
148}
149
150TEST_F(ProgressiveDecoderTest, Direct24Bmp) {
151 static constexpr uint8_t kInput[] = {
152 0x42, 0x4d, 0x3a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00,
153 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
154 0x00, 0x00, 0x01, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
155 0x00, 0x00, 0x13, 0x0b, 0x00, 0x00, 0x13, 0x0b, 0x00, 0x00, 0x00, 0x00,
156 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x80, 0x40, 0x00};
157
158 ProgressiveDecoder decoder;
159
160 auto source = pdfium::MakeRetain<CFX_ReadOnlySpanStream>(kInput);
161 CFX_DIBAttribute attr;
162 FXCODEC_STATUS status =
163 decoder.LoadImageInfo(std::move(source), FXCODEC_IMAGE_BMP, &attr, true);
164 ASSERT_EQ(FXCODEC_STATUS::kFrameReady, status);
165
166 ASSERT_EQ(1, decoder.GetWidth());
167 ASSERT_EQ(1, decoder.GetHeight());
168
169 auto bitmap = pdfium::MakeRetain<CFX_DIBitmap>();
170 bitmap->Create(decoder.GetWidth(), decoder.GetHeight(), FXDIB_Format::kRgb);
171
172 size_t frames;
173 std::tie(status, frames) = decoder.GetFrames();
174 ASSERT_EQ(FXCODEC_STATUS::kDecodeReady, status);
175 ASSERT_EQ(1u, frames);
176
177 status = DecodeToBitmap(decoder, bitmap);
178 EXPECT_EQ(FXCODEC_STATUS::kDecodeFinished, status);
179 EXPECT_THAT(bitmap->GetScanline(0), ElementsAre(0xc0, 0x80, 0x40, 0x00));
180}
181
182TEST_F(ProgressiveDecoderTest, Direct32Bmp) {
183 static constexpr uint8_t kInput[] = {
184 0x42, 0x4d, 0x3a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00,
185 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
186 0x00, 0x00, 0x01, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
187 0x00, 0x00, 0x13, 0x0b, 0x00, 0x00, 0x13, 0x0b, 0x00, 0x00, 0x00, 0x00,
188 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x80, 0x40, 0xff};
189
190 ProgressiveDecoder decoder;
191
192 auto source = pdfium::MakeRetain<CFX_ReadOnlySpanStream>(kInput);
193 CFX_DIBAttribute attr;
194 FXCODEC_STATUS status =
195 decoder.LoadImageInfo(std::move(source), FXCODEC_IMAGE_BMP, &attr, true);
196 ASSERT_EQ(FXCODEC_STATUS::kFrameReady, status);
197
198 ASSERT_EQ(1, decoder.GetWidth());
199 ASSERT_EQ(1, decoder.GetHeight());
200
201 auto bitmap = pdfium::MakeRetain<CFX_DIBitmap>();
202 bitmap->Create(decoder.GetWidth(), decoder.GetHeight(), FXDIB_Format::kRgb);
203
204 size_t frames;
205 std::tie(status, frames) = decoder.GetFrames();
206 ASSERT_EQ(FXCODEC_STATUS::kDecodeReady, status);
207 ASSERT_EQ(1u, frames);
208
209 status = DecodeToBitmap(decoder, bitmap);
210 EXPECT_EQ(FXCODEC_STATUS::kDecodeFinished, status);
211 EXPECT_THAT(bitmap->GetScanline(0), ElementsAre(0xc0, 0x80, 0x40, 0x00));
212}
213
214TEST_F(ProgressiveDecoderTest, BmpWithDataOffsetBeforeEndOfHeader) {
215 static constexpr uint8_t kInput[] = {
216 0x42, 0x4d, 0x3a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x35, 0x00,
217 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
218 0x00, 0x00, 0x01, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
219 0x00, 0x00, 0x13, 0x0b, 0x00, 0x00, 0x13, 0x0b, 0x00, 0x00, 0x00, 0x00,
220 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x80, 0x40, 0x00};
221
222 ProgressiveDecoder decoder;
223
224 auto source = pdfium::MakeRetain<CFX_ReadOnlySpanStream>(kInput);
225 CFX_DIBAttribute attr;
226 FXCODEC_STATUS status =
227 decoder.LoadImageInfo(std::move(source), FXCODEC_IMAGE_BMP, &attr, true);
228 ASSERT_EQ(FXCODEC_STATUS::kFrameReady, status);
229
230 ASSERT_EQ(1, decoder.GetWidth());
231 ASSERT_EQ(1, decoder.GetHeight());
232
233 auto bitmap = pdfium::MakeRetain<CFX_DIBitmap>();
234 bitmap->Create(decoder.GetWidth(), decoder.GetHeight(), FXDIB_Format::kRgb);
235
236 size_t frames;
237 std::tie(status, frames) = decoder.GetFrames();
238 ASSERT_EQ(FXCODEC_STATUS::kDecodeReady, status);
239 ASSERT_EQ(1u, frames);
240
241 status = DecodeToBitmap(decoder, bitmap);
242 EXPECT_EQ(FXCODEC_STATUS::kDecodeFinished, status);
243 EXPECT_THAT(bitmap->GetScanline(0), ElementsAre(0xc0, 0x80, 0x40, 0x00));
244}
245
246TEST_F(ProgressiveDecoderTest, BmpWithDataOffsetAfterEndOfHeader) {
247 static constexpr uint8_t kInput[] = {
248 0x42, 0x4d, 0x3b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x37, 0x00,
249 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00,
250 0x00, 0x00, 0x01, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
251 0x00, 0x00, 0x13, 0x0b, 0x00, 0x00, 0x13, 0x0b, 0x00, 0x00, 0x00, 0x00,
252 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x80, 0x40, 0x00};
253
254 ProgressiveDecoder decoder;
255
256 auto source = pdfium::MakeRetain<CFX_ReadOnlySpanStream>(kInput);
257 CFX_DIBAttribute attr;
258 FXCODEC_STATUS status =
259 decoder.LoadImageInfo(std::move(source), FXCODEC_IMAGE_BMP, &attr, true);
260 ASSERT_EQ(FXCODEC_STATUS::kFrameReady, status);
261
262 ASSERT_EQ(1, decoder.GetWidth());
263 ASSERT_EQ(1, decoder.GetHeight());
264
265 auto bitmap = pdfium::MakeRetain<CFX_DIBitmap>();
266 bitmap->Create(decoder.GetWidth(), decoder.GetHeight(), FXDIB_Format::kRgb);
267
268 size_t frames;
269 std::tie(status, frames) = decoder.GetFrames();
270 ASSERT_EQ(FXCODEC_STATUS::kDecodeReady, status);
271 ASSERT_EQ(1u, frames);
272
273 status = DecodeToBitmap(decoder, bitmap);
274 EXPECT_EQ(FXCODEC_STATUS::kDecodeFinished, status);
275 EXPECT_THAT(bitmap->GetScanline(0), ElementsAre(0xc0, 0x80, 0x40, 0x00));
276}
277
278TEST_F(ProgressiveDecoderTest, LargeBmp) {
279 // Construct a 24-bit BMP larger than `kBlockSize` (4096 bytes).
280 static constexpr uint8_t kWidth = 37;
281 static constexpr uint8_t kHeight = 38;
282 static constexpr size_t kScanlineSize = kWidth * 3 + 1;
283 DataVector<uint8_t> input = {
284 0x42, 0x4d, 0xd6, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36,
285 0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, kWidth, 0x00, 0x00, 0x00,
286 kHeight, 0x00, 0x00, 0x00, 0x01, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00,
287 0x00, 0xa0, 0x10, 0x00, 0x00, 0x13, 0x0b, 0x00, 0x00, 0x13, 0x0b,
288 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
289 input.resize(54 + kScanlineSize * kHeight);
290 std::iota(input.begin() + 54, input.end(), 0);
291 ASSERT_EQ(4310u, input.size());
292
293 ProgressiveDecoder decoder;
294
295 auto source = pdfium::MakeRetain<CFX_ReadOnlyVectorStream>(std::move(input));
296 CFX_DIBAttribute attr;
297 FXCODEC_STATUS status =
298 decoder.LoadImageInfo(std::move(source), FXCODEC_IMAGE_BMP, &attr, true);
299 ASSERT_EQ(FXCODEC_STATUS::kFrameReady, status);
300
301 ASSERT_EQ(kWidth, decoder.GetWidth());
302 ASSERT_EQ(kHeight, decoder.GetHeight());
303
304 auto bitmap = pdfium::MakeRetain<CFX_DIBitmap>();
305 bitmap->Create(decoder.GetWidth(), decoder.GetHeight(), FXDIB_Format::kRgb);
306
307 size_t frames;
308 std::tie(status, frames) = decoder.GetFrames();
309 ASSERT_EQ(FXCODEC_STATUS::kDecodeReady, status);
310 ASSERT_EQ(1u, frames);
311
312 status = DecodeToBitmap(decoder, bitmap);
313 EXPECT_EQ(FXCODEC_STATUS::kDecodeFinished, status);
314
315 for (size_t row = 0; row < kHeight; ++row) {
316 // BMP encodes rows from bottom to top by default.
317 pdfium::span<const uint8_t> scanline =
318 bitmap->GetScanline(kHeight - row - 1);
319
320 EXPECT_THAT(
321 scanline.subspan(0, kScanlineSize - 1),
322 ElementsAreArray(IotaArray<kScanlineSize - 1>(row * kScanlineSize)));
323
324 // Last byte is padding to a 32-bit boundary.
325 EXPECT_EQ(0, scanline[kScanlineSize - 1]);
326 }
327}
328#endif // PDF_ENABLE_XFA_BMP
329
330#ifdef PDF_ENABLE_XFA_GIF
331TEST_F(ProgressiveDecoderTest, Gif87a) {
332 static constexpr uint8_t kInput[] = {
333 0x47, 0x49, 0x46, 0x38, 0x37, 0x61, 0x01, 0x00, 0x01, 0x00, 0x80, 0x01,
334 0x00, 0x40, 0x80, 0xc0, 0x80, 0x80, 0x80, 0x2c, 0x00, 0x00, 0x00, 0x00,
335 0x01, 0x00, 0x01, 0x00, 0x00, 0x02, 0x02, 0x44, 0x01, 0x00, 0x3b};
336
337 ProgressiveDecoder decoder;
338
339 auto source = pdfium::MakeRetain<CFX_ReadOnlySpanStream>(kInput);
340 CFX_DIBAttribute attr;
341 FXCODEC_STATUS status =
342 decoder.LoadImageInfo(std::move(source), FXCODEC_IMAGE_GIF, &attr, true);
343 ASSERT_EQ(FXCODEC_STATUS::kFrameReady, status);
344
345 ASSERT_EQ(1, decoder.GetWidth());
346 ASSERT_EQ(1, decoder.GetHeight());
347
348 auto bitmap = pdfium::MakeRetain<CFX_DIBitmap>();
349 bitmap->Create(decoder.GetWidth(), decoder.GetHeight(), FXDIB_Format::kArgb);
350
351 size_t frames;
352 std::tie(status, frames) = decoder.GetFrames();
353 ASSERT_EQ(FXCODEC_STATUS::kDecodeReady, status);
354 ASSERT_EQ(1u, frames);
355
356 status = DecodeToBitmap(decoder, bitmap);
357 EXPECT_EQ(FXCODEC_STATUS::kDecodeFinished, status);
358 EXPECT_THAT(bitmap->GetScanline(0), ElementsAre(0xc0, 0x80, 0x40, 0xff));
359}
360
361TEST_F(ProgressiveDecoderTest, Gif89a) {
362 static constexpr uint8_t kInput[] = {
363 0x47, 0x49, 0x46, 0x38, 0x39, 0x61, 0x01, 0x00, 0x01, 0x00, 0x80,
364 0x01, 0x00, 0x40, 0x80, 0xc0, 0x80, 0x80, 0x80, 0x21, 0xf9, 0x04,
365 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x01,
366 0x00, 0x01, 0x00, 0x00, 0x02, 0x02, 0x44, 0x01, 0x00, 0x3b};
367
368 ProgressiveDecoder decoder;
369
370 auto source = pdfium::MakeRetain<CFX_ReadOnlySpanStream>(kInput);
371 CFX_DIBAttribute attr;
372 FXCODEC_STATUS status =
373 decoder.LoadImageInfo(std::move(source), FXCODEC_IMAGE_GIF, &attr, true);
374 ASSERT_EQ(FXCODEC_STATUS::kFrameReady, status);
375
376 ASSERT_EQ(1, decoder.GetWidth());
377 ASSERT_EQ(1, decoder.GetHeight());
378
379 auto bitmap = pdfium::MakeRetain<CFX_DIBitmap>();
380 bitmap->Create(decoder.GetWidth(), decoder.GetHeight(), FXDIB_Format::kArgb);
381
382 size_t frames;
383 std::tie(status, frames) = decoder.GetFrames();
384 ASSERT_EQ(FXCODEC_STATUS::kDecodeReady, status);
385 ASSERT_EQ(1u, frames);
386
387 status = DecodeToBitmap(decoder, bitmap);
388 EXPECT_EQ(FXCODEC_STATUS::kDecodeFinished, status);
389 EXPECT_THAT(bitmap->GetScanline(0), ElementsAre(0xc0, 0x80, 0x40, 0xff));
390}
391
392TEST_F(ProgressiveDecoderTest, GifInsufficientCodeSize) {
393 // This GIF causes `LZWDecompressor::Create()` to fail because the minimum
394 // code size is too small for the palette.
395 static constexpr uint8_t kInput[] = {
396 0x47, 0x49, 0x46, 0x38, 0x37, 0x61, 0x01, 0x00, 0x01, 0x00, 0x82,
397 0x01, 0x00, 0x40, 0x80, 0xc0, 0x80, 0x80, 0x80, 0x81, 0x81, 0x81,
398 0x82, 0x82, 0x82, 0x83, 0x83, 0x83, 0x84, 0x84, 0x84, 0x85, 0x85,
399 0x85, 0x86, 0x86, 0x86, 0x2c, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
400 0x01, 0x00, 0x00, 0x02, 0x2, 0x44, 0x01, 0x00, 0x3b};
401
402 ProgressiveDecoder decoder;
403
404 auto source = pdfium::MakeRetain<CFX_ReadOnlySpanStream>(kInput);
405 CFX_DIBAttribute attr;
406 FXCODEC_STATUS status =
407 decoder.LoadImageInfo(std::move(source), FXCODEC_IMAGE_GIF, &attr, true);
408 ASSERT_EQ(FXCODEC_STATUS::kFrameReady, status);
409
410 ASSERT_EQ(1, decoder.GetWidth());
411 ASSERT_EQ(1, decoder.GetHeight());
412
413 auto bitmap = pdfium::MakeRetain<CFX_DIBitmap>();
414 bitmap->Create(decoder.GetWidth(), decoder.GetHeight(), FXDIB_Format::kArgb);
415
416 size_t frames;
417 std::tie(status, frames) = decoder.GetFrames();
418 ASSERT_EQ(FXCODEC_STATUS::kDecodeReady, status);
419 ASSERT_EQ(1u, frames);
420
421 status = DecodeToBitmap(decoder, bitmap);
422 EXPECT_EQ(FXCODEC_STATUS::kError, status);
423}
424
425TEST_F(ProgressiveDecoderTest, GifDecodeAcrossScanlines) {
426 // This GIF contains an LZW code unit split across 2 scanlines. The decoder
427 // must continue decoding the second scanline using the residual data.
428 static constexpr uint8_t kInput[] = {
429 0x47, 0x49, 0x46, 0x38, 0x37, 0x61, 0x04, 0x00, 0x02, 0x00, 0x80, 0x01,
430 0x00, 0x40, 0x80, 0xc0, 0x80, 0x80, 0x80, 0x2c, 0x00, 0x00, 0x00, 0x00,
431 0x04, 0x00, 0x02, 0x00, 0x00, 0x02, 0x03, 0x84, 0x6f, 0x05, 0x00, 0x3b};
432
433 ProgressiveDecoder decoder;
434
435 auto source = pdfium::MakeRetain<CFX_ReadOnlySpanStream>(kInput);
436 CFX_DIBAttribute attr;
437 FXCODEC_STATUS status =
438 decoder.LoadImageInfo(std::move(source), FXCODEC_IMAGE_GIF, &attr, true);
439 ASSERT_EQ(FXCODEC_STATUS::kFrameReady, status);
440
441 ASSERT_EQ(4, decoder.GetWidth());
442 ASSERT_EQ(2, decoder.GetHeight());
443
444 auto bitmap = pdfium::MakeRetain<CFX_DIBitmap>();
445 bitmap->Create(decoder.GetWidth(), decoder.GetHeight(), FXDIB_Format::kArgb);
446
447 size_t frames;
448 std::tie(status, frames) = decoder.GetFrames();
449 ASSERT_EQ(FXCODEC_STATUS::kDecodeReady, status);
450 ASSERT_EQ(1u, frames);
451
452 status = DecodeToBitmap(decoder, bitmap);
453 EXPECT_EQ(FXCODEC_STATUS::kDecodeFinished, status);
454 EXPECT_THAT(bitmap->GetScanline(0),
455 ElementsAre(0xc0, 0x80, 0x40, 0xff, 0xc0, 0x80, 0x40, 0xff, 0xc0,
456 0x80, 0x40, 0xff, 0xc0, 0x80, 0x40, 0xff));
457 EXPECT_THAT(bitmap->GetScanline(1),
458 ElementsAre(0xc0, 0x80, 0x40, 0xff, 0xc0, 0x80, 0x40, 0xff, 0xc0,
459 0x80, 0x40, 0xff, 0xc0, 0x80, 0x40, 0xff));
460}
461
462TEST_F(ProgressiveDecoderTest, GifDecodeAcrossSubblocks) {
463 // This GIF contains a scanline split across 2 data sub-blocks. The decoder
464 // must continue decoding in the second sub-block.
465 static constexpr uint8_t kInput[] = {
466 0x47, 0x49, 0x46, 0x38, 0x37, 0x61, 0x04, 0x00, 0x02, 0x00,
467 0x80, 0x01, 0x00, 0x40, 0x80, 0xc0, 0x80, 0x80, 0x80, 0x2c,
468 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x02,
469 0x02, 0x84, 0x6f, 0x01, 0x05, 0x00, 0x3b};
470
471 ProgressiveDecoder decoder;
472
473 auto source = pdfium::MakeRetain<CFX_ReadOnlySpanStream>(kInput);
474 CFX_DIBAttribute attr;
475 FXCODEC_STATUS status =
476 decoder.LoadImageInfo(std::move(source), FXCODEC_IMAGE_GIF, &attr, true);
477 ASSERT_EQ(FXCODEC_STATUS::kFrameReady, status);
478
479 ASSERT_EQ(4, decoder.GetWidth());
480 ASSERT_EQ(2, decoder.GetHeight());
481
482 auto bitmap = pdfium::MakeRetain<CFX_DIBitmap>();
483 bitmap->Create(decoder.GetWidth(), decoder.GetHeight(), FXDIB_Format::kArgb);
484
485 size_t frames;
486 std::tie(status, frames) = decoder.GetFrames();
487 ASSERT_EQ(FXCODEC_STATUS::kDecodeReady, status);
488 ASSERT_EQ(1u, frames);
489
490 status = DecodeToBitmap(decoder, bitmap);
491 EXPECT_EQ(FXCODEC_STATUS::kDecodeFinished, status);
492 EXPECT_THAT(bitmap->GetScanline(0),
493 ElementsAre(0xc0, 0x80, 0x40, 0xff, 0xc0, 0x80, 0x40, 0xff, 0xc0,
494 0x80, 0x40, 0xff, 0xc0, 0x80, 0x40, 0xff));
495 EXPECT_THAT(bitmap->GetScanline(1),
496 ElementsAre(0xc0, 0x80, 0x40, 0xff, 0xc0, 0x80, 0x40, 0xff, 0xc0,
497 0x80, 0x40, 0xff, 0xc0, 0x80, 0x40, 0xff));
498}
499#endif // PDF_ENABLE_XFA_GIF
500
501} // namespace fxcodec
FXCODEC_STATUS
FXCODEC_STATUS
Definition fx_codec_def.h:10
FXCODEC_STATUS::kDecodeToBeContinued
@ kDecodeToBeContinued