SkYUVAPixmaps Class Reference

#include <SkYUVAPixmaps.h>

Public Types
using	DataType = SkYUVAPixmapInfo::DataType

Public Member Functions
	SkYUVAPixmaps ()=default
	~SkYUVAPixmaps ()=default
	SkYUVAPixmaps (SkYUVAPixmaps &&that)=default
SkYUVAPixmaps &	operator= (SkYUVAPixmaps &&that)=default
	SkYUVAPixmaps (const SkYUVAPixmaps &)=default
SkYUVAPixmaps &	operator= (const SkYUVAPixmaps &that)=default
bool	isValid () const
const SkYUVAInfo &	yuvaInfo () const
DataType	dataType () const
SkYUVAPixmapInfo	pixmapsInfo () const
int	numPlanes () const
const std::array< SkPixmap, kMaxPlanes > &	planes () const
const SkPixmap &	plane (int i) const
SkYUVAInfo::YUVALocations	toYUVALocations () const
bool	ownsStorage () const

Static Public Member Functions
static SkColorType	RecommendedRGBAColorType (DataType)
static SkYUVAPixmaps	Allocate (const SkYUVAPixmapInfo &yuvaPixmapInfo)
static SkYUVAPixmaps	FromData (const SkYUVAPixmapInfo &, sk_sp< SkData >)
static SkYUVAPixmaps	MakeCopy (const SkYUVAPixmaps &src)
static SkYUVAPixmaps	FromExternalMemory (const SkYUVAPixmapInfo &, void *memory)
static SkYUVAPixmaps	FromExternalPixmaps (const SkYUVAInfo &, const SkPixmap[kMaxPlanes])

Static Public Attributes
static constexpr auto	kMaxPlanes = SkYUVAPixmapInfo::kMaxPlanes

Detailed Description

Helper to store SkPixmap planes as described by a SkYUVAPixmapInfo. Can be responsible for allocating/freeing memory for pixmaps or use external memory.

Definition at line 172 of file SkYUVAPixmaps.h.

Member Typedef Documentation

DataType

using SkYUVAPixmaps::DataType = SkYUVAPixmapInfo::DataType

Definition at line 174 of file SkYUVAPixmaps.h.

Constructor & Destructor Documentation

SkYUVAPixmaps() [1/3]

SkYUVAPixmaps::SkYUVAPixmaps ( )

default

Default SkYUVAPixmaps is invalid.

~SkYUVAPixmaps()

SkYUVAPixmaps::~SkYUVAPixmaps ( )

default

SkYUVAPixmaps() [2/3]

SkYUVAPixmaps::SkYUVAPixmaps ( SkYUVAPixmaps &&  that )

default

SkYUVAPixmaps() [3/3]

SkYUVAPixmaps::SkYUVAPixmaps ( const SkYUVAPixmaps &  )

default

Member Function Documentation

Allocate()

SkYUVAPixmaps SkYUVAPixmaps::Allocate ( const SkYUVAPixmapInfo &  yuvaPixmapInfo )

static

Allocate space for pixmaps' pixels in the SkYUVAPixmaps.

Definition at line 169 of file SkYUVAPixmaps.cpp.

                                                                            {
    if (!yuvaPixmapInfo.isValid()) {
        return {};
    }
    return SkYUVAPixmaps(yuvaPixmapInfo,
                         SkData::MakeUninitialized(yuvaPixmapInfo.computeTotalBytes()));
}

dataType()

DataType SkYUVAPixmaps::dataType ( ) const

inline

Definition at line 223 of file SkYUVAPixmaps.h.

{ return fDataType; }

FromData()

SkYUVAPixmaps SkYUVAPixmaps::FromData ( const SkYUVAPixmapInfo &  yuvaPixmapInfo, sk_sp< SkData >  data  )

static

Use storage in SkData as backing store for pixmaps' pixels. SkData is retained by the SkYUVAPixmaps.

