diff --git a/CHANGELOG.md b/CHANGELOG.md
index d7c8307..206d2aa 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,6 +12,7 @@
 
 * Add the ignoreICC option to avifDecoder
 * Support ignoring alpha in avifDecoder::imageContentToDecode
+* Support encoding layered image with pre-scaled inputs
 * avifenc: add --ignore-alpha flag to discard alpha channel on encode
 * avifgainmaputil: add --ignore-alpha flag to discard alpha channel
 * avifgainmaputil: add --ignore-exif and --ignore-xmp flags
diff --git a/apps/avifenc.c b/apps/avifenc.c
index e169839..c3b37d0 100644
--- a/apps/avifenc.c
+++ b/apps/avifenc.c
@@ -78,6 +78,10 @@
     avifMatrixCoefficients matrixCoefficients;
     avifChromaDownsampling chromaDownsampling;
     avifAppFileFormat inputFormat;
+
+    // The last layer's size. Inferred from the last input, only needed when using --layered.
+    uint32_t width;
+    uint32_t height;
 } avifSettings;
 
 typedef struct
@@ -454,6 +458,58 @@
     return AVIF_TRUE;
 }
 
+static avifBool avifVerifyImageFitsLastLayerSize(const avifSettings * settings, const avifImage * image, const char * filename)
+{
+    if (settings->width == 0) {
+        return AVIF_TRUE;
+    }
+    if ((image->width > settings->width) || (image->height > settings->height)) {
+        fprintf(stderr,
+                "ERROR: Input image dimensions [%ux%u] exceed the last layer's size [%ux%u]: %s\n",
+                image->width,
+                image->height,
+                settings->width,
+                settings->height,
+                filename);
+        return AVIF_FALSE;
+    }
+    return AVIF_TRUE;
+}
+
+// Checks, before encoding and in terms of CLI, for the settings that the library would reject once
+// combined with --layered inputs of different sizes (--layered sets avifEncoder.width/height, two
+// fields avifenc's users never set directly). Only checks conditions actually reachable via
+// avifenc's CLI. For example, grids and non-layered images can't reach this point at all, so they
+// are not checked here.
+static avifBool avifVerifyLastLayerSizeCompatibility(const avifSettings * settings, const avifInput * input, const avifImage * firstImage)
+{
+    if (settings->width == 0) {
+        return AVIF_TRUE;
+    }
+    for (int i = 0; i < settings->layers; ++i) {
+        const avifScalingMode * scalingMode = &input->files[i].settings.scalingMode.value;
+        const avifBool isNoScaling = (scalingMode->horizontal.n == scalingMode->horizontal.d) &&
+                                     (scalingMode->vertical.n == scalingMode->vertical.d);
+        if (input->files[i].settings.scalingMode.set && !isNoScaling) {
+            fprintf(stderr, "ERROR: --scaling-mode cannot be used with --layered inputs of different sizes\n");
+            return AVIF_FALSE;
+        }
+    }
+    if (input->requestedDepthExtension != 0) {
+        fprintf(stderr, "ERROR: --depth with bit depth extension cannot be used with --layered inputs of different sizes\n");
+        return AVIF_FALSE;
+    }
+#if defined(AVIF_ENABLE_JPEG_GAIN_MAP_CONVERSION)
+    if (firstImage->gainMap && firstImage->gainMap->image) {
+        fprintf(stderr, "ERROR: A gain map cannot be used with --layered inputs of different sizes (use --ignore-gain-map)\n");
+        return AVIF_FALSE;
+    }
+#else
+    (void)firstImage;
+#endif
+    return AVIF_TRUE;
+}
+
 static avifBool avifInputAddCachedImage(avifInput * input)
 {
     avifImage * newImage = avifImageCreateEmpty();
@@ -860,10 +916,11 @@
 static avifBool avifEncoderVerifyImageCompatibility(const avifImage * refImage,
                                                     const avifImage * testImage,
                                                     const char * seriesType,
-                                                    const char * filename)
+                                                    const char * filename,
+                                                    avifBool allowDimensionChange)
 {
     // Verify that this frame's properties matches the first frame's properties
-    if ((refImage->width != testImage->width) || (refImage->height != testImage->height)) {
+    if (!allowDimensionChange && ((refImage->width != testImage->width) || (refImage->height != testImage->height))) {
         fprintf(stderr,
                 "ERROR: Image %s dimensions mismatch, [%ux%u] vs [%ux%u]: %s\n",
                 seriesType,
@@ -954,7 +1011,11 @@
                                 settings->inputFormat)) {
             goto cleanup;
         }
-        if (!avifEncoderVerifyImageCompatibility(firstImage, nextImage, "sequence", avifPrettyFilename(nextFile->filename))) {
+        if (!avifEncoderVerifyImageCompatibility(firstImage,
+                                                 nextImage,
+                                                 "sequence",
+                                                 avifPrettyFilename(nextFile->filename),
+                                                 /*allowDimensionChange=*/AVIF_FALSE)) {
             goto cleanup;
         }
         if (!avifEncodeUpdateEncoderSettings(encoder, nextSettings)) {
@@ -1061,6 +1122,9 @@
                                     settings->inputFormat)) {
                 goto cleanup;
             }
+            if (!avifVerifyImageFitsLastLayerSize(settings, nextImage, avifPrettyFilename(nextFile->filename))) {
+                goto cleanup;
+            }
             // frameIter is NULL if y4m reached end, so single frame y4m is still supported.
             if (input->frameIter) {
                 fprintf(stderr,
@@ -1068,7 +1132,11 @@
                         avifPrettyFilename(nextFile->filename));
                 goto cleanup;
             }
-            if (!avifEncoderVerifyImageCompatibility(firstImage, nextImage, "layer", avifPrettyFilename(nextFile->filename))) {
+            if (!avifEncoderVerifyImageCompatibility(firstImage,
+                                                     nextImage,
+                                                     "layer",
+                                                     avifPrettyFilename(nextFile->filename),
+                                                     /*allowDimensionChange=*/AVIF_TRUE)) {
                 goto cleanup;
             }
             if (!avifEncodeUpdateEncoderSettings(encoder, nextSettings)) {
@@ -1129,6 +1197,8 @@
     encoder->creationTime = settings->creationTime;
     encoder->modificationTime = settings->modificationTime;
     encoder->extraLayerCount = settings->layers - 1;
+    encoder->width = settings->width;
+    encoder->height = settings->height;
     if (!avifEncodeUpdateEncoderSettings(encoder, &firstFile->settings)) {
         goto cleanup;
     }
@@ -2381,6 +2451,38 @@
         goto cleanup;
     }
 
+    uint32_t outputImageWidth = image->width;
+    uint32_t outputImageHeight = image->height;
+    if (settings.layered) {
+        // Get the resolution of the last layer without decoding it, to fill the output image size
+        // in advance.
+        // Only fill the output image size if the last layer's resolution differs from the first
+        // layer's, to not interfere with --scaling-mode.
+        const avifInputFile * lastFile = &input.files[input.filesCount - 1];
+        avifImage * lastImage = avifImageCreateEmpty();
+        if (!lastImage) {
+            fprintf(stderr, "ERROR: Out of memory\n");
+            goto cleanup;
+        }
+        const avifBool lastImageOk = avifPeekImage(lastFile->filename, settings.inputFormat, lastImage) != AVIF_APP_FILE_FORMAT_UNKNOWN;
+        if (lastImageOk && ((lastImage->width != image->width) || (lastImage->height != image->height))) {
+            outputImageWidth = settings.width = lastImage->width;
+            outputImageHeight = settings.height = lastImage->height;
+        }
+        avifImageDestroy(lastImage);
+        if (!lastImageOk) {
+            fprintf(stderr, "ERROR: Failed to peek last layer: %s\n", avifPrettyFilename(lastFile->filename));
+            goto cleanup;
+        }
+    }
+
+    if (!avifVerifyImageFitsLastLayerSize(&settings, image, avifPrettyFilename(firstFile->filename))) {
+        goto cleanup;
+    }
+    if (!avifVerifyLastLayerSizeCompatibility(&settings, &input, image)) {
+        goto cleanup;
+    }
+
     printf("Successfully loaded: %s\n", avifPrettyFilename(firstFile->filename));
 
     // Prepare image timings
@@ -2433,7 +2535,7 @@
         image->pasp.vSpacing = settings.paspValues[1];
     }
     if (cropConversionRequired) {
-        if (!convertCropToClap(image->width, image->height, settings.clapValues)) {
+        if (!convertCropToClap(outputImageWidth, outputImageHeight, settings.clapValues)) {
             goto cleanup;
         }
         settings.clapValid = AVIF_TRUE;
@@ -2453,7 +2555,7 @@
         avifCropRect cropRect;
         avifDiagnostics diag;
         avifDiagnosticsClearError(&diag);
-        if (!avifCropRectFromCleanApertureBox(&cropRect, &image->clap, image->width, image->height, &diag)) {
+        if (!avifCropRectFromCleanApertureBox(&cropRect, &image->clap, outputImageWidth, outputImageHeight, &diag)) {
             fprintf(stderr,
                     "ERROR: Invalid clap: width:[%d / %d], height:[%d / %d], horizOff:[%d / %d], vertOff:[%d / %d] - %s\n",
                     (int32_t)image->clap.widthN,
@@ -2634,8 +2736,14 @@
         lossyHint = " (Lossless)";
     }
     printf("AVIF to be written:%s\n", lossyHint);
+    // avifImageDump wants the info of one cell, but image, outputImageWidth, and outputImageHeight
+    // are the before-split image and its info when avifImageSplitGrid is called.
     const avifImage * avif = gridCells ? gridCells[0] : image;
+    const uint32_t cellWidth = gridCells ? avif->width : outputImageWidth;
+    const uint32_t cellHeight = gridCells ? avif->height : outputImageHeight;
     avifImageDump(avif,
+                  cellWidth,
+                  cellHeight,
                   settings.gridDims[0],
                   settings.gridDims[1],
                   settings.layers > 1 ? AVIF_PROGRESSIVE_STATE_AVAILABLE : AVIF_PROGRESSIVE_STATE_UNAVAILABLE);
diff --git a/apps/avifgainmaputil/imageio.cc b/apps/avifgainmaputil/imageio.cc
index 2333733..8b3ed6f 100644
--- a/apps/avifgainmaputil/imageio.cc
+++ b/apps/avifgainmaputil/imageio.cc
@@ -362,7 +362,7 @@
                      const std::string& output_filename) {
   avifRWData encoded = AVIF_DATA_EMPTY;
   std::cout << "AVIF to be written:\n";
-  avifImageDump(image,
+  avifImageDump(image, image->width, image->height,
                 /*gridCols=*/1,
                 /*gridRows=*/1, AVIF_PROGRESSIVE_STATE_UNAVAILABLE);
   PrintEncodingSettings(encoder, image->gainMap != nullptr);
@@ -407,7 +407,8 @@
 
   avifRWData encoded = AVIF_DATA_EMPTY;
   std::cout << "AVIF to be written:\n";
-  avifImageDump(grid_cells_ptrs[0], grid_cols, grid_rows,
+  avifImageDump(grid_cells_ptrs[0], grid_cells_ptrs[0]->width,
+                grid_cells_ptrs[0]->height, grid_cols, grid_rows,
                 AVIF_PROGRESSIVE_STATE_UNAVAILABLE);
   PrintEncodingSettings(encoder, image->gainMap != nullptr);
   avifResult result = avifEncoderAddImageGrid(encoder, grid_cols, grid_rows,
diff --git a/apps/shared/avifjpeg.c b/apps/shared/avifjpeg.c
index 0126cd2..cd9e061 100644
--- a/apps/shared/avifjpeg.c
+++ b/apps/shared/avifjpeg.c
@@ -486,7 +486,8 @@
                                      avifBool ignoreExif,
                                      avifBool ignoreXMP,
                                      avifBool ignoreGainMap,
-                                     uint32_t sizeLimit);
+                                     uint32_t sizeLimit,
+                                     avifBool headerOnly);
 
 // Arbitrary max number of jpeg segments to parse before giving up.
 #define MAX_JPEG_SEGMENTS 100
@@ -1024,7 +1025,8 @@
                                   /*ignoreExif=*/AVIF_TRUE,
                                   /*ignoreXMP=*/AVIF_FALSE,
                                   /*ignoreGainMap=*/AVIF_TRUE,
-                                  sizeLimit)) {
+                                  sizeLimit,
+                                  /*headerOnly=*/AVIF_FALSE)) {
             continue;
         }
         if (avifJPEGHasGainMapXMPNode(avif->xmp.data, avif->xmp.size, NULL)) {
@@ -1261,7 +1263,8 @@
                                      avifBool ignoreExif,
                                      avifBool ignoreXMP,
                                      avifBool ignoreGainMap,
-                                     uint32_t sizeLimit)
+                                     uint32_t sizeLimit,
+                                     avifBool headerOnly)
 {
     volatile avifBool ret = AVIF_FALSE;
     uint8_t * volatile iccData = NULL;
@@ -1305,6 +1308,8 @@
         fprintf(stderr, "Too big JPEG dimensions (%u x %u > %u px): %s\n", cinfo.output_width, cinfo.output_height, sizeLimit, inputFilename);
         goto cleanup;
     }
+    avif->width = cinfo.output_width;
+    avif->height = cinfo.output_height;
 
     if (!ignoreColorProfile) {
         uint8_t * iccDataTmp;
@@ -1336,6 +1341,12 @@
     // JPEG doesn't have alpha. Prevent confusion.
     avif->alphaPremultiplied = AVIF_FALSE;
 
+    if (headerOnly) {
+        // No real decoding needed. Stop here.
+        ret = AVIF_TRUE;
+        goto cleanup;
+    }
+
     if (avifJPEGReadCopy(avif, sizeLimit, &cinfo)) {
         // JPEG pixels were successfully copied without conversion. Notify the enduser.
 
@@ -1351,8 +1362,6 @@
         int row_stride = cinfo.output_width * cinfo.output_components;
         JSAMPARRAY buffer = (*cinfo.mem->alloc_sarray)((j_common_ptr)&cinfo, JPOOL_IMAGE, row_stride, 1);
 
-        avif->width = cinfo.output_width;
-        avif->height = cinfo.output_height;
         if (avif->matrixCoefficients == AVIF_MATRIX_COEFFICIENTS_YCGCO_RO) {
             fprintf(stderr, "AVIF_MATRIX_COEFFICIENTS_YCGCO_RO cannot be used with JPEG because it has an even bit depth.\n");
             goto cleanup;
@@ -1672,13 +1681,37 @@
                                               ignoreExif,
                                               ignoreXMP,
                                               ignoreGainMap,
-                                              sizeLimit);
+                                              sizeLimit,
+                                              /*headerOnly=*/AVIF_FALSE);
     if (f && f != stdin) {
         fclose(f);
     }
     return res;
 }
 
+avifBool avifJPEGPeek(const char * inputFilename, avifImage * avif)
+{
+    FILE * f = fopen(inputFilename, "rb");
+    if (!f) {
+        fprintf(stderr, "Can't open JPEG file for read: %s\n", inputFilename);
+        return AVIF_FALSE;
+    }
+    const avifBool res = avifJPEGReadInternal(f,
+                                              inputFilename,
+                                              avif,
+                                              AVIF_PIXEL_FORMAT_NONE,
+                                              /*requestedDepth=*/0,
+                                              AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC,
+                                              /*ignoreColorProfile=*/AVIF_TRUE,
+                                              /*ignoreExif=*/AVIF_TRUE,
+                                              /*ignoreXMP=*/AVIF_TRUE,
+                                              /*ignoreGainMap=*/AVIF_TRUE,
+                                              /*sizeLimit=*/UINT32_MAX,
+                                              /*headerOnly=*/AVIF_TRUE);
+    fclose(f);
+    return res;
+}
+
 avifBool avifJPEGWrite(const char * outputFilename, const avifImage * avif, int jpegQuality, avifChromaUpsampling chromaUpsampling)
 {
     avifBool ret = AVIF_FALSE;
diff --git a/apps/shared/avifjpeg.h b/apps/shared/avifjpeg.h
index 4cfc1e5..ad035d7 100644
--- a/apps/shared/avifjpeg.h
+++ b/apps/shared/avifjpeg.h
@@ -26,6 +26,11 @@
                       avifBool ignoreXMP,
                       avifBool ignoreGainMap,
                       uint32_t sizeLimit);
+
+// Parse the jpeg file at path 'inputFilename' and write its metadata into 'avif'
+// without decoding the pixels.
+avifBool avifJPEGPeek(const char * inputFilename, avifImage * avif);
+
 avifBool avifJPEGWrite(const char * outputFilename, const avifImage * avif, int jpegQuality, avifChromaUpsampling chromaUpsampling);
 
 #if defined(AVIF_ENABLE_JPEG_GAIN_MAP_CONVERSION)
diff --git a/apps/shared/avifpng.c b/apps/shared/avifpng.c
index 9d7fee5..cfb5049 100644
--- a/apps/shared/avifpng.c
+++ b/apps/shared/avifpng.c
@@ -279,7 +279,8 @@
                                 avifBool ignoreXMP,
                                 avifBool ignoreAlpha,
                                 uint32_t imageSizeLimit,
-                                uint32_t * outPNGDepth)
+                                uint32_t * outPNGDepth,
+                                avifBool headerOnly)
 {
     volatile avifBool readResult = AVIF_FALSE;
     png_structp png = NULL;
@@ -505,15 +506,23 @@
         // Note: There is no support for the rare "Raw profile type icc" or "Raw profile type icm" text chunks.
     }
 
+    if (avif->width > imageSizeLimit / avif->height) {
+        fprintf(stderr, "Too big PNG dimensions (%u x %u > %u px): %s\n", avif->width, avif->height, imageSizeLimit, inputFilename);
+        goto cleanup;
+    }
+
+    if (headerOnly) {
+        // All the metadata read so far (dimensions, depth, yuvFormat, ICC/color primaries if
+        // requested) is already set on avif. Stop here instead of decoding any pixel data.
+        readResult = AVIF_TRUE;
+        goto cleanup;
+    }
+
     const int numChannels = png_get_channels(png, info);
     if (numChannels < 1 || numChannels > 4) {
         fprintf(stderr, "png_get_channels() should return 1, 2, 3 or 4 but returns %d.\n", numChannels);
         goto cleanup;
     }
-    if (avif->width > imageSizeLimit / avif->height) {
-        fprintf(stderr, "Too big PNG dimensions (%u x %u > %u px): %s\n", avif->width, avif->height, imageSizeLimit, inputFilename);
-        goto cleanup;
-    }
 
     avifRGBImageSetDefaults(&rgb, avif);
     rgb.chromaDownsampling = chromaDownsampling;
@@ -613,7 +622,8 @@
                                          ignoreXMP,
                                          ignoreAlpha,
                                          imageSizeLimit,
-                                         outPNGDepth);
+                                         outPNGDepth,
+                                         /*headerOnly=*/AVIF_FALSE);
 
     if (f != stdin) {
         fclose(f);
@@ -621,6 +631,31 @@
     return res;
 }
 
