Michael Ludwig

This commit introduces **new overloads for `SkImages::WrapTexture`** in the **Graphite GPU backend**, enabling the `SkColorType` to be inferred directly from the texture format, thus simplifying API usage. This **API enhancement** also allows `kUnknown_SkAlphaType` to force an opaque interpretation for any color type, improving flexibility and resolving ambiguities in single-channel texture handling. The change streamlines image creation by reducing caller burden and potential `SkColorType` mismatches, impacting various image factories and tests across the system.

This commit **refactors** the **Graphite pixel transfer paths** to use `TextureFormatXferFn` for all pixel format conversions, replacing the deprecated `Caps::supportedTransferColorType()`. This change centralizes conversion logic within `Context::transferPixels` and `UploadTask`'s `UploadSource` and `UploadInstance` creation, improving consistency for both GPU-to-CPU readbacks and CPU-to-GPU uploads. The `RPOps` struct within `TextureFormatXferFn` is now **reference-counted** to facilitate sharing and lambda captures, and `TextureUploadWriter` gains a new `convert` method leveraging this functionality. This **maintenance** effort **streamlines the pixel transfer architecture**, laying the groundwork for significant API cleanup in related `Upload` and `TextureUploadWriter` components.

This commit **refactors** the **Graphite GPU backend's texture upload mechanism** by removing the `UploadSource` parameter from the `Texture::canUploadOnHost` virtual function. The decision logic for applying host-side uploads with intermediate conversions, previously dependent on `UploadSource` within `Texture` subclasses, is now centralized and handled universally within the `UploadTask` system. This **architectural improvement** simplifies the `Texture` interface, such as `VulkanTexture`, by abstracting conversion concerns and preparing for more consistent and robust handling of all format conversions.

This commit introduces a new `format()` helper function to the **Graphite** `TextureProxy` class, providing a standardized and consistent way to retrieve a texture's format. This **maintenance refactoring** updates numerous internal **Graphite** components, including image factories, device drawing, and texture utility functions, to utilize this new helper. The change centralizes texture format access, improving code consistency and maintainability across the **GPU rendering backend**. This internal improvement streamlines texture format queries within **Graphite**, affecting how various rendering and image processing operations interact with texture properties.

This commit **refactors** the **Graphite rendering backend** to consistently plumb `TextureProxyView` through various **pixel readback and upload codepaths**, ensuring that necessary swizzle information is available for correct readbacks when color types are ambiguous. The **`DrawContext`** now always creates its `TextureProxyView` with the appropriate read swizzle and caches whether its target is texturable, avoiding redundant `Caps` queries. This widespread **maintenance** and **refactoring** effort impacts core components like `Context`, `Device`, `DrawContext`, and `Surface`, standardizing texture access and preparing the system for future changes, such as the adoption of `TextureFormatXferFn`, while addressing bug b/390473370.

This commit **enhances Graphite's texture format transfer functions** (`TextureFormatXferFn`) by introducing support for **color space and alpha type conversions** during texture data transfers. It allows `MakeCpuToGpu` and `MakeGpuToCpu` to accept `SkColorSpaceXformSteps`, enabling transformations like premultiplication and unpremultiplication of alpha. The `RPOps::Make` function was **refactored** to be templated, providing a flexible mechanism for applying raster pipeline operations. This **new capability** required significant changes to the internal swizzle logic, splitting `srcToDst` into `loadSrc` and `storeDst` for precise alpha handling, and is thoroughly validated by **extensive updates to `TextureFormatTest`** covering various alpha and color space combinations.

This commit delivers a **bug fix** for the **Graphite GPU backend**, addressing an issue where `TextureFormatXferFn::MakeCpuToGpu` failed to correctly convert non-gray CPU colors to gray when targeting red-only R8 textures during CPU-to-GPU transfers. A new heuristic is introduced within `MakeCpuToGpu` to detect when a grayscale conversion is necessary based on the read swizzle, ensuring proper data representation. This change improves the reliability of the **texture format transfer pipeline** for gray-scale textures. **Unit tests** in `tests/graphite/TextureFormatTest.cpp` are updated to accurately reflect and validate these gray color type conversions, preventing future regressions.

This commit **refactors** the **Graphite GPU backend's texture format transfer functions** by modifying `TextureFormatXferFn` to pre-build `SkRasterPipeline` objects conditionally within its `MakeCpuToGpu` and `MakeGpuToCpu` methods. This **architectural improvement** introduces a new `RPOps` struct to better manage pipeline operations, making it significantly easier to add new raster pipeline ops that depend on the transfer direction. The **refactoring** enhances the flexibility and extensibility of texture format conversions within **Graphite**, paving the way for more complex and optimized transfer logic.

This commit introduces **extended texture format conversion operations** within **Graphite's `TextureFormatXferFn`**, specifically enhancing support for 3-channel formats. It adds new capabilities for efficient alpha padding and dropping, utilizing SIMD and row-by-row processing to avoid full image allocations during CPU-to-GPU and GPU-to-CPU transfers. This **optimization** significantly improves memory efficiency for format conversions and establishes a foundation for future enhancements aimed at reducing reliance on `SkRasterPipeline` for typical scenarios.

This commit implements a **bug fix** within the **Graphite** rendering engine's **TextureFormatTest** module. It modifies the `channel_to_bits` function to explicitly handle padding channels, ensuring they ignore input values and use a sentinel instead of attempting conversion. This change prevents **NaN conversion** when processing texture formats, thereby improving the reliability and correctness of texture data handling.

