| |
| /* |
| * Copyright 2010 The Android Open Source Project |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| |
| #include "SkPDFImage.h" |
| |
| #include "SkBitmap.h" |
| #include "SkColor.h" |
| #include "SkColorPriv.h" |
| #include "SkPaint.h" |
| #include "SkPackBits.h" |
| #include "SkPDFCatalog.h" |
| #include "SkRect.h" |
| #include "SkStream.h" |
| #include "SkString.h" |
| #include "SkUnPreMultiply.h" |
| |
| namespace { |
| |
| void extractImageData(const SkBitmap& bitmap, const SkIRect& srcRect, |
| SkStream** imageData, SkStream** alphaData) { |
| SkMemoryStream* image = NULL; |
| SkMemoryStream* alpha = NULL; |
| bool hasAlpha = false; |
| bool isTransparent = false; |
| |
| bitmap.lockPixels(); |
| switch (bitmap.getConfig()) { |
| case SkBitmap::kIndex8_Config: { |
| const int rowBytes = srcRect.width(); |
| image = new SkMemoryStream(rowBytes * srcRect.height()); |
| uint8_t* dst = (uint8_t*)image->getMemoryBase(); |
| for (int y = srcRect.fTop; y < srcRect.fBottom; y++) { |
| memcpy(dst, bitmap.getAddr8(srcRect.fLeft, y), rowBytes); |
| dst += rowBytes; |
| } |
| break; |
| } |
| case SkBitmap::kRLE_Index8_Config: { |
| const int rowBytes = srcRect.width(); |
| image = new SkMemoryStream(rowBytes * srcRect.height()); |
| uint8_t* dst = (uint8_t*)image->getMemoryBase(); |
| const SkBitmap::RLEPixels* rle = |
| (const SkBitmap::RLEPixels*)bitmap.getPixels(); |
| for (int y = srcRect.fTop; y < srcRect.fBottom; y++) { |
| SkPackBits::Unpack8(dst, srcRect.fLeft, rowBytes, |
| rle->packedAtY(y)); |
| dst += rowBytes; |
| } |
| break; |
| } |
| case SkBitmap::kARGB_4444_Config: { |
| isTransparent = true; |
| const int rowBytes = (srcRect.width() * 3 + 1) / 2; |
| const int alphaRowBytes = (srcRect.width() + 1) / 2; |
| image = new SkMemoryStream(rowBytes * srcRect.height()); |
| alpha = new SkMemoryStream(alphaRowBytes * srcRect.height()); |
| uint8_t* dst = (uint8_t*)image->getMemoryBase(); |
| uint8_t* alphaDst = (uint8_t*)alpha->getMemoryBase(); |
| for (int y = srcRect.fTop; y < srcRect.fBottom; y++) { |
| uint16_t* src = bitmap.getAddr16(0, y); |
| int x; |
| for (x = srcRect.fLeft; x + 1 < srcRect.fRight; x += 2) { |
| dst[0] = (SkGetPackedR4444(src[x]) << 4) | |
| SkGetPackedG4444(src[x]); |
| dst[1] = (SkGetPackedB4444(src[x]) << 4) | |
| SkGetPackedR4444(src[x + 1]); |
| dst[2] = (SkGetPackedG4444(src[x + 1]) << 4) | |
| SkGetPackedB4444(src[x + 1]); |
| dst += 3; |
| alphaDst[0] = (SkGetPackedA4444(src[x]) << 4) | |
| SkGetPackedA4444(src[x + 1]); |
| if (alphaDst[0] != 0xFF) { |
| hasAlpha = true; |
| } |
| if (alphaDst[0]) { |
| isTransparent = false; |
| } |
| alphaDst++; |
| } |
| if (srcRect.width() & 1) { |
| dst[0] = (SkGetPackedR4444(src[x]) << 4) | |
| SkGetPackedG4444(src[x]); |
| dst[1] = (SkGetPackedB4444(src[x]) << 4); |
| dst += 2; |
| alphaDst[0] = (SkGetPackedA4444(src[x]) << 4); |
| if (alphaDst[0] != 0xF0) { |
| hasAlpha = true; |
| } |
| if (alphaDst[0] & 0xF0) { |
| isTransparent = false; |
| } |
| alphaDst++; |
| } |
| } |
| break; |
| } |
| case SkBitmap::kRGB_565_Config: { |
| const int rowBytes = srcRect.width() * 3; |
| image = new SkMemoryStream(rowBytes * srcRect.height()); |
| uint8_t* dst = (uint8_t*)image->getMemoryBase(); |
| for (int y = srcRect.fTop; y < srcRect.fBottom; y++) { |
| uint16_t* src = bitmap.getAddr16(0, y); |
| for (int x = srcRect.fLeft; x < srcRect.fRight; x++) { |
| dst[0] = SkGetPackedR16(src[x]); |
| dst[1] = SkGetPackedG16(src[x]); |
| dst[2] = SkGetPackedB16(src[x]); |
| dst += 3; |
| } |
| } |
| break; |
| } |
| case SkBitmap::kARGB_8888_Config: { |
| isTransparent = true; |
| const int rowBytes = srcRect.width() * 3; |
| image = new SkMemoryStream(rowBytes * srcRect.height()); |
| alpha = new SkMemoryStream(srcRect.width() * srcRect.height()); |
| uint8_t* dst = (uint8_t*)image->getMemoryBase(); |
| uint8_t* alphaDst = (uint8_t*)alpha->getMemoryBase(); |
| for (int y = srcRect.fTop; y < srcRect.fBottom; y++) { |
| uint32_t* src = bitmap.getAddr32(0, y); |
| for (int x = srcRect.fLeft; x < srcRect.fRight; x++) { |
| dst[0] = SkGetPackedR32(src[x]); |
| dst[1] = SkGetPackedG32(src[x]); |
| dst[2] = SkGetPackedB32(src[x]); |
| dst += 3; |
| alphaDst[0] = SkGetPackedA32(src[x]); |
| if (alphaDst[0] != 0xFF) { |
| hasAlpha = true; |
| } |
| if (alphaDst[0]) { |
| isTransparent = false; |
| } |
| alphaDst++; |
| } |
| } |
| break; |
| } |
| case SkBitmap::kA1_Config: { |
| isTransparent = true; |
| image = new SkMemoryStream(1); |
| ((uint8_t*)image->getMemoryBase())[0] = 0; |
| |
| const int alphaRowBytes = (srcRect.width() + 7) / 8; |
| alpha = new SkMemoryStream(alphaRowBytes * srcRect.height()); |
| uint8_t* alphaDst = (uint8_t*)alpha->getMemoryBase(); |
| int offset1 = srcRect.fLeft % 8; |
| int offset2 = 8 - offset1; |
| for (int y = srcRect.fTop; y < srcRect.fBottom; y++) { |
| uint8_t* src = bitmap.getAddr1(0, y); |
| // This may read up to one byte after src, but the potentially |
| // invalid bits are never used for computation. |
| for (int x = srcRect.fLeft; x < srcRect.fRight; x += 8) { |
| if (offset1) { |
| alphaDst[0] = src[x / 8] << offset1 | |
| src[x / 8 + 1] >> offset2; |
| } else { |
| alphaDst[0] = src[x / 8]; |
| } |
| if (x + 7 < srcRect.fRight && alphaDst[0] != 0xFF) { |
| hasAlpha = true; |
| } |
| if (x + 7 < srcRect.fRight && alphaDst[0]) { |
| isTransparent = false; |
| } |
| alphaDst++; |
| } |
| // Calculate the mask of bits we're interested in within the |
| // last byte of alphaDst. |
| // width mod 8 == 1 -> 0x80 ... width mod 8 == 7 -> 0xFE |
| uint8_t mask = ~((1 << (8 - (srcRect.width() % 8))) - 1); |
| if (srcRect.width() % 8 && (alphaDst[-1] & mask) != mask) { |
| hasAlpha = true; |
| } |
| if (srcRect.width() % 8 && (alphaDst[-1] & mask)) { |
| isTransparent = false; |
| } |
| } |
| break; |
| } |
| case SkBitmap::kA8_Config: { |
| isTransparent = true; |
| image = new SkMemoryStream(1); |
| ((uint8_t*)image->getMemoryBase())[0] = 0; |
| |
| const int alphaRowBytes = srcRect.width(); |
| alpha = new SkMemoryStream(alphaRowBytes * srcRect.height()); |
| uint8_t* alphaDst = (uint8_t*)alpha->getMemoryBase(); |
| for (int y = srcRect.fTop; y < srcRect.fBottom; y++) { |
| uint8_t* src = bitmap.getAddr8(0, y); |
| for (int x = srcRect.fLeft; x < srcRect.fRight; x++) { |
| alphaDst[0] = src[x]; |
| if (alphaDst[0] != 0xFF) { |
| hasAlpha = true; |
| } |
| if (alphaDst[0]) { |
| isTransparent = false; |
| } |
| alphaDst++; |
| } |
| } |
| break; |
| } |
| default: |
| SkASSERT(false); |
| } |
| bitmap.unlockPixels(); |
| |
| if (isTransparent) { |
| SkSafeUnref(image); |
| } else { |
| *imageData = image; |
| } |
| |
| if (isTransparent || !hasAlpha) { |
| SkSafeUnref(alpha); |
| } else { |
| *alphaData = alpha; |
| } |
| } |
| |
| SkPDFArray* makeIndexedColorSpace(SkColorTable* table) { |
| SkPDFArray* result = new SkPDFArray(); |
| result->reserve(4); |
| result->appendName("Indexed"); |
| result->appendName("DeviceRGB"); |
| result->appendInt(table->count() - 1); |
| |
| // Potentially, this could be represented in fewer bytes with a stream. |
| // Max size as a string is 1.5k. |
| SkString index; |
| for (int i = 0; i < table->count(); i++) { |
| char buf[3]; |
| SkColor color = SkUnPreMultiply::PMColorToColor((*table)[i]); |
| buf[0] = SkGetPackedR32(color); |
| buf[1] = SkGetPackedG32(color); |
| buf[2] = SkGetPackedB32(color); |
| index.append(buf, 3); |
| } |
| result->append(new SkPDFString(index))->unref(); |
| return result; |
| } |
| |
| }; // namespace |
| |
| // static |
| SkPDFImage* SkPDFImage::CreateImage(const SkBitmap& bitmap, |
| const SkIRect& srcRect, |
| const SkPaint& paint) { |
| if (bitmap.getConfig() == SkBitmap::kNo_Config) { |
| return NULL; |
| } |
| |
| SkStream* imageData = NULL; |
| SkStream* alphaData = NULL; |
| extractImageData(bitmap, srcRect, &imageData, &alphaData); |
| SkAutoUnref unrefImageData(imageData); |
| SkAutoUnref unrefAlphaData(alphaData); |
| if (!imageData) { |
| SkASSERT(!alphaData); |
| return NULL; |
| } |
| |
| SkPDFImage* image = |
| new SkPDFImage(imageData, bitmap, srcRect, false, paint); |
| |
| if (alphaData != NULL) { |
| image->addSMask(new SkPDFImage(alphaData, bitmap, srcRect, true, |
| paint))->unref(); |
| } |
| return image; |
| } |
| |
| SkPDFImage::~SkPDFImage() { |
| fResources.unrefAll(); |
| } |
| |
| SkPDFImage* SkPDFImage::addSMask(SkPDFImage* mask) { |
| fResources.push(mask); |
| mask->ref(); |
| insert("SMask", new SkPDFObjRef(mask))->unref(); |
| return mask; |
| } |
| |
| void SkPDFImage::getResources(SkTDArray<SkPDFObject*>* resourceList) { |
| GetResourcesHelper(&fResources, resourceList); |
| } |
| |
| SkPDFImage::SkPDFImage(SkStream* imageData, const SkBitmap& bitmap, |
| const SkIRect& srcRect, bool doingAlpha, |
| const SkPaint& paint) { |
| this->setData(imageData); |
| SkBitmap::Config config = bitmap.getConfig(); |
| bool alphaOnly = (config == SkBitmap::kA1_Config || |
| config == SkBitmap::kA8_Config); |
| |
| insertName("Type", "XObject"); |
| insertName("Subtype", "Image"); |
| |
| if (!doingAlpha && 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", srcRect.width()); |
| insertInt("Height", srcRect.height()); |
| } |
| |
| // if (!image mask) { |
| if (doingAlpha || alphaOnly) { |
| insertName("ColorSpace", "DeviceGray"); |
| } else if (config == SkBitmap::kIndex8_Config || |
| config == SkBitmap::kRLE_Index8_Config) { |
| insert("ColorSpace", |
| makeIndexedColorSpace(bitmap.getColorTable()))->unref(); |
| } else { |
| insertName("ColorSpace", "DeviceRGB"); |
| } |
| // } |
| |
| int bitsPerComp = 8; |
| if (config == SkBitmap::kARGB_4444_Config) { |
| bitsPerComp = 4; |
| } else if (doingAlpha && config == SkBitmap::kA1_Config) { |
| bitsPerComp = 1; |
| } |
| insertInt("BitsPerComponent", bitsPerComp); |
| |
| if (config == SkBitmap::kRGB_565_Config) { |
| SkAutoTUnref<SkPDFInt> zeroVal(new SkPDFInt(0)); |
| SkAutoTUnref<SkPDFScalar> scale5Val( |
| new SkPDFScalar(SkFloatToScalar(8.2258f))); // 255/2^5-1 |
| SkAutoTUnref<SkPDFScalar> scale6Val( |
| new SkPDFScalar(SkFloatToScalar(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()); |
| } |
| } |