Definition at line 177 of file SkYUVAPixmaps.cpp.

                                                                                                {
    if (!yuvaPixmapInfo.isValid()) {
        return {};
    }
    if (yuvaPixmapInfo.computeTotalBytes() > data->size()) {
        return {};
    }
    return SkYUVAPixmaps(yuvaPixmapInfo, std::move(data));
}

FromExternalMemory()

SkYUVAPixmaps SkYUVAPixmaps::FromExternalMemory ( const SkYUVAPixmapInfo &  yuvaPixmapInfo, void *  memory  )

static

Use passed in memory as backing store for pixmaps' pixels. Caller must ensure memory remains allocated while pixmaps are in use. There must be at least SkYUVAPixmapInfo::computeTotalBytes() allocated starting at memory.

Definition at line 208 of file SkYUVAPixmaps.cpp.

                                                              {
    if (!yuvaPixmapInfo.isValid()) {
        return {};
    }
    SkPixmap pixmaps[kMaxPlanes];
    yuvaPixmapInfo.initPixmapsFromSingleAllocation(memory, pixmaps);
    return SkYUVAPixmaps(yuvaPixmapInfo.yuvaInfo(), yuvaPixmapInfo.dataType(), pixmaps);
}

FromExternalPixmaps()

SkYUVAPixmaps SkYUVAPixmaps::FromExternalPixmaps ( const SkYUVAInfo &  yuvaInfo, const SkPixmap  pixmaps[kMaxPlanes]  )

static

Wraps existing SkPixmaps. The SkYUVAPixmaps will have no ownership of the SkPixmaps' pixel memory so the caller must ensure it remains valid. Will return an invalid SkYUVAPixmaps if the SkYUVAInfo isn't compatible with the SkPixmap array (number of planes, plane dimensions, sufficient color channels in planes, ...).

Definition at line 218 of file SkYUVAPixmaps.cpp.

                                                                                     {
    SkColorType colorTypes[kMaxPlanes] = {};
    size_t rowBytes[kMaxPlanes] = {};
    int numPlanes = yuvaInfo.numPlanes();
    for (int i = 0; i < numPlanes; ++i) {
        colorTypes[i] = pixmaps[i].colorType();
        rowBytes[i] = pixmaps[i].rowBytes();
    }
    SkYUVAPixmapInfo yuvaPixmapInfo(yuvaInfo, colorTypes, rowBytes);
    if (!yuvaPixmapInfo.isValid()) {
        return {};
    }
    return SkYUVAPixmaps(yuvaInfo, yuvaPixmapInfo.dataType(), pixmaps);
}

isValid()

bool SkYUVAPixmaps::isValid ( ) const

inline

Does have initialized pixmaps compatible with its SkYUVAInfo.

Definition at line 219 of file SkYUVAPixmaps.h.

{ return !fYUVAInfo.dimensions().isEmpty(); }

MakeCopy()

SkYUVAPixmaps SkYUVAPixmaps::MakeCopy ( const SkYUVAPixmaps &  src )

static

Makes a deep copy of the src SkYUVAPixmaps. The returned SkYUVAPixmaps owns its planes' backing stores.

Definition at line 187 of file SkYUVAPixmaps.cpp.

                                                              {
    if (!src.isValid()) {
        return {};
    }
    SkYUVAPixmaps result = Allocate(src.pixmapsInfo());
    int n = result.numPlanes();
    for (int i = 0; i < n; ++i) {
        // We use SkRectMemCpy rather than readPixels to ensure that we don't do any alpha type
        // conversion.
        const SkPixmap& s = src.plane(i);
        const SkPixmap& d = result.plane(i);
        SkRectMemcpy(d.writable_addr(),
                     d.rowBytes(),
                     s.addr(),
                     s.rowBytes(),
                     s.info().minRowBytes(),
                     s.height());
    }
    return result;
}

numPlanes()

int SkYUVAPixmaps::numPlanes ( ) const

inline

Number of pixmap planes or 0 if this SkYUVAPixmaps is invalid.

Definition at line 228 of file SkYUVAPixmaps.h.

{ return this->isValid() ? fYUVAInfo.numPlanes() : 0; }

