SkYUVAInfo Class Reference

#include <SkYUVAInfo.h>

Classes
struct	YUVALocation

Public Types
enum	YUVAChannels {   kY , kU , kV , kA ,   kLast = kA }
enum class	PlaneConfig {   kUnknown , kY_U_V , kY_V_U , kY_UV ,   kY_VU , kYUV , kUYV , kY_U_V_A ,   kY_V_U_A , kY_UV_A , kY_VU_A , kYUVA ,   kUYVA , kLast = kUYVA }
enum class	Subsampling {   kUnknown , k444 , k422 , k420 ,   k440 , k411 , k410 , kLast = k410 }
enum class	Siting { kCentered }
using	YUVALocations = std::array< YUVALocation, kYUVAChannelCount >

Public Member Functions
	SkYUVAInfo ()=default
	SkYUVAInfo (const SkYUVAInfo &)=default
	SkYUVAInfo (SkISize dimensions, PlaneConfig, Subsampling, SkYUVColorSpace, SkEncodedOrigin origin=kTopLeft_SkEncodedOrigin, Siting sitingX=Siting::kCentered, Siting sitingY=Siting::kCentered)
SkYUVAInfo &	operator= (const SkYUVAInfo &that)=default
PlaneConfig	planeConfig () const
Subsampling	subsampling () const
std::tuple< int, int >	planeSubsamplingFactors (int planeIdx) const
SkISize	dimensions () const
int	width () const
int	height () const
SkYUVColorSpace	yuvColorSpace () const
Siting	sitingX () const
Siting	sitingY () const
SkEncodedOrigin	origin () const
SkMatrix	originMatrix () const
bool	hasAlpha () const
int	planeDimensions (SkISize planeDimensions[kMaxPlanes]) const
size_t	computeTotalBytes (const size_t rowBytes[kMaxPlanes], size_t planeSizes[kMaxPlanes]=nullptr) const
int	numPlanes () const
int	numChannelsInPlane (int i) const
YUVALocations	toYUVALocations (const uint32_t *channelFlags) const
SkYUVAInfo	makeSubsampling (SkYUVAInfo::Subsampling) const
SkYUVAInfo	makeDimensions (SkISize) const
bool	operator== (const SkYUVAInfo &that) const
bool	operator!= (const SkYUVAInfo &that) const
bool	isValid () const

Static Public Member Functions
static std::tuple< int, int >	SubsamplingFactors (Subsampling)
static std::tuple< int, int >	PlaneSubsamplingFactors (PlaneConfig, Subsampling, int planeIdx)
static int	PlaneDimensions (SkISize imageDimensions, PlaneConfig, Subsampling, SkEncodedOrigin, SkISize planeDimensions[kMaxPlanes])
static constexpr int	NumPlanes (PlaneConfig)
static constexpr int	NumChannelsInPlane (PlaneConfig, int i)
static YUVALocations	GetYUVALocations (PlaneConfig, const uint32_t *planeChannelFlags)
static bool	HasAlpha (PlaneConfig)

Static Public Attributes
static constexpr int	kYUVAChannelCount = static_cast<int>(YUVAChannels::kLast + 1)
static constexpr int	kMaxPlanes = 4

Detailed Description

Specifies the structure of planes for a YUV image with optional alpha. The actual planar data is not part of this structure and depending on usage is in external textures or pixmaps.

Definition at line 26 of file SkYUVAInfo.h.

Member Typedef Documentation

YUVALocations

using SkYUVAInfo::YUVALocations = std::array<YUVALocation, kYUVAChannelCount>

Definition at line 32 of file SkYUVAInfo.h.

Member Enumeration Documentation

PlaneConfig

enum class SkYUVAInfo::PlaneConfig

strong

