TestUtils.cpp revision f4cf5d3b019fa60e96219578a4c6ad1a90c7b665 
1/*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "TestUtils.h"
18
19#include "DeferredLayerUpdater.h"
20#include "LayerRenderer.h"
21
22#include <utils/Unicode.h>
23
24#include <unistd.h>
25#include <signal.h>
26
27namespace android {
28namespace uirenderer {
29
30SkColor TestUtils::interpolateColor(float fraction, SkColor start, SkColor end) {
31    int startA = (start >> 24) & 0xff;
32    int startR = (start >> 16) & 0xff;
33    int startG = (start >> 8) & 0xff;
34    int startB = start & 0xff;
35
36    int endA = (end >> 24) & 0xff;
37    int endR = (end >> 16) & 0xff;
38    int endG = (end >> 8) & 0xff;
39    int endB = end & 0xff;
40
41    return (int)((startA + (int)(fraction * (endA - startA))) << 24)
42            | (int)((startR + (int)(fraction * (endR - startR))) << 16)
43            | (int)((startG + (int)(fraction * (endG - startG))) << 8)
44            | (int)((startB + (int)(fraction * (endB - startB))));
45}
46
47sp<DeferredLayerUpdater> TestUtils::createTextureLayerUpdater(
48        renderthread::RenderThread& renderThread, uint32_t width, uint32_t height,
49        std::function<void(Matrix4*)> transformSetupCallback) {
50    bool isOpaque = true;
51    bool forceFilter = true;
52    GLenum renderTarget = GL_TEXTURE_EXTERNAL_OES;
53
54    Layer* layer = LayerRenderer::createTextureLayer(renderThread.renderState());
55    LayerRenderer::updateTextureLayer(layer, width, height, isOpaque, forceFilter,
56            renderTarget, Matrix4::identity().data);
57    transformSetupCallback(&(layer->getTransform()));
58
59    sp<DeferredLayerUpdater> layerUpdater = new DeferredLayerUpdater(layer);
60    return layerUpdater;
61}
62
63void TestUtils::layoutTextUnscaled(const SkPaint& paint, const char* text,
64        std::vector<glyph_t>* outGlyphs, std::vector<float>* outPositions,
65        float* outTotalAdvance, Rect* outBounds) {
66    Rect bounds;
67    float totalAdvance = 0;
68    SkSurfaceProps surfaceProps(0, kUnknown_SkPixelGeometry);
69    SkAutoGlyphCacheNoGamma autoCache(paint, &surfaceProps, &SkMatrix::I());
70    while (*text != '\0') {
71        size_t nextIndex = 0;
72        int32_t unichar = utf32_from_utf8_at(text, 4, 0, &nextIndex);
73        text += nextIndex;
74
75        glyph_t glyph = autoCache.getCache()->unicharToGlyph(unichar);
76        autoCache.getCache()->unicharToGlyph(unichar);
77
78        // push glyph and its relative position
79        outGlyphs->push_back(glyph);
80        outPositions->push_back(totalAdvance);
81        outPositions->push_back(0);
82
83        // compute bounds
84        SkGlyph skGlyph = autoCache.getCache()->getUnicharMetrics(unichar);
85        Rect glyphBounds(skGlyph.fWidth, skGlyph.fHeight);
86        glyphBounds.translate(totalAdvance + skGlyph.fLeft, skGlyph.fTop);
87        bounds.unionWith(glyphBounds);
88
89        // advance next character
90        SkScalar skWidth;
91        paint.getTextWidths(&glyph, sizeof(glyph), &skWidth, NULL);
92        totalAdvance += skWidth;
93    }
94    *outBounds = bounds;
95    *outTotalAdvance = totalAdvance;
96}
97
98void TestUtils::drawTextToCanvas(TestCanvas* canvas, const char* text,
99        const SkPaint& paint, float x, float y) {
100    // drawing text requires GlyphID TextEncoding (which JNI layer would have done)
101    LOG_ALWAYS_FATAL_IF(paint.getTextEncoding() != SkPaint::kGlyphID_TextEncoding,
102            "must use glyph encoding");
103    SkSurfaceProps surfaceProps(0, kUnknown_SkPixelGeometry);
104    SkAutoGlyphCacheNoGamma autoCache(paint, &surfaceProps, &SkMatrix::I());
105
106    std::vector<glyph_t> glyphs;
107    std::vector<float> positions;
108    float totalAdvance;
109    Rect bounds;
110    layoutTextUnscaled(paint, text, &glyphs, &positions, &totalAdvance, &bounds);
111
112    // apply alignment via x parameter (which JNI layer would have done)
113    if (paint.getTextAlign() == SkPaint::kCenter_Align) {
114        x -= totalAdvance / 2;
115    } else if (paint.getTextAlign() == SkPaint::kRight_Align) {
116        x -= totalAdvance;
117    }
118
119    bounds.translate(x, y);
120
121    // Force left alignment, since alignment offset is already baked in
122    SkPaint alignPaintCopy(paint);
123    alignPaintCopy.setTextAlign(SkPaint::kLeft_Align);
124    canvas->drawText(glyphs.data(), positions.data(), glyphs.size(), alignPaintCopy, x, y,
125                bounds.left, bounds.top, bounds.right, bounds.bottom, totalAdvance);
126}
127
128void TestUtils::drawTextToCanvas(TestCanvas* canvas, const char* text,
129        const SkPaint& paint, const SkPath& path) {
130    // drawing text requires GlyphID TextEncoding (which JNI layer would have done)
131    LOG_ALWAYS_FATAL_IF(paint.getTextEncoding() != SkPaint::kGlyphID_TextEncoding,
132            "must use glyph encoding");
133    SkSurfaceProps surfaceProps(0, kUnknown_SkPixelGeometry);
134    SkAutoGlyphCacheNoGamma autoCache(paint, &surfaceProps, &SkMatrix::I());
135
136    std::vector<glyph_t> glyphs;
137    while (*text != '\0') {
138        size_t nextIndex = 0;
139        int32_t unichar = utf32_from_utf8_at(text, 4, 0, &nextIndex);
140        text += nextIndex;
141
142        glyphs.push_back(autoCache.getCache()->unicharToGlyph(unichar));
143    }
144    canvas->drawTextOnPath(glyphs.data(), glyphs.size(), path, 0, 0, paint);
145}
146
147static void defaultCrashHandler() {
148    fprintf(stderr, "RenderThread crashed!");
149}
150
151static std::function<void()> gCrashHandler = defaultCrashHandler;
152static sighandler_t gPreviousSignalHandler;
153
154static void signalHandler(int sig) {
155    gCrashHandler();
156    if (gPreviousSignalHandler) {
157        gPreviousSignalHandler(sig);
158    }
159}
160
161void TestUtils::setRenderThreadCrashHandler(std::function<void()> crashHandler) {
162    gCrashHandler = crashHandler;
163}
164
165void TestUtils::TestTask::run() {
166    gPreviousSignalHandler = signal(SIGABRT, signalHandler);
167
168    // RenderState only valid once RenderThread is running, so queried here
169    RenderState& renderState = renderthread::RenderThread::getInstance().renderState();
170
171    renderState.onGLContextCreated();
172    rtCallback(renderthread::RenderThread::getInstance());
173    renderState.flush(Caches::FlushMode::Full);
174    renderState.onGLContextDestroyed();
175
176    // Restore the previous signal handler
177    signal(SIGABRT, gPreviousSignalHandler);
178}
179
180} /* namespace uirenderer */
181} /* namespace android */
182