SkYUVAPixmapInfo Class Reference

#include <SkYUVAPixmaps.h>

Classes
class	SupportedDataTypes

Public Types
enum class	DataType {   kUnorm8 , kUnorm16 , kFloat16 , kUnorm10_Unorm2 ,   kLast = kUnorm10_Unorm2 }
using	PlaneConfig = SkYUVAInfo::PlaneConfig
using	Subsampling = SkYUVAInfo::Subsampling

Public Member Functions
	SkYUVAPixmapInfo ()=default
	SkYUVAPixmapInfo (const SkYUVAInfo &, const SkColorType[kMaxPlanes], const size_t rowBytes[kMaxPlanes])
	SkYUVAPixmapInfo (const SkYUVAInfo &, DataType, const size_t rowBytes[kMaxPlanes])
	SkYUVAPixmapInfo (const SkYUVAPixmapInfo &)=default
SkYUVAPixmapInfo &	operator= (const SkYUVAPixmapInfo &)=default
bool	operator== (const SkYUVAPixmapInfo &) const
bool	operator!= (const SkYUVAPixmapInfo &that) const
const SkYUVAInfo &	yuvaInfo () const
SkYUVColorSpace	yuvColorSpace () const
int	numPlanes () const
DataType	dataType () const
size_t	rowBytes (int i) const
const SkImageInfo &	planeInfo (int i) const
size_t	computeTotalBytes (size_t planeSizes[kMaxPlanes]=nullptr) const
bool	initPixmapsFromSingleAllocation (void *memory, SkPixmap pixmaps[kMaxPlanes]) const
bool	isValid () const
bool	isSupported (const SupportedDataTypes &) const

Static Public Member Functions
static constexpr SkColorType	DefaultColorTypeForDataType (DataType dataType, int numChannels)
static std::tuple< int, DataType >	NumChannelsAndDataType (SkColorType)

Static Public Attributes
static constexpr auto	kMaxPlanes = SkYUVAInfo::kMaxPlanes
static constexpr int	kDataTypeCnt = static_cast<int>(DataType::kLast) + 1

Detailed Description

SkYUVAInfo combined with per-plane SkColorTypes and row bytes. Fully specifies the SkPixmaps for a YUVA image without the actual pixel memory and data.

Definition at line 30 of file SkYUVAPixmaps.h.

Member Typedef Documentation

PlaneConfig

using SkYUVAPixmapInfo::PlaneConfig = SkYUVAInfo::PlaneConfig

Definition at line 34 of file SkYUVAPixmaps.h.

Subsampling

using SkYUVAPixmapInfo::Subsampling = SkYUVAInfo::Subsampling

Definition at line 35 of file SkYUVAPixmaps.h.

Member Enumeration Documentation

DataType

enum class SkYUVAPixmapInfo::DataType

strong

Data type for Y, U, V, and possibly A channels independent of how values are packed into planes.

Enumerator
kUnorm8	8 bit unsigned normalized
kUnorm16	16 bit unsigned normalized
kFloat16	16 bit (half) floating point
kUnorm10_Unorm2	10 bit unorm for Y, U, and V. 2 bit unorm for alpha (if present).
kLast

Definition at line 41 of file SkYUVAPixmaps.h.

                        {
        kUnorm8,          ///< 8 bit unsigned normalized
        kUnorm16,         ///< 16 bit unsigned normalized
        kFloat16,         ///< 16 bit (half) floating point
        kUnorm10_Unorm2,  ///< 10 bit unorm for Y, U, and V. 2 bit unorm for alpha (if present).
 
        kLast = kUnorm10_Unorm2
    };

Constructor & Destructor Documentation

SkYUVAPixmapInfo() [1/4]

SkYUVAPixmapInfo::SkYUVAPixmapInfo ( )

default

Default SkYUVAPixmapInfo is invalid.

SkYUVAPixmapInfo() [2/4]

SkYUVAPixmapInfo::SkYUVAPixmapInfo	(	const SkYUVAInfo &	yuvaInfo,
		const SkColorType	colorTypes[kMaxPlanes],
		const size_t	rowBytes[kMaxPlanes]
	)

Initializes the SkYUVAPixmapInfo from a SkYUVAInfo with per-plane color types and row bytes. This will be invalid if the colorTypes aren't compatible with the SkYUVAInfo or if a rowBytes entry is not valid for the plane dimensions and color type. Color type and row byte values beyond the number of planes in SkYUVAInfo are ignored. All SkColorTypes must have the same DataType or this will be invalid.