Specifies how YUV (and optionally A) are divided among planes. Planes are separated by underscores in the enum value names. Within each plane the pixmap/texture channels are mapped to the YUVA channels in the order specified, e.g. for kY_UV Y is in channel 0 of plane 0, U is in channel 0 of plane 1, and V is in channel 1 of plane 1. Channel ordering within a pixmap/texture given the channels it contains: A: 0:A Luminance/Gray: 0:Gray Luminance/Gray + Alpha: 0:Gray, 1:A RG 0:R, 1:G RGB 0:R, 1:G, 2:B RGBA 0:R, 1:G, 2:B, 3:A

Enumerator
kUnknown
kY_U_V	Plane 0: Y, Plane 1: U, Plane 2: V.
kY_V_U	Plane 0: Y, Plane 1: V, Plane 2: U.
kY_UV	Plane 0: Y, Plane 1: UV.
kY_VU	Plane 0: Y, Plane 1: VU.
kYUV	Plane 0: YUV.
kUYV	Plane 0: UYV.
kY_U_V_A	Plane 0: Y, Plane 1: U, Plane 2: V, Plane 3: A.
kY_V_U_A	Plane 0: Y, Plane 1: V, Plane 2: U, Plane 3: A.
kY_UV_A	Plane 0: Y, Plane 1: UV, Plane 2: A.
kY_VU_A	Plane 0: Y, Plane 1: VU, Plane 2: A.
kYUVA	Plane 0: YUVA.
kUYVA	Plane 0: UYVA.
kLast

Definition at line 47 of file SkYUVAInfo.h.

                           {
        kUnknown,
 
        kY_U_V,    ///< Plane 0: Y, Plane 1: U,  Plane 2: V
        kY_V_U,    ///< Plane 0: Y, Plane 1: V,  Plane 2: U
        kY_UV,     ///< Plane 0: Y, Plane 1: UV
        kY_VU,     ///< Plane 0: Y, Plane 1: VU
        kYUV,      ///< Plane 0: YUV
        kUYV,      ///< Plane 0: UYV
 
        kY_U_V_A,  ///< Plane 0: Y, Plane 1: U,  Plane 2: V, Plane 3: A
        kY_V_U_A,  ///< Plane 0: Y, Plane 1: V,  Plane 2: U, Plane 3: A
        kY_UV_A,   ///< Plane 0: Y, Plane 1: UV, Plane 2: A
        kY_VU_A,   ///< Plane 0: Y, Plane 1: VU, Plane 2: A
        kYUVA,     ///< Plane 0: YUVA
        kUYVA,     ///< Plane 0: UYVA
 
        kLast = kUYVA
    };

Siting

enum class SkYUVAInfo::Siting

strong

Describes how subsampled chroma values are sited relative to luma values.

Currently only centered siting is supported but will expand to support additional sitings.

Enumerator
kCentered	Subsampled chroma value is sited at the center of the block of corresponding luma values.

Definition at line 91 of file SkYUVAInfo.h.

                      {
        /**
         * Subsampled chroma value is sited at the center of the block of corresponding luma values.
         */
        kCentered,
    };

Subsampling

enum class SkYUVAInfo::Subsampling

strong

UV subsampling is also specified in the enum value names using J:a:b notation (e.g. 4:2:0 is 1/2 horizontal and 1/2 vertical resolution for U and V). If alpha is present it is not sub- sampled. Note that Subsampling values other than k444 are only valid with PlaneConfig values that have U and V in different planes than Y (and A, if present).

Enumerator
kUnknown
k444	No subsampling. UV values for each Y.
k422	1 set of UV values for each 2x1 block of Y values.
k420	1 set of UV values for each 2x2 block of Y values.
k440	1 set of UV values for each 1x2 block of Y values.
k411	1 set of UV values for each 4x1 block of Y values.
k410	1 set of UV values for each 4x2 block of Y values.
kLast

Definition at line 73 of file SkYUVAInfo.h.

                           {
        kUnknown,
 
        k444,    ///< No subsampling. UV values for each Y.
        k422,    ///< 1 set of UV values for each 2x1 block of Y values.
        k420,    ///< 1 set of UV values for each 2x2 block of Y values.
        k440,    ///< 1 set of UV values for each 1x2 block of Y values.
        k411,    ///< 1 set of UV values for each 4x1 block of Y values.
        k410,    ///< 1 set of UV values for each 4x2 block of Y values.
 
        kLast = k410
    };

