SkiaCanvasProxy.cpp revision fc9999505a36c66892d7ccce85187936105f4f36 
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 "SkiaCanvasProxy.h"
18
19#include "hwui/Bitmap.h"
20
21#include <cutils/log.h>
22#include <SkPatchUtils.h>
23#include <SkPaint.h>
24#include <SkPath.h>
25#include <SkPixelRef.h>
26#include <SkRect.h>
27#include <SkRRect.h>
28#include <SkRSXform.h>
29#include <SkSurface.h>
30
31#include <memory>
32
33namespace android {
34namespace uirenderer {
35
36SkiaCanvasProxy::SkiaCanvasProxy(Canvas* canvas, bool filterHwuiCalls)
37        : INHERITED(canvas->width(), canvas->height())
38        , mCanvas(canvas)
39        , mFilterHwuiCalls(filterHwuiCalls) {}
40
41void SkiaCanvasProxy::onDrawPaint(const SkPaint& paint) {
42    mCanvas->drawPaint(paint);
43}
44
45void SkiaCanvasProxy::onDrawPoints(PointMode pointMode, size_t count, const SkPoint pts[],
46        const SkPaint& paint) {
47    if (!pts || count == 0) {
48        return;
49    }
50
51    // convert the SkPoints into floats
52    static_assert(sizeof(SkPoint) == sizeof(float)*2, "SkPoint is no longer two floats");
53    const size_t floatCount = count << 1;
54    const float* floatArray = &pts[0].fX;
55
56    switch (pointMode) {
57        case kPoints_PointMode: {
58            mCanvas->drawPoints(floatArray, floatCount, paint);
59            break;
60        }
61        case kLines_PointMode: {
62            mCanvas->drawLines(floatArray, floatCount, paint);
63            break;
64        }
65        case kPolygon_PointMode: {
66            SkPaint strokedPaint(paint);
67            strokedPaint.setStyle(SkPaint::kStroke_Style);
68
69            SkPath path;
70            for (size_t i = 0; i < count - 1; i++) {
71                path.moveTo(pts[i]);
72                path.lineTo(pts[i+1]);
73                this->drawPath(path, strokedPaint);
74                path.rewind();
75            }
76            break;
77        }
78        default:
79            LOG_ALWAYS_FATAL("Unknown point type");
80    }
81}
82
83void SkiaCanvasProxy::onDrawOval(const SkRect& rect, const SkPaint& paint) {
84    mCanvas->drawOval(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, paint);
85}
86
87void SkiaCanvasProxy::onDrawRect(const SkRect& rect, const SkPaint& paint) {
88    mCanvas->drawRect(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, paint);
89}
90
91void SkiaCanvasProxy::onDrawRRect(const SkRRect& roundRect, const SkPaint& paint) {
92    if (!roundRect.isComplex()) {
93        const SkRect& rect = roundRect.rect();
94        SkVector radii = roundRect.getSimpleRadii();
95        mCanvas->drawRoundRect(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom,
96                               radii.fX, radii.fY, paint);
97    } else {
98        SkPath path;
99        path.addRRect(roundRect);
100        mCanvas->drawPath(path, paint);
101    }
102}
103
104void SkiaCanvasProxy::onDrawPath(const SkPath& path, const SkPaint& paint) {
105    mCanvas->drawPath(path, paint);
106}
107
108void SkiaCanvasProxy::onDrawBitmap(const SkBitmap& bitmap, SkScalar left, SkScalar top,
109        const SkPaint* paint) {
110    sk_sp<Bitmap> hwuiBitmap = Bitmap::createFrom(bitmap.info(), *bitmap.pixelRef());
111    // HWUI doesn't support extractSubset(), so convert any subsetted bitmap into
112    // a drawBitmapRect(); pass through an un-subsetted bitmap.
113    if (hwuiBitmap && bitmap.dimensions() != hwuiBitmap->info().dimensions()) {
114        SkIPoint origin = bitmap.pixelRefOrigin();
115        mCanvas->drawBitmap(*hwuiBitmap, origin.fX, origin.fY,
116                            origin.fX + bitmap.dimensions().width(),
117                            origin.fY + bitmap.dimensions().height(),
118                            left, top,
119                            left + bitmap.dimensions().width(),
120                            top + bitmap.dimensions().height(),
121                            paint);
122    } else {
123        mCanvas->drawBitmap(*hwuiBitmap, left, top, paint);
124    }
125}
126
127void SkiaCanvasProxy::onDrawBitmapRect(const SkBitmap& skBitmap, const SkRect* srcPtr,
128        const SkRect& dst, const SkPaint* paint, SrcRectConstraint) {
129    SkRect src = (srcPtr) ? *srcPtr : SkRect::MakeWH(skBitmap.width(), skBitmap.height());
130    // TODO: if bitmap is a subset, do we need to add pixelRefOrigin to src?
131   Bitmap* bitmap = reinterpret_cast<Bitmap*>(skBitmap.pixelRef());
132   mCanvas->drawBitmap(*bitmap, src.fLeft, src.fTop, src.fRight, src.fBottom,
133                        dst.fLeft, dst.fTop, dst.fRight, dst.fBottom, paint);
134}
135
136void SkiaCanvasProxy::onDrawBitmapNine(const SkBitmap& bitmap, const SkIRect& center,
137        const SkRect& dst, const SkPaint*) {
138    //TODO make nine-patch drawing a method on Canvas.h
139    SkDEBUGFAIL("SkiaCanvasProxy::onDrawBitmapNine is not yet supported");
140}
141
142void SkiaCanvasProxy::onDrawVertices(VertexMode mode, int vertexCount, const SkPoint vertices[],
143        const SkPoint texs[], const SkColor colors[], SkXfermode*, const uint16_t indices[],
144        int indexCount, const SkPaint& paint) {
145    if (mFilterHwuiCalls) {
146        return;
147    }
148    // convert the SkPoints into floats
149    static_assert(sizeof(SkPoint) == sizeof(float)*2, "SkPoint is no longer two floats");
150    const int floatCount = vertexCount << 1;
151    const float* vArray = &vertices[0].fX;
152    const float* tArray = (texs) ? &texs[0].fX : NULL;
153    const int* cArray = (colors) ? (int*)colors : NULL;
154    mCanvas->drawVertices(mode, floatCount, vArray, tArray, cArray, indices, indexCount, paint);
155}
156
157sk_sp<SkSurface> SkiaCanvasProxy::onNewSurface(const SkImageInfo&, const SkSurfaceProps&) {
158    SkDEBUGFAIL("SkiaCanvasProxy::onNewSurface is not supported");
159    return NULL;
160}
161
162void SkiaCanvasProxy::willSave() {
163    mCanvas->save(android::SaveFlags::MatrixClip);
164}
165
166static inline SaveFlags::Flags saveFlags(SkCanvas::SaveLayerFlags layerFlags) {
167    SaveFlags::Flags saveFlags = 0;
168
169    if (!(layerFlags & SkCanvas::kDontClipToLayer_Legacy_SaveLayerFlag)) {
170        saveFlags |= SaveFlags::ClipToLayer;
171    }
172
173    if (!(layerFlags & SkCanvas::kIsOpaque_SaveLayerFlag)) {
174        saveFlags |= SaveFlags::HasAlphaLayer;
175    }
176
177    return saveFlags;
178}
179
180SkCanvas::SaveLayerStrategy SkiaCanvasProxy::getSaveLayerStrategy(const SaveLayerRec& saveLayerRec) {
181    SkRect rect;
182    if (saveLayerRec.fBounds) {
183        rect = *saveLayerRec.fBounds;
184    } else if (!mCanvas->getClipBounds(&rect)) {
185        rect = SkRect::MakeEmpty();
186    }
187    mCanvas->saveLayer(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, saveLayerRec.fPaint,
188                       saveFlags(saveLayerRec.fSaveLayerFlags));
189    return SkCanvas::kNoLayer_SaveLayerStrategy;
190}
191
192void SkiaCanvasProxy::willRestore() {
193    mCanvas->restore();
194}
195
196void SkiaCanvasProxy::didConcat(const SkMatrix& matrix) {
197    mCanvas->concat(matrix);
198}
199
200void SkiaCanvasProxy::didSetMatrix(const SkMatrix& matrix) {
201    mCanvas->setMatrix(matrix);
202}
203
204void SkiaCanvasProxy::onDrawDRRect(const SkRRect& outer, const SkRRect& inner,
205        const SkPaint& paint) {
206    SkPath path;
207    path.addRRect(outer);
208    path.addRRect(inner);
209    path.setFillType(SkPath::kEvenOdd_FillType);
210    this->drawPath(path, paint);
211}
212
213/**
214 * Utility class that converts the incoming text & paint from the given encoding
215 * into glyphIDs.
216 */
217class GlyphIDConverter {
218public:
219    GlyphIDConverter(const void* text, size_t byteLength, const SkPaint& origPaint) {
220        paint = origPaint;
221        if (paint.getTextEncoding() == SkPaint::kGlyphID_TextEncoding) {
222            glyphIDs = (uint16_t*)text;
223            count = byteLength >> 1;
224        } else {
225             // ensure space for one glyph per ID given UTF8 encoding.
226            storage.reset(new uint16_t[byteLength]);
227            glyphIDs = storage.get();
228            count = paint.textToGlyphs(text, byteLength, storage.get());
229            paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
230        }
231    }
232
233    SkPaint paint;
234    uint16_t* glyphIDs;
235    int count;
236private:
237    std::unique_ptr<uint16_t[]> storage;
238};
239
240void SkiaCanvasProxy::onDrawText(const void* text, size_t byteLength, SkScalar x, SkScalar y,
241        const SkPaint& origPaint) {
242    // convert to glyphIDs if necessary
243    GlyphIDConverter glyphs(text, byteLength, origPaint);
244
245    // compute the glyph positions
246    std::unique_ptr<SkPoint[]> pointStorage(new SkPoint[glyphs.count]);
247    std::unique_ptr<SkScalar[]> glyphWidths(new SkScalar[glyphs.count]);
248    glyphs.paint.getTextWidths(glyphs.glyphIDs, glyphs.count << 1, glyphWidths.get());
249
250    // compute conservative bounds
251    // NOTE: We could call the faster paint.getFontBounds for a less accurate,
252    //       but even more conservative bounds if this  is too slow.
253    SkRect bounds;
254    glyphs.paint.measureText(glyphs.glyphIDs, glyphs.count << 1, &bounds);
255
256    // adjust for non-left alignment
257    if (glyphs.paint.getTextAlign() != SkPaint::kLeft_Align) {
258        SkScalar stop = 0;
259        for (int i = 0; i < glyphs.count; i++) {
260            stop += glyphWidths[i];
261        }
262        if (glyphs.paint.getTextAlign() == SkPaint::kCenter_Align) {
263            stop = SkScalarHalf(stop);
264        }
265        if (glyphs.paint.isVerticalText()) {
266            y -= stop;
267        } else {
268            x -= stop;
269        }
270    }
271
272    // setup the first glyph position and adjust bounds if needed
273    int xBaseline = 0;
274    int yBaseline = 0;
275    if (mCanvas->drawTextAbsolutePos()) {
276        bounds.offset(x,y);
277        xBaseline = x;
278        yBaseline = y;
279    }
280    pointStorage[0].set(xBaseline, yBaseline);
281
282    // setup the remaining glyph positions
283    if (glyphs.paint.isVerticalText()) {
284        for (int i = 1; i < glyphs.count; i++) {
285            pointStorage[i].set(xBaseline, glyphWidths[i-1] + pointStorage[i-1].fY);
286        }
287    } else {
288        for (int i = 1; i < glyphs.count; i++) {
289            pointStorage[i].set(glyphWidths[i-1] + pointStorage[i-1].fX, yBaseline);
290        }
291    }
292
293    static_assert(sizeof(SkPoint) == sizeof(float)*2, "SkPoint is no longer two floats");
294    mCanvas->drawGlyphs(glyphs.glyphIDs, &pointStorage[0].fX, glyphs.count, glyphs.paint,
295                      x, y, bounds.fLeft, bounds.fTop, bounds.fRight, bounds.fBottom, 0);
296}
297
298void SkiaCanvasProxy::onDrawPosText(const void* text, size_t byteLength, const SkPoint pos[],
299        const SkPaint& origPaint) {
300    // convert to glyphIDs if necessary
301    GlyphIDConverter glyphs(text, byteLength, origPaint);
302
303    // convert to relative positions if necessary
304    int x, y;
305    const SkPoint* posArray;
306    std::unique_ptr<SkPoint[]> pointStorage;
307    if (mCanvas->drawTextAbsolutePos()) {
308        x = 0;
309        y = 0;
310        posArray = pos;
311    } else {
312        x = pos[0].fX;
313        y = pos[0].fY;
314        pointStorage.reset(new SkPoint[glyphs.count]);
315        for (int i = 0; i < glyphs.count; i++) {
316            pointStorage[i].fX = pos[i].fX - x;
317            pointStorage[i].fY = pos[i].fY - y;
318        }
319        posArray = pointStorage.get();
320    }
321
322    // Compute conservative bounds.  If the content has already been processed
323    // by Minikin then it had already computed these bounds.  Unfortunately,
324    // there is no way to capture those bounds as part of the Skia drawPosText
325    // API so we need to do that computation again here.
326    SkRect bounds = SkRect::MakeEmpty();
327    for (int i = 0; i < glyphs.count; i++) {
328        SkRect glyphBounds = SkRect::MakeEmpty();
329        glyphs.paint.measureText(&glyphs.glyphIDs[i], sizeof(uint16_t), &glyphBounds);
330        glyphBounds.offset(pos[i].fX, pos[i].fY);
331        bounds.join(glyphBounds);
332    }
333
334    static_assert(sizeof(SkPoint) == sizeof(float)*2, "SkPoint is no longer two floats");
335    mCanvas->drawGlyphs(glyphs.glyphIDs, &posArray[0].fX, glyphs.count, glyphs.paint, x, y,
336                      bounds.fLeft, bounds.fTop, bounds.fRight, bounds.fBottom, 0);
337}
338
339void SkiaCanvasProxy::onDrawPosTextH(const void* text, size_t byteLength, const SkScalar xpos[],
340        SkScalar constY, const SkPaint& paint) {
341    const size_t pointCount = byteLength >> 1;
342    std::unique_ptr<SkPoint[]> pts(new SkPoint[pointCount]);
343    for (size_t i = 0; i < pointCount; i++) {
344        pts[i].set(xpos[i], constY);
345    }
346    this->onDrawPosText(text, byteLength, pts.get(), paint);
347}
348
349void SkiaCanvasProxy::onDrawTextOnPath(const void* text, size_t byteLength, const SkPath& path,
350        const SkMatrix* matrix, const SkPaint& origPaint) {
351    SkDEBUGFAIL("SkiaCanvasProxy::onDrawTextOnPath is not supported");
352}
353
354void SkiaCanvasProxy::onDrawTextRSXform(const void* text, size_t byteLength,
355        const SkRSXform xform[], const SkRect* cullRect, const SkPaint& paint) {
356    GlyphIDConverter glyphs(text, byteLength, paint); // Just get count
357    SkMatrix localM, currM, origM;
358    mCanvas->getMatrix(&currM);
359    origM = currM;
360    for (int i = 0; i < glyphs.count; i++) {
361        localM.setRSXform(*xform++);
362        currM.setConcat(origM, localM);
363        mCanvas->setMatrix(currM);
364        this->onDrawText((char*)text + (byteLength / glyphs.count * i),
365                         byteLength / glyphs.count, 0, 0, paint);
366    }
367    mCanvas->setMatrix(origM);
368}
369
370
371void SkiaCanvasProxy::onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
372        const SkPaint& paint) {
373    SkDEBUGFAIL("SkiaCanvasProxy::onDrawTextBlob is not supported");
374}
375
376void SkiaCanvasProxy::onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
377        const SkPoint texCoords[4], SkXfermode* xmode, const SkPaint& paint) {
378    if (mFilterHwuiCalls) {
379        return;
380    }
381    SkPatchUtils::VertexData data;
382
383    SkMatrix matrix;
384    mCanvas->getMatrix(&matrix);
385    SkISize lod = SkPatchUtils::GetLevelOfDetail(cubics, &matrix);
386
387    // It automatically adjusts lodX and lodY in case it exceeds the number of indices.
388    // If it fails to generate the vertices, then we do not draw.
389    if (SkPatchUtils::getVertexData(&data, cubics, colors, texCoords, lod.width(), lod.height())) {
390        this->drawVertices(SkCanvas::kTriangles_VertexMode, data.fVertexCount, data.fPoints,
391                           data.fTexCoords, data.fColors, xmode, data.fIndices, data.fIndexCount,
392                           paint);
393    }
394}
395
396void SkiaCanvasProxy::onClipRect(const SkRect& rect, SkRegion::Op op, ClipEdgeStyle) {
397    mCanvas->clipRect(rect.fLeft, rect.fTop, rect.fRight, rect.fBottom, op);
398}
399
400void SkiaCanvasProxy::onClipRRect(const SkRRect& roundRect, SkRegion::Op op, ClipEdgeStyle) {
401    SkPath path;
402    path.addRRect(roundRect);
403    mCanvas->clipPath(&path, op);
404}
405
406void SkiaCanvasProxy::onClipPath(const SkPath& path, SkRegion::Op op, ClipEdgeStyle) {
407    mCanvas->clipPath(&path, op);
408}
409
410void SkiaCanvasProxy::onClipRegion(const SkRegion& region, SkRegion::Op op) {
411    mCanvas->clipRegion(&region, op);
412}
413
414}; // namespace uirenderer
415}; // namespace android
416