diff --git a/CHANGELOG.md b/CHANGELOG.md
index b4479ac..2786bd8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -28,6 +28,8 @@
   should be updated to set quality (and qualityAlpha if applicable) and leave
   minQuantizer, maxQuantizer, minQuantizerAlpha, and maxQuantizerAlpha
   initialized to the default values.
+* The --targetSize flag in avifenc was added to adapt the quality so that the
+  output file size is as close to the given number of bytes as possible.
 * Add the public API function avifImageIsOpaque() in avif.h.
 * Add experimental API for progressive AVIF encoding.
 * Add API for multi-threaded YUV to RGB color conversion.
diff --git a/apps/avifenc.c b/apps/avifenc.c
index ef892d7..a8d05ee 100644
--- a/apps/avifenc.c
+++ b/apps/avifenc.c
@@ -34,6 +34,15 @@
 } avifInputFile;
 static avifInputFile stdinFile;
 
+typedef struct
+{
+    int fileIndex;
+    avifImage * image;
+    uint32_t fileBitDepth;
+    avifBool fileIsRGB;
+    avifAppSourceTiming sourceTiming;
+} avifInputCacheEntry;
+
 typedef struct avifInput
 {
     avifInputFile * files;
@@ -43,8 +52,19 @@
     avifPixelFormat requestedFormat;
     int requestedDepth;
     avifBool useStdin;
+
+    avifBool cacheEnabled;
+    avifInputCacheEntry * cache;
+    int cacheCount;
 } avifInput;
 
+typedef struct
+{
+    char ** keys;
+    char ** values;
+    int count;
+} avifCodecSpecificOptions;
+
 static void syntax(void)
 {
     printf("Syntax: avifenc [options] input.[jpg|jpeg|png|y4m] output.avif\n");
@@ -117,6 +137,7 @@
            AVIF_QUANTIZER_BEST_QUALITY,
            AVIF_QUANTIZER_WORST_QUALITY,
            AVIF_QUANTIZER_LOSSLESS);
+    printf("    --target-size S                   : Set target file size in bytes (up to 7 times slower)\n");
     printf("    --                                : Signals the end of options. Everything after this is interpreted as file names.\n");
     printf("\n");
     if (avifCodecName(AVIF_CODEC_CHOICE_AOM, 0)) {
@@ -244,8 +265,36 @@
     return AVIF_TRUE;
 }
 
-static avifInputFile * avifInputGetNextFile(avifInput * input)
+static avifBool avifInputAddCachedImage(avifInput * input)
 {
+    avifImage * newImage = avifImageCreateEmpty();
+    if (!newImage) {
+        return AVIF_FALSE;
+    }
+    avifInputCacheEntry * newCachedImages = malloc((input->cacheCount + 1) * sizeof(*input->cache));
+    if (!newCachedImages) {
+        avifImageDestroy(newImage);
+        return AVIF_FALSE;
+    }
+    avifInputCacheEntry * oldCachedImages = input->cache;
+    input->cache = newCachedImages;
+    if (input->cacheCount) {
+        memcpy(input->cache, oldCachedImages, input->cacheCount * sizeof(*input->cache));
+    }
+    memset(&input->cache[input->cacheCount], 0, sizeof(input->cache[input->cacheCount]));
+    input->cache[input->cacheCount].fileIndex = input->fileIndex;
+    input->cache[input->cacheCount].image = newImage;
+    ++input->cacheCount;
+    free(oldCachedImages);
+    return AVIF_TRUE;
+}
+
+static const avifInputFile * avifInputGetFile(const avifInput * input, int imageIndex)
+{
+    if (imageIndex < input->cacheCount) {
+        return &input->files[input->cache[imageIndex].fileIndex];
+    }
+
     if (input->useStdin) {
         ungetc(fgetc(stdin), stdin); // Kick stdin to force EOF
 
@@ -260,66 +309,124 @@
     }
     return &input->files[input->fileIndex];
 }
-static avifBool avifInputHasRemainingData(avifInput * input)
+
+static avifBool avifInputHasRemainingData(const avifInput * input, int imageIndex)
 {
+    if (imageIndex < input->cacheCount) {
+        return AVIF_TRUE;
+    }
+
     if (input->useStdin) {
         return !feof(stdin);
     }
     return (input->fileIndex < input->filesCount);
 }
 
