Image_YUVA_Graphite.h

Go to the documentation of this file.

/*
 * Copyright 2023 Google LLC
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */
 
#ifndef skgpu_graphite_Image_YUVA_Graphite_DEFINED
#define skgpu_graphite_Image_YUVA_Graphite_DEFINED
 
#include "include/core/SkYUVAInfo.h"
#include "src/gpu/graphite/Image_Base_Graphite.h"
#include "src/gpu/graphite/TextureProxyView.h"
 
#include <functional>
 
namespace skgpu::graphite {
 
class Recorder;
 
class Image_YUVA final : public Image_Base {
public:
    ~Image_YUVA() override;
 
    // Create an Image_YUVA by interpreting the multiple 'planes' using 'yuvaInfo'. If the info
    // or provided plane proxies do not produce a valid mulitplane image, null is returned.
    static sk_sp<Image_YUVA> Make(const Caps* caps,
                                  const SkYUVAInfo& yuvaInfo,
                                  SkSpan<TextureProxyView> planes,
                                  sk_sp<SkColorSpace> imageColorSpace);
 
    // Wraps the Graphite-backed Image planes into a YUV[A] image. The returned image shares
    // textures as well as any links to Devices that might modify those textures.
    static sk_sp<Image_YUVA> WrapImages(const Caps* caps,
                                        const SkYUVAInfo& yuvaInfo,
                                        SkSpan<const sk_sp<SkImage>> images,
                                        sk_sp<SkColorSpace> imageColorSpace);
 
    SkImage_Base::Type type() const override { return SkImage_Base::Type::kGraphiteYUVA; }
 
    size_t textureSize() const override;
 
    bool onHasMipmaps() const override { return fMipmapped == Mipmapped::kYes; }
 
    bool onIsProtected() const override { return fProtected == Protected::kYes; }
 
    sk_sp<SkImage> onReinterpretColorSpace(sk_sp<SkColorSpace>) const override;
 
    // Returns the proxy view that provides value for the YUVA channel specified by 'channelIndex'.
    // The view of the returned proxy applies a swizzle to map the relevant data channel into all
    // slots of the sample value. The alpha proxy may be null.
    const TextureProxyView& proxyView(int channelIndex) const {
        SkASSERT(channelIndex >= 0 && channelIndex < SkYUVAInfo::kYUVAChannelCount);
        return fProxies[channelIndex];
    }
 
    std::tuple<int, int> uvSubsampleFactors() const { return fUVSubsampleFactors; }
 
    const SkYUVAInfo& yuvaInfo() const { return fYUVAInfo; }
 
private:
    // The proxy views are ordered Y,U,V,A and if the channels are held in the same plane, the
    // respective proxy views will share the underlying TextureProxy but have the appropriate
    // swizzle to access the appropriate channel and return it in the R slot.
    using YUVAProxies = std::array<TextureProxyView, SkYUVAInfo::kYUVAChannelCount>;
 
    Image_YUVA(const YUVAProxies&,
               const SkYUVAInfo&,
               sk_sp<SkColorSpace>);
 
    YUVAProxies fProxies;
    SkYUVAInfo fYUVAInfo;
    std::tuple<int, int> fUVSubsampleFactors;
 
    // Aggregate mipmap/protected status from the proxies
    Mipmapped fMipmapped = Mipmapped::kYes;
    Protected fProtected = Protected::kNo;
};
 
} // namespace skgpu::graphite
 
#endif // skgpu_graphite_Image_YUVA_Graphite_DEFINED