OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "platform/image-decoders/ImageDecoderTestHelpers.h" | 5 #include "platform/image-decoders/ImageDecoderTestHelpers.h" |
6 | 6 |
7 #include "platform/SharedBuffer.h" | 7 #include "platform/SharedBuffer.h" |
8 #include "platform/image-decoders/ImageFrame.h" | 8 #include "platform/image-decoders/ImageFrame.h" |
9 #include "platform/testing/UnitTestHelpers.h" | 9 #include "platform/testing/UnitTestHelpers.h" |
10 #include "testing/gtest/include/gtest/gtest.h" | 10 #include "testing/gtest/include/gtest/gtest.h" |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
47 Vector<unsigned>* baselineHashes) { | 47 Vector<unsigned>* baselineHashes) { |
48 std::unique_ptr<ImageDecoder> decoder = createDecoder(); | 48 std::unique_ptr<ImageDecoder> decoder = createDecoder(); |
49 decoder->setData(data, true); | 49 decoder->setData(data, true); |
50 size_t frameCount = decoder->frameCount(); | 50 size_t frameCount = decoder->frameCount(); |
51 for (size_t i = 0; i < frameCount; ++i) { | 51 for (size_t i = 0; i < frameCount; ++i) { |
52 ImageFrame* frame = decoder->frameBufferAtIndex(i); | 52 ImageFrame* frame = decoder->frameBufferAtIndex(i); |
53 baselineHashes->push_back(hashBitmap(frame->bitmap())); | 53 baselineHashes->push_back(hashBitmap(frame->bitmap())); |
54 } | 54 } |
55 } | 55 } |
56 | 56 |
57 static void testByteByByteDecode(DecoderCreator createDecoder, | 57 void testByteByByteDecode(DecoderCreator createDecoder, |
58 SharedBuffer* data, | 58 SharedBuffer* data, |
59 size_t expectedFrameCount, | 59 size_t expectedFrameCount, |
60 int expectedRepetitionCount) { | 60 int expectedRepetitionCount) { |
61 ASSERT_TRUE(data->data()); | 61 ASSERT_TRUE(data->data()); |
62 | 62 |
63 Vector<unsigned> baselineHashes; | 63 Vector<unsigned> baselineHashes; |
64 createDecodingBaseline(createDecoder, data, &baselineHashes); | 64 createDecodingBaseline(createDecoder, data, &baselineHashes); |
65 | 65 |
66 std::unique_ptr<ImageDecoder> decoder = createDecoder(); | 66 std::unique_ptr<ImageDecoder> decoder = createDecoder(); |
67 | 67 |
68 size_t frameCount = 0; | 68 size_t frameCount = 0; |
69 size_t framesDecoded = 0; | 69 size_t framesDecoded = 0; |
70 | 70 |
(...skipping 146 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
217 SharedBuffer* data, | 217 SharedBuffer* data, |
218 size_t frameOffset, | 218 size_t frameOffset, |
219 bool hasColorSpace, | 219 bool hasColorSpace, |
220 int expectedRepetitionCount) { | 220 int expectedRepetitionCount) { |
221 std::unique_ptr<ImageDecoder> decoder = createDecoder(); | 221 std::unique_ptr<ImageDecoder> decoder = createDecoder(); |
222 EXPECT_LT(frameOffset, data->size()); | 222 EXPECT_LT(frameOffset, data->size()); |
223 | 223 |
224 // Send data to the decoder byte-by-byte and use the provided frame offset in | 224 // Send data to the decoder byte-by-byte and use the provided frame offset in |
225 // the data to check that isSizeAvailable() changes state only when that | 225 // the data to check that isSizeAvailable() changes state only when that |
226 // offset is reached. Also check other decoder state. | 226 // offset is reached. Also check other decoder state. |
| 227 RefPtr<SharedBuffer> tempData = SharedBuffer::create(); |
| 228 const char* source = data->data(); |
227 for (size_t length = 1; length <= frameOffset; ++length) { | 229 for (size_t length = 1; length <= frameOffset; ++length) { |
228 RefPtr<SharedBuffer> tempData = SharedBuffer::create(data->data(), length); | 230 tempData->append(source++, 1u); |
229 decoder->setData(tempData.get(), false); | 231 decoder->setData(tempData.get(), false); |
230 | 232 |
231 if (length < frameOffset) { | 233 if (length < frameOffset) { |
232 EXPECT_FALSE(decoder->isSizeAvailable()); | 234 EXPECT_FALSE(decoder->isSizeAvailable()); |
233 EXPECT_TRUE(decoder->size().isEmpty()); | 235 EXPECT_TRUE(decoder->size().isEmpty()); |
234 EXPECT_FALSE(decoder->hasEmbeddedColorSpace()); | 236 EXPECT_FALSE(decoder->hasEmbeddedColorSpace()); |
235 EXPECT_EQ(0u, decoder->frameCount()); | 237 EXPECT_EQ(0u, decoder->frameCount()); |
236 EXPECT_EQ(cAnimationLoopOnce, decoder->repetitionCount()); | 238 EXPECT_EQ(cAnimationLoopOnce, decoder->repetitionCount()); |
237 EXPECT_FALSE(decoder->frameBufferAtIndex(0)); | 239 EXPECT_FALSE(decoder->frameBufferAtIndex(0)); |
238 } else { | 240 } else { |
(...skipping 12 matching lines...) Expand all Loading... |
251 SharedBuffer* fullData, | 253 SharedBuffer* fullData, |
252 size_t increment) { | 254 size_t increment) { |
253 const size_t fullLength = fullData->size(); | 255 const size_t fullLength = fullData->size(); |
254 | 256 |
255 std::unique_ptr<ImageDecoder> decoder; | 257 std::unique_ptr<ImageDecoder> decoder; |
256 | 258 |
257 Vector<unsigned> truncatedHashes; | 259 Vector<unsigned> truncatedHashes; |
258 Vector<unsigned> progressiveHashes; | 260 Vector<unsigned> progressiveHashes; |
259 | 261 |
260 // Compute hashes when the file is truncated. | 262 // Compute hashes when the file is truncated. |
| 263 RefPtr<SharedBuffer> data = SharedBuffer::create(); |
| 264 const char* source = fullData->data(); |
261 for (size_t i = 1; i <= fullLength; i += increment) { | 265 for (size_t i = 1; i <= fullLength; i += increment) { |
262 decoder = createDecoder(); | 266 decoder = createDecoder(); |
263 RefPtr<SharedBuffer> data = SharedBuffer::create(fullData->data(), i); | 267 data->append(source++, 1u); |
264 decoder->setData(data.get(), i == fullLength); | 268 decoder->setData(data.get(), i == fullLength); |
265 ImageFrame* frame = decoder->frameBufferAtIndex(0); | 269 ImageFrame* frame = decoder->frameBufferAtIndex(0); |
266 if (!frame) { | 270 if (!frame) { |
267 truncatedHashes.push_back(0); | 271 truncatedHashes.push_back(0); |
268 continue; | 272 continue; |
269 } | 273 } |
270 truncatedHashes.push_back(hashBitmap(frame->bitmap())); | 274 truncatedHashes.push_back(hashBitmap(frame->bitmap())); |
271 } | 275 } |
272 | 276 |
273 // Compute hashes when the file is progressively decoded. | 277 // Compute hashes when the file is progressively decoded. |
274 decoder = createDecoder(); | 278 decoder = createDecoder(); |
| 279 data = SharedBuffer::create(); |
| 280 source = fullData->data(); |
275 for (size_t i = 1; i <= fullLength; i += increment) { | 281 for (size_t i = 1; i <= fullLength; i += increment) { |
276 RefPtr<SharedBuffer> data = SharedBuffer::create(fullData->data(), i); | 282 data->append(source++, 1u); |
277 decoder->setData(data.get(), i == fullLength); | 283 decoder->setData(data.get(), i == fullLength); |
278 ImageFrame* frame = decoder->frameBufferAtIndex(0); | 284 ImageFrame* frame = decoder->frameBufferAtIndex(0); |
279 if (!frame) { | 285 if (!frame) { |
280 progressiveHashes.push_back(0); | 286 progressiveHashes.push_back(0); |
281 continue; | 287 continue; |
282 } | 288 } |
283 progressiveHashes.push_back(hashBitmap(frame->bitmap())); | 289 progressiveHashes.push_back(hashBitmap(frame->bitmap())); |
284 } | 290 } |
285 | 291 |
286 for (size_t i = 0; i < truncatedHashes.size(); ++i) | 292 for (size_t i = 0; i < truncatedHashes.size(); ++i) |
287 ASSERT_EQ(truncatedHashes[i], progressiveHashes[i]); | 293 ASSERT_EQ(truncatedHashes[i], progressiveHashes[i]); |
288 } | 294 } |
289 | 295 |
290 void testUpdateRequiredPreviousFrameAfterFirstDecode( | 296 void testUpdateRequiredPreviousFrameAfterFirstDecode( |
291 DecoderCreator createDecoder, | 297 DecoderCreator createDecoder, |
292 SharedBuffer* fullData) { | 298 SharedBuffer* fullData) { |
293 std::unique_ptr<ImageDecoder> decoder = createDecoder(); | 299 std::unique_ptr<ImageDecoder> decoder = createDecoder(); |
294 | 300 |
295 // Give it data that is enough to parse but not decode in order to check the | 301 // Give it data that is enough to parse but not decode in order to check the |
296 // status of requiredPreviousFrameIndex before decoding. | 302 // status of requiredPreviousFrameIndex before decoding. |
297 size_t partialSize = 1; | 303 RefPtr<SharedBuffer> data = SharedBuffer::create(); |
| 304 const char* source = fullData->data(); |
298 do { | 305 do { |
299 RefPtr<SharedBuffer> data = | 306 data->append(source++, 1u); |
300 SharedBuffer::create(fullData->data(), partialSize); | |
301 decoder->setData(data.get(), false); | 307 decoder->setData(data.get(), false); |
302 ++partialSize; | |
303 } while (!decoder->frameCount() || | 308 } while (!decoder->frameCount() || |
304 decoder->frameBufferAtIndex(0)->getStatus() == | 309 decoder->frameBufferAtIndex(0)->getStatus() == |
305 ImageFrame::FrameEmpty); | 310 ImageFrame::FrameEmpty); |
306 | 311 |
307 EXPECT_EQ(kNotFound, | 312 EXPECT_EQ(kNotFound, |
308 decoder->frameBufferAtIndex(0)->requiredPreviousFrameIndex()); | 313 decoder->frameBufferAtIndex(0)->requiredPreviousFrameIndex()); |
309 unsigned frameCount = decoder->frameCount(); | 314 unsigned frameCount = decoder->frameCount(); |
310 for (size_t i = 1; i < frameCount; ++i) { | 315 for (size_t i = 1; i < frameCount; ++i) { |
311 EXPECT_EQ(i - 1, | 316 EXPECT_EQ(i - 1, |
312 decoder->frameBufferAtIndex(i)->requiredPreviousFrameIndex()); | 317 decoder->frameBufferAtIndex(i)->requiredPreviousFrameIndex()); |
313 } | 318 } |
314 | 319 |
315 decoder->setData(fullData, true); | 320 decoder->setData(fullData, true); |
316 for (size_t i = 0; i < frameCount; ++i) { | 321 for (size_t i = 0; i < frameCount; ++i) { |
317 EXPECT_EQ(kNotFound, | 322 EXPECT_EQ(kNotFound, |
318 decoder->frameBufferAtIndex(i)->requiredPreviousFrameIndex()); | 323 decoder->frameBufferAtIndex(i)->requiredPreviousFrameIndex()); |
319 } | 324 } |
320 } | 325 } |
321 | 326 |
322 void testResumePartialDecodeAfterClearFrameBufferCache( | 327 void testResumePartialDecodeAfterClearFrameBufferCache( |
323 DecoderCreator createDecoder, | 328 DecoderCreator createDecoder, |
324 SharedBuffer* fullData) { | 329 SharedBuffer* fullData) { |
325 Vector<unsigned> baselineHashes; | 330 Vector<unsigned> baselineHashes; |
326 createDecodingBaseline(createDecoder, fullData, &baselineHashes); | 331 createDecodingBaseline(createDecoder, fullData, &baselineHashes); |
327 size_t frameCount = baselineHashes.size(); | 332 size_t frameCount = baselineHashes.size(); |
328 | 333 |
329 std::unique_ptr<ImageDecoder> decoder = createDecoder(); | 334 std::unique_ptr<ImageDecoder> decoder = createDecoder(); |
330 | 335 |
331 // Let frame 0 be partially decoded. | 336 // Let frame 0 be partially decoded. |
332 size_t partialSize = 1; | 337 RefPtr<SharedBuffer> data = SharedBuffer::create(); |
| 338 const char* source = fullData->data(); |
333 do { | 339 do { |
334 RefPtr<SharedBuffer> data = | 340 data->append(source++, 1u); |
335 SharedBuffer::create(fullData->data(), partialSize); | |
336 decoder->setData(data.get(), false); | 341 decoder->setData(data.get(), false); |
337 ++partialSize; | |
338 } while (!decoder->frameCount() || | 342 } while (!decoder->frameCount() || |
339 decoder->frameBufferAtIndex(0)->getStatus() == | 343 decoder->frameBufferAtIndex(0)->getStatus() == |
340 ImageFrame::FrameEmpty); | 344 ImageFrame::FrameEmpty); |
341 | 345 |
342 // Skip to the last frame and clear. | 346 // Skip to the last frame and clear. |
343 decoder->setData(fullData, true); | 347 decoder->setData(fullData, true); |
344 EXPECT_EQ(frameCount, decoder->frameCount()); | 348 EXPECT_EQ(frameCount, decoder->frameCount()); |
345 ImageFrame* lastFrame = decoder->frameBufferAtIndex(frameCount - 1); | 349 ImageFrame* lastFrame = decoder->frameBufferAtIndex(frameCount - 1); |
346 EXPECT_EQ(baselineHashes[frameCount - 1], hashBitmap(lastFrame->bitmap())); | 350 EXPECT_EQ(baselineHashes[frameCount - 1], hashBitmap(lastFrame->bitmap())); |
347 decoder->clearCacheExceptFrame(kNotFound); | 351 decoder->clearCacheExceptFrame(kNotFound); |
(...skipping 221 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
569 size_t frameCount = decoderA->frameCount(); | 573 size_t frameCount = decoderA->frameCount(); |
570 ASSERT_EQ(frameCount, decoderB->frameCount()); | 574 ASSERT_EQ(frameCount, decoderB->frameCount()); |
571 | 575 |
572 for (size_t i = 0; i < frameCount; ++i) { | 576 for (size_t i = 0; i < frameCount; ++i) { |
573 verifyFramesMatch(file, decoderA->frameBufferAtIndex(i), | 577 verifyFramesMatch(file, decoderA->frameBufferAtIndex(i), |
574 decoderB->frameBufferAtIndex(i)); | 578 decoderB->frameBufferAtIndex(i)); |
575 } | 579 } |
576 } | 580 } |
577 | 581 |
578 } // namespace blink | 582 } // namespace blink |
OLD | NEW |