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