+avifBool avifPNGPeek(const char * inputFilename, avifImage * avif)
+{
+    FILE * f = fopen(inputFilename, "rb");
+    if (!f) {
+        fprintf(stderr, "Can't open PNG file for read: %s\n", inputFilename);
+        return AVIF_FALSE;
+    }
+
+    const avifBool res = avifPNGReadImpl(f,
+                                         inputFilename,
+                                         avif,
+                                         /*requestedFormat=*/AVIF_PIXEL_FORMAT_NONE,
+                                         /*requestedDepth=*/0,
+                                         AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC,
+                                         /*ignoreColorProfile=*/AVIF_TRUE,
+                                         /*ignoreExif=*/AVIF_TRUE,
+                                         /*ignoreXMP=*/AVIF_TRUE,
+                                         /*ignoreAlpha=*/AVIF_TRUE,
+                                         /*imageSizeLimit=*/UINT32_MAX,
+                                         /*outPNGDepth=*/NULL,
+                                         /*headerOnly=*/AVIF_TRUE);
+    fclose(f);
+    return res;
+}
+
 //------------------------------------------------------------------------------
 // Writing
 
diff --git a/apps/shared/avifpng.h b/apps/shared/avifpng.h
index b50d2b7..cbe3774 100644
--- a/apps/shared/avifpng.h
+++ b/apps/shared/avifpng.h
@@ -22,6 +22,11 @@
                      avifBool ignoreAlpha,
                      uint32_t imageSizeLimit,
                      uint32_t * outPNGDepth);
