blob: 78d256df704e0ee8043de201abaa2e74d3808b41 [file] [log] [blame]
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "skia/ext/pixel_ref_utils.h"
#include <algorithm>
#include "third_party/skia/include/core/SkBitmapDevice.h"
#include "third_party/skia/include/core/SkCanvas.h"
#include "third_party/skia/include/core/SkData.h"
#include "third_party/skia/include/core/SkDraw.h"
#include "third_party/skia/include/core/SkPixelRef.h"
#include "third_party/skia/include/core/SkRRect.h"
#include "third_party/skia/include/core/SkRect.h"
#include "third_party/skia/include/core/SkShader.h"
#include "third_party/skia/include/utils/SkNoSaveLayerCanvas.h"
#include "third_party/skia/src/core/SkRasterClip.h"
namespace skia {
namespace {
// URI label for a discardable SkPixelRef.
const char kLabelDiscardable[] = "discardable";
class DiscardablePixelRefSet {
public:
DiscardablePixelRefSet(
std::vector<PixelRefUtils::PositionPixelRef>* pixel_refs)
: pixel_refs_(pixel_refs) {}
void Add(SkPixelRef* pixel_ref, const SkRect& rect) {
// Only save discardable pixel refs.
if (pixel_ref->getURI() &&
!strcmp(pixel_ref->getURI(), kLabelDiscardable)) {
PixelRefUtils::PositionPixelRef position_pixel_ref;
position_pixel_ref.pixel_ref = pixel_ref;
position_pixel_ref.pixel_ref_rect = rect;
pixel_refs_->push_back(position_pixel_ref);
}
}
private:
std::vector<PixelRefUtils::PositionPixelRef>* pixel_refs_;
};
class GatherPixelRefDevice : public SkBitmapDevice {
public:
GatherPixelRefDevice(const SkBitmap& bm,
DiscardablePixelRefSet* pixel_ref_set)
: SkBitmapDevice(bm), pixel_ref_set_(pixel_ref_set) {}
void drawPaint(const SkDraw& draw, const SkPaint& paint) override {
SkBitmap bitmap;
if (GetBitmapFromPaint(paint, &bitmap)) {
SkRect clip_rect = SkRect::Make(draw.fRC->getBounds());
AddBitmap(bitmap, clip_rect);
}
}
void drawPoints(const SkDraw& draw,
SkCanvas::PointMode mode,
size_t count,
const SkPoint points[],
const SkPaint& paint) override {
SkBitmap bitmap;
if (!GetBitmapFromPaint(paint, &bitmap))
return;
if (count == 0)
return;
SkPoint min_point = points[0];
SkPoint max_point = points[0];
for (size_t i = 1; i < count; ++i) {
const SkPoint& point = points[i];
min_point.set(std::min(min_point.x(), point.x()),
std::min(min_point.y(), point.y()));
max_point.set(std::max(max_point.x(), point.x()),
std::max(max_point.y(), point.y()));
}
SkRect bounds = SkRect::MakeLTRB(
min_point.x(), min_point.y(), max_point.x(), max_point.y());
GatherPixelRefDevice::drawRect(draw, bounds, paint);
}
void drawRect(const SkDraw& draw,
const SkRect& rect,
const SkPaint& paint) override {
SkBitmap bitmap;
if (GetBitmapFromPaint(paint, &bitmap)) {
SkRect mapped_rect;
draw.fMatrix->mapRect(&mapped_rect, rect);
if (mapped_rect.intersect(SkRect::Make(draw.fRC->getBounds())))
AddBitmap(bitmap, mapped_rect);
}
}
void drawOval(const SkDraw& draw,
const SkRect& rect,
const SkPaint& paint) override {
GatherPixelRefDevice::drawRect(draw, rect, paint);
}
void drawRRect(const SkDraw& draw,
const SkRRect& rect,
const SkPaint& paint) override {
GatherPixelRefDevice::drawRect(draw, rect.rect(), paint);
}
void drawPath(const SkDraw& draw,
const SkPath& path,
const SkPaint& paint,
const SkMatrix* pre_path_matrix,
bool path_is_mutable) override {
SkBitmap bitmap;
if (!GetBitmapFromPaint(paint, &bitmap))
return;
SkRect path_bounds = path.getBounds();
SkRect final_rect;
if (pre_path_matrix != NULL)
pre_path_matrix->mapRect(&final_rect, path_bounds);
else
final_rect = path_bounds;
GatherPixelRefDevice::drawRect(draw, final_rect, paint);
}
void drawBitmap(const SkDraw& draw,
const SkBitmap& bitmap,
const SkMatrix& matrix,
const SkPaint& paint) override {
SkMatrix total_matrix;
total_matrix.setConcat(*draw.fMatrix, matrix);
SkRect bitmap_rect = SkRect::MakeWH(bitmap.width(), bitmap.height());
SkRect mapped_rect;
total_matrix.mapRect(&mapped_rect, bitmap_rect);
AddBitmap(bitmap, mapped_rect);
SkBitmap paint_bitmap;
if (GetBitmapFromPaint(paint, &paint_bitmap))
AddBitmap(paint_bitmap, mapped_rect);
}
void drawBitmapRect(const SkDraw& draw,
const SkBitmap& bitmap,
const SkRect* src_or_null,
const SkRect& dst,
const SkPaint& paint,
SkCanvas::SrcRectConstraint flags) override {
SkRect bitmap_rect = SkRect::MakeWH(bitmap.width(), bitmap.height());
SkMatrix matrix;
matrix.setRectToRect(bitmap_rect, dst, SkMatrix::kFill_ScaleToFit);
GatherPixelRefDevice::drawBitmap(draw, bitmap, matrix, paint);
}
void drawSprite(const SkDraw& draw,
const SkBitmap& bitmap,
int x,
int y,
const SkPaint& paint) override {
// Sprites aren't affected by current matrix, so we can't reuse drawRect.
SkMatrix matrix;
matrix.setTranslate(x, y);
SkRect bitmap_rect = SkRect::MakeWH(bitmap.width(), bitmap.height());
SkRect mapped_rect;
matrix.mapRect(&mapped_rect, bitmap_rect);
AddBitmap(bitmap, mapped_rect);
SkBitmap paint_bitmap;
if (GetBitmapFromPaint(paint, &paint_bitmap))
AddBitmap(paint_bitmap, mapped_rect);
}
void drawText(const SkDraw& draw,
const void* text,
size_t len,
SkScalar x,
SkScalar y,
const SkPaint& paint) override {
SkBitmap bitmap;
if (!GetBitmapFromPaint(paint, &bitmap))
return;
// Math is borrowed from SkBBoxRecord
SkRect bounds;
paint.measureText(text, len, &bounds);
SkPaint::FontMetrics metrics;
paint.getFontMetrics(&metrics);
if (paint.isVerticalText()) {
SkScalar h = bounds.fBottom - bounds.fTop;
if (paint.getTextAlign() == SkPaint::kCenter_Align) {
bounds.fTop -= h / 2;
bounds.fBottom -= h / 2;
}
bounds.fBottom += metrics.fBottom;
bounds.fTop += metrics.fTop;
} else {
SkScalar w = bounds.fRight - bounds.fLeft;
if (paint.getTextAlign() == SkPaint::kCenter_Align) {
bounds.fLeft -= w / 2;
bounds.fRight -= w / 2;
} else if (paint.getTextAlign() == SkPaint::kRight_Align) {
bounds.fLeft -= w;
bounds.fRight -= w;
}
bounds.fTop = metrics.fTop;
bounds.fBottom = metrics.fBottom;
}
SkScalar pad = (metrics.fBottom - metrics.fTop) / 2;
bounds.fLeft -= pad;
bounds.fRight += pad;
bounds.fLeft += x;
bounds.fRight += x;
bounds.fTop += y;
bounds.fBottom += y;
GatherPixelRefDevice::drawRect(draw, bounds, paint);
}
void drawPosText(const SkDraw& draw,
const void* text,
size_t len,
const SkScalar pos[],
int scalars_per_pos,
const SkPoint& offset,
const SkPaint& paint) override {
SkBitmap bitmap;
if (!GetBitmapFromPaint(paint, &bitmap))
return;
if (len == 0)
return;
// Similar to SkDraw asserts.
SkASSERT(scalars_per_pos == 1 || scalars_per_pos == 2);
SkPoint min_point = SkPoint::Make(offset.x() + pos[0],
offset.y() + (2 == scalars_per_pos ? pos[1] : 0));
SkPoint max_point = min_point;
for (size_t i = 0; i < len; ++i) {
SkScalar x = offset.x() + pos[i * scalars_per_pos];
SkScalar y = offset.y() + (2 == scalars_per_pos ? pos[i * scalars_per_pos + 1] : 0);
min_point.set(std::min(x, min_point.x()), std::min(y, min_point.y()));
max_point.set(std::max(x, max_point.x()), std::max(y, max_point.y()));
}
SkRect bounds = SkRect::MakeLTRB(
min_point.x(), min_point.y(), max_point.x(), max_point.y());
// Math is borrowed from SkBBoxRecord
SkPaint::FontMetrics metrics;
paint.getFontMetrics(&metrics);
bounds.fTop += metrics.fTop;
bounds.fBottom += metrics.fBottom;
SkScalar pad = (metrics.fTop - metrics.fBottom) / 2;
bounds.fLeft += pad;
bounds.fRight -= pad;
GatherPixelRefDevice::drawRect(draw, bounds, paint);
}
void drawTextOnPath(const SkDraw& draw,
const void* text,
size_t len,
const SkPath& path,
const SkMatrix* matrix,
const SkPaint& paint) override {
SkBitmap bitmap;
if (!GetBitmapFromPaint(paint, &bitmap))
return;
// Math is borrowed from SkBBoxRecord
SkRect bounds = path.getBounds();
SkPaint::FontMetrics metrics;
paint.getFontMetrics(&metrics);
SkScalar pad = metrics.fTop;
bounds.fLeft += pad;
bounds.fRight -= pad;
bounds.fTop += pad;
bounds.fBottom -= pad;
GatherPixelRefDevice::drawRect(draw, bounds, paint);
}
void drawVertices(const SkDraw& draw,
SkCanvas::VertexMode,
int vertex_count,
const SkPoint verts[],
const SkPoint texs[],
const SkColor colors[],
SkXfermode* xmode,
const uint16_t indices[],
int index_count,
const SkPaint& paint) override {
GatherPixelRefDevice::drawPoints(
draw, SkCanvas::kPolygon_PointMode, vertex_count, verts, paint);
}
void drawDevice(const SkDraw&,
SkBaseDevice*,
int x,
int y,
const SkPaint&) override {}
protected:
bool onReadPixels(const SkImageInfo& info,
void* pixels,
size_t rowBytes,
int x,
int y) override {
return false;
}
bool onWritePixels(const SkImageInfo& info,
const void* pixels,
size_t rowBytes,
int x,
int y) override {
return false;
}
private:
DiscardablePixelRefSet* pixel_ref_set_;
void AddBitmap(const SkBitmap& bm, const SkRect& rect) {
SkRect canvas_rect = SkRect::MakeWH(width(), height());
SkRect paint_rect = SkRect::MakeEmpty();
if (paint_rect.intersect(rect, canvas_rect))
pixel_ref_set_->Add(bm.pixelRef(), paint_rect);
}
bool GetBitmapFromPaint(const SkPaint& paint, SkBitmap* bm) {
SkShader* shader = paint.getShader();
if (shader) {
// Check whether the shader is a gradient in order to prevent generation
// of bitmaps from gradient shaders, which implement asABitmap.
if (SkShader::kNone_GradientType == shader->asAGradient(NULL))
return shader->asABitmap(bm, NULL, NULL);
}
return false;
}
};
} // namespace
void PixelRefUtils::GatherDiscardablePixelRefs(
SkPicture* picture,
std::vector<PositionPixelRef>* pixel_refs) {
pixel_refs->clear();
DiscardablePixelRefSet pixel_ref_set(pixel_refs);
SkRect picture_bounds = picture->cullRect();
SkIRect picture_ibounds = picture_bounds.roundOut();
SkBitmap empty_bitmap;
empty_bitmap.setInfo(SkImageInfo::MakeUnknown(picture_ibounds.width(),
picture_ibounds.height()));
GatherPixelRefDevice device(empty_bitmap, &pixel_ref_set);
SkNoSaveLayerCanvas canvas(&device);
// Draw the picture pinned against our top/left corner.
canvas.translate(-picture_bounds.left(), -picture_bounds.top());
canvas.drawPicture(picture);
}
} // namespace skia