static void unit_test() {
for (unsigned a = 0; a <= 255; a++) {
for (unsigned c = 0; c <= a; c++) {
SkPMColor pm = SkPackARGB32(a, c, c, c);
for (unsigned aa = 0; aa <= 255; aa++) {
for (unsigned cc = 0; cc <= aa; cc++) {
SkPMColor pm2 = SkPackARGB32(aa, cc, cc, cc);
const size_t N = SK_ARRAY_COUNT(gProcCoeffs);
for (size_t i = 0; i < N; i++) {
gProcCoeffs[i].fProc(pm, pm2);
}
}
}
}
}
}
bool SkPNGImageDecoder::getBitmapConfig(png_structp png_ptr, png_infop info_ptr,
SkBitmap::Config *configp, bool *hasAlphap, bool *doDitherp,
SkPMColor *theTranspColorp) {
png_uint_32 origWidth, origHeight;
int bit_depth, color_type, interlace_type;
png_get_IHDR(png_ptr, info_ptr, &origWidth, &origHeight, &bit_depth,
&color_type, &interlace_type, int_p_NULL, int_p_NULL);
// check for sBIT chunk data, in case we should disable dithering because
// our data is not truely 8bits per component
if (*doDitherp) {
#if 0
SkDebugf("----- sBIT %d %d %d %d\n", info_ptr->sig_bit.red,
info_ptr->sig_bit.green, info_ptr->sig_bit.blue,
info_ptr->sig_bit.alpha);
#endif
// 0 seems to indicate no information available
if (pos_le(info_ptr->sig_bit.red, SK_R16_BITS) &&
pos_le(info_ptr->sig_bit.green, SK_G16_BITS) &&
pos_le(info_ptr->sig_bit.blue, SK_B16_BITS)) {
*doDitherp = false;
}
}
if (color_type == PNG_COLOR_TYPE_PALETTE) {
bool paletteHasAlpha = hasTransparencyInPalette(png_ptr, info_ptr);
*configp = this->getPrefConfig(kIndex_SrcDepth, paletteHasAlpha);
// now see if we can upscale to their requested config
if (!canUpscalePaletteToConfig(*configp, paletteHasAlpha)) {
*configp = SkBitmap::kIndex8_Config;
}
} else {
png_color_16p transpColor = NULL;
int numTransp = 0;
png_get_tRNS(png_ptr, info_ptr, NULL, &numTransp, &transpColor);
bool valid = png_get_valid(png_ptr, info_ptr, PNG_INFO_tRNS);
if (valid && numTransp == 1 && transpColor != NULL) {
/* Compute our transparent color, which we'll match against later.
We don't really handle 16bit components properly here, since we
do our compare *after* the values have been knocked down to 8bit
which means we will find more matches than we should. The real
fix seems to be to see the actual 16bit components, do the
compare, and then knock it down to 8bits ourselves.
*/
if (color_type & PNG_COLOR_MASK_COLOR) {
if (16 == bit_depth) {
*theTranspColorp = SkPackARGB32(0xFF, transpColor->red >> 8,
transpColor->green >> 8, transpColor->blue >> 8);
} else {
*theTranspColorp = SkPackARGB32(0xFF, transpColor->red,
transpColor->green, transpColor->blue);
}
} else { // gray
if (16 == bit_depth) {
static SkPMColor multiply_modeproc(SkPMColor src, SkPMColor dst) {
int sa = SkGetPackedA32(src);
int da = SkGetPackedA32(dst);
int a = srcover_byte(sa, da);
int r = blendfunc_multiply_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da);
int g = blendfunc_multiply_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da);
int b = blendfunc_multiply_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da);
return SkPackARGB32(a, r, g, b);
}
static SkPMColor hardlight_modeproc(SkPMColor src, SkPMColor dst) {
int sa = SkGetPackedA32(src);
int da = SkGetPackedA32(dst);
int a = srcover_byte(sa, da);
int r = hardlight_byte(SkGetPackedR32(src), SkGetPackedR32(dst), sa, da);
int g = hardlight_byte(SkGetPackedG32(src), SkGetPackedG32(dst), sa, da);
int b = hardlight_byte(SkGetPackedB32(src), SkGetPackedB32(dst), sa, da);
return SkPackARGB32(a, r, g, b);
}
static SkPMColor SkFourByteInterp(SkPMColor src, SkPMColor dst, unsigned scale)
{
unsigned a = SkAlphaBlend(SkGetPackedA32(src), SkGetPackedA32(dst), scale);
unsigned r = SkAlphaBlend(SkGetPackedR32(src), SkGetPackedR32(dst), scale);
unsigned g = SkAlphaBlend(SkGetPackedG32(src), SkGetPackedG32(dst), scale);
unsigned b = SkAlphaBlend(SkGetPackedB32(src), SkGetPackedB32(dst), scale);
return SkPackARGB32(a, r, g, b);
}
static inline SkPMColor rgb2gray(SkPMColor c) {
unsigned r = SkGetPackedR32(c);
unsigned g = SkGetPackedG32(c);
unsigned b = SkGetPackedB32(c);
unsigned x = (r * 5 + g * 7 + b * 4) >> 4;
return SkPackARGB32(0, x, x, x) | (c & (SK_A32_MASK << SK_A32_SHIFT));
}
void ImageBuffer::putUnmultipliedImageData(ByteArray* source, const IntSize& sourceSize, const IntRect& sourceRect, const IntPoint& destPoint)
{
GraphicsContext* gc = this->context();
if (!gc) {
return;
}
const SkBitmap& dst = imageBufferCanvas(this)->getDevice()->accessBitmap(true);
SkAutoLockPixels alp(dst);
if (!dst.getPixels()) {
return;
}
ASSERT(sourceRect.width() > 0);
ASSERT(sourceRect.height() > 0);
int originx = sourceRect.x();
int destx = destPoint.x() + sourceRect.x();
ASSERT(destx >= 0);
ASSERT(destx < m_size.width());
ASSERT(originx >= 0);
ASSERT(originx <= sourceRect.maxX());
int endx = destPoint.x() + sourceRect.maxX();
ASSERT(endx <= m_size.width());
int numColumns = endx - destx;
int originy = sourceRect.y();
int desty = destPoint.y() + sourceRect.y();
ASSERT(desty >= 0);
ASSERT(desty < m_size.height());
ASSERT(originy >= 0);
ASSERT(originy <= sourceRect.maxY());
int endy = destPoint.y() + sourceRect.maxY();
ASSERT(endy <= m_size.height());
int numRows = endy - desty;
unsigned srcBytesPerRow = 4 * sourceSize.width();
unsigned dstPixelsPerRow = dst.rowBytesAsPixels();
unsigned char* srcRows = source->data() + originy * srcBytesPerRow + originx * 4;
SkPMColor* dstRows = dst.getAddr32(destx, desty);
for (int y = 0; y < numRows; ++y) {
for (int x = 0; x < numColumns; x++) {
int basex = x * 4;
dstRows[x] = SkPackARGB32(srcRows[basex + 3],
srcRows[basex + 0],
srcRows[basex + 1],
srcRows[basex + 2]);
}
dstRows += dstPixelsPerRow;
srcRows += srcBytesPerRow;
}
}
void SkGifCodec::initializeColorTable(const SkImageInfo& dstInfo, SkPMColor* inputColorPtr,
int* inputColorCount) {
// Set up our own color table
const uint32_t maxColors = 256;
SkPMColor colorPtr[256];
if (NULL != inputColorCount) {
// We set the number of colors to maxColors in order to ensure
// safe memory accesses. Otherwise, an invalid pixel could
// access memory outside of our color table array.
*inputColorCount = maxColors;
}
// Get local color table
ColorMapObject* colorMap = fGif->Image.ColorMap;
// If there is no local color table, use the global color table
if (NULL == colorMap) {
colorMap = fGif->SColorMap;
}
uint32_t colorCount = 0;
if (NULL != colorMap) {
colorCount = colorMap->ColorCount;
// giflib guarantees these properties
SkASSERT(colorCount == (unsigned) (1 << (colorMap->BitsPerPixel)));
SkASSERT(colorCount <= 256);
for (uint32_t i = 0; i < colorCount; i++) {
colorPtr[i] = SkPackARGB32(0xFF, colorMap->Colors[i].Red,
colorMap->Colors[i].Green, colorMap->Colors[i].Blue);
}
}
// Gifs have the option to specify the color at a single index of the color
// table as transparent. If the transparent index is greater than the
// colorCount, we know that there is no valid transparent color in the color
// table. If there is not valid transparent index, we will try to use the
// backgroundIndex as the fill index. If the backgroundIndex is also not
// valid, we will let fFillIndex default to 0 (it is set to zero in the
// constructor). This behavior is not specified but matches
// SkImageDecoder_libgif.
uint32_t backgroundIndex = fGif->SBackGroundColor;
if (fTransIndex < colorCount) {
colorPtr[fTransIndex] = SK_ColorTRANSPARENT;
fFillIndex = fTransIndex;
} else if (backgroundIndex < colorCount) {
fFillIndex = backgroundIndex;
}
// Fill in the color table for indices greater than color count.
// This allows for predictable, safe behavior.
for (uint32_t i = colorCount; i < maxColors; i++) {
colorPtr[i] = colorPtr[fFillIndex];
}
fColorTable.reset(new SkColorTable(colorPtr, maxColors));
copy_color_table(dstInfo, this->fColorTable, inputColorPtr, inputColorCount);
}
static void copyLine(uint32_t* dst, const unsigned char* src, const ColorMapObject* cmap,
int transparent, int width)
{
for (; width > 0; width--, src++, dst++) {
if (*src != transparent) {
const GifColorType& col = cmap->Colors[*src];
*dst = SkPackARGB32(0xFF, col.Red, col.Green, col.Blue);
}
}
}
void SkGlyph::expandA8ToLCD() const {
SkASSERT(fMaskFormat == SkMask::kHorizontalLCD_Format ||
fMaskFormat == SkMask::kVerticalLCD_Format);
#if defined(SK_SUPPORT_LCDTEXT)
uint8_t* input = reinterpret_cast<uint8_t*>(fImage);
uint32_t* output = reinterpret_cast<uint32_t*>(input + SkAlign4(rowBytes() * fHeight));
if (fMaskFormat == SkMask::kHorizontalLCD_Format) {
for (unsigned y = 0; y < fHeight; ++y) {
const uint8_t* inputRow = input;
*output++ = 0; // make the extra column on the left clear
for (unsigned x = 0; x < fWidth; ++x) {
const uint8_t alpha = *inputRow++;
*output++ = SkPackARGB32(alpha, alpha, alpha, alpha);
}
*output++ = 0;
input += rowBytes();
}
} else {
const unsigned outputRowBytes = sizeof(uint32_t) * fWidth;
memset(output, 0, outputRowBytes);
output += fWidth;
for (unsigned y = 0; y < fHeight; ++y) {
const uint8_t* inputRow = input;
for (unsigned x = 0; x < fWidth; ++x) {
const uint8_t alpha = *inputRow++;
*output++ = SkPackARGB32(alpha, alpha, alpha, alpha);
}
input += rowBytes();
}
memset(output, 0, outputRowBytes);
output += fWidth;
}
#else
#endif
}
static sk_sp<SkShader> make_bg_shader() {
SkBitmap bm;
bm.allocN32Pixels(2, 2);
*bm.getAddr32(0, 0) = *bm.getAddr32(1, 1) = 0xFFFFFFFF;
*bm.getAddr32(1, 0) = *bm.getAddr32(0, 1) = SkPackARGB32(0xFF, 0xCC, 0xCC, 0xCC);
SkMatrix m;
m.setScale(SkIntToScalar(6), SkIntToScalar(6));
return SkShader::MakeBitmapShader(bm, SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode, &m);
}
SkARGB32_Blitter::SkARGB32_Blitter(const SkBitmap& device, const SkPaint& paint)
: INHERITED(device) {
uint32_t color = paint.getColor();
fSrcA = SkColorGetA(color);
unsigned scale = SkAlpha255To256(fSrcA);
fSrcR = SkAlphaMul(SkColorGetR(color), scale);
fSrcG = SkAlphaMul(SkColorGetG(color), scale);
fSrcB = SkAlphaMul(SkColorGetB(color), scale);
fPMColor = SkPackARGB32(fSrcA, fSrcR, fSrcG, fSrcB);
}
static void copy_g8_to_32(void* dst, size_t dstRB, const void* src, size_t srcRB, int w, int h) {
uint32_t* dst32 = (uint32_t*)dst;
const uint8_t* src8 = (const uint8_t*)src;
for (int y = 0; y < h; ++y) {
for (int x = 0; x < w; ++x) {
dst32[x] = SkPackARGB32(0xFF, src8[x], src8[x], src8[x]);
}
dst32 = (uint32_t*)((char*)dst32 + dstRB);
src8 += srcRB;
}
}
static sk_sp<SkImage> make_image(GrContext* context, int size, GrSurfaceOrigin origin) {
if (context) {
SkImageInfo ii = SkImageInfo::Make(size, size, kN32_SkColorType, kPremul_SkAlphaType);
sk_sp<SkSurface> surf(SkSurface::MakeRenderTarget(context, SkBudgeted::kYes, ii, 0,
origin, nullptr));
if (!surf) {
return nullptr;
}
SkCanvas* canvas = surf->getCanvas();
canvas->clear(SK_ColorRED);
const struct {
SkPoint fPt;
SkColor fColor;
} rec[] = {
{ { 1.5f, 1.5f }, SK_ColorGREEN },
{ { 2.5f, 1.5f }, SK_ColorBLUE },
{ { 1.5f, 2.5f }, SK_ColorCYAN },
{ { 2.5f, 2.5f }, SK_ColorGRAY },
};
SkPaint paint;
for (const auto& r : rec) {
paint.setColor(r.fColor);
canvas->drawPoints(SkCanvas::kPoints_PointMode, 1, &r.fPt, paint);
}
return surf->makeImageSnapshot();
} else {
SkBitmap bm;
bm.allocN32Pixels(size, size);
bm.eraseColor(SK_ColorRED);
*bm.getAddr32(1, 1) = SkPackARGB32(0xFF, 0x00, 0xFF, 0x00);
*bm.getAddr32(2, 1) = SkPackARGB32(0xFF, 0x00, 0x00, 0xFF);
*bm.getAddr32(1, 2) = SkPackARGB32(0xFF, 0x00, 0xFF, 0xFF);
*bm.getAddr32(2, 2) = SkPackARGB32(0xFF, 0x88, 0x88, 0x88);
return SkImage::MakeFromBitmap(bm);
}
}
static void apply_gamma(const SkBitmap& bm) {
return; // below is our experiment for sRGB correction
bm.lockPixels();
for (int y = 0; y < bm.height(); ++y) {
for (int x = 0; x < bm.width(); ++x) {
SkPMColor c = *bm.getAddr32(x, y);
unsigned r = gamma(SkGetPackedR32(c));
unsigned g = gamma(SkGetPackedG32(c));
unsigned b = gamma(SkGetPackedB32(c));
*bm.getAddr32(x, y) = SkPackARGB32(0xFF, r, g, b);
}
}
}
// kDstATop_Mode, //!< [Sa, Sa * Dc + Sc * (1 - Da)]
static SkPMColor dstatop_modeproc(SkPMColor src, SkPMColor dst) {
unsigned sa = SkGetPackedA32(src);
unsigned da = SkGetPackedA32(dst);
unsigned ida = 255 - da;
return SkPackARGB32(sa,
SkAlphaMulAlpha(ida, SkGetPackedR32(src)) +
SkAlphaMulAlpha(sa, SkGetPackedR32(dst)),
SkAlphaMulAlpha(ida, SkGetPackedG32(src)) +
SkAlphaMulAlpha(sa, SkGetPackedG32(dst)),
SkAlphaMulAlpha(ida, SkGetPackedB32(src)) +
SkAlphaMulAlpha(sa, SkGetPackedB32(dst)));
}
void putImageData(ImageData*& source, const IntRect& sourceRect, const IntPoint& destPoint,
const SkBitmap& bitmap, const IntSize& size)
{
ASSERT(sourceRect.width() > 0);
ASSERT(sourceRect.height() > 0);
int originX = sourceRect.x();
int destX = destPoint.x() + sourceRect.x();
ASSERT(destX >= 0);
ASSERT(destX < size.width());
ASSERT(originX >= 0);
ASSERT(originX < sourceRect.right());
int endX = destPoint.x() + sourceRect.right();
ASSERT(endX <= size.width());
int numColumns = endX - destX;
int originY = sourceRect.y();
int destY = destPoint.y() + sourceRect.y();
ASSERT(destY >= 0);
ASSERT(destY < size.height());
ASSERT(originY >= 0);
ASSERT(originY < sourceRect.bottom());
int endY = destPoint.y() + sourceRect.bottom();
ASSERT(endY <= size.height());
int numRows = endY - destY;
ASSERT(bitmap.config() == SkBitmap::kARGB_8888_Config);
SkAutoLockPixels bitmapLock(bitmap);
unsigned srcBytesPerRow = 4 * source->width();
const unsigned char* srcRow = source->data()->data()->data() + originY * srcBytesPerRow + originX * 4;
for (int y = 0; y < numRows; ++y) {
uint32_t* destRow = bitmap.getAddr32(destX, destY + y);
for (int x = 0; x < numColumns; ++x) {
const unsigned char* srcPixel = &srcRow[x * 4];
if (multiplied == Unmultiplied)
destRow[x] = SkPreMultiplyARGB(srcPixel[3], srcPixel[0],
srcPixel[1], srcPixel[2]);
else
destRow[x] = SkPackARGB32(srcPixel[3], srcPixel[0],
srcPixel[1], srcPixel[2]);
}
srcRow += srcBytesPerRow;
}
}
inline SkPMColor cubicBlend(const SkScalar c[16], SkScalar t, SkPMColor c0, SkPMColor c1, SkPMColor c2, SkPMColor c3) {
SkScalar t2 = t * t, t3 = t2 * t;
SkScalar cc[4];
// FIXME: For the fractx case, this should be refactored out of this function.
cc[0] = c[0] + SkScalarMul(c[1], t) + SkScalarMul(c[2], t2) + SkScalarMul(c[3], t3);
cc[1] = c[4] + SkScalarMul(c[5], t) + SkScalarMul(c[6], t2) + SkScalarMul(c[7], t3);
cc[2] = c[8] + SkScalarMul(c[9], t) + SkScalarMul(c[10], t2) + SkScalarMul(c[11], t3);
cc[3] = c[12] + SkScalarMul(c[13], t) + SkScalarMul(c[14], t2) + SkScalarMul(c[15], t3);
SkScalar a = SkScalarMul(cc[0], SkGetPackedA32(c0)) + SkScalarMul(cc[1], SkGetPackedA32(c1)) + SkScalarMul(cc[2], SkGetPackedA32(c2)) + SkScalarMul(cc[3], SkGetPackedA32(c3));
SkScalar r = SkScalarMul(cc[0], SkGetPackedR32(c0)) + SkScalarMul(cc[1], SkGetPackedR32(c1)) + SkScalarMul(cc[2], SkGetPackedR32(c2)) + SkScalarMul(cc[3], SkGetPackedR32(c3));
SkScalar g = SkScalarMul(cc[0], SkGetPackedG32(c0)) + SkScalarMul(cc[1], SkGetPackedG32(c1)) + SkScalarMul(cc[2], SkGetPackedG32(c2)) + SkScalarMul(cc[3], SkGetPackedG32(c3));
SkScalar b = SkScalarMul(cc[0], SkGetPackedB32(c0)) + SkScalarMul(cc[1], SkGetPackedB32(c1)) + SkScalarMul(cc[2], SkGetPackedB32(c2)) + SkScalarMul(cc[3], SkGetPackedB32(c3));
return SkPackARGB32(SkScalarRoundToInt(SkScalarClampMax(a, 255)), SkScalarRoundToInt(SkScalarClampMax(r, 255)), SkScalarRoundToInt(SkScalarClampMax(g, 255)), SkScalarRoundToInt(SkScalarClampMax(b, 255)));
}
SkPMColor SkPreMultiplyARGB(U8CPU a, U8CPU r, U8CPU g, U8CPU b) {
if (a != 255) {
#if 0
unsigned scale = SkAlpha255To256(a);
r = SkAlphaMul(r, scale);
g = SkAlphaMul(g, scale);
b = SkAlphaMul(b, scale);
#else
r = SkMulDiv255Round(r, a);
g = SkMulDiv255Round(g, a);
b = SkMulDiv255Round(b, a);
#endif
}
return SkPackARGB32(a, r, g, b);
}
SkARGB32_Blitter::SkARGB32_Blitter(const SkBitmap& device, const SkPaint& paint)
: INHERITED(device) {
SkColor color = paint.getColor();
fColor = color;
fSrcA = SkColorGetA(color);
unsigned scale = SkAlpha255To256(fSrcA);
fSrcR = SkAlphaMul(SkColorGetR(color), scale);
fSrcG = SkAlphaMul(SkColorGetG(color), scale);
fSrcB = SkAlphaMul(SkColorGetB(color), scale);
fPMColor = SkPackARGB32(fSrcA, fSrcR, fSrcG, fSrcB);
fColor32Proc = SkBlitRow::ColorProcFactory();
fColorRect32Proc = SkBlitRow::ColorRectProcFactory();
}
static SkBitmap make_bitmap() {
const SkPMColor c[] = { SkPackARGB32(0x80, 0x80, 0, 0) };
SkColorTable* ctable = new SkColorTable(c, SK_ARRAY_COUNT(c));
SkBitmap bm;
bm.allocPixels(SkImageInfo::Make(1, 1, kIndex_8_SkColorType,
kPremul_SkAlphaType),
NULL, ctable);
ctable->unref();
bm.lockPixels();
*bm.getAddr8(0, 0) = 0;
bm.unlockPixels();
return bm;
}
static SkShader* make_bg_shader() {
SkBitmap bm;
bm.allocN32Pixels(2, 2);
*bm.getAddr32(0, 0) = *bm.getAddr32(1, 1) = 0xFFFFFFFF;
*bm.getAddr32(1, 0) = *bm.getAddr32(0, 1) = SkPackARGB32(0xFF, 0xCC,
0xCC, 0xCC);
SkShader* s = SkShader::CreateBitmapShader(bm,
SkShader::kRepeat_TileMode,
SkShader::kRepeat_TileMode);
SkMatrix m;
m.setScale(SkIntToScalar(6), SkIntToScalar(6));
s->setLocalMatrix(m);
return s;
}
static SkBitmap make_argb8888_gradient() {
SkBitmap bitmap;
init_bitmap(kPMColor_SkColorType, &bitmap);
uint8_t rowColor = 0;
for (int y = 0; y < SLIDE_SIZE; y++) {
uint32_t* dst = bitmap.getAddr32(0, y);
for (int x = 0; x < SLIDE_SIZE; x++) {
dst[x] = SkPackARGB32(rowColor, rowColor,
rowColor, rowColor);
}
if (y % PIXEL_SIZE_8888 == PIXEL_SIZE_8888 - 1) {
rowColor++;
}
}
return bitmap;
}
SkARGB32_Blitter::SkARGB32_Blitter(const SkBitmap& device, const SkPaint& paint)
: INHERITED(device) {
SkColor color = paint.getColor();
fColor = color;
fSrcA = SkColorGetA(color);
unsigned scale = SkAlpha255To256(fSrcA);
fSrcR = SkAlphaMul(SkColorGetR(color), scale);
fSrcG = SkAlphaMul(SkColorGetG(color), scale);
fSrcB = SkAlphaMul(SkColorGetB(color), scale);
fPMColor = SkPackARGB32(fSrcA, fSrcR, fSrcG, fSrcB);
fColor32Proc = SkBlitRow::ColorProcFactory();
// init the pro for blitmask
fBlitMaskProc = SkBlitMask::Factory(SkBitmap::kARGB_8888_Config, color);
}
static SkBitmap make_bitmap() {
SkBitmap bm;
SkColorTable* ctable = new SkColorTable(1);
SkPMColor* c = ctable->lockColors();
c[0] = SkPackARGB32(0x80, 0x80, 0, 0);
ctable->unlockColors(true);
bm.setConfig(SkBitmap::kIndex8_Config, 1, 1);
bm.allocPixels(ctable);
ctable->unref();
bm.lockPixels();
*bm.getAddr8(0, 0) = 0;
bm.unlockPixels();
return bm;
}
static SkPMColor lighten_modeproc(SkPMColor src, SkPMColor dst) {
unsigned sa = SkGetPackedA32(src);
unsigned da = SkGetPackedA32(dst);
unsigned src_scale = SkAlpha255To256(255 - sa);
unsigned dst_scale = SkAlpha255To256(255 - da);
unsigned ra = sa + da - SkAlphaMulAlpha(sa, da);
unsigned rr = lighten_p(SkGetPackedR32(src), SkGetPackedR32(dst),
src_scale, dst_scale);
unsigned rg = lighten_p(SkGetPackedG32(src), SkGetPackedG32(dst),
src_scale, dst_scale);
unsigned rb = lighten_p(SkGetPackedB32(src), SkGetPackedB32(dst),
src_scale, dst_scale);
return SkPackARGB32(ra, SkFastMin32(rr, ra),
SkFastMin32(rg, ra), SkFastMin32(rb, ra));
}
bool SkFPDFEMBImageDecoder::render(FPDFEMB_PAGE page, const FPDFEMB_RECT& bounds, SkBitmap* bm,
SkBitmap::Config prefConfig, SkImageDecoder::Mode mode) {
int width = PDF2Pixels(bounds.right - bounds.left);
int height = PDF2Pixels(bounds.top - bounds.bottom);
SkDebugf("----- bitmap size [%d %d], mode=%d\n", width, height, mode);
bm->setConfig(SkBitmap::kARGB_8888_Config, width, height);
if (SkImageDecoder::kDecodeBounds_Mode == mode) {
return true;
}
// USE THE CODEC TO ALLOCATE THE PIXELS!!!!
if (!this->allocPixelRef(bm, NULL)) {
SkDebugf("----- failed to alloc pixels\n");
return false;
}
bm->eraseColor(0);
FPDFEMB_RESULT result;
FPDFEMB_BITMAP dib;
result = FPDFEMB_CreateDIB(width, height, FPDFDIB_BGRA, bm->getPixels(),
bm->rowBytes(), &dib);
SkDebugf("---- createdib %d\n", result);
result = FPDFEMB_StartRender(dib, page, 0, 0, width, height, 0, 0, NULL, NULL);
SkDebugf("---- render %d\n", result);
result = FPDFEMB_DestroyDIB(dib);
SkDebugf("---- destroydib %d\n", result);
SkPMColor* dst = bm->getAddr32(0, 0);
const uint8_t* src = (uint8_t*)dst;
int n = bm->getSize() >> 2;
for (int i = 0; i < n; i++) {
int b = *src++;
int g = *src++;
int r = *src++;
int a = *src++;
*dst++ = SkPackARGB32(a, r, g, b);
}
return true;
}
static const sk_sp<SkImage> make_image(int firstBlackRow, int lastBlackRow) {
static const int kWidth = 25;
static const int kHeight = 27;
SkBitmap bm;
bm.allocN32Pixels(kWidth, kHeight);
bm.eraseColor(SK_ColorWHITE);
for (int y = firstBlackRow; y < lastBlackRow; ++y) {
for (int x = 0; x < kWidth; ++x) {
*bm.getAddr32(x, y) = SkPackARGB32(0xFF, 0x0, 0x0, 0x0);
}
}
bm.setAlphaType(SkAlphaType::kOpaque_SkAlphaType);
bm.setImmutable();
return SkImage::MakeFromBitmap(bm);
}
static SkBitmap make_argb8888_stripes() {
SkBitmap bitmap;
init_bitmap(kPMColor_SkColorType, &bitmap);
uint8_t rowColor = 0;
for (int y = 0; y < SLIDE_SIZE; y++) {
uint32_t* dst = bitmap.getAddr32(0, y);
for (int x = 0; x < SLIDE_SIZE; x++) {
dst[x] = SkPackARGB32(rowColor, rowColor,
rowColor, rowColor);
}
if (rowColor == 0) {
rowColor = 255;
} else {
rowColor = 0;
}
}
return bitmap;
}
virtual void filterSpan(const SkPMColor shader[], int count,
SkPMColor result[]) {
unsigned scaleR = SkAlpha255To256(SkColorGetR(fMul));
unsigned scaleG = SkAlpha255To256(SkColorGetG(fMul));
unsigned scaleB = SkAlpha255To256(SkColorGetB(fMul));
for (int i = 0; i < count; i++) {
SkPMColor c = shader[i];
if (c) {
unsigned a = SkGetPackedA32(c);
unsigned r = SkAlphaMul(SkGetPackedR32(c), scaleR);
unsigned g = SkAlphaMul(SkGetPackedG32(c), scaleG);
unsigned b = SkAlphaMul(SkGetPackedB32(c), scaleB);
c = SkPackARGB32(a, r, g, b);
}
result[i] = c;
}
}
