diff --git a/CHANGELOG.md b/CHANGELOG.md
index f10b3e9..59ba49c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,7 +8,8 @@
 
 There are incompatible ABI changes in this release. The clli member was added
 to the avifImage struct. The repetitionCount member was added to the avifEncoder
-and avifDecoder structs.
+and avifDecoder structs. The quality and qualityAlpha members were added to the
+avifEncoder struct.
 
 ### Added
 * Add STATIC library target avif_internal to allow tests to access functions
@@ -16,6 +17,11 @@
 * Add clli metadata read and write support
 * Add repetitionCount member to avifEncoder and avifDecoder structs to specify
   the number of repetitions for animated image sequences.
+* Add quality and qualityAlpha to avifEncoder. Note: minQuantizer,
+  maxQuantizer, minQuantizerAlpha, and maxQuantizerAlpha are deprecated. Code
+  should be updated to set quality (and qualityAlpha if applicable) and leave
+  minQuantizer, maxQuantizer, minQuantizerAlpha, and maxQuantizerAlpha
+  initialized to the default values.
 
 ### Changed
 * Exif and XMP metadata is exported to PNG and JPEG files by default,
@@ -26,6 +32,12 @@
 * Update svt.cmd/svt.sh: v1.3.0
 * avifImageCopy() no longer accepts source U and V channels to be NULL for
   non-4:0:0 input if Y is not NULL and if AVIF_PLANES_YUV is specified.
+* The default values of the maxQuantizer and maxQuantizerAlpha members of
+  avifEncoder changed from AVIF_QUANTIZER_LOSSLESS (0) to
+  AVIF_QUANTIZER_WORST_QUALITY (63). The behavior changed if minQuantizer and
+  maxQuantizer are left initialized to the default values. Code should be
+  updated to set the quality member. Similarly for the alpha quantizers and
+  qualityAlpha.
 
 ## [0.11.1] - 2022-10-19
 
diff --git a/apps/avifenc.c b/apps/avifenc.c
index d9c2d8e..339293c 100644
--- a/apps/avifenc.c
+++ b/apps/avifenc.c
@@ -66,22 +66,14 @@
     printf("                                        M = matrix coefficients\n");
     printf("                                        (use 2 for any you wish to leave unspecified)\n");
     printf("    -r,--range RANGE                  : YUV range [limited or l, full or f]. (JPEG/PNG only, default: full; For y4m or stdin, range is retained)\n");
-    printf("    --min Q                           : Set min quantizer for color (%d-%d, where %d is lossless)\n",
-           AVIF_QUANTIZER_BEST_QUALITY,
-           AVIF_QUANTIZER_WORST_QUALITY,
-           AVIF_QUANTIZER_LOSSLESS);
-    printf("    --max Q                           : Set max quantizer for color (%d-%d, where %d is lossless)\n",
-           AVIF_QUANTIZER_BEST_QUALITY,
-           AVIF_QUANTIZER_WORST_QUALITY,
-           AVIF_QUANTIZER_LOSSLESS);
-    printf("    --minalpha Q                      : Set min quantizer for alpha (%d-%d, where %d is lossless)\n",
-           AVIF_QUANTIZER_BEST_QUALITY,
-           AVIF_QUANTIZER_WORST_QUALITY,
-           AVIF_QUANTIZER_LOSSLESS);
-    printf("    --maxalpha Q                      : Set max quantizer for alpha (%d-%d, where %d is lossless)\n",
-           AVIF_QUANTIZER_BEST_QUALITY,
-           AVIF_QUANTIZER_WORST_QUALITY,
-           AVIF_QUANTIZER_LOSSLESS);
+    printf("    -q,--qcolor Q                     : Set quality for color (%d-%d, where %d is lossless)\n",
+           AVIF_QUALITY_WORST,
+           AVIF_QUALITY_BEST,
+           AVIF_QUALITY_LOSSLESS);
+    printf("    --qalpha Q                        : Set quality for alpha (%d-%d, where %d is lossless)\n",
+           AVIF_QUALITY_WORST,
+           AVIF_QUALITY_BEST,
+           AVIF_QUALITY_LOSSLESS);
     printf("    --tilerowslog2 R                  : Set log2 of number of tile rows (0-6, default: 0)\n");
     printf("    --tilecolslog2 C                  : Set log2 of number of tile columns (0-6, default: 0)\n");
     printf("    --autotiling                      : Set --tilerowslog2 and --tilecolslog2 automatically\n");
@@ -109,6 +101,22 @@
     printf("    --irot ANGLE                      : Add irot property (rotation). [0-3], makes (90 * ANGLE) degree rotation anti-clockwise\n");
     printf("    --imir MODE                       : Add imir property (mirroring). 0=top-to-bottom, 1=left-to-right\n");
     printf("    --repetition-count N or infinite  : Number of times an animated image sequence will be repeated. Use 'infinite' for infinite repetitions (Default: infinite)\n");
