From 438b2adefb9e9213e0ddaf0609405d3087a1cf0a Mon Sep 17 00:00:00 2001 From: msarett Date: Thu, 9 Apr 2015 12:43:10 -0700 Subject: ***Disables swizzles to 565. We may want to enable swizzles to 565 for images that are encoded in a format similar to 565, however, we do not want to take images that decode naturally to kN32 and then convert them to 565. ***Enable swizzles to kIndex_8. For images encoded in a color table format, we suggest that they be decoded to kIndex_8. When we decode, we only allow conversion to kIndex_8 if it matches the suggested color type (except wbmp which seems good as is). ***Modify dm to test images that decode to kIndex_8. BUG=skia:3257 BUG=skia:3440 Review URL: https://codereview.chromium.org/1055743003 --- tests/SwizzlerTest.cpp | 112 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 112 insertions(+) create mode 100644 tests/SwizzlerTest.cpp (limited to 'tests/SwizzlerTest.cpp') diff --git a/tests/SwizzlerTest.cpp b/tests/SwizzlerTest.cpp new file mode 100644 index 0000000000..1355f3be8c --- /dev/null +++ b/tests/SwizzlerTest.cpp @@ -0,0 +1,112 @@ +/* + * Copyright 2015 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#include "SkSwizzler.h" +#include "Test.h" + +// These are the values that we will look for to indicate that the fill was successful +static const uint8_t kFillIndex = 0x1; +static const uint32_t kFillColor = 0x22334455; + +static void check_fill(skiatest::Reporter* r, + const SkImageInfo& imageInfo, + uint32_t startRow, + size_t rowBytes, + uint32_t offset, + uint32_t colorOrIndex, + SkPMColor* colorTable) { + + // Calculate the total size of the image in bytes. Use the smallest possible size. + // The offset value tells us to adjust the pointer from the memory we allocate in order + // to test on different memory alignments. If offset is nonzero, we need to increase the + // size of the memory we allocate in order to make sure that we have enough. We are + // still allocating the smallest possible size. + const size_t totalBytes = imageInfo.getSafeSize(rowBytes) + offset; + + // Create fake image data where every byte has a value of 0 + SkAutoTDelete storage((uint8_t*) sk_malloc_throw(totalBytes)); + memset(storage.get(), 0, totalBytes); + // Adjust the pointer in order to test on different memory alignments + uint8_t* imageData = storage.get() + offset; + + // Fill image with the fill value starting at the indicated row + SkSwizzler::Fill(imageData, imageInfo, rowBytes, startRow, colorOrIndex, colorTable); + + // Ensure that the pixels are filled properly + // The bots should catch any memory corruption + uint8_t* indexPtr = imageData + startRow * rowBytes; + uint32_t* colorPtr = (uint32_t*) indexPtr; + for (int32_t y = startRow; y < imageInfo.height(); y++) { + for (int32_t x = 0; x < imageInfo.width(); x++) { + if (kIndex_8_SkColorType == imageInfo.colorType()) { + REPORTER_ASSERT(r, kFillIndex == indexPtr[x]); + } else { + REPORTER_ASSERT(r, kFillColor == colorPtr[x]); + } + } + indexPtr += rowBytes; + colorPtr = (uint32_t*) indexPtr; + } +} + +// Test Fill() with different combinations of dimensions, alignment, and padding +DEF_TEST(SwizzlerFill, r) { + // Set up a color table + SkPMColor colorTable[kFillIndex + 1]; + colorTable[kFillIndex] = kFillColor; + // Apart from the fill index, we will leave the other colors in the color table uninitialized. + // If we incorrectly try to fill with this uninitialized memory, the bots will catch it. + + // Test on an invalid width and representative widths + const uint32_t widths[] = { 0, 10, 50 }; + + // In order to call Fill(), there must be at least one row to fill + // Test on the smallest possible height and representative heights + const uint32_t heights[] = { 1, 5, 10 }; + + // Test on interesting possibilities for row padding + const uint32_t paddings[] = { 0, 1, 2, 3, 4 }; + + // Iterate over test dimensions + for (uint32_t width : widths) { + for (uint32_t height : heights) { + + // Create image info objects + const SkImageInfo colorInfo = SkImageInfo::MakeN32(width, height, + kUnknown_SkAlphaType); + const SkImageInfo indexInfo = colorInfo.makeColorType(kIndex_8_SkColorType); + + for (uint32_t padding : paddings) { + + // Calculate row bytes + size_t colorRowBytes = SkColorTypeBytesPerPixel(kN32_SkColorType) * width + + padding; + size_t indexRowBytes = width + padding; + + // If there is padding, we can invent an offset to change the memory alignment + for (uint32_t offset = 0; offset <= padding; offset++) { + + // Test all possible start rows + for (uint32_t startRow = 0; startRow < height; startRow++) { + + // Fill with an index that we use to look up a color + check_fill(r, colorInfo, startRow, colorRowBytes, offset, kFillIndex, + colorTable); + + // Fill with a color + check_fill(r, colorInfo, startRow, colorRowBytes, offset, kFillColor, + NULL); + + // Fill with an index + check_fill(r, indexInfo, startRow, indexRowBytes, offset, kFillIndex, + NULL); + } + } + } + } + } +} -- cgit v1.2.3