Revert "Add idea of DataType to SkYUVAPixmapInfo."

This reverts commit ed63444.

Reason for revert: trying to unblock android roller, which incorrectly thinks this has a merge conflict: https://b.corp.google.com/issues/167576324

Original change's description:
> Add idea of DataType to SkYUVAPixmapInfo.
> 
> DataType describes the data type of YUVA channels
> independent of how they are grouped into planes.
> 
> Adds mapping functions between SkColorType/channel count
> and DataType.
> 
> SkYUVAPixmapInfo can be constructed from DataType and will
> choose appropriate SkColorTypes for each plane.
> 
> Valid SkYUVAPixmapInfos now have the same DataType for each
> plane (could relax this in the future, esp for alpha plane).
> 
> SkYUVAPixmapInfo::SupportedDataTypes specifies the supported
> combinations of SkYUVAInfo::PlanarConfig and
> kYUVAPixmapInfo::DataType supported by a GrContext (based on
> supported texture formats).
> 
> SkImageGenerator/SkCodec YUVA query API now takes a
> SupportedDataTypes.
> 
> Change-Id: I8791234638e6ba3396d1e7960b7bc210edc6dd57
> Bug: skia:10632
> Reviewed-on: https://skia-review.googlesource.com/c/skia/+/314276
> Reviewed-by: Leon Scroggins <scroggo@google.com>
> Reviewed-by: Robert Phillips <robertphillips@google.com>
> Commit-Queue: Brian Salomon <bsalomon@google.com>

TBR=bsalomon@google.com,robertphillips@google.com,scroggo@google.com

Change-Id: I72c39539a4766f10cac3ca3cdef6c503a8319ff1
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: skia:10632
Reviewed-on: https://skia-review.googlesource.com/c/skia/+/314895
Reviewed-by: Michael Ludwig <michaelludwig@google.com>
Commit-Queue: Michael Ludwig <michaelludwig@google.com>

Author: lhkbob

RELEASE_NOTES.txt

@@ -21,7 +21,6 @@ Milestone 87
     Doesn't assume 8bit planar values.
     https://review.skia.org/309658
     https://review.skia.org/312886
-    https://review.skia.org/314276
 
   * Added VkImageUsageFlags to GrVkImageInfo struct.
 

dm/DMSrcSink.cpp