+    printf("    --min QP                          : Set min quantizer for color (%d-%d, where %d is lossless)\n",
+           AVIF_QUANTIZER_BEST_QUALITY,
+           AVIF_QUANTIZER_WORST_QUALITY,
+           AVIF_QUANTIZER_LOSSLESS);
+    printf("    --max QP                          : Set max quantizer for color (%d-%d, where %d is lossless)\n",
+           AVIF_QUANTIZER_BEST_QUALITY,
+           AVIF_QUANTIZER_WORST_QUALITY,
+           AVIF_QUANTIZER_LOSSLESS);
+    printf("    --minalpha QP                     : Set min quantizer for alpha (%d-%d, where %d is lossless)\n",
+           AVIF_QUANTIZER_BEST_QUALITY,
+           AVIF_QUANTIZER_WORST_QUALITY,
+           AVIF_QUANTIZER_LOSSLESS);
+    printf("    --maxalpha QP                     : Set max quantizer for alpha (%d-%d, where %d is lossless)\n",
+           AVIF_QUANTIZER_BEST_QUALITY,
+           AVIF_QUANTIZER_WORST_QUALITY,
+           AVIF_QUANTIZER_LOSSLESS);
     printf("    --                                : Signals the end of options. Everything after this is interpreted as file names.\n");
     printf("\n");
     if (avifCodecName(AVIF_CODEC_CHOICE_AOM, 0)) {
@@ -137,18 +145,18 @@
 }
 
 // This is *very* arbitrary, I just want to set people's expectations a bit
