2012-11-06 21:29:16 +00:00
|
|
|
/*
|
2012-07-26 17:27:57 +00:00
|
|
|
* 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
|
2012-11-02 21:28:12 +00:00
|
|
|
|
2013-03-04 16:41:06 +00:00
|
|
|
#include "SkCanvas.h"
|
2012-11-06 21:26:13 +00:00
|
|
|
#include "SkDrawFilter.h"
|
2014-06-26 18:26:40 +00:00
|
|
|
#include "SkJSONCPP.h"
|
2012-08-23 20:53:25 +00:00
|
|
|
#include "SkMath.h"
|
2012-11-06 22:14:54 +00:00
|
|
|
#include "SkPaint.h"
|
2012-09-07 15:21:18 +00:00
|
|
|
#include "SkPicture.h"
|
2014-04-18 18:04:41 +00:00
|
|
|
#include "SkPictureRecorder.h"
|
2012-09-18 14:32:35 +00:00
|
|
|
#include "SkRect.h"
|
2012-07-26 17:27:57 +00:00
|
|
|
#include "SkRefCnt.h"
|
2012-09-07 15:21:18 +00:00
|
|
|
#include "SkString.h"
|
2012-11-02 21:28:12 +00:00
|
|
|
#include "SkTDArray.h"
|
|
|
|
#include "SkTypes.h"
|
2012-07-26 17:27:57 +00:00
|
|
|
|
2012-08-20 15:03:33 +00:00
|
|
|
#if SK_SUPPORT_GPU
|
|
|
|
#include "GrContextFactory.h"
|
|
|
|
#include "GrContext.h"
|
|
|
|
#endif
|
|
|
|
|
2014-05-09 03:18:41 +00:00
|
|
|
#include "image_expectations.h"
|
|
|
|
|
2015-05-22 21:01:46 +00:00
|
|
|
struct GrContextOptions;
|
2012-07-26 17:27:57 +00:00
|
|
|
class SkBitmap;
|
|
|
|
class SkCanvas;
|
2014-10-09 12:24:15 +00:00
|
|
|
class SkGLContext;
|
2012-11-02 21:28:12 +00:00
|
|
|
class SkThread;
|
2012-07-26 17:27:57 +00:00
|
|
|
|
|
|
|
namespace sk_tools {
|
|
|
|
|
Provide an option to bench drawing individual tiles in bench_pictures.
Provides output like the following:
running bench [1236 12045] androidpolice.skp
tile_256x256: tile [0,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [1,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [2,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [3,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [4,0] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,1] out of [5,48]: msecs = 2.00
tile_256x256: tile [1,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [2,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [3,1] out of [5,48]: msecs = 6.00
tile_256x256: tile [4,1] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,2] out of [5,48]: msecs = 2.00
BUG=https://code.google.com/p/skia/issues/detail?id=1016
Review URL: https://codereview.appspot.com/6937047
git-svn-id: http://skia.googlecode.com/svn/trunk@6805 2bbb7eff-a529-9590-31e7-b0007b416f81
2012-12-13 22:09:28 +00:00
|
|
|
class TiledPictureRenderer;
|
|
|
|
|
2012-07-26 17:27:57 +00:00
|
|
|
class PictureRenderer : public SkRefCnt {
|
Provide an option to bench drawing individual tiles in bench_pictures.
Provides output like the following:
running bench [1236 12045] androidpolice.skp
tile_256x256: tile [0,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [1,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [2,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [3,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [4,0] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,1] out of [5,48]: msecs = 2.00
tile_256x256: tile [1,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [2,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [3,1] out of [5,48]: msecs = 6.00
tile_256x256: tile [4,1] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,2] out of [5,48]: msecs = 2.00
BUG=https://code.google.com/p/skia/issues/detail?id=1016
Review URL: https://codereview.appspot.com/6937047
git-svn-id: http://skia.googlecode.com/svn/trunk@6805 2bbb7eff-a529-9590-31e7-b0007b416f81
2012-12-13 22:09:28 +00:00
|
|
|
|
2012-07-26 17:27:57 +00:00
|
|
|
public:
|
2012-08-20 15:04:04 +00:00
|
|
|
enum SkDeviceTypes {
|
2013-02-08 19:38:21 +00:00
|
|
|
#if SK_ANGLE
|
|
|
|
kAngle_DeviceType,
|
2014-01-06 18:37:24 +00:00
|
|
|
#endif
|
|
|
|
#if SK_MESA
|
|
|
|
kMesa_DeviceType,
|
2013-02-08 19:38:21 +00:00
|
|
|
#endif
|
2012-08-20 15:04:04 +00:00
|
|
|
kBitmap_DeviceType,
|
|
|
|
#if SK_SUPPORT_GPU
|
2013-02-08 19:38:21 +00:00
|
|
|
kGPU_DeviceType,
|
2014-03-07 18:41:14 +00:00
|
|
|
kNVPR_DeviceType,
|
2012-08-20 15:04:04 +00:00
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
2012-11-02 18:11:49 +00:00
|
|
|
enum BBoxHierarchyType {
|
|
|
|
kNone_BBoxHierarchyType = 0,
|
|
|
|
kRTree_BBoxHierarchyType,
|
2014-03-11 17:27:07 +00:00
|
|
|
|
2015-01-09 14:41:48 +00:00
|
|
|
kLast_BBoxHierarchyType = kRTree_BBoxHierarchyType,
|
2012-11-02 18:11:49 +00:00
|
|
|
};
|
|
|
|
|
2012-11-06 21:26:13 +00:00
|
|
|
// this uses SkPaint::Flags as a base and adds additional flags
|
|
|
|
enum DrawFilterFlags {
|
|
|
|
kNone_DrawFilterFlag = 0,
|
2013-05-22 14:03:45 +00:00
|
|
|
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
|
2013-07-09 14:13:04 +00:00
|
|
|
kMaskFilter_DrawFilterFlag = 0x80000, // toggles on/off mask filters (e.g., blurs)
|
2012-11-06 21:26:13 +00:00
|
|
|
};
|
|
|
|
|
2013-07-03 15:34:35 +00:00
|
|
|
SK_COMPILE_ASSERT(!(kMaskFilter_DrawFilterFlag & SkPaint::kAllFlags), maskfilter_flag_must_be_greater);
|
2012-11-06 21:26:13 +00:00
|
|
|
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);
|
|
|
|
|
2012-11-02 21:28:12 +00:00
|
|
|
/**
|
|
|
|
* Called with each new SkPicture to render.
|
2014-03-19 17:26:07 +00:00
|
|
|
*
|
|
|
|
* @param pict The SkPicture to render.
|
2014-05-15 15:10:48 +00:00
|
|
|
* @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.
|
2014-03-19 17:26:07 +00:00
|
|
|
* @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.
|
2014-10-09 11:59:19 +00:00
|
|
|
* @param useMultiPictureDraw true if MultiPictureDraw should be used for rendering
|
2012-11-02 21:28:12 +00:00
|
|
|
*/
|
2014-08-26 21:07:04 +00:00
|
|
|
virtual void init(const SkPicture* pict,
|
|
|
|
const SkString* writePath,
|
2014-07-07 20:46:35 +00:00
|
|
|
const SkString* mismatchPath,
|
2014-08-26 21:07:04 +00:00
|
|
|
const SkString* inputFilename,
|
2014-10-09 11:59:19 +00:00
|
|
|
bool useChecksumBasedFilenames,
|
|
|
|
bool useMultiPictureDraw);
|
2012-09-07 15:21:18 +00:00
|
|
|
|
2014-05-22 00:36:05 +00:00
|
|
|
/**
|
|
|
|
* 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; }
|
|
|
|
|
2012-12-13 21:40:48 +00:00
|
|
|
/**
|
|
|
|
* Set the viewport so that only the portion listed gets drawn.
|
|
|
|
*/
|
|
|
|
void setViewport(SkISize size) { fViewport = size; }
|
|
|
|
|
2012-12-17 19:25:54 +00:00
|
|
|
/**
|
|
|
|
* Set the scale factor at which draw the picture.
|
|
|
|
*/
|
|
|
|
void setScaleFactor(SkScalar scale) { fScaleFactor = scale; }
|
|
|
|
|
2012-09-07 15:21:18 +00:00
|
|
|
/**
|
|
|
|
* Perform any setup that should done prior to each iteration of render() which should not be
|
|
|
|
* timed.
|
|
|
|
*/
|
|
|
|
virtual void setup() {}
|
|
|
|
|
|
|
|
/**
|
2014-03-19 17:26:07 +00:00
|
|
|
* 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.
|
|
|
|
*
|
2014-05-15 15:10:48 +00:00
|
|
|
* 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.
|
2014-03-19 17:26:07 +00:00
|
|
|
*
|
|
|
|
* @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)
|
2014-05-15 15:10:48 +00:00
|
|
|
* @return bool True if rendering succeeded and, if fWritePath had been specified, the output
|
2014-03-19 17:26:07 +00:00
|
|
|
* was successfully written to a file.
|
2012-09-07 15:21:18 +00:00
|
|
|
*/
|
2014-03-19 17:26:07 +00:00
|
|
|
virtual bool render(SkBitmap** out = NULL) = 0;
|
2012-09-07 15:21:18 +00:00
|
|
|
|
2012-11-02 21:28:12 +00:00
|
|
|
/**
|
|
|
|
* Called once finished with a particular SkPicture, before calling init again, and before
|
|
|
|
* being done with this Renderer.
|
|
|
|
*/
|
2012-08-07 17:11:33 +00:00
|
|
|
virtual void end();
|
2012-11-02 21:28:12 +00:00
|
|
|
|
Provide an option to bench drawing individual tiles in bench_pictures.
Provides output like the following:
running bench [1236 12045] androidpolice.skp
tile_256x256: tile [0,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [1,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [2,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [3,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [4,0] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,1] out of [5,48]: msecs = 2.00
tile_256x256: tile [1,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [2,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [3,1] out of [5,48]: msecs = 6.00
tile_256x256: tile [4,1] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,2] out of [5,48]: msecs = 2.00
BUG=https://code.google.com/p/skia/issues/detail?id=1016
Review URL: https://codereview.appspot.com/6937047
git-svn-id: http://skia.googlecode.com/svn/trunk@6805 2bbb7eff-a529-9590-31e7-b0007b416f81
2012-12-13 22:09:28 +00:00
|
|
|
/**
|
|
|
|
* 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; }
|
|
|
|
|
Change the method for timing individual tiles in bench_pictures.
When timing individual tiles in bench_pictures, keep a timer running
across all repeats, and then take the average. The former method of
timing each iteration separately runs into precision errors on some
platforms.
Running on my Mac Pro with OSX 10.8, the cmsecs for the new method
and the old method are roughly the same when checking the CPU time.
When checking the wall time, the old method often gives me 0ms,
while the new method gives me a larger value. I don't think this
can be entirely attributed to rounding though, since on occasion I
see the old method showing a short time period (.05 - .15ms) while
the new method shows .15ms higher (which is in range for the
difference I'm seeing for other tiles where the old method reports
0ms).
Some other changes:
PictureRenderer::resetState now takes a boolean parameter. If called
with false, it will only do a flush, while if called with true, it
will also call finish.
resetState is now called with true everywhere except in between
iterations of drawing the same tile (when timing individual tiles).
render_pictures_main no longer calls resetState directly, since it
already calls end, which calls resetState.
BUG=http://code.google.com/p/skia/issues/detail?id=1066
Review URL: https://codereview.appspot.com/7101060
git-svn-id: http://skia.googlecode.com/svn/trunk@7424 2bbb7eff-a529-9590-31e7-b0007b416f81
2013-01-28 20:40:24 +00:00
|
|
|
/**
|
|
|
|
* Resets the GPU's state. Does nothing if the backing is raster. For a GPU renderer, calls
|
2014-03-11 22:58:00 +00:00
|
|
|
* flush, swapBuffers and, if callFinish is true, finish.
|
Change the method for timing individual tiles in bench_pictures.
When timing individual tiles in bench_pictures, keep a timer running
across all repeats, and then take the average. The former method of
timing each iteration separately runs into precision errors on some
platforms.
Running on my Mac Pro with OSX 10.8, the cmsecs for the new method
and the old method are roughly the same when checking the CPU time.
When checking the wall time, the old method often gives me 0ms,
while the new method gives me a larger value. I don't think this
can be entirely attributed to rounding though, since on occasion I
see the old method showing a short time period (.05 - .15ms) while
the new method shows .15ms higher (which is in range for the
difference I'm seeing for other tiles where the old method reports
0ms).
Some other changes:
PictureRenderer::resetState now takes a boolean parameter. If called
with false, it will only do a flush, while if called with true, it
will also call finish.
resetState is now called with true everywhere except in between
iterations of drawing the same tile (when timing individual tiles).
render_pictures_main no longer calls resetState directly, since it
already calls end, which calls resetState.
BUG=http://code.google.com/p/skia/issues/detail?id=1066
Review URL: https://codereview.appspot.com/7101060
git-svn-id: http://skia.googlecode.com/svn/trunk@7424 2bbb7eff-a529-9590-31e7-b0007b416f81
2013-01-28 20:40:24 +00:00
|
|
|
* @param callFinish Whether to call finish.
|
|
|
|
*/
|
|
|
|
void resetState(bool callFinish);
|
2012-08-07 17:11:33 +00:00
|
|
|
|
2013-12-18 17:25:33 +00:00
|
|
|
/**
|
|
|
|
* Remove all decoded textures from the CPU caches and all uploaded textures
|
|
|
|
* from the GPU.
|
|
|
|
*/
|
|
|
|
void purgeTextures();
|
|
|
|
|
2013-02-08 19:38:21 +00:00
|
|
|
/**
|
|
|
|
* Set the backend type. Returns true on success and false on failure.
|
|
|
|
*/
|
2014-06-30 13:36:31 +00:00
|
|
|
#if SK_SUPPORT_GPU
|
|
|
|
bool setDeviceType(SkDeviceTypes deviceType, GrGLStandard gpuAPI = kNone_GrGLStandard) {
|
|
|
|
#else
|
2013-02-08 19:38:21 +00:00
|
|
|
bool setDeviceType(SkDeviceTypes deviceType) {
|
2014-06-30 13:36:31 +00:00
|
|
|
#endif
|
2012-08-20 15:04:04 +00:00
|
|
|
fDeviceType = deviceType;
|
2013-02-08 19:38:21 +00:00
|
|
|
#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;
|
2014-03-07 18:41:14 +00:00
|
|
|
case kNVPR_DeviceType:
|
|
|
|
glContextType = GrContextFactory::kNVPR_GLContextType;
|
|
|
|
break;
|
2013-02-08 19:38:21 +00:00
|
|
|
#if SK_ANGLE
|
|
|
|
case kAngle_DeviceType:
|
|
|
|
glContextType = GrContextFactory::kANGLE_GLContextType;
|
|
|
|
break;
|
|
|
|
#endif
|
2014-01-06 18:37:24 +00:00
|
|
|
#if SK_MESA
|
|
|
|
case kMesa_DeviceType:
|
|
|
|
glContextType = GrContextFactory::kMESA_GLContextType;
|
|
|
|
break;
|
|
|
|
#endif
|
2013-02-08 19:38:21 +00:00
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
// Invalid device type.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#if SK_SUPPORT_GPU
|
2014-06-30 13:36:31 +00:00
|
|
|
fGrContext = fGrContextFactory.get(glContextType, gpuAPI);
|
2013-02-08 19:38:21 +00:00
|
|
|
if (NULL == fGrContext) {
|
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
fGrContext->ref();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
#endif
|
2012-08-20 15:03:41 +00:00
|
|
|
}
|
|
|
|
|
2013-05-02 12:39:37 +00:00
|
|
|
#if SK_SUPPORT_GPU
|
|
|
|
void setSampleCount(int sampleCount) {
|
|
|
|
fSampleCount = sampleCount;
|
|
|
|
}
|
2014-11-07 15:12:46 +00:00
|
|
|
|
|
|
|
void setUseDFText(bool useDFText) {
|
|
|
|
fUseDFText = useDFText;
|
|
|
|
}
|
2013-05-02 12:39:37 +00:00
|
|
|
#endif
|
|
|
|
|
2012-11-07 16:42:17 +00:00
|
|
|
void setDrawFilters(DrawFilterFlags const * const filters, const SkString& configName) {
|
|
|
|
memcpy(fDrawFilters, filters, sizeof(fDrawFilters));
|
2012-11-06 21:26:13 +00:00
|
|
|
fDrawFiltersConfig = configName;
|
|
|
|
}
|
|
|
|
|
2012-11-02 18:11:49 +00:00
|
|
|
void setBBoxHierarchyType(BBoxHierarchyType bbhType) {
|
|
|
|
fBBoxHierarchyType = bbhType;
|
|
|
|
}
|
|
|
|
|
2013-03-13 17:27:16 +00:00
|
|
|
BBoxHierarchyType getBBoxHierarchyType() { return fBBoxHierarchyType; }
|
|
|
|
|
2014-05-12 15:37:20 +00:00
|
|
|
void setJsonSummaryPtr(ImageResultsAndExpectations* jsonSummaryPtr) {
|
2013-12-13 20:52:36 +00:00
|
|
|
fJsonSummaryPtr = jsonSummaryPtr;
|
|
|
|
}
|
|
|
|
|
2012-08-20 15:03:41 +00:00
|
|
|
bool isUsingBitmapDevice() {
|
2012-08-20 15:03:44 +00:00
|
|
|
return kBitmap_DeviceType == fDeviceType;
|
2012-08-20 15:03:29 +00:00
|
|
|
}
|
|
|
|
|
2012-09-07 15:21:18 +00:00
|
|
|
virtual SkString getPerIterTimeFormat() { return SkString("%.2f"); }
|
|
|
|
|
|
|
|
virtual SkString getNormalTimeFormat() { return SkString("%6.2f"); }
|
|
|
|
|
2012-11-02 22:01:26 +00:00
|
|
|
/**
|
|
|
|
* Reports the configuration of this PictureRenderer.
|
|
|
|
*/
|
|
|
|
SkString getConfigName() {
|
|
|
|
SkString config = this->getConfigNameInternal();
|
2012-12-13 22:07:08 +00:00
|
|
|
if (!fViewport.isEmpty()) {
|
|
|
|
config.appendf("_viewport_%ix%i", fViewport.width(), fViewport.height());
|
|
|
|
}
|
2013-12-20 21:49:33 +00:00
|
|
|
if (fScaleFactor != SK_Scalar1) {
|
|
|
|
config.appendf("_scalar_%f", SkScalarToFloat(fScaleFactor));
|
|
|
|
}
|
2012-11-02 22:01:26 +00:00
|
|
|
if (kRTree_BBoxHierarchyType == fBBoxHierarchyType) {
|
|
|
|
config.append("_rtree");
|
|
|
|
}
|
|
|
|
#if SK_SUPPORT_GPU
|
2013-02-13 13:26:13 +00:00
|
|
|
switch (fDeviceType) {
|
2013-02-08 19:38:21 +00:00
|
|
|
case kGPU_DeviceType:
|
2013-05-02 12:39:37 +00:00
|
|
|
if (fSampleCount) {
|
|
|
|
config.appendf("_msaa%d", fSampleCount);
|
2014-11-07 15:12:46 +00:00
|
|
|
} else if (fUseDFText) {
|
|
|
|
config.append("_gpudft");
|
2013-05-02 12:39:37 +00:00
|
|
|
} else {
|
|
|
|
config.append("_gpu");
|
|
|
|
}
|
2013-02-08 19:38:21 +00:00
|
|
|
break;
|
2014-03-07 18:41:14 +00:00
|
|
|
case kNVPR_DeviceType:
|
|
|
|
config.appendf("_nvprmsaa%d", fSampleCount);
|
|
|
|
break;
|
2013-02-08 19:38:21 +00:00
|
|
|
#if SK_ANGLE
|
|
|
|
case kAngle_DeviceType:
|
|
|
|
config.append("_angle");
|
|
|
|
break;
|
2014-01-06 18:37:24 +00:00
|
|
|
#endif
|
|
|
|
#if SK_MESA
|
|
|
|
case kMesa_DeviceType:
|
|
|
|
config.append("_mesa");
|
|
|
|
break;
|
2012-11-02 22:01:26 +00:00
|
|
|
#endif
|
2013-02-08 19:38:21 +00:00
|
|
|
default:
|
|
|
|
// Assume that no extra info means bitmap.
|
|
|
|
break;
|
|
|
|
}
|
2013-02-13 13:26:13 +00:00
|
|
|
#endif
|
2012-11-06 21:26:13 +00:00
|
|
|
config.append(fDrawFiltersConfig.c_str());
|
2012-11-02 22:01:26 +00:00
|
|
|
return config;
|
|
|
|
}
|
|
|
|
|
2014-06-26 18:26:40 +00:00
|
|
|
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();
|
2014-11-07 15:12:46 +00:00
|
|
|
} else if (fUseDFText) {
|
|
|
|
result["config"] = "gpudft";
|
2014-06-26 18:26:40 +00:00
|
|
|
} 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;
|
|
|
|
}
|
|
|
|
|
2012-08-20 15:03:29 +00:00
|
|
|
#if SK_SUPPORT_GPU
|
2012-08-20 15:03:41 +00:00
|
|
|
bool isUsingGpuDevice() {
|
2013-02-08 19:38:21 +00:00
|
|
|
switch (fDeviceType) {
|
|
|
|
case kGPU_DeviceType:
|
2014-03-07 18:41:14 +00:00
|
|
|
case kNVPR_DeviceType:
|
2013-02-08 19:38:21 +00:00
|
|
|
// fall through
|
|
|
|
#if SK_ANGLE
|
|
|
|
case kAngle_DeviceType:
|
2014-01-06 18:37:24 +00:00
|
|
|
// fall through
|
|
|
|
#endif
|
|
|
|
#if SK_MESA
|
|
|
|
case kMesa_DeviceType:
|
2013-02-08 19:38:21 +00:00
|
|
|
#endif
|
|
|
|
return true;
|
|
|
|
default:
|
|
|
|
return false;
|
|
|
|
}
|
2012-08-20 15:03:41 +00:00
|
|
|
}
|
2012-08-20 15:03:47 +00:00
|
|
|
|
2014-10-09 12:24:15 +00:00
|
|
|
SkGLContext* getGLContext() {
|
2013-02-08 19:38:21 +00:00
|
|
|
GrContextFactory::GLContextType glContextType
|
|
|
|
= GrContextFactory::kNull_GLContextType;
|
|
|
|
switch(fDeviceType) {
|
|
|
|
case kGPU_DeviceType:
|
|
|
|
glContextType = GrContextFactory::kNative_GLContextType;
|
|
|
|
break;
|
2014-03-07 18:41:14 +00:00
|
|
|
case kNVPR_DeviceType:
|
|
|
|
glContextType = GrContextFactory::kNVPR_GLContextType;
|
|
|
|
break;
|
2013-02-08 19:38:21 +00:00
|
|
|
#if SK_ANGLE
|
|
|
|
case kAngle_DeviceType:
|
|
|
|
glContextType = GrContextFactory::kANGLE_GLContextType;
|
|
|
|
break;
|
2014-01-06 18:37:24 +00:00
|
|
|
#endif
|
|
|
|
#if SK_MESA
|
|
|
|
case kMesa_DeviceType:
|
|
|
|
glContextType = GrContextFactory::kMESA_GLContextType;
|
|
|
|
break;
|
2013-02-08 19:38:21 +00:00
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
return NULL;
|
2012-08-20 15:03:47 +00:00
|
|
|
}
|
2013-02-08 19:38:21 +00:00
|
|
|
return fGrContextFactory.getGLContext(glContextType);
|
2012-08-20 15:03:47 +00:00
|
|
|
}
|
2012-09-13 15:40:37 +00:00
|
|
|
|
|
|
|
GrContext* getGrContext() {
|
|
|
|
return fGrContext;
|
|
|
|
}
|
2014-08-18 14:52:17 +00:00
|
|
|
|
2015-05-22 21:01:46 +00:00
|
|
|
const GrContextOptions& getGrContextOptions() {
|
2014-08-18 14:52:17 +00:00
|
|
|
return fGrContextFactory.getGlobalOptions();
|
|
|
|
}
|
2012-08-20 15:03:29 +00:00
|
|
|
#endif
|
|
|
|
|
2014-03-16 19:46:36 +00:00
|
|
|
SkCanvas* getCanvas() {
|
|
|
|
return fCanvas;
|
|
|
|
}
|
|
|
|
|
2014-07-07 20:46:35 +00:00
|
|
|
const SkPicture* getPicture() {
|
2014-03-31 17:55:12 +00:00
|
|
|
return fPicture;
|
|
|
|
}
|
2014-08-26 21:07:04 +00:00
|
|
|
|
2014-08-18 14:52:17 +00:00
|
|
|
#if SK_SUPPORT_GPU
|
2015-05-22 21:01:46 +00:00
|
|
|
explicit PictureRenderer(const GrContextOptions &opts)
|
2014-08-18 14:52:17 +00:00
|
|
|
#else
|
2012-08-20 15:03:36 +00:00
|
|
|
PictureRenderer()
|
2014-08-18 14:52:17 +00:00
|
|
|
#endif
|
2014-04-13 19:09:42 +00:00
|
|
|
: fJsonSummaryPtr(NULL)
|
2012-08-20 15:03:33 +00:00
|
|
|
, fDeviceType(kBitmap_DeviceType)
|
2014-05-22 00:36:05 +00:00
|
|
|
, fEnableWrites(false)
|
2012-11-02 19:16:22 +00:00
|
|
|
, fBBoxHierarchyType(kNone_BBoxHierarchyType)
|
2013-02-08 21:16:19 +00:00
|
|
|
, fScaleFactor(SK_Scalar1)
|
2012-08-20 15:03:33 +00:00
|
|
|
#if SK_SUPPORT_GPU
|
2014-08-18 14:52:17 +00:00
|
|
|
, fGrContextFactory(opts)
|
2013-02-08 19:38:21 +00:00
|
|
|
, fGrContext(NULL)
|
2013-05-02 12:39:37 +00:00
|
|
|
, fSampleCount(0)
|
2014-11-07 15:12:46 +00:00
|
|
|
, fUseDFText(false)
|
2012-08-20 15:03:33 +00:00
|
|
|
#endif
|
2012-11-07 16:42:17 +00:00
|
|
|
{
|
|
|
|
sk_bzero(fDrawFilters, sizeof(fDrawFilters));
|
2012-12-13 21:40:48 +00:00
|
|
|
fViewport.set(0, 0);
|
2012-11-07 16:42:17 +00:00
|
|
|
}
|
2012-08-20 15:03:33 +00:00
|
|
|
|
2013-02-08 19:38:21 +00:00
|
|
|
#if SK_SUPPORT_GPU
|
|
|
|
virtual ~PictureRenderer() {
|
|
|
|
SkSafeUnref(fGrContext);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2012-08-07 17:11:33 +00:00
|
|
|
protected:
|
|
|
|
SkAutoTUnref<SkCanvas> fCanvas;
|
2014-07-07 20:46:35 +00:00
|
|
|
SkAutoTUnref<const SkPicture> fPicture;
|
2014-03-19 17:26:07 +00:00
|
|
|
bool fUseChecksumBasedFilenames;
|
2014-10-09 11:59:19 +00:00
|
|
|
bool fUseMultiPictureDraw;
|
2014-05-12 15:37:20 +00:00
|
|
|
ImageResultsAndExpectations* fJsonSummaryPtr;
|
2012-12-13 21:40:48 +00:00
|
|
|
SkDeviceTypes fDeviceType;
|
2014-05-22 00:36:05 +00:00
|
|
|
bool fEnableWrites;
|
2012-12-13 21:40:48 +00:00
|
|
|
BBoxHierarchyType fBBoxHierarchyType;
|
|
|
|
DrawFilterFlags fDrawFilters[SkDrawFilter::kTypeCount];
|
|
|
|
SkString fDrawFiltersConfig;
|
2014-05-15 15:10:48 +00:00
|
|
|
SkString fWritePath;
|
|
|
|
SkString fMismatchPath;
|
2014-03-19 17:26:07 +00:00
|
|
|
SkString fInputFilename;
|
2012-08-20 15:03:33 +00:00
|
|
|
|
2012-12-13 21:40:48 +00:00
|
|
|
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();
|
|
|
|
|
2012-12-17 19:25:54 +00:00
|
|
|
/**
|
|
|
|
* Scales the provided canvas to the scale factor set by setScaleFactor.
|
|
|
|
*/
|
|
|
|
void scaleToScaleFactor(SkCanvas*);
|
|
|
|
|
2014-04-17 23:35:06 +00:00
|
|
|
SkBBHFactory* getFactory();
|
2014-06-09 13:25:34 +00:00
|
|
|
uint32_t recordFlags() const { return 0; }
|
2012-12-13 21:40:48 +00:00
|
|
|
SkCanvas* setupCanvas();
|
|
|
|
virtual SkCanvas* setupCanvas(int width, int height);
|
|
|
|
|
2014-03-19 17:26:07 +00:00
|
|
|
/**
|
|
|
|
* Copy src to dest; if src==NULL, set dest to empty string.
|
|
|
|
*/
|
|
|
|
static void CopyString(SkString* dest, const SkString* src);
|
|
|
|
|
2012-08-07 17:11:33 +00:00
|
|
|
private:
|
2012-12-13 21:40:48 +00:00
|
|
|
SkISize fViewport;
|
2012-12-17 19:25:54 +00:00
|
|
|
SkScalar fScaleFactor;
|
2013-02-08 19:38:21 +00:00
|
|
|
#if SK_SUPPORT_GPU
|
|
|
|
GrContextFactory fGrContextFactory;
|
|
|
|
GrContext* fGrContext;
|
2013-05-02 12:39:37 +00:00
|
|
|
int fSampleCount;
|
2014-11-07 15:12:46 +00:00
|
|
|
bool fUseDFText;
|
2013-02-08 19:38:21 +00:00
|
|
|
#endif
|
2012-12-13 21:40:48 +00:00
|
|
|
|
2012-11-02 22:01:26 +00:00
|
|
|
virtual SkString getConfigNameInternal() = 0;
|
|
|
|
|
2012-08-07 17:11:33 +00:00
|
|
|
typedef SkRefCnt INHERITED;
|
2012-07-26 17:27:57 +00:00
|
|
|
};
|
|
|
|
|
2012-09-07 15:21:18 +00:00
|
|
|
/**
|
|
|
|
* This class does not do any rendering, but its render function executes recording, which we want
|
|
|
|
* to time.
|
|
|
|
*/
|
|
|
|
class RecordPictureRenderer : public PictureRenderer {
|
2014-08-18 14:52:17 +00:00
|
|
|
public:
|
|
|
|
#if SK_SUPPORT_GPU
|
2015-05-22 21:01:46 +00:00
|
|
|
RecordPictureRenderer(const GrContextOptions &opts) : INHERITED(opts) { }
|
2014-08-18 14:52:17 +00:00
|
|
|
#endif
|
|
|
|
|
2015-03-26 01:17:31 +00:00
|
|
|
bool render(SkBitmap** out = NULL) override;
|
2012-09-07 15:21:18 +00:00
|
|
|
|
2015-03-26 01:17:31 +00:00
|
|
|
SkString getPerIterTimeFormat() override { return SkString("%.4f"); }
|
2012-09-07 15:21:18 +00:00
|
|
|
|
2015-03-26 01:17:31 +00:00
|
|
|
SkString getNormalTimeFormat() override { return SkString("%6.4f"); }
|
2012-11-02 22:01:26 +00:00
|
|
|
|
2012-11-06 16:54:40 +00:00
|
|
|
protected:
|
2015-03-26 01:17:31 +00:00
|
|
|
SkCanvas* setupCanvas(int width, int height) override;
|
2012-11-06 16:54:40 +00:00
|
|
|
|
2012-11-02 22:01:26 +00:00
|
|
|
private:
|
2015-03-26 01:17:31 +00:00
|
|
|
SkString getConfigNameInternal() override;
|
2014-08-18 14:52:17 +00:00
|
|
|
|
|
|
|
typedef PictureRenderer INHERITED;
|
2012-09-07 15:21:18 +00:00
|
|
|
};
|
|
|
|
|
2012-07-26 17:27:57 +00:00
|
|
|
class PipePictureRenderer : public PictureRenderer {
|
2012-08-01 17:53:29 +00:00
|
|
|
public:
|
2014-08-18 14:52:17 +00:00
|
|
|
#if SK_SUPPORT_GPU
|
2015-05-22 21:01:46 +00:00
|
|
|
PipePictureRenderer(const GrContextOptions &opts) : INHERITED(opts) { }
|
2014-08-18 14:52:17 +00:00
|
|
|
#endif
|
|
|
|
|
2015-03-26 01:17:31 +00:00
|
|
|
bool render(SkBitmap** out = NULL) override;
|
2012-08-07 17:11:33 +00:00
|
|
|
|
|
|
|
private:
|
2015-03-26 01:17:31 +00:00
|
|
|
SkString getConfigNameInternal() override;
|
2012-11-02 22:01:26 +00:00
|
|
|
|
2012-08-07 17:11:33 +00:00
|
|
|
typedef PictureRenderer INHERITED;
|
2012-07-26 17:27:57 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
class SimplePictureRenderer : public PictureRenderer {
|
2012-08-01 17:53:29 +00:00
|
|
|
public:
|
2014-08-18 14:52:17 +00:00
|
|
|
#if SK_SUPPORT_GPU
|
2015-05-22 21:01:46 +00:00
|
|
|
SimplePictureRenderer(const GrContextOptions &opts) : INHERITED(opts) { }
|
2014-08-18 14:52:17 +00:00
|
|
|
#endif
|
|
|
|
|
2014-07-07 20:46:35 +00:00
|
|
|
virtual void init(const SkPicture* pict,
|
2014-08-26 21:07:04 +00:00
|
|
|
const SkString* writePath,
|
2014-07-07 20:46:35 +00:00
|
|
|
const SkString* mismatchPath,
|
2014-08-26 21:07:04 +00:00
|
|
|
const SkString* inputFilename,
|
2014-10-09 11:59:19 +00:00
|
|
|
bool useChecksumBasedFilenames,
|
2015-03-26 01:17:31 +00:00
|
|
|
bool useMultiPictureDraw) override;
|
2012-11-02 18:11:49 +00:00
|
|
|
|
2015-03-26 01:17:31 +00:00
|
|
|
bool render(SkBitmap** out = NULL) override;
|
2012-08-07 17:11:33 +00:00
|
|
|
|
|
|
|
private:
|
2015-03-26 01:17:31 +00:00
|
|
|
SkString getConfigNameInternal() override;
|
2012-11-02 22:01:26 +00:00
|
|
|
|
2012-08-07 17:11:33 +00:00
|
|
|
typedef PictureRenderer INHERITED;
|
2012-07-26 17:27:57 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
class TiledPictureRenderer : public PictureRenderer {
|
|
|
|
public:
|
2014-08-18 14:52:17 +00:00
|
|
|
#if SK_SUPPORT_GPU
|
2015-05-22 21:01:46 +00:00
|
|
|
TiledPictureRenderer(const GrContextOptions &opts);
|
2014-08-18 14:52:17 +00:00
|
|
|
#else
|
2012-07-26 17:27:57 +00:00
|
|
|
TiledPictureRenderer();
|
2014-08-18 14:52:17 +00:00
|
|
|
#endif
|
2012-07-26 17:27:57 +00:00
|
|
|
|
2014-08-26 21:07:04 +00:00
|
|
|
virtual void init(const SkPicture* pict,
|
|
|
|
const SkString* writePath,
|
2014-07-07 20:46:35 +00:00
|
|
|
const SkString* mismatchPath,
|
2014-08-26 21:07:04 +00:00
|
|
|
const SkString* inputFilename,
|
2014-10-09 11:59:19 +00:00
|
|
|
bool useChecksumBasedFilenames,
|
2015-03-26 01:17:31 +00:00
|
|
|
bool useMultiPictureDraw) override;
|
2012-09-20 14:54:21 +00:00
|
|
|
|
|
|
|
/**
|
2014-03-19 17:26:07 +00:00
|
|
|
* Renders to tiles, rather than a single canvas.
|
2014-05-15 15:10:48 +00:00
|
|
|
* If fWritePath was provided, a separate file is
|
2012-09-20 14:54:21 +00:00
|
|
|
* created for each tile, named "path0.png", "path1.png", etc.
|
|
|
|
*/
|
2015-03-26 01:17:31 +00:00
|
|
|
bool render(SkBitmap** out = NULL) override;
|
2012-09-20 14:54:21 +00:00
|
|
|
|
2015-03-26 01:17:31 +00:00
|
|
|
void end() override;
|
2012-07-26 17:27:57 +00:00
|
|
|
|
2012-07-27 20:09:26 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2012-08-01 17:53:29 +00:00
|
|
|
double getTileWidthPercentage() const {
|
2012-07-27 20:09:26 +00:00
|
|
|
return fTileWidthPercentage;
|
|
|
|
}
|
|
|
|
|
|
|
|
void setTileHeightPercentage(double percentage) {
|
|
|
|
fTileHeightPercentage = percentage;
|
|
|
|
}
|
|
|
|
|
2012-08-01 17:53:29 +00:00
|
|
|
double getTileHeightPercentage() const {
|
2012-07-27 20:09:26 +00:00
|
|
|
return fTileHeightPercentage;
|
|
|
|
}
|
|
|
|
|
2012-08-23 20:53:25 +00:00
|
|
|
void setTileMinPowerOf2Width(int width) {
|
|
|
|
SkASSERT(SkIsPow2(width) && width > 0);
|
|
|
|
if (!SkIsPow2(width) || width <= 0) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
fTileMinPowerOf2Width = width;
|
|
|
|
}
|
|
|
|
|
|
|
|
int getTileMinPowerOf2Width() const {
|
|
|
|
return fTileMinPowerOf2Width;
|
|
|
|
}
|
|
|
|
|
2015-03-26 01:17:31 +00:00
|
|
|
TiledPictureRenderer* getTiledRenderer() override { return this; }
|
Provide an option to bench drawing individual tiles in bench_pictures.
Provides output like the following:
running bench [1236 12045] androidpolice.skp
tile_256x256: tile [0,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [1,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [2,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [3,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [4,0] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,1] out of [5,48]: msecs = 2.00
tile_256x256: tile [1,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [2,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [3,1] out of [5,48]: msecs = 6.00
tile_256x256: tile [4,1] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,2] out of [5,48]: msecs = 2.00
BUG=https://code.google.com/p/skia/issues/detail?id=1016
Review URL: https://codereview.appspot.com/6937047
git-svn-id: http://skia.googlecode.com/svn/trunk@6805 2bbb7eff-a529-9590-31e7-b0007b416f81
2012-12-13 22:09:28 +00:00
|
|
|
|
2013-03-04 16:41:06 +00:00
|
|
|
virtual bool supportsTimingIndividualTiles() { return true; }
|
|
|
|
|
Provide an option to bench drawing individual tiles in bench_pictures.
Provides output like the following:
running bench [1236 12045] androidpolice.skp
tile_256x256: tile [0,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [1,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [2,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [3,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [4,0] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,1] out of [5,48]: msecs = 2.00
tile_256x256: tile [1,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [2,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [3,1] out of [5,48]: msecs = 6.00
tile_256x256: tile [4,1] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,2] out of [5,48]: msecs = 2.00
BUG=https://code.google.com/p/skia/issues/detail?id=1016
Review URL: https://codereview.appspot.com/6937047
git-svn-id: http://skia.googlecode.com/svn/trunk@6805 2bbb7eff-a529-9590-31e7-b0007b416f81
2012-12-13 22:09:28 +00:00
|
|
|
/**
|
|
|
|
* 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();
|
|
|
|
|
2012-11-02 21:28:12 +00:00
|
|
|
protected:
|
2014-10-09 11:59:19 +00:00
|
|
|
SkTDArray<SkIRect> fTileRects;
|
2012-07-26 17:27:57 +00:00
|
|
|
|
2015-03-26 01:17:31 +00:00
|
|
|
SkCanvas* setupCanvas(int width, int height) override;
|
|
|
|
SkString getConfigNameInternal() override;
|
2012-11-02 22:01:26 +00:00
|
|
|
|
2012-07-26 17:27:57 +00:00
|
|
|
private:
|
Provide an option to bench drawing individual tiles in bench_pictures.
Provides output like the following:
running bench [1236 12045] androidpolice.skp
tile_256x256: tile [0,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [1,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [2,0] out of [5,48]: msecs = 1.00
tile_256x256: tile [3,0] out of [5,48]: msecs = 1.50
tile_256x256: tile [4,0] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,1] out of [5,48]: msecs = 2.00
tile_256x256: tile [1,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [2,1] out of [5,48]: msecs = 3.50
tile_256x256: tile [3,1] out of [5,48]: msecs = 6.00
tile_256x256: tile [4,1] out of [5,48]: msecs = 2.50
tile_256x256: tile [0,2] out of [5,48]: msecs = 2.00
BUG=https://code.google.com/p/skia/issues/detail?id=1016
Review URL: https://codereview.appspot.com/6937047
git-svn-id: http://skia.googlecode.com/svn/trunk@6805 2bbb7eff-a529-9590-31e7-b0007b416f81
2012-12-13 22:09:28 +00:00
|
|
|
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;
|
2012-09-20 14:42:33 +00:00
|
|
|
|
2012-08-07 17:11:33 +00:00
|
|
|
void setupTiles();
|
2012-08-23 20:53:25 +00:00
|
|
|
void setupPowerOf2Tiles();
|
2015-01-09 14:41:48 +00:00
|
|
|
bool postRender(SkCanvas*, const SkIRect& tileRect,
|
2014-10-09 11:59:19 +00:00
|
|
|
SkBitmap* tempBM, SkBitmap** out,
|
|
|
|
int tileNumber);
|
2012-08-07 17:11:33 +00:00
|
|
|
|
|
|
|
typedef PictureRenderer INHERITED;
|
2012-07-26 17:27:57 +00:00
|
|
|
};
|
|
|
|
|
2012-09-07 15:21:18 +00:00
|
|
|
/**
|
|
|
|
* 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:
|
2014-08-18 14:52:17 +00:00
|
|
|
#if SK_SUPPORT_GPU
|
2015-05-22 21:01:46 +00:00
|
|
|
PlaybackCreationRenderer(const GrContextOptions &opts) : INHERITED(opts) { }
|
2014-08-18 14:52:17 +00:00
|
|
|
#endif
|
|
|
|
|
2015-03-26 01:17:31 +00:00
|
|
|
void setup() override;
|
2012-09-07 15:21:18 +00:00
|
|
|
|
2015-03-26 01:17:31 +00:00
|
|
|
bool render(SkBitmap** out = NULL) override;
|
2012-09-07 15:21:18 +00:00
|
|
|
|
2015-03-26 01:17:31 +00:00
|
|
|
SkString getPerIterTimeFormat() override { return SkString("%.4f"); }
|
2012-09-07 15:21:18 +00:00
|
|
|
|
2015-03-26 01:17:31 +00:00
|
|
|
SkString getNormalTimeFormat() override { return SkString("%6.4f"); }
|
2012-09-07 15:21:18 +00:00
|
|
|
|
|
|
|
private:
|
2014-04-13 19:09:42 +00:00
|
|
|
SkAutoTDelete<SkPictureRecorder> fRecorder;
|
2012-11-02 22:01:26 +00:00
|
|
|
|
2015-03-26 01:17:31 +00:00
|
|
|
SkString getConfigNameInternal() override;
|
2012-11-02 22:01:26 +00:00
|
|
|
|
2012-09-07 15:21:18 +00:00
|
|
|
typedef PictureRenderer INHERITED;
|
|
|
|
};
|
|
|
|
|
2014-08-18 14:52:17 +00:00
|
|
|
#if SK_SUPPORT_GPU
|
2015-05-22 21:01:46 +00:00
|
|
|
extern PictureRenderer* CreateGatherPixelRefsRenderer(const GrContextOptions& opts);
|
2014-08-18 14:52:17 +00:00
|
|
|
#else
|
2012-11-29 21:00:39 +00:00
|
|
|
extern PictureRenderer* CreateGatherPixelRefsRenderer();
|
2014-08-18 14:52:17 +00:00
|
|
|
#endif
|
2012-11-29 21:00:39 +00:00
|
|
|
|
2012-07-26 17:27:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif // PictureRenderer_DEFINED
|