GrGLFragmentProcessor* GrColorCubeEffect::createGLInstance() const {
return SkNEW_ARGS(GLProcessor, (*this));
}
SkBicubicImageFilter* SkBicubicImageFilter::CreateMitchell(const SkSize& scale,
SkImageFilter* input) {
return SkNEW_ARGS(SkBicubicImageFilter, (scale, gMitchellCoefficients, input));
}
/* Called once (ensured by the sentinel check at the beginning of our body).
Initializes all the globals, and register the system fonts.
*/
static void load_system_fonts() {
// check if we've already be called
if (NULL != gDefaultNormal) {
return;
}
const FontInitRec* rec = gSystemFonts;
SkTypeface* firstInFamily = NULL;
int fallbackCount = 0;
for (size_t i = 0; i < SK_ARRAY_COUNT(gSystemFonts); i++) {
// if we're the first in a new family, clear firstInFamily
if (rec[i].fNames != NULL) {
firstInFamily = NULL;
}
bool isFixedWidth;
SkString name;
SkTypeface::Style style;
// we expect all the fonts, except the "fallback" fonts
bool isExpected = (rec[i].fNames != gFBNames);
if (!get_name_and_style(rec[i].fFileName, &name, &style,
&isFixedWidth, isExpected)) {
continue;
}
SkTypeface* tf = SkNEW_ARGS(FileTypeface,
(style,
true, // system-font (cannot delete)
firstInFamily, // what family to join
rec[i].fFileName,
isFixedWidth) // filename
);
if (rec[i].fNames != NULL) {
// see if this is one of our fallback fonts
if (rec[i].fNames == gFBNames) {
// SkDebugf("---- adding %s as fallback[%d] fontID %d\n",
// rec[i].fFileName, fallbackCount, tf->uniqueID());
gFallbackFonts[fallbackCount++] = tf->uniqueID();
}
firstInFamily = tf;
FamilyRec* family = find_family(tf);
const char* const* names = rec[i].fNames;
// record the default family if this is it
if (names == DEFAULT_NAMES) {
gDefaultFamily = family;
}
// add the names to map to this family
while (*names) {
add_name(*names, family);
names += 1;
}
}
}
// do this after all fonts are loaded. This is our default font, and it
// acts as a sentinel so we only execute load_system_fonts() once
gDefaultNormal = find_best_face(gDefaultFamily, SkTypeface::kNormal);
// now terminate our fallback list with the sentinel value
gFallbackFonts[fallbackCount] = 0;
}
/*
* Assumes IsIco was called and returned true
* Creates an Ico decoder
* Reads enough of the stream to determine the image format
*/
SkCodec* SkIcoCodec::NewFromStream(SkStream* stream) {
// Ensure that we do not leak the input stream
SkAutoTDelete<SkStream> inputStream(stream);
// Header size constants
static const uint32_t kIcoDirectoryBytes = 6;
static const uint32_t kIcoDirEntryBytes = 16;
// Read the directory header
SkAutoTDeleteArray<uint8_t> dirBuffer(
SkNEW_ARRAY(uint8_t, kIcoDirectoryBytes));
if (inputStream.get()->read(dirBuffer.get(), kIcoDirectoryBytes) !=
kIcoDirectoryBytes) {
SkCodecPrintf("Error: unable to read ico directory header.\n");
return NULL;
}
// Process the directory header
const uint16_t numImages = get_short(dirBuffer.get(), 4);
if (0 == numImages) {
SkCodecPrintf("Error: No images embedded in ico.\n");
return NULL;
}
// Ensure that we can read all of indicated directory entries
SkAutoTDeleteArray<uint8_t> entryBuffer(
SkNEW_ARRAY(uint8_t, numImages*kIcoDirEntryBytes));
if (inputStream.get()->read(entryBuffer.get(), numImages*kIcoDirEntryBytes) !=
numImages*kIcoDirEntryBytes) {
SkCodecPrintf("Error: unable to read ico directory entries.\n");
return NULL;
}
// This structure is used to represent the vital information about entries
// in the directory header. We will obtain this information for each
// directory entry.
struct Entry {
uint32_t offset;
uint32_t size;
};
SkAutoTDeleteArray<Entry> directoryEntries(SkNEW_ARRAY(Entry, numImages));
// Iterate over directory entries
for (uint32_t i = 0; i < numImages; i++) {
// The directory entry contains information such as width, height,
// bits per pixel, and number of colors in the color palette. We will
// ignore these fields since they are repeated in the header of the
// embedded image. In the event of an inconsistency, we would always
// defer to the value in the embedded header anyway.
// Specifies the size of the embedded image, including the header
uint32_t size = get_int(entryBuffer.get(), 8 + i*kIcoDirEntryBytes);
// Specifies the offset of the embedded image from the start of file.
// It does not indicate the start of the pixel data, but rather the
// start of the embedded image header.
uint32_t offset = get_int(entryBuffer.get(), 12 + i*kIcoDirEntryBytes);
// Save the vital fields
directoryEntries.get()[i].offset = offset;
directoryEntries.get()[i].size = size;
}
// It is "customary" that the embedded images will be stored in order of
// increasing offset. However, the specification does not indicate that
// they must be stored in this order, so we will not trust that this is the
// case. Here we sort the embedded images by increasing offset.
struct EntryLessThan {
bool operator() (Entry a, Entry b) const {
return a.offset < b.offset;
}
};
EntryLessThan lessThan;
SkTQSort(directoryEntries.get(), directoryEntries.get() + numImages - 1,
lessThan);
// Now will construct a candidate codec for each of the embedded images
uint32_t bytesRead = kIcoDirectoryBytes + numImages * kIcoDirEntryBytes;
SkAutoTDelete<SkTArray<SkAutoTDelete<SkCodec>, true>> codecs(
SkNEW_ARGS((SkTArray<SkAutoTDelete<SkCodec>, true>), (numImages)));
for (uint32_t i = 0; i < numImages; i++) {
uint32_t offset = directoryEntries.get()[i].offset;
uint32_t size = directoryEntries.get()[i].size;
// Ensure that the offset is valid
if (offset < bytesRead) {
SkCodecPrintf("Warning: invalid ico offset.\n");
continue;
}
// If we cannot skip, assume we have reached the end of the stream and
// stop trying to make codecs
if (inputStream.get()->skip(offset - bytesRead) != offset - bytesRead) {
SkCodecPrintf("Warning: could not skip to ico offset.\n");
break;
}
bytesRead = offset;
// Create a new stream for the embedded codec
SkAutoTUnref<SkData> data(
SkData::NewFromStream(inputStream.get(), size));
if (NULL == data.get()) {
SkCodecPrintf("Warning: could not create embedded stream.\n");
break;
}
SkAutoTDelete<SkMemoryStream>
embeddedStream(SkNEW_ARGS(SkMemoryStream, (data.get())));
bytesRead += size;
// Check if the embedded codec is bmp or png and create the codec
const bool isPng = SkPngCodec::IsPng(embeddedStream);
SkAssertResult(embeddedStream->rewind());
SkCodec* codec = NULL;
if (isPng) {
codec = SkPngCodec::NewFromStream(embeddedStream.detach());
} else {
codec = SkBmpCodec::NewFromIco(embeddedStream.detach());
}
// Save a valid codec
if (NULL != codec) {
codecs->push_back().reset(codec);
}
}
// Recognize if there are no valid codecs
if (0 == codecs->count()) {
SkCodecPrintf("Error: could not find any valid embedded ico codecs.\n");
return NULL;
}
// Use the largest codec as a "suggestion" for image info
uint32_t maxSize = 0;
uint32_t maxIndex = 0;
for (int32_t i = 0; i < codecs->count(); i++) {
SkImageInfo info = codecs->operator[](i)->getInfo();
uint32_t size = info.width() * info.height();
if (size > maxSize) {
maxSize = size;
maxIndex = i;
}
}
SkImageInfo info = codecs->operator[](maxIndex)->getInfo();
// Note that stream is owned by the embedded codec, the ico does not need
// direct access to the stream.
return SkNEW_ARGS(SkIcoCodec, (info, codecs.detach()));
}
GrGLVertexProgramEffectsBuilder::GrGLVertexProgramEffectsBuilder(GrGLFullShaderBuilder* builder,
int reserveCount)
: fBuilder(builder)
, fProgramEffects(SkNEW_ARGS(GrGLVertexProgramEffects,
(reserveCount, fBuilder->hasExplicitLocalCoords()))) {
}
SkScalerContext* SkFontHost::CreateScalerContext(const SkDescriptor* desc)
{
return SkNEW_ARGS(SkScalerContext_Ascender, (desc));
}
GrGLFragmentProcessor* GrBicubicEffect::createGLInstance() const {
return SkNEW_ARGS(GrGLBicubicEffect, (*this));
}
MockGpu(GrContext* context, const GrContextOptions& options) : INHERITED(context) {
fCaps.reset(SkNEW_ARGS(GrCaps, (options)));
}
static void load_system_fonts() {
// check if we've already be called
if (NULL != gDefaultNormal) {
// printf("---- default font %p\n", gDefaultNormal);
return;
}
SkOSFile::Iter iter(SK_FONT_FILE_PREFIX, ".ttf");
SkString name;
int count = 0;
while (iter.next(&name, false)) {
SkString filename;
GetFullPathForSysFonts(&filename, name.c_str());
bool isFixedWidth;
SkString realname;
SkTypeface::Style style = SkTypeface::kNormal; // avoid uninitialized warning
if (!get_name_and_style(filename.c_str(), &realname, &style, &isFixedWidth)) {
SkDebugf("------ can't load <%s> as a font\n", filename.c_str());
continue;
}
// SkDebugf("font: <%s> %d <%s>\n", realname.c_str(), style, filename.c_str());
FamilyRec* family = find_familyrec(realname.c_str());
if (family && family->fFaces[style]) {
// SkDebugf("---- skipping duplicate typeface %s style %d\n",
// realname.c_str(), style);
continue;
}
// this constructor puts us into the global gFamilyHead llist
FamilyTypeface* tf = SkNEW_ARGS(FileTypeface,
(style,
true, // system-font (cannot delete)
family, // what family to join
filename.c_str(),
isFixedWidth) // filename
);
if (NULL == family) {
add_name(realname.c_str(), tf->getFamily());
}
count += 1;
}
if (0 == count) {
SkNEW(EmptyTypeface);
}
// do this after all fonts are loaded. This is our default font, and it
// acts as a sentinel so we only execute load_system_fonts() once
static const char* gDefaultNames[] = {
"Arial", "Verdana", "Times New Roman", NULL
};
const char** names = gDefaultNames;
while (*names) {
SkTypeface* tf = find_typeface(*names++, SkTypeface::kNormal);
if (tf) {
gDefaultNormal = tf;
break;
}
}
// check if we found *something*
if (NULL == gDefaultNormal) {
if (NULL == gFamilyHead) {
sk_throw();
}
for (int i = 0; i < 4; i++) {
if ((gDefaultNormal = gFamilyHead->fFaces[i]) != NULL) {
break;
}
}
}
if (NULL == gDefaultNormal) {
sk_throw();
}
gFallBackTypeface = gDefaultNormal;
gDefaultFamily = find_family(gDefaultNormal);
// SkDebugf("---- default %p head %p family %p\n", gDefaultNormal, gFamilyHead, gDefaultFamily);
}
static GrEffectRef* Create(GrTexture* tex, Direction dir, int radius, MorphologyType type) {
AutoEffectUnref effect(SkNEW_ARGS(GrMorphologyEffect, (tex, dir, radius, type)));
return CreateEffectRef(effect);
}
SkBBoxHierarchy* SkQuadTreePicture::createBBoxHierarchy() const {
return SkNEW_ARGS(SkQuadTree, (fBounds));
}
static SkArithmeticMode_scalar* Create(SkScalar k1, SkScalar k2, SkScalar k3, SkScalar k4,
bool enforcePMColor) {
return SkNEW_ARGS(SkArithmeticMode_scalar, (k1, k2, k3, k4, enforcePMColor));
}
SkXfermode* SkLumaMaskXfermode::Create(SkXfermode::Mode mode) {
if (kSrcIn_Mode == mode || kDstIn_Mode == mode) {
return SkNEW_ARGS(SkLumaMaskXfermode, (mode));
}
return NULL;
}
SkTextureCache::Entry* SkTextureCache::lock(const SkBitmap& bitmap) {
this->validate();
// call this before we call find(), so we don't reorder after find() and
// invalidate our index
this->purgeIfNecessary(SkGL::ComputeTextureMemorySize(bitmap));
Key key(bitmap);
int index;
Entry* entry = this->find(key, &index);
if (NULL == entry) {
entry = SkNEW_ARGS(Entry, (bitmap));
entry->fName = SkGL::BindNewTexture(bitmap, &entry->fTexSize);
if (0 == entry->fName) {
SkDELETE(entry);
return NULL;
}
fHash[key.getHashIndex()] = entry;
*fSorted.insert(index) = entry;
fTexCount += 1;
fTexSize += entry->memSize();
} else {
// detach from our llist
Entry* prev = entry->fPrev;
Entry* next = entry->fNext;
if (prev) {
prev->fNext = next;
} else {
SkASSERT(fHead == entry);
fHead = next;
}
if (next) {
next->fPrev = prev;
} else {
SkASSERT(fTail == entry);
fTail = prev;
}
// now bind the texture
glBindTexture(GL_TEXTURE_2D, entry->fName);
}
// add to head of llist for LRU
entry->fPrev = NULL;
entry->fNext = fHead;
if (NULL != fHead) {
SkASSERT(NULL == fHead->fPrev);
fHead->fPrev = entry;
}
fHead = entry;
if (NULL == fTail) {
fTail = entry;
}
this->validate();
entry->lock();
#ifdef TRACE_HASH_HITS
SkDebugf("---- texture cache hash=%d sorted=%d\n", gHashHits, gSortedHits);
#endif
return entry;
}
void SkMipMapCache::Add(const SkBitmap& src, const SkMipMap* result) {
if (result) {
SkScaledImageCache::Add(SkNEW_ARGS(MipMapRec, (src, result)));
}
}
SkFlattenable* SkGroupShape::CreateProc(SkFlattenableReadBuffer& buffer) {
return SkNEW_ARGS(SkGroupShape, (buffer));
}
SkPixelRef* SkCreateRLEPixelRef(const SkBitmap& src) {
if (SkBitmap::kIndex8_Config != src.config() &&
SkBitmap::kA8_Config != src.config()) {
return NULL;
}
size_t maxPacked = SkPackBits::ComputeMaxSize8(src.width());
// estimate the rle size based on the original size
size_t size = src.getSize() >> 3;
if (size < maxPacked) {
size = maxPacked;
}
ChunkRLEPixels* rlePixels = SkNEW_ARGS(ChunkRLEPixels,
(src.width(), src.height(), size));
uint8_t* dstRow = NULL;
size_t free = 0;
size_t totalPacked = 0;
for (int y = 0; y < src.height(); y++) {
const uint8_t* srcRow = src.getAddr8(0, y);
if (free < maxPacked) {
dstRow = (uint8_t*)rlePixels->fStorage.allocThrow(size);
free = size;
}
size_t packedSize = SkPackBits::Pack8(srcRow, src.width(), dstRow);
SkASSERT(packedSize <= free);
rlePixels->setPackedAtY(y, dstRow);
dstRow += packedSize;
free -= packedSize;
totalPacked += packedSize;
}
//#ifdef SK_DEBUG
#if 0
// test
uint8_t* buffer = new uint8_t[src.width()];
for (int y = 0; y < src.height(); y++) {
const uint8_t* srcRow = src.getAddr8(0, y);
SkPackBits::Unpack8(buffer, 0, src.width(), rlePixels->packedAtY(y));
int n = memcmp(buffer, srcRow, src.width());
if (n) {
SkDebugf("----- memcmp returned %d on line %d\n", n, y);
}
SkASSERT(n == 0);
}
delete[] buffer;
size_t totalAlloc = src.height() * sizeof(uint8_t*) + totalPacked;
SkDebugf("--- RLE: orig [%d %d] %d, rle %d %d savings %g\n",
src.width(), src.height(), src.getSize(),
src.height() * sizeof(uint8_t*), totalPacked,
(float)totalAlloc / src.getSize());
#endif
// transfer ownership of rlePixels to our pixelref
return SkNEW_ARGS(RLEPixelRef, (rlePixels, src.getColorTable()));
}
static GrEffectRef* Create(EdgeType edgeType, const SkRect& rect) {
return CreateEffectRef(AutoEffectUnref(SkNEW_ARGS(AARectEffect, (edgeType, rect))));
}
bool LightingShader::asFragmentProcessor(GrContext* context, const SkPaint& paint,
const SkMatrix& viewM, const SkMatrix* localMatrix,
GrColor* color, GrProcessorDataManager*,
GrFragmentProcessor** fp) const {
// we assume diffuse and normal maps have same width and height
// TODO: support different sizes
SkASSERT(fDiffuseMap.width() == fNormalMap.width() &&
fDiffuseMap.height() == fNormalMap.height());
SkMatrix matrix;
matrix.setIDiv(fDiffuseMap.width(), fDiffuseMap.height());
SkMatrix lmInverse;
if (!this->getLocalMatrix().invert(&lmInverse)) {
return false;
}
if (localMatrix) {
SkMatrix inv;
if (!localMatrix->invert(&inv)) {
return false;
}
lmInverse.postConcat(inv);
}
matrix.preConcat(lmInverse);
// Must set wrap and filter on the sampler before requesting a texture. In two places below
// we check the matrix scale factors to determine how to interpret the filter quality setting.
// This completely ignores the complexity of the drawVertices case where explicit local coords
// are provided by the caller.
GrTextureParams::FilterMode textureFilterMode = GrTextureParams::kBilerp_FilterMode;
switch (paint.getFilterQuality()) {
case kNone_SkFilterQuality:
textureFilterMode = GrTextureParams::kNone_FilterMode;
break;
case kLow_SkFilterQuality:
textureFilterMode = GrTextureParams::kBilerp_FilterMode;
break;
case kMedium_SkFilterQuality:{
SkMatrix matrix;
matrix.setConcat(viewM, this->getLocalMatrix());
if (matrix.getMinScale() < SK_Scalar1) {
textureFilterMode = GrTextureParams::kMipMap_FilterMode;
} else {
// Don't trigger MIP level generation unnecessarily.
textureFilterMode = GrTextureParams::kBilerp_FilterMode;
}
break;
}
case kHigh_SkFilterQuality:
default:
SkErrorInternals::SetError(kInvalidPaint_SkError,
"Sorry, I don't understand the filtering "
"mode you asked for. Falling back to "
"MIPMaps.");
textureFilterMode = GrTextureParams::kMipMap_FilterMode;
break;
}
// TODO: support other tile modes
GrTextureParams params(kClamp_TileMode, textureFilterMode);
SkAutoTUnref<GrTexture> diffuseTexture(GrRefCachedBitmapTexture(context, fDiffuseMap, ¶ms));
if (!diffuseTexture) {
SkErrorInternals::SetError(kInternalError_SkError,
"Couldn't convert bitmap to texture.");
return false;
}
SkAutoTUnref<GrTexture> normalTexture(GrRefCachedBitmapTexture(context, fNormalMap, ¶ms));
if (!normalTexture) {
SkErrorInternals::SetError(kInternalError_SkError,
"Couldn't convert bitmap to texture.");
return false;
}
GrColor lightColor = GrColorPackRGBA(SkColorGetR(fLight.fColor), SkColorGetG(fLight.fColor),
SkColorGetB(fLight.fColor), SkColorGetA(fLight.fColor));
GrColor ambientColor = GrColorPackRGBA(SkColorGetR(fAmbientColor), SkColorGetG(fAmbientColor),
SkColorGetB(fAmbientColor), SkColorGetA(fAmbientColor));
*fp = SkNEW_ARGS(LightingFP, (diffuseTexture, normalTexture, matrix,
fLight.fDirection, lightColor, ambientColor));
*color = GrColorPackA4(paint.getAlpha());
return true;
}
static void* CreateTLS() {
return SkNEW_ARGS(GrMemoryPool, (16384, 16384));
}
static inline void wrap_texture(GrTexture* texture, int width, int height, SkBitmap* result) {
SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
result->setInfo(info);
result->setPixelRef(SkNEW_ARGS(SkGrPixelRef, (info, texture)))->unref();
}
GrClipTarget::GrClipTarget(GrContext* context)
: INHERITED(context->getGpu(), context->resourceProvider())
, fContext(context) {
fClipMaskManager.reset(SkNEW_ARGS(GrClipMaskManager, (this)));
}
SkLayerRasterizer::SkLayerRasterizer()
: fLayers(SkNEW_ARGS(SkDeque, (sizeof(SkLayerRasterizer_Rec))))
{
}
static void parse_commandline(int argc, char* const argv[], SkTArray<SkString>* inputs,
sk_tools::PictureBenchmark* benchmark) {
const char* argv0 = argv[0];
char* const* stop = argv + argc;
int repeats = DEFAULT_REPEATS;
sk_tools::PictureRenderer::SkDeviceTypes deviceType =
sk_tools::PictureRenderer::kBitmap_DeviceType;
SkAutoTUnref<sk_tools::PictureRenderer> renderer(NULL);
// Create a string to show our current settings.
// TODO: Make it prettier. Currently it just repeats the command line.
SkString commandLine("bench_pictures:");
for (int i = 1; i < argc; i++) {
commandLine.appendf(" %s", *(argv+i));
}
commandLine.append("\n");
bool usePipe = false;
int numThreads = 1;
bool useTiles = false;
const char* widthString = NULL;
const char* heightString = NULL;
int gridWidth = 0;
int gridHeight = 0;
bool isPowerOf2Mode = false;
bool isCopyMode = false;
const char* xTilesString = NULL;
const char* yTilesString = NULL;
const char* mode = NULL;
bool gridSupported = false;
sk_tools::PictureRenderer::BBoxHierarchyType bbhType =
sk_tools::PictureRenderer::kNone_BBoxHierarchyType;
sk_tools::PictureRenderer::DrawFilterFlags drawFilters[SkDrawFilter::kTypeCount];
sk_bzero(drawFilters, sizeof(drawFilters));
SkISize viewport;
viewport.setEmpty();
for (++argv; argv < stop; ++argv) {
if (0 == strcmp(*argv, "--repeat")) {
++argv;
if (argv < stop) {
repeats = atoi(*argv);
if (repeats < 1) {
gLogger.logError("--repeat must be given a value > 0\n");
PRINT_USAGE_AND_EXIT;
}
} else {
gLogger.logError("Missing arg for --repeat\n");
PRINT_USAGE_AND_EXIT;
}
} else if (0 == strcmp(*argv, "--pipe")) {
usePipe = true;
} else if (0 == strcmp(*argv, "--logFile")) {
argv++;
if (argv < stop) {
if (!gLogger.SetLogFile(*argv)) {
SkString str;
str.printf("Could not open %s for writing.", *argv);
gLogger.logError(str);
usage(argv0);
// TODO(borenet): We're disabling this for now, due to
// write-protected Android devices. The very short-term
// solution is to ignore the fact that we have no log file.
//exit(-1);
}
} else {
gLogger.logError("Missing arg for --logFile\n");
PRINT_USAGE_AND_EXIT;
}
} else if (0 == strcmp(*argv, "--multi")) {
++argv;
if (argv >= stop) {
gLogger.logError("Missing arg for --multi\n");
PRINT_USAGE_AND_EXIT;
}
numThreads = atoi(*argv);
if (numThreads < 2) {
gLogger.logError("Number of threads must be at least 2.\n");
PRINT_USAGE_AND_EXIT;
}
} else if (0 == strcmp(*argv, "--bbh")) {
++argv;
if (argv >= stop) {
gLogger.logError("Missing value for --bbh\n");
PRINT_USAGE_AND_EXIT;
}
if (0 == strcmp(*argv, "none")) {
bbhType = sk_tools::PictureRenderer::kNone_BBoxHierarchyType;
} else if (0 == strcmp(*argv, "rtree")) {
bbhType = sk_tools::PictureRenderer::kRTree_BBoxHierarchyType;
} else if (0 == strcmp(*argv, "grid")) {
bbhType = sk_tools::PictureRenderer::kTileGrid_BBoxHierarchyType;
++argv;
if (argv >= stop) {
gLogger.logError("Missing width for --bbh grid\n");
PRINT_USAGE_AND_EXIT;
}
gridWidth = atoi(*argv);
++argv;
if (argv >= stop) {
gLogger.logError("Missing height for --bbh grid\n");
PRINT_USAGE_AND_EXIT;
}
gridHeight = atoi(*argv);
} else {
SkString err;
err.printf("%s is not a valid value for --bbhType\n", *argv);
gLogger.logError(err);
PRINT_USAGE_AND_EXIT;
}
} else if (0 == strcmp(*argv, "--mode")) {
if (renderer.get() != NULL) {
SkDebugf("Cannot combine modes.\n");
PRINT_USAGE_AND_EXIT;
}
++argv;
if (argv >= stop) {
gLogger.logError("Missing mode for --mode\n");
PRINT_USAGE_AND_EXIT;
}
if (0 == strcmp(*argv, "record")) {
renderer.reset(SkNEW(sk_tools::RecordPictureRenderer));
gridSupported = true;
} else if (0 == strcmp(*argv, "clone")) {
renderer.reset(sk_tools::CreatePictureCloneRenderer());
} else if (0 == strcmp(*argv, "simple")) {
renderer.reset(SkNEW(sk_tools::SimplePictureRenderer));
} else if ((0 == strcmp(*argv, "tile")) || (0 == strcmp(*argv, "pow2tile"))
|| 0 == strcmp(*argv, "copyTile")) {
useTiles = true;
mode = *argv;
if (0 == strcmp(*argv, "pow2tile")) {
isPowerOf2Mode = true;
} else if (0 == strcmp(*argv, "copyTile")) {
isCopyMode = true;
} else {
gridSupported = true;
}
++argv;
if (argv >= stop) {
SkString err;
err.printf("Missing width for --mode %s\n", mode);
gLogger.logError(err);
PRINT_USAGE_AND_EXIT;
}
widthString = *argv;
++argv;
if (argv >= stop) {
SkString err;
err.appendf("Missing height for --mode %s\n", mode);
gLogger.logError(err);
PRINT_USAGE_AND_EXIT;
}
heightString = *argv;
} else if (0 == strcmp(*argv, "playbackCreation")) {
renderer.reset(SkNEW(sk_tools::PlaybackCreationRenderer));
gridSupported = true;
} else if (0 == strcmp(*argv, "gatherPixelRefs")) {
renderer.reset(sk_tools::CreateGatherPixelRefsRenderer());
} else {
SkString err;
err.printf("%s is not a valid mode for --mode\n", *argv);
gLogger.logError(err);
PRINT_USAGE_AND_EXIT;
}
} else if (0 == strcmp(*argv, "--viewport")) {
++argv;
if (argv >= stop) {
gLogger.logError("Missing width for --viewport\n");
PRINT_USAGE_AND_EXIT;
}
viewport.fWidth = atoi(*argv);
++argv;
if (argv >= stop) {
gLogger.logError("Missing height for --viewport\n");
PRINT_USAGE_AND_EXIT;
}
viewport.fHeight = atoi(*argv);
} else if (0 == strcmp(*argv, "--tiles")) {
++argv;
if (argv >= stop) {
gLogger.logError("Missing x for --tiles\n");
PRINT_USAGE_AND_EXIT;
}
xTilesString = *argv;
++argv;
if (argv >= stop) {
gLogger.logError("Missing y for --tiles\n");
PRINT_USAGE_AND_EXIT;
}
yTilesString = *argv;
} else if (0 == strcmp(*argv, "--device")) {
++argv;
if (argv >= stop) {
gLogger.logError("Missing mode for --device\n");
PRINT_USAGE_AND_EXIT;
}
if (0 == strcmp(*argv, "bitmap")) {
deviceType = sk_tools::PictureRenderer::kBitmap_DeviceType;
}
#if SK_SUPPORT_GPU
else if (0 == strcmp(*argv, "gpu")) {
deviceType = sk_tools::PictureRenderer::kGPU_DeviceType;
}
#endif
else {
SkString err;
err.printf("%s is not a valid mode for --device\n", *argv);
gLogger.logError(err);
PRINT_USAGE_AND_EXIT;
}
} else if (0 == strcmp(*argv, "--timers")) {
++argv;
if (argv < stop) {
bool timerWall = false;
bool truncatedTimerWall = false;
bool timerCpu = false;
bool truncatedTimerCpu = false;
bool timerGpu = false;
for (char* t = *argv; *t; ++t) {
switch (*t) {
case 'w':
timerWall = true;
break;
case 'c':
timerCpu = true;
break;
case 'W':
truncatedTimerWall = true;
break;
case 'C':
truncatedTimerCpu = true;
break;
case 'g':
timerGpu = true;
break;
default: {
break;
}
}
}
benchmark->setTimersToShow(timerWall, truncatedTimerWall, timerCpu,
truncatedTimerCpu, timerGpu);
} else {
gLogger.logError("Missing arg for --timers\n");
PRINT_USAGE_AND_EXIT;
}
} else if (0 == strcmp(*argv, "--timeIndividualTiles")) {
benchmark->setTimeIndividualTiles(true);
} else if (0 == strcmp(*argv, "--min")) {
benchmark->setPrintMin(true);
} else if (0 == strcmp(*argv, "--logPerIter")) {
++argv;
if (argv < stop) {
bool log = atoi(*argv) != 0;
benchmark->setLogPerIter(log);
} else {
gLogger.logError("Missing arg for --logPerIter\n");
PRINT_USAGE_AND_EXIT;
}
} else if (0 == strcmp(*argv, "--filter")) {
++argv;
if (argv < stop) {
const char* colon = strchr(*argv, ':');
if (colon) {
int type = -1;
size_t typeLen = colon - *argv;
for (size_t tIndex = 0; tIndex < kFilterTypesCount; ++tIndex) {
if (typeLen == strlen(gFilterTypes[tIndex])
&& !strncmp(*argv, gFilterTypes[tIndex], typeLen)) {
type = tIndex;
break;
}
}
if (type < 0) {
SkString err;
err.printf("Unknown type for --filter %s\n", *argv);
gLogger.logError(err);
PRINT_USAGE_AND_EXIT;
}
int flag = -1;
size_t flagLen = strlen(*argv) - typeLen - 1;
for (size_t fIndex = 0; fIndex < kFilterFlagsCount; ++fIndex) {
if (flagLen == strlen(gFilterFlags[fIndex])
&& !strncmp(colon + 1, gFilterFlags[fIndex], flagLen)) {
flag = 1 << fIndex;
break;
}
}
if (flag < 0) {
SkString err;
err.printf("Unknown flag for --filter %s\n", *argv);
gLogger.logError(err);
PRINT_USAGE_AND_EXIT;
}
for (int index = 0; index < SkDrawFilter::kTypeCount; ++index) {
if (type != SkDrawFilter::kTypeCount && index != type) {
continue;
}
drawFilters[index] = (sk_tools::PictureRenderer::DrawFilterFlags)
(drawFilters[index] | flag);
}
} else {
SkString err;
err.printf("Unknown arg for --filter %s : missing colon\n", *argv);
gLogger.logError(err);
PRINT_USAGE_AND_EXIT;
}
} else {
gLogger.logError("Missing arg for --filter\n");
PRINT_USAGE_AND_EXIT;
}
} else if (0 == strcmp(*argv, "--help") || 0 == strcmp(*argv, "-h")) {
PRINT_USAGE_AND_EXIT;
} else {
inputs->push_back(SkString(*argv));
}
}
if (numThreads > 1 && !useTiles) {
gLogger.logError("Multithreaded drawing requires tiled rendering.\n");
PRINT_USAGE_AND_EXIT;
}
if (usePipe && sk_tools::PictureRenderer::kNone_BBoxHierarchyType != bbhType) {
gLogger.logError("--pipe and --bbh cannot be used together\n");
PRINT_USAGE_AND_EXIT;
}
if (sk_tools::PictureRenderer::kTileGrid_BBoxHierarchyType == bbhType &&
!gridSupported) {
gLogger.logError("'--bbh grid' is not compatible with specified --mode.\n");
PRINT_USAGE_AND_EXIT;
}
if (useTiles) {
SkASSERT(NULL == renderer);
sk_tools::TiledPictureRenderer* tiledRenderer;
if (isCopyMode) {
int x, y;
if (xTilesString != NULL) {
SkASSERT(yTilesString != NULL);
x = atoi(xTilesString);
y = atoi(yTilesString);
if (x <= 0 || y <= 0) {
gLogger.logError("--tiles must be given values > 0\n");
PRINT_USAGE_AND_EXIT;
}
} else {
x = y = 4;
}
tiledRenderer = SkNEW_ARGS(sk_tools::CopyTilesRenderer, (x, y));
if (benchmark->timeIndividualTiles()) {
gLogger.logError("timeIndividualTiles is not compatible with copyTile\n");
PRINT_USAGE_AND_EXIT;
}
} else if (numThreads > 1) {
tiledRenderer = SkNEW_ARGS(sk_tools::MultiCorePictureRenderer, (numThreads));
} else {
tiledRenderer = SkNEW(sk_tools::TiledPictureRenderer);
}
if (isPowerOf2Mode) {
int minWidth = atoi(widthString);
if (!SkIsPow2(minWidth) || minWidth < 0) {
tiledRenderer->unref();
SkString err;
err.printf("-mode %s must be given a width"
" value that is a power of two\n", mode);
gLogger.logError(err);
PRINT_USAGE_AND_EXIT;
}
tiledRenderer->setTileMinPowerOf2Width(minWidth);
} else if (sk_tools::is_percentage(widthString)) {
if (isCopyMode) {
tiledRenderer->unref();
SkString err;
err.printf("--mode %s does not support percentages.\n", mode);
gLogger.logError(err.c_str());
PRINT_USAGE_AND_EXIT;
}
tiledRenderer->setTileWidthPercentage(atof(widthString));
if (!(tiledRenderer->getTileWidthPercentage() > 0)) {
tiledRenderer->unref();
SkString err;
err.appendf("--mode %s must be given a width percentage > 0\n", mode);
gLogger.logError(err);
PRINT_USAGE_AND_EXIT;
}
} else {
tiledRenderer->setTileWidth(atoi(widthString));
if (!(tiledRenderer->getTileWidth() > 0)) {
tiledRenderer->unref();
SkString err;
err.appendf("--mode %s must be given a width > 0\n", mode);
gLogger.logError(err);
PRINT_USAGE_AND_EXIT;
}
}
if (sk_tools::is_percentage(heightString)) {
if (isCopyMode) {
tiledRenderer->unref();
SkString err;
err.printf("--mode %s does not support percentages.\n", mode);
gLogger.logError(err.c_str());
PRINT_USAGE_AND_EXIT;
}
tiledRenderer->setTileHeightPercentage(atof(heightString));
if (!(tiledRenderer->getTileHeightPercentage() > 0)) {
tiledRenderer->unref();
SkString err;
err.appendf("--mode %s must be given a height percentage > 0\n", mode);
gLogger.logError(err);
PRINT_USAGE_AND_EXIT;
}
} else {
tiledRenderer->setTileHeight(atoi(heightString));
if (!(tiledRenderer->getTileHeight() > 0)) {
tiledRenderer->unref();
SkString err;
err.appendf("--mode %s must be given a height > 0\n", mode);
gLogger.logError(err);
PRINT_USAGE_AND_EXIT;
}
}
if (numThreads > 1) {
#if SK_SUPPORT_GPU
if (sk_tools::PictureRenderer::kGPU_DeviceType == deviceType) {
tiledRenderer->unref();
gLogger.logError("GPU not compatible with multithreaded tiling.\n");
PRINT_USAGE_AND_EXIT;
}
#endif
}
renderer.reset(tiledRenderer);
if (usePipe) {
gLogger.logError("Pipe rendering is currently not compatible with tiling.\n"
"Turning off pipe.\n");
}
} else {
if (benchmark->timeIndividualTiles()) {
gLogger.logError("timeIndividualTiles requires tiled rendering.\n");
PRINT_USAGE_AND_EXIT;
}
if (usePipe) {
if (renderer.get() != NULL) {
gLogger.logError("Pipe is incompatible with other modes.\n");
PRINT_USAGE_AND_EXIT;
}
renderer.reset(SkNEW(sk_tools::PipePictureRenderer));
}
}
if (inputs->count() < 1) {
PRINT_USAGE_AND_EXIT;
}
if (NULL == renderer) {
renderer.reset(SkNEW(sk_tools::SimplePictureRenderer));
}
renderer->setBBoxHierarchyType(bbhType);
renderer->setDrawFilters(drawFilters, filtersName(drawFilters));
renderer->setGridSize(gridWidth, gridHeight);
renderer->setViewport(viewport);
benchmark->setRenderer(renderer);
benchmark->setRepeats(repeats);
benchmark->setDeviceType(deviceType);
benchmark->setLogger(&gLogger);
// Report current settings:
gLogger.logProgress(commandLine);
}
GrGLPathTexGenProgramEffectsBuilder::GrGLPathTexGenProgramEffectsBuilder(
GrGLFragmentOnlyShaderBuilder* builder,
int reserveCount)
: fBuilder(builder)
, fProgramEffects(SkNEW_ARGS(GrGLPathTexGenProgramEffects, (reserveCount))) {
}
SkCodec* SkCodec::NewFromData(SkData* data) {
if (!data) {
return NULL;
}
return NewFromStream(SkNEW_ARGS(SkMemoryStream, (data)));
}
static GrBatch* Create(const Geometry& geometry, bool snapToPixelCenters) {
return SkNEW_ARGS(StrokeRectBatch, (geometry, snapToPixelCenters));
}
void SkBitmapCache::Add(uint32_t genID, int width, int height, const SkBitmap& result) {
SkScaledImageCache::Add(SkNEW_ARGS(BitmapRec, (genID, SK_Scalar1, SK_Scalar1,
SkIRect::MakeWH(width, height), result)));
}
SkDevice* SkDevice::onCreateCompatibleDevice(SkBitmap::Config config,
int width, int height,
bool isOpaque,
Usage usage) {
return SkNEW_ARGS(SkDevice,(config, width, height, isOpaque));
}
static GrFragmentProcessor* Create(GrTexture* colorCube) {
return (NULL != colorCube) ? SkNEW_ARGS(GrColorCubeEffect, (colorCube)) : NULL;
}