-static const char * quantizerString(int quantizer)
+static const char * qualityString(int quality)
 {
-    if (quantizer == 0) {
+    if (quality == AVIF_QUALITY_LOSSLESS) {
         return "Lossless";
     }
-    if (quantizer <= 12) {
+    if (quality >= 80) {
         return "High";
     }
-    if (quantizer <= 32) {
+    if (quality >= 50) {
         return "Medium";
     }
-    if (quantizer == AVIF_QUANTIZER_WORST_QUALITY) {
+    if (quality == AVIF_QUALITY_WORST) {
         return "Worst";
     }
     return "Low";
@@ -428,6 +436,10 @@
     return AVIF_TRUE;
 }
 
+#define INVALID_QUALITY -1
+#define DEFAULT_QUALITY 60 // Maps to a quantizer (QP) of 25.
+#define DEFAULT_QUALITY_ALPHA AVIF_QUALITY_LOSSLESS
+
 int main(int argc, char * argv[])
 {
     if (argc < 2) {
@@ -447,6 +459,8 @@
 
     int returnCode = 0;
     int jobs = 1;
+    int quality = INVALID_QUALITY;
+    int qualityAlpha = INVALID_QUALITY;
     int minQuantizer = -1;
     int maxQuantizer = -1;
     int minQuantizerAlpha = -1;
@@ -564,6 +578,24 @@
         } else if (!strcmp(arg, "-k") || !strcmp(arg, "--keyframe")) {
             NEXTARG();
             keyframeInterval = atoi(arg);
+        } else if (!strcmp(arg, "-q") || !strcmp(arg, "--qcolor")) {
+            NEXTARG();
+            quality = atoi(arg);
+            if (quality < AVIF_QUALITY_WORST) {
+                quality = AVIF_QUALITY_WORST;
+            }
+            if (quality > AVIF_QUALITY_BEST) {
+                quality = AVIF_QUALITY_BEST;
+            }
+        } else if (!strcmp(arg, "--qalpha")) {
+            NEXTARG();
+            qualityAlpha = atoi(arg);
+            if (qualityAlpha < AVIF_QUALITY_WORST) {
+                qualityAlpha = AVIF_QUALITY_WORST;
+            }
+            if (qualityAlpha > AVIF_QUALITY_BEST) {
+                qualityAlpha = AVIF_QUALITY_BEST;
+            }
         } else if (!strcmp(arg, "--min")) {
             NEXTARG();
             minQuantizer = atoi(arg);
@@ -841,6 +873,13 @@
         }
         // 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)) {
+            fprintf(stderr, "Quality cannot be set in lossless mode, except to %d.\n", AVIF_QUALITY_LOSSLESS);
+            returnCode = 1;
+        }
+        quality = qualityAlpha = AVIF_QUALITY_LOSSLESS;
         // Quantizers.
         if (minQuantizer > 0 || maxQuantizer > 0 || minQuantizerAlpha > 0 || maxQuantizerAlpha > 0) {
             fprintf(stderr, "Quantizers cannot be set in lossless mode, except to 0.\n");
@@ -873,16 +912,32 @@
     } else {
         // Set lossy defaults.
         if (minQuantizer == -1) {
-            minQuantizer = 24;
-        }
-        if (maxQuantizer == -1) {
-            maxQuantizer = 26;
+            assert(maxQuantizer == -1);
+            if (quality == INVALID_QUALITY) {
+                quality = DEFAULT_QUALITY;
+            }
+            minQuantizer = AVIF_QUANTIZER_BEST_QUALITY;
+            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;
+            }
         }
         if (minQuantizerAlpha == -1) {
-            minQuantizerAlpha = AVIF_QUANTIZER_LOSSLESS;
-        }
-        if (maxQuantizerAlpha == -1) {
-            maxQuantizerAlpha = AVIF_QUANTIZER_LOSSLESS;
+            assert(maxQuantizerAlpha == -1);
+            if (qualityAlpha == INVALID_QUALITY) {
+                qualityAlpha = DEFAULT_QUALITY_ALPHA;
+            }
+            minQuantizerAlpha = AVIF_QUANTIZER_BEST_QUALITY;
+            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;
+            }
         }
     }
 
@@ -1044,8 +1099,8 @@
         usingAOM = AVIF_TRUE;
     }
     avifBool hasAlpha = (image->alphaPlane && image->alphaRowBytes);
-    avifBool losslessColorQP = (minQuantizer == AVIF_QUANTIZER_LOSSLESS) && (maxQuantizer == AVIF_QUANTIZER_LOSSLESS);
-    avifBool losslessAlphaQP = (minQuantizerAlpha == AVIF_QUANTIZER_LOSSLESS) && (maxQuantizerAlpha == AVIF_QUANTIZER_LOSSLESS);
+    avifBool usingLosslessColor = (quality == AVIF_QUALITY_LOSSLESS);
+    avifBool usingLosslessAlpha = (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);
@@ -1053,9 +1108,9 @@
     avifBool usingIdentityMatrix = (image->matrixCoefficients == AVIF_MATRIX_COEFFICIENTS_IDENTITY);
 
     // Guess if the enduser is asking for lossless and enable it so that warnings can be emitted
-    if (!lossless && losslessColorQP && (!hasAlpha || losslessAlphaQP)) {
+    if (!lossless && usingLosslessColor && (!hasAlpha || usingLosslessAlpha)) {
         // The enduser is probably expecting lossless. Turn it on and emit warnings
-        printf("Min/max QPs set to %d, assuming --lossless to enable warnings on potential lossless issues.\n", AVIF_QUANTIZER_LOSSLESS);
+        printf("Quality set to %d, assuming --lossless to enable warnings on potential lossless issues.\n", AVIF_QUALITY_LOSSLESS);
         lossless = AVIF_TRUE;
     }
 
@@ -1066,17 +1121,17 @@
             lossless = AVIF_FALSE;
         }
 
-        if (!losslessColorQP) {
+        if (!usingLosslessColor) {
             fprintf(stderr,
-                    "WARNING: [--lossless] Color quantizer range (--min, --max) not set to %d. Color output might not be lossless.\n",
-                    AVIF_QUANTIZER_LOSSLESS);
+                    "WARNING: [--lossless] Color quality (-q or --qcolor) not set to %d. Color output might not be lossless.\n",
+                    AVIF_QUALITY_LOSSLESS);
             lossless = AVIF_FALSE;
         }
 
-        if (hasAlpha && !losslessAlphaQP) {
+        if (hasAlpha && !usingLosslessAlpha) {
             fprintf(stderr,
-                    "WARNING: [--lossless] Alpha present and alpha quantizer range (--minalpha, --maxalpha) not set to %d. Alpha output might not be lossless.\n",
-                    AVIF_QUANTIZER_LOSSLESS);
+                    "WARNING: [--lossless] Alpha present and alpha quality (--qalpha) not set to %d. Alpha output might not be lossless.\n",
+                    AVIF_QUALITY_LOSSLESS);
             lossless = AVIF_FALSE;
         }
 
@@ -1194,20 +1249,18 @@
     char manualTilingStr[128];
     snprintf(manualTilingStr, sizeof(manualTilingStr), "tileRowsLog2 [%d], tileColsLog2 [%d]", tileRowsLog2, tileColsLog2);
 
-    printf("Encoding with AV1 codec '%s' speed [%d], color QP [%d (%s) <-> %d (%s)], alpha QP [%d (%s) <-> %d (%s)], %s, %d worker thread(s), please wait...\n",
+    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,
-           minQuantizer,
-           quantizerString(minQuantizer),
-           maxQuantizer,
-           quantizerString(maxQuantizer),
-           minQuantizerAlpha,
-           quantizerString(minQuantizerAlpha),
-           maxQuantizerAlpha,
-           quantizerString(maxQuantizerAlpha),
+           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;
diff --git a/examples/avif_example_encode.c b/examples/avif_example_encode.c
index 34b6cdc..0480ba4 100644
--- a/examples/avif_example_encode.c
+++ b/examples/avif_example_encode.c
@@ -77,15 +77,15 @@
     encoder = avifEncoderCreate();
     // Configure your encoder here (see avif/avif.h):
     // * maxThreads
-    // * minQuantizer
-    // * maxQuantizer
-    // * minQuantizerAlpha
-    // * maxQuantizerAlpha
+    // * quality
+    // * qualityAlpha
     // * tileRowsLog2
     // * tileColsLog2
     // * speed
     // * keyframeInterval
     // * timescale
+    encoder->quality = 60;
+    encoder->qualityAlpha = AVIF_QUALITY_LOSSLESS;
 
     // Call avifEncoderAddImage() for each image in your sequence
     // Only set AVIF_ADD_IMAGE_FLAG_SINGLE if you're not encoding a sequence
diff --git a/include/avif/avif.h b/include/avif/avif.h
index b91a9fa..d778fa4 100644
--- a/include/avif/avif.h
+++ b/include/avif/avif.h
@@ -78,6 +78,11 @@
 // a 12 hour AVIF image sequence, running at 60 fps (a basic sanity check as this is quite ridiculous)
 #define AVIF_DEFAULT_IMAGE_COUNT_LIMIT (12 * 3600 * 60)
 
+#define AVIF_QUALITY_DEFAULT -1
+#define AVIF_QUALITY_LOSSLESS 100
+#define AVIF_QUALITY_WORST 0
+#define AVIF_QUALITY_BEST 100
+
 #define AVIF_QUANTIZER_LOSSLESS 0
 #define AVIF_QUANTIZER_BEST_QUALITY 0
 #define AVIF_QUANTIZER_WORST_QUALITY 63
@@ -1066,7 +1071,14 @@
 // * If avifEncoderWrite() returns AVIF_RESULT_OK, output must be freed with avifRWDataFree()
 // * If (maxThreads < 2), multithreading is disabled
 //   * NOTE: Please see the "Understanding maxThreads" comment block above
-// * Quality range: [AVIF_QUANTIZER_BEST_QUALITY - AVIF_QUANTIZER_WORST_QUALITY]
+// * Quality range: [AVIF_QUALITY_WORST - AVIF_QUALITY_BEST]
+// * Quantizer range: [AVIF_QUANTIZER_BEST_QUALITY - AVIF_QUANTIZER_WORST_QUALITY]
+// * In older versions of libavif, the avifEncoder struct doesn't have the quality and qualityAlpha
+//   fields. For backward compatibility, if the quality field is not set, the default value of
+//   quality is based on the average of minQuantizer and maxQuantizer. Similarly the default value
+//   of qualityAlpha is based on the average of minQuantizerAlpha and maxQuantizerAlpha. New code
+//   should set quality and qualityAlpha and leave minQuantizer, maxQuantizer, minQuantizerAlpha,
+//   and maxQuantizerAlpha initialized to their default values.
 // * To enable tiling, set tileRowsLog2 > 0 and/or tileColsLog2 > 0.
 //   Tiling values range [0-6], where the value indicates a request for 2^n tiles in that dimension.
 //   If autoTiling is set to AVIF_TRUE, libavif ignores tileRowsLog2 and tileColsLog2 and
@@ -1093,6 +1105,8 @@
                           // played back `n + 1` times. Defaults to AVIF_REPETITION_COUNT_INFINITE.
 
     // changeable encoder settings
+    int quality;
+    int qualityAlpha;
     int minQuantizer;
     int maxQuantizer;
     int minQuantizerAlpha;
diff --git a/include/avif/internal.h b/include/avif/internal.h
index 6b89827..84974b0 100644
--- a/include/avif/internal.h
+++ b/include/avif/internal.h
@@ -289,6 +289,8 @@
     AVIF_ENCODER_CHANGE_MAX_QUANTIZER_ALPHA = (1u << 3),
     AVIF_ENCODER_CHANGE_TILE_ROWS_LOG2 = (1u << 4),
     AVIF_ENCODER_CHANGE_TILE_COLS_LOG2 = (1u << 5),
+    AVIF_ENCODER_CHANGE_QUANTIZER = (1u << 6),
+    AVIF_ENCODER_CHANGE_QUANTIZER_ALPHA = (1u << 7),
 
     AVIF_ENCODER_CHANGE_CODEC_SPECIFIC = (1u << 31)
 } avifEncoderChange;
@@ -308,6 +310,8 @@
 // encoder->tileRowsLog2, encoder->tileColsLog2, and encoder->autoTiling. The caller of
 // avifCodecEncodeImageFunc is responsible for automatic tiling if encoder->autoTiling is set to
 // AVIF_TRUE. The actual tiling values are passed to avifCodecEncodeImageFunc as parameters.
+// Similarly, avifCodecEncodeImageFunc should use the quantizer parameter instead of
+// encoder->quality and encoder->qualityAlpha.
 //
 // Note: The caller of avifCodecEncodeImageFunc always passes encoder->data->tileRowsLog2 and
 // encoder->data->tileColsLog2 as the tileRowsLog2 and tileColsLog2 arguments. Because
@@ -320,6 +324,7 @@
                                                avifBool alpha,
                                                int tileRowsLog2,
                                                int tileColsLog2,
+                                               int quantizer,
                                                avifEncoderChanges encoderChanges,
                                                avifAddImageFlags addImageFlags,
                                                avifCodecEncodeOutput * output);
