SkMipmap Class Reference

#include <SkMipmap.h>

Inheritance diagram for SkMipmap:

Classes
struct	Level

Public Member Functions
	~SkMipmap () override
bool	extractLevel (SkSize scale, Level *) const
int	countLevels () const
bool	getLevel (int index, Level *) const
bool	validForRootLevel (const SkImageInfo &) const
Public Member Functions inherited from SkCachedData
	SkCachedData (void *mallocData, size_t size)
	SkCachedData (size_t size, SkDiscardableMemory *)
virtual	~SkCachedData ()
size_t	size () const
const void *	data () const
void *	writable_data ()
void	ref () const
void	unref () const
int	testing_only_getRefCnt () const
bool	testing_only_isLocked () const
bool	testing_only_isInCache () const
SkDiscardableMemory *	diagnostic_only_getDiscardable () const
void	validate () const
void	attachToCacheAndRef () const
void	detachFromCacheAndUnref () const

Static Public Member Functions
static SkMipmap *	Build (const SkPixmap &src, SkDiscardableFactoryProc, bool computeContents=true)
static SkMipmap *	Build (const SkBitmap &src, SkDiscardableFactoryProc)
static int	ComputeLevelCount (int baseWidth, int baseHeight)
static int	ComputeLevelCount (SkISize s)
static SkISize	ComputeLevelSize (int baseWidth, int baseHeight, int level)
static SkISize	ComputeLevelSize (SkISize s, int level)
static float	ComputeLevel (SkSize scaleSize)
static std::unique_ptr< SkMipmapDownSampler >	MakeDownSampler (const SkPixmap &)

Protected Member Functions
void	onDataChange (void *oldData, void *newData) override
virtual void	onDataChange (void *oldData, void *newData)

Detailed Description

Definition at line 39 of file SkMipmap.h.

Constructor & Destructor Documentation

~SkMipmap()

SkMipmap::~SkMipmap ( )

overridedefault

Member Function Documentation

Build() [1/2]

SkMipmap * SkMipmap::Build ( const SkBitmap &  src, SkDiscardableFactoryProc  fact  )

static

Definition at line 268 of file SkMipmap.cpp.

                                                                            {
    SkPixmap srcPixmap;
    if (!src.peekPixels(&srcPixmap)) {
        return nullptr;
    }
    return Build(srcPixmap, fact);
}

Build() [2/2]

SkMipmap * SkMipmap::Build ( const SkPixmap &  src, SkDiscardableFactoryProc  fact, bool  computeContents = true  )

static

Definition at line 45 of file SkMipmap.cpp.

                                                {
    if (src.width() <= 1 && src.height() <= 1) {
        return nullptr;
    }
 
    const SkColorType ct = src.colorType();
    const SkAlphaType at = src.alphaType();
 
    // whip through our loop to compute the exact size needed
    size_t size = 0;
    int countLevels = ComputeLevelCount(src.width(), src.height());
    for (int currentMipLevel = countLevels; currentMipLevel >= 0; currentMipLevel--) {
        SkISize mipSize = ComputeLevelSize(src.width(), src.height(), currentMipLevel);
        size += SkColorTypeMinRowBytes(ct, mipSize.fWidth) * mipSize.fHeight;
    }
 
    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 {
        void* tmp = sk_malloc_canfail(storageSize);
        if (!tmp) {
            return nullptr;
        }
 
        mipmap = new SkMipmap(tmp, storageSize);
    }
 
    // init
    mipmap->fCS = sk_ref_sp(src.info().colorSpace());
    mipmap->fCount = countLevels;
    mipmap->fLevels = (Level*)mipmap->writable_data();
    SkASSERT(mipmap->fLevels);
 
    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);
 
    // Depending on architecture and other factors, the pixel data alignment may need to be as
    // large as 8 (for F16 pixels). See the comment on SkMipmap::Level.
    SkASSERT(SkIsAlign8((uintptr_t)addr));
 
    std::unique_ptr<SkMipmapDownSampler> downsampler;
    if (computeContents) {
        downsampler = MakeDownSampler(src);
        if (!downsampler) {
            return nullptr;
        }
    }
 
    for (int i = 0; i < countLevels; ++i) {
        width = std::max(1, width >> 1);
        height = std::max(1, height >> 1);
        rowBytes = SkToU32(SkColorTypeMinRowBytes(ct, width));
 
        // We make the Info w/o any colorspace, since that storage is not under our control, and
        // will not be deleted in a controlled fashion. When the caller is given the pixmap for
        // a given level, we augment this pixmap with fCS (which we do manage).
        new (&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;
        if (downsampler) {
            downsampler->buildLevel(dstPM, srcPM);
        }
        srcPM = dstPM;
        addr += height * rowBytes;
    }
    SkASSERT(addr == baseAddr + size);
 
    SkASSERT(mipmap->fLevels);
    return mipmap;
}

