| // Copyright 2017 The Dawn Authors |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #include "dawn_native/d3d12/TextureCopySplitter.h" |
| |
| #include "common/Assert.h" |
| #include "dawn_native/Format.h" |
| #include "dawn_native/d3d12/d3d12_platform.h" |
| |
| namespace dawn_native { namespace d3d12 { |
| |
| namespace { |
| Origin3D ComputeTexelOffsets(const TexelBlockInfo& blockInfo, |
| uint32_t offset, |
| uint32_t bytesPerRow) { |
| ASSERT(bytesPerRow != 0); |
| uint32_t byteOffsetX = offset % bytesPerRow; |
| uint32_t byteOffsetY = offset - byteOffsetX; |
| |
| return {byteOffsetX / blockInfo.byteSize * blockInfo.width, |
| byteOffsetY / bytesPerRow * blockInfo.height, 0}; |
| } |
| } // namespace |
| |
| Texture2DCopySplit ComputeTextureCopySplit(Origin3D origin, |
| Extent3D copySize, |
| const TexelBlockInfo& blockInfo, |
| uint64_t offset, |
| uint32_t bytesPerRow, |
| uint32_t rowsPerImage) { |
| Texture2DCopySplit copy; |
| |
| ASSERT(bytesPerRow % blockInfo.byteSize == 0); |
| |
| // The copies must be 512-aligned. To do this, we calculate the first 512-aligned address |
| // preceding our data. |
| uint64_t alignedOffset = |
| offset & ~static_cast<uint64_t>(D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT - 1); |
| |
| copy.offset = alignedOffset; |
| |
| // If the provided offset to the data was already 512-aligned, we can simply copy the data |
| // without further translation. |
| if (offset == alignedOffset) { |
| copy.count = 1; |
| |
| copy.copies[0].textureOffset = origin; |
| |
| copy.copies[0].copySize = copySize; |
| |
| copy.copies[0].bufferOffset.x = 0; |
| copy.copies[0].bufferOffset.y = 0; |
| copy.copies[0].bufferOffset.z = 0; |
| copy.copies[0].bufferSize = copySize; |
| |
| return copy; |
| } |
| |
| ASSERT(alignedOffset < offset); |
| ASSERT(offset - alignedOffset < D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT); |
| |
| // We must reinterpret our aligned offset into X and Y offsets with respect to the row |
| // pitch. |
| // |
| // You can visualize the data in the buffer like this: |
| // |-----------------------++++++++++++++++++++++++++++++++| |
| // ^ 512-aligned address ^ Aligned offset ^ End of copy data |
| // |
| // Now when you consider the row pitch, you can visualize the data like this: |
| // |~~~~~~~~~~~~~~~~| |
| // |~~~~~+++++++++++| |
| // |++++++++++++++++| |
| // |+++++~~~~~~~~~~~| |
| // |<---row pitch-->| |
| // |
| // The X and Y offsets calculated in ComputeTexelOffsets can be visualized like this: |
| // |YYYYYYYYYYYYYYYY| |
| // |XXXXXX++++++++++| |
| // |++++++++++++++++| |
| // |++++++~~~~~~~~~~| |
| // |<---row pitch-->| |
| Origin3D texelOffset = ComputeTexelOffsets( |
| blockInfo, static_cast<uint32_t>(offset - alignedOffset), bytesPerRow); |
| |
| ASSERT(texelOffset.z == 0); |
| |
| uint32_t copyBytesPerRowPitch = copySize.width / blockInfo.width * blockInfo.byteSize; |
| uint32_t byteOffsetInRowPitch = texelOffset.x / blockInfo.width * blockInfo.byteSize; |
| uint32_t rowsPerImageInTexels = rowsPerImage * blockInfo.height; |
| if (copyBytesPerRowPitch + byteOffsetInRowPitch <= bytesPerRow) { |
| // The region's rows fit inside the bytes per row. In this case, extend the width of the |
| // PlacedFootprint and copy the buffer with an offset location |
| // |<------------- bytes per row ------------->| |
| // |
| // |-------------------------------------------| |
| // | | |
| // | +++++++++++++++++~~~~~~~~~| |
| // |~~~~~~~~~~~~~~~~~+++++++++++++++++~~~~~~~~~| |
| // |~~~~~~~~~~~~~~~~~+++++++++++++++++~~~~~~~~~| |
| // |~~~~~~~~~~~~~~~~~+++++++++++++++++~~~~~~~~~| |
| // |~~~~~~~~~~~~~~~~~+++++++++++++++++ | |
| // |-------------------------------------------| |
| |
| // Copy 0: |
| // |----------------------------------| |
| // | | |
| // | +++++++++++++++++| |
| // |~~~~~~~~~~~~~~~~~+++++++++++++++++| |
| // |~~~~~~~~~~~~~~~~~+++++++++++++++++| |
| // |~~~~~~~~~~~~~~~~~+++++++++++++++++| |
| // |~~~~~~~~~~~~~~~~~+++++++++++++++++| |
| // |----------------------------------| |
| |
| copy.count = 1; |
| |
| copy.copies[0].textureOffset = origin; |
| |
| copy.copies[0].copySize = copySize; |
| |
| copy.copies[0].bufferOffset = texelOffset; |
| copy.copies[0].bufferSize.width = copySize.width + texelOffset.x; |
| copy.copies[0].bufferSize.height = rowsPerImageInTexels + texelOffset.y; |
| copy.copies[0].bufferSize.depthOrArrayLayers = copySize.depthOrArrayLayers; |
| |
| return copy; |
| } |
| |
| // The region's rows straddle the bytes per row. Split the copy into two copies |
| // |<------------- bytes per row ------------->| |
| // |
| // |-------------------------------------------| |
| // | | |
| // | ++++++++| |
| // |+++++++++~~~~~~~~~~~~~~~~~~~~~~~~~~++++++++| |
| // |+++++++++~~~~~~~~~~~~~~~~~~~~~~~~~~++++++++| |
| // |+++++++++~~~~~~~~~~~~~~~~~~~~~~~~~~++++++++| |
| // |+++++++++~~~~~~~~~~~~~~~~~~~~~~~~~~++++++++| |
| // |+++++++++ | |
| // |-------------------------------------------| |
| |
| // Copy 0: |
| // |-------------------------------------------| |
| // | | |
| // | ++++++++| |
| // |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++++++++| |
| // |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++++++++| |
| // |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++++++++| |
| // |~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~++++++++| |
| // |-------------------------------------------| |
| |
| // Copy 1: |
| // |---------| |
| // | | |
| // | | |
| // |+++++++++| |
| // |+++++++++| |
| // |+++++++++| |
| // |+++++++++| |
| // |+++++++++| |
| // |---------| |
| |
| copy.count = 2; |
| |
| copy.copies[0].textureOffset = origin; |
| |
| ASSERT(bytesPerRow > byteOffsetInRowPitch); |
| uint32_t texelsPerRow = bytesPerRow / blockInfo.byteSize * blockInfo.width; |
| copy.copies[0].copySize.width = texelsPerRow - texelOffset.x; |
| copy.copies[0].copySize.height = copySize.height; |
| copy.copies[0].copySize.depthOrArrayLayers = copySize.depthOrArrayLayers; |
| |
| copy.copies[0].bufferOffset = texelOffset; |
| copy.copies[0].bufferSize.width = texelsPerRow; |
| copy.copies[0].bufferSize.height = rowsPerImageInTexels + texelOffset.y; |
| copy.copies[0].bufferSize.depthOrArrayLayers = copySize.depthOrArrayLayers; |
| |
| copy.copies[1].textureOffset.x = origin.x + copy.copies[0].copySize.width; |
| copy.copies[1].textureOffset.y = origin.y; |
| copy.copies[1].textureOffset.z = origin.z; |
| |
| ASSERT(copySize.width > copy.copies[0].copySize.width); |
| copy.copies[1].copySize.width = copySize.width - copy.copies[0].copySize.width; |
| copy.copies[1].copySize.height = copySize.height; |
| copy.copies[1].copySize.depthOrArrayLayers = copySize.depthOrArrayLayers; |
| |
| copy.copies[1].bufferOffset.x = 0; |
| copy.copies[1].bufferOffset.y = texelOffset.y + blockInfo.height; |
| copy.copies[1].bufferOffset.z = 0; |
| copy.copies[1].bufferSize.width = copy.copies[1].copySize.width; |
| copy.copies[1].bufferSize.height = rowsPerImageInTexels + texelOffset.y + blockInfo.height; |
| copy.copies[1].bufferSize.depthOrArrayLayers = copySize.depthOrArrayLayers; |
| |
| return copy; |
| } |
| |
| TextureCopySplits ComputeTextureCopySplits(Origin3D origin, |
| Extent3D copySize, |
| const TexelBlockInfo& blockInfo, |
| uint64_t offset, |
| uint32_t bytesPerRow, |
| uint32_t rowsPerImage, |
| bool is3DTexture) { |
| TextureCopySplits copies; |
| |
| const uint64_t bytesPerSlice = bytesPerRow * rowsPerImage; |
| |
| // The function ComputeTextureCopySplit() decides how to split the copy based on: |
| // - the alignment of the buffer offset with D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT (512) |
| // - the alignment of the buffer offset with D3D12_TEXTURE_DATA_PITCH_ALIGNMENT (256) |
| // Each slice of a 2D array or 3D copy might need to be split, but because of the WebGPU |
| // constraint that "bytesPerRow" must be a multiple of 256, all odd (resp. all even) slices |
| // will be at an offset multiple of 512 of each other, which means they will all result in |
| // the same 2D split. Thus we can just compute the copy splits for the first and second |
| // slices, and reuse them for the remaining slices by adding the related offset of each |
| // slice. Moreover, if "rowsPerImage" is even, both the first and second copy layers can |
| // share the same copy split, so in this situation we just need to compute copy split once |
| // and reuse it for all the slices. |
| Extent3D copyOneLayerSize = copySize; |
| Origin3D copyFirstLayerOrigin = origin; |
| if (!is3DTexture) { |
| copyOneLayerSize.depthOrArrayLayers = 1; |
| copyFirstLayerOrigin.z = 0; |
| } |
| |
| copies.copies2D[0] = ComputeTextureCopySplit(copyFirstLayerOrigin, copyOneLayerSize, |
| blockInfo, offset, bytesPerRow, rowsPerImage); |
| |
| // When the copy only refers one texture 2D array layer or a 3D texture, copies.copies2D[1] |
| // will never be used so we can safely early return here. |
| if (copySize.depthOrArrayLayers == 1 || is3DTexture) { |
| return copies; |
| } |
| |
| if (bytesPerSlice % D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT == 0) { |
| copies.copies2D[1] = copies.copies2D[0]; |
| copies.copies2D[1].offset += bytesPerSlice; |
| } else { |
| const uint64_t bufferOffsetNextLayer = offset + bytesPerSlice; |
| copies.copies2D[1] = |
| ComputeTextureCopySplit(copyFirstLayerOrigin, copyOneLayerSize, blockInfo, |
| bufferOffsetNextLayer, bytesPerRow, rowsPerImage); |
| } |
| |
| return copies; |
| } |
| |
| }} // namespace dawn_native::d3d12 |