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
check_fill(skiatest::Reporter * r,const SkImageInfo & imageInfo,uint32_t startRow,uint32_t endRow,size_t rowBytes,uint32_t offset,uint32_t colorOrIndex)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.computeByteSize(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
DEF_TEST(SwizzlerFill,r)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
DEF_TEST(SwizzleOpts,r)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
DEF_TEST(PublicSwizzleOpts,r)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