diff --git a/src/codec_aom.c b/src/codec_aom.c
index c833082..586f1e5 100644
--- a/src/codec_aom.c
+++ b/src/codec_aom.c
@@ -64,12 +64,6 @@
     avifPixelFormatInfo formatInfo;
     aom_img_fmt_t aomFormat;
     avifBool monochromeEnabled;
-    // Whether cfg.rc_end_usage was set with an
-    // avifEncoderSetCodecSpecificOption(encoder, "end-usage", value) call.
-    avifBool endUsageSet;
-    // Whether cq-level was set with an
-    // avifEncoderSetCodecSpecificOption(encoder, "cq-level", value) call.
-    avifBool cqLevelSet;
     // Whether 'tuning' (of the specified distortion metric) was set with an
     // avifEncoderSetCodecSpecificOption(encoder, "tune", value) call.
     avifBool tuningSet;
@@ -376,7 +370,6 @@
                 return AVIF_FALSE;
             }
             cfg->rc_end_usage = val;
-            codec->internal->endUsageSet = AVIF_TRUE;
         }
     }
     return AVIF_TRUE;
@@ -466,9 +459,7 @@
                                   aom_codec_error_detail(&codec->internal->encoder));
             return AVIF_FALSE;
         }
-        if (!strcmp(key, "cq-level")) {
-            codec->internal->cqLevelSet = AVIF_TRUE;
-        } else if (!strcmp(key, "tune")) {
+        if (!strcmp(key, "tune")) {
             codec->internal->tuningSet = AVIF_TRUE;
         }
 #else  // !defined(HAVE_AOM_CODEC_SET_OPTION)
@@ -502,9 +493,7 @@
                 if (!success) {
                     return AVIF_FALSE;
                 }
-                if (aomOptionDefs[j].controlId == AOME_SET_CQ_LEVEL) {
-                    codec->internal->cqLevelSet = AVIF_TRUE;
-                } else if (aomOptionDefs[j].controlId == AOME_SET_TUNING) {
+                if (aomOptionDefs[j].controlId == AOME_SET_TUNING) {
                     codec->internal->tuningSet = AVIF_TRUE;
                 }
                 break;
@@ -526,6 +515,7 @@
                                       avifBool alpha,
                                       int tileRowsLog2,
                                       int tileColsLog2,
+                                      int quantizer,
                                       avifEncoderChanges encoderChanges,
                                       avifAddImageFlags addImageFlags,
                                       avifCodecEncodeOutput * output)
@@ -687,15 +677,6 @@
             cfg->g_threads = encoder->maxThreads;
         }
 
