SkCompressedDataUtils.h File Reference

#include "include/core/SkRefCnt.h"
#include "include/core/SkTextureCompressionType.h"
#include "include/private/base/SkAssert.h"
#include "include/private/base/SkTArray.h"
#include <cstddef>

Go to the source code of this file.

Functions
static constexpr bool	SkTextureCompressionTypeIsOpaque (SkTextureCompressionType compression)
size_t	SkCompressedDataSize (SkTextureCompressionType, SkISize baseDimensions, skia_private::TArray< size_t > *individualMipOffsets, bool mipmapped)
size_t	SkCompressedBlockSize (SkTextureCompressionType type)
size_t	SkCompressedFormatDataSize (SkTextureCompressionType compressionType, SkISize dimensions, bool mipmapped)
bool	SkDecompress (sk_sp< SkData > data, SkISize dimensions, SkTextureCompressionType compressionType, SkBitmap *dst)

Function Documentation

SkCompressedBlockSize()

size_t SkCompressedBlockSize

(

SkTextureCompressionType

type

)

Definition at line 290 of file SkCompressedDataUtils.cpp.

                                                            {
    switch (type) {
        case SkTextureCompressionType::kNone:
            return 0;
        case SkTextureCompressionType::kETC2_RGB8_UNORM:
            return sizeof(ETC1Block);
        case SkTextureCompressionType::kBC1_RGB8_UNORM:
        case SkTextureCompressionType::kBC1_RGBA8_UNORM:
            return sizeof(BC1Block);
    }
    SkUNREACHABLE;
}

SkCompressedDataSize()

size_t SkCompressedDataSize	(	SkTextureCompressionType	type,
		SkISize	baseDimensions,
		skia_private::TArray< size_t > *	individualMipOffsets,
		bool	mipmapped
	)

Definition at line 254 of file SkCompressedDataUtils.cpp.

                                                                                  {
    SkASSERT(!individualMipOffsets || individualMipOffsets->empty());
 
    int numMipLevels = 1;
    if (mipmapped) {
        numMipLevels = SkMipmap::ComputeLevelCount(dimensions.width(), dimensions.height()) + 1;
    }
 
    size_t totalSize = 0;
    switch (type) {
        case SkTextureCompressionType::kNone:
            break;
        case SkTextureCompressionType::kETC2_RGB8_UNORM:
        case SkTextureCompressionType::kBC1_RGB8_UNORM:
        case SkTextureCompressionType::kBC1_RGBA8_UNORM: {
            for (int i = 0; i < numMipLevels; ++i) {
                int numBlocks = num_4x4_blocks(dimensions.width()) *
                                num_4x4_blocks(dimensions.height());
 
                if (individualMipOffsets) {
                    individualMipOffsets->push_back(totalSize);
                }
 
                static_assert(sizeof(ETC1Block) == sizeof(BC1Block));
                totalSize += numBlocks * sizeof(ETC1Block);
 
                dimensions = {std::max(1, dimensions.width()/2), std::max(1, dimensions.height()/2)};
            }
            break;
        }
    }
 
    return totalSize;
}

SkCompressedFormatDataSize()

size_t SkCompressedFormatDataSize	(	SkTextureCompressionType	compressionType,
		SkISize	dimensions,
		bool	mipmapped
	)

Returns the data size for the given SkTextureCompressionType

Definition at line 303 of file SkCompressedDataUtils.cpp.

                                                                      {
    return SkCompressedDataSize(compressionType, dimensions, nullptr, mipmapped);
}

SkDecompress()

bool SkDecompress	(	sk_sp< SkData >	data,
		SkISize	dimensions,
		SkTextureCompressionType	compressionType,
		SkBitmap *	dst
	)

Definition at line 237 of file SkCompressedDataUtils.cpp.

                                 {
    using Type = SkTextureCompressionType;
 
    const uint8_t* bytes = data->bytes();
    switch (compressionType) {
        case Type::kNone:            return false;
        case Type::kETC2_RGB8_UNORM: return decompress_etc1(dimensions, bytes, dst);
        case Type::kBC1_RGB8_UNORM:  return decompress_bc1(dimensions, bytes, true, dst);
        case Type::kBC1_RGBA8_UNORM: return decompress_bc1(dimensions, bytes, false, dst);
    }
 
    SkUNREACHABLE;
}

SkTextureCompressionTypeIsOpaque()

static constexpr bool SkTextureCompressionTypeIsOpaque ( SkTextureCompressionType  compression )

staticconstexpr

Definition at line 22 of file SkCompressedDataUtils.h.

                                                                                             {
    switch (compression) {
        case SkTextureCompressionType::kNone:            return true;
        case SkTextureCompressionType::kETC2_RGB8_UNORM: return true;
        case SkTextureCompressionType::kBC1_RGB8_UNORM:  return true;
        case SkTextureCompressionType::kBC1_RGBA8_UNORM: return false;
    }
 
    SkUNREACHABLE;
}