-static avifAppFileFormat avifInputReadImage(avifInput * input,
-                                            avifBool ignoreICC,
-                                            avifBool ignoreExif,
-                                            avifBool ignoreXMP,
-                                            avifImage * image,
-                                            uint32_t * outDepth,
-                                            avifAppSourceTiming * sourceTiming,
-                                            avifChromaDownsampling chromaDownsampling)
+static avifBool avifInputReadImage(avifInput * input,
+                                   int imageIndex,
+                                   avifBool ignoreICC,
+                                   avifBool ignoreExif,
+                                   avifBool ignoreXMP,
+                                   avifImage * image,
+                                   uint32_t * outDepth,
+                                   avifBool * sourceIsRGB,
+                                   avifAppSourceTiming * sourceTiming,
+                                   avifChromaDownsampling chromaDownsampling)
 {
-    if (sourceTiming) {
+    if (imageIndex < input->cacheCount) {
+        const avifInputCacheEntry * cached = &input->cache[imageIndex];
+        const avifCropRect rect = { 0, 0, cached->image->width, cached->image->height };
+        if (avifImageSetViewRect(image, cached->image, &rect) != AVIF_RESULT_OK) {
+            assert(AVIF_FALSE);
+        }
+        if (outDepth) {
+            *outDepth = cached->fileBitDepth;
+        }
+        if (sourceIsRGB) {
+            *sourceIsRGB = cached->fileIsRGB;
+        }
+        if (sourceTiming) {
+            *sourceTiming = cached->sourceTiming;
+        }
+        return AVIF_TRUE;
+    }
+
+    avifImage * dstImage = image;
+    uint32_t * dstDepth = outDepth;
+    avifBool * dstSourceIsRGB = sourceIsRGB;
+    avifAppSourceTiming * dstSourceTiming = sourceTiming;
+    if (input->cacheEnabled) {
+        if (!avifInputAddCachedImage(input)) {
+            fprintf(stderr, "ERROR: Out of memory");
+            return AVIF_FALSE;
+        }
+        assert(imageIndex + 1 == input->cacheCount);
+        dstImage = input->cache[imageIndex].image;
+        // Copy CICP, clap etc.
+        if (avifImageCopy(dstImage, image, /*planes=*/0) != AVIF_RESULT_OK) {
+            assert(AVIF_FALSE);
+        }
+        dstDepth = &input->cache[imageIndex].fileBitDepth;
+        dstSourceIsRGB = &input->cache[imageIndex].fileIsRGB;
+        dstSourceTiming = &input->cache[imageIndex].sourceTiming;
+    }
+
+    if (dstSourceTiming) {
         // A source timing of all 0s is a sentinel value hinting that the value is unset / should be
         // ignored. This is memset here as many of the paths in avifInputReadImage() do not set these
         // values. See the declaration for avifAppSourceTiming for more information.
-        memset(sourceTiming, 0, sizeof(avifAppSourceTiming));
+        memset(dstSourceTiming, 0, sizeof(avifAppSourceTiming));
     }
 
     if (input->useStdin) {
         if (feof(stdin)) {
-            return AVIF_APP_FILE_FORMAT_UNKNOWN;
+            return AVIF_FALSE;
         }
-        if (!y4mRead(NULL, image, sourceTiming, &input->frameIter)) {
-            return AVIF_APP_FILE_FORMAT_UNKNOWN;
+        if (!y4mRead(NULL, dstImage, dstSourceTiming, &input->frameIter)) {
+            fprintf(stderr, "ERROR: Cannot read y4m through standard input");
+            return AVIF_FALSE;
         }
-        assert(image->yuvFormat != AVIF_PIXEL_FORMAT_NONE);
-        return AVIF_APP_FILE_FORMAT_Y4M;
-    }
+        assert(dstImage->yuvFormat != AVIF_PIXEL_FORMAT_NONE);
+        if (dstSourceIsRGB) {
+            *dstSourceIsRGB = AVIF_FALSE;
+        }
+    } else {
+        if (input->fileIndex >= input->filesCount) {
+            return AVIF_FALSE;
+        }
 
-    if (input->fileIndex >= input->filesCount) {
-        return AVIF_APP_FILE_FORMAT_UNKNOWN;
-    }
-
-    const avifAppFileFormat nextInputFormat = avifReadImage(input->files[input->fileIndex].filename,
+        const avifAppFileFormat inputFormat = avifReadImage(input->files[input->fileIndex].filename,
                                                             input->requestedFormat,
                                                             input->requestedDepth,
                                                             chromaDownsampling,
                                                             ignoreICC,
                                                             ignoreExif,
                                                             ignoreXMP,
-                                                            image,
-                                                            outDepth,
-                                                            sourceTiming,
+                                                            dstImage,
+                                                            dstDepth,
+                                                            dstSourceTiming,
                                                             &input->frameIter);
-    if (nextInputFormat == AVIF_APP_FILE_FORMAT_UNKNOWN) {
-        return AVIF_APP_FILE_FORMAT_UNKNOWN;
+        if (inputFormat == AVIF_APP_FILE_FORMAT_UNKNOWN) {
+            fprintf(stderr, "Cannot determine input file format: %s\n", input->files[input->fileIndex].filename);
+            return AVIF_FALSE;
+        }
+        if (dstSourceIsRGB) {
+            *dstSourceIsRGB = (inputFormat != AVIF_APP_FILE_FORMAT_Y4M);
+        }
+
+        if (!input->frameIter) {
+            ++input->fileIndex;
+        }
+
+        assert(dstImage->yuvFormat != AVIF_PIXEL_FORMAT_NONE);
     }
 
-    if (!input->frameIter) {
-        ++input->fileIndex;
+    if (input->cacheEnabled) {
+        // Reuse the just created cache entry.
+        assert(imageIndex < input->cacheCount);
+        return avifInputReadImage(input, imageIndex, ignoreICC, ignoreExif, ignoreXMP, image, outDepth, sourceIsRGB, sourceTiming, chromaDownsampling);
     }
-
-    assert(image->yuvFormat != AVIF_PIXEL_FORMAT_NONE);
-    return nextInputFormat;
+    return AVIF_TRUE;
 }
 
 static avifBool readEntireFile(const char * filename, avifRWData * raw)
@@ -349,6 +456,65 @@
     return AVIF_TRUE;
 }
 
+// Returns NULL if a memory allocation failed.
+static char * avifStrdup(const char * str)
+{
+    size_t len = strlen(str);
+    char * dup = avifAlloc(len + 1);
+    if (!dup) {
+        return NULL;
+    }
+    memcpy(dup, str, len + 1);
+    return dup;
+}
+
+static avifBool avifCodecSpecificOptionsAdd(avifCodecSpecificOptions * options, const char * keyValue)
+{
+    avifBool success = AVIF_FALSE;
+    char ** oldKeys = options->keys;
+    char ** oldValues = options->values;
+    options->keys = malloc((options->count + 1) * sizeof(*options->keys));
+    options->values = malloc((options->count + 1) * sizeof(*options->values));
+    if (!options->keys || !options->values) {
+        free(options->keys);
+        free(options->values);
+        options->keys = oldKeys;
+        options->values = oldValues;
+        return AVIF_FALSE;
+    }
+    if (options->count) {
+        memcpy(options->keys, oldKeys, options->count * sizeof(*options->keys));
+        memcpy(options->values, oldValues, options->count * sizeof(*options->values));
+    }
+
+    const char * value = strchr(keyValue, '=');
+    if (value) {
+        // Keep the parts on the left and on the right of the equal sign,
+        // but not the equal sign itself.
+        options->values[options->count] = avifStrdup(value + 1);
+        const size_t keyLength = strlen(keyValue) - strlen(value);
+        options->keys[options->count] = malloc(keyLength + 1);
+        if (!options->values[options->count] || !options->keys[options->count]) {
+            goto cleanup;
+        }
+        memcpy(options->keys[options->count], keyValue, keyLength);
+        options->keys[options->count][keyLength] = '\0';
+    } else {
+        // Pass in a non-NULL, empty string. Codecs can use the mere existence of a key as a boolean value.
+        options->values[options->count] = avifStrdup("");
+        options->keys[options->count] = avifStrdup(keyValue);
+        if (!options->values[options->count] || !options->keys[options->count]) {
+            goto cleanup;
+        }
+    }
+    success = AVIF_TRUE;
+cleanup:
+    ++options->count;
+    free(oldKeys);
+    free(oldValues);
+    return success;
+}
+
 // Returns the best cell size for a given horizontal or vertical dimension.
 static avifBool avifGetBestCellSize(const char * dimensionStr, uint32_t numPixels, uint32_t numCells, avifBool isSubsampled, uint32_t * cellSize)
 {
@@ -440,10 +606,339 @@
     return AVIF_TRUE;
 }
 
-#define INVALID_QUALITY -1
+typedef struct
+{
+    avifCodecChoice codecChoice;
+    int jobs;
+    int quality;
+    avifBool qualityIsConstrained; // true if quality explicitly set by the user
+    int qualityAlpha;
+    avifBool qualityAlphaIsConstrained; // true if qualityAlpha explicitly set by the user
+    int minQuantizer;
+    int maxQuantizer;
+    int minQuantizerAlpha;
+    int maxQuantizerAlpha;
+    int targetSize;
+    int tileRowsLog2;
+    int tileColsLog2;
+    avifBool autoTiling;
+    int speed;
+
+    int paspCount;
+    uint32_t paspValues[8]; // only the first two are used
+    int clapCount;
+    uint32_t clapValues[8];
+    int gridDimsCount;
+    uint32_t gridDims[8]; // only the first two are used
+
+    int repetitionCount;
+    int keyframeInterval;
+    avifBool ignoreExif;
+    avifBool ignoreXMP;
+    avifBool ignoreICC;
+
+    // This holds the output timing for image sequences. The timescale member in this struct will
+    // become the timescale set on avifEncoder, and the duration member will be the default duration
+    // for any frame that doesn't have a specific duration set on the commandline. See the
+    // declaration of avifAppSourceTiming for more documentation.
+    avifAppSourceTiming outputTiming;
+
+    avifColorPrimaries colorPrimaries;
+    avifTransferCharacteristics transferCharacteristics;
+    avifMatrixCoefficients matrixCoefficients;
+    avifChromaDownsampling chromaDownsampling;
+
+    avifCodecSpecificOptions codecSpecificOptions;
+} avifSettings;
+
+static avifBool avifEncodeImagesFixedQuality(const avifSettings * settings,
+                                             avifInput * input,
+                                             const avifInputFile * firstFile,
+                                             const avifImage * firstImage,
+                                             const avifImage * const * gridCells,
+                                             avifRWData * encoded,
+                                             avifIOStats * ioStats)
+{
+    avifBool success = AVIF_FALSE;
+    avifRWDataFree(encoded);
+    avifEncoder * encoder = avifEncoderCreate();
+    avifImage * nextImage = NULL;
+    if (!encoder) {
+        fprintf(stderr, "ERROR: Out of memory\n");
+        goto cleanup;
+    }
+
+    char manualTilingStr[128];
+    snprintf(manualTilingStr, sizeof(manualTilingStr), "tileRowsLog2 [%d], tileColsLog2 [%d]", settings->tileRowsLog2, settings->tileColsLog2);
+
+    printf("Encoding with AV1 codec '%s' speed [%d], color quality [%d (%s)], alpha quality [%d (%s)], %s, %d worker thread(s), please wait...\n",
+           avifCodecName(settings->codecChoice, AVIF_CODEC_FLAG_CAN_ENCODE),
+           settings->speed,
+           settings->quality,
+           qualityString(settings->quality),
+           settings->qualityAlpha,
+           qualityString(settings->qualityAlpha),
+           settings->autoTiling ? "automatic tiling" : manualTilingStr,
+           settings->jobs);
+    encoder->maxThreads = settings->jobs;
+    encoder->quality = settings->quality;
+    encoder->qualityAlpha = settings->qualityAlpha;
+    encoder->minQuantizer = settings->minQuantizer;
+    encoder->maxQuantizer = settings->maxQuantizer;
+    encoder->minQuantizerAlpha = settings->minQuantizerAlpha;
+    encoder->maxQuantizerAlpha = settings->maxQuantizerAlpha;
+    encoder->tileRowsLog2 = settings->tileRowsLog2;
+    encoder->tileColsLog2 = settings->tileColsLog2;
+    encoder->autoTiling = settings->autoTiling;
+    encoder->codecChoice = settings->codecChoice;
+    encoder->speed = settings->speed;
+    encoder->timescale = settings->outputTiming.timescale;
+    encoder->keyframeInterval = settings->keyframeInterval;
+    encoder->repetitionCount = settings->repetitionCount;
+
+    for (int i = 0; i < settings->codecSpecificOptions.count; ++i) {
+        if (avifEncoderSetCodecSpecificOption(encoder, settings->codecSpecificOptions.keys[i], settings->codecSpecificOptions.values[i]) !=
+            AVIF_RESULT_OK) {
+            fprintf(stderr,
+                    "ERROR: Failed to set codec specific option: %s = %s\n",
+                    settings->codecSpecificOptions.keys[i],
+                    settings->codecSpecificOptions.values[i]);
+            goto cleanup;
+        }
+    }
+
+    if (settings->gridDimsCount > 0) {
+        const avifResult addImageResult =
+            avifEncoderAddImageGrid(encoder, settings->gridDims[0], settings->gridDims[1], gridCells, AVIF_ADD_IMAGE_FLAG_SINGLE);
+        if (addImageResult != AVIF_RESULT_OK) {
+            fprintf(stderr, "ERROR: Failed to encode image grid: %s\n", avifResultToString(addImageResult));
+            goto cleanup;
+        }
+    } else {
+        int imageIndex = 1; // firstImage with imageIndex 0 is already available.
+
+        avifAddImageFlags addImageFlags = AVIF_ADD_IMAGE_FLAG_NONE;
+        if (!avifInputHasRemainingData(input, imageIndex)) {
+            addImageFlags |= AVIF_ADD_IMAGE_FLAG_SINGLE;
+        }
+
+        uint64_t firstDurationInTimescales = firstFile->duration ? firstFile->duration : settings->outputTiming.duration;
+        if (input->useStdin || (input->filesCount > 1)) {
+            printf(" * Encoding frame 1 [%" PRIu64 "/%" PRIu64 " ts]: %s\n",
+                   firstDurationInTimescales,
+                   settings->outputTiming.timescale,
+                   firstFile->filename);
+        }
+        const avifResult addImageResult = avifEncoderAddImage(encoder, firstImage, firstDurationInTimescales, addImageFlags);
+        if (addImageResult != AVIF_RESULT_OK) {
+            fprintf(stderr, "ERROR: Failed to encode image: %s\n", avifResultToString(addImageResult));
+            goto cleanup;
+        }
+
+        // Not generating a single-image grid: Use all remaining input files as subsequent frames.
+
+        const avifInputFile * nextFile;
+        while ((nextFile = avifInputGetFile(input, imageIndex)) != NULL) {
+            uint64_t nextDurationInTimescales = nextFile->duration ? nextFile->duration : settings->outputTiming.duration;
+
+            printf(" * Encoding frame %d [%" PRIu64 "/%" PRIu64 " ts]: %s\n",
+                   imageIndex,
+                   nextDurationInTimescales,
+                   settings->outputTiming.timescale,
+                   nextFile->filename);
+
+            if (nextImage) {
+                avifImageDestroy(nextImage);
+            }
+            nextImage = avifImageCreateEmpty();
+            if (!nextImage) {
+                fprintf(stderr, "ERROR: Out of memory\n");
+                goto cleanup;
+            }
+            nextImage->colorPrimaries = firstImage->colorPrimaries;
+            nextImage->transferCharacteristics = firstImage->transferCharacteristics;
+            nextImage->matrixCoefficients = firstImage->matrixCoefficients;
+            nextImage->yuvRange = firstImage->yuvRange;
+            nextImage->alphaPremultiplied = firstImage->alphaPremultiplied;
+
+            // Ignore ICC, Exif and XMP because only the metadata of the first frame is taken into
+            // account by the libavif API.
+            if (!avifInputReadImage(input,
+                                    imageIndex,
+                                    /*ignoreICC=*/AVIF_TRUE,
+                                    /*ignoreExif=*/AVIF_TRUE,
+                                    /*ignoreXMP=*/AVIF_TRUE,
+                                    nextImage,
+                                    /*outDepth=*/NULL,
+                                    /*sourceIsRGB=*/NULL,
+                                    /*sourceTiming=*/NULL,
+                                    settings->chromaDownsampling)) {
+                goto cleanup;
+            }
+
+            // Verify that this frame's properties matches the first frame's properties
+            if ((firstImage->width != nextImage->width) || (firstImage->height != nextImage->height)) {
+                fprintf(stderr,
+                        "ERROR: Image sequence dimensions mismatch, [%ux%u] vs [%ux%u]: %s\n",
+                        firstImage->width,
+                        firstImage->height,
+                        nextImage->width,
+                        nextImage->height,
+                        nextFile->filename);
+                goto cleanup;
+            }
+            if (firstImage->depth != nextImage->depth) {
+                fprintf(stderr,
+                        "ERROR: Image sequence depth mismatch, [%u] vs [%u]: %s\n",
+                        firstImage->depth,
+                        nextImage->depth,
+                        nextFile->filename);
+                goto cleanup;
+            }
+            if ((firstImage->colorPrimaries != nextImage->colorPrimaries) ||
+                (firstImage->transferCharacteristics != nextImage->transferCharacteristics) ||
+                (firstImage->matrixCoefficients != nextImage->matrixCoefficients)) {
+                fprintf(stderr,
+                        "ERROR: Image sequence CICP mismatch, [%u/%u/%u] vs [%u/%u/%u]: %s\n",
+                        firstImage->colorPrimaries,
+                        firstImage->matrixCoefficients,
+                        firstImage->transferCharacteristics,
+                        nextImage->colorPrimaries,
+                        nextImage->transferCharacteristics,
+                        nextImage->matrixCoefficients,
+                        nextFile->filename);
+                goto cleanup;
+            }
+            if (firstImage->yuvRange != nextImage->yuvRange) {
+                fprintf(stderr,
+                        "ERROR: Image sequence range mismatch, [%s] vs [%s]: %s\n",
+                        (firstImage->yuvRange == AVIF_RANGE_FULL) ? "Full" : "Limited",
+                        (nextImage->yuvRange == AVIF_RANGE_FULL) ? "Full" : "Limited",
+                        nextFile->filename);
+                goto cleanup;
+            }
+
+            const avifResult nextImageResult =
+                avifEncoderAddImage(encoder, nextImage, nextDurationInTimescales, AVIF_ADD_IMAGE_FLAG_NONE);
+            if (nextImageResult != AVIF_RESULT_OK) {
+                fprintf(stderr, "ERROR: Failed to encode image: %s\n", avifResultToString(nextImageResult));
+                goto cleanup;
+            }
+            ++imageIndex;
+        }
+    }
+
+    const avifResult finishResult = avifEncoderFinish(encoder, encoded);
+    if (finishResult != AVIF_RESULT_OK) {
+        fprintf(stderr, "ERROR: Failed to finish encoding: %s\n", avifResultToString(finishResult));
+        goto cleanup;
+    }
+    success = AVIF_TRUE;
+    memcpy(ioStats, &encoder->ioStats, sizeof(*ioStats));
+
+cleanup:
+    if (encoder) {
+        if (!success) {
+            avifDumpDiagnostics(&encoder->diag);
+        }
+        avifEncoderDestroy(encoder);
+    }
+    if (nextImage) {
+        avifImageDestroy(nextImage);
+    }
+    return success;
+}
+
+#define INVALID_QUALITY (-1)
 #define DEFAULT_QUALITY 60 // Maps to a quantizer (QP) of 25.
 #define DEFAULT_QUALITY_ALPHA AVIF_QUALITY_LOSSLESS
 
+static avifBool avifEncodeImages(avifSettings * settings,
+                                 avifInput * input,
+                                 const avifInputFile * firstFile,
+                                 const avifImage * firstImage,
+                                 const avifImage * const * gridCells,
+                                 avifRWData * encoded,
+                                 avifIOStats * ioStats)
+{
+    if (settings->targetSize == -1) {
+        return avifEncodeImagesFixedQuality(settings, input, firstFile, firstImage, gridCells, encoded, ioStats);
+    }
+
+    if (settings->qualityIsConstrained && settings->qualityAlphaIsConstrained) {
+        fprintf(stderr, "ERROR: --target_size is used with constrained --qcolor and --qalpha\n");
+        return AVIF_FALSE;
+    }
+
+    printf("Starting a binary search to find the %s generating the encoded image size closest to %d bytes, please wait...\n",
+           settings->qualityAlphaIsConstrained ? "color quality"
+                                               : (settings->qualityIsConstrained ? "alpha quality" : "color and alpha qualities"),
+           settings->targetSize);
+    const size_t targetSize = (size_t)settings->targetSize;
+
+    // TODO(yguyon): Use quantizer instead of quality because quantizer range is smaller (faster binary search).
+    int closestQuality = INVALID_QUALITY;
+    avifRWData closestEncoded = { NULL, 0 };
+    size_t closestSizeDiff = 0;
+    avifIOStats closestIoStats = { 0, 0 };
+
+    int minQuality = AVIF_QUALITY_WORST; // inclusive
+    int maxQuality = AVIF_QUALITY_BEST;  // inclusive
+    while (minQuality <= maxQuality) {
+        const int quality = (minQuality + maxQuality) / 2;
+        if (!settings->qualityIsConstrained) {
+            settings->quality = quality;
+        }
+        if (!settings->qualityAlphaIsConstrained) {
+            settings->qualityAlpha = quality;
+        }
+
+        if (!avifEncodeImagesFixedQuality(settings, input, firstFile, firstImage, gridCells, encoded, ioStats)) {
+            avifRWDataFree(&closestEncoded);
+            return AVIF_FALSE;
+        }
+        printf("Encoded image of size %" AVIF_FMT_ZU " bytes.\n", encoded->size);
+
+        if (encoded->size == targetSize) {
+            return AVIF_TRUE;
+        }
+
+        size_t sizeDiff;
+        if (encoded->size > targetSize) {
+            sizeDiff = encoded->size - targetSize;
+            maxQuality = quality - 1;
+        } else {
+            sizeDiff = targetSize - encoded->size;
+            minQuality = quality + 1;
+        }
+
+        if ((closestQuality == INVALID_QUALITY) || (sizeDiff < closestSizeDiff)) {
+            closestQuality = quality;
+            avifRWDataFree(&closestEncoded);
+            closestEncoded = *encoded;
+            encoded->size = 0;
+            encoded->data = NULL;
+            closestSizeDiff = sizeDiff;
+            closestIoStats = *ioStats;
+        }
+    }
+
+    if (!settings->qualityIsConstrained) {
+        settings->quality = closestQuality;
+    }
+    if (!settings->qualityAlphaIsConstrained) {
+        settings->qualityAlpha = closestQuality;
+    }
+    avifRWDataFree(encoded);
+    *encoded = closestEncoded;
+    *ioStats = closestIoStats;
+    printf("Kept the encoded image of size %" AVIF_FMT_ZU " bytes generated with color quality %d and alpha quality %d.\n",
+           encoded->size,
+           settings->quality,
+           settings->qualityAlpha);
+    return AVIF_TRUE;
+}
+
 int main(int argc, char * argv[])
 {
     if (argc < 2) {
@@ -462,68 +957,51 @@
     //     https://github.com/AOMediaCodec/libavif/issues/440
 
     int returnCode = 0;
-    int jobs = 1;
-    int quality = INVALID_QUALITY;
-    int qualityAlpha = INVALID_QUALITY;
-    int minQuantizer = -1;
-    int maxQuantizer = -1;
-    int minQuantizerAlpha = -1;
-    int maxQuantizerAlpha = -1;
-    int tileRowsLog2 = -1;
-    int tileColsLog2 = -1;
-    avifBool autoTiling = AVIF_FALSE;
-    int speed = 6;
-    int paspCount = 0;
-    uint32_t paspValues[8]; // only the first two are used
-    int clapCount = 0;
-    uint32_t clapValues[8];
+    avifSettings settings;
+    memset(&settings, 0, sizeof(settings));
+    settings.codecChoice = AVIF_CODEC_CHOICE_AUTO;
+    settings.jobs = 1;
+    settings.quality = INVALID_QUALITY;
+    settings.qualityAlpha = INVALID_QUALITY;
+    settings.minQuantizer = -1;
+    settings.maxQuantizer = -1;
+    settings.minQuantizerAlpha = -1;
+    settings.maxQuantizerAlpha = -1;
+    settings.targetSize = -1;
+    settings.tileRowsLog2 = -1;
+    settings.tileColsLog2 = -1;
+    settings.autoTiling = AVIF_FALSE;
+    settings.speed = 6;
+    settings.repetitionCount = AVIF_REPETITION_COUNT_INFINITE;
+    settings.keyframeInterval = 0;
+    settings.ignoreExif = AVIF_FALSE;
+    settings.ignoreXMP = AVIF_FALSE;
+    settings.ignoreICC = AVIF_FALSE;
+
     avifBool cropConversionRequired = AVIF_FALSE;
     uint8_t irotAngle = 0xff; // sentinel value indicating "unused"
     uint8_t imirMode = 0xff;  // sentinel value indicating "unused"
-    int repetitionCount = AVIF_REPETITION_COUNT_INFINITE;
-    avifCodecChoice codecChoice = AVIF_CODEC_CHOICE_AUTO;
     avifRange requestedRange = AVIF_RANGE_FULL;
     avifBool lossless = AVIF_FALSE;
-    avifBool ignoreExif = AVIF_FALSE;
-    avifBool ignoreXMP = AVIF_FALSE;
-    avifBool ignoreICC = AVIF_FALSE;
     avifImage * image = NULL;
-    avifImage * nextImage = NULL;
     avifRWData raw = AVIF_DATA_EMPTY;
     avifRWData exifOverride = AVIF_DATA_EMPTY;
     avifRWData xmpOverride = AVIF_DATA_EMPTY;
     avifRWData iccOverride = AVIF_DATA_EMPTY;
-    int keyframeInterval = 0;
     avifBool cicpExplicitlySet = AVIF_FALSE;
     avifBool premultiplyAlpha = AVIF_FALSE;
-    int gridDimsCount = 0;
-    uint32_t gridDims[8]; // only the first two are used
     uint32_t gridCellCount = 0;
     avifImage ** gridCells = NULL;
     avifImage * gridSplitImage = NULL; // used for cleanup tracking
-    memset(gridDims, 0, sizeof(gridDims));
-
-    // This holds the output timing for image sequences. The timescale member in this struct will
-    // become the timescale set on avifEncoder, and the duration member will be the default duration
-    // for any frame that doesn't have a specific duration set on the commandline. See the
-    // declaration of avifAppSourceTiming for more documentation.
-    avifAppSourceTiming outputTiming = { 0, 0 };
 
     // By default, the color profile itself is unspecified, so CP/TC are set (to 2) accordingly.
     // However, if the end-user doesn't specify any CICP, we will convert to YUV using BT601
     // coefficients anyway (as MC:2 falls back to MC:5/6), so we might as well signal it explicitly.
     // See: ISO/IEC 23000-22:2019 Amendment 2, or the comment in avifCalcYUVCoefficients()
-    avifColorPrimaries colorPrimaries = AVIF_COLOR_PRIMARIES_UNSPECIFIED;
-    avifTransferCharacteristics transferCharacteristics = AVIF_TRANSFER_CHARACTERISTICS_UNSPECIFIED;
-    avifMatrixCoefficients matrixCoefficients = AVIF_MATRIX_COEFFICIENTS_BT601;
-    avifChromaDownsampling chromaDownsampling = AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC;
-
-    avifEncoder * encoder = avifEncoderCreate();
-    if (!encoder) {
-        fprintf(stderr, "ERROR: Out of memory\n");
-        returnCode = 1;
-        goto cleanup;
-    }
+    settings.colorPrimaries = AVIF_COLOR_PRIMARIES_UNSPECIFIED;
+    settings.transferCharacteristics = AVIF_TRANSFER_CHARACTERISTICS_UNSPECIFIED;
+    settings.matrixCoefficients = AVIF_MATRIX_COEFFICIENTS_BT601;
+    settings.chromaDownsampling = AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC;
 
     int argIndex = 1;
     while (argIndex < argc) {
@@ -536,7 +1014,7 @@
             while (argIndex < argc) {
                 arg = argv[argIndex];
                 input.files[input.filesCount].filename = arg;
-                input.files[input.filesCount].duration = outputTiming.duration;
+                input.files[input.filesCount].duration = settings.outputTiming.duration;
                 ++input.filesCount;
                 ++argIndex;
             }
@@ -550,11 +1028,11 @@
         } else if (!strcmp(arg, "-j") || !strcmp(arg, "--jobs")) {
             NEXTARG();
             if (!strcmp(arg, "all")) {
-                jobs = avifQueryCPUCount();
+                settings.jobs = avifQueryCPUCount();
             } else {
-                jobs = atoi(arg);
-                if (jobs < 1) {
-                    jobs = 1;
+                settings.jobs = atoi(arg);
+                if (settings.jobs < 1) {
+                    settings.jobs = 1;
                 }
             }
         } else if (!strcmp(arg, "--stdin")) {
@@ -587,90 +1065,99 @@
             }
         } else if (!strcmp(arg, "-k") || !strcmp(arg, "--keyframe")) {
             NEXTARG();
-            keyframeInterval = atoi(arg);
+            settings.keyframeInterval = atoi(arg);
         } else if (!strcmp(arg, "-q") || !strcmp(arg, "--qcolor")) {
             NEXTARG();
-            quality = atoi(arg);
-            if (quality < AVIF_QUALITY_WORST) {
-                quality = AVIF_QUALITY_WORST;
+            settings.quality = atoi(arg);
+            if (settings.quality < AVIF_QUALITY_WORST) {
+                settings.quality = AVIF_QUALITY_WORST;
             }
-            if (quality > AVIF_QUALITY_BEST) {
-                quality = AVIF_QUALITY_BEST;
+            if (settings.quality > AVIF_QUALITY_BEST) {
+                settings.quality = AVIF_QUALITY_BEST;
             }
+            settings.qualityIsConstrained = AVIF_TRUE;
         } else if (!strcmp(arg, "--qalpha")) {
             NEXTARG();
-            qualityAlpha = atoi(arg);
-            if (qualityAlpha < AVIF_QUALITY_WORST) {
-                qualityAlpha = AVIF_QUALITY_WORST;
+            settings.qualityAlpha = atoi(arg);
+            if (settings.qualityAlpha < AVIF_QUALITY_WORST) {
+                settings.qualityAlpha = AVIF_QUALITY_WORST;
             }
-            if (qualityAlpha > AVIF_QUALITY_BEST) {
-                qualityAlpha = AVIF_QUALITY_BEST;
+            if (settings.qualityAlpha > AVIF_QUALITY_BEST) {
+                settings.qualityAlpha = AVIF_QUALITY_BEST;
             }
+            settings.qualityAlphaIsConstrained = AVIF_TRUE;
         } else if (!strcmp(arg, "--min")) {
             NEXTARG();
-            minQuantizer = atoi(arg);
-            if (minQuantizer < AVIF_QUANTIZER_BEST_QUALITY) {
-                minQuantizer = AVIF_QUANTIZER_BEST_QUALITY;
+            settings.minQuantizer = atoi(arg);
+            if (settings.minQuantizer < AVIF_QUANTIZER_BEST_QUALITY) {
+                settings.minQuantizer = AVIF_QUANTIZER_BEST_QUALITY;
             }
-            if (minQuantizer > AVIF_QUANTIZER_WORST_QUALITY) {
-                minQuantizer = AVIF_QUANTIZER_WORST_QUALITY;
+            if (settings.minQuantizer > AVIF_QUANTIZER_WORST_QUALITY) {
+                settings.minQuantizer = AVIF_QUANTIZER_WORST_QUALITY;
             }
         } else if (!strcmp(arg, "--max")) {
             NEXTARG();
-            maxQuantizer = atoi(arg);
-            if (maxQuantizer < AVIF_QUANTIZER_BEST_QUALITY) {
-                maxQuantizer = AVIF_QUANTIZER_BEST_QUALITY;
+            settings.maxQuantizer = atoi(arg);
+            if (settings.maxQuantizer < AVIF_QUANTIZER_BEST_QUALITY) {
+                settings.maxQuantizer = AVIF_QUANTIZER_BEST_QUALITY;
             }
-            if (maxQuantizer > AVIF_QUANTIZER_WORST_QUALITY) {
-                maxQuantizer = AVIF_QUANTIZER_WORST_QUALITY;
+            if (settings.maxQuantizer > AVIF_QUANTIZER_WORST_QUALITY) {
+                settings.maxQuantizer = AVIF_QUANTIZER_WORST_QUALITY;
             }
         } else if (!strcmp(arg, "--minalpha")) {
             NEXTARG();
-            minQuantizerAlpha = atoi(arg);
-            if (minQuantizerAlpha < AVIF_QUANTIZER_BEST_QUALITY) {
-                minQuantizerAlpha = AVIF_QUANTIZER_BEST_QUALITY;
+            settings.minQuantizerAlpha = atoi(arg);
+            if (settings.minQuantizerAlpha < AVIF_QUANTIZER_BEST_QUALITY) {
+                settings.minQuantizerAlpha = AVIF_QUANTIZER_BEST_QUALITY;
             }
-            if (minQuantizerAlpha > AVIF_QUANTIZER_WORST_QUALITY) {
-                minQuantizerAlpha = AVIF_QUANTIZER_WORST_QUALITY;
+            if (settings.minQuantizerAlpha > AVIF_QUANTIZER_WORST_QUALITY) {
+                settings.minQuantizerAlpha = AVIF_QUANTIZER_WORST_QUALITY;
             }
         } else if (!strcmp(arg, "--maxalpha")) {
             NEXTARG();
-            maxQuantizerAlpha = atoi(arg);
-            if (maxQuantizerAlpha < AVIF_QUANTIZER_BEST_QUALITY) {
-                maxQuantizerAlpha = AVIF_QUANTIZER_BEST_QUALITY;
+            settings.maxQuantizerAlpha = atoi(arg);
+            if (settings.maxQuantizerAlpha < AVIF_QUANTIZER_BEST_QUALITY) {
+                settings.maxQuantizerAlpha = AVIF_QUANTIZER_BEST_QUALITY;
             }
-            if (maxQuantizerAlpha > AVIF_QUANTIZER_WORST_QUALITY) {
-                maxQuantizerAlpha = AVIF_QUANTIZER_WORST_QUALITY;
+            if (settings.maxQuantizerAlpha > AVIF_QUANTIZER_WORST_QUALITY) {
+                settings.maxQuantizerAlpha = AVIF_QUANTIZER_WORST_QUALITY;
+            }
+        } else if (!strcmp(arg, "--target-size")) {
+            NEXTARG();
+            settings.targetSize = atoi(arg);
+            if (settings.targetSize < 0) {
+                settings.targetSize = -1;
             }
         } else if (!strcmp(arg, "--tilerowslog2")) {
             NEXTARG();
-            tileRowsLog2 = atoi(arg);
-            if (tileRowsLog2 < 0) {
-                tileRowsLog2 = 0;
+            settings.tileRowsLog2 = atoi(arg);
+            if (settings.tileRowsLog2 < 0) {
+                settings.tileRowsLog2 = 0;
             }
-            if (tileRowsLog2 > 6) {
-                tileRowsLog2 = 6;
+            if (settings.tileRowsLog2 > 6) {
+                settings.tileRowsLog2 = 6;
             }
         } else if (!strcmp(arg, "--tilecolslog2")) {
             NEXTARG();
-            tileColsLog2 = atoi(arg);
-            if (tileColsLog2 < 0) {
-                tileColsLog2 = 0;
+            settings.tileColsLog2 = atoi(arg);
+            if (settings.tileColsLog2 < 0) {
+                settings.tileColsLog2 = 0;
             }
-            if (tileColsLog2 > 6) {
-                tileColsLog2 = 6;
+            if (settings.tileColsLog2 > 6) {
+                settings.tileColsLog2 = 6;
             }
         } else if (!strcmp(arg, "--autotiling")) {
-            autoTiling = AVIF_TRUE;
+            settings.autoTiling = AVIF_TRUE;
         } else if (!strcmp(arg, "-g") || !strcmp(arg, "--grid")) {
             NEXTARG();
-            gridDimsCount = parseU32List(gridDims, arg);
-            if (gridDimsCount != 2) {
+            settings.gridDimsCount = parseU32List(settings.gridDims, arg);
+            if (settings.gridDimsCount != 2) {
                 fprintf(stderr, "ERROR: Invalid grid dims: %s\n", arg);
                 returnCode = 1;
                 goto cleanup;
             }
-            if ((gridDims[0] == 0) || (gridDims[0] > 256) || (gridDims[1] == 0) || (gridDims[1] > 256)) {
+            if ((settings.gridDims[0] == 0) || (settings.gridDims[0] > 256) || (settings.gridDims[1] == 0) ||
+                (settings.gridDims[1] > 256)) {
                 fprintf(stderr, "ERROR: Invalid grid dims (valid dim range [1-256]): %s\n", arg);
                 returnCode = 1;
                 goto cleanup;
@@ -682,9 +1169,9 @@
                 returnCode = 1;
                 goto cleanup;
             }
-            colorPrimaries = (avifColorPrimaries)cicp[0];
-            transferCharacteristics = (avifTransferCharacteristics)cicp[1];
-            matrixCoefficients = (avifMatrixCoefficients)cicp[2];
+            settings.colorPrimaries = (avifColorPrimaries)cicp[0];
+            settings.transferCharacteristics = (avifTransferCharacteristics)cicp[1];
+            settings.matrixCoefficients = (avifMatrixCoefficients)cicp[2];
             cicpExplicitlySet = AVIF_TRUE;
         } else if (!strcmp(arg, "-r") || !strcmp(arg, "--range")) {
             NEXTARG();
@@ -700,14 +1187,14 @@
         } else if (!strcmp(arg, "-s") || !strcmp(arg, "--speed")) {
             NEXTARG();
             if (!strcmp(arg, "default") || !strcmp(arg, "d")) {
-                speed = AVIF_SPEED_DEFAULT;
+                settings.speed = AVIF_SPEED_DEFAULT;
             } else {
-                speed = atoi(arg);
-                if (speed > AVIF_SPEED_FASTEST) {
-                    speed = AVIF_SPEED_FASTEST;
+                settings.speed = atoi(arg);
+                if (settings.speed > AVIF_SPEED_FASTEST) {
+                    settings.speed = AVIF_SPEED_FASTEST;
                 }
-                if (speed < AVIF_SPEED_SLOWEST) {
-                    speed = AVIF_SPEED_SLOWEST;
+                if (settings.speed < AVIF_SPEED_SLOWEST) {
+                    settings.speed = AVIF_SPEED_SLOWEST;
                 }
             }
         } else if (!strcmp(arg, "--exif")) {
@@ -717,7 +1204,7 @@
                 returnCode = 1;
                 goto cleanup;
             }
-            ignoreExif = AVIF_TRUE;
+            settings.ignoreExif = AVIF_TRUE;
         } else if (!strcmp(arg, "--xmp")) {
             NEXTARG();
             if (!readEntireFile(arg, &xmpOverride)) {
@@ -725,7 +1212,7 @@
                 returnCode = 1;
                 goto cleanup;
             }
-            ignoreXMP = AVIF_TRUE;
+            settings.ignoreXMP = AVIF_TRUE;
         } else if (!strcmp(arg, "--icc")) {
             NEXTARG();
             if (!readEntireFile(arg, &iccOverride)) {
@@ -733,7 +1220,7 @@
                 returnCode = 1;
                 goto cleanup;
             }
-            ignoreICC = AVIF_TRUE;
+            settings.ignoreICC = AVIF_TRUE;
         } else if (!strcmp(arg, "--duration")) {
             NEXTARG();
             int durationInt = atoi(arg);
@@ -742,7 +1229,7 @@
                 returnCode = 1;
                 goto cleanup;
             }
-            outputTiming.duration = (uint64_t)durationInt;
+            settings.outputTiming.duration = (uint64_t)durationInt;
         } else if (!strcmp(arg, "--timescale") || !strcmp(arg, "--fps")) {
             NEXTARG();
             int timescaleInt = atoi(arg);
@@ -751,16 +1238,16 @@
                 returnCode = 1;
                 goto cleanup;
             }
-            outputTiming.timescale = (uint64_t)timescaleInt;
+            settings.outputTiming.timescale = (uint64_t)timescaleInt;
         } else if (!strcmp(arg, "-c") || !strcmp(arg, "--codec")) {
             NEXTARG();
-            codecChoice = avifCodecChoiceFromName(arg);
-            if (codecChoice == AVIF_CODEC_CHOICE_AUTO) {
+            settings.codecChoice = avifCodecChoiceFromName(arg);
+            if (settings.codecChoice == AVIF_CODEC_CHOICE_AUTO) {
                 fprintf(stderr, "ERROR: Unrecognized codec: %s\n", arg);
                 returnCode = 1;
                 goto cleanup;
             } else {
-                const char * codecName = avifCodecName(codecChoice, AVIF_CODEC_FLAG_CAN_ENCODE);
+                const char * codecName = avifCodecName(settings.codecChoice, AVIF_CODEC_FLAG_CAN_ENCODE);
                 if (codecName == NULL) {
                     fprintf(stderr, "ERROR: AV1 Codec cannot encode: %s\n", arg);
                     returnCode = 1;
@@ -769,41 +1256,29 @@
             }
         } else if (!strcmp(arg, "-a") || !strcmp(arg, "--advanced")) {
             NEXTARG();
-            char * tempBuffer = strdup(arg);
-            char * value = strchr(tempBuffer, '=');
-            if (value) {
-                *value = 0; // remove equals sign,
-                ++value;    // and move past it
-
-            } else {
-                value = ""; // Pass in a non-NULL, empty string. Codecs can use the
-                            // mere existence of a key as a boolean value.
-            }
-            avifResult result = avifEncoderSetCodecSpecificOption(encoder, tempBuffer, value);
-            free(tempBuffer);
-            if (result != AVIF_RESULT_OK) {
-                fprintf(stderr, "ERROR: Failed to set codec specific option: %s\n", arg);
+            if (!avifCodecSpecificOptionsAdd(&settings.codecSpecificOptions, arg)) {
+                fprintf(stderr, "ERROR: Out of memory when setting codec specific option: %s\n", arg);
                 returnCode = 1;
                 goto cleanup;
             }
         } else if (!strcmp(arg, "--ignore-exif")) {
-            ignoreExif = AVIF_TRUE;
+            settings.ignoreExif = AVIF_TRUE;
         } else if (!strcmp(arg, "--ignore-xmp")) {
-            ignoreXMP = AVIF_TRUE;
+            settings.ignoreXMP = AVIF_TRUE;
         } else if (!strcmp(arg, "--ignore-icc")) {
-            ignoreICC = AVIF_TRUE;
+            settings.ignoreICC = AVIF_TRUE;
         } else if (!strcmp(arg, "--pasp")) {
             NEXTARG();
-            paspCount = parseU32List(paspValues, arg);
-            if (paspCount != 2) {
+            settings.paspCount = parseU32List(settings.paspValues, arg);
+            if (settings.paspCount != 2) {
                 fprintf(stderr, "ERROR: Invalid pasp values: %s\n", arg);
                 returnCode = 1;
                 goto cleanup;
             }
         } else if (!strcmp(arg, "--crop")) {
             NEXTARG();
-            clapCount = parseU32List(clapValues, arg);
-            if (clapCount != 4) {
+            settings.clapCount = parseU32List(settings.clapValues, arg);
+            if (settings.clapCount != 4) {
                 fprintf(stderr, "ERROR: Invalid crop values: %s\n", arg);
                 returnCode = 1;
                 goto cleanup;
@@ -811,8 +1286,8 @@
             cropConversionRequired = AVIF_TRUE;
         } else if (!strcmp(arg, "--clap")) {
             NEXTARG();
-            clapCount = parseU32List(clapValues, arg);
-            if (clapCount != 8) {
+            settings.clapCount = parseU32List(settings.clapValues, arg);
+            if (settings.clapCount != 8) {
                 fprintf(stderr, "ERROR: Invalid clap values: %s\n", arg);
                 returnCode = 1;
                 goto cleanup;
@@ -836,10 +1311,10 @@
         } else if (!strcmp(arg, "--repetition-count")) {
             NEXTARG();
             if (!strcmp(arg, "infinite")) {
-                repetitionCount = AVIF_REPETITION_COUNT_INFINITE;
+                settings.repetitionCount = AVIF_REPETITION_COUNT_INFINITE;
             } else {
-                repetitionCount = atoi(arg);
-                if (repetitionCount < 0) {
+                settings.repetitionCount = atoi(arg);
+                if (settings.repetitionCount < 0) {
                     fprintf(stderr, "ERROR: Invalid repetition count: %s\n", arg);
                     returnCode = 1;
                     goto cleanup;
@@ -850,7 +1325,7 @@
         } else if (!strcmp(arg, "-p") || !strcmp(arg, "--premultiply")) {
             premultiplyAlpha = AVIF_TRUE;
         } else if (!strcmp(arg, "--sharpyuv")) {
-            chromaDownsampling = AVIF_CHROMA_DOWNSAMPLING_SHARP_YUV;
+            settings.chromaDownsampling = AVIF_CHROMA_DOWNSAMPLING_SHARP_YUV;
         } else if (arg[0] == '-') {
             fprintf(stderr, "ERROR: unrecognized option %s\n\n", arg);
             syntax();
@@ -859,19 +1334,19 @@
         } else {
             // Positional argument
             input.files[input.filesCount].filename = arg;
-            input.files[input.filesCount].duration = outputTiming.duration;
+            input.files[input.filesCount].duration = settings.outputTiming.duration;
             ++input.filesCount;
         }
 
         ++argIndex;
     }
 
-    if ((minQuantizer < 0) != (maxQuantizer < 0)) {
+    if ((settings.minQuantizer < 0) != (settings.maxQuantizer < 0)) {
         fprintf(stderr, "--min and --max must be either both specified or both unspecified.\n");
         returnCode = 1;
         goto cleanup;
     }
-    if ((minQuantizerAlpha < 0) != (maxQuantizerAlpha < 0)) {
+    if ((settings.minQuantizerAlpha < 0) != (settings.maxQuantizerAlpha < 0)) {
         fprintf(stderr, "--minalpha and --maxalpha must be either both specified or both unspecified.\n");
         returnCode = 1;
         goto cleanup;
@@ -889,20 +1364,20 @@
         // Don't subsample when using AVIF_MATRIX_COEFFICIENTS_IDENTITY.
         input.requestedFormat = AVIF_PIXEL_FORMAT_YUV444;
         // Quality.
-        if ((quality != INVALID_QUALITY && quality != AVIF_QUALITY_LOSSLESS) ||
-            (qualityAlpha != INVALID_QUALITY && qualityAlpha != AVIF_QUALITY_LOSSLESS)) {
+        if ((settings.quality != INVALID_QUALITY && settings.quality != AVIF_QUALITY_LOSSLESS) ||
+            (settings.qualityAlpha != INVALID_QUALITY && settings.qualityAlpha != AVIF_QUALITY_LOSSLESS)) {
             fprintf(stderr, "Quality cannot be set in lossless mode, except to %d.\n", AVIF_QUALITY_LOSSLESS);
             returnCode = 1;
         }
-        quality = qualityAlpha = AVIF_QUALITY_LOSSLESS;
+        settings.quality = settings.qualityAlpha = AVIF_QUALITY_LOSSLESS;
         // Quantizers.
-        if (minQuantizer > 0 || maxQuantizer > 0 || minQuantizerAlpha > 0 || maxQuantizerAlpha > 0) {
+        if (settings.minQuantizer > 0 || settings.maxQuantizer > 0 || settings.minQuantizerAlpha > 0 || settings.maxQuantizerAlpha > 0) {
             fprintf(stderr, "Quantizers cannot be set in lossless mode, except to 0.\n");
             returnCode = 1;
         }
-        minQuantizer = maxQuantizer = minQuantizerAlpha = maxQuantizerAlpha = AVIF_QUANTIZER_LOSSLESS;
+        settings.minQuantizer = settings.maxQuantizer = settings.minQuantizerAlpha = settings.maxQuantizerAlpha = AVIF_QUANTIZER_LOSSLESS;
         // Codec.
-        if (codecChoice != AVIF_CODEC_CHOICE_AUTO && codecChoice != AVIF_CODEC_CHOICE_AOM) {
+        if (settings.codecChoice != AVIF_CODEC_CHOICE_AUTO && settings.codecChoice != AVIF_CODEC_CHOICE_AOM) {
             fprintf(stderr, "Codec can only be AOM in lossless mode.\n");
             returnCode = 1;
         }
@@ -910,54 +1385,54 @@
         // https://github.com/xiph/rav1e/issues/151
         // SVT-AV1 doesn't support lossless encoding yet:
         // https://gitlab.com/AOMediaCodec/SVT-AV1/-/issues/1636
-        codecChoice = AVIF_CODEC_CHOICE_AOM;
+        settings.codecChoice = AVIF_CODEC_CHOICE_AOM;
         // Range.
         if (requestedRange != AVIF_RANGE_FULL) {
             fprintf(stderr, "Range has to be full in lossless mode.\n");
             returnCode = 1;
         }
         // Matrix coefficients.
-        if (cicpExplicitlySet && matrixCoefficients != AVIF_MATRIX_COEFFICIENTS_IDENTITY) {
+        if (cicpExplicitlySet && settings.matrixCoefficients != AVIF_MATRIX_COEFFICIENTS_IDENTITY) {
             fprintf(stderr, "Matrix coefficients have to be identity in lossless mode.\n");
             returnCode = 1;
         }
-        matrixCoefficients = AVIF_MATRIX_COEFFICIENTS_IDENTITY;
+        settings.matrixCoefficients = AVIF_MATRIX_COEFFICIENTS_IDENTITY;
         if (returnCode == 1)
             goto cleanup;
     } else {
         // Set lossy defaults.
-        if (minQuantizer == -1) {
-            assert(maxQuantizer == -1);
-            if (quality == INVALID_QUALITY) {
-                quality = DEFAULT_QUALITY;
+        if (settings.minQuantizer == -1) {
+            assert(settings.maxQuantizer == -1);
+            if (settings.quality == INVALID_QUALITY) {
+                settings.quality = DEFAULT_QUALITY;
             }
-            minQuantizer = AVIF_QUANTIZER_BEST_QUALITY;
-            maxQuantizer = AVIF_QUANTIZER_WORST_QUALITY;
+            settings.minQuantizer = AVIF_QUANTIZER_BEST_QUALITY;
+            settings.maxQuantizer = AVIF_QUANTIZER_WORST_QUALITY;
         } else {
-            assert(maxQuantizer != -1);
-            if (quality == INVALID_QUALITY) {
-                const int quantizer = (minQuantizer + maxQuantizer) / 2;
-                quality = ((63 - quantizer) * 100 + 31) / 63;
+            assert(settings.maxQuantizer != -1);
+            if (settings.quality == INVALID_QUALITY) {
+                const int quantizer = (settings.minQuantizer + settings.maxQuantizer) / 2;
+                settings.quality = ((63 - quantizer) * 100 + 31) / 63;
             }
         }
-        if (minQuantizerAlpha == -1) {
-            assert(maxQuantizerAlpha == -1);
-            if (qualityAlpha == INVALID_QUALITY) {
-                qualityAlpha = DEFAULT_QUALITY_ALPHA;
+        if (settings.minQuantizerAlpha == -1) {
+            assert(settings.maxQuantizerAlpha == -1);
+            if (settings.qualityAlpha == INVALID_QUALITY) {
+                settings.qualityAlpha = DEFAULT_QUALITY_ALPHA;
             }
-            minQuantizerAlpha = AVIF_QUANTIZER_BEST_QUALITY;
-            maxQuantizerAlpha = AVIF_QUANTIZER_WORST_QUALITY;
+            settings.minQuantizerAlpha = AVIF_QUANTIZER_BEST_QUALITY;
+            settings.maxQuantizerAlpha = AVIF_QUANTIZER_WORST_QUALITY;
         } else {
-            assert(maxQuantizerAlpha != -1);
-            if (qualityAlpha == INVALID_QUALITY) {
-                const int quantizerAlpha = (minQuantizerAlpha + maxQuantizerAlpha) / 2;
-                qualityAlpha = ((63 - quantizerAlpha) * 100 + 31) / 63;
+            assert(settings.maxQuantizerAlpha != -1);
+            if (settings.qualityAlpha == INVALID_QUALITY) {
+                const int quantizerAlpha = (settings.minQuantizerAlpha + settings.maxQuantizerAlpha) / 2;
+                settings.qualityAlpha = ((63 - quantizerAlpha) * 100 + 31) / 63;
             }
         }
     }
 
     stdinFile.filename = "(stdin)";
-    stdinFile.duration = outputTiming.duration;
+    stdinFile.duration = settings.outputTiming.duration;
 
     if (!outputFilename) {
         if (((input.useStdin && (input.filesCount == 1)) || (!input.useStdin && (input.filesCount > 1)))) {
@@ -986,9 +1461,9 @@
     }
 
     // Set these in advance so any upcoming RGB -> YUV use the proper coefficients
-    image->colorPrimaries = colorPrimaries;
-    image->transferCharacteristics = transferCharacteristics;
-    image->matrixCoefficients = matrixCoefficients;
+    image->colorPrimaries = settings.colorPrimaries;
+    image->transferCharacteristics = settings.transferCharacteristics;
+    image->matrixCoefficients = settings.matrixCoefficients;
     image->yuvRange = requestedRange;
     image->alphaPremultiplied = premultiplyAlpha;
 
@@ -1006,17 +1481,26 @@
         }
     }
 
-    avifInputFile * firstFile = avifInputGetNextFile(&input);
+    // --target-size requires multiple encodings of the same files. Cache the input images.
+    input.cacheEnabled = (settings.targetSize != -1);
+
+    const avifInputFile * firstFile = avifInputGetFile(&input, /*imageIndex=*/0);
     uint32_t sourceDepth = 0;
+    avifBool sourceWasRGB = AVIF_FALSE;
     avifAppSourceTiming firstSourceTiming;
-    avifAppFileFormat inputFormat =
-        avifInputReadImage(&input, ignoreICC, ignoreExif, ignoreXMP, image, &sourceDepth, &firstSourceTiming, chromaDownsampling);
-    if (inputFormat == AVIF_APP_FILE_FORMAT_UNKNOWN) {
-        fprintf(stderr, "Cannot determine input file format: %s\n", firstFile->filename);
+    if (!avifInputReadImage(&input,
+                            /*imageIndex=*/0,
+                            settings.ignoreICC,
+                            settings.ignoreExif,
+                            settings.ignoreXMP,
+                            image,
+                            &sourceDepth,
+                            &sourceWasRGB,
+                            &firstSourceTiming,
+                            settings.chromaDownsampling)) {
         returnCode = 1;
         goto cleanup;
     }
-    avifBool sourceWasRGB = (inputFormat != AVIF_APP_FILE_FORMAT_Y4M);
 
     // Check again for y4m input (y4m input ignores input.requestedFormat and retains the format in file).
     if ((image->matrixCoefficients == AVIF_MATRIX_COEFFICIENTS_IDENTITY) && (image->yuvFormat != AVIF_PIXEL_FORMAT_YUV444)) {
@@ -1028,17 +1512,17 @@
     printf("Successfully loaded: %s\n", firstFile->filename);
 
     // Prepare image timings
-    if ((outputTiming.duration == 0) && (outputTiming.timescale == 0) && (firstSourceTiming.duration > 0) &&
+    if ((settings.outputTiming.duration == 0) && (settings.outputTiming.timescale == 0) && (firstSourceTiming.duration > 0) &&
         (firstSourceTiming.timescale > 0)) {
         // Set the default duration and timescale to the first image's timing.
-        outputTiming = firstSourceTiming;
+        settings.outputTiming = firstSourceTiming;
     } else {
         // Set output timing defaults to 30 fps
-        if (outputTiming.duration == 0) {
-            outputTiming.duration = 1;
+        if (settings.outputTiming.duration == 0) {
+            settings.outputTiming.duration = 1;
         }
-        if (outputTiming.timescale == 0) {
-            outputTiming.timescale = 30;
+        if (settings.outputTiming.timescale == 0) {
+            settings.outputTiming.timescale = 30;
         }
     }
 
@@ -1061,28 +1545,28 @@
         image->transferCharacteristics = AVIF_TRANSFER_CHARACTERISTICS_SRGB;
     }
 
-    if (paspCount == 2) {
+    if (settings.paspCount == 2) {
         image->transformFlags |= AVIF_TRANSFORM_PASP;
-        image->pasp.hSpacing = paspValues[0];
-        image->pasp.vSpacing = paspValues[1];
+        image->pasp.hSpacing = settings.paspValues[0];
+        image->pasp.vSpacing = settings.paspValues[1];
     }
     if (cropConversionRequired) {
-        if (!convertCropToClap(image->width, image->height, image->yuvFormat, clapValues)) {
+        if (!convertCropToClap(image->width, image->height, image->yuvFormat, settings.clapValues)) {
             returnCode = 1;
             goto cleanup;
         }
-        clapCount = 8;
+        settings.clapCount = 8;
     }
-    if (clapCount == 8) {
+    if (settings.clapCount == 8) {
         image->transformFlags |= AVIF_TRANSFORM_CLAP;
-        image->clap.widthN = clapValues[0];
-        image->clap.widthD = clapValues[1];
-        image->clap.heightN = clapValues[2];
-        image->clap.heightD = clapValues[3];
-        image->clap.horizOffN = clapValues[4];
-        image->clap.horizOffD = clapValues[5];
-        image->clap.vertOffN = clapValues[6];
-        image->clap.vertOffD = clapValues[7];
+        image->clap.widthN = settings.clapValues[0];
+        image->clap.widthD = settings.clapValues[1];
+        image->clap.heightN = settings.clapValues[2];
+        image->clap.heightD = settings.clapValues[3];
+        image->clap.horizOffN = settings.clapValues[4];
+        image->clap.horizOffD = settings.clapValues[5];
+        image->clap.vertOffN = settings.clapValues[6];
+        image->clap.vertOffD = settings.clapValues[7];
 
         // Validate clap
         avifCropRect cropRect;
@@ -1114,13 +1598,13 @@
     }
 
     avifBool usingAOM = AVIF_FALSE;
-    const char * codecName = avifCodecName(codecChoice, AVIF_CODEC_FLAG_CAN_ENCODE);
+    const char * codecName = avifCodecName(settings.codecChoice, AVIF_CODEC_FLAG_CAN_ENCODE);
     if (codecName && !strcmp(codecName, "aom")) {
         usingAOM = AVIF_TRUE;
     }
     avifBool hasAlpha = (image->alphaPlane && image->alphaRowBytes);
-    avifBool usingLosslessColor = (quality == AVIF_QUALITY_LOSSLESS);
-    avifBool usingLosslessAlpha = (qualityAlpha == AVIF_QUALITY_LOSSLESS);
+    avifBool usingLosslessColor = (settings.quality == AVIF_QUALITY_LOSSLESS);
+    avifBool usingLosslessAlpha = (settings.qualityAlpha == AVIF_QUALITY_LOSSLESS);
     avifBool depthMatches = (sourceDepth == image->depth);
     avifBool using400 = (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV400);
     avifBool using444 = (image->yuvFormat == AVIF_PIXEL_FORMAT_YUV444);
@@ -1181,29 +1665,28 @@
         }
     }
 
-    if (gridDimsCount > 0) {
+    if (settings.gridDimsCount > 0) {
         // Grid image!
 
-        gridCellCount = gridDims[0] * gridDims[1];
-        printf("Preparing to encode a %ux%u grid (%u cells)...\n", gridDims[0], gridDims[1], gridCellCount);
+        gridCellCount = settings.gridDims[0] * settings.gridDims[1];
+        printf("Preparing to encode a %ux%u grid (%u cells)...\n", settings.gridDims[0], settings.gridDims[1], gridCellCount);
 
         gridCells = calloc(gridCellCount, sizeof(avifImage *));
         gridCells[0] = image; // take ownership of image
 
-        uint32_t gridCellIndex = 0;
-        avifInputFile * nextFile;
-        while ((nextFile = avifInputGetNextFile(&input)) != NULL) {
-            if (!gridCellIndex) {
+        int imageIndex = 1; // The first grid cell was loaded into image (imageIndex 0).
+        const avifInputFile * nextFile;
+        while ((nextFile = avifInputGetFile(&input, imageIndex)) != NULL) {
+            if (imageIndex == 1) {
                 printf("Loading additional cells for grid image (%u cells)...\n", gridCellCount);
             }
-            ++gridCellIndex;
-            if (gridCellIndex >= gridCellCount) {
+            if (imageIndex >= (int)gridCellCount) {
                 // We have enough, warn and continue
                 fprintf(stderr,
                         "WARNING: [--grid] More than %u images were supplied for this %ux%u grid. The rest will be ignored.\n",
                         gridCellCount,
-                        gridDims[0],
-                        gridDims[1]);
+                        settings.gridDims[0],
+                        settings.gridDims[1]);
                 break;
             }
 
@@ -1218,34 +1701,43 @@
             cellImage->matrixCoefficients = image->matrixCoefficients;
             cellImage->yuvRange = image->yuvRange;
             cellImage->alphaPremultiplied = image->alphaPremultiplied;
-            gridCells[gridCellIndex] = cellImage;
+            gridCells[imageIndex] = cellImage;
 
-            avifAppFileFormat nextInputFormat =
-                avifInputReadImage(&input, ignoreICC, ignoreExif, ignoreXMP, cellImage, NULL, NULL, chromaDownsampling);
-            if (nextInputFormat == AVIF_APP_FILE_FORMAT_UNKNOWN) {
+            // Ignore ICC, Exif and XMP because only the metadata of the first frame is taken into
+            // account by the libavif API.
+            if (!avifInputReadImage(&input,
+                                    imageIndex,
+                                    /*ignoreICC=*/AVIF_TRUE,
+                                    /*ignoreExif=*/AVIF_TRUE,
+                                    /*ignoreXMP=*/AVIF_TRUE,
+                                    cellImage,
+                                    /*outDepth=*/NULL,
+                                    /*sourceIsRGB=*/NULL,
+                                    /*sourceTiming=*/NULL,
+                                    settings.chromaDownsampling)) {
                 returnCode = 1;
                 goto cleanup;
             }
             // Let avifEncoderAddImageGrid() verify the grid integrity (valid cell sizes, depths etc.).
+
+            ++imageIndex;
         }
 
-        if (gridCellIndex == 0) {
+        if (imageIndex == 1) {
             printf("Single image input for a grid image. Attempting to split into %u cells...\n", gridCellCount);
             gridSplitImage = image;
             gridCells[0] = NULL;
 
-            if (!avifImageSplitGrid(gridSplitImage, gridDims[0], gridDims[1], gridCells)) {
+            if (!avifImageSplitGrid(gridSplitImage, settings.gridDims[0], settings.gridDims[1], gridCells)) {
                 returnCode = 1;
                 goto cleanup;
             }
-            gridCellIndex = gridCellCount - 1;
-        }
-
-        if (gridCellIndex != gridCellCount - 1) {
+        } else if (imageIndex != (int)gridCellCount) {
             fprintf(stderr, "ERROR: Not enough input files for grid image! (expecting %u, or a single image to be split)\n", gridCellCount);
             returnCode = 1;
             goto cleanup;
         }
+        // TODO(yguyon): Check if it is possible to use frames from a single input file as grid cells. Maybe forbid it.
     }
 
     const char * lossyHint = " (Lossy)";
@@ -1254,188 +1746,38 @@
     }
     printf("AVIF to be written:%s\n", lossyHint);
     const avifImage * avif = gridCells ? gridCells[0] : image;
-    avifImageDump(avif, gridDims[0], gridDims[1], AVIF_PROGRESSIVE_STATE_UNAVAILABLE);
+    avifImageDump(avif, settings.gridDims[0], settings.gridDims[1], AVIF_PROGRESSIVE_STATE_UNAVAILABLE);
 
-    if (autoTiling) {
-        if ((tileRowsLog2 >= 0) || (tileColsLog2 >= 0)) {
+    if (settings.autoTiling) {
+        if ((settings.tileRowsLog2 >= 0) || (settings.tileColsLog2 >= 0)) {
             fprintf(stderr, "ERROR: --autotiling is specified but --tilerowslog2 or --tilecolslog2 is also specified\n");
             returnCode = 1;
             goto cleanup;
         }
     } else {
-        if (tileRowsLog2 < 0) {
-            tileRowsLog2 = 0;
+        if (settings.tileRowsLog2 < 0) {
+            settings.tileRowsLog2 = 0;
         }
-        if (tileColsLog2 < 0) {
-            tileColsLog2 = 0;
+        if (settings.tileColsLog2 < 0) {
+            settings.tileColsLog2 = 0;
         }
     }
 
-    char manualTilingStr[128];
-    snprintf(manualTilingStr, sizeof(manualTilingStr), "tileRowsLog2 [%d], tileColsLog2 [%d]", tileRowsLog2, tileColsLog2);
-
-    printf("Encoding with AV1 codec '%s' speed [%d], color quality [%d (%s)], alpha quality [%d (%s)], %s, %d worker thread(s), please wait...\n",
-           avifCodecName(codecChoice, AVIF_CODEC_FLAG_CAN_ENCODE),
-           speed,
-           quality,
-           qualityString(quality),
-           qualityAlpha,
-           qualityString(qualityAlpha),
-           autoTiling ? "automatic tiling" : manualTilingStr,
-           jobs);
-    encoder->maxThreads = jobs;
-    encoder->quality = quality;
-    encoder->qualityAlpha = qualityAlpha;
-    encoder->minQuantizer = minQuantizer;
-    encoder->maxQuantizer = maxQuantizer;
-    encoder->minQuantizerAlpha = minQuantizerAlpha;
-    encoder->maxQuantizerAlpha = maxQuantizerAlpha;
-    encoder->tileRowsLog2 = tileRowsLog2;
-    encoder->tileColsLog2 = tileColsLog2;
-    encoder->autoTiling = autoTiling;
-    encoder->codecChoice = codecChoice;
-    encoder->speed = speed;
-    encoder->timescale = outputTiming.timescale;
-    encoder->keyframeInterval = keyframeInterval;
-    encoder->repetitionCount = repetitionCount;
-
-    avifBool isImageSequence = AVIF_FALSE;
-    if (gridDimsCount > 0) {
-        avifResult addImageResult =
-            avifEncoderAddImageGrid(encoder, gridDims[0], gridDims[1], (const avifImage * const *)gridCells, AVIF_ADD_IMAGE_FLAG_SINGLE);
-        if (addImageResult != AVIF_RESULT_OK) {
-            fprintf(stderr, "ERROR: Failed to encode image grid: %s\n", avifResultToString(addImageResult));
-            returnCode = 1;
-            goto cleanup;
-        }
-    } else {
-        avifAddImageFlags addImageFlags = AVIF_ADD_IMAGE_FLAG_NONE;
-        if (!avifInputHasRemainingData(&input)) {
-            addImageFlags |= AVIF_ADD_IMAGE_FLAG_SINGLE;
-        }
-
-        uint64_t firstDurationInTimescales = firstFile->duration ? firstFile->duration : outputTiming.duration;
-        if (input.useStdin || (input.filesCount > 1)) {
-            printf(" * Encoding frame 1 [%" PRIu64 "/%" PRIu64 " ts]: %s\n",
-                   firstDurationInTimescales,
-                   outputTiming.timescale,
-                   firstFile->filename);
-        }
-        avifResult addImageResult = avifEncoderAddImage(encoder, image, firstDurationInTimescales, addImageFlags);
-        if (addImageResult != AVIF_RESULT_OK) {
-            fprintf(stderr, "ERROR: Failed to encode image: %s\n", avifResultToString(addImageResult));
-            returnCode = 1;
-            goto cleanup;
-        }
-
-        // Not generating a single-image grid: Use all remaining input files as subsequent frames.
-
-        avifInputFile * nextFile;
-        int nextImageIndex = -1;
-        while ((nextFile = avifInputGetNextFile(&input)) != NULL) {
-            ++nextImageIndex;
-            isImageSequence = AVIF_TRUE;
-
-            uint64_t nextDurationInTimescales = nextFile->duration ? nextFile->duration : outputTiming.duration;
-
-            printf(" * Encoding frame %d [%" PRIu64 "/%" PRIu64 " ts]: %s\n",
-                   nextImageIndex + 1,
-                   nextDurationInTimescales,
-                   outputTiming.timescale,
-                   nextFile->filename);
-
-            if (nextImage) {
-                avifImageDestroy(nextImage);
-            }
-            nextImage = avifImageCreateEmpty();
-            if (!nextImage) {
-                fprintf(stderr, "ERROR: Out of memory\n");
-                returnCode = 1;
-                goto cleanup;
-            }
-            nextImage->colorPrimaries = image->colorPrimaries;
-            nextImage->transferCharacteristics = image->transferCharacteristics;
-            nextImage->matrixCoefficients = image->matrixCoefficients;
-            nextImage->yuvRange = image->yuvRange;
-            nextImage->alphaPremultiplied = image->alphaPremultiplied;
-
-            avifAppFileFormat nextInputFormat =
-                avifInputReadImage(&input, ignoreICC, ignoreExif, ignoreXMP, nextImage, NULL, NULL, chromaDownsampling);
-            if (nextInputFormat == AVIF_APP_FILE_FORMAT_UNKNOWN) {
-                returnCode = 1;
-                goto cleanup;
-            }
-
-            // Verify that this frame's properties matches the first frame's properties
-            if ((image->width != nextImage->width) || (image->height != nextImage->height)) {
-                fprintf(stderr,
-                        "ERROR: Image sequence dimensions mismatch, [%ux%u] vs [%ux%u]: %s\n",
-                        image->width,
-                        image->height,
-                        nextImage->width,
-                        nextImage->height,
-                        nextFile->filename);
-                returnCode = 1;
-                goto cleanup;
-            }
-            if (image->depth != nextImage->depth) {
-                fprintf(stderr,
-                        "ERROR: Image sequence depth mismatch, [%u] vs [%u]: %s\n",
-                        image->depth,
-                        nextImage->depth,
-                        nextFile->filename);
-                returnCode = 1;
-                goto cleanup;
-            }
-            if ((image->colorPrimaries != nextImage->colorPrimaries) ||
-                (image->transferCharacteristics != nextImage->transferCharacteristics) ||
-                (image->matrixCoefficients != nextImage->matrixCoefficients)) {
-                fprintf(stderr,
-                        "ERROR: Image sequence CICP mismatch, [%u/%u/%u] vs [%u/%u/%u]: %s\n",
-                        image->colorPrimaries,
-                        image->matrixCoefficients,
-                        image->transferCharacteristics,
-                        nextImage->colorPrimaries,
-                        nextImage->transferCharacteristics,
-                        nextImage->matrixCoefficients,
-                        nextFile->filename);
-                returnCode = 1;
-                goto cleanup;
-            }
-            if (image->yuvRange != nextImage->yuvRange) {
-                fprintf(stderr,
-                        "ERROR: Image sequence range mismatch, [%s] vs [%s]: %s\n",
-                        (image->yuvRange == AVIF_RANGE_FULL) ? "Full" : "Limited",
-                        (nextImage->yuvRange == AVIF_RANGE_FULL) ? "Full" : "Limited",
-                        nextFile->filename);
-                returnCode = 1;
-                goto cleanup;
-            }
-
-            avifResult nextImageResult = avifEncoderAddImage(encoder, nextImage, nextDurationInTimescales, AVIF_ADD_IMAGE_FLAG_NONE);
-            if (nextImageResult != AVIF_RESULT_OK) {
-                fprintf(stderr, "ERROR: Failed to encode image: %s\n", avifResultToString(nextImageResult));
-                returnCode = 1;
-                goto cleanup;
-            }
-        }
-    }
-
-    avifResult finishResult = avifEncoderFinish(encoder, &raw);
-    if (finishResult != AVIF_RESULT_OK) {
-        fprintf(stderr, "ERROR: Failed to finish encoding: %s\n", avifResultToString(finishResult));
+    avifIOStats ioStats = { 0, 0 };
+    if (!avifEncodeImages(&settings, &input, firstFile, image, (const avifImage * const *)gridCells, &raw, &ioStats)) {
         returnCode = 1;
         goto cleanup;
     }
 
     printf("Encoded successfully.\n");
-    printf(" * Color AV1 total size: %" AVIF_FMT_ZU " bytes\n", encoder->ioStats.colorOBUSize);
-    printf(" * Alpha AV1 total size: %" AVIF_FMT_ZU " bytes\n", encoder->ioStats.alphaOBUSize);
+    printf(" * Color AV1 total size: %" AVIF_FMT_ZU " bytes\n", ioStats.colorOBUSize);
+    printf(" * Alpha AV1 total size: %" AVIF_FMT_ZU " bytes\n", ioStats.alphaOBUSize);
+    const avifBool isImageSequence = (settings.gridDimsCount == 0) && (input.filesCount > 1);
     if (isImageSequence) {
-        if (encoder->repetitionCount == AVIF_REPETITION_COUNT_INFINITE) {
+        if (settings.repetitionCount == AVIF_REPETITION_COUNT_INFINITE) {
             printf(" * Repetition Count: Infinite\n");
         } else {
-            printf(" * Repetition Count: %d\n", encoder->repetitionCount);
+            printf(" * Repetition Count: %d\n", settings.repetitionCount);
         }
     }
     FILE * f = fopen(outputFilename, "wb");
@@ -1453,12 +1795,6 @@
     fclose(f);
 
 cleanup:
-    if (encoder) {
-        if (returnCode != 0) {
-            avifDumpDiagnostics(&encoder->diag);
-        }
-        avifEncoderDestroy(encoder);
-    }
     if (gridCells) {
         for (uint32_t i = 0; i < gridCellCount; ++i) {
             if (gridCells[i]) {
@@ -1472,13 +1808,24 @@
     if (gridSplitImage) {
         avifImageDestroy(gridSplitImage);
     }
-    if (nextImage) {
-        avifImageDestroy(nextImage);
-    }
     avifRWDataFree(&raw);
     avifRWDataFree(&exifOverride);
     avifRWDataFree(&xmpOverride);
     avifRWDataFree(&iccOverride);
-    free((void *)input.files);
+    while (input.cacheCount) {
+        --input.cacheCount;
+        if (input.cache[input.cacheCount].image) {
+            avifImageDestroy(input.cache[input.cacheCount].image);
+        }
+    }
+    free(input.cache);
+    free(input.files);
+    while (settings.codecSpecificOptions.count) {
+        --settings.codecSpecificOptions.count;
+        free(settings.codecSpecificOptions.keys[settings.codecSpecificOptions.count]);
+        free(settings.codecSpecificOptions.values[settings.codecSpecificOptions.count]);
+    }
+    free(settings.codecSpecificOptions.keys);
+    free(settings.codecSpecificOptions.values);
     return returnCode;
 }
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 5e4f459..52f3259 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -189,6 +189,9 @@
     add_test(NAME test_cmd_metadata COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/test_cmd_metadata.sh ${CMAKE_BINARY_DIR}
                                             ${CMAKE_CURRENT_SOURCE_DIR}/data
     )
+    add_test(NAME test_cmd_targetsize COMMAND bash ${CMAKE_CURRENT_SOURCE_DIR}/test_cmd_targetsize.sh ${CMAKE_BINARY_DIR}
+                                              ${CMAKE_CURRENT_SOURCE_DIR}/data
+    )
 
     if(NOT AVIF_CODEC_AOM OR NOT AVIF_CODEC_AOM_ENCODE)
         # Only aom encoder supports lossless encoding.
diff --git a/tests/test_cmd_targetsize.sh b/tests/test_cmd_targetsize.sh
new file mode 100644
index 0000000..010cdc2
--- /dev/null
+++ b/tests/test_cmd_targetsize.sh
@@ -0,0 +1,125 @@
+#!/bin/bash
+# Copyright 2023 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ------------------------------------------------------------------------------
+#
+# tests for command lines (--target-size)
+
+set -ex
+
+if [[ "$#" -ge 1 ]]; then
+  # eval so that the passed in directory can contain variables.
+  BINARY_DIR="$(eval echo "$1")"
+else
+  # Assume "tests" is the current directory.
+  BINARY_DIR="$(pwd)/.."
+fi
+if [[ "$#" -ge 2 ]]; then
+  TESTDATA_DIR="$(eval echo "$2")"
+else
+  TESTDATA_DIR="$(pwd)/data"
+fi
+if [[ "$#" -ge 3 ]]; then
+  TMP_DIR="$(eval echo "$3")"
+else
+  TMP_DIR="$(mktemp -d)"
+fi
+
+AVIFENC="${BINARY_DIR}/avifenc"
+AVIFDEC="${BINARY_DIR}/avifdec"
+
+# Input file paths.
+INPUT_Y4M="${TESTDATA_DIR}/kodim03_yuv420_8bpc.y4m"
+# Output file names.
+ENCODED_FILE="avif_test_cmd_targetsize_encoded.avif"
+DECODED_SMALLEST_FILE="avif_test_cmd_targetsize_decoded_smallest.png"
+DECODED_BIGGEST_FILE="avif_test_cmd_targetsize_decoded_biggest.png"
+
+# Cleanup
+cleanup() {
+  pushd ${TMP_DIR}
+    rm -- "${ENCODED_FILE}" "${DECODED_SMALLEST_FILE}" "${DECODED_BIGGEST_FILE}"
+  popd
+}
+trap cleanup EXIT
+
+pushd ${TMP_DIR}
+  "${AVIFENC}" -s 8 "${INPUT_Y4M}" -o "${ENCODED_FILE}"
+  DEFAULT_QUALITY_FILE_SIZE=$(wc -c < "${ENCODED_FILE}")
+
+  "${AVIFENC}" -s 8 "${INPUT_Y4M}" -o "${ENCODED_FILE}" --target-size 0
+  "${AVIFDEC}" "${ENCODED_FILE}" "${DECODED_SMALLEST_FILE}"
+  SMALLEST_FILE_SIZE=$(wc -c < "${ENCODED_FILE}")
+
+  "${AVIFENC}" -s 8 "${INPUT_Y4M}" -o "${ENCODED_FILE}" --target-size 999999999
+  "${AVIFDEC}" "${ENCODED_FILE}" "${DECODED_BIGGEST_FILE}"
+  BIGGEST_FILE_SIZE=$(wc -c < "${ENCODED_FILE}")
+
+  [[ ${SMALLEST_FILE_SIZE} -lt ${DEFAULT_QUALITY_FILE_SIZE} ]] || exit 1
+  [[ ${DEFAULT_QUALITY_FILE_SIZE} -lt ${BIGGEST_FILE_SIZE} ]] || exit 1
+
+  # Check that min/max file sizes match lowest/highest qualities.
+  "${AVIFENC}" -s 8 "${INPUT_Y4M}" -o "${ENCODED_FILE}" -q 0
+  [[ $(wc -c < "${ENCODED_FILE}") -eq ${SMALLEST_FILE_SIZE} ]] || exit 1
+  "${AVIFENC}" -s 8 "${INPUT_Y4M}" -o "${ENCODED_FILE}" -q 100
+  [[ $(wc -c < "${ENCODED_FILE}") -eq ${BIGGEST_FILE_SIZE} ]] || exit 1
+  # Negative test.
+  [[ $(wc -c < "${ENCODED_FILE}") -eq ${SMALLEST_FILE_SIZE} ]] && exit 1
+
+  # Same as above but with a grid made of two tiles.
+  TILE0="${DECODED_SMALLEST_FILE}"
+  TILE1="${DECODED_BIGGEST_FILE}"
+
+  "${AVIFENC}" -s 9 --grid 2x1 "${TILE0}" "${TILE1}" -o "${ENCODED_FILE}"
+  DEFAULT_QUALITY_FILE_SIZE=$(wc -c < "${ENCODED_FILE}")
+
+  "${AVIFENC}" -s 9 --grid 2x1 "${TILE0}" "${TILE1}" -o "${ENCODED_FILE}" --target-size 0
+  SMALLEST_FILE_SIZE=$(wc -c < "${ENCODED_FILE}")
+
+  "${AVIFENC}" -s 9 --grid 2x1 "${TILE0}" "${TILE1}" -o "${ENCODED_FILE}" --target-size 999999999
+  BIGGEST_FILE_SIZE=$(wc -c < "${ENCODED_FILE}")
+
+  [[ ${SMALLEST_FILE_SIZE} -lt ${DEFAULT_QUALITY_FILE_SIZE} ]] || exit 1
+  [[ ${DEFAULT_QUALITY_FILE_SIZE} -lt ${BIGGEST_FILE_SIZE} ]] || exit 1
+
+  # The remaining tests in this file use animations that may trigger segmentation faults
+  # with libaom versions older than 3.6.0. Skip the tests if that is the case.
+  # TODO(yguyon): Investigate.
+  # The grep and cut commands are not pretty but seem to work on most platforms.
+  AOM_VERSION=$("${AVIFENC}" -V | grep -o "aom.*[0-9]*\.")        # "aom [enc/dec]:X.Y."
+  AOM_VERSION=$(echo "${AOM_VERSION}" | cut -d ":" -f 2)          # "X.Y" maybe prepended by a 'v'
+  AOM_VERSION=$(echo "${AOM_VERSION}" | grep -o "[0-9]*\.[0-9]*") # "X.Y"
+  AOM_MAJOR_VERSION=$(echo "${AOM_VERSION}" | cut -d "." -f 1)
+  AOM_MINOR_VERSION=$(echo "${AOM_VERSION}" | cut -d "." -f 2)
+  [[ ${AOM_MAJOR_VERSION} -ge 3 ]] || exit 0 # older than 3.0.0
+  [[ ${AOM_MAJOR_VERSION} -ge 4 ]] || [[ ${AOM_MINOR_VERSION} -ge 6 ]] || exit 0 # older than 3.5.0
+
+  # Same as above but with an animation made of two frames.
+  FRAME0="${DECODED_SMALLEST_FILE}"
+  FRAME1="${DECODED_BIGGEST_FILE}"
+
+  "${AVIFENC}" -s 9 "${FRAME0}" "${FRAME1}" -o "${ENCODED_FILE}"
+  DEFAULT_QUALITY_FILE_SIZE=$(wc -c < "${ENCODED_FILE}")
+
+  "${AVIFENC}" -s 9 "${FRAME0}" "${FRAME1}" -o "${ENCODED_FILE}" --target-size 0
+  SMALLEST_FILE_SIZE=$(wc -c < "${ENCODED_FILE}")
+
+  "${AVIFENC}" -s 9 "${FRAME0}" "${FRAME1}" -o "${ENCODED_FILE}" --target-size 999999999
+  BIGGEST_FILE_SIZE=$(wc -c < "${ENCODED_FILE}")
+
+  [[ ${SMALLEST_FILE_SIZE} -lt ${DEFAULT_QUALITY_FILE_SIZE} ]] || exit 1
+  [[ ${DEFAULT_QUALITY_FILE_SIZE} -lt ${BIGGEST_FILE_SIZE} ]] || exit 1
+popd
+
+exit 0