Home | History | Annotate | Download | only in tests 
      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 /*
      9  * This is a straightforward test of using packed pixel configs (4444, 565).
     10  * This test will make sure that these RGBA_4444 and RGB_565 are always supported
     11  * as valid texturing configs.
     12  */
     13 
     14 #include "Test.h"
     15 
     16 #include "GrContext.h"
     17 #include "GrContextPriv.h"
     18 #include "GrProxyProvider.h"
     19 #include "GrTextureProxy.h"
     20 #include "ProxyUtils.h"
     21 
     22 static const int DEV_W = 10, DEV_H = 10;
     23 static const uint8_t TOL = 0x4;
     24 
     25 static void check_component(skiatest::Reporter* reporter, uint8_t control, uint8_t test) {
     26     uint8_t diff = 0;
     27     if (control >= test) {
     28         diff = control - test;
     29     } else {
     30         diff = test - control;
     31     }
     32     REPORTER_ASSERT(reporter, diff < TOL);
     33 }
     34 
     35 static uint8_t expand_value(uint8_t original, int sigBits) {
     36     SkASSERT(sigBits >= 4);
     37     uint8_t inSigBitShift = 8 - sigBits;
     38     uint8_t duplBitShift = sigBits - inSigBitShift;
     39     return (original << inSigBitShift) + (original >> duplBitShift);
     40 }
     41 
     42 static void check_4444(skiatest::Reporter* reporter,
     43                        const SkTDArray<uint16_t>& controlData,
     44                        const SkTDArray<uint32_t>& readBuffer) {
     45     for (int j = 0; j < DEV_H; ++j) {
     46         for (int i = 0; i < DEV_W; ++i) {
     47             uint16_t control = controlData[i + j * DEV_H];
     48             uint32_t test = readBuffer[i + j * DEV_H];
     49 
     50             // Test alpha component
     51             uint8_t ctrlComp = expand_value(control & 0xF, 4);
     52             uint8_t testComp = GrColorUnpackA(test);
     53             check_component(reporter, ctrlComp, testComp);
     54 
     55             // Test blue component
     56             ctrlComp = expand_value((control >> 4) & 0xF, 4);
     57             testComp = GrColorUnpackB(test);
     58             check_component(reporter, ctrlComp, testComp);
     59 
     60             // Test green component
     61             ctrlComp = expand_value((control >> 8) & 0xF, 4);
     62             testComp = GrColorUnpackG(test);
     63             check_component(reporter, ctrlComp, testComp);
     64 
     65             // Test red component
     66             ctrlComp = expand_value((control >> 12) & 0xF, 4);
     67             testComp = GrColorUnpackR(test);
     68             check_component(reporter, ctrlComp, testComp);
     69         }
     70     }
     71 }
     72 
     73 static void check_565(skiatest::Reporter* reporter,
     74                       const SkTDArray<uint16_t>& controlData,
     75                       const SkTDArray<GrColor>& readBuffer) {
     76     for (int j = 0; j < DEV_H; ++j) {
     77         for (int i = 0; i < DEV_W; ++i) {
     78             uint16_t control = controlData[i + j * DEV_H];
     79             GrColor test = readBuffer[i + j * DEV_H];
     80             // Test blue component (5 bit control)
     81             uint8_t ctrlComp = expand_value(control & 0x1F, 5);
     82             uint8_t testComp = GrColorUnpackB(test);
     83             check_component(reporter, ctrlComp, testComp);
     84 
     85             // Test green component (6 bit control)
     86             ctrlComp = expand_value((control >> 5) & 0x3F, 6);
     87             testComp = GrColorUnpackG(test);
     88             check_component(reporter, ctrlComp, testComp);
     89 
     90             // Test red component (5 bit control)
     91             ctrlComp = expand_value((control >> 11) & 0x1F, 5);
     92             testComp = GrColorUnpackR(test);
     93             check_component(reporter, ctrlComp, testComp);
     94         }
     95     }
     96 }
     97 
     98 static void run_test(skiatest::Reporter* reporter, GrContext* context, int arraySize,
     99                      SkColorType colorType) {
    100     SkTDArray<uint16_t> controlPixelData;
    101     // We will read back into an 8888 buffer since 565/4444 read backs aren't supported
    102     SkTDArray<GrColor> readBuffer;
    103     controlPixelData.setCount(arraySize);
    104     readBuffer.setCount(arraySize);
    105 
    106     for (int i = 0; i < arraySize; i += 2) {
    107         controlPixelData[i] = 0xF00F;
    108         controlPixelData[i + 1] = 0xA62F;
    109     }
    110 
    111     const SkImageInfo dstInfo =
    112             SkImageInfo::Make(DEV_W, DEV_H, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
    113 
    114     for (auto origin : { kTopLeft_GrSurfaceOrigin, kBottomLeft_GrSurfaceOrigin }) {
    115         auto proxy = sk_gpu_test::MakeTextureProxyFromData(context, false, DEV_W, DEV_H,
    116                                                            colorType,
    117                                                            origin, controlPixelData.begin(), 0);
    118         SkASSERT(proxy);
    119 
    120         sk_sp<GrSurfaceContext> sContext = context->contextPriv().makeWrappedSurfaceContext(
    121                                                                         std::move(proxy));
    122 
    123         if (!sContext->readPixels(dstInfo, readBuffer.begin(), 0, 0, 0)) {
    124             // We only require this to succeed if the format is renderable.
    125             REPORTER_ASSERT(reporter, !context->colorTypeSupportedAsSurface(colorType));
    126             return;
    127         }
    128 
    129         if (kARGB_4444_SkColorType == colorType) {
    130             check_4444(reporter, controlPixelData, readBuffer);
    131         } else {
    132             SkASSERT(kRGB_565_SkColorType == colorType);
    133             check_565(reporter, controlPixelData, readBuffer);
    134         }
    135     }
    136 }
    137 
    138 static const int CONTROL_ARRAY_SIZE = DEV_W * DEV_H;
    139 
    140 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(RGBA4444TextureTest, reporter, ctxInfo) {
    141     run_test(reporter, ctxInfo.grContext(), CONTROL_ARRAY_SIZE, kARGB_4444_SkColorType);
    142 }
    143 
    144 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(RGB565TextureTest, reporter, ctxInfo) {
    145     run_test(reporter, ctxInfo.grContext(), CONTROL_ARRAY_SIZE, kRGB_565_SkColorType);
    146 }
    147