Helper for robust texture content checking

src/common/framework/fixture.ts

@@ -246,9 +246,9 @@ export class Fixture {
     return cond;
   }
 
-  /** If the argument is an Error, fail (or warn). Otherwise, no-op. */
+  /** If the argument is an `Error`, fail (or warn). If it's `undefined`, no-op. */
   expectOK(
-    error: Error | unknown,
+    error: Error | undefined,
     { mode = 'fail', niceStack }: { mode?: 'fail' | 'warn'; niceStack?: Error } = {}
   ): void {
     if (error instanceof Error) {
@@ -264,4 +264,13 @@ export class Fixture {
       }
     }
   }
+
+  eventualExpectOK(
+    error: Promise<Error | undefined>,
+    { mode = 'fail' }: { mode?: 'fail' | 'warn' } = {}
+  ) {
+    this.eventualAsyncExpectation(async niceStack => {
+      this.expectOK(await error, { mode, niceStack });
+    });
+  }
 }

src/unittests/conversion.spec.ts

@@ -30,18 +30,34 @@ const cases = [
 ];
 
 g.test('float16BitsToFloat32').fn(t => {
-  cases.forEach(value => {
-    // some loose check
-    t.expect(Math.abs(float16BitsToFloat32(value[0]) - value[1]) <= 0.00001, value[0].toString(2));
-  });
+  for (const [bits, number] of [
+    ...cases,
+    [0b1_00000_0000000000, -0], // (resulting sign is not actually tested)
+    [0b0_00000_1111111111, 0.00006104], // subnormal f16 input
+    [0b1_00000_1111111111, -0.00006104],
+  ]) {
+    const actual = float16BitsToFloat32(bits);
+    t.expect(
+      // some loose check
+      Math.abs(actual - number) <= 0.00001,
+      `for ${bits.toString(2)}, expected ${number}, got ${actual}`
+    );
+  }
 });
 
 g.test('float32ToFloat16Bits').fn(t => {
-  cases.forEach(value => {
+  for (const [bits, number] of [
+    ...cases,
+    [0b0_00000_0000000000, 0.00001], // input that becomes subnormal in f16 is rounded to 0
+    [0b1_00000_0000000000, -0.00001], // and sign is preserved
+  ]) {
     // some loose check
-    // Does not handle clamping, underflow, overflow, or denormalized numbers.
-    t.expect(Math.abs(float32ToFloat16Bits(value[1]) - value[0]) <= 1, value[1].toString());
-  });
+    const actual = float32ToFloat16Bits(number);
+    t.expect(
+      Math.abs(actual - bits) <= 1,
+      `for ${number}, expected ${bits.toString(2)}, got ${actual.toString(2)}`
+    );
+  }
 });
 
 g.test('float32ToFloatBits_floatBitsToNumber')

src/webgpu/api/operation/command_buffer/image_copy.spec.ts

@@ -762,7 +762,7 @@ class ImageCopyTest extends GPUTest {
     this.expectGPUBufferValuesEqual(outputBuffer, expectedData);
   }
 
-  // MAINTENANCE_TODO(crbug.com/dawn/868): Revisit this when consolidating texture helpers.
+  // MAINTENANCE_TODO(#881): Migrate this into the texture_ok helpers.
   async checkStencilTextureContent(
     stencilTexture: GPUTexture,
     stencilTextureSize: readonly [number, number, number],
@@ -984,7 +984,7 @@ class ImageCopyTest extends GPUTest {
     }
   }
 
