1
2/*
3 * Copyright 2012 Google Inc.
4 *
5 * Use of this source code is governed by a BSD-style license that can be
6 * found in the LICENSE file.
7 */
8
9#if SK_SUPPORT_GPU
10
11#include "GrContext.h"
12#include "GrContextFactory.h"
13#include "SkBitmap.h"
14#include "SkCanvas.h"
15#include "SkColor.h"
16#include "SkGpuDevice.h"
17#include "SkPaint.h"
18#include "SkPixelRef.h"
19#include "SkRect.h"
20#include "Test.h"
21
22static const char* boolStr(bool value) {
23    return value ? "true" : "false";
24}
25
26// these are in the same order as the SkBitmap::Config enum
27static const char* gConfigName[] = {
28    "None", "8888"
29};
30
31struct Pair {
32    SkBitmap::Config    fConfig;
33    const char*         fValid;
34};
35
36/**
37 *  Check to ensure that copying a GPU-backed SkBitmap behaved as expected.
38 *  @param reporter Used to report failures.
39 *  @param desiredConfig Config being copied to. If the copy succeeded, dst must have this Config.
40 *  @param success True if the copy succeeded.
41 *  @param src A GPU-backed SkBitmap that had copyTo or deepCopyTo called on it.
42 *  @param dst SkBitmap that was copied to.
43 *  @param deepCopy True if deepCopyTo was used; false if copyTo was used.
44 */
45static void TestIndividualCopy(skiatest::Reporter* reporter, const SkBitmap::Config desiredConfig,
46                               const bool success, const SkBitmap& src, const SkBitmap& dst,
47                               const bool deepCopy = true) {
48    if (success) {
49        REPORTER_ASSERT(reporter, src.width() == dst.width());
50        REPORTER_ASSERT(reporter, src.height() == dst.height());
51        REPORTER_ASSERT(reporter, dst.config() == desiredConfig);
52        if (src.config() == dst.config()) {
53            // FIXME: When calling copyTo (so deepCopy is false here), sometimes we copy the pixels
54            // exactly, in which case the IDs should be the same, but sometimes we do a bitmap draw,
55            // in which case the IDs should not be the same. Is there any way to determine which is
56            // the case at this point?
57            if (deepCopy) {
58                REPORTER_ASSERT(reporter, src.getGenerationID() == dst.getGenerationID());
59            }
60            REPORTER_ASSERT(reporter, src.pixelRef() != NULL && dst.pixelRef() != NULL);
61
62            // Do read backs and make sure that the two are the same.
63            SkBitmap srcReadBack, dstReadBack;
64            {
65                SkASSERT(src.getTexture() != NULL);
66                bool readBack = src.pixelRef()->readPixels(&srcReadBack);
67                REPORTER_ASSERT(reporter, readBack);
68            }
69            if (dst.getTexture() != NULL) {
70                bool readBack = dst.pixelRef()->readPixels(&dstReadBack);
71                REPORTER_ASSERT(reporter, readBack);
72            } else {
73                // If dst is not a texture, do a copy instead, to the same config as srcReadBack.
74                bool copy = dst.copyTo(&dstReadBack, srcReadBack.config());
75                REPORTER_ASSERT(reporter, copy);
76            }
77
78            SkAutoLockPixels srcLock(srcReadBack);
79            SkAutoLockPixels dstLock(dstReadBack);
80            REPORTER_ASSERT(reporter, srcReadBack.readyToDraw() && dstReadBack.readyToDraw());
81
82            const char* srcP = static_cast<const char*>(srcReadBack.getAddr(0, 0));
83            const char* dstP = static_cast<const char*>(dstReadBack.getAddr(0, 0));
84            REPORTER_ASSERT(reporter, srcP != dstP);
85
86            REPORTER_ASSERT(reporter, !memcmp(srcP, dstP, srcReadBack.getSize()));
87        } else {
88            REPORTER_ASSERT(reporter, src.getGenerationID() != dst.getGenerationID());
89        }
90    } else {
91        // dst should be unchanged from its initial state
92        REPORTER_ASSERT(reporter, dst.config() == SkBitmap::kNo_Config);
93        REPORTER_ASSERT(reporter, dst.width() == 0);
94        REPORTER_ASSERT(reporter, dst.height() == 0);
95    }
96
97}
98
99// Stripped down version of TestBitmapCopy that checks basic fields (width, height, config, genID)
100// to ensure that they were copied properly.
101static void TestGpuBitmapCopy(skiatest::Reporter* reporter, GrContextFactory* factory) {
102#ifdef SK_BUILD_FOR_ANDROID // https://code.google.com/p/skia/issues/detail?id=753
103    return;
104#endif
105    for (int type = 0; type < GrContextFactory::kLastGLContextType; ++type) {
106        GrContextFactory::GLContextType glType = static_cast<GrContextFactory::GLContextType>(type);
107        if (!GrContextFactory::IsRenderingGLContext(glType)) {
108            continue;
109        }
110
111        GrContext* grContext = factory->get(glType);
112        if (NULL == grContext) {
113            continue;
114        }
115
116
117        if (NULL == grContext) {
118            return;
119        }
120        static const Pair gPairs[] = {
121            { SkBitmap::kNo_Config,         "00"  },
122            { SkBitmap::kARGB_8888_Config,  "01"  },
123        };
124
125        const int W = 20;
126        const int H = 33;
127
128        for (size_t i = 0; i < SK_ARRAY_COUNT(gPairs); i++) {
129            SkBitmap src, dst;
130
131            SkGpuDevice* device = SkNEW_ARGS(SkGpuDevice, (grContext, gPairs[i].fConfig, W, H));
132            SkAutoUnref aur(device);
133            src = device->accessBitmap(false);
134            device->clear(SK_ColorWHITE);
135
136            // Draw something different to the same portion of the bitmap that we will extract as a
137            // subset, so that comparing the pixels of the subset will be meaningful.
138            SkIRect subsetRect = SkIRect::MakeLTRB(W/2, H/2, W, H);
139            SkCanvas drawingCanvas(device);
140            SkPaint paint;
141            paint.setColor(SK_ColorRED);
142            drawingCanvas.drawRect(SkRect::Make(subsetRect), paint);
143
144            // Extract a subset. If this succeeds we will test copying the subset.
145            SkBitmap subset;
146            const bool extracted = src.extractSubset(&subset, subsetRect);
147
148            for (size_t j = 0; j < SK_ARRAY_COUNT(gPairs); j++) {
149                dst.reset();
150                bool success = src.deepCopyTo(&dst, gPairs[j].fConfig);
151                bool expected = gPairs[i].fValid[j] != '0';
152                if (success != expected) {
153                    SkString str;
154                    str.printf("SkBitmap::deepCopyTo from %s to %s. expected %s returned %s",
155                               gConfigName[i], gConfigName[j], boolStr(expected),
156                               boolStr(success));
157                    reporter->reportFailed(str);
158                }
159
160                bool canSucceed = src.canCopyTo(gPairs[j].fConfig);
161                if (success != canSucceed) {
162                    SkString str;
163                    str.printf("SkBitmap::deepCopyTo from %s to %s returned %s,"
164                               "but canCopyTo returned %s",
165                               gConfigName[i], gConfigName[j], boolStr(success),
166                               boolStr(canSucceed));
167                    reporter->reportFailed(str);
168                }
169
170                TestIndividualCopy(reporter, gPairs[j].fConfig, success, src, dst);
171
172                // Test copying the subset bitmap, using both copyTo and deepCopyTo.
173                if (extracted) {
174                    SkBitmap subsetCopy;
175                    success = subset.copyTo(&subsetCopy, gPairs[j].fConfig);
176                    REPORTER_ASSERT(reporter, success == expected);
177                    REPORTER_ASSERT(reporter, success == canSucceed);
178                    TestIndividualCopy(reporter, gPairs[j].fConfig, success, subset, subsetCopy,
179                                       false);
180
181                    // Reset the bitmap so that a failed copyTo will leave it in the expected state.
182                    subsetCopy.reset();
183                    success = subset.deepCopyTo(&subsetCopy, gPairs[j].fConfig);
184                    REPORTER_ASSERT(reporter, success == expected);
185                    REPORTER_ASSERT(reporter, success == canSucceed);
186                    TestIndividualCopy(reporter, gPairs[j].fConfig, success, subset, subsetCopy,
187                                       true);
188                }
189            } // for (size_t j = ...
190        } // for (size_t i = ...
191    } // GrContextFactory::GLContextType
192}
193
194#include "TestClassDef.h"
195DEFINE_GPUTESTCLASS("GpuBitmapCopy", TestGpuBitmapCopyClass, TestGpuBitmapCopy)
196
197#endif
198