static SkBitmap deepSkBitmapCopy(const SkBitmap& bitmap) { SkBitmap tmp; if (!bitmap.deepCopyTo(&tmp, bitmap.config())) bitmap.copyTo(&tmp, bitmap.config()); return tmp; }
PassRefPtr<BitmapImageSingleFrameSkia> BitmapImageSingleFrameSkia::create(const SkBitmap& bitmap, bool copyPixels, float resolutionScale) { if (copyPixels) { SkBitmap temp; if (!bitmap.deepCopyTo(&temp, bitmap.config())) bitmap.copyTo(&temp, bitmap.config()); return adoptRef(new BitmapImageSingleFrameSkia(temp, resolutionScale)); } return adoptRef(new BitmapImageSingleFrameSkia(bitmap, resolutionScale)); }
virtual void onDraw(SkCanvas* canvas) { SkPaint paint; SkScalar horizMargin(SkIntToScalar(10)); SkScalar vertMargin(SkIntToScalar(10)); SkBitmapDevice devTmp(SkBitmap::kARGB_8888_Config, 40, 40, false); SkCanvas canvasTmp(&devTmp); draw_checks(&canvasTmp, 40, 40); SkBitmap src = canvasTmp.getTopDevice()->accessBitmap(false); for (unsigned i = 0; i < NUM_CONFIGS; ++i) { if (!src.deepCopyTo(&fDst[i], gConfigs[i])) { src.copyTo(&fDst[i], gConfigs[i]); } } canvas->clear(0xFFDDDDDD); paint.setAntiAlias(true); SkScalar width = SkIntToScalar(40); SkScalar height = SkIntToScalar(40); if (paint.getFontSpacing() > height) { height = paint.getFontSpacing(); } for (unsigned i = 0; i < NUM_CONFIGS; i++) { const char* name = gConfigNames[src.config()]; SkScalar textWidth = paint.measureText(name, strlen(name)); if (textWidth > width) { width = textWidth; } } SkScalar horizOffset = width + horizMargin; SkScalar vertOffset = height + vertMargin; canvas->translate(SkIntToScalar(20), SkIntToScalar(20)); for (unsigned i = 0; i < NUM_CONFIGS; i++) { canvas->save(); // Draw destination config name const char* name = gConfigNames[fDst[i].config()]; SkScalar textWidth = paint.measureText(name, strlen(name)); SkScalar x = (width - textWidth) / SkScalar(2); SkScalar y = paint.getFontSpacing() / SkScalar(2); canvas->drawText(name, strlen(name), x, y, paint); // Draw destination bitmap canvas->translate(0, vertOffset); x = (width - 40) / SkScalar(2); canvas->drawBitmap(fDst[i], x, 0, &paint); canvas->restore(); canvas->translate(horizOffset, 0); } }
SkPDFImage::SkPDFImage(SkStream* stream, const SkBitmap& bitmap, bool isAlpha, const SkIRect& srcRect) : fIsAlpha(isAlpha), fSrcRect(srcRect) { if (bitmap.isImmutable()) { fBitmap = bitmap; } else { bitmap.deepCopyTo(&fBitmap); fBitmap.setImmutable(); } if (stream != NULL) { this->setData(stream); fStreamValid = true; } else { fStreamValid = false; } SkColorType colorType = fBitmap.colorType(); insertName("Type", "XObject"); insertName("Subtype", "Image"); bool alphaOnly = (kAlpha_8_SkColorType == colorType); if (!isAlpha && alphaOnly) { // For alpha only images, we stretch a single pixel of black for // the color/shape part. SkAutoTUnref<SkPDFInt> one(new SkPDFInt(1)); insert("Width", one.get()); insert("Height", one.get()); } else { insertInt("Width", fSrcRect.width()); insertInt("Height", fSrcRect.height()); } if (isAlpha || alphaOnly) { insertName("ColorSpace", "DeviceGray"); } else if (kIndex_8_SkColorType == colorType) { SkAutoLockPixels alp(fBitmap); insert("ColorSpace", make_indexed_color_space(fBitmap.getColorTable()))->unref(); } else { insertName("ColorSpace", "DeviceRGB"); } int bitsPerComp = 8; if (kARGB_4444_SkColorType == colorType) { bitsPerComp = 4; } insertInt("BitsPerComponent", bitsPerComp); if (kRGB_565_SkColorType == colorType) { SkASSERT(!isAlpha); SkAutoTUnref<SkPDFInt> zeroVal(new SkPDFInt(0)); SkAutoTUnref<SkPDFScalar> scale5Val( new SkPDFScalar(8.2258f)); // 255/2^5-1 SkAutoTUnref<SkPDFScalar> scale6Val( new SkPDFScalar(4.0476f)); // 255/2^6-1 SkAutoTUnref<SkPDFArray> decodeValue(new SkPDFArray()); decodeValue->reserve(6); decodeValue->append(zeroVal.get()); decodeValue->append(scale5Val.get()); decodeValue->append(zeroVal.get()); decodeValue->append(scale6Val.get()); decodeValue->append(zeroVal.get()); decodeValue->append(scale5Val.get()); insert("Decode", decodeValue.get()); } }
// Stripped down version of TestBitmapCopy that checks basic fields (width, height, config, genID) // to ensure that they were copied properly. static void TestGpuBitmapCopy(skiatest::Reporter* reporter, GrContextFactory* factory) { #ifdef SK_BUILD_FOR_ANDROID // https://code.google.com/p/skia/issues/detail?id=753 return; #endif for (int type = 0; type < GrContextFactory::kLastGLContextType; ++type) { GrContextFactory::GLContextType glType = static_cast<GrContextFactory::GLContextType>(type); if (!GrContextFactory::IsRenderingGLContext(glType)) { continue; } GrContext* grContext = factory->get(glType); if (NULL == grContext) { continue; } if (NULL == grContext) { return; } static const Pair gPairs[] = { { SkBitmap::kNo_Config, "000" }, { SkBitmap::kARGB_4444_Config, "011" }, { SkBitmap::kARGB_8888_Config, "011" }, }; const int W = 20; const int H = 33; for (size_t i = 0; i < SK_ARRAY_COUNT(gPairs); i++) { SkBitmap src, dst; SkGpuDevice* device = SkNEW_ARGS(SkGpuDevice, (grContext, gPairs[i].fConfig, W, H)); SkAutoUnref aur(device); src = device->accessBitmap(false); device->clear(SK_ColorWHITE); // Draw something different to the same portion of the bitmap that we will extract as a // subset, so that comparing the pixels of the subset will be meaningful. SkIRect subsetRect = SkIRect::MakeLTRB(W/2, H/2, W, H); SkCanvas drawingCanvas(device); SkPaint paint; paint.setColor(SK_ColorRED); drawingCanvas.drawRect(SkRect::MakeFromIRect(subsetRect), paint); // Extract a subset. If this succeeds we will test copying the subset. SkBitmap subset; const bool extracted = src.extractSubset(&subset, subsetRect); for (size_t j = 0; j < SK_ARRAY_COUNT(gPairs); j++) { dst.reset(); bool success = src.deepCopyTo(&dst, gPairs[j].fConfig); bool expected = gPairs[i].fValid[j] != '0'; if (success != expected) { SkString str; str.printf("SkBitmap::deepCopyTo from %s to %s. expected %s returned %s", gConfigName[i], gConfigName[j], boolStr(expected), boolStr(success)); reporter->reportFailed(str); } bool canSucceed = src.canCopyTo(gPairs[j].fConfig); if (success != canSucceed) { SkString str; str.printf("SkBitmap::deepCopyTo from %s to %s returned %s," "but canCopyTo returned %s", gConfigName[i], gConfigName[j], boolStr(success), boolStr(canSucceed)); reporter->reportFailed(str); } TestIndividualCopy(reporter, gPairs[j].fConfig, success, src, dst); // Test copying the subset bitmap, using both copyTo and deepCopyTo. if (extracted) { SkBitmap subsetCopy; success = subset.copyTo(&subsetCopy, gPairs[j].fConfig); REPORTER_ASSERT(reporter, success == expected); REPORTER_ASSERT(reporter, success == canSucceed); TestIndividualCopy(reporter, gPairs[j].fConfig, success, subset, subsetCopy, false); // Reset the bitmap so that a failed copyTo will leave it in the expected state. subsetCopy.reset(); success = subset.deepCopyTo(&subsetCopy, gPairs[j].fConfig); REPORTER_ASSERT(reporter, success == expected); REPORTER_ASSERT(reporter, success == canSucceed); TestIndividualCopy(reporter, gPairs[j].fConfig, success, subset, subsetCopy, true); } } // for (size_t j = ... } // for (size_t i = ... } // GrContextFactory::GLContextType }