This commit **reverts** a previous change, thereby **reintroducing** the use of `SK_FloatNaN` within the `channel_to_float` function in the **Graphite testing framework's** `TextureFormatTest.cpp`. The original modification, which removed `NaN` for `Signed` and `Pad` channel types, was found not to be the source of a UBSAN complaint. This **maintenance revert** restores the original test logic, indicating that the prior change did not resolve the underlying issue. The impact is confined to **testing** within the **Graphite** subsystem, ensuring test stability while the actual cause of the UBSAN warning is investigated.

This commit **introduces the `kR16_float_SkColorType`**, a new single-channel half-float red color type, as a **new capability** within Skia. It comprehensively integrates this color type across **core Skia functionalities**, including pixel conversion, image info, `SkPixmap`, and `SkRasterPipeline` operations. Furthermore, it extends support to **all major GPU backends** (Ganesh: D3D, GL, Metal, Vulkan; Graphite: Dawn, Metal, Vulkan) by updating their format tables and testing combinations, while also **fixing angle-d3d11 failures** encountered in a previous attempt. This change enables efficient handling of single-channel float data, updates to account for new `TextureFormatTest` APIs, and includes a mapping for storing r16f data in luminance 16f textures.

This commit performs **maintenance** on the **Graphite testing framework** by modifying the `channel_to_float` helper function within `tests/graphite/TextureFormatTest.cpp`. Previously, this function would return `NaN` for `Signed` and `Pad` channel types, which triggered **UBSAN warnings**. The change now ensures that these channel types fall through to `UNorm` processing instead, effectively **suppressing these warnings**. This **bug fix** improves the robustness and reliability of the **Graphite test suite**, preventing false positive reports from UBSAN during test execution.

This commit introduces a **new `TextureFormatXferFn` API** within the **Graphite rendering engine** to centralize and standardize the conversion of texture data between CPU color types and GPU formats with read swizzles. This **refactoring** effort provides a shared mechanism for data transfer, aiming to replace duplicated logic found in areas like `UploadInstance::Make` and async readback code. By establishing this foundational API, it **unblocks future work** to remove reliance on `colortype` in the public API, fix `RenderEngine` wrapping issues, and enable subsequent performance optimizations for texture data handling.

This commit introduces **comprehensive unit tests** for **Graphite's texture format data transfer** mechanisms, addressing `Bug: b/390473370`. The new tests systematically validate uploads from and readbacks to every `SkColorType` for all texture formats, employing sophisticated logic to generate input pixel values and derive expected outputs while accounting for channel types and precision loss. This **new testing infrastructure** significantly improves the validation of data conversions between CPU-side `SkColorType`s and GPU-side texture formats, ensuring correctness across a vast array of combinations and laying the groundwork for future transfer API development. A minor **refactoring** in `src/gpu/graphite/TextureFormat.h` also occurred to clean up enum declarations.

This commit **fixes a bug** in the **Graphite Dawn backend** by ensuring **MSRTSS (Multi-Sample Render To Single Sample) support** is correctly advertised. Specifically, the `src/gpu/graphite/dawn/DawnCaps.cpp` file, particularly within the `getTextureUsageAndSampleCounts` function, now accurately reports these capabilities by properly checking the relevant WebGPU extension and texture format. This **bug fix** is crucial for applications relying on the **Graphite Dawn backend** to correctly determine and utilize multi-sampled rendering features. It prevents potential rendering issues or incorrect feature usage by providing reliable **graphics capabilities reporting** for the **Dawn (WebGPU) graphics API**.

This commit **reverts** a previous change that aimed to fix Vulkan extension mismanagement within the **Vulkan test utilities** (`VkTestUtils`). The original modification, which adjusted how extensions and layers were initialized in `VkTestUtils.cpp` and `VkTestUtils.h` to correctly utilize `VulkanPreferredFeatures`, inadvertently introduced **critical runtime failures** in various Vulkan tests. These failures included memory allocation errors and the inability to acquire function pointers for Vulkan commands like `vkGetSemaphoreFdKHR`. This **revert** restores the prior **Vulkan extension and layer initialization logic** and `TestVkFeatures` struct, thereby eliminating the newly introduced test instability and ensuring the **Vulkan backend context creation** functions correctly.

This commit **updates Graphite tests** to use the `syncedSubmit` helper, which implements a busy-wait mechanism for command submission when direct yielding to **WebGPU** is not feasible. This is a **maintenance** and **testing improvement** that standardizes how **Graphite tests** synchronize their context, ensuring more robust and consistent behavior across different GPU backends. Specifically, `tests/graphite/SubmitWithFinishProcTest.cpp` now leverages `DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS` and `testCtx->syncedSubmit` to improve the reliability of test execution and context management within the **Graphite** rendering pipeline.

This commit introduces a **new capability** by adding an `invert()` method to the **`Swizzle` utility class** within the GPU module. This function computes the inverse of a swizzle, which is crucial for a new format transfer function API to correctly handle CPU-to-GPU data transfers. It ensures a well-defined write swizzle can always be derived, even for `TextureFormat`s that do not explicitly define one for rendering. The change includes the method's implementation in `src/gpu/Swizzle.cpp` and `src/gpu/Swizzle.h`, accompanied by **unit tests** in `tests/graphite/SwizzleTest.cpp` to verify its behavior across different swizzle configurations.

This commit **refactors** the **Graphite `TextureFormatTest`** to define texture format properties more explicitly using **per-channel information**. It introduces structures like `ChannelDataType` and `Channel` to specify the name, type, and bit size for each channel, from which other format properties are now **derived**, improving the accuracy and maintainability of expected pixel value generation. This **refactoring** of `tests/graphite/TextureFormatTest.cpp` addresses a need for more explicit `TextureFormat` and `SkColorType` layouts. The change also provides channel definitions for all `SkColorTypes`, serving as a **preparatory step** for future work on **data transfer generation and validation**.