virtual void onPreDraw() {
SkBitmap bm;
if (SkBitmap::kIndex8_Config == fConfig) {
bm.setConfig(SkBitmap::kARGB_8888_Config, W, H);
} else {
bm.setConfig(fConfig, W, H);
}
bm.allocPixels();
bm.eraseColor(fIsOpaque ? SK_ColorBLACK : 0);
onDrawIntoBitmap(bm);
if (SkBitmap::kIndex8_Config == fConfig) {
convertToIndex666(bm, &fBitmap);
} else {
fBitmap = bm;
}
if (fBitmap.getColorTable()) {
fBitmap.getColorTable()->setIsOpaque(fIsOpaque);
}
fBitmap.setIsOpaque(fIsOpaque);
fBitmap.setIsVolatile(fIsVolatile);
}
DEF_TEST(DiscardablePixelRef_SecondLockColorTableCheck, r) {
SkString resourceDir = GetResourcePath();
SkString path = SkOSPath::Join(resourceDir.c_str(), "randPixels.gif");
if (!sk_exists(path.c_str())) {
return;
}
SkAutoDataUnref encoded(SkData::NewFromFileName(path.c_str()));
SkBitmap bitmap;
if (!SkInstallDiscardablePixelRef(
SkDecodingImageGenerator::Create(
encoded, SkDecodingImageGenerator::Options()), &bitmap)) {
#ifndef SK_BUILD_FOR_WIN
ERRORF(r, "SkInstallDiscardablePixelRef [randPixels.gif] failed.");
#endif
return;
}
if (kIndex_8_SkColorType != bitmap.colorType()) {
return;
}
{
SkAutoLockPixels alp(bitmap);
REPORTER_ASSERT(r, bitmap.getColorTable() && "first pass");
}
{
SkAutoLockPixels alp(bitmap);
REPORTER_ASSERT(r, bitmap.getColorTable() && "second pass");
}
}
BitmapBench(void* param, bool isOpaque, SkBitmap::Config c,
bool forceUpdate = false, bool bitmapVolatile = false,
int tx = -1, int ty = -1)
: INHERITED(param), fIsOpaque(isOpaque), fForceUpdate(forceUpdate), fTileX(tx), fTileY(ty) {
const int w = 128;
const int h = 128;
SkBitmap bm;
if (SkBitmap::kIndex8_Config == c) {
bm.setConfig(SkBitmap::kARGB_8888_Config, w, h);
} else {
bm.setConfig(c, w, h);
}
bm.allocPixels();
bm.eraseColor(isOpaque ? SK_ColorBLACK : 0);
drawIntoBitmap(bm);
if (SkBitmap::kIndex8_Config == c) {
convertToIndex666(bm, &fBitmap);
} else {
fBitmap = bm;
}
if (fBitmap.getColorTable()) {
fBitmap.getColorTable()->setIsOpaque(isOpaque);
}
fBitmap.setIsOpaque(isOpaque);
fBitmap.setIsVolatile(bitmapVolatile);
}
DEF_TEST(BitmapCopy_extractSubset, reporter) {
for (size_t i = 0; i < SK_ARRAY_COUNT(gPairs); i++) {
SkBitmap srcOpaque, srcPremul;
setup_src_bitmaps(&srcOpaque, &srcPremul, gPairs[i].fColorType);
SkBitmap bitmap(srcOpaque);
SkBitmap subset;
SkIRect r;
// Extract a subset which has the same width as the original. This
// catches a bug where we cloned the genID incorrectly.
r.set(0, 1, W, 3);
bitmap.setIsVolatile(true);
// Relies on old behavior of extractSubset failing if colortype is unknown
if (kUnknown_SkColorType != bitmap.colorType() && bitmap.extractSubset(&subset, r)) {
REPORTER_ASSERT(reporter, subset.width() == W);
REPORTER_ASSERT(reporter, subset.height() == 2);
REPORTER_ASSERT(reporter, subset.alphaType() == bitmap.alphaType());
REPORTER_ASSERT(reporter, subset.isVolatile() == true);
// Test copying an extracted subset.
for (size_t j = 0; j < SK_ARRAY_COUNT(gPairs); j++) {
SkBitmap copy;
bool success = subset.copyTo(©, gPairs[j].fColorType);
if (!success) {
// Skip checking that success matches fValid, which is redundant
// with the code below.
REPORTER_ASSERT(reporter, gPairs[i].fColorType != gPairs[j].fColorType);
continue;
}
// When performing a copy of an extracted subset, the gen id should
// change.
REPORTER_ASSERT(reporter, copy.getGenerationID() != subset.getGenerationID());
REPORTER_ASSERT(reporter, copy.width() == W);
REPORTER_ASSERT(reporter, copy.height() == 2);
if (gPairs[i].fColorType == gPairs[j].fColorType) {
SkAutoLockPixels alp0(subset);
SkAutoLockPixels alp1(copy);
// they should both have, or both not-have, a colortable
bool hasCT = subset.getColorTable() != nullptr;
REPORTER_ASSERT(reporter, (copy.getColorTable() != nullptr) == hasCT);
}
}
}
bitmap = srcPremul;
bitmap.setIsVolatile(false);
if (bitmap.extractSubset(&subset, r)) {
REPORTER_ASSERT(reporter, subset.alphaType() == bitmap.alphaType());
REPORTER_ASSERT(reporter, subset.isVolatile() == false);
}
}
}
virtual Result onGetPixels(const SkImageInfo& info, void* pixels, size_t rowBytes,
const Options&,
SkPMColor ctableEntries[], int* ctableCount) override {
SkMemoryStream stream(fData->data(), fData->size(), false);
SkAutoTUnref<BareMemoryAllocator> allocator(SkNEW_ARGS(BareMemoryAllocator,
(info, pixels, rowBytes)));
fDecoder->setAllocator(allocator);
fDecoder->setRequireUnpremultipliedColors(kUnpremul_SkAlphaType == info.alphaType());
SkBitmap bm;
const SkImageDecoder::Result result = fDecoder->decode(&stream, &bm, info.colorType(),
SkImageDecoder::kDecodePixels_Mode);
if (SkImageDecoder::kFailure == result) {
return kInvalidInput;
}
SkASSERT(info.colorType() == bm.info().colorType());
if (kIndex_8_SkColorType == info.colorType()) {
SkASSERT(ctableEntries);
SkColorTable* ctable = bm.getColorTable();
if (NULL == ctable) {
return kInvalidConversion;
}
const int count = ctable->count();
memcpy(ctableEntries, ctable->readColors(), count * sizeof(SkPMColor));
*ctableCount = count;
}
if (SkImageDecoder::kPartialSuccess == result) {
return kIncompleteInput;
}
return kSuccess;
}
/* Fill out buffer with the compressed format Ganesh expects from a colortable
based bitmap. [palette (colortable) + indices].
At the moment Ganesh only supports 8bit version. If Ganesh allowed we others
we could detect that the colortable.count is <= 16, and then repack the
indices as nibbles to save RAM, but it would take more time (i.e. a lot
slower than memcpy), so skipping that for now.
Ganesh wants a full 256 palette entry, even though Skia's ctable is only as big
as the colortable.count says it is.
*/
static void build_compressed_data(void* buffer, const SkBitmap& bitmap) {
SkASSERT(SkBitmap::kIndex8_Config == bitmap.config());
SkAutoLockPixels apl(bitmap);
if (!bitmap.readyToDraw()) {
SkASSERT(!"bitmap not ready to draw!");
return;
}
SkColorTable* ctable = bitmap.getColorTable();
char* dst = (char*)buffer;
memcpy(dst, ctable->lockColors(), ctable->count() * sizeof(SkPMColor));
ctable->unlockColors(false);
// always skip a full 256 number of entries, even if we memcpy'd fewer
dst += kGrColorTableSize;
if (bitmap.width() == bitmap.rowBytes()) {
memcpy(dst, bitmap.getPixels(), bitmap.getSize());
} else {
// need to trim off the extra bytes per row
size_t width = bitmap.width();
size_t rowBytes = bitmap.rowBytes();
const char* src = (const char*)bitmap.getPixels();
for (int y = 0; y < bitmap.height(); y++) {
memcpy(dst, src, width);
src += rowBytes;
dst += width;
}
}
}
static void init_src(const SkBitmap& bitmap) {
SkAutoLockPixels lock(bitmap);
if (bitmap.getPixels()) {
if (bitmap.getColorTable()) {
sk_bzero(bitmap.getPixels(), bitmap.getSize());
} else {
bitmap.eraseColor(SK_ColorWHITE);
}
}
}
/* Fill out buffer with the compressed format GL expects from a colortable
based bitmap. [palette (colortable) + indices].
At the moment I always take the 8bit version, since that's what my data
is. I could detect that the colortable.count is <= 16, and then repack the
indices as nibbles to save RAM, but it would take more time (i.e. a lot
slower than memcpy), so I'm skipping that for now.
GL wants a full 256 palette entry, even though my ctable is only as big
as the colortable.count says it is. I presume it is OK to leave any
trailing entries uninitialized, since none of my indices should exceed
ctable->count().
*/
static void build_compressed_data(void* buffer, const SkBitmap& bitmap) {
SkASSERT(SkBitmap::kIndex8_Config == bitmap.config());
SkColorTable* ctable = bitmap.getColorTable();
uint8_t* dst = (uint8_t*)buffer;
memcpy(dst, ctable->lockColors(), ctable->count() * sizeof(SkPMColor));
ctable->unlockColors(false);
// always skip a full 256 number of entries, even if we memcpy'd fewer
dst += SK_GL_SIZE_OF_PALETTE;
memcpy(dst, bitmap.getPixels(), bitmap.getSize());
}
static void emit_image_xobject(SkWStream* stream,
const SkImage* image,
bool alpha,
const sk_sp<SkPDFObject>& smask,
const SkPDFObjNumMap& objNumMap,
const SkPDFSubstituteMap& substitutes) {
SkBitmap bitmap;
image_get_ro_pixels(image, &bitmap); // TODO(halcanary): test
SkAutoLockPixels autoLockPixels(bitmap); // with malformed images.
// Write to a temporary buffer to get the compressed length.
SkDynamicMemoryWStream buffer;
SkDeflateWStream deflateWStream(&buffer);
if (alpha) {
bitmap_alpha_to_a8(bitmap, &deflateWStream);
} else {
bitmap_to_pdf_pixels(bitmap, &deflateWStream);
}
deflateWStream.finalize(); // call before detachAsStream().
std::unique_ptr<SkStreamAsset> asset(buffer.detachAsStream());
SkPDFDict pdfDict("XObject");
pdfDict.insertName("Subtype", "Image");
pdfDict.insertInt("Width", bitmap.width());
pdfDict.insertInt("Height", bitmap.height());
if (alpha) {
pdfDict.insertName("ColorSpace", "DeviceGray");
} else if (bitmap.colorType() == kIndex_8_SkColorType) {
SkASSERT(1 == pdf_color_component_count(bitmap.colorType()));
pdfDict.insertObject("ColorSpace",
make_indexed_color_space(bitmap.getColorTable(),
bitmap.alphaType()));
} else if (1 == pdf_color_component_count(bitmap.colorType())) {
pdfDict.insertName("ColorSpace", "DeviceGray");
} else {
pdfDict.insertName("ColorSpace", "DeviceRGB");
}
if (smask) {
pdfDict.insertObjRef("SMask", smask);
}
pdfDict.insertInt("BitsPerComponent", 8);
pdfDict.insertName("Filter", "FlateDecode");
pdfDict.insertInt("Length", asset->getLength());
pdfDict.emitObject(stream, objNumMap, substitutes);
pdf_stream_begin(stream);
stream->writeStream(asset.get(), asset->getLength());
pdf_stream_end(stream);
}
static bool valid_for_drawing(const SkBitmap& bm) {
if (0 == bm.width() || 0 == bm.height()) {
return false; // nothing to draw
}
if (NULL == bm.pixelRef()) {
return false; // no pixels to read
}
if (SkBitmap::kIndex8_Config == bm.config()) {
// ugh, I have to lock-pixels to inspect the colortable
SkAutoLockPixels alp(bm);
if (!bm.getColorTable()) {
return false;
}
}
return true;
}
/* Fill out buffer with the compressed format Ganesh expects from a colortable
based bitmap. [palette (colortable) + indices].
At the moment Ganesh only supports 8bit version. If Ganesh allowed we others
we could detect that the colortable.count is <= 16, and then repack the
indices as nibbles to save RAM, but it would take more time (i.e. a lot
slower than memcpy), so skipping that for now.
Ganesh wants a full 256 palette entry, even though Skia's ctable is only as big
as the colortable.count says it is.
*/
static void build_compressed_data(void* buffer, const SkBitmap& bitmap) {
SkASSERT(SkBitmap::kIndex8_Config == bitmap.config());
SkAutoLockPixels alp(bitmap);
if (!bitmap.readyToDraw()) {
SkDEBUGFAIL("bitmap not ready to draw!");
return;
}
SkColorTable* ctable = bitmap.getColorTable();
char* dst = (char*)buffer;
const int count = ctable->count();
SkDstPixelInfo dstPI;
dstPI.fColorType = kRGBA_8888_SkColorType;
dstPI.fAlphaType = kPremul_SkAlphaType;
dstPI.fPixels = buffer;
dstPI.fRowBytes = count * sizeof(SkPMColor);
SkSrcPixelInfo srcPI;
srcPI.fColorType = kPMColor_SkColorType;
srcPI.fAlphaType = kPremul_SkAlphaType;
srcPI.fPixels = ctable->lockColors();
srcPI.fRowBytes = count * sizeof(SkPMColor);
srcPI.convertPixelsTo(&dstPI, count, 1);
ctable->unlockColors();
// always skip a full 256 number of entries, even if we memcpy'd fewer
dst += kGrColorTableSize;
if ((unsigned)bitmap.width() == bitmap.rowBytes()) {
memcpy(dst, bitmap.getPixels(), bitmap.getSize());
} else {
// need to trim off the extra bytes per row
size_t width = bitmap.width();
size_t rowBytes = bitmap.rowBytes();
const char* src = (const char*)bitmap.getPixels();
for (int y = 0; y < bitmap.height(); y++) {
memcpy(dst, src, width);
src += rowBytes;
dst += width;
}
}
}
// can return NULL
static ToColorProc ChooseToColorProc(const SkBitmap& src) {
switch (src.colorType()) {
case kN32_SkColorType:
switch (src.alphaType()) {
case kOpaque_SkAlphaType:
return ToColor_S32_Opaque;
case kPremul_SkAlphaType:
return ToColor_S32_Alpha;
case kUnpremul_SkAlphaType:
return ToColor_S32_Raw;
default:
return NULL;
}
case kARGB_4444_SkColorType:
switch (src.alphaType()) {
case kOpaque_SkAlphaType:
return ToColor_S4444_Opaque;
case kPremul_SkAlphaType:
return ToColor_S4444_Alpha;
case kUnpremul_SkAlphaType:
return ToColor_S4444_Raw;
default:
return NULL;
}
case kRGB_565_SkColorType:
return ToColor_S565;
case kIndex_8_SkColorType:
if (src.getColorTable() == NULL) {
return NULL;
}
switch (src.alphaType()) {
case kOpaque_SkAlphaType:
return ToColor_SI8_Opaque;
case kPremul_SkAlphaType:
return ToColor_SI8_Alpha;
case kUnpremul_SkAlphaType:
return ToColor_SI8_Raw;
default:
return NULL;
}
default:
break;
}
return NULL;
}
// can return NULL
static ToColorProc ChooseToColorProc(const SkBitmap& src) {
switch (src.config()) {
case SkBitmap::kARGB_8888_Config:
return src.isOpaque() ? ToColor_S32_Opaque : ToColor_S32_Alpha;
case SkBitmap::kARGB_4444_Config:
return src.isOpaque() ? ToColor_S4444_Opaque : ToColor_S4444_Alpha;
case SkBitmap::kRGB_565_Config:
return ToColor_S565;
case SkBitmap::kIndex8_Config:
if (src.getColorTable() == NULL) {
return NULL;
}
return src.isOpaque() ? ToColor_SI8_Opaque : ToColor_SI8_Alpha;
default:
break;
}
return NULL;
}
static bool valid_for_drawing(const SkBitmap& bm) {
if (0 == bm.width() || 0 == bm.height()) {
return false; // nothing to draw
}
if (NULL == bm.pixelRef()) {
return false; // no pixels to read
}
if (bm.getTexture()) {
// we can handle texture (ugh) since lockPixels will perform a read-back
return true;
}
if (kIndex_8_SkColorType == bm.colorType()) {
SkAutoLockPixels alp(bm); // but we need to call it before getColorTable() is safe.
if (!bm.getColorTable()) {
return false;
}
}
return true;
}
// can return NULL
static ToColorProc ChooseToColorProc(const SkBitmap& src, bool isPremultiplied) {
switch (src.config()) {
case SkBitmap::kARGB_8888_Config:
if (src.isOpaque()) return ToColor_S32_Opaque;
return isPremultiplied ? ToColor_S32_Alpha : ToColor_S32_Raw;
case SkBitmap::kARGB_4444_Config:
if (src.isOpaque()) return ToColor_S4444_Opaque;
return isPremultiplied ? ToColor_S4444_Alpha : ToColor_S4444_Raw;
case SkBitmap::kRGB_565_Config:
return ToColor_S565;
case SkBitmap::kIndex8_Config:
if (src.getColorTable() == NULL) {
return NULL;
}
if (src.isOpaque()) return ToColor_SI8_Opaque;
return isPremultiplied ? ToColor_SI8_Raw : ToColor_SI8_Alpha;
default:
break;
}
return NULL;
}
// Note, this returns a new, mutable, bitmap, with a new genID.
// If you want the immutable bitmap with the same ID as our cacherator, call tryLockAsBitmap()
//
bool SkImageCacherator::generateBitmap(SkBitmap* bitmap) {
ScopedGenerator generator(this);
const SkImageInfo& genInfo = generator->getInfo();
if (fInfo.dimensions() == genInfo.dimensions()) {
SkASSERT(fOrigin.x() == 0 && fOrigin.y() == 0);
// fast-case, no copy needed
return generator->tryGenerateBitmap(bitmap, fInfo);
} else {
// need to handle subsetting, so we first generate the full size version, and then
// "read" from it to get our subset. See skbug.com/4213
SkBitmap full;
if (!generator->tryGenerateBitmap(&full, genInfo)) {
return false;
}
if (!bitmap->tryAllocPixels(fInfo, nullptr, full.getColorTable())) {
return false;
}
return full.readPixels(bitmap->info(), bitmap->getPixels(), bitmap->rowBytes(),
fOrigin.x(), fOrigin.y());
}
}
static bool getColor(const SkBitmap& bitmap, int x, int y, SkColor* c) {
switch (bitmap.getConfig()) {
case SkBitmap::kARGB_8888_Config:
*c = SkUnPreMultiply::PMColorToColor(*bitmap.getAddr32(x, y));
break;
case SkBitmap::kRGB_565_Config:
*c = SkPixel16ToPixel32(*bitmap.getAddr16(x, y));
break;
case SkBitmap::kARGB_4444_Config:
*c = SkUnPreMultiply::PMColorToColor(
SkPixel4444ToPixel32(*bitmap.getAddr16(x, y)));
break;
case SkBitmap::kIndex8_Config: {
SkColorTable* ctable = bitmap.getColorTable();
*c = SkUnPreMultiply::PMColorToColor(
(*ctable)[*bitmap.getAddr8(x, y)]);
break;
}
default:
return false;
}
return true;
}
/* Fill out buffer with the compressed format Ganesh expects from a colortable
based bitmap. [palette (colortable) + indices].
At the moment Ganesh only supports 8bit version. If Ganesh allowed we others
we could detect that the colortable.count is <= 16, and then repack the
indices as nibbles to save RAM, but it would take more time (i.e. a lot
slower than memcpy), so skipping that for now.
Ganesh wants a full 256 palette entry, even though Skia's ctable is only as big
as the colortable.count says it is.
*/
static void build_compressed_data(void* buffer, const SkBitmap& bitmap) {
SkASSERT(SkBitmap::kIndex8_Config == bitmap.config());
SkAutoLockPixels alp(bitmap);
if (!bitmap.readyToDraw()) {
SkDEBUGFAIL("bitmap not ready to draw!");
return;
}
SkColorTable* ctable = bitmap.getColorTable();
char* dst = (char*)buffer;
uint32_t* colorTableDst = reinterpret_cast<uint32_t*>(dst);
const uint32_t* colorTableSrc = reinterpret_cast<const uint32_t*>(ctable->lockColors());
SkConvertConfig8888Pixels(colorTableDst, 0, SkCanvas::kRGBA_Premul_Config8888,
colorTableSrc, 0, SkCanvas::kNative_Premul_Config8888,
ctable->count(), 1);
ctable->unlockColors();
// always skip a full 256 number of entries, even if we memcpy'd fewer
dst += kGrColorTableSize;
if ((unsigned)bitmap.width() == bitmap.rowBytes()) {
memcpy(dst, bitmap.getPixels(), bitmap.getSize());
} else {
// need to trim off the extra bytes per row
size_t width = bitmap.width();
size_t rowBytes = bitmap.rowBytes();
const char* src = (const char*)bitmap.getPixels();
for (int y = 0; y < bitmap.height(); y++) {
memcpy(dst, src, width);
src += rowBytes;
dst += width;
}
}
}
static void test_peekpixels(skiatest::Reporter* reporter) {
const SkImageInfo info = SkImageInfo::MakeN32Premul(10, 10);
SkPixmap pmap;
SkBitmap bm;
// empty should return false
REPORTER_ASSERT(reporter, !bm.peekPixels(nullptr));
REPORTER_ASSERT(reporter, !bm.peekPixels(&pmap));
// no pixels should return false
bm.setInfo(SkImageInfo::MakeN32Premul(10, 10));
REPORTER_ASSERT(reporter, !bm.peekPixels(nullptr));
REPORTER_ASSERT(reporter, !bm.peekPixels(&pmap));
// real pixels should return true
bm.allocPixels(info);
REPORTER_ASSERT(reporter, bm.peekPixels(nullptr));
REPORTER_ASSERT(reporter, bm.peekPixels(&pmap));
REPORTER_ASSERT(reporter, pmap.info() == bm.info());
REPORTER_ASSERT(reporter, pmap.addr() == bm.getPixels());
REPORTER_ASSERT(reporter, pmap.rowBytes() == bm.rowBytes());
REPORTER_ASSERT(reporter, pmap.ctable() == bm.getColorTable());
}
static void TestBitmapCopy(skiatest::Reporter* reporter) {
static const Pair gPairs[] = {
{ SkBitmap::kNo_Config, "00000000" },
{ SkBitmap::kA1_Config, "01000000" },
{ SkBitmap::kA8_Config, "00101110" },
{ SkBitmap::kIndex8_Config, "00111110" },
{ SkBitmap::kRGB_565_Config, "00101110" },
{ SkBitmap::kARGB_4444_Config, "00101110" },
{ SkBitmap::kARGB_8888_Config, "00101110" },
// TODO: create valid RLE bitmap to test with
// { SkBitmap::kRLE_Index8_Config, "00101111" }
};
const int W = 20;
const int H = 33;
for (size_t i = 0; i < SK_ARRAY_COUNT(gPairs); i++) {
for (size_t j = 0; j < SK_ARRAY_COUNT(gPairs); j++) {
SkBitmap src, dst;
SkColorTable* ct = NULL;
src.setConfig(gPairs[i].fConfig, W, H);
if (SkBitmap::kIndex8_Config == src.config() ||
SkBitmap::kRLE_Index8_Config == src.config()) {
ct = init_ctable();
}
src.allocPixels(ct);
ct->safeRef();
init_src(src);
bool success = src.copyTo(&dst, gPairs[j].fConfig);
bool expected = gPairs[i].fValid[j] != '0';
if (success != expected) {
SkString str;
str.printf("SkBitmap::copyTo 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::copyTo from %s to %s. returned %s canCopyTo %s",
gConfigName[i], gConfigName[j], boolStr(success),
boolStr(canSucceed));
reporter->reportFailed(str);
}
if (success) {
REPORTER_ASSERT(reporter, src.width() == dst.width());
REPORTER_ASSERT(reporter, src.height() == dst.height());
REPORTER_ASSERT(reporter, dst.config() == gPairs[j].fConfig);
test_isOpaque(reporter, src, dst.config());
if (src.config() == dst.config()) {
SkAutoLockPixels srcLock(src);
SkAutoLockPixels dstLock(dst);
REPORTER_ASSERT(reporter, src.readyToDraw());
REPORTER_ASSERT(reporter, dst.readyToDraw());
const char* srcP = (const char*)src.getAddr(0, 0);
const char* dstP = (const char*)dst.getAddr(0, 0);
REPORTER_ASSERT(reporter, srcP != dstP);
REPORTER_ASSERT(reporter, !memcmp(srcP, dstP,
src.getSize()));
}
// test extractSubset
{
SkBitmap subset;
SkIRect r;
r.set(1, 1, 2, 2);
if (src.extractSubset(&subset, r)) {
REPORTER_ASSERT(reporter, subset.width() == 1);
REPORTER_ASSERT(reporter, subset.height() == 1);
SkBitmap copy;
REPORTER_ASSERT(reporter,
subset.copyTo(©, subset.config()));
REPORTER_ASSERT(reporter, copy.width() == 1);
REPORTER_ASSERT(reporter, copy.height() == 1);
REPORTER_ASSERT(reporter, copy.rowBytes() <= 4);
SkAutoLockPixels alp0(subset);
SkAutoLockPixels alp1(copy);
// they should both have, or both not-have, a colortable
bool hasCT = subset.getColorTable() != NULL;
REPORTER_ASSERT(reporter,
(copy.getColorTable() != NULL) == hasCT);
}
}
} else {
// dst should be unchanged from its initial state
REPORTER_ASSERT(reporter, dst.config() == SkBitmap::kNo_Config);
REPORTER_ASSERT(reporter, dst.width() == 0);
REPORTER_ASSERT(reporter, dst.height() == 0);
}
}
}
}
QImage toQImage(const SkBitmap &bitmap)
{
QImage image;
switch (bitmap.colorType()) {
case kUnknown_SkColorType:
break;
case kAlpha_8_SkColorType:
image = toQImage(bitmap, QImage::Format_Alpha8);
break;
case kRGB_565_SkColorType:
image = toQImage(bitmap, QImage::Format_RGB16);
break;
case kARGB_4444_SkColorType:
switch (bitmap.alphaType()) {
case kUnknown_SkAlphaType:
break;
case kUnpremul_SkAlphaType:
// not supported - treat as opaque
case kOpaque_SkAlphaType:
image = toQImage(bitmap, QImage::Format_RGB444);
break;
case kPremul_SkAlphaType:
image = toQImage(bitmap, QImage::Format_ARGB4444_Premultiplied);
break;
}
break;
case kRGBA_8888_SkColorType:
switch (bitmap.alphaType()) {
case kUnknown_SkAlphaType:
break;
case kOpaque_SkAlphaType:
image = toQImage(bitmap, QImage::Format_RGBX8888);
break;
case kPremul_SkAlphaType:
image = toQImage(bitmap, QImage::Format_RGBA8888_Premultiplied);
break;
case kUnpremul_SkAlphaType:
image = toQImage(bitmap, QImage::Format_RGBA8888);
break;
}
break;
case kBGRA_8888_SkColorType:
// we are assuming little-endian arch here.
switch (bitmap.alphaType()) {
case kUnknown_SkAlphaType:
break;
case kOpaque_SkAlphaType:
image = toQImage(bitmap, QImage::Format_RGB32);
break;
case kPremul_SkAlphaType:
image = toQImage(bitmap, QImage::Format_ARGB32_Premultiplied);
break;
case kUnpremul_SkAlphaType:
image = toQImage(bitmap, QImage::Format_ARGB32);
break;
}
break;
case kIndex_8_SkColorType: {
image = toQImage(bitmap, QImage::Format_Indexed8);
SkColorTable *skTable = bitmap.getColorTable();
if (skTable) {
QVector<QRgb> qTable(skTable->count());
for (int i = 0; i < skTable->count(); ++i)
qTable[i] = (*skTable)[i];
image.setColorTable(qTable);
}
break;
}
case kGray_8_SkColorType:
image = toQImage(bitmap, QImage::Format_Grayscale8);
break;
}
return image;
}
SkPDFImage::SkPDFImage(const SkBitmap& bitmap, const SkPaint& paint) {
SkBitmap::Config config = bitmap.getConfig();
// TODO(vandebo) Handle alpha and alpha only images correctly.
SkASSERT(config == SkBitmap::kRGB_565_Config ||
config == SkBitmap::kARGB_4444_Config ||
config == SkBitmap::kARGB_8888_Config ||
config == SkBitmap::kIndex8_Config ||
config == SkBitmap::kRLE_Index8_Config);
SkMemoryStream* image_data = extractImageData(bitmap);
SkAutoUnref image_data_unref(image_data);
fStream = new SkPDFStream(image_data);
fStream->unref(); // SkRefPtr and new both took a reference.
SkRefPtr<SkPDFName> typeValue = new SkPDFName("XObject");
typeValue->unref(); // SkRefPtr and new both took a reference.
insert("Type", typeValue.get());
SkRefPtr<SkPDFName> subTypeValue = new SkPDFName("Image");
subTypeValue->unref(); // SkRefPtr and new both took a reference.
insert("Subtype", subTypeValue.get());
SkRefPtr<SkPDFInt> widthValue = new SkPDFInt(bitmap.width());
widthValue->unref(); // SkRefPtr and new both took a reference.
insert("Width", widthValue.get());
SkRefPtr<SkPDFInt> heightValue = new SkPDFInt(bitmap.height());
heightValue->unref(); // SkRefPtr and new both took a reference.
insert("Height", heightValue.get());
// if (!image mask) {
SkRefPtr<SkPDFObject> colorSpaceValue;
if (config == SkBitmap::kIndex8_Config ||
config == SkBitmap::kRLE_Index8_Config) {
colorSpaceValue = makeIndexedColorSpace(bitmap.getColorTable());
} else {
colorSpaceValue = new SkPDFName("DeviceRGB");
}
colorSpaceValue->unref(); // SkRefPtr and new both took a reference.
insert("ColorSpace", colorSpaceValue.get());
// }
int bitsPerComp = bitmap.bytesPerPixel() * 2;
if (bitsPerComp == 0) {
SkASSERT(config == SkBitmap::kA1_Config);
bitsPerComp = 1;
} else if (bitsPerComp == 2 ||
(bitsPerComp == 4 && config == SkBitmap::kRGB_565_Config)) {
bitsPerComp = 8;
}
SkRefPtr<SkPDFInt> bitsPerCompValue = new SkPDFInt(bitsPerComp);
bitsPerCompValue->unref(); // SkRefPtr and new both took a reference.
insert("BitsPerComponent", bitsPerCompValue.get());
if (config == SkBitmap::kRGB_565_Config) {
SkRefPtr<SkPDFInt> zeroVal = new SkPDFInt(0);
zeroVal->unref(); // SkRefPtr and new both took a reference.
SkRefPtr<SkPDFScalar> scale5Val = new SkPDFScalar(8.2258); // 255/2^5-1
scale5Val->unref(); // SkRefPtr and new both took a reference.
SkRefPtr<SkPDFScalar> scale6Val = new SkPDFScalar(4.0476); // 255/2^6-1
scale6Val->unref(); // SkRefPtr and new both took a reference.
SkRefPtr<SkPDFArray> decodeValue = new SkPDFArray();
decodeValue->unref(); // SkRefPtr and new both took a reference.
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());
}
}