operator=() [1/2]

SkYUVAPixmaps & SkYUVAPixmaps::operator= ( const SkYUVAPixmaps &  that )

default

operator=() [2/2]

SkYUVAPixmaps & SkYUVAPixmaps::operator= ( SkYUVAPixmaps &&  that )

default

ownsStorage()

bool SkYUVAPixmaps::ownsStorage ( ) const

inline

Does this SkPixmaps own the backing store of the planes?

Definition at line 249 of file SkYUVAPixmaps.h.

{ return SkToBool(fData); }

pixmapsInfo()

SkYUVAPixmapInfo SkYUVAPixmaps::pixmapsInfo

(

)

const

Definition at line 251 of file SkYUVAPixmaps.cpp.

                                                  {
    if (!this->isValid()) {
        return {};
    }
    SkColorType colorTypes[kMaxPlanes] = {};
    size_t rowBytes[kMaxPlanes] = {};
    int numPlanes = this->numPlanes();
    for (int i = 0; i < numPlanes; ++i) {
        colorTypes[i] = fPlanes[i].colorType();
        rowBytes[i] = fPlanes[i].rowBytes();
    }
    return {fYUVAInfo, colorTypes, rowBytes};
}

plane()

const SkPixmap & SkYUVAPixmaps::plane ( int  i ) const

inline

Get the ith SkPixmap plane. SkPixmap will be default initialized if i >= numPlanes or this SkYUVAPixmaps is invalid.

Definition at line 240 of file SkYUVAPixmaps.h.

{ return fPlanes[SkToSizeT(i)]; }

planes()

const std::array< SkPixmap, kMaxPlanes > & SkYUVAPixmaps::planes ( ) const

inline

Access the SkPixmap planes. They are default initialized if this is not a valid SkYUVAPixmaps.

Definition at line 234 of file SkYUVAPixmaps.h.

{ return fPlanes; }

RecommendedRGBAColorType()

SkColorType SkYUVAPixmaps::RecommendedRGBAColorType ( DataType  dataType )

static

Definition at line 157 of file SkYUVAPixmaps.cpp.

                                                                     {
    switch (dataType) {
        case DataType::kUnorm8:         return kRGBA_8888_SkColorType;
        // F16 has better GPU support than 16 bit unorm. Often "16" bit unorm values are actually
        // lower precision.
        case DataType::kUnorm16:        return kRGBA_F16_SkColorType;
        case DataType::kFloat16:        return kRGBA_F16_SkColorType;
        case DataType::kUnorm10_Unorm2: return kRGBA_1010102_SkColorType;
    }
    SkUNREACHABLE;
}

toYUVALocations()

SkYUVAInfo::YUVALocations SkYUVAPixmaps::toYUVALocations

(

)

const

Computes a YUVALocations representation of the planar layout. The result is guaranteed to be valid if this->isValid().

Definition at line 265 of file SkYUVAPixmaps.cpp.

                                                             {
    uint32_t channelFlags[] = {SkColorTypeChannelFlags(fPlanes[0].colorType()),
                               SkColorTypeChannelFlags(fPlanes[1].colorType()),
                               SkColorTypeChannelFlags(fPlanes[2].colorType()),
                               SkColorTypeChannelFlags(fPlanes[3].colorType())};
    auto result = fYUVAInfo.toYUVALocations(channelFlags);
    SkDEBUGCODE(int numPlanes;)
    SkASSERT(SkYUVAInfo::YUVALocation::AreValidLocations(result, &numPlanes));
    SkASSERT(numPlanes == this->numPlanes());
    return result;
}

yuvaInfo()

const SkYUVAInfo & SkYUVAPixmaps::yuvaInfo ( ) const

inline

Definition at line 221 of file SkYUVAPixmaps.h.

{ return fYUVAInfo; }

Member Data Documentation

kMaxPlanes

constexpr auto SkYUVAPixmaps::kMaxPlanes = SkYUVAPixmapInfo::kMaxPlanes

staticconstexpr

Definition at line 175 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