1 // Copyright 2014 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "skia/ext/pixel_ref_utils.h" 6 7 #include <algorithm> 8 9 #include "third_party/skia/include/core/SkBitmapDevice.h" 10 #include "third_party/skia/include/core/SkCanvas.h" 11 #include "third_party/skia/include/core/SkData.h" 12 #include "third_party/skia/include/core/SkDraw.h" 13 #include "third_party/skia/include/core/SkPixelRef.h" 14 #include "third_party/skia/include/core/SkRRect.h" 15 #include "third_party/skia/include/core/SkRect.h" 16 #include "third_party/skia/include/core/SkShader.h" 17 #include "third_party/skia/include/utils/SkNoSaveLayerCanvas.h" 18 #include "third_party/skia/src/core/SkRasterClip.h" 19 20 namespace skia { 21 22 namespace { 23 24 // URI label for a discardable SkPixelRef. 25 const char kLabelDiscardable[] = "discardable"; 26 27 class DiscardablePixelRefSet { 28 public: 29 DiscardablePixelRefSet( 30 std::vector<PixelRefUtils::PositionPixelRef>* pixel_refs) 31 : pixel_refs_(pixel_refs) {} 32 33 void Add(SkPixelRef* pixel_ref, const SkRect& rect) { 34 // Only save discardable pixel refs. 35 if (pixel_ref->getURI() && 36 !strcmp(pixel_ref->getURI(), kLabelDiscardable)) { 37 PixelRefUtils::PositionPixelRef position_pixel_ref; 38 position_pixel_ref.pixel_ref = pixel_ref; 39 position_pixel_ref.pixel_ref_rect = rect; 40 pixel_refs_->push_back(position_pixel_ref); 41 } 42 } 43 44 private: 45 std::vector<PixelRefUtils::PositionPixelRef>* pixel_refs_; 46 }; 47 48 class GatherPixelRefDevice : public SkBitmapDevice { 49 public: 50 GatherPixelRefDevice(const SkBitmap& bm, 51 DiscardablePixelRefSet* pixel_ref_set) 52 : SkBitmapDevice(bm), pixel_ref_set_(pixel_ref_set) {} 53 54 virtual void clear(SkColor color) SK_OVERRIDE {} 55 virtual void drawPaint(const SkDraw& draw, const SkPaint& paint) SK_OVERRIDE { 56 SkBitmap bitmap; 57 if (GetBitmapFromPaint(paint, &bitmap)) { 58 SkRect clip_rect = SkRect::Make(draw.fRC->getBounds()); 59 AddBitmap(bitmap, clip_rect); 60 } 61 } 62 63 virtual void drawPoints(const SkDraw& draw, 64 SkCanvas::PointMode mode, 65 size_t count, 66 const SkPoint points[], 67 const SkPaint& paint) SK_OVERRIDE { 68 SkBitmap bitmap; 69 if (!GetBitmapFromPaint(paint, &bitmap)) 70 return; 71 72 if (count == 0) 73 return; 74 75 SkPoint min_point = points[0]; 76 SkPoint max_point = points[0]; 77 for (size_t i = 1; i < count; ++i) { 78 const SkPoint& point = points[i]; 79 min_point.set(std::min(min_point.x(), point.x()), 80 std::min(min_point.y(), point.y())); 81 max_point.set(std::max(max_point.x(), point.x()), 82 std::max(max_point.y(), point.y())); 83 } 84 85 SkRect bounds = SkRect::MakeLTRB( 86 min_point.x(), min_point.y(), max_point.x(), max_point.y()); 87 88 GatherPixelRefDevice::drawRect(draw, bounds, paint); 89 } 90 virtual void drawRect(const SkDraw& draw, 91 const SkRect& rect, 92 const SkPaint& paint) SK_OVERRIDE { 93 SkBitmap bitmap; 94 if (GetBitmapFromPaint(paint, &bitmap)) { 95 SkRect mapped_rect; 96 draw.fMatrix->mapRect(&mapped_rect, rect); 97 mapped_rect.intersect(SkRect::Make(draw.fRC->getBounds())); 98 AddBitmap(bitmap, mapped_rect); 99 } 100 } 101 virtual void drawOval(const SkDraw& draw, 102 const SkRect& rect, 103 const SkPaint& paint) SK_OVERRIDE { 104 GatherPixelRefDevice::drawRect(draw, rect, paint); 105 } 106 virtual void drawRRect(const SkDraw& draw, 107 const SkRRect& rect, 108 const SkPaint& paint) SK_OVERRIDE { 109 GatherPixelRefDevice::drawRect(draw, rect.rect(), paint); 110 } 111 virtual void drawPath(const SkDraw& draw, 112 const SkPath& path, 113 const SkPaint& paint, 114 const SkMatrix* pre_path_matrix, 115 bool path_is_mutable) SK_OVERRIDE { 116 SkBitmap bitmap; 117 if (!GetBitmapFromPaint(paint, &bitmap)) 118 return; 119 120 SkRect path_bounds = path.getBounds(); 121 SkRect final_rect; 122 if (pre_path_matrix != NULL) 123 pre_path_matrix->mapRect(&final_rect, path_bounds); 124 else 125 final_rect = path_bounds; 126 127 GatherPixelRefDevice::drawRect(draw, final_rect, paint); 128 } 129 virtual void drawBitmap(const SkDraw& draw, 130 const SkBitmap& bitmap, 131 const SkMatrix& matrix, 132 const SkPaint& paint) SK_OVERRIDE { 133 SkMatrix total_matrix; 134 total_matrix.setConcat(*draw.fMatrix, matrix); 135 136 SkRect bitmap_rect = SkRect::MakeWH(bitmap.width(), bitmap.height()); 137 SkRect mapped_rect; 138 total_matrix.mapRect(&mapped_rect, bitmap_rect); 139 AddBitmap(bitmap, mapped_rect); 140 141 SkBitmap paint_bitmap; 142 if (GetBitmapFromPaint(paint, &paint_bitmap)) 143 AddBitmap(paint_bitmap, mapped_rect); 144 } 145 virtual void drawBitmapRect(const SkDraw& draw, 146 const SkBitmap& bitmap, 147 const SkRect* src_or_null, 148 const SkRect& dst, 149 const SkPaint& paint, 150 SkCanvas::DrawBitmapRectFlags flags) SK_OVERRIDE { 151 SkRect bitmap_rect = SkRect::MakeWH(bitmap.width(), bitmap.height()); 152 SkMatrix matrix; 153 matrix.setRectToRect(bitmap_rect, dst, SkMatrix::kFill_ScaleToFit); 154 GatherPixelRefDevice::drawBitmap(draw, bitmap, matrix, paint); 155 } 156 virtual void drawSprite(const SkDraw& draw, 157 const SkBitmap& bitmap, 158 int x, 159 int y, 160 const SkPaint& paint) SK_OVERRIDE { 161 // Sprites aren't affected by current matrix, so we can't reuse drawRect. 162 SkMatrix matrix; 163 matrix.setTranslate(x, y); 164 165 SkRect bitmap_rect = SkRect::MakeWH(bitmap.width(), bitmap.height()); 166 SkRect mapped_rect; 167 matrix.mapRect(&mapped_rect, bitmap_rect); 168 169 AddBitmap(bitmap, mapped_rect); 170 SkBitmap paint_bitmap; 171 if (GetBitmapFromPaint(paint, &paint_bitmap)) 172 AddBitmap(paint_bitmap, mapped_rect); 173 } 174 virtual void drawText(const SkDraw& draw, 175 const void* text, 176 size_t len, 177 SkScalar x, 178 SkScalar y, 179 const SkPaint& paint) SK_OVERRIDE { 180 SkBitmap bitmap; 181 if (!GetBitmapFromPaint(paint, &bitmap)) 182 return; 183 184 // Math is borrowed from SkBBoxRecord 185 SkRect bounds; 186 paint.measureText(text, len, &bounds); 187 SkPaint::FontMetrics metrics; 188 paint.getFontMetrics(&metrics); 189 190 if (paint.isVerticalText()) { 191 SkScalar h = bounds.fBottom - bounds.fTop; 192 if (paint.getTextAlign() == SkPaint::kCenter_Align) { 193 bounds.fTop -= h / 2; 194 bounds.fBottom -= h / 2; 195 } 196 bounds.fBottom += metrics.fBottom; 197 bounds.fTop += metrics.fTop; 198 } else { 199 SkScalar w = bounds.fRight - bounds.fLeft; 200 if (paint.getTextAlign() == SkPaint::kCenter_Align) { 201 bounds.fLeft -= w / 2; 202 bounds.fRight -= w / 2; 203 } else if (paint.getTextAlign() == SkPaint::kRight_Align) { 204 bounds.fLeft -= w; 205 bounds.fRight -= w; 206 } 207 bounds.fTop = metrics.fTop; 208 bounds.fBottom = metrics.fBottom; 209 } 210 211 SkScalar pad = (metrics.fBottom - metrics.fTop) / 2; 212 bounds.fLeft -= pad; 213 bounds.fRight += pad; 214 bounds.fLeft += x; 215 bounds.fRight += x; 216 bounds.fTop += y; 217 bounds.fBottom += y; 218 219 GatherPixelRefDevice::drawRect(draw, bounds, paint); 220 } 221 virtual void drawPosText(const SkDraw& draw, 222 const void* text, 223 size_t len, 224 const SkScalar pos[], 225 SkScalar const_y, 226 int scalars_per_pos, 227 const SkPaint& paint) SK_OVERRIDE { 228 SkBitmap bitmap; 229 if (!GetBitmapFromPaint(paint, &bitmap)) 230 return; 231 232 if (len == 0) 233 return; 234 235 // Similar to SkDraw asserts. 236 SkASSERT(scalars_per_pos == 1 || scalars_per_pos == 2); 237 238 SkPoint min_point; 239 SkPoint max_point; 240 if (scalars_per_pos == 1) { 241 min_point.set(pos[0], const_y); 242 max_point.set(pos[0], const_y); 243 } else if (scalars_per_pos == 2) { 244 min_point.set(pos[0], const_y + pos[1]); 245 max_point.set(pos[0], const_y + pos[1]); 246 } 247 248 for (size_t i = 0; i < len; ++i) { 249 SkScalar x = pos[i * scalars_per_pos]; 250 SkScalar y = const_y; 251 if (scalars_per_pos == 2) 252 y += pos[i * scalars_per_pos + 1]; 253 254 min_point.set(std::min(x, min_point.x()), std::min(y, min_point.y())); 255 max_point.set(std::max(x, max_point.x()), std::max(y, max_point.y())); 256 } 257 258 SkRect bounds = SkRect::MakeLTRB( 259 min_point.x(), min_point.y(), max_point.x(), max_point.y()); 260 261 // Math is borrowed from SkBBoxRecord 262 SkPaint::FontMetrics metrics; 263 paint.getFontMetrics(&metrics); 264 265 bounds.fTop += metrics.fTop; 266 bounds.fBottom += metrics.fBottom; 267 268 SkScalar pad = (metrics.fTop - metrics.fBottom) / 2; 269 bounds.fLeft += pad; 270 bounds.fRight -= pad; 271 272 GatherPixelRefDevice::drawRect(draw, bounds, paint); 273 } 274 virtual void drawTextOnPath(const SkDraw& draw, 275 const void* text, 276 size_t len, 277 const SkPath& path, 278 const SkMatrix* matrix, 279 const SkPaint& paint) SK_OVERRIDE { 280 SkBitmap bitmap; 281 if (!GetBitmapFromPaint(paint, &bitmap)) 282 return; 283 284 // Math is borrowed from SkBBoxRecord 285 SkRect bounds = path.getBounds(); 286 SkPaint::FontMetrics metrics; 287 paint.getFontMetrics(&metrics); 288 289 SkScalar pad = metrics.fTop; 290 bounds.fLeft += pad; 291 bounds.fRight -= pad; 292 bounds.fTop += pad; 293 bounds.fBottom -= pad; 294 295 GatherPixelRefDevice::drawRect(draw, bounds, paint); 296 } 297 virtual void drawVertices(const SkDraw& draw, 298 SkCanvas::VertexMode, 299 int vertex_count, 300 const SkPoint verts[], 301 const SkPoint texs[], 302 const SkColor colors[], 303 SkXfermode* xmode, 304 const uint16_t indices[], 305 int index_count, 306 const SkPaint& paint) SK_OVERRIDE { 307 GatherPixelRefDevice::drawPoints( 308 draw, SkCanvas::kPolygon_PointMode, vertex_count, verts, paint); 309 } 310 virtual void drawDevice(const SkDraw&, 311 SkBaseDevice*, 312 int x, 313 int y, 314 const SkPaint&) SK_OVERRIDE {} 315 316 protected: 317 virtual bool onReadPixels(const SkImageInfo& info, 318 void* pixels, 319 size_t rowBytes, 320 int x, 321 int y) SK_OVERRIDE { 322 return false; 323 } 324 325 virtual bool onWritePixels(const SkImageInfo& info, 326 const void* pixels, 327 size_t rowBytes, 328 int x, 329 int y) SK_OVERRIDE { 330 return false; 331 } 332 333 private: 334 DiscardablePixelRefSet* pixel_ref_set_; 335 336 void AddBitmap(const SkBitmap& bm, const SkRect& rect) { 337 SkRect canvas_rect = SkRect::MakeWH(width(), height()); 338 SkRect paint_rect = SkRect::MakeEmpty(); 339 paint_rect.intersect(rect, canvas_rect); 340 pixel_ref_set_->Add(bm.pixelRef(), paint_rect); 341 } 342 343 bool GetBitmapFromPaint(const SkPaint& paint, SkBitmap* bm) { 344 SkShader* shader = paint.getShader(); 345 if (shader) { 346 // Check whether the shader is a gradient in order to prevent generation 347 // of bitmaps from gradient shaders, which implement asABitmap. 348 if (SkShader::kNone_GradientType == shader->asAGradient(NULL)) 349 return shader->asABitmap(bm, NULL, NULL); 350 } 351 return false; 352 } 353 }; 354 355 } // namespace 356 357 void PixelRefUtils::GatherDiscardablePixelRefs( 358 SkPicture* picture, 359 std::vector<PositionPixelRef>* pixel_refs) { 360 pixel_refs->clear(); 361 DiscardablePixelRefSet pixel_ref_set(pixel_refs); 362 363 SkBitmap empty_bitmap; 364 empty_bitmap.setInfo(SkImageInfo::MakeUnknown(picture->width(), picture->height())); 365 366 GatherPixelRefDevice device(empty_bitmap, &pixel_ref_set); 367 SkNoSaveLayerCanvas canvas(&device); 368 369 canvas.clipRect(SkRect::MakeWH(picture->width(), picture->height()), 370 SkRegion::kIntersect_Op, 371 false); 372 canvas.drawPicture(picture); 373 } 374 375 } // namespace skia 376