If rowBytes is nullptr then bpp*width is assumed for each plane.

Definition at line 56 of file SkYUVAPixmaps.cpp.

        : fYUVAInfo(yuvaInfo) {
    if (!yuvaInfo.isValid()) {
        *this = {};
        SkASSERT(!this->isValid());
        return;
    }
    SkISize planeDimensions[4];
    int n = yuvaInfo.planeDimensions(planeDimensions);
    size_t tempRowBytes[kMaxPlanes];
    if (!rowBytes) {
        for (int i = 0; i < n; ++i) {
            tempRowBytes[i] = SkColorTypeBytesPerPixel(colorTypes[i]) * planeDimensions[i].width();
        }
        rowBytes = tempRowBytes;
    }
    bool ok = true;
    for (size_t i = 0; i < static_cast<size_t>(n); ++i) {
        fRowBytes[i] = rowBytes[i];
        // Use kUnpremul so that we never multiply alpha when copying data in.
        fPlaneInfos[i] = SkImageInfo::Make(planeDimensions[i],
                                           colorTypes[i],
                                           kUnpremul_SkAlphaType);
        int numRequiredChannels = yuvaInfo.numChannelsInPlane(i);
        SkASSERT(numRequiredChannels > 0);
        auto [numColorTypeChannels, colorTypeDataType] = NumChannelsAndDataType(colorTypes[i]);
        ok &= i == 0 || colorTypeDataType == fDataType;
        ok &= numColorTypeChannels >= numRequiredChannels;
        ok &= fPlaneInfos[i].validRowBytes(fRowBytes[i]);
        fDataType = colorTypeDataType;
    }
    if (!ok) {
        *this = {};
        SkASSERT(!this->isValid());
    } else {
        SkASSERT(this->isValid());
    }
}

SkYUVAPixmapInfo() [3/4]

SkYUVAPixmapInfo::SkYUVAPixmapInfo	(	const SkYUVAInfo &	yuvaInfo,
		DataType	dataType,
		const size_t	rowBytes[kMaxPlanes]
	)

Like above but uses DefaultColorTypeForDataType to determine each plane's SkColorType. If rowBytes is nullptr then bpp*width is assumed for each plane.

Definition at line 97 of file SkYUVAPixmaps.cpp.

                                                                      {
    SkColorType colorTypes[kMaxPlanes] = {};
    int numPlanes = yuvaInfo.numPlanes();
    for (int i = 0; i < numPlanes; ++i) {
        int numChannels = yuvaInfo.numChannelsInPlane(i);
        colorTypes[i] = DefaultColorTypeForDataType(dataType, numChannels);
    }
    *this = SkYUVAPixmapInfo(yuvaInfo, colorTypes, rowBytes);
}

SkYUVAPixmapInfo() [4/4]

SkYUVAPixmapInfo::SkYUVAPixmapInfo ( const SkYUVAPixmapInfo &  )

default

Member Function Documentation

computeTotalBytes()

size_t SkYUVAPixmapInfo::computeTotalBytes

(

size_t

planeSizes[kMaxPlanes] = nullptr

)

const

Determine size to allocate for all planes. Optionally retrieves the per-plane sizes in planeSizes if not null. If total size overflows will return SIZE_MAX and set all planeSizes to SIZE_MAX. Returns 0 and fills planesSizes with 0 if this SkYUVAPixmapInfo is not valid.

Definition at line 117 of file SkYUVAPixmaps.cpp.

                                                                              {
    if (!this->isValid()) {
        if (planeSizes) {
            std::fill_n(planeSizes, kMaxPlanes, 0);
        }
        return 0;
    }
    return fYUVAInfo.computeTotalBytes(fRowBytes.data(), planeSizes);
}

dataType()

DataType SkYUVAPixmapInfo::dataType ( ) const

inline

The per-YUV[A] channel data type.

Definition at line 126 of file SkYUVAPixmaps.h.

{ return fDataType; }

DefaultColorTypeForDataType()

constexpr SkColorType SkYUVAPixmapInfo::DefaultColorTypeForDataType ( DataType  dataType, int  numChannels  )

staticconstexpr

Gets the default SkColorType to use with numChannels channels, each represented as DataType. Returns kUnknown_SkColorType if no such color type.