-        if (alpha) {
-            cfg->rc_min_quantizer = AVIF_CLAMP(encoder->minQuantizerAlpha, 0, 63);
-            cfg->rc_max_quantizer = AVIF_CLAMP(encoder->maxQuantizerAlpha, 0, 63);
-        } else {
-            cfg->rc_min_quantizer = AVIF_CLAMP(encoder->minQuantizer, 0, 63);
-            cfg->rc_max_quantizer = AVIF_CLAMP(encoder->maxQuantizer, 0, 63);
-        }
-        quantizerUpdated = AVIF_TRUE;
-
         codec->internal->monochromeEnabled = AVIF_FALSE;
         if (aomVersion > aomVersion_2_0_0) {
             // There exists a bug in libaom's chroma_check() function where it will attempt to
@@ -716,6 +697,32 @@
             return AVIF_RESULT_INVALID_CODEC_SPECIFIC_OPTION;
         }
 
+        int minQuantizer;
+        int maxQuantizer;
+        if (alpha) {
+            minQuantizer = encoder->minQuantizerAlpha;
+            maxQuantizer = encoder->maxQuantizerAlpha;
+        } else {
+            minQuantizer = encoder->minQuantizer;
+            maxQuantizer = encoder->maxQuantizer;
+        }
+        minQuantizer = AVIF_CLAMP(minQuantizer, 0, 63);
+        maxQuantizer = AVIF_CLAMP(maxQuantizer, 0, 63);
+        if ((cfg->rc_end_usage == AOM_VBR) || (cfg->rc_end_usage == AOM_CBR)) {
+            // cq-level is ignored in these two end-usage modes, so adjust minQuantizer and
+            // maxQuantizer to the target quantizer.
+            if (quantizer == AVIF_QUANTIZER_LOSSLESS) {
+                minQuantizer = AVIF_QUANTIZER_LOSSLESS;
+                maxQuantizer = AVIF_QUANTIZER_LOSSLESS;
+            } else {
+                minQuantizer = AVIF_MAX(quantizer - 4, minQuantizer);
+                maxQuantizer = AVIF_MIN(quantizer + 4, maxQuantizer);
+            }
+        }
+        cfg->rc_min_quantizer = minQuantizer;
+        cfg->rc_max_quantizer = maxQuantizer;
+        quantizerUpdated = AVIF_TRUE;
+
         aom_codec_flags_t encoderFlags = 0;
         if (image->depth > 8) {
             encoderFlags |= AOM_CODEC_USE_HIGHBITDEPTH;
@@ -729,7 +736,10 @@
         }
         codec->internal->encoderInitialized = AVIF_TRUE;
 
-        avifBool lossless = ((cfg->rc_min_quantizer == AVIF_QUANTIZER_LOSSLESS) && (cfg->rc_max_quantizer == AVIF_QUANTIZER_LOSSLESS));
+        if ((cfg->rc_end_usage == AOM_CQ) || (cfg->rc_end_usage == AOM_Q)) {
+            aom_codec_control(&codec->internal->encoder, AOME_SET_CQ_LEVEL, quantizer);
+        }
+        avifBool lossless = (quantizer == AVIF_QUANTIZER_LOSSLESS);
         if (lossless) {
             aom_codec_control(&codec->internal->encoder, AV1E_SET_LOSSLESS, 1);
         }
@@ -783,10 +793,20 @@
                 quantizerUpdated = AVIF_TRUE;
             }
         }
