SRGBReadWritePixelsTest.cpp revision 24429c68c56683252e3fc2a79d9b660eaf96ec0c 
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 "Test.h"
9#if SK_SUPPORT_GPU
10#include "GrCaps.h"
11#include "GrContext.h"
12#include "GrTextureProvider.h"
13#include "SkCanvas.h"
14#include "SkSurface.h"
15
16// using anonymous namespace because these functions are used as template params.
17namespace {
18/** convert 0..1 srgb value to 0..1 linear */
19float srgb_to_linear(float srgb) {
20    if (srgb <= 0.04045f) {
21        return srgb / 12.92f;
22    } else {
23        return powf((srgb + 0.055f) / 1.055f, 2.4f);
24    }
25}
26
27/** convert 0..1 linear value to 0..1 srgb */
28float linear_to_srgb(float linear) {
29    if (linear <= 0.0031308) {
30        return linear * 12.92f;
31    } else {
32        return 1.055f * powf(linear, 1.f / 2.4f) - 0.055f;
33    }
34}
35}
36
37/** tests a conversion with an error tolerance */
38template <float (*CONVERT)(float)> static bool check_conversion(uint32_t input, uint32_t output,
39                                                                float error) {
40    // alpha should always be exactly preserved.
41    if ((input & 0xff000000) != (output & 0xff000000)) {
42        return false;
43    }
44
45    for (int c = 0; c < 3; ++c) {
46        uint8_t inputComponent = (uint8_t) ((input & (0xff << (c*8))) >> (c*8));
47        float lower = SkTMax(0.f, (float) inputComponent - error);
48        float upper = SkTMin(255.f, (float) inputComponent + error);
49        lower = CONVERT(lower / 255.f);
50        upper = CONVERT(upper / 255.f);
51        SkASSERT(lower >= 0.f && lower <= 255.f);
52        SkASSERT(upper >= 0.f && upper <= 255.f);
53        uint8_t outputComponent = (output & (0xff << (c*8))) >> (c*8);
54        if (outputComponent < SkScalarFloorToInt(lower * 255.f) ||
55            outputComponent > SkScalarCeilToInt(upper * 255.f)) {
56            return false;
57        }
58    }
59    return true;
60}
61
62/** tests a forward and backward conversion with an error tolerance */
63template <float (*FORWARD)(float), float (*BACKWARD)(float)>
64static bool check_double_conversion(uint32_t input, uint32_t output, float error) {
65    // alpha should always be exactly preserved.
66    if ((input & 0xff000000) != (output & 0xff000000)) {
67        return false;
68    }
69
70    for (int c = 0; c < 3; ++c) {
71        uint8_t inputComponent = (uint8_t) ((input & (0xff << (c*8))) >> (c*8));
72        float lower = SkTMax(0.f, (float) inputComponent - error);
73        float upper = SkTMin(255.f, (float) inputComponent + error);
74        lower = FORWARD(lower / 255.f);
75        upper = FORWARD(upper / 255.f);
76        SkASSERT(lower >= 0.f && lower <= 255.f);
77        SkASSERT(upper >= 0.f && upper <= 255.f);
78        uint8_t upperComponent = SkScalarCeilToInt(upper * 255.f);
79        uint8_t lowerComponent = SkScalarFloorToInt(lower * 255.f);
80        lower = SkTMax(0.f, (float) lowerComponent - error);
81        upper = SkTMin(255.f, (float) upperComponent + error);
82        lower = BACKWARD(lowerComponent / 255.f);
83        upper = BACKWARD(upperComponent / 255.f);
84        SkASSERT(lower >= 0.f && lower <= 255.f);
85        SkASSERT(upper >= 0.f && upper <= 255.f);
86        upperComponent = SkScalarCeilToInt(upper * 255.f);
87        lowerComponent = SkScalarFloorToInt(lower * 255.f);
88
89        uint8_t outputComponent = (output & (0xff << (c*8))) >> (c*8);
90        if (outputComponent < lowerComponent || outputComponent > upperComponent) {
91            return false;
92        }
93    }
94    return true;
95}
96
97static bool check_srgb_to_linear_conversion(uint32_t srgb, uint32_t linear, float error) {
98    return check_conversion<srgb_to_linear>(srgb, linear, error);
99}
100
101static bool check_linear_to_srgb_conversion(uint32_t linear, uint32_t srgb, float error) {
102    return check_conversion<linear_to_srgb>(linear, srgb, error);
103}
104
105static bool check_linear_to_srgb_to_linear_conversion(uint32_t input, uint32_t output, float error) {
106    return check_double_conversion<linear_to_srgb, srgb_to_linear>(input, output, error);
107}
108
109static bool check_srgb_to_linear_to_srgb_conversion(uint32_t input, uint32_t output, float error) {
110    return check_double_conversion<srgb_to_linear, linear_to_srgb>(input, output, error);
111}
112
113typedef bool (*CheckFn) (uint32_t orig, uint32_t actual, float error);
114
115void read_and_check_pixels(skiatest::Reporter* reporter, GrTexture* texture, uint32_t* origData,
116                           GrPixelConfig readConfig, CheckFn checker, float error,
117                           const char* subtestName) {
118    int w = texture->width();
119    int h = texture->height();
120    SkAutoTMalloc<uint32_t> readData(w * h);
121    memset(readData.get(), 0, sizeof(uint32_t) * w * h);
122    if (!texture->readPixels(0, 0, w, h, readConfig, readData.get())) {
123        ERRORF(reporter, "Could not read pixels for %s.", subtestName);
124        return;
125    }
126    for (int j = 0; j < h; ++j) {
127        for (int i = 0; i < w; ++i) {
128            uint32_t orig = origData[j * w + i];
129            uint32_t read = readData[j * w + i];
130
131            if (!checker(orig, read, error)) {
132                ERRORF(reporter, "Expected 0x%08x, read back as 0x%08x in %s at %d, %d).",
133                       orig, read, subtestName, i, j);
134                return;
135            }
136        }
137    }
138}
139
140// TODO: Add tests for copySurface between srgb/linear textures. Add tests for unpremul/premul
141// conversion during read/write along with srgb/linear conversions.
142DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SRGBReadWritePixels, reporter, ctxInfo) {
143    GrContext* context = ctxInfo.grContext();
144#if defined(GOOGLE3)
145    // Stack frame size is limited in GOOGLE3.
146    static const int kW = 63;
147    static const int kH = 63;
148#else
149    static const int kW = 255;
150    static const int kH = 255;
151#endif
152    uint32_t origData[kW * kH];
153    for (int j = 0; j < kH; ++j) {
154        for (int i = 0; i < kW; ++i) {
155            origData[j * kW + i] = (j << 24) | (i << 16) | (i << 8) | i;
156        }
157    }
158
159    GrSurfaceDesc desc;
160    desc.fFlags = kRenderTarget_GrSurfaceFlag;
161    desc.fWidth = kW;
162    desc.fHeight = kH;
163    desc.fConfig = kSRGBA_8888_GrPixelConfig;
164    if (context->caps()->isConfigRenderable(desc.fConfig, false) &&
165        context->caps()->isConfigTexturable(desc.fConfig)) {
166        sk_sp<GrTexture> tex(context->textureProvider()->createTexture(desc, SkBudgeted::kNo));
167        if (!tex) {
168            ERRORF(reporter, "Could not create SRGBA texture.");
169            return;
170        }
171
172        float error = context->caps()->shaderCaps()->floatPrecisionVaries() ? 1.2f  : 0.5f;
173
174        // Write srgba data and read as srgba and then as rgba
175        if (tex->writePixels(0, 0, kW, kH, kSRGBA_8888_GrPixelConfig, origData)) {
176            // For the all-srgba case, we allow a small error only for devices that have
177            // precision variation because the srgba data gets converted to linear and back in
178            // the shader.
179            float smallError = context->caps()->shaderCaps()->floatPrecisionVaries() ? 1.f :
180                    0.0f;
181            read_and_check_pixels(reporter, tex.get(), origData, kSRGBA_8888_GrPixelConfig,
182                                  check_srgb_to_linear_to_srgb_conversion, smallError,
183                                  "write/read srgba to srgba texture");
184            read_and_check_pixels(reporter, tex.get(), origData, kRGBA_8888_GrPixelConfig,
185                                  check_srgb_to_linear_conversion, error,
186                                  "write srgba/read rgba with srgba texture");
187        } else {
188            ERRORF(reporter, "Could not write srgba data to srgba texture.");
189        }
190
191        // Now verify that we can write linear data
192        if (tex->writePixels(0, 0, kW, kH, kRGBA_8888_GrPixelConfig, origData)) {
193            // We allow more error on GPUs with lower precision shader variables.
194            read_and_check_pixels(reporter, tex.get(), origData, kSRGBA_8888_GrPixelConfig,
195                                  check_linear_to_srgb_conversion, error,
196                                  "write rgba/read srgba with srgba texture");
197            read_and_check_pixels(reporter, tex.get(), origData, kRGBA_8888_GrPixelConfig,
198                                  check_linear_to_srgb_to_linear_conversion, error,
199                                  "write/read rgba with srgba texture");
200        } else {
201            ERRORF(reporter, "Could not write rgba data to srgba texture.");
202        }
203
204        desc.fConfig = kRGBA_8888_GrPixelConfig;
205        tex.reset(context->textureProvider()->createTexture(desc, SkBudgeted::kNo));
206        if (!tex) {
207            ERRORF(reporter, "Could not create RGBA texture.");
208            return;
209        }
210
211        // Write srgba data to a rgba texture and read back as srgba and rgba
212        if (tex->writePixels(0, 0, kW, kH, kSRGBA_8888_GrPixelConfig, origData)) {
213            read_and_check_pixels(reporter, tex.get(), origData, kSRGBA_8888_GrPixelConfig,
214                                  check_srgb_to_linear_to_srgb_conversion, error,
215                                  "write/read srgba to rgba texture");
216            read_and_check_pixels(reporter, tex.get(), origData, kRGBA_8888_GrPixelConfig,
217                                  check_srgb_to_linear_conversion, error,
218                                  "write srgba/read rgba to rgba texture");
219        } else {
220            ERRORF(reporter, "Could not write srgba data to rgba texture.");
221        }
222
223        // Write rgba data to a rgba texture and read back as srgba
224        if (tex->writePixels(0, 0, kW, kH, kRGBA_8888_GrPixelConfig, origData)) {
225            read_and_check_pixels(reporter, tex.get(), origData, kSRGBA_8888_GrPixelConfig,
226                                  check_linear_to_srgb_conversion, 1.2f,
227                                  "write rgba/read srgba to rgba texture");
228        } else {
229            ERRORF(reporter, "Could not write rgba data to rgba texture.");
230        }
231    }
232}
233#endif
234