Definition at line 293 of file SkYUVAPixmaps.h.

                                                                                     {
    switch (numChannels) {
        case 1:
            switch (dataType) {
                case DataType::kUnorm8:         return kGray_8_SkColorType;
                case DataType::kUnorm16:        return kA16_unorm_SkColorType;
                case DataType::kFloat16:        return kA16_float_SkColorType;
                case DataType::kUnorm10_Unorm2: return kUnknown_SkColorType;
            }
            break;
        case 2:
            switch (dataType) {
                case DataType::kUnorm8:         return kR8G8_unorm_SkColorType;
                case DataType::kUnorm16:        return kR16G16_unorm_SkColorType;
                case DataType::kFloat16:        return kR16G16_float_SkColorType;
                case DataType::kUnorm10_Unorm2: return kUnknown_SkColorType;
            }
            break;
        case 3:
            // None of these are tightly packed. The intended use case is for interleaved YUVA
            // planes where we're forcing opaqueness by ignoring the alpha values.
            // There are "x" rather than "A" variants for Unorm8 and Unorm10_Unorm2 but we don't
            // choose them because 1) there is no inherent advantage and 2) there is better support
            // in the GPU backend for the "A" versions.
            switch (dataType) {
                case DataType::kUnorm8:         return kRGBA_8888_SkColorType;
                case DataType::kUnorm16:        return kR16G16B16A16_unorm_SkColorType;
                case DataType::kFloat16:        return kRGBA_F16_SkColorType;
                case DataType::kUnorm10_Unorm2: return kRGBA_1010102_SkColorType;
            }
            break;
        case 4:
            switch (dataType) {
                case DataType::kUnorm8:         return kRGBA_8888_SkColorType;
                case DataType::kUnorm16:        return kR16G16B16A16_unorm_SkColorType;
                case DataType::kFloat16:        return kRGBA_F16_SkColorType;
                case DataType::kUnorm10_Unorm2: return kRGBA_1010102_SkColorType;
            }
            break;
    }
    return kUnknown_SkColorType;
}

initPixmapsFromSingleAllocation()

bool SkYUVAPixmapInfo::initPixmapsFromSingleAllocation	(	void *	memory,
		SkPixmap	pixmaps[kMaxPlanes]
	)		const

Takes an allocation that is assumed to be at least computeTotalBytes() in size and configures the first numPlanes() entries in pixmaps array to point into that memory. The remaining entries of pixmaps are default initialized. Fails if this SkYUVAPixmapInfo not valid.

Definition at line 127 of file SkYUVAPixmaps.cpp.

                                                                                           {
    if (!this->isValid()) {
        return false;
    }
    SkASSERT(pixmaps);
    char* addr = static_cast<char*>(memory);
    int n = this->numPlanes();
    for (int i = 0; i < n; ++i) {
        SkASSERT(fPlaneInfos[i].validRowBytes(fRowBytes[i]));
        pixmaps[i].reset(fPlaneInfos[i], addr, fRowBytes[i]);
        size_t planeSize = pixmaps[i].rowBytes()*pixmaps[i].height();
        SkASSERT(planeSize);
        addr += planeSize;
    }
    for (int i = n; i < kMaxPlanes; ++i) {
        pixmaps[i] = {};
    }
    return true;
}

isSupported()

bool SkYUVAPixmapInfo::isSupported

(

const SupportedDataTypes &

supportedDataTypes

)

const

Is this valid and does it use color types allowed by the passed SupportedDataTypes?

Definition at line 148 of file SkYUVAPixmaps.cpp.

                                                                                     {
    if (!this->isValid()) {
        return false;
    }
    return supportedDataTypes.supported(fYUVAInfo.planeConfig(), fDataType);
}

isValid()

bool SkYUVAPixmapInfo::isValid ( ) const

inline

Returns true if this has been configured with a non-empty dimensioned SkYUVAInfo with compatible color types and row bytes.

Definition at line 155 of file SkYUVAPixmaps.h.

{ return fYUVAInfo.isValid(); }

NumChannelsAndDataType()

std::tuple< int, SkYUVAPixmapInfo::DataType > SkYUVAPixmapInfo::NumChannelsAndDataType ( SkColorType  ct )

static

If the SkColorType is supported for YUVA pixmaps this will return the number of YUVA channels that can be stored in a plane of this color type and what the DataType is of those channels. If the SkColorType is not supported as a YUVA plane the number of channels is reported as 0 and the DataType returned should be ignored.

