1/*
2 * Copyright 2012 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// This test is specific to the GPU backend.
9#if SK_SUPPORT_GPU && !defined(SK_BUILD_FOR_ANDROID)
10
11#include "GrContextFactory.h"
12#include "SkGpuDevice.h"
13#include "Test.h"
14
15static const int X_SIZE = 12;
16static const int Y_SIZE = 12;
17
18DEF_GPUTEST(ReadWriteAlpha, reporter, factory) {
19    for (int type = 0; type < GrContextFactory::kLastGLContextType; ++type) {
20        GrContextFactory::GLContextType glType = static_cast<GrContextFactory::GLContextType>(type);
21        if (!GrContextFactory::IsRenderingGLContext(glType)) {
22            continue;
23        }
24        GrContext* context = factory->get(glType);
25        if (NULL == context) {
26            continue;
27        }
28
29        unsigned char textureData[X_SIZE][Y_SIZE];
30
31        memset(textureData, 0, X_SIZE * Y_SIZE);
32
33        GrTextureDesc desc;
34
35        // let Skia know we will be using this texture as a render target
36        desc.fFlags     = kRenderTarget_GrTextureFlagBit;
37        // it is a single channel texture
38        desc.fConfig    = kAlpha_8_GrPixelConfig;
39        desc.fWidth     = X_SIZE;
40        desc.fHeight    = Y_SIZE;
41
42        // We are initializing the texture with zeros here
43        GrTexture* texture = context->createUncachedTexture(desc, textureData, 0);
44        if (!texture) {
45            return;
46        }
47
48        SkAutoTUnref<GrTexture> au(texture);
49
50        // create a distinctive texture
51        for (int y = 0; y < Y_SIZE; ++y) {
52            for (int x = 0; x < X_SIZE; ++x) {
53                textureData[x][y] = x*Y_SIZE+y;
54            }
55        }
56
57        // upload the texture
58        texture->writePixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
59                             textureData, 0);
60
61        unsigned char readback[X_SIZE][Y_SIZE];
62
63        // clear readback to something non-zero so we can detect readback failures
64        memset(readback, 0x1, X_SIZE * Y_SIZE);
65
66        // read the texture back
67        texture->readPixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
68                            readback, 0);
69
70        // make sure the original & read back versions match
71        bool match = true;
72
73        for (int y = 0; y < Y_SIZE; ++y) {
74            for (int x = 0; x < X_SIZE; ++x) {
75                if (textureData[x][y] != readback[x][y]) {
76                    match = false;
77                }
78            }
79        }
80
81        REPORTER_ASSERT(reporter, match);
82
83        // Now try writing on the single channel texture
84        SkAutoTUnref<SkBaseDevice> device(SkGpuDevice::Create(texture->asRenderTarget(),
85                                      SkSurfaceProps(SkSurfaceProps::kLegacyFontHost_InitType)));
86        SkCanvas canvas(device);
87
88        SkPaint paint;
89
90        const SkRect rect = SkRect::MakeLTRB(-10, -10, X_SIZE + 10, Y_SIZE + 10);
91
92        paint.setColor(SK_ColorWHITE);
93
94        canvas.drawRect(rect, paint);
95
96        texture->readPixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
97                            readback, 0);
98
99        match = true;
100
101        for (int y = 0; y < Y_SIZE; ++y) {
102            for (int x = 0; x < X_SIZE; ++x) {
103                if (0xFF != readback[x][y]) {
104                    match = false;
105                }
106            }
107        }
108
109        REPORTER_ASSERT(reporter, match);
110    }
111}
112
113#endif
114