Home | History | Annotate | Download | only in tests 
      1 /*
      2  * Copyright 2015 Google Inc.
      3  *
      4  * Use of this source code is governed by a BSD-style license that can be
      5  * found in the LICENSE file.
      6  */
      7 
      8 #include "SkSwizzle.h"
      9 #include "SkSwizzler.h"
     10 #include "Test.h"
     11 #include "SkOpts.h"
     12 
     13 // These are the values that we will look for to indicate that the fill was successful
     14 static const uint8_t kFillGray = 0x22;
     15 static const uint16_t kFill565 = 0x3344;
     16 static const uint32_t kFillColor = 0x55667788;
     17 
     18 static void check_fill(skiatest::Reporter* r,
     19                        const SkImageInfo& imageInfo,
     20                        uint32_t startRow,
     21                        uint32_t endRow,
     22                        size_t rowBytes,
     23                        uint32_t offset,
     24                        uint32_t colorOrIndex) {
     25 
     26     // Calculate the total size of the image in bytes.  Use the smallest possible size.
     27     // The offset value tells us to adjust the pointer from the memory we allocate in order
     28     // to test on different memory alignments.  If offset is nonzero, we need to increase the
     29     // size of the memory we allocate in order to make sure that we have enough.  We are
     30     // still allocating the smallest possible size.
     31     const size_t totalBytes = imageInfo.getSafeSize(rowBytes) + offset;
     32 
     33     // Create fake image data where every byte has a value of 0
     34     std::unique_ptr<uint8_t[]> storage(new uint8_t[totalBytes]);
     35     memset(storage.get(), 0, totalBytes);
     36     // Adjust the pointer in order to test on different memory alignments
     37     uint8_t* imageData = storage.get() + offset;
     38     uint8_t* imageStart = imageData + rowBytes * startRow;
     39     const SkImageInfo fillInfo = imageInfo.makeWH(imageInfo.width(), endRow - startRow + 1);
     40     SkSampler::Fill(fillInfo, imageStart, rowBytes, colorOrIndex, SkCodec::kNo_ZeroInitialized);
     41 
     42     // Ensure that the pixels are filled properly
     43     // The bots should catch any memory corruption
     44     uint8_t* indexPtr = imageData + startRow * rowBytes;
     45     uint8_t* grayPtr = indexPtr;
     46     uint32_t* colorPtr = (uint32_t*) indexPtr;
     47     uint16_t* color565Ptr = (uint16_t*) indexPtr;
     48     for (uint32_t y = startRow; y <= endRow; y++) {
     49         for (int32_t x = 0; x < imageInfo.width(); x++) {
     50             switch (imageInfo.colorType()) {
     51                 case kN32_SkColorType:
     52                     REPORTER_ASSERT(r, kFillColor == colorPtr[x]);
     53                     break;
     54                 case kGray_8_SkColorType:
     55                     REPORTER_ASSERT(r, kFillGray == grayPtr[x]);
     56                     break;
     57                 case kRGB_565_SkColorType:
     58                     REPORTER_ASSERT(r, kFill565 == color565Ptr[x]);
     59                     break;
     60                 default:
     61                     REPORTER_ASSERT(r, false);
     62                     break;
     63             }
     64         }
     65         indexPtr += rowBytes;
     66         colorPtr = (uint32_t*) indexPtr;
     67     }
     68 }
     69 
     70 // Test Fill() with different combinations of dimensions, alignment, and padding
     71 DEF_TEST(SwizzlerFill, r) {
     72     // Test on an invalid width and representative widths
     73     const uint32_t widths[] = { 0, 10, 50 };
     74 
     75     // In order to call Fill(), there must be at least one row to fill
     76     // Test on the smallest possible height and representative heights
     77     const uint32_t heights[] = { 1, 5, 10 };
     78 
     79     // Test on interesting possibilities for row padding
     80     const uint32_t paddings[] = { 0, 4 };
     81 
     82     // Iterate over test dimensions
     83     for (uint32_t width : widths) {
     84         for (uint32_t height : heights) {
     85 
     86             // Create image info objects
     87             const SkImageInfo colorInfo = SkImageInfo::MakeN32(width, height, kUnknown_SkAlphaType);
     88             const SkImageInfo grayInfo = colorInfo.makeColorType(kGray_8_SkColorType);
     89             const SkImageInfo color565Info = colorInfo.makeColorType(kRGB_565_SkColorType);
     90 
     91             for (uint32_t padding : paddings) {
     92 
     93                 // Calculate row bytes
     94                 const size_t colorRowBytes = SkColorTypeBytesPerPixel(kN32_SkColorType) * width
     95                         + padding;
     96                 const size_t indexRowBytes = width + padding;
     97                 const size_t grayRowBytes = indexRowBytes;
     98                 const size_t color565RowBytes =
     99                         SkColorTypeBytesPerPixel(kRGB_565_SkColorType) * width + padding;
    100 
    101                 // If there is padding, we can invent an offset to change the memory alignment
    102                 for (uint32_t offset = 0; offset <= padding; offset += 4) {
    103 
    104                     // Test all possible start rows with all possible end rows
    105                     for (uint32_t startRow = 0; startRow < height; startRow++) {
    106                         for (uint32_t endRow = startRow; endRow < height; endRow++) {
    107 
    108                             // Test fill with each color type
    109                             check_fill(r, colorInfo, startRow, endRow, colorRowBytes, offset,
    110                                     kFillColor);
    111                             check_fill(r, grayInfo, startRow, endRow, grayRowBytes, offset,
    112                                     kFillGray);
    113                             check_fill(r, color565Info, startRow, endRow, color565RowBytes, offset,
    114                                     kFill565);
    115                         }
    116                     }
    117                 }
    118             }
    119         }
    120     }
    121 }
    122 
    123 DEF_TEST(SwizzleOpts, r) {
    124     uint32_t dst, src;
    125 
    126     // forall c, c*255 == c, c*0 == 0
    127     for (int c = 0; c <= 255; c++) {
    128         src = (255<<24) | c;
    129         SkOpts::RGBA_to_rgbA(&dst, &src, 1);
    130         REPORTER_ASSERT(r, dst == src);
    131         SkOpts::RGBA_to_bgrA(&dst, &src, 1);
    132         REPORTER_ASSERT(r, dst == (uint32_t)((255<<24) | (c<<16)));
    133 
    134         src = (0<<24) | c;
    135         SkOpts::RGBA_to_rgbA(&dst, &src, 1);
    136         REPORTER_ASSERT(r, dst == 0);
    137         SkOpts::RGBA_to_bgrA(&dst, &src, 1);
    138         REPORTER_ASSERT(r, dst == 0);
    139     }
    140 
    141     // check a totally arbitrary color
    142     src = 0xFACEB004;
    143     SkOpts::RGBA_to_rgbA(&dst, &src, 1);
    144     REPORTER_ASSERT(r, dst == 0xFACAAD04);
    145 
    146     // swap red and blue
    147     SkOpts::RGBA_to_BGRA(&dst, &src, 1);
    148     REPORTER_ASSERT(r, dst == 0xFA04B0CE);
    149 
    150     // all together now
    151     SkOpts::RGBA_to_bgrA(&dst, &src, 1);
    152     REPORTER_ASSERT(r, dst == 0xFA04ADCA);
    153 }
    154 
    155 DEF_TEST(PublicSwizzleOpts, r) {
    156     uint32_t dst, src;
    157 
    158     // check a totally arbitrary color
    159     src = 0xFACEB004;
    160     SkSwapRB(&dst, &src, 1);
    161     REPORTER_ASSERT(r, dst == 0xFA04B0CE);
    162 }
    163