You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
337 lines
13 KiB
337 lines
13 KiB
/*
|
|
* Copyright 2020 Google LLC
|
|
*
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
#ifndef SkYUVAPixmaps_DEFINED
|
|
#define SkYUVAPixmaps_DEFINED
|
|
|
|
#include "include/core/SkData.h"
|
|
#include "include/core/SkImageInfo.h"
|
|
#include "include/core/SkPixmap.h"
|
|
#include "include/core/SkYUVAInfo.h"
|
|
#include "include/private/SkTo.h"
|
|
|
|
#include <array>
|
|
#include <bitset>
|
|
|
|
class GrImageContext;
|
|
|
|
/**
|
|
* SkYUVAInfo combined with per-plane SkColorTypes and row bytes. Fully specifies the SkPixmaps
|
|
* for a YUVA image without the actual pixel memory and data.
|
|
*/
|
|
class SK_API SkYUVAPixmapInfo {
|
|
public:
|
|
static constexpr auto kMaxPlanes = SkYUVAInfo::kMaxPlanes;
|
|
|
|
using PlaneConfig = SkYUVAInfo::PlaneConfig;
|
|
using Subsampling = SkYUVAInfo::Subsampling;
|
|
|
|
/**
|
|
* Data type for Y, U, V, and possibly A channels independent of how values are packed into
|
|
* planes.
|
|
**/
|
|
enum class DataType {
|
|
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
|
|
};
|
|
static constexpr int kDataTypeCnt = static_cast<int>(DataType::kLast) + 1;
|
|
|
|
class SK_API SupportedDataTypes {
|
|
public:
|
|
/** Defaults to nothing supported. */
|
|
constexpr SupportedDataTypes() = default;
|
|
|
|
/** Init based on texture formats supported by the context. */
|
|
SupportedDataTypes(const GrImageContext&);
|
|
|
|
/** All legal combinations of PlaneConfig and DataType are supported. */
|
|
static constexpr SupportedDataTypes All();
|
|
|
|
/**
|
|
* Checks whether there is a supported combination of color types for planes structured
|
|
* as indicated by PlaneConfig with channel data types as indicated by DataType.
|
|
*/
|
|
constexpr bool supported(PlaneConfig, DataType) const;
|
|
|
|
/**
|
|
* Update to add support for pixmaps with numChannel channels where each channel is
|
|
* represented as DataType.
|
|
*/
|
|
void enableDataType(DataType, int numChannels);
|
|
|
|
private:
|
|
// The bit for DataType dt with n channels is at index kDataTypeCnt*(n-1) + dt.
|
|
std::bitset<kDataTypeCnt*4> fDataTypeSupport = {};
|
|
};
|
|
|
|
/**
|
|
* Gets the default SkColorType to use with numChannels channels, each represented as DataType.
|
|
* Returns kUnknown_SkColorType if no such color type.
|
|
*/
|
|
static constexpr SkColorType DefaultColorTypeForDataType(DataType dataType, int numChannels);
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
static std::tuple<int, DataType> NumChannelsAndDataType(SkColorType);
|
|
|
|
/** Default SkYUVAPixmapInfo is invalid. */
|
|
SkYUVAPixmapInfo() = default;
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
SkYUVAPixmapInfo(const SkYUVAInfo&,
|
|
const SkColorType[kMaxPlanes],
|
|
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.
|
|
*/
|
|
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 { return !(*this == that); }
|
|
|
|
const SkYUVAInfo& yuvaInfo() const { return fYUVAInfo; }
|
|
|
|
SkYUVColorSpace yuvColorSpace() const { return fYUVAInfo.yuvColorSpace(); }
|
|
|
|
/** The number of SkPixmap planes, 0 if this SkYUVAPixmapInfo is invalid. */
|
|
int numPlanes() const { return fYUVAInfo.numPlanes(); }
|
|
|
|
/** The per-YUV[A] channel data type. */
|
|
DataType dataType() const { return fDataType; }
|
|
|
|
/**
|
|
* Row bytes for the ith plane. Returns zero if i >= numPlanes() or this SkYUVAPixmapInfo is
|
|
* invalid.
|
|
*/
|
|
size_t rowBytes(int i) const { return fRowBytes[static_cast<size_t>(i)]; }
|
|
|
|
/** Image info for the ith plane, or default SkImageInfo if i >= numPlanes() */
|
|
const SkImageInfo& planeInfo(int i) const { return fPlaneInfos[static_cast<size_t>(i)]; }
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
size_t computeTotalBytes(size_t planeSizes[kMaxPlanes] = nullptr) 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.
|
|
*/
|
|
bool initPixmapsFromSingleAllocation(void* memory, SkPixmap pixmaps[kMaxPlanes]) const;
|
|
|
|
/**
|
|
* Returns true if this has been configured with a non-empty dimensioned SkYUVAInfo with
|
|
* compatible color types and row bytes.
|
|
*/
|
|
bool isValid() const { return fYUVAInfo.isValid(); }
|
|
|
|
/** Is this valid and does it use color types allowed by the passed SupportedDataTypes? */
|
|
bool isSupported(const SupportedDataTypes&) const;
|
|
|
|
private:
|
|
SkYUVAInfo fYUVAInfo;
|
|
std::array<SkImageInfo, kMaxPlanes> fPlaneInfos = {};
|
|
std::array<size_t, kMaxPlanes> fRowBytes = {};
|
|
DataType fDataType = DataType::kUnorm8;
|
|
static_assert(kUnknown_SkColorType == 0, "default init isn't kUnknown");
|
|
};
|
|
|
|
/**
|
|
* Helper to store SkPixmap planes as described by a SkYUVAPixmapInfo. Can be responsible for
|
|
* allocating/freeing memory for pixmaps or use external memory.
|
|
*/
|
|
class SK_API SkYUVAPixmaps {
|
|
public:
|
|
using DataType = SkYUVAPixmapInfo::DataType;
|
|
static constexpr auto kMaxPlanes = SkYUVAPixmapInfo::kMaxPlanes;
|
|
|
|
static SkColorType RecommendedRGBAColorType(DataType);
|
|
|
|
/** Allocate space for pixmaps' pixels in the SkYUVAPixmaps. */
|
|
static SkYUVAPixmaps Allocate(const SkYUVAPixmapInfo& yuvaPixmapInfo);
|
|
|
|
/**
|
|
* Use storage in SkData as backing store for pixmaps' pixels. SkData is retained by the
|
|
* SkYUVAPixmaps.
|
|
*/
|
|
static SkYUVAPixmaps FromData(const SkYUVAPixmapInfo&, sk_sp<SkData>);
|
|
|
|
/**
|
|
* Makes a deep copy of the src SkYUVAPixmaps. The returned SkYUVAPixmaps owns its planes'
|
|
* backing stores.
|
|
*/
|
|
static SkYUVAPixmaps MakeCopy(const SkYUVAPixmaps& src);
|
|
|
|
/**
|
|
* 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.
|
|
*/
|
|
static SkYUVAPixmaps FromExternalMemory(const SkYUVAPixmapInfo&, void* memory);
|
|
|
|
/**
|
|
* 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, ...).
|
|
*/
|
|
static SkYUVAPixmaps FromExternalPixmaps(const SkYUVAInfo&, const SkPixmap[kMaxPlanes]);
|
|
|
|
/** Default SkYUVAPixmaps is invalid. */
|
|
SkYUVAPixmaps() = default;
|
|
~SkYUVAPixmaps() = default;
|
|
|
|
SkYUVAPixmaps(SkYUVAPixmaps&& that) = default;
|
|
SkYUVAPixmaps& operator=(SkYUVAPixmaps&& that) = default;
|
|
SkYUVAPixmaps(const SkYUVAPixmaps&) = default;
|
|
SkYUVAPixmaps& operator=(const SkYUVAPixmaps& that) = default;
|
|
|
|
/** Does have initialized pixmaps compatible with its SkYUVAInfo. */
|
|
bool isValid() const { return !fYUVAInfo.dimensions().isEmpty(); }
|
|
|
|
const SkYUVAInfo& yuvaInfo() const { return fYUVAInfo; }
|
|
|
|
DataType dataType() const { return fDataType; }
|
|
|
|
SkYUVAPixmapInfo pixmapsInfo() const;
|
|
|
|
/** Number of pixmap planes or 0 if this SkYUVAPixmaps is invalid. */
|
|
int numPlanes() const { return this->isValid() ? fYUVAInfo.numPlanes() : 0; }
|
|
|
|
/**
|
|
* Access the SkPixmap planes. They are default initialized if this is not a valid
|
|
* SkYUVAPixmaps.
|
|
*/
|
|
const std::array<SkPixmap, kMaxPlanes>& planes() const { return fPlanes; }
|
|
|
|
/**
|
|
* Get the ith SkPixmap plane. SkPixmap will be default initialized if i >= numPlanes or this
|
|
* SkYUVAPixmaps is invalid.
|
|
*/
|
|
const SkPixmap& plane(int i) const { return fPlanes[SkToSizeT(i)]; }
|
|
|
|
/**
|
|
* Computes a YUVALocations representation of the planar layout. The result is guaranteed to be
|
|
* valid if this->isValid().
|
|
*/
|
|
SkYUVAInfo::YUVALocations toYUVALocations() const;
|
|
|
|
/** Does this SkPixmaps own the backing store of the planes? */
|
|
bool ownsStorage() const { return SkToBool(fData); }
|
|
|
|
private:
|
|
SkYUVAPixmaps(const SkYUVAPixmapInfo&, sk_sp<SkData>);
|
|
SkYUVAPixmaps(const SkYUVAInfo&, DataType, const SkPixmap[kMaxPlanes]);
|
|
|
|
std::array<SkPixmap, kMaxPlanes> fPlanes = {};
|
|
sk_sp<SkData> fData;
|
|
SkYUVAInfo fYUVAInfo;
|
|
DataType fDataType;
|
|
};
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
|
|
constexpr SkYUVAPixmapInfo::SupportedDataTypes SkYUVAPixmapInfo::SupportedDataTypes::All() {
|
|
using ULL = unsigned long long; // bitset cons. takes this.
|
|
ULL bits = 0;
|
|
for (ULL c = 1; c <= 4; ++c) {
|
|
for (ULL dt = 0; dt <= ULL(kDataTypeCnt); ++dt) {
|
|
if (DefaultColorTypeForDataType(static_cast<DataType>(dt),
|
|
static_cast<int>(c)) != kUnknown_SkColorType) {
|
|
bits |= ULL(1) << (dt + static_cast<ULL>(kDataTypeCnt)*(c - 1));
|
|
}
|
|
}
|
|
}
|
|
SupportedDataTypes combinations;
|
|
combinations.fDataTypeSupport = bits;
|
|
return combinations;
|
|
}
|
|
|
|
constexpr bool SkYUVAPixmapInfo::SupportedDataTypes::supported(PlaneConfig config,
|
|
DataType type) const {
|
|
int n = SkYUVAInfo::NumPlanes(config);
|
|
for (int i = 0; i < n; ++i) {
|
|
auto c = static_cast<size_t>(SkYUVAInfo::NumChannelsInPlane(config, i));
|
|
SkASSERT(c >= 1 && c <= 4);
|
|
if (!fDataTypeSupport[static_cast<size_t>(type) +
|
|
(c - 1)*static_cast<size_t>(kDataTypeCnt)]) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
constexpr SkColorType SkYUVAPixmapInfo::DefaultColorTypeForDataType(DataType dataType,
|
|
int numChannels) {
|
|
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;
|
|
}
|
|
|
|
#endif
|