YUVAChannels

enum SkYUVAInfo::YUVAChannels

Enumerator
kY
kU
kV
kA
kLast

Definition at line 28 of file SkYUVAInfo.h.

{ kY, kU, kV, kA, kLast = kA };

Constructor & Destructor Documentation

SkYUVAInfo() [1/3]

SkYUVAInfo::SkYUVAInfo ( )

default

SkYUVAInfo() [2/3]

SkYUVAInfo::SkYUVAInfo ( const SkYUVAInfo &  )

default

SkYUVAInfo() [3/3]

SkYUVAInfo::SkYUVAInfo	(	SkISize	dimensions,
		PlaneConfig	planeConfig,
		Subsampling	subsampling,
		SkYUVColorSpace	yuvColorSpace,
		SkEncodedOrigin	origin = kTopLeft_SkEncodedOrigin,
		Siting	sitingX = Siting::kCentered,
		Siting	sitingY = Siting::kCentered
	)

'dimensions' should specify the size of the full resolution image (after planes have been oriented to how the image is displayed as indicated by 'origin').

Definition at line 302 of file SkYUVAInfo.cpp.

        : fDimensions(dimensions)
        , fPlaneConfig(planeConfig)
        , fSubsampling(subsampling)
        , fYUVColorSpace(yuvColorSpace)
        , fOrigin(origin)
        , fSitingX(sitingX)
        , fSitingY(sitingY) {
    if (fDimensions.isEmpty() ||
        !is_plane_config_compatible_with_subsampling(planeConfig, subsampling)) {
        *this = {};
        SkASSERT(!this->isValid());
        return;
    }
    SkASSERT(this->isValid());
}

Member Function Documentation

computeTotalBytes()

size_t SkYUVAInfo::computeTotalBytes	(	const size_t	rowBytes[kMaxPlanes],
		size_t	planeSizes[kMaxPlanes] = nullptr
	)		const

Given a per-plane row bytes, determine size to allocate for all planes. Optionally retrieves the per-plane byte sizes in planeSizes if not null. If total size overflows will return SIZE_MAX and set all planeSizes to SIZE_MAX.

Definition at line 325 of file SkYUVAInfo.cpp.

                                                                          {
    if (!this->isValid()) {
        return 0;
    }
    SkSafeMath safe;
    size_t totalBytes = 0;
    SkISize planeDimensions[kMaxPlanes];
    int n = this->planeDimensions(planeDimensions);
    for (int i = 0; i < n; ++i) {
        SkASSERT(!planeDimensions[i].isEmpty());
        SkASSERT(rowBytes[i]);
        size_t size = safe.mul(rowBytes[i], planeDimensions[i].height());
        if (planeSizes) {
            planeSizes[i] = size;
        }
        totalBytes = safe.add(totalBytes, size);
    }
    if (planeSizes) {
        if (safe.ok()) {
            for (int i = n; i < kMaxPlanes; ++i) {
                planeSizes[i] = 0;
            }
        } else {
            for (int i = 0; n < kMaxPlanes; ++i) {
                planeSizes[i] = SIZE_MAX;
            }
        }
    }
 
    return safe.ok() ? totalBytes : SIZE_MAX;
}

dimensions()

SkISize SkYUVAInfo::dimensions ( ) const

inline

Dimensions of the full resolution image (after planes have been oriented to how the image is displayed as indicated by fOrigin).

Definition at line 171 of file SkYUVAInfo.h.

{ return fDimensions; }

GetYUVALocations()

SkYUVAInfo::YUVALocations SkYUVAInfo::GetYUVALocations ( PlaneConfig  config, const uint32_t *  planeChannelFlags  )

static

Given a PlaneConfig and a set of channel flags for each plane, convert to YUVALocations representation. Fails if channel flags aren't valid for the PlaneConfig (i.e. don't have enough channels in a plane) by returning an invalid set of locations (plane indices are -1).

