Support encoding layered image with pre-scaled inputs Add the width and height encoding options to avifEncoder.
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