@@ -1814,8 +1814,7 @@ Result GPUDDLSink::ddlDraw(const Src& src,
     // this is our ultimate final drawing area/rect
     SkIRect viewport = SkIRect::MakeWH(size.fWidth, size.fHeight);
 
-    SkYUVAPixmapInfo::SupportedDataTypes supportedYUVADataTypes(*gpuThreadCtx);
-    DDLPromiseImageHelper promiseImageHelper(supportedYUVADataTypes);
+    DDLPromiseImageHelper promiseImageHelper;
     sk_sp<SkData> compressedPictureData = promiseImageHelper.deflateSKP(inputPicture.get());
     if (!compressedPictureData) {
         return Result::Fatal("GPUDDLSink: Couldn't deflate SkPicture");
@@ -2271,7 +2270,7 @@ Result ViaDDL::draw(const Src& src, SkBitmap* bitmap, SkWStream* stream, SkStrin
     // this is our ultimate final drawing area/rect
     SkIRect viewport = SkIRect::MakeWH(size.fWidth, size.fHeight);
 
-    DDLPromiseImageHelper promiseImageHelper(SkYUVAPixmapInfo::SupportedDataTypes::All());
+    DDLPromiseImageHelper promiseImageHelper;
     sk_sp<SkData> compressedPictureData = promiseImageHelper.deflateSKP(inputPicture.get());
     if (!compressedPictureData) {
         return Result::Fatal("ViaDDL: Couldn't deflate SkPicture");

include/codec/SkCodec.h

@@ -381,18 +381,11 @@ class SK_API SkCodec : SkNoncopyable {
     }
 
     /**
-     *  If decoding to YUV is supported, this returns true. Otherwise, this
-     *  returns false and the caller will ignore output parameter yuvaPixmapInfo.
-     *
-     * @param  supportedDataTypes Indicates the data type/planar config combinations that are
-     *                            supported by the caller. If the generator supports decoding to
-     *                            YUV(A), but not as a type in supportedDataTypes, this method
-     *                            returns false.
-     *  @param yuvaPixmapInfo Output parameter that specifies the planar configuration, subsampling,
-     *                        orientation, chroma siting, plane color types, and row bytes.
+     * If decoding to YUVA is supported, this returns true and updates yuvaPixmapInfo to be a
+     * specification of the planar layout, YUVA->RGBA transformation, per-plane color types and row
+     * bytes. If YUVA decoding is not supported then returns false.
      */
-    bool queryYUVAInfo(const SkYUVAPixmapInfo::SupportedDataTypes& supportedDataTypes,
-                       SkYUVAPixmapInfo* yuvaPixmapInfo) const;
+    bool queryYUVAInfo(SkYUVAPixmapInfo* yuvaPixmapInfo) const;
 
     /**
      *  Returns kSuccess, or another value explaining the type of failure.
@@ -739,8 +732,7 @@ class SK_API SkCodec : SkNoncopyable {
                                void* pixels, size_t rowBytes, const Options&,
                                int* rowsDecoded) = 0;
 
-    virtual bool onQueryYUVAInfo(const SkYUVAPixmapInfo::SupportedDataTypes&,
-                                 SkYUVAPixmapInfo*) const { return false; }
+    virtual bool onQueryYUVAInfo(SkYUVAPixmapInfo*) const { return false; }
 
     virtual Result onGetYUVAPlanes(const SkYUVAPixmaps&) { return kUnimplemented; }
 

include/core/SkImageGenerator.h

@@ -91,17 +91,12 @@ class SK_API SkImageGenerator {
 
     /**
      *  If decoding to YUV is supported, this returns true. Otherwise, this
-     *  returns false and the caller will ignore output parameter yuvaPixmapInfo.
-     *
-     * @param  supportedDataTypes Indicates the data type/planar config combinations that are
-     *                            supported by the caller. If the generator supports decoding to
-     *                            YUV(A), but not as a type in supportedDataTypes, this method
-     *                            returns false.
-     *  @param yuvaPixmapInfo Output parameter that specifies the planar configuration, subsampling,
-     *                        orientation, chroma siting, plane color types, and row bytes.
+     *  returns false and does not modify yuvaPixmapInfo.
+     *
+     *  @param yuvaPixmapInfo Specifies the planar configuration, subsampling, orientation,
+     *                        chroma siting, plane color types, and row bytes.
      */
-    bool queryYUVAInfo(const SkYUVAPixmapInfo::SupportedDataTypes& supportedDataTypes,
-                       SkYUVAPixmapInfo* yuvaPixmapInfo) const;
+    bool queryYUVAInfo(SkYUVAPixmapInfo* yuvaPixmapInfo) const;
 
     /**
      *  Returns true on success and false on failure.
@@ -209,8 +204,7 @@ class SK_API SkImageGenerator {
     struct Options {};
     virtual bool onGetPixels(const SkImageInfo&, void*, size_t, const Options&) { return false; }
     virtual bool onIsValid(GrRecordingContext*) const { return true; }
-    virtual bool onQueryYUVAInfo(const SkYUVAPixmapInfo::SupportedDataTypes&,
-                                 SkYUVAPixmapInfo*) const { return false; }
+    virtual bool onQueryYUVAInfo(SkYUVAPixmapInfo*) const { return false; }
     virtual bool onGetYUVAPlanes(const SkYUVAPixmaps&) { return false; }
     virtual bool onQueryYUVA8(SkYUVASizeInfo*, SkYUVAIndex[SkYUVAIndex::kIndexCount],
                               SkYUVColorSpace*) const { return false; }

include/core/SkYUVAPixmaps.h

@@ -15,9 +15,7 @@
 #include "include/private/SkTo.h"
 
 #include <array>
-#include <bitset>
 
-class GrImageContext;
 struct SkYUVASizeInfo;
 struct SkYUVAIndex;
 
@@ -29,113 +27,44 @@ class SK_API SkYUVAPixmapInfo {
 public:
     static constexpr auto kMaxPlanes = SkYUVAInfo::kMaxPlanes;
 
-    using PlanarConfig = SkYUVAInfo::PlanarConfig;
-
-    /**
-     * 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
-
-        kLast = kFloat16
-    };
-    static constexpr int kDataTypeCnt = static_cast<int>(DataType::kLast) + 1;
-
-    class SupportedDataTypes {
-    public:
-        /** Defaults to nothing supported. */
-        constexpr SupportedDataTypes() = default;
-
-        /** Init based on texture formats supported by the context. */
-        SupportedDataTypes(const GrImageContext&);
-
-        /** All combinations of PlanarConfig and DataType are supported. */
-        static constexpr SupportedDataTypes All() {
-            SupportedDataTypes combinations;
-            combinations.fDataTypeSupport = std::bitset<kDataTypeCnt>(~(0ULL));
-            return combinations;
-        }
-
-        constexpr bool supported(PlanarConfig, DataType type) const {
-            return fDataTypeSupport[static_cast<size_t>(type)];
-        }
-
-        /**
-         * Update to add support for pixmaps with numChannel channels where each channel is
-         * represented as DataType.
-         */
-        void enableDataType(DataType, int numChannels);
-
-    private:
-        // Because all of our PlanarConfigs are currently single channel per-plane, we just need to
-        // keep track of whether each data type is supported (implicitly as a single channel plane).
-        // As we add multi-channel per-plane PlanarConfigs this will have to change.
-        std::bitset<kDataTypeCnt> fDataTypeSupport = {};
-    };
-
-    /**
-     * Gets the default SkColorType to use with numChannels channels, each represented as DataType.
-     * Returns kUnknown_SkColorType if no such color type.
-     */
-    static 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.
+     * row byte values beyond the number of planes in SkYUVAInfo are ignored.
      *
      * 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.
+     * Like above but uses the same color type for all planes.
      */
-    SkYUVAPixmapInfo(const SkYUVAInfo&, DataType, const size_t rowBytes[kMaxPlanes]);
+    SkYUVAPixmapInfo(const SkYUVAInfo&, SkColorType, 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 this->isValid() ? fYUVAInfo.numPlanes() : 0; }
 
-    /** 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)]; }
+    size_t rowBytes(int i) const { return fRowBytes[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)]; }
+    const SkImageInfo& planeInfo(int i) const { return fPlaneInfos[i]; }
 
     /**
      * Determine size to allocate for all planes. Optionally retrieves the per-plane sizes in
@@ -157,14 +86,10 @@ class SK_API SkYUVAPixmapInfo {
      */
     bool isValid() const { return fPlaneInfos[0].colorType() != kUnknown_SkColorType; }
 
-    /** 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;
+    SkImageInfo fPlaneInfos[kMaxPlanes] = {};
+    size_t fRowBytes[kMaxPlanes] = {};
     static_assert(kUnknown_SkColorType == 0, "default init isn't kUnknown");
 };
 

src/codec/SkCodec.cpp

@@ -167,13 +167,11 @@ SkCodec::SkCodec(SkEncodedInfo&& info, XformFormat srcFormat, std::unique_ptr<Sk
 
 SkCodec::~SkCodec() {}
 
-bool SkCodec::queryYUVAInfo(const SkYUVAPixmapInfo::SupportedDataTypes& supportedDataTypes,
-                            SkYUVAPixmapInfo* yuvaPixmapInfo) const {
+bool SkCodec::queryYUVAInfo(SkYUVAPixmapInfo* yuvaPixmapInfo) const {
     if (!yuvaPixmapInfo) {
         return false;
     }
-    return this->onQueryYUVAInfo(supportedDataTypes, yuvaPixmapInfo) &&
-           yuvaPixmapInfo->isSupported(supportedDataTypes);
+    return this->onQueryYUVAInfo(yuvaPixmapInfo) && yuvaPixmapInfo->isValid();
 }
 
 SkCodec::Result SkCodec::getYUVAPlanes(const SkYUVAPixmaps& yuvaPixmaps) {

src/codec/SkCodecImageGenerator.cpp

@@ -69,10 +69,8 @@ bool SkCodecImageGenerator::onGetPixels(const SkImageInfo& requestInfo, void* re
     return this->getPixels(requestInfo, requestPixels, requestRowBytes, nullptr);
 }
 
-bool SkCodecImageGenerator::onQueryYUVAInfo(
-        const SkYUVAPixmapInfo::SupportedDataTypes& supportedDataTypes,
-        SkYUVAPixmapInfo* yuvaPixmapInfo) const {
-    return fCodec->queryYUVAInfo(supportedDataTypes, yuvaPixmapInfo);
+bool SkCodecImageGenerator::onQueryYUVAInfo(SkYUVAPixmapInfo* yuvaPixmapInfo) const {
+    return fCodec->queryYUVAInfo(yuvaPixmapInfo);
 }
 
 bool SkCodecImageGenerator::onGetYUVAPlanes(const SkYUVAPixmaps& yuvaPixmaps) {

src/codec/SkCodecImageGenerator.h

@@ -98,8 +98,7 @@ class SkCodecImageGenerator : public SkImageGenerator {
                      size_t rowBytes,
                      const Options& opts) override;
 
-    bool onQueryYUVAInfo(const SkYUVAPixmapInfo::SupportedDataTypes&,
-                         SkYUVAPixmapInfo*) const override;
+    bool onQueryYUVAInfo(SkYUVAPixmapInfo* yuvaPixmapInfo) const override;
 
     bool onGetYUVAPlanes(const SkYUVAPixmaps& yuvaPixmaps) override;
 

src/codec/SkJpegCodec.cpp

@@ -745,7 +745,6 @@ bool SkJpegCodec::onSkipScanlines(int count) {
 
 static bool is_yuv_supported(const jpeg_decompress_struct* dinfo,
                              const SkJpegCodec& codec,
-                             const SkYUVAPixmapInfo::SupportedDataTypes* supportedDataTypes,
                              SkYUVAPixmapInfo* yuvaPixmapInfo) {
     // Scaling is not supported in raw data mode.
     SkASSERT(dinfo->scale_num == dinfo->scale_denom);
@@ -812,10 +811,6 @@ static bool is_yuv_supported(const jpeg_decompress_struct* dinfo,
     } else {
         return false;
     }
-    if (supportedDataTypes &&
-        !supportedDataTypes->supported(tempPlanarConfig, SkYUVAPixmapInfo::DataType::kUnorm8)) {
-        return false;
-    }
     if (yuvaPixmapInfo) {
         SkColorType colorTypes[SkYUVAPixmapInfo::kMaxPlanes];
         size_t rowBytes[SkYUVAPixmapInfo::kMaxPlanes];
@@ -834,16 +829,15 @@ static bool is_yuv_supported(const jpeg_decompress_struct* dinfo,
     return true;
 }
 
-bool SkJpegCodec::onQueryYUVAInfo(const SkYUVAPixmapInfo::SupportedDataTypes& supportedDataTypes,
-                                  SkYUVAPixmapInfo* yuvaPixmapInfo) const {
+bool SkJpegCodec::onQueryYUVAInfo(SkYUVAPixmapInfo* yuvaPixmapInfo) const {
     jpeg_decompress_struct* dinfo = fDecoderMgr->dinfo();
-    return is_yuv_supported(dinfo, *this, &supportedDataTypes, yuvaPixmapInfo);
+    return is_yuv_supported(dinfo, *this, yuvaPixmapInfo);
 }
 
 SkCodec::Result SkJpegCodec::onGetYUVAPlanes(const SkYUVAPixmaps& yuvaPixmaps) {
     // Get a pointer to the decompress info since we will use it quite frequently
     jpeg_decompress_struct* dinfo = fDecoderMgr->dinfo();
-    if (!is_yuv_supported(dinfo, *this, nullptr, nullptr)) {
+    if (!is_yuv_supported(dinfo, *this, nullptr)) {
         return fDecoderMgr->returnFailure("onGetYUVAPlanes", kInvalidInput);
     }
     // Set the jump location for libjpeg errors
@@ -866,7 +860,7 @@ SkCodec::Result SkJpegCodec::onGetYUVAPlanes(const SkYUVAPixmaps& yuvaPixmaps) {
         // was caused by a bug in the old code, but we'll be safe and check here.
         // Also check that pixmap properties agree with expectations.
         SkYUVAPixmapInfo info;
-        SkASSERT(is_yuv_supported(dinfo, *this, nullptr, &info));
+        SkASSERT(is_yuv_supported(dinfo, *this,  &info));
         SkASSERT(info.yuvaInfo() == yuvaPixmaps.yuvaInfo());
         for (int i = 0; i < info.numPlanes(); ++i) {
             SkASSERT(planes[i].colorType() == kAlpha_8_SkColorType);

src/codec/SkJpegCodec.h

@@ -44,8 +44,7 @@ class SkJpegCodec : public SkCodec {
     Result onGetPixels(const SkImageInfo& dstInfo, void* dst, size_t dstRowBytes, const Options&,
             int*) override;
 
-    bool onQueryYUVAInfo(const SkYUVAPixmapInfo::SupportedDataTypes&,
-                         SkYUVAPixmapInfo*) const override;
+    bool onQueryYUVAInfo(SkYUVAPixmapInfo*) const override;
 
     Result onGetYUVAPlanes(const SkYUVAPixmaps& yuvaPixmaps) override;