+
+// Parse the PNG file at path 'inputFilename' and write its metadata into 'avif'
+// without decoding the pixels.
+avifBool avifPNGPeek(const char * inputFilename, avifImage * avif);
+
 avifBool avifPNGWrite(const char * outputFilename,
                       const avifImage * avif,
                       uint32_t requestedDepth,
diff --git a/apps/shared/avifutil.c b/apps/shared/avifutil.c
index bd0eaf6..6a370fc 100644
--- a/apps/shared/avifutil.c
+++ b/apps/shared/avifutil.c
@@ -61,10 +61,16 @@
     }
 }
 
-static void avifImageDumpInternal(const avifImage * avif, uint32_t gridCols, uint32_t gridRows, avifBool alphaPresent, avifProgressiveState progressiveState)
+static void avifImageDumpInternal(const avifImage * avif,
+                                  uint32_t cellWidth,
+                                  uint32_t cellHeight,
+                                  uint32_t gridCols,
+                                  uint32_t gridRows,
+                                  avifBool alphaPresent,
+                                  avifProgressiveState progressiveState)
 {
-    uint32_t width = avif->width;
-    uint32_t height = avif->height;
+    uint32_t width = cellWidth;
+    uint32_t height = cellHeight;
     if (gridCols && gridRows) {
         width *= gridCols;
         height *= gridRows;
@@ -120,7 +126,7 @@
             avifCropRect cropRect;
             avifDiagnostics diag;
             avifDiagnosticsClearError(&diag);
-            avifBool validClap = avifCropRectFromCleanApertureBox(&cropRect, &avif->clap, avif->width, avif->height, &diag);
+            avifBool validClap = avifCropRectFromCleanApertureBox(&cropRect, &avif->clap, cellWidth, cellHeight, &diag);
             if (validClap) {
                 printf("      * Valid, derived crop rect: X: %d, Y: %d, W: %d, H: %d%s\n",
                        cropRect.x,
@@ -193,15 +199,15 @@
     }
 }
 
-void avifImageDump(const avifImage * avif, uint32_t gridCols, uint32_t gridRows, avifProgressiveState progressiveState)
+void avifImageDump(const avifImage * avif, uint32_t cellWidth, uint32_t cellHeight, uint32_t gridCols, uint32_t gridRows, avifProgressiveState progressiveState)
 {
     const avifBool alphaPresent = avif->alphaPlane && (avif->alphaRowBytes > 0);
-    avifImageDumpInternal(avif, gridCols, gridRows, alphaPresent, progressiveState);
+    avifImageDumpInternal(avif, cellWidth, cellHeight, gridCols, gridRows, alphaPresent, progressiveState);
 }
 
 void avifContainerDump(const avifDecoder * decoder)
 {
-    avifImageDumpInternal(decoder->image, 0, 0, decoder->alphaPresent, decoder->progressiveState);
+    avifImageDumpInternal(decoder->image, decoder->image->width, decoder->image->height, 0, 0, decoder->alphaPresent, decoder->progressiveState);
     if (decoder->imageSequenceTrackPresent) {
         if (decoder->repetitionCount == AVIF_REPETITION_COUNT_INFINITE) {
             printf(" * Repeat Count   : Infinite\n");
@@ -364,6 +370,34 @@
     return inputFormat;
 }
 
+avifAppFileFormat avifPeekImage(const char * filename, avifAppFileFormat inputFormat, avifImage * image)
+{
+    if (inputFormat == AVIF_APP_FILE_FORMAT_UNKNOWN) {
+        inputFormat = avifGuessFileFormat(filename);
+    }
+
+    if (inputFormat == AVIF_APP_FILE_FORMAT_Y4M) {
+        if (!y4mPeek(filename, image)) {
+            return AVIF_APP_FILE_FORMAT_UNKNOWN;
+        }
+    } else if (inputFormat == AVIF_APP_FILE_FORMAT_JPEG) {
+        if (!avifJPEGPeek(filename, image)) {
+            return AVIF_APP_FILE_FORMAT_UNKNOWN;
+        }
+    } else if (inputFormat == AVIF_APP_FILE_FORMAT_PNG) {
+        if (!avifPNGPeek(filename, image)) {
+            return AVIF_APP_FILE_FORMAT_UNKNOWN;
+        }
+    } else if (inputFormat == AVIF_APP_FILE_FORMAT_UNKNOWN) {
+        fprintf(stderr, "Unrecognized file format for input file: %s\n", filename);
+        return AVIF_APP_FILE_FORMAT_UNKNOWN;
+    } else {
+        fprintf(stderr, "Unsupported file format %s for input file: %s\n", avifFileFormatToString(inputFormat), filename);
+        return AVIF_APP_FILE_FORMAT_UNKNOWN;
+    }
+    return inputFormat;
+}
+
 avifBool avifReadEntireFile(const char * filename, avifRWData * raw)
 {
     FILE * f = fopen(filename, "rb");
diff --git a/apps/shared/avifutil.h b/apps/shared/avifutil.h
index 5b01d85..bec09ab 100644
--- a/apps/shared/avifutil.h
+++ b/apps/shared/avifutil.h
@@ -28,7 +28,9 @@
 #define AVIF_FMT_ZU "zu"
 #endif
 
-void avifImageDump(const avifImage * avif, uint32_t gridCols, uint32_t gridRows, avifProgressiveState progressiveState);
+// Dumps the information of an AVIF file that has gridCols*gridRows cells (1*1 for non-grid image)
+// and 'avif' as the first cell that's encoded to have size cellWidth*cellHeight.
+void avifImageDump(const avifImage * avif, uint32_t cellWidth, uint32_t cellHeight, uint32_t gridCols, uint32_t gridRows, avifProgressiveState progressiveState);
 void avifContainerDump(const avifDecoder * decoder);
 void avifPrintVersions(void);
 void avifDumpDiagnostics(const avifDiagnostics * diag);
@@ -118,6 +120,16 @@
                                 avifAppSourceTiming * sourceTiming,
                                 struct y4mFrameIterator ** frameIter);
 
+// Determines only the metadata available before pixel decoding starts (currently width, height,
+// depth, yuvFormat and, for JPEG/PNG, color profile information) for an image file, without
+// decoding any pixel data.
+// If 'inputFormat' is AVIF_APP_FILE_FORMAT_UNKNOWN, the image format is guessed
+// based on the filename or first few bytes.
+// Returns the format of the file, or AVIF_APP_FILE_FORMAT_UNKNOWN in case of error.
+// Note: This function reuses the code that reads an image. The current user of this function only
+// uses the width and height reported. Double check first when using the other info returned.
+avifAppFileFormat avifPeekImage(const char * filename, avifAppFileFormat inputFormat, avifImage * image);
+
 // Copies all the bytes from the file at filename to a newly allocated memory chunk.
 avifBool avifReadEntireFile(const char * filename, avifRWData * raw);
 
diff --git a/apps/shared/y4m.c b/apps/shared/y4m.c
index 9a604ed..791aa82 100644
--- a/apps/shared/y4m.c
+++ b/apps/shared/y4m.c
@@ -253,12 +253,13 @@
             goto cleanup; \
     } while (0)
 
-avifBool y4mRead(const char * inputFilename,
-                 avifBool ignoreAlpha,
-                 uint32_t imageSizeLimit,
-                 avifImage * avif,
-                 avifAppSourceTiming * sourceTiming,
-                 struct y4mFrameIterator ** iter)
+static avifBool y4mReadInternal(const char * inputFilename,
+                                avifBool ignoreAlpha,
+                                uint32_t imageSizeLimit,
+                                avifBool headerOnly,
+                                avifImage * avif,
+                                avifAppSourceTiming * sourceTiming,
+                                struct y4mFrameIterator ** iter)
 {
     avifBool result = AVIF_FALSE;
 
@@ -412,6 +413,14 @@
     avif->yuvFormat = frame.format;
     avif->yuvRange = frame.range;
     avif->yuvChromaSamplePosition = frame.chromaSamplePosition;
+
+    if (headerOnly) {
+        // All the metadata (dimensions, depth, format, range, chroma sample position) is already
+        // known. Stop here instead of reading any frame data.
+        result = AVIF_TRUE;
+        goto cleanup;
+    }
+
     avifResult allocationResult = avifImageAllocatePlanes(avif, frame.hasAlpha ? AVIF_PLANES_ALL : AVIF_PLANES_YUV);
     if (allocationResult != AVIF_RESULT_OK) {
         fprintf(stderr, "Failed to allocate the planes: %s\n", avifResultToString(allocationResult));
@@ -478,6 +487,27 @@
     return result;
 }
 
+avifBool y4mRead(const char * inputFilename,
+                 avifBool ignoreAlpha,
+                 uint32_t imageSizeLimit,
+                 avifImage * avif,
+                 avifAppSourceTiming * sourceTiming,
+                 struct y4mFrameIterator ** iter)
+{
+    return y4mReadInternal(inputFilename, ignoreAlpha, imageSizeLimit, /*headerOnly=*/AVIF_FALSE, avif, sourceTiming, iter);
+}
+
+avifBool y4mPeek(const char * inputFilename, avifImage * avif)
+{
+    return y4mReadInternal(inputFilename,
+                           /*ignoreAlpha=*/AVIF_TRUE,
+                           /*imageSizeLimit=*/UINT32_MAX,
+                           /*headerOnly=*/AVIF_TRUE,
+                           avif,
+                           /*sourceTiming=*/NULL,
+                           /*iter=*/NULL);
+}
+
 avifBool y4mWrite(const char * outputFilename, const avifImage * avif)
 {
     avifBool hasAlpha = (avif->alphaPlane != NULL) && (avif->alphaRowBytes > 0);
diff --git a/apps/shared/y4m.h b/apps/shared/y4m.h
index bf9d645..4b4630e 100644
--- a/apps/shared/y4m.h
+++ b/apps/shared/y4m.h
@@ -24,6 +24,11 @@
                  avifImage * avif,
                  avifAppSourceTiming * sourceTiming,
                  struct y4mFrameIterator ** iter);
+
+// Parse the y4m file at path 'inputFilename' and write its metadata into 'avif'
+// without decoding the pixels.
+avifBool y4mPeek(const char * inputFilename, avifImage * avif);
+
 avifBool y4mWrite(const char * outputFilename, const avifImage * avif);
 
 #ifdef __cplusplus
diff --git a/include/avif/avif.h b/include/avif/avif.h
index bd81044..92ea161 100644
--- a/include/avif/avif.h
+++ b/include/avif/avif.h
@@ -821,6 +821,12 @@
     // To encode any of these boxes, set the values in the associated box, then enable the flag in
     // transformFlags. On decode, only honor the values in boxes with the associated transform flag set.
     // These also apply to gainMap->image, if any.
+    //
+    // When encoding with avifEncoder.width/height set (see their comment), these transformations
+    // are interpreted relative to that size rather than to the current layer's own
+    // width/height. No special handling is needed during decode: the decoded layer is
+    // automatically scaled to the configured size, so these transformations are relative to the
+    // decoded avifImage's width/height as usual.
     avifTransformFlags transformFlags;
     avifPixelAspectRatioBox pasp;
     avifCleanApertureBox clap;
@@ -1582,6 +1588,7 @@
     avifBool autoTiling;
 
     // Up/down scaling of the image to perform before encoding.
+    // This cannot be used together with encoder->width / encoder->height.
     avifScalingMode scalingMode;
 
     // --------------------------------------------------------------------------------------------
@@ -1628,6 +1635,13 @@
 
     // Version 1.4.0 ends here. Add any new members after this line.
     // --------------------------------------------------------------------------------------------
+
+    // Only for layered image (extraLayerCount > 0), otherwise must be the default value 0.
+    // Declares the size of the encoded image beforehand, which shall be exactly the size of the
+    // last layer. This allows adding smaller images as earlier layers to avoid a wasted scaling
+    // round trip, or scale ratios that the encoder does not support via scalingMode.
+    uint32_t width;
+    uint32_t height;
 } avifEncoder;
 
 // Creates an encoder initialized with default settings values.
diff --git a/src/codec_aom.c b/src/codec_aom.c
index ec4a50a..dd6205a 100644
--- a/src/codec_aom.c
+++ b/src/codec_aom.c
@@ -871,6 +871,8 @@
         cfg->g_input_bit_depth = image->depth;
         cfg->g_w = image->width;
         cfg->g_h = image->height;
+        cfg->g_forced_max_frame_width = encoder->width;
+        cfg->g_forced_max_frame_height = encoder->height;
 
         // Detect the libaom v3.6.0 bug described in
         // https://crbug.com/aomedia/2871#c12. See the changes to
@@ -933,10 +935,30 @@
         if (disableLaggedOutput) {
             cfg->g_lag_in_frames = 0;
         }
+        if ((encoder->width || encoder->height) && (cfg->g_lag_in_frames > 1)) {
+            // aom_codec_enc_config_set() does not allow changing frame dimensions if
+            // g_lag_in_frames > 1.
+            cfg->g_lag_in_frames = 1;
+        }
         if (encoder->maxThreads > 1) {
             // libaom fails if cfg->g_threads is greater than 64 threads. See MAX_NUM_THREADS in
             // aom/aom_util/aom_thread.h.
             cfg->g_threads = AVIF_MIN(encoder->maxThreads, 64);
+
+            // Detect the libaom bug before v3.15.2 described in
+            // https://issues.oss-fuzz.com/issues/559019046. See the changes in
+            // https://aomedia-review.googlesource.com/c/aom/+/216921.
+            static const int aomVersion_3_15_2 = (3 << 16) | (15 << 8) | 2;
+            if (aom_codec_version() < aomVersion_3_15_2) {
+                // When creating extra worker threads during encoding (which can
+                // happen when the new frame is larger), libaom may skip
+                // allocating the pixel_gradient_info buffers needed by
+                // GOOD_QUALITY mode. Work around the bug by disabling
+                // multithreading.
+                if (aomUsage == AOM_USAGE_GOOD_QUALITY && (encoder->width || encoder->height)) {
+                    cfg->g_threads = 1;
+                }
+            }
         }
 
         // Encode alpha as 4:0:0.
@@ -1082,8 +1104,9 @@
     } else {
         avifBool dimensionsChanged = AVIF_FALSE;
         if ((cfg->g_w != image->width) || (cfg->g_h != image->height)) {
-            // We are not ready for dimension change for now.
-            return AVIF_RESULT_NOT_IMPLEMENTED;
+            cfg->g_w = image->width;
+            cfg->g_h = image->height;
+            dimensionsChanged = AVIF_TRUE;
         }
         if (alpha) {
             if (encoderChanges & (AVIF_ENCODER_CHANGE_MIN_QUANTIZER_ALPHA | AVIF_ENCODER_CHANGE_MAX_QUANTIZER_ALPHA)) {
diff --git a/src/codec_avm.c b/src/codec_avm.c
index 6222f7f..77b795a 100644
--- a/src/codec_avm.c
+++ b/src/codec_avm.c
@@ -444,6 +444,11 @@
                                       avifAddImageFlags addImageFlags,
                                       avifCodecEncodeOutput * output)
 {
+    // AVM does not support encoding a layered image.
+    if (encoder->width || encoder->height) {
+        return AVIF_RESULT_NOT_IMPLEMENTED;
+    }
+
     struct avm_codec_enc_cfg * cfg = &codec->internal->cfg;
     avifBool quantizerUpdated = AVIF_FALSE;
     const int quantizer = avmQualityToQuantizer(quality, image->depth);
diff --git a/src/codec_rav1e.c b/src/codec_rav1e.c
index 97c92be..7fc064e 100644
--- a/src/codec_rav1e.c
+++ b/src/codec_rav1e.c
@@ -82,8 +82,8 @@
         return AVIF_RESULT_NOT_IMPLEMENTED;
     }
 
-    // rav1e does not support encoding layered image.
-    if (encoder->extraLayerCount > 0) {
+    // rav1e does not support encoding a layered image.
+    if (encoder->width || encoder->height || encoder->extraLayerCount > 0) {
         return AVIF_RESULT_NOT_IMPLEMENTED;
     }
 
diff --git a/src/codec_svt.c b/src/codec_svt.c
index a76fb5b..395afc8 100644
--- a/src/codec_svt.c
+++ b/src/codec_svt.c
@@ -75,8 +75,8 @@
         }
     }
 
-    // SVT-AV1 does not support encoding layered image.
-    if (encoder->extraLayerCount > 0) {
+    // SVT-AV1 does not support encoding a layered image.
+    if (encoder->width || encoder->height || encoder->extraLayerCount > 0) {
         return AVIF_RESULT_NOT_IMPLEMENTED;
     }
 
diff --git a/src/write.c b/src/write.c
index 2070600..f6653d1 100644
--- a/src/write.c
+++ b/src/write.c
@@ -477,6 +477,45 @@
 
 static const avifScalingMode noScaling = { { 1, 1 }, { 1, 1 } };
 
+static avifBool avifEncoderSizeIsSet(const avifEncoder * encoder)
+{
+    return (encoder->width != 0) || (encoder->height != 0);
+}
+
+static avifBool avifScalingModeIsNoScaling(const avifScalingMode * scalingMode)
+{
+    return (scalingMode->horizontal.n == scalingMode->horizontal.d) && (scalingMode->vertical.n == scalingMode->vertical.d);
+}
+
+static avifBool avifImageHasEquivalentTransformProperties(const avifImage * lhs, const avifImage * rhs)
+{
+    const uint32_t lhsTransformFlags = lhs->transformFlags &
+                                       (AVIF_TRANSFORM_PASP | AVIF_TRANSFORM_CLAP | AVIF_TRANSFORM_IROT | AVIF_TRANSFORM_IMIR);
+    const uint32_t rhsTransformFlags = rhs->transformFlags &
+                                       (AVIF_TRANSFORM_PASP | AVIF_TRANSFORM_CLAP | AVIF_TRANSFORM_IROT | AVIF_TRANSFORM_IMIR);
+    if (lhsTransformFlags != rhsTransformFlags) {
+        return AVIF_FALSE;
+    }
+    if ((lhsTransformFlags & AVIF_TRANSFORM_PASP) &&
+        ((lhs->pasp.hSpacing != rhs->pasp.hSpacing) || (lhs->pasp.vSpacing != rhs->pasp.vSpacing))) {
+        return AVIF_FALSE;
+    }
+    if ((lhsTransformFlags & AVIF_TRANSFORM_CLAP) &&
+        ((lhs->clap.widthN != rhs->clap.widthN) || (lhs->clap.widthD != rhs->clap.widthD) ||
+         (lhs->clap.heightN != rhs->clap.heightN) || (lhs->clap.heightD != rhs->clap.heightD) ||
+         (lhs->clap.horizOffN != rhs->clap.horizOffN) || (lhs->clap.horizOffD != rhs->clap.horizOffD) ||
+         (lhs->clap.vertOffN != rhs->clap.vertOffN) || (lhs->clap.vertOffD != rhs->clap.vertOffD))) {
+        return AVIF_FALSE;
+    }
+    if ((lhsTransformFlags & AVIF_TRANSFORM_IROT) && (lhs->irot.angle != rhs->irot.angle)) {
+        return AVIF_FALSE;
+    }
+    if ((lhsTransformFlags & AVIF_TRANSFORM_IMIR) && (lhs->imir.axis != rhs->imir.axis)) {
+        return AVIF_FALSE;
+    }
+    return AVIF_TRUE;
+}
+
 avifEncoder * avifEncoderCreate(void)
 {
     avifEncoder * encoder = (avifEncoder *)avifAlloc(sizeof(avifEncoder));
@@ -511,6 +550,8 @@
     encoder->creationTime = 0;
     encoder->modificationTime = 0;
     encoder->sampleTransformRecipe = AVIF_SAMPLE_TRANSFORM_NONE;
+    encoder->width = 0;
+    encoder->height = 0;
     return encoder;
 }
 
@@ -554,6 +595,8 @@
     encoder->data->lastTileColsLog2 = encoder->data->tileColsLog2;
     lastEncoder->scalingMode = encoder->scalingMode;
     lastEncoder->sampleTransformRecipe = encoder->sampleTransformRecipe;
+    lastEncoder->width = encoder->width;
+    lastEncoder->height = encoder->height;
 }
 
 // This function detects changes made on avifEncoder. It returns true on success (i.e., if every
@@ -572,7 +615,8 @@
     if ((lastEncoder->codecChoice != encoder->codecChoice) || (lastEncoder->maxThreads != encoder->maxThreads) ||
         (lastEncoder->speed != encoder->speed) || (lastEncoder->keyframeInterval != encoder->keyframeInterval) ||
         (lastEncoder->timescale != encoder->timescale) || (lastEncoder->repetitionCount != encoder->repetitionCount) ||
-        (lastEncoder->extraLayerCount != encoder->extraLayerCount)) {
+        (lastEncoder->extraLayerCount != encoder->extraLayerCount) || (lastEncoder->width != encoder->width) ||
+        (lastEncoder->height != encoder->height)) {
         return AVIF_FALSE;
     }
 
@@ -1587,6 +1631,129 @@
     return avifCodecTypeFromChoice(encoder->codecChoice, AVIF_CODEC_FLAG_CAN_ENCODE);
 }
 
+static avifResult avifEncoderValidateSize(avifEncoder * encoder, uint32_t gridCols, uint32_t gridRows, const avifImage * firstCell)
+{
+    if (!avifEncoderSizeIsSet(encoder)) {
+        // First image, encoder->data->imageMetadata not initialized yet, nothing to check against.
+        if (encoder->data->items.count == 0) {
+            return AVIF_RESULT_OK;
+        }
+
+        // For animation, the encoder verifies the input size never changes, so this check is redundant.
+        // But for a layered image, the encoder relaxes the check to allow layers to have different sizes.
+        // We support 2 ways to produce different sized layers:
+        // 1. Send full sized inputs and let the encoder scale them via scalingMode
+        // 2. Declare the full size via width/height and send pre-scaled inputs
+        // To avoid confusion, we require the user to consistently use only one of the 2 ways,
+        // and this check blocks the attempt to start with method 1 and try to switch to method 2.
+        if ((firstCell->width != encoder->data->imageMetadata->width) || (firstCell->height != encoder->data->imageMetadata->height)) {
+            avifDiagnosticsPrintf(&encoder->diag, "All images must have the same width/height unless avifEncoder.width/height is set");
+            return AVIF_RESULT_INVALID_ARGUMENT;
+        }
+
+        // According to section 2.2.2 of AV1 Image File Format specification v1.2.0:
+        //   [...] the values of image_width and image_height shall respectively equal the values of
+        //   UpscaledWidth and FrameHeight as defined in [AV1] but for a specific frame in the item
+        //   payload. [...]
+        //   In the absence of a 'lsel' property associated with the item, or if it is present and its
+        //   layer_id value is set to 0xFFFF:
+        //     If no OperatingPointSelectorProperty is associated with the item, the 'ispe' property
+        //     shall document the dimensions of the last frame decoded when processing the operating
+        //     point whose index is 0.
+        //   NOTE: The dimensions of possible intermediate output images might not match the ones given
+        //   in the 'ispe' property. If renderers display these intermediate images, they are expected
+        //   to scale the output image to match the 'ispe' property.
+        // See https://aomediacodec.github.io/av1-avif/v1.2.0.html#image-spatial-extents-property.
+        //
+        // Therefore the last layer must not have any scaling.
+        if ((encoder->data->frames.count == encoder->extraLayerCount) && !avifScalingModeIsNoScaling(&encoder->scalingMode)) {
+            avifDiagnosticsPrintf(&encoder->diag,
+                                  "The last layer must not be scaled, but got scalingMode=(%d/%d, %d/%d)",
+                                  encoder->scalingMode.horizontal.n,
+                                  encoder->scalingMode.horizontal.d,
+                                  encoder->scalingMode.vertical.n,
+                                  encoder->scalingMode.vertical.d);
+            return AVIF_RESULT_INVALID_ARGUMENT;
+        }
+        return AVIF_RESULT_OK;
+    }
+
+    if ((encoder->width == 0) || (encoder->height == 0)) {
+        avifDiagnosticsPrintf(&encoder->diag, "avifEncoder.width and avifEncoder.height must either both be zero or both be nonzero");
+        return AVIF_RESULT_INVALID_ARGUMENT;
+    }
+
+    if ((gridCols > 1) || (gridRows > 1)) {
+        avifDiagnosticsPrintf(&encoder->diag, "avifEncoder.width/height cannot be set with grid images");
+        return AVIF_RESULT_NOT_IMPLEMENTED;
+    }
+
+    // This blocks the attempt to use both ways to produce different sized layers together,
+    // or start with method 2 and try to switch to method 1,
+    // so the result is INVALID_ARGUMENT. See the comment above for the detail.
+    if (!avifScalingModeIsNoScaling(&encoder->scalingMode)) {
+        avifDiagnosticsPrintf(&encoder->diag, "avifEncoder.width/height cannot be set together with encoder->scalingMode");
+        return AVIF_RESULT_INVALID_ARGUMENT;
+    }
+
+    if (encoder->sampleTransformRecipe != AVIF_SAMPLE_TRANSFORM_NONE) {
+        avifDiagnosticsPrintf(&encoder->diag, "avifEncoder.width/height cannot be set with sample transforms");
+        return AVIF_RESULT_NOT_IMPLEMENTED;
+    }
+
+    if (firstCell->gainMap && firstCell->gainMap->image) {
+        avifDiagnosticsPrintf(&encoder->diag, "avifEncoder.width/height cannot be set with gain maps");
+        return AVIF_RESULT_NOT_IMPLEMENTED;
+    }
+
+    // These 3 checks below are based on section 2.2.2 of AV1 Image File Format specification v1.2.0.
+    // See the comment above for the detail.
+    // Only a layered image can have frames of different sizes, so reject otherwise.
+    if (encoder->extraLayerCount == 0) {
+        avifDiagnosticsPrintf(&encoder->diag, "avifEncoder.width/height can only be set for layered images (extraLayerCount > 0)");
+        return AVIF_RESULT_INVALID_ARGUMENT;
+    }
+
+    // The spec allows arbitrary sizes. We tighten the rule to "earlier layers shall be smaller" due to encoder restrictions.
+    if ((encoder->width < firstCell->width) || (encoder->height < firstCell->height)) {
+        avifDiagnosticsPrintf(&encoder->diag,
+                              "avifEncoder.width/height %ux%u must be at least the coded image size %ux%u",
+                              encoder->width,
+                              encoder->height,
+                              firstCell->width,
+                              firstCell->height);
+        return AVIF_RESULT_INCOMPATIBLE_IMAGE;
+    }
+
+    // The declared width/height must exactly match the coded size of the last layer.
+    if ((encoder->data->frames.count == encoder->extraLayerCount) &&
+        ((encoder->width != firstCell->width) || (encoder->height != firstCell->height))) {
+        avifDiagnosticsPrintf(&encoder->diag,
+                              "avifEncoder.width/height %ux%u must exactly match the coded size %ux%u of the last layer",
+                              encoder->width,
+                              encoder->height,
+                              firstCell->width,
+                              firstCell->height);
+        return AVIF_RESULT_INCOMPATIBLE_IMAGE;
+    }
+
+    if (firstCell->transformFlags & AVIF_TRANSFORM_CLAP) {
+        avifCropRect cropRect;
+        if (!avifCropRectFromCleanApertureBox(&cropRect, &firstCell->clap, encoder->width, encoder->height, &encoder->diag)) {
+            return AVIF_RESULT_INVALID_ARGUMENT;
+        }
+    }
+
+    if ((encoder->data->items.count > 0) && (encoder->extraLayerCount > 0) &&
+        !avifImageHasEquivalentTransformProperties(firstCell, encoder->data->imageMetadata)) {
+        avifDiagnosticsPrintf(&encoder->diag,
+                              "When avifEncoder.width/height is set, 'pasp', 'clap', 'irot' and 'imir' must match across layers");
+        return AVIF_RESULT_INCOMPATIBLE_IMAGE;
+    }
+
+    return AVIF_RESULT_OK;
+}
+
 // This function is called after every color frame is encoded. It returns AVIF_TRUE if a keyframe needs to be forced for the next
 // alpha frame to be encoded, AVIF_FALSE otherwise.
 static avifBool avifEncoderDataShouldForceKeyframeForAlpha(const avifEncoderData * data,
@@ -1769,6 +1936,8 @@
         return AVIF_RESULT_NO_CONTENT;
     }
 
+    AVIF_CHECKRES(avifEncoderValidateSize(encoder, gridCols, gridRows, firstCell));
+
     AVIF_CHECKRES(avifValidateGrid(gridCols, gridRows, cellImages, /*validateGainMap=*/AVIF_FALSE, &encoder->diag));
 
     const avifBool hasGainMap = (firstCell->gainMap && firstCell->gainMap->image != NULL);
@@ -1822,7 +1991,7 @@
         encoder->data->singleImage = AVIF_TRUE;
 
         if (encoder->extraLayerCount > 0) {
-            // AVIF_ADD_IMAGE_FLAG_SINGLE may not be set for layered image.
+            // AVIF_ADD_IMAGE_FLAG_SINGLE may not be set for a layered image.
             return AVIF_RESULT_INVALID_ARGUMENT;
         }
 
@@ -1899,6 +2068,10 @@
     if (encoder->data->items.count == 0) {
         // Make a copy of the first image's metadata (sans pixels) for future writing/validation
         AVIF_CHECKRES(avifImageCopy(encoder->data->imageMetadata, firstCell, 0));
+        if (avifEncoderSizeIsSet(encoder)) {
+            encoder->data->imageMetadata->width = encoder->width;
+            encoder->data->imageMetadata->height = encoder->height;
+        }
 
         const uint32_t gridWidth = avifGridWidth(gridCols, firstCell, bottomRightCell);
         const uint32_t gridHeight = avifGridHeight(gridRows, firstCell, bottomRightCell);
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 96ca5d7..8a3dd79 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -220,6 +220,7 @@
     add_avif_fuzztest(avif_fuzztest_dec_incr gtest/avifincrtest_helpers.cc)
     add_avif_fuzztest(avif_fuzztest_enc_dec)
     add_avif_fuzztest(avif_fuzztest_enc_dec_anim)
+    add_avif_fuzztest(avif_fuzztest_enc_dec_layered)
     add_avif_fuzztest(avif_fuzztest_enc_dec_incr gtest/avifincrtest_helpers.cc)
     add_avif_fuzztest(avif_fuzztest_properties)
     add_avif_fuzztest(avif_fuzztest_read_image)
diff --git a/tests/data/kodim03_yuv420_8bpc_384x256.y4m b/tests/data/kodim03_yuv420_8bpc_384x256.y4m
new file mode 100644
index 0000000..3301162
--- /dev/null
+++ b/tests/data/kodim03_yuv420_8bpc_384x256.y4m
Binary files differ
diff --git a/tests/gtest/avif_fuzztest_enc_dec_layered.cc b/tests/gtest/avif_fuzztest_enc_dec_layered.cc
new file mode 100644
index 0000000..ddc2eb0
--- /dev/null
+++ b/tests/gtest/avif_fuzztest_enc_dec_layered.cc
@@ -0,0 +1,217 @@
+// Copyright 2026 Google LLC
+// SPDX-License-Identifier: BSD-2-Clause
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+#include "avif/avif.h"
+#include "avif_fuzztest_helpers.h"
+#include "aviftest_helpers.h"
+#include "fuzztest/fuzztest.h"
+#include "gtest/gtest.h"
+
+namespace avif {
+namespace testutil {
+namespace {
+
+constexpr size_t kLayerCount = kMaxNumLayers;
+
+constexpr avifFraction kNoScale = {1, 1};
+constexpr size_t kRandomScalingModeCount = kLayerCount - 1;
+static_assert(kRandomScalingModeCount == 3);
+constexpr std::array<avifFraction, 6> kSupportedScalingModes = {
+    avifFraction{1, 8}, avifFraction{1, 4}, avifFraction{1, 2},
+    avifFraction{3, 5}, avifFraction{3, 4}, avifFraction{4, 5}};
+constexpr avifScalingMode kNoScalingMode = {kNoScale, kNoScale};
+constexpr std::array<avifScalingMode, kLayerCount> kNoScalingModes = {
+    kNoScalingMode, kNoScalingMode, kNoScalingMode, kNoScalingMode};
+
+constexpr avifScalingMode MakeScalingMode(avifFraction horizontal,
+                                          avifFraction vertical) {
+  return {horizontal, vertical};
+}
+
+constexpr size_t BinomialCoefficient(size_t n, size_t k) {
+  if (k > n) {
+    return 0;
+  }
+  if (k > (n - k)) {
+    k = n - k;
+  }
+  size_t coefficient = 1;
+  for (size_t i = 1; i <= k; ++i) {
+    coefficient = (coefficient * (n - k + i)) / i;
+  }
+  return coefficient;
+}
+
+constexpr size_t CombinationCountWithRepetition(size_t value_count,
+                                                size_t pick_count) {
+  return BinomialCoefficient(value_count + pick_count - 1, pick_count);
+}
+
+constexpr size_t kScalingModeCombinationCount = CombinationCountWithRepetition(
+    kSupportedScalingModes.size(), kRandomScalingModeCount);
+
+std::array<avifFraction, kRandomScalingModeCount> GetScalingModeCombination(
+    size_t combination_index) {
+  std::array<avifFraction, kRandomScalingModeCount> combination = {};
+  size_t remaining_index = combination_index;
+  size_t next_candidate = 0;
+  for (size_t slot = 0; slot < combination.size(); ++slot) {
+    const size_t remaining_slots = combination.size() - slot - 1;
+    for (size_t candidate = next_candidate;
+         candidate < kSupportedScalingModes.size(); ++candidate) {
+      const size_t combinations_with_candidate = CombinationCountWithRepetition(
+          kSupportedScalingModes.size() - candidate, remaining_slots);
+      if (remaining_index < combinations_with_candidate) {
+        combination[slot] = kSupportedScalingModes[candidate];
+        next_candidate = candidate;
+        break;
+      }
+      remaining_index -= combinations_with_candidate;
+    }
+  }
+  return combination;
+}
+
+std::array<avifScalingMode, kLayerCount> MakeRandomScalingModes(
+    int horizontal_combination_index, int vertical_combination_index) {
+  const auto horizontal_combination =
+      GetScalingModeCombination(horizontal_combination_index);
+  const auto vertical_combination =
+      GetScalingModeCombination(vertical_combination_index);
+  return std::array<avifScalingMode, kLayerCount>{
+      MakeScalingMode(horizontal_combination[0], vertical_combination[0]),
+      MakeScalingMode(horizontal_combination[1], vertical_combination[1]),
+      MakeScalingMode(horizontal_combination[2], vertical_combination[2]),
+      kNoScalingMode};
+}
+
+inline auto ArbitraryScalingModes() {
+  constexpr int kMaxCombinationIndex =
+      static_cast<int>(kScalingModeCombinationCount - 1);
+  return fuzztest::Map(MakeRandomScalingModes,
+                       fuzztest::InRange<int>(0, kMaxCombinationIndex),
+                       fuzztest::InRange<int>(0, kMaxCombinationIndex));
+}
+
+void EncodeDecodeLayered(
+    std::vector<ImagePtr> layers,
+    const std::array<avifScalingMode, kLayerCount>& scaling_modes,
+    uint32_t expected_width, uint32_t expected_height, bool set_last_layer_size,
+    EncoderPtr encoder, DecoderPtr decoder) {
+  ASSERT_EQ(layers.size(), kLayerCount);
+  ASSERT_NE(encoder, nullptr);
+  ASSERT_NE(decoder, nullptr);
+
+  if (avifCodecName(AVIF_CODEC_CHOICE_AOM, AVIF_CODEC_FLAG_CAN_ENCODE) ==
+      nullptr) {
+    return;
+  }
+  if (avifLibYUVVersion() == 0) {
+    return;
+  }
+
+  const avifImage* const reference = layers.front().get();
+  ASSERT_NE(reference, nullptr);
+
+  encoder->codecChoice = AVIF_CODEC_CHOICE_AOM;
+  encoder->extraLayerCount = static_cast<uint32_t>(layers.size() - 1);
+  if (set_last_layer_size) {
+    encoder->width = expected_width;
+    encoder->height = expected_height;
+  }
+
+  for (size_t i = 0; i < layers.size(); ++i) {
+    ASSERT_NE(layers[i].get(), nullptr);
+    encoder->scalingMode = scaling_modes[i];
+    const avifResult result = avifEncoderAddImage(
+        encoder.get(), layers[i].get(),
+        /*durationInTimescales=*/1, AVIF_ADD_IMAGE_FLAG_NONE);
+    ASSERT_EQ(result, AVIF_RESULT_OK)
+        << " layer " << i << ": " << avifResultToString(result) << ": "
+        << encoder->diag.error;
+  }
+
+  AvifRwData encoded_data;
+  avifResult result = avifEncoderFinish(encoder.get(), &encoded_data);
+  ASSERT_EQ(result, AVIF_RESULT_OK)
+      << avifResultToString(result) << ": " << encoder->diag.error;
+
+  result = avifDecoderSetIOMemory(decoder.get(), encoded_data.data,
+                                  encoded_data.size);
+  ASSERT_EQ(result, AVIF_RESULT_OK)
+      << avifResultToString(result) << ": " << decoder->diag.error;
+
+  result = avifDecoderParse(decoder.get());
+  ASSERT_EQ(result, AVIF_RESULT_OK)
+      << avifResultToString(result) << ": " << decoder->diag.error;
+
+  const int num_decodes =
+      decoder->allowProgressive ? static_cast<int>(layers.size()) : 1;
+  if (decoder->allowProgressive) {
+    EXPECT_EQ(decoder->progressiveState, AVIF_PROGRESSIVE_STATE_ACTIVE);
+    ASSERT_EQ(decoder->imageCount, static_cast<int>(layers.size()));
+  } else {
+    EXPECT_EQ(decoder->progressiveState, AVIF_PROGRESSIVE_STATE_AVAILABLE);
+    ASSERT_EQ(decoder->imageCount, 1);
+  }
+
+  for (int i = 0; i < num_decodes; ++i) {
+    result = avifDecoderNextImage(decoder.get());
+    ASSERT_EQ(result, AVIF_RESULT_OK)
+        << " layer " << i << ": " << avifResultToString(result) << ": "
+        << decoder->diag.error;
+    EXPECT_EQ(decoder->image->width, expected_width);
+    EXPECT_EQ(decoder->image->height, expected_height);
+    EXPECT_EQ(decoder->image->depth, reference->depth);
+    EXPECT_EQ(decoder->image->yuvFormat, reference->yuvFormat);
+  }
+  result = avifDecoderNextImage(decoder.get());
+  ASSERT_EQ(result, AVIF_RESULT_NO_IMAGES_REMAINING)
+      << avifResultToString(result) << ": " << decoder->diag.error;
+}
+
+void EncodeDecodeDimensionChange(
+    std::vector<ImagePtr> layers,
+    const std::array<avifScalingMode, kLayerCount>& scaling_modes,
+    EncoderPtr encoder, DecoderPtr decoder) {
+  ASSERT_EQ(layers.size(), kLayerCount);
+  ASSERT_NE(layers.back().get(), nullptr);
+  const uint32_t expected_width = layers.back()->width;
+  const uint32_t expected_height = layers.back()->height;
+  EncodeDecodeLayered(std::move(layers), scaling_modes,
+                      /*expected_width=*/expected_width,
+                      /*expected_height=*/expected_height,
+                      /*set_last_layer_size=*/false, std::move(encoder),
+                      std::move(decoder));
+}
+
+void EncodeDecodeDimensionChangeExternal(std::vector<ImagePtr> layers,
+                                         EncoderPtr encoder,
+                                         DecoderPtr decoder) {
+  ASSERT_EQ(layers.size(), kLayerCount);
+  ASSERT_NE(layers.back().get(), nullptr);
+  const uint32_t expected_width = layers.back()->width;
+  const uint32_t expected_height = layers.back()->height;
+  EncodeDecodeLayered(std::move(layers), kNoScalingModes,
+                      /*expected_width=*/expected_width,
+                      /*expected_height=*/expected_height,
+                      /*set_last_layer_size=*/true, std::move(encoder),
+                      std::move(decoder));
+}
+
+FUZZ_TEST(LayeredEncodeDecodeAvifFuzzTest, EncodeDecodeDimensionChange)
+    .WithDomains(ArbitraryAvifLayered(), ArbitraryScalingModes(),
+                 ArbitraryAvifEncoder(), ArbitraryAvifDecoder());
+
+FUZZ_TEST(LayeredEncodeDecodeAvifFuzzTest, EncodeDecodeDimensionChangeExternal)
+    .WithDomains(ArbitraryAvifLayeredRandDim(), ArbitraryAvifEncoder(),
+                 ArbitraryAvifDecoder());
+
+}  // namespace
+}  // namespace testutil
+}  // namespace avif
diff --git a/tests/gtest/avif_fuzztest_helpers.cc b/tests/gtest/avif_fuzztest_helpers.cc
index 95d7693..e73ab73 100644
--- a/tests/gtest/avif_fuzztest_helpers.cc
+++ b/tests/gtest/avif_fuzztest_helpers.cc
@@ -4,6 +4,7 @@
 #include "avif_fuzztest_helpers.h"
 
 #include <algorithm>
+#include <array>
 #include <cassert>
 #include <cstdint>
 #include <cstdlib>
@@ -22,6 +23,27 @@
 
 //------------------------------------------------------------------------------
 
+constexpr size_t kNumLayeredRandDimSeeds = 2 * (kMaxNumLayers - 1);
+
+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);
+  std::array<std::pair<size_t, size_t>, kMaxNumLayers> sizes = {};
+  for (size_t i = 0; i + 1 < kMaxNumLayers; ++i) {
+    const size_t width =
+        1 + (static_cast<size_t>(seeds[2 * i]) % (display_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);
+    sizes[i] = {width, height};
+  }
+  sizes.back() = {display_width, display_height};
+  return sizes;
+}
+
 ImagePtr CreateAvifImage(size_t width, size_t height, int depth,
                          avifPixelFormat pixel_format, bool has_alpha,
                          const uint8_t* samples) {
@@ -104,6 +126,76 @@
   return frames;
 }
 
+std::vector<ImagePtr> CreateAvifLayered8b(size_t width, size_t height,
+                                          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;
+}
+
+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;
+}
+
+size_t GetNumSamplesLayeredRandDim(size_t display_width, size_t display_height,
+                                   avifPixelFormat pixel_format,
+                                   bool has_alpha) {
+  return kNumLayeredRandDimSeeds + GetNumSamples(kMaxNumLayers, display_width,
+                                                 display_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) {
+  assert(samples.size() >= kNumLayeredRandDimSeeds);
+  const auto dims =
+      GetAvifLayeredRandDims(display_width, display_height, samples.data());
+  std::vector<ImagePtr> layers;
+  layers.reserve(kMaxNumLayers);
+
+  size_t offset = kNumLayeredRandDimSeeds;
+  for (const auto& [width, height] : dims) {
+    const size_t num_samples = GetNumSamples(
+        /*num_frames=*/1, width, height, pixel_format, has_alpha);
+    layers.push_back(CreateAvifImage8b(
+        width, height, pixel_format, has_alpha,
+        std::vector<uint8_t>(samples.begin() + offset,
+                             samples.begin() + offset + num_samples)));
+    offset += num_samples;
+  }
+  return layers;
+}
+
+std::vector<ImagePtr> CreateAvifLayeredRandDim16b(
+    size_t display_width, size_t display_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());
+  std::vector<ImagePtr> layers;
+  layers.reserve(kMaxNumLayers);
+
+  size_t offset = kNumLayeredRandDimSeeds;
+  for (const auto& [width, height] : dims) {
+    const size_t num_samples = GetNumSamples(
+        /*num_frames=*/1, width, height, pixel_format, has_alpha);
+    layers.push_back(CreateAvifImage16b(
+        width, height, depth, pixel_format, has_alpha,
+        std::vector<uint16_t>(samples.begin() + offset,
+                              samples.begin() + offset + num_samples)));
+    offset += num_samples;
+  }
+  return layers;
+}
+
 EncoderPtr CreateAvifEncoder(avifCodecChoice codec_choice, int max_threads,
                              int quality, int quality_alpha, int tile_rows_log2,
                              int tile_cols_log2, int speed) {
diff --git a/tests/gtest/avif_fuzztest_helpers.h b/tests/gtest/avif_fuzztest_helpers.h
index 6a8fbf5..849f368 100644
--- a/tests/gtest/avif_fuzztest_helpers.h
+++ b/tests/gtest/avif_fuzztest_helpers.h
@@ -58,6 +58,20 @@
                                         avifPixelFormat pixel_format,
                                         bool has_alpha,
                                         const std::vector<uint16_t>& samples);
+std::vector<ImagePtr> CreateAvifLayered8b(size_t width, size_t height,
+                                          avifPixelFormat pixel_format,
+                                          bool has_alpha,
+                                          const std::vector<uint8_t>& 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> CreateAvifLayeredRandDim8b(
+    size_t display_width, size_t display_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,
+    avifPixelFormat pixel_format, bool has_alpha,
+    const std::vector<uint16_t>& samples);
 EncoderPtr CreateAvifEncoder(avifCodecChoice codec_choice, int max_threads,
                              int quality, int quality_alpha, int tile_rows_log2,
                              int tile_cols_log2, int speed);
@@ -84,9 +98,14 @@
 // Do not generate animations with more than this number of frames.
 inline constexpr size_t kMaxNumFrames =
     kMaxNumFramesSquareRoot * kMaxNumFramesSquareRoot;
+// Do not generate layered images with more than this number of layers.
+inline constexpr size_t kMaxNumLayers = AVIF_MAX_AV1_LAYER_COUNT;
 
 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,
+                                   avifPixelFormat pixel_format,
+                                   bool has_alpha);
 
 // To avoid using fuzztest::internal, the return type of the functions below is
 // auto.
@@ -186,6 +205,107 @@
   return fuzztest::OneOf(ArbitraryAvifAnim8b(), ArbitraryAvifAnim16b());
 }
 
