1 /*
2  * Copyright 2016 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 "SkHalf.h"
9 #include "SkRasterPipeline.h"
10 #include "SkTo.h"
11 #include "Test.h"
12 
DEF_TEST(SkRasterPipeline,r)13 DEF_TEST(SkRasterPipeline, r) {
14     // Build and run a simple pipeline to exercise SkRasterPipeline,
15     // drawing 50% transparent blue over opaque red in half-floats.
16     uint64_t red  = 0x3c00000000003c00ull,
17              blue = 0x3800380000000000ull,
18              result;
19 
20     SkRasterPipeline_MemoryCtx load_s_ctx = { &blue, 0 },
21                                load_d_ctx = { &red, 0 },
22                                store_ctx  = { &result, 0 };
23 
24     SkRasterPipeline_<256> p;
25     p.append(SkRasterPipeline::load_f16,     &load_s_ctx);
26     p.append(SkRasterPipeline::load_f16_dst, &load_d_ctx);
27     p.append(SkRasterPipeline::srcover);
28     p.append(SkRasterPipeline::store_f16, &store_ctx);
29     p.run(0,0,1,1);
30 
31     // We should see half-intensity magenta.
32     REPORTER_ASSERT(r, ((result >>  0) & 0xffff) == 0x3800);
33     REPORTER_ASSERT(r, ((result >> 16) & 0xffff) == 0x0000);
34     REPORTER_ASSERT(r, ((result >> 32) & 0xffff) == 0x3800);
35     REPORTER_ASSERT(r, ((result >> 48) & 0xffff) == 0x3c00);
36 }
37 
DEF_TEST(SkRasterPipeline_empty,r)38 DEF_TEST(SkRasterPipeline_empty, r) {
39     // No asserts... just a test that this is safe to run.
40     SkRasterPipeline_<256> p;
41     p.run(0,0,20,1);
42 }
43 
DEF_TEST(SkRasterPipeline_nonsense,r)44 DEF_TEST(SkRasterPipeline_nonsense, r) {
45     // No asserts... just a test that this is safe to run and terminates.
46     // srcover() calls st->next(); this makes sure we've always got something there to call.
47     SkRasterPipeline_<256> p;
48     p.append(SkRasterPipeline::srcover);
49     p.run(0,0,20,1);
50 }
51 
DEF_TEST(SkRasterPipeline_JIT,r)52 DEF_TEST(SkRasterPipeline_JIT, r) {
53     // This tests a couple odd corners that a JIT backend can stumble over.
54 
55     uint32_t buf[72] = {
56          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
57          1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12,
58         13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
59          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
60          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
61          0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
62     };
63 
64     SkRasterPipeline_MemoryCtx src = { buf +  0, 0 },
65                        dst = { buf + 36, 0 };
66 
67     // Copy buf[x] to buf[x+36] for x in [15,35).
68     SkRasterPipeline_<256> p;
69     p.append(SkRasterPipeline:: load_8888, &src);
70     p.append(SkRasterPipeline::store_8888, &dst);
71     p.run(15,0, 20,1);
72 
73     for (int i = 0; i < 36; i++) {
74         if (i < 15 || i == 35) {
75             REPORTER_ASSERT(r, buf[i+36] == 0);
76         } else {
77             REPORTER_ASSERT(r, buf[i+36] == (uint32_t)(i - 11));
78         }
79     }
80 }
81 
h(float f)82 static uint16_t h(float f) {
83     // Remember, a float is 1-8-23 (sign-exponent-mantissa) with 127 exponent bias.
84     uint32_t sem;
85     memcpy(&sem, &f, sizeof(sem));
86     uint32_t s  = sem & 0x80000000,
87              em = sem ^ s;
88 
89     // Convert to 1-5-10 half with 15 bias, flushing denorm halfs (including zero) to zero.
90     auto denorm = (int32_t)em < 0x38800000;  // I32 comparison is often quicker, and always safe
91     // here.
92     return denorm ? SkTo<uint16_t>(0)
93                   : SkTo<uint16_t>((s>>16) + (em>>13) - ((127-15)<<10));
94 }
95 
DEF_TEST(SkRasterPipeline_tail,r)96 DEF_TEST(SkRasterPipeline_tail, r) {
97     {
98         float data[][4] = {
99             {00, 01, 02, 03},
100             {10, 11, 12, 13},
101             {20, 21, 22, 23},
102             {30, 31, 32, 33},
103         };
104 
105         float buffer[4][4];
106 
107         SkRasterPipeline_MemoryCtx src = { &data[0][0], 0 },
108                            dst = { &buffer[0][0], 0 };
109 
110         for (unsigned i = 1; i <= 4; i++) {
111             memset(buffer, 0xff, sizeof(buffer));
112             SkRasterPipeline_<256> p;
113             p.append(SkRasterPipeline::load_f32, &src);
114             p.append(SkRasterPipeline::store_f32, &dst);
115             p.run(0,0, i,1);
116             for (unsigned j = 0; j < i; j++) {
117                 for (unsigned k = 0; k < 4; k++) {
118                     if (buffer[j][k] != data[j][k]) {
119                         ERRORF(r, "(%u, %u) - a: %g r: %g\n", j, k, data[j][k], buffer[j][k]);
120                     }
121                 }
122             }
123             for (int j = i; j < 4; j++) {
124                 for (auto f : buffer[j]) {
125                     REPORTER_ASSERT(r, SkScalarIsNaN(f));
126                 }
127             }
128         }
129     }
130 
131     {
132         alignas(8) uint16_t data[][4] = {
133             {h(00), h(01), h(02), h(03)},
134             {h(10), h(11), h(12), h(13)},
135             {h(20), h(21), h(22), h(23)},
136             {h(30), h(31), h(32), h(33)},
137         };
138         alignas(8) uint16_t buffer[4][4];
139         SkRasterPipeline_MemoryCtx src = { &data[0][0], 0 },
140                            dst = { &buffer[0][0], 0 };
141 
142         for (unsigned i = 1; i <= 4; i++) {
143             memset(buffer, 0xff, sizeof(buffer));
144             SkRasterPipeline_<256> p;
145             p.append(SkRasterPipeline::load_f16, &src);
146             p.append(SkRasterPipeline::store_f16, &dst);
147             p.run(0,0, i,1);
148             for (unsigned j = 0; j < i; j++) {
149                 REPORTER_ASSERT(r,
150                                 !memcmp(&data[j][0], &buffer[j][0], sizeof(buffer[j])));
151             }
152             for (int j = i; j < 4; j++) {
153                 for (auto f : buffer[j]) {
154                     REPORTER_ASSERT(r, f == 0xffff);
155                 }
156             }
157         }
158     }
159 }
160 
DEF_TEST(SkRasterPipeline_lowp,r)161 DEF_TEST(SkRasterPipeline_lowp, r) {
162     uint32_t rgba[64];
163     for (int i = 0; i < 64; i++) {
164         rgba[i] = (4*i+0) << 0
165                 | (4*i+1) << 8
166                 | (4*i+2) << 16
167                 | (4*i+3) << 24;
168     }
169 
170     SkRasterPipeline_MemoryCtx ptr = { rgba, 0 };
171 
172     SkRasterPipeline_<256> p;
173     p.append(SkRasterPipeline::load_8888,  &ptr);
174     p.append(SkRasterPipeline::swap_rb);
175     p.append(SkRasterPipeline::store_8888, &ptr);
176     p.run(0,0,64,1);
177 
178     for (int i = 0; i < 64; i++) {
179         uint32_t want = (4*i+0) << 16
180                       | (4*i+1) << 8
181                       | (4*i+2) << 0
182                       | (4*i+3) << 24;
183         if (rgba[i] != want) {
184             ERRORF(r, "got %08x, want %08x\n", rgba[i], want);
185         }
186     }
187 }
188 
DEF_TEST(SkRasterPipeline_lowp_clamp01,r)189 DEF_TEST(SkRasterPipeline_lowp_clamp01, r) {
190     // This may seem like a funny pipeline to create,
191     // but it certainly shouldn't crash when you run it.
192 
193     uint32_t rgba = 0xff00ff00;
194 
195     SkRasterPipeline_MemoryCtx ptr = { &rgba, 0 };
196 
197     SkRasterPipeline_<256> p;
198     p.append(SkRasterPipeline::load_8888,  &ptr);
199     p.append(SkRasterPipeline::swap_rb);
200     p.append(SkRasterPipeline::clamp_0);
201     p.append(SkRasterPipeline::clamp_1);
202     p.append(SkRasterPipeline::store_8888, &ptr);
203     p.run(0,0,1,1);
204 }
205