Definition at line 191 of file SkYUVAInfo.cpp.

                                                                                          {
    // Like YUVALocation but chanIdx refers to channels by index rather than absolute channel, e.g.
    // A is the 0th channel of an alpha-only texture. We'll use this plus planeChannelFlags to get
    // the actual channel.
    struct PlaneAndIndex {int plane, chanIdx;};
    const PlaneAndIndex* planesAndIndices = nullptr;
    switch (config) {
        case PlaneConfig::kUnknown:
            return {};
 
        case PlaneConfig::kY_U_V: {
            static constexpr PlaneAndIndex kPlanesAndIndices[] = {{0, 0}, {1, 0}, {2, 0}, {-1, -1}};
            planesAndIndices = kPlanesAndIndices;
            break;
        }
        case PlaneConfig::kY_V_U: {
            static constexpr PlaneAndIndex kPlanesAndIndices[] = {{0, 0}, {2, 0}, {1, 0}, {-1, -1}};
            planesAndIndices = kPlanesAndIndices;
            break;
        }
        case PlaneConfig::kY_UV: {
            static constexpr PlaneAndIndex kPlanesAndIndices[] = {{0, 0}, {1, 0}, {1, 1}, {-1, -1}};
            planesAndIndices = kPlanesAndIndices;
            break;
        }
        case PlaneConfig::kY_VU: {
            static constexpr PlaneAndIndex kPlanesAndIndices[] = {{0, 0}, {1, 1}, {1, 0}, {-1, -1}};
            planesAndIndices = kPlanesAndIndices;
            break;
        }
        case PlaneConfig::kYUV: {
            static constexpr PlaneAndIndex kPlanesAndIndices[] = {{0, 0}, {0, 1}, {0, 2}, {-1, -1}};
            planesAndIndices = kPlanesAndIndices;
            break;
        }
        case PlaneConfig::kUYV: {
            static constexpr PlaneAndIndex kPlanesAndIndices[] = {{0, 1}, {0, 0}, {0, 2}, {-1, -1}};
            planesAndIndices = kPlanesAndIndices;
            break;
        }
        case PlaneConfig::kY_U_V_A: {
            static constexpr PlaneAndIndex kPlanesAndIndices[] = {{0, 0}, {1, 0}, {2, 0}, {3, 0}};
            planesAndIndices = kPlanesAndIndices;
            break;
        }
        case PlaneConfig::kY_V_U_A: {
            static constexpr PlaneAndIndex kPlanesAndIndices[] = {{0, 0}, {2, 0}, {1, 0}, {3, 0}};
            planesAndIndices = kPlanesAndIndices;
            break;
        }
        case PlaneConfig::kY_UV_A: {
            static constexpr PlaneAndIndex kPlanesAndIndices[] = {{0, 0}, {1, 0}, {1, 1}, {2, 0}};
            planesAndIndices = kPlanesAndIndices;
            break;
        }
        case PlaneConfig::kY_VU_A: {
            static constexpr PlaneAndIndex kPlanesAndIndices[] = {{0, 0}, {1, 1}, {1, 0}, {2, 0}};
            planesAndIndices = kPlanesAndIndices;
            break;
        }
        case PlaneConfig::kYUVA: {
            static constexpr PlaneAndIndex kPlanesAndIndices[] = {{0, 0}, {0, 1}, {0, 2}, {0, 3}};
            planesAndIndices = kPlanesAndIndices;
            break;
        }
        case PlaneConfig::kUYVA: {
            static constexpr PlaneAndIndex kPlanesAndIndices[] = {{0, 1}, {0, 0}, {0, 2}, {0, 3}};
            planesAndIndices = kPlanesAndIndices;
            break;
        }
    }
    SkASSERT(planesAndIndices);
    YUVALocations yuvaLocations;
    for (int i = 0; i < SkYUVAInfo::kYUVAChannelCount; ++i) {
        auto [plane, chanIdx] = planesAndIndices[i];
        SkColorChannel channel;
        if (plane >= 0) {
            if (!channel_index_to_channel(planeChannelFlags[plane], chanIdx, &channel)) {
                return {};
            }
            yuvaLocations[i] = {plane, channel};
        } else {
            SkASSERT(i == 3);
            yuvaLocations[i] = {-1, SkColorChannel::kR};
        }
    }
    return yuvaLocations;
}