Definition at line 29 of file SkYUVAPixmaps.cpp.

                        {
    // We could allow BGR[A] color types, but then we'd have to decide whether B should be the 0th
    // or 2nd channel. Our docs currently say channel order is always R=0, G=1, B=2[, A=3].
    switch (ct) {
        case kAlpha_8_SkColorType:
        case kGray_8_SkColorType:    return {1, DataType::kUnorm8 };
        case kA16_unorm_SkColorType: return {1, DataType::kUnorm16};
        case kA16_float_SkColorType: return {1, DataType::kFloat16};
 
        case kR8G8_unorm_SkColorType:   return {2, DataType::kUnorm8  };
        case kR16G16_unorm_SkColorType: return {2, DataType::kUnorm16 };
        case kR16G16_float_SkColorType: return {2, DataType::kFloat16 };
 
        case kRGB_888x_SkColorType:    return {3, DataType::kUnorm8          };
        case kRGB_101010x_SkColorType: return {3, DataType::kUnorm10_Unorm2  };
 
        case kRGBA_8888_SkColorType:          return {4, DataType::kUnorm8  };
        case kR16G16B16A16_unorm_SkColorType: return {4, DataType::kUnorm16 };
        case kRGBA_F16_SkColorType:           return {4, DataType::kFloat16 };
        case kRGBA_F16Norm_SkColorType:       return {4, DataType::kFloat16 };
        case kRGBA_1010102_SkColorType:       return {4, DataType::kUnorm10_Unorm2 };
 
        default: return {0, DataType::kUnorm8 };
    }
}

numPlanes()

int SkYUVAPixmapInfo::numPlanes ( ) const

inline

The number of SkPixmap planes, 0 if this SkYUVAPixmapInfo is invalid.

Definition at line 123 of file SkYUVAPixmaps.h.

{ return fYUVAInfo.numPlanes(); }

operator!=()

bool SkYUVAPixmapInfo::operator!= ( const SkYUVAPixmapInfo &  that ) const

inline

Definition at line 116 of file SkYUVAPixmaps.h.

{ return !(*this == that); }

operator=()

SkYUVAPixmapInfo & SkYUVAPixmapInfo::operator= ( const SkYUVAPixmapInfo &  )

default

operator==()

bool SkYUVAPixmapInfo::operator==

(

const SkYUVAPixmapInfo &

that

)

const

Definition at line 109 of file SkYUVAPixmaps.cpp.

                                                                    {
    bool result = fYUVAInfo   == that.fYUVAInfo   &&
                  fPlaneInfos == that.fPlaneInfos &&
                  fRowBytes   == that.fRowBytes;
    SkASSERT(!result || fDataType == that.fDataType);
    return result;
}

planeInfo()

const SkImageInfo & SkYUVAPixmapInfo::planeInfo ( int  i ) const

inline

Image info for the ith plane, or default SkImageInfo if i >= numPlanes()

Definition at line 135 of file SkYUVAPixmaps.h.

{ return fPlaneInfos[static_cast<size_t>(i)]; }

rowBytes()

size_t SkYUVAPixmapInfo::rowBytes ( int  i ) const

inline

Row bytes for the ith plane. Returns zero if i >= numPlanes() or this SkYUVAPixmapInfo is invalid.

Definition at line 132 of file SkYUVAPixmaps.h.

{ return fRowBytes[static_cast<size_t>(i)]; }

yuvaInfo()

const SkYUVAInfo & SkYUVAPixmapInfo::yuvaInfo ( ) const

inline

Definition at line 118 of file SkYUVAPixmaps.h.

{ return fYUVAInfo; }

yuvColorSpace()

SkYUVColorSpace SkYUVAPixmapInfo::yuvColorSpace ( ) const

inline

Definition at line 120 of file SkYUVAPixmaps.h.

{ return fYUVAInfo.yuvColorSpace(); }

Member Data Documentation

kDataTypeCnt

constexpr int SkYUVAPixmapInfo::kDataTypeCnt = static_cast<int>(DataType::kLast) + 1

staticconstexpr

Definition at line 49 of file SkYUVAPixmaps.h.

kMaxPlanes

constexpr auto SkYUVAPixmapInfo::kMaxPlanes = SkYUVAInfo::kMaxPlanes

staticconstexpr

Definition at line 32 of file SkYUVAPixmaps.h.

---

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

• third_party/skia/include/core/SkYUVAPixmaps.h
• third_party/skia/src/core/SkYUVAPixmaps.cpp