explicit SkFontStyleSet_Android(const FontFamily& family,
const SkTypeface_FreeType::Scanner& scanner)
{
const SkString* cannonicalFamilyName = NULL;
if (family.fNames.count() > 0) {
cannonicalFamilyName = &family.fNames[0];
}
// TODO? make this lazy
for (int i = 0; i < family.fFonts.count(); ++i) {
const FontFileInfo& fontFile = family.fFonts[i];
SkString pathName(family.fBasePath);
pathName.append(fontFile.fFileName);
SkAutoTDelete<SkStream> stream(SkStream::NewFromFile(pathName.c_str()));
if (!stream.get()) {
SkDEBUGF(("Requested font file %s does not exist or cannot be opened.\n",
pathName.c_str()));
continue;
}
const int ttcIndex = fontFile.fIndex;
SkString familyName;
SkFontStyle style;
bool isFixedWidth;
if (!scanner.scanFont(stream.get(), ttcIndex, &familyName, &style, &isFixedWidth)) {
SkDEBUGF(("Requested font file %s exists, but is not a valid font.\n",
pathName.c_str()));
continue;
}
int weight = fontFile.fWeight != 0 ? fontFile.fWeight : style.weight();
SkFontStyle::Slant slant = style.slant();
switch (fontFile.fStyle) {
case FontFileInfo::Style::kAuto: slant = style.slant(); break;
case FontFileInfo::Style::kNormal: slant = SkFontStyle::kUpright_Slant; break;
case FontFileInfo::Style::kItalic: slant = SkFontStyle::kItalic_Slant; break;
default: SkASSERT(false); break;
}
style = SkFontStyle(weight, style.width(), slant);
const SkLanguage& lang = family.fLanguage;
uint32_t variant = family.fVariant;
if (kDefault_FontVariant == variant) {
variant = kCompact_FontVariant | kElegant_FontVariant;
}
// The first specified family name overrides the family name found in the font.
// TODO: SkTypeface_AndroidSystem::onCreateFamilyNameIterator should return
// all of the specified family names in addition to the names found in the font.
if (cannonicalFamilyName != NULL) {
familyName = *cannonicalFamilyName;
}
fStyles.push_back().reset(SkNEW_ARGS(SkTypeface_AndroidSystem,
(pathName, ttcIndex,
style, isFixedWidth, familyName,
lang, variant)));
}
}
void SkTraceHR(const char* file, unsigned long line,
HRESULT hr, const char* msg) {
if (NULL != msg) SkDEBUGF(("%s\n", msg));
SkDEBUGF(("%s(%lu) : error 0x%x: ", file, line, hr));
LPSTR errorText = NULL;
FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL,
hr,
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPSTR) &errorText,
0,
NULL
);
if (NULL == errorText) {
SkDEBUGF(("<unknown>\n"));
} else {
SkDEBUGF((errorText));
LocalFree(errorText);
errorText = NULL;
}
}
void init_skin_anim(const char path[], SkAnimator* anim) {
SkASSERT(path && anim);
SkAutoTUnref<SkStream> stream(SkStream::NewFromFile(path));
if (!stream.get()) {
SkDEBUGF(("init_skin_anim: loading skin failed <%s>\n", path));
sk_throw();
}
if (!anim->decodeStream(stream)) {
SkDEBUGF(("init_skin_anim: decoding skin failed <%s>\n", path));
sk_throw();
}
}
FILE* sk_fopen(const char path[], SkFILE_Flags flags) {
char perm[4] = {0, 0, 0, 0};
char* p = perm;
if (flags & kRead_SkFILE_Flag) {
*p++ = 'r';
}
if (flags & kWrite_SkFILE_Flag) {
*p++ = 'w';
}
*p = 'b';
FILE* file = nullptr;
#ifdef _WIN32
file = fopen_win(path, perm);
#else
file = fopen(path, perm);
#endif
#ifdef SK_BUILD_FOR_IOS
// if not found in default path and read-only, try to open from bundle
if (!file && kRead_SkFILE_Flag == flags) {
SkString bundlePath;
if (ios_get_path_in_bundle(path, &bundlePath)) {
file = fopen(bundlePath.c_str(), perm);
}
}
#endif
if (nullptr == file && (flags & kWrite_SkFILE_Flag)) {
SkDEBUGF(("sk_fopen: fopen(\"%s\", \"%s\") returned nullptr (errno:%d): %s\n",
path, perm, errno, strerror(errno)));
}
return file;
}
FILE* sk_fopen(const char path[], SkFILE_Flags flags) {
char perm[4];
char* p = perm;
if (flags & kRead_SkFILE_Flag) {
*p++ = 'r';
}
if (flags & kWrite_SkFILE_Flag) {
*p++ = 'w';
}
*p++ = 'b';
*p = 0;
//TODO: on Windows fopen is just ASCII or the current code page,
//convert to utf16 and use _wfopen
FILE* file = nullptr;
#ifdef SK_BUILD_FOR_IOS
// if read-only, try to open from bundle first
if (kRead_SkFILE_Flag == flags) {
file = ios_open_from_bundle(path, perm);
}
// otherwise just read from the Documents directory (default)
if (!file) {
#endif
file = fopen(path, perm);
#ifdef SK_BUILD_FOR_IOS
}
#endif
if (nullptr == file && (flags & kWrite_SkFILE_Flag)) {
SkDEBUGF(("sk_fopen: fopen(\"%s\", \"%s\") returned NULL (errno:%d): %s\n",
path, perm, errno, strerror(errno)));
}
return file;
}
static void init_bitmap(Fuzz* fuzz, SkBitmap* bmp) {
uint8_t colorType;
fuzz->nextRange(&colorType, 0, (int)kLastEnum_SkColorType);
// ColorType needs to match what the system configuration is.
if (colorType == kRGBA_8888_SkColorType || colorType == kBGRA_8888_SkColorType) {
colorType = kN32_SkColorType;
}
bool b;
fuzz->next(&b);
SkImageInfo info = SkImageInfo::Make(kBmpSize,
kBmpSize,
(SkColorType)colorType,
b ? kOpaque_SkAlphaType : kPremul_SkAlphaType);
if (!bmp->tryAllocPixels(info)) {
SkDEBUGF("Bitmap not allocated\n");
}
SkColor c;
fuzz->next(&c);
bmp->eraseColor(c);
fuzz->next(&b);
SkPaint p;
if (b) {
init_paint(fuzz, &p);
}
else {
fuzz->next(&c);
p.setColor(c);
}
}
SkPath1DPathEffect::SkPath1DPathEffect(const SkPath& path, SkScalar advance,
SkScalar phase, Style style) : fPath(path)
{
SkASSERT(advance > 0 && !path.isEmpty());
// cleanup their phase parameter, inverting it so that it becomes an
// offset along the path (to match the interpretation in PostScript)
if (phase < 0) {
phase = -phase;
if (phase > advance) {
phase = SkScalarMod(phase, advance);
}
} else {
if (phase > advance) {
phase = SkScalarMod(phase, advance);
}
phase = advance - phase;
}
// now catch the edge case where phase == advance (within epsilon)
if (phase >= advance) {
phase = 0;
}
SkASSERT(phase >= 0);
fAdvance = advance;
fInitialOffset = phase;
if ((unsigned)style > kMorph_Style) {
SkDEBUGF(("SkPath1DPathEffect style enum out of range %d\n", style));
}
fStyle = style;
}
bool SkImageDecoder::cropBitmap(SkBitmap *dst, SkBitmap *src, int sampleSize,
int dstX, int dstY, int width, int height,
int srcX, int srcY) {
int w = width / sampleSize;
int h = height / sampleSize;
if (src->getConfig() == SkBitmap::kIndex8_Config) {
// kIndex8 does not allow drawing via an SkCanvas, as is done below.
// Instead, use extractSubset. Note that this shares the SkPixelRef and
// SkColorTable.
// FIXME: Since src is discarded in practice, this holds on to more
// pixels than is strictly necessary. Switch to a copy if memory
// savings are more important than speed here. This also means
// that the pixels in dst can not be reused (though there is no
// allocation, which was already done on src).
int x = (dstX - srcX) / sampleSize;
int y = (dstY - srcY) / sampleSize;
SkIRect subset = SkIRect::MakeXYWH(x, y, w, h);
return src->extractSubset(dst, subset);
}
// if the destination has no pixels then we must allocate them.
if (dst->isNull()) {
dst->setConfig(src->getConfig(), w, h);
dst->setIsOpaque(src->isOpaque());
if (!this->allocPixelRef(dst, NULL)) {
SkDEBUGF(("failed to allocate pixels needed to crop the bitmap"));
return false;
}
}
// check to see if the destination is large enough to decode the desired
// region. If this assert fails we will just draw as much of the source
// into the destination that we can.
if (dst->width() < w || dst->height() < h) {
SkDEBUGF(("SkImageDecoder::cropBitmap does not have a large enough bitmap.\n"));
}
// Set the Src_Mode for the paint to prevent transparency issue in the
// dest in the event that the dest was being re-used.
SkPaint paint;
paint.setXfermodeMode(SkXfermode::kSrc_Mode);
SkCanvas canvas(*dst);
canvas.drawSprite(*src, (srcX - dstX) / sampleSize,
(srcY - dstY) / sampleSize,
&paint);
return true;
}
/* This loops through all available fallback contexts (if needed) until it
finds some context that can handle the unichar and return it.
As this is somewhat expensive operation, it should only be done on the first
char of a run.
*/
unsigned SkScalerContext::getBaseGlyphCount(SkUnichar uni) {
SkScalerContext* ctx = this->getContextFromChar(uni, NULL);
if (NULL != ctx) {
return ctx->fBaseGlyphCount;
} else {
SkDEBUGF(("--- no context for char %x\n", uni));
return this->fBaseGlyphCount;
}
}
SkXfermode::Mode WebCoreCompositeToSkiaComposite(CompositeOperator op, WebBlendMode blendMode)
{
if (blendMode != WebBlendModeNormal) {
if (static_cast<uint8_t>(blendMode) >= SK_ARRAY_COUNT(gMapBlendOpsToXfermodeModes)) {
SkDEBUGF(("GraphicsContext::setPlatformCompositeOperation unknown WebBlendMode %d\n", blendMode));
return SkXfermode::kSrcOver_Mode;
}
return gMapBlendOpsToXfermodeModes[static_cast<uint8_t>(blendMode)];
}
const CompositOpToXfermodeMode* table = gMapCompositOpsToXfermodeModes;
if (static_cast<uint8_t>(op) >= SK_ARRAY_COUNT(gMapCompositOpsToXfermodeModes)) {
SkDEBUGF(("GraphicsContext::setPlatformCompositeOperation unknown CompositeOperator %d\n", op));
return SkXfermode::kSrcOver_Mode;
}
SkASSERT(table[static_cast<uint8_t>(op)].mCompositOp == op);
return table[static_cast<uint8_t>(op)].m_xfermodeMode;
}
void init_skin_anim(const char path[], SkAnimator* anim)
{
SkASSERT(path && anim);
SkFILEStream stream(path);
if (!stream.isValid())
{
SkDEBUGF(("init_skin_anim: loading skin failed <%s>\n", path));
sk_throw();
}
if (!anim->decodeStream(&stream))
{
SkDEBUGF(("init_skin_anim: decoding skin failed <%s>\n", path));
sk_throw();
}
}
size_t sk_fread(void* buffer, size_t byteCount, SkFILE* f) {
SkASSERT(f);
if (buffer == nullptr) {
size_t curr = ::ftell((FILE*)f);
if ((long)curr == -1) {
SkDEBUGF(("sk_fread: ftell(%p) returned -1 feof:%d ferror:%d\n", f, feof((FILE*)f), ferror((FILE*)f)));
return 0;
}
int err = ::fseek((FILE*)f, (long)byteCount, SEEK_CUR);
if (err != 0) {
SkDEBUGF(("sk_fread: fseek(%d) tell:%d failed with feof:%d ferror:%d returned:%d\n",
byteCount, curr, feof((FILE*)f), ferror((FILE*)f), err));
return 0;
}
return byteCount;
}
else
return ::fread(buffer, 1, byteCount, (FILE*)f);
}
SkMMAPStream::SkMMAPStream(const char filename[])
{
fAddr = NULL; // initialize to failure case
fSize = 0;
int fildes = open(filename, O_RDONLY);
if (fildes < 0)
{
SkDEBUGF(("---- failed to open(%s) for mmap stream error=%d\n", filename, errno));
return;
}
off_t offset = lseek(fildes, 0, SEEK_END); // find the file size
if (offset == -1)
{
SkDEBUGF(("---- failed to lseek(%s) for mmap stream error=%d\n", filename, errno));
close(fildes);
return;
}
(void)lseek(fildes, 0, SEEK_SET); // restore file offset to beginning
// to avoid a 64bit->32bit warning, I explicitly create a size_t size
size_t size = static_cast<size_t>(offset);
void* addr = mmap(NULL, size, PROT_READ, MAP_SHARED, fildes, 0);
// According to the POSIX documentation of mmap it adds an extra reference
// to the file associated with the fildes which is not removed by a
// subsequent close() on that fildes. This reference is removed when there
// are no more mappings to the file.
close(fildes);
if (MAP_FAILED == addr)
{
SkDEBUGF(("---- failed to mmap(%s) for mmap stream error=%d\n", filename, errno));
return;
}
this->INHERITED::setMemory(addr, size);
fAddr = addr;
fSize = size;
}
void SkListView::onInflate(const SkDOM& dom, const SkDOM::Node* node)
{
this->INHERITED::onInflate(dom, node);
{
bool hasScrollBar;
if (dom.findBool(node, "scrollBar", &hasScrollBar))
this->setHasScrollBar(hasScrollBar);
}
const SkDOM::Node* child;
if ((child = dom.getFirstChild(node, "bindings")) != NULL)
{
delete[] fBindings;
fBindings = NULL;
fBindingCount = 0;
SkListSource* listSrc = SkListSource::Factory(dom.findAttr(child, "data-fields"));
SkASSERT(listSrc);
fSkinName.set(dom.findAttr(child, "skin-slots"));
SkASSERT(fSkinName.size());
this->setListSource(listSrc)->unref();
int count = dom.countChildren(child, "bind");
if (count > 0)
{
fBindings = new BindingRec[count];
count = 0; // reuse this to count up to the number of valid bindings
child = dom.getFirstChild(child, "bind");
SkASSERT(child);
do {
const char* fieldName = dom.findAttr(child, "field");
const char* slotName = dom.findAttr(child, "slot");
if (fieldName && slotName)
{
fBindings[count].fFieldIndex = listSrc->findFieldIndex(fieldName);
if (fBindings[count].fFieldIndex >= 0)
fBindings[count++].fSlotName.set(slotName);
}
} while ((child = dom.getNextSibling(child, "bind")) != NULL);
fBindingCount = SkToU16(count);
if (count == 0)
{
SkDEBUGF(("SkListView::onInflate: no valid <bind> elements in <listsource>\n"));
delete[] fBindings;
}
}
this->dirtyCache(kAnimCount_DirtyFlag);
this->setSelection(0);
}
}
void SkUseTestFontConfigFile(const char* mainconf, const char* fallbackconf,
const char* fontsdir) {
gTestMainConfigFile = mainconf;
gTestFallbackConfigFile = fallbackconf;
gTestFontFilePrefix = fontsdir;
SkASSERT(gTestMainConfigFile);
SkASSERT(gTestFallbackConfigFile);
SkASSERT(gTestFontFilePrefix);
SkDEBUGF(("Use Test Config File Main %s, Fallback %s, Font Dir %s",
gTestMainConfigFile, gTestFallbackConfigFile, gTestFontFilePrefix));
}
void inflate_paint(const SkDOM& dom, const SkDOM::Node* node, SkPaint* paint)
{
SkASSERT(paint);
SkAnimator anim;
SkCanvas canvas;
if (!anim.decodeDOM(dom, node))
{
SkDEBUGF(("inflate_paint: decoding dom failed\n"));
SkDEBUGCODE(dom.dump(node);)
void SkUseTestFontConfigFile(const char* fontsXml, const char* fallbackFontsXml,
const char* basePath)
{
gTestFontsXml = fontsXml;
gTestFallbackFontsXml = fallbackFontsXml;
gTestBasePath = basePath;
SkASSERT(gTestFontsXml);
SkASSERT(gTestFallbackFontsXml);
SkASSERT(gTestBasePath);
SkDEBUGF(("Test BasePath: %s Fonts: %s FallbackFonts: %s\n",
gTestBasePath, gTestFontsXml, gTestFallbackFontsXml));
}
bool SkImageRef::prepareBitmap(SkImageDecoder::Mode mode) {
if (fErrorInDecoding) {
return false;
}
if (NULL != fBitmap.getPixels() ||
(SkBitmap::kNo_Config != fBitmap.config() &&
SkImageDecoder::kDecodeBounds_Mode == mode)) {
return true;
}
SkASSERT(fBitmap.getPixels() == NULL);
if (!fStream->rewind()) {
SkDEBUGF(("Failed to rewind SkImageRef stream!"));
return false;
}
SkImageDecoder* codec;
if (fFactory) {
codec = fFactory->newDecoder(fStream);
} else {
codec = SkImageDecoder::Factory(fStream);
}
if (codec) {
SkAutoTDelete<SkImageDecoder> ad(codec);
codec->setSampleSize(fSampleSize);
codec->setDitherImage(fDoDither);
codec->setRequireUnpremultipliedColors(this->info().fAlphaType == kUnpremul_SkAlphaType);
if (this->onDecode(codec, fStream, &fBitmap, fBitmap.config(), mode)) {
if (kOpaque_SkAlphaType == fBitmap.alphaType()) {
this->changeAlphaType(kOpaque_SkAlphaType);
}
SkASSERT(this->info() == fBitmap.info());
return true;
}
}
#ifdef DUMP_IMAGEREF_LIFECYCLE
if (NULL == codec) {
SkDebugf("--- ImageRef: <%s> failed to find codec\n", this->getURI());
} else {
SkDebugf("--- ImageRef: <%s> failed in codec for %d mode\n",
this->getURI(), mode);
}
#endif
fErrorInDecoding = true;
fBitmap.reset();
return false;
}
static SkFaceRec* ref_ft_face(uint32_t fontID) {
SkFaceRec* rec = gFaceRecHead;
while (rec) {
if (rec->fFontID == fontID) {
SkASSERT(rec->fFace);
rec->fRefCnt += 1;
return rec;
}
rec = rec->fNext;
}
SkStream* strm = SkFontHost::OpenStream(fontID);
if (NULL == strm) {
SkDEBUGF(("SkFontHost::OpenStream failed opening %x\n", fontID));
sk_throw();
return 0;
}
// this passes ownership of strm to the rec
rec = SkNEW_ARGS(SkFaceRec, (strm, fontID));
FT_Open_Args args;
memset(&args, 0, sizeof(args));
const void* memoryBase = strm->getMemoryBase();
if (NULL != memoryBase) {
//printf("mmap(%s)\n", keyString.c_str());
args.flags = FT_OPEN_MEMORY;
args.memory_base = (const FT_Byte*)memoryBase;
args.memory_size = strm->getLength();
} else {
//printf("fopen(%s)\n", keyString.c_str());
args.flags = FT_OPEN_STREAM;
args.stream = &rec->fFTStream;
}
FT_Error err = FT_Open_Face(gFTLibrary, &args, 0, &rec->fFace);
if (err) { // bad filename, try the default font
fprintf(stderr, "ERROR: unable to open font '%x'\n", fontID);
SkDELETE(rec);
sk_throw();
return 0;
} else {
SkASSERT(rec->fFace);
//fprintf(stderr, "Opened font '%s'\n", filename.c_str());
rec->fNext = gFaceRecHead;
gFaceRecHead = rec;
rec->fRefCnt = 1;
return rec;
}
}
SkFontMgr* SkFontMgr_New_Android(const SkFontMgr_Android_CustomFonts* custom) {
if (custom) {
SkASSERT(0 <= custom->fSystemFontUse);
SkASSERT(custom->fSystemFontUse < SK_ARRAY_COUNT(gSystemFontUseStrings));
SkDEBUGF(("SystemFontUse: %s BasePath: %s Fonts: %s FallbackFonts: %s\n",
gSystemFontUseStrings[custom->fSystemFontUse],
custom->fBasePath,
custom->fFontsXml,
custom->fFallbackFontsXml));
}
return new SkFontMgr_Android(custom);
}
SkPath1DPathEffect::SkPath1DPathEffect(SkFlattenableReadBuffer& buffer) {
fAdvance = buffer.readScalar();
if (fAdvance > 0) {
fPath.unflatten(buffer);
fInitialOffset = buffer.readScalar();
fStyle = (Style) buffer.readU8();
} else {
SkDEBUGF(("SkPath1DPathEffect can't use advance <= 0\n"));
// Make Coverity happy.
fInitialOffset = 0;
fStyle = kStyleCount;
}
}
SkPath1DPathEffect::SkPath1DPathEffect(SkReadBuffer& buffer) {
fAdvance = buffer.readScalar();
if (fAdvance > 0) {
buffer.readPath(&fPath);
fInitialOffset = buffer.readScalar();
fStyle = (Style) buffer.readUInt();
} else {
SkDEBUGF(("SkPath1DPathEffect can't use advance <= 0\n"));
// Make Coverity happy.
fInitialOffset = 0;
fStyle = kStyleCount;
}
}
SkMMAPStream::SkMMAPStream(const char filename[])
{
fFildes = -1; // initialize to failure case
int fildes = open(filename, O_RDONLY);
if (fildes < 0)
{
SkDEBUGF(("---- failed to open(%s) for mmap stream error=%d\n", filename, errno));
return;
}
off_t offset = lseek(fildes, 0, SEEK_END); // find the file size
if (offset == -1)
{
SkDEBUGF(("---- failed to lseek(%s) for mmap stream error=%d\n", filename, errno));
close(fildes);
return;
}
(void)lseek(fildes, 0, SEEK_SET); // restore file offset to beginning
// to avoid a 64bit->32bit warning, I explicitly create a size_t size
size_t size = static_cast<size_t>(offset);
void* addr = mmap(NULL, size, PROT_READ, MAP_SHARED, fildes, 0);
if (MAP_FAILED == addr)
{
SkDEBUGF(("---- failed to mmap(%s) for mmap stream error=%d\n", filename, errno));
close(fildes);
return;
}
this->INHERITED::setMemory(addr, size);
fFildes = fildes;
fAddr = addr;
fSize = size;
}
size_t sk_fread(void* buffer, size_t byteCount, SkFILE* f)
{
SkASSERT(f);
if (buffer == NULL)
{
int err = IFILE_Seek((IFile*)f, _SEEK_CURRENT, (int)byteCount);
if (err == EFAILED) {
SkDEBUGF(("sk_fread: IFILE_Seek(%d) failed returned:%d\n", byteCount, err));
return 0;
}
return byteCount;
}
else
return IFILE_Read((IFile*)f, buffer, byteCount);
}
DEF_FUZZ(DrawFunctions, fuzz) {
uint8_t i;
fuzz->next(&i);
switch(i) {
case 0: {
sk_sp<SkTypeface> f = SkTypeface::MakeDefault();
if (f == nullptr) {
SkDebugf("Could not initialize font.\n");
fuzz->signalBug();
}
SkDEBUGF("Fuzz DrawText\n");
fuzz_drawText(fuzz, f);
return;
}
case 1:
SkDEBUGF("Fuzz DrawRect\n");
fuzz_drawRect(fuzz);
return;
case 2:
SkDEBUGF("Fuzz DrawCircle\n");
fuzz_drawCircle(fuzz);
return;
case 3:
SkDEBUGF("Fuzz DrawLine\n");
fuzz_drawLine(fuzz);
return;
case 4:
SkDEBUGF("Fuzz DrawPath\n");
fuzz_drawPath(fuzz);
return;
case 5:
SkDEBUGF("Fuzz DrawImage/DrawImageRect\n");
fuzz_drawImage(fuzz);
return;
case 6:
SkDEBUGF("Fuzz DrawBitmap\n");
fuzz_drawBitmap(fuzz);
return;
case 7:
SkDEBUGF("Fuzz DrawPaint\n");
fuzz_drawPaint(fuzz);
return;
}
}
SkMutex::SkMutex() {
if (sizeof(pthread_mutex_t) > sizeof(fStorage)) {
SkDEBUGF(("pthread mutex size = %d\n", sizeof(pthread_mutex_t)));
SkDEBUGFAIL("mutex storage is too small");
}
int status;
pthread_mutexattr_t attr;
status = pthread_mutexattr_init(&attr);
print_pthread_error(status);
SkASSERT(0 == status);
status = pthread_mutex_init((pthread_mutex_t*)fStorage, &attr);
print_pthread_error(status);
SkASSERT(0 == status);
}
void SkImageRef::flatten(SkWriteBuffer& buffer) const {
this->INHERITED::flatten(buffer);
buffer.writeInt(fSampleSize);
buffer.writeBool(fDoDither);
// FIXME: Consider moving this logic should go into writeStream itself.
// writeStream currently has no other callers, so this may be fine for
// now.
if (!fStream->rewind()) {
SkDEBUGF(("Failed to rewind SkImageRef stream!"));
buffer.write32(0);
} else {
// FIXME: Handle getLength properly here. Perhaps this class should
// take an SkStreamAsset.
buffer.writeStream(fStream, fStream->getLength());
}
}
bool SkMultiPictureDocumentRead(SkStreamSeekable* stream,
SkDocumentPage* dstArray,
int dstArrayCount,
const SkDeserialProcs* procs) {
if (!SkMultiPictureDocumentReadPageSizes(stream, dstArray, dstArrayCount)) {
return false;
}
SkSize joined = {0.0f, 0.0f};
for (int i = 0; i < dstArrayCount; ++i) {
joined = SkSize{SkTMax(joined.width(), dstArray[i].fSize.width()),
SkTMax(joined.height(), dstArray[i].fSize.height())};
}
auto picture = SkPicture::MakeFromStream(stream, procs);
PagerCanvas canvas(joined.toCeil(), dstArray, dstArrayCount);
// Must call playback(), not drawPicture() to reach
// PagerCanvas::onDrawAnnotation().
picture->playback(&canvas);
if (canvas.fIndex != dstArrayCount) {
SkDEBUGF("Malformed SkMultiPictureDocument\n");
}
return true;
}
// A function used to determine at runtime if the target CPU supports
// the ARM NEON instruction set. This implementation is Linux-specific.
static bool sk_cpu_arm_check_neon(void) {
// If we fail any of the following, assume we don't have NEON instructions
// This allows us to return immediately in case of error.
bool result = false;
// Use the Android NDK's cpu-features helper library to detect NEON at runtime.
// See http://crbug.com/164154 to see why this is needed in Chromium for Android.
#ifdef SK_BUILD_FOR_ANDROID
result = (android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_NEON) != 0;
#else // SK_BUILD_FOR_ANDROID
// There is no user-accessible CPUID instruction on ARM that we can use.
// Instead, we must parse /proc/cpuinfo and look for the 'neon' feature.
// For example, here's a typical output (Nexus S running ICS 4.0.3):
/*
Processor : ARMv7 Processor rev 2 (v7l)
BogoMIPS : 994.65
Features : swp half thumb fastmult vfp edsp thumbee neon vfpv3
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x2
CPU part : 0xc08
CPU revision : 2
Hardware : herring
Revision : 000b
Serial : 3833c77d6dc000ec
*/
char buffer[4096];
do {
// open /proc/cpuinfo
int fd = TEMP_FAILURE_RETRY(open("/proc/cpuinfo", O_RDONLY));
if (fd < 0) {
SkDebugf("Could not open /proc/cpuinfo: %s\n", strerror(errno));
break;
}
// Read the file. To simplify our search, we're going to place two
// sentinel '\n' characters: one at the start of the buffer, and one at
// the end. This means we reserve the first and last buffer bytes.
buffer[0] = '\n';
int size = TEMP_FAILURE_RETRY(read(fd, buffer+1, sizeof(buffer)-2));
close(fd);
if (size < 0) { // should not happen
SkDebugf("Could not read /proc/cpuinfo: %s\n", strerror(errno));
break;
}
SkDebugf("START /proc/cpuinfo:\n%.*s\nEND /proc/cpuinfo\n",
size, buffer+1);
// Compute buffer limit, and place final sentinel
char* buffer_end = buffer + 1 + size;
buffer_end[0] = '\n';
// Now, find a line that starts with "Features", i.e. look for
// '\nFeatures ' in our buffer.
const char features[] = "\nFeatures\t";
const size_t features_len = sizeof(features)-1;
char* line = (char*) memmem(buffer, buffer_end - buffer,
features, features_len);
if (line == nullptr) { // Weird, no Features line, bad kernel?
SkDebugf("Could not find a line starting with 'Features'"
"in /proc/cpuinfo ?\n");
break;
}
line += features_len; // Skip the "\nFeatures\t" prefix
// Find the end of the current line
char* line_end = (char*) memchr(line, '\n', buffer_end - line);
if (line_end == nullptr)
line_end = buffer_end;
// Now find an instance of 'neon' in the flags list. We want to
// ensure it's only 'neon' and not something fancy like 'noneon'
// so check that it follows a space.
const char neon[] = " neon";
const size_t neon_len = sizeof(neon)-1;
const char* flag = (const char*) memmem(line, line_end - line,
neon, neon_len);
if (flag == nullptr)
break;
// Ensure it is followed by a space or a newline.
if (flag[neon_len] != ' ' && flag[neon_len] != '\n')
break;
// Fine, we support Arm NEON !
result = true;
} while (0);
#endif // SK_BUILD_FOR_ANDROID
if (result) {
SkDEBUGF(("Device supports ARM NEON instructions!\n"));
} else {
SkDEBUGF(("Device does NOT support ARM NEON instructions!\n"));
}
return result;
}
void NinePatch_Draw(SkCanvas* canvas, const SkRect& bounds,
const SkBitmap& bitmap, const android::Res_png_9patch& chunk,
const SkPaint* paint, SkRegion** outRegion) {
if (canvas && canvas->quickReject(bounds, SkCanvas::kBW_EdgeType)) {
return;
}
// if our canvas is GL, draw this as a mesh, which will be faster than
// in parts (which is faster for raster)
if (canvas && canvas->getViewport(NULL)) {
SkNinePatch::DrawMesh(canvas, bounds, bitmap,
chunk.xDivs, chunk.numXDivs,
chunk.yDivs, chunk.numYDivs,
paint);
return;
}
#ifdef USE_TRACE
gTrace = true;
#endif
SkASSERT(canvas || outRegion);
#if 0
if (canvas) {
const SkMatrix& m = canvas->getTotalMatrix();
SkDebugf("ninepatch [%g %g %g] [%g %g %g]\n",
SkScalarToFloat(m[0]), SkScalarToFloat(m[1]), SkScalarToFloat(m[2]),
SkScalarToFloat(m[3]), SkScalarToFloat(m[4]), SkScalarToFloat(m[5]));
}
#endif
#ifdef USE_TRACE
if (gTrace) {
SkDEBUGF(("======== ninepatch bounds [%g %g]\n", SkScalarToFloat(bounds.width()), SkScalarToFloat(bounds.height())));
SkDEBUGF(("======== ninepatch paint bm [%d,%d]\n", bitmap.width(), bitmap.height()));
SkDEBUGF(("======== ninepatch xDivs [%d,%d]\n", chunk.xDivs[0], chunk.xDivs[1]));
SkDEBUGF(("======== ninepatch yDivs [%d,%d]\n", chunk.yDivs[0], chunk.yDivs[1]));
}
#endif
if (bounds.isEmpty() ||
bitmap.width() == 0 || bitmap.height() == 0 ||
(paint && paint->getXfermode() == NULL && paint->getAlpha() == 0))
{
#ifdef USE_TRACE
if (gTrace) SkDEBUGF(("======== abort ninepatch draw\n"));
#endif
return;
}
// should try a quick-reject test before calling lockPixels
SkAutoLockPixels alp(bitmap);
// after the lock, it is valid to check getPixels()
if (bitmap.getPixels() == NULL)
return;
SkPaint defaultPaint;
if (NULL == paint) {
paint = &defaultPaint;
}
const bool hasXfer = paint->getXfermode() != NULL;
SkRect dst;
SkIRect src;
const int32_t x0 = chunk.xDivs[0];
const int32_t y0 = chunk.yDivs[0];
const SkColor initColor = ((SkPaint*)paint)->getColor();
const uint8_t numXDivs = chunk.numXDivs;
const uint8_t numYDivs = chunk.numYDivs;
int i;
int j;
int colorIndex = 0;
uint32_t color;
bool xIsStretchable;
const bool initialXIsStretchable = (x0 == 0);
bool yIsStretchable = (y0 == 0);
const int bitmapWidth = bitmap.width();
const int bitmapHeight = bitmap.height();
SkScalar* dstRights = (SkScalar*) alloca((numXDivs + 1) * sizeof(SkScalar));
bool dstRightsHaveBeenCached = false;
int numStretchyXPixelsRemaining = 0;
for (i = 0; i < numXDivs; i += 2) {
numStretchyXPixelsRemaining += chunk.xDivs[i + 1] - chunk.xDivs[i];
}
int numFixedXPixelsRemaining = bitmapWidth - numStretchyXPixelsRemaining;
int numStretchyYPixelsRemaining = 0;
for (i = 0; i < numYDivs; i += 2) {
numStretchyYPixelsRemaining += chunk.yDivs[i + 1] - chunk.yDivs[i];
}
int numFixedYPixelsRemaining = bitmapHeight - numStretchyYPixelsRemaining;
#if 0
SkDebugf("NinePatch [%d %d] bounds [%g %g %g %g] divs [%d %d]\n",
bitmap.width(), bitmap.height(),
SkScalarToFloat(bounds.fLeft), SkScalarToFloat(bounds.fTop),
SkScalarToFloat(bounds.width()), SkScalarToFloat(bounds.height()),
numXDivs, numYDivs);
#endif
src.fTop = 0;
dst.fTop = bounds.fTop;
// The first row always starts with the top being at y=0 and the bottom
// being either yDivs[1] (if yDivs[0]=0) of yDivs[0]. In the former case
// the first row is stretchable along the Y axis, otherwise it is fixed.
// The last row always ends with the bottom being bitmap.height and the top
// being either yDivs[numYDivs-2] (if yDivs[numYDivs-1]=bitmap.height) or
// yDivs[numYDivs-1]. In the former case the last row is stretchable along
// the Y axis, otherwise it is fixed.
//
// The first and last columns are similarly treated with respect to the X
// axis.
//
// The above is to help explain some of the special casing that goes on the
// code below.
// The initial yDiv and whether the first row is considered stretchable or
// not depends on whether yDiv[0] was zero or not.
for (j = yIsStretchable ? 1 : 0;
j <= numYDivs && src.fTop < bitmapHeight;
j++, yIsStretchable = !yIsStretchable) {
src.fLeft = 0;
dst.fLeft = bounds.fLeft;
if (j == numYDivs) {
src.fBottom = bitmapHeight;
dst.fBottom = bounds.fBottom;
} else {
src.fBottom = chunk.yDivs[j];
const int srcYSize = src.fBottom - src.fTop;
if (yIsStretchable) {
dst.fBottom = dst.fTop + calculateStretch(bounds.fBottom, dst.fTop,
srcYSize,
numStretchyYPixelsRemaining,
numFixedYPixelsRemaining);
numStretchyYPixelsRemaining -= srcYSize;
} else {
dst.fBottom = dst.fTop + SkIntToScalar(srcYSize);
numFixedYPixelsRemaining -= srcYSize;
}
}
xIsStretchable = initialXIsStretchable;
// The initial xDiv and whether the first column is considered
// stretchable or not depends on whether xDiv[0] was zero or not.
for (i = xIsStretchable ? 1 : 0;
i <= numXDivs && src.fLeft < bitmapWidth;
i++, xIsStretchable = !xIsStretchable) {
color = chunk.colors[colorIndex++];
if (i == numXDivs) {
src.fRight = bitmapWidth;
dst.fRight = bounds.fRight;
} else {
src.fRight = chunk.xDivs[i];
if (dstRightsHaveBeenCached) {
dst.fRight = dstRights[i];
} else {
const int srcXSize = src.fRight - src.fLeft;
if (xIsStretchable) {
dst.fRight = dst.fLeft + calculateStretch(bounds.fRight, dst.fLeft,
srcXSize,
numStretchyXPixelsRemaining,
numFixedXPixelsRemaining);
numStretchyXPixelsRemaining -= srcXSize;
} else {
dst.fRight = dst.fLeft + SkIntToScalar(srcXSize);
numFixedXPixelsRemaining -= srcXSize;
}
dstRights[i] = dst.fRight;
}
}
// If this horizontal patch is too small to be displayed, leave
// the destination left edge where it is and go on to the next patch
// in the source.
if (src.fLeft >= src.fRight) {
src.fLeft = src.fRight;
continue;
}
// Make sure that we actually have room to draw any bits
if (dst.fRight <= dst.fLeft || dst.fBottom <= dst.fTop) {
goto nextDiv;
}
// If this patch is transparent, skip and don't draw.
if (color == android::Res_png_9patch::TRANSPARENT_COLOR && !hasXfer) {
if (outRegion) {
if (*outRegion == NULL) {
*outRegion = new SkRegion();
}
SkIRect idst;
dst.round(&idst);
//LOGI("Adding trans rect: (%d,%d)-(%d,%d)\n",
// idst.fLeft, idst.fTop, idst.fRight, idst.fBottom);
(*outRegion)->op(idst, SkRegion::kUnion_Op);
}
goto nextDiv;
}
if (canvas) {
#if 0
SkDebugf("-- src [%d %d %d %d] dst [%g %g %g %g]\n",
src.fLeft, src.fTop, src.width(), src.height(),
SkScalarToFloat(dst.fLeft), SkScalarToFloat(dst.fTop),
SkScalarToFloat(dst.width()), SkScalarToFloat(dst.height()));
if (2 == src.width() && SkIntToScalar(5) == dst.width()) {
SkDebugf("--- skip patch\n");
}
#endif
drawStretchyPatch(canvas, src, dst, bitmap, *paint, initColor,
color, hasXfer);
}
nextDiv:
src.fLeft = src.fRight;
dst.fLeft = dst.fRight;
}
src.fTop = src.fBottom;
dst.fTop = dst.fBottom;
dstRightsHaveBeenCached = true;
}
}