+// Layered avifImage generator type: fixed number of layers, same width/height,
+// pixel format and 8-bit samples.
+inline auto ArbitraryAvifLayered8b() {
+  constexpr uint16_t kMinLayerDimension = 8;
+  constexpr uint16_t kMaxLayerDimension =
+      kMaxDimension / kMaxNumFramesSquareRoot;
+  return fuzztest::FlatMap(
+      [](size_t width, size_t height, avifPixelFormat pixel_format,
+         bool has_alpha) {
+        return fuzztest::Map(
+            CreateAvifLayered8b, fuzztest::Just(width), fuzztest::Just(height),
+            fuzztest::Just(pixel_format), fuzztest::Just(has_alpha),
+            fuzztest::Arbitrary<std::vector<uint8_t>>().WithSize(GetNumSamples(
+                kMaxNumLayers, width, height, pixel_format, has_alpha)));
+      },
+      fuzztest::InRange<uint16_t>(kMinLayerDimension, kMaxLayerDimension),
+      fuzztest::InRange<uint16_t>(kMinLayerDimension, kMaxLayerDimension),
+      ArbitraryPixelFormat(), fuzztest::Arbitrary<bool>());
+}
+
+// Layered avifImage generator type: fixed number of layers, same width/height,
+// depth, pixel format and 16-bit samples.
+inline auto ArbitraryAvifLayered16b() {
+  constexpr uint16_t kMinLayerDimension = 8;
+  constexpr uint16_t kMaxLayerDimension =
+      kMaxDimension / kMaxNumFramesSquareRoot;
+  return fuzztest::FlatMap(
+      [](size_t width, size_t height, int depth, avifPixelFormat pixel_format,
+         bool has_alpha) {
+        return fuzztest::Map(
+            CreateAvifLayered16b, fuzztest::Just(width), fuzztest::Just(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(GetNumSamples(kMaxNumLayers, width, height,
+                                        pixel_format, has_alpha)));
+      },
+      fuzztest::InRange<uint16_t>(kMinLayerDimension, kMaxLayerDimension),
+      fuzztest::InRange<uint16_t>(kMinLayerDimension, kMaxLayerDimension),
+      fuzztest::ElementOf({10, 12}), ArbitraryPixelFormat(),
+      fuzztest::Arbitrary<bool>());
+}
+
+// Generator for an arbitrary layered still image with same-sized layers.
+inline auto ArbitraryAvifLayered() {
+  return fuzztest::OneOf(ArbitraryAvifLayered8b(), ArbitraryAvifLayered16b());
+}
+
+// Layered avifImage generator type: fixed number of layers, display 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,
+         avifPixelFormat pixel_format, bool has_alpha) {
+        return fuzztest::Map(
+            CreateAvifLayeredRandDim8b, fuzztest::Just(display_width),
+            fuzztest::Just(display_height), fuzztest::Just(pixel_format),
+            fuzztest::Just(has_alpha),
+            fuzztest::Arbitrary<std::vector<uint8_t>>().WithSize(
+                GetNumSamplesLayeredRandDim(display_width, display_height,
+                                            pixel_format, has_alpha)));
+      },
+      fuzztest::InRange<uint16_t>(kMinLayerDimension, kMaxLayerDimension),
+      fuzztest::InRange<uint16_t>(kMinLayerDimension, kMaxLayerDimension),
+      ArbitraryPixelFormat(), fuzztest::Arbitrary<bool>());
+}
+
+// Layered avifImage generator type: fixed number of layers, display 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,
+         avifPixelFormat pixel_format, bool has_alpha) {
+        return fuzztest::Map(
+            CreateAvifLayeredRandDim16b, fuzztest::Just(display_width),
+            fuzztest::Just(display_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)));
+      },
+      fuzztest::InRange<uint16_t>(kMinLayerDimension, kMaxLayerDimension),
+      fuzztest::InRange<uint16_t>(kMinLayerDimension, kMaxLayerDimension),
+      fuzztest::ElementOf({10, 12}), ArbitraryPixelFormat(),
+      fuzztest::Arbitrary<bool>());
+}
+
+// Generator for an arbitrary layered still image with display size override.
+inline auto ArbitraryAvifLayeredRandDim() {
+  return fuzztest::OneOf(ArbitraryAvifLayeredRandDim8b(),
+                         ArbitraryAvifLayeredRandDim16b());
+}
+
 // Generates two signed fractions where the first one is smaller than or equal
 // to the second one.
 inline auto ArbitraryMinMaxSignedFraction() {
diff --git a/tests/gtest/avifchangesettingtest.cc b/tests/gtest/avifchangesettingtest.cc
index 485a87b..de4ffe4 100644
--- a/tests/gtest/avifchangesettingtest.cc
+++ b/tests/gtest/avifchangesettingtest.cc
@@ -241,6 +241,42 @@
             AVIF_RESULT_INCOMPATIBLE_IMAGE);
 }
 