-        if (quantizerUpdated) {
-            avifBool lossless =
-                ((cfg->rc_min_quantizer == AVIF_QUANTIZER_LOSSLESS) && (cfg->rc_max_quantizer == AVIF_QUANTIZER_LOSSLESS));
-            aom_codec_control(&codec->internal->encoder, AV1E_SET_LOSSLESS, lossless);
+        const int quantizerChangedBit = alpha ? AVIF_ENCODER_CHANGE_QUANTIZER_ALPHA : AVIF_ENCODER_CHANGE_QUANTIZER;
+        if (encoderChanges & quantizerChangedBit) {
+            if ((cfg->rc_end_usage == AOM_VBR) || (cfg->rc_end_usage == AOM_CBR)) {
+                // cq-level is ignored in these two end-usage modes, so adjust minQuantizer and
+                // maxQuantizer to the target quantizer.
+                if (quantizer == AVIF_QUANTIZER_LOSSLESS) {
+                    cfg->rc_min_quantizer = AVIF_QUANTIZER_LOSSLESS;
+                    cfg->rc_max_quantizer = AVIF_QUANTIZER_LOSSLESS;
+                } else {
+                    cfg->rc_min_quantizer = AVIF_MAX(quantizer - 4, (int)cfg->rc_min_quantizer);
+                    cfg->rc_max_quantizer = AVIF_MIN(quantizer + 4, (int)cfg->rc_max_quantizer);
+                }
+                quantizerUpdated = AVIF_TRUE;
+            }
         }
         if (quantizerUpdated || dimensionsChanged) {
             aom_codec_err_t err = aom_codec_enc_config_set(&codec->internal->encoder, cfg);
@@ -804,6 +824,13 @@
         if (encoderChanges & AVIF_ENCODER_CHANGE_TILE_COLS_LOG2) {
             aom_codec_control(&codec->internal->encoder, AV1E_SET_TILE_COLUMNS, tileColsLog2);
         }
+        if (encoderChanges & quantizerChangedBit) {
+            if ((cfg->rc_end_usage == AOM_CQ) || (cfg->rc_end_usage == AOM_Q)) {
+                aom_codec_control(&codec->internal->encoder, AOME_SET_CQ_LEVEL, quantizer);
+            }
+            avifBool lossless = (quantizer == AVIF_QUANTIZER_LOSSLESS);
+            aom_codec_control(&codec->internal->encoder, AV1E_SET_LOSSLESS, lossless);
+        }
         if (encoderChanges & AVIF_ENCODER_CHANGE_CODEC_SPECIFIC) {
             if (!avifProcessAOMOptionsPostInit(codec, alpha)) {
                 return AVIF_RESULT_INVALID_CODEC_SPECIFIC_OPTION;
@@ -811,19 +838,6 @@
         }
     }
 
-#if defined(AOM_USAGE_ALL_INTRA)
-    if (quantizerUpdated && cfg->g_usage == AOM_USAGE_ALL_INTRA && !codec->internal->endUsageSet && !codec->internal->cqLevelSet) {
-        // The default rc_end_usage in all intra mode is AOM_Q, which requires cq-level to
-        // function. A libavif user may not know this internal detail and therefore may only
-        // set the min and max quantizers in the avifEncoder struct. If this is the case, set
-        // cq-level to a reasonable value for the user, otherwise the default cq-level
-        // (currently 10) will be unknowingly used.
-        assert(cfg->rc_end_usage == AOM_Q);
-        unsigned int cqLevel = (cfg->rc_min_quantizer + cfg->rc_max_quantizer) / 2;
-        aom_codec_control(&codec->internal->encoder, AOME_SET_CQ_LEVEL, cqLevel);
-    }
-#endif
-
     aom_image_t aomImage;
     // We prefer to simply set the aomImage.planes[] pointers to the plane buffers in 'image'. When
     // doing this, we set aomImage.w equal to aomImage.d_w and aomImage.h equal to aomImage.d_h and
diff --git a/src/codec_rav1e.c b/src/codec_rav1e.c
index 7e3a315..4b93b79 100644
--- a/src/codec_rav1e.c
+++ b/src/codec_rav1e.c
@@ -55,6 +55,7 @@
                                         avifBool alpha,
                                         int tileRowsLog2,
                                         int tileColsLog2,
+                                        int quantizer,
                                         avifEncoderChanges encoderChanges,
                                         uint32_t addImageFlags,
                                         avifCodecEncodeOutput * output)
@@ -139,17 +140,15 @@
         }
 
         int minQuantizer = AVIF_CLAMP(encoder->minQuantizer, 0, 63);
-        int maxQuantizer = AVIF_CLAMP(encoder->maxQuantizer, 0, 63);
         if (alpha) {
             minQuantizer = AVIF_CLAMP(encoder->minQuantizerAlpha, 0, 63);
-            maxQuantizer = AVIF_CLAMP(encoder->maxQuantizerAlpha, 0, 63);
         }
         minQuantizer = (minQuantizer * 255) / 63; // Rescale quantizer values as rav1e's QP range is [0,255]
-        maxQuantizer = (maxQuantizer * 255) / 63;
+        quantizer = (quantizer * 255) / 63;
         if (rav1e_config_parse_int(rav1eConfig, "min_quantizer", minQuantizer) == -1) {
             goto cleanup;
         }
