/* * 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