| /* |
| * Copyright 2022 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/dawn/DawnGraphiteUtils.h" |
| |
| #include "include/gpu/ShaderErrorHandler.h" |
| #include "include/gpu/graphite/Context.h" |
| #include "include/gpu/graphite/dawn/DawnBackendContext.h" |
| #include "include/private/base/SkTArray.h" |
| #include "src/gpu/graphite/ContextPriv.h" |
| #include "src/gpu/graphite/TextureFormat.h" |
| #include "src/gpu/graphite/dawn/DawnQueueManager.h" |
| #include "src/gpu/graphite/dawn/DawnSharedContext.h" |
| |
| using namespace skia_private; |
| |
| namespace skgpu::graphite { |
| |
| namespace ContextFactory { |
| std::unique_ptr<Context> MakeDawn(const DawnBackendContext& backendContext, |
| const ContextOptions& options) { |
| sk_sp<SharedContext> sharedContext = DawnSharedContext::Make(backendContext, options); |
| if (!sharedContext) { |
| return nullptr; |
| } |
| |
| auto queueManager = |
| std::make_unique<DawnQueueManager>(backendContext.fQueue, sharedContext.get()); |
| if (!queueManager) { |
| return nullptr; |
| } |
| |
| auto context = ContextCtorAccessor::MakeContext(std::move(sharedContext), |
| std::move(queueManager), |
| options); |
| SkASSERT(context); |
| return context; |
| } |
| } // namespace ContextFactory |
| |
| namespace { |
| // If the extension is available (or if it's empty), the format flag bitmask is supported |
| using ExtensionLimitedFlags = std::pair<std::optional<wgpu::FeatureName>, |
| SkEnumBitMask<DawnFormatFlag>>; |
| |
| // These two operators allow an ExtensionLimitedFlags to be built with syntax like: |
| // wgpu::FeatureName >> Filter | Resolve | ... |
| // without needing extra parentheses or braces. The | operator is needed to resolve precedence. |
| ExtensionLimitedFlags operator>>(std::optional<wgpu::FeatureName> extension, DawnFormatFlag flags) { |
| return std::make_pair(extension, flags); |
| } |
| ExtensionLimitedFlags operator|(ExtensionLimitedFlags flagSet, |
| SkEnumBitMask<DawnFormatFlag> flags) { |
| return std::make_pair(flagSet.first, flagSet.second | flags); |
| } |
| |
| // Stores all ExtensionLimitedFlags for every format and every extension |
| class DawnFormatCapabilityMap { |
| public: |
| static const DawnFormatCapabilityMap& Get(); |
| |
| SkEnumBitMask<DawnFormatFlag> getFormatFlags(wgpu::Device device, |
| wgpu::TextureFormat format) const { |
| const ExtensionFlagList& features = |
| fFormatFeatures[(int) DawnFormatToTextureFormat(format)]; |
| SkEnumBitMask<DawnFormatFlag> supported; |
| for (const ExtensionLimitedFlags& featureSet : features) { |
| if (!featureSet.first.has_value() || device.HasFeature(*featureSet.first)) { |
| supported |= featureSet.second; |
| } |
| } |
| return supported; |
| } |
| |
| private: |
| // N = 3 since no current wgpu::TextureFormat modifies its behavior more than its baseline and |
| // two additional extensions. |
| using ExtensionFlagList = STArray<3, ExtensionLimitedFlags>; |
| using FormatFlags = std::pair<wgpu::TextureFormat, ExtensionFlagList>; |
| |
| DawnFormatCapabilityMap(std::initializer_list<FormatFlags> features) { |
| for (const auto& [format, featureList] : features) { |
| TextureFormat tf = DawnFormatToTextureFormat(format); |
| if (tf == TextureFormat::kUnsupported) { continue; } // Skip if Graphite doesn't use it |
| |
| int index = static_cast<int>(tf); |
| if (fFormatFeatures[index].empty()) { |
| fFormatFeatures[index] = featureList; |
| } else { |
| // Allow concatenation, so long as there aren't duplicate features |
| #if defined(SK_DEBUG) |
| for (const ExtensionLimitedFlags& priorExt : fFormatFeatures[index]) { |
| for (const ExtensionLimitedFlags& newExt : featureList) { |
| SkASSERT(priorExt.first != newExt.first); |
| } |
| } |
| #endif |
| fFormatFeatures[index].push_back_n(featureList.size(), featureList.data()); |
| } |
| } |
| SkASSERT(fFormatFeatures[static_cast<int>(TextureFormat::kUnsupported)].empty()); |
| } |
| |
| // We only care about wgpu::TextureFormats that map back to a TextureFormat. |
| std::array<ExtensionFlagList, kTextureFormatCount> fFormatFeatures; |
| }; |
| |
| const DawnFormatCapabilityMap& DawnFormatCapabilityMap::Get() { |
| using enum DawnFormatFlag; |
| using enum wgpu::TextureFormat; |
| |
| // Alias some commonly used feature names |
| using F = wgpu::FeatureName; |
| static constexpr std::optional<F> Compat = std::nullopt; // The baseline |
| static constexpr F Core = F::CoreFeaturesAndLimits; |
| static constexpr F Tier1 = F::TextureFormatsTier1; |
| static constexpr F Tier2 = F::TextureFormatsTier2; |
| |
| // To read this table with the HTML table in the links below, each format corresponds to a row |
| // in the original document. For a format, the first extension listed is the "Required feature" |
| // column, where blank is `Compat`. Any additional conditional capabilities in the row are |
| // listed below the primary extension, followed by >> to indicate the capabilities they add. |
| // |
| // As noted in DawnFormatFlag, we convert the `GPUTextureSampleType` column to `Filter` if it |
| // includes "float". The other sample types ("unfilterable-float", "uint", and "sint") are |
| // implicitly defined by the data type of the format, having "filterable-float" capabilities is |
| // the bit we care about. |
| static const DawnFormatCapabilityMap kSingleton{{ |
| // Plain color formats: https://gpuweb.github.io/gpuweb/#plain-color-formats |
| // 8 bits per component |
| {R8Unorm, {Compat >> Filter | Render | Blend | MSAA | Resolve, |
| Tier1 >> WriteOnly | ReadOnly, |
| Tier2 >> ReadWrite}}, |
| |
| {R8Snorm, {Compat >> Filter, |
| Tier1 >> Render | Blend | MSAA | Resolve | WriteOnly | ReadOnly}}, |
| |
| {R8Uint, {Compat >> Render, |
| Core >> MSAA, |
| Tier1 >> WriteOnly | ReadOnly, |
| Tier2 >> ReadWrite}}, |
| |
| {R8Sint, {Compat >> Render, |
| Core >> MSAA, |
| Tier1 >> WriteOnly | ReadOnly, |
| Tier2 >> ReadWrite}}, |
| |
| {RG8Unorm, {Compat >> Filter | Render | Blend | MSAA | Resolve, |
| Tier1 >> WriteOnly | ReadOnly}}, |
| |
| {RG8Snorm, {Compat >> Filter, |
| Tier1 >> Render | Blend | MSAA | Resolve | WriteOnly | ReadOnly}}, |
| |
| {RG8Uint, {Compat >> Render, |
| Core >> MSAA, |
| Tier1 >> WriteOnly | ReadOnly}}, |
| |
| {RG8Sint, {Compat >> Render, |
| Core >> MSAA, |
| Tier1 >> WriteOnly | ReadOnly}}, |
| |
| {RGBA8Unorm, {Compat >> Filter | Render | Blend | MSAA | Resolve | WriteOnly | ReadOnly, |
| Tier2 >> ReadWrite}}, |
| |
| {RGBA8UnormSrgb, {Compat >> Filter | Render | Blend | MSAA | Resolve}}, |
| |
| {RGBA8Snorm, {Compat >> Filter | WriteOnly | ReadOnly, |
| Tier1 >> Render | Blend | MSAA | Resolve}}, |
| |
| {RGBA8Uint, {Compat >> Render | WriteOnly | ReadOnly, |
| Core >> MSAA, |
| Tier2 >> ReadWrite}}, |
| |
| {RGBA8Sint, {Compat >> Render | WriteOnly | ReadOnly, |
| Core >> MSAA, |
| Tier2 >> ReadWrite}}, |
| |
| {BGRA8Unorm, {Compat >> Filter | Render | Blend | MSAA | Resolve, |
| F::BGRA8UnormStorage >> WriteOnly}}, |
| |
| {BGRA8UnormSrgb, {Core >> Filter | Render | Blend | MSAA | Resolve}}, |
| |
| // 16 bits per component |
| {R16Unorm, {Tier1 >> Render | Blend | MSAA | WriteOnly | ReadOnly}}, |
| |
| {R16Snorm, {Tier1 >> Render | Blend | MSAA | WriteOnly | ReadOnly}}, |
| |
| {R16Uint, {Compat >> Render, |
| Core >> MSAA, |
| Tier1 >> WriteOnly | ReadOnly, |
| Tier2 >> ReadWrite}}, |
| |
| {R16Sint, {Compat >> Render, |
| Core >> MSAA, |
| Tier1 >> WriteOnly | ReadOnly, |
| Tier2 >> ReadWrite}}, |
| |
| {R16Float, {Compat >> Filter | Render | Blend | MSAA | Resolve, |
| Tier1 >> WriteOnly | ReadOnly, |
| Tier2 >> ReadWrite}}, |
| |
| {RG16Unorm, {Tier1 >> Render | Blend | MSAA | WriteOnly | ReadOnly}}, |
| |
| {RG16Snorm, {Tier1 >> Render | Blend | MSAA | WriteOnly | ReadOnly}}, |
| |
| {RG16Uint, {Compat >> Render, |
| Core >> MSAA, |
| Tier1 >> WriteOnly | ReadOnly}}, |
| |
| {RG16Sint, {Compat >> Render, |
| Core >> MSAA, |
| Tier1 >> WriteOnly | ReadOnly}}, |
| |
| {RG16Float, {Compat >> Filter | Render | Blend | MSAA | Resolve, |
| Tier1 >> WriteOnly | ReadOnly}}, |
| |
| {RGBA16Unorm, {Tier1 >> Render | Blend | MSAA | WriteOnly | ReadOnly}}, |
| |
| {RGBA16Snorm, {Tier1 >> Render | Blend | MSAA | WriteOnly | ReadOnly}}, |
| |
| {RGBA16Uint, {Compat >> Render | WriteOnly | ReadOnly, |
| Core >> MSAA, |
| Tier2 >> ReadWrite}}, |
| |
| {RGBA16Sint, {Compat >> Render | WriteOnly | ReadOnly, |
| Core >> MSAA, |
| Tier2 >> ReadWrite}}, |
| |
| {RGBA16Float, {Compat >> Filter | Render | Blend | WriteOnly | ReadOnly, |
| Core >> MSAA | Resolve, |
| Tier2 >> ReadWrite}}, |
| |
| // 32 bits per component |
| {R32Uint, {Compat >> Render | WriteOnly | ReadOnly | ReadWrite}}, |
| |
| {R32Sint, {Compat >> Render | WriteOnly | ReadOnly | ReadWrite}}, |
| |
| {R32Float, {Compat >> Render | WriteOnly | ReadOnly | ReadWrite, |
| Core >> MSAA, |
| F::Float32Filterable >> Filter, |
| F::Float32Blendable >> Blend}}, |
| |
| {RG32Uint, {Compat >> Render, |
| Core >> WriteOnly | ReadOnly}}, |
| |
| {RG32Sint, {Compat >> Render, |
| Core >> WriteOnly | ReadOnly}}, |
| |
| {RG32Float, {Compat >> Render, |
| Core >> WriteOnly | ReadOnly, |
| F::Float32Filterable >> Filter, |
| F::Float32Blendable >> Blend}}, |
| |
| {RGBA32Uint, {Compat >> Render | WriteOnly | ReadOnly, |
| Tier2 >> ReadWrite}}, |
| |
| {RGBA32Sint, {Compat >> Render | WriteOnly | ReadOnly, |
| Tier2 >> ReadWrite}}, |
| |
| {RGBA32Float, {Compat >> Render| WriteOnly | ReadOnly, |
| Tier2 >> ReadWrite, |
| F::Float32Filterable >> Filter, |
| F::Float32Blendable >> Blend}}, |
| |
| // mixed component width, 32 bits per texel |
| {RGB10A2Uint, {Compat >> Render, |
| Core >> MSAA, |
| Tier1 >> WriteOnly | ReadOnly}}, |
| |
| {RGB10A2Unorm, {Compat >> Filter | Render | Blend | MSAA | Resolve, |
| Tier1 >> WriteOnly | ReadOnly}}, |
| |
| {RG11B10Ufloat, {Compat >> Filter, |
| F::RG11B10UfloatRenderable >> Render | Blend | MSAA | Resolve, |
| Tier1 >> WriteOnly | ReadOnly}}, |
| |
| // Depth-stencil formats: https://gpuweb.github.io/gpuweb/#depth-formats |
| {Stencil8, {Compat >> Render | MSAA}}, |
| {Depth16Unorm, {Compat >> Render | MSAA}}, |
| {Depth24Plus, {Compat >> Render | MSAA}}, |
| {Depth24PlusStencil8, {Compat >> Render | MSAA}}, |
| {Depth32Float, {Compat >> Render | MSAA}}, |
| {Depth32FloatStencil8, {Compat >> Render | MSAA}}, |
| |
| // Packed formats: https://gpuweb.github.io/gpuweb/#packed-formats |
| // (Only including compressed formats for BC1 and ETC2 for brevity, Skia doesn't use ASTC) |
| {RGB9E5Ufloat, {Compat >> Filter}}, |
| {BC1RGBAUnorm, {F::TextureCompressionBC >> Filter}}, |
| {BC1RGBAUnormSrgb, {F::TextureCompressionBC >> Filter}}, |
| {ETC2RGB8Unorm, {F::TextureCompressionETC2 >> Filter}}, |
| {ETC2RGB8UnormSrgb, {F::TextureCompressionETC2 >> Filter}}, |
| |
| #if !defined(__EMSCRIPTEN__) |
| // Dawn-native only (either format OR feature), these are not included in the format tables. |
| |
| // NOTE: Unorm16TextureFormats is not an extension of TextureFormatsTier1 and is deprecated. |
| // There will be a new Unorm16Filterable extension that augments the Tier1 capabilities. |
| {R16Unorm, {F::Unorm16TextureFormats >> Filter | Render | Blend | MSAA | Resolve}}, |
| {RG16Unorm, {F::Unorm16TextureFormats >> Filter | Render | Blend | MSAA | Resolve}}, |
| {RGBA16Unorm, {F::Unorm16TextureFormats >> Filter | Render | Blend | MSAA | Resolve}}, |
| // The multiplanar formats have no format capabilities on their own, they produce texture |
| // views for each plane that have more capabilities. |
| {R8BG8Biplanar420Unorm, {Core >> None}}, |
| {R10X6BG10X6Biplanar420Unorm, {Core >> None}}, |
| {R8BG8Biplanar422Unorm, {Core >> None}}, |
| {R10X6BG10X6Biplanar422Unorm, {Core >> None}}, |
| {R8BG8Biplanar444Unorm, {Core >> None}}, |
| {R10X6BG10X6Biplanar444Unorm, {Core >> None}}, |
| // This corresponds to Vulkan's external formats, which are always filterable. |
| {OpaqueYCbCrAndroid, {F::YCbCrVulkanSamplers >> Filter}}, |
| #endif |
| }}; |
| return kSingleton; |
| } |
| |
| } // anonymous namespace |
| |
| SkEnumBitMask<DawnFormatFlag> DawnTextureFormatSupport(wgpu::Device device, |
| wgpu::TextureFormat format) { |
| return DawnFormatCapabilityMap::Get().getFormatFlags(device, format); |
| } |
| |
| // *** Ground truth bidirectional map between TextureFormat and wgpu::TextureFormat *** |
| |
| #define DAWN_FORMAT_MAPPING(M) \ |
| M(TextureFormat::kR8, wgpu::TextureFormat::R8Unorm) \ |
| M(TextureFormat::kR16, wgpu::TextureFormat::R16Unorm) \ |
| M(TextureFormat::kR16F, wgpu::TextureFormat::R16Float) \ |
| M(TextureFormat::kR32F, wgpu::TextureFormat::R32Float) \ |
| /*TextureFormat::kA8, unsupported */ \ |
| M(TextureFormat::kRG8, wgpu::TextureFormat::RG8Unorm) \ |
| M(TextureFormat::kRG16, wgpu::TextureFormat::RG16Unorm) \ |
| M(TextureFormat::kRG16F, wgpu::TextureFormat::RG16Float) \ |
| M(TextureFormat::kRG32F, wgpu::TextureFormat::RG32Float) \ |
| /*TextureFormat::kRGB8, unsupported */ \ |
| /*TextureFormat::kBGR8, unsupported */ \ |
| /*TextureFormat::kB5_G6_R5, unsupported */ \ |
| /*TextureFormat::kR5_G6_B5, unsupported */ \ |
| /*TextureFormat::kRGB16, unsupported */ \ |
| /*TextureFormat::kRGB16F, unsupported */ \ |
| /*TextureFormat::kRGB32F, unsupported */ \ |
| /*TextureFormat::kRGB8_sRGB, unsupported */ \ |
| /*TextureFormat::kBGR10_XR, unsupported */ \ |
| M(TextureFormat::kRGBA8, wgpu::TextureFormat::RGBA8Unorm) \ |
| M(TextureFormat::kRGBA16, wgpu::TextureFormat::RGBA16Unorm) \ |
| M(TextureFormat::kRGBA16F, wgpu::TextureFormat::RGBA16Float) \ |
| M(TextureFormat::kRGBA32F, wgpu::TextureFormat::RGBA32Float) \ |
| M(TextureFormat::kRGB10_A2, wgpu::TextureFormat::RGB10A2Unorm) \ |
| /*TextureFormat::kRGBA10x6, unsupported */ \ |
| M(TextureFormat::kRGBA8_sRGB, wgpu::TextureFormat::RGBA8UnormSrgb) \ |
| M(TextureFormat::kBGRA8, wgpu::TextureFormat::BGRA8Unorm) \ |
| /*TextureFormat::kBGR10_A2, unsupported */ \ |
| M(TextureFormat::kBGRA8_sRGB, wgpu::TextureFormat::BGRA8UnormSrgb) \ |
| /*TextureFormat::kABGR4, unsupported */ \ |
| /*TextureFormat::kARGB4, unsupported */ \ |
| /*TextureFormat::kBGRA10x6_XR, unsupported */ \ |
| M(TextureFormat::kRGB8_ETC2, wgpu::TextureFormat::ETC2RGB8Unorm) \ |
| M(TextureFormat::kRGB8_ETC2_sRGB, wgpu::TextureFormat::ETC2RGB8UnormSrgb) \ |
| /*TextureFormat::kRGB_BC1 unsupported */ \ |
| M(TextureFormat::kRGBA8_BC1, wgpu::TextureFormat::BC1RGBAUnorm) \ |
| M(TextureFormat::kRGBA8_BC1_sRGB, wgpu::TextureFormat::BC1RGBAUnormSrgb) \ |
| /*TextureFormat::kYUV8_P2_420, Native-only */ \ |
| /*TextureFormat::kYUV8_P3_420, unsupported */ \ |
| /*TextureFormat::kYUV10x6_P2_420, Native-only */ \ |
| /*TextureFormat::kYUV8_P2_422, Native-only */ \ |
| /*TextureFormat::kYUV8_P3_422, unsupported */ \ |
| /*TextureFormat::kYUV10x6_P2_422, Native-only */ \ |
| /*TextureFormat::kYUV8_P2_444, Native-only */ \ |
| /*TextureFormat::kYUV8_P3_444, unsupported */ \ |
| /*TextureFormat::kYUV10x6_P2_444, Native-only */ \ |
| /*TextureFormat::kExternal, Native-only */ \ |
| M(TextureFormat::kS8, wgpu::TextureFormat::Stencil8) \ |
| M(TextureFormat::kD16, wgpu::TextureFormat::Depth16Unorm) \ |
| M(TextureFormat::kD32F, wgpu::TextureFormat::Depth32Float) \ |
| M(TextureFormat::kD24_S8, wgpu::TextureFormat::Depth24PlusStencil8) \ |
| M(TextureFormat::kD32F_S8, wgpu::TextureFormat::Depth32FloatStencil8) \ |
| |
| #if !defined(__EMSCRIPTEN__) |
| #define DAWN_FORMAT_MAPPING_NATIVE_ONLY(M) \ |
| M(TextureFormat::kYUV8_P2_420, wgpu::TextureFormat::R8BG8Biplanar420Unorm) \ |
| M(TextureFormat::kYUV10x6_P2_420, wgpu::TextureFormat::R10X6BG10X6Biplanar420Unorm) \ |
| M(TextureFormat::kYUV8_P2_422, wgpu::TextureFormat::R8BG8Biplanar422Unorm) \ |
| M(TextureFormat::kYUV10x6_P2_422, wgpu::TextureFormat::R10X6BG10X6Biplanar422Unorm) \ |
| M(TextureFormat::kYUV8_P2_444, wgpu::TextureFormat::R8BG8Biplanar444Unorm) \ |
| M(TextureFormat::kYUV10x6_P2_444, wgpu::TextureFormat::R10X6BG10X6Biplanar444Unorm) \ |
| M(TextureFormat::kExternal, wgpu::TextureFormat::OpaqueYCbCrAndroid) |
| #else |
| #define DAWN_FORMAT_MAPPING_NATIVE_ONLY(M) |
| #endif |
| |
| TextureFormat DawnFormatToTextureFormat(wgpu::TextureFormat format) { |
| #define M(TF, WGPU) case WGPU: return TF; |
| switch(format) { |
| DAWN_FORMAT_MAPPING(M) |
| DAWN_FORMAT_MAPPING_NATIVE_ONLY(M) |
| default: return TextureFormat::kUnsupported; |
| } |
| #undef M |
| } |
| wgpu::TextureFormat TextureFormatToDawnFormat(TextureFormat format) { |
| #define M(TF, WGPU) case TF: return WGPU; |
| switch(format) { |
| DAWN_FORMAT_MAPPING(M) |
| DAWN_FORMAT_MAPPING_NATIVE_ONLY(M) |
| default: return wgpu::TextureFormat::Undefined; |
| } |
| #undef M |
| } |
| |
| static bool check_shader_module([[maybe_unused]] const DawnSharedContext* sharedContext, |
| wgpu::ShaderModule* module, |
| const char* shaderText, |
| ShaderErrorHandler* errorHandler) { |
| // Prior to emsdk 3.1.51 wgpu::ShaderModule::GetCompilationInfo is unimplemented. |
| #if defined(__EMSCRIPTEN__) && \ |
| ((__EMSCRIPTEN_major__ < 3 || \ |
| (__EMSCRIPTEN_major__ == 3 && __EMSCRIPTEN_minor__ < 1) || \ |
| (__EMSCRIPTEN_major__ == 3 && __EMSCRIPTEN_minor__ == 1 && __EMSCRIPTEN_tiny__ < 51))) |
| return true; |
| #else |
| struct Handler { |
| static void Fn(WGPUCompilationInfoRequestStatus status, |
| const WGPUCompilationInfo* info, |
| void* userdata) { |
| Handler* self = reinterpret_cast<Handler*>(userdata); |
| SkASSERT(status == WGPUCompilationInfoRequestStatus_Success); |
| |
| // Walk the message list and check for hard errors. |
| self->fSuccess = true; |
| for (size_t index = 0; index < info->messageCount; ++index) { |
| const WGPUCompilationMessage& entry = info->messages[index]; |
| if (entry.type == WGPUCompilationMessageType_Error) { |
| self->fSuccess = false; |
| break; |
| } |
| } |
| |
| // If we found a hard error, report the compilation messages to the error handler. |
| if (!self->fSuccess) { |
| std::string errors; |
| for (size_t index = 0; index < info->messageCount; ++index) { |
| const WGPUCompilationMessage& entry = info->messages[index]; |
| std::string messageString(entry.message.data, entry.message.length); |
| errors += "line " + std::to_string(entry.lineNum) + ':' + |
| std::to_string(entry.linePos) + ' ' + messageString + '\n'; |
| } |
| self->fErrorHandler->compileError( |
| self->fShaderText, errors.c_str(), /*shaderWasCached=*/false); |
| } |
| } |
| |
| const char* fShaderText; |
| ShaderErrorHandler* fErrorHandler; |
| bool fSuccess = false; |
| }; |
| |
| Handler handler; |
| handler.fShaderText = shaderText; |
| handler.fErrorHandler = errorHandler; |
| #if defined(__EMSCRIPTEN__) |
| // Deprecated function. |
| module->GetCompilationInfo(&Handler::Fn, &handler); |
| #else |
| // New API. |
| wgpu::FutureWaitInfo waitInfo{}; |
| waitInfo.future = module->GetCompilationInfo( |
| wgpu::CallbackMode::WaitAnyOnly, |
| [handlerPtr = &handler](wgpu::CompilationInfoRequestStatus status, |
| const wgpu::CompilationInfo* info) { |
| Handler::Fn(static_cast<WGPUCompilationInfoRequestStatus>(status), |
| reinterpret_cast<const WGPUCompilationInfo*>(info), |
| handlerPtr); |
| }); |
| |
| const auto& instance = static_cast<const DawnSharedContext*>(sharedContext)->instance(); |
| [[maybe_unused]] auto status = |
| instance.WaitAny(1, &waitInfo, /*timeoutNS=*/std::numeric_limits<uint64_t>::max()); |
| SkASSERT(status == wgpu::WaitStatus::Success); |
| #endif // defined(__EMSCRIPTEN__) |
| |
| return handler.fSuccess; |
| #endif |
| } |
| |
| bool DawnCompileWGSLShaderModule(const DawnSharedContext* sharedContext, |
| const char* label, |
| const SkSL::NativeShader& wgsl, |
| wgpu::ShaderModule* module, |
| ShaderErrorHandler* errorHandler) { |
| #if defined(__EMSCRIPTEN__) |
| wgpu::ShaderModuleWGSLDescriptor wgslDesc; |
| #else |
| wgpu::ShaderSourceWGSL wgslDesc; |
| #endif |
| wgslDesc.code = wgsl.fText.c_str(); |
| |
| wgpu::ShaderModuleDescriptor desc; |
| desc.nextInChain = &wgslDesc; |
| if (sharedContext->caps()->setBackendLabels()) { |
| desc.label = label; |
| } |
| |
| *module = sharedContext->device().CreateShaderModule(&desc); |
| |
| return check_shader_module(sharedContext, module, wgsl.fText.c_str(), errorHandler); |
| } |
| |
| #if !defined(__EMSCRIPTEN__) |
| |
| namespace { |
| |
| static constexpr int kUsesExternalFormatBits = 1; |
| static constexpr int kYcbcrModelBits = 3; |
| static constexpr int kYcbcrRangeBits = 1; |
| static constexpr int kXChromaOffsetBits = 1; |
| static constexpr int kYChromaOffsetBits = 1; |
| // wgpu::FilterMode contains Undefined/Nearest/Linear entries (Linear is 2). |
| static constexpr int kChromaFilterBits = 2; |
| static constexpr int kForceExplicitReconBits = 1; |
| static constexpr int kComponentBits = 3; |
| |
| static constexpr int kUsesExternalFormatShift = 0; |
| static constexpr int kYcbcrModelShift = kUsesExternalFormatShift + kUsesExternalFormatBits; |
| static constexpr int kYcbcrRangeShift = kYcbcrModelShift + kYcbcrModelBits; |
| static constexpr int kXChromaOffsetShift = kYcbcrRangeShift + kYcbcrRangeBits; |
| static constexpr int kYChromaOffsetShift = kXChromaOffsetShift + kXChromaOffsetBits; |
| static constexpr int kChromaFilterShift = kYChromaOffsetShift + kYChromaOffsetBits; |
| static constexpr int kForceExplicitReconShift = kChromaFilterShift + kChromaFilterBits; |
| static constexpr int kComponentRShift = kForceExplicitReconShift + kForceExplicitReconBits; |
| static constexpr int kComponentGShift = kComponentRShift + kComponentBits; |
| static constexpr int kComponentBShift = kComponentGShift + kComponentBits; |
| static constexpr int kComponentAShift = kComponentBShift + kComponentBits; |
| |
| static constexpr uint32_t kUseExternalFormatMask = |
| ((1 << kUsesExternalFormatBits) - 1) << kUsesExternalFormatShift; |
| static constexpr uint32_t kYcbcrModelMask = |
| ((1 << kYcbcrModelBits) - 1) << kYcbcrModelShift; |
| static constexpr uint32_t kYcbcrRangeMask = |
| ((1 << kYcbcrRangeBits) - 1) << kYcbcrRangeShift; |
| static constexpr uint32_t kXChromaOffsetMask = |
| ((1 << kXChromaOffsetBits) - 1) << kXChromaOffsetShift; |
| static constexpr uint32_t kYChromaOffsetMask = |
| ((1 << kYChromaOffsetBits) - 1) << kYChromaOffsetShift; |
| static constexpr uint32_t kChromaFilterMask = |
| ((1 << kChromaFilterBits) - 1) << kChromaFilterShift; |
| static constexpr uint32_t kForceExplicitReconMask = |
| ((1 << kForceExplicitReconBits) - 1) << kForceExplicitReconShift; |
| static constexpr uint32_t kComponentRMask = ((1 << kComponentBits) - 1) << kComponentRShift; |
| static constexpr uint32_t kComponentBMask = ((1 << kComponentBits) - 1) << kComponentBShift; |
| static constexpr uint32_t kComponentGMask = ((1 << kComponentBits) - 1) << kComponentGShift; |
| static constexpr uint32_t kComponentAMask = ((1 << kComponentBits) - 1) << kComponentAShift; |
| |
| } // anonymous namespace |
| |
| bool DawnDescriptorsAreEquivalent(const wgpu::YCbCrVkDescriptor& desc1, |
| const wgpu::YCbCrVkDescriptor& desc2) { |
| return desc1.vkFormat == desc2.vkFormat && |
| desc1.vkYCbCrModel == desc2.vkYCbCrModel && |
| desc1.vkYCbCrRange == desc2.vkYCbCrRange && |
| desc1.vkComponentSwizzleRed == desc2.vkComponentSwizzleRed && |
| desc1.vkComponentSwizzleGreen == desc2.vkComponentSwizzleGreen && |
| desc1.vkComponentSwizzleBlue == desc2.vkComponentSwizzleBlue && |
| desc1.vkComponentSwizzleAlpha == desc2.vkComponentSwizzleAlpha && |
| desc1.vkXChromaOffset == desc2.vkXChromaOffset && |
| desc1.vkYChromaOffset == desc2.vkYChromaOffset && |
| desc1.vkChromaFilter == desc2.vkChromaFilter && |
| desc1.forceExplicitReconstruction == desc2.forceExplicitReconstruction && |
| desc1.externalFormat == desc2.externalFormat; |
| } |
| |
| bool DawnDescriptorIsValid(const wgpu::YCbCrVkDescriptor& desc) { |
| static const wgpu::YCbCrVkDescriptor kDefaultYcbcrDescriptor = {}; |
| return !DawnDescriptorsAreEquivalent(desc, kDefaultYcbcrDescriptor); |
| } |
| |
| bool DawnDescriptorUsesExternalFormat(const wgpu::YCbCrVkDescriptor& desc) { |
| SkASSERT(desc.externalFormat != 0 || desc.vkFormat != 0); |
| return desc.externalFormat != 0; |
| } |
| |
| ImmutableSamplerInfo DawnDescriptorToImmutableSamplerInfo(const wgpu::YCbCrVkDescriptor& desc) { |
| static_assert(kComponentAShift + kComponentBits <= 32); |
| SkASSERT(desc.vkYCbCrModel < (1u << kYcbcrModelBits )); |
| SkASSERT(desc.vkYCbCrRange < (1u << kYcbcrRangeBits )); |
| SkASSERT(desc.vkXChromaOffset < (1u << kXChromaOffsetBits )); |
| SkASSERT(desc.vkYChromaOffset < (1u << kYChromaOffsetBits )); |
| SkASSERT(static_cast<uint32_t>(desc.vkChromaFilter) < (1u << kChromaFilterBits )); |
| SkASSERT(desc.vkComponentSwizzleRed < (1u << kComponentBits )); |
| SkASSERT(desc.vkComponentSwizzleGreen < (1u << kComponentBits )); |
| SkASSERT(desc.vkComponentSwizzleBlue < (1u << kComponentBits )); |
| SkASSERT(desc.vkComponentSwizzleAlpha < (1u << kComponentBits )); |
| SkASSERT(static_cast<uint32_t>(desc.forceExplicitReconstruction) |
| < (1u << kForceExplicitReconBits)); |
| |
| const bool usesExternalFormat = DawnDescriptorUsesExternalFormat(desc); |
| |
| ImmutableSamplerInfo info; |
| info.fNonFormatYcbcrConversionInfo = |
| (((uint32_t)(usesExternalFormat ) << kUsesExternalFormatShift) | |
| ((uint32_t)(desc.vkYCbCrModel ) << kYcbcrModelShift ) | |
| ((uint32_t)(desc.vkYCbCrRange ) << kYcbcrRangeShift ) | |
| ((uint32_t)(desc.vkXChromaOffset ) << kXChromaOffsetShift ) | |
| ((uint32_t)(desc.vkYChromaOffset ) << kYChromaOffsetShift ) | |
| ((uint32_t)(desc.vkChromaFilter ) << kChromaFilterShift ) | |
| ((uint32_t)(desc.forceExplicitReconstruction ) << kForceExplicitReconShift) | |
| ((uint32_t)(desc.vkComponentSwizzleRed ) << kComponentRShift ) | |
| ((uint32_t)(desc.vkComponentSwizzleGreen ) << kComponentGShift ) | |
| ((uint32_t)(desc.vkComponentSwizzleBlue ) << kComponentBShift ) | |
| ((uint32_t)(desc.vkComponentSwizzleAlpha ) << kComponentAShift )); |
| info.fFormat = usesExternalFormat ? desc.externalFormat : desc.vkFormat; |
| return info; |
| } |
| |
| wgpu::YCbCrVkDescriptor DawnDescriptorFromImmutableSamplerInfo(ImmutableSamplerInfo info) { |
| const uint32_t nonFormatInfo = info.fNonFormatYcbcrConversionInfo; |
| |
| wgpu::YCbCrVkDescriptor desc; |
| const bool usesExternalFormat = |
| (nonFormatInfo >> kUsesExternalFormatShift) & kUseExternalFormatMask; |
| if (usesExternalFormat) { |
| desc.vkFormat = 0; |
| desc.externalFormat = info.fFormat; |
| } else { |
| desc.vkFormat = (uint32_t) info.fFormat; |
| desc.externalFormat = 0; |
| } |
| |
| desc.vkYCbCrModel = (nonFormatInfo & kYcbcrModelMask) >> kYcbcrModelShift; |
| desc.vkYCbCrRange = (nonFormatInfo & kYcbcrRangeMask) >> kYcbcrRangeShift; |
| desc.vkComponentSwizzleRed = (nonFormatInfo & kComponentRMask) >> kComponentRShift; |
| desc.vkComponentSwizzleGreen = (nonFormatInfo & kComponentGMask) >> kComponentGShift; |
| desc.vkComponentSwizzleBlue = (nonFormatInfo & kComponentBMask) >> kComponentBShift; |
| desc.vkComponentSwizzleAlpha = (nonFormatInfo & kComponentAMask) >> kComponentAShift; |
| desc.vkXChromaOffset = (nonFormatInfo & kXChromaOffsetMask) >> kXChromaOffsetShift; |
| desc.vkYChromaOffset = (nonFormatInfo & kYChromaOffsetMask) >> kYChromaOffsetShift; |
| desc.vkChromaFilter = static_cast<wgpu::FilterMode>( |
| (nonFormatInfo & kChromaFilterMask) >> kChromaFilterShift); |
| desc.forceExplicitReconstruction = |
| (nonFormatInfo & kForceExplicitReconMask) >> kForceExplicitReconShift; |
| return desc; |
| } |
| |
| #endif // !defined(__EMSCRIPTEN__) |
| |
| } // namespace skgpu::graphite |
