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; }