| // Copyright 2021 The Dawn & Tint Authors |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are met: |
| // |
| // 1. Redistributions of source code must retain the above copyright notice, this |
| // list of conditions and the following disclaimer. |
| // |
| // 2. Redistributions in binary form must reproduce the above copyright notice, |
| // this list of conditions and the following disclaimer in the documentation |
| // and/or other materials provided with the distribution. |
| // |
| // 3. Neither the name of the copyright holder nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE |
| // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
| // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
| // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| #include "dawn/native/ExternalTexture.h" |
| |
| #include <algorithm> |
| #include <utility> |
| |
| #include "dawn/native/Buffer.h" |
| #include "dawn/native/Device.h" |
| #include "dawn/native/ObjectType_autogen.h" |
| #include "dawn/native/Queue.h" |
| #include "dawn/native/Texture.h" |
| |
| #include "dawn/native/dawn_platform.h" |
| |
| namespace dawn::native { |
| |
| MaybeError ValidateExternalTexturePlane(const TextureViewBase* textureView) { |
| DAWN_INVALID_IF( |
| (textureView->GetTexture()->GetUsage() & wgpu::TextureUsage::TextureBinding) == 0, |
| "The external texture plane (%s) usage (%s) doesn't include the required usage (%s)", |
| textureView, textureView->GetTexture()->GetUsage(), wgpu::TextureUsage::TextureBinding); |
| |
| DAWN_INVALID_IF(textureView->GetDimension() != wgpu::TextureViewDimension::e2D, |
| "The external texture plane (%s) dimension (%s) is not 2D.", textureView, |
| textureView->GetDimension()); |
| |
| DAWN_INVALID_IF(textureView->GetLevelCount() > 1, |
| "The external texture plane (%s) mip level count (%u) is not 1.", textureView, |
| textureView->GetLevelCount()); |
| |
| DAWN_INVALID_IF(textureView->GetTexture()->GetSampleCount() != 1, |
| "The external texture plane (%s) sample count (%u) is not one.", textureView, |
| textureView->GetTexture()->GetSampleCount()); |
| |
| return {}; |
| } |
| |
| MaybeError ValidateExternalTextureDescriptor(const DeviceBase* device, |
| const ExternalTextureDescriptor* descriptor) { |
| DAWN_ASSERT(descriptor); |
| DAWN_ASSERT(descriptor->plane0); |
| |
| DAWN_TRY(device->ValidateObject(descriptor->plane0)); |
| |
| DAWN_INVALID_IF(!descriptor->gamutConversionMatrix, |
| "The gamut conversion matrix must be non-null."); |
| |
| DAWN_INVALID_IF(!descriptor->srcTransferFunctionParameters, |
| "The source transfer function parameters must be non-null."); |
| |
| DAWN_INVALID_IF(!descriptor->dstTransferFunctionParameters, |
| "The destination transfer function parameters must be non-null."); |
| |
| DAWN_TRY(ValidateExternalTexturePlane(descriptor->plane0)); |
| |
| auto CheckPlaneFormat = [](const DeviceBase* device, const Format& format, |
| uint32_t requiredComponentCount) -> MaybeError { |
| DAWN_INVALID_IF(format.aspects != Aspect::Color, "The format (%s) is not a color format.", |
| format.format); |
| DAWN_INVALID_IF(!IsSubset(SampleTypeBit::Float, |
| format.GetAspectInfo(Aspect::Color).supportedSampleTypes), |
| "The format (%s) is not filterable float.", format.format); |
| DAWN_INVALID_IF(format.componentCount != requiredComponentCount, |
| "The format (%s) component count (%u) is not %u.", format.format, |
| requiredComponentCount, format.componentCount); |
| return {}; |
| }; |
| |
| if (descriptor->plane1) { |
| DAWN_INVALID_IF( |
| !descriptor->yuvToRgbConversionMatrix, |
| "When more than one plane is set, the YUV-to-RGB conversion matrix must be non-null."); |
| |
| DAWN_TRY(device->ValidateObject(descriptor->plane1)); |
| DAWN_TRY(ValidateExternalTexturePlane(descriptor->plane1)); |
| |
| // Y + UV case. |
| DAWN_TRY_CONTEXT(CheckPlaneFormat(device, descriptor->plane0->GetFormat(), 1), |
| "validating the format of plane 0 (%s)", descriptor->plane0); |
| DAWN_TRY_CONTEXT(CheckPlaneFormat(device, descriptor->plane1->GetFormat(), 2), |
| "validating the format of plane 1 (%s)", descriptor->plane1); |
| } else { |
| // RGBA case. |
| DAWN_TRY_CONTEXT(CheckPlaneFormat(device, descriptor->plane0->GetFormat(), 4), |
| "validating the format of plane 0 (%s)", descriptor->plane0); |
| } |
| |
| DAWN_INVALID_IF(descriptor->visibleSize.width == 0 || descriptor->visibleSize.height == 0, |
| "VisibleSize %s have 0 on width or height.", &descriptor->visibleSize); |
| |
| const Extent3D textureSize = descriptor->plane0->GetSingleSubresourceVirtualSize(); |
| DAWN_INVALID_IF(descriptor->visibleSize.width > textureSize.width || |
| descriptor->visibleSize.height > textureSize.height, |
| "VisibleSize %s is exceed the texture size, defined by Plane0 size (%u, %u).", |
| &descriptor->visibleSize, textureSize.width, textureSize.height); |
| DAWN_INVALID_IF( |
| descriptor->visibleOrigin.x > textureSize.width - descriptor->visibleSize.width || |
| descriptor->visibleOrigin.y > textureSize.height - descriptor->visibleSize.height, |
| "VisibleRect[Origin: %s, Size: %s] is exceed the texture size, defined by " |
| "Plane0 size (%u, %u).", |
| &descriptor->visibleOrigin, &descriptor->visibleSize, textureSize.width, |
| textureSize.height); |
| |
| return {}; |
| } |
| |
| // static |
| ResultOrError<Ref<ExternalTextureBase>> ExternalTextureBase::Create( |
| DeviceBase* device, |
| const ExternalTextureDescriptor* descriptor) { |
| Ref<ExternalTextureBase> externalTexture = |
| AcquireRef(new ExternalTextureBase(device, descriptor)); |
| DAWN_TRY(externalTexture->Initialize(device, descriptor)); |
| return std::move(externalTexture); |
| } |
| |
| ExternalTextureBase::ExternalTextureBase(DeviceBase* device, |
| const ExternalTextureDescriptor* descriptor) |
| : ApiObjectBase(device, descriptor->label), |
| mVisibleOrigin(descriptor->visibleOrigin), |
| mVisibleSize(descriptor->visibleSize), |
| mState(ExternalTextureState::Active) { |
| GetObjectTrackingList()->Track(this); |
| } |
| |
| // Error external texture cannot be used in bind group. |
| ExternalTextureBase::ExternalTextureBase(DeviceBase* device, |
| ObjectBase::ErrorTag tag, |
| const char* label) |
| : ApiObjectBase(device, tag, label), mState(ExternalTextureState::Destroyed) {} |
| |
| ExternalTextureBase::~ExternalTextureBase() = default; |
| |
| MaybeError ExternalTextureBase::Initialize(DeviceBase* device, |
| const ExternalTextureDescriptor* descriptor) { |
| // Store any passed in TextureViews associated with individual planes. |
| mTextureViews[0] = descriptor->plane0; |
| |
| if (descriptor->plane1) { |
| mTextureViews[1] = descriptor->plane1; |
| } else { |
| DAWN_TRY_ASSIGN(mTextureViews[1], |
| device->GetOrCreatePlaceholderTextureViewForExternalTexture()); |
| } |
| |
| // We must create a buffer to store parameters needed by a shader that operates on this |
| // external texture. |
| BufferDescriptor bufferDesc; |
| bufferDesc.size = sizeof(ExternalTextureParams); |
| bufferDesc.usage = wgpu::BufferUsage::Uniform | wgpu::BufferUsage::CopyDst; |
| bufferDesc.label = "Dawn_External_Texture_Params_Buffer"; |
| |
| DAWN_TRY_ASSIGN(mParamsBuffer, device->CreateBuffer(&bufferDesc)); |
| |
| ExternalTextureParams params; |
| params.numPlanes = descriptor->plane1 == nullptr ? 1 : 2; |
| |
| params.doYuvToRgbConversionOnly = descriptor->doYuvToRgbConversionOnly ? 1 : 0; |
| |
| // YUV-to-RGB conversion is performed by multiplying the source YUV values with a 4x3 matrix |
| // passed from Chromium. The matrix was originally sourced from /skia/src/core/SkYUVMath.cpp. |
| // This matrix is only used in multiplanar scenarios. |
| if (params.numPlanes == 2) { |
| DAWN_ASSERT(descriptor->yuvToRgbConversionMatrix); |
| const float* yMat = descriptor->yuvToRgbConversionMatrix; |
| std::copy(yMat, yMat + 12, params.yuvToRgbConversionMatrix.begin()); |
| } |
| |
| // Gamut correction is performed by multiplying a 3x3 matrix passed from Chromium. The |
| // matrix was computed by multiplying the appropriate source and destination gamut |
| // matrices sourced from ui/gfx/color_space.cc. |
| const float* gMat = descriptor->gamutConversionMatrix; |
| params.gamutConversionMatrix = {gMat[0], gMat[1], gMat[2], 0.0f, // |
| gMat[3], gMat[4], gMat[5], 0.0f, // |
| gMat[6], gMat[7], gMat[8], 0.0f}; |
| |
| // Gamma decode/encode is performed by the logic: |
| // if (abs(v) < params.D) { |
| // return sign(v) * (params.C * abs(v) + params.F); |
| // } |
| // return pow(A * x + B, G) + E |
| // |
| // Constants are passed from Chromium and originally sourced from ui/gfx/color_space.cc |
| const float* srcFn = descriptor->srcTransferFunctionParameters; |
| std::copy(srcFn, srcFn + 7, params.gammaDecodingParams.begin()); |
| |
| const float* dstFn = descriptor->dstTransferFunctionParameters; |
| std::copy(dstFn, dstFn + 7, params.gammaEncodingParams.begin()); |
| |
| // Unlike WGSL, which stores matrices in column vectors, the following arithmetic uses row |
| // vectors, so elements are stored in the following order: |
| // ┌ ┐ |
| // │ 0, 1, 2 │ |
| // │ 3, 4, 5 │ |
| // └ ┘ |
| // The matrix is transposed at the end. |
| using mat2x3 = std::array<float, 6>; |
| |
| // Multiplies the two mat2x3 matrices, by treating the RHS matrix as a mat3x3 where the last row |
| // is [0, 0, 1]. |
| auto Mul = [&](const mat2x3& lhs, const mat2x3& rhs) { |
| auto& a = lhs[0]; |
| auto& b = lhs[1]; |
| auto& c = lhs[2]; |
| auto& d = lhs[3]; |
| auto& e = lhs[4]; |
| auto& f = lhs[5]; |
| auto& g = rhs[0]; |
| auto& h = rhs[1]; |
| auto& i = rhs[2]; |
| auto& j = rhs[3]; |
| auto& k = rhs[4]; |
| auto& l = rhs[5]; |
| // ┌ ┐ ┌ ┐ |
| // │ a, b, c │ │ g, h, i │ |
| // │ d, e, f │ x │ j, k, l │ |
| // └ ┘ │ 0, 0, 1 │ |
| // └ ┘ |
| return mat2x3{ |
| a * g + b * j, // |
| a * h + b * k, // |
| a * i + b * l + c, // |
| d * g + e * j, // |
| d * h + e * k, // |
| d * i + e * l + f, // |
| }; |
| }; |
| |
| auto Scale = [&](const mat2x3& m, float x, float y) { |
| return Mul(mat2x3{x, 0, 0, 0, y, 0}, m); |
| }; |
| |
| auto Translate = [&](const mat2x3& m, float x, float y) { |
| return Mul(mat2x3{1, 0, x, 0, 1, y}, m); |
| }; |
| |
| mat2x3 coordTransformMatrix = { |
| 1, 0, 0, // |
| 0, 1, 0, // |
| }; |
| |
| // Offset the coordinates so the center texel is at the origin, so we can apply rotations and |
| // y-flips. After translation, coordinates range from [-0.5 .. +0.5] in both U and V. |
| coordTransformMatrix = Translate(coordTransformMatrix, -0.5, -0.5); |
| |
| // Texture applies rotation first and do mirrored(horizontal flip) next. |
| // Do reverse order here to mapping final uv coordinate to origin texture. |
| // TODO(crbug.com/1514732): VideoFrame metadata defines horizontal flip (mirrored) and rotation. |
| // The vertical flip (which is flipY) could be achieved by rotate 180 + mirrored. Deprecate |
| // flipY attribute to align with VideoFrame metadata. Chrome is the only place to use this |
| // attribute and pass mirrored to descriptor->flipY and this is incorrect. Workaround to fix |
| // mirrored issue by delegate flipY operation to mirrored and remove flipY attribute in future. |
| if (descriptor->flipY || descriptor->mirrored) { |
| coordTransformMatrix = Scale(coordTransformMatrix, -1, 1); |
| } |
| |
| // Apply rotations as needed. |
| switch (descriptor->rotation) { |
| case wgpu::ExternalTextureRotation::Rotate0Degrees: |
| break; |
| case wgpu::ExternalTextureRotation::Rotate90Degrees: |
| coordTransformMatrix = Mul(mat2x3{0, +1, 0, // x' = y |
| -1, 0, 0}, // y' = -x |
| coordTransformMatrix); |
| break; |
| case wgpu::ExternalTextureRotation::Rotate180Degrees: |
| coordTransformMatrix = Mul(mat2x3{-1, 0, 0, // x' = -x |
| 0, -1, 0}, // y' = -y |
| coordTransformMatrix); |
| break; |
| case wgpu::ExternalTextureRotation::Rotate270Degrees: |
| |
| coordTransformMatrix = Mul(mat2x3{0, -1, 0, // x' = -y |
| +1, 0, 0}, // y' = x |
| coordTransformMatrix); |
| break; |
| } |
| |
| // Offset the coordinates so the bottom-left texel is at origin. |
| // After translation, coordinates range from [0 .. 1] in both U and V. |
| coordTransformMatrix = Translate(coordTransformMatrix, 0.5, 0.5); |
| |
| // Calculate scale factors and offsets from the specified visibleSize. |
| DAWN_ASSERT(descriptor->visibleSize.width > 0); |
| DAWN_ASSERT(descriptor->visibleSize.height > 0); |
| uint32_t frameWidth = descriptor->plane0->GetSingleSubresourceVirtualSize().width; |
| uint32_t frameHeight = descriptor->plane0->GetSingleSubresourceVirtualSize().height; |
| float xScale = |
| static_cast<float>(descriptor->visibleSize.width) / static_cast<float>(frameWidth); |
| float yScale = |
| static_cast<float>(descriptor->visibleSize.height) / static_cast<float>(frameHeight); |
| float xOffset = |
| static_cast<float>(descriptor->visibleOrigin.x) / static_cast<float>(frameWidth); |
| float yOffset = |
| static_cast<float>(descriptor->visibleOrigin.y) / static_cast<float>(frameHeight); |
| |
| // Finally, scale and translate based on the visible rect. This applies cropping. |
| coordTransformMatrix = Scale(coordTransformMatrix, xScale, yScale); |
| coordTransformMatrix = Translate(coordTransformMatrix, xOffset, yOffset); |
| |
| // Transpose the mat2x3 into column vectors for use by WGSL. |
| params.coordTransformMatrix[0] = coordTransformMatrix[0]; |
| params.coordTransformMatrix[1] = coordTransformMatrix[3]; |
| params.coordTransformMatrix[2] = coordTransformMatrix[1]; |
| params.coordTransformMatrix[3] = coordTransformMatrix[4]; |
| params.coordTransformMatrix[4] = coordTransformMatrix[2]; |
| params.coordTransformMatrix[5] = coordTransformMatrix[5]; |
| |
| DAWN_TRY(device->GetQueue()->WriteBuffer(mParamsBuffer.Get(), 0, ¶ms, |
| sizeof(ExternalTextureParams))); |
| |
| return {}; |
| } |
| |
| const std::array<Ref<TextureViewBase>, kMaxPlanesPerFormat>& ExternalTextureBase::GetTextureViews() |
| const { |
| return mTextureViews; |
| } |
| |
| MaybeError ExternalTextureBase::ValidateCanUseInSubmitNow() const { |
| DAWN_ASSERT(!IsError()); |
| DAWN_INVALID_IF(mState != ExternalTextureState::Active, |
| "External texture %s used in a submit is not active.", this); |
| |
| for (uint32_t i = 0; i < kMaxPlanesPerFormat; ++i) { |
| if (mTextureViews[i] != nullptr) { |
| DAWN_TRY_CONTEXT(mTextureViews[i]->GetTexture()->ValidateCanUseInSubmitNow(), |
| "Validate plane %u of %s can be used in a submit.", i, this); |
| } |
| } |
| return {}; |
| } |
| |
| MaybeError ExternalTextureBase::ValidateRefresh() { |
| DAWN_TRY(GetDevice()->ValidateObject(this)); |
| DAWN_INVALID_IF(mState == ExternalTextureState::Destroyed, "%s is destroyed.", this); |
| return {}; |
| } |
| |
| MaybeError ExternalTextureBase::ValidateExpire() { |
| DAWN_TRY(GetDevice()->ValidateObject(this)); |
| DAWN_INVALID_IF(mState != ExternalTextureState::Active, "%s is not active.", this); |
| return {}; |
| } |
| |
| void ExternalTextureBase::APIRefresh() { |
| if (GetDevice()->ConsumedError(ValidateRefresh(), "calling %s.Refresh()", this)) { |
| return; |
| } |
| mState = ExternalTextureState::Active; |
| } |
| |
| void ExternalTextureBase::APIExpire() { |
| if (GetDevice()->ConsumedError(ValidateExpire(), "calling %s.Expire()", this)) { |
| return; |
| } |
| mState = ExternalTextureState::Expired; |
| } |
| |
| void ExternalTextureBase::APIDestroy() { |
| Destroy(); |
| } |
| |
| void ExternalTextureBase::DestroyImpl() { |
| // TODO(crbug.com/dawn/831): DestroyImpl is called from two places. |
| // - It may be called if the texture is explicitly destroyed with APIDestroy. |
| // This case is NOT thread-safe and needs proper synchronization with other |
| // simultaneous uses of the texture. |
| // - It may be called when the last ref to the texture is dropped and the texture |
| // is implicitly destroyed. This case is thread-safe because there are no |
| // other threads using the texture since there are no other live refs. |
| mState = ExternalTextureState::Destroyed; |
| } |
| |
| // static |
| Ref<ExternalTextureBase> ExternalTextureBase::MakeError(DeviceBase* device, const char* label) { |
| return AcquireRef(new ExternalTextureBase(device, ObjectBase::kError, label)); |
| } |
| |
| BufferBase* ExternalTextureBase::GetParamsBuffer() const { |
| return mParamsBuffer.Get(); |
| } |
| |
| ObjectType ExternalTextureBase::GetType() const { |
| return ObjectType::ExternalTexture; |
| } |
| |
| const Extent2D& ExternalTextureBase::GetVisibleSize() const { |
| DAWN_ASSERT(!IsError()); |
| return mVisibleSize; |
| } |
| |
| const Origin2D& ExternalTextureBase::GetVisibleOrigin() const { |
| DAWN_ASSERT(!IsError()); |
| return mVisibleOrigin; |
| } |
| |
| } // namespace dawn::native |