diff --git a/tests/data/README.md b/tests/data/README.md
index 86ff1e0..31499f5 100644
--- a/tests/data/README.md
+++ b/tests/data/README.md
@@ -155,12 +155,21 @@
 
 ### Files `kodim*`
 
-#### File [kodim03_yuv420_8bpc.avif](io/kodim03_yuv420_8bpc.avif)
+#### File [kodim03_yuv420_8bpc.avif](io/kodim03_yuv420_8bpc.avif), [kodim03_yuv420_8bpc.y4m](kodim03_yuv420_8bpc.y4m)
 
 ![](io/kodim03_yuv420_8bpc.avif)
 
 License: released by the Eastman Kodak Company for unrestricted usage
 
+#### File [kodim03_yuv420_8bpc_384x256.y4m](kodim03_yuv420_8bpc_384x256.y4m)
+
+![](kodim03_yuv420_8bpc_384x256.y4m)
+
+License: released by the Eastman Kodak Company for unrestricted usage
+
+It is [kodim03_yuv420_8bpc.y4m](kodim03_yuv420_8bpc.y4m) resized to half the
+width and height.
+
 #### File [kodim03_grayscale_gamma1.6.png](kodim03_grayscale_gamma1.6.png)
 
 ![](kodim03_grayscale_gamma1.6.png)
diff --git a/tests/gtest/avif_fuzztest_helpers.cc b/tests/gtest/avif_fuzztest_helpers.cc
index e73ab73..28ab5ba 100644
--- a/tests/gtest/avif_fuzztest_helpers.cc
+++ b/tests/gtest/avif_fuzztest_helpers.cc
@@ -23,24 +23,30 @@
 
 //------------------------------------------------------------------------------
 
+// The number of seeds for kMaxNumLayers - 1 pairs of random width and height.
 constexpr size_t kNumLayeredRandDimSeeds = 2 * (kMaxNumLayers - 1);
 
+// Generates kMaxNumLayers pairs of random width and height. The first
+// kMaxNumLayers - 1 pairs of width and height are less than last_layer_width
+// and last_layer_height, respectively. The last pair is the given
+// last_layer_width and last_layer_height.
 template <typename Sample>
 std::array<std::pair<size_t, size_t>, kMaxNumLayers> GetAvifLayeredRandDims(
-    size_t display_width, size_t display_height, const Sample* seeds) {
-  assert(display_width > 1);
-  assert(display_height > 1);
+    size_t last_layer_width, size_t last_layer_height,
+    const std::vector<Sample>& seeds) {
+  assert(last_layer_width > 1);
+  assert(last_layer_height > 1);
   std::array<std::pair<size_t, size_t>, kMaxNumLayers> sizes = {};
-  for (size_t i = 0; i + 1 < kMaxNumLayers; ++i) {
+  for (size_t i = 0; i < kMaxNumLayers - 1; ++i) {
     const size_t width =
-        1 + (static_cast<size_t>(seeds[2 * i]) % (display_width - 1));
+        1 + (static_cast<size_t>(seeds[2 * i]) % (last_layer_width - 1));
     const size_t height =
-        1 + (static_cast<size_t>(seeds[2 * i + 1]) % (display_height - 1));
-    assert(width < display_width);
-    assert(height < display_height);
+        1 + (static_cast<size_t>(seeds[2 * i + 1]) % (last_layer_height - 1));
+    assert(width < last_layer_width);
+    assert(height < last_layer_height);
     sizes[i] = {width, height};
   }
-  sizes.back() = {display_width, display_height};
+  sizes[kMaxNumLayers - 1] = {last_layer_width, last_layer_height};
   return sizes;
 }
 
@@ -130,33 +136,33 @@
                                           avifPixelFormat pixel_format,
                                           bool has_alpha,
                                           const std::vector<uint8_t>& samples) {
-  std::vector<ImagePtr> layers = CreateAvifAnim8b(
-      kMaxNumLayers, width, height, pixel_format, has_alpha, samples);
-  return layers;
+  return CreateAvifAnim8b(kMaxNumLayers, width, height, pixel_format, has_alpha,
+                          samples);
 }
 
 std::vector<ImagePtr> CreateAvifLayered16b(
     size_t width, size_t height, int depth, avifPixelFormat pixel_format,
     bool has_alpha, const std::vector<uint16_t>& samples) {
-  std::vector<ImagePtr> layers = CreateAvifAnim16b(
-      kMaxNumLayers, width, height, depth, pixel_format, has_alpha, samples);
-  return layers;
+  return CreateAvifAnim16b(kMaxNumLayers, width, height, depth, pixel_format,
+                           has_alpha, samples);
 }
 
