skia2/tools/PictureRenderer.h
2013-05-22 14:03:45 +00:00

556 lines
16 KiB
C++

/*
* 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 "SkCountdown.h"
#include "SkDrawFilter.h"
#include "SkMath.h"
#include "SkPaint.h"
#include "SkPicture.h"
#include "SkRect.h"
#include "SkRefCnt.h"
#include "SkRunnable.h"
#include "SkString.h"
#include "SkTDArray.h"
#include "SkThreadPool.h"
#include "SkTileGridPicture.h"
#include "SkTypes.h"
#if SK_SUPPORT_GPU
#include "GrContextFactory.h"
#include "GrContext.h"
#endif
class SkBitmap;
class SkCanvas;
class SkGLContextHelper;
class SkThread;
namespace sk_tools {
class TiledPictureRenderer;
class PictureRenderer : public SkRefCnt {
public:
enum SkDeviceTypes {
#if SK_ANGLE
kAngle_DeviceType,
#endif
kBitmap_DeviceType,
#if SK_SUPPORT_GPU
kGPU_DeviceType,
#endif
};
enum BBoxHierarchyType {
kNone_BBoxHierarchyType = 0,
kRTree_BBoxHierarchyType,
kTileGrid_BBoxHierarchyType,
};
// this uses SkPaint::Flags as a base and adds additional flags
enum DrawFilterFlags {
kNone_DrawFilterFlag = 0,
kBlur_DrawFilterFlag = 0x8000, // toggles between blur and no blur
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
};
SK_COMPILE_ASSERT(!(kBlur_DrawFilterFlag & SkPaint::kAllFlags), blur_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.
*/
virtual void init(SkPicture* pict);
/**
* 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 work that is to be timed. Typically this is rendering, but is also used for recording
* and preparing picture for playback by the subclasses which do those.
* If path is non-null, subclass implementations should call write().
* @param path If non-null, also write the output to the file specified by path. path should
* have no extension; it will be added by write().
* @return bool True if rendering succeeded and, if path is non-null, the output was
* successfully written to a file.
*/
virtual bool render(const SkString* path, 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, and calls finish if callFinish is true.
* @param callFinish Whether to call finish.
*/
void resetState(bool callFinish);
/**
* Set the backend type. Returns true on success and false on failure.
*/
bool setDeviceType(SkDeviceTypes deviceType) {
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;
#if SK_ANGLE
case kAngle_DeviceType:
glContextType = GrContextFactory::kANGLE_GLContextType;
break;
#endif
#endif
default:
// Invalid device type.
return false;
}
#if SK_SUPPORT_GPU
fGrContext = fGrContextFactory.get(glContextType);
if (NULL == fGrContext) {
return false;
} else {
fGrContext->ref();
return true;
}
#endif
}
#if SK_SUPPORT_GPU
void setSampleCount(int sampleCount) {
fSampleCount = sampleCount;
}
#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 setGridSize(int width, int height) {
fGridInfo.fTileInterval.set(width, height);
}
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 (kRTree_BBoxHierarchyType == fBBoxHierarchyType) {
config.append("_rtree");
} else if (kTileGrid_BBoxHierarchyType == fBBoxHierarchyType) {
config.append("_grid");
}
#if SK_SUPPORT_GPU
switch (fDeviceType) {
case kGPU_DeviceType:
if (fSampleCount) {
config.appendf("_msaa%d", fSampleCount);
} else {
config.append("_gpu");
}
break;
#if SK_ANGLE
case kAngle_DeviceType:
config.append("_angle");
break;
#endif
default:
// Assume that no extra info means bitmap.
break;
}
#endif
config.append(fDrawFiltersConfig.c_str());
return config;
}
#if SK_SUPPORT_GPU
bool isUsingGpuDevice() {
switch (fDeviceType) {
case kGPU_DeviceType:
// fall through
#if SK_ANGLE
case kAngle_DeviceType:
#endif
return true;
default:
return false;
}
}
SkGLContextHelper* getGLContext() {
GrContextFactory::GLContextType glContextType
= GrContextFactory::kNull_GLContextType;
switch(fDeviceType) {
case kGPU_DeviceType:
glContextType = GrContextFactory::kNative_GLContextType;
break;
#if SK_ANGLE
case kAngle_DeviceType:
glContextType = GrContextFactory::kANGLE_GLContextType;
break;
#endif
default:
return NULL;
}
return fGrContextFactory.getGLContext(glContextType);
}
GrContext* getGrContext() {
return fGrContext;
}
#endif
PictureRenderer()
: fPicture(NULL)
, fDeviceType(kBitmap_DeviceType)
, fBBoxHierarchyType(kNone_BBoxHierarchyType)
, fScaleFactor(SK_Scalar1)
#if SK_SUPPORT_GPU
, fGrContext(NULL)
, fSampleCount(0)
#endif
{
fGridInfo.fMargin.setEmpty();
fGridInfo.fOffset.setZero();
fGridInfo.fTileInterval.set(1, 1);
sk_bzero(fDrawFilters, sizeof(fDrawFilters));
fViewport.set(0, 0);
}
#if SK_SUPPORT_GPU
virtual ~PictureRenderer() {
SkSafeUnref(fGrContext);
}
#endif
protected:
SkAutoTUnref<SkCanvas> fCanvas;
SkPicture* fPicture;
SkDeviceTypes fDeviceType;
BBoxHierarchyType fBBoxHierarchyType;
DrawFilterFlags fDrawFilters[SkDrawFilter::kTypeCount];
SkString fDrawFiltersConfig;
SkTileGridPicture::TileGridInfo fGridInfo; // used when fBBoxHierarchyType is TileGrid
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*);
SkPicture* createPicture();
uint32_t recordFlags();
SkCanvas* setupCanvas();
virtual SkCanvas* setupCanvas(int width, int height);
private:
SkISize fViewport;
SkScalar fScaleFactor;
#if SK_SUPPORT_GPU
GrContextFactory fGrContextFactory;
GrContext* fGrContext;
int fSampleCount;
#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 {
virtual bool render(const SkString*, SkBitmap** out = NULL) SK_OVERRIDE;
virtual SkString getPerIterTimeFormat() SK_OVERRIDE { return SkString("%.4f"); }
virtual SkString getNormalTimeFormat() SK_OVERRIDE { return SkString("%6.4f"); }
protected:
virtual SkCanvas* setupCanvas(int width, int height) SK_OVERRIDE;
private:
virtual SkString getConfigNameInternal() SK_OVERRIDE;
};
class PipePictureRenderer : public PictureRenderer {
public:
virtual bool render(const SkString*, SkBitmap** out = NULL) SK_OVERRIDE;
private:
virtual SkString getConfigNameInternal() SK_OVERRIDE;
typedef PictureRenderer INHERITED;
};
class SimplePictureRenderer : public PictureRenderer {
public:
virtual void init(SkPicture* pict) SK_OVERRIDE;
virtual bool render(const SkString*, SkBitmap** out = NULL) SK_OVERRIDE;
private:
virtual SkString getConfigNameInternal() SK_OVERRIDE;
typedef PictureRenderer INHERITED;
};
class TiledPictureRenderer : public PictureRenderer {
public:
TiledPictureRenderer();
virtual void init(SkPicture* pict) SK_OVERRIDE;
/**
* Renders to tiles, rather than a single canvas. If a path is provided, a separate file is
* created for each tile, named "path0.png", "path1.png", etc.
* Multithreaded mode currently does not support writing to a file.
*/
virtual bool render(const SkString* path, SkBitmap** out = NULL) SK_OVERRIDE;
virtual void end() SK_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;
}
virtual TiledPictureRenderer* getTiledRenderer() SK_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<SkRect> fTileRects;
virtual SkCanvas* setupCanvas(int width, int height) SK_OVERRIDE;
virtual SkString getConfigNameInternal() SK_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();
typedef PictureRenderer INHERITED;
};
class CloneData;
class MultiCorePictureRenderer : public TiledPictureRenderer {
public:
explicit MultiCorePictureRenderer(int threadCount);
~MultiCorePictureRenderer();
virtual void init(SkPicture* pict) SK_OVERRIDE;
/**
* Behaves like TiledPictureRenderer::render(), only using multiple threads.
*/
virtual bool render(const SkString* path, SkBitmap** out = NULL) SK_OVERRIDE;
virtual void end() SK_OVERRIDE;
virtual bool supportsTimingIndividualTiles() SK_OVERRIDE { return false; }
private:
virtual SkString getConfigNameInternal() SK_OVERRIDE;
const int fNumThreads;
SkTDArray<SkCanvas*> fCanvasPool;
SkThreadPool fThreadPool;
SkPicture* fPictureClones;
CloneData** fCloneData;
SkCountdown fCountdown;
typedef TiledPictureRenderer 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:
virtual void setup() SK_OVERRIDE;
virtual bool render(const SkString*, SkBitmap** out = NULL) SK_OVERRIDE;
virtual SkString getPerIterTimeFormat() SK_OVERRIDE { return SkString("%.4f"); }
virtual SkString getNormalTimeFormat() SK_OVERRIDE { return SkString("%6.4f"); }
private:
SkAutoTUnref<SkPicture> fReplayer;
virtual SkString getConfigNameInternal() SK_OVERRIDE;
typedef PictureRenderer INHERITED;
};
extern PictureRenderer* CreateGatherPixelRefsRenderer();
extern PictureRenderer* CreatePictureCloneRenderer();
}
#endif // PictureRenderer_DEFINED