+TEST(ChangeSettingTest, UnchangeableEncoderSize) {
+  if (avifCodecName(AVIF_CODEC_CHOICE_AOM, AVIF_CODEC_FLAG_CAN_ENCODE) ==
+      nullptr) {
+    GTEST_SKIP() << "Codec unavailable, skip test.";
+  }
+
+  ImagePtr image = testutil::CreateImage(/*width=*/64, /*height=*/64,
+                                         /*depth=*/8, AVIF_PIXEL_FORMAT_YUV444,
+                                         AVIF_PLANES_YUV, AVIF_RANGE_FULL);
+  ASSERT_NE(image, nullptr);
+  testutil::FillImageGradient(image.get());
+
+  EncoderPtr encoder(avifEncoderCreate());
+  ASSERT_NE(encoder, nullptr);
+  encoder->codecChoice = AVIF_CODEC_CHOICE_AOM;
+  encoder->speed = AVIF_SPEED_FASTEST;
+  encoder->extraLayerCount = 1;
+  encoder->width = 128;
+  encoder->height = 128;
+
+  ASSERT_EQ(avifEncoderAddImage(encoder.get(), image.get(), 1,
+                                AVIF_ADD_IMAGE_FLAG_NONE),
+            AVIF_RESULT_OK);
+
+  ImagePtr image2 = testutil::CreateImage(/*width=*/256, /*height=*/128,
+                                          /*depth=*/8, AVIF_PIXEL_FORMAT_YUV444,
+                                          AVIF_PLANES_YUV, AVIF_RANGE_FULL);
+  ASSERT_NE(image2, nullptr);
+  testutil::FillImageGradient(image2.get());
+
+  encoder->width = 256;
+  ASSERT_EQ(avifEncoderAddImage(encoder.get(), image2.get(), 1,
+                                AVIF_ADD_IMAGE_FLAG_NONE),
+            AVIF_RESULT_CANNOT_CHANGE_SETTING);
+}
+
 void EncodeAnimation(const char* key, const char* value_before_first_frame,
                      const char* value_after_first_frame,
                      const char* value_before_second_frame,
diff --git a/tests/gtest/avifprogressivetest.cc b/tests/gtest/avifprogressivetest.cc
index 3071b56..641a9d9 100644
--- a/tests/gtest/avifprogressivetest.cc
+++ b/tests/gtest/avifprogressivetest.cc
@@ -129,7 +129,7 @@
 //   `ms_params->ms_buffers.ref->stride == ms_params->search_sites->stride'
 //   failed.
 // See https://aomedia.googlesource.com/aom/+/945edd671.
-TEST_F(ProgressiveTest, DimensionChange) {
+TEST_F(ProgressiveTest, ResolutionChange) {
   if (avifLibYUVVersion() == 0) {
     GTEST_SKIP() << "libyuv not available, skip test.";
   }
@@ -152,7 +152,7 @@
   TestDecode(kImageSize, kImageSize);
 }
 
-TEST_F(ProgressiveTest, DimensionChangeWithAlpha) {
+TEST_F(ProgressiveTest, ResolutionChangeWithAlpha) {
   if (avifLibYUVVersion() == 0) {
     GTEST_SKIP() << "libyuv not available, skip test.";
   }
@@ -187,6 +187,112 @@
   TestDecode(kImageSize, kImageSize, /*expect_alpha=*/true);
 }
 
+TEST_F(ProgressiveTest, ResolutionChangeExternal) {
+  encoder_->extraLayerCount = 1;
+  encoder_->width = kImageSize;
+  encoder_->height = kImageSize;
+
+  const auto smallImage = testutil::CreateImage(
+      kImageSize / 2, kImageSize / 2, 8, AVIF_PIXEL_FORMAT_YUV444,
+      AVIF_PLANES_YUV, AVIF_RANGE_FULL);
+  ASSERT_NE(smallImage, nullptr);
+  testutil::FillImageGradient(smallImage.get(), /*offset=*/17);
+
+  ASSERT_EQ(avifEncoderAddImage(encoder_.get(), smallImage.get(), 1,
+                                AVIF_ADD_IMAGE_FLAG_NONE),
+            AVIF_RESULT_OK);
+
+  ASSERT_EQ(avifEncoderAddImage(encoder_.get(), image_.get(), 1,
+                                AVIF_ADD_IMAGE_FLAG_NONE),
+            AVIF_RESULT_OK);
+
+  ASSERT_EQ(avifEncoderFinish(encoder_.get(), &encoded_avif_), AVIF_RESULT_OK);
+
+  TestDecode(256, 256);
+}
+
+TEST_F(ProgressiveTest, ResolutionChangeExternalWithAlpha) {
+  const auto image =
+      testutil::CreateImage(kImageSize, kImageSize, 8, AVIF_PIXEL_FORMAT_YUV444,
+                            AVIF_PLANES_ALL, AVIF_RANGE_FULL);
+  ASSERT_NE(image, nullptr);
+  testutil::FillImageGradient(image.get());
+
+  encoder_->extraLayerCount = 2;
+  encoder_->width = kImageSize;
+  encoder_->height = kImageSize;
+
+  auto smallImage = testutil::CreateImage(kImageSize / 2, kImageSize / 2, 8,
+                                          AVIF_PIXEL_FORMAT_YUV444,
+                                          AVIF_PLANES_ALL, AVIF_RANGE_FULL);
+  ASSERT_NE(smallImage, nullptr);
+  testutil::FillImageGradient(smallImage.get(), /*offset=*/17);
+
+  ASSERT_EQ(avifEncoderAddImage(encoder_.get(), smallImage.get(), 1,
+                                AVIF_ADD_IMAGE_FLAG_NONE),
+            AVIF_RESULT_OK);
+
+  ASSERT_EQ(avifEncoderAddImage(encoder_.get(), smallImage.get(), 1,
+                                AVIF_ADD_IMAGE_FLAG_NONE),
+            AVIF_RESULT_OK);
+
+  ASSERT_EQ(avifEncoderAddImage(encoder_.get(), image.get(), 1,
+                                AVIF_ADD_IMAGE_FLAG_NONE),
+            AVIF_RESULT_OK);
+
+  ASSERT_EQ(avifEncoderFinish(encoder_.get(), &encoded_avif_), AVIF_RESULT_OK);
+
+  TestDecode(kImageSize, kImageSize, /*expect_alpha=*/true);
+}
+
+TEST_F(ProgressiveTest, ResolutionChangeExternalBadSize) {
+  encoder_->extraLayerCount = 1;
+  encoder_->width = kImageSize * 2;
+  encoder_->height = kImageSize * 2;
+
+  ASSERT_EQ(avifEncoderAddImage(encoder_.get(), image_.get(), 1,
+                                AVIF_ADD_IMAGE_FLAG_NONE),
+            AVIF_RESULT_OK);
+
+  // Last layer does not match the pre-declared size
+  ASSERT_EQ(avifEncoderAddImage(encoder_.get(), image_.get(), 1,
+                                AVIF_ADD_IMAGE_FLAG_NONE),
+            AVIF_RESULT_INCOMPATIBLE_IMAGE);
+}
+
+// Reject mixed usage of internal and external resolution change.
+TEST_F(ProgressiveTest, ResolutionChangeMixedRejected) {
+  encoder_->extraLayerCount = 1;
+  encoder_->width = kImageSize;
+  encoder_->height = kImageSize;
+  encoder_->scalingMode = {{1, 2}, {1, 2}};
+
+  ASSERT_EQ(avifEncoderAddImage(encoder_.get(), image_.get(), 1,
+                                AVIF_ADD_IMAGE_FLAG_NONE),
+            AVIF_RESULT_INVALID_ARGUMENT);
+}
+
+TEST_F(ProgressiveTest, ResolutionChangeMixedDuringEncodingRejected) {
+  encoder_->extraLayerCount = 2;
+  encoder_->width = kImageSize;
+  encoder_->height = kImageSize;
+
+  const auto smallImage = testutil::CreateImage(
+      kImageSize / 2, kImageSize / 2, 8, AVIF_PIXEL_FORMAT_YUV444,
+      AVIF_PLANES_YUV, AVIF_RANGE_FULL);
+  ASSERT_NE(smallImage, nullptr);
+  testutil::FillImageGradient(smallImage.get(), /*offset=*/17);
+
+  ASSERT_EQ(avifEncoderAddImage(encoder_.get(), smallImage.get(), 1,
+                                AVIF_ADD_IMAGE_FLAG_NONE),
+            AVIF_RESULT_OK);
+
+  encoder_->scalingMode = {{1, 2}, {1, 2}};
+  ASSERT_EQ(avifEncoderAddImage(encoder_.get(), image_.get(), 1,
+                                AVIF_ADD_IMAGE_FLAG_NONE),
+            AVIF_RESULT_INVALID_ARGUMENT);
+}
+
 TEST_F(ProgressiveTest, LayeredGrid) {
   encoder_->extraLayerCount = 1;
   encoder_->quality = 21;
diff --git a/tests/test_cmd_progressive.sh b/tests/test_cmd_progressive.sh
index 6492ee0..c2e1583 100755
--- a/tests/test_cmd_progressive.sh
+++ b/tests/test_cmd_progressive.sh
@@ -22,14 +22,16 @@
 
 # Input file paths.
 INPUT_Y4M="${TESTDATA_DIR}/kodim03_yuv420_8bpc.y4m"
+INPUT_SMALL_Y4M="${TESTDATA_DIR}/kodim03_yuv420_8bpc_384x256.y4m"
 # Output file names.
 ENCODED_FILE="avif_test_cmd_encoded.avif"
 DECODED_FILE="avif_test_cmd_decoded.png"
+INFO_FILE="avif_test_cmd_info.txt"
 
 # Cleanup
 cleanup() {
   pushd ${TMP_DIR}
-    rm -- "${ENCODED_FILE}" "${DECODED_FILE}"
+    rm -- "${ENCODED_FILE}" "${DECODED_FILE}" "${INFO_FILE}"
   popd
 }
 trap cleanup EXIT
@@ -55,6 +57,22 @@
     done
   fi
 
+  echo "Testing manual layered encoding with pre-scaled input"
+  "${AVIFENC}" -s 8 --layered \
+    "${INPUT_SMALL_Y4M}" "${INPUT_Y4M}" -o "${ENCODED_FILE}"
+  "${AVIFDEC}" --info "${ENCODED_FILE}" > "${INFO_FILE}"
+  grep -F "[768x512]" "${INFO_FILE}"
+  "${AVIFDEC}" "${ENCODED_FILE}" "${DECODED_FILE}"
+  "${AVIFDEC}" --progressive "${ENCODED_FILE}" "${DECODED_FILE}"
+
+  echo "Testing an earlier layer larger than the last layer"
+  "${AVIFENC}" -s 8 --layered \
+    "${INPUT_Y4M}" "${INPUT_SMALL_Y4M}" -o "${ENCODED_FILE}" && exit 1
+
+  echo "Testing layered encoding with pre-scaled input and frame scaling (rejected)"
+  "${AVIFENC}" -s 8 --layered --scaling-mode:u 1/2 \
+    "${INPUT_SMALL_Y4M}" "${INPUT_Y4M}" -o "${ENCODED_FILE}" && exit 1
+
   echo "Testing too few layers"
   "${AVIFENC}" -s 8 --layered -q:u 60 "${INPUT_Y4M}" -o "${ENCODED_FILE}" && exit 1