hasAlpha()

bool SkYUVAInfo::hasAlpha ( ) const

inline

Definition at line 185 of file SkYUVAInfo.h.

{ return HasAlpha(fPlaneConfig); }

HasAlpha()

bool SkYUVAInfo::HasAlpha ( PlaneConfig  planeConfig )

static

Does the PlaneConfig have alpha values?

Definition at line 281 of file SkYUVAInfo.cpp.

                                                 {
    switch (planeConfig) {
        case PlaneConfig::kUnknown: return false;
 
        case PlaneConfig::kY_U_V:   return false;
        case PlaneConfig::kY_V_U:   return false;
        case PlaneConfig::kY_UV:    return false;
        case PlaneConfig::kY_VU:    return false;
        case PlaneConfig::kYUV:     return false;
        case PlaneConfig::kUYV:     return false;
 
        case PlaneConfig::kY_U_V_A: return true;
        case PlaneConfig::kY_V_U_A: return true;
        case PlaneConfig::kY_UV_A:  return true;
        case PlaneConfig::kY_VU_A:  return true;
        case PlaneConfig::kYUVA:    return true;
        case PlaneConfig::kUYVA:    return true;
    }
    SkUNREACHABLE;
}

height()

int SkYUVAInfo::height ( ) const

inline

Definition at line 173 of file SkYUVAInfo.h.

{ return fDimensions.height(); }

isValid()

bool SkYUVAInfo::isValid ( ) const

inline

Definition at line 233 of file SkYUVAInfo.h.

{ return fPlaneConfig != PlaneConfig::kUnknown; }

makeDimensions()

SkYUVAInfo SkYUVAInfo::makeDimensions

(

SkISize

dimensions

)

const

Makes a SkYUVAInfo that is identical to this one but with the passed dimensions. If the passed dimensions is empty then the result will be an invalid SkYUVAInfo.

Definition at line 366 of file SkYUVAInfo.cpp.

                                                              {
    return {dimensions, fPlaneConfig, fSubsampling, fYUVColorSpace, fOrigin, fSitingX, fSitingY};
}

makeSubsampling()

SkYUVAInfo SkYUVAInfo::makeSubsampling

(

SkYUVAInfo::Subsampling

subsampling

)

const

Makes a SkYUVAInfo that is identical to this one but with the passed Subsampling. If the passed Subsampling is not k444 and this info's PlaneConfig is not compatible with chroma subsampling (because Y is in the same plane as UV) then the result will be an invalid SkYUVAInfo.

Definition at line 362 of file SkYUVAInfo.cpp.

                                                                              {
    return {fDimensions, fPlaneConfig, subsampling, fYUVColorSpace, fOrigin, fSitingX, fSitingY};
}

numChannelsInPlane()

int SkYUVAInfo::numChannelsInPlane ( int  i ) const

inline

Definition at line 206 of file SkYUVAInfo.h.

{ return NumChannelsInPlane(fPlaneConfig, i); }

NumChannelsInPlane()

constexpr int SkYUVAInfo::NumChannelsInPlane ( PlaneConfig  config, int  i  )

staticconstexpr

Number of Y, U, V, A channels in the ith plane for a given PlaneConfig (or 0 if i is invalid).

