| /* |
| * Copyright 2013 Google Inc. |
| * |
| * Use of this source code is governed by a BSD-style license that can be |
| * found in the LICENSE file. |
| */ |
| |
| #include "SkMipMap.h" |
| #include "SkBitmap.h" |
| #include "SkColorPriv.h" |
| #include "SkMath.h" |
| #include "SkNx.h" |
| #include "SkTypes.h" |
| |
| // |
| // ColorTypeFilter is the "Type" we pass to some downsample template functions. |
| // It controls how we expand a pixel into a large type, with space between each component, |
| // so we can then perform our simple filter (either box or triangle) and store the intermediates |
| // in the expanded type. |
| // |
| |
| struct ColorTypeFilter_8888 { |
| typedef uint32_t Type; |
| #if defined(SKNX_IS_FAST) |
| static Sk4h Expand(uint32_t x) { |
| return SkNx_cast<uint16_t>(Sk4b::Load(&x)); |
| } |
| static uint32_t Compact(const Sk4h& x) { |
| uint32_t r; |
| SkNx_cast<uint8_t>(x).store(&r); |
| return r; |
| } |
| #else |
| static uint64_t Expand(uint32_t x) { |
| return (x & 0xFF00FF) | ((uint64_t)(x & 0xFF00FF00) << 24); |
| } |
| static uint32_t Compact(uint64_t x) { |
| return (uint32_t)((x & 0xFF00FF) | ((x >> 24) & 0xFF00FF00)); |
| } |
| #endif |
| }; |
| |
| struct ColorTypeFilter_565 { |
| typedef uint16_t Type; |
| static uint32_t Expand(uint16_t x) { |
| return (x & ~SK_G16_MASK_IN_PLACE) | ((x & SK_G16_MASK_IN_PLACE) << 16); |
| } |
| static uint16_t Compact(uint32_t x) { |
| return (x & ~SK_G16_MASK_IN_PLACE) | ((x >> 16) & SK_G16_MASK_IN_PLACE); |
| } |
| }; |
| |
| struct ColorTypeFilter_4444 { |
| typedef uint16_t Type; |
| static uint32_t Expand(uint16_t x) { |
| return (x & 0xF0F) | ((x & ~0xF0F) << 12); |
| } |
| static uint16_t Compact(uint32_t x) { |
| return (x & 0xF0F) | ((x >> 12) & ~0xF0F); |
| } |
| }; |
| |
| struct ColorTypeFilter_8 { |
| typedef uint8_t Type; |
| static unsigned Expand(unsigned x) { |
| return x; |
| } |
| static uint8_t Compact(unsigned x) { |
| return (uint8_t)x; |
| } |
| }; |
| |
| template <typename T> T add_121(const T& a, const T& b, const T& c) { |
| return a + b + b + c; |
| } |
| |
| // |
| // To produce each mip level, we need to filter down by 1/2 (e.g. 100x100 -> 50,50) |
| // If the starting dimension is odd, we floor the size of the lower level (e.g. 101 -> 50) |
| // In those (odd) cases, we use a triangle filter, with 1-pixel overlap between samplings, |
| // else for even cases, we just use a 2x box filter. |
| // |
| // This produces 4 possible filters: 2x2 2x3 3x2 3x3 where WxH indicates the number of src pixels |
| // we need to sample in each dimension to produce 1 dst pixel. |
| // |
| |
| template <typename F> void downsample_2_2(void* dst, const void* src, size_t srcRB, int count) { |
| auto p0 = static_cast<const typename F::Type*>(src); |
| auto p1 = (const typename F::Type*)((const char*)p0 + srcRB); |
| auto d = static_cast<typename F::Type*>(dst); |
| |
| for (int i = 0; i < count; ++i) { |
| auto c00 = F::Expand(p0[0]); |
| auto c01 = F::Expand(p0[1]); |
| auto c10 = F::Expand(p1[0]); |
| auto c11 = F::Expand(p1[1]); |
| |
| auto c = c00 + c10 + c01 + c11; |
| d[i] = F::Compact(c >> 2); |
| p0 += 2; |
| p1 += 2; |
| } |
| } |
| |
| template <typename F> void downsample_3_2(void* dst, const void* src, size_t srcRB, int count) { |
| SkASSERT(count > 0); |
| auto p0 = static_cast<const typename F::Type*>(src); |
| auto p1 = (const typename F::Type*)((const char*)p0 + srcRB); |
| auto d = static_cast<typename F::Type*>(dst); |
| |
| auto c02 = F::Expand(p0[0]); |
| auto c12 = F::Expand(p1[0]); |
| for (int i = 0; i < count; ++i) { |
| auto c00 = c02; |
| auto c01 = F::Expand(p0[1]); |
| c02 = F::Expand(p0[2]); |
| auto c10 = c12; |
| auto c11 = F::Expand(p1[1]); |
| c12 = F::Expand(p1[2]); |
| |
| auto c = add_121(c00, c01, c02) + add_121(c10, c11, c12); |
| d[i] = F::Compact(c >> 3); |
| p0 += 2; |
| p1 += 2; |
| } |
| } |
| |
| template <typename F> void downsample_2_3(void* dst, const void* src, size_t srcRB, int count) { |
| auto p0 = static_cast<const typename F::Type*>(src); |
| auto p1 = (const typename F::Type*)((const char*)p0 + srcRB); |
| auto p2 = (const typename F::Type*)((const char*)p1 + srcRB); |
| auto d = static_cast<typename F::Type*>(dst); |
| |
| for (int i = 0; i < count; ++i) { |
| auto c00 = F::Expand(p0[0]); |
| auto c01 = F::Expand(p0[1]); |
| auto c10 = F::Expand(p1[0]); |
| auto c11 = F::Expand(p1[1]); |
| auto c20 = F::Expand(p2[0]); |
| auto c21 = F::Expand(p2[1]); |
| |
| auto c = add_121(c00, c10, c20) + add_121(c01, c11, c21); |
| d[i] = F::Compact(c >> 3); |
| p0 += 2; |
| p1 += 2; |
| p2 += 2; |
| } |
| } |
| |
| template <typename F> void downsample_3_3(void* dst, const void* src, size_t srcRB, int count) { |
| auto p0 = static_cast<const typename F::Type*>(src); |
| auto p1 = (const typename F::Type*)((const char*)p0 + srcRB); |
| auto p2 = (const typename F::Type*)((const char*)p1 + srcRB); |
| auto d = static_cast<typename F::Type*>(dst); |
| |
| auto c02 = F::Expand(p0[0]); |
| auto c12 = F::Expand(p1[0]); |
| auto c22 = F::Expand(p2[0]); |
| for (int i = 0; i < count; ++i) { |
| auto c00 = c02; |
| auto c01 = F::Expand(p0[1]); |
| c02 = F::Expand(p0[2]); |
| auto c10 = c12; |
| auto c11 = F::Expand(p1[1]); |
| c12 = F::Expand(p1[2]); |
| auto c20 = c22; |
| auto c21 = F::Expand(p2[1]); |
| c22 = F::Expand(p2[2]); |
| |
| auto c = add_121(c00, c01, c02) + (add_121(c10, c11, c12) << 1) + add_121(c20, c21, c22); |
| d[i] = F::Compact(c >> 4); |
| p0 += 2; |
| p1 += 2; |
| p2 += 2; |
| } |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////////////////////////// |
| |
| size_t SkMipMap::AllocLevelsSize(int levelCount, size_t pixelSize) { |
| if (levelCount < 0) { |
| return 0; |
| } |
| int64_t size = sk_64_mul(levelCount + 1, sizeof(Level)) + pixelSize; |
| if (!sk_64_isS32(size)) { |
| return 0; |
| } |
| return sk_64_asS32(size); |
| } |
| |
| SkMipMap* SkMipMap::Build(const SkPixmap& src, SkDiscardableFactoryProc fact) { |
| typedef void FilterProc(void*, const void* srcPtr, size_t srcRB, int count); |
| |
| FilterProc* proc_2_2 = nullptr; |
| FilterProc* proc_2_3 = nullptr; |
| FilterProc* proc_3_2 = nullptr; |
| FilterProc* proc_3_3 = nullptr; |
| |
| const SkColorType ct = src.colorType(); |
| const SkAlphaType at = src.alphaType(); |
| switch (ct) { |
| case kRGBA_8888_SkColorType: |
| case kBGRA_8888_SkColorType: |
| proc_2_2 = downsample_2_2<ColorTypeFilter_8888>; |
| proc_2_3 = downsample_2_3<ColorTypeFilter_8888>; |
| proc_3_2 = downsample_3_2<ColorTypeFilter_8888>; |
| proc_3_3 = downsample_3_3<ColorTypeFilter_8888>; |
| break; |
| case kRGB_565_SkColorType: |
| proc_2_2 = downsample_2_2<ColorTypeFilter_565>; |
| proc_2_3 = downsample_2_3<ColorTypeFilter_565>; |
| proc_3_2 = downsample_3_2<ColorTypeFilter_565>; |
| proc_3_3 = downsample_3_3<ColorTypeFilter_565>; |
| break; |
| case kARGB_4444_SkColorType: |
| proc_2_2 = downsample_2_2<ColorTypeFilter_4444>; |
| proc_2_3 = downsample_2_3<ColorTypeFilter_4444>; |
| proc_3_2 = downsample_3_2<ColorTypeFilter_4444>; |
| proc_3_3 = downsample_3_3<ColorTypeFilter_4444>; |
| break; |
| case kAlpha_8_SkColorType: |
| case kGray_8_SkColorType: |
| proc_2_2 = downsample_2_2<ColorTypeFilter_8>; |
| proc_2_3 = downsample_2_3<ColorTypeFilter_8>; |
| proc_3_2 = downsample_3_2<ColorTypeFilter_8>; |
| proc_3_3 = downsample_3_3<ColorTypeFilter_8>; |
| break; |
| default: |
| // TODO: We could build miplevels for kIndex8 if the levels were in 8888. |
| // Means using more ram, but the quality would be fine. |
| return nullptr; |
| } |
| |
| // whip through our loop to compute the exact size needed |
| size_t size = 0; |
| int countLevels = 0; |
| { |
| int width = src.width(); |
| int height = src.height(); |
| for (;;) { |
| width >>= 1; |
| height >>= 1; |
| if (0 == width || 0 == height) { |
| break; |
| } |
| size += SkColorTypeMinRowBytes(ct, width) * height; |
| countLevels += 1; |
| } |
| } |
| if (0 == countLevels) { |
| return nullptr; |
| } |
| |
| SkASSERT(countLevels == SkMipMap::ComputeLevelCount(src.width(), src.height())); |
| |
| size_t storageSize = SkMipMap::AllocLevelsSize(countLevels, size); |
| if (0 == storageSize) { |
| return nullptr; |
| } |
| |
| SkMipMap* mipmap; |
| if (fact) { |
| SkDiscardableMemory* dm = fact(storageSize); |
| if (nullptr == dm) { |
| return nullptr; |
| } |
| mipmap = new SkMipMap(storageSize, dm); |
| } else { |
| mipmap = new SkMipMap(sk_malloc_throw(storageSize), storageSize); |
| } |
| |
| // init |
| mipmap->fCount = countLevels; |
| mipmap->fLevels = (Level*)mipmap->writable_data(); |
| |
| Level* levels = mipmap->fLevels; |
| uint8_t* baseAddr = (uint8_t*)&levels[countLevels]; |
| uint8_t* addr = baseAddr; |
| int width = src.width(); |
| int height = src.height(); |
| uint32_t rowBytes; |
| SkPixmap srcPM(src); |
| |
| for (int i = 0; i < countLevels; ++i) { |
| FilterProc* proc; |
| if (height & 1) { // src-height is 3 |
| if (width & 1) { // src-width is 3 |
| proc = proc_3_3; |
| } else { // src-width is 2 |
| proc = proc_2_3; |
| } |
| } else { // src-height is 2 |
| if (width & 1) { // src-width is 3 |
| proc = proc_3_2; |
| } else { // src-width is 2 |
| proc = proc_2_2; |
| } |
| } |
| width >>= 1; |
| height >>= 1; |
| rowBytes = SkToU32(SkColorTypeMinRowBytes(ct, width)); |
| |
| levels[i].fPixmap = SkPixmap(SkImageInfo::Make(width, height, ct, at), addr, rowBytes); |
| levels[i].fScale = SkSize::Make(SkIntToScalar(width) / src.width(), |
| SkIntToScalar(height) / src.height()); |
| |
| const SkPixmap& dstPM = levels[i].fPixmap; |
| const void* srcBasePtr = srcPM.addr(); |
| void* dstBasePtr = dstPM.writable_addr(); |
| |
| const size_t srcRB = srcPM.rowBytes(); |
| for (int y = 0; y < height; y++) { |
| proc(dstBasePtr, srcBasePtr, srcRB, width); |
| srcBasePtr = (char*)srcBasePtr + srcRB * 2; // jump two rows |
| dstBasePtr = (char*)dstBasePtr + dstPM.rowBytes(); |
| } |
| srcPM = dstPM; |
| addr += height * rowBytes; |
| } |
| SkASSERT(addr == baseAddr + size); |
| |
| return mipmap; |
| } |
| |
| int SkMipMap::ComputeLevelCount(int baseWidth, int baseHeight) { |
| // OpenGL's spec requires that each mipmap level have height/width equal to |
| // max(1, floor(original_height / 2^i) |
| // (or original_width) where i is the mipmap level. |
| // Continue scaling down until both axes are size 1. |
| // |
| // This means it maintains isotropic space (both axes scaling down |
| // at the same rate) until one axis hits size 1. |
| // At that point, OpenGL continues to scale down into anisotropic space |
| // (where the scales are not the same between axes). |
| // |
| // Skia currently does not go into anisotropic space. |
| // Once an axis hits size 1 we stop. |
| // All this means is rather than use the largest axis we will use the |
| // smallest axis. |
| |
| const int smallestAxis = SkTMin(baseWidth, baseHeight); |
| if (smallestAxis < 2) { |
| // SkMipMap::Build requires a minimum size of 2. |
| return 0; |
| } |
| const int leadingZeros = SkCLZ(static_cast<uint32_t>(smallestAxis)); |
| // If the value 00011010 has 3 leading 0s then it has 5 significant bits |
| // (the bits which are not leading zeros) |
| const int significantBits = (sizeof(uint32_t) * 8) - leadingZeros; |
| // This is making the assumption that the size of a byte is 8 bits |
| // and that sizeof(uint32_t)'s implementation-defined behavior is 4. |
| int mipLevelCount = significantBits; |
| |
| // SkMipMap does not include the base mip level. |
| // For example, it contains levels 1-x instead of 0-x. |
| // This is because the image used to create SkMipMap is the base level. |
| // So subtract 1 from the mip level count. |
| if (mipLevelCount > 0) { |
| --mipLevelCount; |
| } |
| |
| return mipLevelCount; |
| } |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| bool SkMipMap::extractLevel(const SkSize& scaleSize, Level* levelPtr) const { |
| if (nullptr == fLevels) { |
| return false; |
| } |
| |
| SkASSERT(scaleSize.width() >= 0 && scaleSize.height() >= 0); |
| |
| #ifndef SK_SUPPORT_LEGACY_ANISOTROPIC_MIPMAP_SCALE |
| // Use the smallest scale to match the GPU impl. |
| const SkScalar scale = SkTMin(scaleSize.width(), scaleSize.height()); |
| #else |
| // Ideally we'd pick the smaller scale, to match Ganesh. But ignoring one of the |
| // scales can produce some atrocious results, so for now we use the geometric mean. |
| // (https://bugs.chromium.org/p/skia/issues/detail?id=4863) |
| const SkScalar scale = SkScalarSqrt(scaleSize.width() * scaleSize.height()); |
| #endif |
| |
| if (scale >= SK_Scalar1 || scale <= 0 || !SkScalarIsFinite(scale)) { |
| return false; |
| } |
| |
| SkScalar L = -SkScalarLog2(scale); |
| if (!SkScalarIsFinite(L)) { |
| return false; |
| } |
| SkASSERT(L >= 0); |
| // int rndLevel = SkScalarRoundToInt(L); |
| int level = SkScalarFloorToInt(L); |
| // SkDebugf("mipmap scale=%g L=%g level=%d rndLevel=%d\n", scale, L, level, rndLevel); |
| |
| SkASSERT(level >= 0); |
| if (level <= 0) { |
| return false; |
| } |
| |
| if (level > fCount) { |
| level = fCount; |
| } |
| if (levelPtr) { |
| *levelPtr = fLevels[level - 1]; |
| } |
| return true; |
| } |
| |
| // Helper which extracts a pixmap from the src bitmap |
| // |
| SkMipMap* SkMipMap::Build(const SkBitmap& src, SkDiscardableFactoryProc fact) { |
| SkAutoPixmapUnlock srcUnlocker; |
| if (!src.requestLock(&srcUnlocker)) { |
| return nullptr; |
| } |
| const SkPixmap& srcPixmap = srcUnlocker.pixmap(); |
| // Try to catch where we might have returned nullptr for src crbug.com/492818 |
| if (nullptr == srcPixmap.addr()) { |
| sk_throw(); |
| } |
| return Build(srcPixmap, fact); |
| } |
| |
| int SkMipMap::countLevels() const { |
| return fCount; |
| } |
| |
| bool SkMipMap::getLevel(int index, Level* levelPtr) const { |
| if (NULL == fLevels) { |
| return false; |
| } |
| if (index < 0) { |
| return false; |
| } |
| if (index > fCount - 1) { |
| return false; |
| } |
| if (levelPtr) { |
| *levelPtr = fLevels[index]; |
| } |
| return true; |
| } |