-        if (rav1e_config_parse_int(rav1eConfig, "quantizer", maxQuantizer) == -1) {
+        if (rav1e_config_parse_int(rav1eConfig, "quantizer", quantizer) == -1) {
             goto cleanup;
         }
         if (tileRowsLog2 != 0) {
diff --git a/src/codec_svt.c b/src/codec_svt.c
index 6a3ba85..158b2a4 100644
--- a/src/codec_svt.c
+++ b/src/codec_svt.c
@@ -48,6 +48,7 @@
                                       avifBool alpha,
                                       int tileRowsLog2,
                                       int tileColsLog2,
+                                      int quantizer,
                                       avifEncoderChanges encoderChanges,
                                       uint32_t addImageFlags,
                                       avifCodecEncodeOutput * output)
@@ -136,7 +137,7 @@
             svt_config->min_qp_allowed = AVIF_CLAMP(encoder->minQuantizer, 0, 63);
             svt_config->max_qp_allowed = AVIF_CLAMP(encoder->maxQuantizer, 0, 63);
         }
-        svt_config->qp = (svt_config->min_qp_allowed + svt_config->max_qp_allowed) / 2;
+        svt_config->qp = quantizer;
 
         if (tileRowsLog2 != 0) {
             svt_config->tile_rows = tileRowsLog2;
diff --git a/src/write.c b/src/write.c
index 66ad49e..5484e46 100644
--- a/src/write.c
+++ b/src/write.c
@@ -204,10 +204,17 @@
 {
     avifEncoderItemArray items;
     avifEncoderFrameArray frames;
+    // Map the encoder settings quality and qualityAlpha to quantizer and quantizerAlpha
+    int quantizer;
+    int quantizerAlpha;
     // tileRowsLog2 and tileColsLog2 are the actual tiling values after automatic tiling is handled
     int tileRowsLog2;
     int tileColsLog2;
     avifEncoder lastEncoder;
+    // lastQuantizer and lastQuantizerAlpha are the quantizer and quantizerAlpha values used last
+    // time
+    int lastQuantizer;
+    int lastQuantizerAlpha;
     // lastTileRowsLog2 and lastTileColsLog2 are the actual tiling values used last time
     int lastTileRowsLog2;
     int lastTileColsLog2;
@@ -385,10 +392,12 @@
     encoder->speed = AVIF_SPEED_DEFAULT;
     encoder->keyframeInterval = 0;
     encoder->timescale = 1;
-    encoder->minQuantizer = AVIF_QUANTIZER_LOSSLESS;
-    encoder->maxQuantizer = AVIF_QUANTIZER_LOSSLESS;
-    encoder->minQuantizerAlpha = AVIF_QUANTIZER_LOSSLESS;
-    encoder->maxQuantizerAlpha = AVIF_QUANTIZER_LOSSLESS;
+    encoder->quality = AVIF_QUALITY_DEFAULT;
+    encoder->qualityAlpha = AVIF_QUALITY_DEFAULT;
+    encoder->minQuantizer = AVIF_QUANTIZER_BEST_QUALITY;
+    encoder->maxQuantizer = AVIF_QUANTIZER_WORST_QUALITY;
+    encoder->minQuantizerAlpha = AVIF_QUANTIZER_BEST_QUALITY;
+    encoder->maxQuantizerAlpha = AVIF_QUANTIZER_WORST_QUALITY;
     encoder->tileRowsLog2 = 0;
     encoder->tileColsLog2 = 0;
     encoder->autoTiling = AVIF_FALSE;
@@ -425,6 +434,8 @@
     lastEncoder->maxQuantizer = encoder->maxQuantizer;
     lastEncoder->minQuantizerAlpha = encoder->minQuantizerAlpha;
     lastEncoder->maxQuantizerAlpha = encoder->maxQuantizerAlpha;
+    encoder->data->lastQuantizer = encoder->data->quantizer;
+    encoder->data->lastQuantizerAlpha = encoder->data->quantizerAlpha;
     encoder->data->lastTileRowsLog2 = encoder->data->tileRowsLog2;
     encoder->data->lastTileColsLog2 = encoder->data->tileColsLog2;
 }
@@ -448,6 +459,12 @@
         return AVIF_FALSE;
     }
 
+    if (encoder->data->lastQuantizer != encoder->data->quantizer) {
+        *encoderChanges |= AVIF_ENCODER_CHANGE_QUANTIZER;
+    }
+    if (encoder->data->lastQuantizerAlpha != encoder->data->quantizerAlpha) {
+        *encoderChanges |= AVIF_ENCODER_CHANGE_QUANTIZER_ALPHA;
+    }
     if (lastEncoder->minQuantizer != encoder->minQuantizer) {
         *encoderChanges |= AVIF_ENCODER_CHANGE_MIN_QUANTIZER;
     }
@@ -811,6 +828,21 @@
     return dstImage;
 }
 
+static int avifQualityToQuantizer(int quality, int minQuantizer, int maxQuantizer)
+{
+    int quantizer;
+    if (quality == AVIF_QUALITY_DEFAULT) {
+        // In older libavif releases, avifEncoder didn't have the quality and qualityAlpha fields.
+        // Supply a default value for quantizer.
+        quantizer = (minQuantizer + maxQuantizer) / 2;
+        quantizer = AVIF_CLAMP(quantizer, 0, 63);
+    } else {
+        quality = AVIF_CLAMP(quality, 0, 100);
+        quantizer = ((100 - quality) * 63 + 50) / 100;
+    }
+    return quantizer;
+}
+
 static avifResult avifEncoderAddImageInternal(avifEncoder * encoder,
                                               uint32_t gridCols,
                                               uint32_t gridRows,
@@ -914,6 +946,11 @@
     }
 
     // -----------------------------------------------------------------------
