/*
 * 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 {

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

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

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

size_t TextureFormatBytesPerBlock(TextureFormat format) {
    switch (format) {
        case TextureFormat::kUnsupported: return 0;
        case TextureFormat::kR8:          return 1;
        case TextureFormat::kR16:         return 2;
        case TextureFormat::kR16F:        return 2;
        case TextureFormat::kR32F:        return 4;
        case TextureFormat::kA8:          return 1;
        case TextureFormat::kRG8:         return 2;
        case TextureFormat::kRG16:        return 4;
        case TextureFormat::kRG16F:       return 4;
        case TextureFormat::kRG32F:       return 8;
        case TextureFormat::kRGB8:        return 3;
        case TextureFormat::kBGR8:        return 3;
        case TextureFormat::kB5_G6_R5:    return 2;
        case TextureFormat::kR5_G6_B5:    return 2;
        case TextureFormat::kRGB16:       return 6;
        case TextureFormat::kRGB16F:      return 6;
        case TextureFormat::kRGB32F:      return 12;
        case TextureFormat::kRGB8_sRGB:   return 3;
        case TextureFormat::kBGR10_XR:    return 4;
        case TextureFormat::kRGBA8:       return 4;
        case TextureFormat::kRGBA16:      return 8;
        case TextureFormat::kRGBA16F:     return 8;
        case TextureFormat::kRGBA32F:     return 16;
        case TextureFormat::kRGB10_A2:    return 4;
        case TextureFormat::kRGBA10x6:    return 8;
        case TextureFormat::kRGBA8_sRGB:  return 4;
        case TextureFormat::kBGRA8:       return 4;
        case TextureFormat::kBGR10_A2:    return 4;
        case TextureFormat::kBGRA8_sRGB:  return 4;
        case TextureFormat::kABGR4:       return 2;
        case TextureFormat::kARGB4:       return 2;
        case TextureFormat::kBGRA10x6_XR: return 8;
        case TextureFormat::kS8:          return 1;
        case TextureFormat::kD16:         return 2;
        case TextureFormat::kD32F:        return 4;
        case TextureFormat::kD24_S8:      return 4;
        case TextureFormat::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 TextureFormat::kRGB8_ETC2:
        case TextureFormat::kRGB8_ETC2_sRGB:
        case TextureFormat::kRGB8_BC1:
        case TextureFormat::kRGBA8_BC1:
        case TextureFormat::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 TextureFormat::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 TextureFormat::kYUV8_P2_420:
        case TextureFormat::kYUV8_P3_420:
            return 3;
        case TextureFormat::kYUV10x6_P2_420:
            return 6;
    }
    SkUNREACHABLE;
}

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

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

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

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

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

        case TextureFormat::kS8:             [[fallthrough]];
        case TextureFormat::kD16:
        case TextureFormat::kD32F:
        case TextureFormat::kD24_S8:
        case TextureFormat::kD32F_S8:
        case TextureFormat::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 == TextureFormat::kBGR10_XR ||
             format == TextureFormat::kBGRA10x6_XR ||
             format == TextureFormat::kS8);
}

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

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

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

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

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

bool TextureFormatIsMultiplanar(TextureFormat format) {
    switch (format) {
        case TextureFormat::kYUV8_P2_420:    [[fallthrough]];
        case TextureFormat::kYUV8_P3_420:
        case TextureFormat::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. TextureFormat::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. TextureFormat::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) || (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.

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

    SkUNREACHABLE;
    #undef CASE
    #undef N
}

} // namespace skgpu::graphite