Definition at line 272 of file SkYUVAInfo.h.

                                                                      {
    switch (config) {
        case PlaneConfig::kUnknown:
            return 0;
 
        case SkYUVAInfo::PlaneConfig::kY_U_V:
        case SkYUVAInfo::PlaneConfig::kY_V_U:
            return i >= 0 && i < 3 ? 1 : 0;
        case SkYUVAInfo::PlaneConfig::kY_UV:
        case SkYUVAInfo::PlaneConfig::kY_VU:
            switch (i) {
                case 0:  return 1;
                case 1:  return 2;
                default: return 0;
            }
        case SkYUVAInfo::PlaneConfig::kYUV:
        case SkYUVAInfo::PlaneConfig::kUYV:
            return i == 0 ? 3 : 0;
        case SkYUVAInfo::PlaneConfig::kY_U_V_A:
        case SkYUVAInfo::PlaneConfig::kY_V_U_A:
            return i >= 0 && i < 4 ? 1 : 0;
        case SkYUVAInfo::PlaneConfig::kY_UV_A:
        case SkYUVAInfo::PlaneConfig::kY_VU_A:
            switch (i) {
                case 0:  return 1;
                case 1:  return 2;
                case 2:  return 1;
                default: return 0;
            }
        case SkYUVAInfo::PlaneConfig::kYUVA:
        case SkYUVAInfo::PlaneConfig::kUYVA:
            return i == 0 ? 4 : 0;
    }
    return 0;
}

numPlanes()

int SkYUVAInfo::numPlanes ( ) const

inline

Definition at line 204 of file SkYUVAInfo.h.

{ return NumPlanes(fPlaneConfig); }

NumPlanes()

constexpr int SkYUVAInfo::NumPlanes ( PlaneConfig  planeConfig )

staticconstexpr

Number of planes for a given PlaneConfig.

Definition at line 253 of file SkYUVAInfo.h.

                                                           {
    switch (planeConfig) {
        case PlaneConfig::kUnknown: return 0;
        case PlaneConfig::kY_U_V:   return 3;
        case PlaneConfig::kY_V_U:   return 3;
        case PlaneConfig::kY_UV:    return 2;
        case PlaneConfig::kY_VU:    return 2;
        case PlaneConfig::kYUV:     return 1;
        case PlaneConfig::kUYV:     return 1;
        case PlaneConfig::kY_U_V_A: return 4;
        case PlaneConfig::kY_V_U_A: return 4;
        case PlaneConfig::kY_UV_A:  return 3;
        case PlaneConfig::kY_VU_A:  return 3;
        case PlaneConfig::kYUVA:    return 1;
        case PlaneConfig::kUYVA:    return 1;
    }
    SkUNREACHABLE;
}

operator!=()

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

inline

Definition at line 231 of file SkYUVAInfo.h.

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

operator=()

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

default

operator==()

bool SkYUVAInfo::operator==

(

const SkYUVAInfo &

that

)

const

Definition at line 370 of file SkYUVAInfo.cpp.

                                                        {
    return fPlaneConfig   == that.fPlaneConfig   &&
           fSubsampling   == that.fSubsampling  &&
           fYUVColorSpace == that.fYUVColorSpace &&
           fDimensions    == that.fDimensions    &&
           fSitingX       == that.fSitingX       &&
           fSitingY       == that.fSitingY       &&
           fOrigin        == that.fOrigin;
}

origin()

SkEncodedOrigin SkYUVAInfo::origin ( ) const

inline

Definition at line 179 of file SkYUVAInfo.h.

{ return fOrigin; }

originMatrix()

SkMatrix SkYUVAInfo::originMatrix ( ) const

inline

Definition at line 181 of file SkYUVAInfo.h.

                                  {
        return SkEncodedOriginToMatrix(fOrigin, this->width(), this->height());
    }

planeConfig()

PlaneConfig SkYUVAInfo::planeConfig ( ) const

inline

Definition at line 160 of file SkYUVAInfo.h.

{ return fPlaneConfig; }

PlaneDimensions()

int SkYUVAInfo::PlaneDimensions ( SkISize  imageDimensions, PlaneConfig  , Subsampling  , SkEncodedOrigin  , SkISize  planeDimensions[kMaxPlanes]  )

static

