/*
 * Copyright 2025 Google LLC
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "src/gpu/graphite/TextureFormat.h"

#include "include/core/SkColor.h"
#include "include/core/SkColorType.h"
#include "src/core/SkImageInfoPriv.h"

namespace skgpu::graphite {

using TF = TextureFormat; // for brevity in this file

const char* TextureFormatName(TextureFormat format) {
    switch (format) {
        case TF::kUnsupported:    return "Unsupported";
        case TF::kR8:             return "R8";
        case TF::kR16:            return "R16";
        case TF::kR16F:           return "R16F";
        case TF::kR32F:           return "R32F";
        case TF::kA8:             return "A8";
        case TF::kRG8:            return "RG8";
        case TF::kRG16:           return "RG16";
        case TF::kRG16F:          return "RG16F";
        case TF::kRG32F:          return "RG32F";
        case TF::kRGB8:           return "RGB8";
        case TF::kBGR8:           return "BGR8";
        case TF::kB5_G6_R5:       return "B5_G6_R5";
        case TF::kR5_G6_B5:       return "R5_G6_B5";
        case TF::kRGB16:          return "RGB16";
        case TF::kRGB16F:         return "RGB16F";
        case TF::kRGB32F:         return "RGB32F";
        case TF::kRGB8_sRGB:      return "RGB8_sRGB";
        case TF::kBGR10_XR:       return "BGR10_XR";
        case TF::kRGBA8:          return "RGBA8";
        case TF::kRGBA16:         return "RBGA16";
        case TF::kRGBA16F:        return "RGBA16F";
        case TF::kRGBA32F:        return "RGBA32F";
        case TF::kRGB10_A2:       return "RGB10_A2";
        case TF::kRGBA10x6:       return "RGBA10x6";
        case TF::kRGBA8_sRGB:     return "RGBA8_sRGB";
        case TF::kBGRA8:          return "BGRA8";
        case TF::kBGR10_A2:       return "BGR10_A2";
        case TF::kBGRA8_sRGB:     return "BGRA8_sRGB";
        case TF::kABGR4:          return "ABGR4";
        case TF::kARGB4:          return "ARGB4";
        case TF::kBGRA10x6_XR:    return "BGRA10x6_XR";
        case TF::kRGB8_ETC2:      return "RGB8_ETC2";
        case TF::kRGB8_ETC2_sRGB: return "RGB8_ETC2_sRGB";
        case TF::kRGB8_BC1:       return "RGB8_BC1";
        case TF::kRGBA8_BC1:      return "RGBA8_BC1";
        case TF::kRGBA8_BC1_sRGB: return "RGBA8_BC1_sRGB";
        case TF::kYUV8_P2_420:    return "YUV8_P2_420";
        case TF::kYUV8_P3_420:    return "YUV8_P3_420";
        case TF::kYUV10x6_P2_420: return "YUV10x6_P2_420";
        case TF::kExternal:       return "External";
        case TF::kS8:             return "S8";
        case TF::kD16:            return "D16";
        case TF::kD32F:           return "D32F";
        case TF::kD24_S8:         return "D24_S8";
        case TF::kD32F_S8:        return "D32F_S8";
    }
    SkUNREACHABLE;
}

SkTextureCompressionType TextureFormatCompressionType(TextureFormat format) {
    switch (format) {
        case TF::kRGB8_ETC2:      [[fallthrough]];
        case TF::kRGB8_ETC2_sRGB: return SkTextureCompressionType::kETC2_RGB8_UNORM;
        case TF::kRGB8_BC1:       return SkTextureCompressionType::kBC1_RGB8_UNORM;
        case TF::kRGBA8_BC1:      [[fallthrough]];
        case TF::kRGBA8_BC1_sRGB: return SkTextureCompressionType::kBC1_RGBA8_UNORM;
        default:                  return SkTextureCompressionType::kNone;
    }
}

TextureFormat CompressionTypeToTextureFormat(SkTextureCompressionType type) {
    switch (type) {
        case SkTextureCompressionType::kBC1_RGB8_UNORM:  return TF::kRGB8_BC1;
        case SkTextureCompressionType::kBC1_RGBA8_UNORM: return TF::kRGBA8_BC1;
        case SkTextureCompressionType::kETC2_RGB8_UNORM: return TF::kRGB8_ETC2;
        default:                                         return TF::kUnsupported;
    }
}

int TextureFormatBytesPerBlock(TextureFormat format) {
    switch (format) {
        case TF::kUnsupported: return 0;
        case TF::kR8:          return 1;
        case TF::kR16:         return 2;
        case TF::kR16F:        return 2;
        case TF::kR32F:        return 4;
        case TF::kA8:          return 1;
        case TF::kRG8:         return 2;
        case TF::kRG16:        return 4;
        case TF::kRG16F:       return 4;
        case TF::kRG32F:       return 8;
        case TF::kRGB8:        return 3;
        case TF::kBGR8:        return 3;
        case TF::kB5_G6_R5:    return 2;
        case TF::kR5_G6_B5:    return 2;
        case TF::kRGB16:       return 6;
        case TF::kRGB16F:      return 6;
        case TF::kRGB32F:      return 12;
        case TF::kRGB8_sRGB:   return 3;
        case TF::kBGR10_XR:    return 4;
        case TF::kRGBA8:       return 4;
        case TF::kRGBA16:      return 8;
        case TF::kRGBA16F:     return 8;
        case TF::kRGBA32F:     return 16;
        case TF::kRGB10_A2:    return 4;
        case TF::kRGBA10x6:    return 8;
        case TF::kRGBA8_sRGB:  return 4;
        case TF::kBGRA8:       return 4;
        case TF::kBGR10_A2:    return 4;
        case TF::kBGRA8_sRGB:  return 4;
        case TF::kABGR4:       return 2;
        case TF::kARGB4:       return 2;
        case TF::kBGRA10x6_XR: return 8;
        case TF::kS8:          return 1;
        case TF::kD16:         return 2;
        case TF::kD32F:        return 4;
        case TF::kD24_S8:      return 4;
        case TF::kD32F_S8:     return 5; // Assuming it's multiplanar

        // NOTE: For compressed formats, the block size refers to an actual compressed block of
        // multiple texels, whereas with other formats the block size represents a single pixel.
        case TF::kRGB8_ETC2:
        case TF::kRGB8_ETC2_sRGB:
        case TF::kRGB8_BC1:
        case TF::kRGBA8_BC1:
        case TF::kRGBA8_BC1_sRGB:
            return 8;
        // NOTE: We don't actually know the size of external formats, so this is an arbitrary value.
        // We will see external formats only in wrapped SkImages, so this won't impact Skia's
        // internal budgeting.
        case TF::kExternal:
            return 4;
        // TODO(b/401016699): We are just over estimating this value to be used in gpu size
        // calculations even though the actually size is probably less. We should instead treat
        // planar formats similar to compressed textures that go through their own special query for
        // calculating size.
        case TF::kYUV8_P2_420:
        case TF::kYUV8_P3_420:
            return 3;
        case TF::kYUV10x6_P2_420:
            return 6;
    }
    SkUNREACHABLE;
}

uint32_t TextureFormatChannelMask(TextureFormat format) {
    switch (format) {
        case TF::kA8:             return kAlpha_SkColorChannelFlag;

        case TF::kR8:             [[fallthrough]];
        case TF::kR16:
        case TF::kR16F:
        case TF::kR32F:           return kRed_SkColorChannelFlag;

        case TF::kRG8:            [[fallthrough]];
        case TF::kRG16:
        case TF::kRG16F:
        case TF::kRG32F:          return kRG_SkColorChannelFlags;

        case TF::kRGB8:           [[fallthrough]];
        case TF::kBGR8:
        case TF::kB5_G6_R5:
        case TF::kR5_G6_B5:
        case TF::kRGB16:
        case TF::kRGB16F:
        case TF::kRGB32F:
        case TF::kRGB8_sRGB:
        case TF::kBGR10_XR:
        case TF::kRGB8_ETC2:
        case TF::kRGB8_ETC2_sRGB:
        case TF::kRGB8_BC1:
        case TF::kYUV8_P2_420:
        case TF::kYUV8_P3_420:
        case TF::kYUV10x6_P2_420: return kRGB_SkColorChannelFlags;

        case TF::kRGBA8:          [[fallthrough]];
        case TF::kRGBA16:
        case TF::kRGBA16F:
        case TF::kRGBA32F:
        case TF::kRGB10_A2:
        case TF::kRGBA10x6:
        case TF::kRGBA8_sRGB:
        case TF::kBGRA8:
        case TF::kBGR10_A2:
        case TF::kBGRA8_sRGB:
        case TF::kABGR4:
        case TF::kARGB4:
        case TF::kBGRA10x6_XR:
        case TF::kRGBA8_BC1:
        case TF::kRGBA8_BC1_sRGB:
        case TF::kExternal:       return kRGBA_SkColorChannelFlags;

        case TF::kS8:             [[fallthrough]];
        case TF::kD16:
        case TF::kD32F:
        case TF::kD24_S8:
        case TF::kD32F_S8:
        case TF::kUnsupported:    return 0;
    }
    SkUNREACHABLE;
}

bool TextureFormatAutoClamps(TextureFormat format) {
    // Floating point formats, extended range formats, and non-normalized integer formats do not
    // auto-clamp. Everything behaves like an unsigned normalized number.
    return !(TextureFormatIsFloatingPoint(format) ||
             format == TF::kBGR10_XR ||
             format == TF::kBGRA10x6_XR ||
             format == TF::kS8);
}

bool TextureFormatIsFloatingPoint(TextureFormat format) {
    switch (format) {
        // Floating point formats
        case TF::kR16F:           [[fallthrough]];
        case TF::kR32F:
        case TF::kRG16F:
        case TF::kRG32F:
        case TF::kRGB16F:
        case TF::kRGB32F:
        case TF::kRGBA16F:
        case TF::kRGBA32F:
        case TF::kD32F:
        case TF::kD32F_S8:        return true;

        // Everything else is unorm, unorm-srgb, fixed point, or integral
        case TF::kUnsupported:    [[fallthrough]];
        case TF::kR8:
        case TF::kR16:
        case TF::kA8:
        case TF::kRG8:
        case TF::kRG16:
        case TF::kRGB8:
        case TF::kBGR8:
        case TF::kB5_G6_R5:
        case TF::kR5_G6_B5:
        case TF::kRGB16:
        case TF::kRGB8_sRGB:
        case TF::kBGR10_XR:
        case TF::kRGBA8:
        case TF::kRGBA16:
        case TF::kRGB10_A2:
        case TF::kRGBA10x6:
        case TF::kRGBA8_sRGB:
        case TF::kBGRA8:
        case TF::kBGR10_A2:
        case TF::kBGRA8_sRGB:
        case TF::kABGR4:
        case TF::kARGB4:
        case TF::kBGRA10x6_XR:
        case TF::kRGB8_ETC2:
        case TF::kRGB8_ETC2_sRGB:
        case TF::kRGB8_BC1:
        case TF::kRGBA8_BC1:
        case TF::kRGBA8_BC1_sRGB:
        case TF::kYUV8_P2_420:
        case TF::kYUV8_P3_420:
        case TF::kYUV10x6_P2_420:
        case TF::kExternal:
        case TF::kS8:
        case TF::kD16:
        case TF::kD24_S8:          return false;
    }
    SkUNREACHABLE;
}

bool TextureFormatIsDepthOrStencil(TextureFormat format) {
    switch (format) {
        case TF::kS8:      [[fallthrough]];
        case TF::kD16:
        case TF::kD32F:
        case TF::kD24_S8:
        case TF::kD32F_S8:
            return true;
        default:
            return false;
    }
}

bool TextureFormatHasDepth(TextureFormat format) {
    switch (format) {
        case TF::kD16:     [[fallthrough]];
        case TF::kD32F:
        case TF::kD24_S8:
        case TF::kD32F_S8:
            return true;
        default:
            return false;
    }
}

bool TextureFormatHasStencil(TextureFormat format) {
    switch (format) {
        case TF::kS8:      [[fallthrough]];
        case TF::kD24_S8:
        case TF::kD32F_S8:
            return true;
        default:
            return false;
    }
}

bool TextureFormatIsMultiplanar(TextureFormat format) {
    switch (format) {
        case TF::kYUV8_P2_420:    [[fallthrough]];
        case TF::kYUV8_P3_420:
        case TF::kYUV10x6_P2_420:
            return true;
        default:
            return false;
    }
}

// Supporting implementation details for TextureFormat and SkColorType conversions
// ------------------------------------------------------------------------------------------------

Swizzle ReadSwizzleForColorType(SkColorType ct, TextureFormat format) {
    // TODO(b/390473370): When data transfers can apply an RG swizzle outside of the
    // SkColorType representation, we should instead apply the swizzle on upload and
    // preserve the expected order for any GPU use.
    if (ct == kARGB_4444_SkColorType && format == TextureFormat::kARGB4) {
        return Swizzle::BGRA();
    }

    uint32_t colorChannels = SkColorTypeChannelFlags(ct);
    uint32_t formatChannels = TextureFormatChannelMask(format);

    // Read swizzles only have to handle a few semantics around the sampled values, as any sort of
    // channel ordering for RGB vs BGR is handled by hardware. All we have to handle is mapping to
    // "gray", red-vs-alpha, and forcing to opaque.
    if (SkColorTypeIsAlphaOnly(ct)) {
        // If the format isn't just an alpha channel (e.g. TF::kA8), we need to adjust
        if (formatChannels != kAlpha_SkColorChannelFlag) {
            // If the format has an alpha channel, mask every other channel to 0
            if (formatChannels & kAlpha_SkColorChannelFlag) {
                return Swizzle("000a");
            } else {
                // Otherwise move the red channel to alpha
                SkASSERT(formatChannels & kRed_SkColorChannelFlag);
                return Swizzle("000r");
            }
        } else {
            // otherwise leave as "rgba" and let hardware do the right thing
            return Swizzle::RGBA();
        }
    } else {
        // First map gray to rrra; if this is just gray and not gray+alpha, it will also be forced
        // to opaque below and become rrr1.
        Swizzle swizzle;
        if (colorChannels & kGray_SkColorChannelFlag) {
            SkASSERT(formatChannels & kRed_SkColorChannelFlag);
            swizzle = Swizzle::RRRA();
        } else {
            swizzle = Swizzle::RGBA();
        }

        // Last, force the alpha to opaque if the color type masks it off but is present in the
        // texture format.
        if (!(colorChannels & kAlpha_SkColorChannelFlag) &&
             (formatChannels & kAlpha_SkColorChannelFlag)) {
            swizzle = Swizzle::Concat(swizzle, Swizzle::RGB1());
        }

        return swizzle;
    }
}

std::optional<skgpu::Swizzle> WriteSwizzleForColorType(SkColorType ct, TextureFormat format) {
    // D/S, compressed, external, and multiplanar formats aren't renderable with a color type.
    // Format support would mean we never really try to get here in practice, but keep consistent.
    if (format == TextureFormat::kExternal ||
        TextureFormatIsDepthOrStencil(format) ||
        TextureFormatIsMultiplanar(format) ||
        TextureFormatCompressionType(format) != SkTextureCompressionType::kNone) {
        return std::nullopt;
    }

    // TODO(b/390473370): When data transfers can apply an RG swizzle outside of the
    // SkColorType representation, we should instead apply the swizzle on upload and
    // preserve the expected order for any GPU use.
    if (ct == kARGB_4444_SkColorType && format == TextureFormat::kARGB4) {
        return Swizzle::BGRA();
    }

    uint32_t colorChannels = SkColorTypeChannelFlags(ct);
    uint32_t formatChannels = TextureFormatChannelMask(format);

    // Write swizzles only have to handle a few semantics around the sampled values, as any sort of
    // channel ordering for RGB vs BGR is handled by hardware. This reduces to just handling red
    // vs alpha. The other cases for read swizzles do not apply:
    //   - We disallow gray since computing luminance is beyond a swizzle.
    //   - We disallow forcing to opaque since in all cases where we'd do that we have no guarantee
    //     of what the dst pixel's alpha was. In the future, we could support forced-opaque
    //     rendering by always using shader-based blending or by guaranteeing a one-time initialize
    //     draw that forced any alpha channel to 1 (b/489785214).
    if (SkColorTypeIsAlphaOnly(ct)) {
        // If the format isn't just an alpha channel (e.g. TF::kA8), we need to adjust
        if (formatChannels != kAlpha_SkColorChannelFlag) {
            // If the format has an alpha channel, mask every other channel to 0
            if (formatChannels & kAlpha_SkColorChannelFlag) {
                return Swizzle("000a");
            } else {
                // Otherwise move the alpha channel to red
                SkASSERT(formatChannels & kRed_SkColorChannelFlag);
                return Swizzle("a000");
            }
        } else {
            // otherwise leave as "rgba" and let hardware do the right thing
            return Swizzle::RGBA();
        }
    } else {
        if (((colorChannels & formatChannels) != formatChannels) ||
            (colorChannels & kGray_SkColorChannelFlag)) {
            return std::nullopt;
        }
        return Swizzle::RGBA();
    }
}

SkSpan<const TextureFormat> PreferredTextureFormats(SkColorType ct) {
    #define N(...) std::size({__VA_ARGS__})
    #define CASE(C, ...) case C: { \
            static const std::array<TextureFormat, N(__VA_ARGS__)> kFormats{{__VA_ARGS__}}; \
            return SkSpan(kFormats); }

    switch (ct) {
        case kUnknown_SkColorType:  return {};
        // NOTE: Not all backends support all TextureFormats. Some of the more advanced formats
        // may not be supported at all and have no viable fallback. For color types that have
        // equivalent texture formats differing only in RGB vs. BGR swizzle, we allow both
        // format variations to maximize color types that have some format. For alpha-only color
        // types, we only match to red-channel formats as they have the broadest support.

        //   SkColorType                    | TextureFormat(s)...
        CASE(kAlpha_8_SkColorType,            TF::kR8)
        // NOTE: kRGB_565_SkColorType is misnamed and natively matches B5_G6_R5
        CASE(kRGB_565_SkColorType,            TF::kB5_G6_R5,   TF::kR5_G6_B5)
        // NOTE: kARGB_4444_SkColorType is misnamed and natively matches ABGR4
        CASE(kARGB_4444_SkColorType,          TF::kABGR4,      TF::kARGB4)
        CASE(kRGBA_8888_SkColorType,          TF::kRGBA8,      TF::kBGRA8)
        CASE(kRGB_888x_SkColorType,           TF::kRGB8,       TF::kRGBA8,      TF::kBGRA8)
        CASE(kBGRA_8888_SkColorType,          TF::kBGRA8,      TF::kRGBA8)
        CASE(kRGBA_1010102_SkColorType,       TF::kRGB10_A2,   TF::kBGR10_A2)
        CASE(kBGRA_1010102_SkColorType,       TF::kBGR10_A2,   TF::kRGB10_A2)
        CASE(kRGB_101010x_SkColorType,        TF::kRGB10_A2,   TF::kBGR10_A2)
        CASE(kBGR_101010x_SkColorType,        TF::kBGR10_A2,   TF::kRGB10_A2)
        CASE(kBGR_101010x_XR_SkColorType,     TF::kBGR10_XR)
        CASE(kBGRA_10101010_XR_SkColorType,   TF::kBGRA10x6_XR)
        CASE(kRGBA_10x6_SkColorType,          TF::kRGBA10x6)
        CASE(kGray_8_SkColorType,             TF::kR8)
        CASE(kRGBA_F16Norm_SkColorType,       TF::kRGBA16F)
        CASE(kRGBA_F16_SkColorType,           TF::kRGBA16F)
        CASE(kRGB_F16F16F16x_SkColorType,     TF::kRGBA16F)
        CASE(kRGBA_F32_SkColorType,           TF::kRGBA32F)
        CASE(kR8G8_unorm_SkColorType,         TF::kRG8)
        CASE(kA16_float_SkColorType,          TF::kR16F)
        CASE(kR16_float_SkColorType,          TF::kR16F)
        CASE(kR16G16_float_SkColorType,       TF::kRG16F)
        CASE(kA16_unorm_SkColorType,          TF::kR16)
        CASE(kR16_unorm_SkColorType,          TF::kR16)
        CASE(kR16G16_unorm_SkColorType,       TF::kRG16)
        CASE(kR16G16B16A16_unorm_SkColorType, TF::kRGBA16)
        CASE(kSRGBA_8888_SkColorType,         TF::kRGBA8_sRGB,
                                              TF::kBGRA8_sRGB)
        CASE(kR8_unorm_SkColorType,           TF::kR8)
    }

    SkUNREACHABLE;
    #undef CASE
    #undef N
}

std::pair<SkColorType, SkEnumBitMask<FormatXferOp>>
TextureFormatColorTypeInfo(TextureFormat format) {
    #define CASE(TF, CT, Ops) case TF: return {CT, Ops};
    using X = FormatXferOp;

    switch (format) {
        //   TextureFormat      | SkColorType                    | FormatXferOp(s)
        CASE(TF::kUnsupported,    kUnknown_SkColorType,            X::kDisabled)

        CASE(TF::kR8,             kR8_unorm_SkColorType,           X::kIdentity)
        CASE(TF::kR16,            kR16_unorm_SkColorType,          X::kIdentity)
        CASE(TF::kR16F,           kR16_float_SkColorType,          X::kIdentity)
        CASE(TF::kR32F,           kR16_float_SkColorType,          X::kDisabled)
        CASE(TF::kA8,             kAlpha_8_SkColorType,            X::kIdentity)
        CASE(TF::kRG8,            kR8G8_unorm_SkColorType,         X::kIdentity)
        CASE(TF::kRG16,           kR16G16_unorm_SkColorType,       X::kIdentity)
        CASE(TF::kRG16F,          kR16G16_float_SkColorType,       X::kIdentity)
        CASE(TF::kRG32F,          kR16G16_float_SkColorType,       X::kDisabled)
        CASE(TF::kRGB8,           kRGB_888x_SkColorType,           X::kDropAlpha)
        CASE(TF::kBGR8,           kRGB_888x_SkColorType,           X::kSwapRB | X::kDropAlpha)
        // NOTE: kRGB_565_SkColorType is misnamed and natively matches TextureFormat::kB5_G6_R5
        CASE(TF::kB5_G6_R5,       kRGB_565_SkColorType,            X::kIdentity)
        CASE(TF::kR5_G6_B5,       kRGB_565_SkColorType,            X::kSwapRB)
        CASE(TF::kRGB16,          kR16G16B16A16_unorm_SkColorType, X::kDropAlpha)
        CASE(TF::kRGB16F,         kRGB_F16F16F16x_SkColorType,     X::kDropAlpha)
        CASE(TF::kRGB32F,         kRGBA_F32_SkColorType,           X::kDropAlpha)
        CASE(TF::kRGB8_sRGB,      kSRGBA_8888_SkColorType,         X::kDropAlpha)
        CASE(TF::kBGR10_XR,       kBGR_101010x_XR_SkColorType,     X::kIdentity)
        CASE(TF::kRGBA8,          kRGBA_8888_SkColorType,          X::kIdentity)
        CASE(TF::kRGBA16,         kR16G16B16A16_unorm_SkColorType, X::kIdentity)
        CASE(TF::kRGBA16F,        kRGBA_F16_SkColorType,           X::kIdentity)
        CASE(TF::kRGBA32F,        kRGBA_F32_SkColorType,           X::kIdentity)
        CASE(TF::kRGB10_A2,       kRGBA_1010102_SkColorType,       X::kIdentity)
        CASE(TF::kRGBA10x6,       kRGBA_10x6_SkColorType,          X::kIdentity)
        CASE(TF::kRGBA8_sRGB,     kSRGBA_8888_SkColorType,         X::kIdentity)
        CASE(TF::kBGRA8,          kBGRA_8888_SkColorType,          X::kIdentity)
        CASE(TF::kBGR10_A2,       kBGRA_1010102_SkColorType,       X::kIdentity)
        CASE(TF::kBGRA8_sRGB,     kSRGBA_8888_SkColorType,         X::kSwapRB)
        // NOTE: kARGB_4444_SkColorType is misnamed and natively matches TextureFormat::kABGR4
        CASE(TF::kABGR4,          kARGB_4444_SkColorType,          X::kIdentity)
        CASE(TF::kARGB4,          kARGB_4444_SkColorType,          X::kSwapRB)
        CASE(TF::kBGRA10x6_XR,    kBGRA_10101010_XR_SkColorType,   X::kIdentity)

        // Compressed, multi-planar, and external formats can't exactly describe their data as
        // an SkColorType (although transfers with specialized data could be allowed).
        CASE(TF::kRGB8_ETC2,      kRGB_888x_SkColorType,           X::kDisabled)
        CASE(TF::kRGB8_ETC2_sRGB, kSRGBA_8888_SkColorType,         X::kDisabled)
        CASE(TF::kRGB8_BC1,       kRGB_888x_SkColorType,           X::kDisabled)
        CASE(TF::kRGBA8_BC1,      kRGBA_8888_SkColorType,          X::kDisabled)
        CASE(TF::kRGBA8_BC1_sRGB, kSRGBA_8888_SkColorType,         X::kDisabled)
        CASE(TF::kYUV8_P2_420,    kRGB_888x_SkColorType,           X::kDisabled)
        CASE(TF::kYUV8_P3_420,    kRGB_888x_SkColorType,           X::kDisabled)
        CASE(TF::kYUV10x6_P2_420, kRGBA_10x6_SkColorType,          X::kDisabled)
        CASE(TF::kExternal,       kRGBA_8888_SkColorType,          X::kDisabled)

        // Non color texture formats can't be used with SkColorType
        CASE(TF::kS8,             kUnknown_SkColorType,            X::kDisabled)
        CASE(TF::kD16,            kUnknown_SkColorType,            X::kDisabled)
        CASE(TF::kD32F,           kUnknown_SkColorType,            X::kDisabled)
        CASE(TF::kD24_S8,         kUnknown_SkColorType,            X::kDisabled)
        CASE(TF::kD32F_S8,        kUnknown_SkColorType,            X::kDisabled)
    }

    SkUNREACHABLE;
    #undef CASE
}

bool AreColorTypeAndFormatCompatible(SkColorType targetColorType, TextureFormat format) {
    // If the format maps to the color type, they are compatible
    auto [baseColorType, _] = TextureFormatColorTypeInfo(format);
    if (baseColorType != kUnknown_SkColorType && baseColorType == targetColorType) {
        return true; // shortcut
    }

    // If the color type could map to the format, they are compatible
    for (TextureFormat preferred : PreferredTextureFormats(targetColorType)) {
        if (preferred == format) {
            return true;
        }
    }

    // Also allow kRGB_888x if kRGBA_8888 is compatible since RGBx is just a swizzle. This is almost
    // always handled by the combination of base color type and preferred formats, but for external
    // and compressed formats those two functions aren't quite descriptive enough.
    if (targetColorType == kRGB_888x_SkColorType &&
        AreColorTypeAndFormatCompatible(kRGBA_8888_SkColorType, format)) {
        return true;
    }

    // Otherwise consider them incompatible
    return false;
}

} // namespace skgpu::graphite