-  // MAINTENANCE_TODO(crbug.com/dawn/868): Revisit this when consolidating texture helpers.
+  // MAINTENANCE_TODO(#881): Consider if this can be simplified/encapsulated using TexelView.
   initializeDepthAspectWithRendering(
     depthTexture: GPUTexture,
     depthFormat: GPUTextureFormat,

src/webgpu/util/check_contents.ts

@@ -1,3 +1,9 @@
+// MAINTENANCE_TODO: The "checkThingTrue" naming is confusing; these must be used with `expectOK`
+// or the result is dropped on the floor. Rename these to things like `typedArrayIsOK`(??) to
+// make it clearer.
+// MAINTENANCE_TODO: Also, audit to make sure we aren't dropping any on the floor. Consider a
+// no-ignored-return lint check if we can find one that we can use.
+
 import {
   assert,
   ErrorWithExtra,

src/webgpu/util/color_space_conversion.ts

@@ -1,4 +1,4 @@
-import { assert } from '../../common/util/util.js';
+import { assert, unreachable } from '../../common/util/util.js';
 
 import { multiplyMatrices } from './math.js';
 
@@ -194,3 +194,68 @@ export function srgbToDisplayP3(pixel: {
 
   return pixel;
 }
+
+type InPlaceColorConversion = (rgba: {
+  R: number;
+  G: number;
+  B: number;
+  readonly A: number; // Alpha never changes during a conversion.
+}) => void;
+
+/**
+ * Returns a function which applies the specified colorspace/premultiplication conversion.
+ * Does not clamp, so may return values outside of the `dstColorSpace` gamut, due to either
+ * color space conversion or alpha premultiplication.
+ */
+export function makeInPlaceColorConversion({
+  srcPremultiplied,
+  dstPremultiplied,
+  srcColorSpace = 'srgb',
+  dstColorSpace = 'srgb',
+}: {
+  srcPremultiplied: boolean;
+  dstPremultiplied: boolean;
+  srcColorSpace?: PredefinedColorSpace;
+  dstColorSpace?: GPUPredefinedColorSpace;
+}): InPlaceColorConversion {
+  const requireColorSpaceConversion = srcColorSpace !== dstColorSpace;
+  const requireUnpremultiplyAlpha =
+    srcPremultiplied && (requireColorSpaceConversion || srcPremultiplied !== dstPremultiplied);
+  const requirePremultiplyAlpha =
+    dstPremultiplied && (requireColorSpaceConversion || srcPremultiplied !== dstPremultiplied);
+
+  return rgba => {
+    assert(rgba.A >= 0.0 && rgba.A <= 1.0, 'rgba.A out of bounds');
+
+    if (requireUnpremultiplyAlpha) {
+      if (rgba.A !== 0.0) {
+        rgba.R /= rgba.A;
+        rgba.G /= rgba.A;
+        rgba.B /= rgba.A;
+      } else {
+        assert(
+          rgba.R === 0.0 && rgba.G === 0.0 && rgba.B === 0.0 && rgba.A === 0.0,
+          'Unpremultiply ops with alpha value 0.0 requires all channels equals to 0.0'
+        );
+      }
+    }
+    // It's possible RGB are now > 1.
+    // This technically represents colors outside the src gamut, so no clamping yet.
+
+    if (requireColorSpaceConversion) {
+      // WebGPU currently only supports dstColorSpace = 'srgb'.
+      if (srcColorSpace === 'display-p3' && dstColorSpace === 'srgb') {
+        rgba = displayP3ToSrgb(rgba);
+      } else {
+        unreachable();
+      }
+    }
+    // Now RGB may also be negative if the src gamut is larger than the dst gamut.
+
+    if (requirePremultiplyAlpha) {
+      rgba.R *= rgba.A;
+      rgba.G *= rgba.A;
+      rgba.B *= rgba.A;
+    }
+  };
+}

src/webgpu/util/conversion.ts

@@ -9,11 +9,11 @@ import { clamp } from './math.js';
  */
 export function floatAsNormalizedInteger(float: number, bits: number, signed: boolean): number {
   if (signed) {
-    assert(float >= -1 && float <= 1);
+    assert(float >= -1 && float <= 1, () => `${float} out of bounds of snorm`);
     const max = Math.pow(2, bits - 1) - 1;
     return Math.round(float * max);
   } else {
-    assert(float >= 0 && float <= 1);
+    assert(float >= 0 && float <= 1, () => `${float} out of bounds of unorm`);
     const max = Math.pow(2, bits) - 1;
     return Math.round(float * max);
   }
@@ -44,7 +44,10 @@ export function normalizedIntegerAsFloat(integer: number, bits: number, signed:
  * sign, exponent, mantissa bits, and exponent bias.
  * Returns the result as an integer-valued JS `number`.
  *
- * Does not handle clamping, underflow, overflow, or denormalized numbers.
+ * Does not handle clamping, overflow, or denormal inputs.
+ * On underflow (result is subnormal), rounds to (signed) zero.
+ *
+ * MAINTENANCE_TODO: Replace usages of this with numberToFloatBits.
  */
 export function float32ToFloatBits(
   n: number,
@@ -80,18 +83,24 @@ export function float32ToFloatBits(
 
   // Convert to the new biased exponent.
   const newBiasedExp = bias + exp;
-  assert(newBiasedExp >= 0 && newBiasedExp < 1 << exponentBits);
+  assert(newBiasedExp < 1 << exponentBits, () => `input number ${n} overflows target type`);
 
-  // Mask only the mantissa, and discard the lower bits.
-  const newMantissa = (bits & 0x7fffff) >> mantissaBitsToDiscard;
-  return (sign << (exponentBits + mantissaBits)) | (newBiasedExp << mantissaBits) | newMantissa;
+  if (newBiasedExp <= 0) {
+    // Result is subnormal or zero. Round to (signed) zero.
+    return sign << (exponentBits + mantissaBits);
+  } else {
+    // Mask only the mantissa, and discard the lower bits.
+    const newMantissa = (bits & 0x7fffff) >> mantissaBitsToDiscard;
+    return (sign << (exponentBits + mantissaBits)) | (newBiasedExp << mantissaBits) | newMantissa;
+  }
 }
 
 /**
  * Encodes a JS `number` into an IEEE754 16 bit floating point number.
  * Returns the result as an integer-valued JS `number`.
  *
- * Does not handle clamping, underflow, overflow, or denormalized numbers.
+ * Does not handle clamping, overflow, or denormal inputs.
+ * On underflow (result is subnormal), rounds to (signed) zero.
  */
 export function float32ToFloat16Bits(n: number) {
   return float32ToFloatBits(n, 1, 5, 10, 15);
@@ -146,6 +155,17 @@ export function floatBitsToNumber(bits: number, fmt: FloatFormat): number {
   return numberWithWrongBias * 2 ** (kFloat32Format.bias - fmt.bias);
 }
 
+/**
+ * Encodes a JS `number` into an IEEE754 floating point number with the specified format.
+ * Returns the result as an integer-valued JS `number`.
+ *
+ * Does not handle clamping, overflow, or denormal inputs.
+ * On underflow (result is subnormal), rounds to (signed) zero.
+ */
+export function numberToFloatBits(number: number, fmt: FloatFormat): number {
+  return float32ToFloatBits(number, fmt.signed, fmt.exponentBits, fmt.mantissaBits, fmt.bias);
+}
+
 /**
  * Given a floating point number (as an integer representing its bits), computes how many ULPs it is
  * from zero.