Given image dimensions, a planer configuration, subsampling, and origin, determine the expected size of each plane. Returns the number of expected planes. planeDimensions[0] through planeDimensions[<ret>] are written. The input image dimensions are as displayed (after the planes have been transformed to the intended display orientation). The plane dimensions are output as the planes are stored in memory (may be rotated from image dimensions).

Definition at line 77 of file SkYUVAInfo.cpp.

                                                                               {
    std::fill_n(planeDimensions, SkYUVAInfo::kMaxPlanes, SkISize{0, 0});
    if (!is_plane_config_compatible_with_subsampling(planeConfig, subsampling)) {
        return 0;
    }
 
    int w = imageDimensions.width();
    int h = imageDimensions.height();
    if (origin >= kLeftTop_SkEncodedOrigin) {
        using std::swap;
        swap(w, h);
    }
    auto down2 = [](int x) { return (x + 1)/2; };
    auto down4 = [](int x) { return (x + 3)/4; };
    SkISize uvSize;
    switch (subsampling) {
        case Subsampling::kUnknown: SkUNREACHABLE;
 
        case Subsampling::k444: uvSize = {      w ,       h }; break;
        case Subsampling::k422: uvSize = {down2(w),       h }; break;
        case Subsampling::k420: uvSize = {down2(w), down2(h)}; break;
        case Subsampling::k440: uvSize = {      w , down2(h)}; break;
        case Subsampling::k411: uvSize = {down4(w),       h }; break;
        case Subsampling::k410: uvSize = {down4(w), down2(h)}; break;
    }
    switch (planeConfig) {
        case PlaneConfig::kUnknown: SkUNREACHABLE;
 
        case PlaneConfig::kY_U_V:
        case PlaneConfig::kY_V_U:
            planeDimensions[0] = {w, h};
            planeDimensions[1] = planeDimensions[2] = uvSize;
            return 3;
 
        case PlaneConfig::kY_UV:
        case PlaneConfig::kY_VU:
            planeDimensions[0] = {w, h};
            planeDimensions[1] = uvSize;
            return 2;
 
        case PlaneConfig::kY_U_V_A:
        case PlaneConfig::kY_V_U_A:
            planeDimensions[0] = planeDimensions[3] = {w, h};
            planeDimensions[1] = planeDimensions[2] = uvSize;
            return 4;
 
        case PlaneConfig::kY_UV_A:
        case PlaneConfig::kY_VU_A:
            planeDimensions[0] = planeDimensions[2] = {w, h};
            planeDimensions[1] = uvSize;
            return 3;
 
        case PlaneConfig::kYUV:
        case PlaneConfig::kUYV:
        case PlaneConfig::kYUVA:
        case PlaneConfig::kUYVA:
            planeDimensions[0] = {w, h};
            SkASSERT(planeDimensions[0] == uvSize);
            return 1;
    }
    SkUNREACHABLE;
}

planeDimensions()

int SkYUVAInfo::planeDimensions ( SkISize  planeDimensions[kMaxPlanes] ) const

inline

Returns the number of planes and initializes planeDimensions[0]..planeDimensions[<ret>] to the expected dimensions for each plane. Dimensions are as stored in memory, before transformation to image display space as indicated by origin().

Definition at line 192 of file SkYUVAInfo.h.

                                                                   {
        return PlaneDimensions(fDimensions, fPlaneConfig, fSubsampling, fOrigin, planeDimensions);
    }

planeSubsamplingFactors()

std::tuple< int, int > SkYUVAInfo::planeSubsamplingFactors ( int  planeIdx ) const

inline

Definition at line 163 of file SkYUVAInfo.h.

                                                                   {
        return PlaneSubsamplingFactors(fPlaneConfig, fSubsampling, planeIdx);
    }

PlaneSubsamplingFactors()

std::tuple< int, int > SkYUVAInfo::PlaneSubsamplingFactors ( PlaneConfig  planeConfig, Subsampling  subsampling, int  planeIdx  )

static