ComputeLevel()

float SkMipmap::ComputeLevel ( SkSize  scaleSize )

static

Definition at line 195 of file SkMipmap.cpp.

                                             {
    SkASSERT(scaleSize.width() >= 0 && scaleSize.height() >= 0);
 
#ifndef SK_SUPPORT_LEGACY_ANISOTROPIC_MIPMAP_SCALE
    // Use the smallest scale to match the GPU impl.
    const float scale = std::min(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 float scale = std::sqrt(scaleSize.width() * scaleSize.height());
#endif
 
    if (scale >= SK_Scalar1 || scale <= 0 || !SkIsFinite(scale)) {
        return -1;
    }
 
    // The -0.5 bias here is to emulate GPU's sharpen mipmap option.
    float L = std::max(-SkScalarLog2(scale) - 0.5f, 0.f);
    if (!SkIsFinite(L)) {
        return -1;
    }
    return L;
}

ComputeLevelCount() [1/2]

int SkMipmap::ComputeLevelCount ( int  baseWidth, int  baseHeight  )

static

Definition at line 134 of file SkMipmap.cpp.

                                                             {
    if (baseWidth < 1 || baseHeight < 1) {
        return 0;
    }
 
    // 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.
 
    const int largestAxis = std::max(baseWidth, baseHeight);
    if (largestAxis < 2) {
        // SkMipmap::Build requires a minimum size of 2.
        return 0;
    }
    const int leadingZeros = SkCLZ(static_cast<uint32_t>(largestAxis));
    // 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;
}

ComputeLevelCount() [2/2]

static int SkMipmap::ComputeLevelCount ( SkISize  s )

inlinestatic

Definition at line 53 of file SkMipmap.h.

{ return ComputeLevelCount(s.width(), s.height()); }

ComputeLevelSize() [1/2]

SkISize SkMipmap::ComputeLevelSize ( int  baseWidth, int  baseHeight, int  level  )

static

Definition at line 168 of file SkMipmap.cpp.

                                                                           {
    if (baseWidth < 1 || baseHeight < 1) {
        return SkISize::Make(0, 0);
    }
 
    int maxLevelCount = ComputeLevelCount(baseWidth, baseHeight);
    if (level >= maxLevelCount || level < 0) {
        return SkISize::Make(0, 0);
    }
    // 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.
 
    // 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 to get the index stored by SkMipmap.
    int width = std::max(1, baseWidth >> (level + 1));
    int height = std::max(1, baseHeight >> (level + 1));
 
    return SkISize::Make(width, height);
}

ComputeLevelSize() [2/2]

static SkISize SkMipmap::ComputeLevelSize ( SkISize  s, int  level  )

inlinestatic

Definition at line 59 of file SkMipmap.h.

                                                          {
        return ComputeLevelSize(s.width(), s.height(), level);
    }

countLevels()

int SkMipmap::countLevels

(

)

const

Definition at line 276 of file SkMipmap.cpp.

                                {
    return fCount;
}

extractLevel()

bool SkMipmap::extractLevel	(	SkSize	scale,
		Level *	levelPtr
	)		const

Definition at line 220 of file SkMipmap.cpp.

                                                                   {
    if (nullptr == fLevels) {
        return false;
    }
 
    float L = ComputeLevel(scaleSize);
    int level = sk_float_round2int(L);
    if (level <= 0) {
        return false;
    }
 
    if (level > fCount) {
        level = fCount;
    }
    if (levelPtr) {
        *levelPtr = fLevels[level - 1];
        // need to augment with our colorspace
        levelPtr->fPixmap.setColorSpace(fCS);
    }
    return true;
}

getLevel()

bool SkMipmap::getLevel	(	int	index,
		Level *	levelPtr
	)		const

Definition at line 280 of file SkMipmap.cpp.

                                                        {
    if (nullptr == fLevels) {
        return false;
    }
    if (index < 0) {
        return false;
    }
    if (index > fCount - 1) {
        return false;
    }
    if (levelPtr) {
        *levelPtr = fLevels[index];
        // need to augment with our colorspace
        levelPtr->fPixmap.setColorSpace(fCS);
    }
    return true;
}

MakeDownSampler()

std::unique_ptr< SkMipmapDownSampler > SkMipmap::MakeDownSampler ( const SkPixmap &  root )

static

Definition at line 441 of file SkMipmapHQDownSampler.cpp.

                                                                                 {
    FilterProc* proc_1_2 = nullptr;
    FilterProc* proc_1_3 = nullptr;
    FilterProc* proc_2_1 = nullptr;
    FilterProc* proc_2_2 = nullptr;
    FilterProc* proc_2_3 = nullptr;
    FilterProc* proc_3_1 = nullptr;
    FilterProc* proc_3_2 = nullptr;
    FilterProc* proc_3_3 = nullptr;
 
    switch (root.colorType()) {
        case kRGBA_8888_SkColorType:
        case kBGRA_8888_SkColorType:
            proc_1_2 = downsample_1_2<ColorTypeFilter_8888>;
            proc_1_3 = downsample_1_3<ColorTypeFilter_8888>;
            proc_2_1 = downsample_2_1<ColorTypeFilter_8888>;
            proc_2_2 = downsample_2_2<ColorTypeFilter_8888>;
            proc_2_3 = downsample_2_3<ColorTypeFilter_8888>;
            proc_3_1 = downsample_3_1<ColorTypeFilter_8888>;
            proc_3_2 = downsample_3_2<ColorTypeFilter_8888>;
            proc_3_3 = downsample_3_3<ColorTypeFilter_8888>;
            break;
        case kRGB_565_SkColorType:
            proc_1_2 = downsample_1_2<ColorTypeFilter_565>;
            proc_1_3 = downsample_1_3<ColorTypeFilter_565>;
            proc_2_1 = downsample_2_1<ColorTypeFilter_565>;
            proc_2_2 = downsample_2_2<ColorTypeFilter_565>;
            proc_2_3 = downsample_2_3<ColorTypeFilter_565>;
            proc_3_1 = downsample_3_1<ColorTypeFilter_565>;
            proc_3_2 = downsample_3_2<ColorTypeFilter_565>;
            proc_3_3 = downsample_3_3<ColorTypeFilter_565>;
            break;
        case kARGB_4444_SkColorType:
            proc_1_2 = downsample_1_2<ColorTypeFilter_4444>;
            proc_1_3 = downsample_1_3<ColorTypeFilter_4444>;
            proc_2_1 = downsample_2_1<ColorTypeFilter_4444>;
            proc_2_2 = downsample_2_2<ColorTypeFilter_4444>;
            proc_2_3 = downsample_2_3<ColorTypeFilter_4444>;
            proc_3_1 = downsample_3_1<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:
        case kR8_unorm_SkColorType:
            proc_1_2 = downsample_1_2<ColorTypeFilter_8>;
            proc_1_3 = downsample_1_3<ColorTypeFilter_8>;
            proc_2_1 = downsample_2_1<ColorTypeFilter_8>;
            proc_2_2 = downsample_2_2<ColorTypeFilter_8>;
            proc_2_3 = downsample_2_3<ColorTypeFilter_8>;
            proc_3_1 = downsample_3_1<ColorTypeFilter_8>;
            proc_3_2 = downsample_3_2<ColorTypeFilter_8>;
            proc_3_3 = downsample_3_3<ColorTypeFilter_8>;
            break;
        case kRGBA_F16Norm_SkColorType:
        case kRGBA_F16_SkColorType:
            proc_1_2 = downsample_1_2<ColorTypeFilter_RGBA_F16>;
            proc_1_3 = downsample_1_3<ColorTypeFilter_RGBA_F16>;
            proc_2_1 = downsample_2_1<ColorTypeFilter_RGBA_F16>;
            proc_2_2 = downsample_2_2<ColorTypeFilter_RGBA_F16>;
            proc_2_3 = downsample_2_3<ColorTypeFilter_RGBA_F16>;
            proc_3_1 = downsample_3_1<ColorTypeFilter_RGBA_F16>;
            proc_3_2 = downsample_3_2<ColorTypeFilter_RGBA_F16>;
            proc_3_3 = downsample_3_3<ColorTypeFilter_RGBA_F16>;
            break;
        case kR8G8_unorm_SkColorType:
            proc_1_2 = downsample_1_2<ColorTypeFilter_88>;
            proc_1_3 = downsample_1_3<ColorTypeFilter_88>;
            proc_2_1 = downsample_2_1<ColorTypeFilter_88>;
            proc_2_2 = downsample_2_2<ColorTypeFilter_88>;
            proc_2_3 = downsample_2_3<ColorTypeFilter_88>;
            proc_3_1 = downsample_3_1<ColorTypeFilter_88>;
            proc_3_2 = downsample_3_2<ColorTypeFilter_88>;
            proc_3_3 = downsample_3_3<ColorTypeFilter_88>;
            break;
        case kR16G16_unorm_SkColorType:
            proc_1_2 = downsample_1_2<ColorTypeFilter_1616>;
            proc_1_3 = downsample_1_3<ColorTypeFilter_1616>;
            proc_2_1 = downsample_2_1<ColorTypeFilter_1616>;
            proc_2_2 = downsample_2_2<ColorTypeFilter_1616>;
            proc_2_3 = downsample_2_3<ColorTypeFilter_1616>;
            proc_3_1 = downsample_3_1<ColorTypeFilter_1616>;
            proc_3_2 = downsample_3_2<ColorTypeFilter_1616>;
            proc_3_3 = downsample_3_3<ColorTypeFilter_1616>;
            break;
        case kA16_unorm_SkColorType:
            proc_1_2 = downsample_1_2<ColorTypeFilter_16>;
            proc_1_3 = downsample_1_3<ColorTypeFilter_16>;
            proc_2_1 = downsample_2_1<ColorTypeFilter_16>;
            proc_2_2 = downsample_2_2<ColorTypeFilter_16>;
            proc_2_3 = downsample_2_3<ColorTypeFilter_16>;
            proc_3_1 = downsample_3_1<ColorTypeFilter_16>;
            proc_3_2 = downsample_3_2<ColorTypeFilter_16>;
            proc_3_3 = downsample_3_3<ColorTypeFilter_16>;
            break;
        case kRGBA_1010102_SkColorType:
        case kBGRA_1010102_SkColorType:
            proc_1_2 = downsample_1_2<ColorTypeFilter_1010102>;
            proc_1_3 = downsample_1_3<ColorTypeFilter_1010102>;
            proc_2_1 = downsample_2_1<ColorTypeFilter_1010102>;
            proc_2_2 = downsample_2_2<ColorTypeFilter_1010102>;
            proc_2_3 = downsample_2_3<ColorTypeFilter_1010102>;
            proc_3_1 = downsample_3_1<ColorTypeFilter_1010102>;
            proc_3_2 = downsample_3_2<ColorTypeFilter_1010102>;
            proc_3_3 = downsample_3_3<ColorTypeFilter_1010102>;
            break;
        case kA16_float_SkColorType:
            proc_1_2 = downsample_1_2<ColorTypeFilter_Alpha_F16>;
            proc_1_3 = downsample_1_3<ColorTypeFilter_Alpha_F16>;
            proc_2_1 = downsample_2_1<ColorTypeFilter_Alpha_F16>;
            proc_2_2 = downsample_2_2<ColorTypeFilter_Alpha_F16>;
            proc_2_3 = downsample_2_3<ColorTypeFilter_Alpha_F16>;
            proc_3_1 = downsample_3_1<ColorTypeFilter_Alpha_F16>;
            proc_3_2 = downsample_3_2<ColorTypeFilter_Alpha_F16>;
            proc_3_3 = downsample_3_3<ColorTypeFilter_Alpha_F16>;
            break;
        case kR16G16_float_SkColorType:
            proc_1_2 = downsample_1_2<ColorTypeFilter_F16F16>;
            proc_1_3 = downsample_1_3<ColorTypeFilter_F16F16>;
            proc_2_1 = downsample_2_1<ColorTypeFilter_F16F16>;
            proc_2_2 = downsample_2_2<ColorTypeFilter_F16F16>;
            proc_2_3 = downsample_2_3<ColorTypeFilter_F16F16>;
            proc_3_1 = downsample_3_1<ColorTypeFilter_F16F16>;
            proc_3_2 = downsample_3_2<ColorTypeFilter_F16F16>;
            proc_3_3 = downsample_3_3<ColorTypeFilter_F16F16>;
            break;
        case kR16G16B16A16_unorm_SkColorType:
            proc_1_2 = downsample_1_2<ColorTypeFilter_16161616>;
            proc_1_3 = downsample_1_3<ColorTypeFilter_16161616>;
            proc_2_1 = downsample_2_1<ColorTypeFilter_16161616>;
            proc_2_2 = downsample_2_2<ColorTypeFilter_16161616>;
            proc_2_3 = downsample_2_3<ColorTypeFilter_16161616>;
            proc_3_1 = downsample_3_1<ColorTypeFilter_16161616>;
            proc_3_2 = downsample_3_2<ColorTypeFilter_16161616>;
            proc_3_3 = downsample_3_3<ColorTypeFilter_16161616>;
            break;
 
        case kUnknown_SkColorType:
        case kRGB_888x_SkColorType:     // TODO: use 8888?
        case kRGB_101010x_SkColorType:  // TODO: use 1010102?
        case kBGR_101010x_SkColorType:  // TODO: use 1010102?
        case kBGR_101010x_XR_SkColorType:  // TODO: use 1010102?
        case kBGRA_10101010_XR_SkColorType:
        case kRGBA_10x6_SkColorType:
        case kRGBA_F32_SkColorType:
            return nullptr;
 
        case kSRGBA_8888_SkColorType:  // TODO: needs careful handling
            return nullptr;
    }
 
    auto sampler = std::make_unique<HQDownSampler>();
    sampler->proc_1_2 = proc_1_2;
    sampler->proc_1_3 = proc_1_3;
    sampler->proc_2_1 = proc_2_1;
    sampler->proc_2_2 = proc_2_2;
    sampler->proc_2_3 = proc_2_3;
    sampler->proc_3_1 = proc_3_1;
    sampler->proc_3_2 = proc_3_2;
    sampler->proc_3_3 = proc_3_3;
    return sampler;
}

onDataChange()

void SkMipmap::onDataChange ( void *  oldData, void *  newData  )

inlineoverrideprotectedvirtual

Reimplemented from SkCachedData.

Definition at line 90 of file SkMipmap.h.

                                                             {
        fLevels = (Level*)newData; // could be nullptr
    }

validForRootLevel()

bool SkMipmap::validForRootLevel

(

const SkImageInfo &

root

)

const

Definition at line 242 of file SkMipmap.cpp.

                                                              {
    if (nullptr == fLevels) {
        return false;
    }
 
    const SkISize dimension = root.dimensions();
    if (dimension.width() <= 1 && dimension.height() <= 1) {
        return false;
    }
 
    if (fLevels[0].fPixmap. width() != std::max(1, dimension. width() >> 1) ||
        fLevels[0].fPixmap.height() != std::max(1, dimension.height() >> 1)) {
        return false;
    }
 
    for (int i = 0; i < this->countLevels(); ++i) {
        if (fLevels[i].fPixmap.colorType() != root.colorType() ||
            fLevels[i].fPixmap.alphaType() != root.alphaType()) {
            return false;
        }
    }
    return true;
}

---

The documentation for this class was generated from the following files:

• third_party/skia/src/core/SkMipmap.h
• third_party/skia/src/core/SkMipmap.cpp
• third_party/skia/src/core/SkMipmapHQDownSampler.cpp