Remove the defaulting for bytesPerRow = 0
Bug: dawn:432
Change-Id: I335cdc367c322764861878bfb604ecc6a146b732
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/22340
Reviewed-by: Stephen White <senorblanco@chromium.org>
Reviewed-by: Austin Eng <enga@chromium.org>
Commit-Queue: Corentin Wallez <cwallez@chromium.org>
diff --git a/src/dawn_native/CommandEncoder.cpp b/src/dawn_native/CommandEncoder.cpp
index 79db419..db0271b 100644
--- a/src/dawn_native/CommandEncoder.cpp
+++ b/src/dawn_native/CommandEncoder.cpp
@@ -204,10 +204,6 @@
return {};
}
- uint32_t ComputeDefaultBytesPerRow(const Format& format, uint32_t width) {
- return width / format.blockWidth * format.blockByteSize;
- }
-
MaybeError ValidateBytesPerRow(const Format& format,
const Extent3D& copySize,
uint32_t bytesPerRow) {
@@ -653,13 +649,7 @@
DAWN_TRY(GetDevice()->ValidateObject(destination->texture));
}
- // Compute default values for bytesPerRow/rowsPerImage
- uint32_t defaultedBytesPerRow = source->bytesPerRow;
- if (defaultedBytesPerRow == 0) {
- defaultedBytesPerRow =
- ComputeDefaultBytesPerRow(destination->texture->GetFormat(), copySize->width);
- }
-
+ // Compute default value for rowsPerImage
uint32_t defaultedRowsPerImage = source->rowsPerImage;
if (defaultedRowsPerImage == 0) {
defaultedRowsPerImage = copySize->height;
@@ -677,10 +667,10 @@
uint32_t bufferCopySize = 0;
DAWN_TRY(ValidateBytesPerRow(destination->texture->GetFormat(), *copySize,
- defaultedBytesPerRow));
+ source->bytesPerRow));
DAWN_TRY(ComputeTextureCopyBufferSize(destination->texture->GetFormat(), *copySize,
- defaultedBytesPerRow, defaultedRowsPerImage,
+ source->bytesPerRow, defaultedRowsPerImage,
&bufferCopySize));
DAWN_TRY(ValidateCopySizeFitsInTexture(*destination, *copySize));
@@ -699,7 +689,7 @@
allocator->Allocate<CopyBufferToTextureCmd>(Command::CopyBufferToTexture);
copy->source.buffer = source->buffer;
copy->source.offset = source->offset;
- copy->source.bytesPerRow = defaultedBytesPerRow;
+ copy->source.bytesPerRow = source->bytesPerRow;
copy->source.rowsPerImage = defaultedRowsPerImage;
copy->destination.texture = destination->texture;
copy->destination.origin = destination->origin;
@@ -721,13 +711,7 @@
DAWN_TRY(GetDevice()->ValidateObject(destination->buffer));
}
- // Compute default values for bytesPerRow/rowsPerImage
- uint32_t defaultedBytesPerRow = destination->bytesPerRow;
- if (defaultedBytesPerRow == 0) {
- defaultedBytesPerRow =
- ComputeDefaultBytesPerRow(source->texture->GetFormat(), copySize->width);
- }
-
+ // Compute default value for rowsPerImage
uint32_t defaultedRowsPerImage = destination->rowsPerImage;
if (defaultedRowsPerImage == 0) {
defaultedRowsPerImage = copySize->height;
@@ -744,10 +728,10 @@
uint32_t bufferCopySize = 0;
DAWN_TRY(ValidateBytesPerRow(source->texture->GetFormat(), *copySize,
- defaultedBytesPerRow));
+ destination->bytesPerRow));
DAWN_TRY(ComputeTextureCopyBufferSize(source->texture->GetFormat(), *copySize,
- defaultedBytesPerRow, defaultedRowsPerImage,
- &bufferCopySize));
+ destination->bytesPerRow,
+ defaultedRowsPerImage, &bufferCopySize));
DAWN_TRY(ValidateCopySizeFitsInTexture(*source, *copySize));
DAWN_TRY(ValidateCopySizeFitsInBuffer(*destination, bufferCopySize));
@@ -770,7 +754,7 @@
copy->source.arrayLayer = source->arrayLayer;
copy->destination.buffer = destination->buffer;
copy->destination.offset = destination->offset;
- copy->destination.bytesPerRow = defaultedBytesPerRow;
+ copy->destination.bytesPerRow = destination->bytesPerRow;
copy->destination.rowsPerImage = defaultedRowsPerImage;
return {};
diff --git a/src/tests/end2end/CompressedTextureFormatTests.cpp b/src/tests/end2end/CompressedTextureFormatTests.cpp
index 41ea507..b29729a 100644
--- a/src/tests/end2end/CompressedTextureFormatTests.cpp
+++ b/src/tests/end2end/CompressedTextureFormatTests.cpp
@@ -488,34 +488,6 @@
}
}
-// Test using bytesPerRow == 0 in the copies with BC formats works correctly.
-TEST_P(CompressedTextureBCFormatTest, CopyWithZeroRowPitch) {
- // TODO(jiawei.shao@intel.com): find out why this test is flaky on Windows Intel Vulkan
- // bots.
- DAWN_SKIP_TEST_IF(IsIntel() && IsVulkan() && IsWindows());
-
- // TODO(jiawei.shao@intel.com): find out why this test fails on Windows Intel OpenGL drivers.
- DAWN_SKIP_TEST_IF(IsIntel() && IsOpenGL() && IsWindows());
-
- DAWN_SKIP_TEST_IF(!IsBCFormatSupported());
-
- CopyConfig config;
- config.textureDescriptor.usage = kDefaultBCFormatTextureUsage;
- config.textureDescriptor.size.height = 8;
- config.textureDescriptor.size.depth = 1;
-
- config.bytesPerRowAlignment = 0;
-
- for (wgpu::TextureFormat format : kBCFormats) {
- config.textureDescriptor.format = format;
- config.textureDescriptor.size.width = kTextureBytesPerRowAlignment /
- CompressedFormatBlockSizeInBytes(format) *
- kBCBlockWidthInTexels;
- config.copyExtent3D = config.textureDescriptor.size;
- TestCopyRegionIntoBCFormatTextures(config);
- }
-}
-
// Test copying into the non-zero layer of a 2D array texture with BC formats works correctly.
TEST_P(CompressedTextureBCFormatTest, CopyIntoNonZeroArrayLayer) {
// TODO(jiawei.shao@intel.com): find out why this test is flaky on Windows Intel Vulkan
diff --git a/src/tests/end2end/NonzeroTextureCreationTests.cpp b/src/tests/end2end/NonzeroTextureCreationTests.cpp
index 7cdafd5..0026322 100644
--- a/src/tests/end2end/NonzeroTextureCreationTests.cpp
+++ b/src/tests/end2end/NonzeroTextureCreationTests.cpp
@@ -141,7 +141,7 @@
wgpu::Buffer bufferDst = utils::CreateBufferFromData(
device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc);
- wgpu::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(bufferDst, 0, 0, 0);
+ wgpu::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(bufferDst, 0, kSize * 4, 0);
wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, 0, {0, 0, 0});
wgpu::Extent3D copySize = {kSize, kSize, 1};
@@ -175,7 +175,7 @@
wgpu::Buffer bufferDst = utils::CreateBufferFromData(
device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc);
- wgpu::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(bufferDst, 0, 0, 0);
+ wgpu::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(bufferDst, 0, kSize * 4, 0);
wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, 1, {0, 0, 0});
wgpu::Extent3D copySize = {kSize, kSize, 1};
diff --git a/src/tests/end2end/TextureZeroInitTests.cpp b/src/tests/end2end/TextureZeroInitTests.cpp
index 95e8119..d6b0df8 100644
--- a/src/tests/end2end/TextureZeroInitTests.cpp
+++ b/src/tests/end2end/TextureZeroInitTests.cpp
@@ -231,7 +231,8 @@
wgpu::Buffer stagingBuffer = utils::CreateBufferFromData(
device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc);
- wgpu::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(stagingBuffer, 0, 0, 0);
+ wgpu::BufferCopyView bufferCopyView =
+ utils::CreateBufferCopyView(stagingBuffer, 0, kSize * sizeof(uint32_t), 0);
wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, 0, {0, 0, 0});
wgpu::Extent3D copySize = {kSize, kSize, 1};
@@ -261,7 +262,8 @@
wgpu::Buffer stagingBuffer = utils::CreateBufferFromData(
device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc);
- wgpu::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(stagingBuffer, 0, 0, 0);
+ wgpu::BufferCopyView bufferCopyView =
+ utils::CreateBufferCopyView(stagingBuffer, 0, kSize * sizeof(uint16_t), 0);
wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, 0, {0, 0, 0});
wgpu::Extent3D copySize = {kSize / 2, kSize, 1};
@@ -331,7 +333,8 @@
std::vector<uint8_t> data(kFormatBlockByteSize * kSize * kSize, 100);
wgpu::Buffer stagingBuffer = utils::CreateBufferFromData(
device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc);
- wgpu::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(stagingBuffer, 0, 0, 0);
+ wgpu::BufferCopyView bufferCopyView =
+ utils::CreateBufferCopyView(stagingBuffer, 0, kSize * kFormatBlockByteSize, 0);
wgpu::TextureCopyView textureCopyView =
utils::CreateTextureCopyView(srcTexture, 0, 0, {0, 0, 0});
wgpu::Extent3D copySize = {kSize, kSize, 1};
@@ -704,7 +707,8 @@
wgpu::Buffer bufferDst = utils::CreateBufferFromData(
device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc);
- wgpu::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(bufferDst, 0, 0, 0);
+ wgpu::BufferCopyView bufferCopyView =
+ utils::CreateBufferCopyView(bufferDst, 0, kSize * kFormatBlockByteSize, 0);
wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, 1, {0, 0, 0});
wgpu::Extent3D copySize = {kSize, kSize, 1};
@@ -741,7 +745,8 @@
std::vector<uint8_t> data(kFormatBlockByteSize * kSize * kSize, 1);
wgpu::Buffer stagingBuffer = utils::CreateBufferFromData(
device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc);
- wgpu::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(stagingBuffer, 0, 0, 0);
+ wgpu::BufferCopyView bufferCopyView =
+ utils::CreateBufferCopyView(stagingBuffer, 0, kSize * kFormatBlockByteSize, 0);
wgpu::TextureCopyView textureCopyView = utils::CreateTextureCopyView(texture, 0, 0, {0, 0, 0});
wgpu::Extent3D copySize = {kSize, kSize, 1};
wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
@@ -888,7 +893,8 @@
std::vector<uint8_t> data(kFormatBlockByteSize * mipSize * mipSize, 2);
wgpu::Buffer stagingBuffer = utils::CreateBufferFromData(
device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc);
- wgpu::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(stagingBuffer, 0, 0, 0);
+ wgpu::BufferCopyView bufferCopyView =
+ utils::CreateBufferCopyView(stagingBuffer, 0, mipSize * kFormatBlockByteSize, 0);
wgpu::TextureCopyView textureCopyView =
utils::CreateTextureCopyView(sampleTexture, 1, 0, {0, 0, 0});
wgpu::Extent3D copySize = {mipSize, mipSize, 1};
@@ -965,7 +971,8 @@
std::vector<uint8_t> data(kFormatBlockByteSize * kSize * kSize, 2);
wgpu::Buffer stagingBuffer = utils::CreateBufferFromData(
device, data.data(), static_cast<uint32_t>(data.size()), wgpu::BufferUsage::CopySrc);
- wgpu::BufferCopyView bufferCopyView = utils::CreateBufferCopyView(stagingBuffer, 0, 0, 0);
+ wgpu::BufferCopyView bufferCopyView =
+ utils::CreateBufferCopyView(stagingBuffer, 0, kSize * kFormatBlockByteSize, 0);
wgpu::TextureCopyView textureCopyView =
utils::CreateTextureCopyView(sampleTexture, 0, 1, {0, 0, 0});
wgpu::Extent3D copySize = {kSize, kSize, 1};
diff --git a/src/tests/unittests/validation/CopyCommandsValidationTests.cpp b/src/tests/unittests/validation/CopyCommandsValidationTests.cpp
index de1da26..917446b 100644
--- a/src/tests/unittests/validation/CopyCommandsValidationTests.cpp
+++ b/src/tests/unittests/validation/CopyCommandsValidationTests.cpp
@@ -83,15 +83,15 @@
void TestB2TCopy(utils::Expectation expectation,
wgpu::Buffer srcBuffer,
uint64_t srcOffset,
- uint32_t srcRowPitch,
- uint32_t srcImageHeight,
+ uint32_t srcBytesPerRow,
+ uint32_t srcRowsPerImage,
wgpu::Texture destTexture,
uint32_t destLevel,
uint32_t destSlice,
wgpu::Origin3D destOrigin,
wgpu::Extent3D extent3D) {
wgpu::BufferCopyView bufferCopyView =
- utils::CreateBufferCopyView(srcBuffer, srcOffset, srcRowPitch, srcImageHeight);
+ utils::CreateBufferCopyView(srcBuffer, srcOffset, srcBytesPerRow, srcRowsPerImage);
wgpu::TextureCopyView textureCopyView =
utils::CreateTextureCopyView(destTexture, destLevel, destSlice, destOrigin);
@@ -108,11 +108,11 @@
wgpu::Origin3D srcOrigin,
wgpu::Buffer destBuffer,
uint64_t destOffset,
- uint32_t destRowPitch,
- uint32_t destImageHeight,
+ uint32_t destBytesPerRow,
+ uint32_t destRowsPerImage,
wgpu::Extent3D extent3D) {
wgpu::BufferCopyView bufferCopyView =
- utils::CreateBufferCopyView(destBuffer, destOffset, destRowPitch, destImageHeight);
+ utils::CreateBufferCopyView(destBuffer, destOffset, destBytesPerRow, destRowsPerImage);
wgpu::TextureCopyView textureCopyView =
utils::CreateTextureCopyView(srcTexture, srcLevel, srcSlice, srcOrigin);
@@ -465,15 +465,15 @@
{4, 4, 1});
}
-TEST_F(CopyCommandTest_B2T, IncorrectRowPitch) {
+TEST_F(CopyCommandTest_B2T, IncorrectBytesPerRow) {
uint64_t bufferSize = BufferSizeForTextureCopy(128, 16, 1);
wgpu::Buffer source = CreateBuffer(bufferSize, wgpu::BufferUsage::CopySrc);
wgpu::Texture destination = Create2DTexture(128, 16, 5, 1, wgpu::TextureFormat::RGBA8Unorm,
wgpu::TextureUsage::CopyDst);
- // Default bytes per row is not 256-byte aligned
+ // bytes per row is 0
TestB2TCopy(utils::Expectation::Failure, source, 0, 0, 0, destination, 0, 0, {0, 0, 0},
- {3, 4, 1});
+ {64, 4, 1});
// bytes per row is not 256-byte aligned
TestB2TCopy(utils::Expectation::Failure, source, 0, 128, 0, destination, 0, 0, {0, 0, 0},
@@ -582,7 +582,7 @@
// Regression tests for a bug in the computation of texture copy buffer size in Dawn.
TEST_F(CopyCommandTest_B2T, TextureCopyBufferSizeLastRowComputation) {
- constexpr uint32_t kRowPitch = 256;
+ constexpr uint32_t kBytesPerRow = 256;
constexpr uint32_t kWidth = 4;
constexpr uint32_t kHeight = 4;
@@ -590,15 +590,15 @@
wgpu::TextureFormat::RG8Unorm};
{
- // kRowPitch * (kHeight - 1) + kWidth is not large enough to be the valid buffer size in
+ // kBytesPerRow * (kHeight - 1) + kWidth is not large enough to be the valid buffer size in
// this test because the buffer sizes in B2T copies are not in texels but in bytes.
- constexpr uint32_t kInvalidBufferSize = kRowPitch * (kHeight - 1) + kWidth;
+ constexpr uint32_t kInvalidBufferSize = kBytesPerRow * (kHeight - 1) + kWidth;
for (wgpu::TextureFormat format : kFormats) {
wgpu::Buffer source = CreateBuffer(kInvalidBufferSize, wgpu::BufferUsage::CopySrc);
wgpu::Texture destination =
Create2DTexture(kWidth, kHeight, 1, 1, format, wgpu::TextureUsage::CopyDst);
- TestB2TCopy(utils::Expectation::Failure, source, 0, kRowPitch, 0, destination, 0, 0,
+ TestB2TCopy(utils::Expectation::Failure, source, 0, kBytesPerRow, 0, destination, 0, 0,
{0, 0, 0}, {kWidth, kHeight, 1});
}
}
@@ -614,14 +614,14 @@
{
uint32_t invalidBuffferSize = validBufferSize - 1;
wgpu::Buffer source = CreateBuffer(invalidBuffferSize, wgpu::BufferUsage::CopySrc);
- TestB2TCopy(utils::Expectation::Failure, source, 0, kRowPitch, 0, destination, 0, 0,
- {0, 0, 0}, {kWidth, kHeight, 1});
+ TestB2TCopy(utils::Expectation::Failure, source, 0, kBytesPerRow, 0, destination, 0,
+ 0, {0, 0, 0}, {kWidth, kHeight, 1});
}
{
wgpu::Buffer source = CreateBuffer(validBufferSize, wgpu::BufferUsage::CopySrc);
- TestB2TCopy(utils::Expectation::Success, source, 0, kRowPitch, 0, destination, 0, 0,
- {0, 0, 0}, {kWidth, kHeight, 1});
+ TestB2TCopy(utils::Expectation::Success, source, 0, kBytesPerRow, 0, destination, 0,
+ 0, {0, 0, 0}, {kWidth, kHeight, 1});
}
}
}
@@ -798,15 +798,15 @@
TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, vertex, 0, 256, 0, {4, 4, 1});
}
-TEST_F(CopyCommandTest_T2B, IncorrectRowPitch) {
+TEST_F(CopyCommandTest_T2B, IncorrectBytesPerRow) {
uint64_t bufferSize = BufferSizeForTextureCopy(128, 16, 1);
wgpu::Texture source = Create2DTexture(128, 16, 5, 1, wgpu::TextureFormat::RGBA8Unorm,
wgpu::TextureUsage::CopyDst);
wgpu::Buffer destination = CreateBuffer(bufferSize, wgpu::BufferUsage::CopySrc);
- // Default bytes per row is not 256-byte aligned
+ // bytes per row is 0
TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 256, 0,
- {3, 4, 1});
+ {64, 4, 1});
// bytes per row is not 256-byte aligned
TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0, 257, 0,
@@ -913,7 +913,7 @@
// Regression tests for a bug in the computation of texture copy buffer size in Dawn.
TEST_F(CopyCommandTest_T2B, TextureCopyBufferSizeLastRowComputation) {
- constexpr uint32_t kRowPitch = 256;
+ constexpr uint32_t kBytesPerRow = 256;
constexpr uint32_t kWidth = 4;
constexpr uint32_t kHeight = 4;
@@ -921,9 +921,9 @@
wgpu::TextureFormat::RG8Unorm};
{
- // kRowPitch * (kHeight - 1) + kWidth is not large enough to be the valid buffer size in
+ // kBytesPerRow * (kHeight - 1) + kWidth is not large enough to be the valid buffer size in
// this test because the buffer sizes in T2B copies are not in texels but in bytes.
- constexpr uint32_t kInvalidBufferSize = kRowPitch * (kHeight - 1) + kWidth;
+ constexpr uint32_t kInvalidBufferSize = kBytesPerRow * (kHeight - 1) + kWidth;
for (wgpu::TextureFormat format : kFormats) {
wgpu::Texture source =
@@ -931,7 +931,7 @@
wgpu::Buffer destination = CreateBuffer(kInvalidBufferSize, wgpu::BufferUsage::CopySrc);
TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0,
- kRowPitch, 0, {kWidth, kHeight, 1});
+ kBytesPerRow, 0, {kWidth, kHeight, 1});
}
}
@@ -948,14 +948,14 @@
wgpu::Buffer destination =
CreateBuffer(invalidBufferSize, wgpu::BufferUsage::CopyDst);
TestT2BCopy(utils::Expectation::Failure, source, 0, 0, {0, 0, 0}, destination, 0,
- kRowPitch, 0, {kWidth, kHeight, 1});
+ kBytesPerRow, 0, {kWidth, kHeight, 1});
}
{
wgpu::Buffer destination =
CreateBuffer(validBufferSize, wgpu::BufferUsage::CopyDst);
TestT2BCopy(utils::Expectation::Success, source, 0, 0, {0, 0, 0}, destination, 0,
- kRowPitch, 0, {kWidth, kHeight, 1});
+ kBytesPerRow, 0, {kWidth, kHeight, 1});
}
}
}
@@ -1263,17 +1263,17 @@
void TestBothTBCopies(utils::Expectation expectation,
wgpu::Buffer buffer,
uint64_t bufferOffset,
- uint32_t bufferRowPitch,
+ uint32_t bufferBytesPerRow,
uint32_t rowsPerImage,
wgpu::Texture texture,
uint32_t level,
uint32_t arraySlice,
wgpu::Origin3D origin,
wgpu::Extent3D extent3D) {
- TestB2TCopy(expectation, buffer, bufferOffset, bufferRowPitch, rowsPerImage, texture, level,
- arraySlice, origin, extent3D);
+ TestB2TCopy(expectation, buffer, bufferOffset, bufferBytesPerRow, rowsPerImage, texture,
+ level, arraySlice, origin, extent3D);
TestT2BCopy(expectation, texture, level, arraySlice, origin, buffer, bufferOffset,
- bufferRowPitch, rowsPerImage, extent3D);
+ bufferBytesPerRow, rowsPerImage, extent3D);
}
void TestBothT2TCopies(utils::Expectation expectation,
@@ -1330,12 +1330,10 @@
}
}
-// Tests to verify that RowPitch must not be smaller than (width / blockWidth) * blockSizeInBytes
-// and it is valid to use 0 as RowPitch in buffer-to-texture or texture-to-buffer copies with
-// compressed texture formats.
-// Note that in Dawn we require RowPitch be a multiple of 256, which ensures RowPitch will always be
-// the multiple of compressed texture block width in bytes.
-TEST_F(CopyCommandTest_CompressedTextureFormats, RowPitch) {
+// Tests to verify that bytesPerRow must not be less than (width / blockWidth) * blockSizeInBytes.
+// Note that in Dawn we require bytesPerRow be a multiple of 256, which ensures bytesPerRow will
+// always be the multiple of compressed texture block width in bytes.
+TEST_F(CopyCommandTest_CompressedTextureFormats, BytesPerRow) {
wgpu::Buffer buffer =
CreateBuffer(1024, wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst);
@@ -1343,60 +1341,36 @@
constexpr uint32_t kTestWidth = 160;
constexpr uint32_t kTestHeight = 160;
- // Failures on the RowPitch that is not large enough.
+ // Failures on the BytesPerRow that is not large enough.
{
- constexpr uint32_t kSmallRowPitch = 256;
+ constexpr uint32_t kSmallBytesPerRow = 256;
for (wgpu::TextureFormat bcFormat : kBCFormats) {
wgpu::Texture texture = Create2DTexture(bcFormat, 1, kTestWidth, kTestHeight);
- TestBothTBCopies(utils::Expectation::Failure, buffer, 0, kSmallRowPitch, 4, texture,
- 0, 0, {0, 0, 0}, {kTestWidth, 4, 1});
+ TestBothTBCopies(utils::Expectation::Failure, buffer, 0, kSmallBytesPerRow, 4,
+ texture, 0, 0, {0, 0, 0}, {kTestWidth, 4, 1});
}
}
- // Test it is not valid to use a RowPitch that is not a multiple of 256.
+ // Test it is not valid to use a BytesPerRow that is not a multiple of 256.
{
for (wgpu::TextureFormat bcFormat : kBCFormats) {
wgpu::Texture texture = Create2DTexture(bcFormat, 1, kTestWidth, kTestHeight);
- uint32_t inValidRowPitch =
+ uint32_t inValidBytesPerRow =
kTestWidth / 4 * CompressedFormatBlockSizeInBytes(bcFormat);
- ASSERT_NE(0u, inValidRowPitch % 256);
- TestBothTBCopies(utils::Expectation::Failure, buffer, 0, inValidRowPitch, 4,
+ ASSERT_NE(0u, inValidBytesPerRow % 256);
+ TestBothTBCopies(utils::Expectation::Failure, buffer, 0, inValidBytesPerRow, 4,
texture, 0, 0, {0, 0, 0}, {kTestWidth, 4, 1});
}
}
- // Test the smallest valid RowPitch should work.
+ // Test the smallest valid BytesPerRow should work.
{
for (wgpu::TextureFormat bcFormat : kBCFormats) {
wgpu::Texture texture = Create2DTexture(bcFormat, 1, kTestWidth, kTestHeight);
- uint32_t smallestValidRowPitch =
+ uint32_t smallestValidBytesPerRow =
Align(kTestWidth / 4 * CompressedFormatBlockSizeInBytes(bcFormat), 256);
- TestBothTBCopies(utils::Expectation::Success, buffer, 0, smallestValidRowPitch, 4,
- texture, 0, 0, {0, 0, 0}, {kTestWidth, 4, 1});
- }
- }
- }
-
- // Test RowPitch == 0.
- {
- constexpr uint32_t kZeroRowPitch = 0;
- constexpr uint32_t kTestHeight = 128;
-
- {
- constexpr uint32_t kValidWidth = 128;
- for (wgpu::TextureFormat bcFormat : kBCFormats) {
- wgpu::Texture texture = Create2DTexture(bcFormat, 1, kValidWidth, kTestHeight);
- TestBothTBCopies(utils::Expectation::Success, buffer, 0, kZeroRowPitch, 4, texture,
- 0, 0, {0, 0, 0}, {kValidWidth, 4, 1});
- }
- }
-
- {
- constexpr uint32_t kInValidWidth = 16;
- for (wgpu::TextureFormat bcFormat : kBCFormats) {
- wgpu::Texture texture = Create2DTexture(bcFormat, 1, kInValidWidth, kTestHeight);
- TestBothTBCopies(utils::Expectation::Failure, buffer, 0, kZeroRowPitch, 4, texture,
- 0, 0, {0, 0, 0}, {kInValidWidth, 4, 1});
+ TestBothTBCopies(utils::Expectation::Success, buffer, 0, smallestValidBytesPerRow,
+ 4, texture, 0, 0, {0, 0, 0}, {kTestWidth, 4, 1});
}
}
}