SubsamplingFactors(Subsampling) if planedIdx refers to a U/V plane and otherwise {1, 1} if inputs are valid. Invalid inputs consist of incompatible PlaneConfig/Subsampling/planeIdx combinations. {0, 0} is returned for invalid inputs.

Definition at line 42 of file SkYUVAInfo.cpp.

                                                                       {
    if (!is_plane_config_compatible_with_subsampling(planeConfig, subsampling) ||
        planeIdx < 0                                                           ||
        planeIdx > NumPlanes(planeConfig)) {
        return {0, 0};
    }
    bool isSubsampledPlane = false;
    switch (planeConfig) {
        case PlaneConfig::kUnknown:     SkUNREACHABLE;
 
        case PlaneConfig::kY_U_V:
        case PlaneConfig::kY_V_U:
        case PlaneConfig::kY_U_V_A:
        case PlaneConfig::kY_V_U_A:
            isSubsampledPlane = planeIdx == 1 || planeIdx == 2;
            break;
 
        case PlaneConfig::kY_UV:
        case PlaneConfig::kY_VU:
        case PlaneConfig::kY_UV_A:
        case PlaneConfig::kY_VU_A:
            isSubsampledPlane = planeIdx == 1;
            break;
 
        case PlaneConfig::kYUV:
        case PlaneConfig::kUYV:
        case PlaneConfig::kYUVA:
        case PlaneConfig::kUYVA:
            break;
    }
    return isSubsampledPlane ? SubsamplingFactors(subsampling) : std::make_tuple(1, 1);
}

sitingX()

Siting SkYUVAInfo::sitingX ( ) const

inline

Definition at line 176 of file SkYUVAInfo.h.

{ return fSitingX; }

sitingY()

Siting SkYUVAInfo::sitingY ( ) const

inline

Definition at line 177 of file SkYUVAInfo.h.

{ return fSitingY; }

subsampling()

Subsampling SkYUVAInfo::subsampling ( ) const

inline

Definition at line 161 of file SkYUVAInfo.h.

{ return fSubsampling; }

SubsamplingFactors()

std::tuple< int, int > SkYUVAInfo::SubsamplingFactors ( Subsampling  subsampling )

static

ratio of Y/A values to U/V values in x and y.

Definition at line 29 of file SkYUVAInfo.cpp.

                                                                         {
    switch (subsampling) {
        case Subsampling::kUnknown: return {0, 0};
        case Subsampling::k444:     return {1, 1};
        case Subsampling::k422:     return {2, 1};
        case Subsampling::k420:     return {2, 2};
        case Subsampling::k440:     return {1, 2};
        case Subsampling::k411:     return {4, 1};
        case Subsampling::k410:     return {4, 2};
    }
    SkUNREACHABLE;
}

toYUVALocations()

SkYUVAInfo::YUVALocations SkYUVAInfo::toYUVALocations

(

const uint32_t *

channelFlags

)

const

Given a set of channel flags for each plane, converts this->planeConfig() to YUVALocations representation. Fails if the channel flags aren't valid for the PlaneConfig (i.e. don't have enough channels in a plane) by returning default initialized locations (all plane indices are -1).

Definition at line 358 of file SkYUVAInfo.cpp.

                                                                                      {
    return GetYUVALocations(fPlaneConfig, channelFlags);
}

width()

int SkYUVAInfo::width ( ) const

inline

Definition at line 172 of file SkYUVAInfo.h.

{ return fDimensions.width(); }

yuvColorSpace()

SkYUVColorSpace SkYUVAInfo::yuvColorSpace ( ) const

inline

Definition at line 175 of file SkYUVAInfo.h.

{ return fYUVColorSpace; }

Member Data Documentation

kMaxPlanes

constexpr int SkYUVAInfo::kMaxPlanes = 4

staticconstexpr

Definition at line 98 of file SkYUVAInfo.h.

kYUVAChannelCount

constexpr int SkYUVAInfo::kYUVAChannelCount = static_cast<int>(YUVAChannels::kLast + 1)

staticconstexpr

Definition at line 29 of file SkYUVAInfo.h.

---

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

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