blob: fadf97085fcd79f1b33e84b182cf7f24198dfa00 [file] [log] [blame]
/*
* Copyright 2012 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef PictureRenderer_DEFINED
#define PictureRenderer_DEFINED
#include "SkCanvas.h"
#include "SkDrawFilter.h"
#include "SkJSONCPP.h"
#include "SkMath.h"
#include "SkPaint.h"
#include "SkPicture.h"
#include "SkPictureRecorder.h"
#include "SkRect.h"
#include "SkRefCnt.h"
#include "SkString.h"
#include "SkTDArray.h"
#include "SkTypes.h"
#if SK_SUPPORT_GPU
#include "GrContextFactory.h"
#include "GrContext.h"
#endif
#include "image_expectations.h"
struct GrContextOptions;
class SkBitmap;
class SkCanvas;
class SkGLContext;
class SkThread;
namespace sk_tools {
class TiledPictureRenderer;
class PictureRenderer : public SkRefCnt {
public:
enum SkDeviceTypes {
#if SK_ANGLE
kAngle_DeviceType,
#endif
#if SK_MESA
kMesa_DeviceType,
#endif
kBitmap_DeviceType,
#if SK_SUPPORT_GPU
kGPU_DeviceType,
kNVPR_DeviceType,
#endif
};
enum BBoxHierarchyType {
kNone_BBoxHierarchyType = 0,
kRTree_BBoxHierarchyType,
kLast_BBoxHierarchyType = kRTree_BBoxHierarchyType,
};
// this uses SkPaint::Flags as a base and adds additional flags
enum DrawFilterFlags {
kNone_DrawFilterFlag = 0,
kHinting_DrawFilterFlag = 0x10000, // toggles between no hinting and normal hinting
kSlightHinting_DrawFilterFlag = 0x20000, // toggles between slight and normal hinting
kAAClip_DrawFilterFlag = 0x40000, // toggles between soft and hard clip
kMaskFilter_DrawFilterFlag = 0x80000, // toggles on/off mask filters (e.g., blurs)
};
SK_COMPILE_ASSERT(!(kMaskFilter_DrawFilterFlag & SkPaint::kAllFlags), maskfilter_flag_must_be_greater);
SK_COMPILE_ASSERT(!(kHinting_DrawFilterFlag & SkPaint::kAllFlags),
hinting_flag_must_be_greater);
SK_COMPILE_ASSERT(!(kSlightHinting_DrawFilterFlag & SkPaint::kAllFlags),
slight_hinting_flag_must_be_greater);
/**
* Called with each new SkPicture to render.
*
* @param pict The SkPicture to render.
* @param writePath The output directory within which this renderer should write all images,
* or NULL if this renderer should not write all images.
* @param mismatchPath The output directory within which this renderer should write any images
* which do not match expectations, or NULL if this renderer should not write mismatches.
* @param inputFilename The name of the input file we are rendering.
* @param useChecksumBasedFilenames Whether to use checksum-based filenames when writing
* bitmap images to disk.
* @param useMultiPictureDraw true if MultiPictureDraw should be used for rendering
*/
virtual void init(const SkPicture* pict,
const SkString* writePath,
const SkString* mismatchPath,
const SkString* inputFilename,
bool useChecksumBasedFilenames,
bool useMultiPictureDraw);
/**
* TODO(epoger): Temporary hack, while we work on http://skbug.com/2584 ('bench_pictures is
* timing reading pixels and writing json files'), such that:
* - render_pictures can call this method and continue to work
* - any other callers (bench_pictures) will skip calls to write() by default
*/
void enableWrites() { fEnableWrites = true; }
/**
* Set the viewport so that only the portion listed gets drawn.
*/
void setViewport(SkISize size) { fViewport = size; }
/**
* Set the scale factor at which draw the picture.
*/
void setScaleFactor(SkScalar scale) { fScaleFactor = scale; }
/**
* Perform any setup that should done prior to each iteration of render() which should not be
* timed.
*/
virtual void setup() {}
/**
* Perform the work. If this is being called within the context of bench_pictures,
* this is the step that will be timed.
*
* Typically "the work" is rendering an SkPicture into a bitmap, but in some subclasses
* it is recording the source SkPicture into another SkPicture.
*
* If fWritePath has been specified, the result of the work will be written to that dir.
* If fMismatchPath has been specified, and the actual image result differs from its
* expectation, the result of the work will be written to that dir.
*
* @param out If non-null, the implementing subclass MAY allocate an SkBitmap, copy the
* output image into it, and return it here. (Some subclasses ignore this parameter)
* @return bool True if rendering succeeded and, if fWritePath had been specified, the output
* was successfully written to a file.
*/
virtual bool render(SkBitmap** out = NULL) = 0;
/**
* Called once finished with a particular SkPicture, before calling init again, and before
* being done with this Renderer.
*/
virtual void end();
/**
* If this PictureRenderer is actually a TiledPictureRender, return a pointer to this as a
* TiledPictureRender so its methods can be called.
*/
virtual TiledPictureRenderer* getTiledRenderer() { return NULL; }
/**
* Resets the GPU's state. Does nothing if the backing is raster. For a GPU renderer, calls
* flush, swapBuffers and, if callFinish is true, finish.
* @param callFinish Whether to call finish.
*/
void resetState(bool callFinish);
/**
* Remove all decoded textures from the CPU caches and all uploaded textures
* from the GPU.
*/
void purgeTextures();
/**
* Set the backend type. Returns true on success and false on failure.
*/
#if SK_SUPPORT_GPU
bool setDeviceType(SkDeviceTypes deviceType, GrGLStandard gpuAPI = kNone_GrGLStandard) {
#else
bool setDeviceType(SkDeviceTypes deviceType) {
#endif
fDeviceType = deviceType;
#if SK_SUPPORT_GPU
// In case this function is called more than once
SkSafeUnref(fGrContext);
fGrContext = NULL;
// Set to Native so it will have an initial value.
GrContextFactory::GLContextType glContextType = GrContextFactory::kNative_GLContextType;
#endif
switch(deviceType) {
case kBitmap_DeviceType:
return true;
#if SK_SUPPORT_GPU
case kGPU_DeviceType:
// Already set to GrContextFactory::kNative_GLContextType, above.
break;
case kNVPR_DeviceType:
glContextType = GrContextFactory::kNVPR_GLContextType;
break;
#if SK_ANGLE
case kAngle_DeviceType:
glContextType = GrContextFactory::kANGLE_GLContextType;
break;
#endif
#if SK_MESA
case kMesa_DeviceType:
glContextType = GrContextFactory::kMESA_GLContextType;
break;
#endif
#endif
default:
// Invalid device type.
return false;
}
#if SK_SUPPORT_GPU
fGrContext = fGrContextFactory.get(glContextType, gpuAPI);
if (NULL == fGrContext) {
return false;
} else {
fGrContext->ref();
return true;
}
#endif
}
#if SK_SUPPORT_GPU
void setSampleCount(int sampleCount) {
fSampleCount = sampleCount;
}
void setUseDFText(bool useDFText) {
fUseDFText = useDFText;
}
#endif
void setDrawFilters(DrawFilterFlags const * const filters, const SkString& configName) {
memcpy(fDrawFilters, filters, sizeof(fDrawFilters));
fDrawFiltersConfig = configName;
}
void setBBoxHierarchyType(BBoxHierarchyType bbhType) {
fBBoxHierarchyType = bbhType;
}
BBoxHierarchyType getBBoxHierarchyType() { return fBBoxHierarchyType; }
void setJsonSummaryPtr(ImageResultsAndExpectations* jsonSummaryPtr) {
fJsonSummaryPtr = jsonSummaryPtr;
}
bool isUsingBitmapDevice() {
return kBitmap_DeviceType == fDeviceType;
}
virtual SkString getPerIterTimeFormat() { return SkString("%.2f"); }
virtual SkString getNormalTimeFormat() { return SkString("%6.2f"); }
/**
* Reports the configuration of this PictureRenderer.
*/
SkString getConfigName() {
SkString config = this->getConfigNameInternal();
if (!fViewport.isEmpty()) {
config.appendf("_viewport_%ix%i", fViewport.width(), fViewport.height());
}
if (fScaleFactor != SK_Scalar1) {
config.appendf("_scalar_%f", SkScalarToFloat(fScaleFactor));
}
if (kRTree_BBoxHierarchyType == fBBoxHierarchyType) {
config.append("_rtree");
}
#if SK_SUPPORT_GPU
switch (fDeviceType) {
case kGPU_DeviceType:
if (fSampleCount) {
config.appendf("_msaa%d", fSampleCount);
} else if (fUseDFText) {
config.append("_gpudft");
} else {
config.append("_gpu");
}
break;
case kNVPR_DeviceType:
config.appendf("_nvprmsaa%d", fSampleCount);
break;
#if SK_ANGLE
case kAngle_DeviceType:
config.append("_angle");
break;
#endif
#if SK_MESA
case kMesa_DeviceType:
config.append("_mesa");
break;
#endif
default:
// Assume that no extra info means bitmap.
break;
}
#endif
config.append(fDrawFiltersConfig.c_str());
return config;
}
Json::Value getJSONConfig() {
Json::Value result;
result["mode"] = this->getConfigNameInternal().c_str();
result["scale"] = 1.0f;
if (SK_Scalar1 != fScaleFactor) {
result["scale"] = SkScalarToFloat(fScaleFactor);
}
if (kRTree_BBoxHierarchyType == fBBoxHierarchyType) {
result["bbh"] = "rtree";
}
#if SK_SUPPORT_GPU
SkString tmp;
switch (fDeviceType) {
case kGPU_DeviceType:
if (0 != fSampleCount) {
tmp = "msaa";
tmp.appendS32(fSampleCount);
result["config"] = tmp.c_str();
} else if (fUseDFText) {
result["config"] = "gpudft";
} else {
result["config"] = "gpu";
}
break;
case kNVPR_DeviceType:
tmp = "nvprmsaa";
tmp.appendS32(fSampleCount);
result["config"] = tmp.c_str();
break;
#if SK_ANGLE
case kAngle_DeviceType:
result["config"] = "angle";
break;
#endif
#if SK_MESA
case kMesa_DeviceType:
result["config"] = "mesa";
break;
#endif
default:
// Assume that no extra info means bitmap.
break;
}
#endif
return result;
}
#if SK_SUPPORT_GPU
bool isUsingGpuDevice() {
switch (fDeviceType) {
case kGPU_DeviceType:
case kNVPR_DeviceType:
// fall through
#if SK_ANGLE
case kAngle_DeviceType:
// fall through
#endif
#if SK_MESA
case kMesa_DeviceType:
#endif
return true;
default:
return false;
}
}
SkGLContext* getGLContext() {
GrContextFactory::GLContextType glContextType
= GrContextFactory::kNull_GLContextType;
switch(fDeviceType) {
case kGPU_DeviceType:
glContextType = GrContextFactory::kNative_GLContextType;
break;
case kNVPR_DeviceType:
glContextType = GrContextFactory::kNVPR_GLContextType;
break;
#if SK_ANGLE
case kAngle_DeviceType:
glContextType = GrContextFactory::kANGLE_GLContextType;
break;
#endif
#if SK_MESA
case kMesa_DeviceType:
glContextType = GrContextFactory::kMESA_GLContextType;
break;
#endif
default:
return NULL;
}
return fGrContextFactory.getGLContext(glContextType);
}
GrContext* getGrContext() {
return fGrContext;
}
const GrContextOptions& getGrContextOptions() {
return fGrContextFactory.getGlobalOptions();
}
#endif
SkCanvas* getCanvas() {
return fCanvas;
}
const SkPicture* getPicture() {
return fPicture;
}
#if SK_SUPPORT_GPU
explicit PictureRenderer(const GrContextOptions &opts)
#else
PictureRenderer()
#endif
: fJsonSummaryPtr(NULL)
, fDeviceType(kBitmap_DeviceType)
, fEnableWrites(false)
, fBBoxHierarchyType(kNone_BBoxHierarchyType)
, fScaleFactor(SK_Scalar1)
#if SK_SUPPORT_GPU
, fGrContextFactory(opts)
, fGrContext(NULL)
, fSampleCount(0)
, fUseDFText(false)
#endif
{
sk_bzero(fDrawFilters, sizeof(fDrawFilters));
fViewport.set(0, 0);
}
#if SK_SUPPORT_GPU
virtual ~PictureRenderer() {
SkSafeUnref(fGrContext);
}
#endif
protected:
SkAutoTUnref<SkCanvas> fCanvas;
SkAutoTUnref<const SkPicture> fPicture;
bool fUseChecksumBasedFilenames;
bool fUseMultiPictureDraw;
ImageResultsAndExpectations* fJsonSummaryPtr;
SkDeviceTypes fDeviceType;
bool fEnableWrites;
BBoxHierarchyType fBBoxHierarchyType;
DrawFilterFlags fDrawFilters[SkDrawFilter::kTypeCount];
SkString fDrawFiltersConfig;
SkString fWritePath;
SkString fMismatchPath;
SkString fInputFilename;
void buildBBoxHierarchy();
/**
* Return the total width that should be drawn. If the viewport width has been set greater than
* 0, this will be the minimum of the current SkPicture's width and the viewport's width.
*/
int getViewWidth();
/**
* Return the total height that should be drawn. If the viewport height has been set greater
* than 0, this will be the minimum of the current SkPicture's height and the viewport's height.
*/
int getViewHeight();
/**
* Scales the provided canvas to the scale factor set by setScaleFactor.
*/
void scaleToScaleFactor(SkCanvas*);
SkBBHFactory* getFactory();
uint32_t recordFlags() const { return 0; }
SkCanvas* setupCanvas();
virtual SkCanvas* setupCanvas(int width, int height);
/**
* Copy src to dest; if src==NULL, set dest to empty string.
*/
static void CopyString(SkString* dest, const SkString* src);
private:
SkISize fViewport;
SkScalar fScaleFactor;
#if SK_SUPPORT_GPU
GrContextFactory fGrContextFactory;
GrContext* fGrContext;
int fSampleCount;
bool fUseDFText;
#endif
virtual SkString getConfigNameInternal() = 0;
typedef SkRefCnt INHERITED;
};
/**
* This class does not do any rendering, but its render function executes recording, which we want
* to time.
*/
class RecordPictureRenderer : public PictureRenderer {
public:
#if SK_SUPPORT_GPU
RecordPictureRenderer(const GrContextOptions &opts) : INHERITED(opts) { }
#endif
bool render(SkBitmap** out = NULL) override;
SkString getPerIterTimeFormat() override { return SkString("%.4f"); }
SkString getNormalTimeFormat() override { return SkString("%6.4f"); }
protected:
SkCanvas* setupCanvas(int width, int height) override;
private:
SkString getConfigNameInternal() override;
typedef PictureRenderer INHERITED;
};
class PipePictureRenderer : public PictureRenderer {
public:
#if SK_SUPPORT_GPU
PipePictureRenderer(const GrContextOptions &opts) : INHERITED(opts) { }
#endif
bool render(SkBitmap** out = NULL) override;
private:
SkString getConfigNameInternal() override;
typedef PictureRenderer INHERITED;
};
class SimplePictureRenderer : public PictureRenderer {
public:
#if SK_SUPPORT_GPU
SimplePictureRenderer(const GrContextOptions &opts) : INHERITED(opts) { }
#endif
virtual void init(const SkPicture* pict,
const SkString* writePath,
const SkString* mismatchPath,
const SkString* inputFilename,
bool useChecksumBasedFilenames,
bool useMultiPictureDraw) override;
bool render(SkBitmap** out = NULL) override;
private:
SkString getConfigNameInternal() override;
typedef PictureRenderer INHERITED;
};
class TiledPictureRenderer : public PictureRenderer {
public:
#if SK_SUPPORT_GPU
TiledPictureRenderer(const GrContextOptions &opts);
#else
TiledPictureRenderer();
#endif
virtual void init(const SkPicture* pict,
const SkString* writePath,
const SkString* mismatchPath,
const SkString* inputFilename,
bool useChecksumBasedFilenames,
bool useMultiPictureDraw) override;
/**
* Renders to tiles, rather than a single canvas.
* If fWritePath was provided, a separate file is
* created for each tile, named "path0.png", "path1.png", etc.
*/
bool render(SkBitmap** out = NULL) override;
void end() override;
void setTileWidth(int width) {
fTileWidth = width;
}
int getTileWidth() const {
return fTileWidth;
}
void setTileHeight(int height) {
fTileHeight = height;
}
int getTileHeight() const {
return fTileHeight;
}
void setTileWidthPercentage(double percentage) {
fTileWidthPercentage = percentage;
}
double getTileWidthPercentage() const {
return fTileWidthPercentage;
}
void setTileHeightPercentage(double percentage) {
fTileHeightPercentage = percentage;
}
double getTileHeightPercentage() const {
return fTileHeightPercentage;
}
void setTileMinPowerOf2Width(int width) {
SkASSERT(SkIsPow2(width) && width > 0);
if (!SkIsPow2(width) || width <= 0) {
return;
}
fTileMinPowerOf2Width = width;
}
int getTileMinPowerOf2Width() const {
return fTileMinPowerOf2Width;
}
TiledPictureRenderer* getTiledRenderer() override { return this; }
virtual bool supportsTimingIndividualTiles() { return true; }
/**
* Report the number of tiles in the x and y directions. Must not be called before init.
* @param x Output parameter identifying the number of tiles in the x direction.
* @param y Output parameter identifying the number of tiles in the y direction.
* @return True if the tiles have been set up, and x and y are meaningful. If false, x and y are
* unmodified.
*/
bool tileDimensions(int& x, int&y);
/**
* Move to the next tile and return its indices. Must be called before calling drawCurrentTile
* for the first time.
* @param i Output parameter identifying the column of the next tile to be drawn on the next
* call to drawNextTile.
* @param j Output parameter identifying the row of the next tile to be drawn on the next call
* to drawNextTile.
* @param True if the tiles have been created and the next tile to be drawn by drawCurrentTile
* is within the range of tiles. If false, i and j are unmodified.
*/
bool nextTile(int& i, int& j);
/**
* Render one tile. This will draw the same tile each time it is called until nextTile is
* called. The tile rendered will depend on how many calls have been made to nextTile.
* It is an error to call this without first calling nextTile, or if nextTile returns false.
*/
void drawCurrentTile();
protected:
SkTDArray<SkIRect> fTileRects;
SkCanvas* setupCanvas(int width, int height) override;
SkString getConfigNameInternal() override;
private:
int fTileWidth;
int fTileHeight;
double fTileWidthPercentage;
double fTileHeightPercentage;
int fTileMinPowerOf2Width;
// These variables are only used for timing individual tiles.
// Next tile to draw in fTileRects.
int fCurrentTileOffset;
// Number of tiles in the x direction.
int fTilesX;
// Number of tiles in the y direction.
int fTilesY;
void setupTiles();
void setupPowerOf2Tiles();
bool postRender(SkCanvas*, const SkIRect& tileRect,
SkBitmap* tempBM, SkBitmap** out,
int tileNumber);
typedef PictureRenderer INHERITED;
};
/**
* This class does not do any rendering, but its render function executes turning an SkPictureRecord
* into an SkPicturePlayback, which we want to time.
*/
class PlaybackCreationRenderer : public PictureRenderer {
public:
#if SK_SUPPORT_GPU
PlaybackCreationRenderer(const GrContextOptions &opts) : INHERITED(opts) { }
#endif
void setup() override;
bool render(SkBitmap** out = NULL) override;
SkString getPerIterTimeFormat() override { return SkString("%.4f"); }
SkString getNormalTimeFormat() override { return SkString("%6.4f"); }
private:
SkAutoTDelete<SkPictureRecorder> fRecorder;
SkString getConfigNameInternal() override;
typedef PictureRenderer INHERITED;
};
#if SK_SUPPORT_GPU
extern PictureRenderer* CreateGatherPixelRefsRenderer(const GrContextOptions& opts);
#else
extern PictureRenderer* CreateGatherPixelRefsRenderer();
#endif
}
#endif // PictureRenderer_DEFINED