diff options
Diffstat (limited to 'gfx/skia/patches/archive/0015-Bug-766017-warnings.patch')
| -rw-r--r-- | gfx/skia/patches/archive/0015-Bug-766017-warnings.patch | 865 |
1 files changed, 865 insertions, 0 deletions
diff --git a/gfx/skia/patches/archive/0015-Bug-766017-warnings.patch b/gfx/skia/patches/archive/0015-Bug-766017-warnings.patch new file mode 100644 index 0000000000..174dcb9bce --- /dev/null +++ b/gfx/skia/patches/archive/0015-Bug-766017-warnings.patch @@ -0,0 +1,865 @@ +From: David Zbarsky <dzbarsky@gmail.com> +Bug 766017 - Fix some skia warnings r=gw280 + +diff --git a/gfx/skia/include/utils/mac/SkCGUtils.h b/gfx/skia/include/utils/mac/SkCGUtils.h +--- a/gfx/skia/include/utils/mac/SkCGUtils.h ++++ b/gfx/skia/include/utils/mac/SkCGUtils.h +@@ -39,18 +39,16 @@ static inline CGImageRef SkCreateCGImage + /** + * Draw the bitmap into the specified CG context. The bitmap will be converted + * to a CGImage using the generic RGB colorspace. (x,y) specifies the position + * of the top-left corner of the bitmap. The bitmap is converted using the + * colorspace returned by CGColorSpaceCreateDeviceRGB() + */ + void SkCGDrawBitmap(CGContextRef, const SkBitmap&, float x, float y); + +-bool SkPDFDocumentToBitmap(SkStream* stream, SkBitmap* output); +- + /** + * Return a provider that wraps the specified stream. It will become an + * owner of the stream, so the caller must still manage its ownership. + * + * To hand-off ownership of the stream to the provider, the caller must do + * something like the following: + * + * SkStream* stream = new ...; +diff --git a/gfx/skia/src/core/SkAAClip.cpp b/gfx/skia/src/core/SkAAClip.cpp +--- a/gfx/skia/src/core/SkAAClip.cpp ++++ b/gfx/skia/src/core/SkAAClip.cpp +@@ -246,17 +246,17 @@ static void count_left_right_zeros(const + zeros = 0; + } + row += 2; + width -= n; + } + *riteZ = zeros; + } + +-#ifdef SK_DEBUG ++#if 0 + static void test_count_left_right_zeros() { + static bool gOnce; + if (gOnce) { + return; + } + gOnce = true; + + const uint8_t data0[] = { 0, 0, 10, 0xFF }; +@@ -1319,22 +1319,16 @@ bool SkAAClip::setPath(const SkPath& pat + } + + /////////////////////////////////////////////////////////////////////////////// + + typedef void (*RowProc)(SkAAClip::Builder&, int bottom, + const uint8_t* rowA, const SkIRect& rectA, + const uint8_t* rowB, const SkIRect& rectB); + +-static void sectRowProc(SkAAClip::Builder& builder, int bottom, +- const uint8_t* rowA, const SkIRect& rectA, +- const uint8_t* rowB, const SkIRect& rectB) { +- +-} +- + typedef U8CPU (*AlphaProc)(U8CPU alphaA, U8CPU alphaB); + + static U8CPU sectAlphaProc(U8CPU alphaA, U8CPU alphaB) { + // Multiply + return SkMulDiv255Round(alphaA, alphaB); + } + + static U8CPU unionAlphaProc(U8CPU alphaA, U8CPU alphaB) { +@@ -1429,31 +1423,16 @@ private: + static void adjust_row(RowIter& iter, int& leftA, int& riteA, int rite) { + if (rite == riteA) { + iter.next(); + leftA = iter.left(); + riteA = iter.right(); + } + } + +-static bool intersect(int& min, int& max, int boundsMin, int boundsMax) { +- SkASSERT(min < max); +- SkASSERT(boundsMin < boundsMax); +- if (min >= boundsMax || max <= boundsMin) { +- return false; +- } +- if (min < boundsMin) { +- min = boundsMin; +- } +- if (max > boundsMax) { +- max = boundsMax; +- } +- return true; +-} +- + static void operatorX(SkAAClip::Builder& builder, int lastY, + RowIter& iterA, RowIter& iterB, + AlphaProc proc, const SkIRect& bounds) { + int leftA = iterA.left(); + int riteA = iterA.right(); + int leftB = iterB.left(); + int riteB = iterB.right(); + +@@ -1970,34 +1949,33 @@ static void small_bzero(void* dst, size_ + static inline uint8_t mergeOne(uint8_t value, unsigned alpha) { + return SkMulDiv255Round(value, alpha); + } + static inline uint16_t mergeOne(uint16_t value, unsigned alpha) { + unsigned r = SkGetPackedR16(value); + unsigned g = SkGetPackedG16(value); + unsigned b = SkGetPackedB16(value); + return SkPackRGB16(SkMulDiv255Round(r, alpha), +- SkMulDiv255Round(r, alpha), +- SkMulDiv255Round(r, alpha)); ++ SkMulDiv255Round(g, alpha), ++ SkMulDiv255Round(b, alpha)); + } + static inline SkPMColor mergeOne(SkPMColor value, unsigned alpha) { + unsigned a = SkGetPackedA32(value); + unsigned r = SkGetPackedR32(value); + unsigned g = SkGetPackedG32(value); + unsigned b = SkGetPackedB32(value); + return SkPackARGB32(SkMulDiv255Round(a, alpha), + SkMulDiv255Round(r, alpha), + SkMulDiv255Round(g, alpha), + SkMulDiv255Round(b, alpha)); + } + + template <typename T> void mergeT(const T* SK_RESTRICT src, int srcN, + const uint8_t* SK_RESTRICT row, int rowN, + T* SK_RESTRICT dst) { +- SkDEBUGCODE(int accumulated = 0;) + for (;;) { + SkASSERT(rowN > 0); + SkASSERT(srcN > 0); + + int n = SkMin32(rowN, srcN); + unsigned rowA = row[1]; + if (0xFF == rowA) { + small_memcpy(dst, src, n * sizeof(T)); +diff --git a/gfx/skia/src/core/SkBlitMask_D32.cpp b/gfx/skia/src/core/SkBlitMask_D32.cpp +--- a/gfx/skia/src/core/SkBlitMask_D32.cpp ++++ b/gfx/skia/src/core/SkBlitMask_D32.cpp +@@ -268,107 +268,49 @@ bool SkBlitMask::BlitColor(const SkBitma + return true; + } + return false; + } + + /////////////////////////////////////////////////////////////////////////////// + /////////////////////////////////////////////////////////////////////////////// + +-static void BW_RowProc_Blend(SkPMColor* SK_RESTRICT dst, +- const uint8_t* SK_RESTRICT mask, +- const SkPMColor* SK_RESTRICT src, int count) { +- int i, octuple = (count + 7) >> 3; +- for (i = 0; i < octuple; ++i) { +- int m = *mask++; +- if (m & 0x80) { dst[0] = SkPMSrcOver(src[0], dst[0]); } +- if (m & 0x40) { dst[1] = SkPMSrcOver(src[1], dst[1]); } +- if (m & 0x20) { dst[2] = SkPMSrcOver(src[2], dst[2]); } +- if (m & 0x10) { dst[3] = SkPMSrcOver(src[3], dst[3]); } +- if (m & 0x08) { dst[4] = SkPMSrcOver(src[4], dst[4]); } +- if (m & 0x04) { dst[5] = SkPMSrcOver(src[5], dst[5]); } +- if (m & 0x02) { dst[6] = SkPMSrcOver(src[6], dst[6]); } +- if (m & 0x01) { dst[7] = SkPMSrcOver(src[7], dst[7]); } +- src += 8; +- dst += 8; +- } +- count &= 7; +- if (count > 0) { +- int m = *mask; +- do { +- if (m & 0x80) { dst[0] = SkPMSrcOver(src[0], dst[0]); } +- m <<= 1; +- src += 1; +- dst += 1; +- } while (--count > 0); +- } +-} +- +-static void BW_RowProc_Opaque(SkPMColor* SK_RESTRICT dst, +- const uint8_t* SK_RESTRICT mask, +- const SkPMColor* SK_RESTRICT src, int count) { +- int i, octuple = (count + 7) >> 3; +- for (i = 0; i < octuple; ++i) { +- int m = *mask++; +- if (m & 0x80) { dst[0] = src[0]; } +- if (m & 0x40) { dst[1] = src[1]; } +- if (m & 0x20) { dst[2] = src[2]; } +- if (m & 0x10) { dst[3] = src[3]; } +- if (m & 0x08) { dst[4] = src[4]; } +- if (m & 0x04) { dst[5] = src[5]; } +- if (m & 0x02) { dst[6] = src[6]; } +- if (m & 0x01) { dst[7] = src[7]; } +- src += 8; +- dst += 8; +- } +- count &= 7; +- if (count > 0) { +- int m = *mask; +- do { +- if (m & 0x80) { dst[0] = SkPMSrcOver(src[0], dst[0]); } +- m <<= 1; +- src += 1; +- dst += 1; +- } while (--count > 0); +- } +-} +- + static void A8_RowProc_Blend(SkPMColor* SK_RESTRICT dst, + const uint8_t* SK_RESTRICT mask, + const SkPMColor* SK_RESTRICT src, int count) { + for (int i = 0; i < count; ++i) { + if (mask[i]) { + dst[i] = SkBlendARGB32(src[i], dst[i], mask[i]); + } + } + } + + // expand the steps that SkAlphaMulQ performs, but this way we can +-// exand.. add.. combine ++// expand.. add.. combine + // instead of + // expand..combine add expand..combine + // + #define EXPAND0(v, m, s) ((v) & (m)) * (s) + #define EXPAND1(v, m, s) (((v) >> 8) & (m)) * (s) + #define COMBINE(e0, e1, m) ((((e0) >> 8) & (m)) | ((e1) & ~(m))) + + static void A8_RowProc_Opaque(SkPMColor* SK_RESTRICT dst, + const uint8_t* SK_RESTRICT mask, + const SkPMColor* SK_RESTRICT src, int count) { +- const uint32_t rbmask = gMask_00FF00FF; + for (int i = 0; i < count; ++i) { + int m = mask[i]; + if (m) { + m += (m >> 7); + #if 1 + // this is slightly slower than the expand/combine version, but it + // is much closer to the old results, so we use it for now to reduce + // rebaselining. + dst[i] = SkAlphaMulQ(src[i], m) + SkAlphaMulQ(dst[i], 256 - m); + #else ++ const uint32_t rbmask = gMask_00FF00FF; + uint32_t v = src[i]; + uint32_t s0 = EXPAND0(v, rbmask, m); + uint32_t s1 = EXPAND1(v, rbmask, m); + v = dst[i]; + uint32_t d0 = EXPAND0(v, rbmask, m); + uint32_t d1 = EXPAND1(v, rbmask, m); + dst[i] = COMBINE(s0 + d0, s1 + d1, rbmask); + #endif +@@ -559,17 +501,17 @@ SkBlitMask::RowProc SkBlitMask::RowFacto + // make this opt-in until chrome can rebaseline + RowProc proc = PlatformRowProcs(config, format, flags); + if (proc) { + return proc; + } + + static const RowProc gProcs[] = { + // need X coordinate to handle BW +- NULL, NULL, //(RowProc)BW_RowProc_Blend, (RowProc)BW_RowProc_Opaque, ++ NULL, NULL, + (RowProc)A8_RowProc_Blend, (RowProc)A8_RowProc_Opaque, + (RowProc)LCD16_RowProc_Blend, (RowProc)LCD16_RowProc_Opaque, + (RowProc)LCD32_RowProc_Blend, (RowProc)LCD32_RowProc_Opaque, + }; + + int index; + switch (config) { + case SkBitmap::kARGB_8888_Config: +diff --git a/gfx/skia/src/core/SkConcaveToTriangles.cpp b/gfx/skia/src/core/SkConcaveToTriangles.cpp +--- a/gfx/skia/src/core/SkConcaveToTriangles.cpp ++++ b/gfx/skia/src/core/SkConcaveToTriangles.cpp +@@ -37,17 +37,16 @@ + #include "SkTDArray.h" + #include "SkGeometry.h" + #include "SkTSort.h" + + // This is used to prevent runaway code bugs, and can probably be removed after + // the code has been proven robust. + #define kMaxCount 1000 + +-#define DEBUG + #ifdef DEBUG + //------------------------------------------------------------------------------ + // Debugging support + //------------------------------------------------------------------------------ + + #include <cstdio> + #include <stdarg.h> + +diff --git a/gfx/skia/src/core/SkPath.cpp b/gfx/skia/src/core/SkPath.cpp +--- a/gfx/skia/src/core/SkPath.cpp ++++ b/gfx/skia/src/core/SkPath.cpp +@@ -469,17 +469,16 @@ void SkPath::incReserve(U16CPU inc) { + fPts.setReserve(fPts.count() + inc); + + SkDEBUGCODE(this->validate();) + } + + void SkPath::moveTo(SkScalar x, SkScalar y) { + SkDEBUGCODE(this->validate();) + +- int vc = fVerbs.count(); + SkPoint* pt; + + // remember our index + fLastMoveToIndex = fPts.count(); + + pt = fPts.append(); + *fVerbs.append() = kMove_Verb; + pt->set(x, y); +@@ -1163,17 +1162,16 @@ void SkPath::reversePathTo(const SkPath& + } + pts -= gPtsInVerb[verbs[i]]; + } + } + + void SkPath::reverseAddPath(const SkPath& src) { + this->incReserve(src.fPts.count()); + +- const SkPoint* startPts = src.fPts.begin(); + const SkPoint* pts = src.fPts.end(); + const uint8_t* startVerbs = src.fVerbs.begin(); + const uint8_t* verbs = src.fVerbs.end(); + + fIsOval = false; + + bool needMove = true; + bool needClose = false; +diff --git a/gfx/skia/src/core/SkRegion.cpp b/gfx/skia/src/core/SkRegion.cpp +--- a/gfx/skia/src/core/SkRegion.cpp ++++ b/gfx/skia/src/core/SkRegion.cpp +@@ -920,20 +920,16 @@ static int operate(const SkRegion::RunTy + /* Given count RunTypes in a complex region, return the worst case number of + logical intervals that represents (i.e. number of rects that would be + returned from the iterator). + + We could just return count/2, since there must be at least 2 values per + interval, but we can first trim off the const overhead of the initial TOP + value, plus the final BOTTOM + 2 sentinels. + */ +-static int count_to_intervals(int count) { +- SkASSERT(count >= 6); // a single rect is 6 values +- return (count - 4) >> 1; +-} + + /* Given a number of intervals, what is the worst case representation of that + many intervals? + + Worst case (from a storage perspective), is a vertical stack of single + intervals: TOP + N * (BOTTOM INTERVALCOUNT LEFT RIGHT SENTINEL) + SENTINEL + */ + static int intervals_to_count(int intervals) { +diff --git a/gfx/skia/src/core/SkScalerContext.cpp b/gfx/skia/src/core/SkScalerContext.cpp +--- a/gfx/skia/src/core/SkScalerContext.cpp ++++ b/gfx/skia/src/core/SkScalerContext.cpp +@@ -336,44 +336,16 @@ SK_ERROR: + glyph->fTop = 0; + glyph->fWidth = 0; + glyph->fHeight = 0; + // put a valid value here, in case it was earlier set to + // MASK_FORMAT_JUST_ADVANCE + glyph->fMaskFormat = fRec.fMaskFormat; + } + +-static bool isLCD(const SkScalerContext::Rec& rec) { +- return SkMask::kLCD16_Format == rec.fMaskFormat || +- SkMask::kLCD32_Format == rec.fMaskFormat; +-} +- +-static uint16_t a8_to_rgb565(unsigned a8) { +- return SkPackRGB16(a8 >> 3, a8 >> 2, a8 >> 3); +-} +- +-static void copyToLCD16(const SkBitmap& src, const SkMask& dst) { +- SkASSERT(SkBitmap::kA8_Config == src.config()); +- SkASSERT(SkMask::kLCD16_Format == dst.fFormat); +- +- const int width = dst.fBounds.width(); +- const int height = dst.fBounds.height(); +- const uint8_t* srcP = src.getAddr8(0, 0); +- size_t srcRB = src.rowBytes(); +- uint16_t* dstP = (uint16_t*)dst.fImage; +- size_t dstRB = dst.fRowBytes; +- for (int y = 0; y < height; ++y) { +- for (int x = 0; x < width; ++x) { +- dstP[x] = a8_to_rgb565(srcP[x]); +- } +- srcP += srcRB; +- dstP = (uint16_t*)((char*)dstP + dstRB); +- } +-} +- + #define SK_FREETYPE_LCD_LERP 160 + + static int lerp(int start, int end) { + SkASSERT((unsigned)SK_FREETYPE_LCD_LERP <= 256); + return start + ((end - start) * (SK_FREETYPE_LCD_LERP) >> 8); + } + + static uint16_t packLCD16(unsigned r, unsigned g, unsigned b) { +diff --git a/gfx/skia/src/core/SkScan_AntiPath.cpp b/gfx/skia/src/core/SkScan_AntiPath.cpp +--- a/gfx/skia/src/core/SkScan_AntiPath.cpp ++++ b/gfx/skia/src/core/SkScan_AntiPath.cpp +@@ -230,52 +230,16 @@ void SuperBlitter::blitH(int x, int y, i + fOffsetX); + + #ifdef SK_DEBUG + fRuns.assertValid(y & MASK, (1 << (8 - SHIFT))); + fCurrX = x + width; + #endif + } + +-static void set_left_rite_runs(SkAlphaRuns& runs, int ileft, U8CPU leftA, +- int n, U8CPU riteA) { +- SkASSERT(leftA <= 0xFF); +- SkASSERT(riteA <= 0xFF); +- +- int16_t* run = runs.fRuns; +- uint8_t* aa = runs.fAlpha; +- +- if (ileft > 0) { +- run[0] = ileft; +- aa[0] = 0; +- run += ileft; +- aa += ileft; +- } +- +- SkASSERT(leftA < 0xFF); +- if (leftA > 0) { +- *run++ = 1; +- *aa++ = leftA; +- } +- +- if (n > 0) { +- run[0] = n; +- aa[0] = 0xFF; +- run += n; +- aa += n; +- } +- +- SkASSERT(riteA < 0xFF); +- if (riteA > 0) { +- *run++ = 1; +- *aa++ = riteA; +- } +- run[0] = 0; +-} +- + void SuperBlitter::blitRect(int x, int y, int width, int height) { + SkASSERT(width > 0); + SkASSERT(height > 0); + + // blit leading rows + while ((y & MASK)) { + this->blitH(x, y++, width); + if (--height <= 0) { +diff --git a/gfx/skia/src/effects/SkGradientShader.cpp b/gfx/skia/src/effects/SkGradientShader.cpp +--- a/gfx/skia/src/effects/SkGradientShader.cpp ++++ b/gfx/skia/src/effects/SkGradientShader.cpp +@@ -865,45 +865,16 @@ bool Linear_Gradient::setContext(const S + } while (0) + + namespace { + + typedef void (*LinearShadeProc)(TileProc proc, SkFixed dx, SkFixed fx, + SkPMColor* dstC, const SkPMColor* cache, + int toggle, int count); + +-// This function is deprecated, and will be replaced by +-// shadeSpan_linear_vertical_lerp() once Chrome has been weaned off of it. +-void shadeSpan_linear_vertical(TileProc proc, SkFixed dx, SkFixed fx, +- SkPMColor* SK_RESTRICT dstC, +- const SkPMColor* SK_RESTRICT cache, +- int toggle, int count) { +- if (proc == clamp_tileproc) { +- // Read out clamp values from beginning/end of the cache. No need to lerp +- // or dither +- if (fx < 0) { +- sk_memset32(dstC, cache[-1], count); +- return; +- } else if (fx > 0xFFFF) { +- sk_memset32(dstC, cache[Gradient_Shader::kCache32Count * 2], count); +- return; +- } +- } +- +- // We're a vertical gradient, so no change in a span. +- // If colors change sharply across the gradient, dithering is +- // insufficient (it subsamples the color space) and we need to lerp. +- unsigned fullIndex = proc(fx); +- unsigned fi = fullIndex >> (16 - Gradient_Shader::kCache32Bits); +- sk_memset32_dither(dstC, +- cache[toggle + fi], +- cache[(toggle ^ Gradient_Shader::kDitherStride32) + fi], +- count); +-} +- + // Linear interpolation (lerp) is unnecessary if there are no sharp + // discontinuities in the gradient - which must be true if there are + // only 2 colors - but it's cheap. + void shadeSpan_linear_vertical_lerp(TileProc proc, SkFixed dx, SkFixed fx, + SkPMColor* SK_RESTRICT dstC, + const SkPMColor* SK_RESTRICT cache, + int toggle, int count) { + if (proc == clamp_tileproc) { +@@ -2131,16 +2102,18 @@ protected: + buffer.writePoint(fCenter); + } + + private: + typedef Gradient_Shader INHERITED; + const SkPoint fCenter; + }; + ++#ifndef SK_SCALAR_IS_FLOAT ++ + #ifdef COMPUTE_SWEEP_TABLE + #define PI 3.14159265 + static bool gSweepTableReady; + static uint8_t gSweepTable[65]; + + /* Our table stores precomputed values for atan: [0...1] -> [0..PI/4] + We scale the results to [0..32] + */ +@@ -2168,20 +2141,23 @@ static const uint8_t gSweepTable[] = { + 10, 11, 11, 12, 12, 13, 13, 14, 15, 15, 16, 16, 17, 17, 18, 18, + 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 24, 25, 25, 25, 26, + 26, 27, 27, 27, 28, 28, 29, 29, 29, 30, 30, 30, 31, 31, 31, 32, + 32 + }; + static const uint8_t* build_sweep_table() { return gSweepTable; } + #endif + ++#endif ++ + // divide numer/denom, with a bias of 6bits. Assumes numer <= denom + // and denom != 0. Since our table is 6bits big (+1), this is a nice fit. + // Same as (but faster than) SkFixedDiv(numer, denom) >> 10 + ++#ifndef SK_SCALAR_IS_FLOAT + //unsigned div_64(int numer, int denom); + static unsigned div_64(int numer, int denom) { + SkASSERT(numer <= denom); + SkASSERT(numer > 0); + SkASSERT(denom > 0); + + int nbits = SkCLZ(numer); + int dbits = SkCLZ(denom); +@@ -2294,16 +2270,17 @@ static unsigned atan_0_90(SkFixed y, SkF + result = 64 - result; + // pin to 63 + result -= result >> 6; + } + + SkASSERT(result <= 63); + return result; + } ++#endif + + // returns angle in a circle [0..2PI) -> [0..255] + #ifdef SK_SCALAR_IS_FLOAT + static unsigned SkATan2_255(float y, float x) { + // static const float g255Over2PI = 255 / (2 * SK_ScalarPI); + static const float g255Over2PI = 40.584510488433314f; + + float result = sk_float_atan2(y, x); +diff --git a/gfx/skia/src/opts/SkBlitRect_opts_SSE2.cpp b/gfx/skia/src/opts/SkBlitRect_opts_SSE2.cpp +--- a/gfx/skia/src/opts/SkBlitRect_opts_SSE2.cpp ++++ b/gfx/skia/src/opts/SkBlitRect_opts_SSE2.cpp +@@ -112,17 +112,17 @@ void BlitRect32_OpaqueWide_SSE2(SkPMColo + } + + void ColorRect32_SSE2(SkPMColor* destination, + int width, int height, + size_t rowBytes, uint32_t color) { + if (0 == height || 0 == width || 0 == color) { + return; + } +- unsigned colorA = SkGetPackedA32(color); ++ //unsigned colorA = SkGetPackedA32(color); + //if (255 == colorA) { + //if (width < 31) { + //BlitRect32_OpaqueNarrow_SSE2(destination, width, height, + //rowBytes, color); + //} else { + //BlitRect32_OpaqueWide_SSE2(destination, width, height, + //rowBytes, color); + //} +diff --git a/gfx/skia/src/ports/SkFontHost_mac_coretext.cpp b/gfx/skia/src/ports/SkFontHost_mac_coretext.cpp +--- a/gfx/skia/src/ports/SkFontHost_mac_coretext.cpp ++++ b/gfx/skia/src/ports/SkFontHost_mac_coretext.cpp +@@ -75,20 +75,16 @@ static CGFloat CGRectGetMinY_inline(cons + static CGFloat CGRectGetMaxY_inline(const CGRect& rect) { + return rect.origin.y + rect.size.height; + } + + static CGFloat CGRectGetWidth_inline(const CGRect& rect) { + return rect.size.width; + } + +-static CGFloat CGRectGetHeight(const CGRect& rect) { +- return rect.size.height; +-} +- + /////////////////////////////////////////////////////////////////////////////// + + static void sk_memset_rect32(uint32_t* ptr, uint32_t value, size_t width, + size_t height, size_t rowBytes) { + SkASSERT(width); + SkASSERT(width * sizeof(uint32_t) <= rowBytes); + + if (width >= 32) { +@@ -125,28 +121,30 @@ static void sk_memset_rect32(uint32_t* p + *ptr++ = value; + } while (--w > 0); + ptr = (uint32_t*)((char*)ptr + rowBytes); + height -= 1; + } + } + } + ++#if 0 + // Potentially this should be made (1) public (2) optimized when width is small. + // Also might want 16 and 32 bit version + // + static void sk_memset_rect(void* ptr, U8CPU byte, size_t width, size_t height, + size_t rowBytes) { + uint8_t* dst = (uint8_t*)ptr; + while (height) { + memset(dst, byte, width); + dst += rowBytes; + height -= 1; + } + } ++#endif + + #include <sys/utsname.h> + + typedef uint32_t CGRGBPixel; + + static unsigned CGRGBPixel_getAlpha(CGRGBPixel pixel) { + return pixel & 0xFF; + } +@@ -250,23 +248,16 @@ static CGAffineTransform MatrixToCGAffin + return CGAffineTransformMake(ScalarToCG(matrix[SkMatrix::kMScaleX]) * sx, + -ScalarToCG(matrix[SkMatrix::kMSkewY]) * sy, + -ScalarToCG(matrix[SkMatrix::kMSkewX]) * sx, + ScalarToCG(matrix[SkMatrix::kMScaleY]) * sy, + ScalarToCG(matrix[SkMatrix::kMTransX]) * sx, + ScalarToCG(matrix[SkMatrix::kMTransY]) * sy); + } + +-static void CGAffineTransformToMatrix(const CGAffineTransform& xform, SkMatrix* matrix) { +- matrix->setAll( +- CGToScalar(xform.a), CGToScalar(xform.c), CGToScalar(xform.tx), +- CGToScalar(xform.b), CGToScalar(xform.d), CGToScalar(xform.ty), +- 0, 0, SK_Scalar1); +-} +- + static SkScalar getFontScale(CGFontRef cgFont) { + int unitsPerEm = CGFontGetUnitsPerEm(cgFont); + return SkScalarInvert(SkIntToScalar(unitsPerEm)); + } + + /////////////////////////////////////////////////////////////////////////////// + + #define BITMAP_INFO_RGB (kCGImageAlphaNoneSkipFirst | kCGBitmapByteOrder32Host) +@@ -1075,16 +1066,17 @@ static const uint8_t* getInverseTable(bo + if (!gInited) { + build_power_table(gWhiteTable, 1.5f); + build_power_table(gTable, 2.2f); + gInited = true; + } + return isWhite ? gWhiteTable : gTable; + } + ++#ifdef SK_USE_COLOR_LUMINANCE + static const uint8_t* getGammaTable(U8CPU luminance) { + static uint8_t gGammaTables[4][256]; + static bool gInited; + if (!gInited) { + #if 1 + float start = 1.1; + float stop = 2.1; + for (int i = 0; i < 4; ++i) { +@@ -1097,45 +1089,49 @@ static const uint8_t* getGammaTable(U8CP + build_power_table(gGammaTables[2], 1); + build_power_table(gGammaTables[3], 1); + #endif + gInited = true; + } + SkASSERT(0 == (luminance >> 8)); + return gGammaTables[luminance >> 6]; + } ++#endif + ++#ifndef SK_USE_COLOR_LUMINANCE + static void invertGammaMask(bool isWhite, CGRGBPixel rgb[], int width, + int height, size_t rb) { + const uint8_t* table = getInverseTable(isWhite); + for (int y = 0; y < height; ++y) { + for (int x = 0; x < width; ++x) { + uint32_t c = rgb[x]; + int r = (c >> 16) & 0xFF; + int g = (c >> 8) & 0xFF; + int b = (c >> 0) & 0xFF; + rgb[x] = (table[r] << 16) | (table[g] << 8) | table[b]; + } + rgb = (CGRGBPixel*)((char*)rgb + rb); + } + } ++#endif + + static void cgpixels_to_bits(uint8_t dst[], const CGRGBPixel src[], int count) { + while (count > 0) { + uint8_t mask = 0; + for (int i = 7; i >= 0; --i) { + mask |= (CGRGBPixel_getAlpha(*src++) >> 7) << i; + if (0 == --count) { + break; + } + } + *dst++ = mask; + } + } + ++#ifdef SK_USE_COLOR_LUMINANCE + static int lerpScale(int dst, int src, int scale) { + return dst + (scale * (src - dst) >> 23); + } + + static CGRGBPixel lerpPixel(CGRGBPixel dst, CGRGBPixel src, + int scaleR, int scaleG, int scaleB) { + int sr = (src >> 16) & 0xFF; + int sg = (src >> 8) & 0xFF; +@@ -1147,37 +1143,31 @@ static CGRGBPixel lerpPixel(CGRGBPixel d + int rr = lerpScale(dr, sr, scaleR); + int rg = lerpScale(dg, sg, scaleG); + int rb = lerpScale(db, sb, scaleB); + return (rr << 16) | (rg << 8) | rb; + } + + static void lerpPixels(CGRGBPixel dst[], const CGRGBPixel src[], int width, + int height, int rowBytes, int lumBits) { +-#ifdef SK_USE_COLOR_LUMINANCE + int scaleR = (1 << 23) * SkColorGetR(lumBits) / 0xFF; + int scaleG = (1 << 23) * SkColorGetG(lumBits) / 0xFF; + int scaleB = (1 << 23) * SkColorGetB(lumBits) / 0xFF; +-#else +- int scale = (1 << 23) * lumBits / SkScalerContext::kLuminance_Max; +- int scaleR = scale; +- int scaleG = scale; +- int scaleB = scale; +-#endif + + for (int y = 0; y < height; ++y) { + for (int x = 0; x < width; ++x) { + // bit-not the src, since it was drawn from black, so we need the + // compliment of those bits + dst[x] = lerpPixel(dst[x], ~src[x], scaleR, scaleG, scaleB); + } + src = (CGRGBPixel*)((char*)src + rowBytes); + dst = (CGRGBPixel*)((char*)dst + rowBytes); + } + } ++#endif + + #if 1 + static inline int r32_to_16(int x) { return SkR32ToR16(x); } + static inline int g32_to_16(int x) { return SkG32ToG16(x); } + static inline int b32_to_16(int x) { return SkB32ToB16(x); } + #else + static inline int round8to5(int x) { + return (x + 3 - (x >> 5) + (x >> 7)) >> 3; +@@ -1212,22 +1202,21 @@ static inline uint32_t rgb_to_lcd32(CGRG + return SkPackARGB32(0xFF, r, g, b); + } + + #define BLACK_LUMINANCE_LIMIT 0x40 + #define WHITE_LUMINANCE_LIMIT 0xA0 + + void SkScalerContext_Mac::generateImage(const SkGlyph& glyph) { + CGGlyph cgGlyph = (CGGlyph) glyph.getGlyphID(fBaseGlyphCount); +- + const bool isLCD = isLCDFormat(glyph.fMaskFormat); ++#ifdef SK_USE_COLOR_LUMINANCE + const bool isBW = SkMask::kBW_Format == glyph.fMaskFormat; + const bool isA8 = !isLCD && !isBW; +- +-#ifdef SK_USE_COLOR_LUMINANCE ++ + unsigned lumBits = fRec.getLuminanceColor(); + uint32_t xorMask = 0; + + if (isA8) { + // for A8, we just want a component (they're all the same) + lumBits = SkColorGetR(lumBits); + } + #else +diff --git a/gfx/skia/src/utils/mac/SkCreateCGImageRef.cpp b/gfx/skia/src/utils/mac/SkCreateCGImageRef.cpp +--- a/gfx/skia/src/utils/mac/SkCreateCGImageRef.cpp ++++ b/gfx/skia/src/utils/mac/SkCreateCGImageRef.cpp +@@ -163,59 +163,8 @@ private: + CGPDFDocumentRef fDoc; + }; + + static void CGDataProviderReleaseData_FromMalloc(void*, const void* data, + size_t size) { + sk_free((void*)data); + } + +-bool SkPDFDocumentToBitmap(SkStream* stream, SkBitmap* output) { +- size_t size = stream->getLength(); +- void* ptr = sk_malloc_throw(size); +- stream->read(ptr, size); +- CGDataProviderRef data = CGDataProviderCreateWithData(NULL, ptr, size, +- CGDataProviderReleaseData_FromMalloc); +- if (NULL == data) { +- return false; +- } +- +- CGPDFDocumentRef pdf = CGPDFDocumentCreateWithProvider(data); +- CGDataProviderRelease(data); +- if (NULL == pdf) { +- return false; +- } +- SkAutoPDFRelease releaseMe(pdf); +- +- CGPDFPageRef page = CGPDFDocumentGetPage(pdf, 1); +- if (NULL == page) { +- return false; +- } +- +- CGRect bounds = CGPDFPageGetBoxRect(page, kCGPDFMediaBox); +- +- int w = (int)CGRectGetWidth(bounds); +- int h = (int)CGRectGetHeight(bounds); +- +- SkBitmap bitmap; +- bitmap.setConfig(SkBitmap::kARGB_8888_Config, w, h); +- bitmap.allocPixels(); +- bitmap.eraseColor(SK_ColorWHITE); +- +- size_t bitsPerComponent; +- CGBitmapInfo info; +- getBitmapInfo(bitmap, &bitsPerComponent, &info, NULL); +- +- CGColorSpaceRef cs = CGColorSpaceCreateDeviceRGB(); +- CGContextRef ctx = CGBitmapContextCreate(bitmap.getPixels(), w, h, +- bitsPerComponent, bitmap.rowBytes(), +- cs, info); +- CGColorSpaceRelease(cs); +- +- if (ctx) { +- CGContextDrawPDFPage(ctx, page); +- CGContextRelease(ctx); +- } +- +- output->swap(bitmap); +- return true; +-} +- |