SkYUVAInfo.h

Go to the documentation of this file.

/*
 * 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 SkYUVAInfo_DEFINED
#define SkYUVAInfo_DEFINED
 
#include "include/codec/SkEncodedOrigin.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkSize.h"
#include "include/core/SkTypes.h"
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <tuple>
 
class SK_API SkYUVAInfo {
public:
    enum YUVAChannels { kY, kU, kV, kA, kLast = kA };
    static constexpr int kYUVAChannelCount = static_cast<int>(YUVAChannels::kLast + 1);
 
    struct YUVALocation;  // For internal use.
    using YUVALocations = std::array<YUVALocation, kYUVAChannelCount>;
 
    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,
    };
 
    static constexpr int kMaxPlanes = 4;
 
    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);
 
    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 { return fPlaneConfig; }
    Subsampling subsampling() const { return fSubsampling; }
 
    std::tuple<int, int> planeSubsamplingFactors(int planeIdx) const {
        return PlaneSubsamplingFactors(fPlaneConfig, fSubsampling, planeIdx);
    }
 
    SkISize dimensions() const { return fDimensions; }
    int width() const { return fDimensions.width(); }
    int height() const { return fDimensions.height(); }
 
    SkYUVColorSpace yuvColorSpace() const { return fYUVColorSpace; }
    Siting sitingX() const { return fSitingX; }
    Siting sitingY() const { return fSitingY; }
 
    SkEncodedOrigin origin() const { return fOrigin; }
 
    SkMatrix originMatrix() const {
        return SkEncodedOriginToMatrix(fOrigin, this->width(), this->height());
    }
 
    bool hasAlpha() const { return HasAlpha(fPlaneConfig); }
 
    int planeDimensions(SkISize planeDimensions[kMaxPlanes]) const {
        return PlaneDimensions(fDimensions, fPlaneConfig, fSubsampling, fOrigin, planeDimensions);
    }
 
    size_t computeTotalBytes(const size_t rowBytes[kMaxPlanes],
                             size_t planeSizes[kMaxPlanes] = nullptr) const;
 
    int numPlanes() const { return NumPlanes(fPlaneConfig); }
 
    int numChannelsInPlane(int i) const { return NumChannelsInPlane(fPlaneConfig, i); }
 
    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 { return !(*this == that); }
 
    bool isValid() const { return fPlaneConfig != PlaneConfig::kUnknown; }
 
private:
    SkISize fDimensions = {0, 0};
 
    PlaneConfig fPlaneConfig = PlaneConfig::kUnknown;
    Subsampling fSubsampling = Subsampling::kUnknown;
 
    SkYUVColorSpace fYUVColorSpace = SkYUVColorSpace::kIdentity_SkYUVColorSpace;
 
    SkEncodedOrigin fOrigin = kTopLeft_SkEncodedOrigin;
 
    Siting fSitingX = Siting::kCentered;
    Siting fSitingY = Siting::kCentered;
};
 
constexpr int SkYUVAInfo::NumPlanes(PlaneConfig planeConfig) {
    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;
}
 
constexpr int SkYUVAInfo::NumChannelsInPlane(PlaneConfig config, int i) {
    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;
}
 
#endif