-size_t GetNumSamplesLayeredRandDim(size_t display_width, size_t display_height,
+size_t GetNumSamplesLayeredRandDim(size_t last_layer_width,
+                                   size_t last_layer_height,
                                    avifPixelFormat pixel_format,
                                    bool has_alpha) {
-  return kNumLayeredRandDimSeeds + GetNumSamples(kMaxNumLayers, display_width,
-                                                 display_height, pixel_format,
-                                                 has_alpha);
+  return kNumLayeredRandDimSeeds +
+         GetNumSamples(kMaxNumLayers, last_layer_width, last_layer_height,
+                       pixel_format, has_alpha);
 }
 
 std::vector<ImagePtr> CreateAvifLayeredRandDim8b(
-    size_t display_width, size_t display_height, avifPixelFormat pixel_format,
-    bool has_alpha, const std::vector<uint8_t>& samples) {
+    size_t last_layer_width, size_t last_layer_height,
+    avifPixelFormat pixel_format, bool has_alpha,
+    const std::vector<uint8_t>& samples) {
   assert(samples.size() >= kNumLayeredRandDimSeeds);
   const auto dims =
-      GetAvifLayeredRandDims(display_width, display_height, samples.data());
+      GetAvifLayeredRandDims(last_layer_width, last_layer_height, samples);
   std::vector<ImagePtr> layers;
   layers.reserve(kMaxNumLayers);
 
@@ -174,12 +180,12 @@
 }
 
 std::vector<ImagePtr> CreateAvifLayeredRandDim16b(
-    size_t display_width, size_t display_height, int depth,
+    size_t last_layer_width, size_t last_layer_height, int depth,
     avifPixelFormat pixel_format, bool has_alpha,
     const std::vector<uint16_t>& samples) {
   assert(samples.size() >= kNumLayeredRandDimSeeds);
   const auto dims =
-      GetAvifLayeredRandDims(display_width, display_height, samples.data());
+      GetAvifLayeredRandDims(last_layer_width, last_layer_height, samples);
   std::vector<ImagePtr> layers;
   layers.reserve(kMaxNumLayers);
 
diff --git a/tests/gtest/avif_fuzztest_helpers.h b/tests/gtest/avif_fuzztest_helpers.h
index 849f368..e210827 100644
--- a/tests/gtest/avif_fuzztest_helpers.h
+++ b/tests/gtest/avif_fuzztest_helpers.h
@@ -58,6 +58,7 @@
                                         avifPixelFormat pixel_format,
                                         bool has_alpha,
                                         const std::vector<uint16_t>& samples);
+// CreateAvifLayered* all return exactly kMaxNumLayers images.
 std::vector<ImagePtr> CreateAvifLayered8b(size_t width, size_t height,
                                           avifPixelFormat pixel_format,
                                           bool has_alpha,
@@ -66,10 +67,11 @@
     size_t width, size_t height, int depth, avifPixelFormat pixel_format,
     bool has_alpha, const std::vector<uint16_t>& samples);
 std::vector<ImagePtr> CreateAvifLayeredRandDim8b(
-    size_t display_width, size_t display_height, avifPixelFormat pixel_format,
-    bool has_alpha, const std::vector<uint8_t>& samples);
+    size_t last_layer_width, size_t last_layer_height,
+    avifPixelFormat pixel_format, bool has_alpha,
+    const std::vector<uint8_t>& samples);
 std::vector<ImagePtr> CreateAvifLayeredRandDim16b(
-    size_t display_width, size_t display_height, int depth,
+    size_t last_layer_width, size_t last_layer_height, int depth,
     avifPixelFormat pixel_format, bool has_alpha,
     const std::vector<uint16_t>& samples);
 EncoderPtr CreateAvifEncoder(avifCodecChoice codec_choice, int max_threads,
@@ -103,7 +105,10 @@
 
 size_t GetNumSamples(size_t num_frames, size_t width, size_t height,
                      avifPixelFormat pixel_format, bool has_alpha);
-size_t GetNumSamplesLayeredRandDim(size_t display_width, size_t display_height,
+// Returns the number of samples needed for CreateAvifLayeredRandDim8b() and
+// CreateAvifLayeredRandDim16b().
+size_t GetNumSamplesLayeredRandDim(size_t last_layer_width,
+                                   size_t last_layer_height,
                                    avifPixelFormat pixel_format,
                                    bool has_alpha);
 
@@ -254,21 +259,21 @@
   return fuzztest::OneOf(ArbitraryAvifLayered8b(), ArbitraryAvifLayered16b());
 }
 
-// Layered avifImage generator type: fixed number of layers, display size,
+// Layered avifImage generator type: fixed number of layers, last layer size,
 // pixel format and 8-bit samples.
 inline auto ArbitraryAvifLayeredRandDim8b() {
   constexpr uint16_t kMinLayerDimension = 8;
   constexpr uint16_t kMaxLayerDimension =
       kMaxDimension / kMaxNumFramesSquareRoot;
   return fuzztest::FlatMap(
-      [](size_t display_width, size_t display_height,
+      [](size_t last_layer_width, size_t last_layer_height,
          avifPixelFormat pixel_format, bool has_alpha) {
         return fuzztest::Map(
-            CreateAvifLayeredRandDim8b, fuzztest::Just(display_width),
-            fuzztest::Just(display_height), fuzztest::Just(pixel_format),
+            CreateAvifLayeredRandDim8b, fuzztest::Just(last_layer_width),
+            fuzztest::Just(last_layer_height), fuzztest::Just(pixel_format),
             fuzztest::Just(has_alpha),
             fuzztest::Arbitrary<std::vector<uint8_t>>().WithSize(
-                GetNumSamplesLayeredRandDim(display_width, display_height,
+                GetNumSamplesLayeredRandDim(last_layer_width, last_layer_height,
                                             pixel_format, has_alpha)));
       },
       fuzztest::InRange<uint16_t>(kMinLayerDimension, kMaxLayerDimension),
@@ -276,23 +281,24 @@
       ArbitraryPixelFormat(), fuzztest::Arbitrary<bool>());
 }
 
-// Layered avifImage generator type: fixed number of layers, display size,
+// Layered avifImage generator type: fixed number of layers, last layer size,
 // depth, pixel format and 16-bit samples.
 inline auto ArbitraryAvifLayeredRandDim16b() {
   constexpr uint16_t kMinLayerDimension = 8;
   constexpr uint16_t kMaxLayerDimension =
       kMaxDimension / kMaxNumFramesSquareRoot;
   return fuzztest::FlatMap(
-      [](size_t display_width, size_t display_height, int depth,
+      [](size_t last_layer_width, size_t last_layer_height, int depth,
          avifPixelFormat pixel_format, bool has_alpha) {
         return fuzztest::Map(
-            CreateAvifLayeredRandDim16b, fuzztest::Just(display_width),
-            fuzztest::Just(display_height), fuzztest::Just(depth),
+            CreateAvifLayeredRandDim16b, fuzztest::Just(last_layer_width),
+            fuzztest::Just(last_layer_height), fuzztest::Just(depth),
             fuzztest::Just(pixel_format), fuzztest::Just(has_alpha),
             fuzztest::ContainerOf<std::vector<uint16_t>>(
                 fuzztest::InRange<uint16_t>(0, (1 << depth) - 1))
                 .WithSize(GetNumSamplesLayeredRandDim(
-                    display_width, display_height, pixel_format, has_alpha)));
+                    last_layer_width, last_layer_height, pixel_format,
+                    has_alpha)));
       },
       fuzztest::InRange<uint16_t>(kMinLayerDimension, kMaxLayerDimension),
       fuzztest::InRange<uint16_t>(kMinLayerDimension, kMaxLayerDimension),
@@ -300,7 +306,7 @@
       fuzztest::Arbitrary<bool>());
 }
 
-// Generator for an arbitrary layered still image with display size override.
+// Generator for an arbitrary layered still image with varying layer sizes.
 inline auto ArbitraryAvifLayeredRandDim() {
   return fuzztest::OneOf(ArbitraryAvifLayeredRandDim8b(),
                          ArbitraryAvifLayeredRandDim16b());