+    // Map quality and qualityAlpha to quantizer and quantizerAlpha
+    encoder->data->quantizer = avifQualityToQuantizer(encoder->quality, encoder->minQuantizer, encoder->maxQuantizer);
+    encoder->data->quantizerAlpha = avifQualityToQuantizer(encoder->qualityAlpha, encoder->minQuantizerAlpha, encoder->maxQuantizerAlpha);
+
+    // -----------------------------------------------------------------------
     // Handle automatic tiling
 
     encoder->data->tileRowsLog2 = AVIF_CLAMP(encoder->tileRowsLog2, 0, 6);
@@ -1120,12 +1157,14 @@
                 }
                 cellImage = paddedCellImage;
             }
+            const int quantizer = item->alpha ? encoder->data->quantizerAlpha : encoder->data->quantizer;
             avifResult encodeResult = item->codec->encodeImage(item->codec,
                                                                encoder,
                                                                cellImage,
                                                                item->alpha,
                                                                encoder->data->tileRowsLog2,
                                                                encoder->data->tileColsLog2,
+                                                               quantizer,
                                                                encoderChanges,
                                                                addImageFlags,
                                                                item->encodeOutput);
diff --git a/tests/gtest/avifgridapitest.cc b/tests/gtest/avifgridapitest.cc
index c69994b..6c606d9 100644
--- a/tests/gtest/avifgridapitest.cc
+++ b/tests/gtest/avifgridapitest.cc
@@ -42,10 +42,8 @@
     return AVIF_RESULT_OUT_OF_MEMORY;
   }
   encoder->speed = AVIF_SPEED_FASTEST;
-  encoder->minQuantizer = AVIF_QUANTIZER_LOSSLESS;
-  encoder->maxQuantizer = AVIF_QUANTIZER_LOSSLESS;
-  encoder->minQuantizerAlpha = AVIF_QUANTIZER_LOSSLESS;
-  encoder->minQuantizerAlpha = AVIF_QUANTIZER_LOSSLESS;
+  encoder->quality = AVIF_QUALITY_LOSSLESS;
+  encoder->qualityAlpha = AVIF_QUALITY_LOSSLESS;
   // cell_image_ptrs exists only to match the libavif API.
   std::vector<avifImage*> cell_image_ptrs(cell_images.size());
   for (size_t i = 0; i < cell_images.size(); ++i) {
diff --git a/tests/test_cmd.sh b/tests/test_cmd.sh
index 67b5e16..1e5d70b 100755
--- a/tests/test_cmd.sh
+++ b/tests/test_cmd.sh
@@ -51,11 +51,12 @@
 ENCODED_FILE="avif_test_cmd_encoded.avif"
 ENCODED_FILE_WITH_DASH="-avif_test_cmd_encoded.avif"
 DECODED_FILE="avif_test_cmd_decoded.png"
+OUT_MSG="avif_test_cmd_out_msg.txt"
 
 # Cleanup
 cleanup() {
   pushd ${TMP_DIR}
-    rm -- "${ENCODED_FILE}" "${ENCODED_FILE_WITH_DASH}" "${DECODED_FILE}"
+    rm -- "${ENCODED_FILE}" "${ENCODED_FILE_WITH_DASH}" "${DECODED_FILE}" "${OUT_MSG}"
   popd
 }
 trap cleanup EXIT
@@ -81,6 +82,21 @@
   # --minalpha and --maxalpha must be both specified.
   "${AVIFENC}" -s 10 --minalpha 0 "${INPUT_PNG}" "${ENCODED_FILE}" && exit 1
   "${AVIFENC}" -s 10 --maxalpha 0 "${INPUT_PNG}" "${ENCODED_FILE}" && exit 1
+
+  # The default quality is 60. The default alpha quality is 100 (lossless).
+  "${AVIFENC}" -s 10 "${INPUT_Y4M}" "${ENCODED_FILE}" > "${OUT_MSG}"
+  grep " color quality \[60 " "${OUT_MSG}"
+  grep " alpha quality \[100 " "${OUT_MSG}"
+  "${AVIFENC}" -s 10 -q 85 "${INPUT_Y4M}" "${ENCODED_FILE}" > "${OUT_MSG}"
+  grep " color quality \[85 " "${OUT_MSG}"
+  grep " alpha quality \[100 " "${OUT_MSG}"
+  # The average of 15 and 25 is 20. Quantizer 20 maps to quality 68.
+  "${AVIFENC}" -s 10 --min 15 --max 25 "${INPUT_Y4M}" "${ENCODED_FILE}" > "${OUT_MSG}"
+  grep " color quality \[68 " "${OUT_MSG}"
+  grep " alpha quality \[100 " "${OUT_MSG}"
+  "${AVIFENC}" -s 10 -q 65 --min 15 --max 25 "${INPUT_Y4M}" "${ENCODED_FILE}" > "${OUT_MSG}"
+  grep " color quality \[65 " "${OUT_MSG}"
+  grep " alpha quality \[100 " "${OUT_MSG}"
 popd
 
 exit 0